velbus-aio 2024.5.1__py3-none-any.whl → 2024.7.0__py3-none-any.whl

{velbus_aio-2024.5.1.dist-info → velbus_aio-2024.7.0.dist-info}/METADATA

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

{velbus_aio-2024.5.1.dist-info → velbus_aio-2024.7.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
 velbusaio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-velbusaio/channels.py,sha256=1fqxsNHmJmb6lYRr4UqP9HLeTprbvektzrjQ8QBvWi0,22889
+velbusaio/channels.py,sha256=YdIMneLYj_zTa8e2dHmhZvGKcD3iyv5jMeZpfuORcTU,22910
 velbusaio/command_registry.py,sha256=j9KuLmada41PMEdtfPvLmXVOAZOkBM9zi-3kluwYffk,5140
-velbusaio/const.py,sha256=aysTlQcpACZaDVqoXAjWmaEDGlCB7KT04Rv-SAusPFc,1575
-velbusaio/controller.py,sha256=txOd0JuYi_OGMzO1t2u7KXlF085HWa1HVlszz7A2O5c,8846
+velbusaio/const.py,sha256=HyBLMJkzZ0ApJRjCffcWlSGr2c3Qgt6kFpdhLQwl--c,1862
+velbusaio/controller.py,sha256=XcASgSs5DBwmjAjV3Aa9L4wyJEuLpn8qEUqwfWNkTPA,7369
 velbusaio/discovery.py,sha256=Px6qoZl4QhF17aMz6JxstCORBpLzZGWEK9h4Vyvg57o,1649
 velbusaio/exceptions.py,sha256=FHkXaM3dK5Gkk-QGAf9dLE3FPlCU2FRZWUyY-4KRNnA,515
-velbusaio/handler.py,sha256=jTWIV26ibAqs3rcTku81NIHlPUeyWjStSih1Nfx-an0,5946
+velbusaio/handler.py,sha256=UF-F2LeVEocDniXKLE8FmUMO-o9QdRtDQoYog6d4rag,10867
 velbusaio/helpers.py,sha256=iqpoereRH4JY5WAkozIqWvXWyRmhko-J-UGXDylFyEM,2537
-velbusaio/message.py,sha256=gnhXpA5NAG4qnI9vlxwlWQKETWneDb1lp0P9w_-nxhQ,5020
-velbusaio/module.py,sha256=_yFxZIi71eqq9xxNal-9ATNHGMjZDOr-dcpKYIxa7_8,35458
-velbusaio/protocol.json,sha256=7PifRZXctU5zSsodDGsUAhnnSsGNlcGcim1gr2su720,250396
-velbusaio/protocol.py,sha256=ofDwJfwyrVQDQ40WX2QdH1nTK-y2HibQPTo5dFY7SkQ,8224
+velbusaio/message.py,sha256=_MRuI4XnMcqeduCDJ3AwhAPL1B8VMstFDnjjLo8QuxM,5018
+velbusaio/module.py,sha256=OMFIa8VhJR-G_rg2PcGUdpmubLD6gDwVruN4ZCmwpMY,35215
+velbusaio/protocol.json,sha256=cQ2RsXomOjB-sd4fIu53QthOlkcfJSa7M0oGkzi9fJQ,253142
+velbusaio/protocol.py,sha256=3XhSFYe2GS-3fis5uClJV4tJxI_XO0x-JKZW0cD5cKs,8004
 velbusaio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velbusaio/raw_message.py,sha256=ODoTPVAvyXXQSMXxtQO1U5OxcoQ4W8JJN5fotEDGSTo,4690
 velbusaio/util.py,sha256=FW6YCiPYWOCgqHDs8-LbzME0h81mqftYVG0qqZ-oo7Y,1568
@@ -51,8 +51,8 @@ velbusaio/messages/memory_data_block.py,sha256=3QufrOahEkIhJjivWtOXp62YuVaUwx6tr
 velbusaio/messages/memory_dump_request.py,sha256=xrPsdpygD9DUF3lp-BzJacuq1dNkqz2wtHpqu_F1zVM,699
 velbusaio/messages/module_status.py,sha256=83UrRFXgRRngcF36fogyw8G5XPFlyaoZoW7XlxwvnQE,6637
 velbusaio/messages/module_status_request.py,sha256=s3h8F6Dpmjcb4hqDQKIzdOgocW1F_st40cctcW7WmQ4,961
-velbusaio/messages/module_subtype.py,sha256=VQXQ-c_yFbj9_64SjfiM-PLk1hV7xUWIcQ1DZYTpKhI,1464
-velbusaio/messages/module_type.py,sha256=toHlsLoek61cQ9JXG3alJyAuQtny1RSY7K6cM4hfNOk,4116
+velbusaio/messages/module_subtype.py,sha256=KG-OC0eW-ZRnP1P8EWmcay6O-no6Mn2cklEjokaIW9M,1487
+velbusaio/messages/module_type.py,sha256=fb4q_SP3B6h_f9jGxgMvNoIpgBPXx36nwjCmtf0DfBw,4154
 velbusaio/messages/module_type_request.py,sha256=fntMYCF1WVwSseCy3zRoZQH6JeGz8JDfTkwHC3AvcB4,754
 velbusaio/messages/push_button_status.py,sha256=SRFLvNC00FdKDTSb4kNVSHeXI1i5Ey5ENxpsB3B8FuU,1554
 velbusaio/messages/raw.py,sha256=pepZSUVY-ro5jv3ZyO6BI3ap5RZ2g_Bd9dlbaICFldQ,1964
@@ -96,8 +96,8 @@ velbusaio/messages/very_fast_blinking_led.py,sha256=vlMEern8PoOvtO5JaAk9erMR4IKJ
 velbusaio/messages/write_data_to_memory.py,sha256=gr6bi4SzK8Mw8fnp8yV-STq5jts7NoeV7zZgdptH5Vs,1039
 velbusaio/messages/write_memory_block.py,sha256=zGnNxx_M66HpBQ8S7kagtNw8_qSRHsOLk1MuiS0uygM,1032
 velbusaio/messages/write_module_address_and_serial_number.py,sha256=6y57j-md3btNtQddX5CUREtSs1Dzgkd953sQPZ3Pioo,1597
-velbus_aio-2024.5.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-velbus_aio-2024.5.1.dist-info/METADATA,sha256=z1Q-cGFQfsDQYGHAppFwXJUDplFi6qaFKIGJW0Me3c4,3259
-velbus_aio-2024.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-velbus_aio-2024.5.1.dist-info/top_level.txt,sha256=W0-lSOwD23mm8FqaIe9vY20fKicBMIdUVjF-zmfxRnY,15
-velbus_aio-2024.5.1.dist-info/RECORD,,
+velbus_aio-2024.7.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+velbus_aio-2024.7.0.dist-info/METADATA,sha256=Y590SRjMvVtmhl4FQ5A57mqBqo-KCGF_ABRZwKYVACM,3259
+velbus_aio-2024.7.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+velbus_aio-2024.7.0.dist-info/top_level.txt,sha256=W0-lSOwD23mm8FqaIe9vY20fKicBMIdUVjF-zmfxRnY,15
+velbus_aio-2024.7.0.dist-info/RECORD,,

{velbus_aio-2024.5.1.dist-info → velbus_aio-2024.7.0.dist-info}/WHEEL

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

velbusaio/channels.py

@@ -508,6 +508,7 @@ class Temperature(Channel):
     _min = None
     _target = 0
     _cmode = None
+    _coolmode = None
     _cstatus = None
     _thermostat = False
     _sleep_timer = 0

velbusaio/const.py

@@ -38,7 +38,13 @@ RTR: Final = 0x40
 NO_RTR: Final = 0x00
 
 CACHEDIR: Final = ".velbuscache"
-LOAD_TIMEOUT: Final = 600
+
+# Module scan timeout values (in mSec)
+SCAN_MODULETYPE_TIMEOUT: Final = 2000  # time to wait for ModuleTypeRequest
+SCAN_MODULEINFO_TIMEOUT_INITIAL: Final = 1000  # time to wait for first info (status)
+SCAN_MODULEINFO_TIMEOUT_INTERVAL: Final = (
+    150  # time to wait for info interval (between next message)
+)
 
 DEVICE_CLASS_ILLUMINANCE: Final = "illuminance"
 DEVICE_CLASS_TEMPERATURE: Final = "temperature"

velbusaio/controller.py

@@ -14,7 +14,6 @@ import serial
 import serial_asyncio_fast
 
 from velbusaio.channels import Channel
-from velbusaio.const import LOAD_TIMEOUT
 from velbusaio.exceptions import VelbusConnectionFailed
 from velbusaio.handler import PacketHandler
 from velbusaio.helpers import get_cache_dir
@@ -42,17 +41,16 @@ class Velbus:
         self._protocol = VelbusProtocol(
             message_received_callback=self._on_message_received,
             connection_lost_callback=self._on_connection_lost,
-            end_of_scan_callback=self._on_end_of_scan,
         )
         self._closing = False
         self._auto_reconnect = True
 
         self._dsn = dsn
-        self._handler = PacketHandler(self.send, self)
+        self._handler = PacketHandler(self)
         self._modules: dict[int, Module] = {}
         self._submodules: list[int] = []
-        self._send_queue = asyncio.Queue()
-        self._cache_dir = cache_dir
+        self._send_queue: asyncio.Queue = asyncio.Queue()
+        self._cache_dir: str = cache_dir
         # make sure the cachedir exists
         pathlib.Path(self._cache_dir).mkdir(parents=True, exist_ok=True)
 
@@ -66,11 +64,7 @@ class Velbus:
             self._log.debug("Reconnecting to transport")
             asyncio.ensure_future(self.connect())
 
-    def _on_end_of_scan(self) -> None:
-        """Notify the scan failure."""
-        self._handler.scan_finished()
-
-    async def add_module(
+    def add_module(
         self,
         addr: int,
         typ: int,
@@ -81,8 +75,7 @@ class Velbus:
         build_week: int | None = None,
     ) -> None:
         """Add a found module to the module cache."""
-        self._log.info(f"Found module: type:{typ} address:{addr}")
-        self._modules[addr] = Module.factory(
+        module = Module.factory(
             addr,
             typ,
             data,
@@ -92,30 +85,31 @@ class Velbus:
             memorymap=memorymap,
             cache_dir=self._cache_dir,
         )
-        self._modules[addr].initialize(self.send)
-        await self._modules[addr].load()
+        module.initialize(self.send)
+        self._modules[addr] = module
+        self._log.info(f"Found module {addr}: {module}")
 
-    async def add_submodules(self, addr: int, subList: dict[int, int]) -> None:
+    def add_submodules(self, module: Module, subList: dict[int, int]) -> None:
         """Add submodules address to module."""
         for sub_num, sub_addr in subList.items():
             if sub_addr == 0xFF:
                 continue
             self._submodules.append(sub_addr)
-            self._modules[addr]._sub_address[sub_num] = sub_addr
-            self._modules[sub_addr] = self._modules[addr]
-        self._modules[addr].cleanupSubChannels()
+            module._sub_address[sub_num] = sub_addr
+            self._modules[sub_addr] = module
+        module.cleanupSubChannels()
 
     def get_modules(self) -> dict:
         """Return the module cache."""
         return self._modules
 
-    def get_module(self, addr: str) -> None | Module:
+    def get_module(self, addr: int) -> None | Module:
         """Get a module on an address."""
         if addr in self._modules:
             return self._modules[addr]
         return None
 
-    def get_channels(self, addr: str) -> None | dict:
+    def get_channels(self, addr: int) -> None | dict:
         """Get the channels for an address."""
         if addr in self._modules:
             return (self._modules[addr]).get_channels()
@@ -129,6 +123,7 @@ class Velbus:
 
     async def connect(self, test_connect: bool = False) -> None:
         """Connect to the bus and load all the data."""
+        await self._handler.read_protocol_data()
         auth = None
         # connect to the bus
         if ":" in self._dsn:
@@ -181,44 +176,15 @@ class Velbus:
             await self._protocol.write_auth_key(auth)
 
         # scan the bus
-        await self.scan()
+        await self._handler.scan()
 
     async def scan(self) -> None:
-        """Scan the bus."""
-        self._handler.scan_started()
-        for addr in range(1, 256):
-            msg = ModuleTypeRequestMessage(addr)
-            await self.send(msg)
-        await self._handler._scan_complete_event.wait()
-        # calculate how long to wait
-        calc_timeout = len(self._modules) * 30
-        if calc_timeout < LOAD_TIMEOUT:
-            timeout = calc_timeout
-        else:
-            timeout = LOAD_TIMEOUT
-        # create a task to wait until we have all modules loaded
-        tsk = asyncio.Task(self._check_if_modules_are_loaded())
-        try:
-            await asyncio.wait_for(tsk, timeout=timeout)
-        except asyncio.TimeoutError:
-            self._log.error(
-                f"Not all modules are loaded within a timeout of {LOAD_TIMEOUT} seconds, continuing with the loaded modules"
-            )
+        """Service endpoint to restart the scan"""
+        await self._handler.scan(True)
 
-    async def _check_if_modules_are_loaded(self) -> None:
-        """Task to wait until modules are loaded."""
-        while True:
-            mods_loaded = 0
-            for mod in (self.get_modules()).values():
-                if mod.is_loaded():
-                    mods_loaded += 1
-                else:
-                    self._log.warning(f"Waiting for module {mod._address}")
-            if mods_loaded == len(self.get_modules()):
-                self._log.info("All modules loaded")
-                return
-            self._log.info("Not all modules loaded yet, waiting 15 seconds")
-            await asyncio.sleep(15)
+    async def sendTypeRequestMessage(self, address: int) -> None:
+        msg = ModuleTypeRequestMessage(address)
+        await self.send(msg)
 
     async def send(self, msg: Message) -> None:
         """Send a packet."""

velbusaio/handler.py

@@ -5,9 +5,19 @@ Velbus packet handler
 
 from __future__ import annotations
 
+from velbusaio.const import SCAN_MODULETYPE_TIMEOUT
+from velbusaio.const import SCAN_MODULEINFO_TIMEOUT_INITIAL
+from velbusaio.const import SCAN_MODULEINFO_TIMEOUT_INTERVAL
+
 import asyncio
 import json
 import logging
+import threading
+import os
+import pathlib
+
+from aiofile import async_open
+
 from typing import TYPE_CHECKING, Awaitable, Callable
 import pkg_resources
 
@@ -15,8 +25,10 @@ from velbusaio.command_registry import commandRegistry
 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 ModuleTypeMessage
+from velbusaio.messages.module_type import ModuleTypeMessage, ModuleType2Message
 from velbusaio.raw_message import RawMessage
+from velbusaio.helpers import get_cache_dir
+
 
 if TYPE_CHECKING:
     from velbusaio.controller import Velbus
@@ -29,27 +41,102 @@ class PacketHandler:
 
     def __init__(
         self,
-        writer: Callable[[Message], Awaitable[None]],
         velbus: Velbus,
     ) -> 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._typeResponseReceived = asyncio.Event()
+        self._scanLock = threading.Lock()
+        self._modulescan_address = 0
         self._scan_complete = False
-        self._scan_complete_event = asyncio.Event()
-        with open(
+        self._scan_delay_msec = 0
+
+    async def read_protocol_data(self):
+        async with async_open(
             pkg_resources.resource_filename(__name__, "protocol.json")
         ) as protocol_file:
-            self.pdata = json.load(protocol_file)
+            self.pdata = json.loads(await protocol_file.read())
 
-    def scan_finished(self) -> None:
-        self._scan_complete = True
-        self._scan_complete_event.set()
-        self._log.debug("Scan complete")
+    def empty_cache(self) -> bool:
+        if (
+            len(
+                [
+                    name
+                    for name in os.listdir(f"{get_cache_dir()}")
+                    if os.path.isfile(f"{get_cache_dir()}/{name}")
+                ]
+            )
+            == 0
+        ):
+            return True
+        return False
 
-    def scan_started(self) -> None:
-        self._scan_complete = False
-        self._scan_complete_event.clear()
+    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
+        self._log.info("Start module scan")
+        while self._modulescan_address < 254:
+            address = 0
+            module = None
+            with self._scanLock:
+                self._modulescan_address = self._modulescan_address + 1
+                address = self._modulescan_address
+                module = self._velbus.get_module(address)
+
+            self._log.info(f"Starting handling scan {address}")
+
+            cfile = pathlib.Path(f"{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:
+                try:
+                    self._log.info(f"Starting scan {address}")
+                    self._typeResponseReceived.clear()
+                    await self._velbus.sendTypeRequestMessage(address)
+                    await asyncio.wait_for(
+                        self._typeResponseReceived.wait(),
+                        SCAN_MODULETYPE_TIMEOUT / 1000.0,
+                    )
+                    with self._scanLock:
+                        module = self._velbus.get_module(address)
+                except asyncio.TimeoutError:
+                    self._log.info(
+                        f"Scan module {address} failed: not present or unavailable"
+                    )
+                if module is not None:
+                    try:
+                        self._log.debug(f"Module {address} detected: start loading")
+                        await asyncio.wait_for(
+                            module.load(from_cache=True),
+                            SCAN_MODULEINFO_TIMEOUT_INITIAL / 1000.0,
+                        )
+                        self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INITIAL
+                        while self._scan_delay_msec > 50 and not module.is_loaded():
+                            # self._log.debug(
+                            #    f"\t... waiting {self._scan_delay_msec} is_loaded={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={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")
 
     async def handle(self, rawmsg: RawMessage) -> None:
         """
@@ -66,98 +153,124 @@ 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)
-        elif command_value in (0xB0, 0xA7, 0xA6) and not self._scan_complete:
-            msg = 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")
+        # handle module type response message
+        if command_value == 0xFF:
+            if not self._scan_complete:
+                tmsg: ModuleTypeMessage = ModuleTypeMessage()
+                tmsg.populate(priority, address, rtr, data)
+                with self._scanLock:
+                    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()
+
+        # handle module subtype response message
+        elif command_value in (0xB0, 0xA7, 0xA6):
+            if not self._scan_complete:
+                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
+                with self._scanLock:
+                    self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INITIAL
+                    self._handle_module_subtype(msg)
 
-            self._log.debug(f"Received {msg}")
-            await self._handle_module_subtype(msg)
+        # ignore broadcast
         elif command_value in self.pdata["MessagesBroadCast"]:
             self._log.debug(
                 "Received broadcast message {} from {}, ignoring".format(
-                    self.pdata["MessageBroadCast"][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(),
+                    self.pdata["MessageBroadCast"][str(command_value).upper()], address
                 )
             )
 
-    async def _handle_module_type(self, msg: Message) -> None:
+        # handle other messages for modules that are already scanned
+        else:
+            module = None
+            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}")
+
+    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,
-        )
-
-    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
+        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
+                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,
+                )
+            else:
+                self._log.debug(
+                    f"***Module already exists scanAddr={self._modulescan_address} addr={msg.address} {msg}"
+                )
+
+        # 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/message.py

@@ -20,19 +20,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:
@@ -66,7 +66,7 @@ class Message:
             if callable(getattr(self, key)) or key.startswith("__"):
                 del me[key]
             if isinstance(me[key], (bytes, bytearray)):
-                me[key] = str(me[key], "utf-8")
+                me[key] = str(me[key])
         return me
 
     def to_json(self) -> str:

velbusaio/messages/module_subtype.py

@@ -25,7 +25,7 @@ class ModuleSubTypeMessage(Message):
 
     # pylint: disable-msg=R0902
 
-    def __init__(self, address=None, sub_address_offset: int = 0):
+    def __init__(self, address=None, sub_address_offset: int = 0) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.sub_address_1 = 0xFF
@@ -36,13 +36,13 @@ class ModuleSubTypeMessage(Message):
         self.serial = 0
         self.sub_address_offset = sub_address_offset
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """
         return "Unknown"
 
-    def populate(self, priority, address, rtr, data):
+    def populate(self, priority, address, rtr, data) -> None:
         """
         :return: None
         """

velbusaio/messages/module_type.py

@@ -98,7 +98,7 @@ class ModuleTypeMessage(Message):
 
     # pylint: disable-msg=R0902
 
-    def __init__(self, address=None):
+    def __init__(self, address=None) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.led_on = []
@@ -110,13 +110,13 @@ class ModuleTypeMessage(Message):
         self.build_week = 0
         self.set_defaults(address)
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """
         return "Unknown"
 
-    def populate(self, priority, address, rtr, data):
+    def populate(self, priority, address, rtr, data) -> None:
         """
         :return: None
         """
@@ -151,7 +151,7 @@ class ModuleTypeMessage(Message):
     ],
 )
 class ModuleType2Message(Message):
-    def __init__(self, address=None):
+    def __init__(self, address=None) -> None:
         Message.__init__(self)
         self.module_type = 0x00
         self.led_on = []
@@ -164,7 +164,7 @@ class ModuleType2Message(Message):
         self.term = 0
         self.set_defaults(address)
 
-    def module_name(self):
+    def module_name(self) -> str:
         """
         :return: str
         """

velbusaio/module.py

@@ -9,6 +9,7 @@ import pathlib
 import struct
 import sys
 import json
+import os
 from typing import Awaitable, Callable
 
 from velbusaio.channels import (
@@ -252,6 +253,7 @@ class Module:
         """
         Process received message
         """
+        self._log.debug(f"RX: {message}")
         _channel_offset = self.calc_channel_offset(message.address)
 
         if isinstance(
@@ -515,7 +517,7 @@ class Module:
         try:
             await self._channels[channel].update(updates)
         except KeyError:
-            self._log.error(
+            self._log.info(
                 f"channel {channel} does not exist for module @ address {self}"
             )
 
@@ -526,18 +528,6 @@ class Module:
         return self._channels
 
     async def load(self, from_cache: bool = False) -> None:
-        """
-        Retrieve names of channels
-        """
-        # did we already start the loading?
-        # this is needed for the submodules,
-        # as the submodule address maps to the main module
-        # this method can be called multiple times
-        if self._is_loading or self.loaded:
-            if from_cache:
-                await self._request_module_status()
-            return
-        self._log.info("Load Module")
         # start the loading
         self._is_loading = True
         # see if we have a cache
@@ -548,14 +538,15 @@ class Module:
         except OSError:
             cache = {}
         # load default channels
-        await self._load_default_channels()
+        await self.__load_default_channels()
+
         # load the data from memory ( the stuff that we need)
         if "name" in cache and cache["name"] != "":
             self._name = cache["name"]
         else:
             await self.__load_memory()
         # load the module status
-        await self._request_module_status()
+        # await self._request_module_status()
         # load the channel names
         if "channels" in cache:
             for num, chan in cache["channels"].items():
@@ -569,6 +560,7 @@ class Module:
         self._load()
         # stop the loading
         self._is_loading = False
+        await self._request_module_status()
 
     def _load(self) -> None:
         """
@@ -674,6 +666,8 @@ class Module:
         if "Channels" not in self._data:
             # some modules have no channels
             return
+        self._log.info(f"Request module status {self._address}")
+
         mod_stat_req_msg = ModuleStatusRequestMessage(self._address)
         counter_msg = None
         for chan, chan_data in self._data["Channels"].items():
@@ -728,7 +722,7 @@ class Module:
                     msg.low_address = addr[1]
                     await self._writer(msg)
 
-    async def _load_default_channels(self) -> None:
+    async def __load_default_channels(self) -> None:
         if "Channels" not in self._data:
             return
 
@@ -777,6 +771,7 @@ class VmbDali(Module):
         self.group_members: dict[int, set[int]] = {}
 
     async def _load_default_channels(self) -> None:
+        await super().load()
         for chan in range(1, 64 + 1):
             self._channels[chan] = Channel(
                 self, chan, "placeholder", True, self._writer, self._address

velbusaio/protocol.json

@@ -9045,6 +9045,74 @@
           "Type": "SelectedProgram"
         }
       },
+      "Memory": {
+        "Address": {
+          "049C": { "ModuleName": "0:Start" },
+          "049D": { "ModuleName": "1" },
+          "049E": { "ModuleName": "2" },
+          "049F": { "ModuleName": "3" },
+          "04A0": { "ModuleName": "4" },
+          "04A1": { "ModuleName": "5" },
+          "04A2": { "ModuleName": "6" },
+          "04A3": { "ModuleName": "7" },
+          "04A4": { "ModuleName": "8" },
+          "04A5": { "ModuleName": "9" },
+          "04A6": { "ModuleName": "10" },
+          "04A7": { "ModuleName": "11" },
+          "04A8": { "ModuleName": "12" },
+          "04A9": { "ModuleName": "13" },
+          "04AA": { "ModuleName": "14" },
+          "04AB": { "ModuleName": "15" },
+          "04AC": { "ModuleName": "16" },
+          "04AD": { "ModuleName": "17" },
+          "04AE": { "ModuleName": "18" },
+          "04AF": { "ModuleName": "19" },
+          "04B0": { "ModuleName": "20" },
+          "04B1": { "ModuleName": "21" },
+          "04B2": { "ModuleName": "22" },
+          "04B3": { "ModuleName": "23" },
+          "04B4": { "ModuleName": "24" },
+          "04B5": { "ModuleName": "25" },
+          "04B6": { "ModuleName": "26" },
+          "04B7": { "ModuleName": "27" },
+          "04B8": { "ModuleName": "28" },
+          "04B9": { "ModuleName": "29" },
+          "04BA": { "ModuleName": "30" },
+          "04BB": { "ModuleName": "31" },
+          "04BC": { "ModuleName": "32" },
+          "04BD": { "ModuleName": "33" },
+          "04BE": { "ModuleName": "34" },
+          "04BF": { "ModuleName": "35" },
+          "04C0": { "ModuleName": "36" },
+          "04C1": { "ModuleName": "37" },
+          "04C2": { "ModuleName": "38" },
+          "04C3": { "ModuleName": "39" },
+          "04C4": { "ModuleName": "40" },
+          "04C5": { "ModuleName": "41" },
+          "04C6": { "ModuleName": "42" },
+          "04C7": { "ModuleName": "43" },
+          "04C8": { "ModuleName": "44" },
+          "04C9": { "ModuleName": "45" },
+          "04CA": { "ModuleName": "46" },
+          "04CB": { "ModuleName": "47" },
+          "04CC": { "ModuleName": "48" },
+          "04CD": { "ModuleName": "49" },
+          "04CE": { "ModuleName": "50" },
+          "04CF": { "ModuleName": "51" },
+          "04D0": { "ModuleName": "52" },
+          "04D1": { "ModuleName": "53" },
+          "04D2": { "ModuleName": "54" },
+          "04D3": { "ModuleName": "55" },
+          "04D4": { "ModuleName": "56" },
+          "04D5": { "ModuleName": "57" },
+          "04D6": { "ModuleName": "58" },
+          "04D7": { "ModuleName": "59" },
+          "04D8": { "ModuleName": "60" },
+          "04D9": { "ModuleName": "61" },
+          "04DA": { "ModuleName": "62" },
+          "04DB": { "ModuleName": "64:Save" }
+        }
+      },
       "Info": "8 channel 0 to 10 V dimmer control module",
       "Type": "VMB8DC-20"
     },

velbusaio/protocol.py

@@ -15,9 +15,7 @@ from velbusaio.raw_message import create as create_message_info
 
 def _on_write_backoff(details):
     logging.debug(
-        "Transport is not open, waiting {wait} seconds after {tries}",
-        wait=details.wait,
-        tries=details.tries,
+        f"Transport is not open, waiting {details.wait} seconds after {details.tries}"
     )
 
 
@@ -31,13 +29,11 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         self,
         message_received_callback: t.Callable[[RawMessage], t.Awaitable[None]],
         connection_lost_callback=None,
-        end_of_scan_callback=None,
     ) -> None:
         super().__init__()
         self._log = logging.getLogger("velbus-protocol")
         self._message_received_callback = message_received_callback
         self._connection_lost_callback = connection_lost_callback
-        self._end_of_scan_callback = end_of_scan_callback
 
         # everything for reading from Velbus
         self._buffer = bytearray(MAXIMUM_MESSAGE_SIZE)
@@ -63,14 +59,14 @@ class VelbusProtocol(asyncio.BufferedProtocol):
         self._restart_writer = True
         self.restart_writing()
 
-    async def pause_writing(self):
+    async def pause_writing(self) -> None:
         """Pause writing."""
         self._restart_writer = False
         if self._writer_task:
             self._send_queue.put_nowait(None)
         await asyncio.sleep(0.1)
 
-    def restart_writing(self):
+    def restart_writing(self) -> None:
         """Resume writing."""
         if self._restart_writer and not self._write_transport_lock.locked():
             self._writer_task = asyncio.ensure_future(
@@ -78,7 +74,7 @@ class VelbusProtocol(asyncio.BufferedProtocol):
             )
             self._writer_task.add_done_callback(lambda _future: self.restart_writing())
 
-    def close(self):
+    def close(self) -> None:
         self._closing = True
         self._restart_writer = False
         if self.transport:
@@ -197,8 +193,6 @@ class VelbusProtocol(asyncio.BufferedProtocol):
                     queue_sleep_time = SLEEP_TIME * 33
                 else:
                     queue_sleep_time = SLEEP_TIME
-                if msg_info.rtr and msg_info.address == 0xFF:
-                    self._end_of_scan_callback()
                 await asyncio.sleep(queue_sleep_time)
             except (asyncio.CancelledError, GeneratorExit) as exc:
                 if not self._closing: