Tasmota/tasmota/tasmota_xnrg_energy/xnrg_24_bl0906.ino

/*
  xnrg_24_bl0906.ino - BL0906 energy sensor support for Tasmota

  SPDX-FileCopyrightText: 2024 Theo Arends

  SPDX-License-Identifier: GPL-3.0-only
*/

#ifdef ESP32
#ifdef USE_ENERGY_SENSOR
#ifdef USE_BL0906
/*********************************************************************************************\
 * Support the following Shangai Belling energy sensors:
 *
 * BL0906 - Energy (as in Athom 6CH Energy Meter EM6)
 * Based on athom-tech https://github.com/athom-tech/esp32-configs/tree/main/components/bl0906
 * See https://github.com/arendst/Tasmota/discussions/22167
 * 
 * {"NAME":"Athom EM2","GPIO":[0,0,0,0,0,0,0,3200,11329,1,544,0,0,0,0,0,0,0,1,0,0,0],"FLAG":0,"BASE":1}
 * {"NAME":"Athom EM6","GPIO":[0,0,0,0,0,0,0,3200,11333,1,544,0,0,0,0,0,0,0,1,0,0,0],"FLAG":0,"BASE":1}
 * 
 * Optional commands:
 * EnergyCols <phases>`   - Change default 4 column GUI display to <phases> columns
 * VoltRes 1              - Change none to 1 decimal display
 * FreqRes 1              - Change none to 1 decimal display
 * WattRes 2              - Change none to 2 decimals display
 * SetOption21 1          - Display Voltage
 * SetOption129 1         - Display energy for each phase instead of single sum
 * SetOption150 1         - Display no common voltage/frequency
 * EnergyExportActive 1   - Enable display of Export Active energy based on negative Active Power
 \*********************************************************************************************/

#define XNRG_24                     24

#ifndef BL0906_UPDATE
#define BL0906_UPDATE               2    // Update every 2 seconds (Must be lower than ENERGY_WATCHDOG)
#endif
//#define DEBUG_BL0906

// Total power conversion
static const float BL0906_WATT = 16 * 1.097 * 1.097 * (20000 + 20000 + 20000 + 20000 + 20000) /
                                 (40.41259 * ((5.1 + 5.1) * 1000 / 2000) * 1 * 100 * 1 * 1000);
// Total Energy conversion
static const float BL0906_CF = 16 * 4194304 * 0.032768 * 16 /
                               (3600000 * 16 *
                                (40.4125 * ((5.1 + 5.1) * 1000 / 2000) * 1 * 100 * 1 * 1000 /
                                 (1.097 * 1.097 * (20000 + 20000 + 20000 + 20000 + 20000))));
// Frequency conversion
static const float BL0906_FREF = 10000000;
// Temperature conversion
static const float BL0906_TREF = 12.5 / 59 - 40;  // Celsius
// Current conversion
static const float BL0906_IREF = 1.097 / (12875 * 1 * (5.1 + 5.1) * 1000 / 2000);
// Voltage conversion
static const float BL0906_UREF = 1.097 * (20000 + 20000 + 20000 + 20000 + 20000) / (13162 * 1 * 100 * 1000);
// Power conversion
static const float BL0906_PREF = 1.097 * 1.097 * (20000 + 20000 + 20000 + 20000 + 20000) /
                                 (40.41259 * ((5.1 + 5.1) * 1000 / 2000) * 1 * 100 * 1 * 1000);
// Energy conversion
static const float BL0906_EREF = 4194304 * 0.032768 * 16 /
                                 (3600000 * 16 *
                                  (40.4125 * ((5.1 + 5.1) * 1000 / 2000) * 1 * 100 * 1 * 1000 /
                                   (1.097 * 1.097 * (20000 + 20000 + 20000 + 20000 + 20000))));
// Current coefficient
static const float BL0906_KI = 12875 * 1 * (5.1 + 5.1) * 1000 / 2000 / 1.097;
// Power coefficient
static const float BL0906_KP = 40.4125 * ((5.1 + 5.1) * 1000 / 2000) * 1 * 100 * 1 * 1000 / 1.097 / 1.097 /
                               (20000 + 20000 + 20000 + 20000 + 20000);

// Register address
// Voltage
static const uint8_t BL0906_V_RMS = 0x16;

// Total power
static const uint8_t BL0906_WATT_SUM = 0X2C;

// Current1~6
static const uint8_t BL0906_I_1_RMS = 0x0D;  // current_1
static const uint8_t BL0906_I_2_RMS = 0x0E;
static const uint8_t BL0906_I_3_RMS = 0x0F;
static const uint8_t BL0906_I_4_RMS = 0x10;
static const uint8_t BL0906_I_5_RMS = 0x13;
static const uint8_t BL0906_I_6_RMS = 0x14;  // current_6

// Power1~6
static const uint8_t BL0906_WATT_1 = 0X23;  // power_1
static const uint8_t BL0906_WATT_2 = 0X24;
static const uint8_t BL0906_WATT_3 = 0X25;
static const uint8_t BL0906_WATT_4 = 0X26;
static const uint8_t BL0906_WATT_5 = 0X29;
static const uint8_t BL0906_WATT_6 = 0X2A;  // power_6

// Active pulse count, unsigned
static const uint8_t BL0906_CF_1_CNT = 0X30;  // Channel_1
static const uint8_t BL0906_CF_2_CNT = 0X31;
static const uint8_t BL0906_CF_3_CNT = 0X32;
static const uint8_t BL0906_CF_4_CNT = 0X33;
static const uint8_t BL0906_CF_5_CNT = 0X36;
static const uint8_t BL0906_CF_6_CNT = 0X37;  // Channel_6

// Total active pulse count, unsigned
static const uint8_t BL0906_CF_SUM_CNT = 0X39;

// Voltage frequency cycle
static const uint8_t BL0906_FREQUENCY = 0X4E;

// Internal temperature
static const uint8_t BL0906_TEMPERATURE = 0X5E;

// Calibration register
// RMS gain adjustment register
static const uint8_t BL0906_RMSGN_1 = 0x6D;  // Channel_1
static const uint8_t BL0906_RMSGN_2 = 0x6E;
static const uint8_t BL0906_RMSGN_3 = 0x6F;
static const uint8_t BL0906_RMSGN_4 = 0x70;
static const uint8_t BL0906_RMSGN_5 = 0x73;
static const uint8_t BL0906_RMSGN_6 = 0x74;  // Channel_6

// RMS offset correction register
static const uint8_t BL0906_RMSOS_1 = 0x78;  // Channel_1
static const uint8_t BL0906_RMSOS_2 = 0x79;
static const uint8_t BL0906_RMSOS_3 = 0x7A;
static const uint8_t BL0906_RMSOS_4 = 0x7B;
static const uint8_t BL0906_RMSOS_5 = 0x7E;
static const uint8_t BL0906_RMSOS_6 = 0x7F;  // Channel_6

// Active power gain adjustment register
static const uint8_t BL0906_WATTGN_1 = 0xB7;  // Channel_1
static const uint8_t BL0906_WATTGN_2 = 0xB8;
static const uint8_t BL0906_WATTGN_3 = 0xB9;
static const uint8_t BL0906_WATTGN_4 = 0xBA;
static const uint8_t BL0906_WATTGN_5 = 0xBD;
static const uint8_t BL0906_WATTGN_6 = 0xBE;  // Channel_6

// Commands
static const uint8_t BL0906_READ_COMMAND = 0x35;
static const uint8_t BL0906_WRITE_COMMAND = 0xCA;

// User write protection setting register,
// You must first write 0x5555 to the write protection setting register before writing to other registers.
static const uint8_t BL0906_USR_WRPROT = 0x9E;
// Enable User Operation Write
static const uint8_t BL0906_WRPROT_WRITABLE[6] = {BL0906_WRITE_COMMAND, BL0906_USR_WRPROT, 0x55, 0x55, 0x00, 0xB7};
// Disable User Operation Write
static const uint8_t BL0906_WRPROT_ONLYREAD[6] = {BL0906_WRITE_COMMAND, BL0906_USR_WRPROT, 0x00, 0x00, 0x00, 0x61};

// Reset Register
static const uint8_t BL0906_SOFT_RESET = 0x9F;
// Reset to default
static const uint8_t BL0906_INIT[6] = {BL0906_WRITE_COMMAND, BL0906_SOFT_RESET, 0x5A, 0x5A, 0x5A, 0x52};

typedef struct Bl0906DataPacket {
  uint8_t l{0};
  uint8_t m{0};
  uint8_t h{0};
  uint8_t checksum;
  uint8_t address;
} Bl0906DataPacket;

typedef struct Bl0906ube24_t {
  uint8_t l{0};
  uint8_t m{0};
  uint8_t h{0};
} Bl0906ube24_t;

typedef struct Bl0906sbe24_t {
  uint8_t l{0};
  uint8_t m{0};
  int8_t h{0};
} Bl0906sbe24_t;

#include <TasmotaSerial.h>
TasmotaSerial *Bl0906Serial = nullptr;

struct BL0906 {
  float temperature;
  uint16_t baudrate;
  uint8_t current_channel = 0;
  uint8_t model = 0;
  uint8_t rx_pin;
} Bl0906;

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

bool Bl0906_check_read_timeout(size_t len) {
  if (Bl0906Serial->available() >= int(len)) {
    return true;
  }
  uint32_t start_time = millis();
  while (Bl0906Serial->available() < int(len)) {
    if (millis() - start_time > 100) {
#ifdef DEBUG_BL0906
      AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: Timeout at %u/%u"), Bl0906Serial->available(), len);
#endif  // DEBUG_BL0906
      return false;
    }
    yield();
  }
  return true;
}

bool Bl0906ReadArray(uint8_t *data, size_t len) {
  if (!Bl0906_check_read_timeout(len)) {
    return false;
  }
  Bl0906Serial->read(data, len);
  return true;
}

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

uint32_t Bl0906_to_uint32_t(Bl0906ube24_t input);
uint32_t Bl0906_to_uint32_t(Bl0906ube24_t input) { 
  return input.h << 16 | input.m << 8 | input.l;
}

int32_t Bl0906_to_int32_t(Bl0906sbe24_t input);
int32_t Bl0906_to_int32_t(Bl0906sbe24_t input) { 
  return input.h << 16 | input.m << 8 | input.l;
}

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

// The SUM byte is (Addr+Data_L+Data_M+Data_H)&0xFF negated;
uint8_t Bl0906Checksum(const uint8_t address, const Bl0906DataPacket *data);  // Pre-declare to fix compile error on Bl0906DataPacket
uint8_t Bl0906Checksum(const uint8_t address, const Bl0906DataPacket *data) {
  return (address + data->l + data->m + data->h) ^ 0xFF;
}

// RMS offset correction
void Bl0906BiasCorrection(uint8_t address, float measurements, float correction) {
  Bl0906DataPacket data;
  float ki = 12875 * 1 * (5.1 + 5.1) * 1000 / 2000 / 1.097;  // Current coefficient
  float i_rms0 = measurements * ki;
  float i_rms = correction * ki;
  int32_t value = (i_rms * i_rms - i_rms0 * i_rms0) / 256;
  data.l = value << 24 >> 24;
  data.m = value << 16 >> 24;
  if (value < 0) {
    data.h = (value << 8 >> 24) | 0b10000000;
  }
  data.address = Bl0906Checksum(address, &data);
#ifdef DEBUG_BL0906
  AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: BiasCorrection %02X %02X %02X %02X %02X %02X"), BL0906_WRITE_COMMAND, address, data.l, data.m, data.h, data.address);
#endif  // DEBUG_BL0906
  Bl0906Serial->write(BL0906_WRITE_COMMAND);
  Bl0906Serial->write(address);
  Bl0906Serial->write(data.l);
  Bl0906Serial->write(data.m);
  Bl0906Serial->write(data.h);
  Bl0906Serial->write(data.address);
}
/*
// Gain adjustment
void Bl0906GainCorrection(const uint8_t address, const float measurements, const float Correction, const float coefficient) {
  Bl0906DataPacket data;
  float I_RMS0 = measurements * coefficient;
  float I_RMS = Correction * coefficient;
  float rms_gn = int((I_RMS / I_RMS0 - 1) * 65536);
  int16_t value;
  if (rms_gn <= -32767) {
    value = -32767;
  } else {
    value = int(rms_gn);
  }
  data.h = 0xFF;
  data.m = value >> 8;
  data.l = value << 8 >> 8;
  data.address = Bl0906Checksum(address, &data);
#ifdef DEBUG_BL0906
  AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: GainCorrection %02X %02X %02X %02X %02X %02X"), BL0906_WRITE_COMMAND, address, data.l, data.m, data.h, data.address);
#endif  // DEBUG_BL0906
  Bl0906Serial->write(BL0906_WRITE_COMMAND);
  Bl0906Serial->write(address);
  Bl0906Serial->write(data.l);
  Bl0906Serial->write(data.m);
  Bl0906Serial->write(data.h);
  Bl0906Serial->write(data.address);
}
*/
void Bl0906Setup(void) {
  while (Bl0906Serial->available()) {
    Bl0906Serial->flush();
  }
  Bl0906Serial->write(BL0906_WRPROT_WRITABLE, sizeof(BL0906_WRPROT_WRITABLE));
  // Calibration (1: register address; 2: value before calibration; 3: value after calibration)
  Bl0906BiasCorrection(BL0906_RMSOS_1, 0.01600, 0);  // Calibration current_1
  Bl0906BiasCorrection(BL0906_RMSOS_2, 0.01500, 0);
  Bl0906BiasCorrection(BL0906_RMSOS_3, 0.01400, 0);
  Bl0906BiasCorrection(BL0906_RMSOS_4, 0.01300, 0);
  Bl0906BiasCorrection(BL0906_RMSOS_5, 0.01200, 0);
  Bl0906BiasCorrection(BL0906_RMSOS_6, 0.01200, 0);  // Calibration current_6
/*
  Bl0906GainCorrection(BL0906_RMSGN_1, 2.15000, 2.148, BL0906_KI);   //RMS gain adjustment current_1
  Bl0906GainCorrection(BL0906_RMSGN_2, 2.15100, 2.148, BL0906_KI);
  Bl0906GainCorrection(BL0906_RMSGN_3, 2.15200, 2.148, BL0906_KI);
  Bl0906GainCorrection(BL0906_RMSGN_4, 2.14500, 2.148, BL0906_KI);
  Bl0906GainCorrection(BL0906_RMSGN_5, 2.14600, 2.148, BL0906_KI);
  Bl0906GainCorrection(BL0906_RMSGN_6, 2.14600, 2.148, BL0906_KI);   //RMS gain adjustment current_6

  Bl0906GainCorrection(BL0906_WATTGN_1, 15.13427, 14.5, BL0906_KP);  //Active power gain adjustment power_1
  Bl0906GainCorrection(BL0906_WATTGN_2, 15.23937, 14.5, BL0906_KP);
  Bl0906GainCorrection(BL0906_WATTGN_3, 15.44956, 14.5, BL0906_KP);
  Bl0906GainCorrection(BL0906_WATTGN_4, 16.57646, 14.5, BL0906_KP);
  Bl0906GainCorrection(BL0906_WATTGN_5, 15.27440, 14.5, BL0906_KP);
  Bl0906GainCorrection(BL0906_WATTGN_6, 31.75744, 14.5, BL0906_KP);  //Active power gain adjustment power_6
*/
  Bl0906Serial->write(BL0906_WRPROT_ONLYREAD, sizeof(BL0906_WRPROT_ONLYREAD));
}

// Reset energy
void Bl0906ResetEnergy(void) {
  Bl0906Serial->write(BL0906_INIT, sizeof(BL0906_INIT));
  delay(1);
  Bl0906Serial->flush();    // Flush send buffer
}

// Read data
void Bl0906ReadData(const uint8_t address, const float reference, float *sensor) {
  if (sensor == nullptr) {
    return;
  }

  Bl0906Serial->write(BL0906_READ_COMMAND);
  Bl0906Serial->write(address);
  Bl0906DataPacket buffer;
  if (Bl0906ReadArray((uint8_t *) &buffer, sizeof(buffer) - 1)) {
    if (Bl0906Checksum(address, &buffer) == buffer.checksum) {

      Bl0906ube24_t data_u24;
      Bl0906sbe24_t data_s24;
      bool signed_result = reference == BL0906_TREF || reference == BL0906_WATT || reference == BL0906_PREF;
      if (signed_result) {
        data_s24.l = buffer.l;
        data_s24.m = buffer.m;
        data_s24.h = buffer.h;
      } else {
        data_u24.l = buffer.l;
        data_u24.m = buffer.m;
        data_u24.h = buffer.h;
      }

      float value = 0;
      // Power
      if (reference == BL0906_PREF) {
        value = (float) Bl0906_to_int32_t(data_s24) * reference;
      }
      // Total power
      if (reference == BL0906_WATT) {
        value = (float) Bl0906_to_int32_t(data_s24) * reference;
      }
      // Voltage, current, power, total power
      if (reference == BL0906_UREF || reference == BL0906_IREF || reference == BL0906_EREF || reference == BL0906_CF) {
        value = (float) Bl0906_to_uint32_t(data_u24) * reference;
      }
      // Frequency
      if (reference == BL0906_FREF) {
        value = reference / (float) Bl0906_to_uint32_t(data_u24);
      }
      // Chip temperature
      if (reference == BL0906_TREF) {
        value = (float) Bl0906_to_int32_t(data_s24);
        value = (value - 64) * 12.5 / 59 - 40;  // Celsius
//        value = (value - 64) * reference;
        value = ConvertTemp(value);
      }
      *sensor = value;
    } else {
      AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: CRC error"));
      while (Bl0906Serial->read() >= 0);  // Flush receive buffer
    }
  }
}

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

void Bl0906Loop(void) {
  if (UINT8_MAX == Bl0906.current_channel) {
    return;
  }

  while (Bl0906Serial->available()) {
    Bl0906Serial->flush();
  }
  if (0 == Bl0906.current_channel) {
#ifdef DEBUG_BL0906
    AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: Start polling"));
#endif  // DEBUG_BL0906
    // Temperature
    Bl0906ReadData(BL0906_TEMPERATURE, BL0906_TREF, &Bl0906.temperature);
  } else if (1 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_1_RMS, BL0906_IREF, &Energy->current[0]);
    Bl0906ReadData(BL0906_WATT_1, BL0906_PREF, &Energy->active_power[0]);
    Bl0906ReadData(BL0906_CF_1_CNT, BL0906_EREF, &Energy->import_active[0]);
    Energy->data_valid[0] = 0;
  } else if (2 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_2_RMS, BL0906_IREF, &Energy->current[1]);
    Bl0906ReadData(BL0906_WATT_2, BL0906_PREF, &Energy->active_power[1]);
    Bl0906ReadData(BL0906_CF_2_CNT, BL0906_EREF, &Energy->import_active[1]);
    Energy->data_valid[1] = 0;
  } else if (3 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_3_RMS, BL0906_IREF, &Energy->current[2]);
    Bl0906ReadData(BL0906_WATT_3, BL0906_PREF, &Energy->active_power[2]);
    Bl0906ReadData(BL0906_CF_3_CNT, BL0906_EREF, &Energy->import_active[2]);
    Energy->data_valid[2] = 0;
  } else if (4 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_4_RMS, BL0906_IREF, &Energy->current[3]);
    Bl0906ReadData(BL0906_WATT_4, BL0906_PREF, &Energy->active_power[3]);
    Bl0906ReadData(BL0906_CF_4_CNT, BL0906_EREF, &Energy->import_active[3]);
    Energy->data_valid[3] = 0;
  } else if (5 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_5_RMS, BL0906_IREF, &Energy->current[4]);
    Bl0906ReadData(BL0906_WATT_5, BL0906_PREF, &Energy->active_power[4]);
    Bl0906ReadData(BL0906_CF_5_CNT, BL0906_EREF, &Energy->import_active[4]);
    Energy->data_valid[4] = 0;
  } else if (6 == Bl0906.current_channel) {
    Bl0906ReadData(BL0906_I_6_RMS, BL0906_IREF, &Energy->current[5]);
    Bl0906ReadData(BL0906_WATT_6, BL0906_PREF, &Energy->active_power[5]);
    Bl0906ReadData(BL0906_CF_6_CNT, BL0906_EREF, &Energy->import_active[5]);
    Energy->data_valid[5] = 0;
  } else if (8 == Bl0906.current_channel) {
    // Frequency
    Bl0906ReadData(BL0906_FREQUENCY, BL0906_FREF, &Energy->frequency[0]);
    // Voltage
    Bl0906ReadData(BL0906_V_RMS, BL0906_UREF, &Energy->voltage[0]);
  } else if (9 == Bl0906.current_channel) {
    // Total power
//    Bl0906ReadData(BL0906_WATT_SUM, BL0906_WATT, this->total_power_sensor_);
    // Total Energy
//    Bl0906ReadData(BL0906_CF_SUM_CNT, BL0906_CF, &Energy->total[0]);

    EnergyUpdateTotal();
  } else {
    Bl0906.current_channel = UINT8_MAX - 1;  // Stop
#ifdef DEBUG_BL0906
    AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: Stop polling"));
#endif  // DEBUG_BL0906
  }
  if (Bl0906.current_channel == Energy->phase_count) {
    Bl0906.current_channel = 7;    // Skip next phases and go to frequency and voltage
  }

  Bl0906.current_channel++;

/*
  while (Bl0906Serial->available()) {
    Bl0906Serial->read();
  }
*/
  while (Bl0906Serial->read() >= 0);
}

void Bl0906EverySecond(void) {
  if (!(TasmotaGlobal.uptime % BL0906_UPDATE)) {  // Every BL0906_UPDATE seconds an update
    if (UINT8_MAX == Bl0906.current_channel) {
      Bl0906.current_channel = 0;
    }
  }
}

void Bl0906Show(bool json) {
  if (json) {
    ResponseAppend_P(JSON_SNS_F_TEMP, "BL0906", Settings->flag2.temperature_resolution, &Bl0906.temperature);
    if (0 == TasmotaGlobal.tele_period) {
#ifdef USE_DOMOTICZ
      DomoticzFloatSensor(DZ_TEMP, Bl0906.temperature);
#endif  // USE_DOMOTICZ
#ifdef USE_KNX
      KnxSensor(KNX_TEMPERATURE, Bl0906.temperature);
#endif // USE_KNX
    }
#ifdef USE_WEBSERVER
  } else {
    WSContentSend_Temp("", Bl0906.temperature);
#endif  // USE_WEBSERVER
  }
}

void Bl0906Init(void) {
  // Software serial init needs to be done here as earlier (serial) interrupts may lead to Exceptions
  Bl0906Serial = new TasmotaSerial(Bl0906.rx_pin, Pin(GPIO_TXD), 1);
  if (Bl0906Serial->begin(Bl0906.baudrate)) {
    AddLog(LOG_LEVEL_DEBUG, PSTR("BL6: Serial UART%d"), Bl0906Serial->getUart());
    Bl0906Setup();
//    Bl0906ResetEnergy();
  }
}

void Bl0906PreInit(void) {
  if (PinUsed(GPIO_TXD) && PinUsed(GPIO_BL0906_RX, GPIO_ANY)) {
    Bl0906.rx_pin = Pin(GPIO_BL0906_RX, GPIO_ANY);
    uint32_t option = GetPin(Bl0906.rx_pin) - AGPIO(GPIO_BL0906_RX);  // 0 .. 5
    Bl0906.baudrate = 19200;

    Energy->voltage_common = true;                 // Use common voltage
    Energy->frequency_common = true;               // Use common frequency
    Energy->use_overtemp = true;                   // Use global temperature for overtemp detection
    Energy->phase_count = option +1;               // Handle 1 to 6 channels as phases

    TasmotaGlobal.energy_driver = XNRG_24;
  }
}

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

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

  switch (function) {
    case FUNC_LOOP:
      if (Bl0906Serial) { Bl0906Loop(); }
      break;
    case FUNC_EVERY_SECOND:
      Bl0906EverySecond();
      break;
    case FUNC_JSON_APPEND:
      Bl0906Show(1);
      break;
#ifdef USE_WEBSERVER
    case FUNC_WEB_SENSOR:
      Bl0906Show(0);
      break;
#endif  // USE_WEBSERVER
    case FUNC_INIT:
      Bl0906Init();
      break;
    case FUNC_PRE_INIT:
      Bl0906PreInit();
      break;
  }
  return result;
}

#endif  // USE_BL0906
#endif  // USE_ENERGY_SENSOR
#endif  // ESP32