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 }

Functions
static void	slowAdcEndCB (ADCDriver *adcp)
static void	slowAdcErrorCB (ADCDriver *, adcerror_t)
float	getMcuTemperature ()
float	getMcuVrefVoltage ()
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	adcAuxChannelCount = 2
static OutputPin	muxControl
static const ADCConversionGroup	auxConvGroup
static constexpr int	auxSensorOversample = 4
static volatile NO_CACHE adcsample_t	auxSensorSamples [adcAuxChannelCount *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

Definition at line 184 of file stm32_adc_v2.cpp.

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

Function Documentation

enableFastAdcChannel()

AdcToken enableFastAdcChannel	(	const char *	msg,
		adc_channel_e	hwChannel
	)

Definition at line 314 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 325 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 411 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 76 of file stm32_adc_v2.cpp.

                          {
#if (EFI_INTERNAL_SLOW_ADC_BACKGROUND == FALSE)
    // Temperature sensor is only physically wired to ADC1
    adcConvert(&ADCD1, &auxConvGroup, (adcsample_t *)auxSensorSamples, auxSensorOversample);
#endif
 
    uint32_t sum = 0;
    for (size_t i = 0; i < auxSensorOversample; i++) {
        sum += auxSensorSamples[0 + adcAuxChannelCount * 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;
}

getMcuVrefVoltage()

float getMcuVrefVoltage

(

)

Definition at line 98 of file stm32_adc_v2.cpp.

                          {
    uint32_t sum = 0;
    for (size_t i = 0; i < auxSensorOversample; i++) {
        sum += auxSensorSamples[1 + adcAuxChannelCount * 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 337 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 345 of file stm32_adc_v2.cpp.

                                                       {
}

portInitAdc()

void portInitAdc

(

)

Definition at line 425 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 246 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;
    }
#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 272 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 300 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 216 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:
            adcStartConversionI(adcp, &auxConvGroup, (adcsample_t *)auxSensorSamples, auxSensorOversample);
            break;
        }
        chSysUnlockFromISR();
    }
}

Here is the call graph for this function:

slowAdcErrorCB()

static void slowAdcErrorCB ( ADCDriver *  , adcerror_t  err  )

static

Definition at line 133 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 192 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 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

adcAuxChannelCount

constexpr size_t adcAuxChannelCount = 2

constexpr

Definition at line 19 of file stm32_adc_v2.cpp.

Referenced by getMcuTemperature(), and getMcuVrefVoltage().

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 368 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 390 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().

auxConvGroup

const ADCConversionGroup auxConvGroup

static

Initial value:

= {
    .circular           = FALSE,
    .num_channels       = adcAuxChannelCount,
#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 41 of file stm32_adc_v2.cpp.

                                               {
    .circular           = FALSE,
    .num_channels       = adcAuxChannelCount,
#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 getMcuTemperature(), and slowAdcEndCB().

auxSensorOversample

constexpr int auxSensorOversample = 4

staticconstexpr

Definition at line 73 of file stm32_adc_v2.cpp.

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

auxSensorSamples

volatile NO_CACHE adcsample_t auxSensorSamples[adcAuxChannelCount *auxSensorOversample]

static

Definition at line 74 of file stm32_adc_v2.cpp.

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

convGroupSlow

ADCConversionGroup convGroupSlow

static

Definition at line 143 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 30 of file stm32_adc_v2.cpp.

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

slowAdcState

slowAdcState_t slowAdcState = convertPrimary

static

Definition at line 214 of file stm32_adc_v2.cpp.

Referenced by slowAdcEndCB().

slowSampleBuffer

volatile NO_CACHE adcsample_t slowSampleBuffer[SLOW_ADC_OVERSAMPLE *adcChannelCount]

static

Definition at line 128 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 130 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 348 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 356 of file stm32_adc_v2.cpp.

Go to the source code of this file.