velbus-aio 2021.8.7__py3-none-any.whl → 2025.11.0__py3-none-any.whl

velbusaio/messages/cover_up.py

@@ -1,17 +1,18 @@
 """
 :author: Tom Dupré <gitd8400@gmail.com>
 """
+
 from __future__ import annotations
 
-import json
 import struct
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0x05
 
 
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class CoverUpMessage(Message):
     """
     sent by:
@@ -35,15 +36,6 @@ class CoverUpMessage(Message):
         self.channel = self.byte_to_channel(data[0])
         (self.delay_time,) = struct.unpack(">L", bytes([0]) + data[1:])
 
-    def to_json(self):
-        """
-        :return: str
-        """
-        json_dict = self.to_json_basic()
-        json_dict["channel"] = self.channel
-        json_dict["delay_time"] = self.delay_time
-        return json.dumps(json_dict)
-
     def set_defaults(self, address):
         if address is not None:
             self.set_address(address)
@@ -60,6 +52,7 @@ class CoverUpMessage(Message):
         )
 
 
+@register(COMMAND_CODE, ["VMB1BL", "VMB2BL"])
 class CoverUpMessage2(Message):
     """
     sent by:
@@ -87,15 +80,6 @@ class CoverUpMessage2(Message):
         self.channel = self.byte_to_channel(tmp)
         (self.delay_time,) = struct.unpack(">L", bytes([0]) + data[1:])
 
-    def to_json(self):
-        """
-        :return: str
-        """
-        json_dict = self.to_json_basic()
-        json_dict["channel"] = self.channel
-        json_dict["delay_time"] = self.delay_time
-        return json.dumps(json_dict)
-
     def set_defaults(self, address):
         if address is not None:
             self.set_address(address)
@@ -111,10 +95,3 @@ class CoverUpMessage2(Message):
         else:
             tmp = 0x0C
         return bytes([COMMAND_CODE, tmp]) + struct.pack(">L", self.delay_time)[-3:]
-
-
-register_command(COMMAND_CODE, CoverUpMessage2, "VMB1BL")
-register_command(COMMAND_CODE, CoverUpMessage2, "VMB2BL")
-register_command(COMMAND_CODE, CoverUpMessage, "VMB1BLE")
-register_command(COMMAND_CODE, CoverUpMessage, "VMB2BLE")
-register_command(COMMAND_CODE, CoverUpMessage, "VMB1BLS")

velbusaio/messages/dali_device_settings.py

@@ -0,0 +1,178 @@
+"""
+:author: Niels Laukens
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+
+from velbusaio.command_registry import register
+from velbusaio.message import Message
+
+COMMAND_CODE = 0xE8
+
+
+@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20"])
+class DaliDeviceSettingMsg(Message):
+    """
+    send by: VMBDALI
+    received by:
+    """
+
+    def __init__(self, address: int | None = None):
+        super().__init__()
+        self.set_defaults(address)
+        self.channel: int = 0
+
+    def populate(self, priority, address: int, rtr: int, data: bytes) -> None:
+        self.needs_low_priority(priority)
+        self.needs_no_rtr(rtr)
+        self.set_attributes(priority, address, rtr)
+
+        self.needs_data(data, 2)
+        self.channel = data[0]
+        message_subtype = data[1]
+        self.data: bytes | DaliDeviceSettingSubMessage = data[2:]
+        try:
+            decode_class = DaliDeviceSetting(message_subtype).decode_class
+            if decode_class is not None:
+                self.data = decode_class.from_data(self.data)
+        except Exception:
+            # Unknown subtype or error while decoding; leave as bytes
+            pass
+
+    def to_json_basic(self):
+        me = {
+            "name": str(self.__class__.__name__),
+            "priority": self.priority,
+            "rtr": self.rtr,
+            "channel": self.channel,
+        }
+        if isinstance(self.data, DaliDeviceSettingSubMessage):
+            me["data"] = self.data.to_json_basic()
+        else:
+            me["data"] = self.data.hex()
+        return me
+
+
+class DaliDeviceSettingSubMessage:
+    """Abstract base class."""
+
+    @classmethod
+    def from_data(cls, data: bytes) -> DaliDeviceSettingSubMessage:
+        raise NotImplementedError()
+
+    def to_data(self) -> bytes:
+        raise NotImplementedError()
+
+    def to_json_basic(self):
+        raise NotImplementedError()
+
+
+class DeviceType(enum.Enum):
+    FluorecentLamp = 0
+    EmergencyLamp = 1
+    DischargeLamp = 2
+    LowVoltageLamp = 3
+    Dimmer = 4
+    ConversionToDc = 5
+    LedModule = 6
+    Relay = 7
+    ColorControl = 8
+    Sequencer = 9
+    DevicePresent = 254
+    NoDevicePresent = 255
+
+
+@dataclasses.dataclass
+class DeviceTypeMsg(DaliDeviceSettingSubMessage):
+    device_type: DeviceType
+
+    @classmethod
+    def from_data(cls, data: bytes) -> DeviceTypeMsg:
+        if len(data) != 1:
+            raise ValueError("Expected 1 byte of data")
+        return DeviceTypeMsg(device_type=DeviceType(data[0]))
+
+    def to_data(self) -> bytes:
+        return bytes([self.device_type.value])
+
+    def to_json_basic(self):
+        return {
+            "submsg_type": self.__class__.__name__,
+            "device_type": self.device_type.name,
+        }
+
+
+@dataclasses.dataclass
+class MemberOfGroupMsg(DaliDeviceSettingSubMessage):
+    member_of_group: list[bool]
+
+    @classmethod
+    def from_data(cls, data: bytes) -> DaliDeviceSettingSubMessage:
+        if len(data) != 2:
+            raise ValueError("Expected 2 bytes")
+        i = int.from_bytes(data, "little")
+        member_of_groups = []
+        for group_num in range(0, 16):
+            member_of_groups.append(bool(i & (1 << group_num)))
+        return MemberOfGroupMsg(member_of_groups)
+
+    def to_data(self) -> bytes:
+        i = 0
+        for group_num, member in enumerate(self.member_of_group):
+            if member:
+                i += 1 << group_num
+        return i.to_bytes(2, "little")
+
+    def to_json_basic(self):
+        return {
+            "member_of_groups": self.member_of_groups,
+        }
+
+    @property
+    def member_of_groups(self) -> list[int]:
+        groups = []
+        for num, member in enumerate(self.member_of_group):
+            if member:
+                groups.append(num)
+        return groups
+
+
+class DaliDeviceSetting(enum.Enum):
+    def __new__(
+        cls, value: int, decode_class: type[DaliDeviceSettingSubMessage]
+    ) -> DaliDeviceSetting:
+        obj = object.__new__(cls)
+        obj._value_ = value
+        obj.decode_class = decode_class
+        return obj
+
+    Scene0Level = (0, None)
+    Scene1Level = (1, None)
+    Scene2Level = (2, None)
+    Scene3Level = (3, None)
+    Scene4Level = (4, None)
+    Scene5Level = (5, None)
+    Scene6Level = (6, None)
+    Scene7Level = (7, None)
+    Scene8Level = (8, None)
+    Scene9Level = (9, None)
+    Scene10Level = (10, None)
+    Scene11Level = (11, None)
+    Scene12Level = (12, None)
+    Scene13Level = (13, None)
+    Scene14Level = (14, None)
+    Scene15Level = (15, None)
+    PowerOnLevel = (16, None)
+    SystemFailureLevel = (17, None)
+    MinimumLevel = (18, None)
+    MaximumLevel = (19, None)
+    FadeTimeAndRate = (20, None)
+    MemberOfGroup = (21, MemberOfGroupMsg)
+    GroupMembers0 = (22, None)
+    GroupMembers32 = (22, None)
+    # currently undefined 24
+    DeviceType = (25, DeviceTypeMsg)
+    ActualLevel = (26, None)

velbusaio/messages/dali_device_settings_request.py

@@ -0,0 +1,53 @@
+"""
+:author: Niels Laukens
+"""
+
+from __future__ import annotations
+
+import enum
+
+from velbusaio.command_registry import register
+from velbusaio.message import Message
+from velbusaio.messages.dali_device_settings import DaliDeviceSetting
+
+COMMAND_CODE = 0xE7
+
+
+class DataSource(enum.Enum):
+    FromMemory = 0
+    FromDaliDevice = 1
+
+
+@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20"])
+class DaliDeviceSettingsRequest(Message):
+    """
+    send by:
+    received by: VMBDALI
+
+    Note: requesting a single setting for all (81) channels does not work (no response)
+    """
+
+    def __init__(self, address: int | None = None):
+        super().__init__()
+        self.channel: int = None
+        self.data_source: DataSource = None
+        self.settings: DaliDeviceSetting = None
+        self.set_defaults(address)
+
+    def populate(self, priority, address: int, rtr: int, data: bytes) -> None:
+        self.needs_low_priority(priority)
+        self.needs_no_rtr(rtr)
+        self.needs_data(data, 2)
+        self.set_attributes(priority, address, rtr)
+        self.channel = data[0]
+        self.data_source = DataSource(data[1])
+        if len(data) >= 3:
+            self.settings = data[2]
+        else:
+            self.settings = None  # all
+
+    def data_to_binary(self) -> bytes:
+        data = bytearray([COMMAND_CODE, self.channel, DataSource.FromMemory.value])
+        if self.settings is not None:
+            data.append(self.settings.value)
+        return bytes(data)

velbusaio/messages/dali_dim_value_status.py

@@ -0,0 +1,44 @@
+"""
+:author: Niels Laukens
+"""
+
+from __future__ import annotations
+
+from velbusaio.command_registry import register
+from velbusaio.message import Message
+
+COMMAND_CODE = 0xA5
+
+
+@register(
+    COMMAND_CODE, ["VMBDALI", "VMBDALI-20", "VMB8DC-20", "VMB4LEDPWM-20", "VMB2DC-20"]
+)
+class DimValueStatus(Message):
+    """
+    send by: VMBDALI
+    received by:
+    """
+
+    def __init__(self, address: int = None) -> None:
+        super().__init__()
+        self.set_defaults(address)
+        self.channel: int = 0
+        self.dim_values: list[int] = []
+        # dim_values contain dim value of channel, channel+1, ...
+
+    def populate(self, priority, address: int, rtr: int, data: int) -> None:
+        self.needs_low_priority(priority)
+        self.needs_no_rtr(rtr)
+        self.set_attributes(priority, address, rtr)
+
+        self.needs_data(data, 2)
+        self.channel = data[0]
+        self.dim_values = list(data[1:])
+
+    def data_to_binary(self) -> bytes:
+        return bytes(
+            [
+                COMMAND_CODE,
+                self.channel,
+            ]
+        ) + bytes(self.dim_values)

velbusaio/messages/dimmer_channel_status.py

@@ -1,12 +1,12 @@
 """
 :author: Frank van Breugel
 """
+
 from __future__ import annotations
 
-import json
 import struct
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xB8
@@ -22,6 +22,10 @@ LED_FAST_BLINKING = 1 << 5
 LED_VERY_FAST_BLINKING = 1 << 4
 
 
+@register(
+    COMMAND_CODE,
+    ["VMB4DC", "VMBDMI", "VMBDMI-R", "VMB8DC-20", "VMB4LEDPWM-20", "VMB2DC-20"],
+)
 class DimmerChannelStatusMessage(Message):
     """
     sent by: VMB4DC
@@ -51,18 +55,6 @@ class DimmerChannelStatusMessage(Message):
         self.led_status = data[3]
         (self.delay_time,) = struct.unpack(">L", bytes([0]) + data[4:])
 
-    def to_json(self):
-        """
-        :return: str
-        """
-        json_dict = self.to_json_basic()
-        json_dict["channel"] = self.channel
-        json_dict["disable_inhibit_forced"] = self.disable_inhibit_forced
-        json_dict["dimmer_state"] = self.dimmer_state
-        json_dict["led_status"] = self.led_status
-        json_dict["delay_time"] = self.delay_time
-        return json.dumps(json_dict)
-
     def is_normal(self):
         """
         :return: bool
@@ -109,8 +101,3 @@ class DimmerChannelStatusMessage(Message):
             )
             + struct.pack(">L", self.delay_time)[-3:]
         )
-
-
-register_command(COMMAND_CODE, DimmerChannelStatusMessage, "VMB4DC")
-register_command(COMMAND_CODE, DimmerChannelStatusMessage, "VMBDMI")
-register_command(COMMAND_CODE, DimmerChannelStatusMessage, "VMBDMI-R")

velbusaio/messages/dimmer_status.py

@@ -1,43 +1,42 @@
 """
 :author: Frank van Breugel
 """
+
 from __future__ import annotations
 
-import json
 import struct
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xEE
-
 MODE_START_STOP = 0x00
-
 MODE_STAIRCASE = 0x01
-
 MODE_DIMMER = 0x02
-
 MODE_MEMORY = 0x03
-
 MODE_MULTI = 0x04
-
 MODE_SLOW_ON = 0x05
-
 MODE_SLOW_OFF = 0x06
-
 MODE_SLOW = 0x06
-
 LED_OFF = 0
-
 LED_ON = 1 << 7
-
 LED_SLOW_BLINKING = 1 << 6
-
 LED_FAST_BLINKING = 1 << 5
-
 LED_VERY_FAST_BLINKING = 1 << 4
 
 
+@register(
+    COMMAND_CODE,
+    [
+        "VMB1DM",
+        "VMBDME",
+        "VMB1LED",
+        "VMBDALI",
+        "VMBDALI-20",
+        "VMB8DC-20",
+        "VMB4LEDPWM-20",
+    ],
+)
 class DimmerStatusMessage(Message):
     """
     sent by: VMBDME
@@ -70,18 +69,6 @@ class DimmerStatusMessage(Message):
         (self.delay_time,) = struct.unpack(">L", bytes([0]) + data[4:])
         self.dimmer_config = data[6]
 
-    def to_json(self):
-        """
-        :return: str
-        """
-        json_dict = self.to_json_basic()
-        json_dict["channel"] = self.channel
-        json_dict["dimmer_mode"] = self.dimmer_mode
-        json_dict["dimmer_state"] = self.dimmer_state
-        json_dict["led_status"] = self.led_status
-        json_dict["delay_time"] = self.delay_time
-        return json.dumps(json_dict)
-
     def is_start_stop(self):
         """
         :return: bool
@@ -151,7 +138,3 @@ class DimmerStatusMessage(Message):
             )
             + struct.pack(">L", self.delay_time)[-3:]
         )
-
-
-register_command(COMMAND_CODE, DimmerStatusMessage, "VMBDME")
-register_command(COMMAND_CODE, DimmerStatusMessage, "VMB1LED")

velbusaio/messages/edge_set_color.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+from velbusaio.command_registry import register
+from velbusaio.message import Message
+
+COMMAND_CODE = 0xD4
+
+
+class CustomColorPriority(IntEnum):
+    LOW_PRIORITY = 1
+    MID_PRIORITY = 2
+    HIGH_PRIORITY = 3
+
+
+@register(COMMAND_CODE, ["VMBEL1", "VMBEL2", "VMBEL4", "VMBELO"])
+class SetEdgeColorMessage(Message):
+    """
+    send by:
+    received by: VMBEL1, VMBEL2, VMBEL4, VMBELO
+    """
+
+    apply_background_color = False
+    apply_continuous_feedback_color = False
+    apply_slow_blinking_feedback_color = False
+    apply_fast_blinking_feedback_color = False
+    custom_color_palette = False
+
+    apply_to_left_edge = False
+    apply_to_top_edge = False
+    apply_to_right_edge = False
+    apply_to_bottom_edge = False
+
+    apply_to_page: int | None = None
+    apply_to_all_pages = False
+
+    background_blinking = False
+    custom_color_priority: CustomColorPriority | None = None
+
+    color_idx: int = 0
+
+    def populate(self, priority, address, rtr, data):
+        """
+        :return: None
+        """
+        self.needs_no_rtr(rtr)
+        self.set_attributes(priority, address, rtr)
+
+        self.apply_background_color = bool(data[0] & 0x01)
+        self.apply_continuous_feedback_color = bool(data[0] & 0x02)
+        self.apply_slow_blinking_feedback_color = bool(data[0] & 0x04)
+        self.apply_fast_blinking_feedback_color = bool(data[0] & 0x08)
+        self.custom_color_palette = bool(data[0] & 0x80)
+
+        self.apply_to_left_edge = bool(data[1] & 0x01)
+        self.apply_to_top_edge = bool(data[1] & 0x02)
+        self.apply_to_right_edge = bool(data[1] & 0x04)
+        self.apply_to_bottom_edge = bool(data[1] & 0x08)
+
+        page = (data[1] & 0b0111_0000) >> 4
+        if page > 0:
+            self.apply_to_page = page
+        self.apply_to_all_pages = bool(data[1] & 0x80)
+
+        self.background_blinking = bool(data[2] & 0x80)
+
+        custom_color_priority_value = data[2] & 0b0110_0000 >> 5
+        if custom_color_priority_value:
+            self.custom_color_priority = CustomColorPriority(
+                custom_color_priority_value
+            )
+
+        self.color_idx = data[2] & 0b0001_1111
+
+    def data_to_binary(self):
+        """
+        :return: bytes
+        """
+
+        byte_2 = (
+            self.apply_background_color * 0x01
+            + self.apply_continuous_feedback_color * 0x02
+            + self.apply_slow_blinking_feedback_color * 0x04
+            + self.apply_fast_blinking_feedback_color * 0x08
+            + self.custom_color_palette * 0x80
+        )
+
+        byte_3 = (
+            self.apply_to_left_edge * 0x01
+            + self.apply_to_top_edge * 0x02
+            + self.apply_to_right_edge * 0x04
+            + self.apply_to_bottom_edge * 0x08
+            + (((self.apply_to_page or 0) & 0xFFF) << 4)
+            + self.apply_to_all_pages * 0x80
+        )
+
+        byte_4 = (
+            (self.color_idx & 0xFFFF)
+            + (
+                (int(self.custom_color_priority) if self.custom_color_priority else 0)
+                << 5
+            )
+            + self.background_blinking * 0x80
+        )
+
+        return bytes(
+            [
+                COMMAND_CODE,
+                byte_2,
+                byte_3,
+                byte_4,
+            ]
+        )

velbusaio/messages/edge_set_custom_color.py

@@ -0,0 +1,56 @@
+"""
+:author: Maikel Punie <maikel.punie@gmail.com>
+"""
+
+from __future__ import annotations
+
+from velbusaio.command_registry import register
+from velbusaio.message import Message
+
+COMMAND_CODE = 0xD4
+
+
+@register(COMMAND_CODE, ["VMBEL1", "VMBEL2", "VMBEL4", "VMBELO"])
+class EdgeSetCustomColor(Message):
+    """
+    send by:
+    received by: VMBEL1, VMBEL2, VMBEL4, VMBELO
+    """
+
+    def __init__(self, address=None):
+        Message.__init__(self)
+        self.set_defaults(address)
+        self.pallet = 31
+        self.rgb = False
+        self.saturation = 0
+        self.red = 0
+        self.green = 0
+        self.blue = 0
+
+    def populate(self, priority, address, rtr, data):
+        """
+        :return: None
+        """
+        self.needs_no_rtr(rtr)
+        self.set_attributes(priority, address, rtr)
+        self.pallet = data[0]
+        self.rgb = bool(data[1] & 0x80)
+        self.saturation = data[1] & 0x7F
+        self.red = data[2]
+        self.green = data[3]
+        self.blue = data[4]
+
+    def data_to_binary(self):
+        """
+        :return: bytes
+        """
+        return bytes(
+            [
+                COMMAND_CODE,
+                self.pallet,
+                ((self.rgb << 7) + self.saturation),
+                self.red,
+                self.green,
+                self.blue,
+            ]
+        )

velbusaio/messages/fast_blinking_led.py

@@ -1,14 +1,16 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xF8
 
 
+@register(COMMAND_CODE)
 class FastBlinkingLedMessage(Message):
     """
     send by: VMB4RYLD
@@ -35,6 +37,3 @@ class FastBlinkingLedMessage(Message):
         :return: bytes
         """
         return bytes([COMMAND_CODE, self.channels_to_byte(self.leds)])
-
-
-register_command(COMMAND_CODE, FastBlinkingLedMessage)

velbusaio/messages/forced_off.py

@@ -1,14 +1,16 @@
 """
 :author: Maikel Punie <maikel.punie@gmail.com>
 """
+
 from __future__ import annotations
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0x12
 
 
+@register(COMMAND_CODE)
 class ForcedOff(Message):
     def populate(self, priority, address, rtr, data):
         """
@@ -23,6 +25,3 @@ class ForcedOff(Message):
         :return: bytes
         """
         return bytes([COMMAND_CODE])
-
-
-register_command(COMMAND_CODE, ForcedOff)