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

velbusaio/message.py

@@ -1,19 +1,13 @@
 """
 The velbus abstract message class
 """
+
 from __future__ import annotations
 
+import enum
 import json
 
-from velbusaio.const import (
-    ETX,
-    PRIORITY_FIRMWARE,
-    PRIORITY_HIGH,
-    PRIORITY_LOW,
-    RTR,
-    STX,
-)
-from velbusaio.helpers import checksum
+from velbusaio.const import PRIORITY_FIRMWARE, PRIORITY_HIGH, PRIORITY_LOW
 
 
 class ParserError(Exception):
@@ -27,35 +21,27 @@ class Message:
     Base Velbus message
     """
 
-    def __init__(self, address: int = None) -> None:
+    def __init__(self, address: int = 0) -> None:
         self.priority = PRIORITY_LOW
-        self.address = None
-        self.rtr = False
+        self.address: int = 0
+        self.rtr: bool = False
         self.data = bytearray()
         self.set_defaults(address)
 
-    def set_attributes(self, priority: int, address: int, rtr: int) -> None:
-        """
-        :return: None
-        """
+    def set_attributes(self, priority: int, address: int, rtr: bool) -> None:
         self.priority = priority
         self.address = address
         self.rtr = rtr
 
-    def populate(self, priority, address: int, rtr: int, data: int) -> None:
-        """
-        :return: None
-        """
+    def populate(self, priority: int, address: int, rtr: bool, data: int) -> None:
         raise NotImplementedError
 
-    def set_defaults(self, address) -> None:
+    def set_defaults(self, address: int | None) -> None:
         """
         Set defaults
 
         If a message has different than low priority or NO_RTR set,
         then this method needs override in subclass
-
-        :return: None
         """
         if address is not None:
             self.set_address(address)
@@ -63,65 +49,44 @@ class Message:
         self.set_no_rtr()
 
     def set_address(self, address: int) -> None:
-        """
-        :return: None
-        """
         self.address = address
 
-    def to_binary(self):
-        """
-        :return: bytes
-        """
-        data_bytes = self.data_to_binary()
-        if self.rtr:
-            rtr_and_size = RTR | len(data_bytes)
-        else:
-            rtr_and_size = len(data_bytes)
-        header = bytearray([STX, self.priority, self.address, rtr_and_size])
-        checksum_string = checksum(header + data_bytes)
-        return (
-            header
-            + data_bytes
-            + bytearray.fromhex(f"{checksum_string:02x}")
-            + bytearray([ETX])
-        )
-
-    def data_to_binary(self):
-        """
-        :return: bytes
-        """
-        raise NotImplementedError
+    def data_to_binary(self) -> bytes:
+        raise NotImplementedError()
 
-    def to_json_basic(self):
+    def to_json_basic(self) -> dict:
         """
         Create JSON structure with generic attributes
-
-        :return: dict
         """
-        return {
-            "name": self.__class__.__name__,
-            "priority": self.priority,
-            "address": self.address,
-            "rtr": self.rtr,
-        }
+        me = {}
+        me["name"] = str(self.__class__.__name__)
+        me.update(self.__dict__.copy())
+        for key in me.copy():
+            if key == "name":
+                continue
+            if callable(getattr(self, key)) or key.startswith("__"):
+                del me[key]
+            if isinstance(me[key], (bytes, bytearray, enum.Enum)):
+                me[key] = str(me[key])
+            else:
+                try:
+                    json.dumps(me[key])  # Test if the value is JSON serializable
+                except (TypeError, ValueError):
+                    me[key] = str(me[key])  # Convert non-serializable objects to string
+        return me
 
     def to_json(self) -> str:
         """
         Dump object structure to JSON
 
         This method should be overridden in subclasses to include more than just generic attributes
-
-        :return: str
         """
         return json.dumps(self.to_json_basic())
 
     def __str__(self) -> str:
         return self.to_json()
 
-    def byte_to_channels(self, byte: int) -> str:
-        """
-        :return: list(int)
-        """
+    def byte_to_channels(self, byte: int) -> list[int]:
         # pylint: disable-msg=R0201
         result = []
         for offset in range(0, 8):
@@ -129,10 +94,7 @@ class Message:
                 result.append(offset + 1)
         return result
 
-    def channels_to_byte(self, channels) -> int:
-        """
-        :return: int
-        """
+    def channels_to_byte(self, channels: list[int]) -> int:
         # pylint: disable-msg=R0201
         result = 0
         for offset in range(0, 8):
@@ -140,113 +102,65 @@ class Message:
                 result = result + (1 << offset)
         return result
 
-    def byte_to_channel(self, byte):
-        """
-        :return: int
-        """
+    def byte_to_channel(self, byte: int) -> int:
         channels = self.byte_to_channels(byte)
         self.needs_one_channel(channels)
         return channels[0]
 
-    def parser_error(self, message):
-        """
-        :return: None
-        """
+    def parser_error(self, message: str) -> None:
         raise ParserError(self.__class__.__name__ + " " + message)
 
-    def needs_rtr(self, rtr):
-        """
-        :return: None
-        """
+    def needs_rtr(self, rtr: bool) -> None:
         if not rtr:
             self.parser_error("needs rtr set")
 
-    def set_rtr(self):
-        """
-        :return: None
-        """
+    def set_rtr(self) -> None:
         self.rtr = True
 
-    def needs_no_rtr(self, rtr):
-        """
-        :return: None
-        """
+    def needs_no_rtr(self, rtr: bool) -> None:
         if rtr:
             self.parser_error("does not need rtr set")
 
-    def set_no_rtr(self):
-        """
-        :return: None
-        """
+    def set_no_rtr(self) -> None:
         self.rtr = False
 
-    def needs_low_priority(self, priority):
-        """
-        :return: None
-        """
+    def needs_low_priority(self, priority: int) -> None:
         if priority != PRIORITY_LOW:
             self.parser_error("needs low priority set")
 
-    def set_low_priority(self):
-        """
-        :return: None
-        """
+    def set_low_priority(self) -> None:
         self.priority = PRIORITY_LOW
 
-    def needs_high_priority(self, priority):
-        """
-        :return: None
-        """
+    def needs_high_priority(self, priority: int) -> None:
         if priority != PRIORITY_HIGH:
             self.parser_error("needs high priority set")
 
-    def set_high_priority(self):
-        """
-        :return: None
-        """
+    def set_high_priority(self) -> None:
         self.priority = PRIORITY_HIGH
 
-    def needs_firmware_priority(self, priority):
-        """
-        :return: None
-        """
+    def needs_firmware_priority(self, priority: int) -> None:
         if priority != PRIORITY_FIRMWARE:
             self.parser_error("needs firmware priority set")
 
-    def set_firmware_priority(self):
-        """
-        :return: None
-        """
+    def set_firmware_priority(self) -> None:
         self.priority = PRIORITY_FIRMWARE
 
-    def needs_no_data(self, data):
-        """
-        :return: None
-        """
+    def needs_no_data(self, data: bytes) -> None:
         length = len(data)
         if length != 0:
             self.parser_error("has data included")
 
-    def needs_data(self, data, length):
-        """
-        :return: None
-        """
+    def needs_data(self, data: bytes, length: int) -> None:
         if len(data) < length:
             self.parser_error(
                 "needs " + str(length) + " bytes of data have " + str(len(data))
             )
 
-    def needs_fixed_byte(self, byte, value):
-        """
-        :return: None
-        """
+    def needs_fixed_byte(self, byte: int, value: int) -> None:
         if byte != value:
             self.parser_error("expects " + chr(value) + " in byte " + chr(byte))
 
-    def needs_one_channel(self, channels):
-        """
-        :return: None
-        """
+    def needs_one_channel(self, channels: list[int]) -> None:
         if (
             len(channels) != 1
             or not isinstance(channels[0], int)

velbusaio/messages/__init__.py

@@ -1,6 +1,7 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
 from velbusaio.messages.blind_status import BlindStatusMessage, BlindStatusNgMessage
@@ -32,29 +33,34 @@ from velbusaio.messages.channel_name_request import (
 from velbusaio.messages.clear_led import ClearLedMessage
 from velbusaio.messages.counter_status import CounterStatusMessage
 from velbusaio.messages.counter_status_request import CounterStatusRequestMessage
+from velbusaio.messages.counter_value import CounterValueMessage
 from velbusaio.messages.cover_down import CoverDownMessage, CoverDownMessage2
 from velbusaio.messages.cover_off import CoverOffMessage, CoverOffMessage2
 from velbusaio.messages.cover_position import CoverPosMessage
 from velbusaio.messages.cover_up import CoverUpMessage, CoverUpMessage2
+from velbusaio.messages.dali_device_settings import DaliDeviceSettingMsg
 from velbusaio.messages.dimmer_channel_status import DimmerChannelStatusMessage
 from velbusaio.messages.dimmer_status import DimmerStatusMessage
 from velbusaio.messages.fast_blinking_led import FastBlinkingLedMessage
 from velbusaio.messages.forced_off import ForcedOff
 from velbusaio.messages.forced_on import ForcedOn
 from velbusaio.messages.interface_status_request import InterfaceStatusRequestMessage
+from velbusaio.messages.ir_receiver_status import IRReceiverStatusMessage
 from velbusaio.messages.kwh_status import KwhStatusMessage
 from velbusaio.messages.light_value_request import LightValueRequest
 from velbusaio.messages.memo_text import MemoTextMessage
 from velbusaio.messages.memory_data import MemoryDataMessage
 from velbusaio.messages.memory_data_block import MemoryDataBlockMessage
 from velbusaio.messages.memory_dump_request import MemoryDumpRequestMessage
-from velbusaio.messages.meteo_raw import MeteoRawMessage
 from velbusaio.messages.module_status import ModuleStatusMessage, ModuleStatusMessage2
 from velbusaio.messages.module_status_request import ModuleStatusRequestMessage
 from velbusaio.messages.module_subtype import ModuleSubTypeMessage
-from velbusaio.messages.module_type import ModuleTypeMessage
+from velbusaio.messages.module_type import ModuleType2Message, ModuleTypeMessage
 from velbusaio.messages.module_type_request import ModuleTypeRequestMessage
+from velbusaio.messages.psu_load import PsuLoadMessage
+from velbusaio.messages.psu_values import PsuValuesMessage
 from velbusaio.messages.push_button_status import PushButtonStatusMessage
+from velbusaio.messages.raw import MeteoRawMessage, SensorRawMessage
 from velbusaio.messages.read_data_block_from_memory import (
     ReadDataBlockFromMemoryMessage,
 )
@@ -64,6 +70,7 @@ from velbusaio.messages.receive_buffer_full import ReceiveBufferFullMessage
 from velbusaio.messages.receive_ready import ReceiveReadyMessage
 from velbusaio.messages.relay_status import RelayStatusMessage
 from velbusaio.messages.restore_dimmer import RestoreDimmerMessage
+from velbusaio.messages.select_program import SelectProgramMessage
 from velbusaio.messages.sensor_temp_request import SensorTempRequest
 from velbusaio.messages.sensor_temperature import SensorTemperatureMessage
 from velbusaio.messages.set_date import SetDate
@@ -83,6 +90,9 @@ from velbusaio.messages.switch_to_day import SwitchToDayMessage
 from velbusaio.messages.switch_to_night import SwitchToNightMessage
 from velbusaio.messages.switch_to_safe import SwitchToSafeMessage
 from velbusaio.messages.temp_sensor_settings_part1 import TempSensorSettingsPart1
+from velbusaio.messages.temp_sensor_settings_part2 import TempSensorSettingsPart2
+from velbusaio.messages.temp_sensor_settings_part3 import TempSensorSettingsPart3
+from velbusaio.messages.temp_sensor_settings_part4 import TempSensorSettingsPart4
 from velbusaio.messages.temp_sensor_settings_request import TempSensorSettingsRequest
 from velbusaio.messages.temp_sensor_status import TempSensorStatusMessage
 from velbusaio.messages.temp_set_cooling import TempSetCoolingMessage

velbusaio/messages/blind_status.py

@@ -1,17 +1,19 @@
 """
 :author: Tom Dupré <gitd8400@gmail.com>
 """
+
 from __future__ import annotations
 
 import json
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xEC
 DSTATUS = {0: "off", 1: "up", 2: "down"}
 
 
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class BlindStatusNgMessage(Message):
     """
     sent by: VMB2BLE
@@ -37,7 +39,7 @@ class BlindStatusNgMessage(Message):
         self.channel = self.byte_to_channel(data[0])
         self.timeout = data[1]  # Omzetter seconden ????
         self.status = data[2]
-        self.position = data[4]
+        self.position = data[4]  # 0..255 (0=open, 255=closed)
 
     def to_json(self):
         """
@@ -46,21 +48,19 @@ class BlindStatusNgMessage(Message):
         json_dict = self.to_json_basic()
         json_dict["channel"] = self.channel
         json_dict["timeout"] = self.timeout
+        json_dict["position"] = self.position
         json_dict["status"] = DSTATUS[self.status]
         return json.dumps(json_dict)
 
-    def is_up(self):
-        """
-        :return: bool
-        """
+    def is_moving_up(self) -> bool:
         return self.status == 0x01
 
-    def is_down(self):
-        """
-        :return: bool
-        """
+    def is_moving_down(self) -> bool:
         return self.status == 0x02
 
+    def is_stopped(self) -> bool:
+        return self.status == 0x00
+
     def data_to_binary(self):
         """
         :return: bytes
@@ -79,6 +79,7 @@ class BlindStatusNgMessage(Message):
         )
 
 
+@register(COMMAND_CODE, ["VMB1BL", "VMB2BL"])
 class BlindStatusMessage(Message):
     """
     sent by: VMB2BLE
@@ -107,7 +108,7 @@ class BlindStatusMessage(Message):
         self.channel = self.byte_to_channel(tmp)
         self.timeout = data[1]  # Omzetter seconden ????
         # 2 bits per channel used
-        self.status = data[2] >> ((self.channel - 1) * 2)
+        self.status = (data[2] >> ((self.channel - 1) * 2)) & 0x03
 
     def to_json(self):
         """
@@ -119,21 +120,11 @@ class BlindStatusMessage(Message):
         json_dict["status"] = DSTATUS[self.status]
         return json.dumps(json_dict)
 
-    def is_up(self):
-        """
-        :return: bool
-        """
+    def is_moving_up(self) -> bool:
         return self.status == 0x01
 
-    def is_down(self):
-        """
-        :return: bool
-        """
+    def is_moving_down(self) -> bool:
         return self.status == 0x02
 
-
-register_command(COMMAND_CODE, BlindStatusNgMessage, "VMB1BLE")
-register_command(COMMAND_CODE, BlindStatusNgMessage, "VMB2BLE")
-register_command(COMMAND_CODE, BlindStatusNgMessage, "VMB1BLS")
-register_command(COMMAND_CODE, BlindStatusMessage, "VMB1BL")
-register_command(COMMAND_CODE, BlindStatusMessage, "VMB2BL")
+    def is_stopped(self) -> bool:
+        return self.status == 0x00

velbusaio/messages/bus_active.py

@@ -1,20 +1,17 @@
 """
 :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 = 0x0A
 
 
+@register(COMMAND_CODE)
 class BusActiveMessage(Message):
-    """
-    send by:
-    received by: VMB1USB
-    """
-
     def set_defaults(self, address):
         if address is not None:
             self.set_address(address)
@@ -32,6 +29,3 @@ class BusActiveMessage(Message):
         :return: bytes
         """
         return bytes([COMMAND_CODE])
-
-
-register_command(COMMAND_CODE, BusActiveMessage)

velbusaio/messages/bus_error_counter_status.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 = 0xDA
 
 
+@register(COMMAND_CODE)
 class BusErrorCounterStatusMessage(Message):
     """
     send by: VMB6IN, VMB4RYLD
@@ -45,6 +47,3 @@ class BusErrorCounterStatusMessage(Message):
                 self.bus_off_counter,
             ]
         )
-
-
-register_command(COMMAND_CODE, BusErrorCounterStatusMessage)

velbusaio/messages/bus_error_counter_status_request.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 = 0xD9
 
 
+@register(COMMAND_CODE)
 class BusErrorStatusRequestMessage(Message):
     """
     send by:
@@ -29,6 +31,3 @@ class BusErrorStatusRequestMessage(Message):
         :return: bytes
         """
         return bytes([COMMAND_CODE])
-
-
-register_command(COMMAND_CODE, BusErrorStatusRequestMessage)

velbusaio/messages/bus_off.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 = 0x09
 
 
+@register(COMMAND_CODE)
 class BusOffMessage(Message):
     """
     send by:
@@ -29,6 +31,3 @@ class BusOffMessage(Message):
         :return: bytes
         """
         return bytes([COMMAND_CODE])
-
-
-register_command(COMMAND_CODE, BusOffMessage)

velbusaio/messages/channel_name_part1.py

@@ -1,16 +1,16 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
-from __future__ import annotations
 
-import json
+from __future__ import annotations
 
-from velbusaio.command_registry import register_command
+from velbusaio.command_registry import register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xF0
 
 
+@register(COMMAND_CODE)
 class ChannelNamePart1Message(Message):
     """
     send by: VMB6IN, VMB4RYLD
@@ -44,18 +44,54 @@ class ChannelNamePart1Message(Message):
             self.name, "ascii", "ignore"
         )
 
-    def to_json(self):
-        """
-        :return: str
-        """
-        json_dict = self.to_json_basic()
-        json_dict["channel"] = self.channel
-        return json.dumps(json_dict)
-
 
+@register(
+    COMMAND_CODE,
+    [
+        "VMBGP1",
+        "VMBEL1",
+        "VMBGP1-2",
+        "VMBGP2",
+        "VMBEL2",
+        "VMBGP2-2",
+        "VMBGP4",
+        "VMBEL4",
+        "VMBGP4-2",
+        "VMBGPO",
+        "VMBGPOD",
+        "VMBGPOD-2",
+        "VMBELO",
+        "VMBGP4PIR",
+        "VMBGP4PIR-2",
+        "VMBDMI",
+        "VMBDMI-R",
+        "VMBIN",
+        "VMBKP",
+        "VMBELPIR",
+        "VMBDALI",
+        "VMB4AN",
+        "VMB6PB-20",
+        "VMBEL1-20",
+        "VMBEL2-20",
+        "VMBEL4-20",
+        "VMBELO-20",
+        "VMBGP1-20",
+        "VMBGP2-20",
+        "VMBGP4-20",
+        "VMBGPO-20",
+        "VMBDALI-20",
+        "VMBEL4PIR-20",
+        "VMBGP4PIR-20",
+        "VMB4LEDPWM-20",
+        "VMB8DC-20",
+        "VMB2DC-20",
+        "VMB8IN-20",
+        "VMBPSUMNGR-20",
+    ],
+)
 class ChannelNamePart1Message2(ChannelNamePart1Message):
     """
-    send by: VMBGP*
+    send by: VMBGP*, VMBDALI
     received by:
     """
 
@@ -71,6 +107,7 @@ class ChannelNamePart1Message2(ChannelNamePart1Message):
         self.name = "".join([chr(x) for x in data[1:]])
 
 
+@register(COMMAND_CODE, ["VMB1BL", "VMB2BL"])
 class ChannelNamePart1Message3(ChannelNamePart1Message):
     """
     send by: VMBGP*
@@ -87,24 +124,3 @@ class ChannelNamePart1Message3(ChannelNamePart1Message):
         self.set_attributes(priority, address, rtr)
         self.channel = (data[0] >> 1) & 0x03
         self.name = "".join([chr(x) for x in data[1:]])
-
-
-register_command(COMMAND_CODE, ChannelNamePart1Message)
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP1")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBEL1")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP1-2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBEL2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP2-2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP4")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBEL4")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP4-2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGPO")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGPOD")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGPOD-2")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBELO")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBGP4PIR")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBDMI")
-register_command(COMMAND_CODE, ChannelNamePart1Message2, "VMBDMI-R")
-register_command(COMMAND_CODE, ChannelNamePart1Message3, "VMB1BL")
-register_command(COMMAND_CODE, ChannelNamePart1Message3, "VMB2BL")