goodwe 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

goodwe/__init__.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Type
 
+from .const import GOODWE_TCP_PORT, GOODWE_UDP_PORT
 from .dt import DT
 from .es import ES
 from .et import ET
@@ -26,8 +26,8 @@ DISCOVERY_COMMAND = Aa55ProtocolCommand("010200", "0182")
 _SUPPORTED_PROTOCOLS = [ET, DT, ES]
 
 
-async def connect(host: str, family: str = None, comm_addr: int = 0, timeout: int = 1, retries: int = 3,
-                  do_discover: bool = True) -> Inverter:
+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:
     """Contact the inverter at the specified host/port and answer appropriate Inverter instance.
 
     The specific inverter family/type will be detected automatically, but it can be passed explicitly.
@@ -41,24 +41,24 @@ async def connect(host: str, family: str = None, comm_addr: int = 0, timeout: in
 
     Raise InverterError if unable to contact or recognise supported inverter.
     """
-    if family in ET_FAMILY:
-        inv = ET(host, comm_addr, timeout, retries)
+    if family in ET_FAMILY or port == GOODWE_TCP_PORT:
+        inv = ET(host, port, comm_addr, timeout, retries)
     elif family in ES_FAMILY:
-        inv = ES(host, comm_addr, timeout, retries)
+        inv = ES(host, port, comm_addr, timeout, retries)
     elif family in DT_FAMILY:
-        inv = DT(host, comm_addr, timeout, retries)
+        inv = DT(host, port, comm_addr, timeout, retries)
     elif do_discover:
-        return await discover(host, timeout, retries)
+        return await discover(host, port, timeout, retries)
     else:
         raise InverterError("Specify either an inverter family or set do_discover True")
 
-    logger.debug("Connecting to %s family inverter at %s.", family, host)
+    logger.debug("Connecting to %s family inverter at %s:%s.", family, host, port)
     await inv.read_device_info()
     logger.debug("Connected to inverter %s, S/N:%s.", inv.model_name, inv.serial_number)
     return inv
 
 
-async def discover(host: str, timeout: int = 1, retries: int = 3) -> Inverter:
+async def discover(host: str, port: int = GOODWE_UDP_PORT, timeout: int = 1, retries: int = 3) -> Inverter:
     """Contact the inverter at the specified value and answer appropriate Inverter instance
 
     Raise InverterError if unable to contact or recognise supported inverter
@@ -67,28 +67,33 @@ async def discover(host: str, timeout: int = 1, retries: int = 3) -> Inverter:
 
     # Try the common AA55C07F0102000241 command first and detect inverter type from serial_number
     try:
-        logger.debug("Probing inverter at %s.", host)
-        response = await DISCOVERY_COMMAND.execute(host, timeout, retries)
+        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")
 
-        inverter_class: Type[Inverter] | None = None
+        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)
-                inverter_class = ET
-        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)
-                inverter_class = ES
-        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)
-                inverter_class = DT
-        if inverter_class:
-            i = inverter_class(host, 0, timeout, retries)
+                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 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:
@@ -96,7 +101,7 @@ async def discover(host: str, timeout: int = 1, retries: int = 3) -> Inverter:
 
     # Probe inverter specific protocols
     for inv in _SUPPORTED_PROTOCOLS:
-        i = inv(host, 0, timeout, retries)
+        i = inv(host, port, 0, timeout, retries)
         try:
             logger.debug("Probing %s inverter at %s.", inv.__name__, host)
             await i.read_device_info()
@@ -119,22 +124,12 @@ async def search_inverters() -> bytes:
     Raise InverterError if unable to contact any inverter
     """
     logger.debug("Searching inverters by broadcast to port 48899")
-    loop = asyncio.get_running_loop()
     command = ProtocolCommand("WIFIKIT-214028-READ".encode("utf-8"), lambda r: True)
-    response_future = loop.create_future()
-    transport, _ = await loop.create_datagram_endpoint(
-        lambda: UdpInverterProtocol(response_future, command, 1, 3),
-        remote_addr=("255.255.255.255", 48899),
-        allow_broadcast=True,
-    )
     try:
-        await response_future
-        result = response_future.result()
+        result = await command.execute(UdpInverterProtocol("255.255.255.255", 48899, 1, 0))
         if result is not None:
-            return result
+            return result.response_data()
         else:
             raise InverterError("No response received to broadcast request.")
     except asyncio.CancelledError:
         raise InverterError("No valid response received to broadcast request.") from None
-    finally:
-        transport.close()

goodwe/const.py

@@ -1,5 +1,6 @@
 from typing import Dict
 
+GOODWE_TCP_PORT = 502
 GOODWE_UDP_PORT = 8899
 
 BATTERY_MODES: Dict[int, str] = {

goodwe/dt.py

@@ -7,7 +7,7 @@ from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
 from .model import is_3_mppt, is_single_phase
-from .protocol import ProtocolCommand, ModbusReadCommand, ModbusWriteCommand, ModbusWriteMultiCommand
+from .protocol import ProtocolCommand
 from .sensor import *
 
 
@@ -122,13 +122,13 @@ class DT(Inverter):
         Integer("grid_export_limit", 40336, "Grid Export Limit", "%", Kind.GRID),
     )
 
-    def __init__(self, host: str, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, comm_addr, timeout, retries)
+    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
-        self._READ_DEVICE_VERSION_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x7531, 0x0028)
-        self._READ_DEVICE_RUNNING_DATA: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x7594, 0x0049)
+        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
         self._settings: dict[str, Sensor] = {s.id_: s for s in self.__all_settings}
 
@@ -180,7 +180,7 @@ class DT(Inverter):
         if not setting:
             raise ValueError(f'Unknown setting "{setting_id}"')
         count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+        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):
@@ -190,9 +190,9 @@ class DT(Inverter):
         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(ModbusWriteCommand(self.comm_addr, setting.offset, value))
+            await self._read_from_socket(self._write_command(setting.offset, value))
         else:
-            await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, setting.offset, raw_value))
+            await self._read_from_socket(self._write_multi_command(setting.offset, raw_value))
 
     async def read_settings_data(self) -> Dict[str, Any]:
         data = {}

goodwe/es.py

@@ -7,8 +7,7 @@ from .exceptions import InverterError
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
-from .protocol import ProtocolCommand, Aa55ProtocolCommand, Aa55ReadCommand, Aa55WriteCommand, Aa55WriteMultiCommand, \
-    ModbusReadCommand, ModbusWriteCommand, ModbusWriteMultiCommand
+from .protocol import ProtocolCommand, Aa55ProtocolCommand, Aa55ReadCommand, Aa55WriteCommand, Aa55WriteMultiCommand
 from .sensor import *
 
 logger = logging.getLogger(__name__)
@@ -168,8 +167,8 @@ class ES(Inverter):
         ByteH("eco_mode_4_switch", 47567, "Eco Mode Group 4 Switch"),
     )
 
-    def __init__(self, host: str, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, comm_addr, timeout, retries)
+    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
@@ -228,7 +227,7 @@ class ES(Inverter):
     async def _read_setting(self, setting: Sensor) -> Any:
         count = (setting.size_ + (setting.size_ % 2)) // 2
         if self._is_modbus_setting(setting):
-            response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+            response = await self._read_from_socket(self._read_command(setting.offset, count))
             return setting.read_value(response)
         else:
             response = await self._read_from_socket(Aa55ReadCommand(setting.offset, count))
@@ -249,7 +248,7 @@ class ES(Inverter):
         if setting.size_ == 1:
             # 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(ModbusReadCommand(self.comm_addr, setting.offset, 1))
+                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))
@@ -259,12 +258,12 @@ class ES(Inverter):
         if len(raw_value) <= 2:
             value = int.from_bytes(raw_value, byteorder="big", signed=True)
             if self._is_modbus_setting(setting):
-                await self._read_from_socket(ModbusWriteCommand(self.comm_addr, setting.offset, value))
+                await self._read_from_socket(self._write_command(setting.offset, value))
             else:
                 await self._read_from_socket(Aa55WriteCommand(setting.offset, value))
         else:
             if self._is_modbus_setting(setting):
-                await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, setting.offset, raw_value))
+                await self._read_from_socket(self._write_multi_command(setting.offset, raw_value))
             else:
                 await self._read_from_socket(Aa55WriteMultiCommand(setting.offset, raw_value))
 
@@ -291,7 +290,7 @@ class ES(Inverter):
             result.remove(OperationMode.ECO_DISCHARGE)
         return tuple(result)
 
-    async def get_operation_mode(self) -> OperationMode:
+    async def get_operation_mode(self) -> OperationMode | None:
         mode_id = await self.read_setting('work_mode')
         try:
             mode = OperationMode(mode_id)

goodwe/et.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import logging
 from typing import Tuple
 
-from .exceptions import RequestFailedException, RequestRejectedException
+from .exceptions import RequestRejectedException
 from .inverter import Inverter
 from .inverter import OperationMode
 from .inverter import SensorKind as Kind
 from .model import is_2_battery, is_4_mppt, is_745_platform, is_single_phase
-from .protocol import ProtocolCommand, ModbusReadCommand, ModbusWriteCommand, ModbusWriteMultiCommand
+from .protocol import ProtocolCommand
 from .sensor import *
 
 logger = logging.getLogger(__name__)
@@ -152,6 +152,10 @@ class ET(Inverter):
                    read_bytes4_signed(data, 35182) -
                    read_bytes2_signed(data, 35140),
                    "House Consumption", "W", Kind.AC),
+
+        # Power4S("pbattery2", 35264, "Battery2 Power", Kind.BAT),
+        # Integer("battery2_mode", 35266, "Battery2 Mode code", "", Kind.BAT),
+        # Enum2("battery2_mode_label", 35184, BATTERY_MODES, "Battery2 Mode", Kind.BAT),
     )
 
     # Modbus registers from offset 0x9088 (37000)
@@ -405,18 +409,18 @@ class ET(Inverter):
         Integer("eco_mode_enable", 47612, "Eco Mode Switch"),
     )
 
-    def __init__(self, host: str, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        super().__init__(host, comm_addr, timeout, retries)
+    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
-        self._READ_DEVICE_VERSION_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x88b8, 0x0021)
-        self._READ_RUNNING_DATA: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x891c, 0x007d)
-        self._READ_METER_DATA: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x8ca0, 0x2d)
-        self._READ_METER_DATA_EXTENDED: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x8ca0, 0x3a)
-        self._READ_BATTERY_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x9088, 0x0018)
-        self._READ_BATTERY2_INFO: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x9858, 0x0016)
-        self._READ_MPPT_DATA: ProtocolCommand = ModbusReadCommand(self.comm_addr, 0x89e5, 0x3d)
+        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)
+        self._READ_METER_DATA_EXTENDED: ProtocolCommand = self._read_command(0x8ca0, 0x3a)
+        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)
         self._has_eco_mode_v2: bool = True
         self._has_peak_shaving: bool = True
         self._has_battery: bool = True
@@ -478,27 +482,21 @@ class ET(Inverter):
 
         # Check and add EcoModeV2 settings added in (ETU fw 19)
         try:
-            await self._read_from_socket(ModbusReadCommand(self.comm_addr, 47547, 6))
+            await self._read_from_socket(self._read_command(47547, 6))
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_19})
         except RequestRejectedException as ex:
             if ex.message == 'ILLEGAL DATA ADDRESS':
-                logger.debug("EcoModeV2 settings not supported, switching to EcoModeV1.")
+                logger.debug("Cannot read EcoModeV2 settings, using to EcoModeV1.")
                 self._has_eco_mode_v2 = False
-        except RequestFailedException as ex:
-            logger.debug("Cannot read EcoModeV2 settings, switching to EcoModeV1.")
-            self._has_eco_mode_v2 = False
 
         # Check and add Peak Shaving settings added in (ETU fw 22)
         try:
-            await self._read_from_socket(ModbusReadCommand(self.comm_addr, 47589, 6))
+            await self._read_from_socket(self._read_command(47589, 6))
             self._settings.update({s.id_: s for s in self.__settings_arm_fw_22})
         except RequestRejectedException as ex:
             if ex.message == 'ILLEGAL DATA ADDRESS':
-                logger.debug("PeakShaving setting not supported, disabling it.")
+                logger.debug("Cannot read PeakShaving setting, disabling it.")
                 self._has_peak_shaving = False
-        except RequestFailedException as ex:
-            logger.debug("Cannot read _has_peak_shaving settings, disabling it.")
-            self._has_peak_shaving = False
 
     async def read_runtime_data(self) -> Dict[str, Any]:
         response = await self._read_from_socket(self._READ_RUNNING_DATA)
@@ -511,7 +509,7 @@ class ET(Inverter):
                 data.update(self._map_response(response, self._sensors_battery))
             except RequestRejectedException as ex:
                 if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Battery values not supported, disabling further attempts.")
+                    logger.warning("Cannot read battery values, disabling further attempts.")
                     self._has_battery = False
                 else:
                     raise ex
@@ -522,7 +520,7 @@ class ET(Inverter):
                     self._map_response(response, self._sensors_battery2))
             except RequestRejectedException as ex:
                 if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Battery 2 values not supported, disabling further attempts.")
+                    logger.warning("Cannot read battery 2 values, disabling further attempts.")
                     self._has_battery2 = False
                 else:
                     raise ex
@@ -533,7 +531,7 @@ class ET(Inverter):
                 data.update(self._map_response(response, self._sensors_meter))
             except RequestRejectedException as ex:
                 if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("Extended meter values not supported, disabling further attempts.")
+                    logger.warning("Cannot read extended meter values, disabling further attempts.")
                     self._has_meter_extended = False
                     self._sensors_meter = tuple(filter(self._not_extended_meter, self._sensors_meter))
                     response = await self._read_from_socket(self._READ_METER_DATA)
@@ -551,7 +549,7 @@ class ET(Inverter):
                 data.update(self._map_response(response, self._sensors_mppt))
             except RequestRejectedException as ex:
                 if ex.message == 'ILLEGAL DATA ADDRESS':
-                    logger.warning("MPPT values not supported, disabling further attempts.")
+                    logger.warning("Cannot read MPPT values, disabling further attempts.")
                     self._has_mppt = False
                 else:
                     raise ex
@@ -566,7 +564,7 @@ class ET(Inverter):
 
     async def _read_setting(self, setting: Sensor) -> Any:
         count = (setting.size_ + (setting.size_ % 2)) // 2
-        response = await self._read_from_socket(ModbusReadCommand(self.comm_addr, setting.offset, count))
+        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):
@@ -578,15 +576,15 @@ class ET(Inverter):
     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(ModbusReadCommand(self.comm_addr, setting.offset, 1))
+            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(ModbusWriteCommand(self.comm_addr, setting.offset, value))
+            await self._read_from_socket(self._write_command(setting.offset, value))
         else:
-            await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, setting.offset, raw_value))
+            await self._read_from_socket(self._write_multi_command(setting.offset, raw_value))
 
     async def read_settings_data(self) -> Dict[str, Any]:
         data = {}
@@ -617,7 +615,7 @@ class ET(Inverter):
             result.remove(OperationMode.ECO_DISCHARGE)
         return tuple(result)
 
-    async def get_operation_mode(self) -> OperationMode:
+    async def get_operation_mode(self) -> OperationMode | None:
         mode_id = await self.read_setting('work_mode')
         try:
             mode = OperationMode(mode_id)
@@ -705,8 +703,8 @@ class ET(Inverter):
         return tuple(self._settings.values())
 
     async def _clear_battery_mode_param(self) -> None:
-        await self._read_from_socket(ModbusWriteCommand(self.comm_addr, 0xb9ad, 1))
+        await self._read_from_socket(self._write_command(0xb9ad, 1))
 
     async def _set_offline(self, mode: bool) -> None:
         value = bytes.fromhex('00070000') if mode else bytes.fromhex('00010000')
-        await self._read_from_socket(ModbusWriteMultiCommand(self.comm_addr, 0xb997, value))
+        await self._read_from_socket(self._write_multi_command(0xb997, value))

goodwe/inverter.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -8,7 +7,7 @@ from enum import Enum, IntEnum
 from typing import Any, Callable, Dict, Tuple, Optional
 
 from .exceptions import MaxRetriesException, RequestFailedException
-from .protocol import ProtocolCommand, ProtocolResponse
+from .protocol import InverterProtocol, ProtocolCommand, ProtocolResponse, TcpInverterProtocol, UdpInverterProtocol
 
 logger = logging.getLogger(__name__)
 
@@ -87,15 +86,12 @@ class Inverter(ABC):
     Represents the inverter state and its basic behavior
     """
 
-    def __init__(self, host: str, comm_addr: int = 0, timeout: int = 1, retries: int = 3):
-        self.host: str = host
-        self.comm_addr: int = comm_addr
-        self.timeout: int = timeout
-        self.retries: int = retries
-        self._running_loop: asyncio.AbstractEventLoop | None = None
-        self._lock: asyncio.Lock | None = None
+    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._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,36 +105,30 @@ class Inverter(ABC):
         self.arm_version: int = 0
         self.arm_svn_version: int | None = None
 
-    def _ensure_lock(self) -> asyncio.Lock:
-        """Validate (or create) asyncio Lock.
+    def _read_command(self, offset: int, count: int) -> ProtocolCommand:
+        """Create read protocol command."""
+        return self._protocol.read_command(self.comm_addr, offset, count)
 
-           The asyncio.Lock must always be created from within's asyncio loop,
-           so it cannot be eagerly created in constructor.
-           Additionally, since asyncio.run() creates and closes its own loop,
-           the lock's scope (its creating loop) mus be verified to support proper
-           behavior in subsequent asyncio.run() invocations.
-        """
-        if self._lock and self._running_loop == asyncio.get_event_loop():
-            return self._lock
-        else:
-            logger.debug("Creating lock instance for current event loop.")
-            self._lock = asyncio.Lock()
-            self._running_loop = asyncio.get_event_loop()
-            return self._lock
+    def _write_command(self, register: int, value: int) -> ProtocolCommand:
+        """Create write protocol command."""
+        return self._protocol.write_command(self.comm_addr, 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)
 
     async def _read_from_socket(self, command: ProtocolCommand) -> ProtocolResponse:
-        async with self._ensure_lock():
-            try:
-                result = await command.execute(self.host, self.timeout, self.retries)
-                self._consecutive_failures_count = 0
-                return result
-            except MaxRetriesException:
-                self._consecutive_failures_count += 1
-                raise RequestFailedException(f'No valid response received even after {self.retries} retries',
-                                             self._consecutive_failures_count)
-            except RequestFailedException as ex:
-                self._consecutive_failures_count += 1
-                raise RequestFailedException(ex.message, self._consecutive_failures_count)
+        try:
+            result = await command.execute(self._protocol)
+            self._consecutive_failures_count = 0
+            return result
+        except MaxRetriesException:
+            self._consecutive_failures_count += 1
+            raise RequestFailedException(f'No valid response received even after {self._protocol.retries} retries',
+                                         self._consecutive_failures_count) from None
+        except RequestFailedException as ex:
+            self._consecutive_failures_count += 1
+            raise RequestFailedException(ex.message, self._consecutive_failures_count) from None
 
     @abstractmethod
     async def read_device_info(self):
@@ -190,8 +180,8 @@ class Inverter(ABC):
             self, command: bytes, validator: Callable[[bytes], bool] = lambda x: True
     ) -> ProtocolResponse:
         """
-        Send low level udp command (as bytes).
-        Answer command's raw response data.
+        Send low level command (as bytes).
+        Answer ProtocolResponse with command's raw response data.
         """
         return await self._read_from_socket(ProtocolCommand(command, validator))
 
@@ -277,6 +267,13 @@ class Inverter(ABC):
         """
         raise NotImplementedError()
 
+    @staticmethod
+    def _create_protocol(host: str, port: int, timeout: int, retries: int) -> InverterProtocol:
+        if port == 502:
+            return TcpInverterProtocol(host, port, timeout, retries)
+        else:
+            return UdpInverterProtocol(host, port, timeout, retries)
+
     @staticmethod
     def _map_response(response: ProtocolResponse, sensors: Tuple[Sensor, ...]) -> Dict[str, Any]:
         """Process the response data and return dictionary with runtime values"""

goodwe/modbus.py

@@ -52,9 +52,9 @@ def _modbus_checksum(data: Union[bytearray, bytes]) -> int:
     return crc
 
 
-def create_modbus_request(comm_addr: int, cmd: int, offset: int, value: int) -> bytes:
+def create_modbus_rtu_request(comm_addr: int, cmd: int, offset: int, value: int) -> bytes:
     """
-    Create modbus request.
+    Create modbus RTU request.
     data[0] is inverter address
     data[1] is modbus command
     data[2:3] is command offset parameter
@@ -74,9 +74,36 @@ def create_modbus_request(comm_addr: int, cmd: int, offset: int, value: int) ->
     return bytes(data)
 
 
-def create_modbus_multi_request(comm_addr: int, cmd: int, offset: int, values: bytes) -> bytes:
+def create_modbus_tcp_request(comm_addr: int, cmd: int, offset: int, value: int) -> bytes:
     """
-    Create modbus (multi value) request.
+    Create modbus TCP request.
+    data[0:1] is transaction identifier
+    data[2:3] is protocol identifier (0)
+    data[4:5] message length
+    data[6] is inverter address
+    data[7] is modbus command
+    data[8:9] is command offset parameter
+    data[10:11] is command value parameter
+    """
+    data: bytearray = bytearray(12)
+    data[0] = 0
+    data[1] = 1  # Not transaction ID support yet
+    data[2] = 0
+    data[3] = 0
+    data[4] = 0
+    data[5] = 6
+    data[6] = comm_addr
+    data[7] = cmd
+    data[8] = (offset >> 8) & 0xFF
+    data[9] = offset & 0xFF
+    data[10] = (value >> 8) & 0xFF
+    data[11] = value & 0xFF
+    return bytes(data)
+
+
+def create_modbus_rtu_multi_request(comm_addr: int, cmd: int, offset: int, values: bytes) -> bytes:
+    """
+    Create modbus RTU (multi value) request.
     data[0] is inverter address
     data[1] is modbus command
     data[2:3] is command offset parameter
@@ -100,9 +127,40 @@ def create_modbus_multi_request(comm_addr: int, cmd: int, offset: int, values: b
     return bytes(data)
 
 
-def validate_modbus_response(data: bytes, cmd: int, offset: int, value: int) -> bool:
+def create_modbus_tcp_multi_request(comm_addr: int, cmd: int, offset: int, values: bytes) -> bytes:
+    """
+    Create modbus TCP (multi value) request.
+    data[0:1] is transaction identifier
+    data[2:3] is protocol identifier (0)
+    data[4:5] message length
+    data[6] is inverter address
+    data[7] is modbus command
+    data[8:9] is command offset parameter
+    data[10:11] is number of registers
+    data[12] is number of bytes
+    data[13-n] is data payload
     """
-    Validate the modbus response.
+    data: bytearray = bytearray(13)
+    data[0] = 0
+    data[1] = 1  # Not transaction ID support yet
+    data[2] = 0
+    data[3] = 0
+    data[4] = 0
+    data[5] = 7 + len(values)
+    data[6] = comm_addr
+    data[7] = cmd
+    data[8] = (offset >> 8) & 0xFF
+    data[9] = offset & 0xFF
+    data[10] = 0
+    data[11] = len(values) // 2
+    data[12] = len(values)
+    data.extend(values)
+    return bytes(data)
+
+
+def validate_modbus_rtu_response(data: bytes, cmd: int, offset: int, value: int) -> bool:
+    """
+    Validate the modbus RTU response.
     data[0:1] is header
     data[2] is source address
     data[3] is command return type
@@ -147,3 +205,45 @@ def validate_modbus_response(data: bytes, cmd: int, offset: int, value: int) ->
         raise RequestRejectedException(failure_code)
 
     return True
+
+
+def validate_modbus_tcp_response(data: bytes, cmd: int, offset: int, value: int) -> bool:
+    """
+    Validate the modbus TCP response.
+    data[0:1] is transaction identifier
+    data[2:3] is protocol identifier (0)
+    data[4:5] message length
+    data[6] is source address
+    data[7] is command return type
+    data[8] is response payload length (for read commands)
+    """
+    if len(data) <= 8:
+        logger.debug("Response is too short.")
+        return False
+    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)
+            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
+        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)
+            return False
+        response_value = int.from_bytes(data[10:12], byteorder='big', signed=True)
+        if response_value != value:
+            logger.debug("Response has wrong value: %X, expected %X.", response_value, value)
+            return False
+
+    if data[7] != cmd:
+        failure_code = FAILURE_CODES.get(data[8], "UNKNOWN")
+        logger.debug("Response is command failure: %s.", FAILURE_CODES.get(data[8], "UNKNOWN"))
+        raise RequestRejectedException(failure_code)
+
+    return True

goodwe/protocol.py

@@ -6,80 +6,306 @@ import logging
 from asyncio.futures import Future
 from typing import Tuple, Optional, Callable
 
-from .const import GOODWE_UDP_PORT
 from .exceptions import MaxRetriesException, RequestFailedException, RequestRejectedException
-from .modbus import create_modbus_request, create_modbus_multi_request, validate_modbus_response, MODBUS_READ_CMD, \
+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__)
 
 
-class UdpInverterProtocol(asyncio.DatagramProtocol):
-    def __init__(
-            self,
-            response_future: Future,
-            command: ProtocolCommand,
-            timeout: int,
-            retries: int
-    ):
-        super().__init__()
-        self.response_future: Future = response_future
-        self.command: ProtocolCommand = command
+class InverterProtocol:
+
+    def __init__(self, host: str, port: int, timeout: int, retries: int):
+        self._host: str = host
+        self._port: int = port
+        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.protocol: asyncio.Protocol | None = None
+        self.response_future: Future | None = None
+        self.command: ProtocolCommand | None = None
+
+    def _ensure_lock(self) -> asyncio.Lock:
+        """Validate (or create) asyncio Lock.
+
+           The asyncio.Lock must always be created from within's asyncio loop,
+           so it cannot be eagerly created in constructor.
+           Additionally, since asyncio.run() creates and closes its own loop,
+           the lock's scope (its creating loop) mus be verified to support proper
+           behavior in subsequent asyncio.run() invocations.
+        """
+        if self._lock and self._running_loop == asyncio.get_event_loop():
+            return self._lock
+        else:
+            logger.debug("Creating lock instance for current event loop.")
+            self._lock = asyncio.Lock()
+            self._running_loop = asyncio.get_event_loop()
+            self._close_transport()
+            return self._lock
+
+    def _close_transport(self) -> None:
+        raise NotImplementedError()
+
+    async def send_request(self, command: ProtocolCommand) -> Future:
+        raise NotImplementedError()
+
+    def read_command(self, comm_addr: int, offset: int, count: int) -> ProtocolCommand:
+        """Create read protocol command."""
+        raise NotImplementedError()
+
+    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+        """Create write protocol command."""
+        raise NotImplementedError()
+
+    def write_multi_command(self, comm_addr: int, 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)
         self._transport: asyncio.transports.DatagramTransport | None = None
-        self._retry_timeout: int = timeout
-        self._max_retries: int = retries
-        self._retries: int = 0
+        self._retry: int = 0
+
+    def read_command(self, comm_addr: int, offset: int, count: int) -> ProtocolCommand:
+        """Create read protocol command."""
+        return ModbusRtuReadCommand(comm_addr, offset, count)
+
+    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+        """Create write protocol command."""
+        return ModbusRtuWriteCommand(comm_addr, register, value)
+
+    def write_multi_command(self, comm_addr: int, offset: int, values: bytes) -> ProtocolCommand:
+        """Create write multiple protocol command."""
+        return ModbusRtuWriteMultiCommand(comm_addr, offset, values)
+
+    async def _connect(self) -> None:
+        if not self._transport or self._transport.is_closing():
+            self._transport, self.protocol = await asyncio.get_running_loop().create_datagram_endpoint(
+                lambda: self,
+                remote_addr=(self._host, self._port),
+            )
 
     def connection_made(self, transport: asyncio.DatagramTransport) -> None:
         """On connection made"""
         self._transport = transport
-        self._send_request()
 
     def connection_lost(self, exc: Optional[Exception]) -> None:
         """On connection lost"""
-        if exc is not None:
+        if exc:
             logger.debug("Socket closed with error: %s.", exc)
-        # Cancel Future on connection lost
-        if not self.response_future.done():
-            self.response_future.cancel()
+        else:
+            logger.debug("Socket closed.")
+        self._close_transport()
 
     def datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None:
         """On datagram received"""
+        if self._timer:
+            self._timer.cancel()
+            self._timer = None
         try:
             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())
-                self._retries += 1
-                self._send_request()
+                asyncio.get_running_loop().call_soon(self._retry_mechanism)
         except RequestRejectedException as ex:
             logger.debug("Received exception response: %s", data.hex())
             self.response_future.set_exception(ex)
+            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()
+
+    async def send_request(self, command: ProtocolCommand) -> Future:
+        """Send message via transport"""
+        async with self._ensure_lock():
+            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
 
-    def _send_request(self) -> None:
+    def _send_request(self, command: ProtocolCommand, response_future: Future) -> None:
         """Send message via transport"""
+        self.command = command
+        self.response_future = response_future
         logger.debug("Sending: %s%s", self.command,
-                     f' - retry #{self._retries}/{self._max_retries}' if self._retries > 0 else '')
+                     f' - retry #{self._retry}/{self.retries}' if self._retry > 0 else '')
         self._transport.sendto(self.command.request)
-        asyncio.get_event_loop().call_later(self._retry_timeout, self._retry_mechanism)
+        self._timer = asyncio.get_running_loop().call_later(self.timeout, self._retry_mechanism)
 
     def _retry_mechanism(self) -> None:
         """Retry mechanism to prevent hanging transport"""
         if self.response_future.done():
-            self._transport.close()
-        elif self._retries < self._max_retries:
-            logger.debug("Failed to receive response to %s in time (%ds).", self.command, self._retry_timeout)
-            self._retries += 1
-            self._send_request()
+            logger.debug("Response already received.")
+        elif self._retry < self.retries:
+            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._max_retries, self.command)
+            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()
+
+
+class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
+    def __init__(self, host: str, port: int, timeout: int = 1, retries: int = 0):
+        super().__init__(host, port, 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:
+        """Create read protocol command."""
+        return ModbusTcpReadCommand(comm_addr, offset, count)
+
+    def write_command(self, comm_addr: int, register: int, value: int) -> ProtocolCommand:
+        """Create write protocol command."""
+        return ModbusTcpWriteCommand(comm_addr, register, value)
+
+    def write_multi_command(self, comm_addr: int, offset: int, values: bytes) -> ProtocolCommand:
+        """Create write multiple protocol command."""
+        return ModbusTcpWriteMultiCommand(comm_addr, offset, values)
+
+    async def _connect(self) -> None:
+        if not self._transport or self._transport.is_closing():
+            logger.debug("Opening connection.")
+            self._transport, self.protocol = await asyncio.get_running_loop().create_connection(
+                lambda: self,
+                host=self._host, port=self._port,
+            )
+
+    def connection_made(self, transport: asyncio.DatagramTransport) -> None:
+        """On connection made"""
+        logger.debug("Connection opened.")
+        pass
+
+    def eof_received(self) -> None:
+        logger.debug("EOF received.")
+        self._close_transport()
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        """On connection lost"""
+        if exc:
+            logger.debug("Connection closed with error: %s.", exc)
+        else:
+            logger.debug("Connection closed.")
+        self._close_transport()
+
+    def data_received(self, data: bytes) -> None:
+        """On data received"""
+        if self._timer:
+            self._timer.cancel()
+        try:
+            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())
+                self.response_future.set_exception(RequestRejectedException())
+                self._close_transport()
+        except RequestRejectedException as ex:
+            logger.debug("Received exception response: %s", data.hex())
+            self.response_future.set_exception(ex)
+            # 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()
+
+    async def send_request(self, command: ProtocolCommand) -> Future:
+        """Send message via transport"""
+        await self._ensure_lock().acquire()
+        try:
+            await self._connect()
+            response_future = asyncio.get_running_loop().create_future()
+            self._send_request(command, response_future)
+            await response_future
+            return response_future
+        except asyncio.CancelledError:
+            if self._retry < self.retries:
+                if self._timer:
+                    logger.debug("Connection broken error")
+                self._retry += 1
+                if self._lock and self._lock.locked():
+                    self._lock.release()
+                self._close_transport()
+                return await self.send_request(command)
+            else:
+                return self._max_retries_reached()
+        except (ConnectionRefusedError, TimeoutError) as exc:
+            if self._retry < self.retries:
+                logger.debug("Connection refused error: %s", exc)
+                self._retry += 1
+                if self._lock and self._lock.locked():
+                    self._lock.release()
+                return await self.send_request(command)
+            else:
+                return self._max_retries_reached()
+        finally:
+            if self._lock and self._lock.locked():
+                self._lock.release()
+
+    def _send_request(self, command: ProtocolCommand, response_future: Future) -> None:
+        """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)
+        self._timer = asyncio.get_running_loop().call_later(self.timeout, self._timeout_mechanism)
+
+    def _timeout_mechanism(self) -> None:
+        """Retry mechanism to prevent hanging transport"""
+        if self.response_future.done():
+            self._retry = 0
+        else:
+            if self._timer:
+                logger.debug("Failed to receive response to %s in time (%ds).", self.command, self.timeout)
+                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()
 
 
 class ProtocolResponse:
@@ -136,22 +362,14 @@ class ProtocolCommand:
         """Calculate relative offset to start of the response bytes"""
         return address
 
-    async def execute(self, host: str, timeout: int, retries: int) -> ProtocolResponse:
+    async def execute(self, protocol: InverterProtocol) -> ProtocolResponse:
         """
-        Execute the udp protocol command on the specified address/port.
-        Since the UDP communication is by definition unreliable, when no (valid) response is received by specified
-        timeout, the command will be re-tried up to retries times.
+        Execute the protocol command on the specified connection.
 
-        Return raw response data
+        Return ProtocolResponse with raw response data
         """
-        loop = asyncio.get_running_loop()
-        response_future = loop.create_future()
-        transport, _ = await loop.create_datagram_endpoint(
-            lambda: UdpInverterProtocol(response_future, self, timeout, retries),
-            remote_addr=(host, GOODWE_UDP_PORT),
-        )
         try:
-            await response_future
+            response_future = await protocol.send_request(self)
             result = response_future.result()
             if result is not None:
                 return ProtocolResponse(result, self)
@@ -159,12 +377,10 @@ class ProtocolCommand:
                 raise RequestFailedException(
                     "No response received to '" + self.request.hex() + "' request."
                 )
-        except asyncio.CancelledError:
+        except (asyncio.CancelledError, ConnectionRefusedError):
             raise RequestFailedException(
                 "No valid response received to '" + self.request.hex() + "' request."
             ) from None
-        finally:
-            transport.close()
 
 
 class Aa55ProtocolCommand(ProtocolCommand):
@@ -257,7 +473,7 @@ class Aa55WriteMultiCommand(Aa55ProtocolCommand):
                          "02B9")
 
 
-class ModbusProtocolCommand(ProtocolCommand):
+class ModbusRtuProtocolCommand(ProtocolCommand):
     """
     Inverter communication protocol seen on newer generation of inverters, based on Modbus
     protocol over UDP transport layer.
@@ -282,7 +498,7 @@ class ModbusProtocolCommand(ProtocolCommand):
     def __init__(self, request: bytes, cmd: int, offset: int, value: int):
         super().__init__(
             request,
-            lambda x: validate_modbus_response(x, cmd, offset, value),
+            lambda x: validate_modbus_rtu_response(x, cmd, offset, value),
         )
         self.first_address: int = offset
         self.value = value
@@ -296,14 +512,78 @@ class ModbusProtocolCommand(ProtocolCommand):
         return (address - self.first_address) * 2
 
 
-class ModbusReadCommand(ModbusProtocolCommand):
+class ModbusRtuReadCommand(ModbusRtuProtocolCommand):
     """
-    Inverter modbus READ command for retrieving <count> modbus registers starting at register # <offset>
+    Inverter Modbus/RTU READ command for retrieving <count> modbus registers starting at register # <offset>
+    """
+
+    def __init__(self, comm_addr: int, offset: int, count: int):
+        super().__init__(
+            create_modbus_rtu_request(comm_addr, MODBUS_READ_CMD, offset, count),
+            MODBUS_READ_CMD, offset, count)
+
+    def __repr__(self):
+        if self.value > 1:
+            return f'READ {self.value} registers from {self.first_address} ({self.request.hex()})'
+        else:
+            return f'READ register {self.first_address} ({self.request.hex()})'
+
+
+class ModbusRtuWriteCommand(ModbusRtuProtocolCommand):
+    """
+    Inverter Modbus/RTU WRITE command setting single modbus register # <register> value <value>
+    """
+
+    def __init__(self, comm_addr: int, register: int, value: int):
+        super().__init__(
+            create_modbus_rtu_request(comm_addr, MODBUS_WRITE_CMD, register, value),
+            MODBUS_WRITE_CMD, register, value)
+
+    def __repr__(self):
+        return f'WRITE {self.value} to register {self.first_address} ({self.request.hex()})'
+
+
+class ModbusRtuWriteMultiCommand(ModbusRtuProtocolCommand):
+    """
+    Inverter Modbus/RTU WRITE command setting multiple modbus register # <register> value <value>
+    """
+
+    def __init__(self, comm_addr: int, offset: int, values: bytes):
+        super().__init__(
+            create_modbus_rtu_multi_request(comm_addr, MODBUS_WRITE_MULTI_CMD, offset, values),
+            MODBUS_WRITE_MULTI_CMD, offset, len(values) // 2)
+
+
+class ModbusTcpProtocolCommand(ProtocolCommand):
+    """
+    Modbus/TCP inverter communication protocol.
+    """
+
+    def __init__(self, request: bytes, cmd: int, offset: int, value: int):
+        super().__init__(
+            request,
+            lambda x: validate_modbus_tcp_response(x, cmd, offset, value),
+        )
+        self.first_address: int = offset
+        self.value = value
+
+    def trim_response(self, raw_response: bytes):
+        """Trim raw response from header and checksum data"""
+        return raw_response[9:]
+
+    def get_offset(self, address: int):
+        """Calculate relative offset to start of the response bytes"""
+        return (address - self.first_address) * 2
+
+
+class ModbusTcpReadCommand(ModbusTcpProtocolCommand):
+    """
+    Inverter Modbus/TCP READ command for retrieving <count> modbus registers starting at register # <offset>
     """
 
     def __init__(self, comm_addr: int, offset: int, count: int):
         super().__init__(
-            create_modbus_request(comm_addr, MODBUS_READ_CMD, offset, count),
+            create_modbus_tcp_request(comm_addr, MODBUS_READ_CMD, offset, count),
             MODBUS_READ_CMD, offset, count)
 
     def __repr__(self):
@@ -313,26 +593,26 @@ class ModbusReadCommand(ModbusProtocolCommand):
             return f'READ register {self.first_address} ({self.request.hex()})'
 
 
-class ModbusWriteCommand(ModbusProtocolCommand):
+class ModbusTcpWriteCommand(ModbusTcpProtocolCommand):
     """
-    Inverter modbus WRITE command setting single modbus register # <register> value <value>
+    Inverter Modbus/TCP WRITE command setting single modbus register # <register> value <value>
     """
 
     def __init__(self, comm_addr: int, register: int, value: int):
         super().__init__(
-            create_modbus_request(comm_addr, MODBUS_WRITE_CMD, register, value),
+            create_modbus_tcp_request(comm_addr, MODBUS_WRITE_CMD, register, value),
             MODBUS_WRITE_CMD, register, value)
 
     def __repr__(self):
         return f'WRITE {self.value} to register {self.first_address} ({self.request.hex()})'
 
 
-class ModbusWriteMultiCommand(ModbusProtocolCommand):
+class ModbusTcpWriteMultiCommand(ModbusTcpProtocolCommand):
     """
-    Inverter modbus WRITE command setting multiple modbus register # <register> value <value>
+    Inverter Modbus/TCP WRITE command setting multiple modbus register # <register> value <value>
     """
 
     def __init__(self, comm_addr: int, offset: int, values: bytes):
         super().__init__(
-            create_modbus_multi_request(comm_addr, MODBUS_WRITE_MULTI_CMD, offset, values),
+            create_modbus_tcp_multi_request(comm_addr, MODBUS_WRITE_MULTI_CMD, offset, values),
             MODBUS_WRITE_MULTI_CMD, offset, len(values) // 2)

goodwe/sensor.py

@@ -881,12 +881,15 @@ def read_freq(buffer: ProtocolResponse, offset: int = None) -> float:
     return float(value) / 100
 
 
-def read_temp(buffer: ProtocolResponse, offset: int = None) -> float:
+def read_temp(buffer: ProtocolResponse, offset: int = None) -> float | None:
     """Retrieve temperature [C] value (2 bytes) from buffer"""
     if offset is not None:
         buffer.seek(offset)
     value = int.from_bytes(buffer.read(2), byteorder="big", signed=True)
-    return float(value) / 10
+    if value == 32767:
+        return None
+    else:
+        return float(value) / 10
 
 
 def read_datetime(buffer: ProtocolResponse, offset: int = None) -> datetime:

{goodwe-0.3.5.dist-info → goodwe-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goodwe
-Version: 0.3.5
+Version: 0.4.0
 Summary: Read data from GoodWe inverter via local network
 Home-page: https://github.com/marcelblijleven/goodwe
 Author: Martin Letenay, Marcel Blijleven
@@ -32,15 +32,21 @@ License-File: LICENSE
 Library for connecting to GoodWe inverter over local network and retrieving runtime sensor values and configuration
 parameters.
 
-It has been reported to work on GoodWe ET, EH, BT, BH, ES, EM, BP, DT, MS, D-NS, and XS families of inverters. It may
-work on other inverters as well, as long as they listen on UDP port 8899 and respond to one of supported communication
-protocols.
+It has been reported to work with GoodWe ET, EH, BT, BH, ES, EM, BP, DT, MS, D-NS, and XS families of inverters. It
+should work with other inverters as well, as long as they listen on UDP port 8899 and respond to one of supported
+communication protocols.
+In general, if you can connect to your inverter with the official mobile app (SolarGo/PvMaster) over Wi-Fi (not
+bluetooth), this library should work.
 
 (If you can't communicate with the inverter despite your model is listed above, it is possible you have old ARM firmware
 version. You should ask manufacturer support to upgrade your ARM firmware (not just inverter firmware) to be able to
-communicate with the inveter via UDP.)
+communicate with the inverter via UDP.)
 
-White-label (GoodWe manufactured) inverters may work as well, e.g. General Electric GEP (PSB, PSC) and GEH models.
+White-label (GoodWe manufactured) inverters may work as well, e.g. General Electric GEP (PSB, PSC) and GEH models are
+know to work properly.
+
+Since v0.4.x the library also supports standard Modbus/TCP over port 502.
+This protocol is supported by the V2.0 version of LAN+WiFi communication dongle (model WLA0000-01-00P).
 
 ## Usage
 
@@ -72,4 +78,3 @@ asyncio.run(get_runtime_data())
 - https://github.com/mletenay/home-assistant-goodwe-inverter
 - https://github.com/yasko-pv/modbus-log
 - https://github.com/tkubec/GoodWe
-- https://github.com/OpenEMS/openems

goodwe-0.4.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+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=VJxCl54DILBRFQTmm-9K2yqS_QbBVMDvPFNv8dr0z7Y,39676
+goodwe/exceptions.py,sha256=I6PHG0GTWgxNrDVZwJZBnyzItRq5eiM6ci23-EEsn1I,1012
+goodwe/inverter.py,sha256=JIKYcOLihxCG1_m7HGMoFgVR1dyO8F0OXP5q1ClQJ-w,10336
+goodwe/modbus.py,sha256=sFmkBgylwJkZd64a52fOUst6Rde5Vm3JsAm3Nh3s6e8,8151
+goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
+goodwe/protocol.py,sha256=_jPwIlKE5ou2X3_3PDTUzsgBLLD1dzAdyt5DJOsWTWA,24873
+goodwe/sensor.py,sha256=fWMYyr3Vw02axfGvL7y7YUH2LmfE4A_lsIulX0Zpy5c,37054
+goodwe-0.4.0.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.4.0.dist-info/METADATA,sha256=CRS4h7iSlxExGN2ZjLungFGwuI7d85g-TlVRbnPx6vU,3376
+goodwe-0.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+goodwe-0.4.0.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.4.0.dist-info/RECORD,,

goodwe-0.3.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=PInrrZEpTmMOQKk494vIz8EKSaw_qLBNz-6t9eLIUcg,5642
-goodwe/const.py,sha256=Nw-nd4UJuqUOLfbmOrxTHEdS1AuaTDSpZzQqR6tBb8w,7912
-goodwe/dt.py,sha256=bI53MVdZjtxTYU2qJLO8icsvF6UiXrkgH95V3iUwXT0,10581
-goodwe/es.py,sha256=XBP7txg9d4tMsFmHWs8LB4wdJmspKVD9ALfS9mePiJk,22650
-goodwe/et.py,sha256=0XFwRMZeUdKZ4dhGANpw2o1EKsfgJGdGYsN95zhxV1s,40084
-goodwe/exceptions.py,sha256=I6PHG0GTWgxNrDVZwJZBnyzItRq5eiM6ci23-EEsn1I,1012
-goodwe/inverter.py,sha256=7DgIzSHimkVAfNyIkzALeukHOHkOuYjVyUIvuT0LHdE,10342
-goodwe/modbus.py,sha256=ZPib-zKnOVE5zc0RNnhlf0w_26QBees1ScWGo6bAj0o,4685
-goodwe/model.py,sha256=dWBjMFJMnhZoUdDd9fGT54DERDANz4TirK0Wy8kWMbk,2068
-goodwe/protocol.py,sha256=pUkXTP2DqpKXGO7rbRfHq1x82Y1QM6OiRVx8cAtS0sM,13162
-goodwe/sensor.py,sha256=vFbsz4Dp0yw0rBNdKqzkMUupuBJWC17YcxvBrjvFAjU,36990
-goodwe-0.3.5.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.3.5.dist-info/METADATA,sha256=aITPWNoquftA7VYNraUZqMoO8Bu-DXQ98ZAJxhsHtZM,3050
-goodwe-0.3.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-goodwe-0.3.5.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.3.5.dist-info/RECORD,,