goodwe 0.3.6__py3-none-any.whl → 0.4.1__py3-none-any.whl

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__)
 
@@ -23,6 +22,7 @@ class SensorKind(Enum):
     UPS - inverter ups/eps/backup output (e.g. ac voltage of backup/off-grid connected output)
     BAT - battery (e.g. dc voltage of connected battery pack)
     GRID - power grid/smart meter (e.g. active power exported to grid)
+    BMS - BMS direct data (e.g. dc voltage of)
     """
 
     PV = 1
@@ -30,6 +30,7 @@ class SensorKind(Enum):
     UPS = 3
     BAT = 4
     GRID = 5
+    BMS = 6
 
 
 @dataclass
@@ -87,15 +88,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 +107,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 +182,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 +269,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

@@ -9,9 +9,11 @@ MODBUS_READ_CMD: int = 0x3
 MODBUS_WRITE_CMD: int = 0x6
 MODBUS_WRITE_MULTI_CMD: int = 0x10
 
+ILLEGAL_DATA_ADDRESS = 'ILLEGAL DATA ADDRESS'
+
 FAILURE_CODES = {
     1: "ILLEGAL FUNCTION",
-    2: "ILLEGAL DATA ADDRESS",
+    2: ILLEGAL_DATA_ADDRESS,
     3: "ILLEGAL DATA VALUE",
     4: "SLAVE DEVICE FAILURE",
     5: "ACKNOWLEDGE",
@@ -52,9 +54,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 +76,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 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
     """
-    Create modbus (multi value) request.
+    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 +129,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
+    """
+    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 response.
+    Validate the modbus RTU response.
     data[0:1] is header
     data[2] is source address
     data[3] is command return type
@@ -147,3 +207,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/model.py

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