goodwe 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

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
@@ -35,6 +35,12 @@ class DT(Inverter):
         Calculated("ppv3",
                    lambda data: round(read_voltage(data, 30107) * read_current(data, 30108)),
                    "PV3 Power", "W", Kind.PV),
+        # ppv1 + ppv2 + ppv3
+        Calculated("ppv",
+                   lambda data: (round(read_voltage(data, 30103) * read_current(data, 30104))) + (round(
+                       read_voltage(data, 30105) * read_current(data, 30106))) + (round(
+                       read_voltage(data, 30107) * read_current(data, 30108))),
+                   "PV Power", "W", Kind.PV),
         # Voltage("vpv4", 14, "PV4 Voltage", Kind.PV),
         # Current("ipv4", 16, "PV4 Current", Kind.PV),
         # Voltage("vpv5", 14, "PV5 Voltage", Kind.PV),
@@ -63,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
-        Power("ppv", 30128, "PV Power", Kind.PV),
+        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"),
@@ -72,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
@@ -107,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"),
@@ -133,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:
@@ -154,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):
@@ -176,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:
@@ -257,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/et.py

@@ -257,7 +257,8 @@ class ET(Inverter):
         Apparent4("meter_apparent_power_total", 36041, "Meter Apparent Power Total", Kind.GRID),
         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
+
+        # Sensors added in some ARM fw update (or platform 745/753), read when flag _has_meter_extended is on
         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),
@@ -268,6 +269,15 @@ class ET(Inverter):
         Current("meter_current1", 36055, "Meter L1 Current", Kind.GRID),
         Current("meter_current2", 36056, "Meter L2 Current", Kind.GRID),
         Current("meter_current3", 36057, "Meter L3 Current", Kind.GRID),
+
+        Energy8("meter_e_total_exp1", 36092, "Meter Total Energy (export) L1", Kind.GRID),
+        Energy8("meter_e_total_exp2", 36096, "Meter Total Energy (export) L2", Kind.GRID),
+        Energy8("meter_e_total_exp3", 36100, "Meter Total Energy (export) L3", Kind.GRID),
+        Energy8("meter_e_total_exp", 36104, "Meter Total Energy (export)", Kind.GRID),
+        Energy8("meter_e_total_imp1", 36108, "Meter Total Energy (import) L1", Kind.GRID),
+        Energy8("meter_e_total_imp2", 36112, "Meter Total Energy (import) L2", Kind.GRID),
+        Energy8("meter_e_total_imp3", 36116, "Meter Total Energy (import) L3", Kind.GRID),
+        Energy8("meter_e_total_imp", 36120, "Meter Total Energy (import)", Kind.GRID),
     )
 
     # Inverter's MPPT data
@@ -464,6 +474,7 @@ class ET(Inverter):
         self._READ_RUNNING_DATA: ProtocolCommand = self._read_command(0x891c, 0x007d)
         self._READ_METER_DATA: ProtocolCommand = self._read_command(0x8ca0, 0x2d)
         self._READ_METER_DATA_EXTENDED: ProtocolCommand = self._read_command(0x8ca0, 0x3a)
+        self._READ_METER_DATA_EXTENDED2: ProtocolCommand = self._read_command(0x8ca0, 0x7d)
         self._READ_BATTERY_INFO: ProtocolCommand = self._read_command(0x9088, 0x0018)
         self._READ_BATTERY2_INFO: ProtocolCommand = self._read_command(0x9858, 0x0016)
         self._READ_MPPT_DATA: ProtocolCommand = self._read_command(0x89e5, 0x3d)
@@ -472,6 +483,7 @@ class ET(Inverter):
         self._has_battery: bool = True
         self._has_battery2: bool = False
         self._has_meter_extended: bool = False
+        self._has_meter_extended2: bool = False
         self._has_mppt: bool = False
         self._sensors = self.__all_sensors
         self._sensors_battery = self.__all_sensors_battery
@@ -490,6 +502,11 @@ class ET(Inverter):
         """Filter to exclude extended meter sensors"""
         return s.offset < 36045
 
+    @staticmethod
+    def _not_extended_meter2(s: Sensor) -> bool:
+        """Filter to exclude extended meter sensors"""
+        return s.offset < 36058
+
     async def read_device_info(self):
         response = await self._read_from_socket(self._READ_DEVICE_VERSION_INFO)
         response = response.response_data()
@@ -520,9 +537,10 @@ class ET(Inverter):
         if is_2_battery(self) or self.rated_power >= 25000:
             self._has_battery2 = True
 
-        if self.rated_power >= 15000:
+        if is_745_platform(self) or self.rated_power >= 15000:
             self._has_mppt = True
             self._has_meter_extended = True
+            self._has_meter_extended2 = True
         else:
             self._sensors_meter = tuple(filter(self._not_extended_meter, self._sensors_meter))
 
@@ -577,7 +595,21 @@ class ET(Inverter):
                 else:
                     raise ex
 
-        if self._has_meter_extended:
+        if self._has_meter_extended2:
+            try:
+                response = await self._read_from_socket(self._READ_METER_DATA_EXTENDED2)
+                data.update(self._map_response(response, self._sensors_meter))
+            except RequestRejectedException as ex:
+                if ex.message == ILLEGAL_DATA_ADDRESS:
+                    logger.info("Extended meter values not supported, disabling further attempts.")
+                    self._has_meter_extended2 = False
+                    self._sensors_meter = tuple(filter(self._not_extended_meter2, self._sensors_meter))
+                    response = await self._read_from_socket(self._READ_METER_DATA_EXTENDED)
+                    data.update(
+                        self._map_response(response, self._sensors_meter))
+                else:
+                    raise ex
+        elif self._has_meter_extended:
             try:
                 response = await self._read_from_socket(self._READ_METER_DATA_EXTENDED)
                 data.update(self._map_response(response, self._sensors_meter))

goodwe/model.py

@@ -48,3 +48,7 @@ def is_2_battery(inverter: Inverter) -> bool:
 def is_745_platform(inverter: Inverter) -> bool:
     return any(model in inverter.serial_number for model in PLATFORM_745_LV_MODELS) or any(
         model in inverter.serial_number for model in PLATFORM_745_HV_MODELS)
+
+
+def is_753_platform(inverter: Inverter) -> bool:
+    return any(model in inverter.serial_number for model in PLATFORM_753_MODELS)

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/sensor.py

@@ -197,6 +197,17 @@ class Energy4(Sensor):
         return float(value) / 10 if value is not None else None
 
 
+class Energy8(Sensor):
+    """Sensor representing energy [kWh] value encoded in 8 bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 8, "kWh", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        value = read_bytes8(data)
+        return float(value) / 100 if value is not None else None
+
+
 class Apparent(Sensor):
     """Sensor representing apparent power [VA] value encoded in 2 bytes"""
 
@@ -840,6 +851,14 @@ def read_bytes4_signed(buffer: ProtocolResponse, offset: int = None) -> int:
     return int.from_bytes(buffer.read(4), byteorder="big", signed=True)
 
 
+def read_bytes8(buffer: ProtocolResponse, offset: int = None, undef: int = None) -> int:
+    """Retrieve 8 byte (unsigned int) value from buffer"""
+    if offset is not None:
+        buffer.seek(offset)
+    value = int.from_bytes(buffer.read(8), byteorder="big", signed=False)
+    return undef if value == 0xffffffffffffffff else value
+
+
 def read_decimal2(buffer: ProtocolResponse, scale: int, offset: int = None) -> float:
     """Retrieve 2 byte (signed float) value from buffer"""
     if offset is not None:

{goodwe-0.4.6.dist-info → goodwe-0.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goodwe
-Version: 0.4.6
+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.dist-info/RECORD

@@ -0,0 +1,16 @@
+goodwe/__init__.py,sha256=8fFGBBvBpCo6Ew4puTtW0kYo2hVPKUx6z5A-TA4Tbvc,5795
+goodwe/const.py,sha256=yhWk56YV7k7-MbgfmWEMYNlqeRNLOfOpfTqEfRj6Hp8,7934
+goodwe/dt.py,sha256=IJxLDajuu2psYE5ZpwA2HFJDFdK5JIST6kUqWyRVBko,13663
+goodwe/es.py,sha256=vvHmxcFykp8nhR1I8p7SF0YcYpvdCKBYacgcolbVHXI,23009
+goodwe/et.py,sha256=Sdgqj13DXIg36NptkHMKxuP78oo4aUQ_6zlToyt78qI,46002
+goodwe/exceptions.py,sha256=dKMLxotjoR1ic8OVlw1joIJ4mKWD6oFtUMZ86fNM5ZE,1403
+goodwe/inverter.py,sha256=86aMJzJjNOr1I_tCF5H6mBwzDTjLbGDKUL2hbi0XSxg,10459
+goodwe/modbus.py,sha256=Mg_s_v8kbZgqXZM6ZUUxkZx2boAG8LkuDG5OiFKK2X4,8402
+goodwe/model.py,sha256=OAKfw6ggClgLR9JIdNd7tQ4pnh_7o_UqVdm1KOVsm-Y,2200
+goodwe/protocol.py,sha256=2xRo1H53G6T0ANSuYKPK_KTNfCVTctIU2ZHVu-CvMPk,30163
+goodwe/sensor.py,sha256=xeDZIwjJ_176ULrRXVCTYvVXx6o2_pWgS0KuR3PPQdg,38435
+goodwe-0.4.8.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.4.8.dist-info/METADATA,sha256=kla7IF_7dMZl-uEdQnGqMBXOkOyNlKt9Inwmi4BWCWQ,3376
+goodwe-0.4.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+goodwe-0.4.8.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.4.8.dist-info/RECORD,,

goodwe-0.4.6.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=8fFGBBvBpCo6Ew4puTtW0kYo2hVPKUx6z5A-TA4Tbvc,5795
-goodwe/const.py,sha256=yhWk56YV7k7-MbgfmWEMYNlqeRNLOfOpfTqEfRj6Hp8,7934
-goodwe/dt.py,sha256=8lbc-G1vQUxtYZRDAHi6QW04bFJRW7l4OjBVDp0EjZc,12093
-goodwe/es.py,sha256=vvHmxcFykp8nhR1I8p7SF0YcYpvdCKBYacgcolbVHXI,23009
-goodwe/et.py,sha256=f4XWaV8Ltywlca1GYJCUM46ziQCtKleser34rO09WQg,44053
-goodwe/exceptions.py,sha256=dKMLxotjoR1ic8OVlw1joIJ4mKWD6oFtUMZ86fNM5ZE,1403
-goodwe/inverter.py,sha256=86aMJzJjNOr1I_tCF5H6mBwzDTjLbGDKUL2hbi0XSxg,10459
-goodwe/modbus.py,sha256=Mg_s_v8kbZgqXZM6ZUUxkZx2boAG8LkuDG5OiFKK2X4,8402
-goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
-goodwe/protocol.py,sha256=gnQ1vV4U_lPpaNq5-jmzJO6ngJEDFVo0jWXVujSyu_0,30083
-goodwe/sensor.py,sha256=gns0508zi3dCQ4C01RIUQ8aH-2b8TDpCjW71CFEVEiY,37707
-goodwe-0.4.6.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.4.6.dist-info/METADATA,sha256=jKbTn5rYaHEb6B8TpTYNqhE1F9dDApMFpBiwvJjMoPQ,3376
-goodwe-0.4.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-goodwe-0.4.6.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.4.6.dist-info/RECORD,,