Add support for CSE7761 sensor (#2546)

* Add CSE7761 sensor support

* CSE7761: Added test at test3.yaml

* CSE7761: changed string style

* CSE7761: fixed cpp lint

* CSE7761: Added codeowners

* Lots of code cleanup

* Revert incorrect setup_priority suggestion

* Added error log in read with retries.

Co-authored-by: Oxan van Leeuwen <oxan@oxanvanleeuwen.nl>

* Improved log messages

Co-authored-by: Oxan van Leeuwen <oxan@oxanvanleeuwen.nl>

CODEOWNERS

@@ -39,6 +39,7 @@ esphome/components/color_temperature/* @jesserockz
 esphome/components/coolix/* @glmnet
 esphome/components/cover/* @esphome/core
 esphome/components/cs5460a/* @balrog-kun
+esphome/components/cse7761/* @berfenger
 esphome/components/ct_clamp/* @jesserockz
 esphome/components/current_based/* @djwmarcx
 esphome/components/daly_bms/* @s1lvi0

esphome/components/cse7761/cse7761.cpp

@@ -0,0 +1,244 @@
+#include "cse7761.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace cse7761 {
+
+static const char *const TAG = "cse7761";
+
+/*********************************************************************************************\
+ * CSE7761 - Energy  (Sonoff Dual R3 Pow v1.x)
+ *
+ * Based on Tasmota source code
+ * See https://github.com/arendst/Tasmota/discussions/10793
+ * https://github.com/arendst/Tasmota/blob/development/tasmota/xnrg_19_cse7761.ino
+\*********************************************************************************************/
+
+static const int CSE7761_UREF = 42563;  // RmsUc
+static const int CSE7761_IREF = 52241;  // RmsIAC
+static const int CSE7761_PREF = 44513;  // PowerPAC
+
+static const uint8_t CSE7761_REG_SYSCON = 0x00;     // (2) System Control Register (0x0A04)
+static const uint8_t CSE7761_REG_EMUCON = 0x01;     // (2) Metering control register (0x0000)
+static const uint8_t CSE7761_REG_EMUCON2 = 0x13;    // (2) Metering control register 2 (0x0001)
+static const uint8_t CSE7761_REG_PULSE1SEL = 0x1D;  // (2) Pin function output select register (0x3210)
+
+static const uint8_t CSE7761_REG_RMSIA = 0x24;      // (3) The effective value of channel A current (0x000000)
+static const uint8_t CSE7761_REG_RMSIB = 0x25;      // (3) The effective value of channel B current (0x000000)
+static const uint8_t CSE7761_REG_RMSU = 0x26;       // (3) Voltage RMS (0x000000)
+static const uint8_t CSE7761_REG_POWERPA = 0x2C;    // (4) Channel A active power, update rate 27.2Hz (0x00000000)
+static const uint8_t CSE7761_REG_POWERPB = 0x2D;    // (4) Channel B active power, update rate 27.2Hz (0x00000000)
+static const uint8_t CSE7761_REG_SYSSTATUS = 0x43;  // (1) System status register
+
+static const uint8_t CSE7761_REG_COEFFCHKSUM = 0x6F;  // (2) Coefficient checksum
+static const uint8_t CSE7761_REG_RMSIAC = 0x70;       // (2) Channel A effective current conversion coefficient
+
+static const uint8_t CSE7761_SPECIAL_COMMAND = 0xEA;   // Start special command
+static const uint8_t CSE7761_CMD_RESET = 0x96;         // Reset command, after receiving the command, the chip resets
+static const uint8_t CSE7761_CMD_CLOSE_WRITE = 0xDC;   // Close write operation
+static const uint8_t CSE7761_CMD_ENABLE_WRITE = 0xE5;  // Enable write operation
+
+enum CSE7761 { RMS_IAC, RMS_IBC, RMS_UC, POWER_PAC, POWER_PBC, POWER_SC, ENERGY_AC, ENERGY_BC };
+
+void CSE7761Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up CSE7761...");
+  this->write_(CSE7761_SPECIAL_COMMAND, CSE7761_CMD_RESET);
+  uint16_t syscon = this->read_(0x00, 2);  // Default 0x0A04
+  if ((0x0A04 == syscon) && this->chip_init_()) {
+    this->write_(CSE7761_SPECIAL_COMMAND, CSE7761_CMD_CLOSE_WRITE);
+    ESP_LOGD(TAG, "CSE7761 found");
+    this->data_.ready = true;
+  } else {
+    this->mark_failed();
+  }
+}
+
+void CSE7761Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "CSE7761:");
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with CSE7761 failed!");
+  }
+  LOG_UPDATE_INTERVAL(this);
+  this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
+}
+
+float CSE7761Component::get_setup_priority() const { return setup_priority::DATA; }
+
+void CSE7761Component::update() {
+  if (this->data_.ready) {
+    this->get_data_();
+  }
+}
+
+void CSE7761Component::write_(uint8_t reg, uint16_t data) {
+  uint8_t buffer[5];
+
+  buffer[0] = 0xA5;
+  buffer[1] = reg;
+  uint32_t len = 2;
+  if (data) {
+    if (data < 0xFF) {
+      buffer[2] = data & 0xFF;
+      len = 3;
+    } else {
+      buffer[2] = (data >> 8) & 0xFF;
+      buffer[3] = data & 0xFF;
+      len = 4;
+    }
+    uint8_t crc = 0;
+    for (uint32_t i = 0; i < len; i++) {
+      crc += buffer[i];
+    }
+    buffer[len] = ~crc;
+    len++;
+  }
+
+  this->write_array(buffer, len);
+}
+
+bool CSE7761Component::read_once_(uint8_t reg, uint8_t size, uint32_t *value) {
+  while (this->available()) {
+    this->read();
+  }
+
+  this->write_(reg, 0);
+
+  uint8_t buffer[8] = {0};
+  uint32_t rcvd = 0;
+
+  for (uint32_t i = 0; i <= size; i++) {
+    int value = this->read();
+    if (value > -1 && rcvd < sizeof(buffer) - 1) {
+      buffer[rcvd++] = value;
+    }
+  }
+
+  if (!rcvd) {
+    ESP_LOGD(TAG, "Received 0 bytes for register %hhu", reg);
+    return false;
+  }
+
+  rcvd--;
+  uint32_t result = 0;
+  // CRC check
+  uint8_t crc = 0xA5 + reg;
+  for (uint32_t i = 0; i < rcvd; i++) {
+    result = (result << 8) | buffer[i];
+    crc += buffer[i];
+  }
+  crc = ~crc;
+  if (crc != buffer[rcvd]) {
+    return false;
+  }
+
+  *value = result;
+  return true;
+}
+
+uint32_t CSE7761Component::read_(uint8_t reg, uint8_t size) {
+  bool result = false;  // Start loop
+  uint8_t retry = 3;    // Retry up to three times
+  uint32_t value = 0;   // Default no value
+  while (!result && retry > 0) {
+    retry--;
+    if (this->read_once_(reg, size, &value))
+      return value;
+  }
+  ESP_LOGE(TAG, "Reading register %hhu failed!", reg);
+  return value;
+}
+
+uint32_t CSE7761Component::coefficient_by_unit_(uint32_t unit) {
+  switch (unit) {
+    case RMS_UC:
+      return 0x400000 * 100 / this->data_.coefficient[RMS_UC];
+    case RMS_IAC:
+      return (0x800000 * 100 / this->data_.coefficient[RMS_IAC]) * 10;  // Stay within 32 bits
+    case POWER_PAC:
+      return 0x80000000 / this->data_.coefficient[POWER_PAC];
+  }
+  return 0;
+}
+
+bool CSE7761Component::chip_init_() {
+  uint16_t calc_chksum = 0xFFFF;
+  for (uint32_t i = 0; i < 8; i++) {
+    this->data_.coefficient[i] = this->read_(CSE7761_REG_RMSIAC + i, 2);
+    calc_chksum += this->data_.coefficient[i];
+  }
+  calc_chksum = ~calc_chksum;
+  uint16_t coeff_chksum = this->read_(CSE7761_REG_COEFFCHKSUM, 2);
+  if ((calc_chksum != coeff_chksum) || (!calc_chksum)) {
+    ESP_LOGD(TAG, "Default calibration");
+    this->data_.coefficient[RMS_IAC] = CSE7761_IREF;
+    this->data_.coefficient[RMS_UC] = CSE7761_UREF;
+    this->data_.coefficient[POWER_PAC] = CSE7761_PREF;
+  }
+
+  this->write_(CSE7761_SPECIAL_COMMAND, CSE7761_CMD_ENABLE_WRITE);
+
+  uint8_t sys_status = this->read_(CSE7761_REG_SYSSTATUS, 1);
+  if (sys_status & 0x10) {  // Write enable to protected registers (WREN)
+    this->write_(CSE7761_REG_SYSCON | 0x80, 0xFF04);
+    this->write_(CSE7761_REG_EMUCON | 0x80, 0x1183);
+    this->write_(CSE7761_REG_EMUCON2 | 0x80, 0x0FC1);
+    this->write_(CSE7761_REG_PULSE1SEL | 0x80, 0x3290);
+  } else {
+    ESP_LOGD(TAG, "Write failed at chip_init");
+    return false;
+  }
+  return true;
+}
+
+void CSE7761Component::get_data_() {
+  // The effective value of current and voltage Rms is a 24-bit signed number,
+  // the highest bit is 0 for valid data,
+  //   and when the highest bit is 1, the reading will be processed as zero
+  // The active power parameter PowerA/B is in two’s complement format, 32-bit
+  // data, the highest bit is Sign bit.
+  uint32_t value = this->read_(CSE7761_REG_RMSU, 3);
+  this->data_.voltage_rms = (value >= 0x800000) ? 0 : value;
+
+  value = this->read_(CSE7761_REG_RMSIA, 3);
+  this->data_.current_rms[0] = ((value >= 0x800000) || (value < 1600)) ? 0 : value;  // No load threshold of 10mA
+  value = this->read_(CSE7761_REG_POWERPA, 4);
+  this->data_.active_power[0] = (0 == this->data_.current_rms[0]) ? 0 : ((uint32_t) abs((int) value));
+
+  value = this->read_(CSE7761_REG_RMSIB, 3);
+  this->data_.current_rms[1] = ((value >= 0x800000) || (value < 1600)) ? 0 : value;  // No load threshold of 10mA
+  value = this->read_(CSE7761_REG_POWERPB, 4);
+  this->data_.active_power[1] = (0 == this->data_.current_rms[1]) ? 0 : ((uint32_t) abs((int) value));
+
+  // convert values and publish to sensors
+
+  float voltage = (float) this->data_.voltage_rms / this->coefficient_by_unit_(RMS_UC);
+  if (this->voltage_sensor_ != nullptr) {
+    this->voltage_sensor_->publish_state(voltage);
+  }
+
+  for (uint32_t channel = 0; channel < 2; channel++) {
+    // Active power = PowerPA * PowerPAC * 1000 / 0x80000000
+    float active_power = (float) this->data_.active_power[channel] / this->coefficient_by_unit_(POWER_PAC);  // W
+    float amps = (float) this->data_.current_rms[channel] / this->coefficient_by_unit_(RMS_IAC);             // A
+    ESP_LOGD(TAG, "Channel %d power %f W, current %f A", channel + 1, active_power, amps);
+    if (channel == 0) {
+      if (this->power_sensor_1_ != nullptr) {
+        this->power_sensor_1_->publish_state(active_power);
+      }
+      if (this->current_sensor_1_ != nullptr) {
+        this->current_sensor_1_->publish_state(amps);
+      }
+    } else if (channel == 1) {
+      if (this->power_sensor_2_ != nullptr) {
+        this->power_sensor_2_->publish_state(active_power);
+      }
+      if (this->current_sensor_2_ != nullptr) {
+        this->current_sensor_2_->publish_state(amps);
+      }
+    }
+  }
+}
+
+}  // namespace cse7761
+}  // namespace esphome

esphome/components/cse7761/cse7761.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace cse7761 {
+
+struct CSE7761DataStruct {
+  uint32_t frequency = 0;
+  uint32_t voltage_rms = 0;
+  uint32_t current_rms[2] = {0};
+  uint32_t energy[2] = {0};
+  uint32_t active_power[2] = {0};
+  uint16_t coefficient[8] = {0};
+  uint8_t energy_update = 0;
+  bool ready = false;
+};
+
+/// This class implements support for the CSE7761 UART power sensor.
+class CSE7761Component : public PollingComponent, public uart::UARTDevice {
+ public:
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
+  void set_active_power_1_sensor(sensor::Sensor *power_sensor_1) { power_sensor_1_ = power_sensor_1; }
+  void set_current_1_sensor(sensor::Sensor *current_sensor_1) { current_sensor_1_ = current_sensor_1; }
+  void set_active_power_2_sensor(sensor::Sensor *power_sensor_2) { power_sensor_2_ = power_sensor_2; }
+  void set_current_2_sensor(sensor::Sensor *current_sensor_2) { current_sensor_2_ = current_sensor_2; }
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void update() override;
+
+ protected:
+  // Sensors
+  sensor::Sensor *voltage_sensor_{nullptr};
+  sensor::Sensor *power_sensor_1_{nullptr};
+  sensor::Sensor *current_sensor_1_{nullptr};
+  sensor::Sensor *power_sensor_2_{nullptr};
+  sensor::Sensor *current_sensor_2_{nullptr};
+  CSE7761DataStruct data_;
+
+  void write_(uint8_t reg, uint16_t data);
+  bool read_once_(uint8_t reg, uint8_t size, uint32_t *value);
+  uint32_t read_(uint8_t reg, uint8_t size);
+  uint32_t coefficient_by_unit_(uint32_t unit);
+  bool chip_init_();
+  void get_data_();
+};
+
+}  // namespace cse7761
+}  // namespace esphome

esphome/components/cse7761/sensor.py

@@ -0,0 +1,90 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, uart
+from esphome.const import (
+    CONF_ID,
+    CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+)
+
+CODEOWNERS = ["@berfenger"]
+DEPENDENCIES = ["uart"]
+
+cse7761_ns = cg.esphome_ns.namespace("cse7761")
+CSE7761Component = cse7761_ns.class_(
+    "CSE7761Component", cg.PollingComponent, uart.UARTDevice
+)
+
+CONF_CURRENT_1 = "current_1"
+CONF_CURRENT_2 = "current_2"
+CONF_ACTIVE_POWER_1 = "active_power_1"
+CONF_ACTIVE_POWER_2 = "active_power_2"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CSE7761Component),
+            cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT_1): sensor.sensor_schema(
+                unit_of_measurement=UNIT_AMPERE,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT_2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_AMPERE,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_1): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(uart.UART_DEVICE_SCHEMA)
+)
+
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "cse7761", baud_rate=38400, require_rx=True, require_tx=True
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+
+    for key in [
+        CONF_VOLTAGE,
+        CONF_CURRENT_1,
+        CONF_CURRENT_2,
+        CONF_ACTIVE_POWER_1,
+        CONF_ACTIVE_POWER_2,
+    ]:
+        if key not in config:
+            continue
+        conf = config[key]
+        sens = await sensor.new_sensor(conf)
+        cg.add(getattr(var, f"set_{key}_sensor")(sens))

tests/test3.yaml

@@ -250,6 +250,10 @@ uart:
     tx_pin: GPIO4
     rx_pin: GPIO5
     baud_rate: 9600
+  - id: uart7
+    tx_pin: GPIO4
+    rx_pin: GPIO5
+    baud_rate: 38400
 
 modbus:
   uart_id: uart1
@@ -549,6 +553,18 @@ sensor:
       name: 'PMS Humidity'
     formaldehyde:
       name: 'PMS Formaldehyde Concentration'
+  - platform: cse7761
+    uart_id: uart7
+    voltage:
+      name: 'CSE7761 Voltage'
+    current_1:
+      name: 'CSE7761 Current 1'
+    current_2:
+      name: 'CSE7761 Current 2'
+    active_power_1:
+      name: 'CSE7761 Active Power 1'
+    active_power_2:
+      name: 'CSE7761 Active Power 2'
   - platform: cse7766
     uart_id: uart3
     voltage: