begin attempting async switchover due to library performance improvement

Author: sventenraa

custom_components/victron/__init__.py

@@ -35,6 +35,8 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
         config_entry.data[SCAN_REGISTERS],
         config_entry.options[CONF_INTERVAL],
     )
+
+    await coordinator.api.connect()
     # try:
     #     await coordinator.async_config_entry_first_refresh()
     # except ConfigEntryNotReady:

custom_components/victron/config_flow.py

@@ -70,7 +70,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
     hub = VictronHub(data[CONF_HOST], data[CONF_PORT])
 
     try:
-        hub.connect()
+        await hub.connect()
         _LOGGER.debug("connection was succesfull")
         discovered_devices = await scan_connected_devices(hub=hub)
         _LOGGER.debug("successfully discovered devices")
@@ -81,7 +81,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
 
 async def scan_connected_devices(hub: VictronHub) -> list:
     """Scan for connected devices."""
-    return hub.determine_present_devices()
+    return await hub.determine_present_devices()
 
 
 class VictronFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):

custom_components/victron/coordinator.py

@@ -55,7 +55,6 @@ def __init__(
             hass, _LOGGER, name=DOMAIN, update_interval=timedelta(seconds=interval)
         )
         self.api = VictronHub(host, port)
-        self.api.connect()
         self.decodeInfo = decodeInfo
         self.interval = interval
 
@@ -194,9 +193,7 @@ async def fetch_registers(self, unit, registerData):
         """Fetch the registers."""
         try:
             # run api_update in async job
-            return await self.hass.async_add_executor_job(
-                self.api_update, unit, registerData
-            )
+            return await self.api_update(unit, registerData)
 
         except HomeAssistantError as e:
             raise UpdateFailed("Fetching registers failed") from e
@@ -210,10 +207,10 @@ def api_write(self, unit, address, value):
         # recycle connection
         return self.api.write_register(unit=unit, address=address, value=value)
 
-    def api_update(self, unit, registerInfo):
+    async def api_update(self, unit, registerInfo):
         """Update the api."""
         # recycle connection
-        return self.api.read_holding_registers(
+        return await self.api.read_holding_registers(
             unit=unit,
             address=self.api.get_first_register_id(registerInfo),
             count=self.api.calculate_register_count(registerInfo),

custom_components/victron/hub.py

@@ -4,7 +4,7 @@
 import logging
 import threading
 
-from pymodbus.client import ModbusTcpClient
+from pymodbus.client import AsyncModbusTcpClient
 
 from .const import (
     INT32,
@@ -27,49 +27,54 @@ def __init__(self, host: str, port: int) -> None:
         self.host = host
         self.port = port
         # Fail more quickly and only retry once before executing retry logic
-        self._client = ModbusTcpClient(
-            host=self.host, port=self.port, timeout=10, retries=1
+        self._client = AsyncModbusTcpClient(
+            host=self.host, port=self.port, timeout=30, retries=10
         )
         self._lock = threading.Lock()
 
     def is_still_connected(self):
         """Check if the connection is still open."""
         return self._client.is_socket_open()
 
-    def connect(self):
+    async def connect(self):
         """Connect to the Modbus TCP server."""
-        return self._client.connect()
+        return await self._client.connect()
 
-    def disconnect(self):
+    async def disconnect(self):
         """Disconnect from the Modbus TCP server."""
         if self._client.is_socket_open():
             return self._client.close()
         return None
 
-    def write_register(self, unit, address, value):
+    async def write_register(self, unit, address, value):
         """Write a register."""
         try:
             slave = int(unit)
-            if not unit:
+            if not (0 <= slave <= 254):
                 _LOGGER.error(
                     "Unit for this device (%s) isn't set correctly. Cannot write (%s) to register (%s). Ensure that the config was migrated to latest state by forcing a rescan",
-                    unit,
+                    slave,
                     value,
                     address,
                 )
                 return
-            self._client.write_register(address=address, value=value, slave=slave)
+            await self._client.write_register(address=address, value=value, slave=slave)
         except BrokenPipeError:
             self.__handle_broken_pipe_error()
 
-    def read_holding_registers(self, unit, address, count):
+    async def read_holding_registers(self, unit, address, count):
         """Read holding registers."""
         try:
-            if not unit:
+            slave = int(unit)
+            if not (0 <= slave <= 254):
+                _LOGGER.error(
+                    "Unit for this device (%s) isn't set correctly. Cannot read register (%s). Ensure that the config was migrated to latest state by forcing a rescan",
+                    slave,
+                    address,
+                )
                 return None
 
-            slave = int(unit)
-            return self._client.read_holding_registers(
+            return await self._client.read_holding_registers(
                 address=address, count=count, slave=slave
             )
         except BrokenPipeError:
@@ -111,7 +116,7 @@ def get_first_register_id(self, registerInfoDict: OrderedDict):
         first_register = next(iter(registerInfoDict))
         return registerInfoDict[first_register].register
 
-    def determine_present_devices(self):
+    async def determine_present_devices(self):
         """Determine which devices are present."""
         valid_devices = {}
 
@@ -124,7 +129,7 @@ def determine_present_devices(self):
 
                 address = self.get_first_register_id(register_definition)
                 count = self.calculate_register_count(register_definition)
-                result = self.read_holding_registers(unit, address, count)
+                result = await self.read_holding_registers(unit, address, count)
                 if result is None:
                     _LOGGER.debug(
                         "result is error for unit: %s address: %s count: %s and result: %s",