stm32_adc_v2.cpp File Reference

Detailed Description

Port implementation for the STM32 "v2" ADC found on the STM32F4 and STM32F7.

Date

February 9, 2021

Author

Matthew Kennedy, (c) 2021

Definition in file stm32_adc_v2.cpp.

Enumerations
enum	slowAdcState_t { convertPrimary , convertMuxed , convertAux , convertAux2 }

Functions
static void	slowAdcEndCB (ADCDriver *adcp)
static void	slowAdcErrorCB (ADCDriver *, adcerror_t)
float	getMcuTemperature ()
float	getMcuVrefVoltage ()
float	getMcuVbatVoltage ()
static slowAdcState_t	slowAdcGetNextState (slowAdcState_t state)
static bool	readBatch (adcsample_t *convertedSamples, adcsample_t *b)
bool	readSlowAnalogInputs (adcsample_t *convertedSamples)
static void	slowAdcEnableDisableChannel (adc_channel_e hwChannel, bool en)
AdcToken	enableFastAdcChannel (const char *, adc_channel_e hwChannel)
adcsample_t	getFastAdc (AdcToken token)
static void	knockCompletionCallback (ADCDriver *adcp)
static void	knockErrorCallback (ADCDriver *, adcerror_t)
const ADCConversionGroup *	getKnockConversionGroup (uint8_t channelIdx)
void	portInitAdc ()

Variables
constexpr size_t	adcChannelCount = 16
constexpr size_t	adcAux1ChannelCount = 2
constexpr size_t	adcAux2ChannelCount = 1
static OutputPin	muxControl
static const ADCConversionGroup	aux1ConvGroup
static const ADCConversionGroup	aux2ConvGroup
static constexpr int	auxSensorOversample = 4
static volatile NO_CACHE adcsample_t	aux1SensorSamples [adcAux1ChannelCount *auxSensorOversample]
static volatile NO_CACHE adcsample_t	aux2SensorSamples [adcAux2ChannelCount *auxSensorOversample]
static volatile NO_CACHE adcsample_t	slowSampleBuffer [SLOW_ADC_OVERSAMPLE *adcChannelCount]
static volatile NO_CACHE adcsample_t	slowSampleBufferMuxed [SLOW_ADC_OVERSAMPLE *adcChannelCount]
static ADCConversionGroup	convGroupSlow
static slowAdcState_t	slowAdcState = convertPrimary
AdcDevice	fastAdc
static const uint32_t	smpr1
static const uint32_t	smpr2
static const ADCConversionGroup	adcConvGroupCh1
static const ADCConversionGroup	adcConvGroupCh2

Enumeration Type Documentation

slowAdcState_t

enum slowAdcState_t

Enumerator
convertPrimary
convertMuxed
convertAux
convertAux2

Definition at line 226 of file stm32_adc_v2.cpp.

             {
    convertPrimary,
#ifdef ADC_MUX_PIN
    convertMuxed,
#endif
    convertAux,
    convertAux2,
} slowAdcState_t;

Function Documentation

enableFastAdcChannel()

AdcToken enableFastAdcChannel	(	const char *	msg,
		adc_channel_e	hwChannel
	)

Definition at line 372 of file stm32_adc_v2.cpp.

                                                                    {
    if (!isAdcChannelValid(hwChannel)) {
        return invalidAdcToken;
    }
 
    // Do not run slow ADC for fast ADC inputs
    slowAdcEnableDisableChannel(hwChannel, false);
 
    return fastAdc.getAdcChannelToken(hwChannel);
}

Here is the call graph for this function:

getFastAdc()

adcsample_t getFastAdc

(

AdcToken

token

)

Definition at line 383 of file stm32_adc_v2.cpp.

                                       {
    if (token == invalidAdcToken) {
        return 0;
    }
 
    return fastAdc.getAdcValueByToken(token);
}

Here is the call graph for this function:

getKnockConversionGroup()

const ADCConversionGroup * getKnockConversionGroup

(

uint8_t

channelIdx

)

Definition at line 469 of file stm32_adc_v2.cpp.

                                                                      {
#if KNOCK_HAS_CH2
    if (channelIdx == 1) {
        return &adcConvGroupCh2;
    }
#else
    (void)channelIdx;
#endif // KNOCK_HAS_CH2
 
    return &adcConvGroupCh1;
}

getMcuTemperature()

float getMcuTemperature

(

)

Definition at line 100 of file stm32_adc_v2.cpp.

                          {
    uint32_t sum = 0;
    for (size_t i = 0; i < auxSensorOversample; i++) {
        sum += aux1SensorSamples[0 + adcAux1ChannelCount * i];
    }
 
    float volts = (float)sum / (ADC_MAX_VALUE * auxSensorOversample);
    volts *= engineConfiguration->adcVcc;
 
    volts -= 0.760f; // Subtract the reference voltage at 25 deg C
    float degrees = volts / 0.0025f; // Divide by slope 2.5mV
 
    degrees += 25.0; // Add the 25 deg C
 
    return degrees;
}

getMcuVbatVoltage()

float getMcuVbatVoltage

(

)

Definition at line 132 of file stm32_adc_v2.cpp.

                          {
    uint32_t sum = 0;
    for (size_t i = 0; i < auxSensorOversample; i++) {
        sum += aux2SensorSamples[0 + adcAux2ChannelCount * i];
    }
 
#if defined(STM32F4XX)
    // VBAT/2 on STM32F40xx and STM32F41xx devices, VBAT/4 on STM32F42xx and STM32F43xx devices
    int mult = 2;
    if (isStm32F42x()) {
        mult = 4;
    }
#endif
#if defined(STM32F7XX)
    int mult = 4;
#endif
 
    float Vbat = (float)sum * mult / (ADC_MAX_VALUE * auxSensorOversample);
    Vbat *= engineConfiguration->adcVcc;
 
    return Vbat;
}

Here is the call graph for this function:

getMcuVrefVoltage()

float getMcuVrefVoltage

(

)

Definition at line 117 of file stm32_adc_v2.cpp.

                          {
    uint32_t sum = 0;
    for (size_t i = 0; i < auxSensorOversample; i++) {
        sum += aux1SensorSamples[1 + adcAux1ChannelCount * i];
    }
 
    // TODO: apply calibration value from OTP (if exists)
    // vrefint should be 1.21V
    // Let's calculate external Vref+
    // sum / (ADC_MAX_VALUE * auxSensorOversample) * Vref+ = 1.21;
    float Vref = 1.21f * auxSensorOversample * ADC_MAX_VALUE / sum;
 
    return Vref;
}

knockCompletionCallback()

static void knockCompletionCallback ( ADCDriver *  adcp )

static

Definition at line 395 of file stm32_adc_v2.cpp.

                                                     {
    if (adcIsBufferComplete(adcp)) {
        onKnockSamplingComplete();
    }
 
    assertInterruptPriority(__func__, EFI_IRQ_ADC_PRIORITY);
}

Here is the call graph for this function:

knockErrorCallback()

static void knockErrorCallback ( ADCDriver *  , adcerror_t    )

static

Definition at line 403 of file stm32_adc_v2.cpp.

                                                       {
}

portInitAdc()

void portInitAdc

(

)

Definition at line 483 of file stm32_adc_v2.cpp.

                   {
#ifdef ADC_MUX_PIN
    muxControl.initPin("ADC Mux", ADC_MUX_PIN);
#endif //ADC_MUX_PIN
 
    // Init slow ADC
    adcStart(&ADCD1, NULL);
 
    // Enable internal temperature reference
    adcSTM32EnableTSVREFE(); // Internal temperature sensor
 
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    adcStartConversion(&ADCD1, &convGroupSlow, (adcsample_t *)slowSampleBuffer, SLOW_ADC_OVERSAMPLE);
#endif
 
#if EFI_USE_FAST_ADC
    // Init fast ADC (MAP sensor)
    adcStart(&ADCD2, NULL);
#endif
 
#if defined(STM32F7XX)
    /* the temperature sensor is internally
     * connected to the same input channel as VBAT. Only one conversion,
     * temperature sensor or VBAT, must be selected at a time. */
    adcSTM32DisableVBATE();
#endif
 
    /* Enable this code only when you absolutly sure
     * that there is no possible errors from ADC */
#if 0
    /* All ADC use DMA and DMA calls end_cb from its IRQ
     * If none of ADC users need error callback - we can disable
     * shared ADC IRQ and save some CPU ticks */
    if ((adcgrpcfgSlow.error_cb == NULL) &&
        (adcgrpcfgFast.error_cb == NULL)
        /* TODO: Add ADC3? */) {
        nvicDisableVector(STM32_ADC_NUMBER);
    }
#endif
 
#ifdef EFI_SOFTWARE_KNOCK
    adcStart(&KNOCK_ADC, nullptr);
#endif // EFI_SOFTWARE_KNOCK
}

Here is the call graph for this function:

readBatch()

static bool readBatch ( adcsample_t *  convertedSamples, adcsample_t *  b  )

static

Definition at line 296 of file stm32_adc_v2.cpp.

                                                                     {
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == FALSE)
    msg_t result = adcConvert(&ADCD1, &convGroupSlow, b, SLOW_ADC_OVERSAMPLE);
 
    // If something went wrong - try again later
    if (result != MSG_OK) {
        return false;
    }
 
    // Temperature sensor is only physically wired to ADC1
    adcConvert(&ADCD1, &auxConvGroup, (adcsample_t *)auxSensorSamples, auxSensorOversample);
 
    // Switch IN18 input to Vbat
    adcSTM32EnableVBATE();
    adcConvert(adcp, &aux2ConvGroup, (adcsample_t *)aux2SensorSamples, auxSensorOversample);
    adcSTM32DisableVBATE();
#endif
 
    // Average samples to get some noise filtering and oversampling
    for (size_t i = 0; i < adcChannelCount; i++) {
        uint32_t sum = 0;
        size_t index = i;
        for (size_t j = 0; j < SLOW_ADC_OVERSAMPLE; j++) {
            sum += b[index];
            index += adcChannelCount;
        }
 
        adcsample_t value = static_cast<adcsample_t>(sum / SLOW_ADC_OVERSAMPLE);
        convertedSamples[i] = value;
    }
 
    return true;
}

Referenced by readSlowAnalogInputs().

Here is the caller graph for this function:

readSlowAnalogInputs()

bool readSlowAnalogInputs

(

adcsample_t *

convertedSamples

)

Definition at line 330 of file stm32_adc_v2.cpp.

                                                         {
    bool result = true;
 
    result &= readBatch(convertedSamples, (adcsample_t *)slowSampleBuffer);
 
#ifdef ADC_MUX_PIN
    #if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == FALSE)
        muxControl.setValue(1, /*force*/true);
    #endif
        // read the second batch, starting where we left off
        result &= readBatch(&convertedSamples[adcChannelCount], (adcsample_t *)slowSampleBufferMuxed);
    #if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == FALSE)
        muxControl.setValue(0, /*force*/true);
    #endif
#endif
 
    return result;
}

Here is the call graph for this function:

slowAdcEnableDisableChannel()

static void slowAdcEnableDisableChannel ( adc_channel_e  hwChannel, bool  en  )

static

Definition at line 358 of file stm32_adc_v2.cpp.

{
    if (!isAdcChannelValid(hwChannel)) {
        return;
    }
 
    /* TODO: following is correct for STM32 ADC1/2.
     * ADC3 has another input to gpio mapping
     * and should be handled separately */
    uint32_t channelAdcIndex = hwChannel - EFI_ADC_0;
    // Switch disabled channel to internal Vrefint channel
    adcConversionGroupSetSeqInput(&convGroupSlow, channelAdcIndex, en ? channelAdcIndex : 17);
}

Referenced by enableFastAdcChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

slowAdcEndCB()

static void slowAdcEndCB ( ADCDriver *  adcp )

static

Definition at line 261 of file stm32_adc_v2.cpp.

                                          {
    if (adcIsBufferComplete(adcp)) {
        chSysLockFromISR();
        // Switch state to ready to allow starting new conversion from here
        adcp->state = ADC_READY;
        // get next state
        slowAdcState = slowAdcGetNextState(slowAdcState);
        switch (slowAdcState) {
        case convertPrimary:
            #ifdef ADC_MUX_PIN
            muxControl.setValue(0, /*force*/true);
            #endif
            adcStartConversionI(adcp, &convGroupSlow, (adcsample_t *)slowSampleBuffer, SLOW_ADC_OVERSAMPLE);
            break;
        #ifdef ADC_MUX_PIN
        case convertMuxed:
            muxControl.setValue(1, /*force*/true);
            // convert second half
            adcStartConversionI(adcp, &convGroupSlow, (adcsample_t *)slowSampleBufferMuxed, SLOW_ADC_OVERSAMPLE);
            break;
        #endif
        case convertAux:
            adcSTM32DisableVBATE();
            adcStartConversionI(adcp, &aux1ConvGroup, (adcsample_t *)aux1SensorSamples, auxSensorOversample);
            break;
        case convertAux2:
            adcSTM32EnableVBATE();
            adcStartConversionI(adcp, &aux2ConvGroup, (adcsample_t *)aux2SensorSamples, auxSensorOversample);
            break;
        }
        chSysUnlockFromISR();
    }
}

Here is the call graph for this function:

slowAdcErrorCB()

static void slowAdcErrorCB ( ADCDriver *  , adcerror_t  err  )

static

Definition at line 175 of file stm32_adc_v2.cpp.

                                                        {
    engine->outputChannels.slowAdcErrorCount++;
    if (err == ADC_ERR_OVERFLOW) {
        engine->outputChannels.slowAdcOverrunCount++;
    }
    // TODO: restart?
}

slowAdcGetNextState()

static slowAdcState_t slowAdcGetNextState ( slowAdcState_t  state )

static

Definition at line 235 of file stm32_adc_v2.cpp.

{
    switch (state) {
    case convertPrimary:
        #ifdef ADC_MUX_PIN
        return convertMuxed;
        #else
        return convertAux;
        #endif
    break;
#ifdef ADC_MUX_PIN
    case convertMuxed:
        return convertAux;
    break;
#endif
    case convertAux:
        return convertAux2;
    case convertAux2:
        return convertPrimary;
    break;
    }
    return convertPrimary;
}

Referenced by slowAdcEndCB().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

adcAux1ChannelCount

constexpr size_t adcAux1ChannelCount = 2

constexpr

Definition at line 19 of file stm32_adc_v2.cpp.

Referenced by getMcuTemperature(), and getMcuVrefVoltage().

adcAux2ChannelCount

constexpr size_t adcAux2ChannelCount = 1

constexpr

Definition at line 20 of file stm32_adc_v2.cpp.

Referenced by getMcuVbatVoltage().

adcChannelCount

constexpr size_t adcChannelCount = 16

constexpr

Definition at line 18 of file stm32_adc_v2.cpp.

Referenced by readBatch(), and readSlowAnalogInputs().

adcConvGroupCh1

const ADCConversionGroup adcConvGroupCh1

static

Initial value:

= {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cr1 = 0,
    .cr2 = ADC_CR2_SWSTART,
    
    .smpr1 = smpr1,
    
    .smpr2 = smpr2,
 
    .htr = 0,
    .ltr = 0,
 
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 = ADC_SQR3_SQ1_N(KNOCK_ADC_CH1)
}

Definition at line 426 of file stm32_adc_v2.cpp.

                                                  {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cr1 = 0,
    .cr2 = ADC_CR2_SWSTART,
    // sample times for channels 10...18
    .smpr1 = smpr1,
    // sample times for channels 0...9
    .smpr2 = smpr2,
 
    .htr = 0,
    .ltr = 0,
 
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 = ADC_SQR3_SQ1_N(KNOCK_ADC_CH1)
};

Referenced by getKnockConversionGroup().

adcConvGroupCh2

const ADCConversionGroup adcConvGroupCh2

static

Initial value:

= {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cr1 = 0,
    .cr2 = ADC_CR2_SWSTART,
    
    .smpr1 = smpr1,
    
    .smpr2 = smpr2,
 
    .htr = 0,
    .ltr = 0,
 
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 = ADC_SQR3_SQ1_N(KNOCK_ADC_CH2)
}

Definition at line 448 of file stm32_adc_v2.cpp.

                                                  {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cr1 = 0,
    .cr2 = ADC_CR2_SWSTART,
    // sample times for channels 10...18
    .smpr1 = smpr1,
    // sample times for channels 0...9
    .smpr2 = smpr2,
 
    .htr = 0,
    .ltr = 0,
 
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 = ADC_SQR3_SQ1_N(KNOCK_ADC_CH2)
};

Referenced by getKnockConversionGroup().

aux1ConvGroup

const ADCConversionGroup aux1ConvGroup

static

Initial value:

= {
    .circular           = FALSE,
    .num_channels       = adcAux1ChannelCount,
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    .end_cb             = slowAdcEndCB,
#else
    .end_cb             = nullptr,
#endif
    .error_cb           = slowAdcErrorCB,
    
    .cr1                = 0,
    .cr2                = ADC_CR2_SWSTART,
    
    .smpr1 =
        ADC_SMPR1_SMP_VBAT(ADC_SAMPLE_144) |    
        ADC_SMPR1_SMP_SENSOR(ADC_SAMPLE_144) |  
        ADC_SMPR1_SMP_VREF(ADC_SAMPLE_144),     
    .smpr2 = 0,
    .htr = 0, .ltr = 0,
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 =
#if defined(STM32F4XX)
        ADC_SQR3_SQ1_N(16) |
#endif
#if defined(STM32F7XX)
        ADC_SQR3_SQ1_N(18) |
#endif
        ADC_SQR3_SQ2_N(17),
}

Definition at line 42 of file stm32_adc_v2.cpp.

                                                {
    .circular           = FALSE,
    .num_channels       = adcAux1ChannelCount,
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    .end_cb             = slowAdcEndCB,
#else
    .end_cb             = nullptr,
#endif
    .error_cb           = slowAdcErrorCB,
    /* HW dependent part below */
    .cr1                = 0,
    .cr2                = ADC_CR2_SWSTART,
    // sample times for channels 10...18
    .smpr1 =
        ADC_SMPR1_SMP_VBAT(ADC_SAMPLE_144) |    /* input18 - temperature and vbat input on some STM32F7xx */
        ADC_SMPR1_SMP_SENSOR(ADC_SAMPLE_144) |  /* input16 - temperature sensor input on STM32F4xx */
        ADC_SMPR1_SMP_VREF(ADC_SAMPLE_144),     /* input17 - Vrefint input */
    .smpr2 = 0,
    .htr = 0, .ltr = 0,
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 =
#if defined(STM32F4XX)
        ADC_SQR3_SQ1_N(16) |
#endif
#if defined(STM32F7XX)
        ADC_SQR3_SQ1_N(18) |
#endif
        ADC_SQR3_SQ2_N(17),
};

Referenced by slowAdcEndCB().

aux1SensorSamples

volatile NO_CACHE adcsample_t aux1SensorSamples[adcAux1ChannelCount *auxSensorOversample]

static

Definition at line 97 of file stm32_adc_v2.cpp.

Referenced by getMcuTemperature(), getMcuVrefVoltage(), and slowAdcEndCB().

aux2ConvGroup

const ADCConversionGroup aux2ConvGroup

static

Initial value:

= {
    .circular           = FALSE,
    .num_channels       = adcAux2ChannelCount,
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    .end_cb             = slowAdcEndCB,
#else
    .end_cb             = nullptr,
#endif
    .error_cb           = slowAdcErrorCB,
    
    .cr1                = 0,
    .cr2                = ADC_CR2_SWSTART,
    
    .smpr1 =
        ADC_SMPR1_SMP_VBAT(ADC_SAMPLE_144),     
    .smpr2 = 0,
    .htr = 0, .ltr = 0,
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 =
        ADC_SQR3_SQ1_N(18),
}

Definition at line 73 of file stm32_adc_v2.cpp.

                                                {
    .circular           = FALSE,
    .num_channels       = adcAux2ChannelCount,
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    .end_cb             = slowAdcEndCB,
#else
    .end_cb             = nullptr,
#endif
    .error_cb           = slowAdcErrorCB,
    /* HW dependent part below */
    .cr1                = 0,
    .cr2                = ADC_CR2_SWSTART,
    // sample times for channels 10...18
    .smpr1 =
        ADC_SMPR1_SMP_VBAT(ADC_SAMPLE_144),     /* input18 - vbat input on STM32F4xx and STM32F7xx */
    .smpr2 = 0,
    .htr = 0, .ltr = 0,
    .sqr1 = 0,
    .sqr2 = 0,
    .sqr3 =
        ADC_SQR3_SQ1_N(18),
};

Referenced by readBatch(), and slowAdcEndCB().

aux2SensorSamples

volatile NO_CACHE adcsample_t aux2SensorSamples[adcAux2ChannelCount *auxSensorOversample]

static

Definition at line 98 of file stm32_adc_v2.cpp.

Referenced by getMcuVbatVoltage(), readBatch(), and slowAdcEndCB().

auxSensorOversample

constexpr int auxSensorOversample = 4

staticconstexpr

Definition at line 96 of file stm32_adc_v2.cpp.

Referenced by getMcuTemperature(), getMcuVbatVoltage(), getMcuVrefVoltage(), readBatch(), and slowAdcEndCB().

convGroupSlow

ADCConversionGroup convGroupSlow

static

Definition at line 185 of file stm32_adc_v2.cpp.

                                            {
    .circular           = FALSE,
    .num_channels       = adcChannelCount,
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == TRUE)
    .end_cb             = slowAdcEndCB,
#else
    .end_cb             = nullptr,
#endif
    .error_cb           = slowAdcErrorCB,
    /* HW dependent part.*/
    .cr1                = 0,
    .cr2                = ADC_CR2_SWSTART,
    // Configure all channels to ADC_SAMPLING_SLOW sample time
    .smpr1 =
        ADC_SMPR1_SMP_AN10(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN11(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN12(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN13(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN14(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN15(ADC_SAMPLING_SLOW),
    .smpr2 =
        ADC_SMPR2_SMP_AN0(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN1(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN2(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN3(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN4(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN5(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN6(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN7(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN8(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN9(ADC_SAMPLING_SLOW),
    .htr    = 0,
    .ltr    = 0,
    // Simply sequence every channel in order
    .sqr1   = ADC_SQR1_SQ13_N(12) | ADC_SQR1_SQ14_N(13) | ADC_SQR1_SQ15_N(14) | ADC_SQR1_SQ16_N(15), // Conversion group sequence 13...16
    .sqr2   =   ADC_SQR2_SQ7_N(6) |   ADC_SQR2_SQ8_N(7) |   ADC_SQR2_SQ9_N(8) | ADC_SQR2_SQ10_N(9) | ADC_SQR2_SQ11_N(10) | ADC_SQR2_SQ12_N(11), // Conversion group sequence 7...12
    .sqr3   =   ADC_SQR3_SQ1_N(0) |   ADC_SQR3_SQ2_N(1) |   ADC_SQR3_SQ3_N(2) |  ADC_SQR3_SQ4_N(3) |   ADC_SQR3_SQ5_N(4) |   ADC_SQR3_SQ6_N(5), // Conversion group sequence 1...6
};

Referenced by portInitAdc(), readBatch(), slowAdcEnableDisableChannel(), and slowAdcEndCB().

fastAdc

AdcDevice fastAdc

extern

Referenced by enableFastAdcChannel(), and getFastAdc().

muxControl

OutputPin muxControl

static

Definition at line 31 of file stm32_adc_v2.cpp.

Referenced by portInitAdc(), readSlowAnalogInputs(), and slowAdcEndCB().

slowAdcState

slowAdcState_t slowAdcState = convertPrimary

static

Definition at line 259 of file stm32_adc_v2.cpp.

Referenced by slowAdcEndCB().

slowSampleBuffer

volatile NO_CACHE adcsample_t slowSampleBuffer[SLOW_ADC_OVERSAMPLE *adcChannelCount]

static

Definition at line 170 of file stm32_adc_v2.cpp.

Referenced by portInitAdc(), readSlowAnalogInputs(), and slowAdcEndCB().

slowSampleBufferMuxed

volatile NO_CACHE adcsample_t slowSampleBufferMuxed[SLOW_ADC_OVERSAMPLE *adcChannelCount]

static

Definition at line 172 of file stm32_adc_v2.cpp.

Referenced by readSlowAnalogInputs(), and slowAdcEndCB().

smpr1

const uint32_t smpr1

static

Initial value:

=
    ADC_SMPR1_SMP_AN10(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN11(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN12(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN13(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN14(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN15(KNOCK_SAMPLE_TIME)

Definition at line 406 of file stm32_adc_v2.cpp.

smpr2

const uint32_t smpr2

static

Initial value:

=
    ADC_SMPR2_SMP_AN0(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN1(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN2(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN3(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN4(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN5(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN6(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN7(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN8(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN9(KNOCK_SAMPLE_TIME)

Definition at line 414 of file stm32_adc_v2.cpp.

Go to the source code of this file.