Improve active operation mode

Author: LeeNuss

custom_components/econext/const.py

@@ -92,14 +92,25 @@ def decode_current_season(raw: float | int) -> str | None:
         return "winter"
     return None
 
-# Current active mode - API parameter 495 HeatingOrCooling (read-only)
-ACTIVE_MODE_MAPPING: dict[int, str] = {
-    0: "standby",
-    3: "cooling",
-    4: "heating",
-}
-
-ACTIVE_MODE_OPTIONS: list[str] = list(ACTIVE_MODE_MAPPING.values())
+# Current active mode - API parameter 495 HeatingOrCooling (read-only).
+# This is a bitfield, not a flat enum:
+#   bit 0 (1) = summer season    bit 1 (2) = cooling active    bit 2 (4) = heating active
+# Observed: 0 winter-idle, 1 summer-idle, 3 summer-cooling, 4 winter-heating, 5 summer-heating.
+# The heating bit does not say whether the heat goes to the tank or the radiators,
+# so the flap valve (param 83: 0 = CH, 3 = DHW) is used to flag DHW production.
+ACTIVE_MODE_OPTIONS: list[str] = ["standby", "cooling", "heating", "dhw"]
+
+
+def decode_active_mode(mode_raw: float | int, flap_raw: float | int | None) -> str:
+    """Decode HeatingOrCooling (495) + flapValveStates (83) into a mode."""
+    mode = int(mode_raw)
+    if mode & 0x4:  # heating bit
+        if flap_raw is not None and int(flap_raw) == 3:  # flap routed to DHW
+            return "dhw"
+        return "heating"
+    if mode & 0x2:  # cooling bit
+        return "cooling"
+    return "standby"
 
 # Active preset mode - for circuits in schedule mode (read-only, computed)
 ACTIVE_PRESET_MODE_OPTIONS: list[str] = ["eco", "comfort"]
@@ -383,7 +394,6 @@ class EconextButtonEntityDescription:
         entity_category=EntityCategory.DIAGNOSTIC,
         icon="mdi:sun-snowflake",
         options=ACTIVE_MODE_OPTIONS,
-        value_map=ACTIVE_MODE_MAPPING,
     ),
     # Decoded from workState2 (param 162); reflects the controller's current
     # season disposition even when the heat pump is idle - what the panel icon shows.

custom_components/econext/sensor.py

@@ -22,6 +22,7 @@
     HEATPUMP_SCHEDULE_DIAGNOSTIC_SENSORS,
     HEATPUMP_SENSORS,
     SILENT_MODE_SCHEDULE_DIAGNOSTIC_SENSORS,
+    decode_active_mode,
     get_alarm_name,
 )
 from .coordinator import EconextCoordinator
@@ -87,7 +88,10 @@ async def async_setup_entry(
     for description in CONTROLLER_SENSORS:
         # Only add if parameter exists in data
         if coordinator.get_param(description.param_id) is not None:
-            entities.append(EconextSensor(coordinator, description))
+            if description.key == "active_operating_mode":
+                entities.append(EconextActiveOperatingModeSensor(coordinator, description))
+            else:
+                entities.append(EconextSensor(coordinator, description))
         else:
             _LOGGER.debug(
                 "Skipping sensor %s - parameter %s not found",
@@ -372,6 +376,26 @@ def _is_value_valid(self) -> bool:
         return True
 
 
+class EconextActiveOperatingModeSensor(EconextSensor):
+    """active_operating_mode: decodes the HeatingOrCooling (495) bitfield.
+
+    Uses the flap valve position (param 83: 3 = DHW) to distinguish DHW from
+    space heating.
+    """
+
+    _FLAP_VALVE_PARAM = "83"
+
+    @property
+    def native_value(self) -> str | None:
+        """Return the decoded operating mode."""
+        value = self._get_param_value()
+        if value is None:
+            return None
+        flap_param = self.coordinator.get_param(self._FLAP_VALVE_PARAM)
+        flap_raw = flap_param.get("value") if flap_param else None
+        return decode_active_mode(value, flap_raw)
+
+
 class EconextScheduleDiagnosticSensor(EconextSensor):
     """Sensor that decodes schedule bitfields into human-readable format.
 

custom_components/econext/strings.json

@@ -118,9 +118,10 @@
             "active_operating_mode": {
                 "name": "Active operating mode",
                 "state": {
-                    "summer": "Summer",
-                    "winter": "Winter",
-                    "auto": "Auto",
+                    "standby": "Standby",
+                    "cooling": "Cooling",
+                    "heating": "Heating",
+                    "dhw": "Domestic Hot Water",
                     "unknown": "Unknown"
                 }
             },

custom_components/econext/translations/en.json

@@ -118,9 +118,10 @@
             "active_operating_mode": {
                 "name": "Active operating mode",
                 "state": {
-                    "summer": "Summer",
-                    "winter": "Winter",
-                    "auto": "Auto",
+                    "standby": "Standby",
+                    "cooling": "Cooling",
+                    "heating": "Heating",
+                    "dhw": "Domestic Hot Water",
                     "unknown": "Unknown"
                 }
             },

tests/test_sensor.py

@@ -237,60 +237,53 @@ def test_flap_valve_enum_value(self, coordinator: EconextCoordinator) -> None:
         assert sensor.native_value == "ch"
         assert sensor._attr_options == ["ch", "dhw", "unknown"]
 
-    def test_active_operating_mode_handles_value_4(self, coordinator: EconextCoordinator) -> None:
-        """Test active_operating_mode enum handles value 4 (heating)."""
-        from custom_components.econext.const import ACTIVE_MODE_MAPPING, ACTIVE_MODE_OPTIONS
+    def _active_mode_sensor(self, coordinator: EconextCoordinator, mode: int, flap: int):
+        """Build an active_operating_mode sensor with param 495 and flap valve 83 set."""
+        from custom_components.econext.const import ACTIVE_MODE_OPTIONS
+        from custom_components.econext.sensor import EconextActiveOperatingModeSensor
 
-        coordinator.data["495"]["value"] = 4
+        coordinator.data["495"]["value"] = mode
+        coordinator.data["83"] = {"value": flap, "name": "flapValveStates", "info": 23}
 
         description = EconextSensorEntityDescription(
             key="active_operating_mode",
             param_id="495",
             device_class=SensorDeviceClass.ENUM,
             options=ACTIVE_MODE_OPTIONS,
-            value_map=ACTIVE_MODE_MAPPING,
         )
+        return EconextActiveOperatingModeSensor(coordinator, description)
 
-        sensor = EconextSensor(coordinator, description)
-
+    def test_active_operating_mode_winter_heating(self, coordinator: EconextCoordinator) -> None:
+        """Value 4 (winter + heating bit), flap on CH -> heating."""
+        sensor = self._active_mode_sensor(coordinator, mode=4, flap=0)
         assert sensor.native_value == "heating"
         assert "heating" in sensor._attr_options
 
-    def test_active_operating_mode_standby(self, coordinator: EconextCoordinator) -> None:
-        """Test active_operating_mode enum returns standby for value 0."""
-        from custom_components.econext.const import ACTIVE_MODE_MAPPING, ACTIVE_MODE_OPTIONS
-
-        coordinator.data["495"]["value"] = 0
-
-        description = EconextSensorEntityDescription(
-            key="active_operating_mode",
-            param_id="495",
-            device_class=SensorDeviceClass.ENUM,
-            options=ACTIVE_MODE_OPTIONS,
-            value_map=ACTIVE_MODE_MAPPING,
-        )
-
-        sensor = EconextSensor(coordinator, description)
+    def test_active_operating_mode_winter_idle_standby(self, coordinator: EconextCoordinator) -> None:
+        """Value 0 (winter idle, no bits) -> standby."""
+        sensor = self._active_mode_sensor(coordinator, mode=0, flap=0)
+        assert sensor.native_value == "standby"
 
+    def test_active_operating_mode_summer_idle_standby(self, coordinator: EconextCoordinator) -> None:
+        """Value 1 (summer season bit only, HP idle) -> standby."""
+        sensor = self._active_mode_sensor(coordinator, mode=1, flap=0)
         assert sensor.native_value == "standby"
 
     def test_active_operating_mode_cooling(self, coordinator: EconextCoordinator) -> None:
-        """Test active_operating_mode enum returns cooling for value 3."""
-        from custom_components.econext.const import ACTIVE_MODE_MAPPING, ACTIVE_MODE_OPTIONS
-
-        coordinator.data["495"]["value"] = 3
-
-        description = EconextSensorEntityDescription(
-            key="active_operating_mode",
-            param_id="495",
-            device_class=SensorDeviceClass.ENUM,
-            options=ACTIVE_MODE_OPTIONS,
-            value_map=ACTIVE_MODE_MAPPING,
-        )
+        """Value 3 (summer + cooling bit) -> cooling."""
+        sensor = self._active_mode_sensor(coordinator, mode=3, flap=0)
+        assert sensor.native_value == "cooling"
 
-        sensor = EconextSensor(coordinator, description)
+    def test_active_operating_mode_dhw(self, coordinator: EconextCoordinator) -> None:
+        """Value 5 (heating bit) with flap routed to DHW -> dhw."""
+        sensor = self._active_mode_sensor(coordinator, mode=5, flap=3)
+        assert sensor.native_value == "dhw"
+        assert "dhw" in sensor._attr_options
 
-        assert sensor.native_value == "cooling"
+    def test_active_operating_mode_heating_flap_on_ch(self, coordinator: EconextCoordinator) -> None:
+        """Heating bit set but flap on CH -> heating, not dhw."""
+        sensor = self._active_mode_sensor(coordinator, mode=5, flap=0)
+        assert sensor.native_value == "heating"
 
     def test_enum_sensor_unmapped_value_returns_unknown(self, coordinator: EconextCoordinator) -> None:
         """Test enum sensor returns 'unknown' for unmapped values (e.g., 65336)."""
@@ -410,16 +403,16 @@ def test_decode_current_season_helper(self) -> None:
 
     def test_enum_sensor_unmapped_value_logs_warning(self, coordinator: EconextCoordinator, caplog: pytest.LogCaptureFixture) -> None:
         """Test enum sensor logs a warning with the raw value for unmapped values."""
-        from custom_components.econext.const import ACTIVE_MODE_MAPPING, ACTIVE_MODE_OPTIONS
+        from custom_components.econext.const import HP_STATUS_WORK_MODE_MAPPING, HP_STATUS_WORK_MODE_OPTIONS
 
-        coordinator.data["495"]["value"] = 99
+        coordinator.data["1350"] = {"value": 99, "name": "HPStatusWorkMode", "info": 23}
 
         description = EconextSensorEntityDescription(
-            key="active_operating_mode",
-            param_id="495",
+            key="hp_status_work_mode",
+            param_id="1350",
             device_class=SensorDeviceClass.ENUM,
-            options=ACTIVE_MODE_OPTIONS,
-            value_map=ACTIVE_MODE_MAPPING,
+            options=HP_STATUS_WORK_MODE_OPTIONS,
+            value_map=HP_STATUS_WORK_MODE_MAPPING,
         )
 
         sensor = EconextSensor(coordinator, description)
@@ -429,7 +422,7 @@ def test_enum_sensor_unmapped_value_logs_warning(self, coordinator: EconextCoord
 
         assert result == "unknown"
         assert "Unmapped value 99" in caplog.text
-        assert "active_operating_mode" in caplog.text
+        assert "hp_status_work_mode" in caplog.text
 
 
 class TestSensorEntityCategory: