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

velbusaio/controller.py

@@ -1,227 +1,299 @@
-"""
-Main interface for the velbusaio lib
-"""
+"""Main interface for the velbusaio lib."""
+
 from __future__ import annotations
 
 import asyncio
 import logging
-import pickle
+import pathlib
+import re
 import ssl
+import time
+from urllib.parse import urlparse
 
 import serial
-import serial_asyncio
+import serial_asyncio_fast
 
-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
+from velbusaio.message import Message
 from velbusaio.messages.module_type_request import ModuleTypeRequestMessage
 from velbusaio.messages.set_date import SetDate
 from velbusaio.messages.set_daylight_saving import SetDaylightSaving
 from velbusaio.messages.set_realtime_clock import SetRealtimeClock
 from velbusaio.module import Module
-from velbusaio.parser import VelbusParser
+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) -> None:
+    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._log.setLevel(logging.DEBUG)
-        self._dsn = dsn
-        self._parser = VelbusParser()
-        self._handler = PacketHandler(self.send, self)
-        self._writer = None
-        self._reader = None
-        self._modules = {}
-        self._submodules = []
-        self._send_queue = asyncio.Queue()
-        self._tasks = []
+
+        self._protocol = VelbusProtocol(
+            message_received_callback=self._on_message_received,
+            connection_lost_callback=self._on_connection_lost,
+        )
+        self._closing = False
+        self._auto_reconnect = True
+
+        self._destination = dsn
+        self._handler = PacketHandler(self, one_address)
+        self._modules: dict[int, Module] = {}
+        self._submodules: list[int] = []
+        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:
+        """Respond to Protocol connection lost."""
+        if self._auto_reconnect and not self._closing:
+            self._log.debug("Reconnecting to transport")
+            asyncio.ensure_future(self.connect())
 
     async def add_module(
         self,
-        addr: str,
-        typ: str,
-        data: dict,
-        serial=None,
-        memorymap=None,
-        build_year=None,
-        build_week=None,
+        addr: int,
+        typ: int,
+        serial: int | None = None,
+        memorymap: int | None = None,
+        build_year: int | None = None,
+        build_week: int | None = None,
     ) -> None:
-        """
-        Add a founc module to the module cache
-        """
-        mod = self._load_module_from_cache(addr)
-        if mod:
-            self._log.info(f"Load module from CACHE: {addr}")
-            self._modules[addr] = mod
-        else:
-            self._log.info(f"Load NEW module: {typ} @ {addr}")
-            self._modules[addr] = Module(
-                addr,
-                typ,
-                data,
-                serial=serial,
-                build_year=build_year,
-                build_week=build_week,
-                memorymap=memorymap,
-            )
-        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, subList) -> 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 _load_module_from_cache(self, address) -> None | str:
-        try:
-            with open(f"{get_cache_dir()}/{address}.p", "rb") as fl:
-                return pickle.load(fl)
-        except OSError:
-            pass
+    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:
-        for task in self._tasks:
-            task.cancel()
-        self._writer.close()
-        await self._writer.wait_closed()
-
-    async def connect(self, test_connect: bool = False) -> None:
-        """
-        Connect to the bus and load all the data
-        """
+        """Stop the controller."""
+        self._closing = True
+        self._auto_reconnect = False
+        self._protocol.close()
+
+    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 self._dsn.startswith("tls://"):
-                tmp = self._dsn.replace("tls://", "").split(":")
+            if not re.search(r"^[A-Za-z0-9+.\-]+://", self._destination):
+                # if no scheme, then add the tcp://
+                self._destination = f"tcp://{self._destination}"
+            parts = urlparse(self._destination)
+            if parts.scheme == "tls":
                 ctx = ssl._create_unverified_context()
             else:
-                tmp = self._dsn.split(":")
                 ctx = None
-            self._reader, self._writer = await asyncio.open_connection(
-                tmp[0], tmp[1], ssl=ctx
-            )
+            try:
+                (
+                    _transport,
+                    _protocol,
+                ) = await asyncio.get_event_loop().create_connection(
+                    lambda: self._protocol,
+                    host=parts.hostname,
+                    port=parts.port,
+                    ssl=ctx,
+                )
+
+            except (ConnectionRefusedError, OSError) as err:
+                raise VelbusConnectionFailed from err
         else:
             # serial port
-            self._reader, self._writer = await serial_asyncio.open_serial_connection(
-                url=self._dsn,
-                baudrate=38400,
-                bytesize=serial.EIGHTBITS,
-                parity=serial.PARITY_NONE,
-                stopbits=serial.STOPBITS_ONE,
-                xonxoff=0,
-                rtscts=1,
-            )
-        if test_connect:
-            return
-        # create reader, parser and writer tasks
-        self._tasks.append(asyncio.Task(self._socket_read_task()))
-        self._tasks.append(asyncio.Task(self._socket_send_task()))
-        self._tasks.append(asyncio.Task(self._parser_task()))
-        # scan the bus
-        await self.scan()
+            try:
+                _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
 
-    async def scan(self) -> None:
-        self._handler.scan_started()
-        for addr in range(1, 255):
-            msg = ModuleTypeRequestMessage(addr)
-            await self.send(msg)
-        await asyncio.sleep(30)
-        self._handler.scan_finished()
-        # calculate how long to wait
-        calc_timeout = len(self._modules) * 30
-        if calc_timeout < LOAD_TIMEOUT:
-            timeout = calc_timeout
+    async def start(self) -> None:
+        # if auth is required send the auth key
+        parts = urlparse(self._destination)
+        if parts.username:
+            await self._protocol.write_auth_key(parts.username)
+
+        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:
-            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 laoded within a timeout of {LOAD_TIMEOUT} seconds, continuing with the loaded modules"
+            # 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:
+        """Service endpoint to restart the scan"""
+        await self._handler.scan(True)
+
+    async def sendTypeRequestMessage(self, address: int) -> None:
+        msg = ModuleTypeRequestMessage(address)
+        await self.send(msg)
+
+    async def send(self, msg: Message) -> None:
+        """Send a packet."""
+        await self._protocol.send_message(
+            RawMessage(
+                priority=msg.priority,
+                address=msg.address,
+                rtr=msg.rtr,
+                data=msg.data_to_binary(),
             )
+        )
+
+    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")
 
-    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
-            if mods_loaded == len(self.get_modules()):
-                self._log.info("All modules loaded")
-                return
-            self._log.info("Not all modules loaded yet, waiting 30 seconds")
-            await asyncio.sleep(230)
-
-    async def send(self, msg) -> None:
-        """
-        Send a packet
-        """
-        await self._send_queue.put(msg)
-
-    async def _socket_send_task(self) -> None:
-        """
-        Task to send the packet from the queue to the bus
-        """
-        while self._send_queue:
-            msg = await self._send_queue.get()
-            self._log.debug(f"SENDING message: {msg}")
-            # print(':'.join('{:02X}'.format(x) for x in msg.to_binary()))
-            self._writer.write(msg.to_binary())
-            await asyncio.sleep(0.11)
-
-    async def _socket_read_task(self) -> None:
-        """
-        Task to read from a socket and push into a queue
-        """
-        while True:
-            data = await self._reader.read(10)
-            self._parser.feed(data)
-
-    async def _parser_task(self) -> None:
-        """
-        Task to parser the received queue
-        """
-        while True:
-            packet = await self._parser.wait_for_packet()
-            await self._handler.handle(packet)
-
-    def get_all(self, class_name: str) -> list:
+    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:
@@ -232,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()

velbusaio/discovery.py

@@ -12,7 +12,7 @@ class VelbusDiscoveryProtocol(asyncio.DatagramProtocol):
     def __init__(self, target: Address):
         self.target = target
 
-    def connection_made(self, transport: asyncio.transports.DatagramTransport):
+    def connection_made(self, transport: asyncio.transports.DatagramTransport) -> None:
         self.transport = transport
         sock = transport.get_extra_info("socket")
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -20,7 +20,7 @@ class VelbusDiscoveryProtocol(asyncio.DatagramProtocol):
         string = "Velbus Navigation Request"
         self.transport.sendto(string.encode(), self.target)
 
-    def datagram_received(self, data: bytes | str, addr: Address):
+    def datagram_received(self, data: bytes | str, addr: Address) -> None:
         # data received: b'{"message": "Velbus Navigation Guidance", "hostname": "Velbus", "model": "signum18", "id": "7b95834e", "velbus_port": 27015, "velbus_auth": false}' ('192.168.1.9', 32767)
         try:
             json_data = json.loads(data)

velbusaio/exceptions.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+
+class VelbusException(Exception):
+    """Velbus Exception."""
+
+    def __init__(self, value: str) -> None:
+        Exception.__init__(self)
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class VelbusConnectionFailed(VelbusException):
+    def __init__(self) -> None:
+        super().__init__("Connection setup failed")
+
+
+class VelbusConnectionTerminated(VelbusException):
+    def __init__(self) -> None:
+        super().__init__("Connection terminated")