Update for pymodbus 3.6.x

Author: ccrisan

README.md

@@ -97,6 +97,27 @@ peripherals = [
 ...
 ```
 
+### Passive Tcpdump Client
+
+##### `qtoggleserver.conf:`
+``` ini
+...
+peripherals = [
+    ...
+    {
+        driver = "qtoggleserver.modbus.ModbusTcpDumpClient"
+        port = 5020                     # TCP port to sniff
+        iface = "eth0"                  # network interface to sniff (defaults to `any`)
+        master_ip = "192.168.1.122"     # IP address of the master Modbus machine (optional) 
+        slave_ip = "192.168.1.123"      # IP address of the slave Modbus machine (optional)
+        tcpdumo = "/usr/bin/tcpdump"    # full path to the `tcpdump` binary (optional) 
+        # see below for common parameters
+    }
+    ...
+]
+...
+```
+
 ### Common Parameters
 
 The following parameters are common to all types of Modbus clients and servers:

qtoggleserver/modbus/client.py

@@ -7,8 +7,8 @@
 from pymodbus.client import (
     AsyncModbusSerialClient as InternalAsyncModbusSerialClient,
     AsyncModbusTcpClient as InternalAsyncModbusTcpClient,
-    ModbusBaseClient as InternalModbusBaseClient,
 )
+from pymodbus.client.base import ModbusBaseClient as InternalModbusBaseClient
 from pymodbus.pdu import ExceptionResponse
 
 from qtoggleserver.core import ports as core_ports
@@ -101,22 +101,25 @@ async def ensure_client(self) -> bool:
             self.debug('waiting %d seconds for initial delay', self.initial_delay)
             await asyncio.sleep(self.initial_delay)
 
+        while not self._pymodbus_client.connected:
+            await asyncio.sleep(0.1)
+
         if not self._pymodbus_client.connected:
             self.warning('could not connect to unit')
             # Don't leave the client (partially) connected
             try:
-                await self._pymodbus_client.close()
+                self._pymodbus_client.close()
             except Exception:
                 # We don't care if connection closing fails - we're going to recreate the client from scratch anyway
                 pass
             return False
 
         return True
 
-    async def close_client(self) -> None:
+    def close_client(self) -> None:
         self.info('disconnecting from unit')
         try:
-            await self._pymodbus_client.close()
+            self._pymodbus_client.close()
         except Exception:
             # We don't care if connection closing fails - we're going to recreate the client from scratch anyway
             pass
@@ -142,7 +145,7 @@ async def handle_enable(self) -> None:
 
     async def handle_disable(self) -> None:
         await super().handle_disable()
-        await self.close_client()
+        self.close_client()
 
     async def poll(self) -> None:
         if not await self.ensure_client():
@@ -271,14 +274,14 @@ def __init__(
         serial_baud: int = DEFAULT_SERIAL_BAUD,
         serial_stopbits: int = DEFAULT_SERIAL_STOPBITS,
         serial_bytesize: int = DEFAULT_SERIAL_BYTESIZE,
-        serial_parity: int = DEFAULT_SERIAL_PARITY,
+        serial_parity: str = DEFAULT_SERIAL_PARITY,
         **kwargs
     ) -> None:
         self.serial_port: str = serial_port
         self.serial_baud: int = serial_baud
         self.serial_stopbits: int = serial_stopbits
         self.serial_bytesize: int = serial_bytesize
-        self.serial_parity: int = serial_parity
+        self.serial_parity: str = serial_parity
 
         kwargs.setdefault('method', self.DEFAULT_METHOD)
 
@@ -329,7 +332,7 @@ async def make_internal_client(self) -> InternalModbusBaseClient:
     def handle_offline(self) -> None:
         # Automatically close and cleanup any existing client if peripheral goes offline. We want to start from scratch
         # with a brand-new client.
-        asyncio.create_task(self.close_client())
+        self.close_client()
 
 
 class BasePassiveModbusClient(BaseModbusClient, metaclass=abc.ABCMeta):

qtoggleserver/modbus/passive/base.py

@@ -3,8 +3,8 @@
 
 from typing import List, Optional, Union
 
-from pymodbus import bit_read_message, bit_write_message, register_read_message, register_write_message
-from pymodbus.client import ModbusBaseClient as InternalModbusBaseClient
+from pymodbus import Framer, bit_read_message, bit_write_message, register_read_message, register_write_message
+from pymodbus.client.base import ModbusBaseClient as InternalModbusBaseClient
 
 
 class InternalPassiveException(Exception):
@@ -19,7 +19,7 @@ def __init__(self) -> None:
         self._input_register_values: dict[int, int] = {}
         self._run_task: Optional[asyncio.Task] = None
 
-        super().__init__(xframer='ignored')
+        super().__init__(framer=Framer.RTU)
 
     @abc.abstractmethod
     async def run(self) -> None:
@@ -35,10 +35,9 @@ async def connect(self) -> None:
         if not self._run_task:
             self._run_task = asyncio.create_task(self._run())
 
-    async def close(self) -> None:
+    def close(self, reconnect: bool = False) -> None:
         if self._run_task:
             self._run_task.cancel()
-            await self._run_task
             self._run_task = None
 
     @property