ADC.cpp

/* Teensy 4, 3.x, LC ADC library
 * https://github.com/pedvide/ADC
 * Copyright (c) 2019 Pedro Villanueva
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/* ADC.cpp: Implements the control of one or more ADC modules of Teensy 3.x, LC
 *
 */

#include "ADC.h"



// translate pin number to SC1A nomenclature and viceversa
// we need to create this static const arrays so that we can assign the "normal arrays" to the correct one
// depending on which ADC module we will be.
/* channel2sc1aADCx converts a pin number to their value for the SC1A register, for the ADC0 and ADC1
*  numbers with +ADC_SC1A_PIN_MUX (128) means those pins use mux a, the rest use mux b.
*  numbers with +ADC_SC1A_PIN_DIFF (64) means it's also a differential pin (treated also in the channel2sc1a_diff_ADCx)
*  For diff_table_ADCx, +ADC_SC1A_PIN_PGA means the pin can use PGA on that ADC
*/

///////// ADC0
#if defined(ADC_TEENSY_3_0)
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 0, 19, 3, 21, // 0-13, we treat them as A0-A13
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 (A0-A9)
    31, 31, 31, 31, 31, 31, 31, 31, 31, 31, // 24-33
    0+ADC_SC1A_PIN_DIFF, 19+ADC_SC1A_PIN_DIFF, 3+ADC_SC1A_PIN_DIFF, 21+ADC_SC1A_PIN_DIFF, // 34-37 (A10-A13)
    26, 22, 23, 27, 29, 30 // 38-43: temp. sensor, VREF_OUT, A14, bandgap, VREFH, VREFL. A14 isn't connected to anything in Teensy 3.0.
};
#elif defined(ADC_TEENSY_3_1) // the only difference with 3.0 is that A13 is not connected to ADC0 and that T3.1 has PGA.
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 0, 19, 3, 31, // 0-13, we treat them as A0-A13
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 (A0-A9)
    31, 31, 31, 31, 31, 31, 31, 31, 31, 31, // 24-33
    0+ADC_SC1A_PIN_DIFF, 19+ADC_SC1A_PIN_DIFF, 3+ADC_SC1A_PIN_DIFF, 31+ADC_SC1A_PIN_DIFF, // 34-37 (A10-A13)
    26, 22, 23, 27, 29, 30 // 38-43: temp. sensor, VREF_OUT, A14, bandgap, VREFH, VREFL. A14 isn't connected to anything in Teensy 3.0.
};
#elif defined(ADC_TEENSY_LC)
// Teensy LC
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    5, 14, 8, 9, 13, 12, 6, 7, 15, 11, 0, 4+ADC_SC1A_PIN_MUX, 23, 31, // 0-13, we treat them as A0-A12 + A13= doesn't exist
    5, 14, 8, 9, 13, 12, 6, 7, 15, 11, // 14-23 (A0-A9)
    0+ADC_SC1A_PIN_DIFF, 4+ADC_SC1A_PIN_MUX+ADC_SC1A_PIN_DIFF, 23, 31, 31, 31, 31, 31, 31, 31, // 24-33 ((A10-A12) + nothing), A11 uses mux a
    31, 31, 31, 31, // 34-37 nothing
    26, 27, 31, 27, 29, 30 // 38-43: temp. sensor, , , bandgap, VREFH, VREFL.
};
#elif defined(ADC_TEENSY_3_5)
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 3, 31, 31, 31, // 0-13, we treat them as A0-A13
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 (A0-A9)
    26, 27, 29, 30, 31, 31, 31, // 24-30: Temp_Sensor, bandgap, VREFH, VREFL.
    31, 31, 17, 18,// 31-34 A12(ADC1), A13(ADC1), A14, A15
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 35-43
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 44-52
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 53-61
    31, 31, 3+ADC_SC1A_PIN_DIFF, 31+ADC_SC1A_PIN_DIFF, 23, 31, 1, 31 // 62-69 64: A10, 65: A11 (NOT CONNECTED), 66: A21, 68: A25 (no diff)
};
#elif defined(ADC_TEENSY_3_6)
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 3, 31, 31, 31, // 0-13, we treat them as A0-A13
    5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 (A0-A9)
    26, 27, 29, 30, 31, 31, 31, // 24-30: Temp_Sensor, bandgap, VREFH, VREFL.
    31, 31, 17, 18,// 31-34 A12(ADC1), A13(ADC1), A14, A15
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 35-43
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 44-52
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 53-61
    31, 31, 3+ADC_SC1A_PIN_DIFF, 31+ADC_SC1A_PIN_DIFF, 23, 31 // 62-67 64: A10, 65: A11 (NOT CONNECTED), 66: A21, 67: A22(ADC1)
};
#elif defined(ADC_TEENSY_4)
const uint8_t ADC::channel2sc1aADC0[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    7, 8, 12, 11, 6, 5, 15, 0, 13, 14, 1, 2, 31, 31, // 0-13, we treat them as A0-A13
    7, 8, 12, 11, 6, 5, 15, 0, 13, 14, // 14-23 (A0-A9)
    1, 2, 31, 31 // A10, A11, A12, A13
};
#endif // defined

///////// ADC1
#if defined(ADC_TEENSY_3_1)
const uint8_t ADC::channel2sc1aADC1[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, 3, 31, 0, 19, // 0-13, we treat them as A0-A13
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, // 14-23 (A0-A9)
    31, 31,  // 24,25 are digital only pins
    5+ADC_SC1A_PIN_MUX, 5, 4, 6, 7, 4+ADC_SC1A_PIN_MUX, 31, 31, // 26-33 26=5a, 27=5b, 28=4b, 29=6b, 30=7b, 31=4a, 32,33 are digital only
    3+ADC_SC1A_PIN_DIFF, 31+ADC_SC1A_PIN_DIFF, 0+ADC_SC1A_PIN_DIFF, 19+ADC_SC1A_PIN_DIFF, // 34-37 (A10-A13) A11 isn't connected.
    26, 18, 31, 27, 29, 30 // 38-43: temp. sensor, VREF_OUT, A14 (not connected), bandgap, VREFH, VREFL.
};
#elif defined(ADC_TEENSY_3_5)
const uint8_t ADC::channel2sc1aADC1[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, 31, 19, 14, 15, // 0-13, we treat them as A0-A13
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, // 14-23 (A0-A9)
    26, 27, 29, 30, 18, 31, 31,  // 24-30: Temp_Sensor, bandgap, VREFH, VREFL, VREF_OUT
    14, 15, 31, 31, 4, 5, 6, 7, 17, // 31-39 A12-A20
    31, 31, 31, 31, // 40-43
    31, 31, 31, 31, 31, 10, 11, 31, 31, // 44-52, 49: A23, 50: A24
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 53-61
    31, 31, 0+ADC_SC1A_PIN_DIFF, 19+ADC_SC1A_PIN_DIFF, 31, 23, 31, 1 // 62-69 64: A10, 65: A11, 67: A22, 69: A26 (not diff)
};
#elif defined(ADC_TEENSY_3_6)
const uint8_t ADC::channel2sc1aADC1[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, 31, 19, 14, 15, // 0-13, we treat them as A0-A13
    31, 31, 8, 9, 31, 31, 31, 31, 31, 31, // 14-23 (A0-A9)
    26, 27, 29, 30, 18, 31, 31,  // 24-30: Temp_Sensor, bandgap, VREFH, VREFL, VREF_OUT
    14, 15, 31, 31, 4, 5, 6, 7, 17, // 31-39 A12-A20
    31, 31, 31, 23, // 40-43: A10(ADC0), A11(ADC0), A21, A22
    31, 31, 31, 31, 31, 10, 11, 31, 31, // 44-52, 49: A23, 50: A24
    31, 31, 31, 31, 31, 31, 31, 31, 31, // 53-61
    31, 31, 0+ADC_SC1A_PIN_DIFF, 19+ADC_SC1A_PIN_DIFF, 31, 23 // 61-67 64: A10, 65: A11, 66: A21(ADC0), 67: A22
};
#elif defined(ADC_TEENSY_4)
const uint8_t ADC::channel2sc1aADC1[]= { // new version, gives directly the sc1a number. 0x1F=31 deactivates the ADC.
    7, 8, 12, 11, 6, 5, 15, 0, 13, 14, 31, 31, 3, 4, // 0-13, we treat them as A0-A13
    7, 8, 12, 11, 6, 5, 15, 0, 13, 14, // 14-23 (A0-A9)
    31, 31, 3, 4 // A10, A11, A12, A13
};
#endif

#if defined(ADC_TEENSY_3_1) // Teensy 3.1
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC0[]= {
        {A10, 0+ADC_SC1A_PIN_PGA}, {A12, 3}
    };
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC1[]= {
        {A10, 3}, {A12, 0+ADC_SC1A_PIN_PGA}
    };
#elif defined(ADC_TEENSY_3_0) // Teensy 3.0
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC0[]= {
        {A10, 0}, {A12, 3}
    };
#elif defined(ADC_TEENSY_LC) // Teensy LC
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC0[]= {
        {A10, 0}
    };
#elif defined(ADC_TEENSY_3_5) || defined(ADC_TEENSY_3_6) // Teensy 3.6// Teensy 3.5
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC0[]= {
        {A10, 3}
    };
    const ADC_Module::ADC_NLIST ADC::diff_table_ADC1[]= {
        {A10, 0}
    };
#elif defined(ADC_TEENSY_4)
#endif



// translate SC1A to pin number
///////// ADC0
#if defined(ADC_TEENSY_3_0) || defined(ADC_TEENSY_3_1)
const uint8_t ADC::sc1a2channelADC0[]= { // new version, gives directly the pin number
    34, 0, 0, 36, 23, 14, 20, 21, 16, 17, 0, 0, 19, 18, // 0-13
    15, 22, 23, 0, 0, 35, 0, 37, // 14-21
    39, 40, 0, 0, 38, 41, 42, 43, // VREF_OUT, A14, temp. sensor, bandgap, VREFH, VREFL.
    0 // 31 means disabled, but just in case
};
#elif defined(ADC_TEENSY_LC)
// Teensy LC
const uint8_t ADC::sc1a2channelADC0[]= { // new version, gives directly the pin number
    24, 0, 0, 0, 25, 14, 20, 21, 16, 17, 0, 23, 19, 18, // 0-13
    15, 22, 23, 0, 0, 0, 0, 0, // 14-21
    26, 0, 0, 0, 38, 41, 0, 42, 43, // A12, temp. sensor, bandgap, VREFH, VREFL.
    0 // 31 means disabled, but just in case
};
#elif defined(ADC_TEENSY_3_5) || defined(ADC_TEENSY_3_6)
const uint8_t ADC::sc1a2channelADC0[]= { // new version, gives directly the pin number
    0, 68, 0, 64, 23, 14, 20, 21, 16, 17, 0, 0, 19, 18, // 0-13
    15, 22, 0, 33, 34, 0, 0, 0, // 14-21
    0, 66, 0, 0, 70, 0, 0, 0, // 22-29
    0 // 31 means disabled, but just in case
};
#elif defined(ADC_TEENSY_4)
const uint8_t ADC::sc1a2channelADC0[]= { // new version, gives directly the pin number
    21, 24, 25, 0, 0, 19, 18, 14, 15, 0, 0, 17, 16, 22,
    23, 20, 0, 0, 0, 0, 0, 0, //14-21
    0, 0, 0, 0, 0, 0    //22-27
};
#endif // defined

///////// ADC1
#if defined(ADC_TEENSY_3_1)
const uint8_t ADC::sc1a2channelADC1[]= { // new version, gives directly the pin number
    36, 0, 0, 34, 28, 26, 29, 30, 16, 17, 0, 0, 0, 0, // 0-13. 5a=26, 5b=27, 4b=28, 4a=31
    0, 0, 0, 0, 39, 37, 0, 0, // 14-21
    0, 0, 0, 0, 38, 41, 0, 42, // 22-29. VREF_OUT, A14, temp. sensor, bandgap, VREFH, VREFL.
    43
};
#elif defined(ADC_TEENSY_3_5) || defined(ADC_TEENSY_3_6)
const uint8_t ADC::sc1a2channelADC1[]= { // new version, gives directly the pin number
    0, 69, 0, 0, 35, 36, 37, 38, 0, 0, 49, 50, 0, 0, // 0-13.
    31, 32, 0, 39, 71, 65, 0, 0, // 14-21
    0, 67, 0, 0, 0, 0, 0, 0, // 22-29.
    0
};
#elif defined(ADC_TEENSY_4)
const uint8_t ADC::sc1a2channelADC1[]= { // new version, gives directly the pin number
    21, 0, 0, 26, 27, 19, 18, 14, 15, 0, 0, 17, 16, 22, // 0-13
    23, 20, 0, 0, 0, 0, 0, 0, //14-21
    0, 0, 0, 0, 0, 0    //22-27
};
#endif


// Constructor
ADC::ADC() : // awkward initialization  so there are no -Wreorder warnings
    #if ADC_DIFF_PAIRS > 0
    adc0_obj(0, channel2sc1aADC0, diff_table_ADC0, ADC0_START)
    #ifdef ADC_DUAL_ADCS
    , adc1_obj(1, channel2sc1aADC1, diff_table_ADC1, ADC1_START)
    #endif
    #else
    adc0_obj(0, channel2sc1aADC0, ADC0_START)
    #ifdef ADC_DUAL_ADCS
    , adc1_obj(1, channel2sc1aADC1, ADC1_START)
    #endif
    #endif
    {
    //ctor

    //digitalWriteFast(LED_BUILTIN, HIGH);
}


/* Returns the analog value of the pin.
* It waits until the value is read and then returns the result.
* If a comparison has been set up and fails, it will return ADC_ERROR_VALUE.
* This function is interrupt safe, so it will restore the adc to the state it was before being called
* If more than one ADC exists, it will select the module with less workload, you can force a selection using
* adc_num. If you select ADC1 in Teensy 3.0 it will return ADC_ERROR_VALUE.
*/
int ADC::analogRead(uint8_t pin, int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->analogRead(pin); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkPin(pin);
        bool adc1Pin = adc1->checkPin(pin);

        if(adc0Pin && adc1Pin)  { // Both ADCs
            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->analogRead(pin);
            } else {
                return adc0->analogRead(pin);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->analogRead(pin);
        } else if(adc1Pin) { // ADC1
            return adc1->analogRead(pin);
        } else { // pin not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return ADC_ERROR_VALUE;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->analogRead(pin);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->analogRead(pin);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return ADC_ERROR_VALUE;
    #endif
}

#if ADC_DIFF_PAIRS > 0
/* Reads the differential analog value of two pins (pinP - pinN).
* It waits until the value is read and then returns the result.
* If a comparison has been set up and fails, it will return ADC_ERROR_VALUE.
* \param pinP must be A10 or A12.
* \param pinN must be A11 (if pinP=A10) or A13 (if pinP=A12).
* Other pins will return ADC_ERROR_VALUE.
* This function is interrupt safe, so it will restore the adc to the state it was before being called
* If more than one ADC exists, it will select the module with less workload, you can force a selection using
* adc_num. If you select ADC1 in Teensy 3.0 it will return ADC_ERROR_VALUE.
*/
int ADC::analogReadDifferential(uint8_t pinP, uint8_t pinN, int8_t adc_num) {

    #ifdef ADC_SINGLE_ADC
    return adc0->analogReadDifferential(pinP, pinN); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkDifferentialPins(pinP, pinN);
        bool adc1Pin = adc1->checkDifferentialPins(pinP, pinN);

        if(adc0Pin && adc1Pin)  { // Both ADCs
            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->analogReadDifferential(pinP, pinN);
            } else {
                return adc0->analogReadDifferential(pinP, pinN);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->analogReadDifferential(pinP, pinN);
        } else if(adc1Pin) { // ADC1
            return adc1->analogReadDifferential(pinP, pinN);
        } else { // pins not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return ADC_ERROR_VALUE;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->analogReadDifferential(pinP, pinN);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->analogReadDifferential(pinP, pinN);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return ADC_ERROR_VALUE;
    #endif
}
#endif


// Starts an analog measurement on the pin and enables interrupts.
/* It returns immediately, get value with readSingle().
*   If the pin is incorrect it returns ADC_ERROR_VALUE
*   This function is interrupt safe. The ADC interrupt will restore the adc to its previous settings and
*   restart the adc if it stopped a measurement. If you modify the adc_isr then this won't happen.
*/
bool ADC::startSingleRead(uint8_t pin, int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->startSingleRead(pin); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkPin(pin);
        bool adc1Pin = adc1->checkPin(pin);

        if(adc0Pin && adc1Pin)  { // Both ADCs

            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->startSingleRead(pin);
            } else {
                return adc0->startSingleRead(pin);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->startSingleRead(pin);
        } else if(adc1Pin) { // ADC1
            return adc1->startSingleRead(pin);
        } else { // pin not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return false;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->startSingleRead(pin);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->startSingleRead(pin);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return false;
    #endif
}

#if ADC_DIFF_PAIRS > 0
// Start a differential conversion between two pins (pinP - pinN) and enables interrupts.
/* It returns inmediately, get value with readSingle().
*   \param pinP must be A10 or A12.
*   \param pinN must be A11 (if pinP=A10) or A13 (if pinP=A12).
*   Other pins will return ADC_ERROR_DIFF_VALUE.
*   This function is interrupt safe. The ADC interrupt will restore the adc to its previous settings and
*   restart the adc if it stopped a measurement. If you modify the adc_isr then this won't happen.
*/
bool ADC::startSingleDifferential(uint8_t pinP, uint8_t pinN, int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->startSingleDifferential(pinP, pinN); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkDifferentialPins(pinP, pinN);
        bool adc1Pin = adc1->checkDifferentialPins(pinP, pinN);

        if(adc0Pin && adc1Pin)  { // Both ADCs
            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->startSingleDifferential(pinP, pinN);
            } else {
                return adc0->startSingleDifferential(pinP, pinN);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->startSingleDifferential(pinP, pinN);
        } else if(adc1Pin) { // ADC1
            return adc1->startSingleDifferential(pinP, pinN);
        } else { // pins not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return false;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->startSingleDifferential(pinP, pinN);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->startSingleDifferential(pinP, pinN);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return false;
    #endif
}
#endif

// Reads the analog value of a single conversion.
/* Set the conversion with with startSingleRead(pin) or startSingleDifferential(pinP, pinN).
*   \return the converted value.
*/
int ADC::readSingle(int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->readSingle();
    #else
    if(adc_num==1){ // user wants ADC 1, do nothing if it's a Teensy 3.0
        return adc1->readSingle();
    }
    return adc0->readSingle();
    #endif
}


// Starts continuous conversion on the pin.
/* It returns as soon as the ADC is set, use analogReadContinuous() to read the value.
*/
bool ADC::startContinuous(uint8_t pin, int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->startContinuous(pin); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkPin(pin);
        bool adc1Pin = adc1->checkPin(pin);

        if(adc0Pin && adc1Pin)  { // Both ADCs
            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->startContinuous(pin);
            } else {
                return adc0->startContinuous(pin);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->startContinuous(pin);
        } else if(adc1Pin) { // ADC1
            return adc1->startContinuous(pin);
        } else { // pin not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return false;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->startContinuous(pin);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->startContinuous(pin);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return false;
    #endif
}

#if ADC_DIFF_PAIRS > 0
// Starts continuous conversion between the pins (pinP-pinN).
/* It returns as soon as the ADC is set, use analogReadContinuous() to read the value.
* \param pinP must be A10 or A12.
* \param pinN must be A11 (if pinP=A10) or A13 (if pinP=A12).
* Other pins will return ADC_ERROR_DIFF_VALUE.
*/
bool ADC::startContinuousDifferential(uint8_t pinP, uint8_t pinN, int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->startContinuousDifferential(pinP, pinN); // use ADC0
    #else
    /* Teensy 3.1
    */
    if( adc_num==-1 ) { // use no ADC in particular
        // check which ADC can read the pin
        bool adc0Pin = adc0->checkDifferentialPins(pinP, pinN);
        bool adc1Pin = adc1->checkDifferentialPins(pinP, pinN);

        if(adc0Pin && adc1Pin)  { // Both ADCs
            if( (adc0->num_measurements) > (adc1->num_measurements)) { // use the ADC with less workload
                return adc1->startContinuousDifferential(pinP, pinN);
            } else {
                return adc0->startContinuousDifferential(pinP, pinN);
            }
        } else if(adc0Pin) { // ADC0
            return adc0->startContinuousDifferential(pinP, pinN);
        } else if(adc1Pin) { // ADC1
            return adc1->startContinuousDifferential(pinP, pinN);
        } else { // pins not valid in any ADC
            adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
            adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
            return false;   // all others are invalid
        }
    }
    else if( adc_num==0 ) { // user wants ADC0
        return adc0->startContinuousDifferential(pinP, pinN);
    }
    else if( adc_num==1 ){ // user wants ADC 1
        return adc1->startContinuousDifferential(pinP, pinN);
    }
    adc0->fail_flag |= ADC_ERROR::OTHER;
    return false;
    #endif
}
#endif

//! Reads the analog value of a continuous conversion.
/** Set the continuous conversion with with analogStartContinuous(pin) or startContinuousDifferential(pinP, pinN).
*   \return the last converted value.
*   If single-ended and 16 bits it's necessary to typecast it to an unsigned type (like uint16_t),
*   otherwise values larger than 3.3/2 V are interpreted as negative!
*/
int ADC::analogReadContinuous(int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    return adc0->analogReadContinuous();
    #else
    if(adc_num==1){ // user wants ADC 1, do nothing if it's a Teensy 3.0
        return adc1->analogReadContinuous();
    }
    return adc0->analogReadContinuous();
    #endif
}

//! Stops continuous conversion
void ADC::stopContinuous(int8_t adc_num) {
    #ifdef ADC_SINGLE_ADC
    adc0->stopContinuous();
    #else
    if(adc_num==1){ // user wants ADC 1, do nothing if it's a Teensy 3.0
        adc1->stopContinuous();
        return;
    }
    adc0->stopContinuous();
    return;
    #endif
}



//////////////// SYNCHRONIZED BLOCKING METHODS //////////////////
///// ONLY FOR BOARDS WITH MORE THAN ONE ADC /////
/////////////////////////////////////////////////////////////////

#ifdef ADC_DUAL_ADCS

/*Returns the analog values of both pins, measured at the same time by the two ADC modules.
* It waits until the value is read and then returns the result as a struct Sync_result,
* use Sync_result.result_adc0 and Sync_result.result_adc1.
* If a comparison has been set up and fails, it will return ADC_ERROR_VALUE in both fields of the struct.
*/
ADC::Sync_result ADC::analogSynchronizedRead(uint8_t pin0, uint8_t pin1) {
    Sync_result res = {ADC_ERROR_VALUE, ADC_ERROR_VALUE};

    // check pins
    if ( !adc0->checkPin(pin0) ) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return res;
    }
    if ( !adc1->checkPin(pin1) ) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return res;
    }


    // check if we are interrupting a measurement, store setting if so.
    // vars to save the current state of the ADC in case it's in use
    ADC_Module::ADC_Config old_adc0_config = {};
    uint8_t wasADC0InUse = adc0->isConverting(); // is the ADC running now?
    if(wasADC0InUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->saveConfig(&old_adc0_config);
        __enable_irq();
    }
    ADC_Module::ADC_Config old_adc1_config = {};
    uint8_t wasADC1InUse = adc1->isConverting(); // is the ADC running now?
    if(wasADC1InUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->saveConfig(&old_adc1_config);
        __enable_irq();
    }

    // no continuous mode
    adc0->singleMode();
    adc1->singleMode();

    // start both measurements
    adc0->startReadFast(pin0);
    adc1->startReadFast(pin1);

    // wait for both ADCs to finish
    while( (adc0->isConverting()) || (adc1->isConverting()) ) { // wait for both to finish
        yield();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
    }


    __disable_irq(); // make sure nothing interrupts this part
    if ( adc0->isComplete() ) { // conversion succeded
        res.result_adc0 = adc0->readSingle();
    } else { // comparison was false
        adc0->fail_flag |= ADC_ERROR::COMPARISON;
    }
    if ( adc1->isComplete() ) { // conversion succeded
        res.result_adc1 = adc1->readSingle();
    } else { // comparison was false
        adc1->fail_flag |= ADC_ERROR::COMPARISON;
    }
    __enable_irq();


    // if we interrupted a conversion, set it again
    if (wasADC0InUse) {
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->loadConfig(&old_adc0_config);
    }
    if (wasADC1InUse) {
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->loadConfig(&old_adc1_config);
    }

    //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );

    return res;
}

#if ADC_DIFF_PAIRS > 0
/*Returns the diff analog values of both sets of pins, measured at the same time by the two ADC modules.
* It waits until the value is read and then returns the result as a struct Sync_result,
* use Sync_result.result_adc0 and Sync_result.result_adc1.
* If a comparison has been set up and fails, it will return ADC_ERROR_VALUE in both fields of the struct.
*/
ADC::Sync_result ADC::analogSynchronizedReadDifferential(uint8_t pin0P, uint8_t pin0N, uint8_t pin1P, uint8_t pin1N) {
    Sync_result res = {ADC_ERROR_VALUE, ADC_ERROR_VALUE};;

    // check pins
    if(!adc0->checkDifferentialPins(pin0P, pin0N)) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return res;   // all others are invalid
    }
    if(!adc1->checkDifferentialPins(pin1P, pin1N)) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return res;   // all others are invalid
    }

    uint8_t resolution0 = adc0->getResolution();
    uint8_t resolution1 = adc1->getResolution();

    // check if we are interrupting a measurement, store setting if so.
    // vars to save the current state of the ADC in case it's in use
    ADC_Module::ADC_Config old_adc0_config = {};
    uint8_t wasADC0InUse = adc0->isConverting(); // is the ADC running now?
    if(wasADC0InUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->saveConfig(&old_adc0_config);
        __enable_irq();
    }
    ADC_Module::ADC_Config old_adc1_config = {};
    uint8_t wasADC1InUse = adc1->isConverting(); // is the ADC running now?
    if(wasADC1InUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->saveConfig(&old_adc1_config);
        __enable_irq();
    }

    // no continuous mode
    adc0->singleMode();
    adc1->singleMode();

    // start both measurements
    adc0->startDifferentialFast(pin0P, pin0N);
    adc1->startDifferentialFast(pin1P, pin1N);

    // wait for both ADCs to finish
    while( (adc0->isConverting()) || (adc1->isConverting()) ) {
        yield();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
    }
    __disable_irq(); // make sure nothing interrupts this part
    if (adc0->isComplete()) { // conversion succeded
        res.result_adc0 = adc0->readSingle();
        if(resolution0==16) { // 16 bit differential is actually 15 bit + 1 bit sign
            res.result_adc0 *= 2; // multiply by 2 as if it were really 16 bits, so that getMaxValue gives a correct value.
        }
    } else { // comparison was false
        adc0->fail_flag |= ADC_ERROR::COMPARISON;
    }
    if (adc1->isComplete()) { // conversion succeded
        res.result_adc1 = adc1->readSingle();
        if(resolution1==16) { // 16 bit differential is actually 15 bit + 1 bit sign
            res.result_adc1 *= 2; // multiply by 2 as if it were really 16 bits, so that getMaxValue gives a correct value.
        }
    } else { // comparison was false
        adc1->fail_flag |= ADC_ERROR::COMPARISON;
    }
    __enable_irq();


    // if we interrupted a conversion, set it again
    if (wasADC0InUse) {
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->loadConfig(&old_adc0_config);
    }
    if (wasADC1InUse) {
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->loadConfig(&old_adc1_config);
    }

    //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );

    return res;
}
#endif

/////////////// SYNCHRONIZED NON-BLOCKING METHODS //////////////

// Starts an analog measurement at the same time on the two ADC modules
/* It returns inmediately, get value with readSynchronizedSingle().
*   If the pin is incorrect it returns false
*   If this function interrupts a measurement, it stores the settings in adc_config
*/
bool ADC::startSynchronizedSingleRead(uint8_t pin0, uint8_t pin1) {
    // check pins
    if ( !adc0->checkPin(pin0) ) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;
    }
    if ( !adc1->checkPin(pin1) ) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;
    }

    // check if we are interrupting a measurement, store setting if so.
    adc0->adcWasInUse = adc0->isConverting(); // is the ADC running now?
    if(adc0->adcWasInUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->saveConfig(&adc0->adc_config);
        __enable_irq();
    }
    adc1->adcWasInUse = adc1->isConverting(); // is the ADC running now?
    if(adc1->adcWasInUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->saveConfig(&adc1->adc_config);
        __enable_irq();
    }

    // no continuous mode
    adc0->singleMode();
    adc1->singleMode();

    // start both measurements
    adc0->startReadFast(pin0);
    adc1->startReadFast(pin1);


    //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
    return true;

}

#if ADC_DIFF_PAIRS > 0
// Start a differential conversion between two pins (pin0P - pin0N) and (pin1P - pin1N)
/* It returns inmediately, get value with readSynchronizedSingle().
*   \param pinP must be A10 or A12.
*   \param pinN must be A11 (if pinP=A10) or A13 (if pinP=A12).
*   Other pins will return false.
*   If this function interrupts a measurement, it stores the settings in adc_config
*/
bool ADC::startSynchronizedSingleDifferential(uint8_t pin0P, uint8_t pin0N, uint8_t pin1P, uint8_t pin1N) {

    // check pins
    if(!adc0->checkDifferentialPins(pin0P, pin0N)) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;   // all others are invalid
    }
    if(!adc1->checkDifferentialPins(pin1P, pin1N)) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;   // all others are invalid
    }

    // check if we are interrupting a measurement, store setting if so.
    adc0->adcWasInUse = adc0->isConverting(); // is the ADC running now?
    if(adc0->adcWasInUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc0->saveConfig(&adc0->adc_config);
        __enable_irq();
    }
    adc1->adcWasInUse = adc1->isConverting(); // is the ADC running now?
    if(adc1->adcWasInUse) { // this means we're interrupting a conversion
        // save the current conversion config, the adc isr will restore the adc
        __disable_irq();
        //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );
        adc1->saveConfig(&adc1->adc_config);
        __enable_irq();
    }

    // no continuous mode
    adc0->singleMode();
    adc1->singleMode();

    // start both measurements
    adc0->startDifferentialFast(pin0P, pin0N);
    adc1->startDifferentialFast(pin1P, pin1N);

    //digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN) );

    return true;
}
#endif

// Reads the analog value of a single conversion.
/*
*   \return the converted value.
*/
ADC::Sync_result ADC::readSynchronizedSingle() {
    ADC::Sync_result res;

    res.result_adc0 = adc0->readSingle();
    res.result_adc1 = adc1->readSingle();

    return res;
}


///////////// SYNCHRONIZED CONTINUOUS CONVERSION METHODS ////////////

//! Starts a continuous conversion in both ADCs simultaneously
/** Use readSynchronizedContinuous to get the values
*
*/
bool ADC::startSynchronizedContinuous(uint8_t pin0, uint8_t pin1) {

    // check pins
    if ( !adc0->checkPin(pin0) ) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;
    }
    if ( !adc1->checkPin(pin1) ) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;
    }

    adc0->continuousMode();
    adc1->continuousMode();

    __disable_irq(); // both measurements should have a maximum delay of an instruction time
    adc0->startReadFast(pin0);
    adc1->startReadFast(pin1);
    __enable_irq();

    return true;
}

#if ADC_DIFF_PAIRS > 0
//! Starts a continuous differential conversion in both ADCs simultaneously
/** Use readSynchronizedContinuous to get the values
*
*/
bool ADC::startSynchronizedContinuousDifferential(uint8_t pin0P, uint8_t pin0N, uint8_t pin1P, uint8_t pin1N) {

    // check pins
    if(!adc0->checkDifferentialPins(pin0P, pin0N)) {
        adc0->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;   // all others are invalid
    }
    if(!adc1->checkDifferentialPins(pin1P, pin1N)) {
        adc1->fail_flag |= ADC_ERROR::WRONG_PIN;
        return false;   // all others are invalid
    }

    adc0->continuousMode();
    adc1->continuousMode();

    __disable_irq();
    adc0->startDifferentialFast(pin0P, pin0N);
    adc1->startDifferentialFast(pin1P, pin1N);
    __enable_irq();


    return true;
}
#endif

//! Returns the values of both ADCs.
ADC::Sync_result ADC::readSynchronizedContinuous() {
    ADC::Sync_result res;

    res.result_adc0 = adc0->analogReadContinuous();
    res.result_adc1 = adc1->analogReadContinuous();

    return res;
}

//! Stops synchronous continuous conversion
void ADC::stopSynchronizedContinuous() {

    adc0->stopContinuous();
    adc1->stopContinuous();
}

#endif