goodwe 0.4.4__tar.gz → 0.4.6__tar.gz

{goodwe-0.4.4/goodwe.egg-info → goodwe-0.4.6}/PKG-INFO

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

goodwe-0.4.6/VERSION

@@ -0,0 +1 @@
+0.4.6

{goodwe-0.4.4 → goodwe-0.4.6}/goodwe/dt.py

@@ -114,6 +114,10 @@ class DT(Inverter):
         Integer("shadow_scan", 40326, "Shadow Scan", "", Kind.PV),
         Integer("grid_export", 40327, "Grid Export Enabled", "", Kind.GRID),
         Integer("grid_export_limit", 40328, "Grid Export Limit", "%", Kind.GRID),
+        Integer("start", 40330, "Start / Power On", "", Kind.GRID),
+        Integer("stop", 40331, "Stop / Power Off", "", Kind.GRID),
+        Integer("restart", 40332, "Restart", "", Kind.GRID),
+        Integer("grid_export_hw", 40345, "Grid Export Enabled (HW)", "", Kind.GRID),
     )
 
     # Settings for single phase inverters
@@ -196,6 +200,7 @@ class DT(Inverter):
             if ex.message == ILLEGAL_DATA_ADDRESS:
                 logger.debug("Unsupported setting %s", setting.id_)
                 self._settings.pop(setting.id_, None)
+                raise ValueError(f'Unknown setting "{setting.id_}"')
             return None
 
     async def write_setting(self, setting_id: str, value: Any):

{goodwe-0.4.4 → goodwe-0.4.6}/goodwe/es.py

@@ -174,11 +174,11 @@ class ES(Inverter):
     def _supports_eco_mode_v2(self) -> bool:
         if self.arm_version < 14:
             return False
-        if "EMU" in self.serial_number:
+        if "EMU" in self.serial_number or "EMJ" in self.serial_number:
             return self.dsp1_version >= 11
-        if "ESU" in self.serial_number:
+        if "ESU" in self.serial_number or "ESA" in self.serial_number:
             return self.dsp1_version >= 22
-        if "BPS" in self.serial_number:
+        if "BPS" in self.serial_number or "BPU" in self.serial_number:
             return self.dsp1_version >= 10
         return False
 
@@ -188,7 +188,7 @@ class ES(Inverter):
         self.firmware = self._decode(response[0:5]).rstrip()
         self.model_name = self._decode(response[5:15]).rstrip()
         self.serial_number = self._decode(response[31:47])
-        self.software_version = self._decode(response[51:63])
+        self.arm_firmware = self._decode(response[51:63])  # AKA software_version
         try:
             if len(self.firmware) >= 2:
                 self.dsp1_version = int(self.firmware[0:2])
@@ -220,9 +220,12 @@ class ES(Inverter):
         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:
+        elif setting_id in self._settings:
+            logger.debug("Reading setting %s", setting_id)
             all_settings = await self.read_settings_data()
             return all_settings.get(setting_id)
+        else:
+            raise ValueError(f'Unknown setting "{setting_id}"')
 
     async def _read_setting(self, setting: Sensor) -> Any:
         count = (setting.size_ + (setting.size_ % 2)) // 2
@@ -296,7 +299,7 @@ class ES(Inverter):
         try:
             mode = OperationMode(mode_id)
         except ValueError:
-            logger.debug("Unknown work_mode value %d", mode_id)
+            logger.debug("Unknown work_mode value %s", mode_id)
             return None
         if OperationMode.ECO != mode:
             return mode

{goodwe-0.4.4 → goodwe-0.4.6}/goodwe/et.py

@@ -332,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", ""),
+        Long("modbus_baud_rate", 45132, "Modbus Baud rate", ""),
         Timestamp("time", 45200, "Inverter time"),
 
         Integer("sensitivity_check", 45246, "Sensitivity Check Mode", "", Kind.AC),
@@ -357,6 +357,8 @@ class ET(Inverter):
         Integer("work_mode", 47000, "Work Mode", "", Kind.AC),
         Integer("dred", 47010, "DRED/Remote Shutdown", "", Kind.AC),
 
+        Integer("meter_target_power_offset", 47120, "Meter Target Power Offset", "W", Kind.AC),
+
         Integer("battery_soc_protection", 47500, "Battery SoC Protection", "", Kind.BAT),
 
         Integer("grid_export", 47509, "Grid Export Enabled", "", Kind.GRID),
@@ -626,6 +628,7 @@ class ET(Inverter):
             if ex.message == ILLEGAL_DATA_ADDRESS:
                 logger.debug("Unsupported setting %s", setting.id_)
                 self._settings.pop(setting.id_, None)
+                raise ValueError(f'Unknown setting "{setting.id_}"')
             return None
 
     async def write_setting(self, setting_id: str, value: Any):
@@ -685,7 +688,7 @@ class ET(Inverter):
         try:
             mode = OperationMode(mode_id)
         except ValueError:
-            logger.debug("Unknown work_mode value %d", mode_id)
+            logger.debug("Unknown work_mode value %s", mode_id)
             return None
         if OperationMode.ECO != mode:
             return mode

{goodwe-0.4.4 → goodwe-0.4.6}/goodwe/protocol.py

@@ -141,11 +141,13 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
             logger.debug("Received response fragment (%d of %d): %s", ex.length, ex.expected, data.hex())
             self._partial_data = data
             self._partial_missing = ex.expected - ex.length
+            self._timer = asyncio.get_running_loop().call_later(self.timeout, self._retry_mechanism)
         except asyncio.InvalidStateError:
             logger.debug("Response already handled: %s", data.hex())
         except RequestRejectedException as ex:
             logger.debug("Received exception response: %s", data.hex())
-            self.response_future.set_exception(ex)
+            if self.response_future and not self.response_future.done():
+                self.response_future.set_exception(ex)
             self._close_transport()
 
     def error_received(self, exc: Exception) -> None:
@@ -284,11 +286,13 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
             logger.debug("Received response fragment (%d of %d): %s", ex.length, ex.expected, data.hex())
             self._partial_data = data
             self._partial_missing = ex.expected - ex.length
+            self._timer = asyncio.get_running_loop().call_later(self.timeout, self._timeout_mechanism)
         except asyncio.InvalidStateError:
             logger.debug("Response already handled: %s", data.hex())
         except RequestRejectedException as ex:
             logger.debug("Received exception response: %s", data.hex())
-            self.response_future.set_exception(ex)
+            if self.response_future and not self.response_future.done():
+                self.response_future.set_exception(ex)
             # self._close_transport()
 
     def error_received(self, exc: Exception) -> None:
@@ -469,7 +473,7 @@ class Aa55ProtocolCommand(ProtocolCommand):
     Quite probably it is some variation of the protocol used on RS-485 serial link,
     extended/adapted to UDP transport layer.
 
-    Each request starts with header of 0xAA, 0x55, then 0xC0, 0x7F (probably some sort of address/command)
+    Each request starts with header of 0xAA, 0x55, then 0xC0, 0x7F (client addr, inverter addr)
     followed by actual payload data.
     It is suffixed with 2 bytes of plain checksum of header+payload.
 
@@ -478,15 +482,17 @@ class Aa55ProtocolCommand(ProtocolCommand):
     The last 2 bytes are again plain checksum of header+payload.
     """
 
-    def __init__(self, payload: str, response_type: str):
+    def __init__(self, payload: str, response_type: str, offset: int = 0, value: int = 0):
         super().__init__(
             bytes.fromhex(
                 "AA55C07F"
                 + payload
                 + self._checksum(bytes.fromhex("AA55C07F" + payload)).hex()
             ),
-            lambda x: self._validate_response(x, response_type),
+            lambda x: self._validate_aa55_response(x, response_type),
         )
+        self.first_address: int = offset
+        self.value = value
 
     @staticmethod
     def _checksum(data: bytes) -> bytes:
@@ -496,7 +502,7 @@ class Aa55ProtocolCommand(ProtocolCommand):
         return checksum.to_bytes(2, byteorder="big", signed=False)
 
     @staticmethod
-    def _validate_response(data: bytes, response_type: str) -> bool:
+    def _validate_aa55_response(data: bytes, response_type: str) -> bool:
         """
         Validate the response.
         data[0:3] is header
@@ -504,13 +510,20 @@ class Aa55ProtocolCommand(ProtocolCommand):
         data[6] is response payload length
         data[-2:] is checksum (plain sum of response data incl. header)
         """
-        if len(data) <= 8 or len(data) != data[6] + 9:
+        if len(data) <= 8:
+            logger.debug("Response too short.")
+            return False
+        elif len(data) < data[6] + 9:
             raise PartialResponseException(len(data), data[6] + 9)
+        elif len(data) > data[6] + 9:
+            logger.debug("Response invalid - too long (%d).", len(data))
+            return False
         elif response_type:
             data_rt_int = int.from_bytes(data[4:6], byteorder="big", signed=True)
             if int(response_type, 16) != data_rt_int:
                 logger.debug("Response type unexpected: %04x, expected %s.", data_rt_int, response_type)
                 return False
+
         checksum = 0
         for each in data[:-2]:
             checksum += each
@@ -523,6 +536,17 @@ class Aa55ProtocolCommand(ProtocolCommand):
         """Trim raw response from header and checksum data"""
         return raw_response[7:-2]
 
+    def __repr__(self):
+        if self.request[4] == 1:
+            if self.request[5] == 2:
+                return f'READ device info ({self.request.hex()})'
+            elif self.request[5] == 6:
+                return f'READ runtime data ({self.request.hex()})'
+            elif self.request[5] == 9:
+                return f'READ settings ({self.request.hex()})'
+        else:
+            return self.request.hex()
+
 
 class Aa55ReadCommand(Aa55ProtocolCommand):
     """
@@ -530,7 +554,13 @@ class Aa55ReadCommand(Aa55ProtocolCommand):
     """
 
     def __init__(self, offset: int, count: int):
-        super().__init__("011A03" + "{:04x}".format(offset) + "{:02x}".format(count), "019A")
+        super().__init__("011A03" + "{:04x}".format(offset) + "{:02x}".format(count), "019A", 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 Aa55WriteCommand(Aa55ProtocolCommand):
@@ -539,7 +569,10 @@ class Aa55WriteCommand(Aa55ProtocolCommand):
     """
 
     def __init__(self, register: int, value: int):
-        super().__init__("023905" + "{:04x}".format(register) + "01" + "{:04x}".format(value), "02B9")
+        super().__init__("023905" + "{:04x}".format(register) + "01" + "{:04x}".format(value), "02B9", register, value)
+
+    def __repr__(self):
+        return f'WRITE {self.value} to register {self.first_address} ({self.request.hex()})'
 
 
 class Aa55WriteMultiCommand(Aa55ProtocolCommand):
@@ -549,7 +582,7 @@ class Aa55WriteMultiCommand(Aa55ProtocolCommand):
 
     def __init__(self, offset: int, values: bytes):
         super().__init__("02390B" + "{:04x}".format(offset) + "{:02x}".format(len(values)) + values.hex(),
-                         "02B9")
+                         "02B9", offset, len(values) // 2)
 
 
 class ModbusRtuProtocolCommand(ProtocolCommand):

{goodwe-0.4.4 → goodwe-0.4.6}/goodwe/sensor.py

@@ -364,7 +364,7 @@ class Decimal(Sensor):
         return read_decimal2(data, self.scale)
 
     def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
-        return int.to_bytes(int(value * self.scale), length=2, byteorder="big", signed=True)
+        return int.to_bytes(int(float(value) * self.scale), length=2, byteorder="big", signed=True)
 
 
 class Float(Sensor):
@@ -868,7 +868,7 @@ def read_voltage(buffer: ProtocolResponse, offset: int = None) -> float:
 
 def encode_voltage(value: Any) -> bytes:
     """Encode voltage value to raw (2 unsigned bytes) payload"""
-    return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=False)
+    return int.to_bytes(int(float(value) * 10), length=2, byteorder="big", signed=False)
 
 
 def read_current(buffer: ProtocolResponse, offset: int = None) -> float:
@@ -889,12 +889,12 @@ def read_current_signed(buffer: ProtocolResponse, offset: int = None) -> float:
 
 def encode_current(value: Any) -> bytes:
     """Encode current value to raw (2 unsigned bytes) payload"""
-    return int.to_bytes(int(value * 10), length=2, byteorder="big", signed=False)
+    return int.to_bytes(int(float(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)
+    return int.to_bytes(int(float(value) * 10), length=2, byteorder="big", signed=True)
 
 
 def read_freq(buffer: ProtocolResponse, offset: int = None) -> float:

{goodwe-0.4.4 → goodwe-0.4.6/goodwe.egg-info}/PKG-INFO

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

{goodwe-0.4.4 → goodwe-0.4.6}/tests/test_dt.py

@@ -101,7 +101,7 @@ class GW6000_DT_Test(DtMock):
         self.assertFalse(self.sensor_map, f"Some sensors were not tested {self.sensor_map}")
 
     def test_GW6000_DT_setting(self):
-        self.assertEqual(4, len(self.settings()))
+        self.assertEqual(8, len(self.settings()))
         settings = {s.id_: s for s in self.settings()}
         self.assertEqual('Timestamp', type(settings.get("time")).__name__)
         self.assertEqual('Integer', type(settings.get("grid_export")).__name__)
@@ -416,3 +416,66 @@ class GW20KAU_DT_Test(DtMock):
         self.assertSensor('vnbus', 298.9, 'V', data)
         self.assertSensor('derating_mode', 4, '', data)
         self.assertSensor('derating_mode_label', 'Reactive power derating(PF/QU/FixQ)', '', data)
+
+
+class GW17K_DT_Test(DtMock):
+
+    def __init__(self, methodName='runTest'):
+        DtMock.__init__(self, methodName)
+        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW17K-DT_running_data.hex')
+        self.mock_response(self._READ_DEVICE_VERSION_INFO, 'GW17K-DT_device_info.hex')
+
+    def test_GW20KAU_DT_device_info(self):
+        self.loop.run_until_complete(self.read_device_info())
+        self.assertEqual('GW17KT-DT', self.model_name)
+        self.assertEqual('5017KDTT00BW0000', self.serial_number)
+        self.assertEqual(12, self.dsp1_version)
+        self.assertEqual(12, self.dsp2_version)
+        self.assertEqual(13, self.arm_version)
+        self.assertEqual('12.12.0d', self.firmware)
+
+    def test_GW20KAU_DT_runtime_data(self):
+        self.loop.run_until_complete(self.read_device_info())
+        data = self.loop.run_until_complete(self.read_runtime_data())
+        self.assertEqual(40, len(data))
+
+        self.assertSensor('timestamp', datetime.strptime('2024-05-20 10:35:55', '%Y-%m-%d %H:%M:%S'), '', data)
+        self.assertSensor('vpv1', 540.0, 'V', data)
+        self.assertSensor('ipv1', 10.5, 'A', data)
+        self.assertSensor('ppv1', 5670, 'W', data)
+        self.assertSensor('vpv2', 475.5, 'V', data)
+        self.assertSensor('ipv2', 14.8, 'A', data)
+        self.assertSensor('ppv2', 7037, 'W', data)
+        self.assertSensor('vline1', 413.0, 'V', data)
+        self.assertSensor('vline2', 411.5, 'V', data)
+        self.assertSensor('vline3', 409.5, 'V', data)
+        self.assertSensor('vgrid1', 236.7, 'V', data)
+        self.assertSensor('vgrid2', 238.3, 'V', data)
+        self.assertSensor('vgrid3', 237.3, 'V', data)
+        self.assertSensor('igrid1', 17.6, 'A', data)
+        self.assertSensor('igrid2', 17.5, 'A', data)
+        self.assertSensor('igrid3', 17.5, 'A', data)
+        self.assertSensor('fgrid1', 50.02, 'Hz', data)
+        self.assertSensor('fgrid2', 50.02, 'Hz', data)
+        self.assertSensor('fgrid3', 50.02, 'Hz', data)
+        self.assertSensor('pgrid1', 4166, 'W', data)
+        self.assertSensor('pgrid2', 4170, 'W', data)
+        self.assertSensor('pgrid3', 4153, 'W', data)
+        self.assertSensor('ppv', 12470, 'W', data)
+        self.assertSensor('work_mode', 1, '', data)
+        self.assertSensor('work_mode_label', 'Normal', '', data)
+        self.assertSensor('error_codes', 0, '', data)
+        self.assertSensor('warning_code', 0, '', data)
+        self.assertSensor('apparent_power', 0, 'VA', data)
+        self.assertSensor('reactive_power', 0, 'var', data)
+        self.assertSensor('temperature', 45.7, 'C', data)
+        self.assertSensor('e_day', 29.3, 'kWh', data)
+        self.assertSensor('e_total', 29984.4, 'kWh', data)
+        self.assertSensor('h_total', 8357, 'h', data)
+        self.assertSensor('safety_country', 1, '', data)
+        self.assertSensor('safety_country_label', 'CZ-A1', '', data)
+        self.assertSensor('funbit', 546, '', data)
+        self.assertSensor('vbus', 621.8, 'V', data)
+        self.assertSensor('vnbus', 314.2, 'V', data)
+        self.assertSensor('derating_mode', 4, '', data)
+        self.assertSensor('derating_mode_label', 'Reactive power derating(PF/QU/FixQ)', '', data)

{goodwe-0.4.4 → goodwe-0.4.6}/tests/test_et.py

@@ -240,7 +240,7 @@ class GW10K_ET_Test(EtMock):
         self.assertFalse(self.sensor_map, f"Some sensors were not tested {self.sensor_map}")
 
     def test_GW10K_ET_setting(self):
-        self.assertEqual(65, len(self.settings()))
+        self.assertEqual(66, len(self.settings()))
         settings = {s.id_: s for s in self.settings()}
         self.assertEqual('Timestamp', type(settings.get("time")).__name__)
         self.assertEqual('EcoModeV1', type(settings.get("eco_mode_1")).__name__)
@@ -338,7 +338,7 @@ class GW10K_ET_fw819_Test(EtMock):
         self.assertEqual('02041-19-S00', self.arm_firmware)
 
     def test_GW10K_ET_settings_fw819(self):
-        self.assertEqual(72, len(self.settings()))
+        self.assertEqual(73, len(self.settings()))
         settings = {s.id_: s for s in self.settings()}
         self.assertEqual('EcoModeV2', type(settings.get("eco_mode_1")).__name__)
         self.assertEqual(None, settings.get("peak_shaving_mode"))
@@ -379,7 +379,7 @@ class GW10K_ET_fw1023_Test(EtMock):
         self.assertEqual('02041-23-S00', self.arm_firmware)
 
     def test_GW10K_ET_setting_fw1023(self):
-        self.assertEqual(80, len(self.settings()))
+        self.assertEqual(81, len(self.settings()))
         settings = {s.id_: s for s in self.settings()}
         self.assertEqual('PeakShavingMode', type(settings.get("peak_shaving_mode")).__name__)
 

{goodwe-0.4.4 → goodwe-0.4.6}/tests/test_sensor.py

@@ -30,6 +30,7 @@ class TestUtils(TestCase):
         self.assertEqual(32, testee.read(data))
 
         self.assertEqual("2039", testee.encode_value(32, bytes.fromhex("3039")).hex())
+        self.assertEqual("2039", testee.encode_value("32", bytes.fromhex("3039")).hex())
         self.assertEqual("ff39", testee.encode_value(-1, bytes.fromhex("3039")).hex())
         self.assertEqual("7f39", testee.encode_value(127, bytes.fromhex("3039")).hex())
         self.assertEqual("20ff", testee.encode_value(32, bytes.fromhex("ffff")).hex())
@@ -41,6 +42,7 @@ class TestUtils(TestCase):
         self.assertEqual(127, testee.read(data))
 
         self.assertEqual("3020", testee.encode_value(32, bytes.fromhex("3039")).hex())
+        self.assertEqual("3020", testee.encode_value("32", bytes.fromhex("3039")).hex())
         self.assertEqual("30ff", testee.encode_value(-1, bytes.fromhex("3039")).hex())
         self.assertEqual("307f", testee.encode_value(127, bytes.fromhex("3039")).hex())
         self.assertEqual("ff20", testee.encode_value(32, bytes.fromhex("ffff")).hex())
@@ -51,10 +53,12 @@ class TestUtils(TestCase):
         data = MockResponse("0031")
         self.assertEqual(49, testee.read(data))
         self.assertEqual("0031", testee.encode_value(49).hex())
+        self.assertEqual("0031", testee.encode_value("49").hex())
 
         data = MockResponse("ff9e")
         self.assertEqual(65438, testee.read(data))
         self.assertEqual("ff9e", testee.encode_value(65438).hex())
+        self.assertEqual("ff9e", testee.encode_value("65438").hex())
 
     def test_integer_signed(self):
         testee = IntegerS("", 0, "", "", None)
@@ -62,10 +66,12 @@ class TestUtils(TestCase):
         data = MockResponse("0031")
         self.assertEqual(49, testee.read(data))
         self.assertEqual("0031", testee.encode_value(49).hex())
+        self.assertEqual("0031", testee.encode_value("49").hex())
 
         data = MockResponse("ff9e")
         self.assertEqual(-98, testee.read(data))
         self.assertEqual("ff9e", testee.encode_value(-98).hex())
+        self.assertEqual("ff9e", testee.encode_value("-98").hex())
 
     def test_decimal(self):
         testee = Decimal("", 0, 10, "", "", None)
@@ -73,10 +79,12 @@ class TestUtils(TestCase):
         data = MockResponse("0031")
         self.assertEqual(4.9, testee.read(data))
         self.assertEqual("0031", testee.encode_value(4.9).hex())
+        self.assertEqual("0031", testee.encode_value("4.9").hex())
 
         data = MockResponse("ff9e")
         self.assertEqual(-9.8, testee.read(data))
         self.assertEqual("ff9e", testee.encode_value(-9.8).hex())
+        self.assertEqual("ff9e", testee.encode_value("-9.8").hex())
 
     def test_voltage(self):
         testee = Voltage("", 0, "", None)
@@ -84,10 +92,12 @@ class TestUtils(TestCase):
         data = MockResponse("0cfe")
         self.assertEqual(332.6, testee.read(data))
         self.assertEqual("0cfe", testee.encode_value(332.6).hex())
+        self.assertEqual("0cfe", testee.encode_value("332.6").hex())
 
         data = MockResponse("1f64")
         self.assertEqual(803.6, testee.read(data))
         self.assertEqual("1f64", testee.encode_value(803.6).hex())
+        self.assertEqual("1f64", testee.encode_value("803.6").hex())
 
         data = MockResponse("a000")
         self.assertEqual(4096.0, testee.read(data))
@@ -101,10 +111,12 @@ class TestUtils(TestCase):
         data = MockResponse("0031")
         self.assertEqual(4.9, testee.read(data))
         self.assertEqual("0031", testee.encode_value(4.9).hex())
+        self.assertEqual("0031", testee.encode_value("4.9").hex())
 
         data = MockResponse("ff9e")
         self.assertEqual(6543.8, testee.read(data))
         self.assertEqual("ff9e", testee.encode_value(6543.8).hex())
+        self.assertEqual("ff9e", testee.encode_value("6543.8").hex())
 
         data = MockResponse("ffff")
         self.assertEqual(0, testee.read(data))
@@ -115,10 +127,12 @@ class TestUtils(TestCase):
         data = MockResponse("0031")
         self.assertEqual(4.9, testee.read(data))
         self.assertEqual("0031", testee.encode_value(4.9).hex())
+        self.assertEqual("0031", testee.encode_value("4.9").hex())
 
         data = MockResponse("ff9e")
         self.assertEqual(-9.8, testee.read(data))
         self.assertEqual("ff9e", testee.encode_value(-9.8).hex())
+        self.assertEqual("ff9e", testee.encode_value("-9.8").hex())
 
     def test_power4(self):
         testee = Power4("", 0, "", None)

goodwe-0.4.4/VERSION

@@ -1 +0,0 @@
-0.4.4