feat: add support for light strips

switchbot/__init__.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 from .adv_parser import SwitchbotSupportedType, parse_advertisement_data
 from .const import SwitchbotModel
 from .devices.bot import Switchbot
-from .devices.bulb import ColorMode, SwitchbotBulb
+from .devices.bulb import SwitchbotBulb
 from .devices.curtain import SwitchbotCurtain
-from .devices.device import SwitchbotDevice
+from .devices.device import ColorMode, SwitchbotDevice
+from .devices.light_strip import SwitchbotLightStrip
 from .devices.plug import SwitchbotPlugMini
 from .discovery import GetSwitchbotDevices
 from .models import SwitchBotAdvertisement
@@ -19,6 +20,7 @@ __all__ = [
     "SwitchbotBulb",
     "SwitchbotDevice",
     "SwitchbotCurtain",
+    "SwitchbotLightStrip",
     "Switchbot",
     "SwitchbotPlugMini",
     "SwitchbotSupportedType",

switchbot/adv_parser.py

@@ -11,6 +11,7 @@ from .adv_parsers.bot import process_wohand
 from .adv_parsers.bulb import process_color_bulb
 from .adv_parsers.contact import process_wocontact
 from .adv_parsers.curtain import process_wocurtain
+from .adv_parsers.light_strip import process_wostrip
 from .adv_parsers.meter import process_wosensorth
 from .adv_parsers.motion import process_wopresence
 from .adv_parsers.plug import process_woplugmini
@@ -42,6 +43,11 @@ SUPPORTED_TYPES: dict[str, SwitchbotSupportedType] = {
         "modelFriendlyName": "Motion Sensor",
         "func": process_wopresence,
     },
+    "r": {
+        "modelName": SwitchbotModel.LIGHT_STRIP,
+        "modelFriendlyName": "Light Strip",
+        "func": process_wostrip,
+    },
     "c": {
         "modelName": SwitchbotModel.CURTAIN,
         "modelFriendlyName": "Curtain",

switchbot/adv_parsers/light_strip.py

@@ -0,0 +1,17 @@
+"""Bulb parser."""
+from __future__ import annotations
+
+
+def process_color_bulb(data: bytes, mfr_data: bytes | None) -> dict[str, bool | int]:
+    """Process WoStrip services data."""
+    assert mfr_data is not None
+    return {
+        "sequence_number": mfr_data[6],
+        "isOn": bool(mfr_data[7] & 0b10000000),
+        "brightness": mfr_data[7] & 0b01111111,
+        "delay": bool(mfr_data[8] & 0b10000000),
+        "preset": bool(mfr_data[8] & 0b00001000),
+        "color_mode": mfr_data[8] & 0b00000111,
+        "speed": mfr_data[9] & 0b01111111,
+        "loop_index": mfr_data[10] & 0b11111110,
+    }

switchbot/const.py

@@ -14,6 +14,7 @@ class SwitchbotModel(StrEnum):
     CURTAIN = "WoCurtain"
     PLUG_MINI = "WoPlug"
     CONTACT_SENSOR = "WoContact"
+    LIGHT_STRIP = "WoStrip"
     METER = "WoSensorTH"
     MOTION_SENSOR = "WoPresence"
     COLOR_BULB = "WoBulb"

switchbot/devices/device.py

@@ -41,6 +41,14 @@ BLEAK_EXCEPTIONS = (AttributeError, BleakError, asyncio.exceptions.TimeoutError)
 DISCONNECT_DELAY = 49
 
 
+class ColorMode(Enum):
+
+    OFF = 0
+    COLOR_TEMP = 1
+    RGB = 2
+    EFFECT = 3
+
+
 class CharacteristicMissingError(Exception):
     """Raised when a characteristic is missing."""
 

switchbot/devices/light_strip.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from switchbot.models import SwitchBotAdvertisement
+
+from .device import SwitchbotDevice
+
+REQ_HEADER = "570f"
+STRIP_COMMMAND_HEADER = "4901"
+STRIP_REQUEST = f"{REQ_HEADER}4A01"
+
+STRIP_COMMAND = f"{REQ_HEADER}{STRIP_COMMMAND_HEADER}"
+# Strip keys
+STRIP_ON_KEY = f"{STRIP_COMMAND}01"
+STRIP_OFF_KEY = f"{STRIP_COMMAND}02"
+RGB_BRIGHTNESS_KEY = f"{STRIP_COMMAND}12"
+BRIGHTNESS_KEY = f"{STRIP_COMMAND}14"
+
+_LOGGER = logging.getLogger(__name__)
+
+
+from .device import ColorMode
+
+
+class SwitchbotLightStrip(SwitchbotDevice):
+    """Representation of a Switchbot light strip."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Switchbot light strip constructor."""
+        super().__init__(*args, **kwargs)
+        self._state: dict[str, Any] = {}
+
+    @property
+    def on(self) -> bool | None:
+        """Return if bulb is on."""
+        return self.is_on()
+
+    @property
+    def rgb(self) -> tuple[int, int, int] | None:
+        """Return the current rgb value."""
+        if "r" not in self._state or "g" not in self._state or "b" not in self._state:
+            return None
+        return self._state["r"], self._state["g"], self._state["b"]
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the current brightness value."""
+        return self._get_adv_value("brightness") or 0
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        return ColorMode(self._get_adv_value("color_mode") or 0)
+
+    async def update(self) -> None:
+        """Update state of device."""
+        result = await self._sendcommand(STRIP_REQUEST)
+        self._update_state(result)
+
+    async def turn_on(self) -> bool:
+        """Turn device on."""
+        result = await self._sendcommand(STRIP_ON_KEY)
+        self._update_state(result)
+        return result[1] == 0x80
+
+    async def turn_off(self) -> bool:
+        """Turn device off."""
+        result = await self._sendcommand(STRIP_OFF_KEY)
+        self._update_state(result)
+        return result[1] == 0x00
+
+    async def set_brightness(self, brightness: int) -> bool:
+        """Set brightness."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        result = await self._sendcommand(f"{BRIGHTNESS_KEY}{brightness:02X}")
+        self._update_state(result)
+        return result[1] == 0x80
+
+    async def set_rgb(self, brightness: int, r: int, g: int, b: int) -> bool:
+        """Set rgb."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        assert 0 <= r <= 255, "r must be between 0 and 255"
+        assert 0 <= g <= 255, "g must be between 0 and 255"
+        assert 0 <= b <= 255, "b must be between 0 and 255"
+        result = await self._sendcommand(
+            f"{RGB_BRIGHTNESS_KEY}{brightness:02X}{r:02X}{g:02X}{b:02X}"
+        )
+        self._update_state(result)
+        return result[1] == 0x80
+
+    def is_on(self) -> bool | None:
+        """Return bulb state from cache."""
+        return self._get_adv_value("isOn")
+
+    def _update_state(self, result: bytes) -> None:
+        """Update device state."""
+        if len(result) < 10:
+            return
+        self._state["r"] = result[3]
+        self._state["g"] = result[4]
+        self._state["b"] = result[5]
+        _LOGGER.debug(
+            "%s: Bulb update state: %s = %s", self.name, result.hex(), self._state
+        )
+        self._fire_callbacks()
+
+    def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
+        """Update device data from advertisement."""
+        current_state = self._get_adv_value("sequence_number")
+        super().update_from_advertisement(advertisement)
+        new_state = self._get_adv_value("sequence_number")
+        _LOGGER.debug(
+            "%s: Strip update advertisement: %s (seq before: %s) (seq after: %s)",
+            self.name,
+            advertisement,
+            current_state,
+            new_state,
+        )
+        if current_state != new_state:
+            asyncio.ensure_future(self.update())