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

velbusaio/messages/write_module_address_and_serial_number.py

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

velbusaio/module.py

@@ -1,16 +1,21 @@
 """
 This represents a velbus module
 """
+
 from __future__ import annotations
 
+import asyncio
+import importlib.resources
+import json
 import logging
 import os
 import pathlib
-import pickle
 import struct
 import sys
 from typing import Awaitable, Callable
 
+from aiofile import async_open
+
 from velbusaio.channels import (
     Blind,
     Button,
@@ -24,7 +29,10 @@ from velbusaio.channels import (
     SelectedProgram,
     Sensor,
     SensorNumber,
-    Temperature,
+)
+from velbusaio.channels import Temperature
+from velbusaio.channels import Temperature as TemperatureChannelType
+from velbusaio.channels import (
     ThermostatChannel,
 )
 from velbusaio.command_registry import commandRegistry
@@ -33,10 +41,10 @@ from velbusaio.const import (
     CHANNEL_MEMO_TEXT,
     CHANNEL_SELECTED_PROGRAM,
     PRIORITY_LOW,
+    SCAN_MODULEINFO_TIMEOUT_INITIAL,
 )
-from velbusaio.helpers import handle_match, keys_exists
+from velbusaio.helpers import h2, handle_match, keys_exists
 from velbusaio.message import Message
-from velbusaio.messages import DaliDeviceSettingMsg
 from velbusaio.messages.blind_status import BlindStatusMessage, BlindStatusNgMessage
 from velbusaio.messages.channel_name_part1 import (
     ChannelNamePart1Message,
@@ -56,23 +64,28 @@ from velbusaio.messages.channel_name_part3 import (
 from velbusaio.messages.channel_name_request import (
     COMMAND_CODE as CHANNEL_NAME_REQUEST_COMMAND_CODE,
 )
-from velbusaio.messages.channel_name_request import ChannelNameRequestMessage
+from velbusaio.messages.channel_name_request import (
+    ChannelNameRequestMessage,
+)
 from velbusaio.messages.clear_led import ClearLedMessage
 from velbusaio.messages.counter_status import CounterStatusMessage
 from velbusaio.messages.counter_status_request import CounterStatusRequestMessage
+from velbusaio.messages.counter_value import CounterValueMessage
+from velbusaio.messages.dali_device_settings import DaliDeviceSettingMsg
 from velbusaio.messages.dali_device_settings import DeviceType as DaliDeviceType
 from velbusaio.messages.dali_device_settings import DeviceTypeMsg as DaliDeviceTypeMsg
 from velbusaio.messages.dali_device_settings import MemberOfGroupMsg
 from velbusaio.messages.dali_device_settings_request import (
     COMMAND_CODE as DALI_DEVICE_SETTINGS_REQUEST_COMMAND_CODE,
 )
-from velbusaio.messages.dali_device_settings_request import DaliDeviceSettingsRequest
+from velbusaio.messages.dali_device_settings_request import (
+    DaliDeviceSettingsRequest,
+)
 from velbusaio.messages.dali_dim_value_status import DimValueStatus
 from velbusaio.messages.dimmer_channel_status import DimmerChannelStatusMessage
 from velbusaio.messages.dimmer_status import DimmerStatusMessage
 from velbusaio.messages.fast_blinking_led import FastBlinkingLedMessage
 from velbusaio.messages.memory_data import MemoryDataMessage
-from velbusaio.messages.raw import MeteoRawMessage, SensorRawMessage
 from velbusaio.messages.module_status import (
     ModuleStatusGP4PirMessage,
     ModuleStatusMessage,
@@ -80,9 +93,8 @@ from velbusaio.messages.module_status import (
     ModuleStatusPirMessage,
 )
 from velbusaio.messages.module_status_request import ModuleStatusRequestMessage
-from velbusaio.messages.module_subtype import ModuleSubTypeMessage
-from velbusaio.messages.module_type import ModuleTypeMessage, ModuleType2Message
 from velbusaio.messages.push_button_status import PushButtonStatusMessage
+from velbusaio.messages.raw import MeteoRawMessage, SensorRawMessage
 from velbusaio.messages.read_data_from_memory import ReadDataFromMemoryMessage
 from velbusaio.messages.relay_status import RelayStatusMessage, RelayStatusMessage2
 from velbusaio.messages.sensor_temperature import SensorTemperatureMessage
@@ -91,7 +103,6 @@ from velbusaio.messages.slider_status import SliderStatusMessage
 from velbusaio.messages.slow_blinking_led import SlowBlinkingLedMessage
 from velbusaio.messages.temp_sensor_status import TempSensorStatusMessage
 from velbusaio.messages.update_led_status import UpdateLedStatusMessage
-from velbusaio.channels import Temperature as TemperatureChannelType
 
 
 class Module:
@@ -104,18 +115,16 @@ class Module:
         cls,
         module_address: int,
         module_type: int,
-        module_data: dict,
         serial: int | None = None,
         memorymap: int | None = None,
         build_year: int | None = None,
         build_week: int | None = None,
         cache_dir: str | None = None,
     ) -> Module:
-        if module_type == 0x45:
+        if module_type == 0x45 or module_type == 0x5A:
             return VmbDali(
                 module_address,
                 module_type,
-                module_data,
                 serial,
                 memorymap,
                 build_year,
@@ -126,7 +135,6 @@ class Module:
         return Module(
             module_address,
             module_type,
-            module_data,
             serial,
             memorymap,
             build_year,
@@ -138,7 +146,6 @@ class Module:
         self,
         module_address: int,
         module_type: int,
-        module_data: dict,
         serial: int | None = None,
         memorymap: int | None = None,
         build_year: int | None = None,
@@ -146,8 +153,8 @@ class Module:
         cache_dir: str | None = None,
     ) -> None:
         self._address = module_address
-        self._type = module_type
-        self._data = module_data
+        self._type = int(module_type)
+        self._data = {}
 
         self._name = {}
         self._sub_address = {}
@@ -157,11 +164,47 @@ class Module:
         self.build_week = build_week
         self._cache_dir = cache_dir
         self._is_loading = False
+        self._got_status = asyncio.Event()
+        self._got_status.clear()
         self._channels = {}
         self.loaded = False
+        self._use_cache = True
+        self._loaded_cache = {}
+
+    async def wait_for_status_messages(self) -> None:
+        try:
+            await asyncio.wait_for(self._got_status.wait(), 2)
+        except Exception:
+            self._log.warning(f"Timeout waiting for status messages for: {self}")
 
-    def initialize(self, writer: Callable[[Message], Awaitable[None]]) -> None:
+    def get_initial_timeout(self) -> int:
+        return SCAN_MODULEINFO_TIMEOUT_INITIAL
+
+    async def initialize(self, writer: Callable[[Message], Awaitable[None]]) -> None:
         self._log = logging.getLogger("velbus-module")
+        # load the protocol data
+        try:
+            if sys.version_info >= (3, 13):
+                with importlib.resources.path(
+                    __name__, f"module_spec/{h2(self._type)}.json"
+                ) as fspath:
+                    async with async_open(fspath) as protocol_file:
+                        self._data = 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._data = json.loads(await protocol_file.read())
+            self._log.debug(f"Module spec {h2(self._type)} loaded")
+        except FileNotFoundError:
+            self._log.warning(f"No module spec for {h2(self._type)}")
+            self._data = {}
+
+        # set some params from the velbus controller
         self._writer = writer
         for chan in self._channels.values():
             chan._writer = writer
@@ -186,10 +229,12 @@ class Module:
                     ):
                         del self._channels[i]
 
-    def _cache(self) -> None:
-        cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.p")
-        with cfile.open("wb") as fl:
-            pickle.dump(self, fl)
+    async def _cache(self) -> None:
+        if not self._use_cache:
+            return
+        cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.json")
+        async with async_open(cfile, "w") as fl:
+            await fl.write(json.dumps(self.to_cache(), indent=4))
 
     def __getstate__(self) -> dict:
         d = self.__dict__
@@ -200,20 +245,20 @@ class Module:
         self.__dict__ = state
 
     def __repr__(self) -> str:
-        return (
-            "<{}: {{{}}} @ {{{}}} loaded:{{{}}} loading:{{{}}} channels{{:{}}}>".format(
-                self._name,
-                self._type,
-                self._address,
-                self.loaded,
-                self._is_loading,
-                self._channels,
-            )
-        )
+        return f"<{self._name} type:{self._type} address:{self._address} loaded:{self.loaded} loading:{self._is_loading} channels: {self._channels}>"
 
     def __str__(self) -> str:
         return self.__repr__()
 
+    def to_cache(self) -> dict:
+        d = {"name": self._name, "channels": {}}
+        for num, chan in self._channels.items():
+            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
@@ -231,7 +276,9 @@ class Module:
         return self._type
 
     def get_type_name(self) -> str:
-        return self._data["Type"]
+        if "Type" in self._data:
+            return self._data["Type"]
+        return "UNKNOWN"
 
     def get_serial(self) -> str | None:
         return self.serial
@@ -240,12 +287,7 @@ class Module:
         return self._name
 
     def get_sw_version(self) -> str:
-        return "{}-{}.{}.{}".format(
-            self.serial,
-            self.memory_map_version,
-            self.build_year,
-            self.build_week,
-        )
+        return f"{self.serial}-{self.memory_map_version}.{self.build_year}.{self.build_week}"
 
     def calc_channel_offset(self, address: int) -> int:
         _channel_offset = 0
@@ -260,6 +302,7 @@ class Module:
         """
         Process received message
         """
+        self._log.debug(f"RX: {message}")
         _channel_offset = self.calc_channel_offset(message.address)
 
         if isinstance(
@@ -271,6 +314,7 @@ class Module:
             ),
         ):
             self._process_channel_name_message(1, message)
+            await self._cache()
         elif isinstance(
             message,
             (
@@ -280,6 +324,7 @@ class Module:
             ),
         ):
             self._process_channel_name_message(2, message)
+            await self._cache()
         elif isinstance(
             message,
             (
@@ -289,6 +334,7 @@ class Module:
             ),
         ):
             self._process_channel_name_message(3, message)
+            await self._cache()
         elif isinstance(message, MemoryDataMessage):
             await self._process_memory_data_message(message)
         elif isinstance(message, (RelayStatusMessage, RelayStatusMessage2)):
@@ -516,14 +562,22 @@ class Module:
             await self._update_channel(
                 message.sensor, {"cur": message.value, "unit": message.unit}
             )
-
-        self._cache()
+        elif isinstance(message, CounterValueMessage):
+            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})
+        # notigy status
+        self._got_status.set()
 
     async def _update_channel(self, channel: int, updates: dict):
         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}"
             )
 
@@ -533,33 +587,61 @@ class Module:
         """
         return self._channels
 
+    async def load_from_vlp(self, vlp_data: dict) -> None:
+        self._name = vlp_data.get_name()
+        self._data["Channels"] = vlp_data.get_channels()
+        self._use_cache = False
+        self._is_loading = False
+        self.loaded = True
+        await self._load_default_channels()
+        # TODO set all channels to _is_loaded = True
+        for chan in self._channels.values():
+            chan._is_loaded = True
+        await self._request_module_status()
+
     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
+        cache = await self._get_cache()
+        self._loaded_cache = cache
         # load default channels
-        await self.__load_default_channels()
+        await self._load_default_channels()
+
         # load the data from memory ( the stuff that we need)
-        await self.__load_memory()
+        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
-        await self._request_channel_name()
+        if "channels" in cache:
+            for num, chan in cache["channels"].items():
+                self._channels[int(num)]._name = chan["name"]
+                if "subdevice" in chan:
+                    self._channels[int(num)]._sub_device = chan["subdevice"]
+                else:
+                    self._channels[int(num)]._sub_device = False
+                if "Unit" in chan:
+                    self._channels[int(num)]._Unit = chan["Unit"]
+                self._channels[int(num)]._is_loaded = True
+        else:
+            await self._request_channel_name()
         # load the module specific stuff
         self._load()
         # stop the loading
         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:
         """
@@ -586,7 +668,11 @@ class Module:
         addr = "{high:02X}{low:02X}".format(
             high=message.high_address, low=message.low_address
         )
-        mdata = self._data["Memory"]["1"]["Address"][addr]
+        if "Memory" not in self._data:
+            return
+        if "Address" not in self._data["Memory"]:
+            return
+        mdata = self._data["Memory"]["Address"][addr]
         if "ModuleName" in mdata and isinstance(self._name, dict):
             # if self._name is a dict we are still loading
             # if its a string it was already complete
@@ -635,7 +721,7 @@ class Module:
             )
         return int(channel)
 
-    def is_loaded(self) -> bool:
+    async def is_loaded(self) -> bool:
         """
         Check if all name messages have been received
         """
@@ -653,7 +739,7 @@ class Module:
                 return False
         # set that  we finished the module loading
         self.loaded = True
-        self._cache()
+        await self._cache()
         return True
 
     async def _request_module_status(self) -> None:
@@ -661,15 +747,20 @@ 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():
-            if int(chan) < 9 and chan_data["Type"] in ("Blind", "Dimmer", "Relay"):
-                mod_stat_req_msg.channels.append(int(chan))
-            if chan_data["Type"] == "ButtonCounter":
-                if counter_msg is None:
-                    counter_msg = CounterStatusRequestMessage(self._address)
-                counter_msg.channels.append(int(chan))
+        if keys_exists(self._data, "AllChannelStatus"):
+            mod_stat_req_msg.channels = self._data["AllChannelStatus"]
+        else:
+            for chan, chan_data in self._data["Channels"].items():
+                if int(chan) < 9 and chan_data["Type"] in ("Blind", "Dimmer", "Relay"):
+                    mod_stat_req_msg.channels.append(int(chan))
+                if chan_data["Type"] == "ButtonCounter":
+                    if counter_msg is None:
+                        counter_msg = CounterStatusRequestMessage(self._address)
+                    counter_msg.channels.append(int(chan))
         await self._writer(mod_stat_req_msg)
         if counter_msg is not None:
             await self._writer(counter_msg)
@@ -702,9 +793,10 @@ class Module:
             self._name = None
             return
 
-        for _memory_key, memory_part in self._data["Memory"].items():
-            if "Address" in memory_part:
-                for addr_int in memory_part["Address"].keys():
+        for memory_key, memory_part in self._data["Memory"].items():
+
+            if memory_key == "Address":
+                for addr_int in memory_part.keys():
                     addr = struct.unpack(
                         ">BB", struct.pack(">h", int("0x" + addr_int, 0))
                     )
@@ -714,34 +806,34 @@ 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
 
         for chan, chan_data in self._data["Channels"].items():
             edit = True
+            sub = True
             if "Editable" not in chan_data or chan_data["Editable"] != "yes":
                 edit = False
+            if "Subdevice" not in chan_data or chan_data["Subdevice"] != "yes":
+                sub = False
             cls = getattr(sys.modules[__name__], chan_data["Type"])
             self._channels[int(chan)] = cls(
-                self, int(chan), chan_data["Name"], edit, self._writer, self._address
+                module=self,
+                num=int(chan),
+                name=chan_data["Name"],
+                nameEditable=edit,
+                subDevice=sub,
+                writer=self._writer,
+                address=self._address,
             )
             if chan_data["Type"] == "Temperature":
                 if "Thermostat" in self._data or (
                     "ThermostatAddr" in self._data and self._data["ThermostatAddr"] != 0
                 ):
                     await self._update_channel(int(chan), {"thermostat": True})
-        # add extra channel for program selection which is not in the channel list of the protocol.json file,
-        # but is available in the messages list of the corresponding module.
-        if keys_exists(self._data, "Messages", "B3"):
-            self._channels[CHANNEL_SELECTED_PROGRAM] = SelectedProgram(
-                self,
-                CHANNEL_SELECTED_PROGRAM,
-                "Selected Program",
-                False,
-                self._writer,
-                self._address,
-            )
+            if chan_data["Type"] == "Dimmer" and "sliderScale" in self._data:
+                self._channels[int(chan)].slider_scale = self._data["sliderScale"]
 
 
 class VmbDali(Module):
@@ -754,7 +846,6 @@ class VmbDali(Module):
         self,
         module_address: int,
         module_type: int,
-        module_data: dict,
         serial: int | None = None,
         memorymap: int | None = None,
         build_year: int | None = None,
@@ -764,7 +855,6 @@ class VmbDali(Module):
         super().__init__(
             module_address,
             module_type,
-            module_data,
             serial,
             memorymap,
             build_year,
@@ -773,19 +863,24 @@ class VmbDali(Module):
         )
         self.group_members: dict[int, set[int]] = {}
 
-    async def load(self, from_cache: bool = False) -> None:
-        await super().load(from_cache)
-
-        if not from_cache:
-            for chan in range(1, 64 + 1):
-                self._channels[chan] = Channel(
-                    self, chan, "placeholder", True, self._writer, self._address
-                )
-                # Placeholders will keep this module loading
-                # Until the DaliDeviceSettings messages either delete or replace these placeholder's
-                # with actual channels
-
-            await self._request_dali_channels()
+    def get_initial_timeout(self) -> int:
+        return 100000
+
+    async def _load_default_channels(self) -> None:
+        for chan in range(1, 64 + 1):
+            self._channels[chan] = Channel(
+                module=self,
+                num=chan,
+                name="placeholder",
+                nameEditable=True,
+                subDevice=True,
+                writer=self._writer,
+                address=self._address,
+            )
+            # Placeholders will keep this module loading
+            # Until the DaliDeviceSettings messages either delete or replace these placeholder's
+            # with actual channels
+        await self._request_dali_channels()
 
     async def _request_dali_channels(self):
         msg_type = commandRegistry.get_command(
@@ -804,13 +899,32 @@ 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,
                             message.channel,
                             None,
                             True,
+                            True,
                             self._writer,
                             self._address,
                             slider_scale=254,
@@ -860,8 +974,6 @@ class VmbDali(Module):
         else:
             return await super().on_message(message)
 
-        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/01.json

@@ -0,0 +1,62 @@
+{
+  "Channels": {
+    "01": {
+      "Editable": "yes",
+      "Name": "Push button 1",
+      "Type": "Button"
+    },
+    "02": {
+      "Editable": "yes",
+      "Name": "Push button 2",
+      "Type": "Button"
+    },
+    "03": {
+      "Editable": "yes",
+      "Name": "Push button 3",
+      "Type": "Button"
+    },
+    "04": {
+      "Editable": "yes",
+      "Name": "Push button 4",
+      "Type": "Button"
+    },
+    "05": {
+      "Editable": "yes",
+      "Name": "Push button 5",
+      "Type": "Button"
+    },
+    "06": {
+      "Editable": "yes",
+      "Name": "Push button 6",
+      "Type": "Button"
+    },
+    "07": {
+      "Editable": "yes",
+      "Name": "Push button 7",
+      "Type": "Button"
+    },
+    "08": {
+      "Editable": "yes",
+      "Name": "Push button 8",
+      "Type": "Button"
+    },
+    "96": {
+      "Name": "SelectedProgram",
+      "Type": "SelectedProgram"
+    }
+  },
+  "Info": "8-Channel Push Button Module",
+  "Type": "VMB8PB",
+  "Memory": {
+    "Channels": {
+      "01": "0000-000E",
+      "02": "0010-001E",
+      "03": "0020-002E",
+      "04": "0030-003E",
+      "05": "0040-004E",
+      "06": "0050-005E",
+      "07": "0060-006E",
+      "08": "0070-007E"
+    }
+  }
+}