mirror of
https://github.com/Threnklyn/esphome-dev.git
synced 2026-05-19 04:33:27 +02:00
Carlos Garcia Saura
210 lines
6.2 KiB
C++
210 lines
6.2 KiB
C++
#include "adc_sensor.h"
|
|
#include "esphome/core/log.h"
|
|
#include "esphome/core/helpers.h"
|
|
|
|
#ifdef USE_ESP8266
|
|
#ifdef USE_ADC_SENSOR_VCC
|
|
#include <Esp.h>
|
|
ADC_MODE(ADC_VCC)
|
|
#else
|
|
#include <Arduino.h>
|
|
#endif
|
|
#endif
|
|
|
|
namespace esphome {
|
|
namespace adc {
|
|
|
|
static const char *const TAG = "adc";
|
|
|
|
#ifdef USE_ESP32
|
|
inline adc1_channel_t gpio_to_adc1(uint8_t pin) {
|
|
#if CONFIG_IDF_TARGET_ESP32
|
|
switch (pin) {
|
|
case 36:
|
|
return ADC1_CHANNEL_0;
|
|
case 37:
|
|
return ADC1_CHANNEL_1;
|
|
case 38:
|
|
return ADC1_CHANNEL_2;
|
|
case 39:
|
|
return ADC1_CHANNEL_3;
|
|
case 32:
|
|
return ADC1_CHANNEL_4;
|
|
case 33:
|
|
return ADC1_CHANNEL_5;
|
|
case 34:
|
|
return ADC1_CHANNEL_6;
|
|
case 35:
|
|
return ADC1_CHANNEL_7;
|
|
default:
|
|
return ADC1_CHANNEL_MAX;
|
|
}
|
|
#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
|
|
switch (pin) {
|
|
case 0:
|
|
return ADC1_CHANNEL_0;
|
|
case 1:
|
|
return ADC1_CHANNEL_1;
|
|
case 2:
|
|
return ADC1_CHANNEL_2;
|
|
case 3:
|
|
return ADC1_CHANNEL_3;
|
|
case 4:
|
|
return ADC1_CHANNEL_4;
|
|
default:
|
|
return ADC1_CHANNEL_MAX;
|
|
}
|
|
#endif
|
|
}
|
|
void ADCSensor::set_attenuation(adc_atten_t attenuation) { this->attenuation_ = attenuation; }
|
|
void ADCSensor::set_autorange(bool autorange) { this->autorange_ = autorange; }
|
|
#endif
|
|
|
|
void ADCSensor::setup() {
|
|
ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
|
|
#ifndef USE_ADC_SENSOR_VCC
|
|
pin_->setup();
|
|
#endif
|
|
|
|
#ifdef USE_ESP32
|
|
if (this->autorange_)
|
|
this->attenuation_ = ADC_ATTEN_DB_11;
|
|
adc1_config_channel_atten(gpio_to_adc1(pin_->get_pin()), attenuation_);
|
|
adc1_config_width(ADC_WIDTH_BIT_12);
|
|
#if !CONFIG_IDF_TARGET_ESP32C3 && !CONFIG_IDF_TARGET_ESP32H2
|
|
adc_gpio_init(ADC_UNIT_1, (adc_channel_t) gpio_to_adc1(pin_->get_pin()));
|
|
#endif
|
|
#endif
|
|
}
|
|
void ADCSensor::dump_config() {
|
|
LOG_SENSOR("", "ADC Sensor", this);
|
|
#ifdef USE_ESP8266
|
|
#ifdef USE_ADC_SENSOR_VCC
|
|
ESP_LOGCONFIG(TAG, " Pin: VCC");
|
|
#else
|
|
LOG_PIN(" Pin: ", pin_);
|
|
#endif
|
|
#endif
|
|
#ifdef USE_ESP32
|
|
LOG_PIN(" Pin: ", pin_);
|
|
if (autorange_)
|
|
ESP_LOGCONFIG(TAG, " Attenuation: auto");
|
|
else
|
|
switch (this->attenuation_) {
|
|
case ADC_ATTEN_DB_0:
|
|
ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
|
|
break;
|
|
case ADC_ATTEN_DB_2_5:
|
|
ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
|
|
break;
|
|
case ADC_ATTEN_DB_6:
|
|
ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
|
|
break;
|
|
case ADC_ATTEN_DB_11:
|
|
ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
|
|
break;
|
|
default: // This is to satisfy the unused ADC_ATTEN_MAX
|
|
break;
|
|
}
|
|
#endif
|
|
LOG_UPDATE_INTERVAL(this);
|
|
}
|
|
float ADCSensor::get_setup_priority() const { return setup_priority::DATA; }
|
|
void ADCSensor::update() {
|
|
float value_v = this->sample();
|
|
ESP_LOGD(TAG, "'%s': Got voltage=%.2fV", this->get_name().c_str(), value_v);
|
|
this->publish_state(value_v);
|
|
}
|
|
uint16_t ADCSensor::read_raw_() {
|
|
#ifdef USE_ESP32
|
|
return adc1_get_raw(gpio_to_adc1(pin_->get_pin()));
|
|
#endif
|
|
|
|
#ifdef USE_ESP8266
|
|
#ifdef USE_ADC_SENSOR_VCC
|
|
return ESP.getVcc(); // NOLINT(readability-static-accessed-through-instance)
|
|
#else
|
|
return analogRead(this->pin_->get_pin()); // NOLINT
|
|
#endif
|
|
#endif
|
|
}
|
|
uint32_t ADCSensor::raw_to_microvolts_(uint16_t raw) {
|
|
#ifdef USE_ESP32
|
|
#if CONFIG_IDF_TARGET_ESP32
|
|
switch (this->attenuation_) {
|
|
case ADC_ATTEN_DB_0:
|
|
return raw * 269; // 1e6 * 1.1 / 4095
|
|
case ADC_ATTEN_DB_2_5:
|
|
return raw * 366; // 1e6 * 1.5 / 4095
|
|
case ADC_ATTEN_DB_6:
|
|
return raw * 537; // 1e6 * 2.2 / 4095
|
|
case ADC_ATTEN_DB_11:
|
|
return raw * 952; // 1e6 * 3.9 / 4095
|
|
default: // This is to satisfy the unused ADC_ATTEN_MAX
|
|
return raw * 244; // 1e6 * 1.0 / 4095
|
|
}
|
|
#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
|
|
switch (this->attenuation_) {
|
|
case ADC_ATTEN_DB_0:
|
|
return raw * 205; // 1e6 * 0.84 / 4095
|
|
case ADC_ATTEN_DB_2_5:
|
|
return raw * 276; // 1e6 * 1.13 / 4095
|
|
case ADC_ATTEN_DB_6:
|
|
return raw * 381; // 1e6 * 1.56 / 4095
|
|
case ADC_ATTEN_DB_11:
|
|
return raw * 733; // 1e6 * 3.0 / 4095
|
|
default: // This is to satisfy the unused ADC_ATTEN_MAX
|
|
return raw * 244; // 1e6 * 1.0 / 4095
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef USE_ESP8266
|
|
return raw * 977; // 1e6 / 1024
|
|
#endif
|
|
}
|
|
float ADCSensor::sample() {
|
|
int raw = this->read_raw_();
|
|
uint32_t v = this->raw_to_microvolts_(raw);
|
|
#ifdef USE_ESP32
|
|
if (autorange_) {
|
|
int raw11 = raw, raw6 = 4095, raw2 = 4095, raw0 = 4095;
|
|
uint32_t v11 = v, v6 = 0, v2 = 0, v0 = 0;
|
|
if (raw11 < 4095) { // Progressively read all attenuation ranges
|
|
adc1_config_channel_atten(gpio_to_adc1(pin_->get_pin()), ADC_ATTEN_DB_6);
|
|
raw6 = this->read_raw_();
|
|
v6 = this->raw_to_microvolts_(raw6);
|
|
if (raw6 < 4095) {
|
|
adc1_config_channel_atten(gpio_to_adc1(pin_->get_pin()), ADC_ATTEN_DB_2_5);
|
|
raw2 = this->read_raw_();
|
|
v2 = this->raw_to_microvolts_(raw2);
|
|
if (raw2 < 4095) {
|
|
adc1_config_channel_atten(gpio_to_adc1(pin_->get_pin()), ADC_ATTEN_DB_0);
|
|
raw0 = this->read_raw_();
|
|
v0 = this->raw_to_microvolts_(raw0);
|
|
}
|
|
}
|
|
adc1_config_channel_atten(gpio_to_adc1(pin_->get_pin()), ADC_ATTEN_DB_11);
|
|
} // Contribution coefficients (normalized to 2048)
|
|
uint16_t c11 = clamp(raw11, 0, 2048); // high 1, middle 1, low 0
|
|
uint16_t c6 = (2048 - abs(raw6 - 2048)); // high 0, middle 1, low 0
|
|
uint16_t c2 = (2048 - abs(raw2 - 2048)); // high 0, middle 1, low 0
|
|
uint16_t c0 = clamp(4095 - raw0, 0, 2048); // high 0, middle 1, low 1
|
|
uint32_t csum = c11 + c6 + c2 + c0; // sum to normalize the final result
|
|
if (csum > 0)
|
|
v = (v11 * c11) + (v6 * c6) + (v2 * c2) + (v0 * c0);
|
|
else // in case of error, this keeps the 11db output (v)
|
|
csum = 1;
|
|
csum *= 1e6; // include the 1e6 microvolts->volts conversion factor
|
|
return (float) v / (float) csum; // normalize, convert & return
|
|
}
|
|
#endif
|
|
return v / (float) 1e6; // convert from microvolts to volts
|
|
}
|
|
#ifdef USE_ESP8266
|
|
std::string ADCSensor::unique_id() { return get_mac_address() + "-adc"; }
|
|
#endif
|
|
|
|
} // namespace adc
|
|
} // namespace esphome
|