velbus-aio 2024.7.6__py3-none-any.whl → 2024.11.0__py3-none-any.whl

velbusaio/handler.py

@@ -5,30 +5,30 @@ 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 importlib.resources
 import json
 import logging
-import threading
 import os
 import pathlib
+import pprint
+import sys
+from typing import TYPE_CHECKING, Awaitable, Callable
 
 from aiofile import async_open
 
-from typing import TYPE_CHECKING, Awaitable, Callable
-import pkg_resources
-
 from velbusaio.command_registry import commandRegistry
+from velbusaio.const import (
+    SCAN_MODULEINFO_TIMEOUT_INITIAL,
+    SCAN_MODULEINFO_TIMEOUT_INTERVAL,
+    SCAN_MODULETYPE_TIMEOUT,
+)
 from velbusaio.helpers import h2, keys_exists
 from velbusaio.message import Message
 from velbusaio.messages.module_subtype import ModuleSubTypeMessage
-from velbusaio.messages.module_type import ModuleTypeMessage, ModuleType2Message
+from velbusaio.messages.module_type import ModuleType2Message, ModuleTypeMessage
 from velbusaio.raw_message import RawMessage
 
-
 if TYPE_CHECKING:
     from velbusaio.controller import Velbus
 
@@ -41,21 +41,34 @@ class PacketHandler:
     def __init__(
         self,
         velbus: Velbus,
+        one_address: int | None = None,
     ) -> None:
         self._log = logging.getLogger("velbus-handler")
         self._log.setLevel(logging.DEBUG)
         self._velbus = velbus
+        self._one_address = one_address
         self._typeResponseReceived = asyncio.Event()
-        self._scanLock = threading.Lock()
+        self._scanLock = asyncio.Lock()
         self._modulescan_address = 0
         self._scan_complete = False
         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.loads(await protocol_file.read())
+        if sys.version_info >= (3, 13):
+            with importlib.resources.path(
+                __name__, "module_spec/broadcast.json"
+            ) as fspath:
+                async with async_open(fspath) as protocol_file:
+                    self.broadcast = json.loads(await protocol_file.read())
+        else:
+            async with async_open(
+                str(
+                    importlib.resources.files(__name__.split(".")[0]).joinpath(
+                        "module_spec/broadcast.json"
+                    )
+                )
+            ) as protocol_file:
+                self.broadcast = json.loads(await protocol_file.read())
 
     def empty_cache(self) -> bool:
         if (
@@ -84,12 +97,22 @@ class PacketHandler:
         while self._modulescan_address < 254:
             address = 0
             module = None
-            with self._scanLock:
+            async with self._scanLock:
                 self._modulescan_address = self._modulescan_address + 1
                 address = self._modulescan_address
+                if self._velbus.addr_is_submodule(address):
+                    self._log.info(
+                        f"Skipping submodule address {address}, already handled"
+                    )
+                    continue
+                self._log.info(f"Starting handling scan {address}")
                 module = self._velbus.get_module(address)
 
-            self._log.info(f"Starting handling scan {address}")
+            if self._one_address is not None and address != int(self._one_address):
+                self._log.info(
+                    f"Skipping address {address} as we requested to only scan one address {self._one_address}"
+                )
+                continue
 
             cfile = pathlib.Path(f"{self._velbus.get_cache_dir()}/{address}.json")
             # cleanup the old module cache if needed
@@ -107,7 +130,7 @@ class PacketHandler:
                         self._typeResponseReceived.wait(),
                         SCAN_MODULETYPE_TIMEOUT / 1000.0,
                     )
-                    with self._scanLock:
+                    async with self._scanLock:
                         module = self._velbus.get_module(address)
                 except asyncio.TimeoutError:
                     self._log.info(
@@ -115,20 +138,24 @@ class PacketHandler:
                     )
                 if module is not None:
                     try:
-                        self._log.debug(f"Module {address} detected: start loading")
+                        self._log.debug(
+                            f"Module {module._address} detected: start loading"
+                        )
                         await asyncio.wait_for(
                             module.load(from_cache=True),
                             SCAN_MODULEINFO_TIMEOUT_INITIAL / 1000.0,
                         )
-                        self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INITIAL
-                        while self._scan_delay_msec > 50 and not module.is_loaded():
+                        self._scan_delay_msec = module.get_initial_timeout()
+                        while (
+                            self._scan_delay_msec > 50 and not await module.is_loaded()
+                        ):
                             # self._log.debug(
-                            #    f"\t... waiting {self._scan_delay_msec} is_loaded={module.is_loaded()}"
+                            #    f"\t... waiting {self._scan_delay_msec} is_loaded={await module.is_loaded()}"
                             # )
                             self._scan_delay_msec = self._scan_delay_msec - 50
                             await asyncio.sleep(0.05)
                         self._log.info(
-                            f"Scan module {address} completed, module loaded={module.is_loaded()}"
+                            f"Scan module {address} completed, module loaded={await module.is_loaded()}"
                         )
                     except asyncio.TimeoutError:
                         self._log.error(
@@ -153,49 +180,47 @@ class PacketHandler:
         data = rawmsg.data_only
 
         # 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
+        if command_value == 0xFF and not self._scan_complete:
+            tmsg: ModuleTypeMessage = ModuleTypeMessage()
+            tmsg.populate(priority, address, rtr, data)
+            async with self._scanLock:
+                await self._handle_module_type(tmsg)
+                if address == self._modulescan_address:
+                    self._typeResponseReceived.set()
+                else:
+                    self._log.debug(
+                        f"Unexpected module type message module address {address}, Velbuslink scan?"
+                    )
+                    self._modulescan_address = address - 1
 
-                self._typeResponseReceived.set()
+            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)
+        elif command_value in (0xB0, 0xA7, 0xA6) and 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
+            async with self._scanLock:
+                self._scan_delay_msec += SCAN_MODULEINFO_TIMEOUT_INTERVAL
+                self._handle_module_subtype(msg)
 
         # ignore broadcast
-        elif command_value in self.pdata["MessagesBroadCast"]:
+        elif command_value in self.broadcast:
             self._log.debug(
                 "Received broadcast message {} from {}, ignoring".format(
-                    self.pdata["MessageBroadCast"][str(command_value).upper()], address
+                    self.broadcast[str(command_value).upper()], address
                 )
             )
 
         # handle other messages for modules that are already scanned
         else:
             module = None
-            with self._scanLock:
+            async with self._scanLock:
                 module = self._velbus.get_module(address)
             if module is not None:
                 module_type = module.get_type()
@@ -214,28 +239,29 @@ class PacketHandler:
                         0xFE,
                         0xCC,
                     ):  # names, memory data, memory block
-                        self._scan_delay_msec = SCAN_MODULEINFO_TIMEOUT_INTERVAL
+                        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:
+    async def _handle_module_type(
+        self, msg: ModuleTypeMessage | ModuleType2Message
+    ) -> None:
         """
         load the module data
         """
         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(
+                # data = keys_exists(self.pdata, "ModuleTypes", h2(msg.module_type))
+                # if not data:
+                #    self._log.warning(f"Module not recognized: {msg.module_type}")
+                #    return
+                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,

velbusaio/messages/__init__.py

@@ -51,13 +51,13 @@ from velbusaio.messages.memo_text import MemoTextMessage
 from velbusaio.messages.memory_data import MemoryDataMessage
 from velbusaio.messages.memory_data_block import MemoryDataBlockMessage
 from velbusaio.messages.memory_dump_request import MemoryDumpRequestMessage
-from velbusaio.messages.raw import MeteoRawMessage, SensorRawMessage
 from velbusaio.messages.module_status import ModuleStatusMessage, ModuleStatusMessage2
 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.module_type import ModuleType2Message, ModuleTypeMessage
 from velbusaio.messages.module_type_request import ModuleTypeRequestMessage
 from velbusaio.messages.push_button_status import PushButtonStatusMessage
+from velbusaio.messages.raw import MeteoRawMessage, SensorRawMessage
 from velbusaio.messages.read_data_block_from_memory import (
     ReadDataBlockFromMemoryMessage,
 )

velbusaio/messages/blind_status.py

@@ -13,7 +13,7 @@ COMMAND_CODE = 0xEC
 DSTATUS = {0: "off", 1: "up", 2: "down"}
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class BlindStatusNgMessage(Message):
     """
     sent by: VMB2BLE

velbusaio/messages/channel_name_part1.py

@@ -84,6 +84,7 @@ class ChannelNamePart1Message(Message):
         "VMBGP4PIR-20",
         "VMB4LEDPWM-20",
         "VMB8DC-20",
+        "VMB8IN-20",
     ],
 )
 class ChannelNamePart1Message2(ChannelNamePart1Message):

velbusaio/messages/channel_name_part2.py

@@ -83,6 +83,7 @@ class ChannelNamePart2Message(Message):
         "VMBEL4PIR-20",
         "VMBGP4PIR-20",
         "VMB8DC-20",
+        "VMB8IN-20",
     ],
 )
 class ChannelNamePart2Message2(ChannelNamePart2Message):

velbusaio/messages/channel_name_part3.py

@@ -83,6 +83,7 @@ class ChannelNamePart3Message(Message):
         "VMBEL4PIR-20",
         "VMBGP4PIR-20",
         "VMB8DC-20",
+        "VMB8IN-20",
     ],
 )
 class ChannelNamePart3Message2(ChannelNamePart3Message):

velbusaio/messages/cover_down.py

@@ -12,7 +12,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0x06
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class CoverDownMessage(Message):
     """
     sent by:

velbusaio/messages/cover_off.py

@@ -10,7 +10,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0x04
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class CoverOffMessage(Message):
     """
     sent by:

velbusaio/messages/cover_position.py

@@ -10,7 +10,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0x1C
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class CoverPosMessage(Message):
     """
     sent by:

velbusaio/messages/cover_up.py

@@ -12,7 +12,7 @@ from velbusaio.message import Message
 COMMAND_CODE = 0x05
 
 
-@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS"])
+@register(COMMAND_CODE, ["VMB1BLE", "VMB2BLE", "VMB1BLS", "VMB2BLE-10"])
 class CoverUpMessage(Message):
     """
     sent by:

velbusaio/messages/edge_set_color.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from enum import IntEnum
+
 from velbusaio.command_registry import register
 from velbusaio.message import Message
 

velbusaio/module.py

@@ -4,14 +4,17 @@ This represents a velbus module
 
 from __future__ import annotations
 
+import importlib.resources
+import json
 import logging
+import os
 import pathlib
 import struct
 import sys
-import json
-import os
 from typing import Awaitable, Callable
 
+from aiofile import async_open
+
 from velbusaio.channels import (
     Blind,
     Button,
@@ -25,19 +28,20 @@ from velbusaio.channels import (
     SelectedProgram,
     Sensor,
     SensorNumber,
-    Temperature,
-    ThermostatChannel,
 )
+from velbusaio.channels import Temperature
+from velbusaio.channels import Temperature as TemperatureChannelType
+from velbusaio.channels import ThermostatChannel
 from velbusaio.command_registry import commandRegistry
 from velbusaio.const import (
     CHANNEL_LIGHT_VALUE,
     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.dali_device_settings import DaliDeviceSettingMsg
 from velbusaio.messages.blind_status import BlindStatusMessage, BlindStatusNgMessage
 from velbusaio.messages.channel_name_part1 import (
     ChannelNamePart1Message,
@@ -61,6 +65,7 @@ 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.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
@@ -73,7 +78,6 @@ 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,
@@ -82,6 +86,7 @@ from velbusaio.messages.module_status import (
 )
 from velbusaio.messages.module_status_request import ModuleStatusRequestMessage
 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
@@ -90,7 +95,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:
@@ -103,7 +107,6 @@ 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,
@@ -114,7 +117,6 @@ class Module:
             return VmbDali(
                 module_address,
                 module_type,
-                module_data,
                 serial,
                 memorymap,
                 build_year,
@@ -125,7 +127,6 @@ class Module:
         return Module(
             module_address,
             module_type,
-            module_data,
             serial,
             memorymap,
             build_year,
@@ -137,7 +138,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,
@@ -145,8 +145,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 = {}
@@ -159,8 +159,34 @@ class Module:
         self._channels = {}
         self.loaded = False
 
-    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
@@ -185,10 +211,10 @@ class Module:
                     ):
                         del self._channels[i]
 
-    def _cache(self) -> None:
+    async def _cache(self) -> None:
         cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.json")
-        with cfile.open("w") as fl:
-            json.dump(self.to_cache(), fl, indent=4)
+        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__
@@ -265,6 +291,7 @@ class Module:
             ),
         ):
             self._process_channel_name_message(1, message)
+            await self._cache()
         elif isinstance(
             message,
             (
@@ -274,6 +301,7 @@ class Module:
             ),
         ):
             self._process_channel_name_message(2, message)
+            await self._cache()
         elif isinstance(
             message,
             (
@@ -283,6 +311,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)):
@@ -511,8 +540,6 @@ class Module:
                 message.sensor, {"cur": message.value, "unit": message.unit}
             )
 
-        self._cache()
-
     async def _update_channel(self, channel: int, updates: dict):
         try:
             await self._channels[channel].update(updates)
@@ -533,8 +560,8 @@ class Module:
         # see if we have a cache
         try:
             cfile = pathlib.Path(f"{self._cache_dir}/{self._address}.json")
-            with cfile.open("r") as fl:
-                cache = json.load(fl)
+            async with async_open(cfile, "r") as fl:
+                cache = json.loads(await fl.read())
         except OSError:
             cache = {}
         # load default channels
@@ -551,6 +578,10 @@ class Module:
         if "channels" in cache:
             for num, chan in cache["channels"].items():
                 self._channels[int(num)]._name = chan["name"]
+                if "sub_device" in chan:
+                    self._channels[int(num)]._sub_device = chan["sub_device"]
+                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
@@ -640,7 +671,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
         """
@@ -658,7 +689,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:
@@ -728,11 +759,20 @@ class Module:
 
         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 (
@@ -751,7 +791,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,
@@ -761,7 +800,6 @@ class VmbDali(Module):
         super().__init__(
             module_address,
             module_type,
-            module_data,
             serial,
             memorymap,
             build_year,
@@ -770,10 +808,19 @@ class VmbDali(Module):
         )
         self.group_members: dict[int, set[int]] = {}
 
+    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(
-                self, chan, "placeholder", True, self._writer, self._address
+                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
@@ -804,6 +851,7 @@ class VmbDali(Module):
                             message.channel,
                             None,
                             True,
+                            True,
                             self._writer,
                             self._address,
                             slider_scale=254,
@@ -853,7 +901,7 @@ class VmbDali(Module):
         else:
             return await super().on_message(message)
 
-        self._cache()
+        await self._cache()
 
     async def _request_channel_name(self) -> None:
         # Channel names are requested after channel scan