goodwe 0.4.0__tar.gz → 0.4.2__tar.gz

{goodwe-0.4.0/goodwe.egg-info → goodwe-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goodwe
-Version: 0.4.0
+Version: 0.4.2
 Summary: Read data from GoodWe inverter via local network
 Home-page: https://github.com/marcelblijleven/goodwe
 Author: Martin Letenay, Marcel Blijleven

goodwe-0.4.2/VERSION

@@ -0,0 +1 @@
+0.4.2

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/dt.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import logging
 from typing import Tuple
 
-from .exceptions import InverterError
+from .exceptions import InverterError, RequestRejectedException
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
+from .modbus import ILLEGAL_DATA_ADDRESS
 from .model import is_3_mppt, is_single_phase
 from .protocol import ProtocolCommand
 from .sensor import *
 
+logger = logging.getLogger(__name__)
+
 
 class DT(Inverter):
     """Class representing inverter of DT/MS/D-NS/XS or GE's GEP(PSB/PSC) families"""
@@ -123,10 +127,7 @@ class DT(Inverter):
     )
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, comm_addr, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0x7f
+        super().__init__(host, port, comm_addr if comm_addr else 0x7f, timeout, retries)
         self._READ_DEVICE_VERSION_INFO: ProtocolCommand = self._read_command(0x7531, 0x0028)
         self._READ_DEVICE_RUNNING_DATA: ProtocolCommand = self._read_command(0x7594, 0x0049)
         self._sensors = self.__all_sensors
@@ -177,17 +178,43 @@ class DT(Inverter):
 
     async def read_setting(self, setting_id: str) -> Any:
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(self._read_command(setting.offset, count))
-        return setting.read_value(response)
+        if setting:
+            return await self._read_setting(setting)
+        else:
+            if setting_id.startswith("modbus"):
+                response = await self._read_from_socket(self._read_command(int(setting_id[7:]), 1))
+                return int.from_bytes(response.read(2), byteorder="big", signed=True)
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
+
+    async def _read_setting(self, setting: Sensor) -> Any:
+        try:
+            count = (setting.size_ + (setting.size_ % 2)) // 2
+            response = await self._read_from_socket(self._read_command(setting.offset, count))
+            return setting.read_value(response)
+        except RequestRejectedException as ex:
+            if ex.message == ILLEGAL_DATA_ADDRESS:
+                logger.debug("Unsupported setting %s", setting.id_)
+                self._settings.pop(setting.id_, None)
+            return None
 
     async def write_setting(self, setting_id: str, value: Any):
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        raw_value = setting.encode_value(value)
+        if setting:
+            await self._write_setting(setting, value)
+        else:
+            if setting_id.startswith("modbus"):
+                await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
+
+    async def _write_setting(self, setting: Sensor, value: Any):
+        if setting.size_ == 1:
+            # modbus can address/store only 16 bit values, read the other 8 bytes
+            response = await self._read_from_socket(self._read_command(setting.offset, 1))
+            raw_value = setting.encode_value(value, response.response_data()[0:2])
+        else:
+            raw_value = setting.encode_value(value)
         if len(raw_value) <= 2:
             value = int.from_bytes(raw_value, byteorder="big", signed=True)
             await self._read_from_socket(self._write_command(setting.offset, value))

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/es.py

@@ -168,10 +168,7 @@ class ES(Inverter):
     )
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, comm_addr, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0xf7
+        super().__init__(host, port, comm_addr if comm_addr else 0xf7, timeout, retries)
         self._settings: dict[str, Sensor] = {s.id_: s for s in self.__all_settings}
 
     def _supports_eco_mode_v2(self) -> bool:
@@ -220,6 +217,9 @@ class ES(Inverter):
             if not setting:
                 raise ValueError(f'Unknown setting "{setting_id}"')
             return await self._read_setting(setting)
+        elif setting_id.startswith("modbus"):
+            response = await self._read_from_socket(self._read_command(int(setting_id[7:]), 1))
+            return int.from_bytes(response.read(2), byteorder="big", signed=True)
         else:
             all_settings = await self.read_settings_data()
             return all_settings.get(setting_id)
@@ -238,6 +238,8 @@ class ES(Inverter):
             await self._read_from_socket(
                 Aa55ProtocolCommand("030206" + Timestamp("time", 0, "").encode_value(value).hex(), "0382")
             )
+        elif setting_id.startswith("modbus"):
+            await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
         else:
             setting: Sensor | None = self._settings.get(setting_id)
             if not setting:
@@ -249,10 +251,9 @@ class ES(Inverter):
             # modbus can address/store only 16 bit values, read the other 8 bytes
             if self._is_modbus_setting(setting):
                 response = await self._read_from_socket(self._read_command(setting.offset, 1))
-                raw_value = setting.encode_value(value, response.response_data()[0:2])
             else:
                 response = await self._read_from_socket(Aa55ReadCommand(setting.offset, 1))
-                raw_value = setting.encode_value(value, response.response_data()[2:4])
+            raw_value = setting.encode_value(value, response.response_data()[0:2])
         else:
             raw_value = setting.encode_value(value)
         if len(raw_value) <= 2:

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/et.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import logging
 from typing import Tuple
 
-from .exceptions import RequestRejectedException
+from .exceptions import RequestFailedException, RequestRejectedException
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
+from .modbus import ILLEGAL_DATA_ADDRESS
 from .model import is_2_battery, is_4_mppt, is_745_platform, is_single_phase
 from .protocol import ProtocolCommand
 from .sensor import *
@@ -331,7 +332,7 @@ class ET(Inverter):
     # Modbus registers of inverter settings, offsets are modbus register addresses
     __all_settings: Tuple[Sensor, ...] = (
         Integer("comm_address", 45127, "Communication Address", ""),
-
+        Integer("modbus_baud_rate", 45132, "Modbus Baud rate", ""),
         Timestamp("time", 45200, "Inverter time"),
 
         Integer("sensitivity_check", 45246, "Sensitivity Check Mode", "", Kind.AC),
@@ -371,6 +372,51 @@ class ET(Inverter):
         ByteH("eco_mode_3_switch", 47526, "Eco Mode Group 3 Switch"),
         EcoModeV1("eco_mode_4", 47527, "Eco Mode Group 4"),
         ByteH("eco_mode_4_switch", 47530, "Eco Mode Group 4 Switch"),
+
+        # Direct BMS communication for EMS Control
+        Integer("bms_version", 47900, "BMS Version"),
+        Integer("bms_bat_modules", 47901, "BMS Battery Modules"),
+        # Real time read from BMS
+        Voltage("bms_bat_charge_v_max", 47902, "BMS Battery Charge Voltage (max)", Kind.BMS),
+        Current("bms_bat_charge_i_max", 47903, "BMS Battery Charge Current (max)", Kind.BMS),
+        Voltage("bms_bat_discharge_v_min", 47904, "BMS min. Battery Discharge Voltage (min)", Kind.BMS),
+        Current("bms_bat_discharge_i_max", 47905, "BMS max. Battery Discharge Current (max)", Kind.BMS),
+        Voltage("bms_bat_voltage", 47906, "BMS Battery Voltage", Kind.BMS),
+        Current("bms_bat_current", 47907, "BMS Battery Current", Kind.BMS),
+        #
+        Integer("bms_bat_soc", 47908, "BMS Battery State of Charge", "%", Kind.BMS),
+        Integer("bms_bat_soh", 47909, "BMS Battery State of Health", "%", Kind.BMS),
+        Temp("bms_bat_temperature", 47910, "BMS Battery Temperature", Kind.BMS),
+        Long("bms_bat_warning-code", 47911, "BMS Battery Warning Code"),
+        # Reserved
+        Long("bms_bat_alarm-code", 47913, "BMS Battery Alarm Code"),
+        Integer("bms_status", 47915, "BMS Status"),
+        Integer("bms_comm_loss_disable", 47916, "BMS Communication Loss Disable"),
+        # RW settings of BMS voltage rate
+        Integer("bms_battery_string_rate_v", 47917, "BMS Battery String Rate Voltage"),
+
+        # Direct BMS communication for EMS Control
+        Integer("bms2_version", 47918, "BMS2 Version"),
+        Integer("bms2_bat_modules", 47919, "BMS2 Battery Modules"),
+        # Real time read from BMS
+        Voltage("bms2_bat_charge_v_max", 47920, "BMS2 Battery Charge Voltage (max)", Kind.BMS),
+        Current("bms2_bat_charge_i_max", 47921, "BMS2 Battery Charge Current (max)", Kind.BMS),
+        Voltage("bms2_bat_discharge_v_min", 47922, "BMS2 min. Battery Discharge Voltage (min)", Kind.BMS),
+        Current("bms2_bat_discharge_i_max", 47923, "BMS2 max. Battery Discharge Current (max)", Kind.BMS),
+        Voltage("bms2_bat_voltage", 47924, "BMS2 Battery Voltage", Kind.BMS),
+        Current("bms2_bat_current", 47925, "BMS2 Battery Current", Kind.BMS),
+        #
+        Integer("bms2_bat_soc", 47926, "BMS2 Battery State of Charge", "%", Kind.BMS),
+        Integer("bms2_bat_soh", 47927, "BMS2 Battery State of Health", "%", Kind.BMS),
+        Temp("bms2_bat_temperature", 47928, "BMS2 Battery Temperature", Kind.BMS),
+        Long("bms2_bat_warning-code", 47929, "BMS2 Battery Warning Code"),
+        # Reserved
+        Long("bms2_bat_alarm-code", 47931, "BMS2 Battery Alarm Code"),
+        Integer("bms2_status", 47933, "BMS2 Status"),
+        Integer("bms2_comm_loss_disable", 47934, "BMS2 Communication Loss Disable"),
+        # RW settings of BMS voltage rate
+        Integer("bms2_battery_string_rate_v", 47935, "BMS2 Battery String Rate Voltage"),
+
     )
 
     # Settings added in ARM firmware 19
@@ -389,6 +435,7 @@ class ET(Inverter):
         Integer("load_control_mode", 47595, "Load Control Mode", "", Kind.AC),
         Integer("load_control_switch", 47596, "Load Control Switch", "", Kind.AC),
         Integer("load_control_soc", 47597, "Load Control SoC", "", Kind.AC),
+        Integer("hardware_feed_power", 47599, "Hardware Feed Power"),
 
         Integer("fast_charging_power", 47603, "Fast Charging Power", "%", Kind.BAT),
     )
@@ -410,10 +457,7 @@ class ET(Inverter):
     )
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, comm_addr, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0xf7
+        super().__init__(host, port, comm_addr if comm_addr else 0xf7, timeout, retries)
         self._READ_DEVICE_VERSION_INFO: ProtocolCommand = self._read_command(0x88b8, 0x0021)
         self._READ_RUNNING_DATA: ProtocolCommand = self._read_command(0x891c, 0x007d)
         self._READ_METER_DATA: ProtocolCommand = self._read_command(0x8ca0, 0x2d)
@@ -447,19 +491,19 @@ class ET(Inverter):
     async def read_device_info(self):
         response = await self._read_from_socket(self._READ_DEVICE_VERSION_INFO)
         response = response.response_data()
-        # Modbus registers from offset (35000)
+        # Modbus registers from 35000 - 35032
         self.modbus_version = read_unsigned_int(response, 0)
         self.rated_power = read_unsigned_int(response, 2)
         self.ac_output_type = read_unsigned_int(response, 4)  # 0: 1-phase, 1: 3-phase (4 wire), 2: 3-phase (3 wire)
-        self.serial_number = self._decode(response[6:22])
-        self.model_name = self._decode(response[22:32])
-        self.dsp1_version = read_unsigned_int(response, 32)
-        self.dsp2_version = read_unsigned_int(response, 34)
-        self.dsp_svn_version = read_unsigned_int(response, 36)
-        self.arm_version = read_unsigned_int(response, 38)
-        self.arm_svn_version = read_unsigned_int(response, 40)
-        self.firmware = self._decode(response[42:54])
-        self.arm_firmware = self._decode(response[54:66])
+        self.serial_number = self._decode(response[6:22])  # 35003 - 350010
+        self.model_name = self._decode(response[22:32])  # 35011 - 35015
+        self.dsp1_version = read_unsigned_int(response, 32)  # 35016
+        self.dsp2_version = read_unsigned_int(response, 34)  # 35017
+        self.dsp_svn_version = read_unsigned_int(response, 36)  # 35018
+        self.arm_version = read_unsigned_int(response, 38)  # 35019
+        self.arm_svn_version = read_unsigned_int(response, 40)  # 35020
+        self.firmware = self._decode(response[42:54])  # 35021 - 35027
+        self.arm_firmware = self._decode(response[54:66])  # 35027 - 35032
 
         if not is_4_mppt(self) and self.rated_power < 15000:
             # This inverter does not have 4 MPPTs or PV strings
@@ -485,18 +529,24 @@ class ET(Inverter):
             await self._read_from_socket(self._read_command(47547, 6))
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_19})
         except RequestRejectedException as ex:
-            if ex.message == 'ILLEGAL DATA ADDRESS':
-                logger.debug("Cannot read EcoModeV2 settings, using to EcoModeV1.")
+            if ex.message == ILLEGAL_DATA_ADDRESS:
+                logger.debug("EcoModeV2 settings not supported, switching to EcoModeV1.")
                 self._has_eco_mode_v2 = False
+        except RequestFailedException:
+            logger.debug("Cannot read EcoModeV2 settings, switching to EcoModeV1.")
+            self._has_eco_mode_v2 = False
 
         # Check and add Peak Shaving settings added in (ETU fw 22)
         try:
             await self._read_from_socket(self._read_command(47589, 6))
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_22})
         except RequestRejectedException as ex:
-            if ex.message == 'ILLEGAL DATA ADDRESS':
-                logger.debug("Cannot read PeakShaving setting, disabling it.")
+            if ex.message == ILLEGAL_DATA_ADDRESS:
+                logger.debug("PeakShaving setting not supported, disabling it.")
                 self._has_peak_shaving = False
+        except RequestFailedException:
+            logger.debug("Cannot read _has_peak_shaving settings, disabling it.")
+            self._has_peak_shaving = False
 
     async def read_runtime_data(self) -> Dict[str, Any]:
         response = await self._read_from_socket(self._READ_RUNNING_DATA)
@@ -508,8 +558,8 @@ class ET(Inverter):
                 response = await self._read_from_socket(self._READ_BATTERY_INFO)
                 data.update(self._map_response(response, self._sensors_battery))
             except RequestRejectedException as ex:
-                if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Cannot read battery values, disabling further attempts.")
+                if ex.message == ILLEGAL_DATA_ADDRESS:
+                    logger.info("Battery values not supported, disabling further attempts.")
                     self._has_battery = False
                 else:
                     raise ex
@@ -519,8 +569,8 @@ class ET(Inverter):
                 data.update(
                     self._map_response(response, self._sensors_battery2))
             except RequestRejectedException as ex:
-                if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Cannot read battery 2 values, disabling further attempts.")
+                if ex.message == ILLEGAL_DATA_ADDRESS:
+                    logger.info("Battery 2 values not supported, disabling further attempts.")
                     self._has_battery2 = False
                 else:
                     raise ex
@@ -530,8 +580,8 @@ class ET(Inverter):
                 response = await self._read_from_socket(self._READ_METER_DATA_EXTENDED)
                 data.update(self._map_response(response, self._sensors_meter))
             except RequestRejectedException as ex:
-                if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Cannot read extended meter values, disabling further attempts.")
+                if ex.message == ILLEGAL_DATA_ADDRESS:
+                    logger.info("Extended meter values not supported, disabling further attempts.")
                     self._has_meter_extended = False
                     self._sensors_meter = tuple(filter(self._not_extended_meter, self._sensors_meter))
                     response = await self._read_from_socket(self._READ_METER_DATA)
@@ -548,8 +598,8 @@ class ET(Inverter):
                 response = await self._read_from_socket(self._READ_MPPT_DATA)
                 data.update(self._map_response(response, self._sensors_mppt))
             except RequestRejectedException as ex:
-                if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Cannot read MPPT values, disabling further attempts.")
+                if ex.message == ILLEGAL_DATA_ADDRESS:
+                    logger.info("MPPT values not supported, disabling further attempts.")
                     self._has_mppt = False
                 else:
                     raise ex
@@ -558,20 +608,35 @@ class ET(Inverter):
 
     async def read_setting(self, setting_id: str) -> Any:
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        return await self._read_setting(setting)
+        if setting:
+            return await self._read_setting(setting)
+        else:
+            if setting_id.startswith("modbus"):
+                response = await self._read_from_socket(self._read_command(int(setting_id[7:]), 1))
+                return int.from_bytes(response.read(2), byteorder="big", signed=True)
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
 
     async def _read_setting(self, setting: Sensor) -> Any:
-        count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(self._read_command(setting.offset, count))
-        return setting.read_value(response)
+        try:
+            count = (setting.size_ + (setting.size_ % 2)) // 2
+            response = await self._read_from_socket(self._read_command(setting.offset, count))
+            return setting.read_value(response)
+        except RequestRejectedException as ex:
+            if ex.message == ILLEGAL_DATA_ADDRESS:
+                logger.debug("Unsupported setting %s", setting.id_)
+                self._settings.pop(setting.id_, None)
+            return None
 
     async def write_setting(self, setting_id: str, value: Any):
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        await self._write_setting(setting, value)
+        if setting:
+            await self._write_setting(setting, value)
+        else:
+            if setting_id.startswith("modbus"):
+                await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
 
     async def _write_setting(self, setting: Sensor, value: Any):
         if setting.size_ == 1:
@@ -592,7 +657,7 @@ class ET(Inverter):
             try:
                 value = await self.read_setting(setting.id_)
                 data[setting.id_] = value
-            except ValueError:
+            except (ValueError, RequestFailedException):
                 logger.exception("Error reading setting %s.", setting.id_)
                 data[setting.id_] = None
         return data

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/exceptions.py

@@ -29,5 +29,19 @@ class RequestRejectedException(InverterError):
         self.message: str = message
 
 
+class PartialResponseException(InverterError):
+    """
+    Indicates the received response data are incomplete and is probably fragmented to multiple packets.
+
+    Attributes:
+        length -- received data length
+        expected -- expected data lenght
+    """
+
+    def __init__(self, lenght: int, expected: int):
+        self.length: int = lenght
+        self.expected: int = expected
+
+
 class MaxRetriesException(InverterError):
     """Indicates the maximum number of retries has been reached"""

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/inverter.py

@@ -22,6 +22,7 @@ class SensorKind(Enum):
     UPS - inverter ups/eps/backup output (e.g. ac voltage of backup/off-grid connected output)
     BAT - battery (e.g. dc voltage of connected battery pack)
     GRID - power grid/smart meter (e.g. active power exported to grid)
+    BMS - BMS direct data (e.g. dc voltage of)
     """
 
     PV = 1
@@ -29,6 +30,7 @@ class SensorKind(Enum):
     UPS = 3
     BAT = 4
     GRID = 5
+    BMS = 6
 
 
 @dataclass
@@ -87,10 +89,9 @@ class Inverter(ABC):
     """
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        self._protocol: InverterProtocol = self._create_protocol(host, port, timeout, retries)
+        self._protocol: InverterProtocol = self._create_protocol(host, port, comm_addr, timeout, retries)
         self._consecutive_failures_count: int = 0
-
-        self.comm_addr: int = comm_addr
+        self.keep_alive: bool = True
 
         self.model_name: str | None = None
         self.serial_number: str | None = None
@@ -107,15 +108,15 @@ class Inverter(ABC):
 
     def _read_command(self, offset: int, count: int) -> ProtocolCommand:
         """Create read protocol command."""
-        return self._protocol.read_command(self.comm_addr, offset, count)
+        return self._protocol.read_command(offset, count)
 
     def _write_command(self, register: int, value: int) -> ProtocolCommand:
         """Create write protocol command."""
-        return self._protocol.write_command(self.comm_addr, register, value)
+        return self._protocol.write_command(register, value)
 
     def _write_multi_command(self, offset: int, values: bytes) -> ProtocolCommand:
         """Create write multiple protocol command."""
-        return self._protocol.write_multi_command(self.comm_addr, offset, values)
+        return self._protocol.write_multi_command(offset, values)
 
     async def _read_from_socket(self, command: ProtocolCommand) -> ProtocolResponse:
         try:
@@ -129,6 +130,9 @@ class Inverter(ABC):
         except RequestFailedException as ex:
             self._consecutive_failures_count += 1
             raise RequestFailedException(ex.message, self._consecutive_failures_count) from None
+        finally:
+            if not self.keep_alive:
+                self._protocol.close_transport()
 
     @abstractmethod
     async def read_device_info(self):
@@ -268,11 +272,11 @@ class Inverter(ABC):
         raise NotImplementedError()
 
     @staticmethod
-    def _create_protocol(host: str, port: int, timeout: int, retries: int) -> InverterProtocol:
+    def _create_protocol(host: str, port: int, comm_addr: int, timeout: int, retries: int) -> InverterProtocol:
         if port == 502:
-            return TcpInverterProtocol(host, port, timeout, retries)
+            return TcpInverterProtocol(host, port, comm_addr, timeout, retries)
         else:
-            return UdpInverterProtocol(host, port, timeout, retries)
+            return UdpInverterProtocol(host, port, comm_addr, timeout, retries)
 
     @staticmethod
     def _map_response(response: ProtocolResponse, sensors: Tuple[Sensor, ...]) -> Dict[str, Any]:

{goodwe-0.4.0 → goodwe-0.4.2}/goodwe/modbus.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Union
 
-from .exceptions import RequestRejectedException
+from .exceptions import PartialResponseException, RequestRejectedException
 
 logger = logging.getLogger(__name__)
 
@@ -9,9 +9,11 @@ MODBUS_READ_CMD: int = 0x3
 MODBUS_WRITE_CMD: int = 0x6
 MODBUS_WRITE_MULTI_CMD: int = 0x10
 
+ILLEGAL_DATA_ADDRESS: str = 'ILLEGAL DATA ADDRESS'
+
 FAILURE_CODES = {
     1: "ILLEGAL FUNCTION",
-    2: "ILLEGAL DATA ADDRESS",
+    2: ILLEGAL_DATA_ADDRESS,
     3: "ILLEGAL DATA VALUE",
     4: "SLAVE DEVICE FAILURE",
     5: "ACKNOWLEDGE",
@@ -176,8 +178,7 @@ def validate_modbus_rtu_response(data: bytes, cmd: int, offset: int, value: int)
             return False
         expected_length = data[4] + 7
         if len(data) < expected_length:
-            logger.debug("Response is too short: %d, expected %d.", len(data), expected_length)
-            return False
+            raise PartialResponseException(len(data), expected_length)
     elif data[3] in (MODBUS_WRITE_CMD, MODBUS_WRITE_MULTI_CMD):
         if len(data) < 10:
             logger.debug("Response has unexpected length: %d, expected %d.", len(data), 10)
@@ -220,18 +221,18 @@ def validate_modbus_tcp_response(data: bytes, cmd: int, offset: int, value: int)
     if len(data) <= 8:
         logger.debug("Response is too short.")
         return False
+    expected_length = int.from_bytes(data[4:6], byteorder='big', signed=False) + 6
+    if len(data) < expected_length:
+        raise PartialResponseException(len(data), expected_length)
+
     if data[7] == MODBUS_READ_CMD:
         if data[8] != value * 2:
             logger.debug("Response has unexpected length: %d, expected %d.", data[8], value * 2)
             return False
-        expected_length = data[8] + 9
-        if len(data) < expected_length:
-            logger.debug("Response is too short: %d, expected %d.", len(data), expected_length)
-            return False
     elif data[7] in (MODBUS_WRITE_CMD, MODBUS_WRITE_MULTI_CMD):
         if len(data) < 12:
             logger.debug("Response has unexpected length: %d, expected %d.", len(data), 14)
-            return False
+            raise PartialResponseException(len(data), expected_length)
         response_offset = int.from_bytes(data[8:10], byteorder='big', signed=False)
         if response_offset != offset:
             logger.debug("Response has wrong offset: %X, expected %X.", response_offset, offset)