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

velbusaio/command_registry.py

@@ -1,13 +1,17 @@
-"""
+"""Command registry.
+
 :author: Maikel Punie <maikel.punie@gmail.com> and Thomas Delaet <thomas@delaet.org>
 """
+
 from __future__ import annotations
 
 MODULE_DIRECTORY = {
     0x01: "VMB8PB",
     0x02: "VMB1RY",
     0x03: "VMB1BL",
+    0x04: "VMBPSUMNGR-20",
     0x05: "VMB6IN",
+    0x06: "VMB4LEDPWM-20",
     0x07: "VMB1DM",
     0x08: "VMB4RY",
     0x09: "VMB2BL",
@@ -36,6 +40,11 @@ MODULE_DIRECTORY = {
     0x20: "VMBGP4",
     0x21: "VMBGPO",
     0x22: "VMB7IN",
+    0x23: "VMBPIRO-10",
+    0x24: "VMB2DC-20",
+    0x25: "VMBGPTC",
+    0x26: "VMB4RYLD-20",
+    0x27: "VMB4RYNO-20",
     0x28: "VMBGPOD",
     0x29: "VMB1RYNOS",
     0x2A: "VMBPIRM",
@@ -44,6 +53,7 @@ MODULE_DIRECTORY = {
     0x2D: "VMBGP4PIR",
     0x2E: "VMB1BLS",
     0x2F: "VMBDMI-R",
+    0x30: "VMBRFR8S",
     0x31: "VMBMETEO",
     0x32: "VMB4AN",
     0x33: "VMBVP01",
@@ -68,23 +78,33 @@ MODULE_DIRECTORY = {
     0x48: "VMB4RYLD-10",
     0x49: "VMB4RYNO-10",
     0x4A: "VMB2BLE-10",
+    0x4B: "VMB8DC-20",
     0x4C: "VMB6PB-20",
+    0x4D: "VMBPIR-20",
+    0x4E: "VMB8IN-20",
     0x4F: "VMBEL1-20",
     0x50: "VMBEL2-20",
     0x51: "VMBEL4-20",
     0x52: "VMBELO-20",
-    0x53: "VMBGP1-20",
-    0x54: "VMBGP2-20",
-    0x55: "VMBGP4-20",
-    0x56: "VMBGPO-20",
+    0x54: "VMBGP1-20",
+    0x55: "VMBGP2-20",
+    0x56: "VMBGP4-20",
+    0x57: "VMBGPO-20",
+    0x59: "VMBPIRO-20",
     0x5A: "VMBDALI-20",
+    0x5B: "VMBSIG-20",
     0x5C: "VMBEL4PIR-20",
     0x5F: "VMBGP4PIR-20",
+    0x60: "VMBSIG-21",
+    0x61: "VMB2BLE-20",
 }
 
 
 class CommandRegistry:
+    """Command registry class."""
+
     def __init__(self, module_directory: dict) -> None:
+        """Init method."""
         self._module_directory = module_directory
         self._default_commands = {}
         self._overrides = {}
@@ -92,6 +112,7 @@ class CommandRegistry:
     def register_command(
         self, command_value: int, command_class: type, module_name: str | None = None
     ) -> None:
+        """Register a command."""
         if command_value < 0 or command_value > 255:
             raise ValueError("Command_value should be >=0 and <=255")
         if module_name and module_name not in self._module_directory.values():
@@ -112,6 +133,7 @@ class CommandRegistry:
     def _register_override(
         self, command_value: int, command_class: type, module_type: str
     ) -> None:
+        """Register and override."""
         if module_type not in self._overrides:
             self._overrides[module_type] = {}
         if command_value not in self._overrides[module_type]:
@@ -122,12 +144,14 @@ class CommandRegistry:
             )
 
     def _register_default(self, command_value: int, command_class: type) -> None:
+        """Register a default command."""
         if command_value not in self._default_commands:
             self._default_commands[command_value] = command_class
         else:
             raise Exception("double registration in command registry")
 
     def has_command(self, command_value: int, module_type: int = 0) -> bool:
+        """Find a command."""
         if module_type in self._overrides:
             if command_value in self._overrides[module_type]:
                 return True
@@ -136,6 +160,7 @@ class CommandRegistry:
         return False
 
     def get_command(self, command_value: int, module_type: int = 0) -> None | type:
+        """Search a command in the registry."""
         if module_type in self._overrides:
             if command_value in self._overrides[module_type]:
                 return self._overrides[module_type][command_value]
@@ -148,6 +173,8 @@ commandRegistry = CommandRegistry(MODULE_DIRECTORY)
 
 
 def register(command_value: int, module_types: list[str] | None = None):
+    """Register decorator."""
+
     def inner_register(command_class):
         if module_types:
             for module_type in module_types:

velbusaio/const.py

@@ -1,6 +1,8 @@
-"""
+"""Constant for velbusaio.
+
 Author: Maikel Punie <maikel.punie@gmail.com>
 """
+
 from __future__ import annotations
 
 from typing import Final
@@ -36,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 = 3000  # 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

@@ -1,21 +1,33 @@
-"""
-Main interface for the velbusaio lib
-"""
+"""Main interface for the velbusaio lib."""
+
 from __future__ import annotations
 
 import asyncio
 import logging
 import pathlib
-import pickle
 import re
 import ssl
+import time
 from urllib.parse import urlparse
 
 import serial
-import serial_asyncio
+import serial_asyncio_fast
 
-from velbusaio.channels import Channel
-from velbusaio.const import LOAD_TIMEOUT
+from velbusaio.channels import (
+    Blind,
+    Button,
+    ButtonCounter,
+    Dimmer,
+    EdgeLit,
+    LightSensor,
+    Memo,
+    Relay,
+    SelectedProgram,
+    Sensor,
+    SensorNumber,
+    Temperature,
+    ThermostatChannel,
+)
 from velbusaio.exceptions import VelbusConnectionFailed
 from velbusaio.handler import PacketHandler
 from velbusaio.helpers import get_cache_dir
@@ -27,38 +39,42 @@ from velbusaio.messages.set_realtime_clock import SetRealtimeClock
 from velbusaio.module import Module
 from velbusaio.protocol import VelbusProtocol
 from velbusaio.raw_message import RawMessage
+from velbusaio.vlp_reader import VlpFile
 
 
 class Velbus:
-    """
-    A velbus controller
-    """
+    """A velbus controller."""
 
     def __init__(
         self,
         dsn: str,
         cache_dir: str = get_cache_dir(),
+        vlp_file: str | None = None,
+        one_address: int | None = None,
     ) -> None:
+        """Init the Velbus controller."""
         self._log = logging.getLogger("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._destination = dsn
+        self._handler = PacketHandler(self, one_address)
         self._modules: dict[int, Module] = {}
         self._submodules: list[int] = []
-        self._send_queue = asyncio.Queue()
-        self._cache_dir = cache_dir
-        # make sure the cachedir exists
-        pathlib.Path(self._cache_dir).mkdir(parents=True, exist_ok=True)
+        self._send_queue: asyncio.Queue = asyncio.Queue()
+        self._vlp_file = vlp_file
+        self._cache_dir: str = cache_dir
+
+    def get_cache_dir(self) -> str:
+        return self._cache_dir
 
     async def _on_message_received(self, msg: RawMessage) -> None:
+        """On message received function."""
         await self._handler.handle(msg)
 
     def _on_connection_lost(self, exc: Exception) -> None:
@@ -67,108 +83,79 @@ class Velbus:
             self._log.debug("Reconnecting to transport")
             asyncio.ensure_future(self.connect())
 
-    def _on_end_of_scan(self) -> None:
-        self._handler.scan_finished()
-
     async def add_module(
         self,
         addr: int,
         typ: int,
-        data: dict,
         serial: int | None = None,
         memorymap: int | None = None,
         build_year: int | None = None,
         build_week: int | None = None,
     ) -> None:
-        """
-        Add a found module to the module cache
-        """
-        mod = self._load_module_from_cache(self._cache_dir, addr)
-        if mod is not None:
-            self._log.info(f"Load module from CACHE: {addr}")
-            self._modules[addr] = mod
-            self._modules[addr].initialize(self.send)
-            await self._modules[addr].load(True)
-        else:
-            self._log.info(f"Load NEW module: {typ} @ {addr}")
-            self._modules[addr] = Module.factory(
-                addr,
-                typ,
-                data,
-                serial=serial,
-                build_year=build_year,
-                build_week=build_week,
-                memorymap=memorymap,
-                cache_dir=self._cache_dir,
-            )
-            self._modules[addr].initialize(self.send)
-            await self._modules[addr].load()
+        """Add a found module to the module cache."""
+        module = Module.factory(
+            addr,
+            typ,
+            serial=serial,
+            build_year=build_year,
+            build_week=build_week,
+            memorymap=memorymap,
+            cache_dir=self._cache_dir,
+        )
+        await 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()
-
-    def _load_module_from_cache(self, cache_dir: str, address: int) -> None | Module:
-        try:
-            cfile = pathlib.Path(f"{cache_dir}/{address}.p")
-            with cfile.open("rb") as fl:
-                o = pickle.load(fl)
-                if isinstance(o, Module):
-                    return o
-        except OSError:
-            pass
-        return None
+            module._sub_address[sub_num] = sub_addr
+            self._modules[sub_addr] = module
+        module.cleanupSubChannels()
+
+    def addr_is_submodule(self, addr: int) -> bool:
+        """Check if an address is a submodule."""
+        return addr in self._submodules
 
     def get_modules(self) -> dict:
-        """
-        Return the module cache
-        """
+        """Return the module cache."""
         return self._modules
 
-    def get_module(self, addr: str) -> None | Module:
-        """
-        Get a module on an address
-        """
-        if addr in self._modules.keys():
+    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:
-        """
-        Get the channels for an address
-        """
+    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()
         return None
 
     async def stop(self) -> None:
+        """Stop the controller."""
         self._closing = True
         self._auto_reconnect = False
         self._protocol.close()
 
-    async def connect(self, test_connect: bool = False) -> None:
-        """
-        Connect to the bus and load all the data
-        """
-        auth = None
+    async def connect(self) -> None:
+        """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:
                 ctx = None
-            if parts.username:
-                auth = parts.username
             try:
                 (
                     _transport,
@@ -181,74 +168,76 @@ class Velbus:
                 )
 
             except (ConnectionRefusedError, OSError) as err:
-                raise VelbusConnectionFailed() from err
+                raise VelbusConnectionFailed from err
         else:
             # serial port
             try:
-                _transport, _protocol = await serial_asyncio.create_serial_connection(
-                    asyncio.get_event_loop(),
-                    lambda: self._protocol,
-                    url=self._dsn,
-                    baudrate=38400,
-                    bytesize=serial.EIGHTBITS,
-                    parity=serial.PARITY_NONE,
-                    stopbits=serial.STOPBITS_ONE,
-                    xonxoff=0,
-                    rtscts=1,
+                _transport, _protocol = (
+                    await serial_asyncio_fast.create_serial_connection(
+                        asyncio.get_event_loop(),
+                        lambda: self._protocol,
+                        url=self._destination,
+                        baudrate=38400,
+                        bytesize=serial.EIGHTBITS,
+                        parity=serial.PARITY_NONE,
+                        stopbits=serial.STOPBITS_ONE,
+                        xonxoff=0,
+                        rtscts=1,
+                    )
                 )
             except (FileNotFoundError, serial.SerialException) as err:
-                raise VelbusConnectionFailed() from err
-        if test_connect:
-            return
+                raise VelbusConnectionFailed from err
+
+    async def start(self) -> None:
         # if auth is required send the auth key
-        if auth:
-            await self._protocol.write_auth_key(auth)
+        parts = urlparse(self._destination)
+        if parts.username:
+            await self._protocol.write_auth_key(parts.username)
 
-        # scan the bus
-        await self.scan()
+        if self._vlp_file:
+            # use the vlp file to load the modules
+            vlp = VlpFile(self._vlp_file)
+            await vlp.read()
+            for mod_data in vlp.get():
+                # Convert hex address string to decimal integer
+                addr = mod_data.get_addr().split(",")
+                decimal_addr = int(addr[0], 16)
+                await self.add_module(
+                    decimal_addr,
+                    mod_data.get_type(),
+                    serial=mod_data.get_serial(),
+                    memorymap=mod_data.get_memory(),
+                    build_year=int(mod_data.get_build()[0:2]),
+                    build_week=int(mod_data.get_build()[2:4]),
+                )
+                # handle submodules
+                if len(addr) > 1:
+                    self.add_submodules(
+                        self._modules[decimal_addr], dict(enumerate(addr[1:]))
+                    )
+                # load module data, special for dali
+                if mod_data.get_type() == 0x45 or mod_data.get_type() == 0x5A:
+                    await self._modules[decimal_addr].load()
+                else:
+                    module = self._modules[decimal_addr]
+                    await module.load_from_vlp(mod_data)
+                    await module.wait_for_status_messages()
+        else:
+            # make sure the cachedir exists
+            pathlib.Path(self._cache_dir).mkdir(parents=True, exist_ok=True)
+            # scan the bus
+            await self._handler.scan()
 
     async def scan(self) -> None:
-        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
-        """
+        """Send a packet."""
         await self._protocol.send_message(
             RawMessage(
                 priority=msg.priority,
@@ -258,7 +247,53 @@ class Velbus:
             )
         )
 
-    def get_all(self, class_name: str) -> list[Channel]:
+    def get_all_sensor(
+        self,
+    ) -> list[ButtonCounter | Temperature | LightSensor | SensorNumber]:
+        return self._get_all("sensor")
+
+    def get_all_switch(self) -> list[Relay]:
+        return self._get_all("switch")
+
+    def get_all_binary_sensor(self) -> list[Button]:
+        return self._get_all("binary_sensor")
+
+    def get_all_button(self) -> list[Button | ButtonCounter]:
+        return self._get_all("button")
+
+    def get_all_climate(self) -> list[Temperature]:
+        return self._get_all("climate")
+
+    def get_all_cover(self) -> list[Blind]:
+        return self._get_all("cover")
+
+    def get_all_select(self) -> list[SelectedProgram]:
+        return self._get_all("select")
+
+    def get_all_light(self) -> list[Dimmer]:
+        return self._get_all("light")
+
+    def get_all_led(self) -> list[Button]:
+        return self._get_all("led")
+
+    def _get_all(
+        self, class_name: str
+    ) -> list[
+        Blind
+        | Button
+        | ButtonCounter
+        | Sensor
+        | ThermostatChannel
+        | Dimmer
+        | Temperature
+        | SensorNumber
+        | LightSensor
+        | Relay
+        | EdgeLit
+        | Memo
+        | SelectedProgram
+    ]:
+        """Get all channels."""
         lst = []
         for addr, mod in (self.get_modules()).items():
             if addr in self._submodules:
@@ -269,9 +304,12 @@ class Velbus:
         return lst
 
     async def sync_clock(self) -> None:
-        """
-        This will send all the needed messages to sync the clock
-        """
-        await self.send(SetRealtimeClock())
-        await self.send(SetDate())
-        await self.send(SetDaylightSaving())
+        """Will send all the needed messages to sync the clock."""
+        lclt = time.localtime()
+        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()