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

velbusaio/handler.py

@@ -2,21 +2,30 @@
 Velbus packet handler
 :Author maikel punie <maikel.punie@gmail.com>
 """
+
 from __future__ import annotations
 
 import asyncio
+import importlib.resources
 import json
 import logging
-import re
-from typing import TYPE_CHECKING, Awaitable, Callable
+import os
+import pathlib
+import sys
+import time
+from typing import TYPE_CHECKING
 
-import pkg_resources
+from aiofile import async_open
 
 from velbusaio.command_registry import commandRegistry
-from velbusaio.helpers import h2, keys_exists
-from velbusaio.message import Message
+from velbusaio.const import (
+    SCAN_MODULEINFO_TIMEOUT_INITIAL,
+    SCAN_MODULEINFO_TIMEOUT_INTERVAL,
+    SCAN_MODULETYPE_TIMEOUT,
+)
 from velbusaio.messages.module_subtype import ModuleSubTypeMessage
-from velbusaio.messages.module_type import ModuleTypeMessage
+from velbusaio.messages.module_type import ModuleType2Message, ModuleTypeMessage
+from velbusaio.module import Module
 from velbusaio.raw_message import RawMessage
 
 if TYPE_CHECKING:
@@ -25,32 +34,189 @@ if TYPE_CHECKING:
 
 class PacketHandler:
     """
-    The packetHandler class
+    The PacketHandler class
     """
 
     def __init__(
         self,
-        writer: Callable[[Message], Awaitable[None]],
         velbus: Velbus,
+        one_address: int | None = None,
     ) -> None:
-        self._log = logging.getLogger("velbus-packet")
-        self._writer = writer
+        self._log = logging.getLogger("velbus-handler")
+        self._log.setLevel(logging.DEBUG)
         self._velbus = velbus
+        self._one_address = one_address
+        self._typeResponseReceived = asyncio.Event()
+        self._scanLock = asyncio.Lock()
+        self._fullScanLock = asyncio.Lock()
+        self._modulescan_address = 0
         self._scan_complete = False
-        self._scan_complete_event = asyncio.Event()
-        with open(
-            pkg_resources.resource_filename(__name__, "moduleprotocol/protocol.json")
-        ) as protocol_file:
-            self.pdata = json.load(protocol_file)
-
-    def scan_finished(self) -> None:
-        self._scan_complete = True
-        self._scan_complete_event.set()
-        self._log.debug("Scan complete")
-
-    def scan_started(self) -> None:
-        self._scan_complete = False
-        self._scan_complete_event.clear()
+        self._scan_delay_msec = 0
+        self.__scan_found_addresses: dict[int, ModuleTypeMessage | None] | None = None
+
+    async def read_protocol_data(self):
+        if sys.version_info >= (3, 13):
+            with importlib.resources.path(
+                __name__, "module_spec/broadcast.json"
+            ) as fspath:
+                async with async_open(fspath) as protocol_file:
+                    self.broadcast = json.loads(await protocol_file.read())
+            with importlib.resources.path(
+                __name__, "module_spec/ignore.json"
+            ) as fspath:
+                async with async_open(fspath) as protocol_file:
+                    self.ignore = json.loads(await protocol_file.read())
+        else:
+            async with async_open(
+                str(
+                    importlib.resources.files(__name__.split(".")[0]).joinpath(
+                        "module_spec/broadcast.json"
+                    )
+                )
+            ) as protocol_file:
+                self.broadcast = json.loads(await protocol_file.read())
+            async with async_open(
+                str(
+                    importlib.resources.files(__name__.split(".")[0]).joinpath(
+                        "module_spec/ignore.json"
+                    )
+                )
+            ) as protocol_file:
+                self.ignore = json.loads(await protocol_file.read())
+
+    def empty_cache(self) -> bool:
+        if (
+            len(
+                [
+                    name
+                    for name in os.listdir(f"{self._velbus.get_cache_dir()}")
+                    if os.path.isfile(f"{self._velbus.get_cache_dir()}/{name}")
+                ]
+            )
+            == 0
+        ):
+            return True
+        return False
+
+    async def scan(self, reload_cache: bool = False) -> None:
+        start_address = 1
+        max_address = 254 + 1
+        if self._one_address is not None:
+            start_address = self._one_address
+            max_address = self._one_address + 1
+            self._log.info(
+                f"Scanning only one address {self._one_address} ({self._one_address:#02x})"
+            )
+
+        self._log.info("Start module scan")
+        async with self._fullScanLock:
+            start_time = time.perf_counter()
+            self._scan_complete = False
+
+            self._log.debug("Waiting for Velbus bus to be ready to scan...")
+            await self._velbus.wait_on_all_messages_sent_async()  # don't start a scan while messages are still in the queue
+            self._log.debug("Velbus bus is ready to scan!")
+
+            self._log.info("Sending scan type requests to all addresses...")
+            start_scan_time = time.perf_counter()
+            self.__scan_found_addresses = {}
+            for address in range(start_address, max_address):
+                cfile = pathlib.Path(f"{self._velbus.get_cache_dir()}/{address}.json")
+                if reload_cache and os.path.isfile(cfile):
+                    self._log.info(
+                        f"Reloading cache for address {address} ({address:#02x})"
+                    )
+                    os.remove(cfile)
+
+                self.__scan_found_addresses[address] = None
+                async with self._scanLock:
+                    await self._velbus.sendTypeRequestMessage(address)
+
+            await self._velbus.wait_on_all_messages_sent_async()
+            scan_time = time.perf_counter() - start_scan_time
+            self._log.info(
+                f"Sent scan type requests to all addresses in {scan_time:.2f}. Going to wait for responses..."
+            )
+
+            await asyncio.sleep(SCAN_MODULETYPE_TIMEOUT / 1000)  # wait for responses
+
+            self._log.info(
+                "Waiting for responses done. Going to check for responses..."
+            )
+            for address in range(start_address, max_address):
+                start_module_scan = time.perf_counter()
+                module_type_message: ModuleTypeMessage | None = (
+                    self.__scan_found_addresses[address]
+                )
+                module: Module | None = None
+                if module_type_message is None:
+                    self._log.debug(
+                        f"No module found at address {address} ({address:#02x}). Skipping it."
+                    )
+                    continue
+
+                self._log.info(
+                    f"Found module at address {address} ({address:#02x}): {module_type_message.module_type_name()}"
+                )
+                # cache_file = pathlib.Path(f"{self._velbus.get_cache_dir()}/{address}.json")
+                # TODO: check if cached file module type is the same?
+                await self._handle_module_type(module_type_message)
+                async with self._scanLock:
+                    module = self._velbus.get_module(address)
+
+                if module is None:
+                    self._log.info(
+                        f"Module at address {address} ({address:#02x}) could not be loaded. Skipping it."
+                    )
+                    continue
+
+                try:
+                    self._log.debug(
+                        f"Module {module.get_address()} ({module.get_address():#02x}) detected: start loading"
+                    )
+                    await asyncio.wait_for(
+                        module.load(from_cache=True),
+                        SCAN_MODULEINFO_TIMEOUT_INITIAL / 1000.0,
+                    )
+                    self._scan_delay_msec = module.get_initial_timeout()
+                    while self._scan_delay_msec > 50 and not await module.is_loaded():
+                        # self._log.debug(
+                        #    f"\t... waiting {self._scan_delay_msec} is_loaded={await module.is_loaded()}"
+                        # )
+                        self._scan_delay_msec = self._scan_delay_msec - 50
+                        await asyncio.sleep(0.05)
+                    module_scan_time = time.perf_counter() - start_module_scan
+                    self._log.info(
+                        f"Scan module {address} ({address:#02x}, {module.get_type_name()}) completed in {module_scan_time:.2f}, module loaded={await module.is_loaded()}"
+                    )
+                    await module.wait_for_status_messages()
+                except asyncio.TimeoutError:
+                    self._log.error(
+                        f"Module {address} ({address:#02x}) did not respond to info requests after successful type request"
+                    )
+
+            self._scan_complete = True
+            total_time = time.perf_counter() - start_time
+            self._log.info(f"Module scan completed in {total_time:.2f} seconds")
+
+    async def __handle_module_type_response_async(self, rawmsg: RawMessage) -> None:
+        """
+        Handle a received module type response packet
+        """
+        address = rawmsg.address
+
+        if self.__scan_found_addresses is None:
+            self._log.warning(
+                f"Received module type response for address {address} ({address:#02x}) but no scan in progress"
+            )
+            return
+
+        tmsg: ModuleTypeMessage = ModuleTypeMessage()
+        tmsg.populate(rawmsg.priority, address, rawmsg.rtr, rawmsg.data_only)
+        self._log.debug(
+            f"A '{tmsg.module_type_name()}' ({tmsg.module_type:#02x}) lives on address {address} ({address:#02x})"
+        )
+        self.__scan_found_addresses[address] = tmsg
 
     async def handle(self, rawmsg: RawMessage) -> None:
         """
@@ -67,153 +233,119 @@ class PacketHandler:
         command_value = rawmsg.command
         data = rawmsg.data_only
 
-        if command_value == 0xFF and not self._scan_complete:
-            msg = ModuleTypeMessage()
-            msg.populate(priority, address, rtr, data)
-            self._log.debug(f"Received {msg}")
-            await self._handle_module_type(msg)
+        # handle module type response message
+        if command_value == 0xFF:
+            await self.__handle_module_type_response_async(rawmsg)
+
+        # handle module subtype response message
         elif command_value in (0xB0, 0xA7, 0xA6) and not self._scan_complete:
-            msg = ModuleSubTypeMessage()
+            msg: ModuleSubTypeMessage = ModuleSubTypeMessage()
             msg.populate(priority, address, rtr, data)
-
             if command_value == 0xB0:
                 msg.sub_address_offset = 0
             elif command_value == 0xA7:
                 msg.sub_address_offset = 4
             elif command_value == 0xA6:
                 msg.sub_address_offset = 8
-            else:
-                raise RuntimeError("Unreachable code reached => bug here")
+            async with self._scanLock:
+                self._scan_delay_msec += SCAN_MODULEINFO_TIMEOUT_INTERVAL
+                self._handle_module_subtype(msg)
 
-            self._log.debug(f"Received {msg}")
-            await self._handle_module_subtype(msg)
-        elif command_value in self.pdata["MessagesBroadCast"]:
+        # ignore broadcast
+        elif command_value in self.broadcast:
             self._log.debug(
                 "Received broadcast message {} from {}, ignoring".format(
-                    self.pdata["MessageBroadCast"][command_value.upper()], address
+                    self.broadcast[str(command_value).upper()], address
                 )
             )
-        elif address in self._velbus.get_modules().keys():
-            module_type = self._velbus.get_module(address).get_type()
-            if commandRegistry.has_command(int(command_value), module_type):
-                command = commandRegistry.get_command(command_value, module_type)
-                msg = command()
-                msg.populate(priority, address, rtr, data)
-                self._log.debug(f"Received {msg}")
-                # send the message to the modules
-                await self._velbus.get_module(msg.address).on_message(msg)
-            else:
-                self._log.warning(
-                    "NOT FOUND IN command_registry: addr={} cmd={} packet={}".format(
-                        address, command_value, ":".join(format(x, "02x") for x in data)
-                    )
-                )
-        elif self._scan_complete:
-            # this should only happen once the scan is complete, of its not complete suspended the error message
-            self._log.warning(
-                "UNKNOWN module, you should initialize a full new velbus scan: packet={}, address={}, modules={}".format(
-                    ":".join(format(x, "02x") for x in data),
-                    address,
-                    self._velbus.get_modules().keys(),
+
+        # ignore messages
+        elif command_value in self.ignore:
+            self._log.debug(
+                "Received ignored message {} from {}, ignoring".format(
+                    self.ignore[str(command_value).upper()], address
                 )
             )
 
-    # def _handle_message(self, rawMsg: RawMessage) -> None:
-    #    module_type = self._velbus.get_module(rawMsg.address).get_type()
-    #    this_msg = keys_exists(
-    #        self.pdata, "ModuleTypes", h2(module_type), "Messages", h2(rawMsg.command), "Data"
-    #    )
-    #    if this_msg and "PerByte" in this_msg:
-    #        self._per_byte(this_msg["PerByte"], rawMsg)
-
-    # def _per_byte(self, cmsg, rawMsg: RawMessage) -> dict:
-    #    result = {}
-    #    byte_index = 0
-    #    for byte in rawMsg.data:
-    #        num = str(byte_index)
-    #        # only do something if its defined
-    #        if num not in cmsg:
-    #            continue
-    #        # check if we can do a binary match
-    #        for mat in cmsg[num]["Match"]:
-    #            if (
-    #                (mat.startswith("%") and re.match(mat[1:], f"{byte:08b}"))
-    #                or mat == f"{byte:08b}"
-    #                or mat == f"{byte:02x}"
-    #            ):
-    #                result = self._per_byte_handle(
-    #                    result, cmsg[num]["Match"][mat], byte
-    #                )
-    #        byte_index += 1
-    #    return result
-
-    # def _per_byte_handle(self, result: dict, todo: dict, byte: int) -> dict:
-    #    if "Channel" in todo:
-    #        result["Channel"] = todo["Channel"]
-    #    if "Value" in todo:
-    #        result["Value"] = todo["Value"]
-    #    if "Convert" in todo:
-    #        result["ValueList"] = []
-    #        if todo["Convert"] == "Decimal":
-    #            result["ValueList"].append(int(byte))
-    #        elif todo["Convert"] == "Counter":
-    #            result["ValueList"].append(f"{byte:02x}")
-    #        elif todo["Convert"] == "Temperature":
-    #            print("CONVERT temperature")
-    #        elif todo["Convert"] == "Divider":
-    #            bin_str = f"{byte:08b}"
-    #            chan = bin_str[6:]
-    #            val = bin_str[:5]
-    #            print(f"CONVERT Divider {chan} {val}")
-    #        elif todo["Convert"] == "Channel":
-    #            print("CONVERT Channel")
-    #        elif todo["Convert"] == "ChannelBit":
-    #            print("CONVERT ChannelBit")
-    #        elif todo["Convert"].startswith("ChannelBitStatus"):
-    #            print("CONVERT ChannelBitStatus")
-    #        else:
-    #            self._log.error("UNKNOWN convert requested: {}".format(todo["Convert"]))
-    #    return result
-
-    async def _handle_module_type(self, msg: Message) -> None:
+        # handle other messages for modules that are already scanned
+        else:
+            module = None
+            async with self._scanLock:
+                module = self._velbus.get_module(address)
+            if module is not None:
+                module_type = module.get_type()
+                if commandRegistry.has_command(int(command_value), module_type):
+                    command = commandRegistry.get_command(command_value, module_type)
+                    if not command:
+                        return
+                    msg = command()
+                    msg.populate(priority, address, rtr, data)
+                    # restart the info completion time when info message received
+                    if command_value in (
+                        0xF0,
+                        0xF1,
+                        0xF2,
+                        0xFB,
+                        0xFE,
+                        0xCC,
+                    ):  # names, memory data, memory block
+                        self._scan_delay_msec += SCAN_MODULEINFO_TIMEOUT_INTERVAL
+                        # self._log.debug(f"Restart timeout {msg}")
+                    # send the message to the modules
+                    await module.on_message(msg)
+                else:
+                    self._log.warning(f"NOT FOUND IN command_registry: {rawmsg}")
+
+    async def _handle_module_type(
+        self, msg: ModuleTypeMessage | ModuleType2Message
+    ) -> None:
         """
         load the module data
         """
-        data = keys_exists(self.pdata, "ModuleTypes", h2(msg.module_type))
-        if not data:
-            self._log.warning(f"Module not recognized: {msg.module_type}")
-            return
-        # create the module
-        await self._velbus.add_module(
-            msg.address,
-            msg.module_type,
-            data,
-            memorymap=msg.memory_map_version,
-            build_year=msg.build_year,
-            build_week=msg.build_week,
-            serial=msg.serial,
-        )
+        if msg is not None:
+            module = self._velbus.get_module(msg.address)
+            if module is None:
+                # data = keys_exists(self.pdata, "ModuleTypes", h2(msg.module_type))
+                # if not data:
+                #    self._log.warning(f"Module not recognized: {msg.module_type}")
+                #    return
+                await self._velbus.add_module(
+                    msg.address,
+                    msg.module_type,
+                    memorymap=msg.memory_map_version,
+                    build_year=msg.build_year,
+                    build_week=msg.build_week,
+                    serial=msg.serial,
+                )
+            else:
+                self._log.debug(
+                    f"***Module already exists scanAddr={self._modulescan_address} addr={msg.address} {msg}"
+                )
 
-    async def _handle_module_subtype(self, msg: Message) -> None:
-        if msg.address not in self._velbus.get_modules():
-            return
-        addrList = {
-            (msg.sub_address_offset + 1): msg.sub_address_1,
-            (msg.sub_address_offset + 2): msg.sub_address_2,
-            (msg.sub_address_offset + 3): msg.sub_address_3,
-            (msg.sub_address_offset + 4): msg.sub_address_4,
-        }
-        await self._velbus.add_submodules(msg.address, addrList)
-
-    def _channel_convert(self, module: str, channel: str, ctype: str) -> None | int:
-        data = keys_exists(
-            self.pdata, "ModuleTypes", h2(module), "ChannelNumbers", ctype
-        )
-        if data and "Map" in data and h2(channel) in data["Map"]:
-            return data["Map"][h2(channel)]
-        if data and "Convert" in data:
-            return int(channel)
-        for offset in range(0, 8):
-            if channel & (1 << offset):
-                return offset + 1
-        return None
+        # else:
+        #    self._log.debug("*** handle_module_type called without response message")
+
+    def _handle_module_subtype(self, msg: ModuleSubTypeMessage) -> None:
+        module = self._velbus.get_module(msg.address)
+        if module is not None:
+            addrList = {
+                (msg.sub_address_offset + 1): msg.sub_address_1,
+                (msg.sub_address_offset + 2): msg.sub_address_2,
+                (msg.sub_address_offset + 3): msg.sub_address_3,
+                (msg.sub_address_offset + 4): msg.sub_address_4,
+            }
+            self._velbus.add_submodules(module, addrList)
+
+
+#    def _channel_convert(self, module: str, channel: str, ctype: str) -> None | int:
+#        data = keys_exists(
+#            self.pdata, "ModuleTypes", h2(module), "ChannelNumbers", ctype
+#        )
+#        if data and "Map" in data and h2(channel) in data["Map"]:
+#            return data["Map"][h2(channel)]
+#        if data and "Convert" in data:
+#            return int(channel)
+#        for offset in range(0, 8):
+#            if channel & (1 << offset):
+#                return offset + 1
+#        return None

velbusaio/helpers.py

@@ -1,11 +1,12 @@
 """
 Helper functions
 """
+
 from __future__ import annotations
 
 import os
 import re
-from typing import Any, Dict
+from typing import Any
 
 from velbusaio.const import CACHEDIR
 

velbusaio/message.py

@@ -1,10 +1,11 @@
 """
 The velbus abstract message class
 """
+
 from __future__ import annotations
 
+import enum
 import json
-from typing import Optional
 
 from velbusaio.const import PRIORITY_FIRMWARE, PRIORITY_HIGH, PRIORITY_LOW
 
@@ -20,19 +21,19 @@ 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:
+    def set_attributes(self, priority: int, address: int, rtr: bool) -> None:
         self.priority = priority
         self.address = address
         self.rtr = rtr
 
-    def populate(self, priority: int, address: int, rtr: int, data: int) -> None:
+    def populate(self, priority: int, address: int, rtr: bool, data: int) -> None:
         raise NotImplementedError
 
     def set_defaults(self, address: int | None) -> None:
@@ -65,8 +66,13 @@ class Message:
                 continue
             if callable(getattr(self, key)) or key.startswith("__"):
                 del me[key]
-            if isinstance(me[key], (bytes, bytearray)):
-                me[key] = str(me[key], "utf-8")
+            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:

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,6 +33,7 @@ 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
@@ -50,13 +52,15 @@ 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.raw import MeteoRawMessage, SensorRawMessage
 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, ModuleType2Message
+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,
 )

velbusaio/messages/blind_status.py

@@ -1,6 +1,7 @@
 """
 :author: Tom Dupré <gitd8400@gmail.com>
 """
+
 from __future__ import annotations
 
 import json
@@ -12,7 +13,7 @@ COMMAND_CODE = 0xEC
 DSTATUS = {0: "off", 1: "up", 2: "down"}
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class BlindStatusNgMessage(Message):
     """
     sent by: VMB2BLE
@@ -38,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):
         """
@@ -47,6 +48,7 @@ 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)
 

velbusaio/messages/bus_active.py

@@ -1,6 +1,7 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
 from velbusaio.command_registry import register

velbusaio/messages/bus_error_counter_status.py

@@ -1,6 +1,7 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
 from velbusaio.command_registry import register

velbusaio/messages/bus_error_counter_status_request.py

@@ -1,6 +1,7 @@
 """
 :author: Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
 from velbusaio.command_registry import register