Add Ecoflow Smart Meter & Stream AC & Stream Ultra devices (tolwi#483)

* Add Smart Meter device

* Rename L1/L2/L3 connections

* Adaptation variable params

* Add Stream AC device

* Add serial number

* Add new entities (manual discovered)
for smart meter and stream ac

* Add detection of device by name
Necessary when there is no productName in json flow

* Adjust for Stream Ultra device name

* Add powGetSchuko2 Entity

* Add documentation for new devices
- Generate conf for Smart meter / Stream AC & Ultra
- Fix of the gen.py to generate conf

Author: Angelius007

custom_components/ecoflow_cloud/api/ecoflow_mqtt.py

@@ -95,7 +95,7 @@ def _on_message(self, client, userdata, message):
         try:
             for sn, device in self.__devices.items():
                 if device.update_data(message.payload, message.topic):
-                    _LOGGER.debug(f"Message for {sn} and Topic {message.topic}")
+                    _LOGGER.debug(f"Message for {sn} and Topic {message.topic} : {message.payload}")
         except UnicodeDecodeError as error:
             _LOGGER.error(
                 f"UnicodeDecodeError: {error}. Ignoring message and waiting for the next one."

custom_components/ecoflow_cloud/api/public_api.py

@@ -43,8 +43,15 @@ async def fetch_all_available_devices(self) -> list[EcoflowDeviceInfo]:
         response = await self.call_api("/device/list")
         result = list()
         for device in response["data"]:
+            _LOGGER.debug(str(device))
             sn = device["sn"]
             product_name = device.get("productName", "undefined")
+            if product_name == "undefined" :
+                from ..devices.registry import device_by_product
+                device_list = list(device_by_product.keys())
+                for devicetype in device_list:
+                    if "deviceName" in device and device["deviceName"].lower().startswith(devicetype.lower()):
+                        product_name = devicetype
             device_name = device.get("deviceName", f"{product_name}-{sn}")
             status = int(device["online"])
             result.append(
@@ -94,11 +101,14 @@ async def quota_all(self, device_sn: str | None):
             target_devices = [device_sn]
 
         for sn in target_devices:
-            raw = await self.call_api(
-                "/device/quota/all", {"sn": self.devices[sn].device_info.sn}
-            )
-            if "data" in raw:
-                self.devices[sn].data.update_data({"params": raw["data"]})
+            try:
+                raw = await self.call_api("/device/quota/all", {"sn": sn})
+                if "data" in raw:
+                    self.devices[sn].data.update_data({"params": raw["data"]})
+            except Exception as exception:
+                _LOGGER.error(exception, exc_info=True)
+                _LOGGER.error("Erreur recuperation %s", sn)
+
 
     async def call_api(self, endpoint: str, params: dict[str, str] = None) -> dict:
         async with aiohttp.ClientSession() as session:

custom_components/ecoflow_cloud/config_flow.py

@@ -146,17 +146,18 @@ def remove_device(self, sn: str):
             identifiers = {(ECOFLOW_DOMAIN, f"{sn}")}
 
         device = device_reg.async_get_device(identifiers=identifiers)
-        # _LOGGER.info(f".. getting device by %s: %s", str(identifiers), str(device))
+        _LOGGER.debug(f".. getting device by %s: %s", str(identifiers), str(device))
 
         # Remove all entities for this device
-        ent_reg: EntityRegistry = er.async_get(self.hass)
-        entities = er.async_entries_for_device(ent_reg, device.id)
+        if getattr(device, "id", None) is not None :
+            ent_reg: EntityRegistry = er.async_get(self.hass)
+            entities = er.async_entries_for_device(ent_reg, device.id)
 
-        for entity in entities:
-            ent_reg.async_remove(entity.entity_id)
+            for entity in entities:
+                ent_reg.async_remove(entity.entity_id)
 
-        # Remove the device from the device registry
-        device_reg.async_remove_device(device.id)
+            # Remove the device from the device registry
+            device_reg.async_remove_device(device.id)
 
     async def async_step_user(self, user_input: dict[str, Any] | None = None):
         if self.config_entry:  # reconfigure flow
@@ -386,7 +387,8 @@ async def async_step_remove_device(self, user_input: dict[str, Any] | None = Non
                 ),
             )
         target_device = self.local_devices[user_input[CONF_SELECT_DEVICE_KEY]]
-        self.new_data[CONF_DEVICE_LIST].pop(target_device.sn)
+        if target_device.sn in self.new_data[CONF_DEVICE_LIST]:
+            self.new_data[CONF_DEVICE_LIST].pop(target_device.sn)
 
         self.remove_device(target_device.sn)
         return await self.update_or_create()

custom_components/ecoflow_cloud/devices/const.py

@@ -275,3 +275,45 @@
 MAIN_MODE = "Main mode"
 REMOTE_MODE = "Remote startup/shutdown"
 POWER_SUB_MODE = "Sub-mode"
+
+# Smart Meter
+SMART_METER_POWER_GLOBAL = "Power Grid Global"
+SMART_METER_POWER_L1 = "Power Grid L1"
+SMART_METER_POWER_L2 = "Power Grid L2"
+SMART_METER_POWER_L3 = "Power Grid L3"
+SMART_METER_IN_AMPS_L1 = "Power Grid (L1) In Amps"
+SMART_METER_IN_AMPS_L2 = "Power Grid (L2) In Amps"
+SMART_METER_IN_AMPS_L3 = "Power Grid (L3) In Amps"
+SMART_METER_VOLT_L1 = "Power Grid (L1) Volts"
+SMART_METER_VOLT_L2 = "Power Grid (L2) Volts"
+SMART_METER_VOLT_L3 = "Power Grid (L3) Volts"
+SMART_METER_RECORD_ACTIVE_TODAY = "Lifetime consumption"
+SMART_METER_RECORD_ACTIVE_TOTAL = "Lifetime net usage"
+SMART_METER_RECORD_REACTIVE_TOTAL = "Lifetime injection"
+SMART_METER_RECORD_ACTIVE_TODAY_L1 = "L1 Lifetime net usage"
+SMART_METER_RECORD_ACTIVE_TODAY_L2 = "L2 Lifetime net usage"
+SMART_METER_RECORD_ACTIVE_TODAY_L3 = "L3 Lifetime net usage"
+
+# Stream AC
+STREAM_POWER_AC = "Power AC" # <0 import from home to battery / >0 export from battery to home
+STREAM_POWER_AC_SYS = "Power AC SYS" # <0 import from home to battery / >0 export from battery to home
+STREAM_POWER_PV = "Power PV" # >0 external pv power estimate injection to home/battery
+STREAM_GET_SYS_LOAD = "Power Sys Load" # powGetSysLoad
+STREAM_GET_SYS_LOAD_FROM_GRID = "Power Sys Load From Grid" # powGetSysLoadFromGrid
+STREAM_GET_SCHUKO1 = "Power SCHUKO1" # powGetSchuko1
+STREAM_GET_SCHUKO2 = "Power SCHUKO2" # powGetSchuko2
+STREAM_POWER_GRID = "Power Grid" # power from smart meter or shelly
+STREAM_POWER_BATTERY = "Power Battery" # <0 discharge battery / >0 charge batterie
+STREAM_POWER_BATTERY_SOC = "Power Battery SOC" # <0 discharge battery / >0 charge batterie
+STREAM_BATTERY_LEVEL = "Battery Level"
+STREAM_DESIGN_CAPACITY = "Design Capacity"
+STREAM_FULL_CAPACITY = "Full Capacity"
+STREAM_REMAIN_CAPACITY = "Remain Capacity"
+STREAM_STR_BATTERY_LEVEL = "Battery Level %s "
+STREAM_STR_DESIGN_CAPACITY = "Design Capacity %s "
+STREAM_STR_FULL_CAPACITY = "Full Capacity %s "
+STREAM_STR_REMAIN_CAPACITY = "Remain Capacity %s "
+STREAM_IN_POWER = "In Power"
+STREAM_STR_IN_POWER = "In Power %s"
+STREAM_OUT_POWER = "Out Power"
+STREAM_STR_OUT_POWER = "Out Power %s"

custom_components/ecoflow_cloud/devices/data_holder.py

@@ -92,8 +92,9 @@ def update_data(self, raw: dict[str, Any]):
                     return
                 if raw["moduleSn"] != self.module_sn:
                     return
-            self.params.update(raw["params"])
-            self.params_time = dt.utcnow()
+            if "params" in raw:
+                self.params.update(raw["params"])
+                self.params_time = dt.utcnow()
 
         except Exception as error:
             _LOGGER.error("Error updating data: %s", error)

custom_components/ecoflow_cloud/devices/internal/smart_meter.py

@@ -0,0 +1,43 @@
+from custom_components.ecoflow_cloud.api import EcoflowApiClient
+from custom_components.ecoflow_cloud.devices import const, BaseDevice
+from custom_components.ecoflow_cloud.entities import BaseSensorEntity, BaseNumberEntity, BaseSwitchEntity, \
+    BaseSelectEntity
+from custom_components.ecoflow_cloud.sensor import WattsSensorEntity, InAmpSensorEntity, MilliVoltSensorEntity, \
+    EnergySensorEntity
+
+class SmartMeter(BaseDevice):
+    def sensors(self, client: EcoflowApiClient) -> list[BaseSensorEntity]:
+        return [
+            WattsSensorEntity(client, self, "powGetSysGrid", const.SMART_METER_POWER_GLOBAL),
+
+            WattsSensorEntity(client, self, "gridConnectionPowerL1", const.SMART_METER_POWER_L1, False),
+            WattsSensorEntity(client, self, "gridConnectionPowerL2", const.SMART_METER_POWER_L2, False),
+            WattsSensorEntity(client, self, "gridConnectionPowerL3", const.SMART_METER_POWER_L3, False),
+
+            InAmpSensorEntity(client, self, "gridConnectionAmpL1", const.SMART_METER_IN_AMPS_L1, False),
+            InAmpSensorEntity(client, self, "gridConnectionAmpL2", const.SMART_METER_IN_AMPS_L2, False),
+            InAmpSensorEntity(client, self, "gridConnectionAmpL3", const.SMART_METER_IN_AMPS_L3, False),
+
+            MilliVoltSensorEntity(client, self, "gridConnectionVolL1", const.SMART_METER_VOLT_L1, False),
+            MilliVoltSensorEntity(client, self, "gridConnectionVolL2", const.SMART_METER_VOLT_L2, False),
+            MilliVoltSensorEntity(client, self, "gridConnectionVolL3", const.SMART_METER_VOLT_L3, False),
+
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.todayActive", const.SMART_METER_RECORD_ACTIVE_TODAY),
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.totalActiveEnergy", const.SMART_METER_RECORD_ACTIVE_TOTAL),
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.totalReactiveEnergy", const.SMART_METER_RECORD_REACTIVE_TOTAL),
+
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.todayActiveL1", const.SMART_METER_RECORD_ACTIVE_TODAY_L1,False),
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.todayActiveL2", const.SMART_METER_RECORD_ACTIVE_TODAY_L2, False),
+            EnergySensorEntity(client, self, "gridConnectionDataRecord.todayActiveL3", const.SMART_METER_RECORD_ACTIVE_TODAY_L3, False),
+
+
+        ]
+
+    def numbers(self, client: EcoflowApiClient) -> list[BaseNumberEntity]:
+        return []
+
+    def switches(self, client: EcoflowApiClient) -> list[BaseSwitchEntity]:
+        return []
+
+    def selects(self, client: EcoflowApiClient) -> list[BaseSelectEntity]:
+        return []

custom_components/ecoflow_cloud/devices/internal/stream_ac.py

@@ -0,0 +1,59 @@
+from custom_components.ecoflow_cloud.api import EcoflowApiClient
+from custom_components.ecoflow_cloud.devices import const, BaseDevice
+from custom_components.ecoflow_cloud.entities import BaseSensorEntity, BaseNumberEntity, BaseSwitchEntity, \
+    BaseSelectEntity
+from custom_components.ecoflow_cloud.sensor import WattsSensorEntity,LevelSensorEntity,CapacitySensorEntity, \
+    InWattsSensorEntity,OutWattsSensorEntity, RemainSensorEntity, MilliVoltSensorEntity, TempSensorEntity, \
+    CyclesSensorEntity
+
+class StreamAC(BaseDevice):
+    def sensors(self, client: EcoflowApiClient) -> list[BaseSensorEntity]:
+        return [
+
+            WattsSensorEntity(client, self, "sysGridConnectionPower", const.STREAM_POWER_AC_SYS),
+            WattsSensorEntity(client, self, "powGetSysLoad", const.STREAM_GET_SYS_LOAD),
+            WattsSensorEntity(client, self, "powGetSysLoadFromGrid", const.STREAM_GET_SYS_LOAD_FROM_GRID),
+            WattsSensorEntity(client, self, "powGetSchuko1", const.STREAM_GET_SCHUKO1, False),
+            WattsSensorEntity(client, self, "powGetSchuko2", const.STREAM_GET_SCHUKO2, False),
+            WattsSensorEntity(client, self, "gridConnectionPower", const.STREAM_POWER_AC),
+            WattsSensorEntity(client, self, "powGetSysGrid", const.STREAM_POWER_GRID),
+            WattsSensorEntity(client, self, "powGetPvSum", const.STREAM_POWER_PV),
+            WattsSensorEntity(client, self, "powGetBpCms", const.STREAM_POWER_BATTERY),
+            LevelSensorEntity(client, self, "f32ShowSoc", const.STREAM_POWER_BATTERY_SOC),
+            LevelSensorEntity(client, self, "soc", const.STREAM_POWER_BATTERY)
+            .attr("designCap", const.ATTR_DESIGN_CAPACITY, 0)
+            .attr("fullCap", const.ATTR_FULL_CAPACITY, 0)
+            .attr("remainCap", const.ATTR_REMAIN_CAPACITY, 0),
+            CapacitySensorEntity(client, self, "designCap", const.STREAM_DESIGN_CAPACITY,False),
+            CapacitySensorEntity(client, self, "fullCap", const.STREAM_FULL_CAPACITY, False),
+            CapacitySensorEntity(client, self, "remainCap", const.STREAM_REMAIN_CAPACITY,False),
+
+            MilliVoltSensorEntity(client, self, "vol", const.BATTERY_VOLT, False)
+            .attr("minCellVol", const.ATTR_MIN_CELL_VOLT, 0)
+            .attr("maxCellVol", const.ATTR_MAX_CELL_VOLT, 0),
+            MilliVoltSensorEntity(client, self, "minCellVol", const.MIN_CELL_VOLT, False),
+            MilliVoltSensorEntity(client, self, "maxCellVol", const.MAX_CELL_VOLT, False),
+            LevelSensorEntity(client, self, "soh", const.SOH),
+
+            TempSensorEntity(client, self, "temp", const.BATTERY_TEMP)
+            .attr("minCellTemp", const.ATTR_MIN_CELL_TEMP, 0)
+            .attr("maxCellTemp", const.ATTR_MAX_CELL_TEMP, 0),
+            TempSensorEntity(client, self, "minCellTemp", const.MIN_CELL_TEMP, False),
+            TempSensorEntity(client, self, "maxCellTemp", const.MAX_CELL_TEMP, False),
+
+            CyclesSensorEntity(client, self, "cycles", const.CYCLES),
+
+            InWattsSensorEntity(client, self, "inputWatts", const.STREAM_IN_POWER),
+            OutWattsSensorEntity(client, self, "outputWatts", const.STREAM_OUT_POWER),
+
+            RemainSensorEntity(client, self, "remainTime", const.REMAINING_TIME),
+        ]
+    # moduleWifiRssi
+    def numbers(self, client: EcoflowApiClient) -> list[BaseNumberEntity]:
+        return []
+
+    def switches(self, client: EcoflowApiClient) -> list[BaseSwitchEntity]:
+        return []
+
+    def selects(self, client: EcoflowApiClient) -> list[BaseSelectEntity]:
+        return []

custom_components/ecoflow_cloud/devices/public/data_bridge.py

@@ -1,3 +1,7 @@
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
 plain_to_status: dict[str, str] = {
     "pd": "pdStatus",
     "mppt": "mpptStatus",
@@ -13,42 +17,39 @@
 
 
 def to_plain(raw_data: dict[str, any]) -> dict[str, any]:
+    new_params = {}
+    prefix = ""
     if "typeCode" in raw_data:
-        prefix = status_to_plain.get(
+        prefix1 = status_to_plain.get(
             raw_data["typeCode"], "unknown_" + raw_data["typeCode"]
         )
-        new_params = {}
-        if "params" in raw_data:
-            for k, v in raw_data["params"].items():
-                new_params[f"{prefix}.{k}"] = v
-        if "param" in raw_data:
-            for k, v in raw_data["param"].items():
-                new_params[f"{prefix}.{k}"] = v
-
-        result = {"params": new_params}
-        for k, v in raw_data.items():
-            if k != "param" and k != "params":
-                result[k] = v
-
-        return result
-    else:
-        if "cmdFunc" in raw_data and "cmdId" in raw_data:
-            new_params = {}
-            prefix = f"{raw_data['cmdFunc']}_{raw_data['cmdId']}"
-
-            if "param" in raw_data:
-                for k, v in raw_data["param"].items():
-                    new_params[f"{prefix}.{k}"] = v
-
-            if "params" in raw_data:
-                for k, v in raw_data["params"].items():
-                    new_params[f"{prefix}.{k}"] = v
-
-            result = {"params": new_params}
-            for k, v in raw_data.items():
-                if k != "param" and k != "params":
-                    result[k] = v
-
-            return result
-
-        return raw_data
+        prefix += f"{prefix1}."
+    elif "cmdFunc" in raw_data and "cmdId" in raw_data:
+        prefix += f"{raw_data['cmdFunc']}_{raw_data['cmdId']}."
+    else :
+        prefix += ""
+
+    if "param" in raw_data:
+        for k, v in raw_data["param"].items():
+            new_params[f"{prefix}{k}"] = v
+
+    if "params" in raw_data:
+        for k, v in raw_data["params"].items():
+            new_params[f"{prefix}{k}"] = v
+
+    for k, v in raw_data.items():
+        if k != "param" and k != "params":
+            new_params[f"{prefix}{k}"] = v
+
+    new_params2 = {}
+    for k, v in new_params.items():
+        new_params2[k] = v
+        if isinstance(v, dict):
+            for k2, v2 in v.items():
+                new_params2[f"{k}.{k2}"] = v2
+
+    result = {"params": new_params2}
+    _LOGGER.debug(str(result))
+
+    return result
+

custom_components/ecoflow_cloud/devices/public/smart_meter.py

@@ -0,0 +1,17 @@
+from ...api import EcoflowApiClient
+from ...sensor import StatusSensorEntity
+from ..internal.smart_meter import SmartMeter as InternalSmartMeter
+from .data_bridge import to_plain
+
+
+class SmartMeter(InternalSmartMeter):
+
+    def _prepare_data(self, raw_data) -> dict[str, any]:
+        res = super()._prepare_data(raw_data)
+        res = to_plain(res)
+        return res
+
+    def _status_sensor(self, client: EcoflowApiClient) -> StatusSensorEntity:
+        return StatusSensorEntity(client, self)
+
+

custom_components/ecoflow_cloud/devices/public/stream_ac.py

@@ -0,0 +1,17 @@
+from ...api import EcoflowApiClient
+from ...sensor import StatusSensorEntity
+from ..internal.stream_ac import StreamAC as InternalStreamAC
+from .data_bridge import to_plain
+
+
+class StreamAC(InternalStreamAC):
+
+    def _prepare_data(self, raw_data) -> dict[str, any]:
+        res = super()._prepare_data(raw_data)
+        res = to_plain(res)
+        return res
+
+    def _status_sensor(self, client: EcoflowApiClient) -> StatusSensorEntity:
+        return StatusSensorEntity(client, self)
+
+