asyncio server implementation

examples/common/asyncio_server.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+"""
+Pymodbus Asyncio Server Example
+--------------------------------------------------------------------------
+
+The asyncio server is implemented in pure python without any third
+party libraries (unless you need to use the serial protocols which require
+asyncio-pyserial). This is helpful in constrained or old environments where using
+twisted is just not feasible. What follows is an example of its use:
+"""
+# --------------------------------------------------------------------------- #
+# import the various server implementations
+# --------------------------------------------------------------------------- #
+from pymodbus.server.asyncio import StartTcpServer
+from pymodbus.server.asyncio import StartUdpServer
+from pymodbus.server.asyncio import StartSerialServer
+
+from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.datastore import ModbusSequentialDataBlock, ModbusSparseDataBlock
+from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
+
+from pymodbus.transaction import ModbusRtuFramer, ModbusBinaryFramer
+# --------------------------------------------------------------------------- #
+# configure the service logging
+# --------------------------------------------------------------------------- #
+import logging
+FORMAT = ('%(asctime)-15s %(threadName)-15s'
+          ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
+logging.basicConfig(format=FORMAT)
+log = logging.getLogger()
+log.setLevel(logging.DEBUG)
+
+
+async def run_server():
+    # ----------------------------------------------------------------------- #
+    # initialize your data store
+    # ----------------------------------------------------------------------- #
+    # The datastores only respond to the addresses that they are initialized to
+    # Therefore, if you initialize a DataBlock to addresses of 0x00 to 0xFF, a
+    # request to 0x100 will respond with an invalid address exception. This is
+    # because many devices exhibit this kind of behavior (but not all)::
+    #
+    #     block = ModbusSequentialDataBlock(0x00, [0]*0xff)
+    #
+    # Continuing, you can choose to use a sequential or a sparse DataBlock in
+    # your data context.  The difference is that the sequential has no gaps in
+    # the data while the sparse can. Once again, there are devices that exhibit
+    # both forms of behavior::
+    #
+    #     block = ModbusSparseDataBlock({0x00: 0, 0x05: 1})
+    #     block = ModbusSequentialDataBlock(0x00, [0]*5)
+    #
+    # Alternately, you can use the factory methods to initialize the DataBlocks
+    # or simply do not pass them to have them initialized to 0x00 on the full
+    # address range::
+    #
+    #     store = ModbusSlaveContext(di = ModbusSequentialDataBlock.create())
+    #     store = ModbusSlaveContext()
+    #
+    # Finally, you are allowed to use the same DataBlock reference for every
+    # table or you may use a separate DataBlock for each table.
+    # This depends if you would like functions to be able to access and modify
+    # the same data or not::
+    #
+    #     block = ModbusSequentialDataBlock(0x00, [0]*0xff)
+    #     store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
+    #
+    # The server then makes use of a server context that allows the server to
+    # respond with different slave contexts for different unit ids. By default
+    # it will return the same context for every unit id supplied (broadcast
+    # mode).
+    # However, this can be overloaded by setting the single flag to False and
+    # then supplying a dictionary of unit id to context mapping::
+    #
+    #     slaves  = {
+    #         0x01: ModbusSlaveContext(...),
+    #         0x02: ModbusSlaveContext(...),
+    #         0x03: ModbusSlaveContext(...),
+    #     }
+    #     context = ModbusServerContext(slaves=slaves, single=False)
+    #
+    # The slave context can also be initialized in zero_mode which means that a
+    # request to address(0-7) will map to the address (0-7). The default is
+    # False which is based on section 4.4 of the specification, so address(0-7)
+    # will map to (1-8)::
+    #
+    #     store = ModbusSlaveContext(..., zero_mode=True)
+    # ----------------------------------------------------------------------- #
+    store = ModbusSlaveContext(
+        di=ModbusSequentialDataBlock(0, [17]*100),
+        co=ModbusSequentialDataBlock(0, [17]*100),
+        hr=ModbusSequentialDataBlock(0, [17]*100),
+        ir=ModbusSequentialDataBlock(0, [17]*100))
+
+    context = ModbusServerContext(slaves=store, single=True)
+
+    # ----------------------------------------------------------------------- #
+    # initialize the server information
+    # ----------------------------------------------------------------------- #
+    # If you don't set this or any fields, they are defaulted to empty strings.
+    # ----------------------------------------------------------------------- #
+    identity = ModbusDeviceIdentification()
+    identity.VendorName = 'Pymodbus'
+    identity.ProductCode = 'PM'
+    identity.VendorUrl = 'http://github.com/riptideio/pymodbus/'
+    identity.ProductName = 'Pymodbus Server'
+    identity.ModelName = 'Pymodbus Server'
+    identity.MajorMinorRevision = '2.2.0'
+
+    # ----------------------------------------------------------------------- #
+    # run the server you want
+    # ----------------------------------------------------------------------- #
+    # Tcp:
+    # immediately start serving:
+    server = await StartTcpServer(context, identity=identity, address=("0.0.0.0", 5020),
+                                  allow_reuse_address=True)
+
+    # 	deferred start:
+    # server = await StartTcpServer(context, identity=identity, address=("0.0.0.0", 5020),
+    # 							  allow_reuse_address=True, defer_start=True)
+
+    # asyncio.get_event_loop().call_later(20, lambda : server.)
+    # await server.serve_forever()
+
+
+
+
+    # TCP with different framer
+    # StartTcpServer(context, identity=identity,
+    #                framer=ModbusRtuFramer, address=("0.0.0.0", 5020))
+
+    # Udp:
+    # server = await StartUdpServer(context, identity=identity, address=("0.0.0.0", 5020),
+    # 							  allow_reuse_address=True, defer_start=True)
+    #
+    # await server.serve_forever()
+
+
+    # !!! SERIAL SERVER NOT IMPLEMENTED !!!
+    # Ascii:
+    # StartSerialServer(context, identity=identity,
+    #                    port='/dev/ttyp0', timeout=1)
+
+    # RTU:
+    # StartSerialServer(context, framer=ModbusRtuFramer, identity=identity,
+    #                   port='/dev/ttyp0', timeout=.005, baudrate=9600)
+
+    # Binary
+    # StartSerialServer(context,
+    #                   identity=identity,
+    #                   framer=ModbusBinaryFramer,
+    #                   port='/dev/ttyp0',
+    #                   timeout=1)
+
+
+if __name__ == "__main__":
+    asyncio.run(run_server())
+

pymodbus/client/sync.py

@@ -1,6 +1,5 @@
 import socket
 import select
-import serial
 import time
 import sys
 from functools import partial
@@ -425,6 +424,7 @@ def __init__(self, method='ascii', **kwargs):
         :param strict:  Use Inter char timeout for baudrates <= 19200 (adhere
         to modbus standards)
         """
+        import serial
         self.method = method
         self.socket = None
         BaseModbusClient.__init__(self, self.__implementation(method, self),