Fixed a weird bug with manual colour simulation and fixed persistence

Author: MrSleeps

custom_components/juwel_helialux/light.py

@@ -144,12 +144,13 @@ async def async_turn_on(self, **kwargs):
         await self.coordinator.set_manual_override(True, 5)
 
         try:
-            # Set the light state
-            #await self._controller.start_manual_color_simulation(1439)
-            # duration_hours = self.hass.states.get(f"number.{self._attr_unique_id}_manual_color_simulation_duration").state
-            duration_hours = self.coordinator.data.get("manual_color_simulation_duration", 12)
-            duration_minutes = int(float(duration_hours) * 60)
-            _LOGGER.debug("Manual Hours: %s Manual Minutes: %s", duration_hours, duration_minutes)
+            # Get duration from number entity (same approach as in switch.py)
+            duration_entity = f"number.{self._attr_unique_id.split('_light')[0]}_manual_color_simulation_duration"
+            duration_state = self.coordinator.hass.states.get(duration_entity)
+            duration_minutes = int(float(duration_state.state) * 60) if duration_state else 720  # Default to 12 hours if not found
+            
+            _LOGGER.debug("Using manual color simulation duration: %s minutes", duration_minutes)
+            
             # Set the light state with the configured duration
             await self._controller.start_manual_color_simulation(duration_minutes)            
             await self._controller.set_manual_color(white, blue, green, red)
@@ -168,12 +169,20 @@ async def async_turn_on(self, **kwargs):
     async def async_turn_off(self, **kwargs):
         """Turn the light off."""
         _LOGGER.debug("Turning off Juwel Helialux light")
-        duration_hours = self.coordinator.data.get("manual_color_simulation_duration", 12)  # default 12 hours
-        duration_minutes = int(duration_hours * 60)        
-        await self._controller.start_manual_color_simulation(duration_minutes)
-        await self._controller.set_manual_color(0, 0, 0, 0)
-        self._attr_is_on = False
-        self._attr_brightness = 0
-        self._attr_rgbw_color = (0, 0, 0, 0)
-
-        self.async_write_ha_state()
+        try:
+            # Get duration from number entity (same approach as in switch.py)
+            duration_entity = f"number.{self._attr_unique_id.split('_light')[0]}_manual_color_simulation_duration"
+            duration_state = self.coordinator.hass.states.get(duration_entity)
+            duration_minutes = int(float(duration_state.state) * 60) if duration_state else 720  # Default to 12 hours if not found
+            
+            _LOGGER.debug("Using manual color simulation duration: %s minutes", duration_minutes)
+            
+            await self._controller.start_manual_color_simulation(duration_minutes)
+            await self._controller.set_manual_color(0, 0, 0, 0)
+            self._attr_is_on = False
+            self._attr_brightness = 0
+            self._attr_rgbw_color = (0, 0, 0, 0)
+            self.async_write_ha_state()
+        except Exception as e:
+            _LOGGER.error("Error turning off light: %s", e)
+            raise

custom_components/juwel_helialux/manifest.json

@@ -10,5 +10,5 @@
   "issue_tracker": "https://github.com/MrSleeps/Juwel-HeliaLux-Home-Assistant-Custom-Component/issues",
   "platforms": ["sensor", "light", "select", "binary_sensor", "number", "switch"],
   "requirements": ["aiohttp"],
-  "version": "2.0.4"
+  "version": "2.0.5"
 }

custom_components/juwel_helialux/number.py

@@ -1,6 +1,7 @@
 import logging
 from homeassistant.components.number import NumberEntity
 from homeassistant.const import UnitOfTime
+from homeassistant.helpers.storage import Store  # <-- Added for persistence
 from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
@@ -12,8 +13,8 @@ async def async_setup_entry(hass, entry, async_add_entities):
     tank_id = tank_name.lower().replace(" ", "_")
 
     numbers = [
-        HelialuxColorSimulationDuration(coordinator, entry, tank_name, tank_id),
-        HelialuxDaytimeSimulationDuration(coordinator, entry, tank_name, tank_id)
+        HelialuxColorSimulationDuration(hass, coordinator, entry, tank_name, tank_id),
+        HelialuxDaytimeSimulationDuration(hass, coordinator, entry, tank_name, tank_id)
     ]
 
     async_add_entities(numbers, update_before_add=True)
@@ -22,7 +23,7 @@ async def async_setup_entry(hass, entry, async_add_entities):
 class HelialuxNumberEntity(NumberEntity):
     """Base class for Helialux number entities."""
 
-    def __init__(self, coordinator, entry, tank_name, tank_id, attribute, min_value, max_value, default_value):
+    def __init__(self, hass, coordinator, entry, tank_name, tank_id, attribute, min_value, max_value, default_value):
         self.coordinator = coordinator
         self.entry = entry
         self.tank_name = tank_name
@@ -38,23 +39,22 @@ def __init__(self, coordinator, entry, tank_name, tank_id, attribute, min_value,
         self._attr_device_info = coordinator.device_info
         self._attr_translation_key = f"{attribute}_duration"
 
+        # Initialize persistent storage
+        self._store = Store(hass, 1, f"{DOMAIN}_{self._attr_unique_id}.json")
+
     @property
     def native_value(self):
         """Return the current duration setting."""
         return self._state
 
     async def async_set_native_value(self, value):
-        #"""Set the duration value."""
-        #self._state = int(value)
-        #self.async_write_ha_state()
-        #_LOGGER.debug(f"Set {self.entity_id} to {value} minutes")
-
         """Set the duration value."""
         self._state = float(value)
         # Store the value in the coordinator
         self.coordinator.data[f"{self._attr_translation_key}_duration"] = self._state
         self.async_write_ha_state()
-        _LOGGER.debug(f"Set {self.entity_id} to {value} hours")        
+        await self._store.async_save({"value": self._state})  # Save persistently
+        _LOGGER.debug(f"Set {self.entity_id} to {value} hours")
 
     async def async_update(self):
         """Update the state from HA data."""
@@ -65,20 +65,28 @@ def _update_state(self):
         """Update internal state from coordinator data."""
         self._state = self.native_value
 
+    async def async_added_to_hass(self):
+        """Load previously stored state when added to Home Assistant."""
+        await super().async_added_to_hass()
+        data = await self._store.async_load()
+        if data and "value" in data:
+            self._state = float(data["value"])
+            _LOGGER.debug(f"Restored {self.entity_id} to {self._state} hours")
+
 
 class HelialuxColorSimulationDuration(HelialuxNumberEntity):
     """Number entity for setting the manual color simulation duration."""
 
-    def __init__(self, coordinator, entry, tank_name, tank_id):
+    def __init__(self, hass, coordinator, entry, tank_name, tank_id):
         min_value = entry.data.get("color_simulation_min", 1)
         max_value = entry.data.get("color_simulation_max", 24)
-        super().__init__(coordinator, entry, tank_name, tank_id, "manual_color_simulation", min_value, max_value, 12)
+        super().__init__(hass, coordinator, entry, tank_name, tank_id, "manual_color_simulation", min_value, max_value, 12)
 
 
 class HelialuxDaytimeSimulationDuration(HelialuxNumberEntity):
     """Number entity for setting the manual daytime simulation duration."""
 
-    def __init__(self, coordinator, entry, tank_name, tank_id):
+    def __init__(self, hass, coordinator, entry, tank_name, tank_id):
         min_value = entry.data.get("daytime_simulation_min", 1)
         max_value = entry.data.get("daytime_simulation_max", 24)
-        super().__init__(coordinator, entry, tank_name, tank_id, "manual_daytime_simulation", min_value, max_value, 12)
+        super().__init__(hass, coordinator, entry, tank_name, tank_id, "manual_daytime_simulation", min_value, max_value, 12)