Add OpenDTU energy and inverter telemetry sensors

Author: withoutspam

CHANGELOG.md

@@ -6,6 +6,15 @@ All notable changes to this project are documented here.
 
 ### Added
 
+- ESPHome sensors for daily and lifetime production, summed only across microinverters selected in `microinverter_map`.
+- ESPHome sensors for average mapped-inverter temperature and aggregate inverter efficiency.
+
+### Changed
+
+- Extended OpenDTU livedata parsing to consume `INV["0"]` production, temperature, efficiency, and DC-power fields in addition to the AC channel.
+
+### Added
+
 - Selectable `sdm630` and `dtsu666` meter profiles through `meter_profile`.
 - CHINT DTSU666 instantaneous voltage, current, active-power, and frequency register mapping based on the published CHINT Modbus specification.
 - Separate profile descriptor tables, a shared `meter_profile_codec`, and CI build configurations for SDM630 and DTSU666.

README.md

@@ -69,6 +69,7 @@ flowchart TB
 Each microinverter (**MI**) only needs radio reach to **OpenDTU**. The bridge sums per-phase active, reactive and apparent power plus current from every mapped inverter and encodes the result using the selected meter profile.
 
 - Parses all electrical fields supplied by the OpenDTU AC channel (`inverters[].AC["0"]` → voltage, current, active power, reactive power, power factor and frequency)
+- Reads production, temperature and efficiency from each mapped inverter's `inverters[].INV["0"]` channel; the bridge does not use OpenDTU's global total, which can include unmapped inverters
 - Maps microinverters to grid phases via `microinverter_map` (several inverters can share a phase; current, active power, reactive power and apparent power are summed, voltage and frequency are averaged)
 - Inverts the OpenDTU generation sign for directional values: active power is negative for export in both profiles, SDM630 retains directional current for compatibility, and DTSU666 exposes positive RMS current as required by its register map
 - Serves the selected meter register window on `slave_address` (`0x02` for Deye Grid Tie Meter 2), silently ignoring Deye queries to `0x01` (main meter address)
@@ -194,6 +195,8 @@ When `publish_sensors: true` (default), the component registers:
 - L1/L2/L3 and total reactive-power sensors (`ReactivePower` from OpenDTU)
 - L1/L2/L3 and total apparent-power sensors (derived from OpenDTU active power and power factor)
 - L1/L2/L3 and total power-factor sensors (aggregated from active and apparent power)
+- Total production today [Wh] and total lifetime production [kWh], summed across mapped microinverters
+- Average mapped-inverter temperature and aggregate inverter efficiency
 - Total active-power and frequency sensors
 - **WebSocket Status** and **WebSocket Data Valid** (diagnostic binary sensors)
 - **Board Restart** button and **Component Version** text sensor (diagnostic)

components/opendtu_meter_bridge/__init__.py

@@ -22,22 +22,30 @@
     CONF_PORT,
     DEVICE_CLASS_CONNECTIVITY,
     DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
     DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_RESTART,
+    DEVICE_CLASS_TEMPERATURE,
     DEVICE_CLASS_VOLTAGE,
     ENTITY_CATEGORY_DIAGNOSTIC,
     ICON_RESTART,
     STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL,
+    STATE_CLASS_TOTAL_INCREASING,
     UNIT_AMPERE,
+    UNIT_CELSIUS,
     UNIT_HERTZ,
+    UNIT_KILOWATT_HOURS,
+    UNIT_PERCENT,
     UNIT_VOLT,
     UNIT_VOLT_AMPS,
     UNIT_VOLT_AMPS_REACTIVE,
     UNIT_WATT,
+    UNIT_WATT_HOURS,
 )
 
 # ESPHome 2026.7 introduced the ModbusServer codegen type.  Earlier supported
@@ -53,7 +61,7 @@
 DEPENDENCIES = ["wifi"]
 CONFLICTS_WITH = ["opendtu_sdm630"]
 
-COMPONENT_VERSION = "0.2.1"
+COMPONENT_VERSION = "0.2.2"
 
 CONF_HOST = "host"
 CONF_PATH = "path"
@@ -94,6 +102,10 @@
 CONF_POWER_FACTOR_L2 = "power_factor_l2"
 CONF_POWER_FACTOR_L3 = "power_factor_l3"
 CONF_TOTAL_POWER_FACTOR = "total_power_factor"
+CONF_TOTAL_YIELD_DAY = "total_yield_day"
+CONF_TOTAL_YIELD_TOTAL = "total_yield_total"
+CONF_AVERAGE_TEMPERATURE = "average_temperature"
+CONF_EFFICIENCY = "efficiency"
 CONF_FREQUENCY = "frequency"
 CONF_WEBSOCKET_CONNECTED = "websocket_connected"
 CONF_DATA_VALID = "data_valid"
@@ -175,6 +187,37 @@
     state_class=STATE_CLASS_MEASUREMENT,
 )
 
+YIELD_DAY_SENSOR_SCHEMA = sensor.sensor_schema(
+    sensor.Sensor,
+    unit_of_measurement=UNIT_WATT_HOURS,
+    device_class=DEVICE_CLASS_ENERGY,
+    accuracy_decimals=0,
+    state_class=STATE_CLASS_TOTAL,
+)
+
+YIELD_TOTAL_SENSOR_SCHEMA = sensor.sensor_schema(
+    sensor.Sensor,
+    unit_of_measurement=UNIT_KILOWATT_HOURS,
+    device_class=DEVICE_CLASS_ENERGY,
+    accuracy_decimals=3,
+    state_class=STATE_CLASS_TOTAL_INCREASING,
+)
+
+TEMPERATURE_SENSOR_SCHEMA = sensor.sensor_schema(
+    sensor.Sensor,
+    unit_of_measurement=UNIT_CELSIUS,
+    device_class=DEVICE_CLASS_TEMPERATURE,
+    accuracy_decimals=1,
+    state_class=STATE_CLASS_MEASUREMENT,
+)
+
+EFFICIENCY_SENSOR_SCHEMA = sensor.sensor_schema(
+    sensor.Sensor,
+    unit_of_measurement=UNIT_PERCENT,
+    accuracy_decimals=1,
+    state_class=STATE_CLASS_MEASUREMENT,
+)
+
 FREQUENCY_SENSOR_SCHEMA = sensor.sensor_schema(
     sensor.Sensor,
     unit_of_measurement=UNIT_HERTZ,
@@ -227,6 +270,10 @@
     CONF_POWER_FACTOR_L2: ("L2 Power Factor", POWER_FACTOR_SENSOR_SCHEMA),
     CONF_POWER_FACTOR_L3: ("L3 Power Factor", POWER_FACTOR_SENSOR_SCHEMA),
     CONF_TOTAL_POWER_FACTOR: ("Total Power Factor", POWER_FACTOR_SENSOR_SCHEMA),
+    CONF_TOTAL_YIELD_DAY: ("Total Yield Today", YIELD_DAY_SENSOR_SCHEMA),
+    CONF_TOTAL_YIELD_TOTAL: ("Total Yield", YIELD_TOTAL_SENSOR_SCHEMA),
+    CONF_AVERAGE_TEMPERATURE: ("Average Inverter Temperature", TEMPERATURE_SENSOR_SCHEMA),
+    CONF_EFFICIENCY: ("Inverter Efficiency", EFFICIENCY_SENSOR_SCHEMA),
     CONF_FREQUENCY: ("Frequency", FREQUENCY_SENSOR_SCHEMA),
     CONF_WEBSOCKET_CONNECTED: ("WebSocket Status", BINARY_CONNECTIVITY_SCHEMA),
     CONF_DATA_VALID: ("WebSocket Data Valid", BINARY_DATA_VALID_SCHEMA),
@@ -255,6 +302,10 @@
     CONF_POWER_FACTOR_L2: "set_power_factor_l2_sensor",
     CONF_POWER_FACTOR_L3: "set_power_factor_l3_sensor",
     CONF_TOTAL_POWER_FACTOR: "set_total_power_factor_sensor",
+    CONF_TOTAL_YIELD_DAY: "set_total_yield_day_sensor",
+    CONF_TOTAL_YIELD_TOTAL: "set_total_yield_total_sensor",
+    CONF_AVERAGE_TEMPERATURE: "set_average_temperature_sensor",
+    CONF_EFFICIENCY: "set_efficiency_sensor",
     CONF_FREQUENCY: "set_frequency_sensor",
     CONF_WEBSOCKET_CONNECTED: "set_websocket_connected_binary_sensor",
     CONF_DATA_VALID: "set_data_valid_binary_sensor",
@@ -338,6 +389,10 @@ def _normalize_meter_profile(config):
             cv.Optional(CONF_POWER_FACTOR_L2): POWER_FACTOR_SENSOR_SCHEMA,
             cv.Optional(CONF_POWER_FACTOR_L3): POWER_FACTOR_SENSOR_SCHEMA,
             cv.Optional(CONF_TOTAL_POWER_FACTOR): POWER_FACTOR_SENSOR_SCHEMA,
+            cv.Optional(CONF_TOTAL_YIELD_DAY): YIELD_DAY_SENSOR_SCHEMA,
+            cv.Optional(CONF_TOTAL_YIELD_TOTAL): YIELD_TOTAL_SENSOR_SCHEMA,
+            cv.Optional(CONF_AVERAGE_TEMPERATURE): TEMPERATURE_SENSOR_SCHEMA,
+            cv.Optional(CONF_EFFICIENCY): EFFICIENCY_SENSOR_SCHEMA,
             cv.Optional(CONF_FREQUENCY): FREQUENCY_SENSOR_SCHEMA,
             cv.Optional(CONF_WEBSOCKET_CONNECTED): BINARY_CONNECTIVITY_SCHEMA,
             cv.Optional(CONF_DATA_VALID): BINARY_DATA_VALID_SCHEMA,

components/opendtu_meter_bridge/opendtu_meter_bridge.cpp

@@ -139,6 +139,14 @@ void OpenDtuMeterBridge::mark_data_stale_and_reset_() {
   }
   this->measured_frequency_ = 0.0f;
   this->has_frequency_data_ = false;
+  this->total_yield_day_ = 0.0f;
+  this->total_yield_total_ = 0.0f;
+  this->average_temperature_ = 0.0f;
+  this->efficiency_ = 0.0f;
+  this->has_yield_day_data_ = false;
+  this->has_yield_total_data_ = false;
+  this->has_temperature_data_ = false;
+  this->has_efficiency_data_ = false;
   this->sync_modbus_registers_locked_();
   xSemaphoreGive(this->data_mutex_);
   this->publish_state_();
@@ -212,6 +220,18 @@ void OpenDtuMeterBridge::publish_state_() {
   if (this->total_power_factor_sensor_ != nullptr) {
     this->total_power_factor_sensor_->publish_state(this->get_total_power_factor());
   }
+  if (this->total_yield_day_sensor_ != nullptr) {
+    this->total_yield_day_sensor_->publish_state(this->get_total_yield_day());
+  }
+  if (this->total_yield_total_sensor_ != nullptr) {
+    this->total_yield_total_sensor_->publish_state(this->get_total_yield_total());
+  }
+  if (this->average_temperature_sensor_ != nullptr) {
+    this->average_temperature_sensor_->publish_state(this->get_average_temperature());
+  }
+  if (this->efficiency_sensor_ != nullptr) {
+    this->efficiency_sensor_->publish_state(this->get_efficiency());
+  }
   if (this->frequency_sensor_ != nullptr) {
     this->frequency_sensor_->publish_state(this->get_frequency());
   }
@@ -226,17 +246,21 @@ void OpenDtuMeterBridge::publish_state_() {
 #endif
 }
 
-float OpenDtuMeterBridge::json_field_v_(const cJSON *ac0, const char *key) {
-  const cJSON *field = cJSON_GetObjectItemCaseSensitive(ac0, key);
+bool OpenDtuMeterBridge::json_field_v_(const cJSON *object, const char *key, float &value) {
+  value = 0.0f;
+  const cJSON *field = cJSON_GetObjectItemCaseSensitive(object, key);
   if (field == nullptr) {
-    return 0.0f;
+    return false;
   }
   const cJSON *v = cJSON_GetObjectItemCaseSensitive(field, "v");
   if (cJSON_IsNumber(v)) {
     float out = (float) v->valuedouble;
-    return float_is_finite(out) ? out : 0.0f;
+    if (float_is_finite(out)) {
+      value = out;
+      return true;
+    }
   }
-  return 0.0f;
+  return false;
 }
 
 int OpenDtuMeterBridge::find_inverter_index_(const cJSON *inverters, const MicroinverterMapEntry &entry) {
@@ -279,6 +303,16 @@ void OpenDtuMeterBridge::process_livedata_(const char *json, size_t len) {
   PhaseAccumulator tmp[4] = {};
   float frequency_sum = 0.0f;
   uint8_t frequency_count = 0;
+  float yield_day_total = 0.0f;
+  float yield_total_total = 0.0f;
+  float temperature_sum = 0.0f;
+  uint8_t temperature_count = 0;
+  float dc_power_total = 0.0f;
+  float ac_power_total = 0.0f;
+  float efficiency_sum = 0.0f;
+  uint8_t efficiency_count = 0;
+  bool has_yield_day = false;
+  bool has_yield_total = false;
 
   for (const auto &entry : this->microinverter_map_) {
     uint8_t grid_phase = entry.grid_phase;
@@ -307,12 +341,18 @@ void OpenDtuMeterBridge::process_livedata_(const char *json, size_t len) {
       continue;
     }
 
-    float voltage = this->json_field_v_(ac0, "Voltage");
-    float current = this->json_field_v_(ac0, "Current");
-    float power = this->json_field_v_(ac0, "Power");
-    float reactive_power = this->json_field_v_(ac0, "ReactivePower");
-    float power_factor = this->json_field_v_(ac0, "PowerFactor");
-    float frequency = this->json_field_v_(ac0, "Frequency");
+    float voltage = 0.0f;
+    float current = 0.0f;
+    float power = 0.0f;
+    float reactive_power = 0.0f;
+    float power_factor = 0.0f;
+    float frequency = 0.0f;
+    this->json_field_v_(ac0, "Voltage", voltage);
+    this->json_field_v_(ac0, "Current", current);
+    const bool has_power = this->json_field_v_(ac0, "Power", power);
+    this->json_field_v_(ac0, "ReactivePower", reactive_power);
+    this->json_field_v_(ac0, "PowerFactor", power_factor);
+    this->json_field_v_(ac0, "Frequency", frequency);
 
     if (float_is_finite(voltage) && voltage >= VOLTAGE_MIN_V && voltage <= VOLTAGE_MAX_V) {
       tmp[grid_phase].voltage_sum += voltage;
@@ -333,6 +373,36 @@ void OpenDtuMeterBridge::process_livedata_(const char *json, size_t len) {
       frequency_sum += frequency;
       frequency_count++;
     }
+
+    cJSON *inverter = cJSON_GetObjectItemCaseSensitive(inv, "INV");
+    cJSON *inverter0 = (inverter != nullptr) ? cJSON_GetObjectItemCaseSensitive(inverter, "0") : nullptr;
+    if (inverter0 == nullptr) {
+      continue;
+    }
+
+    float value = 0.0f;
+    if (this->json_field_v_(inverter0, "YieldDay", value)) {
+      yield_day_total += value;
+      has_yield_day = true;
+    }
+    if (this->json_field_v_(inverter0, "YieldTotal", value)) {
+      yield_total_total += value;
+      has_yield_total = true;
+    }
+    if (this->json_field_v_(inverter0, "Temperature", value)) {
+      temperature_sum += value;
+      temperature_count++;
+    }
+    if (this->json_field_v_(inverter0, "Efficiency", value)) {
+      efficiency_sum += value;
+      efficiency_count++;
+    }
+    if (has_power) {
+      ac_power_total += std::fabs(power);
+    }
+    if (this->json_field_v_(inverter0, "Power DC", value) && value > 0.0f) {
+      dc_power_total += value;
+    }
   }
 
   xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
@@ -355,6 +425,24 @@ void OpenDtuMeterBridge::process_livedata_(const char *json, size_t len) {
     this->measured_frequency_ = 0.0f;
     this->has_frequency_data_ = false;
   }
+  this->total_yield_day_ = has_yield_day && float_is_finite(yield_day_total) ? yield_day_total : 0.0f;
+  this->total_yield_total_ = has_yield_total && float_is_finite(yield_total_total) ? yield_total_total : 0.0f;
+  this->average_temperature_ = temperature_count > 0 && float_is_finite(temperature_sum)
+                                   ? temperature_sum / (float) temperature_count
+                                   : 0.0f;
+  if (dc_power_total > 0.0f && float_is_finite(ac_power_total) && float_is_finite(dc_power_total)) {
+    this->efficiency_ = ac_power_total / dc_power_total * 100.0f;
+    this->has_efficiency_data_ = float_is_finite(this->efficiency_);
+  } else if (efficiency_count > 0 && float_is_finite(efficiency_sum)) {
+    this->efficiency_ = efficiency_sum / (float) efficiency_count;
+    this->has_efficiency_data_ = true;
+  } else {
+    this->efficiency_ = 0.0f;
+    this->has_efficiency_data_ = false;
+  }
+  this->has_yield_day_data_ = has_yield_day && float_is_finite(this->total_yield_day_);
+  this->has_yield_total_data_ = has_yield_total && float_is_finite(this->total_yield_total_);
+  this->has_temperature_data_ = temperature_count > 0 && float_is_finite(this->average_temperature_);
   this->last_data_us_ = esp_timer_get_time();
   this->data_stale_ = false;
   this->sync_modbus_registers_locked_();
@@ -735,6 +823,34 @@ float OpenDtuMeterBridge::get_total_power_factor() {
   return std::fabs(total_power) / total_apparent_power;
 }
 
+float OpenDtuMeterBridge::get_total_yield_day() {
+  xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
+  const float value = !this->data_stale_ && this->has_yield_day_data_ ? this->total_yield_day_ : 0.0f;
+  xSemaphoreGive(this->data_mutex_);
+  return float_is_finite(value) ? value : 0.0f;
+}
+
+float OpenDtuMeterBridge::get_total_yield_total() {
+  xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
+  const float value = !this->data_stale_ && this->has_yield_total_data_ ? this->total_yield_total_ : 0.0f;
+  xSemaphoreGive(this->data_mutex_);
+  return float_is_finite(value) ? value : 0.0f;
+}
+
+float OpenDtuMeterBridge::get_average_temperature() {
+  xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
+  const float value = !this->data_stale_ && this->has_temperature_data_ ? this->average_temperature_ : 0.0f;
+  xSemaphoreGive(this->data_mutex_);
+  return float_is_finite(value) ? value : 0.0f;
+}
+
+float OpenDtuMeterBridge::get_efficiency() {
+  xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
+  const float value = !this->data_stale_ && this->has_efficiency_data_ ? this->efficiency_ : 0.0f;
+  xSemaphoreGive(this->data_mutex_);
+  return float_is_finite(value) ? value : 0.0f;
+}
+
 float OpenDtuMeterBridge::get_frequency() {
   xSemaphoreTake(this->data_mutex_, portMAX_DELAY);
   float value = this->data_stale_