goodwe 0.3.5__tar.gz → 0.4.0__tar.gz

{goodwe-0.3.5/goodwe.egg-info → goodwe-0.4.0}/PKG-INFO

@@ -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.3.5 → goodwe-0.4.0}/README.md

@@ -8,15 +8,21 @@
 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
 
@@ -48,4 +54,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/VERSION

@@ -0,0 +1 @@
+0.4.0

{goodwe-0.3.5 → goodwe-0.4.0}/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-0.3.5 → goodwe-0.4.0}/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-0.3.5 → goodwe-0.4.0}/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-0.3.5 → goodwe-0.4.0}/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-0.3.5 → goodwe-0.4.0}/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-0.3.5 → goodwe-0.4.0}/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"""