asyncio server implementation (#400)

* #357 Support registration of custom requests

* #368 Fixes write to broadcast address

When writing to broadcast address (unit_id=0) there should be no response according to the Modbus spec. This fix changes expected_response_length to 0 when writing to unit_id=0. This will break any existing code that is improperly using unit_id 0 for a slave address.

* Bump version to 2.2.0

Fix #366 Update failures in sql context

Update Changelog

Fix major minor version in example codes

* Fix #371 pymodbus repl on python3

* 1. Fix tornado async serial client `TypeError` while processing incoming packet.
2. Fix asyncio examples.
3. Minor update in factory.py, now server logs prints received request instead of only function cod

* [fix v3] poprawa sprawdzania timeout

* Release candidate for pymodbus 2.2.0

*  Fix #377 when invalid port is supplied and minor updates in logging

* #368 adds broadcast support for sync client and server

Adds broadcast_enable parameter to client and server, default value is False. When true it will treat unit_id 0 as broadcast and execute requests on all server slave contexts and not send a response and on the client side will send the request and not try to receive a response.

* #368 Fixes minor bug in broadcast support code

* Fixed erronous CRC handling

If the CRC recieved is not correct in my case my slave got caught in a deadlock, not taking any new requests. This addition fixed that.

* Update Changelog

* Fix test coverage

* Fix #387 Transactions failing on 2.2.0rc2.

* Task Cancellation and CRC Errors

Alternate solution for #356 and #360.

Changes the RTU to make the transaction ID as the unit ID instead of an ever incrementing number.

Previously this transaction ID was always 0 on the receiving end but was the unique transaction ID on sending.

As such the FIFO buffer made the most sense. By tying it to the unit ID, we can recover from failure modes such as: -
- Asyncio task cancellations (eg. timeouts) #360
- Skipped responses from slaves. (hangs on master #360)
- CRC Errors #356
- Busy response

* Cherry pick commit from PR #367 , Update changelog , bump version to 2.2.0rc4

* native asyncio implementation of ModbusTcpServer and ModbusUdpServer

* preliminary asyncio server examples

* move serial module dependency into class instantiation

* unittests for asyncio based server implementation

* induce exception in execute method by mock patching the request object's execute method

* move serial module dependency into class instantiation

* added asynctest depency to requirements-tests.txt

* add unittest skip condition for unsupported targets, remove failing assertion from unsupported targets, use lower asynctest version

* remove logger setLevel call since doing so may override library consumers' already set log level

* remove async def/await keywords from unittest so that the ast can be loaded in py2 even if the test is to be skipped

Author: memetb

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),