Merge branch 'dev' into 3.0.0

Author: dhoomakethu

CHANGELOG.rst

@@ -1,3 +1,6 @@
+version 3.0.0dev2
+----------------------------------------------------------
+
 version 3.0.0dev1
 ----------------------------------------------------------
 * Support python3.10
@@ -13,6 +16,14 @@ version 3.0.0dev0
 * Support python3.7 and above
 * Support creating asyncio clients from with in coroutines.
 
+version 2.5.3
+----------------------------------------------------------
+* Fix retries on tcp client failing randomly.
+* Fix Asyncio client timeout arg not being used.
+* Treat exception codes as valid responses
+* Fix examples (modbus_payload)
+* Add missing identity argument to async ModbusSerialServer
+
 version 2.5.2
 ----------------------------------------------------------
 * Add kwarg `reset_socket` to control closing of the socket on read failures (set to `True` by default).

examples/common/modbus_payload.py

@@ -35,23 +35,31 @@ def run_binary_payload_ex():
     # ----------------------------------------------------------------------- #
     client = ModbusClient('127.0.0.1', port=5020)
     client.connect()
-    
+
     # ----------------------------------------------------------------------- #
     # If you need to build a complex message to send, you can use the payload
     # builder to simplify the packing logic.
     #
     # Here we demonstrate packing a random payload layout, unpacked it looks
     # like the following:
     #
-    # - a 8 byte string 'abcdefgh'
-    # - a 32 bit float 22.34
-    # - a 16 bit unsigned int 0x1234
-    # - another 16 bit unsigned int 0x5678
-    # - an 8 bit int 0x12
+    # - an 8 byte string "abcdefgh"
     # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
-    # - an 32 bit uint 0x12345678
-    # - an 32 bit signed int -0x1234
-    # - an 64 bit signed int 0x12345678
+    # - an 8 bit int -0x12
+    # - an 8 bit unsigned int 0x12
+    # - a 16 bit int -0x5678
+    # - a 16 bit unsigned int 0x1234
+    # - a 32 bit int -0x1234
+    # - a 32 bit unsigned int 0x12345678
+    # - a 16 bit float 12.34
+    # - a 16 bit float -12.34
+    # - a 32 bit float 22.34
+    # - a 32 bit float -22.34
+    # - a 64 bit int -0xDEADBEEF
+    # - a 64 bit unsigned int 0x12345678DEADBEEF
+    # - another 64 bit unsigned int 0x12345678DEADBEEF
+    # - a 64 bit float 123.45
+    # - a 64 bit float -123.45
 
     # The packing can also be applied to the word (wordorder) and bytes in each
     # word (byteorder)
@@ -123,12 +131,23 @@ def run_binary_payload_ex():
         # Here we demonstrate decoding a random register layout, unpacked it looks
         # like the following:
         #
-        # - a 8 byte string 'abcdefgh'
-        # - a 32 bit float 22.34
-        # - a 16 bit unsigned int 0x1234
-        # - another 16 bit unsigned int which we will ignore
-        # - an 8 bit int 0x12
+        # - an 8 byte string "abcdefgh"
         # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
+        # - an 8 bit int -0x12
+        # - an 8 bit unsigned int 0x12
+        # - a 16 bit int -0x5678
+        # - a 16 bit unsigned int 0x1234
+        # - a 32 bit int -0x1234
+        # - a 32 bit unsigned int 0x12345678
+        # - a 16 bit float 12.34
+        # - a 16 bit float -12.34
+        # - a 32 bit float 22.34
+        # - a 32 bit float -22.34
+        # - a 64 bit int -0xDEADBEEF
+        # - a 64 bit unsigned int 0x12345678DEADBEEF
+        # - another 64 bit unsigned int which we will ignore
+        # - a 64 bit float 123.45
+        # - a 64 bit float -123.45
         # ----------------------------------------------------------------------- #
         address = 0x0
         count = len(payload)
@@ -174,7 +193,7 @@ def run_binary_payload_ex():
         print("-" * 60)
         for name, value in iteritems(decoded):
             print("%s\t" % name, hex(value) if isinstance(value, int) else value)
-    
+
     # ----------------------------------------------------------------------- #
     # close the client
     # ----------------------------------------------------------------------- #

pymodbus/client/asynchronous/async_io/__init__.py

@@ -240,7 +240,7 @@ class ReconnectingAsyncioModbusTcpClient(object):
     #: Maximum delay in milli seconds before reconnect is attempted.
     DELAY_MAX_MS = 1000 * 60 * 5
 
-    def __init__(self, protocol_class=None, loop=None):
+    def __init__(self, protocol_class=None, loop=None, **kwargs):
         """
         Initialize ReconnectingAsyncioModbusTcpClient
         :param protocol_class: Protocol used to talk to modbus device.
@@ -257,6 +257,7 @@ def __init__(self, protocol_class=None, loop=None):
         self.connected = False
         #: Reconnect delay in milli seconds.
         self.delay_ms = self.DELAY_MIN_MS
+        self._proto_args = kwargs
 
     def reset_delay(self):
         """
@@ -296,7 +297,7 @@ def _create_protocol(self):
         """
         Factory function to create initialized protocol instance.
         """
-        protocol = self.protocol_class()
+        protocol = self.protocol_class(**self._proto_args)
         protocol.factory = self
         return protocol
 
@@ -353,7 +354,7 @@ async def _reconnect(self):
 class AsyncioModbusTcpClient(object):
     """Client to connect to modbus device over TCP/IP."""
 
-    def __init__(self, host=None, port=502, protocol_class=None, loop=None):
+    def __init__(self, host=None, port=502, protocol_class=None, loop=None, **kwargs):
         """
         Initializes Asyncio Modbus Tcp Client
         :param host: Host IP address
@@ -372,6 +373,7 @@ def __init__(self, host=None, port=502, protocol_class=None, loop=None):
         self.port = port
 
         self.connected = False
+        self._proto_args = kwargs
 
     def stop(self):
         """
@@ -387,7 +389,7 @@ def _create_protocol(self):
         """
         Factory function to create initialized protocol instance.
         """
-        protocol = self.protocol_class()
+        protocol = self.protocol_class(**self._proto_args)
         protocol.factory = self
         return protocol
 
@@ -441,27 +443,34 @@ class ReconnectingAsyncioModbusTlsClient(ReconnectingAsyncioModbusTcpClient):
     """
     Client to connect to modbus device repeatedly over TLS."
     """
-    def __init__(self, protocol_class=None, loop=None, framer=None):
+    def __init__(self, protocol_class=None, loop=None, framer=None, **kwargs):
         """
         Initialize ReconnectingAsyncioModbusTcpClient
         :param protocol_class: Protocol used to talk to modbus device.
         :param loop: Event loop to use
         """
         self.framer = framer
-        ReconnectingAsyncioModbusTcpClient.__init__(self, protocol_class, loop)
+        ReconnectingAsyncioModbusTcpClient.__init__(self, protocol_class, loop, **kwargs)
 
-    async def start(self, host='localhost', port=802, sslctx=None,
-                    certfile=None, keyfile=None, password=None, **kwargs):
+    async def start(self, host, port=802, sslctx=None, server_hostname=None):
         """
         Initiates connection to start client
-        :param host: The host to connect to (default localhost)
-        :param port: Port to connect
-        :param sslctx:The SSLContext to use for TLS (default None and auto create)
-        :param certfile: The optional client's cert file path for TLS server request
-        :param keyfile: The optional client's key file path for TLS server request
-        :param password: The password for for decrypting client's private key file
+        :param host:
+        :param port:
+        :param sslctx:
+        :param server_hostname:
+        :return:
         """
-        self.sslctx = sslctx_provider(sslctx, certfile, keyfile, password)
+        self.sslctx = sslctx
+        if self.sslctx is None:
+            self.sslctx = ssl.create_default_context()
+            # According to MODBUS/TCP Security Protocol Specification, it is
+            # TLSv2 at least
+            self.sslctx.options |= ssl.OP_NO_TLSv1_1
+            self.sslctx.options |= ssl.OP_NO_TLSv1
+            self.sslctx.options |= ssl.OP_NO_SSLv3
+            self.sslctx.options |= ssl.OP_NO_SSLv2
+        self.server_hostname = server_hostname
         return await ReconnectingAsyncioModbusTcpClient.start(self, host, port)
 
     async def _connect(self):
@@ -484,7 +493,7 @@ def _create_protocol(self):
         """
         Factory function to create initialized protocol instance.
         """
-        protocol = self.protocol_class(framer=self.framer)
+        protocol = self.protocol_class(framer=self.framer, **self._proto_args)
         protocol.transaction = FifoTransactionManager(self)
         protocol.factory = self
         return protocol
@@ -500,7 +509,7 @@ class ReconnectingAsyncioModbusUdpClient(object):
     #: Maximum delay in milli seconds before reconnect is attempted.
     DELAY_MAX_MS = 1000 * 60 * 5
 
-    def __init__(self, protocol_class=None, loop=None):
+    def __init__(self, protocol_class=None, loop=None, **kwargs):
         """
         Initializes ReconnectingAsyncioModbusUdpClient
         :param protocol_class: Protocol used to talk to modbus device.
@@ -517,6 +526,7 @@ def __init__(self, protocol_class=None, loop=None):
         self.port = 0
 
         self.connected = False
+        self._proto_args = kwargs
         self.reset_delay()
 
     def reset_delay(self):
@@ -565,7 +575,7 @@ def _create_protocol(self, host=None, port=0):
         """
         Factory function to create initialized protocol instance.
         """
-        protocol = self.protocol_class()
+        protocol = self.protocol_class(**self._proto_args)
         protocol.host = host
         protocol.port = port
         protocol.factory = self
@@ -629,7 +639,7 @@ class AsyncioModbusUdpClient(object):
     Client to connect to modbus device over UDP.
     """
 
-    def __init__(self, host=None, port=502, protocol_class=None, loop=None):
+    def __init__(self, host=None, port=502, protocol_class=None, loop=None, **kwargs):
         """
         Initializes Asyncio Modbus UDP Client
         :param host: Host IP address
@@ -648,6 +658,7 @@ def __init__(self, host=None, port=502, protocol_class=None, loop=None):
         self.port = port
 
         self.connected = False
+        self._proto_args = kwargs
 
     def stop(self):
         """
@@ -666,7 +677,7 @@ def _create_protocol(self, host=None, port=0):
         """
         Factory function to create initialized protocol instance.
         """
-        protocol = self.protocol_class()
+        protocol = self.protocol_class(**self._proto_args)
         protocol.host = host
         protocol.port = port
         protocol.factory = self
@@ -832,31 +843,30 @@ async def init_tcp_client(proto_cls, loop, host, port, **kwargs):
     :return:
     """
     client = ReconnectingAsyncioModbusTcpClient(protocol_class=proto_cls,
-                                                loop=loop)
+                                                loop=loop, **kwargs)
     await client.start(host, port)
     return client
 
 
-async def init_tls_client(proto_cls, loop, host, port, sslctx=None,
-                          certfile=None, keyfile=None, password=None,
-                          framer=None, **kwargs):
+@asyncio.coroutine
+def init_tls_client(proto_cls, loop, host, port, sslctx=None,
+                    server_hostname=None, framer=None, **kwargs):
     """
     Helper function to initialize tcp client
     :param proto_cls:
     :param loop:
     :param host:
     :param port:
     :param sslctx:
-    :param certfile: The optional client's cert file path for TLS server request
-    :param keyfile: The optional client's key file path for TLS server request
-    :param password: The password for for decrypting client's private key file
+    :param server_hostname:
     :param framer:
     :param kwargs:
     :return:
     """
     client = ReconnectingAsyncioModbusTlsClient(protocol_class=proto_cls,
-                                                loop=loop, framer=framer)
-    await client.start(host, port, sslctx, certfile, keyfile, password)
+                                                loop=loop, framer=framer,
+                                                **kwargs)
+    await client.start(host, port, sslctx, server_hostname)
     return client
 
 
@@ -871,6 +881,6 @@ async def init_udp_client(proto_cls, loop, host, port, **kwargs):
     :return:
     """
     client = ReconnectingAsyncioModbusUdpClient(protocol_class=proto_cls,
-                                                loop=loop)
+                                                loop=loop, **kwargs)
     await client.start(host, port)
     return client

pymodbus/client/asynchronous/factory/tcp.py

@@ -77,8 +77,7 @@ def io_loop_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
     return protocol, future
 
 
-def async_io_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
-                     source_address=None, timeout=None, **kwargs):
+def async_io_factory(host="127.0.0.1", port=Defaults.Port, **kwargs):
     """
     Factory to create asyncio based asynchronous tcp clients
     :param host: Host IP address
@@ -93,28 +92,27 @@ def async_io_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
     from pymodbus.client.asynchronous.async_io import init_tcp_client
 
     try:
-        loop = kwargs.get("loop") or asyncio.get_running_loop()
+        loop = kwargs.pop("loop") or asyncio.get_running_loop()
     except RuntimeError:
         loop = asyncio.new_event_loop()
 
-    proto_cls = kwargs.get("proto_cls")
+    proto_cls = kwargs.pop("proto_cls", None)
 
     if not loop.is_running():
         asyncio.set_event_loop(loop)
-        cor = init_tcp_client(proto_cls, loop, host, port)
+        cor = init_tcp_client(proto_cls, loop, host, port, **kwargs)
         client = loop.run_until_complete(asyncio.gather(cor))[0]
+
     elif loop is asyncio.get_event_loop():
-        cor = init_tcp_client(proto_cls, loop, host, port)
+        cor = init_tcp_client(proto_cls, loop, host, port, **kwargs)
         client = asyncio.create_task(cor)
         # future = asyncio.run_coroutine_threadsafe(cor, loop=loop)
         # client = future.result()
     else:
-        if loop is asyncio.get_event_loop():
-            return init_tcp_client(proto_cls, loop, host, port)
-        else:
-            cor = init_tcp_client(proto_cls, loop, host, port)
-            future = asyncio.run_coroutine_threadsafe(cor, loop=loop)
-            client = future.result()
+        cor = init_tcp_client(proto_cls, loop, host, port, **kwargs)
+        future = asyncio.run_coroutine_threadsafe(cor, loop=loop)
+        client = future.result()
+
     return loop, client