diff --git a/tasmota/settings.h b/tasmota/settings.h
index 913309393..880e8af80 100644
--- a/tasmota/settings.h
+++ b/tasmota/settings.h
@@ -691,8 +691,10 @@ typedef union {
} StateBitfield;
// See issue https://github.com/esp8266/Arduino/issues/2913
+#ifdef ESP8266
#ifdef USE_ADC_VCC
ADC_MODE(ADC_VCC); // Set ADC input for Power Supply Voltage usage
#endif
+#endif
#endif // _SETTINGS_H_
diff --git a/tasmota/support_button.ino b/tasmota/support_button.ino
index e6e6e27ea..be8a4dabb 100644
--- a/tasmota/support_button.ino
+++ b/tasmota/support_button.ino
@@ -90,12 +90,14 @@ void ButtonInit(void)
Button.present++;
pinMode(Pin(GPIO_KEY1, i), bitRead(Button.no_pullup_mask, i) ? INPUT : ((16 == Pin(GPIO_KEY1, i)) ? INPUT_PULLDOWN_16 : INPUT_PULLUP));
}
+#ifdef ESP8266
#ifndef USE_ADC_VCC
else if ((99 == Button.adc) && ((ADC0_BUTTON == my_adc0) || (ADC0_BUTTON_INV == my_adc0))) {
Button.present++;
Button.adc = i;
}
#endif // USE_ADC_VCC
+#endif // ESP8266
}
}
@@ -162,7 +164,18 @@ void ButtonHandler(void)
button = (digitalRead(Pin(GPIO_KEY1, button_index)) != bitRead(Button.inverted_mask, button_index));
}
}
-#else
+#ifndef USE_ADC_VCC
+ if (Button.adc == button_index) {
+ button_present = 1;
+ if (ADC0_BUTTON_INV == my_adc0) {
+ button = (AdcRead(1) < 128);
+ }
+ else if (ADC0_BUTTON == my_adc0) {
+ button = (AdcRead(1) > 128);
+ }
+ }
+#endif // USE_ADC_VCC
+#else // ESP32
if (PinUsed(GPIO_KEY1, button_index)) {
button_present = 1;
if (bitRead(Button.touch_mask, button_index)) { // Touch
@@ -188,18 +201,7 @@ void ButtonHandler(void)
button = (digitalRead(Pin(GPIO_KEY1, button_index)) != bitRead(Button.inverted_mask, button_index));
}
}
-#endif // ESP8266
-#ifndef USE_ADC_VCC
- if (Button.adc == button_index) {
- button_present = 1;
- if (ADC0_BUTTON_INV == my_adc0) {
- button = (AdcRead(1) < 128);
- }
- else if (ADC0_BUTTON == my_adc0) {
- button = (AdcRead(1) > 128);
- }
- }
-#endif // USE_ADC_VCC
+#endif // ESP8266 or ESP32
if (button_present) {
XdrvMailbox.index = button_index;
XdrvMailbox.payload = button;
@@ -333,7 +335,7 @@ void ButtonHandler(void)
}
} else { // 6 press start wificonfig 2
- if (!Settings.flag.button_restrict) {
+ if (!Settings.flag.button_restrict) { // SetOption1 - Control button multipress
snprintf_P(scmnd, sizeof(scmnd), PSTR(D_CMND_WIFICONFIG " 2"));
ExecuteCommand(scmnd, SRC_BUTTON);
}
diff --git a/tasmota/support_features.ino b/tasmota/support_features.ino
index 0561eac6b..8b1bb3d96 100644
--- a/tasmota/support_features.ino
+++ b/tasmota/support_features.ino
@@ -230,7 +230,7 @@ void GetFeatures(void)
#ifdef USE_COUNTER
feature_sns1 |= 0x00000001; // xsns_01_counter.ino
#endif
-#ifdef USE_ADC_VCC
+#if defined(USE_ADC_VCC) || defined(USE_ADC)
feature_sns1 |= 0x00000002; // xsns_02_analog.ino
#endif
#ifdef USE_ENERGY_SENSOR
diff --git a/tasmota/support_tasmota.ino b/tasmota/support_tasmota.ino
index db4ce592f..bfe190069 100644
--- a/tasmota/support_tasmota.ino
+++ b/tasmota/support_tasmota.ino
@@ -651,10 +651,12 @@ void MqttShowState(void)
ResponseAppendTime();
ResponseAppend_P(PSTR(",\"" D_JSON_UPTIME "\":\"%s\",\"UptimeSec\":%u"), GetUptime().c_str(), UpTime());
+#ifdef ESP8266
#ifdef USE_ADC_VCC
dtostrfd((double)ESP.getVcc()/1000, 3, stemp1);
ResponseAppend_P(PSTR(",\"" D_JSON_VCC "\":%s"), stemp1);
-#endif
+#endif // USE_ADC_VCC
+#endif // ESP8266
ResponseAppend_P(PSTR(",\"" D_JSON_HEAPSIZE "\":%d,\"SleepMode\":\"%s\",\"Sleep\":%u,\"LoadAvg\":%u,\"MqttCount\":%u"),
ESP_getFreeHeap()/1024, GetTextIndexed(stemp1, sizeof(stemp1), Settings.flag3.sleep_normal, kSleepMode), // SetOption60 - Enable normal sleep instead of dynamic sleep
diff --git a/tasmota/tasmota.h b/tasmota/tasmota.h
index 21a7b5b00..29c8875c7 100644
--- a/tasmota/tasmota.h
+++ b/tasmota/tasmota.h
@@ -85,6 +85,7 @@ const uint8_t MAX_DEV_GROUP_NAMES = 4; // Max number of Device Group names
const uint8_t MAX_HUE_DEVICES = 15; // Max number of Philips Hue device per emulation
const uint8_t MAX_ROTARIES = 2; // Max number of Rotary Encoders
+const uint8_t MAX_ADCS = 18; // Max number of ESP32 ADC pins
const char MQTT_TOKEN_PREFIX[] PROGMEM = "%prefix%"; // To be substituted by mqtt_prefix[x]
const char MQTT_TOKEN_TOPIC[] PROGMEM = "%topic%"; // To be substituted by mqtt_topic, mqtt_grptopic, mqtt_buttontopic, mqtt_switchtopic
diff --git a/tasmota/tasmota_template_ESP32.h b/tasmota/tasmota_template_ESP32.h
index ddd13d87b..923a278c6 100644
--- a/tasmota/tasmota_template_ESP32.h
+++ b/tasmota/tasmota_template_ESP32.h
@@ -36,7 +36,6 @@
// Not ported (yet)
#undef USE_DISCOVERY
-#undef USE_ADC_VCC // Needs to be ported
#undef USE_DEEPSLEEP
#undef USE_MY92X1
#undef USE_TUYA_MCU
@@ -115,12 +114,12 @@ enum UserSelectablePins {
GPIO_HRXL_RX, // Data from MaxBotix HRXL sonar range sensor
GPIO_ELECTRIQ_MOODL_TX, // ElectriQ iQ-wifiMOODL Serial TX
GPIO_AS3935,
- ADC0_INPUT, // Analog input
- ADC0_TEMP, // Analog Thermistor
- ADC0_LIGHT, // Analog Light sensor
- ADC0_BUTTON, ADC0_BUTTON_INV, // Analog Button
- ADC0_RANGE, // Analog Range
- ADC0_CT_POWER, // ANalog Current
+ GPIO_ADC_INPUT, // Analog input
+ GPIO_ADC_TEMP, // Analog Thermistor
+ GPIO_ADC_LIGHT, // Analog Light sensor
+ GPIO_ADC_BUTTON, GPIO_ADC_BUTTON_INV, // Analog Button
+ GPIO_ADC_RANGE, // Analog Range
+ GPIO_ADC_CT_POWER, // ANalog Current
GPIO_WEBCAM_PWDN, GPIO_WEBCAM_RESET, GPIO_WEBCAM_XCLK, // Webcam
GPIO_WEBCAM_SIOD, GPIO_WEBCAM_SIOC, // Webcam I2C
GPIO_WEBCAM_DATA,
@@ -557,17 +556,15 @@ const uint16_t kGpioNiceList[] PROGMEM = {
AGPIO(GPIO_TELEINFO_RX),
AGPIO(GPIO_TELEINFO_ENABLE),
#endif
-/*
-#ifndef USE_ADC_VCC
- AGPIO(ADC0_INPUT), // Analog input
- AGPIO(ADC0_TEMP), // Thermistor
- AGPIO(ADC0_LIGHT), // Light sensor
- AGPIO(ADC0_BUTTON), // Button
- AGPIO(ADC0_BUTTON_INV),
- AGPIO(ADC0_RANGE), // Range
- AGPIO(ADC0_CT_POWER), // Current
+#ifdef USE_ADC
+ AGPIO(GPIO_ADC_INPUT) + MAX_ADCS, // Analog inputs
+ AGPIO(GPIO_ADC_TEMP) + MAX_ADCS, // Thermistor
+ AGPIO(GPIO_ADC_LIGHT) + MAX_ADCS, // Light sensor
+ AGPIO(GPIO_ADC_BUTTON) + MAX_ADCS, // Button
+ AGPIO(GPIO_ADC_BUTTON_INV) + MAX_ADCS,
+ AGPIO(GPIO_ADC_RANGE) + MAX_ADCS, // Range
+ AGPIO(GPIO_ADC_CT_POWER) + MAX_ADCS, // Current
#endif
-*/
#ifdef USE_WEBCAM
AGPIO(GPIO_WEBCAM_PWDN),
AGPIO(GPIO_WEBCAM_RESET),
@@ -591,6 +588,21 @@ const uint16_t kGpioNiceList[] PROGMEM = {
//********************************************************************************************
+// User selectable ADC functionality
+enum UserSelectableAdc {
+ ADC_NONE, // Not used
+ ADC_INPUT, // Analog input
+ ADC_TEMP, // Thermistor
+ ADC_LIGHT, // Light sensor
+ ADC_BUTTON, // Button
+ ADC_BUTTON_INV,
+ ADC_RANGE, // Range
+ ADC_CT_POWER, // Current
+
+// ADC_SWITCH, // Switch
+// ADC_SWITCH_INV,
+ ADC_END };
+
#define MAX_GPIO_PIN 40 // Number of supported GPIO
#define MIN_FLASH_PINS 4 // Number of flash chip pins unusable for configuration (GPIO6, 7, 8 and 11)
#define MAX_USER_PINS 36 // MAX_GPIO_PIN - MIN_FLASH_PINS
diff --git a/tasmota/xdrv_01_webserver.ino b/tasmota/xdrv_01_webserver.ino
index 016240b35..65ea3497d 100644
--- a/tasmota/xdrv_01_webserver.ino
+++ b/tasmota/xdrv_01_webserver.ino
@@ -1921,7 +1921,7 @@ void HandleModuleConfiguration(void)
}
WSContentSend_P(PSTR("\";sk(%d," STR(ADC0_PIN) ");"), Settings.my_adc0);
#endif // USE_ADC_VCC
-#endif // ESP8266 - ESP32
+#endif // ESP8266
WSContentSend_P(PSTR("}wl(sl);"));
diff --git a/tasmota/xdrv_07_domoticz.ino b/tasmota/xdrv_07_domoticz.ino
index 4f26a2c8a..2ea842491 100644
--- a/tasmota/xdrv_07_domoticz.ino
+++ b/tasmota/xdrv_07_domoticz.ino
@@ -66,6 +66,7 @@ int DomoticzBatteryQuality(void) {
int quality = 100; // Voltage range from 2,6V > 0% to 3,6V > 100%
+#ifdef ESP8266
#ifdef USE_ADC_VCC
uint16_t voltage = ESP.getVcc();
if (voltage <= 2600) {
@@ -75,7 +76,8 @@ int DomoticzBatteryQuality(void) {
} else {
quality = (voltage - 2600) / 10;
}
-#endif
+#endif // USE_ADC_VCC
+#endif // ESP8266
return quality;
}
diff --git a/tasmota/xsns_02_analog.ino b/tasmota/xsns_02_analog.ino
index 235a91bdd..963406b3f 100644
--- a/tasmota/xsns_02_analog.ino
+++ b/tasmota/xsns_02_analog.ino
@@ -17,6 +17,7 @@
along with this program. If not, see .
*/
+#ifdef ESP8266
#ifndef USE_ADC_VCC
/*********************************************************************************************\
* ADC support
@@ -455,4 +456,5 @@ bool Xsns02(uint8_t function)
return result;
}
-#endif // USE_ADC_VCC
\ No newline at end of file
+#endif // USE_ADC_VCC
+#endif // ESP8266
diff --git a/tasmota/xsns_02_analog_esp32.ino b/tasmota/xsns_02_analog_esp32.ino
new file mode 100644
index 000000000..0339f8345
--- /dev/null
+++ b/tasmota/xsns_02_analog_esp32.ino
@@ -0,0 +1,502 @@
+/*
+ xsns_02_analog_esp32.ino - ESP32 ADC support for Tasmota
+
+ Copyright (C) 2020 Theo Arends
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifdef ESP32
+#ifdef USE_ADC
+/*********************************************************************************************\
+ * ADC support
+\*********************************************************************************************/
+
+#define XSNS_02 2
+
+#define TO_CELSIUS(x) ((x) - 273.15)
+#define TO_KELVIN(x) ((x) + 273.15)
+
+// Parameters for equation
+#define ANALOG_V33 3.3 // ESP8266 Analog voltage
+#define ANALOG_T0 TO_KELVIN(25.0) // 25 degrees Celcius in Kelvin (= 298.15)
+
+// Shelly 2.5 NTC Thermistor
+// 3V3 --- ANALOG_NTC_BRIDGE_RESISTANCE ---v--- NTC --- Gnd
+// |
+// ADC0
+#define ANALOG_NTC_BRIDGE_RESISTANCE 32000 // NTC Voltage bridge resistor
+#define ANALOG_NTC_RESISTANCE 10000 // NTC Resistance
+#define ANALOG_NTC_B_COEFFICIENT 3350 // NTC Beta Coefficient
+
+// LDR parameters
+// 3V3 --- LDR ---v--- ANALOG_LDR_BRIDGE_RESISTANCE --- Gnd
+// |
+// ADC0
+#define ANALOG_LDR_BRIDGE_RESISTANCE 10000 // LDR Voltage bridge resistor
+#define ANALOG_LDR_LUX_CALC_SCALAR 12518931 // Experimental
+#define ANALOG_LDR_LUX_CALC_EXPONENT -1.4050 // Experimental
+
+// CT Based Apparrent Power Measurement Parameters
+// 3V3 --- R1 ----v--- R1 --- Gnd
+// |
+// CT+ CT-
+// |
+// ADC0
+// Default settings for a 20A/1V Current Transformer.
+// Analog peak to peak range is measured and converted to RMS current using ANALOG_CT_MULTIPLIER
+#define ANALOG_CT_FLAGS 0 // (uint32_t) reserved for possible future use
+#define ANALOG_CT_MULTIPLIER 2146 // (uint32_t) Multiplier*100000 to convert raw ADC peak to peak range 0..1023 to RMS current in Amps. Value of 100000 corresponds to 1
+#define ANALOG_CT_VOLTAGE 2300 // (int) Convert current in Amps to apparrent power in Watts using voltage in Volts*10. Value of 2200 corresponds to 220V
+
+#define CT_FLAG_ENERGY_RESET (1 << 0) // Reset energy total
+
+uint8_t adc_present = 0;
+
+struct {
+ float temperature = 0;
+ float current = 0;
+ float energy = 0;
+ uint32_t previous_millis = 0;
+ uint16_t last_value = 0;
+ uint8_t type = 0;
+ uint8_t pin = 0;
+} Adc[MAX_ADCS];
+
+void AdcInitParams(void) {
+ my_adc0 = Adc[0].type;
+
+ if ((Settings.adc_param_type != my_adc0) || (Settings.adc_param1 > 1000000)) {
+ if (ADC_TEMP == my_adc0) {
+ // Default Shelly 2.5 and 1PM parameters
+ Settings.adc_param_type = ADC_TEMP;
+ Settings.adc_param1 = ANALOG_NTC_BRIDGE_RESISTANCE;
+ Settings.adc_param2 = ANALOG_NTC_RESISTANCE;
+ Settings.adc_param3 = ANALOG_NTC_B_COEFFICIENT * 10000;
+ }
+ else if (ADC_LIGHT == my_adc0) {
+ Settings.adc_param_type = ADC_LIGHT;
+ Settings.adc_param1 = ANALOG_LDR_BRIDGE_RESISTANCE;
+ Settings.adc_param2 = ANALOG_LDR_LUX_CALC_SCALAR;
+ Settings.adc_param3 = ANALOG_LDR_LUX_CALC_EXPONENT * 10000;
+ }
+ else if (ADC_RANGE == my_adc0) {
+ Settings.adc_param_type = ADC_RANGE;
+ Settings.adc_param1 = 0;
+ Settings.adc_param2 = 1023;
+ Settings.adc_param3 = 0;
+ Settings.adc_param4 = 100;
+ }
+ else if (ADC_CT_POWER == my_adc0) {
+ Settings.adc_param_type = ADC_CT_POWER;
+ Settings.adc_param1 = ANALOG_CT_FLAGS; //(uint32_t) 0
+ Settings.adc_param2 = ANALOG_CT_MULTIPLIER; //(uint32_t) 100000
+ Settings.adc_param3 = ANALOG_CT_VOLTAGE; //(int) 10
+ }
+ }
+}
+
+void AdcInit(void) {
+ adc_present = 0;
+ for (uint32_t i = 0; i < MAX_ADCS; i++) {
+ if (PinUsed(GPIO_ADC_INPUT, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_INPUT, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_INPUT;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(GPIO_ADC_TEMP, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_TEMP, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_TEMP;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(GPIO_ADC_LIGHT, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_LIGHT, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_LIGHT;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(GPIO_ADC_BUTTON, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_BUTTON, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_BUTTON;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(ADC_BUTTON_INV, i)) {
+ Adc[adc_present].pin = Pin(ADC_BUTTON_INV, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_BUTTON_INV;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(GPIO_ADC_RANGE, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_RANGE, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_RANGE;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ if (PinUsed(GPIO_ADC_CT_POWER, i)) {
+ Adc[adc_present].pin = Pin(GPIO_ADC_CT_POWER, i);
+ if (adcAttachPin(Adc[adc_present].pin)) {
+ Adc[adc_present].type = ADC_CT_POWER;
+// analogSetPinAttenuation(Adc[adc_present].pin, ADC_11db); // Default
+ adc_present++;
+ }
+ }
+ }
+ if (adc_present) {
+ analogSetClockDiv(1); // Default 1
+ analogSetWidth(12); // Default 12 bits (0 - 4095)
+ analogSetAttenuation(ADC_11db); // Default 11db
+ }
+ AdcInitParams();
+}
+
+uint16_t AdcRead(uint8_t pin, uint8_t factor) {
+ // factor 1 = 2 samples
+ // factor 2 = 4 samples
+ // factor 3 = 8 samples
+ // factor 4 = 16 samples
+ // factor 5 = 32 samples
+ uint8_t samples = 1 << factor;
+ uint16_t analog = 0;
+ for (uint32_t i = 0; i < samples; i++) {
+ analog += analogRead(pin);
+ delay(1);
+ }
+ analog >>= factor;
+ return analog;
+}
+
+#ifdef USE_RULES
+void AdcEvery250ms(void) {
+ for (uint32_t idx = 0; idx < adc_present; idx++) {
+ if (ADC_INPUT == Adc[idx].type) {
+ uint16_t new_value = AdcRead(Adc[idx].pin, 5);
+ if ((new_value < Adc[idx].last_value -10) || (new_value > Adc[idx].last_value +10)) {
+ Adc[idx].last_value = new_value;
+ uint16_t value = Adc[idx].last_value / 10;
+ Response_P(PSTR("{\"ANALOG\":{\"A%ddiv10\":%d}}"), idx, (value > 99) ? 100 : value);
+ XdrvRulesProcess();
+ }
+ }
+ }
+}
+#endif // USE_RULES
+
+uint16_t AdcGetLux(uint8_t pin) {
+ int adc = AdcRead(pin, 2);
+ // Source: https://www.allaboutcircuits.com/projects/design-a-luxmeter-using-a-light-dependent-resistor/
+ double resistorVoltage = ((double)adc / 1023) * ANALOG_V33;
+ double ldrVoltage = ANALOG_V33 - resistorVoltage;
+ double ldrResistance = ldrVoltage / resistorVoltage * (double)Settings.adc_param1;
+ double ldrLux = (double)Settings.adc_param2 * FastPrecisePow(ldrResistance, (double)Settings.adc_param3 / 10000);
+
+ return (uint16_t)ldrLux;
+}
+
+uint16_t AdcGetRange(uint8_t pin) {
+ // formula for calibration: value, fromLow, fromHigh, toLow, toHigh
+ // Example: 514, 632, 236, 0, 100
+ // int( (( - ) / ( - ) ) * ( - ) ) + )
+ int adc = AdcRead(pin, 2);
+ double adcrange = ( ((double)Settings.adc_param2 - (double)adc) / ( ((double)Settings.adc_param2 - (double)Settings.adc_param1)) * ((double)Settings.adc_param3 - (double)Settings.adc_param4) + (double)Settings.adc_param4 );
+ return (uint16_t)adcrange;
+}
+
+void AdcGetCurrentPower(uint8_t idx, uint8_t factor) {
+ // factor 1 = 2 samples
+ // factor 2 = 4 samples
+ // factor 3 = 8 samples
+ // factor 4 = 16 samples
+ // factor 5 = 32 samples
+ uint8_t samples = 1 << factor;
+ uint16_t analog = 0;
+ uint16_t analog_min = 1023;
+ uint16_t analog_max = 0;
+
+ if (0 == Settings.adc_param1) {
+ for (uint32_t i = 0; i < samples; i++) {
+ analog = analogRead(Adc[idx].pin);
+ if (analog < analog_min) {
+ analog_min = analog;
+ }
+ if (analog > analog_max) {
+ analog_max = analog;
+ }
+ delay(1);
+ }
+ Adc[idx].current = (float)(analog_max-analog_min) * ((float)(Settings.adc_param2) / 100000);
+ }
+ else {
+ analog = AdcRead(Adc[idx].pin, 5);
+ if (analog > Settings.adc_param1) {
+ Adc[idx].current = ((float)(analog) - (float)Settings.adc_param1) * ((float)(Settings.adc_param2) / 100000);
+ }
+ else {
+ Adc[idx].current = 0;
+ }
+ }
+
+ float power = Adc[idx].current * (float)(Settings.adc_param3) / 10;
+ uint32_t current_millis = millis();
+ Adc[idx].energy = Adc[idx].energy + ((power * (current_millis - Adc[idx].previous_millis)) / 3600000000);
+ Adc[idx].previous_millis = current_millis;
+}
+
+void AdcEverySecond(void) {
+ for (uint32_t idx = 0; idx < adc_present; idx++) {
+ if (ADC_TEMP == Adc[idx].type) {
+ int adc = AdcRead(Adc[idx].pin, 2);
+ // Steinhart-Hart equation for thermistor as temperature sensor
+ double Rt = (adc * Settings.adc_param1) / (1024.0 * ANALOG_V33 - (double)adc);
+ double BC = (double)Settings.adc_param3 / 10000;
+ double T = BC / (BC / ANALOG_T0 + TaylorLog(Rt / (double)Settings.adc_param2));
+ Adc[idx].temperature = ConvertTemp(TO_CELSIUS(T));
+ }
+ else if (ADC_CT_POWER == Adc[idx].type) {
+ AdcGetCurrentPower(idx, 5);
+ }
+ }
+}
+
+void AdcShow(bool json) {
+ bool domo_flag[ADC_END] = { false };
+ char adc_name[10]; // ANALOG12
+ for (uint32_t idx = 0; idx < adc_present; idx++) {
+ snprintf_P(adc_name, sizeof(adc_name), PSTR("ANALOG%d"), idx);
+
+ switch (Adc[idx].type) {
+ case ADC_INPUT: {
+ uint16_t analog = AdcRead(Adc[idx].pin, 5);
+
+ if (json) {
+ ResponseAppend_P(PSTR(",\"%s\":{\"A0\":%d}"), adc_name, analog);
+#ifdef USE_WEBSERVER
+ } else {
+ WSContentSend_PD(HTTP_SNS_ANALOG, "", idx, analog);
+#endif // USE_WEBSERVER
+ }
+ break;
+ }
+ case ADC_TEMP: {
+ char temperature[33];
+ dtostrfd(Adc[idx].temperature, Settings.flag2.temperature_resolution, temperature);
+
+ if (json) {
+ ResponseAppend_P(JSON_SNS_TEMP, adc_name, temperature);
+ if ((0 == tele_period) && (!domo_flag[ADC_TEMP])) {
+#ifdef USE_DOMOTICZ
+ DomoticzSensor(DZ_TEMP, temperature);
+ domo_flag[ADC_TEMP] = true;
+#endif // USE_DOMOTICZ
+#ifdef USE_KNX
+ KnxSensor(KNX_TEMPERATURE, Adc[idx].temperature);
+#endif // USE_KNX
+ }
+#ifdef USE_WEBSERVER
+ } else {
+ WSContentSend_PD(HTTP_SNS_TEMP, adc_name, temperature, TempUnit());
+#endif // USE_WEBSERVER
+ }
+ break;
+ }
+ case ADC_LIGHT: {
+ uint16_t adc_light = AdcGetLux(Adc[idx].pin);
+
+ if (json) {
+ ResponseAppend_P(JSON_SNS_ILLUMINANCE, adc_name, adc_light);
+#ifdef USE_DOMOTICZ
+ if ((0 == tele_period) && (!domo_flag[ADC_LIGHT])) {
+ DomoticzSensor(DZ_ILLUMINANCE, adc_light);
+ domo_flag[ADC_LIGHT] = true;
+ }
+#endif // USE_DOMOTICZ
+#ifdef USE_WEBSERVER
+ } else {
+ WSContentSend_PD(HTTP_SNS_ILLUMINANCE, adc_name, adc_light);
+#endif // USE_WEBSERVER
+ }
+ break;
+ }
+ case ADC_RANGE: {
+ uint16_t adc_range = AdcGetRange(Adc[idx].pin);
+
+ if (json) {
+ ResponseAppend_P(JSON_SNS_RANGE, adc_name, adc_range);
+#ifdef USE_WEBSERVER
+ } else {
+ WSContentSend_PD(HTTP_SNS_RANGE, adc_name, adc_range);
+#endif // USE_WEBSERVER
+ }
+ break;
+ }
+ case ADC_CT_POWER: {
+ AdcGetCurrentPower(idx, 5);
+
+ float voltage = (float)(Settings.adc_param3) / 10;
+ char voltage_chr[FLOATSZ];
+ dtostrfd(voltage, Settings.flag2.voltage_resolution, voltage_chr);
+ char current_chr[FLOATSZ];
+ dtostrfd(Adc[idx].current, Settings.flag2.current_resolution, current_chr);
+ char power_chr[FLOATSZ];
+ dtostrfd(voltage * Adc[idx].current, Settings.flag2.wattage_resolution, power_chr);
+ char energy_chr[FLOATSZ];
+ dtostrfd(Adc[idx].energy, Settings.flag2.energy_resolution, energy_chr);
+
+ if (json) {
+ ResponseAppend_P(PSTR(",\"%s\":{\"" D_JSON_ENERGY "\":%s,\"" D_JSON_POWERUSAGE "\":%s,\"" D_JSON_VOLTAGE "\":%s,\"" D_JSON_CURRENT "\":%s}"),
+ adc_name, energy_chr, power_chr, voltage_chr, current_chr);
+#ifdef USE_DOMOTICZ
+ if ((0 == tele_period) && (!domo_flag[ADC_CT_POWER])) {
+ DomoticzSensor(DZ_POWER_ENERGY, power_chr);
+ DomoticzSensor(DZ_VOLTAGE, voltage_chr);
+ DomoticzSensor(DZ_CURRENT, current_chr);
+ domo_flag[ADC_CT_POWER] = true;
+ }
+#endif // USE_DOMOTICZ
+#ifdef USE_WEBSERVER
+ } else {
+ WSContentSend_PD(HTTP_SNS_VOLTAGE, voltage_chr);
+ WSContentSend_PD(HTTP_SNS_CURRENT, current_chr);
+ WSContentSend_PD(HTTP_SNS_POWER, power_chr);
+ WSContentSend_PD(HTTP_SNS_ENERGY_TOTAL, energy_chr);
+#endif // USE_WEBSERVER
+ }
+ break;
+ }
+ }
+ }
+}
+
+/*********************************************************************************************\
+ * Commands
+\*********************************************************************************************/
+
+const char kAdcCommands[] PROGMEM = "|" // No prefix
+ D_CMND_ADCPARAM;
+
+void (* const AdcCommand[])(void) PROGMEM = {
+ &CmndAdcParam };
+
+void CmndAdcParam(void) {
+ if (XdrvMailbox.data_len) {
+ if ((ADC_TEMP == XdrvMailbox.payload) ||
+ (ADC_LIGHT == XdrvMailbox.payload) ||
+ (ADC_RANGE == XdrvMailbox.payload) ||
+ (ADC_CT_POWER == XdrvMailbox.payload)) {
+ if (strstr(XdrvMailbox.data, ",") != nullptr) { // Process parameter entry
+ char sub_string[XdrvMailbox.data_len +1];
+ // AdcParam 2, 32000, 10000, 3350
+ // AdcParam 3, 10000, 12518931, -1.405
+ // AdcParam 6, 0, 1023, 0, 100
+ Settings.adc_param_type = XdrvMailbox.payload;
+ Settings.adc_param1 = strtol(subStr(sub_string, XdrvMailbox.data, ",", 2), nullptr, 10);
+ Settings.adc_param2 = strtol(subStr(sub_string, XdrvMailbox.data, ",", 3), nullptr, 10);
+ if (ADC_RANGE == XdrvMailbox.payload) {
+ Settings.adc_param3 = abs(strtol(subStr(sub_string, XdrvMailbox.data, ",", 4), nullptr, 10));
+ Settings.adc_param4 = abs(strtol(subStr(sub_string, XdrvMailbox.data, ",", 5), nullptr, 10));
+ } else {
+ Settings.adc_param3 = (int)(CharToFloat(subStr(sub_string, XdrvMailbox.data, ",", 4)) * 10000);
+ }
+ if (ADC_CT_POWER == XdrvMailbox.payload) {
+ if (((1 == Settings.adc_param1) & CT_FLAG_ENERGY_RESET) > 0) {
+ for (uint32_t idx = 0; idx < MAX_ADCS; idx++) {
+ Adc[idx].energy = 0;
+ }
+ Settings.adc_param1 ^= CT_FLAG_ENERGY_RESET; // Cancel energy reset flag
+ }
+ }
+ } else { // Set default values based on current adc type
+ // AdcParam 2
+ // AdcParam 3
+ // AdcParam 6
+ // AdcParam 7
+ Settings.adc_param_type = 0;
+ AdcInitParams();
+ }
+ }
+ }
+
+ // AdcParam
+ Response_P(PSTR("{\"" D_CMND_ADCPARAM "\":[%d,%d,%d"), Settings.adc_param_type, Settings.adc_param1, Settings.adc_param2);
+ if (ADC_RANGE == my_adc0) {
+ ResponseAppend_P(PSTR(",%d,%d"), Settings.adc_param3, Settings.adc_param4);
+ } else {
+ int value = Settings.adc_param3;
+ uint8_t precision;
+ for (precision = 4; precision > 0; precision--) {
+ if (value % 10) { break; }
+ value /= 10;
+ }
+ char param3[33];
+ dtostrfd(((double)Settings.adc_param3)/10000, precision, param3);
+ ResponseAppend_P(PSTR(",%s"), param3);
+ }
+ ResponseAppend_P(PSTR("]}"));
+}
+
+/*********************************************************************************************\
+ * Interface
+\*********************************************************************************************/
+
+bool Xsns02(uint8_t function) {
+ bool result = false;
+
+ switch (function) {
+ case FUNC_COMMAND:
+ result = DecodeCommand(kAdcCommands, AdcCommand);
+ break;
+ case FUNC_INIT:
+ AdcInit();
+ break;
+ default:
+ if (adc_present) {
+ switch (function) {
+#ifdef USE_RULES
+ case FUNC_EVERY_250_MSECOND:
+ AdcEvery250ms();
+ break;
+#endif // USE_RULES
+ case FUNC_EVERY_SECOND:
+ AdcEverySecond();
+ break;
+ case FUNC_JSON_APPEND:
+ AdcShow(1);
+ break;
+#ifdef USE_WEBSERVER
+ case FUNC_WEB_SENSOR:
+ AdcShow(0);
+ break;
+#endif // USE_WEBSERVER
+ }
+ }
+ }
+ return result;
+}
+
+#endif // USE_ADC
+#endif // ESP32