Tasmota/tasmota/tasmota_xsns_sensor/xsns_02_analog.ino

/*
  xsns_02_analog.ino - ADC support for Tasmota

  Copyright (C) 2021  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 <http://www.gnu.org/licenses/>.
*/

#ifndef FIRMWARE_MINIMAL

#ifdef USE_ADC
/*********************************************************************************************\
 * ADC support for ESP8266 GPIO17 (=PIN_A0) and ESP32 up to 8 channels on GPIO32 to GPIO39
\*********************************************************************************************/

#define XSNS_02                       2
#define XNRG_33                       33

#ifdef ESP32
#include "esp32-hal-adc.h"
#endif

#ifdef ESP8266
#define ANALOG_RESOLUTION             10               // 12 = 4095, 11 = 2047, 10 = 1023
#define ANALOG_RANGE                  1023             // 4095 = 12, 2047 = 11, 1023 = 10
#endif  // ESP8266

#ifdef ESP32
#undef ANALOG_RESOLUTION
#define ANALOG_RESOLUTION             12               // 12 = 4095, 11 = 2047, 10 = 1023
#undef ANALOG_RANGE
#define ANALOG_RANGE                  4095             // 4095 = 12, 2047 = 11, 1023 = 10
#endif  // ESP32

#define TO_CELSIUS(x) ((x) - 273.15f)
#define TO_KELVIN(x) ((x) + 273.15f)

// Parameters for equation
#define ANALOG_V33                    3.3f              // ESP8266 / ESP32 Analog voltage
#define ANALOG_T0                     TO_KELVIN(25.0f)  // 25 degrees Celsius in Kelvin (= 298.15)

// Mode 0 : Shelly 2.5 NTC Thermistor
// 3V3 --- ANALOG_NTC_BRIDGE_RESISTANCE ---v--- NTC --- Gnd
//                                         |
//                                        ADC0
// Mode 1 : NTC towards 3V3 (Sinilink Thermostat Relay Board (XY-WFT1)
// 3V3 --- NTC ---v--- ANALOG_NTC_BRIDGE_RESISTANCE --- 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.4050f         // 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..ANALOG_RANGE 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

// Buttons
//        ---- Inverted
// 3V3 ---|  |----|
//                |
// 3V3 --- R1 ----|--- R1 --- Gnd
//                |
//                |---|  |--- Gnd
//                |   ----
//               ADC
#define ANALOG_BUTTON_THRESHOLD       ANALOG_RANGE / 8  // Add resistor tolerance

// Odroid joysticks
//        ---- Up
// 3V3 ---|  |------------
//                        |
//        ---- Dn         |--- R10k --- Gnd
// 3V3 ---|  |--- R10k ---|
//                        |
//                       ADC
// Press "Up" will raise ADC to ANALOG_RANGE, Press "Dn" will raise ADC to ANALOG_RANGE/2
#define ANALOG_JOYSTICK_THRESHOLD     (ANALOG_RANGE / 3) +100  // Add resistor tolerance

// pH scale minimum and maximum values
#define ANALOG_PH_MAX                             14.0f
#define ANALOG_PH_MIN                             0.0f

// Default values for calibration solution with lower PH
#define ANALOG_PH_CALSOLUTION_LOW_PH              4.0f
#define ANALOG_PH_CALSOLUTION_LOW_ANALOG_VALUE    282
// Default values for calibration solution with higher PH
#define ANALOG_PH_CALSOLUTION_HIGH_PH             9.18f
#define ANALOG_PH_CALSOLUTION_HIGH_ANALOG_VALUE   435

// Multiplier used to store pH with 2 decimal places in a non decimal datatype
#define ANALOG_PH_DECIMAL_MULTIPLIER              100.0f

// MQ-X sensor (MQ-02, MQ-03, MQ-04, MQ-05, MQ-06, MQ-07, MQ-08, MQ-09, MQ-131, MQ-135)
//
// A0  -------------------
//                        |
// GND -----------        |
//                |       |
// VCC ---        |       |
//        |       |       |
//       3V3     GND     ADC  <- (A0 for nodemcu, wemos; GPIO34,35,36,39 and other analog IN/OUT pin for esp32)
//means mq type (ex for mq-02 use 2, mq-131 use 131)
#define ANALOG_MQ_TYPE                            2
//exponential regression a params
#define ANALOG_MQ_A                               574.25f
//exponential regression b params
#define ANALOG_MQ_B                               -2.222f
/*
    Exponential regression:
  Gas    | a      | b
  LPG    | 44771  | -3.245
  CH4    | 2*10^31| 19.01
  CO     | 521853 | -3.821
  Alcohol| 0.3934 | -1.504
  Benzene| 4.8387 | -2.68
  Hexane | 7585.3 | -2.849
  NOx    | -462.43 | -2.204
  CL2    | 47.209 | -1.186
  O3     | 23.943 | -1.11
*/
//ratio for alarm, NOT USED yet (RS / R0 = 15 ppm)
#define ANALOG_MQ_RatioMQCleanAir                 15.0f
// Multiplier used to store pH with 2 decimal places in a non decimal datatype
#define ANALOG_MQ_DECIMAL_MULTIPLIER              100.0f
// lenght of filter
#define ANALOG_MQ_SAMPLES                         60

struct {
  uint8_t present = 0;
} Adcs;

struct {
  float *mq_samples;
  float temperature = 0;
  float current = 0;
  float energy = 0;
  uint32_t previous_millis = 0;
  uint32_t param1 = 0;
  uint32_t param2 = 0;
  int param3 = 0;
  int param4 = 0;
  int indexOfPointer = -1;
  uint16_t last_value = 0;
  uint16_t type;
  uint8_t pin = 0;
} Adc[MAX_ADCS];

/*********************************************************************************************\
 * External use
\*********************************************************************************************/

uint32_t AdcRange(void) {
  return ANALOG_RANGE;
}

bool AdcPin(uint32_t pin) {
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    if (pin == Adc[channel].pin) {
      return true;
    }
  }
  return false;
}

uint16_t AdcRead1(uint32_t pin) {
#ifdef ESP32 
  return analogReadMilliVolts(pin) / (ANALOG_V33 * 1000) * ANALOG_RANGE;  // Go back from mV to ADC
#else
  return analogRead(pin);
#endif
}

/*********************************************************************************************/

uint32_t AdcType(uint32_t channel) {
  return TasmotaGlobal.gpio_pin[Adc[channel].pin] >> 5;
}

uint32_t AdcIndex(uint32_t channel) {
  return TasmotaGlobal.gpio_pin[Adc[channel].pin] & 0x001F;
}

void AdcSaveSettings(uint32_t channel) {
  char parameters[32];
  snprintf_P(parameters, sizeof(parameters), PSTR("%d,%d,%d,%d,%d"),
    Adc[channel].type, Adc[channel].param1, Adc[channel].param2, Adc[channel].param3, Adc[channel].param4);
  SettingsUpdateText(SET_ADC_PARAM1 + channel, parameters);
}

bool AdcGetSettings(uint32_t channel) {
  uint32_t adc_type = 0;
  char parameters[32];
  if (strchr(SettingsText(SET_ADC_PARAM1 + channel), ',') != nullptr) {
    adc_type = atoi(subStr(parameters, SettingsText(SET_ADC_PARAM1 + channel), ",", 1));
    Adc[channel].param1 = atoi(subStr(parameters, SettingsText(SET_ADC_PARAM1 + channel), ",", 2));
    Adc[channel].param2 = atoi(subStr(parameters, SettingsText(SET_ADC_PARAM1 + channel), ",", 3));
    Adc[channel].param3 = atoi(subStr(parameters, SettingsText(SET_ADC_PARAM1 + channel), ",", 4));
    Adc[channel].param4 = atoi(subStr(parameters, SettingsText(SET_ADC_PARAM1 + channel), ",", 5));
    if ((adc_type > 0) && (adc_type < GPIO_ADC_INPUT)) {  // Former ADC_END
      AdcSaveSettings(channel);
      adc_type = AdcType(channel);            // Migrate for backwards compatibility
    }
  }
  return (AdcType(channel) == adc_type);
}

void AdcInitParams(uint32_t channel) {
  Adc[channel].param1 = 0;
  Adc[channel].param2 = 0;
  Adc[channel].param3 = 0;
  Adc[channel].param4 = 0;
  uint32_t adc_type = AdcType(channel);
  switch (adc_type) {
    case GPIO_ADC_INPUT:
//      Adc[channel].param1 = 0;
      Adc[channel].param2 = ANALOG_RANGE;
      Adc[channel].param3 = 3;                       // Margin / Tolerance
//      Adc[channel].param4 = 0;                       // Default mode (0) or Direct mode (1) using Dimmer or Channel command
      break;
    case GPIO_ADC_TEMP:
      // Default Shelly 2.5 and 1PM parameters
      Adc[channel].param1 = ANALOG_NTC_BRIDGE_RESISTANCE;
      Adc[channel].param2 = ANALOG_NTC_RESISTANCE;
      Adc[channel].param3 = ANALOG_NTC_B_COEFFICIENT;
//      Adc[channel].param4 = 0;                       // Default to Shelly mode with NTC towards GND
      break;
    case GPIO_ADC_LIGHT:
      Adc[channel].param1 = ANALOG_LDR_BRIDGE_RESISTANCE;
      Adc[channel].param2 = ANALOG_LDR_LUX_CALC_SCALAR;
      Adc[channel].param3 = ANALOG_LDR_LUX_CALC_EXPONENT * 10000;
//      Adc[channel].param4 = 0;
      break;
    case GPIO_ADC_BUTTON:
    case GPIO_ADC_BUTTON_INV:
      Adc[channel].param1 = ANALOG_BUTTON_THRESHOLD;  // Between 0 or 1
//      Adc[channel].param2 = 0;
//      Adc[channel].param3 = 0;
//      Adc[channel].param4 = 0;
      break;
    case GPIO_ADC_RANGE:
//      Adc[channel].param1 = 0;
      Adc[channel].param2 = ANALOG_RANGE;
//      Adc[channel].param3 = 0;
      Adc[channel].param4 = 100;
      break;
    case GPIO_ADC_CT_POWER:
      Adc[channel].param1 = ANALOG_CT_FLAGS;         // (uint32_t) 0
      Adc[channel].param2 = ANALOG_CT_MULTIPLIER;    // (uint32_t) 100000
      Adc[channel].param3 = ANALOG_CT_VOLTAGE;       // (int)      10
      break;
    case GPIO_ADC_JOY:
      Adc[channel].param1 = ANALOG_JOYSTICK_THRESHOLD;
//      Adc[channel].param2 = 0;
//      Adc[channel].param3 = 0;
//      Adc[channel].param4 = 0;
      break;
    case GPIO_ADC_PH:
      Adc[channel].param1 = ANALOG_PH_CALSOLUTION_LOW_PH * ANALOG_PH_DECIMAL_MULTIPLIER;  // PH of the calibration solution 1, which is the one with the lower PH
      Adc[channel].param2 = ANALOG_PH_CALSOLUTION_LOW_ANALOG_VALUE;                       // Reading of AnalogInput while probe is in solution 1
      Adc[channel].param3 = ANALOG_PH_CALSOLUTION_HIGH_PH * ANALOG_PH_DECIMAL_MULTIPLIER; // PH of the calibration solution 2, which is the one with the higher PH
      Adc[channel].param4 = ANALOG_PH_CALSOLUTION_HIGH_ANALOG_VALUE;                      // Reading of AnalogInput while probe is in solution 2
      break;
    case GPIO_ADC_MQ:
      Adc[channel].param1 = ANALOG_MQ_TYPE;  // Could be MQ-002, MQ-004, MQ-131 ....
      Adc[channel].param2 = (int)(ANALOG_MQ_A * ANALOG_MQ_DECIMAL_MULTIPLIER);                // Exponential regression
      Adc[channel].param3 = (int)(ANALOG_MQ_B * ANALOG_MQ_DECIMAL_MULTIPLIER);                // Exponential regression
      Adc[channel].param4 = (int)(ANALOG_MQ_RatioMQCleanAir * ANALOG_MQ_DECIMAL_MULTIPLIER);  // Exponential regression
      break; 
    case GPIO_ADC_VOLTAGE:
    case GPIO_ADC_CURRENT:
//      Adc[channel].param1 = 0;
      Adc[channel].param2 = ANALOG_RANGE;
//      Adc[channel].param3 = 0;
      Adc[channel].param4 = ANALOG_V33 * 10000;
      break;
  }

//  AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: AdcParam%d %d,%d,%d,%d,%d"), channel+1, Adc[channel].pin, Adc[channel].param1, Adc[channel].param2, Adc[channel].param3, Adc[channel].param4);
}

void AdcInit(void) {
  Adcs.present = 0;
  uint32_t pin = 0;                           // ESP32 full range of GPIOs possible for ADC channels
#ifdef ESP8266  
  pin = ADC0_PIN;                             // ESP8266 single ADC channel
#endif
  for (pin; pin < nitems(TasmotaGlobal.gpio_pin); pin++) {
    uint32_t adc_type = TasmotaGlobal.gpio_pin[pin] >> 5;
    switch(adc_type) {
      case GPIO_ADC_MQ:
        Adc[Adcs.present].mq_samples = (float*)calloc(sizeof(float), ANALOG_MQ_SAMPLES);  // Need calloc to reset registers to 0
        if (nullptr == Adc[Adcs.present].mq_samples) { continue; }
      case GPIO_ADC_CURRENT:
      case GPIO_ADC_VOLTAGE:
      case GPIO_ADC_PH:
      case GPIO_ADC_JOY:
      case GPIO_ADC_CT_POWER:
      case GPIO_ADC_RANGE:
      case GPIO_ADC_BUTTON_INV:
      case GPIO_ADC_BUTTON:
      case GPIO_ADC_LIGHT:
      case GPIO_ADC_TEMP:
      case GPIO_ADC_INPUT:
        Adc[Adcs.present].type = adc_type;
        Adc[Adcs.present].pin = pin;
        Adcs.present++;
        if (Adcs.present == MAX_ADCS) { break; }
    }
  }

  if (Adcs.present) {
#ifdef ESP32
    analogReadResolution(ANALOG_RESOLUTION);  // Default 12 bits (0 - 4095)
    analogSetAttenuation(ADC_11db);           // Default 11db
#endif
    for (uint32_t channel = 0; channel < Adcs.present; channel++) {
      if (!AdcGetSettings(channel)) {
        AdcInitParams(channel);
        AdcSaveSettings(channel);
      }
    }
  }
}

uint16_t AdcRead(uint32_t pin, uint32_t factor) {
  // factor 1 = 2 samples
  // factor 2 = 4 samples
  // factor 3 = 8 samples
  // factor 4 = 16 samples
  // factor 5 = 32 samples
  SystemBusyDelayExecute();

  uint32_t samples = 1 << factor;
  uint32_t analog = 0;
  for (uint32_t i = 0; i < samples; i++) {
#ifdef ESP32 
    analog += analogReadMilliVolts(pin);  // get the value corrected by calibrated values from the eFuses
#else
    analog += analogRead(pin);
#endif
    delay(1);
  }
  analog >>= factor;
#ifdef ESP32
  analog = analog / (ANALOG_V33 * 1000) * ANALOG_RANGE;  // Go back from mV to ADC
#endif
  return analog;
}

void AdcEvery250ms(void) {
  char adc_channel[3] = { 0 };
  uint32_t offset = 0;
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    uint32_t type_index = AdcIndex(channel);
#ifdef ESP32
    snprintf_P(adc_channel, sizeof(adc_channel), PSTR("%d"), type_index +1);
    offset = 1;
#endif
    uint32_t adc_type = AdcType(channel);
    if (GPIO_ADC_INPUT == adc_type) {
      int adc = AdcRead(Adc[channel].pin, 4);                          // 4 = 16 mS
      bool swap = (Adc[channel].param2 < Adc[channel].param1);
      uint32_t lo = (swap) ? Adc[channel].param2 : Adc[channel].param1;
      uint32_t hi = (swap) ? Adc[channel].param1 : Adc[channel].param2;
      int new_value = changeUIntScale(adc, lo, hi, 0, 100);
      if (swap) {
        new_value = 100 - new_value;
      }
      if ((new_value < Adc[channel].last_value -Adc[channel].param3) ||
          (new_value > Adc[channel].last_value +Adc[channel].param3) ||
          ((0 == new_value) && (Adc[channel].last_value != 0)) ||      // Lowest end
          ((100 == new_value) && (Adc[channel].last_value != 100))) {  // Highest end
        Adc[channel].last_value = new_value;
        if (-1 == Adc[channel].indexOfPointer) {
          Adc[channel].indexOfPointer = 0;
          continue;                                                    // Do not use potentiometer state on restart
        }
#ifdef USE_LIGHT
        if (0 == Adc[channel].param4) {                                // Default (0) or Direct mode (1)
#endif  // USE_LIGHT
          Response_P(PSTR("{\"ANALOG\":{\"A%ddiv10\":%d}}"), type_index + offset, new_value);
          XdrvRulesProcess(0);
#ifdef USE_LIGHT
        } else {
          char command[33];
          if (Settings->flag3.pwm_multi_channels) {  // SetOption68 - Enable multi-channels PWM instead of Color PWM
//            snprintf_P(command, sizeof(command), PSTR("_" D_CMND_CHANNEL "%d %d"), type_index +1, new_value);
            snprintf_P(command, sizeof(command), PSTR(D_CMND_CHANNEL "%d %d"), type_index +1, new_value);
          } else {
//            snprintf_P(command, sizeof(command), PSTR("_" D_CMND_DIMMER "3 %d"), new_value);
            snprintf_P(command, sizeof(command), PSTR(D_CMND_DIMMER "3 %d"), new_value);  // Change both RGB and W(W) Dimmers with no fading
          }
          ExecuteCommand(command, SRC_SWITCH);
        }
#endif  // USE_LIGHT
      }
    }
    else if (GPIO_ADC_JOY == adc_type) {
      uint16_t new_value = AdcRead(Adc[channel].pin, 1);
      if (new_value && (new_value != Adc[channel].last_value)) {
        Adc[channel].last_value = new_value;
        uint16_t value = new_value / Adc[channel].param1;
        Response_P(PSTR("{\"ANALOG\":{\"Joy%s\":%d}}"), adc_channel, value);
        XdrvRulesProcess(0);
      } else {
        Adc[channel].last_value = 0;
      }
    }
  }
}

uint8_t AdcGetButton(uint32_t pin) {
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    uint32_t adc_type = AdcType(channel);
    if (Adc[channel].pin == pin) {
      if (GPIO_ADC_BUTTON_INV == adc_type) {
        return (AdcRead(Adc[channel].pin, 1) < Adc[channel].param1);
      }
      else if (GPIO_ADC_BUTTON == adc_type) {
        return (AdcRead(Adc[channel].pin, 1) > Adc[channel].param1);
      }
    }
  }
  return 0;
}

uint16_t AdcGetLux(uint32_t channel) {
  int adc = AdcRead(Adc[channel].pin, 2);
  // Source: https://www.allaboutcircuits.com/projects/design-a-luxmeter-using-a-light-dependent-resistor/
  double resistorVoltage = ((double)adc / ANALOG_RANGE) * ANALOG_V33;
  double ldrVoltage = ANALOG_V33 - resistorVoltage;
  double ldrResistance = ldrVoltage / resistorVoltage * (double)Adc[channel].param1;
  double ldrLux = (double)Adc[channel].param2 * FastPrecisePow(ldrResistance, (double)Adc[channel].param3 / 10000);

  return (uint16_t)ldrLux;
}

void AddSampleMq(uint32_t channel){
//  AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: Adding sample for mq-sensor"));

  int _adc = AdcRead(Adc[channel].pin, 2);
  // init af array at same value
  if (Adc[channel].indexOfPointer == -1) {

//    AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: Init samples for mq-sensor"));

    for (int i = 0; i < ANALOG_MQ_SAMPLES; i ++) {
      Adc[channel].mq_samples[i] = _adc;
    }
  } else {
    Adc[channel].mq_samples[Adc[channel].indexOfPointer] = _adc;
  }
  Adc[channel].indexOfPointer++;
  if (Adc[channel].indexOfPointer==ANALOG_MQ_SAMPLES) {
    Adc[channel].indexOfPointer=0;
  }
}

float AdcGetMq(uint32_t channel) {
//  AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: Getting value for mq-sensor"));

  float avg = 0.0;
  for (int i = 0; i < ANALOG_MQ_SAMPLES; i ++) {
    avg += Adc[channel].mq_samples[i];
  }
  float voltage = (avg / ANALOG_MQ_SAMPLES) * ANALOG_V33 / ANALOG_RANGE;

  float _RL = 10;                                        // Value in KiloOhms
  float _RS_Calc = ((ANALOG_V33 * _RL) / voltage) -_RL;  // Get value of RS in a gas
  if (_RS_Calc < 0) {
    _RS_Calc = 0;                                        // No negative values accepted.
  }

  float _R0 = 10;
  float _ratio = _RS_Calc / _R0;                         // Get ratio RS_gas/RS_air
  float ppm = Adc[channel].param2 / ANALOG_MQ_DECIMAL_MULTIPLIER * FastPrecisePow(_ratio, Adc[channel].param3 / ANALOG_MQ_DECIMAL_MULTIPLIER);  // Source excel analisis https://github.com/miguel5612/MQSensorsLib_Docs/tree/master/Internal_design_documents
  if (ppm < 0) { ppm = 0; }                              // No negative values accepted or upper datasheet recomendation.
  if (ppm > 100000) { ppm = 100000; }

//  AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: Ppm read. ADC-RAW: %2_f, ppm: %2_f"), &voltage, &ppm);

  return ppm;
}

float AdcGetPh(uint32_t channel) {
  int adc = AdcRead(Adc[channel].pin, 2);

  float y1 = (float)Adc[channel].param1 / ANALOG_PH_DECIMAL_MULTIPLIER;
  int32_t x1 = Adc[channel].param2;
  float y2 = (float)Adc[channel].param3 / ANALOG_PH_DECIMAL_MULTIPLIER;
  int32_t x2 = Adc[channel].param4;

  float m = (y2 - y1) / (float)(x2 - x1);
  float ph = m * (float)(adc - x1) + y1;

//  AddLog(LOG_LEVEL_DEBUG, PSTR("ADC: Analog pH read. ADC-RAW: %d, cal-low(pH=ADC): %2_f = %d, cal-high(pH=ADC): %2_f = %d"), adc, &y1, x1, &y2, x2);

  return ph;
}

float AdcGetRange(uint32_t channel) {
  // formula for calibration: value, fromLow, fromHigh, toLow, toHigh
  // Example: 514, 632, 236, 0, 100
  // int( ((<param2> - <analog-value>) / (<param2> - <param1>) ) * (<param3> - <param4>) ) + <param4> )
  int adc = AdcRead(Adc[channel].pin, 5);
  float adcrange = ( ((float)Adc[channel].param2 - (float)adc) / ( ((float)Adc[channel].param2 - (float)Adc[channel].param1)) * ((float)Adc[channel].param3 - (float)Adc[channel].param4) + (float)Adc[channel].param4 );
  return adcrange;
}

void AdcGetCurrentPower(uint8_t channel, 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 = ANALOG_RANGE;
  uint16_t analog_max = 0;

  if (0 == Adc[channel].param1) {
    unsigned long tstart=millis();
    while (millis()-tstart < 35) {
      analog = analogRead(Adc[channel].pin);
      if (analog < analog_min) {
        analog_min = analog;
      }
      if (analog > analog_max) {
        analog_max = analog;
      }
    }
    //AddLog(0, PSTR("min: %u, max:%u, dif:%u"), analog_min, analog_max, analog_max-analog_min);
    Adc[channel].current = (float)(analog_max-analog_min) * ((float)(Adc[channel].param2) / 100000);
    if (Adc[channel].current < (((float)Adc[channel].param4) / 10000.0))
        Adc[channel].current = 0.0;
  }
  else {
    analog = AdcRead(Adc[channel].pin, 5);
    if (analog > Adc[channel].param1) {
     Adc[channel].current = ((float)(analog) - (float)Adc[channel].param1) * ((float)(Adc[channel].param2) / 100000);
    }
    else {
      Adc[channel].current = 0;
    }
  }

  float power = Adc[channel].current * (float)(Adc[channel].param3) / 10;
  uint32_t current_millis = millis();
  Adc[channel].energy = Adc[channel].energy + ((power * (current_millis - Adc[channel].previous_millis)) / 3600000000);
  Adc[channel].previous_millis = current_millis;
}

void AdcEverySecond(void) {
  uint32_t voltage_count = 0;
  uint32_t current_count = 0;
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    uint32_t type_index = AdcIndex(channel);
    uint32_t adc_type = AdcType(channel);
    if (GPIO_ADC_TEMP == adc_type) {
      int adc = AdcRead(Adc[channel].pin, 2);
      // Steinhart-Hart equation for thermistor as temperature sensor:
      // double Rt = (adc * Adc[channel].param1 * MAX_ADC_V) / (ANALOG_RANGE * ANALOG_V33 - (double)adc * MAX_ADC_V);
      // MAX_ADC_V in ESP8266 is 1
      // MAX_ADC_V in ESP32 is 3.3
      double Rt;
#ifdef ESP8266
      if (Adc[channel].param4) { // Alternate mode
        Rt = (double)Adc[channel].param1 * (ANALOG_RANGE * ANALOG_V33 - (double)adc) / (double)adc;
      } else {
        Rt = (double)Adc[channel].param1 * (double)adc / (ANALOG_RANGE * ANALOG_V33 - (double)adc);
      }
#else
      if (Adc[channel].param4) { // Alternate mode
        Rt = (double)Adc[channel].param1 * (ANALOG_RANGE - (double)adc) / (double)adc;
      } else {
        Rt = (double)Adc[channel].param1 * (double)adc / (ANALOG_RANGE - (double)adc);
      }
#endif
      if (Adc[channel].param3 > 1000000) {
        Adc[channel].param3 /= 10000;    // Fix legacy value from 33500000 to 3350
      }
      double BC = (double)Adc[channel].param3;                                              // Shelly param3 = 3350 (ANALOG_NTC_B_COEFFICIENT)
      double T = BC / (BC / ANALOG_T0 + TaylorLog(Rt / (double)Adc[channel].param2));       // Shelly param2 = 10000 (ANALOG_NTC_RESISTANCE)
      Adc[channel].temperature = ConvertTemp(TO_CELSIUS(T));
    }
    else if (GPIO_ADC_CT_POWER == adc_type) {
      AdcGetCurrentPower(channel, 5);
    }
    else if (GPIO_ADC_MQ == adc_type) {
      AddSampleMq(channel);
      AdcGetMq(channel);
    }
#ifdef USE_ENERGY_SENSOR
    else if (GPIO_ADC_VOLTAGE == adc_type) {
      Energy->voltage_available = true;
      Energy->voltage[type_index] = AdcGetRange(channel) / 10000;  // Volt
      voltage_count++;
    }
    else if (GPIO_ADC_CURRENT == adc_type) {
      Energy->current_available = true;
      Energy->current[type_index] = AdcGetRange(channel) / 10000;  // Ampere
      current_count++;
    }
#endif  // USE_ENERGY_SENSOR
  }
#ifdef USE_ENERGY_SENSOR
  if (voltage_count && current_count) {
    for (uint32_t phase = 0; phase < current_count; phase++) {
      uint32_t voltage_phase = (voltage_count == current_count) ? phase : 0;
      Energy->active_power[phase] = Energy->voltage[voltage_phase] * Energy->current[phase];  // Watt
      Energy->kWhtoday_delta[phase] += (uint32_t)(Energy->active_power[phase] * 1000) / 36;   // deca_microWh
    }
    EnergyUpdateToday();
  }
#endif  // USE_ENERGY_SENSOR
}

void AdcShowContinuation(bool *jsonflg) {
  if (*jsonflg) {
    ResponseAppend_P(PSTR(","));
  } else {
    ResponseAppend_P(PSTR(",\"ANALOG\":{"));
    *jsonflg = true;
  }
}

enum DomoFlagsAdc { ADC_TEMP, ADC_LIGHT, ADC_CT_POWER, ADC_END };

void AdcShow(bool json) {
  bool domo_flag[ADC_END] = { false };
  char adc_name[10] = { 0 };  // ANALOG8
  char adc_channel[3] = { 0 };
  uint32_t offset = 0;

  bool jsonflg = false;
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    uint32_t type_index = AdcIndex(channel);
#ifdef ESP32
    snprintf_P(adc_name, sizeof(adc_name), PSTR("Analog%d"), type_index +1);
    snprintf_P(adc_channel, sizeof(adc_channel), PSTR("%d"), type_index +1);
    offset = 1;
#endif
    uint32_t adc_type = AdcType(channel);
    switch (adc_type) {
      case GPIO_ADC_INPUT: {
#ifdef USE_LIGHT
        if (0 == Adc[channel].param4) {                                // Default (0) or Direct mode (1)
#endif  // USE_LIGHT
          uint16_t analog = AdcRead(Adc[channel].pin, 5);
          if (json) {
            AdcShowContinuation(&jsonflg);
            ResponseAppend_P(PSTR("\"A%d\":%d"), type_index + offset, analog);
#ifdef USE_WEBSERVER
          } else {
            WSContentSend_PD(HTTP_SNS_ANALOG, "", type_index + offset, analog);
#endif  // USE_WEBSERVER
          }
#ifdef USE_LIGHT
        }
#endif  // USE_LIGHT
        break;
      }
      case GPIO_ADC_TEMP: {
        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"" D_JSON_TEMPERATURE "%s\":%*_f"), adc_channel, Settings->flag2.temperature_resolution, &Adc[channel].temperature);
          if ((0 == TasmotaGlobal.tele_period) && (!domo_flag[ADC_TEMP])) {
#ifdef USE_DOMOTICZ
            DomoticzFloatSensor(DZ_TEMP, Adc[channel].temperature);
            domo_flag[ADC_TEMP] = true;
#endif  // USE_DOMOTICZ
#ifdef USE_KNX
            KnxSensor(KNX_TEMPERATURE, Adc[channel].temperature);
#endif  // USE_KNX
          }
#ifdef USE_WEBSERVER
        } else {
          WSContentSend_Temp(adc_name, Adc[channel].temperature);
#endif  // USE_WEBSERVER
        }
        break;
      }
      case GPIO_ADC_LIGHT: {
        uint16_t adc_light = AdcGetLux(channel);

        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"" D_JSON_ILLUMINANCE "%s\":%d"), adc_channel, adc_light);
#ifdef USE_DOMOTICZ
          if ((0 == TasmotaGlobal.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 GPIO_ADC_RANGE: {
        float adc_range = AdcGetRange(channel);
        char range_chr[FLOATSZ];
        dtostrfd(adc_range, Settings->flag2.frequency_resolution, range_chr);

        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"" D_JSON_RANGE "%s\":%s"), adc_channel, range_chr);
#ifdef USE_WEBSERVER
        } else {
          WSContentSend_PD(HTTP_SNS_RANGE_CHR, adc_name, range_chr);
#endif  // USE_WEBSERVER
        }
        break;
      }
      case GPIO_ADC_CT_POWER: {
        AdcGetCurrentPower(channel, 5);

        float voltage = (float)(Adc[channel].param3) / 10;
        char voltage_chr[FLOATSZ];
        dtostrfd(voltage, Settings->flag2.voltage_resolution, voltage_chr);
        char current_chr[FLOATSZ];
        dtostrfd(Adc[channel].current, Settings->flag2.current_resolution, current_chr);
        char power_chr[FLOATSZ];
        dtostrfd(voltage * Adc[channel].current, Settings->flag2.wattage_resolution, power_chr);
        char energy_chr[FLOATSZ];
        dtostrfd(Adc[channel].energy, Settings->flag2.energy_resolution, energy_chr);

        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"CTEnergy%s\":{\"" D_JSON_ENERGY "\":%s,\"" D_JSON_POWERUSAGE "\":%s,\"" D_JSON_VOLTAGE "\":%s,\"" D_JSON_CURRENT "\":%s}"),
            adc_channel, energy_chr, power_chr, voltage_chr, current_chr);
#ifdef USE_DOMOTICZ
          if ((0 == TasmotaGlobal.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;
      }
      case GPIO_ADC_JOY: {
        uint16_t new_value = AdcRead(Adc[channel].pin, 1);
        uint16_t value = new_value / Adc[channel].param1;
        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"Joy%s\":%d"), adc_channel, value);
        }
        break;
      }
      case GPIO_ADC_PH: {
        float ph = AdcGetPh(channel);
        char ph_chr[FLOATSZ];
        dtostrfd(ph, 2, ph_chr);

        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"pH%s\":%s"), adc_channel, ph_chr);
  #ifdef USE_WEBSERVER
        } else {
          WSContentSend_PD(HTTP_SNS_PH, "", ph_chr);
  #endif // USE_WEBSERVER
        }
        break;
      }
      case GPIO_ADC_MQ: {
        float mq = AdcGetMq(channel);
        char mq_chr[FLOATSZ];
        dtostrfd(mq, 2, mq_chr);

        float mqnumber =Adc[channel].param1;
        char mqnumber_chr[FLOATSZ];
        dtostrfd(mqnumber, 0, mqnumber_chr);

        if (json) {
          AdcShowContinuation(&jsonflg);
          ResponseAppend_P(PSTR("\"MQ%d_%d\":%s"), Adc[channel].param1, type_index + offset, mq_chr);
  #ifdef USE_WEBSERVER
        } else {
          WSContentSend_PD(HTTP_SNS_MQ, mqnumber_chr, mq_chr);
  #endif // USE_WEBSERVER
        }
        break;
      }
    }
  }
  if (jsonflg) {
    ResponseJsonEnd();
  }
}

/*********************************************************************************************\
 * Commands
\*********************************************************************************************/

const char kAdcCommands[] PROGMEM = "Adc|"  // No prefix
  D_CMND_ADCPARAM "|" D_CMND_ADCGPIO;

void (* const AdcCommand[])(void) PROGMEM = {
  &CmndAdcParam, &CmndAdcGpio };

uint32_t Decimals(int value) {
  uint32_t decimals;
  for (decimals = 4; decimals > 0; decimals--) {
    if (value % 10) { break; }
    value /= 10;
  }
  return decimals;
}

void CmndAdcGpio(void) {
  // AdcGpio33 32000, 10000, 3350          ADC_TEMP Shelly mode
  for (uint32_t channel = 0; channel < Adcs.present; channel++) {
    if (XdrvMailbox.index == Adc[channel].pin) {
      XdrvMailbox.index = channel +1;
      if (XdrvMailbox.data_len) {
        char data[64];
        snprintf_P(data, sizeof(data), PSTR("1,%s"), XdrvMailbox.data);
        XdrvMailbox.data = data;
        XdrvMailbox.data_len = strlen(data);
      }
      CmndAdcParam();
      break;
    }
  }
}

void CmndAdcParam(void) {
  // AdcParam 1, 0, ANALOG_RANGE, 0          ADC_INPUT rule | dimmer
  // AdcParam 1, 32000, 10000, 3350          ADC_TEMP Shelly mode
  // AdcParam 1, 32000, 10000, 3350, 1       ADC_TEMP Alternate mode
  // AdcParam 1, 10000, 12518931, -1.405
  // AdcParam 1, 128, 0, 0
  // AdcParam 1, 128, 0, 0
  // AdcParam 1, 0, ANALOG_RANGE, 0, 100     ADC_RANGE
  // AdcParam 1, 0, 2146, 0.23
  // AdcParam 1, 1000, 0, 0
  // AdcParam 1,                             ADC_PH
  // AdcParam 1,                             ADC_MQ
  // AdcParam 1, 0, ANALOG_RANGE, 0, 3.3     ADC_VOLTAGE
  // AdcParam 1, 0, ANALOG_RANGE, 0, 3.3     ADC_CURRENT
  if ((XdrvMailbox.index > 0) && (XdrvMailbox.index <= MAX_ADCS)) {
    uint8_t channel = XdrvMailbox.index -1;
    uint32_t adc_type = AdcType(channel);
    if (XdrvMailbox.data_len) {
      AdcGetSettings(channel);
      if (ArgC() > 3) {  // Process parameter entry
        char argument[XdrvMailbox.data_len];
        Adc[channel].param1 = strtol(ArgV(argument, 2), nullptr, 10);             // param1 = int
        Adc[channel].param2 = strtol(ArgV(argument, 3), nullptr, 10);             // param2 = int
        if ((GPIO_ADC_INPUT == adc_type) ||
            (GPIO_ADC_TEMP == adc_type) ||
            (GPIO_ADC_RANGE == adc_type)) {
          Adc[channel].param3 = abs(strtol(ArgV(argument, 4), nullptr, 10));      // param3 = abs(int)
          Adc[channel].param4 = abs(strtol(ArgV(argument, 5), nullptr, 10));      // param4 = abs(int)
        } else {
          Adc[channel].param3 = (int)(CharToFloat(ArgV(argument, 4)) * 10000);    // param3 = float
          if (ArgC() > 4) {
            Adc[channel].param4 = (int)(CharToFloat(ArgV(argument, 5)) * 10000);  // param4 = float
          } else {
            Adc[channel].param4 = 0;                                              // param4 = fixed 0
          }
        }
        if (GPIO_ADC_PH == adc_type) {
          float phLow = CharToFloat(ArgV(argument, 2));
          Adc[channel].param1 = phLow * ANALOG_PH_DECIMAL_MULTIPLIER;             // param1 = float
//            Adc[channel].param2 = strtol(ArgV(argument, 3), nullptr, 10);           // param2 = int
          float phHigh = CharToFloat(ArgV(argument, 4));
          Adc[channel].param3 = phHigh * ANALOG_PH_DECIMAL_MULTIPLIER;            // param3 = float
          Adc[channel].param4 = strtol(ArgV(argument, 5), nullptr, 10);           // param4 = int

//            AddLog(LOG_LEVEL_INFO, PSTR("ADC: Analog pH probe calibrated. cal-low(pH=ADC) %2_f = %d, cal-high(pH=ADC) %2_f = %d"), &phLow, Adc[channel].param2, &phHigh, Adc[channel].param4);
        }
        if (GPIO_ADC_CT_POWER == adc_type) {
          if (((1 == Adc[channel].param1) & CT_FLAG_ENERGY_RESET) > 0) {          // param1 = int
            for (uint32_t i = 0; i < Adcs.present; i++) {
              Adc[i].energy = 0;
            }
            Adc[channel].param1 ^= CT_FLAG_ENERGY_RESET;                          // Cancel energy reset flag
          }
        }
        if (GPIO_ADC_MQ == adc_type) {
          float a = CharToFloat(ArgV(argument, 3));                           // param2 = float
          float b = CharToFloat(ArgV(argument, 4));                           // param3 = float
          float ratioMQCleanAir = CharToFloat(ArgV(argument, 5));             // param4 = float
          if ((0 == a) && (0 == b) && (0 == ratioMQCleanAir)) {
            if (2 == Adc[channel].param1) {                                       // param1 = int
              a = 574.25;
              b = -2.222;
              ratioMQCleanAir = 9.83;
            }
            else if (4 == Adc[channel].param1) {
              a = 1012.7;
              b = -2.786;
              ratioMQCleanAir = 4.4;
            }
            else if (7 == Adc[channel].param1) {
              a = 99.042;
              b = -1.518;
              ratioMQCleanAir = 27.5;
            }
            if (131 == Adc[channel].param1) {
              a = 23.943;
              b = -1.11;
              ratioMQCleanAir = 15;
            }
          }
          Adc[channel].param2 = (int)(a * ANALOG_MQ_DECIMAL_MULTIPLIER);                // Exponential regression
          Adc[channel].param3 = (int)(b * ANALOG_MQ_DECIMAL_MULTIPLIER);                // Exponential regression
          Adc[channel].param4 = (int)(ratioMQCleanAir * ANALOG_MQ_DECIMAL_MULTIPLIER);  // Exponential regression

//            AddLog(LOG_LEVEL_INFO, PSTR("ADC: MQ reset mq%d, a = %2_f, b = %2_f, ratioMQCleanAir = %2_f"), Adc[channel].param1, &a, &b, &ratioMQCleanAir);
        }
      } else {                                         // Set default values based on current adc type
        // AdcParam 1
        AdcInitParams(channel);
      }
      AdcSaveSettings(channel);
    }

    // AdcParam / AdcGpio
    AdcGetSettings(channel);
    Response_P(PSTR("{\"%s"), XdrvMailbox.command);      // {"AdcParam or {"AdcGpio
    if (strstr_P(XdrvMailbox.command, PSTR(D_CMND_ADCGPIO))) {
      ResponseAppend_P(PSTR("%d\":["), Adc[channel].pin);
    } else {
      ResponseAppend_P(PSTR("%d\":[%d,"), channel +1, Adc[channel].pin);
    }
    ResponseAppend_P(PSTR("%d,%d"), Adc[channel].param1, Adc[channel].param2);
    if ((GPIO_ADC_INPUT == adc_type) ||
        (GPIO_ADC_TEMP == adc_type) ||
        (GPIO_ADC_RANGE == adc_type) ||
        (GPIO_ADC_MQ == adc_type)) {
      ResponseAppend_P(PSTR(",%d,%d"), Adc[channel].param3, Adc[channel].param4);    // param3 = int, param4 = int
    }
    else {
      float param = (float)Adc[channel].param3 / 10000;
      ResponseAppend_P(PSTR(",%*_f"), Decimals(Adc[channel].param3), &param);    // param3 = float
      if ((GPIO_ADC_CT_POWER == adc_type) ||
          (GPIO_ADC_VOLTAGE == adc_type) ||
          (GPIO_ADC_CURRENT == adc_type)) {
        param = (float)Adc[channel].param4 / 10000;
        ResponseAppend_P(PSTR(",%*_f"), Decimals(Adc[channel].param4), &param);  // param4 = float
      } else {
        ResponseAppend_P(PSTR(",%d"), Adc[channel].param4);                      // param4 = int
      }      
    }
    ResponseAppend_P(PSTR("]}"));
  }
}

/*********************************************************************************************\
 * Energy Interface
\*********************************************************************************************/

#ifdef USE_ENERGY_SENSOR
bool Xnrg33(uint32_t function) {
  bool result = false;

  if (FUNC_PRE_INIT == function) {
    uint32_t voltage_count = 0;
    uint32_t current_count = 0;
    for (uint32_t channel = 0; channel < Adcs.present; channel++) {
      uint32_t adc_type = AdcType(channel);
      if (GPIO_ADC_VOLTAGE == adc_type) { voltage_count++; }
      if (GPIO_ADC_CURRENT == adc_type) { current_count++; }
    }
    if (voltage_count || current_count) {
      Energy->type_dc = true;
      Energy->voltage_common = (1 == voltage_count);
      Energy->phase_count = (voltage_count > current_count) ? voltage_count : current_count;
      Energy->voltage_available = false;
      Energy->current_available = false;
      Energy->use_overtemp = true;   // Use global temperature for overtemp detection
      TasmotaGlobal.energy_driver = XNRG_33;
    }
  }
  return result;
}
#endif  // USE_ENERGY_SENSOR

/*********************************************************************************************\
 * Sensor Interface
\*********************************************************************************************/

bool Xsns02(uint32_t function) {
  bool result = false;

  switch (function) {
    case FUNC_COMMAND:
      result = DecodeCommand(kAdcCommands, AdcCommand);
      break;
    case FUNC_SETUP_RING2:
      AdcInit();
      break;
    default:
      if (Adcs.present) {
        switch (function) {
          case FUNC_EVERY_250_MSECOND:
            AdcEvery250ms();
            break;
          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  // FIRMWARE_MINIMAL