libxr  1.0
Want to be the best embedded framework
Loading...
Searching...
No Matches
esp_adc.cpp
1#include "esp_adc.hpp"
2
3#include <new>
4
5#include "esp_adc/adc_cali_scheme.h"
6#include "esp_clk_tree.h"
7#include "esp_private/adc_private.h"
8#include "esp_private/adc_share_hw_ctrl.h"
9#include "esp_private/esp_clk_tree_common.h"
10#include "esp_private/gpio.h"
11#include "esp_private/sar_periph_ctrl.h"
12#include "hal/adc_hal_common.h"
13#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
14#define sens_dev_t sens_dev_s
15#include "hal/adc_oneshot_hal.h"
16#undef sens_dev_t
17#else
18#include "hal/adc_oneshot_hal.h"
19#endif
20
21#if defined(CONFIG_IDF_TARGET_ESP32) && CONFIG_IDF_TARGET_ESP32 && \
22 defined(CONFIG_ESP_WIFI_ENABLED) && CONFIG_ESP_WIFI_ENABLED
23#include "esp_wifi.h"
24#endif
25
26#ifndef ANALOG_CLOCK_ENABLE
27#define ANALOG_CLOCK_ENABLE() ((void)0)
28#endif
29#ifndef ANALOG_CLOCK_DISABLE
30#define ANALOG_CLOCK_DISABLE() ((void)0)
31#endif
32
33extern portMUX_TYPE rtc_spinlock;
34
35namespace LibXR
36{
37
38namespace
39{
40
41constexpr uint32_t kDefaultLineFittingVrefMv = 1100U;
42
43} // namespace
44
45ESP32ADC::Channel::Channel() : parent_(nullptr), idx_(0), channel_num_(0) {}
46
47ESP32ADC::Channel::Channel(ESP32ADC* parent, uint8_t idx, uint8_t channel_num)
48 : parent_(parent), idx_(idx), channel_num_(channel_num)
49{
50}
51
52float ESP32ADC::Channel::Read() { return parent_ ? parent_->ReadChannel(idx_) : 0.f; }
53
54ESP32ADC::ESP32ADC(adc_unit_t unit, const adc_channel_t* channels, uint8_t num_channels,
55 uint32_t freq, adc_atten_t attenuation, adc_bitwidth_t bitwidth,
56 float reference_voltage, size_t dma_buf_size)
57 : unit_(unit),
58 num_channels_(num_channels),
59 attenuation_(attenuation),
60 bitwidth_(ResolveBitwidth(bitwidth)),
61 reference_voltage_(reference_voltage),
62 max_raw_((1U << static_cast<uint8_t>(bitwidth_)) - 1U)
63{
64 ASSERT(channels != nullptr);
65 ASSERT(num_channels_ > 0U);
66 ASSERT(reference_voltage_ > 0.0f);
67 ASSERT(max_raw_ != 0U);
68 ASSERT(num_channels_ <= SOC_ADC_MAX_CHANNEL_NUM);
69 if ((channels == nullptr) || (num_channels_ == 0U) || (reference_voltage_ <= 0.0f) ||
70 (max_raw_ == 0U) || (num_channels_ > SOC_ADC_MAX_CHANNEL_NUM))
71 {
72 return;
73 }
74
75 channels_ = new (std::nothrow) Channel[num_channels_];
76 channel_ids_ = new (std::nothrow) adc_channel_t[num_channels_];
77 channel_ready_ = new (std::nothrow) bool[num_channels_];
78 latest_values_ = new (std::nothrow) float[num_channels_];
79 latest_raw_ = new (std::nothrow) uint16_t[num_channels_];
80 ASSERT(channels_ != nullptr);
81 ASSERT(channel_ids_ != nullptr);
82 ASSERT(channel_ready_ != nullptr);
83 ASSERT(latest_values_ != nullptr);
84 ASSERT(latest_raw_ != nullptr);
85 if ((channels_ == nullptr) || (channel_ids_ == nullptr) ||
86 (channel_ready_ == nullptr) || (latest_values_ == nullptr) ||
87 (latest_raw_ == nullptr))
88 {
89 ASSERT(false);
90 return;
91 }
92
93 for (uint8_t i = 0; i < SOC_ADC_MAX_CHANNEL_NUM; ++i)
94 {
95 channel_idx_map_[i] = kInvalidChannelIdx;
96 cali_handles_[i] = nullptr;
97 }
98
99 for (uint8_t i = 0; i < num_channels_; ++i)
100 {
101 ASSERT(IsValidChannel(channels[i]));
102 const uint8_t ch = static_cast<uint8_t>(channels[i]);
103 ASSERT(channel_idx_map_[ch] == kInvalidChannelIdx);
104 if (!IsValidChannel(channels[i]) || (channel_idx_map_[ch] != kInvalidChannelIdx))
105 {
106 return;
107 }
108
109 channels_[i] = Channel(this, i, ch);
110 channel_ids_[i] = channels[i];
111 channel_idx_map_[ch] = i;
112 channel_ready_[i] = false;
113 latest_values_[i] = 0.0f;
114 latest_raw_[i] = 0U;
115 }
116
117#if defined(CONFIG_IDF_TARGET_ESP32) && CONFIG_IDF_TARGET_ESP32 && \
118 defined(CONFIG_ESP_WIFI_ENABLED) && CONFIG_ESP_WIFI_ENABLED
119 if (unit_ == ADC_UNIT_2)
120 {
121 wifi_mode_t wifi_mode = WIFI_MODE_NULL;
122 const esp_err_t wifi_mode_err = esp_wifi_get_mode(&wifi_mode);
123 const bool wifi_active = (wifi_mode_err == ESP_OK) && (wifi_mode != WIFI_MODE_NULL);
124 ASSERT(!wifi_active);
125 if (wifi_active)
126 {
127 return;
128 }
129 }
130#endif
131
132 (void)InitCalibration();
133
134 const ContinuousInitResult cont_ans = InitContinuous(freq, dma_buf_size);
135 if (cont_ans == ContinuousInitResult::STARTED)
136 {
137 valid_ = true;
138 return;
139 }
140
141 if (cont_ans == ContinuousInitResult::FAILED)
142 {
143 ASSERT(false);
144 return;
145 }
146
147 const bool oneshot_ok = InitOneshot();
148 ASSERT(oneshot_ok);
149 if (!oneshot_ok)
150 {
151 return;
152 }
153
154 valid_ = true;
155}
156
157ESP32ADC::Channel& ESP32ADC::GetChannel(uint8_t idx)
158{
159 ASSERT(idx < num_channels_);
160 return channels_[idx];
161}
162
163float ESP32ADC::ReadChannel(uint8_t idx)
164{
165 ASSERT(valid_);
166 ASSERT(idx < num_channels_);
167 if (!valid_ || (idx >= num_channels_))
168 {
169 return 0.f;
170 }
171
172 if (backend_ == Backend::CONTINUOUS_DMA)
173 {
174#if SOC_ADC_DIG_CTRL_SUPPORTED && SOC_ADC_DMA_SUPPORTED
175 if (!channel_ready_[idx])
176 {
177 DrainContinuousFrames(continuous_prime_timeout_ms_);
178 }
179 else
180 {
181 DrainContinuousFrames(0U);
182 }
183#endif
184 ASSERT(channel_ready_[idx]);
185 return latest_values_[idx];
186 }
187
188 ASSERT(backend_ == Backend::ONESHOT);
189 ASSERT(oneshot_inited_ && (oneshot_hal_ != nullptr));
190 if (!oneshot_inited_ || (oneshot_hal_ == nullptr))
191 {
192 return 0.f;
193 }
194
195 const esp_err_t lock_err = adc_lock_try_acquire(unit_);
196 ASSERT(lock_err == ESP_OK);
197 if (lock_err != ESP_OK)
198 {
199 return 0.f;
200 }
201
202 int raw = 0;
203 bool converted = false;
204 bool clk_src_enabled = false;
205
206 portENTER_CRITICAL(&rtc_spinlock);
207
208#if SOC_ADC_DIG_CTRL_SUPPORTED && !SOC_ADC_RTC_CTRL_SUPPORTED
209 const esp_err_t clk_on =
210 esp_clk_tree_enable_src(static_cast<soc_module_clk_t>(oneshot_hal_->clk_src), true);
211 ASSERT(clk_on == ESP_OK);
212 clk_src_enabled = (clk_on == ESP_OK);
213#else
214 clk_src_enabled = true;
215#endif
216
217 if (clk_src_enabled)
218 {
219 ANALOG_CLOCK_ENABLE();
220 adc_oneshot_hal_setup(oneshot_hal_, channel_ids_[idx]);
221#if SOC_ADC_CALIBRATION_V1_SUPPORTED
222 adc_set_hw_calibration_code(unit_, attenuation_);
223#endif
224 converted = adc_oneshot_hal_convert(oneshot_hal_, &raw);
225 ANALOG_CLOCK_DISABLE();
226 }
227
228#if SOC_ADC_DIG_CTRL_SUPPORTED && !SOC_ADC_RTC_CTRL_SUPPORTED
229 if (clk_src_enabled)
230 {
231 const esp_err_t clk_off = esp_clk_tree_enable_src(
232 static_cast<soc_module_clk_t>(oneshot_hal_->clk_src), false);
233 ASSERT(clk_off == ESP_OK);
234 if (clk_off != ESP_OK)
235 {
236 converted = false;
237 }
238 }
239#endif
240
241 portEXIT_CRITICAL(&rtc_spinlock);
242
243 const esp_err_t unlock_err = adc_lock_release(unit_);
244 ASSERT(unlock_err == ESP_OK);
245 if (unlock_err != ESP_OK)
246 {
247 return 0.f;
248 }
249
250 ASSERT(converted);
251 if (!converted)
252 {
253 return 0.f;
254 }
255
256 latest_raw_[idx] = static_cast<uint16_t>(raw);
257 latest_values_[idx] = RawToVoltage(idx, latest_raw_[idx]);
258 channel_ready_[idx] = true;
259 return latest_values_[idx];
260}
261
262adc_bitwidth_t ESP32ADC::ResolveBitwidth(adc_bitwidth_t bitwidth)
263{
264 if (bitwidth == ADC_BITWIDTH_DEFAULT)
265 {
266 return static_cast<adc_bitwidth_t>(SOC_ADC_RTC_MAX_BITWIDTH);
267 }
268 return bitwidth;
269}
270
271bool ESP32ADC::InitCalibration()
272{
273#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
274 bool calibrated = false;
275
276 for (uint8_t i = 0; i < num_channels_; ++i)
277 {
278 adc_cali_curve_fitting_config_t config = {};
279 config.unit_id = unit_;
280 config.chan = channel_ids_[i];
281 config.atten = attenuation_;
282 config.bitwidth = bitwidth_;
283
284 adc_cali_handle_t handle = nullptr;
285 const esp_err_t err = adc_cali_create_scheme_curve_fitting(&config, &handle);
286 ASSERT((err == ESP_OK) || (err == ESP_ERR_NOT_SUPPORTED) ||
287 (err == ESP_ERR_INVALID_ARG) || (err == ESP_ERR_NO_MEM));
288 if (err != ESP_OK)
289 {
290 continue;
291 }
292
293 cali_handles_[i] = handle;
294 calibrated = true;
295 }
296
297 return calibrated;
298#elif ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
299 adc_cali_line_fitting_config_t config = {};
300 config.unit_id = unit_;
301 config.atten = attenuation_;
302 config.bitwidth = bitwidth_;
303#if CONFIG_IDF_TARGET_ESP32
304 config.default_vref = kDefaultLineFittingVrefMv;
305#endif
306
307 adc_cali_handle_t handle = nullptr;
308 const esp_err_t err = adc_cali_create_scheme_line_fitting(&config, &handle);
309 ASSERT((err == ESP_OK) || (err == ESP_ERR_NOT_SUPPORTED) ||
310 (err == ESP_ERR_INVALID_ARG) || (err == ESP_ERR_NO_MEM));
311 if (err != ESP_OK)
312 {
313 return false;
314 }
315
316 for (uint8_t i = 0; i < num_channels_; ++i)
317 {
318 cali_handles_[i] = handle;
319 }
320
321 return true;
322#else
323 return false;
324#endif
325}
326
327float ESP32ADC::RawToVoltage(uint8_t idx, uint16_t raw) const
328{
329 ASSERT(idx < num_channels_);
330 if (idx >= num_channels_)
331 {
332 return 0.f;
333 }
334
335 if (cali_handles_[idx] != nullptr)
336 {
337 int voltage_mv = 0;
338 const esp_err_t err =
339 adc_cali_raw_to_voltage(cali_handles_[idx], static_cast<int>(raw), &voltage_mv);
340 ASSERT(err == ESP_OK);
341 if (err == ESP_OK)
342 {
343 return static_cast<float>(voltage_mv) / 1000.0f;
344 }
345 }
346
347 return Normalize(static_cast<float>(raw));
348}
349
350float ESP32ADC::Normalize(float raw) const
351{
352 return (raw / static_cast<float>(max_raw_)) * reference_voltage_;
353}
354
355uint32_t ESP32ADC::ClampSampleFreq(uint32_t freq)
356{
357 if (freq < SOC_ADC_SAMPLE_FREQ_THRES_LOW)
358 {
359 return SOC_ADC_SAMPLE_FREQ_THRES_LOW;
360 }
361 if (freq > SOC_ADC_SAMPLE_FREQ_THRES_HIGH)
362 {
363 return SOC_ADC_SAMPLE_FREQ_THRES_HIGH;
364 }
365 return freq;
366}
367
368uint32_t ESP32ADC::AlignUp(uint32_t value, uint32_t align)
369{
370 if (align == 0U)
371 {
372 return value;
373 }
374 return (value + align - 1U) / align * align;
375}
376
377bool ESP32ADC::IsValidChannel(adc_channel_t channel) const
378{
379 const int channel_count = SOC_ADC_CHANNEL_NUM(static_cast<int>(unit_));
380 const int channel_num = static_cast<int>(channel);
381 return (channel_count > 0) && (channel_num >= 0) && (channel_num < channel_count);
382}
383
384void ESP32ADC::ConfigureAnalogPad(adc_channel_t channel) const
385{
386 int io_num = -1;
387 if ((adc_channel_to_io(unit_, channel, &io_num) == ESP_OK) && (io_num >= 0))
388 {
389 (void)gpio_config_as_analog(static_cast<gpio_num_t>(io_num));
390 }
391}
392
393} // namespace LibXR
LibXR
LibXR 命名空间
Definition ch32_can.hpp:14