velbus-aio 2025.4.2__py3-none-any.whl → 2025.8.0__py3-none-any.whl

{velbus_aio-2025.4.2.dist-info → velbus_aio-2025.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velbus-aio
-Version: 2025.4.2
+Version: 2025.8.0
 Summary: Open-source home automation platform running on Python 3.
 Author-email: Maikel Punie <maikel.punie@gmail.com>
 License: MIT

{velbus_aio-2025.4.2.dist-info → velbus_aio-2025.8.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
-velbus_aio-2025.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+velbus_aio-2025.8.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 velbusaio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velbusaio/channels.py,sha256=pR-y7Res_MAPSFEM62eLx844HU0EjX7SyyEpJT4YU74,23556
 velbusaio/command_registry.py,sha256=nlx4__0ASr5WurOYLC-HEqswlg_qm3Y5trs4V8FhnvU,5350
 velbusaio/const.py,sha256=aHClMaMS6NINTCrjeRwLbVzdvS91VgFKM8j61ks5tn0,1862
-velbusaio/controller.py,sha256=Ohc-18ydnm76-5fOD_b24Aa_uYu6CdkI3ulfhska5og,8887
+velbusaio/controller.py,sha256=zvkd8JWHZEKk9rg0GOAGRR3OS97B2ugQkeKQh-ucaFA,9111
 velbusaio/discovery.py,sha256=Px6qoZl4QhF17aMz6JxstCORBpLzZGWEK9h4Vyvg57o,1649
 velbusaio/exceptions.py,sha256=FHkXaM3dK5Gkk-QGAf9dLE3FPlCU2FRZWUyY-4KRNnA,515
-velbusaio/handler.py,sha256=gkRikfrTzekL0hFQSUV0AjVuMoUY1DNONEhbRBKyRko,11901
+velbusaio/handler.py,sha256=7F5E3vkkptk6alOTg0dIpyF5Uqd6xpzXoJMXkmR9r58,13126
 velbusaio/helpers.py,sha256=iqpoereRH4JY5WAkozIqWvXWyRmhko-J-UGXDylFyEM,2537
-velbusaio/message.py,sha256=_MRuI4XnMcqeduCDJ3AwhAPL1B8VMstFDnjjLo8QuxM,5018
-velbusaio/module.py,sha256=y5uegbCl0vowBqoeagycRjP6FPLDPaGJ4ZJeW22wMqA,37631
-velbusaio/protocol.py,sha256=RIpdL0vPlL4qE4bC8sEZSD0SRS4tWtR9MdzjTPSd2zs,8002
+velbusaio/message.py,sha256=Qzdx6Qrk-DptRnkdfirp5jEKA4hoANtPHfAxvWHzpvU,5305
+velbusaio/module.py,sha256=kVaOp8ZLTSA4OMyTxKx4fJDAQw39teIxdtLagWsrCdc,38975
+velbusaio/protocol.py,sha256=59Qdw2bZ9wL4_XmxvqRD8R1LJoWfrwRRaCOM3KGa0x0,8808
 velbusaio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velbusaio/raw_message.py,sha256=ODoTPVAvyXXQSMXxtQO1U5OxcoQ4W8JJN5fotEDGSTo,4690
 velbusaio/util.py,sha256=FW6YCiPYWOCgqHDs8-LbzME0h81mqftYVG0qqZ-oo7Y,1568
-velbusaio/vlp_reader.py,sha256=mHhp0Le-u8PT0Nk3glZrB7qK4JFR906NyB-nHDlnYC8,1039
+velbusaio/vlp_reader.py,sha256=2oSbBOR2bgaSGnL1JP8TJaHgbY20ZgmCfSivtINuiR8,3997
 velbusaio/messages/__init__.py,sha256=2Zgrk4VBoSJXKYhwS18gxuiE96jDvnpBBjeYI1yHjqs,6072
 velbusaio/messages/blind_status.py,sha256=q2CQgcU1ZsXMyjR2co8Eegj0LZRDfRqvpCTVvjovNWA,3432
 velbusaio/messages/bus_active.py,sha256=AB1mEvbMXRuOaC2CQ7hzKSLmbaJnyFqqXrARi-aSdtg,749
@@ -35,9 +35,9 @@ velbusaio/messages/cover_position.py,sha256=_BgQz3DqZGirXDthj7xq72hxr51FYv2tyrdC
 velbusaio/messages/cover_up.py,sha256=iFPCWuRhIc54oMQAFz5DZsUW23673_nNHoPFJC_HA_c,2561
 velbusaio/messages/dali_device_settings.py,sha256=KzJ7OFkFRPuCXSOThuplM48J_kH0I3RE82ZRCpmiqYA,4870
 velbusaio/messages/dali_device_settings_request.py,sha256=InTnrwLD7l9gCHXKlJ69FHMXcejtYMUZBtnffx9nDQU,1476
-velbusaio/messages/dali_dim_value_status.py,sha256=Kgtfb65HCku4OBm6uaxKFpK3VtlYaTemSjMhZqngqkY,1059
+velbusaio/messages/dali_dim_value_status.py,sha256=MS3bWgBYUsQ9w7jrRRUI8QoQmziTVCYExfweAezT2E0,1089
 velbusaio/messages/dimmer_channel_status.py,sha256=v3VszfQoPY05Dt3yzyWIlOJTKSXE1IP044x1x_sLHj4,2501
-velbusaio/messages/dimmer_status.py,sha256=pWsWXJGWmYGio4FyUktI9aYnIBQkGCQ5ZwaeqnenYsU,2938
+velbusaio/messages/dimmer_status.py,sha256=AikJN-jfdFy8rXrGMSMfrhFcYE1yHlorffxk-bcKCXU,3067
 velbusaio/messages/edge_set_color.py,sha256=YhxTv-WtDrZ_O67Ro6V-bcHrxj3tyBI1GuzTI5LkIVw,3306
 velbusaio/messages/edge_set_custom_color.py,sha256=Lz-7prBveqPwuDWv2Mn13X9TAXGBEquw8xz2_y9NtTk,1338
 velbusaio/messages/fast_blinking_led.py,sha256=_AaG6NcjzG_cBNARogzu56l7DNpGU11XGrDHIkMuKss,909
@@ -54,7 +54,7 @@ velbusaio/messages/memory_dump_request.py,sha256=xrPsdpygD9DUF3lp-BzJacuq1dNkqz2
 velbusaio/messages/module_status.py,sha256=Y2OQUzijtA27snTEVHlyoOrcaLQbSq_3KHKAVDLGR_o,6662
 velbusaio/messages/module_status_request.py,sha256=s3h8F6Dpmjcb4hqDQKIzdOgocW1F_st40cctcW7WmQ4,961
 velbusaio/messages/module_subtype.py,sha256=KG-OC0eW-ZRnP1P8EWmcay6O-no6Mn2cklEjokaIW9M,1487
-velbusaio/messages/module_type.py,sha256=pzIs4VmPRpquV-Z6UJg8dpwXp0TTGTLpoBNuqSY1t1I,4221
+velbusaio/messages/module_type.py,sha256=l5CCLWdsYPxCB4yXrtnJFU9nbKUWTHgIUj-8d2yNRBQ,4373
 velbusaio/messages/module_type_request.py,sha256=fntMYCF1WVwSseCy3zRoZQH6JeGz8JDfTkwHC3AvcB4,754
 velbusaio/messages/psu_load.py,sha256=001KIz84CbnC54gHxhfAiNbcEMRpVUBzDwQ7T-yxY8s,1232
 velbusaio/messages/psu_values.py,sha256=Yd_ndU8yIei7CoL2NV6FHCefO5h_gzRsPNUYxGUGP0o,1300
@@ -121,7 +121,7 @@ velbusaio/module_spec/13.json,sha256=reXGXbaTfVVmLekrXHlfzjsV424bb0ozG7q-PxDv27U
 velbusaio/module_spec/14.json,sha256=ym2T2jCds-lC7QBZr7mqb0L9PlSmQflwpFnlEDxByjk,161
 velbusaio/module_spec/15.json,sha256=VDkI3bJRZgpfAsCiEzRJls7Hj7spmaKZ6XR8TjyymAQ,2698
 velbusaio/module_spec/16.json,sha256=9sdbNwyQQRkGsd477Oyu279tRcSydQC0bGwSQrhnVTU,3459
-velbusaio/module_spec/17.json,sha256=WeWeIV6euBGkPq7jBv5rbSykZwhDP6nPzrfk7rrYz-w,3490
+velbusaio/module_spec/17.json,sha256=bLZ7JDt58vZUxPT6JY1xYeWWb1-jHkOhpBRUghjkQSA,3714
 velbusaio/module_spec/18.json,sha256=ylZ7_86DYCkHxk40ZqsGYEkLeUslZ_-b_ftUihfJ2bQ,3484
 velbusaio/module_spec/1A.json,sha256=dvIxgufmgIhZhsBuVEa27KmukJyvnFciorqpxwRNWFM,2581
 velbusaio/module_spec/1B.json,sha256=JbHvdmoRnsqyqhCItsTOP-UK_Yz_ha1Km9CXDe68YVc,3159
@@ -184,7 +184,7 @@ velbusaio/module_spec/5C.json,sha256=yw_XlccuFp-buRL_NXThwQLwblVRa0diLpUDm9Exrg0
 velbusaio/module_spec/5F.json,sha256=ebSwLMUW5A4LCRGOrF-vwxSVvrWZMNUWz10Xrmz7SwM,1259
 velbusaio/module_spec/60.json,sha256=Teih3jAybl5AELjY3gFbZrFN0RIMSU1yuvdsYZlMvTo,74
 velbusaio/module_spec/broadcast.json,sha256=L2Sc9FhZ7NOuu7K5g5jAhvUQGDP6a2CKrg-uWh_v-sA,2250
-velbus_aio-2025.4.2.dist-info/METADATA,sha256=WSJ0-GV-TmG0ZqKE5t87kTenc4-PSzEEO-j1kn9QWmw,4562
-velbus_aio-2025.4.2.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-velbus_aio-2025.4.2.dist-info/top_level.txt,sha256=W0-lSOwD23mm8FqaIe9vY20fKicBMIdUVjF-zmfxRnY,15
-velbus_aio-2025.4.2.dist-info/RECORD,,
+velbus_aio-2025.8.0.dist-info/METADATA,sha256=xIAwPhzJOI2M9SgDscvXyYKzwdXuR9YShcwDVYfJ3GM,4562
+velbus_aio-2025.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velbus_aio-2025.8.0.dist-info/top_level.txt,sha256=W0-lSOwD23mm8FqaIe9vY20fKicBMIdUVjF-zmfxRnY,15
+velbus_aio-2025.8.0.dist-info/RECORD,,

{velbus_aio-2025.4.2.dist-info → velbus_aio-2025.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

velbusaio/controller.py

@@ -17,7 +17,6 @@ from velbusaio.channels import (
     Blind,
     Button,
     ButtonCounter,
-    Channel,
     Dimmer,
     EdgeLit,
     LightSensor,
@@ -61,7 +60,7 @@ class Velbus:
         self._closing = False
         self._auto_reconnect = True
 
-        self._dsn = dsn
+        self._destination = dsn
         self._handler = PacketHandler(self, one_address)
         self._modules: dict[int, Module] = {}
         self._submodules: list[int] = []
@@ -146,12 +145,12 @@ class Velbus:
         """Connect to the bus and load all the data."""
         await self._handler.read_protocol_data()
         # connect to the bus
-        if ":" in self._dsn:
+        if ":" in self._destination:
             # tcp/ip combination
-            if not re.search(r"^[A-Za-z0-9+.\-]+://", self._dsn):
+            if not re.search(r"^[A-Za-z0-9+.\-]+://", self._destination):
                 # if no scheme, then add the tcp://
-                self._dsn = f"tcp://{self._dsn}"
-            parts = urlparse(self._dsn)
+                self._destination = f"tcp://{self._destination}"
+            parts = urlparse(self._destination)
             if parts.scheme == "tls":
                 ctx = ssl._create_unverified_context()
             else:
@@ -176,7 +175,7 @@ class Velbus:
                     await serial_asyncio_fast.create_serial_connection(
                         asyncio.get_event_loop(),
                         lambda: self._protocol,
-                        url=self._dsn,
+                        url=self._destination,
                         baudrate=38400,
                         bytesize=serial.EIGHTBITS,
                         parity=serial.PARITY_NONE,
@@ -190,7 +189,7 @@ class Velbus:
 
     async def start(self) -> None:
         # if auth is required send the auth key
-        parts = urlparse(self._dsn)
+        parts = urlparse(self._destination)
         if parts.username:
             await self._protocol.write_auth_key(parts.username)
         # scan the bus
@@ -277,3 +276,7 @@ class Velbus:
         await self.send(SetRealtimeClock(wday=lclt[6], hour=lclt[3], min=lclt[4]))
         await self.send(SetDate(day=lclt[2], mon=lclt[1], year=lclt[0]))
         await self.send(SetDaylightSaving(ds=not lclt[8]))
+
+    async def wait_on_all_messages_sent_async(self) -> None:
+        """Wait for all messages to be sent."""
+        await self._protocol.wait_on_all_messages_sent_async()

velbusaio/handler.py

@@ -11,9 +11,9 @@ import json
 import logging
 import os
 import pathlib
-import pprint
 import sys
-from typing import TYPE_CHECKING, Awaitable, Callable
+import time
+from typing import TYPE_CHECKING
 
 from aiofile import async_open
 
@@ -23,10 +23,9 @@ from velbusaio.const import (
     SCAN_MODULEINFO_TIMEOUT_INTERVAL,
     SCAN_MODULETYPE_TIMEOUT,
 )
-from velbusaio.helpers import h2, keys_exists
-from velbusaio.message import Message
 from velbusaio.messages.module_subtype import ModuleSubTypeMessage
 from velbusaio.messages.module_type import ModuleType2Message, ModuleTypeMessage
+from velbusaio.module import Module
 from velbusaio.raw_message import RawMessage
 
 if TYPE_CHECKING:
@@ -35,7 +34,7 @@ if TYPE_CHECKING:
 
 class PacketHandler:
     """
-    The packetHandler class
+    The PacketHandler class
     """
 
     def __init__(
@@ -49,9 +48,11 @@ class PacketHandler:
         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_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):
@@ -85,84 +86,123 @@ class PacketHandler:
         return False
 
     async def scan(self, reload_cache: bool = False) -> None:
-        if reload_cache:
-            self._modulescan_address = 0
-            self._scan_complete = False
-        # non-blocking check to see if the cache_dir is empty
-        loop = asyncio.get_running_loop()
-        if not reload_cache and await loop.run_in_executor(None, self.empty_cache):
-            self._log.info("No cache yet, so forcing a bus scan")
-            reload_cache = True
+        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")
-        while self._modulescan_address < 254:
-            address = 0
-            module = None
-            async with self._scanLock:
-                self._modulescan_address = self._modulescan_address + 1
-                address = self._modulescan_address
-                if self._velbus.addr_is_submodule(address):
+        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"Skipping submodule address {address}, already handled"
+                        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"Starting handling scan {address}")
-                module = self._velbus.get_module(address)
 
-            if self._one_address is not None and address != int(self._one_address):
                 self._log.info(
-                    f"Skipping address {address} as we requested to only scan one address {self._one_address}"
+                    f"Found module at address {address} ({address:#02x}): {module_type_message.module_type_name()}"
                 )
-                continue
-
-            cfile = pathlib.Path(f"{self._velbus.get_cache_dir()}/{address}.json")
-            # cleanup the old module cache if needed
-            scanModule = reload_cache
-            if scanModule and os.path.isfile(cfile):
-                os.remove(cfile)
-            elif os.path.isfile(cfile):
-                scanModule = os.path.isfile(cfile)
-            if scanModule:
+                # 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.info(f"Starting scan {address}")
-                    self._typeResponseReceived.clear()
-                    await self._velbus.sendTypeRequestMessage(address)
+                    self._log.debug(
+                        f"Module {module.get_address()} ({module.get_address():#02x}) detected: start loading"
+                    )
                     await asyncio.wait_for(
-                        self._typeResponseReceived.wait(),
-                        SCAN_MODULETYPE_TIMEOUT / 1000.0,
+                        module.load(from_cache=True),
+                        SCAN_MODULEINFO_TIMEOUT_INITIAL / 1000.0,
                     )
-                    async with self._scanLock:
-                        module = self._velbus.get_module(address)
-                except asyncio.TimeoutError:
+                    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} failed: not present or unavailable"
+                        f"Scan module {address} ({address:#02x}, {module.get_type_name()}) completed in {module_scan_time:.2f}, module loaded={await module.is_loaded()}"
                     )
-                if module is not None:
-                    try:
-                        self._log.debug(
-                            f"Module {module._address} 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)
-                        self._log.info(
-                            f"Scan module {address} completed, module loaded={await module.is_loaded()}"
-                        )
-                    except asyncio.TimeoutError:
-                        self._log.error(
-                            f"Module {address} did not respond to info requests after successful type request"
-                        )
-        self._scan_complete = True
-        self._log.info("Module scan completed")
+                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:
         """
@@ -180,20 +220,8 @@ class PacketHandler:
         data = rawmsg.data_only
 
         # handle module type response message
-        if command_value == 0xFF and not self._scan_complete:
-            tmsg: ModuleTypeMessage = ModuleTypeMessage()
-            tmsg.populate(priority, address, rtr, data)
-            async with self._scanLock:
-                await self._handle_module_type(tmsg)
-                if address == self._modulescan_address:
-                    self._typeResponseReceived.set()
-                else:
-                    self._log.debug(
-                        f"Unexpected module type message module address {address}, Velbuslink scan?"
-                    )
-                    self._modulescan_address = address - 1
-
-            self._typeResponseReceived.set()
+        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:

velbusaio/message.py

@@ -4,6 +4,7 @@ The velbus abstract message class
 
 from __future__ import annotations
 
+import enum
 import json
 
 from velbusaio.const import PRIORITY_FIRMWARE, PRIORITY_HIGH, PRIORITY_LOW
@@ -65,8 +66,13 @@ class Message:
                 continue
             if callable(getattr(self, key)) or key.startswith("__"):
                 del me[key]
-            if isinstance(me[key], (bytes, bytearray)):
+            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/dali_dim_value_status.py

@@ -10,7 +10,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0xA5
 
 
-@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20"])
+@register(COMMAND_CODE, ["VMBDALI", "VMBDALI-20", "VMB8DC-20", "VMB4LEDPWM-20"])
 class DimValueStatus(Message):
     """
     send by: VMBDALI

velbusaio/messages/dimmer_status.py

@@ -25,7 +25,18 @@ LED_FAST_BLINKING = 1 << 5
 LED_VERY_FAST_BLINKING = 1 << 4
 
 
-@register(COMMAND_CODE, ["VMB1DM", "VMBDME", "VMB1LED"])
+@register(
+    COMMAND_CODE,
+    [
+        "VMB1DM",
+        "VMBDME",
+        "VMB1LED",
+        "VMBDALI",
+        "VMBDALI-20",
+        "VMB8DC-20",
+        "VMB4LEDPWM-20",
+    ],
+)
 class DimmerStatusMessage(Message):
     """
     sent by: VMBDME

velbusaio/messages/module_type.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import struct
 
-from velbusaio.command_registry import register
+from velbusaio.command_registry import MODULE_DIRECTORY, register
 from velbusaio.message import Message
 
 COMMAND_CODE = 0xFF
@@ -110,11 +110,16 @@ class ModuleTypeMessage(Message):
         self.build_week = 0
         self.set_defaults(address)
 
-    def module_name(self) -> str:
+    def module_type_name(self) -> str:
         """
         :return: str
         """
-        return "Unknown"
+
+        return (
+            MODULE_DIRECTORY[self.module_type]
+            if self.module_type in MODULE_DIRECTORY
+            else "Unknown"
+        )
 
     def populate(self, priority, address, rtr, data) -> None:
         """

velbusaio/module.py

@@ -165,6 +165,7 @@ class Module:
         self._is_loading = False
         self._channels = {}
         self.loaded = False
+        self._loaded_cache = {}
 
     def get_initial_timeout(self) -> int:
         return SCAN_MODULEINFO_TIMEOUT_INITIAL
@@ -243,6 +244,9 @@ class Module:
             d["channels"][num] = chan.to_cache()
         return d
 
+    def get_address(self) -> int:
+        return self._address
+
     def get_addresses(self) -> list:
         """
         Get all addresses for this module
@@ -550,6 +554,10 @@ class Module:
             await self._update_channel(
                 message.channel, {"power": message.power, "energy": message.energy}
             )
+        elif isinstance(message, DimValueStatus):
+            for offset, dim_value in enumerate(message.dim_values):
+                channel = message.channel + offset
+                await self._update_channel(channel, {"state": dim_value})
 
     async def _update_channel(self, channel: int, updates: dict):
         try:
@@ -569,12 +577,8 @@ class Module:
         # start the loading
         self._is_loading = True
         # see if we have a cache
-        try:
-            cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.json")
-            async with async_open(cfile, "r") as fl:
-                cache = json.loads(await fl.read())
-        except OSError:
-            cache = {}
+        cache = await self._get_cache()
+        self._loaded_cache = cache
         # load default channels
         await self._load_default_channels()
 
@@ -589,8 +593,8 @@ class Module:
         if "channels" in cache:
             for num, chan in cache["channels"].items():
                 self._channels[int(num)]._name = chan["name"]
-                if "sub_device" in chan:
-                    self._channels[int(num)]._sub_device = chan["sub_device"]
+                if "subdevice" in chan:
+                    self._channels[int(num)]._sub_device = chan["subdevice"]
                 else:
                     self._channels[int(num)]._sub_device = False
                 if "Unit" in chan:
@@ -604,6 +608,15 @@ class Module:
         self._is_loading = False
         await self._request_module_status()
 
+    async def _get_cache(self):
+        try:
+            cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.json")
+            async with async_open(cfile, "r") as fl:
+                cache = json.loads(await fl.read())
+        except OSError:
+            cache = {}
+        return cache
+
     def _load(self) -> None:
         """
         Method for per module type loading
@@ -857,7 +870,25 @@ class VmbDali(Module):
                     if message.channel in self._channels:
                         del self._channels[message.channel]
                 elif message.data.device_type == DaliDeviceType.LedModule:
-                    if self._channels.get(message.channel).__class__ != Dimmer:
+                    cache = self._loaded_cache
+                    if (
+                        "channels" in cache
+                        and str(message.channel) in cache["channels"]
+                        and cache["channels"][str(message.channel)]["type"] == "Dimmer"
+                    ):
+                        # If we have a cached dimmer channel, use that name
+                        name = cache["channels"][str(message.channel)]["name"]
+                        self._channels[message.channel] = Dimmer(
+                            self,
+                            message.channel,
+                            name,
+                            False,  # set False to enable an already loaded Dimmer
+                            True,
+                            self._writer,
+                            self._address,
+                            slider_scale=254,
+                        )
+                    elif self._channels.get(message.channel).__class__ != Dimmer:
                         # New or changed type, replace channel:
                         self._channels[message.channel] = Dimmer(
                             self,
@@ -914,8 +945,6 @@ class VmbDali(Module):
         else:
             return await super().on_message(message)
 
-        await self._cache()
-
     async def _request_channel_name(self) -> None:
         # Channel names are requested after channel scan
         # don't do them here (at initialization time)

velbusaio/module_spec/17.json

@@ -113,7 +113,17 @@
       "03FE": { "ModuleName": "62" },
       "03FF": { "ModuleName": "64:Save" }
     },
-    "ModuleName": "03C0-03FF"
+    "ModuleName": "03C0-03FF",
+    "Channels": {
+      "01": "0000-000F",
+      "02": "0010-001F",
+      "03": "0020-002F",
+      "04": "0030-003F",
+      "05": "0040-004F",
+      "06": "0050-005F",
+      "07": "0060-006F",
+      "08": "0070-007F"
+    }
   },
   "Type": "VMB6PBN"
 }

velbusaio/protocol.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import binascii
 import logging
+import time
 import typing as t
 from asyncio import transports
 
@@ -180,20 +181,22 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         await self._write_transport_lock.acquire()
         while self._restart_writer:
             # wait for an item from the queue
-            msg_info = await self._send_queue.get()
+            msg_info: RawMessage | None = await self._send_queue.get()
             if msg_info is None:
                 self._restart_writer = False
                 return
             message_sent = False
             try:
+                start_time = time.perf_counter()
                 while not message_sent:
                     message_sent = await self._write_message(msg_info)
-                if msg_info.command == 0xEF:
-                    # 'channel name request' command provokes in worst case 99 answer packets from VMBGPOD
-                    queue_sleep_time = SLEEP_TIME * 33
-                else:
-                    queue_sleep_time = SLEEP_TIME
+                send_time = time.perf_counter() - start_time
+
+                self._send_queue.task_done()  # indicate that the item of the queue has been processed
+
+                queue_sleep_time = self._calculate_queue_sleep_time(msg_info, send_time)
                 await asyncio.sleep(queue_sleep_time)
+
             except (asyncio.CancelledError, GeneratorExit) as exc:
                 if not self._closing:
                     self._log.error(f"Stopping Velbus writer due to {exc!r}")
@@ -205,6 +208,22 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             self._write_transport_lock.release()
         self._log.debug("Ending Velbus write message from send queue")
 
+    @staticmethod
+    def _calculate_queue_sleep_time(msg_info, send_time):
+        sleep_time = SLEEP_TIME
+
+        if msg_info.rtr:
+            sleep_time = SLEEP_TIME  # this is a scan command. We could be quicker?
+
+        if msg_info.command == 0xEF:
+            # 'channel name request' command provokes in worst case 99 answer packets from VMBGPOD
+            sleep_time = SLEEP_TIME * 33  # TODO make this adaptable on module_type
+
+        if send_time > sleep_time:
+            return 0  # no need to wait, we are already late
+        else:
+            return sleep_time - send_time
+
     @backoff.on_predicate(
         backoff.expo,
         lambda is_sent: not is_sent,
@@ -218,3 +237,7 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             return True
         else:
             return False
+
+    async def wait_on_all_messages_sent_async(self) -> None:
+        self._log.debug("Waiting on all messages sent")
+        await self._send_queue.join()

velbusaio/vlp_reader.py

@@ -1,33 +1,113 @@
+import importlib.resources
+import json
+import logging
+import sys
+
+from aiofile import async_open
 from bs4 import BeautifulSoup
 
+from velbusaio.command_registry import MODULE_DIRECTORY
+from velbusaio.helpers import h2
+
 
 class vlpFile:
 
     def __init__(self, file_path) -> None:
         self._file_path = file_path
-        self._soup = None
         self._modules = {}
-        self._read()
-        self._parse()
-        print(self._modules)
+        self._log = logging.getLogger("velbus-vlpFile")
+
+    def get(self) -> dict:
+        return self._modules
 
-    def _read(self) -> None:
+    async def read(self) -> None:
         with open(self._file_path) as file:
             xml_content = file.read()
-        self._soup = BeautifulSoup(xml_content, "xml")
-
-    def _parse(self) -> None:
-        for module in self._soup.find_all("Module"):
-            self._parse_module(module)
-
-    def _parse_module(self, module) -> None:
-        mod_info = {}
-        mod_info["name"] = module.find("Caption").get_text()
-        mod_info["addresses"] = module["address"]
-        mod_info["build"] = module["build"]
-        mod_info["serial"] = module["serial"]
-        mod_info["build"] = module["build"]
-        mod_info["type"] = module["type"]
-        memory = module.find("Memory")
-        mod_info["memory"] = memory.get_text()
-        self._modules[mod_info["addresses"]] = mod_info
+        _soup = BeautifulSoup(xml_content, "xml")
+        for module in _soup.find_all("Module"):
+            self._modules[module["address"]] = vlpModule(
+                module.find("Caption").get_text(),
+                module["address"],
+                module["build"],
+                module["serial"],
+                module["type"],
+                module.find("Memory").get_text(),
+            )
+            await self._modules[module["address"]].load_module_spec()
+            print(self._modules[module["address"]].get_channel_name(1))
+            print(self._modules[module["address"]].get_channel_name(2))
+            print(self._modules[module["address"]].get_channel_name(3))
+            print(self._modules[module["address"]].get_channel_name(4))
+            print(self._modules[module["address"]].get_channel_name(5))
+            print(self._modules[module["address"]].get_channel_name(10))
+
+
+class vlpModule:
+
+    def __init__(self, name, addresses, build, serial, type, memory) -> None:
+        self._name = name
+        self._addresses = addresses
+        self._build = build
+        self._serial = serial
+        self._type = type
+        self._memory = memory
+        self._spec = {}
+        self._type_id = next(
+            (key for key, value in MODULE_DIRECTORY.items() if value == self._type),
+            None,
+        )
+        self._log = logging.getLogger("velbus-vlpFile")
+
+    def get(self) -> dict:
+        return {
+            "name": self._name,
+            "addresses": self._addresses,
+            "build": self._build,
+            "serial": self._serial,
+            "type": self._type,
+            "memory": self._memory,
+        }
+
+    def get_name(self) -> str:
+        return self._name
+
+    def get_channel_name(self, chan: int) -> str | None:
+        self._log.debug(f"get_channel_name: {chan}")
+        if "Memory" not in self._spec:
+            self._log.debug(" => no Memory locations found")
+            return None
+        if "Channels" not in self._spec["Memory"]:
+            self._log.debug(" => no Channels Memory locations found")
+            return None
+        if h2(chan) not in self._spec["Memory"]["Channels"]:
+            self._log.debug(f" => no chan {chan} Memory locations found")
+            return None
+        byte_data = bytes.fromhex(
+            self._read_from_memory(self._spec["Memory"]["Channels"][h2(chan)]).replace(
+                "FF", ""
+            )
+        )
+        return byte_data.decode("ascii")
+
+    async def load_module_spec(self) -> None:
+        if sys.version_info >= (3, 13):
+            with importlib.resources.path(
+                __name__, f"module_spec/{h2(self._type_id)}.json"
+            ) as fspath:
+                async with async_open(fspath) as protocol_file:
+                    self._spec = json.loads(await protocol_file.read())
+        else:
+            async with async_open(
+                str(
+                    importlib.resources.files(__name__.split(".")[0]).joinpath(
+                        f"module_spec/{h2(self._type)}.json"
+                    )
+                )
+            ) as protocol_file:
+                self._spec = json.loads(await protocol_file.read())
+
+    def _read_from_memory(self, address_range) -> str | None:
+        start_str, end_str = address_range.split("-")
+        start = int(start_str, 16) * 2
+        end = (int(end_str, 16) + 1) * 2
+        return self._memory[start:end]