Esp32AdcOneShot.hxx

Go to the documentation of this file.

 
#ifndef _DRIVERS_ESP32ADCONESHOT_HXX_
#define _DRIVERS_ESP32ADCONESHOT_HXX_
 
#include "utils/logging.h"
 
#if defined(__has_include)
#if __has_include(<driver/adc_types_legacy.h>)
// include legacy types so ADC1_CHANNEL_0 and ADC1_CHANNEL_0_GPIO_NUM etc are
// defined, soc/adc_channel.h includes references to these on release/v5.0
// branch and is planned for update in later relase versions.
#include <driver/adc_types_legacy.h>
#endif // __has_include driver/adc_types_legacy.h
#endif // has_include
 
#include <esp_adc/adc_oneshot.h>
#include <soc/adc_channel.h>
 
template <class Defs> struct Esp32ADCInput : public Defs
{
public:
    using Defs::ATTEN;
    using Defs::BITS;
    using Defs::CHANNEL;
    using Defs::PIN;
    using Defs::HANDLE;
 
    static void hw_init()
    {
        // due to using #if/#elif/#endif it is not possible to include this in
        // the ADC_PIN wrapper code.
        const adc_oneshot_unit_init_cfg_t unit_config =
        {
#if CONFIG_IDF_TARGET_ESP32
            .unit_id = PIN >= 30 ? ADC_UNIT_1 : ADC_UNIT_2,
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
            .unit_id = PIN <= 10 ? ADC_UNIT_1 : ADC_UNIT_2,
#elif CONFIG_IDF_TARGET_ESP32C3
            .unit_id = PIN <= 4 ? ADC_UNIT_1 : ADC_UNIT_2,
#endif
            .ulp_mode = ADC_ULP_MODE_DISABLE,
        };
        const adc_oneshot_chan_cfg_t channel_config =
        {
            .atten = ATTEN,
            .bitwidth = BITS,
        };
 
        LOG(VERBOSE,
            "[Esp32ADCInput] Configuring ADC%d:%d input pin %d, "
            "attenuation %d, bits %d",
            unit_config.unit_id, CHANNEL, PIN, ATTEN, BITS);
        ESP_ERROR_CHECK(adc_oneshot_new_unit(&unit_config, &HANDLE));
        ESP_ERROR_CHECK(
            adc_oneshot_config_channel(HANDLE, CHANNEL, &channel_config));
    }
 
    static void hw_set_to_safe()
    {
        // NO-OP
    }
 
    static void set(bool value)
    {
        // NO-OP
    }
 
    static int sample()
    {
        int value = 0;
        ESP_ERROR_CHECK(adc_oneshot_read(HANDLE, CHANNEL, &value));
        return value;
    }
};
 
#define ADC_PIN(NAME, ADC_CHANNEL, ATTENUATION, BIT_RANGE)                     \
    struct NAME##Defs                                                          \
    {                                                                          \
        static const adc_channel_t CHANNEL = (adc_channel_t)ADC_CHANNEL;       \
        static const gpio_num_t PIN = (gpio_num_t)ADC_CHANNEL##_GPIO_NUM;      \
        static const adc_atten_t ATTEN = (adc_atten_t)ATTENUATION;             \
        static const adc_bitwidth_t BITS = (adc_bitwidth_t)BIT_RANGE;          \
        static adc_oneshot_unit_handle_t HANDLE;                               \
    public:                                                                    \
        static const gpio_num_t pin()                                          \
        {                                                                      \
            return PIN;                                                        \
        }                                                                      \
        static const adc_channel_t channel()                                   \
        {                                                                      \
            return CHANNEL;                                                    \
        }                                                                      \
    };                                                                         \
    adc_oneshot_unit_handle_t NAME##Defs::HANDLE;                              \
    typedef Esp32ADCInput<NAME##Defs> NAME##_Pin
 
#endif // _DRIVERS_ESP32ADCONESHOT_HXX_