adc_sensor.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/voltage_sampler/voltage_sampler.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/hal.h"
 
#ifdef USE_ESP32
#include "esp_adc/adc_cali.h"
#include "esp_adc/adc_cali_scheme.h"
#include "esp_adc/adc_oneshot.h"
#include "hal/adc_types.h"  // This defines ADC_CHANNEL_MAX
#endif                      // USE_ESP32
 
#ifdef USE_ZEPHYR
#include <zephyr/drivers/adc.h>
#endif
 
namespace esphome {
namespace adc {
 
#ifdef USE_ESP32
// clang-format off
#if ESP_IDF_VERSION_MAJOR >= 6 || \
    (ESP_IDF_VERSION_MAJOR == 5 && \
     ((ESP_IDF_VERSION_MINOR == 0 && ESP_IDF_VERSION_PATCH >= 5) || \
      (ESP_IDF_VERSION_MINOR == 1 && ESP_IDF_VERSION_PATCH >= 3) || \
      (ESP_IDF_VERSION_MINOR >= 2)) \
    )
// clang-format on
static const adc_atten_t ADC_ATTEN_DB_12_COMPAT = ADC_ATTEN_DB_12;
#else
static const adc_atten_t ADC_ATTEN_DB_12_COMPAT = ADC_ATTEN_DB_11;
#endif
#endif  // USE_ESP32
 
enum class SamplingMode : uint8_t {
  AVG = 0,
  MIN = 1,
  MAX = 2,
};
 
const LogString *sampling_mode_to_str(SamplingMode mode);
 
template<typename T> class Aggregator {
 public:
  Aggregator(SamplingMode mode);
  void add_sample(T value);
  T aggregate();
 
 protected:
  T aggr_{0};
  uint8_t samples_{0};
  SamplingMode mode_{SamplingMode::AVG};
};
 
class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage_sampler::VoltageSampler {
 public:
  void update() override;
 
  void setup() override;
 
  void dump_config() override;
 
#ifdef USE_ZEPHYR
  void set_adc_channel(const adc_dt_spec *channel) { this->channel_ = channel; }
#endif
  void set_pin(InternalGPIOPin *pin) { this->pin_ = pin; }
 
  void set_output_raw(bool output_raw) { this->output_raw_ = output_raw; }
 
  void set_sample_count(uint8_t sample_count);
 
  void set_sampling_mode(SamplingMode sampling_mode);
 
  float sample() override;
 
#ifdef USE_ESP32
  void set_attenuation(adc_atten_t attenuation) { this->attenuation_ = attenuation; }
 
  void set_channel(adc_unit_t unit, adc_channel_t channel) {
    this->adc_unit_ = unit;
    this->channel_ = channel;
  }
 
  void set_autorange(bool autorange) { this->autorange_ = autorange; }
#endif  // USE_ESP32
 
#ifdef USE_RP2040
  void set_is_temperature() { this->is_temperature_ = true; }
#endif  // USE_RP2040
 
 protected:
  uint8_t sample_count_{1};
  bool output_raw_{false};
  InternalGPIOPin *pin_;
  SamplingMode sampling_mode_{SamplingMode::AVG};
 
#ifdef USE_ESP32
  float sample_autorange_();
  float sample_fixed_attenuation_();
  bool autorange_{false};
  adc_oneshot_unit_handle_t adc_handle_{nullptr};
  adc_cali_handle_t calibration_handle_{nullptr};
  adc_atten_t attenuation_{ADC_ATTEN_DB_0};
  adc_channel_t channel_{};
  adc_unit_t adc_unit_{};
  struct SetupFlags {
    uint8_t init_complete : 1;
    uint8_t config_complete : 1;
    uint8_t handle_init_complete : 1;
    uint8_t calibration_complete : 1;
    uint8_t reserved : 4;
  } setup_flags_{};
  static adc_oneshot_unit_handle_t shared_adc_handles[2];
#endif  // USE_ESP32
 
#ifdef USE_RP2040
  bool is_temperature_{false};
#endif  // USE_RP2040
 
#ifdef USE_ZEPHYR
  const struct adc_dt_spec *channel_ = nullptr;
#endif
};
 
}  // namespace adc
}  // namespace esphome