added led device and brightness control

Author: johnneerdael

custom_components/hyperhdr_control/__init__.py

@@ -8,7 +8,7 @@
 
 from .const import DOMAIN
 
-PLATFORMS: list[Platform] = [Platform.SWITCH, Platform.BUTTON]
+PLATFORMS: list[Platform] = [Platform.SWITCH, Platform.BUTTON, Platform.NUMBER]
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up HyperHDR Control from a config entry."""
@@ -26,7 +26,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         manufacturer="HyperHDR",
         name=f"HyperHDR ({entry.data[CONF_HOST]})",
         model="HyperHDR LED Controller",
-        sw_version="1.0.0",
+        sw_version="1.1.0",
     )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

custom_components/hyperhdr_control/manifest.json

@@ -6,6 +6,6 @@
   "codeowners": [],
   "requirements": ["aiohttp"],
   "iot_class": "local_polling",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "config_flow": true
 } 

custom_components/hyperhdr_control/number.py

@@ -0,0 +1,99 @@
+"""Number platform for HyperHDR Control integration."""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+import aiohttp
+import async_timeout
+from homeassistant.components.number import NumberEntity, NumberMode
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PORT, PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the HyperHDR Control number entities."""
+    host = entry.data[CONF_HOST]
+    port = entry.data[CONF_PORT]
+    
+    async_add_entities([
+        HyperHDRBrightnessNumber(entry.entry_id, host, port)
+    ], True)
+
+class HyperHDRBrightnessNumber(NumberEntity):
+    """Representation of a HyperHDR brightness control."""
+
+    def __init__(self, entry_id: str, host: str, port: int) -> None:
+        """Initialize the number entity."""
+        self._entry_id = entry_id
+        self._host = host
+        self._port = port
+        self._attr_name = "HyperHDR Brightness"
+        self._attr_unique_id = f"hyperhdr_brightness_{host}_{port}"
+        self._attr_native_min_value = 0
+        self._attr_native_max_value = 100
+        self._attr_native_step = 1
+        self._attr_mode = NumberMode.SLIDER
+        self._attr_native_unit_of_measurement = PERCENTAGE
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return device information about this HyperHDR instance."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, f"{self._host}:{self._port}")},
+            manufacturer="HyperHDR",
+            name=f"HyperHDR ({self._host})",
+            model="HyperHDR LED Controller",
+            sw_version="1.1.0",
+        )
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the brightness value."""
+        request_data = {
+            "command": "adjustment",
+            "adjustment": {
+                "classic_config": False,
+                "brightness": int(value)
+            }
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                url = f"http://{self._host}:{self._port}/json-rpc"
+                async with async_timeout.timeout(10):
+                    async with session.get(url, params={"request": json.dumps(request_data)}) as response:
+                        if response.status == 200:
+                            self._attr_native_value = value
+                        else:
+                            _LOGGER.error("Failed to set brightness: %s", response.status)
+        except (aiohttp.ClientError, TimeoutError) as error:
+            _LOGGER.error("Error setting brightness: %s", error)
+
+    async def async_update(self) -> None:
+        """Update the current brightness value."""
+        request_data = {
+            "command": "serverinfo"
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                url = f"http://{self._host}:{self._port}/json-rpc"
+                async with async_timeout.timeout(10):
+                    async with session.get(url, params={"request": json.dumps(request_data)}) as response:
+                        if response.status == 200:
+                            data = await response.json()
+                            adjustment = data.get("info", {}).get("adjustment", {})
+                            self._attr_native_value = float(adjustment.get("brightness", 100))
+        except (aiohttp.ClientError, TimeoutError) as error:
+            _LOGGER.error("Error updating brightness: %s", error) 

custom_components/hyperhdr_control/switch.py

@@ -23,22 +23,26 @@ async def async_setup_entry(
     entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
 ) -> None:
-    """Set up the HyperHDR Control switch."""
+    """Set up the HyperHDR Control switches."""
     host = entry.data[CONF_HOST]
     port = entry.data[CONF_PORT]
 
-    async_add_entities([HyperHDRSwitch(entry.entry_id, host, port)], True)
+    async_add_entities([
+        HyperHDRSwitch(entry.entry_id, host, port, "VIDEOGRABBER", "USB Capture"),
+        HyperHDRSwitch(entry.entry_id, host, port, "LEDDEVICE", "LED Output")
+    ], True)
 
 class HyperHDRSwitch(SwitchEntity):
     """Representation of a HyperHDR Control switch."""
 
-    def __init__(self, entry_id: str, host: str, port: int) -> None:
+    def __init__(self, entry_id: str, host: str, port: int, component: str, name: str) -> None:
         """Initialize the switch."""
         self._entry_id = entry_id
         self._host = host
         self._port = port
-        self._attr_name = "HyperHDR USB Capture"
-        self._attr_unique_id = f"hyperhdr_videograbber_{host}_{port}"
+        self._component = component
+        self._attr_name = f"HyperHDR {name}"
+        self._attr_unique_id = f"hyperhdr_{component.lower()}_{host}_{port}"
         self._attr_is_on = False
 
     @property
@@ -49,7 +53,7 @@ def device_info(self) -> DeviceInfo:
             manufacturer="HyperHDR",
             name=f"HyperHDR ({self._host})",
             model="HyperHDR LED Controller",
-            sw_version="1.0.0",
+            sw_version="1.1.0",
         )
 
     async def async_turn_on(self, **kwargs: Any) -> None:
@@ -61,11 +65,11 @@ async def async_turn_off(self, **kwargs: Any) -> None:
         await self._set_state(False)
 
     async def _set_state(self, state: bool) -> None:
-        """Set the state of the video grabber."""
+        """Set the state of the component."""
         request_data = {
             "command": "componentstate",
             "componentstate": {
-                "component": "VIDEOGRABBER",
+                "component": self._component,
                 "state": state
             }
         }
@@ -97,7 +101,7 @@ async def async_update(self) -> None:
                             data = await response.json()
                             components = data.get("info", {}).get("components", [])
                             for component in components:
-                                if component.get("name") == "VIDEOGRABBER":
+                                if component.get("name") == self._component:
                                     self._attr_is_on = component.get("enabled", False)
                                     break
         except (aiohttp.ClientError, TimeoutError) as error: