goodwe 0.4.1__py3-none-any.whl → 0.4.3__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/dt.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import logging
 from typing import Tuple
 
-from .exceptions import InverterError
+from .exceptions import InverterError, RequestRejectedException
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
+from .modbus import ILLEGAL_DATA_ADDRESS
 from .model import is_3_mppt, is_single_phase
 from .protocol import ProtocolCommand
 from .sensor import *
 
+logger = logging.getLogger(__name__)
+
 
 class DT(Inverter):
     """Class representing inverter of DT/MS/D-NS/XS or GE's GEP(PSB/PSC) families"""
@@ -123,10 +127,7 @@ 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, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0x7f
+        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._sensors = self.__all_sensors
@@ -177,17 +178,43 @@ class DT(Inverter):
 
     async def read_setting(self, setting_id: str) -> Any:
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(self._read_command(setting.offset, count))
-        return setting.read_value(response)
+        if setting:
+            return await self._read_setting(setting)
+        else:
+            if 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:
+                raise ValueError(f'Unknown setting "{setting_id}"')
+
+    async def _read_setting(self, setting: Sensor) -> Any:
+        try:
+            count = (setting.size_ + (setting.size_ % 2)) // 2
+            response = await self._read_from_socket(self._read_command(setting.offset, count))
+            return setting.read_value(response)
+        except RequestRejectedException as ex:
+            if ex.message == ILLEGAL_DATA_ADDRESS:
+                logger.debug("Unsupported setting %s", setting.id_)
+                self._settings.pop(setting.id_, None)
+            return None
 
     async def write_setting(self, setting_id: str, value: Any):
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        raw_value = setting.encode_value(value)
+        if setting:
+            await self._write_setting(setting, value)
+        else:
+            if setting_id.startswith("modbus"):
+                await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
+
+    async def _write_setting(self, setting: Sensor, value: Any):
+        if setting.size_ == 1:
+            # modbus can address/store only 16 bit values, read the other 8 bytes
+            response = await self._read_from_socket(self._read_command(setting.offset, 1))
+            raw_value = setting.encode_value(value, response.response_data()[0:2])
+        else:
+            raw_value = setting.encode_value(value)
         if len(raw_value) <= 2:
             value = int.from_bytes(raw_value, byteorder="big", signed=True)
             await self._read_from_socket(self._write_command(setting.offset, value))

goodwe/es.py

@@ -168,10 +168,7 @@ class ES(Inverter):
     )
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, comm_addr, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0xf7
+        super().__init__(host, port, comm_addr if comm_addr else 0xf7, timeout, retries)
         self._settings: dict[str, Sensor] = {s.id_: s for s in self.__all_settings}
 
     def _supports_eco_mode_v2(self) -> bool:
@@ -220,6 +217,9 @@ class ES(Inverter):
             if not setting:
                 raise ValueError(f'Unknown setting "{setting_id}"')
             return await self._read_setting(setting)
+        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:
             all_settings = await self.read_settings_data()
             return all_settings.get(setting_id)
@@ -238,6 +238,8 @@ class ES(Inverter):
             await self._read_from_socket(
                 Aa55ProtocolCommand("030206" + Timestamp("time", 0, "").encode_value(value).hex(), "0382")
             )
+        elif setting_id.startswith("modbus"):
+            await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
         else:
             setting: Sensor | None = self._settings.get(setting_id)
             if not setting:
@@ -249,10 +251,9 @@ class ES(Inverter):
             # modbus can address/store only 16 bit values, read the other 8 bytes
             if self._is_modbus_setting(setting):
                 response = await self._read_from_socket(self._read_command(setting.offset, 1))
-                raw_value = setting.encode_value(value, response.response_data()[0:2])
             else:
                 response = await self._read_from_socket(Aa55ReadCommand(setting.offset, 1))
-                raw_value = setting.encode_value(value, response.response_data()[2:4])
+            raw_value = setting.encode_value(value, response.response_data()[0:2])
         else:
             raw_value = setting.encode_value(value)
         if len(raw_value) <= 2:

goodwe/et.py

@@ -457,10 +457,7 @@ class ET(Inverter):
     )
 
     def __init__(self, host: str, port: int, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, comm_addr, timeout, retries)
-        if not self.comm_addr:
-            # Set the default inverter address
-            self.comm_addr = 0xf7
+        super().__init__(host, port, comm_addr if comm_addr else 0xf7, timeout, retries)
         self._READ_DEVICE_VERSION_INFO: ProtocolCommand = self._read_command(0x88b8, 0x0021)
         self._READ_RUNNING_DATA: ProtocolCommand = self._read_command(0x891c, 0x007d)
         self._READ_METER_DATA: ProtocolCommand = self._read_command(0x8ca0, 0x2d)
@@ -611,26 +608,35 @@ class ET(Inverter):
 
     async def read_setting(self, setting_id: str) -> Any:
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        try:
+        if setting:
             return await self._read_setting(setting)
+        else:
+            if 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:
+                raise ValueError(f'Unknown setting "{setting_id}"')
+
+    async def _read_setting(self, setting: Sensor) -> Any:
+        try:
+            count = (setting.size_ + (setting.size_ % 2)) // 2
+            response = await self._read_from_socket(self._read_command(setting.offset, count))
+            return setting.read_value(response)
         except RequestRejectedException as ex:
             if ex.message == ILLEGAL_DATA_ADDRESS:
                 logger.debug("Unsupported setting %s", setting.id_)
-                self._settings.pop(setting_id, None)
+                self._settings.pop(setting.id_, None)
             return None
 
-    async def _read_setting(self, setting: Sensor) -> Any:
-        count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(self._read_command(setting.offset, count))
-        return setting.read_value(response)
-
     async def write_setting(self, setting_id: str, value: Any):
         setting = self._settings.get(setting_id)
-        if not setting:
-            raise ValueError(f'Unknown setting "{setting_id}"')
-        await self._write_setting(setting, value)
+        if setting:
+            await self._write_setting(setting, value)
+        else:
+            if setting_id.startswith("modbus"):
+                await self._read_from_socket(self._write_command(int(setting_id[7:]), int(value)))
+            else:
+                raise ValueError(f'Unknown setting "{setting_id}"')
 
     async def _write_setting(self, setting: Sensor, value: Any):
         if setting.size_ == 1:

goodwe/exceptions.py

@@ -29,5 +29,19 @@ class RequestRejectedException(InverterError):
         self.message: str = message
 
 
+class PartialResponseException(InverterError):
+    """
+    Indicates the received response data are incomplete and is probably fragmented to multiple packets.
+
+    Attributes:
+        length -- received data length
+        expected -- expected data lenght
+    """
+
+    def __init__(self, lenght: int, expected: int):
+        self.length: int = lenght
+        self.expected: int = expected
+
+
 class MaxRetriesException(InverterError):
     """Indicates the maximum number of retries has been reached"""

goodwe/inverter.py

@@ -89,11 +89,9 @@ 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, timeout, retries)
+        self._protocol: InverterProtocol = self._create_protocol(host, port, comm_addr, timeout, retries)
         self._consecutive_failures_count: int = 0
 
-        self.comm_addr: int = comm_addr
-
         self.model_name: str | None = None
         self.serial_number: str | None = None
         self.rated_power: int = 0
@@ -109,15 +107,15 @@ class Inverter(ABC):
 
     def _read_command(self, offset: int, count: int) -> ProtocolCommand:
         """Create read protocol command."""
-        return self._protocol.read_command(self.comm_addr, offset, count)
+        return self._protocol.read_command(offset, count)
 
     def _write_command(self, register: int, value: int) -> ProtocolCommand:
         """Create write protocol command."""
-        return self._protocol.write_command(self.comm_addr, register, value)
+        return self._protocol.write_command(register, value)
 
     def _write_multi_command(self, offset: int, values: bytes) -> ProtocolCommand:
         """Create write multiple protocol command."""
-        return self._protocol.write_multi_command(self.comm_addr, offset, values)
+        return self._protocol.write_multi_command(offset, values)
 
     async def _read_from_socket(self, command: ProtocolCommand) -> ProtocolResponse:
         try:
@@ -132,6 +130,9 @@ class Inverter(ABC):
             self._consecutive_failures_count += 1
             raise RequestFailedException(ex.message, self._consecutive_failures_count) from None
 
+    def set_keep_alive(self, keep_alive: bool) -> None:
+        self._protocol.keep_alive = keep_alive
+
     @abstractmethod
     async def read_device_info(self):
         """
@@ -270,11 +271,11 @@ class Inverter(ABC):
         raise NotImplementedError()
 
     @staticmethod
-    def _create_protocol(host: str, port: int, timeout: int, retries: int) -> InverterProtocol:
+    def _create_protocol(host: str, port: int, comm_addr: int, timeout: int, retries: int) -> InverterProtocol:
         if port == 502:
-            return TcpInverterProtocol(host, port, timeout, retries)
+            return TcpInverterProtocol(host, port, comm_addr, timeout, retries)
         else:
-            return UdpInverterProtocol(host, port, timeout, retries)
+            return UdpInverterProtocol(host, port, comm_addr, timeout, retries)
 
     @staticmethod
     def _map_response(response: ProtocolResponse, sensors: Tuple[Sensor, ...]) -> Dict[str, Any]:

goodwe/modbus.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Union
 
-from .exceptions import RequestRejectedException
+from .exceptions import PartialResponseException, RequestRejectedException
 
 logger = logging.getLogger(__name__)
 
@@ -9,7 +9,7 @@ MODBUS_READ_CMD: int = 0x3
 MODBUS_WRITE_CMD: int = 0x6
 MODBUS_WRITE_MULTI_CMD: int = 0x10
 
-ILLEGAL_DATA_ADDRESS = 'ILLEGAL DATA ADDRESS'
+ILLEGAL_DATA_ADDRESS: str = 'ILLEGAL DATA ADDRESS'
 
 FAILURE_CODES = {
     1: "ILLEGAL FUNCTION",
@@ -178,8 +178,7 @@ def validate_modbus_rtu_response(data: bytes, cmd: int, offset: int, value: int)
             return False
         expected_length = data[4] + 7
         if len(data) < expected_length:
-            logger.debug("Response is too short: %d, expected %d.", len(data), expected_length)
-            return False
+            raise PartialResponseException(len(data), expected_length)
     elif data[3] in (MODBUS_WRITE_CMD, MODBUS_WRITE_MULTI_CMD):
         if len(data) < 10:
             logger.debug("Response has unexpected length: %d, expected %d.", len(data), 10)
@@ -222,18 +221,22 @@ 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
+    # The weird expected_length != 12 is work around Goodwe bug answering wrong (hardcoded 6) length.
+    if len(data) < expected_length and expected_length != 12:
+        raise PartialResponseException(len(data), expected_length)
+
     if data[7] == MODBUS_READ_CMD:
-        if data[8] != value * 2:
-            logger.debug("Response has unexpected length: %d, expected %d.", data[8], value * 2)
-            return False
         expected_length = data[8] + 9
         if len(data) < expected_length:
-            logger.debug("Response is too short: %d, expected %d.", 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)
-            return False
+            raise PartialResponseException(len(data), expected_length)
         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

@@ -3,30 +3,45 @@ from __future__ import annotations
 import asyncio
 import io
 import logging
+import platform
+import socket
 from asyncio.futures import Future
 from typing import Tuple, Optional, Callable
 
-from .exceptions import MaxRetriesException, RequestFailedException, RequestRejectedException
+from .exceptions import MaxRetriesException, PartialResponseException, RequestFailedException, RequestRejectedException
 from .modbus import create_modbus_rtu_request, create_modbus_rtu_multi_request, create_modbus_tcp_request, \
     create_modbus_tcp_multi_request, validate_modbus_rtu_response, validate_modbus_tcp_response, MODBUS_READ_CMD, \
     MODBUS_WRITE_CMD, MODBUS_WRITE_MULTI_CMD
 
 logger = logging.getLogger(__name__)
 
+_modbus_tcp_tx = 0
+
+
+def _next_tx() -> bytes:
+    global _modbus_tcp_tx
+    _modbus_tcp_tx += 1
+    if _modbus_tcp_tx == 0xFFFF:
+        _modbus_tcp_tx = 1
+    return int.to_bytes(_modbus_tcp_tx, length=2, byteorder="big", signed=False)
+
 
 class InverterProtocol:
 
-    def __init__(self, host: str, port: int, timeout: int, retries: int):
+    def __init__(self, host: str, port: int, comm_addr: int, timeout: int, retries: int):
         self._host: str = host
         self._port: int = port
+        self._comm_addr: int = comm_addr
         self._running_loop: asyncio.AbstractEventLoop | None = None
         self._lock: asyncio.Lock | None = None
         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
 
     def _ensure_lock(self) -> asyncio.Lock:
         """Validate (or create) asyncio Lock.
@@ -46,42 +61,44 @@ class InverterProtocol:
             self._close_transport()
             return self._lock
 
-    def _close_transport(self) -> None:
+    async def close(self) -> None:
+        """Close the underlying transport/connection."""
         raise NotImplementedError()
 
     async def send_request(self, command: ProtocolCommand) -> Future:
+        """Convert command to request and send it to inverter."""
         raise NotImplementedError()
 
-    def read_command(self, comm_addr: int, offset: int, count: int) -> ProtocolCommand:
+    def read_command(self, offset: int, count: int) -> ProtocolCommand:
         """Create read protocol command."""
         raise NotImplementedError()
 
-    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+    def write_command(self, register: int, value: int) -> ProtocolCommand:
         """Create write protocol command."""
         raise NotImplementedError()
 
-    def write_multi_command(self, comm_addr: int, offset: int, values: bytes) -> ProtocolCommand:
+    def write_multi_command(self, offset: int, values: bytes) -> ProtocolCommand:
         """Create write multiple protocol command."""
         raise NotImplementedError()
 
 
 class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
-    def __init__(self, host: str, port: int, timeout: int = 1, retries: int = 3):
-        super().__init__(host, port, timeout, retries)
+    def __init__(self, host: str, port: int, comm_addr: int, timeout: int = 1, retries: int = 3):
+        super().__init__(host, port, comm_addr, timeout, retries)
         self._transport: asyncio.transports.DatagramTransport | None = None
         self._retry: int = 0
 
-    def read_command(self, comm_addr: int, offset: int, count: int) -> ProtocolCommand:
+    def read_command(self, offset: int, count: int) -> ProtocolCommand:
         """Create read protocol command."""
-        return ModbusRtuReadCommand(comm_addr, offset, count)
+        return ModbusRtuReadCommand(self._comm_addr, offset, count)
 
-    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+    def write_command(self, register: int, value: int) -> ProtocolCommand:
         """Create write protocol command."""
-        return ModbusRtuWriteCommand(comm_addr, register, value)
+        return ModbusRtuWriteCommand(self._comm_addr, register, value)
 
-    def write_multi_command(self, comm_addr: int, offset: int, values: bytes) -> ProtocolCommand:
+    def write_multi_command(self, offset: int, values: bytes) -> ProtocolCommand:
         """Create write multiple protocol command."""
-        return ModbusRtuWriteMultiCommand(comm_addr, offset, values)
+        return ModbusRtuWriteMultiCommand(self._comm_addr, offset, values)
 
     async def _connect(self) -> None:
         if not self._transport or self._transport.is_closing():
@@ -108,12 +125,25 @@ 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())
+                data = self._partial_data + data
             if self.command.validator(data):
-                logger.debug("Received: %s", data.hex())
+                if self._partial_data:
+                    logger.debug("Composed fragmented response: %s", data.hex())
+                else:
+                    logger.debug("Received: %s", data.hex())
+                self._partial_data = None
                 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())
+            self._partial_data = data
+            return
+        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)
@@ -139,9 +169,12 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
         """Send message via transport"""
         self.command = command
         self.response_future = response_future
-        logger.debug("Sending: %s%s", self.command,
-                     f' - retry #{self._retry}/{self.retries}' if self._retry > 0 else '')
-        self._transport.sendto(self.command.request)
+        payload = command.request_bytes()
+        if self._retry > 0:
+            logger.debug("Sending: %s - retry #%s/%s", self.command, self._retry, self.retries)
+        else:
+            logger.debug("Sending: %s", self.command)
+        self._transport.sendto(payload)
         self._timer = asyncio.get_running_loop().call_later(self.timeout, self._retry_mechanism)
 
     def _retry_mechanism(self) -> None:
@@ -169,24 +202,27 @@ 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, timeout: int = 1, retries: int = 0):
-        super().__init__(host, port, timeout, retries)
+    def __init__(self, host: str, port: int, comm_addr: int, timeout: int = 1, retries: int = 0):
+        super().__init__(host, port, comm_addr, timeout, retries)
         self._transport: asyncio.transports.Transport | None = None
         self._retry: int = 0
 
-    def read_command(self, comm_addr: int, offset: int, count: int) -> ProtocolCommand:
+    def read_command(self, offset: int, count: int) -> ProtocolCommand:
         """Create read protocol command."""
-        return ModbusTcpReadCommand(comm_addr, offset, count)
+        return ModbusTcpReadCommand(self._comm_addr, offset, count)
 
-    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+    def write_command(self, register: int, value: int) -> ProtocolCommand:
         """Create write protocol command."""
-        return ModbusTcpWriteCommand(comm_addr, register, value)
+        return ModbusTcpWriteCommand(self._comm_addr, register, value)
 
-    def write_multi_command(self, comm_addr: int, offset: int, values: bytes) -> ProtocolCommand:
+    def write_multi_command(self, offset: int, values: bytes) -> ProtocolCommand:
         """Create write multiple protocol command."""
-        return ModbusTcpWriteMultiCommand(comm_addr, offset, values)
+        return ModbusTcpWriteMultiCommand(self._comm_addr, offset, values)
 
     async def _connect(self) -> None:
         if not self._transport or self._transport.is_closing():
@@ -195,6 +231,18 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 lambda: self,
                 host=self._host, port=self._port,
             )
+            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"""
@@ -218,14 +266,27 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
         if self._timer:
             self._timer.cancel()
         try:
+            if self._partial_data:
+                logger.debug("Received another response fragment: %s.", data.hex())
+                data = self._partial_data + data
             if self.command.validator(data):
-                logger.debug("Received: %s", data.hex())
+                if self._partial_data:
+                    logger.debug("Composed fragmented response: %s", data.hex())
+                else:
+                    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._partial_data = data
+            return
+        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)
@@ -257,7 +318,7 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 return await self.send_request(command)
             else:
                 return self._max_retries_reached()
-        except (ConnectionRefusedError, TimeoutError, OSError, asyncio.TimeoutError) as exc:
+        except (ConnectionRefusedError, TimeoutError, OSError, asyncio.TimeoutError):
             if self._retry < self.retries:
                 logger.debug("Connection refused error.")
                 self._retry += 1
@@ -274,9 +335,12 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
         """Send message via transport"""
         self.command = command
         self.response_future = response_future
-        logger.debug("Sending: %s%s", self.command,
-                     f' - retry #{self._retry}/{self.retries}' if self._retry > 0 else '')
-        self._transport.write(self.command.request)
+        payload = command.request_bytes()
+        if self._retry > 0:
+            logger.debug("Sending: %s - retry #%s/%s", self.command, self._retry, self.retries)
+        else:
+            logger.debug("Sending: %s", self.command)
+        self._transport.write(payload)
         self._timer = asyncio.get_running_loop().call_later(self.timeout, self._timeout_mechanism)
 
     def _timeout_mechanism(self) -> None:
@@ -307,6 +371,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"""
@@ -354,6 +426,10 @@ class ProtocolCommand:
     def __repr__(self):
         return self.request.hex()
 
+    def request_bytes(self) -> bytes:
+        """Return raw bytes payload, optionally pre-processed"""
+        return self.request
+
     def trim_response(self, raw_response: bytes):
         """Trim raw response from header and checksum data"""
         return raw_response
@@ -381,6 +457,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):
@@ -425,8 +504,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:
@@ -567,6 +645,12 @@ class ModbusTcpProtocolCommand(ProtocolCommand):
         self.first_address: int = offset
         self.value = value
 
+    def request_bytes(self) -> bytes:
+        """Return raw bytes payload, optionally pre-processed"""
+        # Apply sequential Modbus/TCP transaction identifier
+        self.request = _next_tx() + self.request[2:]
+        return self.request
+
     def trim_response(self, raw_response: bytes):
         """Trim raw response from header and checksum data"""
         return raw_response[9:]

goodwe/sensor.py

@@ -183,7 +183,7 @@ class Energy(Sensor):
 
     def read_value(self, data: ProtocolResponse):
         value = read_bytes2(data)
-        return float(value) / 10 if value else None
+        return float(value) / 10 if value is not None else None
 
 
 class Energy4(Sensor):
@@ -194,7 +194,7 @@ class Energy4(Sensor):
 
     def read_value(self, data: ProtocolResponse):
         value = read_bytes4(data)
-        return float(value) / 10 if value else None
+        return float(value) / 10 if value is not None else None
 
 
 class Apparent(Sensor):
@@ -910,7 +910,7 @@ def read_temp(buffer: ProtocolResponse, offset: int = None) -> float | None:
     if offset is not None:
         buffer.seek(offset)
     value = int.from_bytes(buffer.read(2), byteorder="big", signed=True)
-    if value == 32767:
+    if value == -1 or value == 32767:
         return None
     else:
         return float(value) / 10

{goodwe-0.4.1.dist-info → goodwe-0.4.3.dist-info}/METADATA

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

goodwe-0.4.3.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=qDFs8pMOtwgHPfwiZLd-P34vCLHc71-b8MQZMb8FJME,8488
+goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
+goodwe/protocol.py,sha256=JhWYzUtCwbhxXCfZMA_hPGGCHcEEhn0y9B4goJ2GyNo,28306
+goodwe/sensor.py,sha256=buPG8BcgZmRDqaMrLQUACLHB85U134qG6qo_ggsu48A,37679
+goodwe-0.4.3.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.4.3.dist-info/METADATA,sha256=m3IqLUDf7Ae-ElSqvqJTNFmUu-ZaQWr1YWmjz7eqJaw,3376
+goodwe-0.4.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+goodwe-0.4.3.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.4.3.dist-info/RECORD,,

goodwe-0.4.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=0Zwuri1cbJ2Qe24R2rEjDMTZeVtsh21YIx3KlRaXgWg,5742
-goodwe/const.py,sha256=yhWk56YV7k7-MbgfmWEMYNlqeRNLOfOpfTqEfRj6Hp8,7934
-goodwe/dt.py,sha256=q8PRs0nVqN4mEhH8243NTbkkBtrGx-n8icwE-BkTN5Q,10460
-goodwe/es.py,sha256=gnSla5SGXK3cJag45o9Z2Wd7rwLkjm3xmS-JN1lf5Ck,22545
-goodwe/et.py,sha256=qqC-1r_Q2gmWSYEHhqdrXRCyBLjihCoWbTmbtSGtLJs,43517
-goodwe/exceptions.py,sha256=I6PHG0GTWgxNrDVZwJZBnyzItRq5eiM6ci23-EEsn1I,1012
-goodwe/inverter.py,sha256=3whUY_ZG7A8aDH1HDSgAzgtFqLOEJBvaxkDwSqKYeuM,10395
-goodwe/modbus.py,sha256=NUlG_d3usiJFjTRNpp61u23CLVSx8NfRJLWP4DmxpMU,8196
-goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
-goodwe/protocol.py,sha256=vVDLDlnjOEMkfdz8_h1bupU4K8VUxyPbrzfNytUK5us,24926
-goodwe/sensor.py,sha256=9Oo74Qp9vHmV8trfTn3PlGJrp0Ql1vk0U81oCmod-1c,37640
-goodwe-0.4.1.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.4.1.dist-info/METADATA,sha256=QpFz1_icH-w7_ZLAxUT3Ee927v_9tUJqbuNqnbsYiPQ,3376
-goodwe-0.4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-goodwe-0.4.1.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.4.1.dist-info/RECORD,,