feat: add power-reset turn_off for E-heater assist and fix sterilize profile mapping

Author: tazomatalax

custom_components/midea_heatpump_hws/binary_sensor.py

@@ -22,7 +22,8 @@
 _LOGGER = logging.getLogger(__name__)
 
 # Register 109 values that indicate an active sanitize cycle
-_SANITIZE_ACTIVE_VALUES = {32, 33}
+_SANITIZE_ACTIVE_VALUES = {32}
+_SANITIZE_SCHEDULED_VALUES = {33}
 
 
 async def async_setup_entry(
@@ -43,15 +44,19 @@ async def async_setup_entry(
                 coordinator=coordinator,
                 config=config,
                 data_key="heater_assist_raw",
-                name=f"Heater Assist{host_suffix}",
+                name=f"Electric Booster Active{host_suffix}",
                 register=config[CONF_HEATER_ASSIST_REGISTER],
                 device_class=BinarySensorDeviceClass.RUNNING,
-                is_on_fn=lambda v: v != 0,
+                # R108 bit 3 (value 8) is set when the electric element relay is energised.
+                # Values 0 and 2 represent idle/standby states; 13 = compressor+fan+element
+                # running together in Hybrid. Using & 8 cleanly isolates the element state.
+                is_on_fn=lambda v: bool(v & 8),
+                unique_id_suffix="heater_assist_raw",
             )
         )
 
     if config.get(CONF_SANITIZE_STATE_REGISTER) is not None:
-        entities.append(
+        entities.extend([
             MideaBinarySensor(
                 coordinator=coordinator,
                 config=config,
@@ -60,8 +65,19 @@ async def async_setup_entry(
                 register=config[CONF_SANITIZE_STATE_REGISTER],
                 device_class=BinarySensorDeviceClass.RUNNING,
                 is_on_fn=lambda v: v in _SANITIZE_ACTIVE_VALUES,
+                unique_id_suffix="sanitize_state_raw",
+            ),
+            MideaBinarySensor(
+                coordinator=coordinator,
+                config=config,
+                data_key="sanitize_state_raw",
+                name=f"Sanitize Cycle Scheduled{host_suffix}",
+                register=config[CONF_SANITIZE_STATE_REGISTER],
+                device_class=BinarySensorDeviceClass.RUNNING,
+                is_on_fn=lambda v: v in _SANITIZE_SCHEDULED_VALUES,
+                unique_id_suffix="sanitize_scheduled",
             )
-        )
+        ])
 
     async_add_entities(entities)
 
@@ -78,6 +94,7 @@ def __init__(
         register: int,
         device_class: BinarySensorDeviceClass,
         is_on_fn,
+        unique_id_suffix: str | None = None,
     ) -> None:
         """Initialize the binary sensor."""
         super().__init__(coordinator)
@@ -87,7 +104,8 @@ def __init__(
         self._is_on_fn = is_on_fn
 
         self._attr_name = name
-        self._attr_unique_id = f"midea_{config['host']}_{config[CONF_MODBUS_UNIT]}_{data_key}"
+        suffix = unique_id_suffix or data_key
+        self._attr_unique_id = f"midea_{config['host']}_{config[CONF_MODBUS_UNIT]}_{suffix}"
         self._attr_device_class = device_class
 
     @property

custom_components/midea_heatpump_hws/const.py

@@ -73,4 +73,5 @@
 CONF_SUCTION_TEMP_REGISTER = "suction_temp_register"
 CONF_ENABLE_ADDITIONAL_SENSORS = "enable_additional_sensors"
 CONF_HEATER_ASSIST_REGISTER = "heater_assist_register"
-CONF_SANITIZE_STATE_REGISTER = "sanitize_state_register"
+CONF_SANITIZE_STATE_REGISTER = "sanitize_state_register"
+CONF_HEATER_ASSIST_TRIGGER_REGISTER = "heater_assist_trigger_register"

custom_components/midea_heatpump_hws/coordinator.py

@@ -37,6 +37,7 @@
     CONF_SUCTION_TEMP_REGISTER,
     CONF_HEATER_ASSIST_REGISTER,
     CONF_SANITIZE_STATE_REGISTER,
+    CONF_HEATER_ASSIST_TRIGGER_REGISTER,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -106,6 +107,7 @@ def __init__(
         # Diagnostic state registers (raw integer, no scaling)
         self.heater_assist_register = config.get(CONF_HEATER_ASSIST_REGISTER)
         self.sanitize_state_register = config.get(CONF_SANITIZE_STATE_REGISTER)
+        self.heater_assist_trigger_register = config.get(CONF_HEATER_ASSIST_TRIGGER_REGISTER)
 
         self._client: AsyncModbusTcpClient | None = None
         self._lock = asyncio.Lock()
@@ -261,6 +263,7 @@ async def _async_update_data(self) -> dict[str, Any]:
                 for reg_name, register in [
                     ("heater_assist_raw", self.heater_assist_register),
                     ("sanitize_state_raw", self.sanitize_state_register),
+                    ("heater_assist_trigger_raw", self.heater_assist_trigger_register),
                 ]:
                     if register is None:
                         continue
@@ -390,6 +393,18 @@ async def _process_pending_writes(self) -> None:
                             else:
                                 _LOGGER.debug("Successfully wrote sterilize mode = %s", params)
 
+                    elif operation == "heater_assist_trigger":
+                        if self.heater_assist_trigger_register is not None:
+                            result = await self._client.write_register(
+                                address=self.heater_assist_trigger_register,
+                                value=params,
+                                device_id=self.modbus_unit
+                            )
+                            if result.isError():
+                                _LOGGER.error("Failed to write heater assist trigger: %s", result)
+                            else:
+                                _LOGGER.debug("Successfully wrote heater assist trigger = %s", params)
+
                     elif operation == "operation_mode":
                         # Handle water heater operation mode changes (now lowercase!)
                         if params == "off":  # lowercase!
@@ -488,6 +503,17 @@ async def write_register(self, operation: str, value: Any) -> bool:
                             self.data["sterilize_mode"] = bool(result.registers[0])
                             _LOGGER.debug("Read back sterilize mode: %s", self.data["sterilize_mode"])
 
+                elif operation == "heater_assist_trigger":
+                    if self.heater_assist_trigger_register is not None:
+                        result = await self._client.read_holding_registers(
+                            address=self.heater_assist_trigger_register,
+                            count=1,
+                            device_id=self.modbus_unit
+                        )
+                        if not result.isError() and result.registers:
+                            self.data["heater_assist_trigger_raw"] = result.registers[0]
+                            _LOGGER.debug("Read back heater assist trigger: %s", self.data["heater_assist_trigger_raw"])
+
                 elif operation == "operation_mode":
                     # After setting operation mode, read both power and mode
                     power_result = await self._client.read_holding_registers(

custom_components/midea_heatpump_hws/models/defaults/ecospring_hp300.json

@@ -26,7 +26,8 @@
     "exhaust_temp": 105,
     "suction_temp": 106,
     "heater_assist_register": 108,
-    "sanitize_state_register": 109
+    "sanitize_state_register": 109,
+    "heater_assist_trigger_register": 4
   },
 
   "mode_values": {

custom_components/midea_heatpump_hws/profile_manager.py

@@ -109,6 +109,7 @@ def save_profile(self, name: str, config: dict[str, Any], model: str = "Custom")
                 "suction_temp": config.get("suction_temp_register", 106),
                 **({} if config.get("heater_assist_register") is None else {"heater_assist_register": config["heater_assist_register"]}),
                 **({} if config.get("sanitize_state_register") is None else {"sanitize_state_register": config["sanitize_state_register"]}),
+                **({} if config.get("heater_assist_trigger_register") is None else {"heater_assist_trigger_register": config["heater_assist_trigger_register"]}),
             },
 
             "mode_values": {
@@ -235,6 +236,7 @@ def apply_profile_to_config(self, profile_data: dict[str, Any], user_input: dict
         config["mode_register"] = registers.get("mode", 1)
         config["temp_register"] = registers.get("current_temp", 102)
         config["target_temp_register"] = registers.get("target_temp", 2)
+        config["sterilize_register"] = registers.get("sterilize", 3)
         config["tank_top_temp_register"] = registers.get("tank_top_temp", 101)
         config["tank_bottom_temp_register"] = registers.get("tank_bottom_temp", 102)
         config["condensor_temp_register"] = registers.get("condensor_temp", 103)
@@ -246,6 +248,8 @@ def apply_profile_to_config(self, profile_data: dict[str, Any], user_input: dict
             config["heater_assist_register"] = registers["heater_assist_register"]
         if "sanitize_state_register" in registers:
             config["sanitize_state_register"] = registers["sanitize_state_register"]
+        if "heater_assist_trigger_register" in registers:
+            config["heater_assist_trigger_register"] = registers["heater_assist_trigger_register"]
 
         # Apply mode values
         mode_values = profile_data.get("mode_values", {})

custom_components/midea_heatpump_hws/switch.py

@@ -8,7 +8,7 @@
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, CONF_MODBUS_UNIT
+from .const import DOMAIN, CONF_MODBUS_UNIT, CONF_HEATER_ASSIST_TRIGGER_REGISTER
 from .coordinator import MideaModbusCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -30,9 +30,17 @@ async def async_setup_entry(
     entities = [MideaPowerSwitch(coordinator, config, host_suffix)]
 
     # Add sterilize switch if register is configured
-    if config.get("sterilize_register") is not None:
+    if coordinator.sterilize_register is not None:
         entities.append(MideaSterilizeSwitch(coordinator, config, host_suffix))
 
+    # Add manual heater assist switch only if the profile exposes both the write
+    # trigger and the R108 diagnostic register it is functionally paired with.
+    if (
+        coordinator.heater_assist_trigger_register is not None
+        and coordinator.heater_assist_register is not None
+    ):
+        entities.append(MideaHeaterAssistSwitch(coordinator, config, host_suffix))
+
     async_add_entities(entities)
 
 
@@ -141,4 +149,55 @@ async def async_turn_off(self, **kwargs: Any) -> None:
     @callback
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
-        self.async_write_ha_state()
+        self.async_write_ha_state()
+
+
+class MideaHeaterAssistSwitch(CoordinatorEntity, SwitchEntity):
+    """Representation of the manual E-Heater assist trigger switch."""
+
+    def __init__(
+        self,
+        coordinator: MideaModbusCoordinator,
+        config: dict,
+        host_suffix: str
+    ):
+        """Initialize the heater assist switch."""
+        super().__init__(coordinator)
+        self._config = config
+
+        # Entity attributes - include host for uniqueness
+        self._attr_name = f"Manual Heater Assist{host_suffix}"
+        self._attr_unique_id = f"midea_{config['host']}_{config[CONF_MODBUS_UNIT]}_heater_assist_trigger"
+        self._attr_icon = "mdi:fire"
+
+    @property
+    def device_info(self):
+        """Return device info to link this switch to the main device."""
+        return {
+            "identifiers": {(DOMAIN, f"{self._config['host']}_{self._config[CONF_MODBUS_UNIT]}")},
+            "name": f"Midea Heat Pump ({self._config['host']})",
+            "manufacturer": "Midea",
+            "model": "Heat Pump Water Heater",
+        }
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if e-heater is triggered."""
+        if self.coordinator.data:
+            return self.coordinator.data.get("heater_assist_trigger_raw") == 1
+        return False
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return self.coordinator.last_update_success
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Trigger manual heater assist."""
+        await self.coordinator.write_register("heater_assist_trigger", 1)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off E-heater assist by resetting power state to clear R4 trigger."""
+        _LOGGER.info("Resetting power state to turn off manual E-heater assist")
+        await self.coordinator.write_register("power_state", False)
+        await self.coordinator.write_register("power_state", True)