Manual colour simulation now uses set number correctly

Author: MrSleeps

custom_components/juwel_helialux/__init__.py

@@ -36,4 +36,4 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_unload_entry(hass, entry):
     """Handle removal of an entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, ["sensor", "light", "select", "binary_sensor","number","switch"])
-    return unload_ok
+    return unload_ok

custom_components/juwel_helialux/coordinator.py

@@ -102,4 +102,4 @@ async def _async_update_data(self):
 
         except Exception as e:
             _LOGGER.error("Error fetching data: %s", e)
-            return self.data or {}
+            return self.data or {}

custom_components/juwel_helialux/light.py

@@ -124,25 +124,34 @@ async def async_turn_on(self, **kwargs):
         brightness = kwargs.get("brightness", 255)
         rgbw_color = kwargs.get("rgbw_color", (255, 255, 255, 255))
 
-        # Convert to device scale (0-100) - only do this once!
-        white = min(100, max(0, round(rgbw_color[3] / 2.55)))
-        blue = min(100, max(0, round(rgbw_color[2] / 2.55)))
-        green = min(100, max(0, round(rgbw_color[1] / 2.55)))
-        red = min(100, max(0, round(rgbw_color[0] / 2.55)))
+        # Convert to device scale (0-100)
+        white = min(100, max(0, rgbw_color[3] / 2.55))
+        blue = min(100, max(0, rgbw_color[2] / 2.55))
+        green = min(100, max(0, rgbw_color[1] / 2.55))
+        red = min(100, max(0, rgbw_color[0] / 2.55))
 
         # Apply brightness scaling if needed
         if brightness < 255:
             scale = brightness / 255.0
-            white = min(100, round(white * scale))
-            blue = min(100, round(blue * scale))
-            green = min(100, round(green * scale))
-            red = min(100, round(red * scale))
+            white = min(100, white * scale)
+            blue = min(100, blue * scale)
+            green = min(100, green * scale)
+            red = min(100, red * scale)
 
         _LOGGER.debug("Setting light to W:%d B:%d G:%d R:%d", white, blue, green, red)
 
+        # Enable manual override for 5 seconds
+        await self.coordinator.set_manual_override(True, 5)
+        
         try:
-            # Set the light state - values are already in 0-100 range
-            await self._controller.start_manual_color_simulation(1439)
+            # 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)
+            # 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)
 
             # Update local state immediately
@@ -153,15 +162,18 @@ async def async_turn_on(self, **kwargs):
 
         except Exception as e:
             _LOGGER.error("Error setting light state: %s", e)
+            await self.coordinator.set_manual_override(False)
             raise
 
     async def async_turn_off(self, **kwargs):
         """Turn the light off."""
         _LOGGER.debug("Turning off Juwel Helialux light")
-        await self._controller.start_manual_color_simulation(1439)
+        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()
+        self.async_write_ha_state()

custom_components/juwel_helialux/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/MrSleeps/Juwel-HeliaLux-Home-Assistant-Custom-Component/issues",
-  "platforms": ["sensor", "light", "select", "binary_sensor"],
+  "platforms": ["sensor", "light", "select", "binary_sensor", "number", "switch"],
   "requirements": ["aiohttp"],
-  "version": "2.0.3"
+  "version": "2.0.4"
 }

custom_components/juwel_helialux/number.py

@@ -44,10 +44,17 @@ def native_value(self):
         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 = int(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} minutes")
+        _LOGGER.debug(f"Set {self.entity_id} to {value} hours")        
 
     async def async_update(self):
         """Update the state from HA data."""

custom_components/juwel_helialux/pyhelialux/pyHelialux.py

@@ -350,4 +350,4 @@ async def stop_manual_daytime_simulation(self):
                 if response.status != 200:
                     _LOGGER.error(f"Failed to stop manual daytime simulation: {response.status}")
         except Exception as e:
-            _LOGGER.error(f"Error stopping manual daytime simulation: {e}")
+            _LOGGER.error(f"Error stopping manual daytime simulation: {e}")

custom_components/juwel_helialux/switch.py

@@ -65,15 +65,29 @@ def __init__(self, coordinator, tank_name, tank_id):
 
     async def async_turn_on(self, **kwargs):
         """Turn on manual color simulation using the duration set in number helper."""
-        duration_entity = f"number.{self.tank_id}_manual_color_simulation_duration"
-        duration_state = self.coordinator.hass.states.get(duration_entity)
-        duration = int(duration_state.state) * 60 if duration_state else 60  # Convert hours to minutes
-
-        _LOGGER.debug(f"Starting manual color simulation for {duration} minutes")
-
-        await self.coordinator.helialux.start_manual_color_simulation(duration)
-        await self.coordinator.async_refresh()
-        self._update_state()
+        try:
+            duration_entity = f"number.{self.tank_id}_manual_color_simulation_duration"
+            duration_state = self.coordinator.hass.states.get(duration_entity)
+            
+            if duration_state is None:
+                _LOGGER.warning("Duration number entity not found, using default 1 hour")
+                duration = 60  # Default to 1 hour in minutes
+            else:
+                try:
+                    duration = float(duration_state.state) * 60  # Convert hours to minutes
+                    duration = max(1, min(1440, duration))  # Clamp between 1 min and 24 hours
+                except (ValueError, TypeError) as e:
+                    _LOGGER.warning(f"Invalid duration value: {duration_state.state}, using default 1 hour. Error: {e}")
+                    duration = 60
+
+            _LOGGER.debug(f"Starting manual color simulation for {duration} minutes")
+            await self.coordinator.helialux.start_manual_color_simulation(int(duration))
+            await self.coordinator.async_refresh()
+            self._update_state()
+            
+        except Exception as e:
+            _LOGGER.error(f"Error starting manual color simulation: {e}")
+            raise
 
     async def async_turn_off(self, **kwargs):
         """Turn off manual color simulation."""