|
| 1 | +#!/usr/bin/env python |
| 2 | +""" |
| 3 | +Pymodbus Asyncio Server Example |
| 4 | +-------------------------------------------------------------------------- |
| 5 | +
|
| 6 | +The asyncio server is implemented in pure python without any third |
| 7 | +party libraries (unless you need to use the serial protocols which require |
| 8 | +asyncio-pyserial). This is helpful in constrained or old environments where using |
| 9 | +twisted is just not feasible. What follows is an example of its use: |
| 10 | +""" |
| 11 | +# --------------------------------------------------------------------------- # |
| 12 | +# import the various server implementations |
| 13 | +# --------------------------------------------------------------------------- # |
| 14 | +from pymodbus.server.asyncio import StartTcpServer |
| 15 | +from pymodbus.server.asyncio import StartUdpServer |
| 16 | +from pymodbus.server.asyncio import StartSerialServer |
| 17 | + |
| 18 | +from pymodbus.device import ModbusDeviceIdentification |
| 19 | +from pymodbus.datastore import ModbusSequentialDataBlock, ModbusSparseDataBlock |
| 20 | +from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext |
| 21 | + |
| 22 | +from pymodbus.transaction import ModbusRtuFramer, ModbusBinaryFramer |
| 23 | +# --------------------------------------------------------------------------- # |
| 24 | +# configure the service logging |
| 25 | +# --------------------------------------------------------------------------- # |
| 26 | +import logging |
| 27 | +FORMAT = ('%(asctime)-15s %(threadName)-15s' |
| 28 | + ' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s') |
| 29 | +logging.basicConfig(format=FORMAT) |
| 30 | +log = logging.getLogger() |
| 31 | +log.setLevel(logging.DEBUG) |
| 32 | + |
| 33 | + |
| 34 | +async def run_server(): |
| 35 | + # ----------------------------------------------------------------------- # |
| 36 | + # initialize your data store |
| 37 | + # ----------------------------------------------------------------------- # |
| 38 | + # The datastores only respond to the addresses that they are initialized to |
| 39 | + # Therefore, if you initialize a DataBlock to addresses of 0x00 to 0xFF, a |
| 40 | + # request to 0x100 will respond with an invalid address exception. This is |
| 41 | + # because many devices exhibit this kind of behavior (but not all):: |
| 42 | + # |
| 43 | + # block = ModbusSequentialDataBlock(0x00, [0]*0xff) |
| 44 | + # |
| 45 | + # Continuing, you can choose to use a sequential or a sparse DataBlock in |
| 46 | + # your data context. The difference is that the sequential has no gaps in |
| 47 | + # the data while the sparse can. Once again, there are devices that exhibit |
| 48 | + # both forms of behavior:: |
| 49 | + # |
| 50 | + # block = ModbusSparseDataBlock({0x00: 0, 0x05: 1}) |
| 51 | + # block = ModbusSequentialDataBlock(0x00, [0]*5) |
| 52 | + # |
| 53 | + # Alternately, you can use the factory methods to initialize the DataBlocks |
| 54 | + # or simply do not pass them to have them initialized to 0x00 on the full |
| 55 | + # address range:: |
| 56 | + # |
| 57 | + # store = ModbusSlaveContext(di = ModbusSequentialDataBlock.create()) |
| 58 | + # store = ModbusSlaveContext() |
| 59 | + # |
| 60 | + # Finally, you are allowed to use the same DataBlock reference for every |
| 61 | + # table or you may use a separate DataBlock for each table. |
| 62 | + # This depends if you would like functions to be able to access and modify |
| 63 | + # the same data or not:: |
| 64 | + # |
| 65 | + # block = ModbusSequentialDataBlock(0x00, [0]*0xff) |
| 66 | + # store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block) |
| 67 | + # |
| 68 | + # The server then makes use of a server context that allows the server to |
| 69 | + # respond with different slave contexts for different unit ids. By default |
| 70 | + # it will return the same context for every unit id supplied (broadcast |
| 71 | + # mode). |
| 72 | + # However, this can be overloaded by setting the single flag to False and |
| 73 | + # then supplying a dictionary of unit id to context mapping:: |
| 74 | + # |
| 75 | + # slaves = { |
| 76 | + # 0x01: ModbusSlaveContext(...), |
| 77 | + # 0x02: ModbusSlaveContext(...), |
| 78 | + # 0x03: ModbusSlaveContext(...), |
| 79 | + # } |
| 80 | + # context = ModbusServerContext(slaves=slaves, single=False) |
| 81 | + # |
| 82 | + # The slave context can also be initialized in zero_mode which means that a |
| 83 | + # request to address(0-7) will map to the address (0-7). The default is |
| 84 | + # False which is based on section 4.4 of the specification, so address(0-7) |
| 85 | + # will map to (1-8):: |
| 86 | + # |
| 87 | + # store = ModbusSlaveContext(..., zero_mode=True) |
| 88 | + # ----------------------------------------------------------------------- # |
| 89 | + store = ModbusSlaveContext( |
| 90 | + di=ModbusSequentialDataBlock(0, [17]*100), |
| 91 | + co=ModbusSequentialDataBlock(0, [17]*100), |
| 92 | + hr=ModbusSequentialDataBlock(0, [17]*100), |
| 93 | + ir=ModbusSequentialDataBlock(0, [17]*100)) |
| 94 | + |
| 95 | + context = ModbusServerContext(slaves=store, single=True) |
| 96 | + |
| 97 | + # ----------------------------------------------------------------------- # |
| 98 | + # initialize the server information |
| 99 | + # ----------------------------------------------------------------------- # |
| 100 | + # If you don't set this or any fields, they are defaulted to empty strings. |
| 101 | + # ----------------------------------------------------------------------- # |
| 102 | + identity = ModbusDeviceIdentification() |
| 103 | + identity.VendorName = 'Pymodbus' |
| 104 | + identity.ProductCode = 'PM' |
| 105 | + identity.VendorUrl = 'http://github.com/riptideio/pymodbus/' |
| 106 | + identity.ProductName = 'Pymodbus Server' |
| 107 | + identity.ModelName = 'Pymodbus Server' |
| 108 | + identity.MajorMinorRevision = '2.2.0' |
| 109 | + |
| 110 | + # ----------------------------------------------------------------------- # |
| 111 | + # run the server you want |
| 112 | + # ----------------------------------------------------------------------- # |
| 113 | + # Tcp: |
| 114 | + # immediately start serving: |
| 115 | + server = await StartTcpServer(context, identity=identity, address=("0.0.0.0", 5020), |
| 116 | + allow_reuse_address=True) |
| 117 | + |
| 118 | + # deferred start: |
| 119 | + # server = await StartTcpServer(context, identity=identity, address=("0.0.0.0", 5020), |
| 120 | + # allow_reuse_address=True, defer_start=True) |
| 121 | + |
| 122 | + # asyncio.get_event_loop().call_later(20, lambda : server.) |
| 123 | + # await server.serve_forever() |
| 124 | + |
| 125 | + |
| 126 | + |
| 127 | + |
| 128 | + # TCP with different framer |
| 129 | + # StartTcpServer(context, identity=identity, |
| 130 | + # framer=ModbusRtuFramer, address=("0.0.0.0", 5020)) |
| 131 | + |
| 132 | + # Udp: |
| 133 | + # server = await StartUdpServer(context, identity=identity, address=("0.0.0.0", 5020), |
| 134 | + # allow_reuse_address=True, defer_start=True) |
| 135 | + # |
| 136 | + # await server.serve_forever() |
| 137 | + |
| 138 | + |
| 139 | + # !!! SERIAL SERVER NOT IMPLEMENTED !!! |
| 140 | + # Ascii: |
| 141 | + # StartSerialServer(context, identity=identity, |
| 142 | + # port='/dev/ttyp0', timeout=1) |
| 143 | + |
| 144 | + # RTU: |
| 145 | + # StartSerialServer(context, framer=ModbusRtuFramer, identity=identity, |
| 146 | + # port='/dev/ttyp0', timeout=.005, baudrate=9600) |
| 147 | + |
| 148 | + # Binary |
| 149 | + # StartSerialServer(context, |
| 150 | + # identity=identity, |
| 151 | + # framer=ModbusBinaryFramer, |
| 152 | + # port='/dev/ttyp0', |
| 153 | + # timeout=1) |
| 154 | + |
| 155 | + |
| 156 | +if __name__ == "__main__": |
| 157 | + asyncio.run(run_server()) |
| 158 | + |
0 commit comments