stm32_adc_v4.cpp File Reference

Detailed Description

Port implementation for the STM32 "v4" ADC found on the STM32H7.

Date

February 25, 2021

Author

Matthew Kennedy, (c) 2021

Definition in file stm32_adc_v4.cpp.

Functions
static constexpr size_t	log2_int (size_t x)
void	portInitAdc ()
float	getMcuTemperature ()
float	getMcuVrefVoltage ()
static void	adc_callback (ADCDriver *adcp)
bool	readSlowAnalogInputs (adcsample_t *convertedSamples)
AdcToken	enableFastAdcChannel (const char *, adc_channel_e channel)
adcsample_t	getFastAdc (AdcToken token)
static void	knockCompletionCallback (ADCDriver *adcp)
static void	knockErrorCallback (ADCDriver *, adcerror_t)
const ADCConversionGroup *	getKnockConversionGroup (uint8_t channelIdx)

Variables
static constexpr int	H7_ADC_SHIFT_BITS = log2_int(H7_ADC_OVERSAMPLE)
adcsample_t *	fastSampleBuffer
constexpr size_t	slowChannelCount = 16
static constexpr ADCConversionGroup	convGroupSlow
static bool	didStart = false
static constexpr int	H7_KNOCK_ADC_SHIFT_BITS = log2_int(H7_KNOCK_OVERSAMPLE)
static const uint32_t	smpr1
static const uint32_t	smpr2
static const ADCConversionGroup	adcConvGroupCh1
static const ADCConversionGroup	adcConvGroupCh2

Function Documentation

adc_callback()

static void adc_callback ( ADCDriver *  adcp )

static

Definition at line 69 of file stm32_adc_v4.cpp.

                                          {
    // State may not be complete if we get a callback for "half done"
    if (adcIsBufferComplete(adcp)) {
      // here we invoke 'fast' from slow ADC due to https://github.com/rusefi/rusefi/issues/3301
        onFastAdcComplete(adcp->samples);
    }
}

Here is the call graph for this function:

enableFastAdcChannel()

AdcToken enableFastAdcChannel	(	const char *	msg,
		adc_channel_e	channel
	)

Definition at line 184 of file stm32_adc_v4.cpp.

                                                                  {
    if (!isAdcChannelValid(channel)) {
        return invalidAdcToken;
    }
 
    // H7 always samples all fast channels, nothing to do here but compute index
    return channel - EFI_ADC_0;
}

Referenced by calcFastAdcIndexes().

Here is the call graph for this function:

Here is the caller graph for this function:

getFastAdc()

adcsample_t getFastAdc

(

AdcToken

token

)

Definition at line 193 of file stm32_adc_v4.cpp.

                                       {
    if (token == invalidAdcToken) {
        return 0;
    }
 
    return fastSampleBuffer[token];
}

Referenced by onFastAdcComplete().

Here is the caller graph for this function:

getKnockConversionGroup()

const ADCConversionGroup * getKnockConversionGroup

(

uint8_t

channelIdx

)

Definition at line 289 of file stm32_adc_v4.cpp.

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

Referenced by onStartKnockSampling().

Here is the caller graph for this function:

getMcuTemperature()

float getMcuTemperature

(

)

Definition at line 57 of file stm32_adc_v4.cpp.

                          {
    // Ugh, internal temp sensor is wired to ADC3, which makes it nearly useless on the H7.
    return 0;
}

getMcuVrefVoltage()

float getMcuVrefVoltage

(

)

Definition at line 62 of file stm32_adc_v4.cpp.

                          {
    // TODO: implement me!
    return engineConfiguration->adcVcc;
}

knockCompletionCallback()

static void knockCompletionCallback ( ADCDriver *  adcp )

static

Definition at line 207 of file stm32_adc_v4.cpp.

                                                     {
    if (adcIsBufferComplete(adcp)) {
        onKnockSamplingComplete();
    }
}

Here is the call graph for this function:

knockErrorCallback()

static void knockErrorCallback ( ADCDriver *  , adcerror_t    )

static

Definition at line 213 of file stm32_adc_v4.cpp.

                                                       {
}

log2_int()

static constexpr size_t log2_int ( size_t  x )

staticconstexpr

Definition at line 30 of file stm32_adc_v4.cpp.

                                           {
    size_t result = 0;
    while (x >>= 1) result++;
    return result;
}

portInitAdc()

void portInitAdc

(

)

Definition at line 43 of file stm32_adc_v4.cpp.

                   {
    // Init slow ADC
    adcStart(&ADCD1, NULL);
 
#if STM32_ADC_USE_ADC3
    // Knock/trigger scope ADC
    adcStart(&ADCD3, nullptr);
#endif // STM32_ADC_USE_ADC3
 
    // Connect the analog switches between {PA0_C, PA1_C, PC2_C, PC3_C} and their non-C counterparts
    // This lets us use normal (non-direct) analog on those channels
    SYSCFG->PMCR &= ~(SYSCFG_PMCR_PA0SO | SYSCFG_PMCR_PA1SO | SYSCFG_PMCR_PC2SO | SYSCFG_PMCR_PC3SO);
}

readSlowAnalogInputs()

bool readSlowAnalogInputs

(

adcsample_t *

convertedSamples

)

Definition at line 150 of file stm32_adc_v4.cpp.

                                                         {
    // This only needs to happen once, as the timer will continue firing the ADC and writing to the buffer without our help
    if (didStart) {
        return true;
    }
    didStart = true;
 
    fastSampleBuffer = convertedSamples;
 
    {
        chibios_rt::CriticalSectionLocker csl;
        // Oversampling and right-shift happen in hardware, so we can sample directly to the output buffer
        adcStartConversionI(&ADCD1, &convGroupSlow, convertedSamples, 1);
    }
 
    constexpr uint32_t samplingRate = H7_ADC_SPEED;
    constexpr uint32_t timerCountFrequency = samplingRate * 10;
    constexpr uint32_t timerPeriod = timerCountFrequency / samplingRate;
 
    static constexpr GPTConfig gptCfg = {
        timerCountFrequency,
        nullptr,
        TIM_CR2_MMS_1,  // TRGO on update event
        0
    };
 
    // Start timer
    gptStart(&GPTD3, &gptCfg);
    gptStartContinuous(&GPTD3, timerPeriod);
 
    // Return true if OK
    return true;
}

Variable Documentation

adcConvGroupCh1

const ADCConversionGroup adcConvGroupCh1

static

Initial value:

= {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cfgr               = 0,
    .cfgr2              =   (H7_KNOCK_OVERSAMPLE - 1) << ADC_CFGR2_OVSR_Pos |   
                            H7_KNOCK_ADC_SHIFT_BITS << ADC_CFGR2_OVSS_Pos |     
                            ADC_CFGR2_ROVSE,            
    .ccr                = 0,
    .pcsel              = 0xFFFFFFFF, 
    
    .ltr1 = 0, .htr1 = 0, .ltr2 = 0, .htr2 = 0, .ltr3 = 0, .htr3 = 0,
    .awd2cr = 0,
    .awd3cr = 0,
    .smpr = {smpr1, smpr2},
    .sqr = {
        ADC_SQR1_SQ1_N(KNOCK_ADC_CH1),
        0,
        0
    },
}

Definition at line 240 of file stm32_adc_v4.cpp.

                                                  {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cfgr               = 0,
    .cfgr2              =   (H7_KNOCK_OVERSAMPLE - 1) << ADC_CFGR2_OVSR_Pos |   // Oversample by Nx (register contains N-1)
                            H7_KNOCK_ADC_SHIFT_BITS << ADC_CFGR2_OVSS_Pos |     // shift the result right log2(N) bits to make a 16 bit result out of the internal oversample sum
                            ADC_CFGR2_ROVSE,            // Enable oversampling
    .ccr                = 0,
    .pcsel              = 0xFFFFFFFF, // enable analog switches on all channels
    // Thresholds aren't used
    .ltr1 = 0, .htr1 = 0, .ltr2 = 0, .htr2 = 0, .ltr3 = 0, .htr3 = 0,
    .awd2cr = 0,
    .awd3cr = 0,
    .smpr = {smpr1, smpr2},
    .sqr = {
        ADC_SQR1_SQ1_N(KNOCK_ADC_CH1),
        0,
        0
    },
};

Referenced by getKnockConversionGroup().

adcConvGroupCh2

const ADCConversionGroup adcConvGroupCh2

static

Initial value:

= {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cfgr               = 0,
    .cfgr2              =   (H7_ADC_OVERSAMPLE - 1) << ADC_CFGR2_OVSR_Pos | 
                            H7_ADC_SHIFT_BITS << ADC_CFGR2_OVSS_Pos |       
                            ADC_CFGR2_ROVSE,            
    .ccr                = 0,
    .pcsel              = 0xFFFFFFFF, 
    
    .ltr1 = 0, .htr1 = 0, .ltr2 = 0, .htr2 = 0, .ltr3 = 0, .htr3 = 0,
    .awd2cr = 0,
    .awd3cr = 0,
    .smpr = {smpr1, smpr2},
    .sqr = {
        ADC_SQR1_SQ1_N(KNOCK_ADC_CH2),
        0,
        0
    },
}

Definition at line 265 of file stm32_adc_v4.cpp.

                                                  {
    .circular = FALSE,
    .num_channels = 1,
    .end_cb = &knockCompletionCallback,
    .error_cb = &knockErrorCallback,
    .cfgr               = 0,
    .cfgr2              =   (H7_ADC_OVERSAMPLE - 1) << ADC_CFGR2_OVSR_Pos | // Oversample by Nx (register contains N-1)
                            H7_ADC_SHIFT_BITS << ADC_CFGR2_OVSS_Pos |       // shift the result right log2(N) bits to make a 16 bit result out of the internal oversample sum
                            ADC_CFGR2_ROVSE,            // Enable oversampling
    .ccr                = 0,
    .pcsel              = 0xFFFFFFFF, // enable analog switches on all channels
    // Thresholds aren't used
    .ltr1 = 0, .htr1 = 0, .ltr2 = 0, .htr2 = 0, .ltr3 = 0, .htr3 = 0,
    .awd2cr = 0,
    .awd3cr = 0,
    .smpr = {smpr1, smpr2},
    .sqr = {
        ADC_SQR1_SQ1_N(KNOCK_ADC_CH2),
        0,
        0
    },
};

Referenced by getKnockConversionGroup().

convGroupSlow

constexpr ADCConversionGroup convGroupSlow

staticconstexpr

Definition at line 88 of file stm32_adc_v4.cpp.

                                                    {
    .circular           = true,     // Continuous mode means we will auto re-trigger on every timer event
    .num_channels       = slowChannelCount,
    .end_cb             = adc_callback,
    .error_cb           = nullptr,
    .cfgr               = ADC_CFGR_EXTEN_0 | (4 << ADC_CFGR_EXTSEL_Pos),    // External trigger ch4, rising edge: TIM3 TRGO
    .cfgr2              =   (H7_ADC_OVERSAMPLE - 1) << ADC_CFGR2_OVSR_Pos | // Oversample by Nx (register contains N-1)
                            H7_ADC_SHIFT_BITS << ADC_CFGR2_OVSS_Pos |       // shift the result right log2(N) bits to make a 16 bit result out of the internal oversample sum
                            ADC_CFGR2_ROVSE,            // Enable oversampling
    .ccr                = 0,
    .pcsel              = 0xFFFFFFFF, // enable analog switches on all channels
    // Thresholds aren't used
    .ltr1 = 0, .htr1 = 0, .ltr2 = 0, .htr2 = 0, .ltr3 = 0, .htr3 = 0,
    .awd2cr = 0,
    .awd3cr = 0,
    .smpr = {
        // Configure all channels to use ADC_SAMPLING_SLOW time
        ADC_SMPR1_SMP_AN0(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN1(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN2(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN3(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN4(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN5(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN6(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN7(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN8(ADC_SAMPLING_SLOW) |
        ADC_SMPR1_SMP_AN9(ADC_SAMPLING_SLOW),
        ADC_SMPR2_SMP_AN10(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN11(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN12(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN13(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN14(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN15(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN16(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN17(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN18(ADC_SAMPLING_SLOW) |
        ADC_SMPR2_SMP_AN19(ADC_SAMPLING_SLOW)
    },
    .sqr = {
        // The seemingly insane values here exist to put the values
        // in the buffer in the same order as the ADCv2 (F4/F7) ADC
        ADC_SQR1_SQ1_N(16) |    // PA0 (aka PA0_C)
        ADC_SQR1_SQ2_N(17) |    // PA1 (aka PA1_C)
        ADC_SQR1_SQ3_N(14) |    // PA2
        ADC_SQR1_SQ4_N(15),     // PA3
        ADC_SQR2_SQ5_N(18) |    // PA4
        ADC_SQR2_SQ6_N(19) |    // PA5
        ADC_SQR2_SQ7_N(3) |     // PA6
        ADC_SQR2_SQ8_N(7) |     // PA7
        ADC_SQR2_SQ9_N(9),      // PB0
        ADC_SQR3_SQ10_N(5) |    // PB1
        ADC_SQR3_SQ11_N(10) |   // PC0
        ADC_SQR3_SQ12_N(11) |   // PC1
        ADC_SQR3_SQ13_N(12) |   // PC2 (aka PC2_C)
        ADC_SQR3_SQ14_N(13),    // PC3 (aka PC3_C)
        ADC_SQR4_SQ15_N(4) |    // PC4
        ADC_SQR4_SQ16_N(8)      // PC5
    },
};

Referenced by readSlowAnalogInputs().

didStart

bool didStart = false

static

Definition at line 148 of file stm32_adc_v4.cpp.

Referenced by readSlowAnalogInputs().

fastSampleBuffer

adcsample_t* fastSampleBuffer

Definition at line 67 of file stm32_adc_v4.cpp.

Referenced by getFastAdc(), and readSlowAnalogInputs().

H7_ADC_SHIFT_BITS

constexpr int H7_ADC_SHIFT_BITS = log2_int(H7_ADC_OVERSAMPLE)

staticconstexpr

Definition at line 41 of file stm32_adc_v4.cpp.

H7_KNOCK_ADC_SHIFT_BITS

constexpr int H7_KNOCK_ADC_SHIFT_BITS = log2_int(H7_KNOCK_OVERSAMPLE)

staticconstexpr

Definition at line 205 of file stm32_adc_v4.cpp.

slowChannelCount

constexpr size_t slowChannelCount = 16

constexpr

Definition at line 84 of file stm32_adc_v4.cpp.

smpr1

const uint32_t smpr1

static

Initial value:

=
    ADC_SMPR1_SMP_AN0(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN1(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN2(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN3(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN4(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN5(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN6(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN7(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN8(KNOCK_SAMPLE_TIME) |
    ADC_SMPR1_SMP_AN9(KNOCK_SAMPLE_TIME)

Definition at line 216 of file stm32_adc_v4.cpp.

smpr2

const uint32_t smpr2

static

Initial value:

=
    ADC_SMPR2_SMP_AN10(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN11(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN12(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN13(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN14(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN15(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN16(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN17(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN18(KNOCK_SAMPLE_TIME) |
    ADC_SMPR2_SMP_AN19(KNOCK_SAMPLE_TIME)

Definition at line 228 of file stm32_adc_v4.cpp.

Go to the source code of this file.