goodwe 0.3.0__tar.gz → 0.3.2__tar.gz

{goodwe-0.3.0/goodwe.egg-info → goodwe-0.3.2}/PKG-INFO

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

goodwe-0.3.2/VERSION

@@ -0,0 +1 @@
+0.3.2

{goodwe-0.3.0 → goodwe-0.3.2}/goodwe/es.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Tuple, cast
+from typing import Tuple
 
 from .exceptions import InverterError
 from .inverter import Inverter
@@ -67,7 +67,7 @@ class ES(Inverter):
         Voltage("vgrid", 34, "On-grid Voltage", Kind.AC),
         Current("igrid", 36, "On-grid Current", Kind.AC),
         Calculated("pgrid",
-                   lambda data: abs(read_bytes2(data, 38)) * (-1 if read_byte(data, 80) == 2 else 1),
+                   lambda data: abs(read_bytes2_signed(data, 38)) * (-1 if read_byte(data, 80) == 2 else 1),
                    "On-grid Export Power", "W", Kind.AC),
         Frequency("fgrid", 40, "On-grid Frequency", Kind.AC),
         Byte("grid_mode", 42, "Work Mode code", "", Kind.GRID),
@@ -87,7 +87,7 @@ class ES(Inverter):
         Energy("e_day", 67, "Today's PV Generation", Kind.PV),
         Energy("e_load_day", 69, "Today's Load", Kind.AC),
         Energy4("e_load_total", 71, "Total Load", Kind.AC),
-        Power("total_power", 75, "Total Power", Kind.AC),  # modbus 0x52c
+        PowerS("total_power", 75, "Total Power", Kind.AC),  # modbus 0x52c
         Byte("effective_work_mode", 77, "Effective Work Mode code"),
         Integer("effective_relay_control", 78, "Effective Relay Control", "", None),
         Byte("grid_in_out", 80, "On-grid Mode code", "", Kind.GRID),
@@ -121,7 +121,7 @@ class ES(Inverter):
                    round(read_voltage(data, 5) * read_current(data, 7)) +
                    (abs(round(read_voltage(data, 10) * read_current(data, 18))) *
                     (-1 if read_byte(data, 30) == 3 else 1)) -
-                   (abs(read_bytes2(data, 38)) * (-1 if read_byte(data, 80) == 2 else 1)),
+                   (abs(read_bytes2_signed(data, 38)) * (-1 if read_byte(data, 80) == 2 else 1)),
                    "House Consumption", "W", Kind.AC),
     )
 
@@ -220,17 +220,20 @@ class ES(Inverter):
             setting: Sensor | None = self._settings.get(setting_id)
             if not setting:
                 raise ValueError(f'Unknown setting "{setting_id}"')
-            count = (setting.size_ + (setting.size_ % 2)) // 2
-            if self._is_modbus_setting(setting):
-                response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
-                return setting.read_value(response)
-            else:
-                response = await self._read_from_socket(Aa55ReadCommand(setting.offset, count))
-                return setting.read_value(response)
+            return await self._read_setting(setting)
         else:
             all_settings = await self.read_settings_data()
             return all_settings.get(setting_id)
 
+    async def _read_setting(self, setting: Sensor) -> Any:
+        count = (setting.size_ + (setting.size_ % 2)) // 2
+        if self._is_modbus_setting(setting):
+            response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+            return setting.read_value(response)
+        else:
+            response = await self._read_from_socket(Aa55ReadCommand(setting.offset, count))
+            return setting.read_value(response)
+
     async def write_setting(self, setting_id: str, value: Any):
         if setting_id == 'time':
             await self._read_from_socket(
@@ -240,27 +243,30 @@ class ES(Inverter):
             setting: Sensor | None = self._settings.get(setting_id)
             if not setting:
                 raise ValueError(f'Unknown setting "{setting_id}"')
-            if setting.size_ == 1:
-                # 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(ModbusReadCommand(self.comm_addr, 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])
+            await self._write_setting(setting, value)
+
+    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
+            if self._is_modbus_setting(setting):
+                response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, 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)
-                if self._is_modbus_setting(setting):
-                    await self._read_from_socket(ModbusWriteCommand(self.comm_addr, setting.offset, value))
-                else:
-                    await self._read_from_socket(Aa55WriteCommand(setting.offset, value))
+                response = await self._read_from_socket(Aa55ReadCommand(setting.offset, 1))
+                raw_value = setting.encode_value(value, response.response_data()[2:4])
+        else:
+            raw_value = setting.encode_value(value)
+        if len(raw_value) <= 2:
+            value = int.from_bytes(raw_value, byteorder="big", signed=True)
+            if self._is_modbus_setting(setting):
+                await self._read_from_socket(ModbusWriteCommand(self.comm_addr, setting.offset, value))
+            else:
+                await self._read_from_socket(Aa55WriteCommand(setting.offset, value))
+        else:
+            if self._is_modbus_setting(setting):
+                await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, setting.offset, raw_value))
             else:
-                if self._is_modbus_setting(setting):
-                    await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, setting.offset, raw_value))
-                else:
-                    await self._read_from_socket(Aa55WriteMultiCommand(setting.offset, raw_value))
+                await self._read_from_socket(Aa55WriteMultiCommand(setting.offset, raw_value))
 
     async def read_settings_data(self) -> Dict[str, Any]:
         response = await self._read_from_socket(self._READ_DEVICE_SETTINGS_DATA)
@@ -313,7 +319,8 @@ class ES(Inverter):
                 raise ValueError()
             if eco_mode_soc < 0 or eco_mode_soc > 100:
                 raise ValueError()
-            eco_mode: EcoMode = self._convert_eco_mode(EcoModeV2("", 0, ""))
+            eco_mode: EcoMode | Sensor = self._settings.get('eco_mode_1')
+            await self._read_setting(eco_mode)
             if operation_mode == OperationMode.ECO_CHARGE:
                 await self.write_setting('eco_mode_1', eco_mode.encode_charge(eco_mode_power, eco_mode_soc))
             else:
@@ -327,7 +334,7 @@ class ES(Inverter):
         return await self.read_setting('dod')
 
     async def set_ongrid_battery_dod(self, dod: int) -> None:
-        if 0 <= dod <= 89:
+        if 0 <= dod <= 100:
             await self._read_from_socket(Aa55WriteCommand(0x560, 100 - dod))
 
     async def _reset_inverter(self) -> None:
@@ -427,13 +434,5 @@ class ES(Inverter):
     async def _set_work_mode(self, mode: int) -> None:
         await self._read_from_socket(Aa55ProtocolCommand("035901" + "{:02x}".format(mode), "03D9"))
 
-    def _convert_eco_mode(self, sensor: Sensor) -> Sensor | EcoMode:
-        if EcoModeV1 == type(sensor) and self._supports_eco_mode_v2():
-            return cast(EcoModeV1, sensor).as_eco_mode_v2()
-        elif EcoModeV2 == type(sensor) and not self._supports_eco_mode_v2():
-            return cast(EcoModeV2, sensor).as_eco_mode_v1()
-        else:
-            return sensor
-
     def _is_modbus_setting(self, sensor: Sensor) -> bool:
-        return EcoModeV2 == type(sensor) or sensor.offset > 30000
+        return sensor.offset > 30000

{goodwe-0.3.0 → goodwe-0.3.2}/goodwe/et.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Tuple, cast
+from typing import Tuple
 
 from .exceptions import RequestRejectedException
 from .inverter import Inverter
@@ -52,23 +52,23 @@ class ET(Inverter):
         Current("igrid", 35122, "On-grid L1 Current", Kind.AC),
         Frequency("fgrid", 35123, "On-grid L1 Frequency", Kind.AC),
         # 35124 reserved
-        Power("pgrid", 35125, "On-grid L1 Power", Kind.AC),
+        PowerS("pgrid", 35125, "On-grid L1 Power", Kind.AC),
         Voltage("vgrid2", 35126, "On-grid L2 Voltage", Kind.AC),
         Current("igrid2", 35127, "On-grid L2 Current", Kind.AC),
         Frequency("fgrid2", 35128, "On-grid L2 Frequency", Kind.AC),
         # 35129 reserved
-        Power("pgrid2", 35130, "On-grid L2 Power", Kind.AC),
+        PowerS("pgrid2", 35130, "On-grid L2 Power", Kind.AC),
         Voltage("vgrid3", 35131, "On-grid L3 Voltage", Kind.AC),
         Current("igrid3", 35132, "On-grid L3 Current", Kind.AC),
         Frequency("fgrid3", 35133, "On-grid L3 Frequency", Kind.AC),
         # 35134 reserved
-        Power("pgrid3", 35135, "On-grid L3 Power", Kind.AC),
+        PowerS("pgrid3", 35135, "On-grid L3 Power", Kind.AC),
         Integer("grid_mode", 35136, "Grid Mode code", "", Kind.PV),
         Enum2("grid_mode_label", 35136, GRID_MODES, "Grid Mode", Kind.PV),
         # 35137 reserved
-        Power("total_inverter_power", 35138, "Total Power", Kind.AC),
+        PowerS("total_inverter_power", 35138, "Total Power", Kind.AC),
         # 35139 reserved
-        Power("active_power", 35140, "Active Power", Kind.GRID),
+        PowerS("active_power", 35140, "Active Power", Kind.GRID),
         Calculated("grid_in_out",
                    lambda data: read_grid_mode(data, 35140),
                    "On-grid Mode code", "", Kind.GRID),
@@ -84,29 +84,29 @@ class ET(Inverter):
         Frequency("backup_f1", 35147, "Back-up L1 Frequency", Kind.UPS),
         Integer("load_mode1", 35148, "Load Mode L1"),
         # 35149 reserved
-        Power("backup_p1", 35150, "Back-up L1 Power", Kind.UPS),
+        PowerS("backup_p1", 35150, "Back-up L1 Power", Kind.UPS),
         Voltage("backup_v2", 35151, "Back-up L2 Voltage", Kind.UPS),
         Current("backup_i2", 35152, "Back-up L2 Current", Kind.UPS),
         Frequency("backup_f2", 35153, "Back-up L2 Frequency", Kind.UPS),
         Integer("load_mode2", 35154, "Load Mode L2"),
         # 35155 reserved
-        Power("backup_p2", 35156, "Back-up L2 Power", Kind.UPS),
+        PowerS("backup_p2", 35156, "Back-up L2 Power", Kind.UPS),
         Voltage("backup_v3", 35157, "Back-up L3 Voltage", Kind.UPS),
         Current("backup_i3", 35158, "Back-up L3 Current", Kind.UPS),
         Frequency("backup_f3", 35159, "Back-up L3 Frequency", Kind.UPS),
         Integer("load_mode3", 35160, "Load Mode L3"),
         # 35161 reserved
-        Power("backup_p3", 35162, "Back-up L3 Power", Kind.UPS),
+        PowerS("backup_p3", 35162, "Back-up L3 Power", Kind.UPS),
         # 35163 reserved
-        Power("load_p1", 35164, "Load L1", Kind.AC),
+        PowerS("load_p1", 35164, "Load L1", Kind.AC),
         # 35165 reserved
-        Power("load_p2", 35166, "Load L2", Kind.AC),
+        PowerS("load_p2", 35166, "Load L2", Kind.AC),
         # 35167 reserved
-        Power("load_p3", 35168, "Load L3", Kind.AC),
+        PowerS("load_p3", 35168, "Load L3", Kind.AC),
         # 35169 reserved
-        Power("backup_ptotal", 35170, "Back-up Load", Kind.UPS),
+        PowerS("backup_ptotal", 35170, "Back-up Load", Kind.UPS),
         # 35171 reserved
-        Power("load_ptotal", 35172, "Load", Kind.AC),
+        PowerS("load_ptotal", 35172, "Load", Kind.AC),
         Integer("ups_load", 35173, "Ups Load", "%", Kind.UPS),
         Temp("temperature_air", 35174, "Inverter Temperature (Air)", Kind.AC),
         Temp("temperature_module", 35175, "Inverter Temperature (Module)"),
@@ -115,8 +115,8 @@ class ET(Inverter):
         Voltage("bus_voltage", 35178, "Bus Voltage", None),
         Voltage("nbus_voltage", 35179, "NBus Voltage", None),
         Voltage("vbattery1", 35180, "Battery Voltage", Kind.BAT),
-        Current("ibattery1", 35181, "Battery Current", Kind.BAT),
-        Power4("pbattery1", 35182, "Battery Power", Kind.BAT),
+        CurrentS("ibattery1", 35181, "Battery Current", Kind.BAT),
+        Power4S("pbattery1", 35182, "Battery Power", Kind.BAT),
         Integer("battery_mode", 35184, "Battery Mode code", "", Kind.BAT),
         Enum2("battery_mode_label", 35184, BATTERY_MODES, "Battery Mode", Kind.BAT),
         Integer("warning_code", 35185, "Warning code"),
@@ -149,8 +149,8 @@ class ET(Inverter):
                    read_bytes4(data, 35109) +
                    read_bytes4(data, 35113) +
                    read_bytes4(data, 35117) +
-                   read_bytes4(data, 35182) -
-                   read_bytes2(data, 35140),
+                   read_bytes4_signed(data, 35182) -
+                   read_bytes2_signed(data, 35140),
                    "House Consumption", "W", Kind.AC),
     )
 
@@ -226,10 +226,10 @@ class ET(Inverter):
         Integer("manufacture_code", 36002, "Manufacture Code"),
         Integer("meter_test_status", 36003, "Meter Test Status"),  # 1: correct，2: reverse，3: incorrect，0: not checked
         Integer("meter_comm_status", 36004, "Meter Communication Status"),  # 1 OK, 0 NotOK
-        Power("active_power1", 36005, "Active Power L1", Kind.GRID),
-        Power("active_power2", 36006, "Active Power L2", Kind.GRID),
-        Power("active_power3", 36007, "Active Power L3", Kind.GRID),
-        Power("active_power_total", 36008, "Active Power Total", Kind.GRID),
+        PowerS("active_power1", 36005, "Active Power L1", Kind.GRID),
+        PowerS("active_power2", 36006, "Active Power L2", Kind.GRID),
+        PowerS("active_power3", 36007, "Active Power L3", Kind.GRID),
+        PowerS("active_power_total", 36008, "Active Power Total", Kind.GRID),
         Reactive("reactive_power_total", 36009, "Reactive Power Total", Kind.GRID),
         Decimal("meter_power_factor1", 36010, 1000, "Meter Power Factor L1", "", Kind.GRID),
         Decimal("meter_power_factor2", 36011, 1000, "Meter Power Factor L2", "", Kind.GRID),
@@ -238,10 +238,10 @@ class ET(Inverter):
         Frequency("meter_freq", 36014, "Meter Frequency", Kind.GRID),
         Float("meter_e_total_exp", 36015, 1000, "Meter Total Energy (export)", "kWh", Kind.GRID),
         Float("meter_e_total_imp", 36017, 1000, "Meter Total Energy (import)", "kWh", Kind.GRID),
-        Power4("meter_active_power1", 36019, "Meter Active Power L1", Kind.GRID),
-        Power4("meter_active_power2", 36021, "Meter Active Power L2", Kind.GRID),
-        Power4("meter_active_power3", 36023, "Meter Active Power L3", Kind.GRID),
-        Power4("meter_active_power_total", 36025, "Meter Active Power Total", Kind.GRID),
+        Power4S("meter_active_power1", 36019, "Meter Active Power L1", Kind.GRID),
+        Power4S("meter_active_power2", 36021, "Meter Active Power L2", Kind.GRID),
+        Power4S("meter_active_power3", 36023, "Meter Active Power L3", Kind.GRID),
+        Power4S("meter_active_power_total", 36025, "Meter Active Power Total", Kind.GRID),
         Reactive4("meter_reactive_power1", 36027, "Meter Reactive Power L1", Kind.GRID),
         Reactive4("meter_reactive_power2", 36029, "Meter Reactive Power L2", Kind.GRID),
         Reactive4("meter_reactive_power3", 36031, "Meter Reactive Power L2", Kind.GRID),
@@ -253,7 +253,7 @@ class ET(Inverter):
         Integer("meter_type", 36043, "Meter Type", "", Kind.GRID),  # (0: Single phase, 1: 3P3W, 2: 3P4W, 3: HomeKit)
         Integer("meter_sw_version", 36044, "Meter Software Version", "", Kind.GRID),
         # Sensors added in some ARM fw update, read when flag _has_meter_extended is on
-        Power4("meter2_active_power", 36045, "Meter 2 Active Power", Kind.GRID),
+        Power4S("meter2_active_power", 36045, "Meter 2 Active Power", Kind.GRID),
         Float("meter2_e_total_exp", 36047, 1000, "Meter 2 Total Energy (export)", "kWh", Kind.GRID),
         Float("meter2_e_total_imp", 36049, 1000, "Meter 2 Total Energy (import)", "kWh", Kind.GRID),
         Integer("meter2_comm_status", 36051, "Meter 2 Communication Status"),
@@ -411,6 +411,8 @@ class ET(Inverter):
         self._READ_BATTERY_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x9088, 0x0018)
         self._READ_BATTERY2_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x9858, 0x0016)
         self._READ_MPPT_DATA: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x89e5, 0x3d)
+        self._has_eco_mode_v2: bool = True
+        self._has_peak_shaving: bool = True
         self._has_battery: bool = True
         self._has_battery2: bool = False
         self._has_meter_extended: bool = False
@@ -422,12 +424,6 @@ class ET(Inverter):
         self._sensors_mppt = self.__all_sensors_mppt
         self._settings: dict[str, Sensor] = {s.id_: s for s in self.__all_settings}
 
-    def _supports_eco_mode_v2(self) -> bool:
-        return self.arm_version >= 19 or 'ETU' not in self.serial_number
-
-    def _supports_peak_shaving(self) -> bool:
-        return self.arm_version >= 22 or 'ETU' not in self.serial_number
-
     @staticmethod
     def _single_phase_only(s: Sensor) -> bool:
         """Filter to exclude phase2/3 sensors on single phase inverters"""
@@ -474,10 +470,23 @@ class ET(Inverter):
         else:
             self._sensors_meter = tuple(filter(self._not_extended_meter, self._sensors_meter))
 
-        if self.arm_version >= 19 or 'ETU' not in self.serial_number:
+        # Check and add EcoModeV2 settings added in (ETU fw 19)
+        try:
+            await self._read_from_socket(ModbusReadCommand(self.comm_addr, 47547, 6))
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_19})
-        if self.arm_version >= 22 or 'ETU' not in self.serial_number:
+        except RequestRejectedException as ex:
+            if ex.message == 'ILLEGAL DATA ADDRESS':
+                logger.debug("Cannot read EcoModeV2 settings, using 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(ModbusReadCommand(self.comm_addr, 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.")
+                self._has_peak_shaving = False
 
     async def read_runtime_data(self) -> Dict[str, Any]:
         response = await self._read_from_socket(self._READ_RUNNING_DATA)
@@ -541,6 +550,9 @@ class ET(Inverter):
         setting = self._settings.get(setting_id)
         if not setting:
             raise ValueError(f'Unknown setting "{setting_id}"')
+        return await self._read_setting(setting)
+
+    async def _read_setting(self, setting: Sensor) -> Any:
         count = (setting.size_ + (setting.size_ % 2)) // 2
         response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
         return setting.read_value(response)
@@ -549,6 +561,9 @@ class ET(Inverter):
         setting = self._settings.get(setting_id)
         if not setting:
             raise ValueError(f'Unknown setting "{setting_id}"')
+        await self._write_setting(setting, value)
+
+    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(ModbusReadCommand(self.comm_addr, setting.offset, 1))
@@ -581,7 +596,7 @@ class ET(Inverter):
 
     async def get_operation_modes(self, include_emulated: bool) -> Tuple[OperationMode, ...]:
         result = [e for e in OperationMode]
-        if not self._supports_peak_shaving():
+        if not self._has_peak_shaving:
             result.remove(OperationMode.PEAK_SHAVING)
         if not include_emulated:
             result.remove(OperationMode.ECO_CHARGE)
@@ -626,7 +641,8 @@ class ET(Inverter):
                 raise ValueError()
             if eco_mode_soc < 0 or eco_mode_soc > 100:
                 raise ValueError()
-            eco_mode: EcoMode = self._convert_eco_mode(EcoModeV2("", 0, ""))
+            eco_mode: EcoMode | Sensor = self._settings.get('eco_mode_1')
+            await self._read_setting(eco_mode)
             if operation_mode == OperationMode.ECO_CHARGE:
                 await self.write_setting('eco_mode_1', eco_mode.encode_charge(eco_mode_power, eco_mode_soc))
             else:
@@ -641,7 +657,7 @@ class ET(Inverter):
         return 100 - await self.read_setting('battery_discharge_depth')
 
     async def set_ongrid_battery_dod(self, dod: int) -> None:
-        if 0 <= dod <= 90:
+        if 0 <= dod <= 100:
             await self.write_setting('battery_discharge_depth', 100 - dod)
 
     def sensors(self) -> Tuple[Sensor, ...]:
@@ -663,11 +679,3 @@ class ET(Inverter):
     async def _set_offline(self, mode: bool) -> None:
         value = bytes.fromhex('00070000') if mode else bytes.fromhex('00010000')
         await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, 0xb997, value))
-
-    def _convert_eco_mode(self, sensor: Sensor) -> Sensor | EcoMode:
-        if EcoModeV1 == type(sensor) and self._supports_eco_mode_v2():
-            return cast(EcoModeV1, sensor).as_eco_mode_v2()
-        elif EcoModeV2 == type(sensor) and not self._supports_eco_mode_v2():
-            return cast(EcoModeV2, sensor).as_eco_mode_v1()
-        else:
-            return sensor

{goodwe-0.3.0 → goodwe-0.3.2}/goodwe/protocol.py

@@ -85,7 +85,7 @@ class UdpInverterProtocol(asyncio.DatagramProtocol):
 class ProtocolResponse:
     """Definition of response to protocol command"""
 
-    def __init__(self, raw_data: bytes, command: ProtocolCommand):
+    def __init__(self, raw_data: bytes, command: Optional[ProtocolCommand]):
         self.raw_data: bytes = raw_data
         self.command: ProtocolCommand = command
         self._bytes: io.BytesIO = io.BytesIO(self.response_data())
@@ -116,6 +116,15 @@ class ProtocolCommand:
         self.request: bytes = request
         self.validator: Callable[[bytes], bool] = validator
 
+    def __eq__(self, other):
+        if not isinstance(other, ProtocolCommand):
+            # don't attempt to compare against unrelated types
+            return NotImplemented
+        return self.request == other.request
+
+    def __hash__(self):
+        return hash(self.request)
+
     def __repr__(self):
         return self.request.hex()
 
@@ -276,6 +285,7 @@ class ModbusProtocolCommand(ProtocolCommand):
             lambda x: validate_modbus_response(x, cmd, offset, value),
         )
         self.first_address: int = offset
+        self.value = value
 
     def trim_response(self, raw_response: bytes):
         """Trim raw response from header and checksum data"""
@@ -296,6 +306,12 @@ class ModbusReadCommand(ModbusProtocolCommand):
             create_modbus_request(comm_addr, MODBUS_READ_CMD, offset, count),
             MODBUS_READ_CMD, offset, count)
 
+    def __repr__(self):
+        if self.value > 1:
+            return f'READ {self.value} registers from {self.first_address} ({self.request.hex()})'
+        else:
+            return f'READ register {self.first_address} ({self.request.hex()})'
+
 
 class ModbusWriteCommand(ModbusProtocolCommand):
     """
@@ -307,6 +323,9 @@ class ModbusWriteCommand(ModbusProtocolCommand):
             create_modbus_request(comm_addr, MODBUS_WRITE_CMD, register, value),
             MODBUS_WRITE_CMD, register, value)
 
+    def __repr__(self):
+        return f'WRITE {self.value} to register {self.first_address} ({self.request.hex()})'
+
 
 class ModbusWriteMultiCommand(ModbusProtocolCommand):
     """