Allow multiple servers. (#1164)

Author: janiversen

examples/client_payload.py

@@ -7,36 +7,30 @@
 
 Works out of the box together with payload_server.py
 """
+import asyncio
 import logging
 from collections import OrderedDict
 
-from pymodbus.client import ModbusTcpClient as ModbusClient
+from pymodbus import pymodbus_apply_logging_config
+from pymodbus.client import AsyncModbusTcpClient
 from pymodbus.constants import Endian
 from pymodbus.payload import BinaryPayloadBuilder, BinaryPayloadDecoder
 
 
-# --------------------------------------------------------------------------- #
-# configure the client logging
-# --------------------------------------------------------------------------- #
-
-FORMAT = (
-    "%(asctime)-15s %(threadName)-15s"
-    " %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s"
-)
-logging.basicConfig(format=FORMAT)
-log = logging.getLogger()
-log.setLevel(logging.INFO)
-
+_logger = logging.getLogger()
 ORDER_DICT = {"<": "LITTLE", ">": "BIG"}
 
 
-def run_binary_payload_client():
+async def run_binary_payload_client(port):
     """Run binary payload."""
+    pymodbus_apply_logging_config()
+    _logger.setLevel(logging.DEBUG)
+
     # ----------------------------------------------------------------------- #
     # We are going to use a simple sync client to send our requests
     # ----------------------------------------------------------------------- #
-    client = ModbusClient("127.0.0.1", port=5020)
-    client.connect()
+    client = AsyncModbusTcpClient("127.0.0.1", port=port)
+    await client.connect()
 
     # ----------------------------------------------------------------------- #
     # If you need to build a complex message to send, you can use the payload
@@ -97,23 +91,26 @@ def run_binary_payload_client():
         print("\n")
         payload = builder.build()
         address = 0
+        slave = 1
         # We can write registers
-        client.write_registers(address, registers, unit=1)
+        rr = await client.write_registers(address, registers, slave=slave)
+        assert not rr.isError()
         # Or we can write an encoded binary string
-        client.write_registers(address, payload, skip_encode=True, unit=1)
+        rr = await client.write_registers(address, payload, skip_encode=True, slave=1)
+        assert not rr.isError()
 
         # ----------------------------------------------------------------------- #
         # If you need to decode a collection of registers in a weird layout, the
         # payload decoder can help you as well.
         # ----------------------------------------------------------------------- #
         print("Reading Registers:")
-        address = 0x0
         count = len(payload)
-        result = client.read_holding_registers(address, count, slave=1)
-        print(result.registers)
+        rr = await client.read_holding_registers(address, count, slave=slave)
+        assert not rr.isError()
+        print(rr.registers)
         print("\n")
         decoder = BinaryPayloadDecoder.fromRegisters(
-            result.registers, byteorder=byte_endian, wordorder=word_endian
+            rr.registers, byteorder=byte_endian, wordorder=word_endian
         )
         # Make sure word/byte order is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder
         assert (
@@ -146,17 +143,14 @@ def run_binary_payload_client():
         )
         print("Decoded Data")
         for name, value in iter(decoded.items()):
-            print(
-                "%s\t" % name,  # pylint: disable=consider-using-f-string
-                hex(value) if isinstance(value, int) else value,
-            )
+            print(f"{name}\t{hex(value) if isinstance(value, int) else value}")
         print("\n")
 
     # ----------------------------------------------------------------------- #
     # close the client
     # ----------------------------------------------------------------------- #
-    client.close()
+    await client.close()
 
 
 if __name__ == "__main__":
-    run_binary_payload_client()
+    asyncio.run(run_binary_payload_client(5020))

examples/modbus_forwarder.py

@@ -39,7 +39,7 @@ def setup_forwarder(args):
         for i in args.slaves:
             store[i.to_bytes(1, "big")] = RemoteSlaveContext(args.client, unit=i)
     else:
-        store = RemoteSlaveContext(args.client)
+        store = RemoteSlaveContext(args.client, unit=1)
     args.context = ModbusServerContext(slaves=store, single=True)
     return args
 

examples/server_async.py

@@ -106,10 +106,7 @@ def setup_server(args):
         single = False
     else:
         context = ModbusSlaveContext(
-            di=datablock,
-            co=datablock,
-            hr=datablock,
-            ir=datablock,
+            di=datablock, co=datablock, hr=datablock, ir=datablock, unit=1
         )
         single = True
 

examples/server_payload.py

@@ -7,6 +7,7 @@
 import asyncio
 import logging
 
+from pymodbus import pymodbus_apply_logging_config
 from pymodbus.constants import Endian
 from pymodbus.datastore import (
     ModbusSequentialDataBlock,
@@ -23,13 +24,14 @@
 from pymodbus.version import version
 
 
-# set logging level for library.
 _logger = logging.getLogger()
-_logger.setLevel(logging.DEBUG)
 
 
-async def run_payload_server():
+async def run_payload_server(port):
     """Run payload server."""
+    pymodbus_apply_logging_config()
+    _logger.setLevel(logging.DEBUG)
+
     # ----------------------------------------------------------------------- #
     # build your payload
     # ----------------------------------------------------------------------- #
@@ -78,10 +80,10 @@ async def run_payload_server():
     await StartAsyncTcpServer(
         context,
         identity=identity,
-        address=("127.0.0.1", 5020),
+        address=("127.0.0.1", port),
         allow_reuse_address=True,
     )
 
 
 if __name__ == "__main__":
-    asyncio.run(run_payload_server())
+    asyncio.run(run_payload_server(5020))

pymodbus/server/async_io.py

@@ -932,16 +932,15 @@ def __init__(self, server, custom_functions, register):
         self.task = None
 
     @classmethod
-    def get_server(cls, index: int):
+    def get_server(cls):
         """Get server at index."""
-        return cls._servers[index]
+        return cls._servers[-1]
 
     def _remove(self):
         """Remove server from active list."""
-        for i in range(len(self._servers)):  # pylint: disable=consider-using-enumerate
-            if self._servers[i] == self:
-                del self._servers[i]
-                break
+        server = self._servers[-1]
+        self._servers.pop()
+        del server
 
     async def run(self):
         """Help starting/stopping server."""
@@ -952,7 +951,9 @@ async def run(self):
             _logger.error(txt)
         await self.job_stop.wait()
         await self.server.shutdown()
+        await asyncio.sleep(0.1)
         self.task.cancel()
+        await asyncio.sleep(0.1)
         try:
             await asyncio.wait_for(self.task, 10)
         except asyncio.CancelledError:
@@ -1152,15 +1153,15 @@ def StartUdpServer(**kwargs):  # pylint: disable=invalid-name
     return asyncio.run(StartAsyncUdpServer(**kwargs))
 
 
-async def ServerAsyncStop(index: int = -1):  # pylint: disable=invalid-name
+async def ServerAsyncStop():  # pylint: disable=invalid-name
     """Terminate server."""
-    my_job = _serverList.get_server(index)
+    my_job = _serverList.get_server()
     my_job.request_stop()
     await my_job.async_await_stop()
 
 
-def ServerStop(index: int = -1):  # pylint: disable=invalid-name
+def ServerStop():  # pylint: disable=invalid-name
     """Terminate server."""
-    my_job = _serverList.get_server(index)
+    my_job = _serverList.get_server()
     my_job.request_stop()
     my_job.await_stop()