LibXR::ESP32ADC Class Reference

Classes
class	Channel

Public Types
enum class	ContinuousInitResult : uint8_t { STARTED = 0 , UNSUPPORTED , FAILED }

Public Member Functions
	ESP32ADC (adc_unit_t unit, const adc_channel_t *channels, uint8_t num_channels, uint32_t freq=SOC_ADC_SAMPLE_FREQ_THRES_LOW, adc_atten_t attenuation=ADC_ATTEN_DB_12, adc_bitwidth_t bitwidth=static_cast< adc_bitwidth_t >(SOC_ADC_DIGI_MAX_BITWIDTH), float reference_voltage=3.3f, size_t dma_buf_size=256)
Channel &	GetChannel (uint8_t idx)
float	ReadChannel (uint8_t idx)

Detailed Description

Definition at line 22 of file esp_adc.hpp.

Member Enumeration Documentation

ContinuousInitResult

enum class LibXR::ESP32ADC::ContinuousInitResult : uint8_t

strong

Definition at line 41 of file esp_adc.hpp.

  {
    STARTED = 0,
    UNSUPPORTED,
    FAILED,
  };

Constructor & Destructor Documentation

ESP32ADC()

LibXR::ESP32ADC::ESP32ADC	(	adc_unit_t	unit,
		const adc_channel_t *	channels,
		uint8_t	num_channels,
		uint32_t	freq = SOC_ADC_SAMPLE_FREQ_THRES_LOW,
		adc_atten_t	attenuation = ADC_ATTEN_DB_12,
		adc_bitwidth_t	bitwidth = static_cast<adc_bitwidth_t>(SOC_ADC_DIGI_MAX_BITWIDTH),
		float	reference_voltage = 3.3f,
		size_t	dma_buf_size = 256 )

Definition at line 52 of file esp_adc.cpp.

    : unit_(unit),
      num_channels_(num_channels),
      attenuation_(attenuation),
      bitwidth_(ResolveBitwidth(bitwidth)),
      reference_voltage_(reference_voltage),
      max_raw_((1U << static_cast<uint8_t>(bitwidth_)) - 1U)
{
  ASSERT(channels != nullptr);
  ASSERT(num_channels_ > 0U);
  ASSERT(reference_voltage_ > 0.0f);
  ASSERT(max_raw_ != 0U);
  ASSERT(num_channels_ <= SOC_ADC_MAX_CHANNEL_NUM);
  if ((channels == nullptr) || (num_channels_ == 0U) || (reference_voltage_ <= 0.0f) ||
      (max_raw_ == 0U) || (num_channels_ > SOC_ADC_MAX_CHANNEL_NUM))
  {
    return;
  }
 
  channels_ = new Channel[num_channels_];
  channel_ids_ = new adc_channel_t[num_channels_];
  channel_ready_ = new bool[num_channels_];
  latest_values_ = new float[num_channels_];
  latest_raw_ = new uint16_t[num_channels_];
 
  for (uint8_t i = 0; i < SOC_ADC_MAX_CHANNEL_NUM; ++i)
  {
    channel_idx_map_[i] = INVALID_CHANNEL_IDX;
    cali_handles_[i] = nullptr;
  }
 
  for (uint8_t i = 0; i < num_channels_; ++i)
  {
    ASSERT(IsValidChannel(channels[i]));
    const uint8_t ch = static_cast<uint8_t>(channels[i]);
    ASSERT(channel_idx_map_[ch] == INVALID_CHANNEL_IDX);
    if (!IsValidChannel(channels[i]) || (channel_idx_map_[ch] != INVALID_CHANNEL_IDX))
    {
      return;
    }
 
    channels_[i] = Channel(this, i, ch);
    channel_ids_[i] = channels[i];
    channel_idx_map_[ch] = i;
    channel_ready_[i] = false;
    latest_values_[i] = 0.0f;
    latest_raw_[i] = 0U;
  }
 
#if defined(CONFIG_IDF_TARGET_ESP32) && CONFIG_IDF_TARGET_ESP32 && \
    defined(CONFIG_ESP_WIFI_ENABLED) && CONFIG_ESP_WIFI_ENABLED
  if (unit_ == ADC_UNIT_2)
  {
    wifi_mode_t wifi_mode = WIFI_MODE_NULL;
    const esp_err_t wifi_mode_err = esp_wifi_get_mode(&wifi_mode);
    const bool wifi_active = (wifi_mode_err == ESP_OK) && (wifi_mode != WIFI_MODE_NULL);
    ASSERT(!wifi_active);
    if (wifi_active)
    {
      return;
    }
  }
#endif
 
  (void)InitCalibration();
 
  const ContinuousInitResult cont_ans = InitContinuous(freq, dma_buf_size);
  if (cont_ans == ContinuousInitResult::STARTED)
  {
    valid_ = true;
    return;
  }
 
  if (cont_ans == ContinuousInitResult::FAILED)
  {
    REQUIRE(false);
    return;
  }
 
  const bool oneshot_ok = InitOneshot();
  REQUIRE(oneshot_ok);
  if (!oneshot_ok)
  {
    return;
  }
 
  valid_ = true;
}

Member Function Documentation

GetChannel()

ESP32ADC::Channel & LibXR::ESP32ADC::GetChannel

(

uint8_t

idx

)

Definition at line 143 of file esp_adc.cpp.

{
  ASSERT(idx < num_channels_);
  return channels_[idx];
}

ReadChannel()

float LibXR::ESP32ADC::ReadChannel

(

uint8_t

idx

)

Definition at line 149 of file esp_adc.cpp.

{
  ASSERT(valid_);
  ASSERT(idx < num_channels_);
  if (!valid_ || (idx >= num_channels_))
  {
    return 0.f;
  }
 
  if (backend_ == Backend::CONTINUOUS_DMA)
  {
#if SOC_ADC_DIG_CTRL_SUPPORTED && SOC_ADC_DMA_SUPPORTED
    if (!channel_ready_[idx])
    {
      DrainContinuousFrames(continuous_prime_timeout_ms_);
    }
    else
    {
      DrainContinuousFrames(0U);
    }
#endif
    return latest_values_[idx];
  }
 
  DEV_ASSERT(backend_ == Backend::ONESHOT);
  DEV_ASSERT(oneshot_inited_ && (oneshot_hal_ != nullptr));
  if (!oneshot_inited_ || (oneshot_hal_ == nullptr))
  {
    return 0.f;
  }
 
  const esp_err_t lock_err = adc_lock_try_acquire(unit_);
 
  if (lock_err != ESP_OK)
  {
    return 0.f;
  }
 
  int raw = 0;
  bool converted = false;
  bool clk_src_enabled = false;
 
  portENTER_CRITICAL(&rtc_spinlock);
 
#if SOC_ADC_DIG_CTRL_SUPPORTED && !SOC_ADC_RTC_CTRL_SUPPORTED
  const esp_err_t clk_on =
      esp_clk_tree_enable_src(static_cast<soc_module_clk_t>(oneshot_hal_->clk_src), true);
 
  clk_src_enabled = (clk_on == ESP_OK);
#else
  clk_src_enabled = true;
#endif
 
  if (clk_src_enabled)
  {
    ANALOG_CLOCK_ENABLE();
    adc_oneshot_hal_setup(oneshot_hal_, channel_ids_[idx]);
#if SOC_ADC_CALIBRATION_V1_SUPPORTED
    adc_set_hw_calibration_code(unit_, attenuation_);
#endif
    converted = adc_oneshot_hal_convert(oneshot_hal_, &raw);
    ANALOG_CLOCK_DISABLE();
  }
 
#if SOC_ADC_DIG_CTRL_SUPPORTED && !SOC_ADC_RTC_CTRL_SUPPORTED
  if (clk_src_enabled)
  {
    const esp_err_t clk_off = esp_clk_tree_enable_src(
        static_cast<soc_module_clk_t>(oneshot_hal_->clk_src), false);
 
    if (clk_off != ESP_OK)
    {
      converted = false;
    }
  }
#endif
 
  portEXIT_CRITICAL(&rtc_spinlock);
 
  const esp_err_t unlock_err = adc_lock_release(unit_);
 
  if (unlock_err != ESP_OK)
  {
    return 0.f;
  }
 
  if (!converted)
  {
    return 0.f;
  }
 
  latest_raw_[idx] = static_cast<uint16_t>(raw);
  latest_values_[idx] = RawToVoltage(idx, latest_raw_[idx]);
  channel_ready_[idx] = true;
  return latest_values_[idx];
}

---

The documentation for this class was generated from the following files:

• driver/esp/esp_adc.hpp
• driver/esp/esp_adc.cpp
• driver/esp/esp_adc_continuous.cpp
• driver/esp/esp_adc_oneshot.cpp