goodwe 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

goodwe/__init__.py

@@ -22,9 +22,6 @@ DT_FAMILY = ["DT", "MS", "NS", "XS"]
 # Initial discovery command
 DISCOVERY_COMMAND = Aa55ProtocolCommand("010200", "0182")
 
-# supported inverter protocols
-_SUPPORTED_PROTOCOLS = [ET, DT, ES]
-
 
 async def connect(host: str, port: int = GOODWE_UDP_PORT, family: str = None, comm_addr: int = 0, timeout: int = 1,
                   retries: int = 3, do_discover: bool = True) -> Inverter:
@@ -41,7 +38,7 @@ async def connect(host: str, port: int = GOODWE_UDP_PORT, family: str = None, co
 
     Raise InverterError if unable to contact or recognise supported inverter.
     """
-    if family in ET_FAMILY or port == GOODWE_TCP_PORT:
+    if family in ET_FAMILY:
         inv = ET(host, port, comm_addr, timeout, retries)
     elif family in ES_FAMILY:
         inv = ES(host, port, comm_addr, timeout, retries)
@@ -65,42 +62,43 @@ async def discover(host: str, port: int = GOODWE_UDP_PORT, timeout: int = 1, ret
     """
     failures = []
 
-    # Try the common AA55C07F0102000241 command first and detect inverter type from serial_number
-    try:
-        logger.debug("Probing inverter at %s:%s.", host, port)
-        response = await DISCOVERY_COMMAND.execute(UdpInverterProtocol(host, port, timeout, retries))
-        response = response.response_data()
-        model_name = response[5:15].decode("ascii").rstrip()
-        serial_number = response[31:47].decode("ascii")
-
-        i: Inverter | None = None
-        for model_tag in ET_MODEL_TAGS:
-            if model_tag in serial_number:
-                logger.debug("Detected ET/EH/BT/BH/GEH inverter %s, S/N:%s.", model_name, serial_number)
-                i = ET(host, port, 0, timeout, retries)
-                break
-        if not i:
-            for model_tag in ES_MODEL_TAGS:
-                if model_tag in serial_number:
-                    logger.debug("Detected ES/EM/BP inverter %s, S/N:%s.", model_name, serial_number)
-                    i = ES(host, port, 0, timeout, retries)
-                    break
-        if not i:
-            for model_tag in DT_MODEL_TAGS:
+    if port == GOODWE_UDP_PORT:
+        # Try the common AA55C07F0102000241 command first and detect inverter type from serial_number
+        try:
+            logger.debug("Probing inverter at %s:%s.", host, port)
+            response = await DISCOVERY_COMMAND.execute(UdpInverterProtocol(host, port, timeout, retries))
+            response = response.response_data()
+            model_name = response[5:15].decode("ascii").rstrip()
+            serial_number = response[31:47].decode("ascii")
+
+            i: Inverter | None = None
+            for model_tag in ET_MODEL_TAGS:
                 if model_tag in serial_number:
-                    logger.debug("Detected DT/MS/D-NS/XS/GEP inverter %s, S/N:%s.", model_name, serial_number)
-                    i = DT(host, port, 0, timeout, retries)
+                    logger.debug("Detected ET/EH/BT/BH/GEH inverter %s, S/N:%s.", model_name, serial_number)
+                    i = ET(host, port, 0, timeout, retries)
                     break
-        if i:
-            await i.read_device_info()
-            logger.debug("Connected to inverter %s, S/N:%s.", i.model_name, i.serial_number)
-            return i
+            if not i:
+                for model_tag in ES_MODEL_TAGS:
+                    if model_tag in serial_number:
+                        logger.debug("Detected ES/EM/BP inverter %s, S/N:%s.", model_name, serial_number)
+                        i = ES(host, port, 0, timeout, retries)
+                        break
+            if not i:
+                for model_tag in DT_MODEL_TAGS:
+                    if model_tag in serial_number:
+                        logger.debug("Detected DT/MS/D-NS/XS/GEP inverter %s, S/N:%s.", model_name, serial_number)
+                        i = DT(host, port, 0, timeout, retries)
+                        break
+            if i:
+                await i.read_device_info()
+                logger.debug("Connected to inverter %s, S/N:%s.", i.model_name, i.serial_number)
+                return i
 
-    except InverterError as ex:
-        failures.append(ex)
+        except InverterError as ex:
+            failures.append(ex)
 
     # Probe inverter specific protocols
-    for inv in _SUPPORTED_PROTOCOLS:
+    for inv in [ET, DT, ES]:
         i = inv(host, port, 0, timeout, retries)
         try:
             logger.debug("Probing %s inverter at %s.", inv.__name__, host)

goodwe/inverter.py

@@ -91,7 +91,6 @@ class Inverter(ABC):
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
         self._protocol: InverterProtocol = self._create_protocol(host, port, comm_addr, timeout, retries)
         self._consecutive_failures_count: int = 0
-        self.keep_alive: bool = True
 
         self.model_name: str | None = None
         self.serial_number: str | None = None
@@ -130,9 +129,9 @@ class Inverter(ABC):
         except RequestFailedException as ex:
             self._consecutive_failures_count += 1
             raise RequestFailedException(ex.message, self._consecutive_failures_count) from None
-        finally:
-            if not self.keep_alive:
-                self._protocol.close_transport()
+
+    def set_keep_alive(self, keep_alive: bool) -> None:
+        self._protocol.keep_alive = keep_alive
 
     @abstractmethod
     async def read_device_info(self):

goodwe/modbus.py

@@ -221,18 +221,23 @@ def validate_modbus_tcp_response(data: bytes, cmd: int, offset: int, value: int)
     if len(data) <= 8:
         logger.debug("Response is too short.")
         return False
-    expected_length = int.from_bytes(data[4:6], byteorder='big', signed=False) + 6
-    if len(data) < expected_length:
-        raise PartialResponseException(len(data), expected_length)
+
+    # The Modbus/TCP message length check is completely ignore due to Goodwe bugs
+    # expected_length = int.from_bytes(data[4:6], byteorder='big', signed=False) + 6
+    # if len(data) < expected_length:
+    #    raise PartialResponseException(len(data), expected_length)
 
     if data[7] == MODBUS_READ_CMD:
+        expected_length = data[8] + 9
+        if len(data) < expected_length:
+            raise PartialResponseException(len(data), expected_length)
         if data[8] != value * 2:
             logger.debug("Response has unexpected length: %d, expected %d.", data[8], value * 2)
             return False
     elif data[7] in (MODBUS_WRITE_CMD, MODBUS_WRITE_MULTI_CMD):
         if len(data) < 12:
-            logger.debug("Response has unexpected length: %d, expected %d.", len(data), 14)
-            raise PartialResponseException(len(data), expected_length)
+            logger.debug("Response has unexpected length: %d, expected %d.", len(data), 12)
+            return False
         response_offset = int.from_bytes(data[8:10], byteorder='big', signed=False)
         if response_offset != offset:
             logger.debug("Response has wrong offset: %X, expected %X.", response_offset, offset)

goodwe/protocol.py

@@ -37,10 +37,12 @@ class InverterProtocol:
         self._timer: asyncio.TimerHandle | None = None
         self.timeout: int = timeout
         self.retries: int = retries
+        self.keep_alive: bool = True
         self.protocol: asyncio.Protocol | None = None
         self.response_future: Future | None = None
         self.command: ProtocolCommand | None = None
         self._partial_data: bytes | None = None
+        self._partial_missing: int = 0
 
     def _ensure_lock(self) -> asyncio.Lock:
         """Validate (or create) asyncio Lock.
@@ -57,10 +59,10 @@ class InverterProtocol:
             logger.debug("Creating lock instance for current event loop.")
             self._lock = asyncio.Lock()
             self._running_loop = asyncio.get_event_loop()
-            self.close_transport()
+            self._close_transport()
             return self._lock
 
-    def close_transport(self) -> None:
+    async def close(self) -> None:
         """Close the underlying transport/connection."""
         raise NotImplementedError()
 
@@ -116,7 +118,7 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
             logger.debug("Socket closed with error: %s.", exc)
         else:
             logger.debug("Socket closed.")
-        self.close_transport()
+        self._close_transport()
 
     def datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None:
         """On datagram received"""
@@ -124,35 +126,33 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
             self._timer.cancel()
             self._timer = None
         try:
-            if self._partial_data:
-                logger.debug("Received another response fragment: %s.", data.hex())
+            if self._partial_data and self._partial_missing == len(data):
+                logger.debug("Composed fragmented response: %s + %s", self._partial_data.hex(), data.hex())
                 data = self._partial_data + data
-            if self.command.validator(data):
-                if self._partial_data:
-                    logger.debug("Composed fragmented response: %s", data.hex())
-                else:
-                    logger.debug("Received: %s", data.hex())
                 self._partial_data = None
+                self._partial_missing = 0
+            if self.command.validator(data):
+                logger.debug("Received: %s", data.hex())
                 self.response_future.set_result(data)
             else:
                 logger.debug("Received invalid response: %s", data.hex())
                 asyncio.get_running_loop().call_soon(self._retry_mechanism)
-        except PartialResponseException:
-            logger.debug("Received response fragment: %s", data.hex())
+        except PartialResponseException as ex:
+            logger.debug("Received response fragment (%d of %d): %s", ex.length, ex.expected, data.hex())
             self._partial_data = data
-            return
+            self._partial_missing = ex.expected - ex.length
         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)
-            self.close_transport()
+            self._close_transport()
 
     def error_received(self, exc: Exception) -> None:
         """On error received"""
         logger.debug("Received error: %s", exc)
         self.response_future.set_exception(exc)
-        self.close_transport()
+        self._close_transport()
 
     async def send_request(self, command: ProtocolCommand) -> Future:
         """Send message via transport"""
@@ -168,6 +168,8 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
         """Send message via transport"""
         self.command = command
         self.response_future = response_future
+        self._partial_data = None
+        self._partial_missing = 0
         payload = command.request_bytes()
         if self._retry > 0:
             logger.debug("Sending: %s - retry #%s/%s", self.command, self._retry, self.retries)
@@ -188,9 +190,9 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
         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()
+            self._close_transport()
 
-    def close_transport(self) -> None:
+    def _close_transport(self) -> None:
         if self._transport:
             try:
                 self._transport.close()
@@ -201,6 +203,9 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
         if self.response_future and not self.response_future.done():
             self.response_future.cancel()
 
+    async def close(self):
+        self._close_transport()
+
 
 class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
     def __init__(self, host: str, port: int, comm_addr: int, timeout: int = 1, retries: int = 0):
@@ -227,14 +232,18 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 lambda: self,
                 host=self._host, port=self._port,
             )
-            sock = self._transport.get_extra_info('socket')
-            if sock is not None:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-                sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 10)
-                sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 10)
-                sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 3)
-                if platform.system() == 'Windows':
-                    sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 10000, 10000))
+            if self.keep_alive:
+                try:
+                    sock = self._transport.get_extra_info('socket')
+                    if sock is not None:
+                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+                        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 10)
+                        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 10)
+                        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 3)
+                        if platform.system() == 'Windows':
+                            sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 10000, 10000))
+                except AttributeError as ex:
+                    logger.debug("Failed to apply KEEPALIVE: %s", ex)
 
     def connection_made(self, transport: asyncio.DatagramTransport) -> None:
         """On connection made"""
@@ -243,7 +252,7 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
 
     def eof_received(self) -> None:
         logger.debug("EOF received.")
-        self.close_transport()
+        self._close_transport()
 
     def connection_lost(self, exc: Optional[Exception]) -> None:
         """On connection lost"""
@@ -251,44 +260,42 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
             logger.debug("Connection closed with error: %s.", exc)
         else:
             logger.debug("Connection closed.")
-        self.close_transport()
+        self._close_transport()
 
     def data_received(self, data: bytes) -> None:
         """On data received"""
         if self._timer:
             self._timer.cancel()
         try:
-            if self._partial_data:
-                logger.debug("Received another response fragment: %s.", data.hex())
+            if self._partial_data and self._partial_missing == len(data):
+                logger.debug("Composed fragmented response: %s + %s", self._partial_data.hex(), data.hex())
                 data = self._partial_data + data
+                self._partial_data = None
+                self._partial_missing = 0
             if self.command.validator(data):
-                if self._partial_data:
-                    logger.debug("Composed fragmented response: %s", data.hex())
-                else:
-                    logger.debug("Received: %s", data.hex())
+                logger.debug("Received: %s", data.hex())
                 self._retry = 0
-                self._partial_data = None
                 self.response_future.set_result(data)
             else:
                 logger.debug("Received invalid response: %s", data.hex())
                 self.response_future.set_exception(RequestRejectedException())
-                self.close_transport()
-        except PartialResponseException:
-            logger.debug("Received response fragment: %s", data.hex())
+                self._close_transport()
+        except PartialResponseException as ex:
+            logger.debug("Received response fragment (%d of %d): %s", ex.length, ex.expected, data.hex())
             self._partial_data = data
-            return
+            self._partial_missing = ex.expected - ex.length
         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)
-            # self.close_transport()
+            # self._close_transport()
 
     def error_received(self, exc: Exception) -> None:
         """On error received"""
         logger.debug("Received error: %s", exc)
         self.response_future.set_exception(exc)
-        self.close_transport()
+        self._close_transport()
 
     async def send_request(self, command: ProtocolCommand) -> Future:
         """Send message via transport"""
@@ -306,7 +313,7 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 self._retry += 1
                 if self._lock and self._lock.locked():
                     self._lock.release()
-                self.close_transport()
+                self._close_transport()
                 return await self.send_request(command)
             else:
                 return self._max_retries_reached()
@@ -327,6 +334,8 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
         """Send message via transport"""
         self.command = command
         self.response_future = response_future
+        self._partial_data = None
+        self._partial_missing = 0
         payload = command.request_bytes()
         if self._retry > 0:
             logger.debug("Sending: %s - retry #%s/%s", self.command, self._retry, self.retries)
@@ -343,16 +352,16 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
             if self._timer:
                 logger.debug("Failed to receive response to %s in time (%ds).", self.command, self.timeout)
                 self._timer = None
-            self.close_transport()
+            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._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:
+    def _close_transport(self) -> None:
         if self._transport:
             try:
                 self._transport.close()
@@ -363,6 +372,14 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
         if self.response_future and not self.response_future.done():
             self.response_future.cancel()
 
+    async def close(self):
+        await self._ensure_lock().acquire()
+        try:
+            self._close_transport()
+        finally:
+            if self._lock and self._lock.locked():
+                self._lock.release()
+
 
 class ProtocolResponse:
     """Definition of response to protocol command"""
@@ -441,6 +458,9 @@ class ProtocolCommand:
             raise RequestFailedException(
                 "No valid response received to '" + self.request.hex() + "' request."
             ) from None
+        finally:
+            if not protocol.keep_alive:
+                await protocol.close()
 
 
 class Aa55ProtocolCommand(ProtocolCommand):
@@ -485,8 +505,7 @@ class Aa55ProtocolCommand(ProtocolCommand):
         data[-2:] is checksum (plain sum of response data incl. header)
         """
         if len(data) <= 8 or len(data) != data[6] + 9:
-            logger.debug("Response has unexpected length: %d, expected %d.", len(data), data[6] + 9)
-            return False
+            raise PartialResponseException(len(data), data[6] + 9)
         elif response_type:
             data_rt_int = int.from_bytes(data[4:6], byteorder="big", signed=True)
             if int(response_type, 16) != data_rt_int:

{goodwe-0.4.2.dist-info → goodwe-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goodwe
-Version: 0.4.2
+Version: 0.4.4
 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.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=oGbkdVHP51KnlwQraKeebmiP6AtJ1S67aLB7euNRIoE,11743
+goodwe/es.py,sha256=iVK8EMCaAJJFihZLntJZ_Eu4sQWoZTVtTROp9mHFG6o,22730
+goodwe/et.py,sha256=CiX-PE7wouDnj1RnPnOyqiNE4FELhOGdyPUOm9VCzUw,43890
+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=bOieJx6jbgSPYvwk8tSGkmRE586HgeCUGKezAkzNSsA,28563
+goodwe/sensor.py,sha256=buPG8BcgZmRDqaMrLQUACLHB85U134qG6qo_ggsu48A,37679
+goodwe-0.4.4.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.4.4.dist-info/METADATA,sha256=QQS2Kydn9eELSDLYpWLzibdXB1x9WON9wmLJXCT7KYw,3376
+goodwe-0.4.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+goodwe-0.4.4.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.4.4.dist-info/RECORD,,

goodwe-0.4.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=0Zwuri1cbJ2Qe24R2rEjDMTZeVtsh21YIx3KlRaXgWg,5742
-goodwe/const.py,sha256=yhWk56YV7k7-MbgfmWEMYNlqeRNLOfOpfTqEfRj6Hp8,7934
-goodwe/dt.py,sha256=oGbkdVHP51KnlwQraKeebmiP6AtJ1S67aLB7euNRIoE,11743
-goodwe/es.py,sha256=iVK8EMCaAJJFihZLntJZ_Eu4sQWoZTVtTROp9mHFG6o,22730
-goodwe/et.py,sha256=CiX-PE7wouDnj1RnPnOyqiNE4FELhOGdyPUOm9VCzUw,43890
-goodwe/exceptions.py,sha256=dKMLxotjoR1ic8OVlw1joIJ4mKWD6oFtUMZ86fNM5ZE,1403
-goodwe/inverter.py,sha256=-eRq6ND-BpLmj6vgYW0K0Oq3WvNcjjScbkalAzPH5ew,10494
-goodwe/modbus.py,sha256=zT3W9ByANPaZd7T0XTqYGBaVo9PEwyg8jus12mRxCPU,8211
-goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
-goodwe/protocol.py,sha256=m4n1VAonXLBswFEjUcvKXEPV2WcOv_-MDMAefpsQ_-g,27703
-goodwe/sensor.py,sha256=buPG8BcgZmRDqaMrLQUACLHB85U134qG6qo_ggsu48A,37679
-goodwe-0.4.2.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.4.2.dist-info/METADATA,sha256=gOkkNodwpHtUf_743Nc7jCKpdxjwX_L5DSr2POJDjs8,3376
-goodwe-0.4.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-goodwe-0.4.2.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.4.2.dist-info/RECORD,,