Add pymodbus exception handling and isolate pymodbus to class modbusHub

homeassistant/components/modbus/binary_sensor.py

@@ -4,8 +4,6 @@
 from datetime import timedelta
 import logging
 
-from pymodbus.exceptions import ConnectionException, ModbusException
-from pymodbus.pdu import ExceptionResponse
 import voluptuous as vol
 
 from homeassistant.components.binary_sensor import (
@@ -165,16 +163,11 @@ def available(self) -> bool:
 
     def _update(self):
         """Update the state of the sensor."""
-        try:
-            if self._input_type == CALL_TYPE_COIL:
-                result = self._hub.read_coils(self._slave, self._address, 1)
-            else:
-                result = self._hub.read_discrete_inputs(self._slave, self._address, 1)
-        except ConnectionException:
-            self._available = False
-            return
-
-        if isinstance(result, (ModbusException, ExceptionResponse)):
+        if self._input_type == CALL_TYPE_COIL:
+            result = self._hub.read_coils(self._slave, self._address, 1)
+        else:
+            result = self._hub.read_discrete_inputs(self._slave, self._address, 1)
+        if result is None:
             self._available = False
             return
 

homeassistant/components/modbus/climate.py

@@ -6,9 +6,6 @@
 import struct
 from typing import Any
 
-from pymodbus.exceptions import ConnectionException, ModbusException
-from pymodbus.pdu import ExceptionResponse
-
 from homeassistant.components.climate import ClimateEntity
 from homeassistant.components.climate.const import (
     HVAC_MODE_AUTO,
@@ -212,7 +209,11 @@ def set_temperature(self, **kwargs):
         )
         byte_string = struct.pack(self._structure, target_temperature)
         register_value = struct.unpack(">h", byte_string[0:2])[0]
-        self._write_register(self._target_temperature_register, register_value)
+        self._available = self._hub.write_registers(
+            self._slave,
+            self._target_temperature_register,
+            register_value,
+        )
         self._update()
 
     @property
@@ -233,20 +234,13 @@ def _update(self):
 
     def _read_register(self, register_type, register) -> float | None:
         """Read register using the Modbus hub slave."""
-        try:
-            if register_type == CALL_TYPE_REGISTER_INPUT:
-                result = self._hub.read_input_registers(
-                    self._slave, register, self._count
-                )
-            else:
-                result = self._hub.read_holding_registers(
-                    self._slave, register, self._count
-                )
-        except ConnectionException:
-            self._available = False
-            return
-
-        if isinstance(result, (ModbusException, ExceptionResponse)):
+        if register_type == CALL_TYPE_REGISTER_INPUT:
+            result = self._hub.read_input_registers(self._slave, register, self._count)
+        else:
+            result = self._hub.read_holding_registers(
+                self._slave, register, self._count
+            )
+        if result is None:
             self._available = False
             return
 
@@ -269,13 +263,3 @@ def _read_register(self, register_type, register) -> float | None:
         self._available = True
 
         return register_value
-
-    def _write_register(self, register, value):
-        """Write holding register using the Modbus hub slave."""
-        try:
-            self._hub.write_registers(self._slave, register, value)
-        except ConnectionException:
-            self._available = False
-            return
-
-        self._available = True

homeassistant/components/modbus/cover.py

@@ -4,9 +4,6 @@
 from datetime import timedelta
 from typing import Any
 
-from pymodbus.exceptions import ConnectionException, ModbusException
-from pymodbus.pdu import ExceptionResponse
-
 from homeassistant.components.cover import SUPPORT_CLOSE, SUPPORT_OPEN, CoverEntity
 from homeassistant.const import (
     CONF_COVERS,
@@ -179,22 +176,17 @@ def _update(self):
 
     def _read_status_register(self) -> int | None:
         """Read status register using the Modbus hub slave."""
-        try:
-            if self._status_register_type == CALL_TYPE_REGISTER_INPUT:
-                result = self._hub.read_input_registers(
-                    self._slave, self._status_register, 1
-                )
-            else:
-                result = self._hub.read_holding_registers(
-                    self._slave, self._status_register, 1
-                )
-        except ConnectionException:
-            self._available = False
-            return
-
-        if isinstance(result, (ModbusException, ExceptionResponse)):
+        if self._status_register_type == CALL_TYPE_REGISTER_INPUT:
+            result = self._hub.read_input_registers(
+                self._slave, self._status_register, 1
+            )
+        else:
+            result = self._hub.read_holding_registers(
+                self._slave, self._status_register, 1
+            )
+        if result is None:
             self._available = False
-            return
+            return None
 
         value = int(result.registers[0])
         self._available = True
@@ -203,37 +195,18 @@ def _read_status_register(self) -> int | None:
 
     def _write_register(self, value):
         """Write holding register using the Modbus hub slave."""
-        try:
-            self._hub.write_register(self._slave, self._register, value)
-        except ConnectionException:
-            self._available = False
-            return
-
-        self._available = True
+        self._available = self._hub.write_register(self._slave, self._register, value)
 
     def _read_coil(self) -> bool | None:
         """Read coil using the Modbus hub slave."""
-        try:
-            result = self._hub.read_coils(self._slave, self._coil, 1)
-        except ConnectionException:
+        result = self._hub.read_coils(self._slave, self._coil, 1)
+        if result is None:
             self._available = False
-            return
-
-        if isinstance(result, (ModbusException, ExceptionResponse)):
-            self._available = False
-            return
+            return None
 
         value = bool(result.bits[0] & 1)
-        self._available = True
-
         return value
 
     def _write_coil(self, value):
         """Write coil using the Modbus hub slave."""
-        try:
-            self._hub.write_coil(self._slave, self._coil, value)
-        except ConnectionException:
-            self._available = False
-            return
-
-        self._available = True
+        self._available = self._hub.write_coil(self._slave, self._coil, value)