goodwe 0.4.7__tar.gz → 0.4.8__tar.gz

{goodwe-0.4.7/goodwe.egg-info → goodwe-0.4.8}/PKG-INFO

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

goodwe-0.4.8/VERSION

@@ -0,0 +1 @@
+0.4.8

{goodwe-0.4.7 → goodwe-0.4.8}/goodwe/dt.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Tuple
 
-from .exceptions import InverterError, RequestRejectedException
+from .exceptions import InverterError, RequestFailedException, RequestRejectedException
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
@@ -69,7 +69,7 @@ class DT(Inverter):
                    lambda data: round(read_voltage(data, 30120) * read_current(data, 30123)),
                    "On-grid L3 Power", "W", Kind.AC),
         # 30127 reserved
-        PowerS("active_power", 30128, "Active Power", Kind.AC),
+        PowerS("total_inverter_power", 30128, "Total Power", Kind.AC),
         Integer("work_mode", 30129, "Work Mode code"),
         Enum2("work_mode_label", 30129, WORK_MODES, "Work Mode"),
         Long("error_codes", 30130, "Error Codes"),
@@ -78,7 +78,7 @@ class DT(Inverter):
         Reactive4("reactive_power", 30135, "Reactive Power", Kind.AC),
         # 30137 reserved
         # 30138 reserved
-        # 30139 reserved
+        Decimal("power_factor", 30139, 1000, "Power Factor", "", Kind.GRID),
         # 30140 reserved
         Temp("temperature", 30141, "Inverter Temperature", Kind.AC),
         # 30142 reserved
@@ -113,6 +113,12 @@ class DT(Inverter):
         # 30172 reserved
     )
 
+    # Inverter's meter data
+    # Modbus registers from offset 0x75f4 (30196)
+    __all_sensors_meter: Tuple[Sensor, ...] = (
+        PowerS("active_power", 30196, "Active Power", Kind.GRID),
+    )
+
     # Modbus registers of inverter settings, offsets are modbus register addresses
     __all_settings: Tuple[Sensor, ...] = (
         Timestamp("time", 40313, "Inverter time"),
@@ -139,9 +145,12 @@ class DT(Inverter):
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
         super().__init__(host, port, comm_addr if comm_addr else 0x7f, timeout, retries)
         self._READ_DEVICE_VERSION_INFO: ProtocolCommand = self._read_command(0x7531, 0x0028)
-        self._READ_DEVICE_RUNNING_DATA: ProtocolCommand = self._read_command(0x7594, 0x0049)
+        self._READ_RUNNING_DATA: ProtocolCommand = self._read_command(0x7594, 0x0049)
+        self._READ_METER_DATA: ProtocolCommand = self._read_command(0x75f4, 0x01)
         self._sensors = self.__all_sensors
+        self._sensors_meter = self.__all_sensors_meter
         self._settings: dict[str, Sensor] = {s.id_: s for s in self.__all_settings}
+        self._has_meter: bool = True
 
     @staticmethod
     def _single_phase_only(s: Sensor) -> bool:
@@ -160,10 +169,13 @@ class DT(Inverter):
             self.model_name = response[22:32].decode("ascii").rstrip()
         except:
             print("No model name sent from the inverter.")
-        self.serial_number = self._decode(response[6:22])
-        self.dsp1_version = read_unsigned_int(response, 66)
-        self.dsp2_version = read_unsigned_int(response, 68)
-        self.arm_version = read_unsigned_int(response, 70)
+        # Modbus registers from 30001 - 30040
+        self.serial_number = self._decode(response[6:22])  # 30004 - 30012
+        self.dsp1_version = read_unsigned_int(response, 66)  # 30034
+        self.dsp2_version = read_unsigned_int(response, 68)  # 30035
+        self.arm_version = read_unsigned_int(response, 70)  # 30036
+        self.dsp_svn_version = read_unsigned_int(response, 72)  # 35037
+        self.arm_svn_version = read_unsigned_int(response, 74)  # 35038
         self.firmware = "{}.{}.{:02x}".format(self.dsp1_version, self.dsp2_version, self.arm_version)
 
         if is_single_phase(self):
@@ -182,8 +194,17 @@ class DT(Inverter):
         pass
 
     async def read_runtime_data(self) -> Dict[str, Any]:
-        response = await self._read_from_socket(self._READ_DEVICE_RUNNING_DATA)
+        response = await self._read_from_socket(self._READ_RUNNING_DATA)
         data = self._map_response(response, self._sensors)
+
+        if self._has_meter:
+            try:
+                response = await self._read_from_socket(self._READ_METER_DATA)
+                data.update(self._map_response(response, self._sensors_meter))
+            except (RequestRejectedException, RequestFailedException):
+                logger.info("Meter values not supported, disabling further attempts.")
+                self._has_meter = False
+
         return data
 
     async def read_setting(self, setting_id: str) -> Any:
@@ -263,7 +284,10 @@ class DT(Inverter):
         raise InverterError("Operation not supported, inverter has no batteries.")
 
     def sensors(self) -> Tuple[Sensor, ...]:
-        return self._sensors
+        result = self._sensors
+        if self._has_meter:
+            result = result + self._sensors_meter
+        return result
 
     def settings(self) -> Tuple[Sensor, ...]:
         return tuple(self._settings.values())

{goodwe-0.4.7 → goodwe-0.4.8}/goodwe/protocol.py

@@ -37,7 +37,7 @@ class InverterProtocol:
         self._timer: asyncio.TimerHandle | None = None
         self.timeout: int = timeout
         self.retries: int = retries
-        self.keep_alive: bool = True
+        self.keep_alive: bool = False
         self.protocol: asyncio.Protocol | None = None
         self.response_future: Future | None = None
         self.command: ProtocolCommand | None = None
@@ -62,6 +62,24 @@ class InverterProtocol:
             self._close_transport()
             return self._lock
 
+    def _max_retries_reached(self) -> Future:
+        logger.debug("Max number of retries (%d) reached, request %s failed.", self.retries, self.command)
+        self._close_transport()
+        self.response_future = asyncio.get_running_loop().create_future()
+        self.response_future.set_exception(MaxRetriesException)
+        return self.response_future
+
+    def _close_transport(self) -> None:
+        if self._transport:
+            try:
+                self._transport.close()
+            except RuntimeError:
+                logger.debug("Failed to close transport.")
+            self._transport = None
+        # Cancel Future on connection lost
+        if self.response_future and not self.response_future.done():
+            self.response_future.cancel()
+
     async def close(self) -> None:
         """Close the underlying transport/connection."""
         raise NotImplementedError()
@@ -133,15 +151,16 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
                 self._partial_missing = 0
             if self.command.validator(data):
                 logger.debug("Received: %s", data.hex())
+                self._retry = 0
                 self.response_future.set_result(data)
             else:
                 logger.debug("Received invalid response: %s", data.hex())
-                asyncio.get_running_loop().call_soon(self._retry_mechanism)
+                asyncio.get_running_loop().call_soon(self._timeout_mechanism)
         except PartialResponseException as ex:
             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)
+            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:
@@ -158,13 +177,28 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
 
     async def send_request(self, command: ProtocolCommand) -> Future:
         """Send message via transport"""
-        async with self._ensure_lock():
+        await self._ensure_lock().acquire()
+        try:
             await self._connect()
             response_future = asyncio.get_running_loop().create_future()
-            self._retry = 0
             self._send_request(command, response_future)
             await response_future
             return response_future
+        except asyncio.CancelledError:
+            if self._retry < self.retries:
+                self._retry += 1
+                if self._lock and self._lock.locked():
+                    self._lock.release()
+                if not self.keep_alive:
+                    self._close_transport()
+                return await self.send_request(command)
+            else:
+                return self._max_retries_reached()
+        finally:
+            if self._lock and self._lock.locked():
+                self._lock.release()
+            if not self.keep_alive:
+                self._close_transport()
 
     def _send_request(self, command: ProtocolCommand, response_future: Future) -> None:
         """Send message via transport"""
@@ -178,32 +212,19 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
         else:
             logger.debug("Sending: %s", self.command)
         self._transport.sendto(payload)
-        self._timer = asyncio.get_running_loop().call_later(self.timeout, self._retry_mechanism)
+        self._timer = asyncio.get_running_loop().call_later(self.timeout, self._timeout_mechanism)
 
-    def _retry_mechanism(self) -> None:
-        """Retry mechanism to prevent hanging transport"""
-        if self.response_future.done():
+    def _timeout_mechanism(self) -> None:
+        """Timeout mechanism to prevent hanging transport"""
+        if self.response_future and self.response_future.done():
             logger.debug("Response already received.")
-        elif self._retry < self.retries:
+            self._retry = 0
+        else:
             if self._timer:
                 logger.debug("Failed to receive response to %s in time (%ds).", self.command, self.timeout)
-            self._retry += 1
-            self._send_request(self.command, self.response_future)
-        else:
-            logger.debug("Max number of retries (%d) reached, request %s failed.", self.retries, self.command)
-            self.response_future.set_exception(MaxRetriesException)
-            self._close_transport()
-
-    def _close_transport(self) -> None:
-        if self._transport:
-            try:
-                self._transport.close()
-            except RuntimeError:
-                logger.debug("Failed to close transport.")
-            self._transport = None
-        # Cancel Future on connection close
-        if self.response_future and not self.response_future.done():
-            self.response_future.cancel()
+                self._timer = None
+            if self.response_future and not self.response_future.done():
+                self.response_future.cancel()
 
     async def close(self):
         self._close_transport()
@@ -358,24 +379,6 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 self._timer = None
             self._close_transport()
 
-    def _max_retries_reached(self) -> Future:
-        logger.debug("Max number of retries (%d) reached, request %s failed.", self.retries, self.command)
-        self._close_transport()
-        self.response_future = asyncio.get_running_loop().create_future()
-        self.response_future.set_exception(MaxRetriesException)
-        return self.response_future
-
-    def _close_transport(self) -> None:
-        if self._transport:
-            try:
-                self._transport.close()
-            except RuntimeError:
-                logger.debug("Failed to close transport.")
-            self._transport = None
-        # Cancel Future on connection lost
-        if self.response_future and not self.response_future.done():
-            self.response_future.cancel()
-
     async def close(self):
         await self._ensure_lock().acquire()
         try:

{goodwe-0.4.7 → goodwe-0.4.8/goodwe.egg-info}/PKG-INFO

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

{goodwe-0.4.7 → goodwe-0.4.8}/tests/test_dt.py

@@ -4,7 +4,8 @@ from datetime import datetime
 from unittest import TestCase
 
 from goodwe.dt import DT
-from goodwe.exceptions import RequestFailedException
+from goodwe.exceptions import RequestFailedException, RequestRejectedException
+from goodwe.modbus import ILLEGAL_DATA_ADDRESS
 from goodwe.protocol import ProtocolCommand, ProtocolResponse
 
 
@@ -13,7 +14,7 @@ class DtMock(TestCase, DT):
     def __init__(self, methodName='runTest', port=8899):
         TestCase.__init__(self, methodName)
         DT.__init__(self, "localhost", port)
-        self.sensor_map = {s.id_: s.unit for s in self.sensors()}
+        self.sensor_map = {s.id_: s for s in self.sensors()}
         self._mock_responses = {}
 
     def mock_response(self, command: ProtocolCommand, filename: str):
@@ -24,6 +25,10 @@ class DtMock(TestCase, DT):
         root_dir = os.path.dirname(os.path.abspath(__file__))
         filename = self._mock_responses.get(command)
         if filename is not None:
+            if ILLEGAL_DATA_ADDRESS == filename:
+                raise RequestRejectedException(ILLEGAL_DATA_ADDRESS)
+            if 'NO RESPONSE' == filename:
+                raise RequestFailedException()
             with open(root_dir + '/sample/dt/' + filename, 'r') as f:
                 response = bytes.fromhex(f.read())
                 if not command.validator(response):
@@ -33,10 +38,11 @@ class DtMock(TestCase, DT):
             self.request = command.request
             return ProtocolResponse(bytes.fromhex("aa557f00010203040506070809"), command)
 
-    def assertSensor(self, sensor, expected_value, expected_unit, data):
-        self.assertEqual(expected_value, data.get(sensor))
-        self.assertEqual(expected_unit, self.sensor_map.get(sensor))
-        self.sensor_map.pop(sensor)
+    def assertSensor(self, sensor_name, expected_value, expected_unit, data):
+        self.assertEqual(expected_value, data.get(sensor_name))
+        sensor = self.sensor_map.get(sensor_name);
+        self.assertEqual(expected_unit, sensor.unit)
+        self.sensor_map.pop(sensor_name)
 
     @classmethod
     def setUpClass(cls):
@@ -47,12 +53,15 @@ class GW6000_DT_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW6000-DT_running_data.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW6000-DT_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW6000_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(41, len(data))
+        self.assertEqual(42, len(data))
+
+        self.sensor_map = {s.id_: s for s in self.sensors()}
 
         self.assertSensor('timestamp', datetime.strptime('2021-08-31 12:03:02', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 320.8, 'V', data)
@@ -61,9 +70,6 @@ class GW6000_DT_Test(DtMock):
         self.assertSensor('vpv2', 324.1, 'V', data)
         self.assertSensor('ipv2', 3.2, 'A', data)
         self.assertSensor('ppv2', 1037, 'W', data)
-        self.assertSensor('vpv3', None, 'V', data)
-        self.assertSensor('ipv3', None, 'A', data)
-        self.assertSensor('ppv3', None, 'W', data)
         self.assertSensor('ppv', 2031, 'W', data)
         self.assertSensor('vline1', 0, 'V', data)
         self.assertSensor('vline2', 0, 'V', data)
@@ -80,13 +86,14 @@ class GW6000_DT_Test(DtMock):
         self.assertSensor('pgrid1', 609, 'W', data)
         self.assertSensor('pgrid2', 597, 'W', data)
         self.assertSensor('pgrid3', 624, 'W', data)
-        self.assertSensor('active_power', 1835, 'W', data)
+        self.assertSensor('total_inverter_power', 1835, '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", -1, "VA", data),
         self.assertSensor("reactive_power", -1, "var", data),
+        self.assertSensor("power_factor", 0.0, "", data),
         self.assertSensor('temperature', 41.3, 'C', data)
         self.assertSensor('e_day', 6.0, 'kWh', data)
         self.assertSensor('e_total', 13350.2, 'kWh', data)
@@ -121,8 +128,9 @@ class GW8K_DT_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW8K-DT_running_data.hex')
         self.mock_response(self._READ_DEVICE_VERSION_INFO, 'GW8K-DT_device_info.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW8K-DT_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW8K_DT_device_info(self):
         self.loop.run_until_complete(self.read_device_info())
@@ -130,13 +138,15 @@ class GW8K_DT_Test(DtMock):
         self.assertEqual('00000DTS00000000', self.serial_number)
         self.assertEqual(1010, self.dsp1_version)
         self.assertEqual(1010, self.dsp2_version)
+        self.assertEqual(728, self.dsp_svn_version)
         self.assertEqual(8, self.arm_version)
+        self.assertEqual(49, self.arm_svn_version)
         self.assertEqual('1010.1010.08', self.firmware)
 
     def test_GW8K_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(41, len(data))
+        self.assertEqual(42, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2021-08-24 16:43:27', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 275.5, 'V', data)
@@ -161,13 +171,14 @@ class GW8K_DT_Test(DtMock):
         self.assertSensor('pgrid1', 237, 'W', data)
         self.assertSensor('pgrid2', 240, 'W', data)
         self.assertSensor('pgrid3', 235, 'W', data)
-        self.assertSensor('active_power', 643, 'W', data)
+        self.assertSensor('total_inverter_power', 643, '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("power_factor", 0.0, "", data),
         self.assertSensor('temperature', 45.3, 'C', data)
         self.assertSensor('e_day', None, 'kWh', data)
         self.assertSensor('e_total', None, 'kWh', data)
@@ -195,13 +206,14 @@ class GW5000D_NS_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW5000D-NS_running_data.hex')
         self.mock_response(self._READ_DEVICE_VERSION_INFO, 'Mock_device_info.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW5000D-NS_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW5000D_NS_runtime_data(self):
         self.loop.run_until_complete(self.read_device_info())
         data = self.loop.run_until_complete(self.read_runtime_data())
-        self.assertEqual(31, len(data))
+        self.assertEqual(32, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2021-09-06 06:56:01', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 224.4, 'V', data)
@@ -216,13 +228,14 @@ class GW5000D_NS_Test(DtMock):
         self.assertSensor('igrid1', 0.0, 'A', data)
         self.assertSensor('fgrid1', 49.97, 'Hz', data)
         self.assertSensor('pgrid1', 0, 'W', data)
-        self.assertSensor('active_power', 0, 'W', data)
+        self.assertSensor('total_inverter_power', 0, 'W', data)
         self.assertSensor('work_mode', 0, '', data)
         self.assertSensor('work_mode_label', 'Wait Mode', '', data)
         self.assertSensor('error_codes', 0, '', data)
         self.assertSensor('warning_code', 0, '', data)
         self.assertSensor("apparent_power", -1, "VA", data),
         self.assertSensor("reactive_power", -1, "var", data),
+        self.assertSensor("power_factor", -0.001, "", data),
         self.assertSensor('temperature', 1.4, 'C', data)
         self.assertSensor('e_day', 0, 'kWh', data)
         self.assertSensor('e_total', 881.7, 'kWh', data)
@@ -250,8 +263,9 @@ class GW5000_MS_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW5000-MS_running_data.hex')
         self.mock_response(self._READ_DEVICE_VERSION_INFO, 'GW5000-MS_device_info.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW5000-MS_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW6000_MS_device_info(self):
         self.loop.run_until_complete(self.read_device_info())
@@ -259,13 +273,15 @@ class GW5000_MS_Test(DtMock):
         self.assertEqual('00000MSU00000000', self.serial_number)
         self.assertEqual(12, self.dsp1_version)
         self.assertEqual(12, self.dsp2_version)
+        self.assertEqual(65535, self.dsp_svn_version)
         self.assertEqual(16, self.arm_version)
+        self.assertEqual(271, self.arm_svn_version)
         self.assertEqual('12.12.10', self.firmware)
 
     def test_GW5000_MS_runtime_data(self):
         self.loop.run_until_complete(self.read_device_info())
         data = self.loop.run_until_complete(self.read_runtime_data())
-        self.assertEqual(34, len(data))
+        self.assertEqual(35, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2021-10-15 09:03:12', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 319.6, 'V', data)
@@ -283,13 +299,14 @@ class GW5000_MS_Test(DtMock):
         self.assertSensor('igrid1', 0.9, 'A', data)
         self.assertSensor('fgrid1', 49.98, 'Hz', data)
         self.assertSensor('pgrid1', 216, 'W', data)
-        self.assertSensor('active_power', 295, 'W', data)
+        self.assertSensor('total_inverter_power', 295, '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", -1, "VA", data),
         self.assertSensor("reactive_power", -1, "var", data),
+        self.assertSensor("power_factor", -0.001, "", data),
         self.assertSensor('temperature', 10.7, 'C', data)
         self.assertSensor('e_day', 0.4, 'kWh', data)
         self.assertSensor('e_total', 6.8, 'kWh', data)
@@ -308,7 +325,8 @@ class GW10K_MS_30_Test(DtMock):
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
         self.mock_response(self._READ_DEVICE_VERSION_INFO, 'GW10K-MS-30_device_info.hex')
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW10K-MS-30_running_data.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW10K-MS-30_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW10K_MS_30_device_info(self):
         self.loop.run_until_complete(self.read_device_info())
@@ -316,13 +334,15 @@ class GW10K_MS_30_Test(DtMock):
         self.assertEqual('5010KMSC000W0000', self.serial_number)
         self.assertEqual(0, self.dsp1_version)
         self.assertEqual(0, self.dsp2_version)
+        self.assertEqual(504, self.dsp_svn_version)
         self.assertEqual(2, self.arm_version)
+        self.assertEqual(13, self.arm_svn_version)
         self.assertEqual('0.0.02', self.firmware)
 
     def test_GW10K_MS_30_runtime_data(self):
         self.loop.run_until_complete(self.read_device_info())
         data = self.loop.run_until_complete(self.read_runtime_data())
-        self.assertEqual(34, len(data))
+        self.assertEqual(35, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2024-01-09 22:08:20', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 0.0, 'V', data)
@@ -340,13 +360,14 @@ class GW10K_MS_30_Test(DtMock):
         self.assertSensor('igrid1', 0.0, 'A', data)
         self.assertSensor('fgrid1', 50.0, 'Hz', data)
         self.assertSensor('pgrid1', 0, 'W', data)
-        self.assertSensor('active_power', 0, 'W', data)
+        self.assertSensor('total_inverter_power', 0, 'W', data)
         self.assertSensor('work_mode', 0, '', data)
         self.assertSensor('work_mode_label', 'Wait Mode', '', 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("power_factor", 0.0, "", data),
         self.assertSensor('temperature', 24.3, 'C', data)
         self.assertSensor('e_day', 71.8, 'kWh', data)
         self.assertSensor('e_total', 3433.4, 'kWh', data)
@@ -364,12 +385,13 @@ class GW10K_MS_TCP_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName, 502)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW10K-MS-30_tcp_running_data.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW10K-MS-30_tcp_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW10K_MS_TCP_runtime_data(self):
         self.loop.run_until_complete(self.read_device_info())
         data = self.loop.run_until_complete(self.read_runtime_data())
-        self.assertEqual(41, len(data))
+        self.assertEqual(42, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2024-06-02 09:07:17', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 400.6, 'V', data)
@@ -394,13 +416,14 @@ class GW10K_MS_TCP_Test(DtMock):
         self.assertSensor('pgrid1', 5955, 'W', data)
         self.assertSensor('pgrid2', 0, 'W', data)
         self.assertSensor('pgrid3', 0, 'W', data)
-        self.assertSensor('active_power', 5914, 'W', data)
+        self.assertSensor('total_inverter_power', 5914, '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', 5957, 'VA', data)
         self.assertSensor('reactive_power', -6, 'var', data)
+        self.assertSensor("power_factor", 0.999, "", data),
         self.assertSensor('temperature', 36.0, 'C', data)
         self.assertSensor('e_day', 4.3, 'kWh', data)
         self.assertSensor('e_total', 998.2, 'kWh', data)
@@ -418,8 +441,9 @@ class GW20KAU_DT_Test(DtMock):
 
     def __init__(self, methodName='runTest'):
         DtMock.__init__(self, methodName)
-        self.mock_response(self._READ_DEVICE_RUNNING_DATA, 'GW20KAU-DT_running_data.hex')
         self.mock_response(self._READ_DEVICE_VERSION_INFO, 'GW20KAU-DT_device_info.hex')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW20KAU-DT_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW20KAU_DT_device_info(self):
         self.loop.run_until_complete(self.read_device_info())
@@ -427,13 +451,15 @@ class GW20KAU_DT_Test(DtMock):
         self.assertEqual('0000KDTA00000000', self.serial_number)
         self.assertEqual(15, self.dsp1_version)
         self.assertEqual(15, self.dsp2_version)
+        self.assertEqual(1099, self.dsp_svn_version)
         self.assertEqual(16, self.arm_version)
+        self.assertEqual(187, self.arm_svn_version)
         self.assertEqual('15.15.10', 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(41, len(data))
+        self.assertEqual(42, len(data))
 
         self.assertSensor('timestamp', datetime.strptime('2022-10-21 19:23:42', '%Y-%m-%d %H:%M:%S'), '', data)
         self.assertSensor('vpv1', 390.5, 'V', data)
@@ -458,13 +484,14 @@ class GW20KAU_DT_Test(DtMock):
         self.assertSensor('pgrid1', 1628, 'W', data)
         self.assertSensor('pgrid2', 1655, 'W', data)
         self.assertSensor('pgrid3', 1621, 'W', data)
-        self.assertSensor('active_power', 4957, 'W', data)
+        self.assertSensor('total_inverter_power', 4957, '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", 205, "var", data),
+        self.assertSensor("power_factor", 0.999, "", data),
         self.assertSensor('temperature', 36.4, 'C', data)
         self.assertSensor('e_day', 19.8, 'kWh', data)
         self.assertSensor('e_total', 4304.8, 'kWh', data)
@@ -482,8 +509,9 @@ 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')
+        self.mock_response(self._READ_RUNNING_DATA, 'GW17K-DT_running_data.hex')
+        self.mock_response(self._READ_METER_DATA, ILLEGAL_DATA_ADDRESS)
 
     def test_GW20KAU_DT_device_info(self):
         self.loop.run_until_complete(self.read_device_info())
@@ -491,13 +519,15 @@ class GW17K_DT_Test(DtMock):
         self.assertEqual('5017KDTT00BW0000', self.serial_number)
         self.assertEqual(12, self.dsp1_version)
         self.assertEqual(12, self.dsp2_version)
+        self.assertEqual(931, self.dsp_svn_version)
         self.assertEqual(13, self.arm_version)
+        self.assertEqual(130, self.arm_svn_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(41, len(data))
+        self.assertEqual(42, 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)
@@ -522,13 +552,14 @@ class GW17K_DT_Test(DtMock):
         self.assertSensor('pgrid1', 4166, 'W', data)
         self.assertSensor('pgrid2', 4170, 'W', data)
         self.assertSensor('pgrid3', 4153, 'W', data)
-        self.assertSensor('active_power', 12470, 'W', data)
+        self.assertSensor('total_inverter_power', 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("power_factor", 0.0, "", data),
         self.assertSensor('temperature', 45.7, 'C', data)
         self.assertSensor('e_day', 29.3, 'kWh', data)
         self.assertSensor('e_total', 29984.4, 'kWh', data)

{goodwe-0.4.7 → goodwe-0.4.8}/tests/test_protocol.py

@@ -36,14 +36,14 @@ class TestUDPClientProtocol(TestCase):
         mock_loop = mock.Mock()
         mock_get_event_loop.return_value = mock_loop
 
-        mock_retry_mechanism = mock.Mock()
-        self.protocol._retry_mechanism = mock_retry_mechanism
+        mock_timeout_mechanism = mock.Mock()
+        self.protocol._timeout_mechanism = mock_timeout_mechanism
         self.protocol.connection_made(transport)
         self.protocol._send_request(self.protocol.command, self.protocol.response_future)
 
         transport.sendto.assert_called_with(self.protocol.command.request)
         mock_get_event_loop.assert_called()
-        mock_loop.call_later.assert_called_with(1, mock_retry_mechanism)
+        mock_loop.call_later.assert_called_with(1, mock_timeout_mechanism)
 
     def test_connection_lost(self):
         self.protocol.response_future.done.return_value = True
@@ -59,41 +59,41 @@ class TestUDPClientProtocol(TestCase):
         self.protocol._transport = mock.Mock()
         self.protocol._send_request = mock.Mock()
         self.protocol.response_future.done.return_value = True
-        self.protocol._retry_mechanism()
+        self.protocol._timeout_mechanism()
 
         # self.protocol._transport.close.assert_called()
         self.protocol._send_request.assert_not_called()
 
-    @mock.patch('goodwe.protocol.asyncio.get_running_loop')
-    def test_retry_mechanism_two_retries(self, mock_get_event_loop):
-        def call_later(_: int, retry_func: Callable):
-            retry_func()
-
-        mock_loop = mock.Mock()
-        mock_get_event_loop.return_value = mock_loop
-        mock_loop.call_later = call_later
-
-        self.protocol._transport = mock.Mock()
-        self.protocol.response_future.done.side_effect = [False, False, True, False]
-        self.protocol._retry_mechanism()
-
-        # self.protocol._transport.close.assert_called()
-        self.assertEqual(self.protocol._retry, 2)
-
-    @mock.patch('goodwe.protocol.asyncio.get_running_loop')
-    def test_retry_mechanism_max_retries(self, mock_get_event_loop):
-        def call_later(_: int, retry_func: Callable):
-            retry_func()
-
-        mock_loop = mock.Mock()
-        mock_get_event_loop.return_value = mock_loop
-        mock_loop.call_later = call_later
-
-        self.protocol._transport = mock.Mock()
-        self.protocol.response_future.done.side_effect = [False, False, False, False, False]
-        self.protocol._retry_mechanism()
-        self.protocol.response_future.set_exception.assert_called_once_with(MaxRetriesException)
-        self.assertEqual(self.protocol._retry, 3)
+    # @mock.patch('goodwe.protocol.asyncio.get_running_loop')
+    # def test_retry_mechanism_two_retries(self, mock_get_event_loop):
+    #     def call_later(_: int, retry_func: Callable):
+    #         retry_func()
+    #
+    #     mock_loop = mock.Mock()
+    #     mock_get_event_loop.return_value = mock_loop
+    #     mock_loop.call_later = call_later
+    #
+    #     self.protocol._transport = mock.Mock()
+    #     self.protocol.response_future.done.side_effect = [False, False, True, False]
+    #     self.protocol._timeout_mechanism()
+    #
+    #     # self.protocol._transport.close.assert_called()
+    #     self.assertEqual(self.protocol._retry, 2)
+
+    # @mock.patch('goodwe.protocol.asyncio.get_running_loop')
+    # def test_retry_mechanism_max_retries(self, mock_get_event_loop):
+    #     def call_later(_: int, retry_func: Callable):
+    #         retry_func()
+    #
+    #     mock_loop = mock.Mock()
+    #     mock_get_event_loop.return_value = mock_loop
+    #     mock_loop.call_later = call_later
+    #
+    #     self.protocol._transport = mock.Mock()
+    #     self.protocol.response_future.done.side_effect = [False, False, False, False, False]
+    #     self.protocol._timeout_mechanism()
+    #     self.protocol.response_future.set_exception.assert_called_once_with(MaxRetriesException)
+    #     self.assertEqual(self.protocol._retry, 3)
 
     def test_modbus_rtu_read_command(self):
         command = ModbusRtuReadCommand(0xf7, 0x88b8, 0x0021)

goodwe-0.4.7/VERSION

@@ -1 +0,0 @@
-0.4.7