Change sync ModbusSerialClient to use framer= instead of method=. (#993)

Author: janiversen

examples/client_sync.py

@@ -72,8 +72,7 @@ def setup_sync_client():
     elif args.comm == "serial":
         client = ModbusSerialClient(
             port=args.port,  # serial port
-            method=args.framer,  # how to interpret the messages
-            # TBD    framer=FRAMERS[args.framer],  # how to interpret the messages
+            framer=FRAMERS[args.framer],  # how to interpret the messages
             stopbits=1,  # The number of stop bits to use
             bytesize=7,  # The bytesize of the serial messages
             parity="even",  # Which kind of parity to use

examples/common/performance.py

@@ -17,8 +17,6 @@
 
 from pymodbus.client.sync import ModbusTcpClient
 
-# from pymodbus.client.sync import ModbusSerialClient
-
 try:
     from multiprocessing import Process as mWorker, log_to_stderr
 except ImportError:

pymodbus/client/sync.py

@@ -15,13 +15,10 @@
 from pymodbus.exceptions import (
     ConnectionException,
     NotImplementedException,
-    ParameterException,
 )
 from pymodbus.factory import ClientDecoder
 from pymodbus.transaction import (
     DictTransactionManager,
-    ModbusAsciiFramer,
-    ModbusBinaryFramer,
     ModbusRtuFramer,
     ModbusSocketFramer,
     ModbusTlsFramer,
@@ -614,16 +611,9 @@ class ModbusSerialClient(
     inter_char_timeout = 0
     silent_interval = 0
 
-    def __init__(self, method="ascii", **kwargs):
+    def __init__(self, framer=ModbusRtuFramer, **kwargs):
         """Initialize a serial client instance.
 
-        The methods to connect are::
-
-          - ascii
-          - rtu
-          - binary
-
-        :param method: The method to use for connection
         :param port: The serial port to attach to
         :param stopbits: The number of stop bits to use
         :param bytesize: The bytesize of the serial messages
@@ -633,10 +623,11 @@ def __init__(self, method="ascii", **kwargs):
         :param strict:  Use Inter char timeout for baudrates <= 19200 (adhere
         to modbus standards)
         :param handle_local_echo: Handle local echo of the USB-to-RS485 adaptor
+        :param framer: The modbus framer to use (default ModbusRtuFramer)
         """
-        self.method = method
+        self.framer = framer
         self.socket = None
-        BaseModbusClient.__init__(self, self.__implementation(method, self), **kwargs)
+        BaseModbusClient.__init__(self, framer(ClientDecoder(), self), **kwargs)
 
         self.port = kwargs.get("port", 0)
         self.stopbits = kwargs.get("stopbits", Defaults.Stopbits)
@@ -647,7 +638,7 @@ def __init__(self, method="ascii", **kwargs):
         self._strict = kwargs.get("strict", False)
         self.last_frame_end = None
         self.handle_local_echo = kwargs.get("handle_local_echo", False)
-        if self.method == "rtu":
+        if isinstance(self.framer, ModbusRtuFramer):
             if self.baudrate > 19200:
                 self.silent_interval = 1.75 / 1000  # ms
             else:
@@ -656,26 +647,6 @@ def __init__(self, method="ascii", **kwargs):
                 self.silent_interval = 3.5 * self._t0
             self.silent_interval = round(self.silent_interval, 6)
 
-    @staticmethod
-    def __implementation(method, client):
-        """Return the requested framer.
-
-        :method: The serial framer to instantiate
-        :returns: The requested serial framer
-        :raises ConnectionException:
-        :raises ParameterException:
-        """
-        method = method.lower()
-        if method == "ascii":
-            return ModbusAsciiFramer(ClientDecoder(), client)
-        if method == "rtu":
-            return ModbusRtuFramer(ClientDecoder(), client)
-        if method == "binary":
-            return ModbusBinaryFramer(ClientDecoder(), client)
-        if method == "socket":
-            return ModbusSocketFramer(ClientDecoder(), client)
-        raise ParameterException("Invalid framer method requested")
-
     def connect(self):
         """Connect to the modbus serial server.
 
@@ -692,7 +663,7 @@ def connect(self):
                 baudrate=self.baudrate,
                 parity=self.parity,
             )
-            if self.method == "rtu":
+            if isinstance(self.framer, ModbusRtuFramer):
                 if self._strict:
                     self.socket.interCharTimeout = self.inter_char_timeout
                 self.last_frame_end = None
@@ -802,13 +773,13 @@ def __str__(self):
 
         :returns: The string representation
         """
-        return f"ModbusSerialClient({self.method} baud[{self.baudrate}])"
+        return f"ModbusSerialClient({self.framer} baud[{self.baudrate}])"
 
     def __repr__(self):
         """Return string representation."""
         return (
             f"<{self.__class__.__name__} at {hex(id(self))} socket={self.socket}, "
-            f"method={self.method}, timeout={self.timeout}>"
+            f"framer={self.framer}, timeout={self.timeout}>"
         )
 
 

pymodbus/repl/client/main.py

@@ -29,11 +29,17 @@
 from prompt_toolkit.styles import Style
 from pygments.lexers.python import PythonLexer
 
-from pymodbus.framer.rtu_framer import ModbusRtuFramer
 from pymodbus.repl.client.completer import CmdCompleter, has_selected_completion
 from pymodbus.repl.client.helper import CLIENT_ATTRIBUTES, Result
 from pymodbus.repl.client.mclient import ModbusSerialClient, ModbusTcpClient
 from pymodbus.version import version
+from pymodbus.exceptions import ParameterException
+from pymodbus.transaction import (
+    ModbusAsciiFramer,
+    ModbusBinaryFramer,
+    ModbusRtuFramer,
+    ModbusSocketFramer,
+)
 
 click.disable_unicode_literals_warning = True
 
@@ -403,8 +409,19 @@ def serial(  # pylint: disable=too-many-arguments
     write_timeout,
 ):
     """Define serial communication."""
+    method = method.lower()
+    if method == "ascii":
+        framer = ModbusAsciiFramer
+    elif method == "rtu":
+        framer = ModbusRtuFramer
+    elif method == "binary":
+        framer = ModbusBinaryFramer
+    elif method == "socket":
+        framer = ModbusSocketFramer
+    else:
+        raise ParameterException("Invalid framer method requested")
     client = ModbusSerialClient(
-        method=method,
+        framer=framer,
         port=port,
         baudrate=baudrate,
         bytesize=bytesize,

test/test_client_sync.py

@@ -22,7 +22,6 @@
 from pymodbus.exceptions import (
     ConnectionException,
     NotImplementedException,
-    ParameterException,
 )
 from pymodbus.transaction import (
     ModbusAsciiFramer,
@@ -524,32 +523,28 @@ class CustomeRequest:  # pylint: disable=too-few-public-methods
     # -----------------------------------------------------------------------#
     # Test Serial Client
     # -----------------------------------------------------------------------#
-
     def test_sync_serial_client_instantiation(self):
         """Test sync serial client."""
         client = ModbusSerialClient()
         self.assertNotEqual(client, None)
         self.assertTrue(
-            isinstance(ModbusSerialClient(method="ascii").framer, ModbusAsciiFramer)
+            isinstance(ModbusSerialClient(framer=ModbusAsciiFramer).framer, ModbusAsciiFramer)
         )
         self.assertTrue(
-            isinstance(ModbusSerialClient(method="rtu").framer, ModbusRtuFramer)
+            isinstance(ModbusSerialClient(framer=ModbusRtuFramer).framer, ModbusRtuFramer)
         )
         self.assertTrue(
-            isinstance(ModbusSerialClient(method="binary").framer, ModbusBinaryFramer)
+            isinstance(ModbusSerialClient(framer=ModbusBinaryFramer).framer, ModbusBinaryFramer)
         )
         self.assertTrue(
-            isinstance(ModbusSerialClient(method="socket").framer, ModbusSocketFramer)
-        )
-        self.assertRaises(
-            ParameterException, lambda: ModbusSerialClient(method="something")
+            isinstance(ModbusSerialClient(framer=ModbusSocketFramer).framer, ModbusSocketFramer)
         )
 
     def test_sync_serial_rtu_client_timeouts(self):
         """Test sync serial rtu."""
-        client = ModbusSerialClient(method="rtu", baudrate=9600)
+        client = ModbusSerialClient(framer=ModbusRtuFramer, baudrate=9600)
         self.assertEqual(client.silent_interval, round((3.5 * 11 / 9600), 6))
-        client = ModbusSerialClient(method="rtu", baudrate=38400)
+        client = ModbusSerialClient(framer=ModbusRtuFramer, baudrate=38400)
         self.assertEqual(client.silent_interval, round((1.75 / 1000), 6))
 
     @patch("serial.Serial")
@@ -573,7 +568,7 @@ def test_basic_sync_serial_client(self, mock_serial):
         client.close()
 
         # rtu connect/disconnect
-        rtu_client = ModbusSerialClient(method="rtu", strict=True)
+        rtu_client = ModbusSerialClient(framer=ModbusRtuFramer, strict=True)
         self.assertTrue(rtu_client.connect())
         self.assertEqual(
             rtu_client.socket.interCharTimeout, rtu_client.inter_char_timeout
@@ -584,7 +579,7 @@ def test_basic_sync_serial_client(self, mock_serial):
         client.socket = False
         client.close()
 
-        self.assertEqual("ModbusSerialClient(ascii baud[19200])", str(client))
+        self.assertTrue("baud[19200])" in str(client))
 
     def test_serial_client_connect(self):
         """Test the serial client connection method"""
@@ -667,7 +662,7 @@ def test_serial_client_repr(self):
         client = ModbusSerialClient()
         rep = (
             f"<{client.__class__.__name__} at {hex(id(client))} socket={client.socket}, "
-            f"method={client.method}, timeout={client.timeout}>"
+            f"framer={client.framer}, timeout={client.timeout}>"
         )
         self.assertEqual(repr(client), rep)
 

test/test_device.py

@@ -16,7 +16,7 @@
 # ---------------------------------------------------------------------------#
 
 
-class SimpleDataStoreTest(unittest.TestCase):  # pylint: disable=too-many-public-methods
+class SimpleDataStoreTest(unittest.TestCase):
     """Unittest for the pymodbus.device module."""
 
     # -----------------------------------------------------------------------#