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

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/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)

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)