feat(stream): per-PV sensors via firmware-agnostic dual-path mapping

The Stream family firmware >=1.0.1.88 stopped emitting per-PV powGetPv1..4
fields - they now publish plugInInfoPv{1-4}Amp + plugInInfoPv{1-4}Vol instead.

This patch adds a StreamPvWattsSensorEntity helper that:
- Subscribes to plugInInfoPv*Amp keys
- Auto-derives the matching Vol key by suffix replacement
- Computes Watts on-the-fly via Amp x Vol multiplication
- Injects the result under a synthetic mqtt_key (pvWatts_*) to avoid
  unique_id collision with the legitimate AmpSensorEntity subscriber
- Delegates to the parent WattsSensorEntity for auto-enable, attribute
  mapping, and energy() helper integration

Backward-compatible: existing powGetPv* sensors remain (older firmware).
New sensors are auto-enabled only when the new firmware fields appear.

Closes #584

Author: optimusbasti

custom_components/ecoflow_cloud/devices/const.py

@@ -341,8 +341,12 @@
 STREAM_POWER_PV_4 = "Power PV 4"
 STREAM_IN_AMPS_PV_1 = "Power PV1 In Amps"
 STREAM_IN_AMPS_PV_2 = "Power PV2 In Amps"
+STREAM_IN_AMPS_PV_3 = "Power PV3 In Amps"
+STREAM_IN_AMPS_PV_4 = "Power PV4 In Amps"
 STREAM_IN_VOL_PV_1 = "Power PV1 Volts"
 STREAM_IN_VOL_PV_2 = "Power PV2 Volts"
+STREAM_IN_VOL_PV_3 = "Power PV3 Volts"
+STREAM_IN_VOL_PV_4 = "Power PV4 Volts"
 STREAM_POWER_PV_SUM = "Power PV Sum"
 STREAM_GET_SYS_LOAD = "Power Sys Load" # powGetSysLoad
 STREAM_GET_SYS_LOAD_FROM_BP = "Power Sys Load From Battery" # powGetSysLoadFromBp

custom_components/ecoflow_cloud/devices/public/stream_ac.py

@@ -10,6 +10,7 @@
 from custom_components.ecoflow_cloud.devices.public.data_bridge import to_plain
 from custom_components.ecoflow_cloud.number import BatteryBackupLevel
 from custom_components.ecoflow_cloud.sensor import (
+    AmpSensorEntity,
     CapacitySensorEntity,
     CumulativeCapacitySensorEntity,
     CyclesSensorEntity,
@@ -24,6 +25,9 @@
     VoltSensorEntity,
     WattsSensorEntity,
 )
+from custom_components.ecoflow_cloud.devices.public.stream_pv_helpers import (
+    StreamPvWattsSensorEntity,
+)
 from custom_components.ecoflow_cloud.switch import EnabledEntity
 
 
@@ -178,6 +182,22 @@ def sensors(self, client: EcoflowApiClient) -> list[SensorEntity]:
             # "powConsumptionMeasurement": 2,
             # "powGetBpCms": 1915.0862,
             WattsSensorEntity(client, self, "powGetBpCms", const.STREAM_POWER_BATTERY),
+            # Per-PV power, voltage, current (Stream Ultra / Ultra X / AC Pro).
+            # Per-PV reporting depends on the firmware version installed:
+            #   - Firmware <  1.0.1.88: powGetPv / powGetPv2..4 emitted, per-PV
+            #     watts are correct, plugInInfoPv*Amp returns 0.
+            #   - Firmware >= 1.0.1.88: powGetPv* returns 0, per-PV data lives
+            #     in plugInInfoPv{,2,3,4}Amp + plugInInfoPv{,2,3,4}Vol instead.
+            # See issues #582, #584. To stay firmware-agnostic we register BOTH
+            # mapping variants with auto_enable=True. HA enables whichever set
+            # first sees a non-zero value.
+            #
+            # New-firmware path (computed amp x vol via StreamPvWattsSensorEntity)
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPvAmp", const.STREAM_POWER_PV_1, False, True),
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPv2Amp", const.STREAM_POWER_PV_2, False, True),
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPv3Amp", const.STREAM_POWER_PV_3, False, True),
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPv4Amp", const.STREAM_POWER_PV_4, False, True),
+            # Legacy-firmware path (powGetPv* keys)
             # "powGetPv": 0.0,
             WattsSensorEntity(client, self, "powGetPv", const.STREAM_POWER_PV_1, False, True),
             # "powGetPv2": 0.0,
@@ -186,6 +206,15 @@ def sensors(self, client: EcoflowApiClient) -> list[SensorEntity]:
             WattsSensorEntity(client, self, "powGetPv3", const.STREAM_POWER_PV_3, False, True),
             # "powGetPv4": 0.0,
             WattsSensorEntity(client, self, "powGetPv4", const.STREAM_POWER_PV_4, False, True),
+            # Per-PV voltage + current (emitted by all Stream firmware versions)
+            VoltSensorEntity(client, self, "plugInInfoPvVol", const.STREAM_IN_VOL_PV_1, False, True),
+            VoltSensorEntity(client, self, "plugInInfoPv2Vol", const.STREAM_IN_VOL_PV_2, False, True),
+            VoltSensorEntity(client, self, "plugInInfoPv3Vol", const.STREAM_IN_VOL_PV_3, False, True),
+            VoltSensorEntity(client, self, "plugInInfoPv4Vol", const.STREAM_IN_VOL_PV_4, False, True),
+            AmpSensorEntity(client, self, "plugInInfoPvAmp", const.STREAM_IN_AMPS_PV_1, False, True),
+            AmpSensorEntity(client, self, "plugInInfoPv2Amp", const.STREAM_IN_AMPS_PV_2, False, True),
+            AmpSensorEntity(client, self, "plugInInfoPv3Amp", const.STREAM_IN_AMPS_PV_3, False, True),
+            AmpSensorEntity(client, self, "plugInInfoPv4Amp", const.STREAM_IN_AMPS_PV_4, False, True),
             # "powGetPvSum": 2051.3975,
             WattsSensorEntity(client, self, "powGetPvSum", const.STREAM_POWER_PV_SUM),
             # "powGetSchuko1": 0.0,

custom_components/ecoflow_cloud/devices/public/stream_microinverter.py

@@ -16,12 +16,23 @@
     VoltSensorEntity,
     WattsSensorEntity,
 )
+from custom_components.ecoflow_cloud.devices.public.stream_pv_helpers import (
+    StreamPvWattsSensorEntity,
+)
 
 
 class StreamMicroinveter(BaseDevice):
     def sensors(self, client: EcoflowApiClient) -> list[SensorEntity]:
         return [
             WattsSensorEntity(client, self, "gridConnectionPower", const.STREAM_POWER_AC),
+            # Per-PV mapping is firmware-dependent. See stream_ac.py comment
+            # and issues #582/#584. Both variants are registered with
+            # auto_enable=True so the integration stays firmware-agnostic.
+            #
+            # New-firmware path (computed amp x vol via StreamPvWattsSensorEntity)
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPvAmp", const.STREAM_POWER_PV_1, False, True),
+            StreamPvWattsSensorEntity(client, self, "plugInInfoPv2Amp", const.STREAM_POWER_PV_2, False, True),
+            # Legacy-firmware path (powGetPv* keys)
             WattsSensorEntity(client, self, "powGetPv", const.STREAM_POWER_PV_1, False, True),
             WattsSensorEntity(client, self, "powGetPv2", const.STREAM_POWER_PV_2, False, True),
             VoltSensorEntity(client, self, "gridConnectionVol", const.STREAM_POWER_VOL, False),

custom_components/ecoflow_cloud/devices/public/stream_pv_helpers.py

@@ -0,0 +1,85 @@
+"""Per-PV computed watts for the EcoFlow Stream family.
+
+Stream family firmware (Stream Ultra, Stream Ultra X, Stream AC Pro, Stream
+Microinverter) starting from version 1.0.1.88 stopped emitting the legacy
+``powGetPv{N}`` per-PV keys. Instead, per-PV data is now published as
+``plugInInfoPv{N}Amp`` and ``plugInInfoPv{N}Vol``. As a consequence, the
+upstream ``WattsSensorEntity`` mappings against ``powGetPv*`` stay forever
+``unknown`` for devices running the newer firmware.
+
+This module provides a drop-in ``WattsSensorEntity`` subclass that:
+
+1. Computes per-PV watts as ``Amp x Vol`` from the same payload tick.
+2. Uses a synthetic ``mqtt_key`` so its ``unique_id`` cannot collide with
+   an ``AmpSensorEntity`` that legitimately subscribes to the same
+   ``plugInInfoPv{N}Amp`` key for the per-PV current sensor.
+3. Auto-derives the ``vol_key`` from the ``amp_key`` via suffix replacement,
+   so the device file only specifies ``amp_key`` once per PV input - less
+   verbose, harder to typo.
+4. Falls through to the upstream base class for attribute mapping, default
+   value handling, ``with_energy()`` integration helpers, etc., by injecting
+   the computed value back under the synthetic key and delegating
+   ``_updated`` to ``super()``.
+
+Registering both the legacy ``powGetPv*`` entity and this new helper with
+``auto_enable=True`` keeps the integration firmware-agnostic: HA enables
+whichever variant first sees a non-zero value.
+
+References:
+- https://github.com/tolwi/hassio-ecoflow-cloud/issues/584
+- https://github.com/tolwi/hassio-ecoflow-cloud/issues/582
+"""
+from typing import Any
+
+from custom_components.ecoflow_cloud.sensor import WattsSensorEntity
+
+
+class StreamPvWattsSensorEntity(WattsSensorEntity):
+    """Compute per-PV watts as ``amp x vol`` from EcoFlow Stream payloads.
+
+    Example:
+        StreamPvWattsSensorEntity(client, self, "plugInInfoPv2Amp",
+                                  const.STREAM_POWER_PV_2)
+        # subscribes to plugInInfoPv2Amp + plugInInfoPv2Vol, exposes watts
+    """
+
+    # Synthetic key prefix - chosen so it cannot exist as a real EcoFlow
+    # payload field and cannot collide with sibling sensor unique_ids.
+    _SYNTHETIC_KEY_PREFIX = "pvWatts"
+
+    def __init__(
+        self,
+        client,
+        device,
+        amp_key: str,
+        title,
+        enabled: bool = True,
+        auto_enable: bool = False,
+    ) -> None:
+        if not amp_key.endswith("Amp"):
+            raise ValueError(
+                f"StreamPvWattsSensorEntity expects an amp_key ending in 'Amp', "
+                f"got: {amp_key!r}"
+            )
+        self._amp_key = amp_key
+        self._vol_key = amp_key[:-3] + "Vol"  # plugInInfoPv2Amp -> plugInInfoPv2Vol
+        synthetic_key = f"{self._SYNTHETIC_KEY_PREFIX}_{amp_key}"
+        super().__init__(client, device, synthetic_key, title, enabled, auto_enable)
+
+    def _updated(self, data: dict[str, Any]) -> None:  # type: ignore[override]
+        amp = data.get(self._amp_key)
+        vol = data.get(self._vol_key)
+        if amp is None or vol is None:
+            # Let the upstream pipeline handle offline / default-value reset
+            super()._updated(data)
+            return
+        try:
+            watts = float(amp) * float(vol)
+        except (TypeError, ValueError):
+            return
+        # Inject the computed value under our synthetic mqtt_key and let the
+        # upstream _updated() do the rest (auto-enable, attribute mapping,
+        # _update_value, schedule_update_ha_state). We deliberately mutate a
+        # shallow copy to avoid surprising other sensors that read the same
+        # payload dict afterwards.
+        super()._updated({**data, self.mqtt_key: watts})