Expose air purifying mode

Author: aitjcize

custom_components/medole/humidifier.py

@@ -18,8 +18,6 @@
     CONTINUOUS_DEHUMIDIFICATION,
     DOMAIN,
     FAN_SPEED_HIGH,
-    FAN_SPEED_LOW,
-    FAN_SPEED_MEDIUM,
     MAX_HUMIDITY,
     MIN_HUMIDITY,
     REG_DEHUMIDIFY_MODE,
@@ -40,14 +38,10 @@
 # Polling interval
 SCAN_INTERVAL = timedelta(seconds=5)
 
-# Fan speed mapping for modes
-MODES = {
-    FAN_SPEED_LOW: "Low",
-    FAN_SPEED_MEDIUM: "Medium",
-    FAN_SPEED_HIGH: "High",
-}
-
-REVERSE_MODES = {v: k for k, v in MODES.items()}
+# Preset modes
+PRESET_MODE_DEHUMIDIFY = "Dehumidify"
+PRESET_MODE_AIR_PURIFICATION = "Air Purification"
+PRESET_MODES = [PRESET_MODE_DEHUMIDIFY, PRESET_MODE_AIR_PURIFICATION]
 
 
 async def async_setup_entry(
@@ -75,7 +69,7 @@ class MedoleDehumidifierHumidifier(HumidifierEntity):
     _attr_name = None
     _attr_supported_features = HumidifierEntityFeature.MODES
     _attr_device_class = HumidifierDeviceClass.DEHUMIDIFIER
-    _attr_available_modes = list(REVERSE_MODES.keys())
+    _attr_available_modes = PRESET_MODES
     _attr_min_humidity = MIN_HUMIDITY
     _attr_max_humidity = MAX_HUMIDITY
 
@@ -97,6 +91,7 @@ def __init__(self, hass, name, client):
         self._attr_mode = None
         self._attr_is_on = False
         self._attr_action = None
+        self._current_preset = PRESET_MODE_DEHUMIDIFY
 
     @property
     def current_humidity(self):
@@ -166,14 +161,27 @@ async def async_update(self) -> None:
         else:
             _LOGGER.error("Failed to read humidity setpoint")
 
-        # Get the fan speed
-        fan_speed_result = await self._client.async_read_register(REG_FAN_SPEED)
-
-        if fan_speed_result:
-            fan_speed = fan_speed_result.registers[0]
-            self._attr_mode = MODES.get(fan_speed, "Medium")
-        else:
-            _LOGGER.error("Failed to read fan speed")
+        # Check which mode is active (dehumidify or air purification)
+        dehumidify_result = await self._client.async_read_register(
+            REG_DEHUMIDIFY_MODE
+        )
+        purify_result = await self._client.async_read_register(REG_PURIFY_MODE)
+
+        if dehumidify_result and purify_result:
+            dehumidify_on = dehumidify_result.registers[0] == 1
+            purify_on = purify_result.registers[0] == 1
+
+            # Prioritize showing dehumidify mode when both are active
+            if dehumidify_on:
+                self._current_preset = PRESET_MODE_DEHUMIDIFY
+                self._attr_mode = PRESET_MODE_DEHUMIDIFY
+            elif purify_on:
+                self._current_preset = PRESET_MODE_AIR_PURIFICATION
+                self._attr_mode = PRESET_MODE_AIR_PURIFICATION
+            else:
+                # Neither mode is active
+                self._current_preset = PRESET_MODE_DEHUMIDIFY
+                self._attr_mode = PRESET_MODE_DEHUMIDIFY
 
         # Get the current humidity
         humidity_result = await self._client.async_read_register(REG_HUMIDITY_1)
@@ -185,16 +193,36 @@ async def async_update(self) -> None:
 
     async def async_set_mode(self, mode: str) -> None:
         """Set new mode."""
-        fan_speed = REVERSE_MODES.get(mode, FAN_SPEED_MEDIUM)
-
-        success = await self._client.async_write_register(
-            REG_FAN_SPEED, fan_speed
-        )
-
-        if success:
-            self._attr_mode = mode
-        else:
-            _LOGGER.error("Failed to set mode to %s", mode)
+        if mode == PRESET_MODE_AIR_PURIFICATION:
+            # Switch to air purification mode with high fan speed
+            await self._client.async_write_register(
+                REG_FAN_SPEED, FAN_SPEED_HIGH
+            )
+            await self._client.async_write_register(REG_DEHUMIDIFY_MODE, 0)
+            success = await self._client.async_write_register(
+                REG_PURIFY_MODE, 1
+            )
+            if success:
+                self._current_preset = PRESET_MODE_AIR_PURIFICATION
+                self._attr_mode = mode
+                _LOGGER.info("Switched to air purification mode")
+            else:
+                _LOGGER.error("Failed to set air purification mode")
+        elif mode == PRESET_MODE_DEHUMIDIFY:
+            # Switch to dehumidify mode with high fan speed
+            await self._client.async_write_register(
+                REG_FAN_SPEED, FAN_SPEED_HIGH
+            )
+            await self._client.async_write_register(REG_PURIFY_MODE, 1)
+            success = await self._client.async_write_register(
+                REG_DEHUMIDIFY_MODE, 1
+            )
+            if success:
+                self._current_preset = PRESET_MODE_DEHUMIDIFY
+                self._attr_mode = mode
+                _LOGGER.info("Switched to dehumidify mode")
+            else:
+                _LOGGER.error("Failed to set dehumidify mode")
 
     async def async_set_humidity(self, humidity: int) -> None:
         """Set new target humidity."""
@@ -212,6 +240,9 @@ async def async_set_humidity(self, humidity: int) -> None:
 
     async def async_turn_on(self, **kwargs) -> None:
         """Turn the device on."""
+        # Set fan speed to high
+        await self._client.async_write_register(REG_FAN_SPEED, FAN_SPEED_HIGH)
+
         # Set the power on
         result = await self._client.async_write_register(REG_POWER, 1)
         if not result:

custom_components/medole/sensor.py

@@ -20,12 +20,14 @@
 from .const import (
     CONF_NAME,
     DOMAIN,
+    REG_DEHUMIDIFY_MODE,
     REG_FAN_ALARM_HOURS,
     REG_FAN_OPERATION_HOURS,
     REG_HUMIDITY_1,
     REG_HUMIDITY_2,
     REG_OPERATION_STATUS,
     REG_PIPE_TEMPERATURE,
+    REG_PURIFY_MODE,
     REG_TEMPERATURE_1,
     REG_TEMPERATURE_2,
     STATUS_COMPRESSOR_ON,
@@ -215,6 +217,8 @@ def __init__(self, hass, name, client):
         super().__init__(hass, name, client, "status")
         self._attr_name = "Status"
         self._status_value = None
+        self._dehumidify_mode = None
+        self._purify_mode = None
 
     @property
     def extra_state_attributes(self):
@@ -228,6 +232,8 @@ def extra_state_attributes(self):
         return {
             "compressor_on": bool(lo_byte & STATUS_COMPRESSOR_ON),
             "fan_on": bool(lo_byte & STATUS_FAN_ON),
+            "dehumidify_mode": bool(self._dehumidify_mode),
+            "air_purification_mode": bool(self._purify_mode),
             "pipe_temp_error": bool(lo_byte & STATUS_PIPE_TEMP_ERROR),
             "humidity_sensor_error": bool(
                 lo_byte & STATUS_HUMIDITY_SENSOR_ERROR
@@ -249,6 +255,19 @@ async def async_update(self) -> None:
         if result:
             self._status_value = result.registers[0]
 
+            # Read mode registers
+            dehumidify_result = await self._client.async_read_register(
+                REG_DEHUMIDIFY_MODE
+            )
+            purify_result = await self._client.async_read_register(
+                REG_PURIFY_MODE
+            )
+
+            if dehumidify_result:
+                self._dehumidify_mode = dehumidify_result.registers[0] == 1
+            if purify_result:
+                self._purify_mode = purify_result.registers[0] == 1
+
             # Set the state based on errors
             errors = []
             lo_byte = self._status_value & 0xFF
@@ -272,9 +291,15 @@ async def async_update(self) -> None:
             elif lo_byte & STATUS_COMPRESSOR_ON:
                 self._attr_native_value = "Dehumidifying"
             elif lo_byte & STATUS_FAN_ON:
-                self._attr_native_value = "Fan Only"
+                # Fan running - check mode
+                if self._purify_mode and not self._dehumidify_mode:
+                    self._attr_native_value = "Air Purification"
+                else:
+                    self._attr_native_value = "Fan Only"
             else:
                 self._attr_native_value = "Idle"
         else:
             self._attr_native_value = "Communication Error"
             self._status_value = None
+            self._dehumidify_mode = None
+            self._purify_mode = None