#include <adc_device.h>

Collaboration diagram for AdcDevice:

[legend]

Public Member Functions
	AdcDevice (ADCDriver p_adcp, ADCConversionGroup p_hwConfig, volatile adcsample_t *p_buf, size_t p_depth)

int	enableChannel (adc_channel_e hwChannel)

void	startConversionI (void)

adc_channel_e	getAdcChannelByInternalIndex (int index) const

adcsample_t	getAvgAdcValue (adc_channel_e hwChannel)

adcsample_t	getAdcValueByToken (AdcToken token)

AdcToken	getAdcChannelToken (adc_channel_e hwChannel)

int	size () const

void	init (void)

Private Attributes
ADCDriver *	adcp

ADCConversionGroup *	hwConfig

volatile adcsample_t *	samples

size_t	depth

uint8_t	internalAdcIndexByHardwareIndex [EFI_ADC_TOTAL_CHANNELS]

size_t	channelCount = 0

Detailed Description

Definition at line 12 of file adc_device.h.

Constructor & Destructor Documentation

◆ AdcDevice()

AdcDevice::AdcDevice	(	ADCDriver *	p_adcp,
		ADCConversionGroup *	p_hwConfig,
		volatile adcsample_t *	p_buf,
		size_t	p_depth
	)

explicit

Definition at line 53 of file adc_onchip_fast.cpp.

                                                                                                                   {
    adcp = p_adcp;
    depth = p_depth;
    hwConfig = p_hwConfig;
    samples = p_buf;
 
    hwConfig->sqr1 = 0;
    hwConfig->sqr2 = 0;
    hwConfig->sqr3 = 0;
#if ADC_MAX_CHANNELS_COUNT > 16
    hwConfig->sqr4 = 0;
    hwConfig->sqr5 = 0;
#endif /* ADC_MAX_CHANNELS_COUNT */
    memset(internalAdcIndexByHardwareIndex, 0xFF, sizeof(internalAdcIndexByHardwareIndex));
}

Member Function Documentation

◆ enableChannel()

int AdcDevice::enableChannel ( adc_channel_e hwChannel )

Definition at line 221 of file adc_onchip_fast.cpp.

                                                    {
    if ((channelCount + 1) >= ADC_MAX_CHANNELS_COUNT) {
        criticalError("Too many ADC channels configured");
        return -1;
    }
 
    int logicChannel = channelCount++;
 
    /* TODO: following is correct for STM32 ADC1/2.
     * ADC3 has another input to gpio mapping
     * and should be handled separately */
    size_t channelAdcIndex = hwChannel - EFI_ADC_0;
 
    internalAdcIndexByHardwareIndex[hwChannel] = logicChannel;
    if (logicChannel < 6) {
        hwConfig->sqr3 |= channelAdcIndex << (5 * logicChannel);
    } else if (logicChannel < 12) {
        hwConfig->sqr2 |= channelAdcIndex << (5 * (logicChannel - 6));
    } else if (logicChannel < 18) {
        hwConfig->sqr1 |= channelAdcIndex << (5 * (logicChannel - 12));
    }
#if ADC_MAX_CHANNELS_COUNT > 16
    else if (logicChannel < 24) {
        hwConfig->sqr4 |= channelAdcIndex << (5 * (logicChannel - 18));
    }
    else if (logicChannel < 30) {
        hwConfig->sqr5 |= channelAdcIndex << (5 * (logicChannel - 24));
    }
#endif /* ADC_MAX_CHANNELS_COUNT */
 
    return channelAdcIndex;
}

Referenced by addFastAdcChannel().

Here is the caller graph for this function:

◆ getAdcChannelByInternalIndex()

adc_channel_e AdcDevice::getAdcChannelByInternalIndex ( int index ) const

Definition at line 294 of file adc_onchip_fast.cpp.

                                                                         {
    for (size_t idx = EFI_ADC_0; idx < EFI_ADC_TOTAL_CHANNELS; idx++) {
        if (internalAdcIndexByHardwareIndex[idx] == hwChannel) {
            return (adc_channel_e)idx;
        }
    }
    return EFI_ADC_NONE;
}

Referenced by printFullAdcReport().

Here is the caller graph for this function:

◆ getAdcChannelToken()

AdcToken AdcDevice::getAdcChannelToken ( adc_channel_e hwChannel )

Definition at line 303 of file adc_onchip_fast.cpp.

                                                              {
    return fastAdc.internalAdcIndexByHardwareIndex[hwChannel];
}

Referenced by enableFastAdcChannel().

Here is the caller graph for this function:

◆ getAdcValueByToken()

adcsample_t AdcDevice::getAdcValueByToken ( AdcToken token )

inline

Definition at line 20 of file adc_device.h.

    {
        /* TODO: validate token? */
 
        /* TODO: in case depth > 1 this will return random (not last) sample */
        return samples[token];
    };

Referenced by getFastAdc().

Here is the caller graph for this function:

◆ getAvgAdcValue()

adcsample_t AdcDevice::getAvgAdcValue ( adc_channel_e hwChannel )

Definition at line 269 of file adc_onchip_fast.cpp.

                                                             {
    uint32_t result = 0;
    int numChannels = size();
    int index = fastAdc.internalAdcIndexByHardwareIndex[hwChannel];
    if (index == 0xff) {
        criticalError("Fast ADC attempt to read unconfigured input %d.", hwChannel);
        return 0;
    }
 
    for (size_t i = 0; i < depth; i++) {
        adcsample_t sample = samples[index];
        if (sample > ADC_MAX_VALUE) {
          // 12bit ADC expected right now. An error here usually means major RAM corruption?
            criticalError("ADC unexpected sample %d at %ld uptime.",
                sample,
                (uint32_t)getTimeNowS());
        }
        result += sample;
        index += numChannels;
    }
 
    // this truncation is guaranteed to not be lossy - the average can't be larger than adcsample_t
    return static_cast<adcsample_t>(result / depth);
}

Referenced by getInternalAdcValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

void AdcDevice::init ( void )

Definition at line 205 of file adc_onchip_fast.cpp.

                         {
    hwConfig->num_channels = size();
    /* driver does this internally */
    //hwConfig->sqr1 += ADC_SQR1_NUM_CH(size());
 
#if defined(EFI_INTERNAL_FAST_ADC_PWM)
    // Start the timer running
    pwmStart(EFI_INTERNAL_FAST_ADC_PWM, &pwmcfg);
    pwmEnableChannel(EFI_INTERNAL_FAST_ADC_PWM, 0, /* width */ 1);
    adcStartConversion(adcp, hwConfig, (adcsample_t *)samples, depth);
#elif defined (EFI_INTERNAL_FAST_ADC_GPT)
    gptStart(EFI_INTERNAL_FAST_ADC_GPT, &fast_adc_config);
    gptStartContinuous(EFI_INTERNAL_FAST_ADC_GPT, GPT_PERIOD_FAST);
#endif
}

Referenced by initAdcInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

int AdcDevice::size ( ) const

Definition at line 201 of file adc_onchip_fast.cpp.

                          {
    return channelCount;
}

Referenced by getAvgAdcValue(), init(), and printFullAdcReport().

Here is the caller graph for this function:

◆ startConversionI()

void AdcDevice::startConversionI ( void )

Definition at line 254 of file adc_onchip_fast.cpp.

{
    chSysLockFromISR();
    if ((ADC_FAST_DEVICE.state == ADC_READY) ||
        (ADC_FAST_DEVICE.state == ADC_ERROR)) {
        /* drop volatile type qualifier - this is safe */
        adcStartConversionI(adcp, hwConfig, (adcsample_t *)samples, depth);
    } else {
        engine->outputChannels.fastAdcErrorCount++;
        // todo: when? why? criticalError("ADC fast not ready?");
        // see notes at https://github.com/rusefi/rusefi/issues/6399
    }
    chSysUnlockFromISR();
}