goodwe 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

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/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/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):
     """

goodwe/sensor.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from datetime import datetime
+from enum import IntEnum
 from struct import unpack
 from typing import Any, Callable, Optional
 
@@ -10,10 +11,79 @@ from .inverter import Sensor, SensorKind
 from .protocol import ProtocolResponse
 
 DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+
+
+class ScheduleType(IntEnum):
+    ECO_MODE = 0,
+    DRY_CONTACT_LOAD = 1,
+    DRY_CONTACT_SMART_LOAD = 2,
+    PEAK_SHAVING = 3,
+    BACKUP_MODE = 4,
+    SMART_CHARGE_MODE = 5,
+    ECO_MODE_745 = 6
+
+    @classmethod
+    def detect_schedule_type(cls, value: int) -> ScheduleType:
+        """Detect schedule type from its on/off value"""
+        if value in (0, -1, 85):
+            return ScheduleType.ECO_MODE
+        elif value in (1, -2):
+            return ScheduleType.DRY_CONTACT_LOAD
+        elif value in (2, -3):
+            return ScheduleType.DRY_CONTACT_SMART_LOAD
+        elif value in (3, -4):
+            return ScheduleType.PEAK_SHAVING
+        elif value in (4, -5):
+            return ScheduleType.BACKUP_MODE
+        elif value in (5, -6):
+            return ScheduleType.SMART_CHARGE_MODE
+        elif value in (6, -7):
+            return ScheduleType.ECO_MODE_745
+        else:
+            raise ValueError(f"{value}: on_off value {value} out of range.")
+
+    def power_unit(self):
+        """Return unit of power parameter"""
+        if self == ScheduleType.PEAK_SHAVING:
+            return "W"
+        else:
+            return "%"
+
+    def decode_power(self, value: int) -> int:
+        """Decode human readable value of power parameter"""
+        if self == ScheduleType.ECO_MODE:
+            return value
+        elif self == ScheduleType.PEAK_SHAVING:
+            return value * 10
+        if self == ScheduleType.ECO_MODE_745:
+            return int(value / 10)
+        else:
+            return value
+
+    def encode_power(self, value: int) -> int:
+        """Encode human readable value of power parameter"""
+        if self == ScheduleType.ECO_MODE:
+            return value
+        elif self == ScheduleType.PEAK_SHAVING:
+            return int(value / 10)
+        if self == ScheduleType.ECO_MODE_745:
+            return value * 10
+        else:
+            return value
+
+    def is_in_range(self, value: int) -> bool:
+        """Check if the value fits in allowed values range"""
+        if self == ScheduleType.ECO_MODE:
+            return -100 <= value <= 100
+        if self == ScheduleType.ECO_MODE_745:
+            return -1000 <= value <= 1000
+        else:
+            return True
 
 
 class Voltage(Sensor):
-    """Sensor representing voltage [V] value encoded in 2 bytes"""
+    """Sensor representing voltage [V] value encoded in 2 (unsigned) bytes"""
 
     def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
         super().__init__(id_, offset, name, 2, "V", kind)
@@ -26,7 +96,7 @@ class Voltage(Sensor):
 
 
 class Current(Sensor):
-    """Sensor representing current [A] value encoded in 2 bytes"""
+    """Sensor representing current [A] value encoded in 2 (unsigned) bytes"""
 
     def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
         super().__init__(id_, offset, name, 2, "A", kind)
@@ -38,6 +108,19 @@ class Current(Sensor):
         return encode_current(value)
 
 
+class CurrentS(Sensor):
+    """Sensor representing current [A] value encoded in 2 (signed) bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 2, "A", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        return read_current_signed(data)
+
+    def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
+        return encode_current_signed(value)
+
+
 class Frequency(Sensor):
     """Sensor representing frequency [Hz] value encoded in 2 bytes"""
 
@@ -49,7 +132,7 @@ class Frequency(Sensor):
 
 
 class Power(Sensor):
-    """Sensor representing power [W] value encoded in 2 bytes"""
+    """Sensor representing power [W] value encoded in 2 (unsigned) bytes"""
 
     def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
         super().__init__(id_, offset, name, 2, "W", kind)
@@ -58,8 +141,18 @@ class Power(Sensor):
         return read_bytes2(data)
 
 
+class PowerS(Sensor):
+    """Sensor representing power [W] value encoded in 2 (signed) bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 2, "W", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        return read_bytes2_signed(data)
+
+
 class Power4(Sensor):
-    """Sensor representing power [W] value encoded in 4 bytes"""
+    """Sensor representing power [W] value encoded in 4 (unsigned) bytes"""
 
     def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
         super().__init__(id_, offset, name, 4, "W", kind)
@@ -68,6 +161,16 @@ class Power4(Sensor):
         return read_bytes4(data)
 
 
+class Power4S(Sensor):
+    """Sensor representing power [W] value encoded in 4 (signed) bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 4, "W", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        return read_bytes4_signed(data)
+
+
 class Energy(Sensor):
     """Sensor representing energy [kWh] value encoded in 2 bytes"""
 
@@ -76,10 +179,7 @@ class Energy(Sensor):
 
     def read_value(self, data: ProtocolResponse):
         value = read_bytes2(data)
-        if value == -1:
-            return None
-        else:
-            return float(value) / 10
+        return float(value) / 10
 
 
 class Energy4(Sensor):
@@ -90,10 +190,7 @@ class Energy4(Sensor):
 
     def read_value(self, data: ProtocolResponse):
         value = read_bytes4(data)
-        if value == -1:
-            return None
-        else:
-            return float(value) / 10
+        return float(value) / 10
 
 
 class Apparent(Sensor):
@@ -103,7 +200,7 @@ class Apparent(Sensor):
         super().__init__(id_, offset, name, 2, "VA", kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes2(data)
+        return read_bytes2_signed(data)
 
 
 class Apparent4(Sensor):
@@ -113,7 +210,7 @@ class Apparent4(Sensor):
         super().__init__(id_, offset, name, 2, "VA", kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes4(data)
+        return read_bytes4_signed(data)
 
 
 class Reactive(Sensor):
@@ -123,7 +220,7 @@ class Reactive(Sensor):
         super().__init__(id_, offset, name, 2, "var", kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes2(data)
+        return read_bytes2_signed(data)
 
 
 class Reactive4(Sensor):
@@ -133,7 +230,7 @@ class Reactive4(Sensor):
         super().__init__(id_, offset, name, 2, "var", kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes4(data)
+        return read_bytes4_signed(data)
 
 
 class Temp(Sensor):
@@ -207,7 +304,7 @@ class Integer(Sensor):
         super().__init__(id_, offset, name, 2, unit, kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes2(data)
+        return read_bytes2_signed(data)
 
     def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
         return int.to_bytes(int(value), length=2, byteorder="big", signed=True)
@@ -220,7 +317,7 @@ class Long(Sensor):
         super().__init__(id_, offset, name, 4, unit, kind)
 
     def read_value(self, data: ProtocolResponse):
-        return read_bytes4(data)
+        return read_bytes4_signed(data)
 
     def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
         return int.to_bytes(int(value), length=4, byteorder="big", signed=True)
@@ -320,7 +417,7 @@ class EnumBitmap4(Sensor):
         raise NotImplementedError()
 
     def read(self, data: ProtocolResponse):
-        bits = read_bytes4(data, self.offset)
+        bits = read_bytes4_signed(data, self.offset)
         return decode_bitmap(bits if bits != -1 else 0, self._labels)
 
 
@@ -413,7 +510,7 @@ class EcoModeV1(Sensor, EcoMode):
         self.end_m = read_byte(data)
         if self.end_m < 0 or self.end_m > 59:
             raise ValueError(f"{self.id_}: end_m value {self.end_m} out of range.")
-        self.power = read_bytes2(data)  # negative=charge, positive=discharge
+        self.power = read_bytes2_signed(data)  # negative=charge, positive=discharge
         if self.power < -100 or self.power > 100:
             raise ValueError(f"{self.id_}: power value {self.power} out of range.")
         self.on_off = read_byte(data)
@@ -479,10 +576,10 @@ class EcoModeV1(Sensor, EcoMode):
         return result
 
 
-class EcoModeV2(Sensor, EcoMode):
-    """Sensor representing Eco Mode Battery Power Group encoded in 12 bytes"""
+class Schedule(Sensor, EcoMode):
+    """Sensor representing Schedule Group encoded in 12 bytes"""
 
-    def __init__(self, id_: str, offset: int, name: str):
+    def __init__(self, id_: str, offset: int, name: str, schedule_type: ScheduleType = ScheduleType.ECO_MODE):
         super().__init__(id_, offset, name, 12, "", SensorKind.BAT)
         self.start_h: int | None = None
         self.start_m: int | None = None
@@ -493,39 +590,43 @@ class EcoModeV2(Sensor, EcoMode):
         self.days: str | None = None
         self.power: int | None = None
         self.soc: int | None = None
-        # 2 bytes padding 0000
+        self.month_bits: int | None = None
+        self.months: str | None = None
+        self.schedule_type: ScheduleType = schedule_type
 
     def __str__(self):
         return f"{self.start_h}:{self.start_m}-{self.end_h}:{self.end_m} {self.days} " \
-               f"{self.power}% (SoC {self.soc}%) " \
-               f"{'On' if self.on_off == -1 else 'Off' if self.on_off == 0 else 'Unset'}"
+               f"{self.months + ' ' if self.months else ''}" \
+               f"{self.schedule_type.decode_power(self.power)}{self.schedule_type.power_unit()} (SoC {self.soc}%) " \
+               f"{'On' if -10 < self.on_off < 0 else 'Off' if 10 > self.on_off >= 0 else 'Unset'}"
 
     def read_value(self, data: ProtocolResponse):
         self.start_h = read_byte(data)
-        if (self.start_h < 0 or self.start_h > 23) and self.start_h != 48:
+        if (self.start_h < 0 or self.start_h > 23) and self.start_h != 48 and self.start_h != -1:
             raise ValueError(f"{self.id_}: start_h value {self.start_h} out of range.")
         self.start_m = read_byte(data)
-        if self.start_m < 0 or self.start_m > 59:
+        if (self.start_m < 0 or self.start_m > 59) and self.start_m != -1:
             raise ValueError(f"{self.id_}: start_m value {self.start_m} out of range.")
         self.end_h = read_byte(data)
-        if (self.end_h < 0 or self.end_h > 23) and self.end_h != 48:
+        if (self.end_h < 0 or self.end_h > 23) and self.end_h != 48 and self.end_h != -1:
             raise ValueError(f"{self.id_}: end_h value {self.end_h} out of range.")
         self.end_m = read_byte(data)
-        if self.end_m < 0 or self.end_m > 59:
+        if (self.end_m < 0 or self.end_m > 59) and self.end_m != -1:
             raise ValueError(f"{self.id_}: end_m value {self.end_m} out of range.")
         self.on_off = read_byte(data)
-        if self.on_off not in (0, -1, 85):
-            raise ValueError(f"{self.id_}: on_off value {self.on_off} out of range.")
+        self.schedule_type = ScheduleType.detect_schedule_type(self.on_off)
         self.day_bits = read_byte(data)
         self.days = decode_day_of_week(self.day_bits)
         if self.day_bits < 0:
             raise ValueError(f"{self.id_}: day_bits value {self.day_bits} out of range.")
-        self.power = read_bytes2(data)  # negative=charge, positive=discharge
-        if self.power < -100 or self.power > 100:
+        self.power = read_bytes2_signed(data)  # negative=charge, positive=discharge
+        if not self.schedule_type.is_in_range(self.power):
             raise ValueError(f"{self.id_}: power value {self.power} out of range.")
-        self.soc = read_bytes2(data)
+        self.soc = read_bytes2_signed(data)
         if self.soc < 0 or self.soc > 100:
             raise ValueError(f"{self.id_}: SoC value {self.soc} out of range.")
+        self.month_bits = read_bytes2_signed(data)
+        self.months = decode_months(self.month_bits)
         return self
 
     def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
@@ -538,15 +639,24 @@ class EcoModeV2(Sensor, EcoMode):
     def encode_charge(self, eco_mode_power: int, eco_mode_soc: int = 100) -> bytes:
         """Answer bytes representing all the time enabled charging eco mode group"""
         return bytes.fromhex(
-            "0000173bff7f{:04x}{:04x}0000".format((-1 * abs(eco_mode_power)) & (2 ** 16 - 1), eco_mode_soc))
+            "0000173b{:02x}7f{:04x}{:04x}{:04x}".format(
+                255 - self.schedule_type,
+                (-1 * abs(self.schedule_type.encode_power(eco_mode_power))) & (2 ** 16 - 1),
+                eco_mode_soc,
+                0 if self.schedule_type != ScheduleType.ECO_MODE_745 else 0x0fff))
 
     def encode_discharge(self, eco_mode_power: int) -> bytes:
         """Answer bytes representing all the time enabled discharging eco mode group"""
-        return bytes.fromhex("0000173bff7f{:04x}00640000".format(abs(eco_mode_power)))
+        return bytes.fromhex("0000173b{:02x}7f{:04x}0064{:04x}".format(
+            255 - self.schedule_type,
+            abs(self.schedule_type.encode_power(eco_mode_power)),
+            0 if self.schedule_type != ScheduleType.ECO_MODE_745 else 0x0fff))
 
     def encode_off(self) -> bytes:
-        """Answer bytes representing empty and disabled eco mode group"""
-        return bytes.fromhex("300030000000006400640000")
+        """Answer bytes representing empty and disabled schedule group"""
+        return bytes.fromhex("30003000{:02x}00{:04x}00640000".format(
+            self.schedule_type.value,
+            self.schedule_type.encode_power(100)))
 
     def is_eco_charge_mode(self) -> bool:
         """Answer if it represents the emulated 24/7 fulltime discharge mode"""
@@ -554,9 +664,10 @@ class EcoModeV2(Sensor, EcoMode):
             and self.start_m == 0 \
             and self.end_h == 23 \
             and self.end_m == 59 \
-            and self.on_off == -1 \
+            and self.on_off == (-1 - self.schedule_type) \
             and self.day_bits == 127 \
-            and self.power < 0
+            and self.power < 0 \
+            and (self.month_bits == 0 or self.month_bits == 0x0fff)
 
     def is_eco_discharge_mode(self) -> bool:
         """Answer if it represents the emulated 24/7 fulltime discharge mode"""
@@ -564,9 +675,10 @@ class EcoModeV2(Sensor, EcoMode):
             and self.start_m == 0 \
             and self.end_h == 23 \
             and self.end_m == 59 \
-            and self.on_off == -1 \
+            and self.on_off == (-1 - self.schedule_type) \
             and self.day_bits == 127 \
-            and self.power > 0
+            and self.power > 0 \
+            and (self.month_bits == 0 or self.month_bits == 0x0fff)
 
     def as_eco_mode_v1(self) -> EcoModeV1:
         """Convert V2 to V1 EcoMode"""
@@ -582,65 +694,18 @@ class EcoModeV2(Sensor, EcoMode):
         return result
 
 
-class PeakShavingMode(Sensor):
-    """Sensor representing Peak Shaving Mode encoded in 12 bytes"""
+class EcoModeV2(Schedule):
+    """Sensor representing Eco Mode Group encoded in 12 bytes"""
 
     def __init__(self, id_: str, offset: int, name: str):
-        super().__init__(id_, offset, name, 12, "", SensorKind.BAT)
-        self.start_h: int | None = None
-        self.start_m: int | None = None
-        self.end_h: int | None = None
-        self.end_m: int | None = None
-        self.on_off: int | None = None
-        self.day_bits: int | None = None
-        self.days: str | None = None
-        self.import_power: float | None = None
-        self.soc: int | None = None
-        # 2 bytes padding 0000
+        super().__init__(id_, offset, name, ScheduleType.ECO_MODE)
 
-    def __str__(self):
-        return f"{self.start_h}:{self.start_m}-{self.end_h}:{self.end_m} {self.days} " \
-               f"{self.import_power}kW (SoC {self.soc}%) " \
-               f"{'On' if self.on_off == -4 else 'Off' if self.on_off == 3 else 'Unset'}"
-
-    def read_value(self, data: ProtocolResponse):
-        self.start_h = read_byte(data)
-        if (self.start_h < 0 or self.start_h > 23) and self.start_h != 48:
-            raise ValueError(f"{self.id_}: start_h value {self.start_h} out of range.")
-        self.start_m = read_byte(data)
-        if self.start_m < 0 or self.start_m > 59:
-            raise ValueError(f"{self.id_}: start_m value {self.start_m} out of range.")
-        self.end_h = read_byte(data)
-        if (self.end_h < 0 or self.end_h > 23) and self.end_h != 48:
-            raise ValueError(f"{self.id_}: end_h value {self.end_h} out of range.")
-        self.end_m = read_byte(data)
-        if self.end_m < 0 or self.end_m > 59:
-            raise ValueError(f"{self.id_}: end_m value {self.end_m} out of range.")
-        self.on_off = read_byte(data)
-        if self.on_off not in (-4, 3, 85):
-            raise ValueError(f"{self.id_}: on_off value {self.on_off} out of range.")
-        self.day_bits = read_byte(data)
-        self.days = decode_day_of_week(self.day_bits)
-        if self.day_bits < 0:
-            raise ValueError(f"{self.id_}: day_bits value {self.day_bits} out of range.")
-        self.import_power = read_decimal2(data, 100)
-        if self.import_power < 0 or self.import_power > 500:
-            raise ValueError(f"{self.id_}: import_power value {self.import_power} out of range.")
-        self.soc = read_bytes2(data)
-        if self.soc < 0 or self.soc > 100:
-            raise ValueError(f"{self.id_}: soc value {self.soc} out of range.")
-        return self
 
-    def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
-        if isinstance(value, bytes) and len(value) == 12:
-            # try to read_value to check if values are valid
-            if self.read_value(ProtocolResponse(value, None)):
-                return value
-        raise ValueError
+class PeakShavingMode(Schedule):
+    """Sensor representing Peak Shaving Mode encoded in 12 bytes"""
 
-    def encode_off(self) -> bytes:
-        """Answer bytes representing empty and disabled eco mode group"""
-        return bytes.fromhex("300030000000006400640000")
+    def __init__(self, id_: str, offset: int, name: str):
+        super().__init__(id_, offset, name, ScheduleType.PEAK_SHAVING)
 
 
 class Calculated(Sensor):
@@ -666,6 +731,14 @@ def read_byte(buffer: ProtocolResponse, offset: int = None) -> int:
 
 
 def read_bytes2(buffer: ProtocolResponse, offset: int = None) -> int:
+    """Retrieve 2 byte (unsigned int) value from buffer"""
+    if offset is not None:
+        buffer.seek(offset)
+    value = int.from_bytes(buffer.read(2), byteorder="big", signed=False)
+    return value if value != 0xffff else 0
+
+
+def read_bytes2_signed(buffer: ProtocolResponse, offset: int = None) -> int:
     """Retrieve 2 byte (signed int) value from buffer"""
     if offset is not None:
         buffer.seek(offset)
@@ -673,6 +746,14 @@ def read_bytes2(buffer: ProtocolResponse, offset: int = None) -> int:
 
 
 def read_bytes4(buffer: ProtocolResponse, offset: int = None) -> int:
+    """Retrieve 4 byte (unsigned int) value from buffer"""
+    if offset is not None:
+        buffer.seek(offset)
+    value = int.from_bytes(buffer.read(4), byteorder="big", signed=False)
+    return value if value != 0xffffffff else 0
+
+
+def read_bytes4_signed(buffer: ProtocolResponse, offset: int = None) -> int:
     """Retrieve 4 byte (signed int) value from buffer"""
     if offset is not None:
         buffer.seek(offset)
@@ -698,20 +779,28 @@ def read_float4(buffer: ProtocolResponse, offset: int = None) -> float:
 
 
 def read_voltage(buffer: ProtocolResponse, offset: int = None) -> float:
-    """Retrieve voltage [V] value (2 bytes) from buffer"""
+    """Retrieve voltage [V] value (2 unsigned bytes) from buffer"""
     if offset is not None:
         buffer.seek(offset)
-    value = int.from_bytes(buffer.read(2), byteorder="big", signed=True)
-    return float(value) / 10
+    value = int.from_bytes(buffer.read(2), byteorder="big", signed=False)
+    return float(value) / 10 if value != 0xffff else 0
 
 
 def encode_voltage(value: Any) -> bytes:
-    """Encode voltage value to raw (2 bytes) payload"""
-    return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=True)
+    """Encode voltage value to raw (2 unsigned bytes) payload"""
+    return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=False)
 
 
 def read_current(buffer: ProtocolResponse, offset: int = None) -> float:
-    """Retrieve current [A] value (2 bytes) from buffer"""
+    """Retrieve current [A] value (2 unsigned bytes) from buffer"""
+    if offset is not None:
+        buffer.seek(offset)
+    value = int.from_bytes(buffer.read(2), byteorder="big", signed=False)
+    return float(value) / 10 if value != 0xffff else 0
+
+
+def read_current_signed(buffer: ProtocolResponse, offset: int = None) -> float:
+    """Retrieve current [A] value (2 signed bytes) from buffer"""
     if offset is not None:
         buffer.seek(offset)
     value = int.from_bytes(buffer.read(2), byteorder="big", signed=True)
@@ -719,7 +808,12 @@ def read_current(buffer: ProtocolResponse, offset: int = None) -> float:
 
 
 def encode_current(value: Any) -> bytes:
-    """Encode current value to raw (2 bytes) payload"""
+    """Encode current value to raw (2 unsigned bytes) payload"""
+    return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=False)
+
+
+def encode_current_signed(value: Any) -> bytes:
+    """Encode current value to raw (2 signed bytes) payload"""
     return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=True)
 
 
@@ -771,7 +865,7 @@ def encode_datetime(value: Any) -> bytes:
 
 def read_grid_mode(buffer: ProtocolResponse, offset: int = None) -> int:
     """Retrieve 'grid mode' sign value from buffer"""
-    value = read_bytes2(buffer, offset)
+    value = read_bytes2_signed(buffer, offset)
     if value < -90:
         return 2
     elif value >= 90:
@@ -807,3 +901,18 @@ def decode_day_of_week(data: int) -> str:
             days += daynames[0]
         daynames.pop(0)
     return days
+
+
+def decode_months(data: int) -> str | None:
+    if data == 0 or data == 0x0fff:
+        return None
+    bits = bin(data)[2:]
+    monthnames = list(MONTH_NAMES)
+    months = ""
+    for each in bits[::-1]:
+        if each == '1':
+            if len(months) > 0:
+                months += ","
+            months += monthnames[0]
+        monthnames.pop(0)
+    return months

{goodwe-0.3.0.dist-info → goodwe-0.3.2.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+goodwe/__init__.py,sha256=PInrrZEpTmMOQKk494vIz8EKSaw_qLBNz-6t9eLIUcg,5642
+goodwe/const.py,sha256=Nw-nd4UJuqUOLfbmOrxTHEdS1AuaTDSpZzQqR6tBb8w,7912
+goodwe/dt.py,sha256=bI53MVdZjtxTYU2qJLO8icsvF6UiXrkgH95V3iUwXT0,10581
+goodwe/es.py,sha256=d0RyW70dnxaMNVZzSxE7eEoW2dMDzQQxA4MlSADOyuo,22417
+goodwe/et.py,sha256=zQUZAhaC4HUV_0hzF6M85ffXasBBKSbpNkT_x37EZjw,38443
+goodwe/exceptions.py,sha256=I6PHG0GTWgxNrDVZwJZBnyzItRq5eiM6ci23-EEsn1I,1012
+goodwe/inverter.py,sha256=HvVtFBz5Zvl1je1V2AuLqpoB1vsur_gDHu-6SjNbJ8o,10323
+goodwe/modbus.py,sha256=ZPib-zKnOVE5zc0RNnhlf0w_26QBees1ScWGo6bAj0o,4685
+goodwe/model.py,sha256=Yy662c6VpuLozxo1Q7Llw1g34UhT5qJd9_rITIjmEd4,1523
+goodwe/protocol.py,sha256=pUkXTP2DqpKXGO7rbRfHq1x82Y1QM6OiRVx8cAtS0sM,13162
+goodwe/sensor.py,sha256=M8v3flB4V7VxY91G1m2a1tdaD5j_lqtVzkxxrcTFHmE,34696
+goodwe-0.3.2.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.3.2.dist-info/METADATA,sha256=izdqayJnYLUwJt9DPS2oUrgMUxGzNNIDMmokDNb3RNs,3050
+goodwe-0.3.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+goodwe-0.3.2.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.3.2.dist-info/RECORD,,

{goodwe-0.3.0.dist-info → goodwe-0.3.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

goodwe-0.3.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=PInrrZEpTmMOQKk494vIz8EKSaw_qLBNz-6t9eLIUcg,5642
-goodwe/const.py,sha256=Nw-nd4UJuqUOLfbmOrxTHEdS1AuaTDSpZzQqR6tBb8w,7912
-goodwe/dt.py,sha256=bI53MVdZjtxTYU2qJLO8icsvF6UiXrkgH95V3iUwXT0,10581
-goodwe/es.py,sha256=dZ_pGb6tI_PNJUm4gWlS0voN22kc37yDq4aNeqeteCM,22649
-goodwe/et.py,sha256=_v7dvRQ18JBBOgwbTn_T2qQIHOO8TjLcavmmJWJEzq8,38032
-goodwe/exceptions.py,sha256=I6PHG0GTWgxNrDVZwJZBnyzItRq5eiM6ci23-EEsn1I,1012
-goodwe/inverter.py,sha256=HvVtFBz5Zvl1je1V2AuLqpoB1vsur_gDHu-6SjNbJ8o,10323
-goodwe/modbus.py,sha256=ZPib-zKnOVE5zc0RNnhlf0w_26QBees1ScWGo6bAj0o,4685
-goodwe/model.py,sha256=Yy662c6VpuLozxo1Q7Llw1g34UhT5qJd9_rITIjmEd4,1523
-goodwe/protocol.py,sha256=P0KYAVoLNkE1Ws70F4AWqqzWbzGA11P8VOYj1wDXDoo,12480
-goodwe/sensor.py,sha256=pGbeZFmvvFcaSKgxgIhUIp-k1wW1jF0RVDfrkMGEdJY,31027
-goodwe-0.3.0.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.3.0.dist-info/METADATA,sha256=R4H86lZ6qBXAoBqEhFYTom36JrEAEJfHmSISe8kUkRA,3050
-goodwe-0.3.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-goodwe-0.3.0.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.3.0.dist-info/RECORD,,