Fix modbus blocking threads

homeassistant/components/modbus/__init__.py

@@ -100,7 +100,7 @@
     MODBUS_DOMAIN as DOMAIN,
     PLATFORMS,
 )
-from .modbus import modbus_setup
+from .modbus import async_modbus_setup
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -348,8 +348,8 @@ def control_scan_interval(config: dict) -> dict:
 )
 
 
-def setup(hass, config):
+async def async_setup(hass, config):
     """Set up Modbus component."""
-    return modbus_setup(
+    return await async_modbus_setup(
         hass, config, SERVICE_WRITE_REGISTER_SCHEMA, SERVICE_WRITE_COIL_SCHEMA
     )

homeassistant/components/modbus/binary_sensor.py

@@ -114,9 +114,7 @@ def __init__(self, hub, hass, entry):
 
     async def async_added_to_hass(self):
         """Handle entity which will be added."""
-        async_track_time_interval(
-            self._hass, lambda arg: self.update(), self._scan_interval
-        )
+        async_track_time_interval(self._hass, self.async_update, self._scan_interval)
 
     @property
     def name(self):
@@ -148,17 +146,21 @@ def available(self) -> bool:
         """Return True if entity is available."""
         return self._available
 
-    def update(self):
+    async def async_update(self, now=None):
         """Update the state of the sensor."""
+        # remark "now" is a dummy parameter to avoid problems with
+        # async_track_time_interval
         if self._input_type == CALL_TYPE_COIL:
-            result = self._hub.read_coils(self._slave, self._address, 1)
+            result = await self._hub.async_read_coils(self._slave, self._address, 1)
         else:
-            result = self._hub.read_discrete_inputs(self._slave, self._address, 1)
+            result = await self._hub.async_read_discrete_inputs(
+                self._slave, self._address, 1
+            )
         if result is None:
             self._available = False
-            self.schedule_update_ha_state()
+            self.async_write_ha_state()
             return
 
         self._value = result.bits[0] & 1
         self._available = True
-        self.schedule_update_ha_state()
+        self.async_write_ha_state()

homeassistant/components/modbus/climate.py

@@ -132,9 +132,7 @@ def __init__(
 
     async def async_added_to_hass(self):
         """Handle entity which will be added."""
-        async_track_time_interval(
-            self.hass, lambda arg: self.update(), self._scan_interval
-        )
+        async_track_time_interval(self.hass, self.async_update, self._scan_interval)
 
     @property
     def should_poll(self):
@@ -160,7 +158,7 @@ def hvac_modes(self):
         """Return the possible HVAC modes."""
         return [HVAC_MODE_AUTO]
 
-    def set_hvac_mode(self, hvac_mode: str) -> None:
+    async def async_set_hvac_mode(self, hvac_mode: str) -> None:
         """Set new target hvac mode."""
         # Home Assistant expects this method.
         # We'll keep it here to avoid getting exceptions.
@@ -200,7 +198,7 @@ def target_temperature_step(self):
         """Return the supported step of target temperature."""
         return self._temp_step
 
-    def set_temperature(self, **kwargs):
+    async def async_set_temperature(self, **kwargs):
         """Set new target temperature."""
         if ATTR_TEMPERATURE not in kwargs:
             return
@@ -209,35 +207,39 @@ def set_temperature(self, **kwargs):
         )
         byte_string = struct.pack(self._structure, target_temperature)
         register_value = struct.unpack(">h", byte_string[0:2])[0]
-        self._available = self._hub.write_registers(
+        self._available = await self._hub.async_write_registers(
             self._slave,
             self._target_temperature_register,
             register_value,
         )
-        self.update()
+        self.async_update()
 
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
         return self._available
 
-    def update(self):
+    async def async_update(self, now=None):
         """Update Target & Current Temperature."""
-        self._target_temperature = self._read_register(
+        # remark "now" is a dummy parameter to avoid problems with
+        # async_track_time_interval
+        self._target_temperature = await self._async_read_register(
             CALL_TYPE_REGISTER_HOLDING, self._target_temperature_register
         )
-        self._current_temperature = self._read_register(
+        self._current_temperature = await self._async_read_register(
             self._current_temperature_register_type, self._current_temperature_register
         )
 
-        self.schedule_update_ha_state()
+        self.async_write_ha_state()
 
-    def _read_register(self, register_type, register) -> float | None:
+    async def _async_read_register(self, register_type, register) -> float | None:
         """Read register using the Modbus hub slave."""
         if register_type == CALL_TYPE_REGISTER_INPUT:
-            result = self._hub.read_input_registers(self._slave, register, self._count)
+            result = await self._hub.async_read_input_registers(
+                self._slave, register, self._count
+            )
         else:
-            result = self._hub.read_holding_registers(
+            result = await self._hub.async_read_holding_registers(
                 self._slave, register, self._count
             )
         if result is None:

homeassistant/components/modbus/cover.py

@@ -106,9 +106,7 @@ async def async_added_to_hass(self):
         if state:
             self._value = state.state
 
-        async_track_time_interval(
-            self.hass, lambda arg: self.update(), self._scan_interval
-        )
+        async_track_time_interval(self.hass, self.async_update, self._scan_interval)
 
     @property
     def device_class(self) -> str | None:
@@ -154,41 +152,43 @@ def should_poll(self):
         # Handle polling directly in this entity
         return False
 
-    def open_cover(self, **kwargs: Any) -> None:
+    async def async_open_cover(self, **kwargs: Any) -> None:
         """Open cover."""
         if self._coil is not None:
-            self._write_coil(True)
+            await self._async_write_coil(True)
         else:
-            self._write_register(self._state_open)
+            await self._async_write_register(self._state_open)
 
-        self.update()
+        self.async_update()
 
-    def close_cover(self, **kwargs: Any) -> None:
+    async def async_close_cover(self, **kwargs: Any) -> None:
         """Close cover."""
         if self._coil is not None:
-            self._write_coil(False)
+            await self._async_write_coil(False)
         else:
-            self._write_register(self._state_closed)
+            await self._async_write_register(self._state_closed)
 
-        self.update()
+        self.async_update()
 
-    def update(self):
+    async def async_update(self, now=None):
         """Update the state of the cover."""
+        # remark "now" is a dummy parameter to avoid problems with
+        # async_track_time_interval
         if self._coil is not None and self._status_register is None:
-            self._value = self._read_coil()
+            self._value = await self._async_read_coil()
         else:
-            self._value = self._read_status_register()
+            self._value = await self._async_read_status_register()
 
-        self.schedule_update_ha_state()
+        self.async_write_ha_state()
 
-    def _read_status_register(self) -> int | None:
+    async def _async_read_status_register(self) -> int | None:
         """Read status register using the Modbus hub slave."""
         if self._status_register_type == CALL_TYPE_REGISTER_INPUT:
-            result = self._hub.read_input_registers(
+            result = await self._hub.async_read_input_registers(
                 self._slave, self._status_register, 1
             )
         else:
-            result = self._hub.read_holding_registers(
+            result = await self._hub.async_read_holding_registers(
                 self._slave, self._status_register, 1
             )
         if result is None:
@@ -200,20 +200,24 @@ def _read_status_register(self) -> int | None:
 
         return value
 
-    def _write_register(self, value):
+    async def _async_write_register(self, value):
         """Write holding register using the Modbus hub slave."""
-        self._available = self._hub.write_register(self._slave, self._register, value)
+        self._available = await self._hub.async_write_register(
+            self._slave, self._register, value
+        )
 
-    def _read_coil(self) -> bool | None:
+    async def _async_read_coil(self) -> bool | None:
         """Read coil using the Modbus hub slave."""
-        result = self._hub.read_coils(self._slave, self._coil, 1)
+        result = await self._hub.async_read_coils(self._slave, self._coil, 1)
         if result is None:
             self._available = False
             return None
 
         value = bool(result.bits[0] & 1)
         return value
 
-    def _write_coil(self, value):
+    async def _async_write_coil(self, value):
         """Write coil using the Modbus hub slave."""
-        self._available = self._hub.write_coil(self._slave, self._coil, value)
+        self._available = await self._hub.async_write_coil(
+            self._slave, self._coil, value
+        )