0% encontró este documento útil (0 votos)

55 vistas250 páginas

Pymodbus

Uso libreria pymodbus

Cargado por

Julio Herrera Yarlequé

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

0% encontró este documento útil (0 votos)

55 vistas250 páginas

Pymodbus

Uso libreria pymodbus

Cargado por

Julio Herrera Yarlequé

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

PyModbus Documentation

Release 2.5.0

Sanjay

Mar 07, 2021

Contents:

1 PyModbus - A Python Modbus Stack 1

1.1 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Example Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 Pymodbus REPL (Read Evaluate Print Loop) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.6 Installing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.7 Current Work In Progress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.8 Development Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.9 Contributing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.10 License Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 CHANGELOGS 7
2.1 version 2.5.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 version 2.5.0rc3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 version 2.5.0rc2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 version 2.5.0rc1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Version 2.4.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 Version 2.3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.7 Version 2.3.0rc1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.8 Version 2.2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.9 Version 2.1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.10 Version 2.0.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.11 Version 2.0.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.12 Version 2.0.0rc1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.13 Version 1.5.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.14 Version 1.5.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.15 Version 1.5.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.16 Version 1.4.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.17 Version 1.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.18 Version 1.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.19 Version 1.3.0.rc2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.20 Version 1.3.0.rc1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.21 Version 1.2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.22 Version 1.1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.23 Version 1.0.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

i
2.24 Version 0.9.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3 Pymodbus REPL 15
3.1 Dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Usage Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 DEMO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4 Examples 23
4.1 Async Asyncio Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2 Async Asyncio Serial Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.3 Async Tornado Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.4 Async Tornado Client Serial Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.5 Async Twisted Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.6 Async Twisted Client Serial Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.7 Asynchronous Processor Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.8 Asynchronous Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.9 Callback Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.10 Changing Framers Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.11 Custom Datablock Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.12 Custom Message Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.13 Dbstore Update Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.14 Modbus Logging Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.15 Modbus Payload Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.16 Modbus Payload Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.17 performance module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.18 Synchronous Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.19 Synchronous Client Ext Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.20 Synchronous Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.21 Updating Server Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.22 Asynchronous Asyncio Serial Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.23 Bcd Payload Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.24 Concurrent Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.25 Libmodbus Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.26 Message Generator Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.27 Message Parser Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.28 Modbus Mapper Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.29 Modbus Saver Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.30 Modbus Scraper Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.31 Modbus Simulator Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
4.32 Modicon Payload Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
4.33 Remote Server Context Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.34 Serial Forwarder Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.35 Sunspec Client Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.36 Thread Safe Datastore Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.37 Gui Common Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

5 Pymodbus 145
5.1 pymodbus package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

6 Indices and tables 225

Python Module Index 227

Index 229

ii
CHAPTER 1

PyModbus - A Python Modbus Stack

Important: Note This is a Major release and might affect your existing Async client implementation. Refer
examples on how to use the latest async clients.

1.1 Summary

Pymodbus is a full Modbus protocol implementation using twisted/torndo/asyncio for its asynchronous communica-
tions core. It can also be used without any third party dependencies (aside from pyserial) if a more lightweight project
is needed. Furthermore, it should work fine under any python version > 2.7 (including python 3+)

1.2 Features

1.2.1 Client Features

• Full read/write protocol on discrete and register

• Most of the extended protocol (diagnostic/file/pipe/setting/information)
• TCP, UDP, Serial ASCII, Serial RTU, and Serial Binary
• asynchronous(powered by twisted/tornado/asyncio) and synchronous versions
• Payload builder/decoder utilities
• Pymodbus REPL for quick tests

1
PyModbus Documentation, Release 2.5.0

1.2.2 Server Features

• Can function as a fully implemented modbus server

• TCP, UDP, Serial ASCII, Serial RTU, and Serial Binary
• asynchronous(powered by twisted) and synchronous versions
• Full server control context (device information, counters, etc)
• A number of backing contexts (database, redis, sqlite, a slave device)

1.3 Use Cases

Although most system administrators will find little need for a Modbus server on any modern hardware, they may find
the need to query devices on their network for status (PDU, PDR, UPS, etc). Since the library is written in python, it
allows for easy scripting and/or integration into their existing solutions.
Continuing, most monitoring software needs to be stress tested against hundreds or even thousands of devices (why
this was originally written), but getting access to that many is unwieldy at best. The pymodbus server will allow a
user to test as many devices as their base operating system will allow (allow in this case means how many Virtual IP
addresses are allowed).
For more information please browse the project documentation:
[Link] or [Link]

1.4 Example Code

For those of you that just want to get started fast, here you go:

from [Link] import ModbusTcpClient

client = ModbusTcpClient('[Link]')
client.write_coil(1, True)
result = client.read_coils(1,1)
print([Link][0])
[Link]()

For more advanced examples, check out the Examples included in the respository. If you have created any utilities that
meet a specific need, feel free to submit them so others can benefit.

1.4.1 Examples Directory structure

examples
common. -> Common examples for clients and server (sync/async), Payload
˓→encoders and decoders.

contrib. -> Examples contributed by contributors. Serial Forwarder, Database

˓→contexts etc.

functional. -> Not actively maintained.

gui. -> Not actively maintained. If you are looking for UI,checkout
˓→`Modbus Simulator <[Link] or `Modbus Cli

˓→<[Link]

(continues on next page)

2 Chapter 1. PyModbus - A Python Modbus Stack

PyModbus Documentation, Release 2.5.0

(continued from previous page)

tools. -> Not actively maintained.
twisted. -> Not actively maintained.

Also, if you have questions, please ask them on the mailing list so that others can benefit from the results and so that I
can trace them. I get a lot of email and sometimes these requests get lost in the noise: [Link]
pymodbus or at gitter: [Link]

Important: Note For async clients, it is recomended to use ‘asyncio‘ as the async facilitator (Python 3.6 and
above). If using tornado make sure the tornado version is ‘4.5.3‘.Other versions of tornado can break the
implementation

1.5 Pymodbus REPL (Read Evaluate Print Loop)

Starting with Pymodbus 2.x, pymodbus library comes with handy Pymodbus REPL to quickly run the modbus clients
in tcp/rtu modes.
Pymodbus REPL comes with many handy features such as payload decoder to directly retrieve the values in desired
format and supports all the diagnostic function codes directly .
For more info on REPL refer Pymodbus REPL

1.6 Installing

You can install using pip or easy install by issuing the following commands in a terminal window (make sure you have
correct permissions or a virtualenv currently running):

1.5. Pymodbus REPL (Read Evaluate Print Loop) 3

PyModbus Documentation, Release 2.5.0

easy_install -U pymodbus
pip install -U pymodbus

To Install pymodbus with twisted support run:

pip install -U pymodbus[twisted]

To Install pymodbus with tornado support run:

pip install -U pymodbus[tornado]

To Install pymodbus REPL:

pip install -U pymodbus[repl]

Otherwise you can pull the trunk source and install from there:

git clone git://[Link]/bashwork/[Link]

cd pymodbus
python [Link] install

Either method will install all the required dependencies (at their appropriate versions) for your current python distri-
bution.
If you would like to install pymodbus without the twisted dependency, simply edit the [Link] file before running
easy_install and comment out all mentions of twisted. It should be noted that without twisted, one will only be able to
run the synchronized version as the asynchronous versions uses twisted for its event loop.

1.7 Current Work In Progress

Since I don’t have access to any live modbus devices anymore it is a bit hard to test on live hardware. However, if you
would like your device tested, I accept devices via mail or by IP address.
That said, the current work mainly involves polishing the library as I get time doing such tasks as:
• Make PEP-8 compatible and flake8 ready
• Fixing bugs/feature requests
• Architecture documentation
• Functional testing against any reference I can find
• The remaining edges of the protocol (that I think no one uses)
• Asynchronous clients with support to tornado , asyncio

1.8 Development Instructions

The current code base is compatible with both py2 and py3. Use make to perform a range of activities

$ make
Makefile for pymodbus

Usage:
(continues on next page)

4 Chapter 1. PyModbus - A Python Modbus Stack

PyModbus Documentation, Release 2.5.0

(continued from previous page)

make install install the package in a virtual environment

make reset recreate the virtual environment
make check check coding style (PEP-8, PEP-257)
make test run the test suite, report coverage
make tox run the tests on all Python versions
make clean cleanup all temporary files

1.9 Contributing

Just fork the repo and raise your PR against dev branch.

1.10 License Information

Pymodbus is built on top of code developed from/by:

• Copyright (c) 2001-2005 S.W.A.C. GmbH, Germany.
• Copyright (c) 2001-2005 S.W.A.C. Bohemia s.r.o., Czech Republic.
• Hynek Petrak, [Link]
• Twisted Matrix
Released under the BSD License

1.9. Contributing 5
PyModbus Documentation, Release 2.5.0

6 Chapter 1. PyModbus - A Python Modbus Stack

CHAPTER 2

CHANGELOGS

2.1 version 2.5.0

• Support response types stray and empty in repl server.

• Minor updates in asyncio server.
• Update reactive server to send stray response of given length.
• Transaction manager updates on retries for empty and invalid packets.
• Test fixes for asyncio client and transaction manager.
• Fix sync client and processing of incomplete frames with rtu framers
• Support synchronous diagnostic client (TCP)
• Server updates (REPL and async)
• Handle Memory leak in sync servers due to socketserver memory leak

2.2 version 2.5.0rc3

• Minor fix in documentations

• Travis fix for Mac OSX
• Disable unnecessary deprecation warning while using async clients.
• Use Github actions for builds in favor of travis.

2.3 version 2.5.0rc2

• Documentation updates

7
PyModbus Documentation, Release 2.5.0

• Disable strict mode by default.

• Fix ReportSlaveIdRequest request
• Sparse datablock initialization updates.

2.4 version 2.5.0rc1

• Support REPL for modbus server (only python3 and asyncio)

• Fix REPL client for write requests
• Fix examples * Asyncio server * Asynchronous server (with custom datablock) * Fix version info for servers
• Fix and enhancements to Tornado clients (seril and tcp)
• Fix and enhancements to Asyncio client and server
• Update Install instructions
• Synchronous client retry on empty and error enhancments
• Add new modbus state RETRYING
• Support runtime response manipulations for Servers
• Bug fixes with logging module in servers
• Asyncio modbus serial server support

2.5 Version 2.4.0

• Support async moduls tls server/client

• Add local echo option
• Add exponential backoffs on retries.
• REPL - Support broadcasts.
• Fix framers using wrong unit address.
• Update documentation for serial_forwarder example
• Fix error with rtu client for local_echo
• Fix asyncio client not working with already running loop
• Fix passing serial arguments to async clients
• Support timeouts to break out of responspe await when server goes offline
• Misc updates and bugfixes.

2.6 Version 2.3.0

• Support Modbus TLS (client / server)

• Distribute license with source
• BinaryPayloadDecoder/Encoder now supports float16 on python3.6 and above

8 Chapter 2. CHANGELOGS
PyModbus Documentation, Release 2.5.0

• Fix asyncio UDP client/server

• Minor cosmetic updates

2.7 Version 2.3.0rc1

• Asyncio Server implementation (Python 3.7 and above only)

• Bug fix for DiagnosticStatusResponse when odd sized response is received
• Remove Pycrypto from dependencies and include cryptodome instead
• Remove SIX requirement pinned to exact version.
• Minor bug-fixes in documentations.

2.8 Version 2.2.0

NOTE: Supports python 3.7, async client is now moved to pymodbus/client/asychronous

from [Link] import ModbusTcpClient

• Support Python 3.7

• Fix to task cancellations and CRC errors for async serial clients.
• Fix passing serial settings to asynchronous serial server.
• Fix AttributeError when setting interCharTimeout for serial clients.
• Provide an option to disable inter char timeouts with Modbus RTU.
• Add support to register custom requests in clients and server instances.
• Fix read timeout calculation in ModbusTCP.
• Fix SQLDbcontext always returning InvalidAddress error.
• Fix SQLDbcontext update failure
• Fix Binary payload example for endianess.
• Fix BinaryPayloadDecoder.to_coils and [Link] methods.
• Fix tornado async serial client TypeError while processing incoming packet.
• Fix erroneous CRC handling in Modbus RTU framer.
• Support broadcasting in Modbus Client and Servers (sync).
• Fix asyncio examples.
• Improved logging in Modbus Server .
• ReportSlaveIdRequest would fetch information from Device identity instead of hardcoded Pymodbus.
• Fix regression introduced in 2.2.0rc2 (Modbus sync client transaction failing)
• Minor update in [Link], now server logs prints received request instead of only function code

2.7. Version 2.3.0rc1 9

PyModbus Documentation, Release 2.5.0

# Now
# DEBUG:[Link]:Factory Request[ReadInputRegistersRequest: 4]
# Before
# DEBUG:[Link]:Factory Request[4]

2.9 Version 2.1.0

• Fix Issues with Serial client where in partial data was read when the response size is unknown.
• Fix Infinite sleep loop in RTU Framer.
• Add pygments as extra requirement for repl.
• Add support to modify modbus client attributes via repl.
• Update modbus repl documentation.
• More verbose logs for repl.

2.10 Version 2.0.1

• Fix unicode decoder error with BinaryPayloadDecoder in some platforms

• Avoid unnecessary import of deprecated modules with dependencies on twisted

2.11 Version 2.0.0

Note This is a Major release and might affect your existing Async client implementation. Refer examples on
how to use the latest async clients.
• Async client implementation based on Tornado, Twisted and asyncio with backward compatibility support for
twisted client.
• Allow reusing existing[running] asyncio loop when creating async client based on asyncio.
• Allow reusing address for Modbus TCP sync server.
• Add support to install tornado as extra requirement while installing pymodbus.
• Support Pymodbus REPL
• Add support to python 3.7.
• Bug fix and enhancements in examples.

2.12 Version 2.0.0rc1

10 Chapter 2. CHANGELOGS
PyModbus Documentation, Release 2.5.0

2.13 Version 1.5.2

• Fix serial client is_socket_open method

2.14 Version 1.5.1

• Fix device information selectors

• Fixed behaviour of the MEI device information command as a server when an invalid object_id is provided by
an external client.
• Add support for repeated MEI device information Object IDs (client/server)
• Added support for encoding device information when it requires more than one PDU to pack.
• Added REPR statements for all syncchronous clients
• Added isError method to exceptions, Any response received can be tested for success before proceeding.

res = client.read_holding_registers(...)
if not [Link]():

# proceed

else:
# handle error or raise

"""

• Add examples for MEI read device information request

2.15 Version 1.5.0

• Improve transaction speeds for sync clients (RTU/ASCII), now retry on empty happens only when
retry_on_empty kwarg is passed to client during intialization
client = Client(. . . , retry_on_empty=True)
• Fix tcp servers (sync/async) not processing requests with transaction id > 255
• Introduce new api to check if the received response is an error or not ([Link]())
• Move timing logic to framers so that irrespective of client, correct timing logics are followed.
• Move framers from [Link] to respective modules
• Fix modbus payload builder and decoder
• Async servers can now have an option to defer [Link]() when using
Start<Tcp/Serial/Udo>Server(. . . ,defer_reactor_run=True)
• Fix UDP client issue while handling MEI messages (ReadDeviceInformationRequest)
• Add expected response lengths for WriteMultipleCoilRequest and WriteMultipleRegisterRequest
• Fix _rtu_byte_count_pos for GetCommEventLogResponse
• Add support for repeated MEI device information Object IDs

2.13. Version 1.5.2 11

PyModbus Documentation, Release 2.5.0

• Fix struct errors while decoding stray response

• Modbus read retries works only when empty/no message is received
• Change test runner from nosetest to pytest
• Fix Misc examples

2.16 Version 1.4.0

• Bug fix Modbus TCP client reading incomplete data

• Check for slave unit id before processing the request for serial clients
• Bug fix serial servers with Modbus Binary Framer
• Bug fix header size for ModbusBinaryFramer
• Bug fix payload decoder with endian Little
• Payload builder and decoder can now deal with the wordorder as well of 32/64 bit data.
• Support Database slave contexts (SqlStore and RedisStore)
• Custom handlers could be passed to Modbus TCP servers
• Asynchronous Server could now be stopped when running on a seperate thread (StopServer)
• Signal handlers on Asyncronous servers are now handled based on current thread
• Registers in Database datastore could now be read from remote clients
• Fix examples in contrib (message_parser.py/message_generator.py/remote_server_context)
• Add new example for SqlStore and RedisStore (db store slave context)
• Fix minor comaptibility issues with utilities.
• Update test requirements
• Update/Add new unit tests
• Move twisted requirements to extra so that it is not installed by default on pymodbus installtion

2.17 Version 1.3.2

• ModbusSerialServer could now be stopped when running on a seperate thread.

• Fix issue with server and client where in the frame buffer had values from previous unsuccesful transaction
• Fix response length calculation for ModbusASCII protocol
• Fix response length calculation ReportSlaveIdResponse, DiagnosticStatusResponse
• Fix never ending transaction case when response is recieved without header and CRC
• Fix tests

12 Chapter 2. CHANGELOGS
PyModbus Documentation, Release 2.5.0

2.18 Version 1.3.1

• Recall socket recv until get a complete response

• Register_write_message.py: Observe skip_encode option when encoding a single register request
• Fix wrong expected response length for coils and discrete inputs
• Fix decode errors with ReadDeviceInformationRequest and ReportSlaveIdRequest on Python3
• Move MaskWriteRegisterRequest/MaskWriteRegisterResponse to register_write_message.py from
file_message.py
• Python3 compatible examples [WIP]
• Misc updates with examples

2.19 Version 1.3.0.rc2

• Fix encoding problem for ReadDeviceInformationRequest method on python3

• Fix problem with the usage of ord in python3 while cleaning up receive buffer
• Fix struct unpack errors with BinaryPayloadDecoder on python3 - string vs bytestring error
• Calculate expected response size for ReadWriteMultipleRegistersRequest
• Enhancement for ModbusTcpClient, ModbusTcpClient can now accept connection timeout as one of the param-
eter
• Misc updates

2.20 Version 1.3.0.rc1

• Timing improvements over MODBUS Serial interface

• Modbus RTU use 3.5 char silence before and after transactions
• Bug fix on FifoTransactionManager , flush stray data before transaction
• Update repository information
• Added ability to ignore missing slaves
• Added ability to revert to ZeroMode
• Passed a number of extra options through the stack
• Fixed documenation and added a number of examples

2.21 Version 1.2.0

• Reworking the transaction managers to be more explicit and to handle modbus RTU over TCP.
• Adding examples for a number of unique requested use cases
• Allow RTU framers to fail fast instead of staying at fault
• Working on datastore saving and loading

2.18. Version 1.3.1 13

PyModbus Documentation, Release 2.5.0

2.22 Version 1.1.0

• Fixing memory leak in clients and servers (removed del)

• Adding the ability to override the client framers
• Working on web page api and GUI
• Moving examples and extra code to contrib sections
• Adding more documentation

2.23 Version 1.0.0

• Adding support for payload builders to form complex encoding and decoding of messages.
• Adding BCD and binary payload builders
• Adding support for pydev
• Cleaning up the build tools
• Adding a message encoding generator for testing.
• Now passing kwargs to base of PDU so arguments can be used correctly at all levels of the protocol.
• A number of bug fixes (see bug tracker and commit messages)

2.24 Version 0.9.0

Please view the git commit log

14 Chapter 2. CHANGELOGS
CHAPTER 3

Pymodbus REPL

3.1 Dependencies

Depends on prompt_toolkit and click

Install dependencies

$ pip install click prompt_toolkit --upgrade

Or Install pymodbus with repl support

$ pip install pymodbus[repl] --upgrade

3.2 Usage Instructions

RTU and TCP are supported as of now

bash-3.2$ [Link]
Usage: [Link] [OPTIONS] COMMAND [ARGS]...

Options:
--version Show the version and exit.
--verbose Verbose logs
--support-diag Support Diagnostic messages
--help Show this message and exit.

Commands:
serial
tcp

TCP Options

15
PyModbus Documentation, Release 2.5.0

bash-3.2$ [Link] tcp --help

Usage: [Link] tcp [OPTIONS]

Options:
--host TEXT Modbus TCP IP
--port INTEGER Modbus TCP port
--help Show this message and exit.

SERIAL Options
bash-3.2$ [Link] serial --help
Usage: [Link] serial [OPTIONS]

Options:
--method TEXT Modbus Serial Mode (rtu/ascii)
--port TEXT Modbus RTU port
--baudrate INTEGER Modbus RTU serial baudrate to use. Defaults to 9600
--bytesize [5|6|7|8] Modbus RTU serial Number of data bits. Possible
values: FIVEBITS, SIXBITS, SEVENBITS, EIGHTBITS.
Defaults to 8
--parity [N|E|O|M|S] Modbus RTU serial parity. Enable parity checking.
Possible values: PARITY_NONE, PARITY_EVEN, PARITY_ODD
PARITY_MARK, PARITY_SPACE. Default to 'N'
--stopbits [1|1.5|2] Modbus RTU serial stop bits. Number of stop bits.
Possible values: STOPBITS_ONE,
STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO. Default to '1'
--xonxoff INTEGER Modbus RTU serial xonxoff. Enable software flow
[Link] to 0
--rtscts INTEGER Modbus RTU serial rtscts. Enable hardware (RTS/CTS)
flow control. Defaults to 0
--dsrdtr INTEGER Modbus RTU serial dsrdtr. Enable hardware (DSR/DTR)
flow control. Defaults to 0
--timeout FLOAT Modbus RTU serial read timeout. Defaults to 0.025 sec
--write-timeout FLOAT Modbus RTU serial write timeout. Defaults to 2 sec
--help Show this message and exit.

To view all available commands type help

TCP
$ [Link] tcp --host [Link] --port 5020

> help
Available commands:
client.change_ascii_input_delimiter Diagnostic sub command, Change message
˓→delimiter for future requests.

client.clear_counters Diagnostic sub command, Clear all

˓→counters and diag registers.

client.clear_overrun_count Diagnostic sub command, Clear over run

˓→counter.

[Link] Closes the underlying socket connection

[Link] Connect to the modbus tcp server
client.debug_enabled Returns a boolean indicating if debug is
˓→enabled.

client.force_listen_only_mode Diagnostic sub command, Forces the

˓→addressed remote device to its Listen Only Mode.
client.get_clear_modbus_plus Diagnostic sub command, Get or clear
˓→stats of remote modbus plus device.
(continues on next page)

16 Chapter 3. Pymodbus REPL

PyModbus Documentation, Release 2.5.0

(continued from previous page)

client.get_com_event_counter Read status word and an event count
˓→from the remote device's communication event counter.
client.get_com_event_log Read status word, event count, message
˓→count, and a field of event bytes from the remote device.

[Link] Read Only!

client.idle_time Bus Idle Time to initiate next
˓→transaction

client.is_socket_open Check whether the underlying socket/

˓→serial is open or not.

client.last_frame_end Read Only!

client.mask_write_register Mask content of holding register at
˓→àddress` with ànd_mask` and òr_mask`.
[Link] Read Only!
client.read_coils Reads `count` coils from a given slave
˓→starting at àddress`.

client.read_device_information Read the identification and additional

˓→information of remote slave.

client.read_discrete_inputs Reads `count` number of discrete inputs

˓→starting at offset `address`.

client.read_exception_status Read the contents of eight Exception

˓→Status outputs in a remote device.
client.read_holding_registers Read `count` number of holding registers
˓→starting at `address`.

client.read_input_registers Read `count` number of input registers

˓→starting at `address`.

client.readwrite_registers Read `read_count` number of holding

˓→registers starting at `read_address` and write `write_registers`
˓→starting at `write_address`.

client.report_slave_id Report information about remote slave ID.

client.restart_comm_option Diagnostic sub command, initialize and
˓→restart remote devices serial interface and clear all of its communications
˓→event counters .

client.return_bus_com_error_count Diagnostic sub command, Return count of

˓→CRC errors received by remote slave.
client.return_bus_exception_error_count Diagnostic sub command, Return count of
˓→Modbus exceptions returned by remote slave.
client.return_bus_message_count Diagnostic sub command, Return count of
˓→message detected on bus by remote slave.
client.return_diagnostic_register Diagnostic sub command, Read 16-bit
˓→diagnostic register.

client.return_iop_overrun_count Diagnostic sub command, Return count of

˓→iop overrun errors by remote slave.
client.return_query_data Diagnostic sub command , Loop back data
˓→sent in response.

client.return_slave_bus_char_overrun_count Diagnostic sub command, Return count of

3.2. Usage Instructions 17

PyModbus Documentation, Release 2.5.0

(continued from previous page)

client.write_coil Write `value` to coil at àddress`.
client.write_coils Write `value` to coil at àddress`.
client.write_register Write `value` to register at àddress`.
client.write_registers Write list of `values` to registers
˓→starting at àddress`.

SERIAL
$ [Link] serial --port /dev/ttyUSB0 --baudrate 19200 --timeout 2
> help
Available commands:
[Link] Read Only!
[Link] Read Only!
client.change_ascii_input_delimiter Diagnostic sub command, Change message
˓→delimiter for future requests.

client.clear_counters Diagnostic sub command, Clear all

˓→counters and diag registers.

client.clear_overrun_count Diagnostic sub command, Clear over run

˓→counter.

[Link] Closes the underlying socket connection

[Link] Connect to the modbus serial server
client.debug_enabled Returns a boolean indicating if debug is
˓→enabled.

client.force_listen_only_mode Diagnostic sub command, Forces the

˓→addressed remote device to its Listen Only Mode.
client.get_baudrate Serial Port baudrate.
client.get_bytesize Number of data bits.
client.get_clear_modbus_plus Diagnostic sub command, Get or clear
˓→stats of remote modbus plus device.
client.get_com_event_counter Read status word and an event count
˓→from the remote device's communication event counter.
client.get_com_event_log Read status word, event count, message
˓→count, and a field of event bytes from the remote device.

client.get_parity Enable Parity Checking.

client.get_port Serial Port.
client.get_serial_settings Gets Current Serial port settings.
client.get_stopbits Number of stop bits.
client.get_timeout Serial Port Read timeout.
client.idle_time Bus Idle Time to initiate next
˓→transaction

client.inter_char_timeout Read Only!

client.is_socket_open c l i e n t . i s s o c k e t o p e n
client.mask_write_register Mask content of holding register at
˓→àddress` with ànd_mask` and òr_mask`.
[Link] Read Only!
[Link] Read Only!
[Link] Read Only!
client.read_coils Reads `count` coils from a given slave
˓→starting at àddress`.

client.read_device_information Read the identification and additional

˓→information of remote slave.

client.read_discrete_inputs Reads `count` number of discrete inputs

˓→starting at offset `address`.

client.read_exception_status Read the contents of eight Exception

˓→Status outputs in a remote device.
client.read_holding_registers Read `count` number of holding registers
˓→starting at `address`.
(continues on next page)

18 Chapter 3. Pymodbus REPL

PyModbus Documentation, Release 2.5.0

(continued from previous page)

client.read_input_registers Read `count` number of input registers
˓→starting at `address`.

client.readwrite_registers Read `read_count` number of holding

˓→registers starting at `read_address` and write `write_registers`
˓→starting at `write_address`.

client.report_slave_id Report information about remote slave ID.

client.restart_comm_option Diagnostic sub command, initialize and
˓→restart remote devices serial interface and clear all of its communications
˓→event counters .

client.return_bus_com_error_count Diagnostic sub command, Return count of

client.return_iop_overrun_count Diagnostic sub command, Return count of

˓→iop overrun errors by remote slave.
client.return_query_data Diagnostic sub command , Loop back data
˓→sent in response.

client.return_slave_bus_char_overrun_count Diagnostic sub command, Return count of

˓→messages not handled by remote slave due to character overrun condition.
client.return_slave_busy_count Diagnostic sub command, Return count of
˓→server busy exceptions sent by remote slave.
client.return_slave_message_count Diagnostic sub command, Return count of
˓→messages addressed to remote slave.
client.return_slave_no_ack_count Diagnostic sub command, Return count of
˓→NO ACK exceptions sent by remote slave.
client.return_slave_no_response_count Diagnostic sub command, Return count of
˓→No responses by remote slave.
client.set_baudrate Baudrate setter.
client.set_bytesize Byte size setter.
client.set_parity Parity Setter.
client.set_port Serial Port setter.
client.set_stopbits Stop bit setter.
client.set_timeout Read timeout setter.
client.silent_interval Read Only!
[Link] Read Only!
[Link] Read Only!
[Link] Read Only!
client.write_coil Write `value` to coil at àddress`.
client.write_coils Write `value` to coil at àddress`.
client.write_register Write `value` to register at àddress`.
client.write_registers Write list of `values` to registers
˓→starting at àddress`.

[Link] Decode the register response to known

˓→formatters.

[Link] Return raw result dict.

Every command has auto suggestion on the arguments supported, arg and value are to be supplied in arg=val format.
> client.read_holding_registers count=4 address=9 unit=1
{
"registers": [
60497,
47134,
(continues on next page)

3.2. Usage Instructions 19

PyModbus Documentation, Release 2.5.0

(continued from previous page)

34091,
15424
]
}

For Holding and Input register reads, the decoded value could be viewed with [Link]
> [Link] word_order=little byte_order=little formatters=float64
28.17

Client settings could be retrieved and altered as well.

> # For serial settings

> # Check the serial mode

> [Link]
"rtu"

> client.get_serial_settings
{
"t1.5": 0.00171875,
"baudrate": 9600,
"read timeout": 0.5,
"port": "/dev/ptyp0",
"t3.5": 0.00401,
"bytesize": 8,
"parity": "N",
"stopbits": 1.0
}
> client.set_timeout value=1
null

> client.get_timeout
1.0

> client.get_serial_settings
{
"t1.5": 0.00171875,
"baudrate": 9600,
"read timeout": 1.0,
"port": "/dev/ptyp0",
"t3.5": 0.00401,
"bytesize": 8,
(continues on next page)

20 Chapter 3. Pymodbus REPL

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"parity": "N",
"stopbits": 1.0
}

3.3 DEMO

3.3. DEMO 21
PyModbus Documentation, Release 2.5.0

22 Chapter 3. Pymodbus REPL

CHAPTER 4

Examples

===

4.1 Async Asyncio Client Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the asynchronous modbus

client implementation from pymodbus with ayncio.

The example is only valid on Python3.4 and above

"""
from [Link] import IS_PYTHON3, PYTHON_VERSION
if IS_PYTHON3 and PYTHON_VERSION >= (3, 4):
import asyncio
import logging
# ----------------------------------------------------------------------- #
# Import the required asynchronous client
# ----------------------------------------------------------------------- #
from [Link] import AsyncModbusTCPClient as ModbusClient
# from [Link] import (
# AsyncModbusUDPClient as ModbusClient)
from [Link] import schedulers

else:
import sys
[Link]("This example needs to be run only on python 3.4 and above")
[Link](1)

from threading import Thread

(continues on next page)

23
PyModbus Documentation, Release 2.5.0

(continued from previous page)

import time
# --------------------------------------------------------------------------- #
# configure the client logging
# --------------------------------------------------------------------------- #

[Link]()
log = [Link]()
[Link]([Link])

# --------------------------------------------------------------------------- #
# specify slave to query
# --------------------------------------------------------------------------- #
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# --------------------------------------------------------------------------- #

UNIT = 0x01

async def start_async_test(client):

# ----------------------------------------------------------------------- #
# example requests
# ----------------------------------------------------------------------- #
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that some modbus
# implementations differentiate holding/input discrete/coils and as such
# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied asynchronous modbus server (script supplied).
# ----------------------------------------------------------------------- #
[Link]("Write to a Coil and read back")
rq = await client.write_coil(0, True, unit=UNIT)
rr = await client.read_coils(0, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link][0] == True) # test the expected value

[Link]("Write to multiple coils and read back- test 1")

rq = await client.write_coils(1, [True]*8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
rr = await client.read_coils(1, 21, unit=UNIT)
assert(rr.function_code < 0x80) # test that we are not an error
resp = [True]*21

(continues on next page)

24 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# If the returned output quantity is not a multiple of eight,
# the remaining bits in the final data byte will be padded with zeros
# (toward the high order end of the byte).

[Link]([False]*3)
assert([Link] == resp) # test the expected value

[Link]("Write to multiple coils and read back - test 2")

rq = await client.write_coils(1, [False]*8, unit=UNIT)
rr = await client.read_coils(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link] == [False]*8) # test the expected value

[Link]("Read discrete inputs")

rr = await client.read_discrete_inputs(0, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error

[Link]("Write to a holding register and read back")

rq = await client.write_register(1, 10, unit=UNIT)
rr = await client.read_holding_registers(1, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link][0] == 10) # test the expected value

[Link]("Write to multiple holding registers and read back")

rq = await client.write_registers(1, [10]*8, unit=UNIT)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link] == [10]*8) # test the expected value

[Link]("Read input registers")

rr = await client.read_input_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error

arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
[Link]("Read write registeres simulataneously")
rq = await client.readwrite_registers(unit=UNIT, **arguments)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link] == [20]*8) # test the expected value
assert([Link] == [20]*8) # test the expected value
await [Link](1)

def run_with_not_running_loop():
"""
A loop is created and is passed to ModbusClient factory to be used.

:return:
"""
[Link]("Running Async client with asyncio loop not yet started")
[Link]("------------------------------------------------------")
loop = asyncio.new_event_loop()
(continues on next page)

4.1. Async Asyncio Client Example 25

PyModbus Documentation, Release 2.5.0

(continued from previous page)

assert not loop.is_running()
asyncio.set_event_loop(loop)
new_loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020, loop=loop)
loop.run_until_complete(start_async_test([Link]))
[Link]()
[Link]("--------------RUN_WITH_NOT_RUNNING_LOOP---------------")
[Link]("")

def run_with_already_running_loop():
"""
An already running loop is passed to ModbusClient Factory
:return:
"""
[Link]("Running Async client with asyncio loop already started")
[Link]("------------------------------------------------------")

def done(future):
[Link]("Done !!!")

def start_loop(loop):
"""
Start Loop
:param loop:
:return:
"""
asyncio.set_event_loop(loop)
loop.run_forever()

loop = asyncio.new_event_loop()
t = Thread(target=start_loop, args=[loop])
[Link] = True
# Start the loop
[Link]()
assert loop.is_running()
asyncio.set_event_loop(loop)
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020, loop=loop)
future = asyncio.run_coroutine_threadsafe(
start_async_test([Link]), loop=loop)
future.add_done_callback(done)
while not [Link]():
[Link](0.1)
[Link]()
[Link]("--------DONE RUN_WITH_ALREADY_RUNNING_LOOP-------------")
[Link]("")

def run_with_no_loop():
"""
ModbusClient Factory creates a loop.
:return:
"""
[Link]("---------------------RUN_WITH_NO_LOOP-----------------")
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020)
loop.run_until_complete(start_async_test([Link]))
[Link]()
[Link]("--------DONE RUN_WITH_NO_LOOP-------------")
(continues on next page)

26 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]("")

if __name__ == '__main__':
# Run with No loop
[Link]("Running Async client")
[Link]("------------------------------------------------------")
run_with_no_loop()

# Run with loop not yet started

# run_with_not_running_loop()

# Run with already running loop

# run_with_already_running_loop()

[Link]("")

4.2 Async Asyncio Serial Client Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the asynchronous serial modbus

client implementation from pymodbus with ayncio.

The example is only valid on Python3.4 and above

"""
from [Link] import IS_PYTHON3, PYTHON_VERSION
if IS_PYTHON3 and PYTHON_VERSION >= (3, 4):
import logging
import asyncio
from [Link] import (
AsyncModbusSerialClient as ModbusClient)
from [Link] import schedulers
else:
import sys
[Link]("This example needs to be run only on python 3.4 and above")
[Link](1)

4.2. Async Asyncio Serial Client Example 27

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# which defaults to `0x00`
# --------------------------------------------------------------------------- #

UNIT = 0x01

async def start_async_test(client):

# ----------------------------------------------------------------------- #
# specify slave to query
# ----------------------------------------------------------------------- #
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
try:
# ----------------------------------------------------------------------- #
# example requests
# ----------------------------------------------------------------------- #
# simply call the methods that you would like to use.
# An example session is displayed below along with some assert checks.
# Note that some modbus implementations differentiate holding/
# input discrete/coils and as such you will not be able to write to
# these, therefore the starting values are not known to these tests.
# Furthermore, some use the same memory blocks for the two sets,
# so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied asynchronous modbus server (script supplied).
# ----------------------------------------------------------------------- #
[Link]("Write to a Coil and read back")
rq = await client.write_coil(0, True, unit=UNIT)
rr = await client.read_coils(0, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link][0] == True) # test the expected value

[Link]("Write to multiple coils and read back- test 1")

# If the returned output quantity is not a multiple of eight,

# the remaining bits in the final data byte will be padded with zeros
# (toward the high order end of the byte).

[Link]([False]*3)
assert([Link] == resp) # test the expected value

[Link]("Write to multiple coils and read back - test 2")

[Link]("Read discrete inputs")

rr = await client.read_discrete_inputs(0, 8, unit=UNIT)
(continues on next page)

28 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

assert(rq.function_code < 0x80) # test that we are not an error

[Link]("Write to a holding register and read back")

[Link]("Write to multiple holding registers and read back")

[Link]("Read input registers")

rr = await client.read_input_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error

arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
[Link]("Read write registers simulataneously")
rq = await client.readwrite_registers(unit=UNIT, **arguments)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link] == [20]*8) # test the expected value
assert([Link] == [20]*8) # test the expected value
except Exception as e:
[Link](e)
[Link]()
await [Link](1)

if __name__ == '__main__':
# ----------------------------------------------------------------------- #
# For testing on linux based systems you can use socat to create serial
# ports
# ----------------------------------------------------------------------- #
# socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600 PTY,
# link=/tmp/ttyp0,raw,echo=0,ospeed=9600
loop, client = ModbusClient(schedulers.ASYNC_IO, port='/tmp/ptyp0',
baudrate=9600, method="rtu")
loop.run_until_complete(start_async_test([Link]))
[Link]()

4.3 Async Tornado Client Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Client Examples
(continues on next page)

4.3. Async Tornado Client Example 29

PyModbus Documentation, Release 2.5.0

(continued from previous page)

--------------------------------------------------------------------------

The following is an example of how to use the asynchronous modbus

client implementation from pymodbus using Tornado.
"""

import functools
from [Link] import IOLoop
from [Link] import schedulers

# ---------------------------------------------------------------------------#
# choose the requested modbus protocol
# ---------------------------------------------------------------------------#

# from [Link] import AsyncModbusUDPClient as ModbusClient

from [Link] import AsyncModbusTCPClient as ModbusClient

# ---------------------------------------------------------------------------#
# helper method to test deferred callbacks
# ---------------------------------------------------------------------------#

def dassert(future, callback):

def _assertor(value):
# by pass assertion, an error here stops the write callbacks
assert value

def on_done(f):
exc = [Link]()
if exc:
[Link](exc)
return _assertor(False)

return _assertor(callback([Link]()))

future.add_done_callback(on_done)

def _print(value):
if hasattr(value, "bits"):
t = [Link]
elif hasattr(value, "registers"):
t = [Link]
else:
[Link](value)
return
[Link]("Printing : -- {}".format(t))
(continues on next page)

30 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

return t

UNIT = 0x01

# ---------------------------------------------------------------------------#
# example requests
# ---------------------------------------------------------------------------#
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that unlike the
# synchronous version of the client, the asynchronous version returns
# deferreds which can be thought of as a handle to the callback to send
# the result of the operation. We are handling the result using the
# deferred assert helper(dassert).
# ---------------------------------------------------------------------------#

def beginAsynchronousTest(client, protocol):

rq = client.write_coil(1, True, unit=UNIT)
rr = client.read_coils(1, 1, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_coils(1, [False]*8, unit=UNIT)

rr = client.read_coils(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_coils(1, [False]*8, unit=UNIT)

rr = client.read_discrete_inputs(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_register(1, 10, unit=UNIT)

rr = client.read_holding_registers(1, 1, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_registers(1, [10]*8, unit=UNIT)

rr = client.read_input_registers(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
rq = client.readwrite_registers(**arguments, unit=UNIT)
rr = client.read_input_registers(1,8, unit=UNIT)
dassert(rq, lambda r: [Link] == [20]*8) # test the expected value
dassert(rr, _print) # test the expected value

# -----------------------------------------------------------------------#
# close the client at some time later
# -----------------------------------------------------------------------#
(continues on next page)

4.3. Async Tornado Client Example 31

PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]().add_timeout([Link]().time() + 1, [Link])
[Link]().add_timeout([Link]().time() + 2, [Link])

# ---------------------------------------------------------------------------#
# choose the client you want
# ---------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
# ---------------------------------------------------------------------------#

def err(*args, **kwargs):

[Link]("Err", args, kwargs)

def callback(protocol, future):

[Link]("Client connected")
exp = [Link]()
if exp:
return err(exp)

client = [Link]()
return beginAsynchronousTest(client, protocol)

if __name__ == "__main__":
protocol, future = ModbusClient(schedulers.IO_LOOP, port=5020)
future.add_done_callback([Link](callback, protocol))

4.4 Async Tornado Client Serial Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the asynchronous serial modbus

client implementation from pymodbus using tornado.
"""
# ---------------------------------------------------------------------------#
# import needed libraries
# ---------------------------------------------------------------------------#
import functools

from [Link] import IOLoop

from [Link] import schedulers

# ---------------------------------------------------------------------------#
# choose the requested modbus protocol
# ---------------------------------------------------------------------------#
(continues on next page)

32 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

from [Link] import AsyncModbusSerialClient

FORMAT = ('%(asctime)-15s %(threadName)-15s'

' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

def dassert(future, callback):

def _assertor(value):
# by pass assertion, an error here stops the write callbacks
assert value

def on_done(f):
exc = [Link]()
if exc:
[Link](exc)
return _assertor(False)

return _assertor(callback([Link]()))

future.add_done_callback(on_done)

def _print(value):
if hasattr(value, "bits"):
t = [Link]
elif hasattr(value, "registers"):
t = [Link]
else:
[Link](value)
return
[Link]("Printing : -- {}".format(t))
return t

4.4. Async Tornado Client Serial Example 33

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# ---------------------------------------------------------------------------#

UNIT = 0x01

def beginAsynchronousTest(client, protocol):

rq = client.write_coil(1, True, unit=UNIT)
rr = client.read_coils(1, 1, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_coils(1, [False]*8, unit=UNIT)

rr = client.read_coils(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_coils(1, [False]*8, unit=UNIT)

rr = client.read_discrete_inputs(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_register(1, 10, unit=UNIT)

rr = client.read_holding_registers(1, 1, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

rq = client.write_registers(1, [10]*8, unit=UNIT)

rr = client.read_input_registers(1, 8, unit=UNIT)
dassert(rq, lambda r: r.function_code < 0x80) # test for no error
dassert(rr, _print) # test the expected value

(continues on next page)

34 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

def err(*args, **kwargs):
[Link]("Err", args, kwargs)

def callback(protocol, future):

[Link]("Client connected")
exp = [Link]()
if exp:
return err(exp)

client = [Link]()
return beginAsynchronousTest(client, protocol)

if __name__ == "__main__":
# ----------------------------------------------------------------------- #
# Create temporary serial ports using SOCAT

# socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600 PTY,

# link=/tmp/ttyp0,raw,echo=0,ospeed=9600

# Default framer is ModbusRtuFramer

# ----------------------------------------------------------------------- #

# Rtu
protocol, future = AsyncModbusSerialClient(schedulers.IO_LOOP,
method="rtu",
port="/tmp/ptyp0",
baudrate=9600,
timeout=2)

# Asci
# from [Link] import ModbusAsciiFramer
# protocol, future = AsyncModbusSerialClient(schedulers.IO_LOOP,
# method="ascii",
# port="/dev/ptyp0",
# framer=ModbusAsciiFramer,
# baudrate=9600,
# timeout=2)

# Binary
# from [Link] import ModbusBinaryFramer
# protocol, future = AsyncModbusSerialClient(schedulers.IO_LOOP,
# method="binary",
# port="/dev/ptyp0",
# framer=ModbusBinaryFramer,
# baudrate=9600,
# timeout=2)
future.add_done_callback([Link](callback, protocol))

4.5 Async Twisted Client Example

#!/usr/bin/env python
"""
(continues on next page)

4.5. Async Twisted Client Example 35

PyModbus Documentation, Release 2.5.0

(continued from previous page)

Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the asynchronous modbus

client implementation from pymodbus.
"""
# --------------------------------------------------------------------------- #
# import needed libraries
# --------------------------------------------------------------------------- #

from [Link] import reactor

from [Link] import AsyncModbusTCPClient

# from [Link] import AsyncModbusUDPClient
from [Link] import schedulers

# --------------------------------------------------------------------------- #
# choose the requested modbus protocol
# --------------------------------------------------------------------------- #

from [Link] import reactor, protocol

# --------------------------------------------------------------------------- #
# configure the client logging
# --------------------------------------------------------------------------- #
import logging
FORMAT = ('%(asctime)-15s %(threadName)-15s'
' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

# --------------------------------------------------------------------------- #
# helper method to test deferred callbacks
# --------------------------------------------------------------------------- #

def err(*args, **kwargs):

[Link]("Err-{}-{}".format(args, kwargs))

def dassert(deferred, callback):

def _assertor(value):
assert value
[Link](lambda r: _assertor(callback(r)))
[Link](err)

UNIT = 0x01
(continues on next page)

36 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

def processResponse(result):
[Link](result)

def exampleRequests(client):
rr = client.read_coils(1, 1, unit=0x02)
[Link](processResponse)
rr = client.read_holding_registers(1, 1, unit=0x02)
[Link](processResponse)
rr = client.read_discrete_inputs(1, 1, unit=0x02)
[Link](processResponse)
rr = client.read_input_registers(1, 1, unit=0x02)
[Link](processResponse)
stopAsynchronousTest(client)

# --------------------------------------------------------------------------- #
# example requests
# --------------------------------------------------------------------------- #
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that unlike the
# synchronous version of the client, the asynchronous version returns
# deferreds which can be thought of as a handle to the callback to send
# the result of the operation. We are handling the result using the
# deferred assert helper(dassert).
# --------------------------------------------------------------------------- #

def stopAsynchronousTest(client):
# ----------------------------------------------------------------------- #
# close the client at some time later
# ----------------------------------------------------------------------- #
[Link](1, [Link])
[Link](2, [Link])

def beginAsynchronousTest(client):
rq = client.write_coil(1, True, unit=UNIT)
rr = client.read_coils(1, 1, unit=UNIT)
dassert(rq, lambda r: not [Link]()) # test for no error
dassert(rr, lambda r: [Link][0] == True) # test the expected value

rq = client.write_coils(1, [True]*8, unit=UNIT)

rr = client.read_coils(1, 8, unit=UNIT)
dassert(rq, lambda r: not [Link]()) # test for no error
dassert(rr, lambda r: [Link] == [True]*8) # test the expected value

rq = client.write_coils(1, [False]*8, unit=UNIT)

rr = client.read_discrete_inputs(1, 8, unit=UNIT)
dassert(rq, lambda r: not [Link]()) # test for no error
dassert(rr, lambda r: [Link] == [True]*8) # test the expected value

rq = client.write_register(1, 10, unit=UNIT)

rr = client.read_holding_registers(1, 1, unit=UNIT)
dassert(rq, lambda r: not [Link]()) # test for no error
dassert(rr, lambda r: [Link][0] == 10) # test the expected value
(continues on next page)

4.5. Async Twisted Client Example 37

PyModbus Documentation, Release 2.5.0

(continued from previous page)

rq = client.write_registers(1, [10]*8, unit=UNIT)

rr = client.read_input_registers(1, 8, unit=UNIT)
dassert(rq, lambda r: not [Link]()) # test for no error
dassert(rr, lambda r: [Link] == [17]*8) # test the expected value

arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
rq = client.readwrite_registers(arguments, unit=UNIT)
rr = client.read_input_registers(1, 8, unit=UNIT)
dassert(rq, lambda r: [Link] == [20]*8) # test the expected value
dassert(rr, lambda r: [Link] == [17]*8) # test the expected value
stopAsynchronousTest(client)

# ----------------------------------------------------------------------- #
# close the client at some time later
# ----------------------------------------------------------------------- #
# [Link](1, [Link])
[Link](2, [Link])

# --------------------------------------------------------------------------- #
# extra requests
# --------------------------------------------------------------------------- #
# If you are performing a request that is not available in the client
# mixin, you have to perform the request like this instead::
#
# from pymodbus.diag_message import ClearCountersRequest
# from pymodbus.diag_message import ClearCountersResponse
#
# request = ClearCountersRequest()
# response = [Link](request)
# if isinstance(response, ClearCountersResponse):
# ... do something with the response
#
# --------------------------------------------------------------------------- #

# --------------------------------------------------------------------------- #
# choose the client you want
# --------------------------------------------------------------------------- #
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
# --------------------------------------------------------------------------- #

if __name__ == "__main__":
protocol, deferred = AsyncModbusTCPClient([Link], port=5020)
# protocol, deferred = AsyncModbusUDPClient([Link], port=5020)
# callback=beginAsynchronousTest,
# errback=err)
[Link](beginAsynchronousTest)
[Link](err)

38 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

4.6 Async Twisted Client Serial Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the asynchronous serial modbus

client implementation from pymodbus with twisted.
"""

from [Link] import reactor

from [Link] import schedulers
from [Link] import AsyncModbusSerialClient
from [Link] import ModbusClientProtocol

import logging
[Link]()
log = [Link]("pymodbus")
[Link]([Link])

# ---------------------------------------------------------------------------#
# state a few constants
# ---------------------------------------------------------------------------#

SERIAL_PORT = "/tmp/ptyp0"
STATUS_REGS = (1, 2)
STATUS_COILS = (1, 3)
CLIENT_DELAY = 1
UNIT = 0x01

class ExampleProtocol(ModbusClientProtocol):

def init(self, framer):

""" Initializes our custom protocol

:param framer: The decoder to use to process messages

:param endpoint: The endpoint to send results to
"""
ModbusClientProtocol.__init__(self, framer)
[Link]("Beginning the processing loop")
[Link](CLIENT_DELAY, self.fetch_holding_registers)

def fetch_holding_registers(self):
""" Defer fetching holding registers
"""
[Link]("Starting the next cycle")
d = self.read_holding_registers(*STATUS_REGS, unit=UNIT)
[Link](self.send_holding_registers, self.error_handler)

def send_holding_registers(self, response):

""" Write values of holding registers, defer fetching coils

:param response: The response to process

"""
[Link]([Link](0))
[Link]([Link](1))
(continues on next page)

4.6. Async Twisted Client Serial Example 39

PyModbus Documentation, Release 2.5.0

(continued from previous page)

d = self.read_coils(*STATUS_COILS, unit=UNIT)
[Link](self.start_next_cycle, self.error_handler)

def start_next_cycle(self, response):

""" Write values of coils, trigger next cycle

:param response: The response to process

"""
[Link]([Link](0))
[Link]([Link](1))
[Link]([Link](2))
[Link](CLIENT_DELAY, self.fetch_holding_registers)

def error_handler(self, failure):

""" Handle any twisted errors

:param failure: The error to handle

"""
[Link](failure)

if __name__ == "__main__":
import time
proto, client = AsyncModbusSerialClient([Link],
method="rtu",
port=SERIAL_PORT,
timeout=2,
proto_cls=ExampleProtocol)
[Link]()
[Link](10) # Wait for operation to complete
# [Link]()

4.7 Asynchronous Processor Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Processor Example
--------------------------------------------------------------------------

The following is a full example of a continuous client processor. Feel

free to use it as a skeleton guide in implementing your own.
"""
# --------------------------------------------------------------------------- #
# import the neccessary modules
# --------------------------------------------------------------------------- #
from [Link] import serialport, reactor
from [Link] import ClientFactory
from [Link] import ClientDecoder
from [Link] import ModbusClientProtocol

# --------------------------------------------------------------------------- #
# Choose the framer you want to use
(continues on next page)

40 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# --------------------------------------------------------------------------- #
# from [Link] import ModbusBinaryFramer as ModbusFramer
# from [Link] import ModbusAsciiFramer as ModbusFramer
from [Link] import ModbusRtuFramer as ModbusFramer
# from [Link] import ModbusSocketFramer as ModbusFramer

# --------------------------------------------------------------------------- #
# state a few constants
# --------------------------------------------------------------------------- #

SERIAL_PORT = "/dev/ptyp0"
STATUS_REGS = (1, 2)
STATUS_COILS = (1, 3)
CLIENT_DELAY = 1
UNIT = 0x01

# --------------------------------------------------------------------------- #
# an example custom protocol
# --------------------------------------------------------------------------- #
# Here you can perform your main procesing loop utilizing defereds and timed
# callbacks.
# --------------------------------------------------------------------------- #
class ExampleProtocol(ModbusClientProtocol):

def init(self, framer, endpoint):

""" Initializes our custom protocol

:param framer: The decoder to use to process messages

:param endpoint: The endpoint to send results to
"""
ModbusClientProtocol.__init__(self, framer)
[Link] = endpoint
[Link]("Beginning the processing loop")
[Link](CLIENT_DELAY, self.fetch_holding_registers)

def send_holding_registers(self, response):

""" Write values of holding registers, defer fetching coils

:param response: The response to process

(continues on next page)

4.7. Asynchronous Processor Example 41

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
[Link]([Link](0))
[Link]([Link](1))
d = self.read_coils(*STATUS_COILS, unit=UNIT)
[Link](self.start_next_cycle, self.error_handler)

def start_next_cycle(self, response):

""" Write values of coils, trigger next cycle

:param response: The response to process

"""
[Link]([Link](0))
[Link]([Link](1))
[Link]([Link](2))
[Link](CLIENT_DELAY, self.fetch_holding_registers)

def error_handler(self, failure):

""" Handle any twisted errors

:param failure: The error to handle

"""
[Link](failure)

# --------------------------------------------------------------------------- #
# a factory for the example protocol
# --------------------------------------------------------------------------- #
# This is used to build client protocol's if you tie into twisted's method
# of processing. It basically produces client instances of the underlying
# protocol::
#
# Factory(Protocol) -> ProtocolInstance
#
# It also persists data between client instances (think protocol singelton).
# --------------------------------------------------------------------------- #
class ExampleFactory(ClientFactory):

protocol = ExampleProtocol

def init(self, framer, endpoint):

""" Remember things necessary for building a protocols """
[Link] = framer
[Link] = endpoint

def buildProtocol(self, _):

""" Create a protocol and start the reading cycle """
proto = [Link]([Link], [Link])
[Link] = self
return proto

42 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# - [Link]
#
# How you start your client is really up to you.
# --------------------------------------------------------------------------- #
class SerialModbusClient([Link]):

def init(self, factory, *args, **kwargs):

""" Setup the client and start listening on the serial port

:param factory: The factory to build clients with

"""
protocol = [Link](None)
[Link] = ClientDecoder()
[Link].__init__(self, protocol, *args, **kwargs)

# --------------------------------------------------------------------------- #
# a custom endpoint for our results
# --------------------------------------------------------------------------- #
# An example line reader, this can replace with:
# - the TCP protocol
# - a context recorder
# - a database or file recorder
# --------------------------------------------------------------------------- #
class LoggingLineReader(object):

def write(self, response):

""" Handle the next modbus response

:param response: The response to process

"""
[Link]("Read Data: %d" % response)

# --------------------------------------------------------------------------- #
# start running the processor
# --------------------------------------------------------------------------- #
# This initializes the client, the framer, the factory, and starts the
# twisted event loop (the reactor). It should be noted that a number of
# things could be chanegd as one sees fit:
# - The ModbusRtuFramer could be replaced with a ModbusAsciiFramer
# - The SerialModbusClient could be replaced with [Link]
# - The LineReader endpoint could be replaced with a database store
# --------------------------------------------------------------------------- #

def main():
[Link]("Initializing the client")
framer = ModbusFramer(ClientDecoder(), client=None)
reader = LoggingLineReader()
factory = ExampleFactory(framer, reader)
SerialModbusClient(factory, SERIAL_PORT, reactor)
# factory = [Link]("localhost", 502, factory)
[Link]("Starting the client")
[Link]()

if __name__ == "__main__":
(continues on next page)

4.7. Asynchronous Processor Example 43

PyModbus Documentation, Release 2.5.0

(continued from previous page)

main()

4.8 Asynchronous Server Example

#!/usr/bin/env python
"""
Pymodbus Asynchronous Server Example
--------------------------------------------------------------------------

The asynchronous server is a high performance implementation using the

twisted library as its backend. This allows it to scale to many thousands
of nodes which can be helpful for testing monitoring software.
"""
# --------------------------------------------------------------------------- #
# import the various server implementations
# --------------------------------------------------------------------------- #
from [Link] import version
from [Link] import StartTcpServer
from [Link] import StartUdpServer
from [Link] import StartSerialServer

from [Link] import ModbusDeviceIdentification

from [Link] import ModbusSequentialDataBlock
from [Link] import ModbusSlaveContext, ModbusServerContext
from [Link] import (ModbusRtuFramer,
ModbusAsciiFramer,
ModbusBinaryFramer)
from custom_message import CustomModbusRequest

# --------------------------------------------------------------------------- #
# configure the service logging
# --------------------------------------------------------------------------- #
import logging
FORMAT = ('%(asctime)-15s %(threadName)-15s'
' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

def run_async_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 from 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
(continues on next page)

44 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# 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 = [Link]())
# store = ModbusSlaveContext()
#
# Finally, you are allowed to use the same DataBlock reference for every
# table or you you may use a seperate 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))
[Link](CustomModbusRequest.function_code, 'cm',
ModbusSequentialDataBlock(0, [17] * 100))
context = ModbusServerContext(slaves=store, single=True)

4.8. Asynchronous Server Example 45

PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link] = 'Pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'Pymodbus Server'
[Link] = 'Pymodbus Server'
[Link] = [Link]()

# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #

# TCP Server

StartTcpServer(context, identity=identity, address=("localhost", 5020),

custom_functions=[CustomModbusRequest])

# TCP Server with deferred reactor run

# from [Link] import reactor

# StartTcpServer(context, identity=identity, address=("localhost", 5020),
# defer_reactor_run=True)
# [Link]()

# Server with RTU framer

# StartTcpServer(context, identity=identity, address=("localhost", 5020),
# framer=ModbusRtuFramer)

# UDP Server
# StartUdpServer(context, identity=identity, address=("[Link]", 5020))

# RTU Server
# StartSerialServer(context, identity=identity,
# port='/dev/ttyp0', framer=ModbusRtuFramer)

# ASCII Server
# StartSerialServer(context, identity=identity,
# port='/dev/ttyp0', framer=ModbusAsciiFramer)

# Binary Server
# StartSerialServer(context, identity=identity,
# port='/dev/ttyp0', framer=ModbusBinaryFramer)

if __name__ == "__main__":
run_async_server()

4.9 Callback Server Example

#!/usr/bin/env python
"""
Pymodbus Server With Callbacks
--------------------------------------------------------------------------

(continues on next page)

46 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

This is an example of adding callbacks to a running modbus server
when a value is written to it. In order for this to work, it needs
a device-mapping file.
"""
# --------------------------------------------------------------------------- #
# import the modbus libraries we need
# --------------------------------------------------------------------------- #
from [Link] import version
from [Link] import StartTcpServer
from [Link] import ModbusDeviceIdentification
from [Link] import ModbusSparseDataBlock
from [Link] import ModbusSlaveContext, ModbusServerContext
from [Link] import ModbusRtuFramer, ModbusAsciiFramer

# --------------------------------------------------------------------------- #
# import the python libraries we need
# --------------------------------------------------------------------------- #
from multiprocessing import Queue, Process

# --------------------------------------------------------------------------- #
# create your custom data block with callbacks
# --------------------------------------------------------------------------- #

class CallbackDataBlock(ModbusSparseDataBlock):
""" A datablock that stores the new value in memory
and passes the operation to a message queue for further
processing.
"""

def init(self, devices, queue):

"""
"""
[Link] = devices
[Link] = queue

values = {k: 0 for k in [Link]()}

values[0xbeef] = len(values) # the number of devices
super(CallbackDataBlock, self).__init__(values)

def setValues(self, address, value):

""" Sets the requested values of the datastore

:param address: The starting address

:param values: The new values to be set
"""
super(CallbackDataBlock, self).setValues(address, value)
[Link](([Link](address, None), value))
(continues on next page)

4.9. Callback Server Example 47

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# --------------------------------------------------------------------------- #
# define your callback process
# --------------------------------------------------------------------------- #

def rescale_value(value):
""" Rescale the input value from the range
of 0..100 to -3200..3200.

:param value: The input value to scale

:returns: The rescaled value
"""
s = 1 if value >= 50 else -1
c = value if value < 50 else (value - 50)
return s * (c * 64)

def device_writer(queue):
""" A worker process that processes new messages
from a queue to write to device outputs

:param queue: The queue to get new messages from

"""
while True:
device, value = [Link]()
scaled = rescale_value(value[0])
[Link]("Write(%s) = %s" % (device, value))
if not device: continue
# do any logic here to update your devices

# --------------------------------------------------------------------------- #
# initialize your device map
# --------------------------------------------------------------------------- #

def read_device_map(path):
""" A helper method to read the device
path to address mapping from file::

0x0001,/dev/device1
0x0002,/dev/device2

:param path: The path to the input file

:returns: The input mapping file
"""
devices = {}
with open(path, 'r') as stream:
for line in stream:
piece = [Link]().split(',')
devices[int(piece[0], 16)] = piece[1]
return devices

def run_callback_server():
# ----------------------------------------------------------------------- #
# initialize your data store
(continues on next page)

48 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# ----------------------------------------------------------------------- #
queue = Queue()
devices = read_device_map("device-mapping")
block = CallbackDataBlock(devices, queue)
store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
context = ModbusServerContext(slaves=store, single=True)

# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
[Link] = 'pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'pymodbus Server'
[Link] = 'pymodbus Server'
[Link] = [Link]()

# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
p = Process(target=device_writer, args=(queue,))
[Link]()
StartTcpServer(context, identity=identity, address=("localhost", 5020))

if __name__ == "__main__":
run_callback_server()

4.10 Changing Framers Example

#!/usr/bin/env python
"""
Pymodbus Client Framer Overload
--------------------------------------------------------------------------

All of the modbus clients are designed to have pluggable framers

so that the transport and protocol are decoupled. This allows a user
to define or plug in their custom protocols into existing transports
(like a binary framer over a serial connection).

It should be noted that although you are not limited to trying whatever
you would like, the library makes no gurantees that all framers with
all transports will produce predictable or correct results (for example
tcp transport with an RTU framer). However, please let us know of any
success cases that are not documented!
"""
# --------------------------------------------------------------------------- #
# import the modbus client and the framers
# --------------------------------------------------------------------------- #
from [Link] import ModbusTcpClient as ModbusClient

# --------------------------------------------------------------------------- #
(continues on next page)

4.10. Changing Framers Example 49

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# Import the modbus framer that you want
# --------------------------------------------------------------------------- #
# --------------------------------------------------------------------------- #
from [Link] import ModbusSocketFramer as ModbusFramer
# from [Link] import ModbusRtuFramer as ModbusFramer
#from [Link] import ModbusBinaryFramer as ModbusFramer
#from [Link] import ModbusAsciiFramer as ModbusFramer

if __name__ == "__main__":
# ----------------------------------------------------------------------- #
# Initialize the client
# ----------------------------------------------------------------------- #
client = ModbusClient('localhost', port=5020, framer=ModbusFramer)
[Link]()

# ----------------------------------------------------------------------- #
# perform your requests
# ----------------------------------------------------------------------- #
rq = client.write_coil(1, True)
rr = client.read_coils(1,1)
assert(not [Link]()) # test that we are not an error
assert([Link][0] == True) # test the expected value

# ----------------------------------------------------------------------- #
# close the client
# ---------------------------------------------------------------------- #
[Link]()

4.11 Custom Datablock Example

#!/usr/bin/env python
"""
Pymodbus Server With Custom Datablock Side Effect
--------------------------------------------------------------------------

This is an example of performing custom logic after a value has been

written to the datastore.
"""
# --------------------------------------------------------------------------- #
# import the modbus libraries we need
# --------------------------------------------------------------------------- #
from __future__ import print_function
from [Link] import version
from [Link] import StartTcpServer
from [Link] import ModbusDeviceIdentification
from [Link] import ModbusSparseDataBlock
(continues on next page)

50 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

from [Link] import ModbusSlaveContext, ModbusServerContext
from [Link] import ModbusRtuFramer, ModbusAsciiFramer

# --------------------------------------------------------------------------- #
# configure the service logging
# --------------------------------------------------------------------------- #

import logging
[Link]()
log = [Link]()
[Link]([Link])

# --------------------------------------------------------------------------- #
# create your custom data block here
# --------------------------------------------------------------------------- #

class CustomDataBlock(ModbusSparseDataBlock):
""" A datablock that stores the new value in memory
and performs a custom action after it has been stored.
"""

def setValues(self, address, value):

""" Sets the requested values of the datastore

:param address: The starting address

:param values: The new values to be set
"""
super(CustomDataBlock, self).setValues(address, value)

# whatever you want to do with the written value is done here,

# however make sure not to do too much work here or it will
# block the server, espectially if the server is being written
# to very quickly
print("wrote {} to {}".format(value, address))

def run_custom_db_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #
block = CustomDataBlock([0]*100)
store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
context = ModbusServerContext(slaves=store, single=True)

# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #

identity = ModbusDeviceIdentification()
[Link] = 'pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'pymodbus Server'
[Link] = 'pymodbus Server'
[Link] = [Link]()

(continues on next page)

4.11. Custom Datablock Example 51

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #

# p = Process(target=device_writer, args=(queue,))
# [Link]()
StartTcpServer(context, identity=identity, address=("localhost", 5020))

if __name__ == "__main__":
run_custom_db_server()

4.12 Custom Message Example

#!/usr/bin/env python
"""
Pymodbus Synchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the synchronous modbus client

implementation from pymodbus.

It should be noted that the client can also be used with

the guard construct that is available in python 2.5 and up::

with ModbusClient('[Link]') as client:

result = client.read_coils(1,10)
print result
"""
import struct
# --------------------------------------------------------------------------- #
# import the various server implementations
# --------------------------------------------------------------------------- #
from [Link] import ModbusRequest, ModbusResponse, ModbusExceptions
from [Link] import ModbusTcpClient as ModbusClient
from pymodbus.bit_read_message import ReadCoilsRequest
from [Link] import int2byte, byte2int
# --------------------------------------------------------------------------- #
# configure the client logging
# --------------------------------------------------------------------------- #
import logging
[Link]()
log = [Link]()
[Link]([Link])

# --------------------------------------------------------------------------- #
# create your custom message
# --------------------------------------------------------------------------- #
# The following is simply a read coil request that always reads 16 coils.
# Since the function code is already registered with the decoder factory,
# this will be decoded as a read coil response. If you implement a new
# method that is not currently implemented, you must register the request
(continues on next page)

52 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# and response with a ClientDecoder factory.
# --------------------------------------------------------------------------- #

class CustomModbusResponse(ModbusResponse):
function_code = 55
_rtu_byte_count_pos = 2

def init(self, values=None, **kwargs):

ModbusResponse.__init__(self, **kwargs)
[Link] = values or []

def encode(self):
""" Encodes response pdu

:returns: The encoded packet message

"""
result = int2byte(len([Link]) * 2)
for register in [Link]:
result += [Link]('>H', register)
return result

def decode(self, data):

""" Decodes response pdu

:param data: The packet data to decode

"""
byte_count = byte2int(data[0])
[Link] = []
for i in range(1, byte_count + 1, 2):
[Link]([Link]('>H', data[i:i + 2])[0])

class CustomModbusRequest(ModbusRequest):

function_code = 55
_rtu_frame_size = 8

def init(self, address=None, **kwargs):

ModbusRequest.__init__(self, **kwargs)
[Link] = address
[Link] = 16

def encode(self):
return [Link]('>HH', [Link], [Link])

def decode(self, data):

[Link], [Link] = [Link]('>HH', data)

def execute(self, context):

if not (1 <= [Link] <= 0x7d0):
return [Link]([Link])
if not [Link](self.function_code, [Link], [Link]):
return [Link]([Link])
values = [Link](self.function_code, [Link],
[Link])
return CustomModbusResponse(values)
(continues on next page)

4.12. Custom Message Example 53

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# --------------------------------------------------------------------------- #
# This could also have been defined as
# --------------------------------------------------------------------------- #

class Read16CoilsRequest(ReadCoilsRequest):

def init(self, address, **kwargs):

""" Initializes a new instance

:param address: The address to start reading from

"""
ReadCoilsRequest.__init__(self, address, 16, **kwargs)

# --------------------------------------------------------------------------- #
# execute the request with your client
# --------------------------------------------------------------------------- #
# using the with context, the client will automatically be connected
# and closed when it leaves the current scope.
# --------------------------------------------------------------------------- #

if __name__ == "__main__":
with ModbusClient(host='localhost', port=5020) as client:
[Link](CustomModbusResponse)
request = CustomModbusRequest(1, unit=1)
result = [Link](request)
print([Link])

4.13 Dbstore Update Server Example

"""
Pymodbus Server With Updating Thread
--------------------------------------------------------------------------
This is an example of having a background thread updating the
context in an SQLite4 database while the server is operating.

This scrit generates a random address range (within 0 - 65000) and a random
value and stores it in a database. It then reads the same address to verify
that the process works as expected

This can also be done with a python thread::

from threading import Thread
thread = Thread(target=updating_writer, args=(context,))
[Link]()
"""
# --------------------------------------------------------------------------- #
# import the modbus libraries we need
# --------------------------------------------------------------------------- #
from [Link] import version
from [Link] import StartTcpServer
from [Link] import ModbusDeviceIdentification
from [Link] import ModbusSequentialDataBlock
(continues on next page)

54 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

from [Link] import ModbusServerContext
from [Link] import SqlSlaveContext
from [Link] import ModbusRtuFramer, ModbusAsciiFramer
import random

# --------------------------------------------------------------------------- #
# import the twisted libraries we need
# --------------------------------------------------------------------------- #
from [Link] import LoopingCall

# --------------------------------------------------------------------------- #
# define your callback process
# --------------------------------------------------------------------------- #

def updating_writer(a):
""" A worker process that runs every so often and
updates live values of the context which resides in an SQLite3 database.
It should be noted that there is a race condition for the update.
:param arguments: The input arguments to the call
"""
[Link]("Updating the database context")
context = a[0]
readfunction = 0x03 # read holding registers
writefunction = 0x10
slave_id = 0x01 # slave address
count = 50

# import pdb; pdb.set_trace()

rand_value = [Link](0, 9999)

rand_addr = [Link](0, 65000)
[Link]("Writing to datastore: {}, {}".format(rand_addr, rand_value))
# import pdb; pdb.set_trace()
context[slave_id].setValues(writefunction, rand_addr, [rand_value],
update=False)
values = context[slave_id].getValues(readfunction, rand_addr, count)
[Link]("Values from datastore: " + str(values))

def run_dbstore_update_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #

block = ModbusSequentialDataBlock(0x00, [0] * 0xff)

store = SqlSlaveContext(block)

context = ModbusServerContext(slaves={1: store}, single=False)

(continues on next page)

4.13. Dbstore Update Server Example 55

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# ----------------------------------------------------------------------- #
# initialize the server information
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
[Link] = 'pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'pymodbus Server'
[Link] = 'pymodbus Server'
[Link] = [Link]()

# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
time = 5 # 5 seconds delay
loop = LoopingCall(f=updating_writer, a=(context,))
[Link](time, now=False) # initially delay by time
[Link]()
StartTcpServer(context, identity=identity, address=("", 5020))

if __name__ == "__main__":
run_dbstore_update_server()

4.14 Modbus Logging Example

#!/usr/bin/env python
"""
Pymodbus Logging Examples
--------------------------------------------------------------------------
"""
import logging
import [Link] as Handlers

if __name__ == "__main__":
# ----------------------------------------------------------------------- #
# This will simply send everything logged to console
# ----------------------------------------------------------------------- #
[Link]()
log = [Link]()
[Link]([Link])

# ----------------------------------------------------------------------- #
# This will send the error messages in the specified namespace to a file.
# The available namespaces in pymodbus are as follows:
# ----------------------------------------------------------------------- #
# * pymodbus.* - The root namespace
# * [Link].* - all logging messages involving the modbus server
# * [Link].* - all logging messages involving the client
# * [Link].* - all logging messages inside the protocol layer
# ----------------------------------------------------------------------- #
(continues on next page)

56 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]()
log = [Link]('[Link]')
[Link]([Link])

# ----------------------------------------------------------------------- #
# This will send the error messages to the specified handlers:
# * [Link]/library/[Link]
# ----------------------------------------------------------------------- #
log = [Link]('pymodbus')
[Link]([Link])
handlers = [
[Link]("logfile", maxBytes=1024*1024),
[Link]("[Link]",
"pymodbus@[Link]",
["support@[Link]"],
"Pymodbus"),
[Link](facility="daemon"),
[Link]('localhost', 12345),
]
[[Link](h) for h in handlers]

4.15 Modbus Payload Example

#!/usr/bin/env python
"""
Pymodbus Payload Building/Decoding Example
--------------------------------------------------------------------------

# Run modbus_payload_server.py or synchronous_server.py to check the behavior

"""
from [Link] import Endian
from [Link] import BinaryPayloadDecoder
from [Link] import BinaryPayloadBuilder
from [Link] import ModbusTcpClient as ModbusClient
from [Link] import iteritems
from collections import OrderedDict

# --------------------------------------------------------------------------- #
# configure the client logging
# --------------------------------------------------------------------------- #

import logging
FORMAT = ('%(asctime)-15s %(threadName)-15s'
' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

ORDER_DICT = {
"<": "LITTLE",
">": "BIG"
}

(continues on next page)

4.15. Modbus Payload Example 57

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def run_binary_payload_ex():
# ----------------------------------------------------------------------- #
# We are going to use a simple client to send our requests
# ----------------------------------------------------------------------- #
client = ModbusClient('[Link]', port=5020)
[Link]()

# ----------------------------------------------------------------------- #
# 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 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

# The packing can also be applied to the word (wordorder) and bytes in each
# word (byteorder)

# The wordorder is applicable only for 32 and 64 bit values

# Lets say we need to write a value 0x12345678 to a 32 bit register

# The following combinations could be used to write the register

# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Word Order - Big Byte Order - Big
# word1 =0x1234 word2 = 0x5678

# Word Order - Big Byte Order - Little

# word1 =0x3412 word2 = 0x7856

# Word Order - Little Byte Order - Big

# word1 = 0x5678 word2 = 0x1234

# Word Order - Little Byte Order - Little

# word1 =0x7856 word2 = 0x3412
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #

# ----------------------------------------------------------------------- #
combos = [(wo, bo) for wo in [[Link], [Link]] for bo in [[Link],
˓→[Link]]]

for wo, bo in combos:

print("-" * 60)
print("Word Order: {}".format(ORDER_DICT[wo]))
print("Byte Order: {}".format(ORDER_DICT[bo]))
print()
builder = BinaryPayloadBuilder(byteorder=bo,
wordorder=wo)
(continues on next page)

58 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

strng = "abcdefgh"
builder.add_string(strng)
builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
builder.add_8bit_int(-0x12)
builder.add_8bit_uint(0x12)
builder.add_16bit_int(-0x5678)
builder.add_16bit_uint(0x1234)
builder.add_32bit_int(-0x1234)
builder.add_32bit_uint(0x12345678)
builder.add_16bit_float(12.34)
builder.add_16bit_float(-12.34)
builder.add_32bit_float(22.34)
builder.add_32bit_float(-22.34)
builder.add_64bit_int(-0xDEADBEEF)
builder.add_64bit_uint(0x12345678DEADBEEF)
builder.add_64bit_uint(0x12345678DEADBEEF)
builder.add_64bit_float(123.45)
builder.add_64bit_float(-123.45)
payload = builder.to_registers()
print("-" * 60)
print("Writing Registers")
print("-" * 60)
print(payload)
print("\n")
payload = [Link]()
address = 0
# Can write registers
# registers = builder.to_registers()
# client.write_registers(address, registers, unit=1)

# Or can write encoded binary string

client.write_registers(address, payload, skip_encode=True, unit=1)
# ----------------------------------------------------------------------- #
# If you need to decode a collection of registers in a weird layout, the
# payload decoder can help you as well.
#
# 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 bit bitstring [0,1,0,1,1,0,1,0]
# ----------------------------------------------------------------------- #
address = 0x0
count = len(payload)
result = client.read_holding_registers(address, count, unit=1)
print("-" * 60)
print("Registers")
print("-" * 60)
print([Link])
print("\n")
decoder = [Link]([Link],
byteorder=bo,
wordorder=wo)
(continues on next page)

4.15. Modbus Payload Example 59

PyModbus Documentation, Release 2.5.0

(continued from previous page)

assert decoder._byteorder == builder._byteorder, \

"Make sure byteorder is consistent between BinaryPayloadBuilder and
˓→BinaryPayloadDecoder"

assert decoder._wordorder == builder._wordorder, \

"Make sure wordorder is consistent between BinaryPayloadBuilder and
˓→BinaryPayloadDecoder"

decoded = OrderedDict([
('string', decoder.decode_string(len(strng))),
('bits', decoder.decode_bits()),
('8int', decoder.decode_8bit_int()),
('8uint', decoder.decode_8bit_uint()),
('16int', decoder.decode_16bit_int()),
('16uint', decoder.decode_16bit_uint()),
('32int', decoder.decode_32bit_int()),
('32uint', decoder.decode_32bit_uint()),
('16float', decoder.decode_16bit_float()),
('16float2', decoder.decode_16bit_float()),
('32float', decoder.decode_32bit_float()),
('32float2', decoder.decode_32bit_float()),
('64int', decoder.decode_64bit_int()),
('64uint', decoder.decode_64bit_uint()),
('ignore', decoder.skip_bytes(8)),
('64float', decoder.decode_64bit_float()),
('64float2', decoder.decode_64bit_float()),
])

print("-" * 60)
print("Decoded Data")
print("-" * 60)
for name, value in iteritems(decoded):
print("%s\t" % name, hex(value) if isinstance(value, int) else value)

# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
[Link]()

if __name__ == "__main__":
run_binary_payload_ex()

4.16 Modbus Payload Server Example

#!/usr/bin/env python
"""
Pymodbus Server Payload Example
--------------------------------------------------------------------------

If you want to initialize a server context with a complicated memory

layout, you can actually use the payload builder.
(continues on next page)

60 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
# --------------------------------------------------------------------------- #
# import the various server implementations
# --------------------------------------------------------------------------- #
from [Link] import version
from [Link] import StartTcpServer
from [Link] import ModbusDeviceIdentification
from [Link] import ModbusSequentialDataBlock
from [Link] import ModbusSlaveContext, ModbusServerContext

# --------------------------------------------------------------------------- #
# import the payload builder
# --------------------------------------------------------------------------- #

from [Link] import Endian

from [Link] import BinaryPayloadDecoder
from [Link] import BinaryPayloadBuilder

def run_payload_server():
# ----------------------------------------------------------------------- #
# build your payload
# ----------------------------------------------------------------------- #
builder = BinaryPayloadBuilder(byteorder=[Link],
wordorder=[Link])
builder.add_string('abcdefgh')
builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
builder.add_8bit_int(-0x12)
builder.add_8bit_uint(0x12)
builder.add_16bit_int(-0x5678)
builder.add_16bit_uint(0x1234)
builder.add_32bit_int(-0x1234)
builder.add_32bit_uint(0x12345678)
builder.add_16bit_float(12.34)
builder.add_16bit_float(-12.34)
builder.add_32bit_float(22.34)
builder.add_32bit_float(-22.34)
builder.add_64bit_int(-0xDEADBEEF)
builder.add_64bit_uint(0x12345678DEADBEEF)
builder.add_64bit_uint(0xDEADBEEFDEADBEED)
builder.add_64bit_float(123.45)
builder.add_64bit_float(-123.45)

# ----------------------------------------------------------------------- #
# use that payload in the data store
# ----------------------------------------------------------------------- #
(continues on next page)

4.16. Modbus Payload Server Example 61

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# Here we use the same reference block for each underlying store.
# ----------------------------------------------------------------------- #

block = ModbusSequentialDataBlock(1, builder.to_registers())

store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
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()
[Link] = 'Pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'Pymodbus Server'
[Link] = 'Pymodbus Server'
[Link] = [Link]()
# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
StartTcpServer(context, identity=identity, address=("localhost", 5020))

if __name__ == "__main__":
run_payload_server()

4.17 performance module

#!/usr/bin/env python
"""
Pymodbus Performance Example
--------------------------------------------------------------------------

The following is an quick performance check of the synchronous

modbus client.
"""
# --------------------------------------------------------------------------- #
# import the necessary modules
# --------------------------------------------------------------------------- #
from __future__ import print_function
import logging, os
from time import time
from [Link] import ModbusTcpClient
from [Link] import ModbusSerialClient

try:
from multiprocessing import log_to_stderr
except ImportError:
import logging
[Link]()
log_to_stderr = [Link]
(continues on next page)

62 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# --------------------------------------------------------------------------- #
# choose between threads or processes
# --------------------------------------------------------------------------- #

#from multiprocessing import Process as Worker

from threading import Thread as Worker
from threading import Lock
_thread_lock = Lock()
# --------------------------------------------------------------------------- #
# initialize the test
# --------------------------------------------------------------------------- #
# Modify the parameters below to control how we are testing the client:
#
# * workers - the number of workers to use at once
# * cycles - the total number of requests to send
# * host - the host to send the requests to
# --------------------------------------------------------------------------- #
workers = 10
cycles = 1000
host = '[Link]'

# --------------------------------------------------------------------------- #
# perform the test
# --------------------------------------------------------------------------- #
# This test is written such that it can be used by many threads of processes
# although it should be noted that there are performance penalties
# associated with each strategy.
# --------------------------------------------------------------------------- #
def single_client_test(host, cycles):
""" Performs a single threaded test of a synchronous
client against the specified host

:param host: The host to connect to

:param cycles: The number of iterations to perform
"""
logger = log_to_stderr()
[Link]([Link])
[Link]("starting worker: %d" % [Link]())

try:
count = 0
client = ModbusTcpClient(host, port=5020)
# client = ModbusSerialClient(method="rtu",
# port="/dev/ttyp0", baudrate=9600)
while count < cycles:
# print(count)
# with _thread_lock:
client.read_holding_registers(10, 123, unit=1)
count += 1
except:
[Link]("failed to run test successfully")
[Link]("finished worker: %d" % [Link]())

def multiprocessing_test(fn, args):

(continues on next page)

4.17. performance module 63

PyModbus Documentation, Release 2.5.0

(continued from previous page)

from multiprocessing import Process as Worker
start = time()
procs = [Worker(target=fn, args=args)
for _ in range(workers)]

any([Link]() for p in procs) # start the workers

any([Link]() for p in procs) # wait for the workers to finish
return start

def thread_test(fn, args):

from threading import Thread as Worker
start = time()
procs = [Worker(target=fn, args=args)
for _ in range(workers)]

any([Link]() for p in procs) # start the workers

any([Link]() for p in procs) # wait for the workers to finish
return start

def thread_pool_exe_test(fn, args):

from [Link] import ThreadPoolExecutor as Worker
from [Link] import as_completed
start = time()
with Worker(max_workers=workers, thread_name_prefix="Perform") as exe:
futures = {[Link](fn, *args): job for job in range(workers)}
for future in as_completed(futures):
[Link]()
return start

# --------------------------------------------------------------------------- #
# run our test and check results
# --------------------------------------------------------------------------- #
# We shard the total number of requests to perform between the number of
# threads that was specified. We then start all the threads and block on
# them to finish. This may need to switch to another mechanism to signal
# finished as the process/thread start up/shut down may skew the test a bit.

# RTU 32 requests/second @9600

# TCP 31430 requests/second

# --------------------------------------------------------------------------- #

if __name__ == "__main__":
args = (host, int(cycles * 1.0 / workers))
# with Worker(max_workers=workers, thread_name_prefix="Perform") as exe:
# futures = {[Link](single_client_test, *args): job for job in
˓→range(workers)}

# for future in as_completed(futures):

# data = [Link]()
# for _ in range(workers):
# [Link]([Link](single_client_test, args=args))
# procs = [Worker(target=single_client_test, args=args)
# for _ in range(workers)]

(continues on next page)

64 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# any([Link]() for p in procs) # start the workers
# any([Link]() for p in procs) # wait for the workers to finish
# start = multiprocessing_test(single_client_test, args)
# start = thread_pool_exe_test(single_client_test, args)
for tester in [multiprocessing_test, thread_test, thread_pool_exe_test]:
print(tester.__name__)
start = tester(single_client_test, args)
stop = time()
print("%d requests/second" % ((1.0 * cycles) / (stop - start)))
print("time taken to complete %s cycle by "
"%s workers is %s seconds" % (cycles, workers, stop-start))
print()

4.18 Synchronous Client Example

#!/usr/bin/env python
"""
Pymodbus Synchronous Client Examples
--------------------------------------------------------------------------

The following is an example of how to use the synchronous modbus client

implementation from pymodbus.

It should be noted that the client can also be used with

the guard construct that is available in python 2.5 and up::

with ModbusClient('[Link]') as client:

result = client.read_coils(1,10)
print result
"""
# --------------------------------------------------------------------------- #
# import the various client implementations
# --------------------------------------------------------------------------- #
from [Link] import ModbusTcpClient as ModbusClient
# from [Link] import ModbusUdpClient as ModbusClient
# from [Link] import ModbusSerialClient as ModbusClient

# --------------------------------------------------------------------------- #
# configure the client logging
# --------------------------------------------------------------------------- #
import logging
FORMAT = ('%(asctime)-15s %(threadName)-15s '
'%(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

UNIT = 0x1

def run_sync_client():
# ------------------------------------------------------------------------#
# choose the client you want
# ------------------------------------------------------------------------#
(continues on next page)

4.18. Synchronous Client Example 65

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use
# the socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
#
# There are also other options that can be set on the client that controls
# how transactions are performed. The current ones are:
#
# * retries - Specify how many retries to allow per transaction (default=3)
# * retry_on_empty - Is an empty response a retry (default = False)
# * source_address - Specifies the TCP source address to bind to
# * strict - Applicable only for Modbus RTU clients.
# Adheres to modbus protocol for timing restrictions
# (default = True).
# Setting this to False would disable the inter char timeout
# restriction (t1.5) for Modbus RTU
#
#
# Here is an example of using these options::
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
# ------------------------------------------------------------------------#
client = ModbusClient('localhost', port=5020)
# from [Link] import ModbusRtuFramer
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
# client = ModbusClient(method='binary', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='ascii', port='/dev/ptyp0', timeout=1)
# client = ModbusClient(method='rtu', port='/dev/ptyp0', timeout=1,
# baudrate=9600)
[Link]()

# ------------------------------------------------------------------------#
# specify slave to query
# ------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
[Link]("Reading Coils")
rr = client.read_coils(1, 1, unit=UNIT)
[Link](rr)

66 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied asynchronous modbus server (script supplied).
# ----------------------------------------------------------------------- #
[Link]("Write to a Coil and read back")
rq = client.write_coil(0, True, unit=UNIT)
rr = client.read_coils(0, 1, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
assert([Link][0] == True) # test the expected value

[Link]("Write to multiple coils and read back- test 1")

rq = client.write_coils(1, [True]*8, unit=UNIT)
rr = client.read_coils(1, 21, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
resp = [True]*21

# If the returned output quantity is not a multiple of eight,

# the remaining bits in the final data byte will be padded with zeros
# (toward the high order end of the byte).

[Link]([False]*3)
assert([Link] == resp) # test the expected value

[Link]("Write to multiple coils and read back - test 2")

rq = client.write_coils(1, [False]*8, unit=UNIT)
rr = client.read_coils(1, 8, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
assert([Link] == [False]*8) # test the expected value

[Link]("Read discrete inputs")

rr = client.read_discrete_inputs(0, 8, unit=UNIT)
assert(not [Link]()) # test that we are not an error

[Link]("Write to a holding register and read back")

rq = client.write_register(1, 10, unit=UNIT)
rr = client.read_holding_registers(1, 1, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
assert([Link][0] == 10) # test the expected value

[Link]("Write to multiple holding registers and read back")

rq = client.write_registers(1, [10]*8, unit=UNIT)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
assert([Link] == [10]*8) # test the expected value

[Link]("Read input registers")

rr = client.read_input_registers(1, 8, unit=UNIT)
assert(not [Link]()) # test that we are not an error

arguments = {
(continues on next page)

4.18. Synchronous Client Example 67

PyModbus Documentation, Release 2.5.0

(continued from previous page)

'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
[Link]("Read write registeres simulataneously")
rq = client.readwrite_registers(unit=UNIT, **arguments)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert(not [Link]()) # test that we are not an error
assert(not [Link]()) # test that we are not an error
assert([Link] == [20]*8) # test the expected value
assert([Link] == [20]*8) # test the expected value

# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
[Link]()

if __name__ == "__main__":
run_sync_client()

4.19 Synchronous Client Ext Example

#!/usr/bin/env python
"""
Pymodbus Synchronous Client Extended Examples
--------------------------------------------------------------------------

The following is an example of how to use the synchronous modbus client

implementation from pymodbus to perform the extended portions of the
modbus protocol.
"""
# --------------------------------------------------------------------------- #
# import the various server implementations
# --------------------------------------------------------------------------- #
# from [Link] import ModbusTcpClient as ModbusClient
# from [Link] import ModbusUdpClient as ModbusClient
from [Link] import ModbusSerialClient as ModbusClient

# --------------------------------------------------------------------------- #
# import the extended messages to perform
# --------------------------------------------------------------------------- #
from pymodbus.diag_message import *
from pymodbus.file_message import *
from pymodbus.other_message import *
from pymodbus.mei_message import *

68 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

'%(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()
[Link]([Link])

UNIT = 0x01

def execute_extended_requests():
# ------------------------------------------------------------------------#
# choose the client you want
# ------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
# ------------------------------------------------------------------------#
client = ModbusClient(method='rtu', port="/dev/ptyp0")
# client = ModbusClient(method='ascii', port="/dev/ptyp0")
# client = ModbusClient(method='binary', port="/dev/ptyp0")
# client = ModbusClient('[Link]', port=5020)
# from [Link] import ModbusRtuFramer
# client = ModbusClient('[Link]', port=5020, framer=ModbusRtuFramer)
[Link]()

# ----------------------------------------------------------------------- #
# extra requests
# ----------------------------------------------------------------------- #
# If you are performing a request that is not available in the client
# mixin, you have to perform the request like this instead::
#
# from pymodbus.diag_message import ClearCountersRequest
# from pymodbus.diag_message import ClearCountersResponse
#
# request = ClearCountersRequest()
# response = [Link](request)
# if isinstance(response, ClearCountersResponse):
# ... do something with the response
#
#
# What follows is a listing of all the supported methods. Feel free to
# comment, uncomment, or modify each result set to match with your ref.
# ----------------------------------------------------------------------- #

# ----------------------------------------------------------------------- #
# information requests
# ----------------------------------------------------------------------- #
[Link]("Running ReadDeviceInformationRequest")
rq = ReadDeviceInformationRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert (not [Link]()) # test that we are not an error
# assert ([Link][0] == b'Pymodbus') # test the vendor name
# assert ([Link][1] == b'PM') # test the product code
(continues on next page)

4.19. Synchronous Client Ext Example 69

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# assert ([Link][2] == b'1.0') # test the code revision

[Link]("Running ReportSlaveIdRequest")
rq = ReportSlaveIdRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert(not [Link]()) # test that we are not an error
# assert([Link] == 0x00) # test the slave identifier
# assert([Link] == 0x00) # test that the status is ok

[Link]("Running ReadExceptionStatusRequest")
rq = ReadExceptionStatusRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert(not [Link]()) # test that we are not an error
# assert([Link] == 0x55) # test the status code

[Link]("Running GetCommEventCounterRequest")
rq = GetCommEventCounterRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert(not [Link]()) # test that we are not an error
# assert([Link] == True) # test the status code
# assert([Link] == 0x00) # test the status code

[Link]("Running GetCommEventLogRequest")
rq = GetCommEventLogRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert(not [Link]()) # test that we are not an error
# assert([Link] == True) # test the status code
# assert(rr.event_count == 0x00) # test the number of events
# assert(rr.message_count == 0x00) # test the number of messages
# assert(len([Link]) == 0x00) # test the number of events

# ------------------------------------------------------------------------#
# diagnostic requests
# ------------------------------------------------------------------------#
[Link]("Running ReturnQueryDataRequest")
rq = ReturnQueryDataRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert([Link][0] == 0x0000) # test the resulting message

[Link]("Running RestartCommunicationsOptionRequest")
rq = RestartCommunicationsOptionRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
# assert([Link] == 0x0000) # test the resulting message

[Link]("Running ReturnDiagnosticRegisterRequest")
(continues on next page)

70 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

rq = ReturnDiagnosticRegisterRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ChangeAsciiInputDelimiterRequest")
rq = ChangeAsciiInputDelimiterRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ForceListenOnlyModeRequest")
rq = ForceListenOnlyModeRequest(unit=UNIT)
rr = [Link](rq) # does not send a response
[Link](rr)

[Link]("Running ClearCountersRequest")
rq = ClearCountersRequest()
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnBusCommunicationErrorCountRequest")
rq = ReturnBusCommunicationErrorCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnBusExceptionErrorCountRequest")
rq = ReturnBusExceptionErrorCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnSlaveMessageCountRequest")
rq = ReturnSlaveMessageCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnSlaveNoResponseCountRequest")
rq = ReturnSlaveNoResponseCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnSlaveNAKCountRequest")
rq = ReturnSlaveNAKCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnSlaveBusyCountRequest")
rq = ReturnSlaveBusyCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference
(continues on next page)

4.19. Synchronous Client Ext Example 71

PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]("Running ReturnSlaveBusCharacterOverrunCountRequest")
rq = ReturnSlaveBusCharacterOverrunCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ReturnIopOverrunCountRequest")
rq = ReturnIopOverrunCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running ClearOverrunCountRequest")
rq = ClearOverrunCountRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

[Link]("Running GetClearModbusPlusRequest")
rq = GetClearModbusPlusRequest(unit=UNIT)
rr = [Link](rq)
[Link](rr)
# assert(rr == None) # not supported by reference

# ------------------------------------------------------------------------#
# close the client
# ------------------------------------------------------------------------#
[Link]()

if __name__ == "__main__":
execute_extended_requests()

4.20 Synchronous Server Example

#!/usr/bin/env python
"""
Pymodbus Synchronous Server Example
--------------------------------------------------------------------------

The synchronous server is implemented in pure python without any third

party libraries (unless you need to use the serial protocols which require
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
# --------------------------------------------------------------------------- #
(continues on next page)

72 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

from [Link] import version
from [Link] import StartTcpServer
from [Link] import StartTlsServer
from [Link] import StartUdpServer
from [Link] import StartSerialServer

from [Link] import ModbusDeviceIdentification

from [Link] import ModbusSequentialDataBlock, ModbusSparseDataBlock
from [Link] import ModbusSlaveContext, ModbusServerContext

from [Link] import ModbusRtuFramer, ModbusBinaryFramer

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 = [Link]())
# 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
(continues on next page)

4.20. Synchronous Server Example 73

PyModbus Documentation, Release 2.5.0

(continued from previous page)

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

# ----------------------------------------------------------------------- #
# run the server you want
# ----------------------------------------------------------------------- #
# Tcp:
StartTcpServer(context, identity=identity, address=("", 5020))
#
# TCP with different framer
# StartTcpServer(context, identity=identity,
# framer=ModbusRtuFramer, address=("[Link]", 5020))

# TLS
# StartTlsServer(context, identity=identity, certfile="[Link]",
# keyfile="[Link]", address=("[Link]", 8020))

# Udp:
# StartUdpServer(context, identity=identity, address=("[Link]", 5020))
(continues on next page)

74 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600 PTY,link=/tmp/ttyp0,raw,

˓→ echo=0,ospeed=9600
# Ascii:
# StartSerialServer(context, identity=identity,
# port='/dev/ttyp0', timeout=1)

# RTU:
# StartSerialServer(context, framer=ModbusRtuFramer, identity=identity,
# port='/tmp/ttyp0', timeout=.005, baudrate=9600)

# Binary
# StartSerialServer(context,
# identity=identity,
# framer=ModbusBinaryFramer,
# port='/dev/ttyp0',
# timeout=1)

if __name__ == "__main__":
run_server()

4.21 Updating Server Example

#!/usr/bin/env python
"""
Pymodbus Server With Updating Thread
--------------------------------------------------------------------------

This is an example of having a background thread updating the

context while the server is operating. This can also be done with
a python thread::

from threading import Thread

thread = Thread(target=updating_writer, args=(context,))

[Link]()
"""
# --------------------------------------------------------------------------- #
# import the modbus libraries we need
# --------------------------------------------------------------------------- #
from [Link] import version
from [Link] import StartTcpServer
from [Link] import ModbusDeviceIdentification
from [Link] import ModbusSequentialDataBlock
from [Link] import ModbusSlaveContext, ModbusServerContext
from [Link] import ModbusRtuFramer, ModbusAsciiFramer

(continues on next page)

4.21. Updating Server Example 75

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# --------------------------------------------------------------------------- #
# define your callback process
# --------------------------------------------------------------------------- #

def updating_writer(a):
""" A worker process that runs every so often and
updates live values of the context. It should be noted
that there is a race condition for the update.

:param arguments: The input arguments to the call

"""
[Link]("updating the context")
context = a[0]
register = 3
slave_id = 0x00
address = 0x10
values = context[slave_id].getValues(register, address, count=5)
values = [v + 1 for v in values]
[Link]("new values: " + str(values))
context[slave_id].setValues(register, address, values)

def run_updating_server():
# ----------------------------------------------------------------------- #
# initialize your data store
# ----------------------------------------------------------------------- #

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
# ----------------------------------------------------------------------- #
identity = ModbusDeviceIdentification()
[Link] = 'pymodbus'
[Link] = 'PM'
[Link] = '[Link]
[Link] = 'pymodbus Server'
[Link] = 'pymodbus Server'
[Link] = [Link]()

76 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

time = 5 # 5 seconds delay
loop = LoopingCall(f=updating_writer, a=(context,))
[Link](time, now=False) # initially delay by time
StartTcpServer(context, identity=identity, address=("localhost", 5020))

if __name__ == "__main__":
run_updating_server()

4.22 Asynchronous Asyncio Serial Client Example

from [Link] import IS_PYTHON3, PYTHON_VERSION

if IS_PYTHON3 and PYTHON_VERSION >= (3, 4):
import asyncio
from serial_asyncio import create_serial_connection
from [Link].async_io import ModbusClientProtocol
from [Link] import ModbusAsciiFramer, ModbusRtuFramer
from [Link] import ClientDecoder
else:
import sys
[Link]("This example needs to be run only on python 3.4 and above")
[Link](1)

# ----------------------------------------------------------------------- #
# configure the client logging
# ----------------------------------------------------------------------- #
import logging
[Link]()
log = [Link]()
[Link]([Link])

UNIT = 0x01

async def start_async_test(client):

4.22. Asynchronous Asyncio Serial Client Example 77

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied asynchronous modbus server (script supplied).
# ----------------------------------------------------------------------- #
[Link]("Write to a Coil and read back")
rq = await client.write_coil(0, True, unit=UNIT)
rr = await client.read_coils(0, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link][0] == True) # test the expected value

[Link]("Write to multiple coils and read back- test 1")

# If the returned output quantity is not a multiple of eight,

# the remaining bits in the final data byte will be padded with zeros
# (toward the high order end of the byte).

[Link]([False]*3)
assert([Link] == resp) # test the expected value

[Link]("Write to multiple coils and read back - test 2")

[Link]("Read discrete inputs")

rr = await client.read_discrete_inputs(0, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error

[Link]("Write to a holding register and read back")

[Link]("Write to multiple holding registers and read back")

[Link]("Read input registers")

rr = await client.read_input_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error

arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
(continues on next page)

78 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]("Read write registeres simulataneously")
rq = await client.readwrite_registers(unit=UNIT, **arguments)
rr = await client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert([Link] == [20]*8) # test the expected value
assert([Link] == [20]*8) # test the expected value

# create_serial_connection doesn't allow to pass arguments

# to protocol so that this is kind of workaround
def make_protocol():
return ModbusClientProtocol(framer=ModbusRtuFramer(ClientDecoder()))

if __name__ == '__main__':
loop = asyncio.get_event_loop()
coro = create_serial_connection(loop, make_protocol, '/dev/ptyp0',
baudrate=9600)
transport, protocol = loop.run_until_complete([Link](coro))[0]
loop.run_until_complete(start_async_test(protocol))
[Link]()

4.23 Bcd Payload Example

"""
Modbus BCD Payload Builder
-----------------------------------------------------------

This is an example of building a custom payload builder

that can be used in the pymodbus library. Below is a
simple binary coded decimal builder and decoder.
"""
from struct import pack, unpack
from [Link] import Endian
from [Link] import IPayloadBuilder
from [Link] import pack_bitstring
from [Link] import unpack_bitstring
from [Link] import ParameterException
from [Link] import BinaryPayloadDecoder

def convert_to_bcd(decimal):
""" Converts a decimal value to a bcd value

:param value: The decimal value to to pack into bcd

:returns: The number in bcd form
"""
place, bcd = 0, 0
while decimal > 0:
nibble = decimal % 10
bcd += nibble << place
decimal /= 10
place += 4
return bcd
(continues on next page)

4.23. Bcd Payload Example 79

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def convert_from_bcd(bcd):
""" Converts a bcd value to a decimal value

:param value: The value to unpack from bcd

:returns: The number in decimal form
"""
place, decimal = 1, 0
while bcd > 0:
nibble = bcd & 0xf
decimal += nibble * place
bcd >>= 4
place *= 10
return decimal

def count_bcd_digits(bcd):
""" Count the number of digits in a bcd value

:param bcd: The bcd number to count the digits of

:returns: The number of digits in the bcd string
"""
count = 0
while bcd > 0:
count += 1
bcd >>= 4
return count

class BcdPayloadBuilder(IPayloadBuilder):
"""
A utility that helps build binary coded decimal payload
messages to be written with the various modbus messages.
example::

builder = BcdPayloadBuilder()
builder.add_number(1)
builder.add_number(int(2.234 * 1000))
payload = [Link]()
"""

def init(self, payload=None, endian=[Link]):

""" Initialize a new instance of the payload builder

:param payload: Raw payload data to initialize with

:param endian: The endianess of the payload
"""
self._payload = payload or []
self._endian = endian

def __str__(self):
""" Return the payload buffer as a string

:returns: The payload buffer as a string

"""
return ''.join(self._payload)
(continues on next page)

80 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

def reset(self):
""" Reset the payload buffer
"""
self._payload = []

def build(self):
""" Return the payload buffer as a list

This list is two bytes per element and can

thus be treated as a list of registers.

:returns: The payload buffer as a list

"""
string = str(self)
length = len(string)
string = string + ('\x00' * (length % 2))
return [string[i:i+2] for i in range(0, length, 2)]

def add_bits(self, values):

""" Adds a collection of bits to be encoded

If these are less than a multiple of eight,

they will be left padded with 0 bits to make
it so.

:param value: The value to add to the buffer

"""
value = pack_bitstring(values)
self._payload.append(value)

def add_number(self, value, size=None):

""" Adds any 8bit numeric type to the buffer

:param value: The value to add to the buffer

"""
encoded = []
value = convert_to_bcd(value)
size = size or count_bcd_digits(value)
while size > 0:
nibble = value & 0xf
[Link](pack('B', nibble))
value >>= 4
size -= 1
self._payload.extend(encoded)

def add_string(self, value):

""" Adds a string to the buffer

:param value: The value to add to the buffer

"""
self._payload.append(value)

class BcdPayloadDecoder(object):
"""
A utility that helps decode binary coded decimal payload
(continues on next page)

4.23. Bcd Payload Example 81

PyModbus Documentation, Release 2.5.0

(continued from previous page)

messages from a modbus reponse message. What follows is
a simple example::

decoder = BcdPayloadDecoder(payload)
first = decoder.decode_int(2)
second = decoder.decode_int(5) / 100
"""

def init(self, payload):

""" Initialize a new payload decoder

:param payload: The payload to decode with

"""
self._payload = payload
self._pointer = 0x00

@staticmethod
def fromRegisters(registers, endian=[Link]):
""" Initialize a payload decoder with the result of
reading a collection of registers from a modbus device.

The registers are treated as a list of 2 byte values.

We have to do this because of how the data has already
been decoded by the rest of the library.

:param registers: The register results to initialize with

:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
"""
if isinstance(registers, list): # repack into flat binary
payload = ''.join(pack('>H', x) for x in registers)
return BinaryPayloadDecoder(payload, endian)
raise ParameterException('Invalid collection of registers supplied')

@staticmethod
def fromCoils(coils, endian=[Link]):
""" Initialize a payload decoder with the result of
reading a collection of coils from a modbus device.

The coils are treated as a list of bit(boolean) values.

:param coils: The coil results to initialize with

:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
"""
if isinstance(coils, list):
payload = pack_bitstring(coils)
return BinaryPayloadDecoder(payload, endian)
raise ParameterException('Invalid collection of coils supplied')

def reset(self):
""" Reset the decoder pointer back to the start
"""
self._pointer = 0x00

def decode_int(self, size=1):

""" Decodes a int or long from the buffer
(continues on next page)

82 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
self._pointer += size
handle = self._payload[self._pointer - size:self._pointer]
return convert_from_bcd(handle)

def decode_bits(self):
""" Decodes a byte worth of bits from the buffer
"""
self._pointer += 1
handle = self._payload[self._pointer - 1:self._pointer]
return unpack_bitstring(handle)

def decode_string(self, size=1):

""" Decodes a string from the buffer

:param size: The size of the string to decode

"""
self._pointer += size
return self._payload[self._pointer - size:self._pointer]

# --------------------------------------------------------------------------- #
# Exported Identifiers
# --------------------------------------------------------------------------- #

all = ["BcdPayloadBuilder", "BcdPayloadDecoder"]

4.24 Concurrent Client Example

#!/usr/bin/env python
"""
Concurrent Modbus Client
---------------------------------------------------------------------------

This is an example of writing a high performance modbus client that allows

a high level of concurrency by using worker threads/processes to handle
writing/reading from one or more client handles at once.
"""
# -------------------------------------------------------------------------- #
# import system libraries
# -------------------------------------------------------------------------- #
import multiprocessing
import threading
import itertools
from collections import namedtuple

from [Link] import IS_PYTHON3

# we are using the future from the [Link] released with

# python3. Alternatively we will try the backported library::
# pip install futures
try:
from [Link] import Future
except ImportError:
(continues on next page)

4.24. Concurrent Client Example 83

PyModbus Documentation, Release 2.5.0

(continued from previous page)

from futures import Future

# -------------------------------------------------------------------------- #
# import neccessary modbus libraries
# -------------------------------------------------------------------------- #
from [Link] import ModbusClientMixin

# -------------------------------------------------------------------------- #
# configure the client logging
# -------------------------------------------------------------------------- #
import logging
log = [Link]("pymodbus")
[Link]([Link])
[Link]()

# -------------------------------------------------------------------------- #
# Initialize out concurrency primitives
# -------------------------------------------------------------------------- #
class _Primitives(object):
""" This is a helper class used to group the
threading primitives depending on the type of
worker situation we want to run (threads or processes).
"""

def init(self, **kwargs):

[Link] = [Link]('queue')
[Link] = [Link]('event')
[Link] = [Link]('worker')

@classmethod
def create(cls, in_process=False):
""" Initialize a new instance of the concurrency
primitives.

:param in_process: True for threaded, False for processes

:returns: An initialized instance of concurrency primitives
"""
if in_process:
if IS_PYTHON3:
from queue import Queue
else:
from Queue import Queue
from threading import Thread
from threading import Event
return cls(queue=Queue, event=Event, worker=Thread)
else:
from multiprocessing import Queue
from multiprocessing import Event
from multiprocessing import Process
return cls(queue=Queue, event=Event, worker=Process)

# -------------------------------------------------------------------------- #
# Define our data transfer objects
# -------------------------------------------------------------------------- #
# These will be used to serialize state between the various workers.
(continues on next page)

84 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# We use named tuples here as they are very lightweight while giving us
# all the benefits of classes.
# -------------------------------------------------------------------------- #
WorkRequest = namedtuple('WorkRequest', 'request, work_id')
WorkResponse = namedtuple('WorkResponse', 'is_exception, work_id, response')

# -------------------------------------------------------------------------- #
# Define our worker processes
# -------------------------------------------------------------------------- #
def _client_worker_process(factory, input_queue, output_queue, is_shutdown):
""" This worker process takes input requests, issues them on its
client handle, and then sends the client response (success or failure)
to the manager to deliver back to the application.

It should be noted that there are N of these workers and they can
be run in process or out of process as all the state serializes.

:param factory: A client factory used to create a new client

:param input_queue: The queue to pull new requests to issue
:param output_queue: The queue to place client responses
:param is_shutdown: Condition variable marking process shutdown
"""
[Link]("starting up worker : %s", threading.current_thread())
client = factory()
while not is_shutdown.is_set():
try:
workitem = input_queue.get(timeout=1)
[Link]("dequeue worker request: %s", workitem)
if not workitem: continue
try:
[Link]("executing request on thread: %s", workitem)
result = [Link]([Link])
output_queue.put(WorkResponse(False, workitem.work_id, result))
except Exception as exception:
[Link]("error in worker "
"thread: %s", threading.current_thread())
output_queue.put(WorkResponse(True,
workitem.work_id, exception))
except Exception as ex:
pass
[Link]("request worker shutting down: %s", threading.current_thread())

def _manager_worker_process(output_queue, futures, is_shutdown):

""" This worker process manages taking output responses and
tying them back to the future keyed on the initial transaction id.
Basically this can be thought of as the delivery worker.

It should be noted that there are one of these threads and it must
be an in process thread as the futures will not serialize across
processes..

:param output_queue: The queue holding output results to return

:param futures: The mapping of tid -> future
:param is_shutdown: Condition variable marking process shutdown
"""
[Link]("starting up manager worker: %s", threading.current_thread())
(continues on next page)

4.24. Concurrent Client Example 85

PyModbus Documentation, Release 2.5.0

(continued from previous page)

while not is_shutdown.is_set():
try:
workitem = output_queue.get()
future = [Link](workitem.work_id, None)
[Link]("dequeue manager response: %s", workitem)
if not future: continue
if workitem.is_exception:
future.set_exception([Link])
else: future.set_result([Link])
[Link]("updated future result: %s", future)
del futures[workitem.work_id]
except Exception as ex:
[Link]("error in manager")
[Link]("manager worker shutting down: %s", threading.current_thread())

# -------------------------------------------------------------------------- #
# Define our concurrent client
# -------------------------------------------------------------------------- #
class ConcurrentClient(ModbusClientMixin):
""" This is a high performance client that can be used
to read/write a large number of reqeusts at once asyncronously.
This operates with a backing worker pool of processes or threads
to achieve its performance.
"""

def init(self, **kwargs):

""" Initialize a new instance of the client
"""
worker_count = [Link]('count', multiprocessing.cpu_count())
[Link] = [Link]('factory')
primitives = _Primitives.create([Link]('in_process', False))
self.is_shutdown = [Link]() # process shutdown condition
self.input_queue = [Link]() # input requests to process
self.output_queue = [Link]() # output results to return
[Link] = {} # mapping of tid -> future
[Link] = [] # handle to our worker threads
[Link] = [Link]()

# creating the response manager

[Link] = [Link](
target=_manager_worker_process,
args=(self.output_queue, [Link], self.is_shutdown)
)
[Link]()
[Link]([Link])

# creating the request workers

for i in range(worker_count):
worker = [Link](
target=_client_worker_process,
args=([Link], self.input_queue, self.output_queue,
self.is_shutdown)
)
[Link]()
[Link](worker)

(continues on next page)

86 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

def shutdown(self):
""" Shutdown all the workers being used to
concurrently process the requests.
"""
[Link]("stating to shut down workers")
self.is_shutdown.set()
# to wake up the manager
self.output_queue.put(WorkResponse(None, None, None))
for worker in [Link]:
[Link]()
[Link]("finished shutting down workers")

def execute(self, request):

""" Given a request, enqueue it to be processed
and then return a future linked to the response
of the call.

:param request: The request to execute

:returns: A future linked to the call's response
"""
if IS_PYTHON3:
fut, work_id = Future(), next([Link])
else:
fut, work_id = Future(), [Link]()
self.input_queue.put(WorkRequest(request, work_id))
[Link][work_id] = fut
return fut

def execute_silently(self, request):

""" Given a write request, enqueue it to
be processed without worrying about calling the
application back (fire and forget)

:param request: The request to execute

"""
self.input_queue.put(WorkRequest(request, None))

if __name__ == "__main__":
from [Link] import ModbusTcpClient

def client_factory():
[Link]("creating client for: %s", threading.current_thread())
client = ModbusTcpClient('[Link]', port=5020)
[Link]()
return client

client = ConcurrentClient(factory = client_factory)

try:
[Link]("issuing concurrent requests")
futures = [client.read_coils(i * 8, 8) for i in range(10)]
[Link]("waiting on futures to complete")
for future in futures:
[Link]("future result: %s", [Link](timeout=1))
finally:
[Link]()

4.24. Concurrent Client Example 87

PyModbus Documentation, Release 2.5.0

4.25 Libmodbus Client Example

#!/usr/bin/env python
"""
Libmodbus Protocol Wrapper
------------------------------------------------------------

What follows is an example wrapper of the libmodbus library

([Link] for use with pymodbus.
There are two utilities involved here:

* LibmodbusLevel1Client

This is simply a python wrapper around the c library. It is

mostly a clone of the pylibmodbus implementation, but I plan
on extending it to implement all the available protocol using
the raw execute methods.

* LibmodbusClient

This is just another modbus client that can be used just like
any other client in pymodbus.

For these to work, you must have `cffi` and `libmodbus-dev` installed:

sudo apt-get install libmodbus-dev

pip install cffi
"""
# -------------------------------------------------------------------------- #
# import system libraries
# -------------------------------------------------------------------------- #

from cffi import FFI

# -------------------------------------------------------------------------- #
# import pymodbus libraries
# -------------------------------------------------------------------------- #

from [Link] import Defaults

from [Link] import ModbusException
from [Link] import ModbusClientMixin
from pymodbus.bit_read_message import ReadCoilsResponse, ReadDiscreteInputsResponse
from pymodbus.register_read_message import ReadHoldingRegistersResponse,
˓→ReadInputRegistersResponse

from pymodbus.register_read_message import ReadWriteMultipleRegistersResponse

from pymodbus.bit_write_message import WriteSingleCoilResponse,
˓→WriteMultipleCoilsResponse

from pymodbus.register_write_message import WriteSingleRegisterResponse,

˓→WriteMultipleRegistersResponse

# --------------------------------------------------------------------------- #
# create the C interface
# --------------------------------------------------------------------------- #
# * TODO add the protocol needed for the servers
# --------------------------------------------------------------------------- #

compiler = FFI()
(continues on next page)

88 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link]("""
typedef struct _modbus modbus_t;

int modbus_connect(modbus_t *ctx);

int modbus_flush(modbus_t *ctx);
void modbus_close(modbus_t *ctx);

const char *modbus_strerror(int errnum);

int modbus_set_slave(modbus_t *ctx, int slave);

void modbus_get_response_timeout(modbus_t ctx, uint32_t to_sec, uint32_t *to_

˓→usec);
void modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_
˓→usec);

int modbus_read_bits(modbus_t ctx, int addr, int nb, uint8_t dest);

int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);

int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);

int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data);
int modbus_write_register(modbus_t *ctx, int reg_addr, int value);
int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data);
int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb,
˓→const uint16_t *src, int read_addr, int read_nb, uint16_t *dest);

int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_

˓→ t or_mask);
int modbus_send_raw_request(modbus_t *ctx, uint8_t *raw_req, int raw_req_length);

float modbus_get_float(const uint16_t *src);

void modbus_set_float(float f, uint16_t *dest);

modbus_t* modbus_new_tcp(const char *ip_address, int port);

modbus_t* modbus_new_rtu(const char *device, int baud, char parity, int data_bit,
˓→int stop_bit);

void modbus_free(modbus_t *ctx);

int modbus_receive(modbus_t ctx, uint8_t req);

int modbus_receive_from(modbus_t *ctx, int sockfd, uint8_t *req);
int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp);
""")
LIB = [Link]('modbus') # create our bindings

# -------------------------------------------------------------------------- #
# helper utilites
# -------------------------------------------------------------------------- #

def get_float(data):
return LIB.modbus_get_float(data)

def set_float(value, data):

LIB.modbus_set_float(value, data)

(continues on next page)

4.25. Libmodbus Client Example 89

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def cast_to_int16(data):
return int([Link]('int16_t', data))

def cast_to_int32(data):
return int([Link]('int32_t', data))

class NotImplementedException(Exception):
pass

# -------------------------------------------------------------------------- #
# level1 client
# -------------------------------------------------------------------------- #

class LibmodbusLevel1Client(object):
""" A raw wrapper around the libmodbus c library. Feel free
to use it if you want increased performance and don't mind the
entire protocol not being implemented.
"""

@classmethod
def create_tcp_client(klass, host='[Link]', port=[Link]):
""" Create a TCP modbus client for the supplied parameters.

:param host: The host to connect to

:param port: The port to connect to on that host
:returns: A new level1 client
"""
client = LIB.modbus_new_tcp([Link](), port)
return klass(client)

@classmethod
def create_rtu_client(klass, **kwargs):
""" Create a TCP modbus client for the supplied parameters.

:param port: The serial port to attach to

:param stopbits: The number of stop bits to use
:param bytesize: The bytesize of the serial messages
:param parity: Which kind of parity to use
:param baudrate: The baud rate to use for the serial device
:returns: A new level1 client
"""
port = [Link]('port', '/dev/ttyS0')
baudrate = [Link]('baud', [Link])
parity = [Link]('parity', [Link])
bytesize = [Link]('bytesize', [Link])
stopbits = [Link]('stopbits', [Link])
client = LIB.modbus_new_rtu(port, baudrate, parity, bytesize, stopbits)
return klass(client)

def init(self, client):

""" Initalize a new instance of the LibmodbusLevel1Client. This
method should not be used, instead new instances should be created
using the two supplied factory methods:
(continues on next page)

90 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

* LibmodbusLevel1Client.create_rtu_client(...)
* LibmodbusLevel1Client.create_tcp_client(...)

:param client: The underlying client instance to operate with.

"""
[Link] = client
[Link] = [Link]

def set_slave(self, slave):

""" Set the current slave to operate against.

:param slave: The new slave to operate against

:returns: The resulting slave to operate against
"""
[Link] = self._execute(LIB.modbus_set_slave, slave)
return [Link]

def connect(self):
""" Attempt to connect to the client target.

:returns: True if successful, throws otherwise

"""
return (self.__execute(LIB.modbus_connect) == 0)

def flush(self):
""" Discards the existing bytes on the wire.

:returns: The number of flushed bytes, or throws

"""
return self.__execute(LIB.modbus_flush)

def close(self):
""" Closes and frees the underlying connection
and context structure.

:returns: Always True

"""
LIB.modbus_close([Link])
LIB.modbus_free([Link])
return True

def __execute(self, command, *args):

""" Run the supplied command against the currently
instantiated client with the supplied arguments. This
will make sure to correctly handle resulting errors.

:param command: The command to execute against the context

:param *args: The arguments for the given command
:returns: The result of the operation unless -1 which throws
"""
result = command([Link], *args)
if result == -1:
message = LIB.modbus_strerror([Link])
raise ModbusException([Link](message))
return result

(continues on next page)

4.25. Libmodbus Client Example 91

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def read_bits(self, address, count=1):
"""

:param address: The starting address to read from

:param count: The number of coils to read
:returns: The resulting bits
"""
result = [Link]("uint8_t[]", count)
self.__execute(LIB.modbus_read_bits, address, count, result)
return result

def read_input_bits(self, address, count=1):

"""

:param address: The starting address to read from

:param count: The number of discretes to read
:returns: The resulting bits
"""
result = [Link]("uint8_t[]", count)
self.__execute(LIB.modbus_read_input_bits, address, count, result)
return result

def write_bit(self, address, value):

"""

:param address: The starting address to write to

:param value: The value to write to the specified address
:returns: The number of written bits
"""
return self.__execute(LIB.modbus_write_bit, address, value)

def write_bits(self, address, values):

"""

:param address: The starting address to write to

:param values: The values to write to the specified address
:returns: The number of written bits
"""
count = len(values)
return self.__execute(LIB.modbus_write_bits, address, count, values)

def write_register(self, address, value):

"""

:param address: The starting address to write to

:param value: The value to write to the specified address
:returns: The number of written registers
"""
return self.__execute(LIB.modbus_write_register, address, value)

def write_registers(self, address, values):

"""

:param address: The starting address to write to

:param values: The values to write to the specified address
:returns: The number of written registers
"""
(continues on next page)

92 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

count = len(values)
return self.__execute(LIB.modbus_write_registers, address, count, values)

def read_registers(self, address, count=1):

"""

:param address: The starting address to read from

:param count: The number of registers to read
:returns: The resulting read registers
"""
result = [Link]("uint16_t[]", count)
self.__execute(LIB.modbus_read_registers, address, count, result)
return result

def read_input_registers(self, address, count=1):

"""

:param address: The starting address to read from

:param count: The number of registers to read
:returns: The resulting read registers
"""
result = [Link]("uint16_t[]", count)
self.__execute(LIB.modbus_read_input_registers, address, count, result)
return result

def read_and_write_registers(self, read_address, read_count, write_address, write_

˓→ registers):
"""

:param read_address: The address to start reading from

:param read_count: The number of registers to read from address
:param write_address: The address to start writing to
:param write_registers: The registers to write to the specified address
:returns: The resulting read registers
"""
write_count = len(write_registers)
read_result = [Link]("uint16_t[]", read_count)
self.__execute(LIB.modbus_write_and_read_registers,
write_address, write_count, write_registers,
read_address, read_count, read_result)
return read_result

# -------------------------------------------------------------------------- #
# level2 client
# -------------------------------------------------------------------------- #

class LibmodbusClient(ModbusClientMixin):
""" A facade around the raw level 1 libmodbus client
that implements the pymodbus protocol on top of the lower level
client.
"""

# ----------------------------------------------------------------------- #
# these are used to convert from the pymodbus request types to the
# libmodbus operations (overloaded operator).
# ----------------------------------------------------------------------- #
(continues on next page)

4.25. Libmodbus Client Example 93

PyModbus Documentation, Release 2.5.0

(continued from previous page)

__methods = {
'ReadCoilsRequest': lambda c, r: c.read_bits([Link], [Link]),
'ReadDiscreteInputsRequest': lambda c, r: c.read_input_bits([Link],
[Link]),
'WriteSingleCoilRequest': lambda c, r: c.write_bit([Link],
[Link]),
'WriteMultipleCoilsRequest': lambda c, r: c.write_bits([Link],
[Link]),
'WriteSingleRegisterRequest': lambda c, r: c.write_register([Link],
[Link]),
'WriteMultipleRegistersRequest':
lambda c, r: c.write_registers([Link], [Link]),
'ReadHoldingRegistersRequest':
lambda c, r: c.read_registers([Link], [Link]),
'ReadInputRegistersRequest':
lambda c, r: c.read_input_registers([Link], [Link]),
'ReadWriteMultipleRegistersRequest':
lambda c, r: c.read_and_write_registers(r.read_address,
r.read_count,
r.write_address,
r.write_registers),
}

# ----------------------------------------------------------------------- #
# these are used to convert from the libmodbus result to the
# pymodbus response type
# ----------------------------------------------------------------------- #

__adapters = {
'ReadCoilsRequest':
lambda tx, rx: ReadCoilsResponse(list(rx)),
'ReadDiscreteInputsRequest':
lambda tx, rx: ReadDiscreteInputsResponse(list(rx)),
'WriteSingleCoilRequest':
lambda tx, rx: WriteSingleCoilResponse([Link], rx),
'WriteMultipleCoilsRequest':
lambda tx, rx: WriteMultipleCoilsResponse([Link], rx),
'WriteSingleRegisterRequest':
lambda tx, rx: WriteSingleRegisterResponse([Link], rx),
'WriteMultipleRegistersRequest':
lambda tx, rx: WriteMultipleRegistersResponse([Link], rx),
'ReadHoldingRegistersRequest':
lambda tx, rx: ReadHoldingRegistersResponse(list(rx)),
'ReadInputRegistersRequest':
lambda tx, rx: ReadInputRegistersResponse(list(rx)),
'ReadWriteMultipleRegistersRequest':
lambda tx, rx: ReadWriteMultipleRegistersResponse(list(rx)),
}

def init(self, client):

""" Initalize a new instance of the LibmodbusClient. This should
be initialized with one of the LibmodbusLevel1Client instances:

* LibmodbusLevel1Client.create_rtu_client(...)
* LibmodbusLevel1Client.create_tcp_client(...)
:param client: The underlying client instance to operate with.
(continues on next page)

94 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
[Link] = client

# ----------------------------------------------------------------------- #
# We use the client mixin to implement the api methods which are all
# forwarded to this method. It is implemented using the previously
# defined lookup tables. Any method not defined simply throws.
# ----------------------------------------------------------------------- #

def execute(self, request):

""" Execute the supplied request against the server.

:param request: The request to process

:returns: The result of the request execution
"""
if [Link] != request.unit_id:
[Link].set_slave(request.unit_id)

method = request.__class__.__name__
operation = self.__methods.get(method, None)
adapter = self.__adapters.get(method, None)

if not operation or not adapter:

raise NotImplementedException("Method not "
"implemented: " + operation)

response = operation([Link], request)

return adapter(request, response)

# ----------------------------------------------------------------------- #
# Other methods can simply be forwarded using the decorator pattern
# ----------------------------------------------------------------------- #

def connect(self):
return [Link]()

def close(self):
return [Link]()

# ----------------------------------------------------------------------- #
# magic methods
# ----------------------------------------------------------------------- #

def __enter__(self):
""" Implement the client with enter block

:returns: The current instance of the client

"""
[Link]()
return self

def exit(self, klass, value, traceback):

""" Implement the client with exit block """
[Link]()

# -------------------------------------------------------------------------- #
# main example runner
(continues on next page)

4.25. Libmodbus Client Example 95

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# -------------------------------------------------------------------------- #

if __name__ == '__main__':

# create our low level client

host = '[Link]'
port = 502
protocol = LibmodbusLevel1Client.create_tcp_client(host, port)

# operate with our high level client

with LibmodbusClient(protocol) as client:
registers = client.write_registers(0, [13, 12, 11])
print(registers)
registers = client.read_holding_registers(0, 10)
print([Link])

4.26 Message Generator Example

#!/usr/bin/env python
"""
Modbus Message Generator
--------------------------------------------------------------------------

The following is an example of how to generate example encoded messages

for the supplied modbus format:

* tcp - `./[Link] -f tcp -m rx -b`

* ascii - `./[Link] -f ascii -m tx -a`
* rtu - `./[Link] -f rtu -m rx -b`
* binary - `./[Link] -f binary -m tx -b`
"""
from optparse import OptionParser
import codecs as c
# -------------------------------------------------------------------------- #
# import all the available framers
# -------------------------------------------------------------------------- #
from [Link] import ModbusSocketFramer
from [Link] import ModbusBinaryFramer
from [Link] import ModbusAsciiFramer
from [Link] import ModbusRtuFramer
# -------------------------------------------------------------------------- #
# import all available messages
# -------------------------------------------------------------------------- #
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.diag_message import *
from pymodbus.file_message import *
from pymodbus.other_message import *
from pymodbus.mei_message import *
from pymodbus.register_read_message import *
from pymodbus.register_write_message import *
from [Link] import IS_PYTHON3

(continues on next page)

96 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# -------------------------------------------------------------------------- #
# initialize logging
# -------------------------------------------------------------------------- #
import logging
modbus_log = [Link]("pymodbus")

# -------------------------------------------------------------------------- #
# enumerate all request messages
# -------------------------------------------------------------------------- #
_request_messages = [
ReadHoldingRegistersRequest,
ReadDiscreteInputsRequest,
ReadInputRegistersRequest,
ReadCoilsRequest,
WriteMultipleCoilsRequest,
WriteMultipleRegistersRequest,
WriteSingleRegisterRequest,
WriteSingleCoilRequest,
ReadWriteMultipleRegistersRequest,

ReadExceptionStatusRequest,
GetCommEventCounterRequest,
GetCommEventLogRequest,
ReportSlaveIdRequest,

ReadFileRecordRequest,
WriteFileRecordRequest,
MaskWriteRegisterRequest,
ReadFifoQueueRequest,

ReadDeviceInformationRequest,

ReturnQueryDataRequest,
RestartCommunicationsOptionRequest,
ReturnDiagnosticRegisterRequest,
ChangeAsciiInputDelimiterRequest,
ForceListenOnlyModeRequest,
ClearCountersRequest,
ReturnBusMessageCountRequest,
ReturnBusCommunicationErrorCountRequest,
ReturnBusExceptionErrorCountRequest,
ReturnSlaveMessageCountRequest,
ReturnSlaveNoResponseCountRequest,
ReturnSlaveNAKCountRequest,
ReturnSlaveBusyCountRequest,
ReturnSlaveBusCharacterOverrunCountRequest,
ReturnIopOverrunCountRequest,
ClearOverrunCountRequest,
GetClearModbusPlusRequest
]

# -------------------------------------------------------------------------- #
# enumerate all response messages
# -------------------------------------------------------------------------- #
_response_messages = [
(continues on next page)

4.26. Message Generator Example 97

PyModbus Documentation, Release 2.5.0

(continued from previous page)

ReadHoldingRegistersResponse,
ReadDiscreteInputsResponse,
ReadInputRegistersResponse,
ReadCoilsResponse,
WriteMultipleCoilsResponse,
WriteMultipleRegistersResponse,
WriteSingleRegisterResponse,
WriteSingleCoilResponse,
ReadWriteMultipleRegistersResponse,

ReadExceptionStatusResponse,
GetCommEventCounterResponse,
GetCommEventLogResponse,
ReportSlaveIdResponse,

ReadFileRecordResponse,
WriteFileRecordResponse,
MaskWriteRegisterResponse,
ReadFifoQueueResponse,

ReadDeviceInformationResponse,

ReturnQueryDataResponse,
RestartCommunicationsOptionResponse,
ReturnDiagnosticRegisterResponse,
ChangeAsciiInputDelimiterResponse,
ForceListenOnlyModeResponse,
ClearCountersResponse,
ReturnBusMessageCountResponse,
ReturnBusCommunicationErrorCountResponse,
ReturnBusExceptionErrorCountResponse,
ReturnSlaveMessageCountResponse,
ReturnSlaveNoReponseCountResponse,
ReturnSlaveNAKCountResponse,
ReturnSlaveBusyCountResponse,
ReturnSlaveBusCharacterOverrunCountResponse,
ReturnIopOverrunCountResponse,
ClearOverrunCountResponse,
GetClearModbusPlusResponse
]

# -------------------------------------------------------------------------- #
# build an arguments singleton
# -------------------------------------------------------------------------- #
# Feel free to override any values here to generate a specific message
# in question. It should be noted that many argument names are reused
# between different messages, and a number of messages are simply using
# their default values.
# -------------------------------------------------------------------------- #
_arguments = {
'address': 0x12,
'count': 0x08,
'value': 0x01,
'values': [0x01] * 8,
'read_address': 0x12,
'read_count': 0x08,
(continues on next page)

98 Chapter 4. Examples
PyModbus Documentation, Release 2.5.0

(continued from previous page)

'write_address': 0x12,
'write_registers': [0x01] * 8,
'transaction': 0x01,
'protocol': 0x00,
'unit': 0xff,
}

# -------------------------------------------------------------------------- #
# generate all the requested messages
# -------------------------------------------------------------------------- #
def generate_messages(framer, options):
""" A helper method to parse the command line options

:param framer: The framer to encode the messages with

:param options: The message options to use
"""
if [Link] == "tx":
messages = _request_messages
else:
messages = _response_messages
for message in messages:
message = message(**_arguments)
print("%-44s = " % message.__class__.__name__)
packet = [Link](message)
if not [Link]:
if not IS_PYTHON3:
packet = [Link]('hex')
else:
packet = [Link](packet, 'hex_codec').decode('utf-8')
print ("{}\n".format(packet)) # because ascii ends with a \r\n

# -------------------------------------------------------------------------- #
# initialize our program settings
# -------------------------------------------------------------------------- #
def get_options():
""" A helper method to parse the command line options

:returns: The options manager

"""
parser = OptionParser()

parser.add_option("-f", "--framer",
help="The type of framer to use "
"(tcp, rtu, binary, ascii)",
dest="framer", default="tcp")

parser.add_option("-D", "--debug",
help="Enable debug tracing",
action="store_true", dest="debug", default=False)

parser.add_option("-a", "--ascii",
help="The indicates that the message is ascii",
action="store_true", dest="ascii", default=True)

parser.add_option("-b", "--binary",
(continues on next page)

4.26. Message Generator Example 99

PyModbus Documentation, Release 2.5.0

(continued from previous page)

help="The indicates that the message is binary",
action="store_false", dest="ascii")

parser.add_option("-m", "--messages",
help="The messages to encode (rx, tx)",
dest="messages", default='rx')

(opt, arg) = parser.parse_args()

return opt

def main():
""" The main runner function
"""
option = get_options()

if [Link]:
try:
modbus_log.setLevel([Link])
[Link]()
except Exception as e:
print("Logging is not supported on this system")

framer = lookup = {
'tcp': ModbusSocketFramer,
'rtu': ModbusRtuFramer,
'binary': ModbusBinaryFramer,
'ascii': ModbusAsciiFramer,
}.get([Link], ModbusSocketFramer)(None)

generate_messages(framer, option)

if __name__ == "__main__":
main()

4.27 Message Parser Example

#!/usr/bin/env python
"""
Modbus Message Parser
--------------------------------------------------------------------------

The following is an example of how to parse modbus messages

using the supplied framers for a number of protocols:

* tcp
* ascii
* rtu
* binary
"""
# -------------------------------------------------------------------------- #
# import needed libraries
# -------------------------------------------------------------------------- #
(continues on next page)

100 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

from __future__ import print_function
import collections
import textwrap
from optparse import OptionParser
import codecs as c

from [Link] import ClientDecoder, ServerDecoder

from [Link] import ModbusSocketFramer
from [Link] import ModbusBinaryFramer
from [Link] import ModbusAsciiFramer
from [Link] import ModbusRtuFramer
from [Link] import IS_PYTHON3
# -------------------------------------------------------------------------- #
# -------------------------------------------------------------------------- #
import logging
FORMAT = ('%(asctime)-15s %(threadName)-15s'
' %(levelname)-8s %(module)-15s:%(lineno)-8s %(message)s')
[Link](format=FORMAT)
log = [Link]()

# -------------------------------------------------------------------------- #
# build a quick wrapper around the framers
# -------------------------------------------------------------------------- #

class Decoder(object):

def init(self, framer, encode=False):

""" Initialize a new instance of the decoder

:param framer: The framer to use

:param encode: If the message needs to be encoded
"""
[Link] = framer
[Link] = encode

def decode(self, message):

""" Attempt to decode the supplied message

:param message: The messge to decode

"""
if IS_PYTHON3:
value = message if [Link] else [Link](message, 'hex_codec')
else:
value = message if [Link] else [Link]('hex')
print("="*80)
print("Decoding Message %s" % value)
print("="*80)
decoders = [
[Link](ServerDecoder(), client=None),
[Link](ClientDecoder(), client=None)
]
for decoder in decoders:
print("%s" % [Link].__class__.__name__)
print("-"*80)
try:
[Link](message)
(continues on next page)

4.27. Message Parser Example 101

PyModbus Documentation, Release 2.5.0

(continued from previous page)

if [Link]():
unit = decoder._header.get("uid", 0x00)
[Link]()
[Link](message, [Link], unit)
else:
self.check_errors(decoder, message)
except Exception as ex:
self.check_errors(decoder, message)

def check_errors(self, decoder, message):

""" Attempt to find message errors

:param message: The message to find errors in

"""
[Link]("Unable to parse message - {} with {}".format(message,
decoder))

def report(self, message):

""" The callback to print the message information

:param message: The message to print

"""
print("%-15s = %s" % ('name', message.__class__.__name__))
for (k, v) in message.__dict__.items():
if isinstance(v, dict):
print("%-15s =" % k)
for kk,vv in [Link]():
print(" %-12s => %s" % (kk, vv))

elif isinstance(v, [Link]):

print("%-15s =" % k)
value = str([int(x) for x in v])
for line in [Link](value, 60):
print("%-15s . %s" % ("", line))
else:
print("%-15s = %s" % (k, hex(v)))
print("%-15s = %s" % ('documentation', message.__doc__))

# -------------------------------------------------------------------------- #
# and decode our message
# -------------------------------------------------------------------------- #
def get_options():
""" A helper method to parse the command line options

:returns: The options manager

"""
parser = OptionParser()

parser.add_option("-p", "--parser",
help="The type of parser to use "
"(tcp, rtu, binary, ascii)",
dest="parser", default="tcp")

parser.add_option("-D", "--debug",
help="Enable debug tracing",
action="store_true", dest="debug", default=False)
(continues on next page)

102 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

parser.add_option("-m", "--message",
help="The message to parse",
dest="message", default=None)

parser.add_option("-a", "--ascii",
help="The indicates that the message is ascii",
action="store_true", dest="ascii", default=False)

parser.add_option("-b", "--binary",
help="The indicates that the message is binary",
action="store_false", dest="ascii")

parser.add_option("-f", "--file",
help="The file containing messages to parse",
dest="file", default=None)

parser.add_option("-t", "--transaction",
help="If the incoming message is in hexadecimal format",
action="store_true", dest="transaction", default=False)
parser.add_option("--framer",
help="Framer to use", dest="framer", default=None,
)

(opt, arg) = parser.parse_args()

if not [Link] and len(arg) > 0:

[Link] = arg[0]

return opt

def get_messages(option):
""" A helper method to generate the messages to parse

:param options: The option manager

:returns: The message iterator to parse
"""
if [Link]:
if [Link]:
msg = ""
for segment in [Link]():
segment = [Link]("0x", "")
segment = "0" + segment if len(segment) == 1 else segment
msg = msg + segment
[Link] = msg

if not [Link]:
if not IS_PYTHON3:
[Link] = [Link]('hex')
else:
[Link] = [Link]([Link](), 'hex_codec')
yield [Link]
elif [Link]:
with open([Link], "r") as handle:
for line in handle:
if [Link]('#'): continue
(continues on next page)

4.27. Message Parser Example 103

PyModbus Documentation, Release 2.5.0

(continued from previous page)

if not [Link]:
line = [Link]()
line = [Link]('hex')
yield line

def main():
""" The main runner function
"""
option = get_options()

if [Link]:
try:
[Link]([Link])
[Link]()
except Exception as e:
print("Logging is not supported on this system- {}".format(e))

framer = lookup = {
'tcp': ModbusSocketFramer,
'rtu': ModbusRtuFramer,
'binary': ModbusBinaryFramer,
'ascii': ModbusAsciiFramer,
}.get([Link] or [Link], ModbusSocketFramer)

decoder = Decoder(framer, [Link])

for message in get_messages(option):
[Link](message)

if __name__ == "__main__":
main()

4.28 Modbus Mapper Example

"""
Given a modbus mapping file, this is used to generate
decoder blocks so that non-programmers can define the
register values and then decode a modbus device all
without having to write a line of code for decoding.

Currently supported formats are:

* csv
* json
* xml

Here is an example of generating and using a mapping decoder

(note that this is still in the works and will be greatly
simplified in the final api; it is just an example of the
requested functionality)::

from modbus_mapper import csv_mapping_parser

from modbus_mapper import mapping_decoder
(continues on next page)

104 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

from [Link] import ModbusTcpClient
from [Link] import BinaryModbusDecoder

template = ['address', 'size', 'function', 'name', 'description']

raw_mapping = csv_mapping_parser('[Link]', template)
mapping = mapping_decoder(raw_mapping)

index, size = 1, 100

client = ModbusTcpClient('localhost')
response = client.read_holding_registers(index, size)
decoder = [Link]([Link])
while index < size:
print "[{}]\t{}".format(i, mapping[i]['type'](decoder))
index += mapping[i]['size']

Also, using the same input mapping parsers, we can generate

populated slave contexts that can be run behing a modbus server::

from modbus_mapper import csv_mapping_parser

from modbus_mapper import modbus_context_decoder
from [Link] import StartTcpServer
from [Link] import ModbusServerContext

template = ['address', 'value', 'function', 'name', 'description']

raw_mapping = csv_mapping_parser('[Link]', template)
slave_context = modbus_context_decoder(raw_mapping)
context = ModbusServerContext(slaves=slave_context, single=True)
StartTcpServer(context)
"""
import csv
import json
from collections import defaultdict

from tokenize import generate_tokens

from [Link] import BinaryPayloadDecoder
from [Link] import ModbusSparseDataBlock
from [Link] import IS_PYTHON3
from [Link] import ModbusSlaveContext
if IS_PYTHON3:
from io import StringIO
else:
from StringIO import StringIO

# --------------------------------------------------------------------------- #
# raw mapping input parsers
# --------------------------------------------------------------------------- #
# These generate the raw mapping_blocks from some form of input
# which can then be passed to the decoder in question to supply
# the requested output result.
# --------------------------------------------------------------------------- #

def csv_mapping_parser(path, template):

""" Given a csv file of the the mapping data for
a modbus device, return a mapping layout that can
be used to decode an new block.

(continues on next page)

4.28. Modbus Mapper Example 105

PyModbus Documentation, Release 2.5.0

(continued from previous page)

.. note:: For the template, a few values are required
to be defined: address, size, function, and type. All the remaining
values will be stored, but not formatted by the application.
So for example::

template = ['address', 'type', 'size', 'name', 'function']

mappings = json_mapping_parser('[Link]', template)

:param path: The path to the csv input file

:param template: The row value template
:returns: The decoded csv dictionary
"""
mapping_blocks = defaultdict(dict)
with open(path, 'r') as handle:
reader = [Link](handle)
[Link]() # skip the csv header
for row in reader:
mapping = dict(zip(template, row))
fid = [Link]('function')
aid = int(mapping['address'])
mapping_blocks[aid] = mapping
return mapping_blocks

def json_mapping_parser(path, template):

""" Given a json file of the the mapping data for
a modbus device, return a mapping layout that can
be used to decode an new block.

.. note:: For the template, a few values are required

to be mapped: address, size, and type. All the remaining
values will be stored, but not formatted by the application.
So for example::

template = {
'Start': 'address',
'DataType': 'type',
'Length': 'size'
# the remaining keys will just pass through
}
mappings = json_mapping_parser('[Link]', template)

:param path: The path to the csv input file

:param template: The row value template
:returns: The decoded csv dictionary
"""
mapping_blocks = {}
with open(path, 'r') as handle:
for tid, rows in [Link](handle).iteritems():
mappings = {}
for key, values in [Link]():
mapping = {[Link](k, k) : v for k, v in [Link]()}
mappings[int(key)] = mapping
mapping_blocks[tid] = mappings
return mapping_blocks

(continues on next page)

106 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def xml_mapping_parser(path):
""" Given an xml file of the the mapping data for
a modbus device, return a mapping layout that can
be used to decode an new block.

.. note:: The input of the xml file is defined as

follows::

:param path: The path to the xml input file

:returns: The decoded csv dictionary
"""
pass

# --------------------------------------------------------------------------- #
# modbus context decoders
# --------------------------------------------------------------------------- #
# These are used to decode a raw mapping_block into a slave context with
# populated function data blocks.
# --------------------------------------------------------------------------- #
def modbus_context_decoder(mapping_blocks):
""" Given a mapping block input, generate a backing
slave context with initialized data blocks.

.. note:: This expects the following for each block:

address, value, and function where function is one of
di (discretes), co (coils), hr (holding registers), or
ir (input registers).

:param mapping_blocks: The mapping blocks

:returns: The initialized modbus slave context
"""
blocks = defaultdict(dict)
for block in mapping_blocks.itervalues():
for mapping in [Link]():
value = int(mapping['value'])
address = int(mapping['address'])
function = mapping['function']
blocks[function][address] = value
return ModbusSlaveContext(**blocks)

# --------------------------------------------------------------------------- #
# modbus mapping decoder
# --------------------------------------------------------------------------- #
# These are used to decode a raw mapping_block into a request decoder.
# So this allows one to simply grab a number of registers, and then
# pass them to this decoder which will do the rest.
# --------------------------------------------------------------------------- #
class ModbusTypeDecoder(object):
""" This is a utility to determine the correct
decoder to use given a type name. By default this
supports all the types available in the default modbus
decoder, however this can easily be extended this class
and adding new types to the mapper::

class CustomTypeDecoder(ModbusTypeDecoder):
(continues on next page)

4.28. Modbus Mapper Example 107

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def __init__(self):
ModbusTypeDecode.__init__(self)
[Link]['type-token'] = [Link]

def parse_my_bitfield(self, tokens):

return lambda d: d.decode_my_type()

"""
def __init__(self):
""" Initializes a new instance of the decoder
"""
[Link] = lambda m: self.parse_16bit_uint
[Link] = {
'uint': self.parse_16bit_uint,
'uint8': self.parse_8bit_uint,
'uint16': self.parse_16bit_uint,
'uint32': self.parse_32bit_uint,
'uint64': self.parse_64bit_uint,
'int': self.parse_16bit_int,
'int8': self.parse_8bit_int,
'int16': self.parse_16bit_int,
'int32': self.parse_32bit_int,
'int64': self.parse_64bit_int,
'float': self.parse_32bit_float,
'float32': self.parse_32bit_float,
'float64': self.parse_64bit_float,
'string': self.parse_32bit_int,
'bits': self.parse_bits,
}

# ------------------------------------------------------------ #
# Type parsers
# ------------------------------------------------------------ #
@staticmethod
def parse_string(tokens):
_ = [Link]()
size = int([Link]())
return lambda d: d.decode_string(size=size)

@staticmethod
def parse_bits(tokens):
return lambda d: d.decode_bits()

@staticmethod
def parse_8bit_uint(tokens):
return lambda d: d.decode_8bit_uint()

@staticmethod
def parse_16bit_uint(tokens):
return lambda d: d.decode_16bit_uint()

@staticmethod
def parse_32bit_uint(tokens):
return lambda d: d.decode_32bit_uint()

@staticmethod
def parse_64bit_uint(tokens):
(continues on next page)

108 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

return lambda d: d.decode_64bit_uint()

@staticmethod
def parse_8bit_int(tokens):
return lambda d: d.decode_8bit_int()

@staticmethod
def parse_16bit_int(tokens):
return lambda d: d.decode_16bit_int()

@staticmethod
def parse_32bit_int(tokens):
return lambda d: d.decode_32bit_int()

@staticmethod
def parse_64bit_int(tokens):
return lambda d: d.decode_64bit_int()

@staticmethod
def parse_32bit_float(tokens):
return lambda d: d.decode_32bit_float()

@staticmethod
def parse_64bit_float(tokens):
return lambda d: d.decode_64bit_float()

#------------------------------------------------------------
# Public Interface
#------------------------------------------------------------
def tokenize(self, value):
""" Given a value, return the tokens

:param value: The value to tokenize

:returns: A token generator
"""
tokens = generate_tokens(StringIO(value).readline)
for toknum, tokval, _, _, _ in tokens:
yield tokval

def parse(self, value):

""" Given a type value, return a function
that supplied with a decoder, will decode
the correct value.

:param value: The type of value to parse

:returns: The decoder method to use
"""
tokens = [Link](value)
token = [Link]().lower()
parser = [Link](token, [Link])
return parser(tokens)

def mapping_decoder(mapping_blocks, decoder=None):

""" Given the raw mapping blocks, convert
them into modbus value decoder map.

(continues on next page)

4.28. Modbus Mapper Example 109

PyModbus Documentation, Release 2.5.0

(continued from previous page)

:param mapping_blocks: The mapping blocks
:param decoder: The type decoder to use
"""
decoder = decoder or ModbusTypeDecoder()
for block in mapping_blocks.itervalues():
for mapping in [Link]():
mapping['address'] = int(mapping['address'])
mapping['size'] = int(mapping['size'])
mapping['type'] = [Link](mapping['type'])

4.29 Modbus Saver Example

"""
These are a collection of helper methods that can be
used to save a modbus server context to file for backup,
checkpointing, or any other purpose. There use is very
simple::

context = [Link]
saver = JsonDatastoreSaver(context)
[Link]()

These can then be re-opened by the parsers in the

modbus_mapping module. At the moment, the supported
output formats are:

* csv
* json
* xml

To implement your own, simply subclass ModbusDatastoreSaver

and supply the needed callbacks for your given format:

* handle_store_start(self, store)
* handle_store_end(self, store)
* handle_slave_start(self, slave)
* handle_slave_end(self, slave)
* handle_save_start(self)
* handle_save_end(self)
"""
import json
import [Link] as xml

class ModbusDatastoreSaver(object):
""" An abstract base class that can be used to implement
a persistance format for the modbus server context. In
order to use it, just complete the neccessary callbacks
(SAX style) that your persistance format needs.
"""

def init(self, context, path=None):

""" Initialize a new instance of the saver.

(continues on next page)

110 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

:param context: The modbus server context
:param path: The output path to save to
"""
[Link] = context
[Link] = path or 'modbus-context-dump'

def save(self):
""" The main runner method to save the
context to file which calls the various
callbacks which the sub classes will
implement.
"""
with open([Link], 'w') as self.file_handle:
self.handle_save_start()
for slave_name, slave in [Link]:
self.handle_slave_start(slave_name)
for store_name, store in [Link]():
self.handle_store_start(store_name)
self.handle_store_values(iter(store))
self.handle_store_end(store_name)
self.handle_slave_end(slave_name)
self.handle_save_end()

#------------------------------------------------------------
# predefined state machine callbacks
#------------------------------------------------------------
def handle_save_start(self):
pass

def handle_store_start(self, store):

pass

def handle_store_end(self, store):

pass

def handle_slave_start(self, slave):

pass

def handle_slave_end(self, slave):

pass

def handle_save_end(self):
pass

# ---------------------------------------------------------------- #
# Implementations of the data store savers
# ---------------------------------------------------------------- #
class JsonDatastoreSaver(ModbusDatastoreSaver):
""" An implementation of the modbus datastore saver
that persists the context as a json document.
"""
_context = None
_store = None
_slave = None

STORE_NAMES = {
(continues on next page)

4.29. Modbus Saver Example 111

PyModbus Documentation, Release 2.5.0

(continued from previous page)

'i': 'input-registers',
'd': 'discretes',
'h': 'holding-registers',
'c': 'coils',
}

def handle_save_start(self):
self._context = dict()

def handle_slave_start(self, slave):

self._context[hex(slave)] = self._slave = dict()

def handle_store_start(self, store):

self._store = self.STORE_NAMES[store]

def handle_store_values(self, values):

self._slave[self._store] = dict(values)

def handle_save_end(self):
[Link](self._context, self.file_handle)

class CsvDatastoreSaver(ModbusDatastoreSaver):
""" An implementation of the modbus datastore saver
that persists the context as a csv document.
"""
_context = None
_store = None
_line = None
NEWLINE = '\r\n'
HEADER = "slave,store,address,value" + NEWLINE
STORE_NAMES = {
'i': 'i',
'd': 'd',
'h': 'h',
'c': 'c',
}

def handle_save_start(self):
self.file_handle.write([Link])

def handle_slave_start(self, slave):

self._line = [str(slave)]

def handle_store_start(self, store):

self._line.append(self.STORE_NAMES[store])

def handle_store_values(self, values):

self.file_handle.writelines(self.handle_store_value(values))

def handle_store_end(self, store):

self._line.pop()

def handle_store_value(self, values):

for a, v in values:
yield ','.join(self._line + [str(a), str(v)]) + [Link]

(continues on next page)

112 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

class XmlDatastoreSaver(ModbusDatastoreSaver):
""" An implementation of the modbus datastore saver
that persists the context as a XML document.
"""
_context = None
_store = None

STORE_NAMES = {
'i' : 'input-registers',
'd' : 'discretes',
'h' : 'holding-registers',
'c' : 'coils',
}

def handle_save_start(self):
self._context = [Link]("context")
self._root = [Link](self._context)

def handle_slave_start(self, slave):

self._slave = [Link](self._context, "slave")
self._slave.set("id", str(slave))

def handle_store_start(self, store):

self._store = [Link](self._slave, "store")
self._store.set("function", self.STORE_NAMES[store])

def handle_store_values(self, values):

for address, value in values:
entry = [Link](self._store, "entry")
[Link] = str(value)
[Link]("address", str(address))

def handle_save_end(self):
self._root.write(self.file_handle)

4.30 Modbus Scraper Example

#!/usr/bin/env python
"""
This is a simple scraper that can be pointed at a
modbus device to pull down all its values and store
them as a collection of sequential data blocks.
"""
import pickle
from optparse import OptionParser
from [Link] import serialport, reactor
from [Link] import ClientFactory
from [Link] import ModbusSequentialDataBlock
from [Link] import ModbusSlaveContext
from [Link] import ClientDecoder
from [Link] import ModbusClientProtocol

# -------------------------------------------------------------------------- #
(continues on next page)

4.30. Modbus Scraper Example 113

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# Configure the client logging
# -------------------------------------------------------------------------- #
import logging
log = [Link]("pymodbus")

# --------------------------------------------------------------------------- #
# Choose the framer you want to use
# --------------------------------------------------------------------------- #
from [Link] import ModbusBinaryFramer
from [Link] import ModbusAsciiFramer
from [Link] import ModbusRtuFramer
from [Link] import ModbusSocketFramer

# --------------------------------------------------------------------------- #
# Define some constants
# --------------------------------------------------------------------------- #
COUNT = 8 # The number of bits/registers to read at once
DELAY = 0 # The delay between subsequent reads
SLAVE = 0x01 # The slave unit id to read from

# --------------------------------------------------------------------------- #
# A simple scraper protocol
# --------------------------------------------------------------------------- #
# I tried to spread the load across the device, but feel free to modify the
# logic to suit your own purpose.
# --------------------------------------------------------------------------- #

class ScraperProtocol(ModbusClientProtocol):

address = None

def init(self, framer, endpoint):

""" Initializes our custom protocol

:param framer: The decoder to use to process messages

:param endpoint: The endpoint to send results to
"""
ModbusClientProtocol.__init__(self, framer)
[Link] = endpoint

def connectionMade(self):
""" Callback for when the client has connected
to the remote server.
"""
super(ScraperProtocol, self).connectionMade()
[Link]("Beginning the processing loop")
[Link] = [Link]
[Link](DELAY, self.scrape_holding_registers)

def connectionLost(self, reason):

""" Callback for when the client disconnects from the
server.

:param reason: The reason for the disconnection

"""
[Link](DELAY, [Link])
(continues on next page)

114 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def scrape_holding_registers(self):
""" Defer fetching holding registers
"""
[Link]("reading holding registers: %d" % [Link])
d = self.read_holding_registers([Link], count=COUNT, unit=SLAVE)
[Link](self.scrape_discrete_inputs, self.error_handler)

def scrape_discrete_inputs(self, response):

""" Defer fetching holding registers
"""
[Link]("reading discrete inputs: %d" % [Link])
[Link]((3, [Link], [Link]))
d = self.read_discrete_inputs([Link], count=COUNT, unit=SLAVE)
[Link](self.scrape_input_registers, self.error_handler)

def scrape_input_registers(self, response):

""" Defer fetching holding registers
"""
[Link]("reading discrete inputs: %d" % [Link])
[Link]((2, [Link], [Link]))
d = self.read_input_registers([Link], count=COUNT, unit=SLAVE)
[Link](self.scrape_coils, self.error_handler)

def scrape_coils(self, response):

""" Write values of holding registers, defer fetching coils

:param response: The response to process

"""
[Link]("reading coils: %d" % [Link])
[Link]((4, [Link], [Link]))
d = self.read_coils([Link], count=COUNT, unit=SLAVE)
[Link](self.start_next_cycle, self.error_handler)

def start_next_cycle(self, response):

""" Write values of coils, trigger next cycle

:param response: The response to process

"""
[Link]("starting next round: %d" % [Link])
[Link]((1, [Link], [Link]))
[Link] += COUNT
if [Link] >= [Link]:
[Link]()
[Link]()
else:
[Link](DELAY, self.scrape_holding_registers)

def error_handler(self, failure):

""" Handle any twisted errors

:param failure: The error to handle

"""
[Link](failure)

# --------------------------------------------------------------------------- #
(continues on next page)

4.30. Modbus Scraper Example 115

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# a factory for the example protocol
# --------------------------------------------------------------------------- #
# This is used to build client protocol's if you tie into twisted's method
# of processing. It basically produces client instances of the underlying
# protocol::
#
# Factory(Protocol) -> ProtocolInstance
#
# It also persists data between client instances (think protocol singelton).
# --------------------------------------------------------------------------- #
class ScraperFactory(ClientFactory):

protocol = ScraperProtocol

def init(self, framer, endpoint, query):

""" Remember things necessary for building a protocols """
[Link] = framer
[Link] = endpoint
[Link], [Link] = query

def buildProtocol(self, _):

""" Create a protocol and start the reading cycle """
protocol = [Link]([Link], [Link])
[Link] = self
return protocol

# --------------------------------------------------------------------------- #
# a custom client for our device
# --------------------------------------------------------------------------- #
# Twisted provides a number of helper methods for creating and starting
# clients:
# - [Link]
# - [Link]
#
# How you start your client is really up to you.
# --------------------------------------------------------------------------- #
class SerialModbusClient([Link]):

def init(self, factory, *args, **kwargs):

""" Setup the client and start listening on the serial port

:param factory: The factory to build clients with

"""
protocol = [Link](None)
[Link] = ClientDecoder()
[Link].__init__(self, protocol, *args, **kwargs)

116 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

class LoggingContextReader(object):

def init(self, output):

""" Initialize a new instance of the logger

:param output: The output file to save to

"""
[Link] = output
[Link] = ModbusSlaveContext(
di = [Link](),
co = [Link](),
hr = [Link](),
ir = [Link]())

def write(self, response):

""" Handle the next modbus response

:param response: The response to process

"""
[Link]("Read Data: %s" % str(response))
fx, address, values = response
[Link](fx, address, values)

def finalize(self):
with open([Link], "w") as handle:
[Link]([Link], handle)

# -------------------------------------------------------------------------- #
# Main start point
# -------------------------------------------------------------------------- #
def get_options():
""" A helper method to parse the command line options

:returns: The options manager

"""
parser = OptionParser()

parser.add_option("-o", "--output",
help="The resulting output file for the scrape",
dest="output", default="[Link]")

parser.add_option("-p", "--port",
help="The port to connect to", type='int',
dest="port", default=502)

parser.add_option("-s", "--server",
help="The server to scrape",
dest="host", default="[Link]")

parser.add_option("-r", "--range",
help="The address range to scan",
dest="query", default="0:1000")

parser.add_option("-d", "--debug",
help="Enable debug tracing",
action="store_true", dest="debug", default=False)
(continues on next page)

4.30. Modbus Scraper Example 117

PyModbus Documentation, Release 2.5.0

(continued from previous page)

(opt, arg) = parser.parse_args()

return opt

def main():
""" The main runner function """
options = get_options()

if [Link]:
try:
[Link]([Link])
[Link]()
except Exception as ex:
print("Logging is not supported on this system")

# split the query into a starting and ending range

query = [int(p) for p in [Link](':')]

try:
[Link]("Initializing the client")
framer = ModbusSocketFramer(ClientDecoder())
reader = LoggingContextReader([Link])
factory = ScraperFactory(framer, reader, query)

# how to connect based on TCP vs Serial clients

if isinstance(framer, ModbusSocketFramer):
[Link]([Link], [Link], factory)
else:
SerialModbusClient(factory, [Link], reactor)

[Link]("Starting the client")

[Link]()
[Link]("Finished scraping the client")
except Exception as ex:
print(ex)

# --------------------------------------------------------------------------- #
# Main jumper
# --------------------------------------------------------------------------- #

if __name__ == "__main__":
main()

4.31 Modbus Simulator Example

#!/usr/bin/env python
"""
An example of creating a fully implemented modbus server
with read/write data as well as user configurable base data
"""

import pickle
(continues on next page)

118 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

from optparse import OptionParser
from [Link] import reactor

from [Link] import StartTcpServer

from [Link] import ModbusServerContext,ModbusSlaveContext

# -------------------------------------------------------------------------- #
# Logging
# -------------------------------------------------------------------------- #
import logging
[Link]()

server_log = [Link]("[Link]")
protocol_log = [Link]("[Link]")

# -------------------------------------------------------------------------- #
# Extra Global Functions
# -------------------------------------------------------------------------- #
# These are extra helper functions that don't belong in a class
# -------------------------------------------------------------------------- #
import getpass

def root_test():
""" Simple test to see if we are running as root """
return True # removed for the time being as it isn't portable
#return [Link]() == "root"

# -------------------------------------------------------------------------- #
# Helper Classes
# -------------------------------------------------------------------------- #

class ConfigurationException(Exception):
""" Exception for configuration error """

def init(self, string):

""" Initializes the ConfigurationException instance

:param string: The message to append to the exception

"""
Exception.__init__(self, string)
[Link] = string

def __str__(self):
""" Builds a representation of the object

:returns: A string representation of the object

"""
return 'Configuration Error: %s' % [Link]

class Configuration:
"""
Class used to parse configuration file and create and modbus
datastore.
(continues on next page)

4.31. Modbus Simulator Example 119

PyModbus Documentation, Release 2.5.0

(continued from previous page)

The format of the configuration file is actually just a

python pickle, which is a compressed memory dump from
the scraper.
"""

def init(self, config):

"""
Trys to load a configuration file, lets the file not
found exception fall through

:param config: The pickled datastore

"""
try:
[Link] = open(config, "rb")
except Exception as e:
_logger.critical(str(e))
raise ConfigurationException("File not found %s" % config)

def parse(self):
""" Parses the config file and creates a server context
"""
handle = [Link]([Link])
try: # test for existance, or bomb
dsd = handle['di']
csd = handle['ci']
hsd = handle['hr']
isd = handle['ir']
except Exception:
raise ConfigurationException("Invalid Configuration")
slave = ModbusSlaveContext(d=dsd, c=csd, h=hsd, i=isd)
return ModbusServerContext(slaves=slave)

# -------------------------------------------------------------------------- #
# Main start point
# -------------------------------------------------------------------------- #

def main():
""" Server launcher """
parser = OptionParser()
parser.add_option("-c", "--conf",
help="The configuration file to load",
dest="file")
parser.add_option("-D", "--debug",
help="Turn on to enable tracing",
action="store_true", dest="debug", default=False)
(opt, arg) = parser.parse_args()

# enable debugging information

if [Link]:
try:
server_log.setLevel([Link])
protocol_log.setLevel([Link])
except Exception as e:
print("Logging is not supported on this system")

(continues on next page)

120 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# parse configuration file and run
try:
conf = Configuration([Link])
StartTcpServer(context=[Link]())
except ConfigurationException as err:
print(err)
parser.print_help()

# -------------------------------------------------------------------------- #
# Main jumper
# -------------------------------------------------------------------------- #

if __name__ == "__main__":
if root_test():
main()
else:
print("This script must be run as root!")

4.32 Modicon Payload Example

"""
Modbus Modicon Payload Builder
-----------------------------------------------------------

This is an example of building a custom payload builder

that can be used in the pymodbus library. Below is a
simple modicon encoded builder and decoder.
"""
from struct import pack, unpack
from [Link] import Endian
from [Link] import IPayloadBuilder
from [Link] import pack_bitstring
from [Link] import unpack_bitstring
from [Link] import ParameterException

class ModiconPayloadBuilder(IPayloadBuilder):
"""
A utility that helps build modicon encoded payload
messages to be written with the various modbus messages.
example::

builder = ModiconPayloadBuilder()
builder.add_8bit_uint(1)
builder.add_16bit_uint(2)
payload = [Link]()
"""

def init(self, payload=None, endian=[Link]):

""" Initialize a new instance of the payload builder

:param payload: Raw payload data to initialize with

:param endian: The endianess of the payload
(continues on next page)

4.32. Modicon Payload Example 121

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
self._payload = payload or []
self._endian = endian

def __str__(self):
""" Return the payload buffer as a string

:returns: The payload buffer as a string

"""
return ''.join(self._payload)

def reset(self):
""" Reset the payload buffer
"""
self._payload = []

def build(self):
""" Return the payload buffer as a list

This list is two bytes per element and can

thus be treated as a list of registers.

:returns: The payload buffer as a list

"""
string = str(self)
length = len(string)
string = string + ('\x00' * (length % 2))
return [string[i:i+2] for i in range(0, length, 2)]

def add_bits(self, values):

""" Adds a collection of bits to be encoded

If these are less than a multiple of eight,

they will be left padded with 0 bits to make
it so.

:param values: The value to add to the buffer

"""
value = pack_bitstring(values)
self._payload.append(value)

def add_8bit_uint(self, value):

""" Adds a 8 bit unsigned int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'B'
self._payload.append(pack(fstring, value))

def add_16bit_uint(self, value):

""" Adds a 16 bit unsigned int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'H'
self._payload.append(pack(fstring, value))

(continues on next page)

122 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def add_32bit_uint(self, value):
""" Adds a 32 bit unsigned int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'I'
handle = pack(fstring, value)
handle = handle[2:] + handle[:2]
self._payload.append(handle)

def add_8bit_int(self, value):

""" Adds a 8 bit signed int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'b'
self._payload.append(pack(fstring, value))

def add_16bit_int(self, value):

""" Adds a 16 bit signed int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'h'
self._payload.append(pack(fstring, value))

def add_32bit_int(self, value):

""" Adds a 32 bit signed int to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'i'
handle = pack(fstring, value)
handle = handle[2:] + handle[:2]
self._payload.append(handle)

def add_32bit_float(self, value):

""" Adds a 32 bit float to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 'f'
handle = pack(fstring, value)
handle = handle[2:] + handle[:2]
self._payload.append(handle)

def add_string(self, value):

""" Adds a string to the buffer

:param value: The value to add to the buffer

"""
fstring = self._endian + 's'
for c in value:
self._payload.append(pack(fstring, c))

class ModiconPayloadDecoder(object):
(continues on next page)

4.32. Modicon Payload Example 123

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
A utility that helps decode modicon encoded payload
messages from a modbus reponse message. What follows is
a simple example::

decoder = ModiconPayloadDecoder(payload)
first = decoder.decode_8bit_uint()
second = decoder.decode_16bit_uint()
"""

def init(self, payload, endian):

""" Initialize a new payload decoder

:param payload: The payload to decode with

"""
self._payload = payload
self._pointer = 0x00
self._endian = endian

@staticmethod
def from_registers(registers, endian=[Link]):
""" Initialize a payload decoder with the result of
reading a collection of registers from a modbus device.

The registers are treated as a list of 2 byte values.

We have to do this because of how the data has already
been decoded by the rest of the library.

:param registers: The register results to initialize with

:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
"""
if isinstance(registers, list): # repack into flat binary
payload = ''.join(pack('>H', x) for x in registers)
return ModiconPayloadDecoder(payload, endian)
raise ParameterException('Invalid collection of registers supplied')

@staticmethod
def from_coils(coils, endian=[Link]):
""" Initialize a payload decoder with the result of
reading a collection of coils from a modbus device.

The coils are treated as a list of bit(boolean) values.

:param coils: The coil results to initialize with

:param endian: The endianess of the payload
:returns: An initialized PayloadDecoder
"""
if isinstance(coils, list):
payload = pack_bitstring(coils)
return ModiconPayloadDecoder(payload, endian)
raise ParameterException('Invalid collection of coils supplied')

def reset(self):
""" Reset the decoder pointer back to the start
"""
(continues on next page)

124 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

self._pointer = 0x00

def decode_8bit_uint(self):
""" Decodes a 8 bit unsigned int from the buffer
"""
self._pointer += 1
fstring = self._endian + 'B'
handle = self._payload[self._pointer - 1:self._pointer]
return unpack(fstring, handle)[0]

def decode_16bit_uint(self):
""" Decodes a 16 bit unsigned int from the buffer
"""
self._pointer += 2
fstring = self._endian + 'H'
handle = self._payload[self._pointer - 2:self._pointer]
return unpack(fstring, handle)[0]

def decode_32bit_uint(self):
""" Decodes a 32 bit unsigned int from the buffer
"""
self._pointer += 4
fstring = self._endian + 'I'
handle = self._payload[self._pointer - 4:self._pointer]
handle = handle[2:] + handle[:2]
return unpack(fstring, handle)[0]

def decode_8bit_int(self):
""" Decodes a 8 bit signed int from the buffer
"""
self._pointer += 1
fstring = self._endian + 'b'
handle = self._payload[self._pointer - 1:self._pointer]
return unpack(fstring, handle)[0]

def decode_16bit_int(self):
""" Decodes a 16 bit signed int from the buffer
"""
self._pointer += 2
fstring = self._endian + 'h'
handle = self._payload[self._pointer - 2:self._pointer]
return unpack(fstring, handle)[0]

def decode_32bit_int(self):
""" Decodes a 32 bit signed int from the buffer
"""
self._pointer += 4
fstring = self._endian + 'i'
handle = self._payload[self._pointer - 4:self._pointer]
handle = handle[2:] + handle[:2]
return unpack(fstring, handle)[0]

def decode_32bit_float(self, size=1):

""" Decodes a float from the buffer
"""
self._pointer += 4
fstring = self._endian + 'f'
(continues on next page)

4.32. Modicon Payload Example 125

PyModbus Documentation, Release 2.5.0

(continued from previous page)

handle = self._payload[self._pointer - 4:self._pointer]
handle = handle[2:] + handle[:2]
return unpack(fstring, handle)[0]

def decode_bits(self):
""" Decodes a byte worth of bits from the buffer
"""
self._pointer += 1
handle = self._payload[self._pointer - 1:self._pointer]
return unpack_bitstring(handle)

def decode_string(self, size=1):

""" Decodes a string from the buffer

:param size: The size of the string to decode

"""
self._pointer += size
return self._payload[self._pointer - size:self._pointer]

# -------------------------------------------------------------------------- #
# Exported Identifiers
# -------------------------------------------------------------------------- #
__all__ = ["ModiconPayloadBuilder", "ModiconPayloadDecoder"]

4.33 Remote Server Context Example

"""
Although there is a remote server context already in the main library,
it works under the assumption that users would have a server context
of the following form::

server_context = {
0x00: client('[Link]'),
0x01: client('[Link]'),
0x02: client('[Link]')
}

This example is how to create a server context where the client is

pointing to the same host, but the requested slave id is used as the
slave for the client::

server_context = {
0x00: client('[Link]', 0x00),
0x01: client('[Link]', 0x01),
0x02: client('[Link]', 0x02)
}
"""
from [Link] import NotImplementedException
from [Link] import IModbusSlaveContext

# -------------------------------------------------------------------------- #
# Logging
# -------------------------------------------------------------------------- #
(continues on next page)

126 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

import logging
_logger = [Link](__name__)

# -------------------------------------------------------------------------- #
# Slave Context
# -------------------------------------------------------------------------- #
# Basically we create a new slave context for the given slave identifier so
# that this slave context will only make requests to that slave with the
# client that the server is maintaining.
# -------------------------------------------------------------------------- #

class RemoteSingleSlaveContext(IModbusSlaveContext):
""" This is a remote server context that allows one
to create a server context backed by a single client that
may be attached to many slave units. This can be used to
effectively create a modbus forwarding server.
"""

def init(self, context, unit_id):

""" Initializes the datastores

:param context: The underlying context to operate with

:param unit_id: The slave that this context will contact
"""
[Link] = context
self.unit_id = unit_id

def reset(self):
""" Resets all the datastores to their default values """
raise NotImplementedException()

def validate(self, fx, address, count=1):

""" Validates the request to make sure it is in range

:param fx: The function we are working with

:param address: The starting address
:param count: The number of values to test
:returns: True if the request in within range, False otherwise
"""
_logger.debug("validate[%d] %d:%d" % (fx, address, count))
result = [Link].get_callbacks[[Link](fx)](address,
count,
self.unit_id)
return not [Link]()

def getValues(self, fx, address, count=1):

""" Get `count` values from datastore

:param fx: The function we are working with

:param address: The starting address
:param count: The number of values to retrieve
:returns: The requested values from a:a+c
"""
_logger.debug("get values[%d] %d:%d" % (fx, address, count))
result = [Link].get_callbacks[[Link](fx)](address,
(continues on next page)

4.33. Remote Server Context Example 127

PyModbus Documentation, Release 2.5.0

(continued from previous page)

count,
self.unit_id)
return self.__extract_result([Link](fx), result)

def setValues(self, fx, address, values):

""" Sets the datastore with the supplied values

:param fx: The function we are working with

:param address: The starting address
:param values: The new values to be set
"""
_logger.debug("set values[%d] %d:%d" % (fx, address, len(values)))
[Link].set_callbacks[[Link](fx)](address,
values,
self.unit_id)

def __str__(self):
""" Returns a string representation of the context

:returns: A string representation of the context

"""
return "Remote Single Slave Context(%s)" % self.unit_id

def __extract_result(self, fx, result):

""" A helper method to extract the values out of
a response. The future api should make the result
consistent so we can just call `[Link]()`.

:param fx: The function to call

:param result: The resulting data
"""
if not [Link]():
if fx in ['d', 'c']:
return [Link]
if fx in ['h', 'i']:
return [Link]
else:
return result

# -------------------------------------------------------------------------- #
# Server Context
# -------------------------------------------------------------------------- #
# Think of this as simply a dictionary of { unit_id: client(req, unit_id) }
# -------------------------------------------------------------------------- #

class RemoteServerContext(object):
""" This is a remote server context that allows one
to create a server context backed by a single client that
may be attached to many slave units. This can be used to
effectively create a modbus forwarding server.
"""

def init(self, client):

""" Initializes the datastores

:param client: The client to retrieve values with

(continues on next page)

128 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
self.get_callbacks = {
'd': lambda a, c, s: client.read_discrete_inputs(a, c, s),
'c': lambda a, c, s: client.read_coils(a, c, s),
'h': lambda a, c, s: client.read_holding_registers(a, c, s),
'i': lambda a, c, s: client.read_input_registers(a, c, s),
}
self.set_callbacks = {
'd': lambda a, v, s: client.write_coils(a, v, s),
'c': lambda a, v, s: client.write_coils(a, v, s),
'h': lambda a, v, s: client.write_registers(a, v, s),
'i': lambda a, v, s: client.write_registers(a, v, s),
}
self._client = client
[Link] = {} # simply a cache

def __str__(self):
""" Returns a string representation of the context

:returns: A string representation of the context

"""
return "Remote Server Context(%s)" % self._client

def __iter__(self):
""" Iterater over the current collection of slave
contexts.

:returns: An iterator over the slave contexts

"""
# note, this may not include all slaves
return iter([Link]())

def contains(self, slave):

""" Check if the given slave is in this list

:param slave: slave The slave to check for existance

:returns: True if the slave exists, False otherwise
"""
# we don't want to check the cache here as the
# slave may not exist yet or may not exist any
# more. The best thing to do is try and fail.
return True

def setitem(self, slave, context):

""" Used to set a new slave context

:param slave: The slave context to set

:param context: The new context to set for this slave
"""
raise NotImplementedException() # doesn't make sense here

def delitem(self, slave):

""" Wrapper used to access the slave context

:param slave: The slave context to remove

"""
raise NotImplementedException() # doesn't make sense here
(continues on next page)

4.33. Remote Server Context Example 129

PyModbus Documentation, Release 2.5.0

(continued from previous page)

def getitem(self, slave):

""" Used to get access to a slave context

:param slave: The slave context to get

:returns: The requested slave context
"""
if slave not in [Link]:
[Link][slave] = RemoteSingleSlaveContext(self, slave)
return [Link][slave]

4.34 Serial Forwarder Example

#!/usr/bin/env python
"""
Pymodbus Synchronous Serial Forwarder
--------------------------------------------------------------------------

We basically set the context for the tcp serial server to be that of a
serial client! This is just an example of how clever you can be with
the data context (basically anything can become a modbus device).
"""
# --------------------------------------------------------------------------- #
# import the various server implementations
# --------------------------------------------------------------------------- #
from [Link] import StartTcpServer as StartServer
from [Link] import ModbusSerialClient as ModbusClient

from [Link] import RemoteSlaveContext

from [Link] import ModbusSlaveContext, ModbusServerContext

def run_serial_forwarder():
# ----------------------------------------------------------------------- #
# initialize the datastore(serial client)
# Note this would send the requests on the serial client with address = 0

# ----------------------------------------------------------------------- #
client = ModbusClient(method='rtu', port='/tmp/ptyp0')
# If required to communicate with a specified client use unit=<unit_id>
# in RemoteSlaveContext
# For e.g to forward the requests to slave with unit address 1 use
# store = RemoteSlaveContext(client, unit=1)
store = RemoteSlaveContext(client)
context = ModbusServerContext(slaves=store, single=True)

(continues on next page)

130 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

if __name__ == "__main__":
run_serial_forwarder()

4.35 Sunspec Client Example

from [Link] import Endian

from [Link] import ModbusTcpClient
from [Link] import BinaryPayloadDecoder
from [Link] import Deferred

# --------------------------------------------------------------------------- #
# Logging
# --------------------------------------------------------------------------- #
import logging
_logger = [Link](__name__)
_logger.setLevel([Link])
[Link]()

# --------------------------------------------------------------------------- #
# Sunspec Common Constants
# --------------------------------------------------------------------------- #
class SunspecDefaultValue(object):
""" A collection of constants to indicate if
a value is not implemented.
"""
Signed16 = 0x8000
Unsigned16 = 0xffff
Accumulator16 = 0x0000
Scale = 0x8000
Signed32 = 0x80000000
Float32 = 0x7fc00000
Unsigned32 = 0xffffffff
Accumulator32 = 0x00000000
Signed64 = 0x8000000000000000
Unsigned64 = 0xffffffffffffffff
Accumulator64 = 0x0000000000000000
String = '\x00'

class SunspecStatus(object):
""" Indicators of the current status of a
sunspec device
"""
Normal = 0x00000000
Error = 0xfffffffe
Unknown = 0xffffffff
(continues on next page)

4.35. Sunspec Client Example 131

PyModbus Documentation, Release 2.5.0

(continued from previous page)

class SunspecIdentifier(object):
""" Assigned identifiers that are pre-assigned
by the sunspec protocol.
"""
Sunspec = 0x53756e53

class SunspecModel(object):
""" Assigned device indentifiers that are pre-assigned
by the sunspec protocol.
"""
#---------------------------------------------
# 0xx Common Models
#---------------------------------------------
CommonBlock = 1
AggregatorBlock = 2

#---------------------------------------------
# 1xx Inverter Models
#---------------------------------------------
SinglePhaseIntegerInverter = 101
SplitPhaseIntegerInverter = 102
ThreePhaseIntegerInverter = 103
SinglePhaseFloatsInverter = 103
SplitPhaseFloatsInverter = 102
ThreePhaseFloatsInverter = 103

#---------------------------------------------
# 2xx Meter Models
#---------------------------------------------
SinglePhaseMeter = 201
SplitPhaseMeter = 201
WyeConnectMeter = 201
DeltaConnectMeter = 201

#---------------------------------------------
# 3xx Environmental Models
#---------------------------------------------
BaseMeteorological = 301
Irradiance = 302
BackOfModuleTemperature = 303
Inclinometer = 304
Location = 305
ReferencePoint = 306
BaseMeteorological = 307
MiniMeteorological = 308

#---------------------------------------------
# 4xx String Combiner Models
#---------------------------------------------
BasicStringCombiner = 401
AdvancedStringCombiner = 402

#---------------------------------------------
# 5xx Panel Models
(continues on next page)

132 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

#---------------------------------------------
PanelFloat = 501
PanelInteger = 502

#---------------------------------------------
# 641xx Outback Blocks
#---------------------------------------------
OutbackDeviceIdentifier = 64110
OutbackChargeController = 64111
OutbackFMSeriesChargeController = 64112
OutbackFXInverterRealTime = 64113
OutbackFXInverterConfiguration = 64114
OutbackSplitPhaseRadianInverter = 64115
OutbackRadianInverterConfiguration = 64116
OutbackSinglePhaseRadianInverterRealTime = 64117
OutbackFLEXNetDCRealTime = 64118
OutbackFLEXNetDCConfiguration = 64119
OutbackSystemControl = 64120

#---------------------------------------------
# 64xxx Vender Extension Block
#---------------------------------------------
EndOfSunSpecMap = 65535

@classmethod
def lookup(klass, code):
""" Given a device identifier, return the
device model name for that identifier

:param code: The device code to lookup

:returns: The device model name, or None if none available
"""
values = dict((v, k) for k, v in klass.__dict__.iteritems()
if not callable(v))
return [Link](code, None)

class SunspecOffsets(object):
""" Well known offsets that are used throughout
the sunspec protocol
"""
CommonBlock = 40000
CommonBlockLength = 69
AlternateCommonBlock = 50000

# --------------------------------------------------------------------------- #
# Common Functions
# --------------------------------------------------------------------------- #
def defer_or_apply(func):
""" Decorator to apply an adapter method
to a result regardless if it is a deferred
or a concrete response.

:param func: The function to decorate

"""
def closure(future, adapt):
(continues on next page)

4.35. Sunspec Client Example 133

PyModbus Documentation, Release 2.5.0

(continued from previous page)

if isinstance(future, Deferred):
d = Deferred()
[Link](lambda r: [Link](adapt(r)))
return d
return adapt(future)
return closure

def create_sunspec_sync_client(host):
""" A quick helper method to create a sunspec
client.

:param host: The host to connect to

:returns: an initialized SunspecClient
"""
modbus = ModbusTcpClient(host)
[Link]()
client = SunspecClient(modbus)
[Link]()
return client

# --------------------------------------------------------------------------- #
# Sunspec Client
# --------------------------------------------------------------------------- #
class SunspecDecoder(BinaryPayloadDecoder):
""" A decoder that deals correctly with the sunspec
binary format.
"""

def init(self, payload, byteorder):

""" Initialize a new instance of the SunspecDecoder

.. note:: This is always set to big endian byte order

as specified in the protocol.
"""
byteorder = [Link]
BinaryPayloadDecoder.__init__(self, payload, byteorder)

def decode_string(self, size=1):

""" Decodes a string from the buffer

:param size: The size of the string to decode

"""
self._pointer += size
string = self._payload[self._pointer - size:self._pointer]
return [Link]([Link])[0]

class SunspecClient(object):

def init(self, client):

""" Initialize a new instance of the client

:param client: The modbus client to use

"""
[Link] = client
(continues on next page)

134 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

[Link] = [Link]

def initialize(self):
""" Initialize the underlying client values

:returns: True if successful, false otherwise

"""
decoder = self.get_device_block([Link], 2)
if decoder.decode_32bit_uint() == [Link]:
return True
[Link] = [Link]
decoder = self.get_device_block([Link], 2)
return decoder.decode_32bit_uint() == [Link]

def get_common_block(self):
""" Read and return the sunspec common information
block.

:returns: A dictionary of the common block information

"""
length = [Link]
decoder = self.get_device_block([Link], length)
return {
'SunSpec_ID': decoder.decode_32bit_uint(),
'SunSpec_DID': decoder.decode_16bit_uint(),
'SunSpec_Length': decoder.decode_16bit_uint(),
'Manufacturer': decoder.decode_string(size=32),
'Model': decoder.decode_string(size=32),
'Options': decoder.decode_string(size=16),
'Version': decoder.decode_string(size=16),
'SerialNumber': decoder.decode_string(size=32),
'DeviceAddress': decoder.decode_16bit_uint(),
'Next_DID': decoder.decode_16bit_uint(),
'Next_DID_Length': decoder.decode_16bit_uint(),
}

def get_device_block(self, offset, size):

""" A helper method to retrieve the next device block

.. note:: We will read 2 more registers so that we have

the information for the next block.

:param offset: The offset to start reading at

:param size: The size of the offset to read
:returns: An initialized decoder for that result
"""
_logger.debug("reading device block[{}..{}]".format(offset, offset + size))
response = [Link].read_holding_registers(offset, size + 2)
return [Link]([Link])

def get_all_device_blocks(self):
""" Retrieve all the available blocks in the supplied
sunspec device.

.. note:: Since we do not know how to decode the available

blocks, this returns a list of dictionaries of the form:

(continues on next page)

4.35. Sunspec Client Example 135

PyModbus Documentation, Release 2.5.0

(continued from previous page)

decoder: the-binary-decoder,
model: the-model-identifier (name)

:returns: A list of the available blocks

"""
blocks = []
offset = [Link] + 2
model = [Link]
while model != [Link]:
decoder = self.get_device_block(offset, 2)
model = decoder.decode_16bit_uint()
length = decoder.decode_16bit_uint()
[Link]({
'model' : model,
'name' : [Link](model),
'length': length,
'offset': offset + length + 2
})
offset += length + 2
return blocks

#------------------------------------------------------------
# A quick test runner
#------------------------------------------------------------
if __name__ == "__main__":
client = create_sunspec_sync_client("[Link]")

# print out all the device common block

common = client.get_common_block()
for key, value in [Link]():
if key == "SunSpec_DID":
value = [Link](value)
print("{:<20}: {}".format(key, value))

# print out all the available device blocks

blocks = client.get_all_device_blocks()
for block in blocks:
print(block)

[Link]()

4.36 Thread Safe Datastore Example

import threading
from contextlib import contextmanager
from [Link] import BaseModbusDataBlock

class ContextWrapper(object):
""" This is a simple wrapper around enter
and exit functions that conforms to the pyhton
context manager protocol:

(continues on next page)

136 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

with ContextWrapper(enter, leave):
do_something()
"""

def init(self, enter=None, leave=None, factory=None):

self._enter = enter
self._leave = leave
self._factory = factory

def __enter__(self):
if [Link]: self._enter()
return self if not self._factory else self._factory()

def exit(self, args):

if self._leave: self._leave()

class ReadWriteLock(object):
""" This reader writer lock gurantees write order, but not
read order and is generally biased towards allowing writes
if they are available to prevent starvation.

TODO:

* allow user to choose between read/write/random biasing

- currently write biased
- read biased allow N readers in queue
- random is 50/50 choice of next
"""

def __init__(self):
""" Initializes a new instance of the ReadWriteLock
"""
[Link] = [] # the current writer queue
[Link] = [Link]() # the underlying condition lock
self.read_condition = [Link]([Link]) # the single reader
˓→condition

[Link] = 0 # the number of current readers

[Link] = False # is there a current writer

def __is_pending_writer(self):
return ([Link] # if there is a current writer
or ([Link] # or if there is a waiting writer
and ([Link][0] != self.read_condition))) # or if the queue head is
˓→not a reader

def acquire_reader(self):
""" Notifies the lock that a new reader is requesting
the underlying resource.
"""
with [Link]:
if self.__is_pending_writer(): # if there are existing
˓→writers waiting

if self.read_condition not in [Link]: # do not pollute the queue

˓→with readers

[Link](self.read_condition) # add the readers in line

˓→for the queue
(continues on next page)

4.36. Thread Safe Datastore Example 137

PyModbus Documentation, Release 2.5.0

(continued from previous page)

while self.__is_pending_writer(): # until the current writer
˓→ is finished
self.read_condition.wait(1) # wait on our condition
if [Link] and self.read_condition == [Link][0]: # if the read
˓→condition is at the queue head

[Link](0) # then go ahead and remove

˓→it

[Link] += 1 # update the current

˓→number of readers

def acquire_writer(self):
""" Notifies the lock that a new writer is requesting
the underlying resource.
"""
with [Link]:
if [Link] or [Link]: # if we need to wait on a
˓→writer or readers

condition = [Link]([Link]) # create a condition just

˓→for this writer

[Link](condition) # and put it on the

˓→waiting queue

while [Link] or [Link]: # until the write lock is

˓→free

[Link](1) # wait on our condition

[Link](0) # remove our condition
˓→after our condition is met

[Link] = True # stop other writers from

˓→operating

def release_reader(self):
""" Notifies the lock that an existing reader is
finished with the underlying resource.
"""
with [Link]:
[Link] = max(0, [Link] - 1) # readers should never go
˓→below 0

if not [Link] and [Link]: # if there are no active

˓→readers

[Link][0].notify_all() # then notify any waiting

˓→writers

def release_writer(self):
""" Notifies the lock that an existing writer is
finished with the underlying resource.
"""
with [Link]:
[Link] = False # give up current writing
˓→handle

if [Link]: # if someone is waiting in

˓→the queue

[Link][0].notify_all() # wake them up first

else: self.read_condition.notify_all() # otherwise wake up all
˓→possible readers

@contextmanager
def get_reader_lock(self):
""" Wrap some code with a reader lock using the
(continues on next page)

138 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

python context manager protocol::

with rwlock.get_reader_lock():
do_read_operation()
"""
try:
self.acquire_reader()
yield self
finally: self.release_reader()

@contextmanager
def get_writer_lock(self):
""" Wrap some code with a writer lock using the
python context manager protocol::

with rwlock.get_writer_lock():
do_read_operation()
"""
try:
self.acquire_writer()
yield self
finally: self.release_writer()

class ThreadSafeDataBlock(BaseModbusDataBlock):
""" This is a simple decorator for a data block. This allows
a user to inject an existing data block which can then be
safely operated on from multiple cocurrent threads.

It should be noted that the choice was made to lock around the
datablock instead of the manager as there is less source of
contention (writes can occur to slave 0x01 while reads can
occur to slave 0x02).
"""

def init(self, block):

""" Initialize a new thread safe decorator

:param block: The block to decorate

"""
[Link] = ReadWriteLock()
[Link] = block

def validate(self, address, count=1):

""" Checks to see if the request is in range

:param address: The starting address

:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
"""
with [Link].get_reader_lock():
return [Link](address, count)

def getValues(self, address, count=1):

""" Returns the requested values of the datastore

:param address: The starting address

(continues on next page)

4.36. Thread Safe Datastore Example 139

PyModbus Documentation, Release 2.5.0

(continued from previous page)

:param count: The number of values to retrieve
:returns: The requested values from a:a+c
"""
with [Link].get_reader_lock():
return [Link](address, count)

def setValues(self, address, values):

""" Sets the requested values of the datastore

:param address: The starting address

:param values: The new values to be set
"""
with [Link].get_writer_lock():
return [Link](address, values)

if __name__ == "__main__":

class AtomicCounter(object):
def __init__(self, **kwargs):
[Link] = [Link]('start', 0)
[Link] = [Link]('finish', 1000)
[Link] = [Link]()

def increment(self, count=1):

with [Link]:
[Link] += count

def is_running(self):
return [Link] <= [Link]

locker = ReadWriteLock()
readers, writers = AtomicCounter(), AtomicCounter()

def read():
while writers.is_running() and readers.is_running():
with locker.get_reader_lock():
[Link]()

def write():
while writers.is_running() and readers.is_running():
with locker.get_writer_lock():
[Link]()

rthreads = [[Link](target=read) for i in range(50)]

wthreads = [[Link](target=write) for i in range(2)]
for t in rthreads + wthreads: [Link]()
for t in rthreads + wthreads: [Link]()
print("readers[%d] writers[%d]" % ([Link], [Link]))

4.37 Gui Common Example

#!/usr/bin/env python
# -------------------------------------------------------------------------- #
(continues on next page)

140 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

# System
# -------------------------------------------------------------------------- #
import os
import getpass
import pickle
from threading import Thread

# -------------------------------------------------------------------------- #
# SNMP Simulator
# -------------------------------------------------------------------------- #
from [Link] import reactor
from [Link] import error as twisted_error
from [Link] import ModbusServerFactory
from [Link] import ModbusServerContext,ModbusSlaveContext

# -------------------------------------------------------------------------- #
# Logging
# -------------------------------------------------------------------------- #
import logging
log = [Link]("pymodbus")

# -------------------------------------------------------------------------- #
# Application Error
# -------------------------------------------------------------------------- #

class ConfigurationException(Exception):
""" Exception for configuration error """
pass

def root_test():
""" Simple test to see if we are running as root """
return [Link]() == "root"

# -------------------------------------------------------------------------- #
# Simulator Class
# -------------------------------------------------------------------------- #

class Simulator(object):
"""
Class used to parse configuration file and create and modbus
datastore.

The format of the configuration file is actually just a

python pickle, which is a compressed memory dump from
the scraper.
"""

def init(self, config):

(continues on next page)

4.37. Gui Common Example 141

PyModbus Documentation, Release 2.5.0

(continued from previous page)

"""
Trys to load a configuration file, lets the file not
found exception fall through

:param config: The pickled datastore

"""
try:
[Link] = open(config, "r")
except Exception:
raise ConfigurationException("File not found %s" % config)

def _parse(self):
""" Parses the config file and creates a server context """
try:
handle = [Link]([Link])
dsd = handle['di']
csd = handle['ci']
hsd = handle['hr']
isd = handle['ir']
except KeyError:
raise ConfigurationException("Invalid Configuration")
slave = ModbusSlaveContext(d=dsd, c=csd, h=hsd, i=isd)
return ModbusServerContext(slaves=slave)

def _simulator(self):
""" Starts the snmp simulator """
ports = [502]+range(20000,25000)
for port in ports:
try:
[Link](port, ModbusServerFactory(self._parse()))
[Link]('listening on port %d' % port)
return port
except twisted_error.CannotListenError:
pass

def run(self):
""" Used to run the simulator """
[Link]('simulator started')
[Link](self._simulator)

# -------------------------------------------------------------------------- #
# Network reset thread
# -------------------------------------------------------------------------- #
# This is linux only, maybe I should make a base class that can be filled
# in for linux(debian/redhat)/windows/nix
# -------------------------------------------------------------------------- #

class NetworkReset(Thread):
"""
This class is simply a daemon that is spun off at the end of the
program to call the network restart function (an easy way to
remove all the virtual interfaces)
"""

def __init__(self):
""" Initialize a new network reset thread """
(continues on next page)

142 Chapter 4. Examples

PyModbus Documentation, Release 2.5.0

(continued from previous page)

Thread.__init__(self)
[Link](True)

def run(self):
""" Run the network reset """
[Link]("/etc/init.d/networking restart")

4.37. Gui Common Example 143

PyModbus Documentation, Release 2.5.0

144 Chapter 4. Examples

CHAPTER 5

Pymodbus

5.1 pymodbus package

5.1.1 Pymodbus: Modbus Protocol Implementation

TwistedModbus is built on top of the code developed by:

Copyright (c) 2001-2005 S.W.A.C. GmbH, Germany. Copyright (c) 2001-2005 S.W.A.C. Bohemia s.r.o.,
Czech Republic. Hynek Petrak <hynek@[Link]>
Released under the the BSD license

5.1.2 Subpackages

[Link] package

Subpackages

[Link] package

Async Modbus Client implementation based on Twisted, tornado and asyncio

Example run:

from [Link] import schedulers

# Import The clients

from [Link] import AsyncModbusTCPClient as Client

from [Link] import AsyncModbusSerialClient as Client
from [Link] import AsyncModbusUDPClient as Client
(continues on next page)

145
PyModbus Documentation, Release 2.5.0

(continued from previous page)

# For tornado based asynchronous client use

event_loop, future = Client(schedulers.IO_LOOP, port=5020)

# For twisted based asynchronous client use

event_loop, future = Client([Link], port=5020)

# For asyncio based asynchronous client use

event_loop, client = Client(schedulers.ASYNC_IO, port=5020)

# Here event_loop is a thread which would control the backend and future is
# a Future/deffered object which would be used to
# add call backs to run asynchronously.

# The Actual client could be accessed with [Link]() with Tornado

# and [Link] when using twisted

# For asyncio the actual client is returned and event loop is asyncio loop

Subpackages

[Link] package

Submodules

[Link] module

Factory to create asynchronous serial clients based on twisted/tornado/asyncio

[Link].async_io_factory(port=None,
framer=None,
**kwargs)
Factory to create asyncio based asynchronous serial clients :param port: Serial port :param framer: Modbus
Framer :param kwargs: Serial port options :return: asyncio event loop and serial client
[Link].get_factory(scheduler)
Gets protocol factory based on the backend scheduler being used :param scheduler: REAC-
TOR/IO_LOOP/ASYNC_IO :return:
[Link].io_loop_factory(port=None,
framer=None,
**kwargs)
Factory to create Tornado based asynchronous serial clients :param port: Serial port :param framer: Modbus
Framer :param kwargs: :return: event_loop_thread and tornado future
[Link].reactor_factory(port, framer,
**kwargs)
Factory to create twisted serial asynchronous client :param port: Serial port :param framer: Modbus Framer
:param kwargs: :return: event_loop_thread and twisted serial client

146 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

[Link] module

Factory to create asynchronous tcp clients based on twisted/tornado/asyncio

[Link].async_io_factory(host=’[Link]’,
port=502,
framer=None,
source_address=None,
timeout=None,
**kwargs)
Factory to create asyncio based asynchronous tcp clients :param host: Host IP address :param port: Port :param
framer: Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds :param
kwargs: :return: asyncio event loop and tcp client
[Link].get_factory(scheduler)
Gets protocol factory based on the backend scheduler being used :param scheduler: REAC-
TOR/IO_LOOP/ASYNC_IO :return
[Link].io_loop_factory(host=’[Link]’,
port=502, framer=None,
source_address=None,
timeout=None,
**kwargs)
Factory to create Tornado based asynchronous tcp clients :param host: Host IP address :param port: Port :param
framer: Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds :param
kwargs: :return: event_loop_thread and tornado future
[Link].reactor_factory(host=’[Link]’,
port=502, framer=None,
source_address=None,
timeout=None,
**kwargs)
Factory to create twisted tcp asynchronous client :param host: Host IP address :param port: Port :param framer:
Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds :param kwargs:
:return: event_loop_thread and twisted_deferred

[Link] module

[Link].async_io_factory(host=’[Link]’,
port=502,
framer=None,
source_address=None,
timeout=None,
**kwargs)
Factory to create asyncio based asynchronous udp clients :param host: Host IP address :param port: Port :param
framer: Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds :param
kwargs: :return: asyncio event loop and udp client
[Link].get_factory(scheduler)
Gets protocol factory based on the backend scheduler being used :param scheduler: REAC-
TOR/IO_LOOP/ASYNC_IO :return
[Link].io_loop_factory(host=’[Link]’,
port=502, framer=None,
source_address=None,
timeout=None,
**kwargs)

5.1. pymodbus package 147

PyModbus Documentation, Release 2.5.0

Factory to create Tornado based asynchronous udp clients :param host: Host IP address :param port: Port
:param framer: Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds
:param kwargs: :return: event_loop_thread and tornado future
[Link].reactor_factory(host=’[Link]’,
port=502, framer=None,
source_address=None,
timeout=None,
**kwargs)
Factory to create twisted udp asynchronous client :param host: Host IP address :param port: Port :param framer:
Modbus Framer :param source_address: Bind address :param timeout: Timeout in seconds :param kwargs:
:return: event_loop_thread and twisted_deferred

[Link] package

Backend schedulers to use with generic Async clients

[Link] package

Asynchronous framework adapter for tornado.

class [Link](*args,
**kwargs)
Bases: [Link]
Tornado based asynchronous serial client
connect()
Connect to the socket identified by host and port
Returns Future
Return type [Link]
execute(request)
Executes a transaction :param request: Request to be written on to the bus :return:
get_socket()
Creates Pyserial object :return: serial object
class [Link](*args,
**kwargs)
Bases: [Link]
Tornado based Async tcp client
get_socket()
Creates socket object :return: socket
class [Link](*args,
**kwargs)
Bases: [Link]
Tornado based Async UDP client
get_socket()
Create socket object :return: socket
class [Link](*args, **kwargs)
Bases: [Link]

148 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Base Tornado client

close()
Closes the underlying IOStream
connect()
Connect to the socket identified by host and port
Returns Future
Return type [Link]
execute(request=None)
Executes a transaction :param request: :return:
get_socket()
return instance of the socket to connect to
io_loop = None
on_receive(*args)
On data recieve call back :param args: data received :return:
stream = None
class [Link](*args,
**kwargs)
Bases: [Link]
Base Tonado serial client
close()
Closes the underlying IOStream
execute(request=None)
Executes a transaction :param request: Request to be written on to the bus :return:
get_socket()
return instance of the socket to connect to
io_loop = None
on_receive(*args)
stream = None
class [Link](connection, *args,
**kwargs)
Bases: [Link]
Serial IO Stream class to control and handle serial connections over tornado
close_fd()
Closes a serial Fd :return:
fileno()
Returns serial fd :return:
read_from_fd()
Reads from a fd :return:
write_to_fd(data)
Writes to a fd :param data: :return:

5.1. pymodbus package 149

PyModbus Documentation, Release 2.5.0

[Link] package

Implementation of a Modbus Client Using Twisted

Example run:

from [Link] import reactor, protocol

from [Link] import ModbusClientProtocol

def printResult(result):
print "Result: %d" % [Link][0]

def process(client):
result = client.write_coil(1, True)
[Link](printResult)
[Link](1, [Link])

defer = [Link](reactor, ModbusClientProtocol

).connectTCP("localhost", 502)
[Link](process)

Another example:

from [Link] import reactor

from [Link] import ModbusClientFactory

def process():
factory = [Link]("localhost", 502, ModbusClientFactory())
[Link]()

if __name__ == "__main__":
[Link](1, process)
[Link]()

class [Link](framer=None,
**kwargs)
Bases: [Link], [Link].
[Link]
This represents the base modbus client protocol. All the application layer code is deferred to a higher level
wrapper.
close()
Closes underlying transport layer ,essentially closing the client :return:
connectionLost(reason=None)
Called upon a client disconnect
Parameters reason – The reason for the disconnect
connectionMade()
Called upon a successful client connection.
dataReceived(data)
Get response, check for valid message, decode result
Parameters data – The data returned from the server
execute(request)
Starts the producer to send the next request to [Link](Frame(request))

150 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

framer = None
class [Link](host=’[Link]’,
port=502,
framer=None,
source_address=None,
time-
out=None,
**kwargs)
Bases: [Link], [Link].
[Link]
This represents the base modbus client protocol. All the application layer code is deferred to a higher level
wrapper.
datagramReceived(data, params)
Get response, check for valid message, decode result
Parameters
• data – The data returned from the server
• params – The host parameters sending the datagram
execute(request)
Starts the producer to send the next request to [Link](Frame(request))
class [Link]
Bases: [Link]
Simple client protocol factory
protocol
alias of ModbusClientProtocol

Submodules

[Link] module

class [Link]
Bases: object
Actual Async Serial Client to be used.
To use do:

from [Link] import AsyncModbusSerialClient

[Link] module

class [Link]
Bases: object
Actual Async Serial Client to be used.
To use do:

from [Link] import AsyncModbusTCPClient

5.1. pymodbus package 151

PyModbus Documentation, Release 2.5.0

[Link] module

class [Link]
Bases: object
Actual Async UDP Client to be used.
To use do:

from [Link] import AsyncModbusUDPClient

Submodules

[Link] module

Modbus Client Common

This is a common client mixin that can be used by both the synchronous and asynchronous clients to simplify the
interface.
class [Link]
Bases: object
This is a modbus client mixin that provides additional factory methods for all the current modbus methods. This
can be used instead of the normal pattern of:

# instead of this
client = ModbusClient(...)
request = ReadCoilsRequest(1,10)
response = [Link](request)

# now like this

client = ModbusClient(...)
response = client.read_coils(1, 10)

last_frame_end = 0
mask_write_register(*args, **kwargs)
Parameters
• address – The address of the register to write

152 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

• and_mask – The and bitmask to apply to the register address

• or_mask – The or bitmask to apply to the register address
• unit – The slave unit this request is targeting
Returns A deferred response handle
read_coils(address, count=1, **kwargs)
Parameters
• address – The starting address to read from
• count – The number of coils to read
• unit – The slave unit this request is targeting
Returns A deferred response handle
read_discrete_inputs(address, count=1, **kwargs)
Parameters
• address – The starting address to read from
• count – The number of discretes to read
• unit – The slave unit this request is targeting
Returns A deferred response handle
read_holding_registers(address, count=1, **kwargs)
Parameters
• address – The starting address to read from
• count – The number of registers to read
• unit – The slave unit this request is targeting
Returns A deferred response handle
read_input_registers(address, count=1, **kwargs)
Parameters
• address – The starting address to read from
• count – The number of registers to read
• unit – The slave unit this request is targeting
Returns A deferred response handle
readwrite_registers(*args, **kwargs)
Parameters
• read_address – The address to start reading from
• read_count – The number of registers to read from address
• write_address – The address to start writing to
• write_registers – The registers to write to the specified address
• unit – The slave unit this request is targeting
Returns A deferred response handle

5.1. pymodbus package 153

PyModbus Documentation, Release 2.5.0

silent_interval = 0
state = 0
write_coil(address, value, **kwargs)
Parameters
• address – The starting address to write to
• value – The value to write to the specified address
• unit – The slave unit this request is targeting
Returns A deferred response handle
write_coils(address, values, **kwargs)
Parameters
• address – The starting address to write to
• values – The values to write to the specified address
• unit – The slave unit this request is targeting
Returns A deferred response handle
write_register(address, value, **kwargs)
Parameters
• address – The starting address to write to
• value – The value to write to the specified address
• unit – The slave unit this request is targeting
Returns A deferred response handle
write_registers(address, values, **kwargs)
Parameters
• address – The starting address to write to
• values – The values to write to the specified address
• unit – The slave unit this request is targeting
Returns A deferred response handle

[Link] module

154 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Returns True if connection succeeded, False otherwise

is_socket_open()
Check whether the underlying socket/serial is open or not.
Returns True if socket/serial is open, False otherwise
class [Link](host=’localhost’, port=802,
sslctx=None, framer=<class ’pymod-
[Link].tls_framer.ModbusTlsFramer’>,
**kwargs)
Bases: [Link]
Implementation of a modbus tls client
connect()
Connect to the modbus tls server
Returns True if connection succeeded, False otherwise
class [Link](host=’[Link]’, port=502,
framer=<class ’pymod-
[Link].socket_framer.ModbusSocketFramer’>,
**kwargs)
Bases: [Link]
Implementation of a modbus udp client
close()
Closes the underlying socket connection
connect()
Connect to the modbus tcp server
Returns True if connection succeeded, False otherwise
is_socket_open()
Check whether the underlying socket/serial is open or not.
Returns True if socket/serial is open, False otherwise
class [Link](method=’ascii’, **kwargs)
Bases: [Link]
Implementation of a modbus serial client
close()
Closes the underlying socket connection
connect()
Connect to the modbus serial server
Returns True if connection succeeded, False otherwise
inter_char_timeout = 0
is_socket_open()
Check whether the underlying socket/serial is open or not.
Returns True if socket/serial is open, False otherwise
silent_interval = 0
state = 0

5.1. pymodbus package 155

PyModbus Documentation, Release 2.5.0

[Link] package

class [Link](address, values)

Bases: [Link]
Creates a sequential modbus datastore
classmethod create()
Factory method to create a datastore with the full address space initialized to 0x00
Returns An initialized datastore
getValues(address, count=1)
Returns the requested values of the datastore
Parameters
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
setValues(address, values)
Sets the requested values of the datastore
Parameters
• address – The starting address
• values – The new values to be set
validate(address, count=1)
Checks to see if the request is in range
Parameters
• address – The starting address
• count – The number of values to test for
Returns True if the request in within range, False otherwise
class [Link](values=None, mutable=True)
Bases: [Link]
Creates a sparse modbus datastore
E.g Usage. sparse = ModbusSparseDataBlock({10: [3, 5, 6, 8], 30: 1, 40: [0]*20})
This would create a datablock with 3 blocks starting at offset 10 with length 4 , 30 with length 1 and 40 with
length 20
sparse = ModbusSparseDataBlock([10]*100) Creates a sparse datablock of length 100 starting at offset 0 and
default value of 10
sparse = ModbusSparseDataBlock() –> Create Empty datablock [Link](0, [10]*10) –> Add block 1 at
offset 0 with length 10 (default value 10) [Link](30, [20]*5) –> Add block 2 at offset 30 with length 5
(default value 20)
if mutable is set to True during initialization, the datablock can not be altered with setValues (new datablocks
can not be added)
classmethod create(values=None)
Factory method to create sparse datastore. Use setValues to initialize registers.
Parameters values – Either a list or a dictionary of values

156 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Returns An initialized datastore

getValues(address, count=1)
Returns the requested values of the datastore
Parameters
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Reset the store to the intially provided defaults
setValues(address, values, use_as_default=False)
Sets the requested values of the datastore
Parameters
• address – The starting address
• values – The new values to be set
• use_as_default – Use the values as default
validate(address, count=1)
Checks to see if the request is in range
Parameters
• address – The starting address
• count – The number of values to test for
Returns True if the request in within range, False otherwise
class [Link](*args, **kwargs)
Bases: [Link]
This creates a modbus data model with each data access stored in its own personal block
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
register(fc, fx, datablock=None)
Registers a datablock with the slave context :param fc: function code (int) :param fx: string representation
of function code (e.g ‘cf’ ) :param datablock: datablock to associate with this function code :return:
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters

5.1. pymodbus package 157

PyModbus Documentation, Release 2.5.0

• fx – The function we are working with

• address – The starting address
• values – The new values to be set
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise
class [Link](slaves=None, single=True)
Bases: object
This represents a master collection of slave contexts. If single is set to true, it will be treated as a single context
so every unit-id returns the same context. If single is set to false, it will be interpreted as a collection of slave
contexts.
slaves()

Subpackages

[Link] package

class [Link](*args, **kwargs)

Bases: [Link]
This creates a modbus data model with each data access stored in its own personal block
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values, update=True)
Sets the datastore with the supplied values
Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
• update – Update existing register in the db

158 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

validate(fx, address, count=1)

Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise
class [Link](**kwargs)
Bases: [Link]
This is a modbus slave context using redis as a backing store.
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise

Submodules

[Link].redis_datastore module

class [Link].redis_datastore.RedisSlaveContext(**kwargs)
Bases: [Link]
This is a modbus slave context using redis as a backing store.

5.1. pymodbus package 159

PyModbus Documentation, Release 2.5.0

getValues(fx, address, count=1)

Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise

[Link].sql_datastore module

class [Link].sql_datastore.SqlSlaveContext(*args,
**kwargs)
Bases: [Link]
This creates a modbus data model with each data access stored in its own personal block
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values, update=True)
Sets the datastore with the supplied values

160 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
• update – Update existing register in the db
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise

Submodules

[Link] module

class [Link](slaves=None, single=True)

Bases: object
This represents a master collection of slave contexts. If single is set to true, it will be treated as a single context
so every unit-id returns the same context. If single is set to false, it will be interpreted as a collection of slave
contexts.
slaves()
class [Link](*args, **kwargs)
Bases: [Link]
This creates a modbus data model with each data access stored in its own personal block
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
register(fc, fx, datablock=None)
Registers a datablock with the slave context :param fc: function code (int) :param fx: string representation
of function code (e.g ‘cf’ ) :param datablock: datablock to associate with this function code :return:
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters

5.1. pymodbus package 161

PyModbus Documentation, Release 2.5.0

• fx – The function we are working with

[Link] module

class [Link](client, unit=None)

Bases: [Link]
TODO This creates a modbus data model that connects to a remote device (depending on the client used)
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise

162 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

[Link] module

Modbus Server Datastore

For each server, you will create a ModbusServerContext and pass in the default address space for each data access.
The class will create and manage the data.
Further modification of said data accesses should be performed with [get,set][access]Values(address, count)

Datastore Implementation

There are two ways that the server datastore can be implemented. The first is a complete range from ‘address’ start to
‘count’ number of indecies. This can be thought of as a straight array:

data = range(1, 1 + count)

[1,2,3,...,count]

The other way that the datastore can be implemented (and how many devices implement it) is a associate-array:

data = {1:'1', 3:'3', ..., count:'count'}

[1,3,...,count]

The difference between the two is that the latter will allow arbitrary gaps in its datastore while the former will not.
This is seen quite commonly in some modbus implementations. What follows is a clear example from the field:
Say a company makes two devices to monitor power usage on a rack. One works with three-phase and the other with
a single phase. The company will dictate a modbus data mapping such that registers:

n: phase 1 power
n+1: phase 2 power
n+2: phase 3 power

Using this, layout, the first device will implement n, n+1, and n+2, however, the second device may set the latter two
values to 0 or will simply not implmented the registers thus causing a single read or a range read to fail.
I have both methods implemented, and leave it up to the user to change based on their preference.
class [Link]
Bases: object
Base class for a modbus datastore
Derived classes must create the following fields: @address The starting address point @defult_value The de-
fault value of the datastore @values The actual datastore values
Derived classes must implemented the following methods: validate(self, address, count=1) getValues(self,
address, count=1) setValues(self, address, values)
default(count, value=False)
Used to initialize a store to one value
Parameters
• count – The number of fields to set
• value – The default value to set to the fields
getValues(address, count=1)
Returns the requested values from the datastore

5.1. pymodbus package 163

PyModbus Documentation, Release 2.5.0

Parameters
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets the datastore to the initialized default value
setValues(address, values)
Returns the requested values from the datastore
Parameters
• address – The starting address
• values – The values to store
validate(address, count=1)
Checks to see if the request is in range
Parameters
• address – The starting address
• count – The number of values to test for
Returns True if the request in within range, False otherwise
class [Link](address, values)
Bases: [Link]
Creates a sequential modbus datastore
classmethod create()
Factory method to create a datastore with the full address space initialized to 0x00
Returns An initialized datastore
getValues(address, count=1)
Returns the requested values of the datastore
Parameters
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
setValues(address, values)
Sets the requested values of the datastore
Parameters
• address – The starting address
• values – The new values to be set
validate(address, count=1)
Checks to see if the request is in range
Parameters
• address – The starting address
• count – The number of values to test for

164 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Returns True if the request in within range, False otherwise

class [Link](values=None, mutable=True)
Bases: [Link]
Creates a sparse modbus datastore
E.g Usage. sparse = ModbusSparseDataBlock({10: [3, 5, 6, 8], 30: 1, 40: [0]*20})
This would create a datablock with 3 blocks starting at offset 10 with length 4 , 30 with length 1 and 40 with
length 20
sparse = ModbusSparseDataBlock([10]*100) Creates a sparse datablock of length 100 starting at offset 0 and
default value of 10
sparse = ModbusSparseDataBlock() –> Create Empty datablock [Link](0, [10]*10) –> Add block 1 at
offset 0 with length 10 (default value 10) [Link](30, [20]*5) –> Add block 2 at offset 30 with length 5
(default value 20)
if mutable is set to True during initialization, the datablock can not be altered with setValues (new datablocks
can not be added)
classmethod create(values=None)
Factory method to create sparse datastore. Use setValues to initialize registers.
Parameters values – Either a list or a dictionary of values
Returns An initialized datastore
getValues(address, count=1)
Returns the requested values of the datastore
Parameters
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Reset the store to the intially provided defaults
setValues(address, values, use_as_default=False)
Sets the requested values of the datastore
Parameters
• address – The starting address
• values – The new values to be set
• use_as_default – Use the values as default
validate(address, count=1)
Checks to see if the request is in range
Parameters
• address – The starting address
• count – The number of values to test for
Returns True if the request in within range, False otherwise

5.1. pymodbus package 165

PyModbus Documentation, Release 2.5.0

[Link] package

Submodules

[Link].ascii_framer module

class [Link].ascii_framer.ModbusAsciiFramer(decoder, client=None)

Bases: [Link]
Modbus ASCII Frame Controller:

[ Start ][Address ][ Function ][ Data ][ LRC ][ End ]

1c 2c 2c Nc 2c 2c

* data can be 0 - 2x252 chars

* end is '\r\n' (Carriage return line feed), however the line feed
character can be changed via a special command
* start is ':'

This framer is used for serial transmission. Unlike the RTU protocol, the data in this framer is transferred in
plain text ascii.
addToFrame(message)
Add the next message to the frame buffer This should be used before the decoding while loop to add the
received data to the buffer handle.
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet Built off of a modbus request/response
Parameters message – The request/response to send
Returns The encoded packet
checkFrame()
Check and decode the next frame
Returns True if we successful, False otherwise
decode_data(data)
getFrame()
Get the next frame from the buffer
Returns The frame data or ‘’
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result header
The serial packets do not have any header information that is copied.

166 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Parameters result – The response packet

processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server))
• single – True or False (If True, ignore unit address validation)
resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).

[Link].binary_framer module

class [Link].binary_framer.ModbusBinaryFramer(decoder, client=None)

Bases: [Link]
Modbus Binary Frame Controller:

[ Start ][Address ][ Function ][ Data ][ CRC ][ End ]

1b 1b 1b Nb 2b 1b

* data can be 0 - 2x252 chars

* end is '}'
* start is '{'

The idea here is that we implement the RTU protocol, however, instead of using timing for message delimiting,
we use start and end of message characters (in this case { and }). Basically, this is a binary framer.
The only case we have to watch out for is when a message contains the { or } characters. If we encounter these
characters, we simply duplicate them. Hopefully we will not encounter those characters that often and will save
a little bit of bandwitch without a real-time system.
Protocol defined by [Link].
addToFrame(message)
Add the next message to the frame buffer This should be used before the decoding while loop to add the
received data to the buffer handle.
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet

5.1. pymodbus package 167

PyModbus Documentation, Release 2.5.0

Parameters message – The request/response to send

Returns The encoded packet
checkFrame()
Check and decode the next frame
Returns True if we are successful, False otherwise
decode_data(data)
getFrame()
Get the next frame from the buffer
Returns The frame data or ‘’
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).

[Link].rtu_framer module

class [Link].rtu_framer.ModbusRtuFramer(decoder, client=None)

Bases: [Link]
Modbus RTU Frame controller:

[ Start Wait ] [Address ][ Function Code] [ Data ][ CRC ][ End Wait ]

3.5 chars 1b 1b Nb 2b 3.5 chars

168 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Wait refers to the amount of time required to transmit at least x many characters. In this case it is 3.5 characters.
Also, if we receive a wait of 1.5 characters at any point, we must trigger an error message. Also, it appears as
though this message is little endian. The logic is simplified as the following:

block-on-read:
read until 3.5 delay
check for errors
decode

The following table is a listing of the baud wait times for the specified baud rates:

------------------------------------------------------------------
Baud 1.5c (18 bits) 3.5c (38 bits)
------------------------------------------------------------------
1200 13333.3 us 31666.7 us
4800 3333.3 us 7916.7 us
9600 1666.7 us 3958.3 us
19200 833.3 us 1979.2 us
38400 416.7 us 989.6 us
------------------------------------------------------------------
1 Byte = start + 8 bits + parity + stop = 11 bits
(1/Baud)(bits) = delay seconds

addToFrame(message)
This should be used before the decoding while loop to add the received data to the buffer handle.
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet
Parameters message – The populated request/response to send
checkFrame()
Check if the next frame is available. Return True if we were successful.
1. Populate header
2. Discard frame if UID does not match
decode_data(data)
getFrame()
Get the next frame from the buffer
Returns The frame data or ‘’
getRawFrame()
Returns the complete buffer
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder know that there is still data in the buffer.
Returns True if ready, False otherwise
populateHeader(data=None)
Try to set the headers uid, len and crc.

5.1. pymodbus package 169

PyModbus Documentation, Release 2.5.0

This method examines self._buffer and writes meta information into self._header.
Beware that this method will raise an IndexError if self._buffer is not yet long enough.
populateResult(result)
Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
recvPacket(size)
Receives packet from the bus with specified len :param size: Number of bytes to read :return:
resetFrame()
Reset the entire message frame. This allows us to skip over errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).
sendPacket(message)
Sends packets on the bus with 3.5char delay between frames :param message: Message to be sent over the
bus :return:

[Link].socket_framer module

class [Link].socket_framer.ModbusSocketFramer(decoder, client=None)

Bases: [Link]
Modbus Socket Frame controller
Before each modbus TCP message is an MBAP header which is used as a message frame. It allows us to easily
separate messages as follows:
[ MBAP Header ] [ Function Code] [ Data ] [ tid ][ pid ][
˓→ length ][ uid ]
2b 2b 2b 1b 1b Nb

while len(message) > 0:

tid, pid, length`, uid = [Link](">HHHB", message)
request = message[0:7 + length - 1`]
message = [7 + length - 1:]

(continues on next page)

170 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

(continued from previous page)

* length = uid + function code + data
* The -1 is to account for the uid byte

addToFrame(message)
Adds new packet data to the current frame buffer
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet
Parameters message – The populated request/response to send
checkFrame()
Check and decode the next frame Return true if we were successful
decode_data(data)
getFrame()
Return the next frame from the buffered data
Returns The next full frame buffer
getRawFrame()
Returns the complete buffer
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder factory know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result with the transport specific header information (pid, tid, uid, checksum, etc)
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
Returns

5.1. pymodbus package 171

PyModbus Documentation, Release 2.5.0

resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).

Module contents

class [Link]
Bases: [Link]
Base Framer class
recvPacket(size)
Receives packet from the bus with specified len :param size: Number of bytes to read :return:
sendPacket(message)
Sends packets on the bus with 3.5char delay between frames :param message: Message to be sent over the
bus :return:

[Link] package

Submodules

[Link] module

A collection of twisted utility code

[Link](namespace, users={’admin’:
’admin’}, port=503)
Helper method to start an ssh management console for the modbus server.

Parameters
• namespace – The data to constrain the server to
• users – The users to login with
• port – The port to host the server on

[Link] package

Submodules

[Link] module

Implementation of a Twisted Modbus Server

[Link](context, identity=None, address=None, con-

sole=False, defer_reactor_run=False, cus-
tom_functions=[], **kwargs)
Helper method to start the Modbus Async TCP server
Parameters

172 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

• context – The server data context

• identify – The server identity to use (default empty)
• address – An optional (interface, port) to bind to.
• console – A flag indicating if you want the debug console
• ignore_missing_slaves – True to not send errors on a request to a missing slave
• defer_reactor_run – True/False defer running [Link]() as part of starting server,
to be explictly started by the user
• custom_functions – An optional list of custom function classes supported by server
instance.
[Link](context, identity=None, address=None,
defer_reactor_run=False, cus-
tom_functions=[], **kwargs)
Helper method to start the Modbus Async Udp server
Parameters
• context – The server data context
• identify – The server identity to use (default empty)
• address – An optional (interface, port) to bind to.
• ignore_missing_slaves – True to not send errors on a request to a missing slave
• defer_reactor_run – True/False defer running [Link]() as part of starting server,
to be explictly started by the user
• custom_functions – An optional list of custom function classes supported by server
instance.
[Link](context, identity=None,
framer=<class ’pymod-
[Link].ascii_framer.ModbusAsciiFramer’>,
defer_reactor_run=False, cus-
tom_functions=[], **kwargs)
Helper method to start the Modbus Async Serial server
Parameters
• context – The server data context
• identify – The server identity to use (default empty)
• framer – The framer to use (default ModbusAsciiFramer)
• port – The serial port to attach to
• baudrate – The baud rate to use for the serial device
• console – A flag indicating if you want the debug console
• ignore_missing_slaves – True to not send errors on a request to a missing slave
• defer_reactor_run – True/False defer running [Link]() as part of starting server,
to be explictly started by the user
• custom_functions – An optional list of custom function classes supported by server
instance.

5.1. pymodbus package 173

PyModbus Documentation, Release 2.5.0

[Link]()
Helper method to stop Async Server

[Link] module

Implementation of a Threaded Modbus Server

[Link](context=None, identity=None, address=None, cus-

tom_functions=[], **kwargs)
A factory to start and run a tcp modbus server
Parameters
• context – The ModbusServerContext datastore
• identity – An optional identify structure
• address – An optional (interface, port) to bind to.
• custom_functions – An optional list of custom function classes supported by server
instance.
• ignore_missing_slaves – True to not send errors on a request to a missing slave
[Link](context=None, identity=None, address=None,
sslctx=None, certfile=None, keyfile=None, cus-
tom_functions=[], **kwargs)
A factory to start and run a tls modbus server
Parameters
• context – The ModbusServerContext datastore
• identity – An optional identify structure
• address – An optional (interface, port) to bind to.
• sslctx – The SSLContext to use for TLS (default None and auto create)
• certfile – The cert file path for TLS (used if sslctx is None)
• keyfile – The key file path for TLS (used if sslctx is None)
• custom_functions – An optional list of custom function classes supported by server
instance.
• ignore_missing_slaves – True to not send errors on a request to a missing slave
[Link](context=None, identity=None, address=None, cus-
tom_functions=[], **kwargs)
A factory to start and run a udp modbus server
Parameters
• context – The ModbusServerContext datastore
• identity – An optional identify structure
• address – An optional (interface, port) to bind to.
• custom_functions – An optional list of custom function classes supported by server
instance.
• framer – The framer to operate with (default ModbusSocketFramer)

174 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

• ignore_missing_slaves – True to not send errors on a request to a missing slave

[Link](context=None, identity=None, custom_functions=[],
**kwargs)
A factory to start and run a serial modbus server
Parameters
• context – The ModbusServerContext datastore
• identity – An optional identify structure
• custom_functions – An optional list of custom function classes supported by server
instance.
• framer – The framer to operate with (default ModbusAsciiFramer)
• port – The serial port to attach to
• stopbits – The number of stop bits to use
• bytesize – The bytesize of the serial messages
• parity – Which kind of parity to use
• baudrate – The baud rate to use for the serial device
• timeout – The timeout to use for the serial device
• ignore_missing_slaves – True to not send errors on a request to a missing slave

[Link] package

Pymodbus REPL Module.

Submodules

[Link] module

5.1.3 Submodules

5.1.4 pymodbus.bit_read_message module

5.1. pymodbus package 175

PyModbus Documentation, Release 2.5.0

Bit Reading Request/Response messages

class pymodbus.bit_read_message.ReadCoilsRequest(address=None, count=None,

**kwargs)
Bases: pymodbus.bit_read_message.ReadBitsRequestBase
This function code is used to read from 1 to 2000(0x7d0) contiguous status of coils in a remote device. The
Request PDU specifies the starting address, ie the address of the first coil specified, and the number of coils. In
the PDU Coils are addressed starting at zero. Therefore coils numbered 1-16 are addressed as 0-15.
execute(context)
Run a read coils request against a datastore
Before running the request, we make sure that the request is in the max valid range (0x001-0x7d0). Next
we make sure that the request is valid against the current datastore.
Parameters context – The datastore to request from
Returns The initializes response message, exception message otherwise
function_code = 1
class pymodbus.bit_read_message.ReadCoilsResponse(values=None, **kwargs)
Bases: pymodbus.bit_read_message.ReadBitsResponseBase
The coils in the response message are packed as one coil per bit of the data field. Status is indicated as 1= ON
and 0= OFF. The LSB of the first data byte contains the output addressed in the query. The other coils follow
toward the high order end of this byte, and from low order to high order in subsequent bytes.
If the returned output quantity is not a multiple of eight, the remaining bits in the final data byte will be padded
with zeros (toward the high order end of the byte). The Byte Count field specifies the quantity of complete bytes
of data.
function_code = 1
class pymodbus.bit_read_message.ReadDiscreteInputsRequest(address=None,
count=None,
**kwargs)
Bases: pymodbus.bit_read_message.ReadBitsRequestBase
This function code is used to read from 1 to 2000(0x7d0) contiguous status of discrete inputs in a remote device.
The Request PDU specifies the starting address, ie the address of the first input specified, and the number of
inputs. In the PDU Discrete Inputs are addressed starting at zero. Therefore Discrete inputs numbered 1-16 are
addressed as 0-15.
execute(context)
Run a read discrete input request against a datastore
Before running the request, we make sure that the request is in the max valid range (0x001-0x7d0). Next
we make sure that the request is valid against the current datastore.
Parameters context – The datastore to request from
Returns The initializes response message, exception message otherwise
function_code = 2
class pymodbus.bit_read_message.ReadDiscreteInputsResponse(values=None,
**kwargs)
Bases: pymodbus.bit_read_message.ReadBitsResponseBase
The discrete inputs in the response message are packed as one input per bit of the data field. Status is indicated
as 1= ON; 0= OFF. The LSB of the first data byte contains the input addressed in the query. The other inputs
follow toward the high order end of this byte, and from low order to high order in subsequent bytes.

176 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

If the returned input quantity is not a multiple of eight, the remaining bits in the final data byte will be padded
with zeros (toward the high order end of the byte). The Byte Count field specifies the quantity of complete bytes
of data.
function_code = 2

5.1.5 pymodbus.bit_write_message module

Bit Writing Request/Response

TODO write mask request/response

class pymodbus.bit_write_message.WriteSingleCoilRequest(address=None,
value=None, **kwargs)
Bases: [Link]
This function code is used to write a single output to either ON or OFF in a remote device.
The requested ON/OFF state is specified by a constant in the request data field. A value of FF 00 hex requests
the output to be ON. A value of 00 00 requests it to be OFF. All other values are illegal and will not affect the
output.
The Request PDU specifies the address of the coil to be forced. Coils are addressed starting at zero. Therefore
coil numbered 1 is addressed as 0. The requested ON/OFF state is specified by a constant in the Coil Value field.
A value of 0XFF00 requests the coil to be ON. A value of 0X0000 requests the coil to be off. All other values
are illegal and will not affect the coil.
decode(data)
Decodes a write coil request
Parameters data – The packet data to decode
encode()
Encodes write coil request
Returns The byte encoded message
execute(context)
Run a write coil request against a datastore
Parameters context – The datastore to request from
Returns The populated response or exception message
function_code = 5
get_response_pdu_size()
Func_code (1 byte) + Output Address (2 byte) + Output Value (2 Bytes) :return:
class pymodbus.bit_write_message.WriteSingleCoilResponse(address=None,
value=None, **kwargs)
Bases: [Link]
The normal response is an echo of the request, returned after the coil state has been written.
decode(data)
Decodes a write coil response
Parameters data – The packet data to decode
encode()
Encodes write coil response

5.1. pymodbus package 177

PyModbus Documentation, Release 2.5.0

Returns The byte encoded message

function_code = 5
class pymodbus.bit_write_message.WriteMultipleCoilsRequest(address=None, val-
ues=None, **kwargs)
Bases: [Link]
“This function code is used to force each coil in a sequence of coils to either ON or OFF in a remote device.
The Request PDU specifies the coil references to be forced. Coils are addressed starting at zero. Therefore coil
numbered 1 is addressed as 0.
The requested ON/OFF states are specified by contents of the request data field. A logical ‘1’ in a bit position
of the field requests the corresponding output to be ON. A logical ‘0’ requests it to be OFF.”
decode(data)
Decodes a write coils request
Parameters data – The packet data to decode
encode()
Encodes write coils request
Returns The byte encoded message
execute(context)
Run a write coils request against a datastore
Parameters context – The datastore to request from
Returns The populated response or exception message
function_code = 15
get_response_pdu_size()
Func_code (1 byte) + Output Address (2 byte) + Quantity of Outputs (2 Bytes) :return:
class pymodbus.bit_write_message.WriteMultipleCoilsResponse(address=None,
count=None,
**kwargs)
Bases: [Link]
The normal response returns the function code, starting address, and quantity of coils forced.
decode(data)
Decodes a write coils response
Parameters data – The packet data to decode
encode()
Encodes write coils response
Returns The byte encoded message
function_code = 15

5.1.6 [Link] module

Python 2.x/3.x Compatibility Layer

This is mostly based on the jinja2 compat code:

Some py2/py3 compatibility support based on a stripped down version of six so we don’t have to depend
on a specific version of it.

178 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

license BSD, see LICENSE for details.
[Link].byte2int(b)
[Link].implements_to_string(x)
[Link].int2byte()
[Link](v1, v2, . . . ) -> bytes
Return a bytes object containing values v1, v2, . . . packed according to the format string [Link]. See
help(struct) for more on format strings.
[Link].is_installed(module)

5.1.7 [Link] module

Constants For Modbus Server/Client

This is the single location for storing default values for the servers and clients.
class [Link]
Bases: [Link]
A collection of modbus default values
Port
The default modbus tcp server port (502)
TLSPort
The default modbus tcp over tls server port (802)
Backoff
The default exponential backoff delay (0.3 seconds)
Retries
The default number of times a client should retry the given request before failing (3)
RetryOnEmpty
A flag indicating if a transaction should be retried in the case that an empty response is received. This is
useful for slow clients that may need more time to process a request.
RetryOnInvalid
A flag indicating if a transaction should be retried in the case that an invalid response is received.
Timeout
The default amount of time a client should wait for a request to be processed (3 seconds)
Reconnects
The default number of times a client should attempt to reconnect before deciding the server is down (0)
TransactionId
The starting transaction identifier number (0)
ProtocolId
The modbus protocol id. Currently this is set to 0 in all but proprietary implementations.
UnitId
The modbus slave addrss. Currently this is set to 0x00 which means this request should be broadcast to all
the slave devices (really means that all the devices should respons).

5.1. pymodbus package 179

PyModbus Documentation, Release 2.5.0

Baudrate
The speed at which the data is transmitted over the serial line. This defaults to 19200.
Parity
The type of checksum to use to verify data integrity. This can be on of the following:

- (E)ven - 1 0 1 0 | P(0)
- (O)dd - 1 0 1 0 | P(1)
- (N)one - 1 0 1 0 | no parity

This defaults to (N)one.

Bytesize
The number of bits in a byte of serial data. This can be one of 5, 6, 7, or 8. This defaults to 8.
Stopbits
The number of bits sent after each character in a message to indicate the end of the byte. This defaults to
1.
ZeroMode
Indicates if the slave datastore should use indexing at 0 or 1. More about this can be read in section 4.4 of
the modbus specification.
IgnoreMissingSlaves
In case a request is made to a missing slave, this defines if an error should be returned or simply ignored.
This is useful for the case of a serial server emulater where a request to a non-existant slave on a bus will
never respond. The client in this case will simply timeout.
broadcast_enable
When False unit_id 0 will be treated as any other unit_id. When True and the unit_id is 0 the server
will execute all requests on all server contexts and not respond and the client will skip trying to receive a
response. Default value False does not conform to Modbus spec but maintains legacy behavior for existing
pymodbus users.
Backoff = 0.3
Baudrate = 19200
Bytesize = 8
IgnoreMissingSlaves = False
Parity = 'N'
Port = 502
ProtocolId = 0
ReadSize = 1024
Reconnects = 0
Retries = 3
RetryOnEmpty = False
RetryOnInvalid = False
Stopbits = 1
TLSPort = 802
Timeout = 3
TransactionId = 0

180 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

UnitId = 0
ZeroMode = False
broadcast_enable = False
class [Link]
Bases: [Link]
These represent various status codes in the modbus protocol.
Waiting
This indicates that a modbus device is currently waiting for a given request to finish some running task.
Ready
This indicates that a modbus device is currently free to perform the next request task.
On
This indicates that the given modbus entity is on
Off
This indicates that the given modbus entity is off
SlaveOn
This indicates that the given modbus slave is running
SlaveOff
This indicates that the given modbus slave is not running
Off = 0
On = 65280
Ready = 0
SlaveOff = 0
SlaveOn = 255
Waiting = 65535
class [Link]
Bases: [Link]
An enumeration representing the various byte endianess.
Auto
This indicates that the byte order is chosen by the current native environment.
Big
This indicates that the bytes are in little endian format
Little
This indicates that the bytes are in big endian format

Note: I am simply borrowing the format strings from the python struct module for my convenience.

Auto = '@'
Big = '>'
Little = '<'

5.1. pymodbus package 181

PyModbus Documentation, Release 2.5.0

class [Link]
Bases: [Link]
Represents the type of modbus plus request
GetStatistics
Operation requesting that the current modbus plus statistics be returned in the response.
ClearStatistics
Operation requesting that the current modbus plus statistics be cleared and not returned in the response.
ClearStatistics = 4
GetStatistics = 3
class [Link]
Bases: [Link]
Represents what type of device information to read
Basic
This is the basic (required) device information to be returned. This includes VendorName, ProductCode,
and MajorMinorRevision code.
Regular
In addition to basic data objects, the device provides additional and optinoal identification and description
data objects. All of the objects of this category are defined in the standard but their implementation is
optional.
Extended
In addition to regular data objects, the device provides additional and optional identification and description
private data about the physical device itself. All of these data are device dependent.
Specific
Request to return a single data object.
Basic = 1
Extended = 3
Regular = 2
Specific = 4
class [Link]
Bases: [Link]
Represents the more follows condition
Nothing
This indiates that no more objects are going to be returned.
KeepReading
This indicates that there are more objects to be returned.
KeepReading = 255
Nothing = 0

5.1.8 [Link] module

182 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Modbus Device Controller

These are the device management handlers. They should be maintained in the server context and the various methods
should be inserted in the correct locations.
class [Link]
Bases: [Link]
This is a simple implementation of a Network Management System table. Its purpose is to control access to the
server (if it is used). We assume that if an entry is in the table, it is allowed accesses to resources. However, if
the host does not appear in the table (all unknown hosts) its connection will simply be closed.
Since it is a singleton, only one version can possible exist and all instances pull from here.
add(host)
Add allowed host(s) from the NMS table
Parameters host – The host to add
check(host)
Check if a host is allowed to access resources
Parameters host – The host to check
remove(host)
Remove allowed host(s) from the NMS table
Parameters host – The host to remove
class [Link]
Bases: object
This is used to maintain the current modbus plus statistics count. As of right now this is simply a stub to
complete the modbus implementation. For more information, see the modbus implementation guide page 87.
encode()
Returns a summary of the modbus plus statistics
Returns 54 16-bit words representing the status
reset()
This clears all of the modbus plus statistics
summary()
Returns a summary of the modbus plus statistics
Returns 54 16-bit words representing the status
class [Link](info=None)
Bases: object
This is used to supply the device identification for the readDeviceIdentification function
For more information read section 6.21 of the modbus application protocol.
MajorMinorRevision
ModelName
ProductCode
ProductName
UserApplicationName
VendorName

5.1. pymodbus package 183

PyModbus Documentation, Release 2.5.0

VendorUrl
summary()
Return a summary of the main items
Returns An dictionary of the main items
update(value)
Update the values of this identity using another identify as the value
Parameters value – The value to copy values from
class [Link]
Bases: [Link]
This is a helper factory that really just hides some of the complexity of processing the device information
requests (function code 0x2b 0x0e).
classmethod get(control, read_code=1, object_id=0)
Get the requested device data from the system
Parameters
• control – The control block to pull data from
• read_code – The read code to process
• object_id – The specific object_id to read
Returns The requested data (id, length, value)
class [Link]
Bases: [Link]
This is a global singleotn that controls all system information
All activity should be logged here and all diagnostic requests should come from here.
Counter
Delimiter
Events
Identity
ListenOnly
Mode
Plus
addEvent(event)
Adds a new event to the event log
Parameters event – A new event to add to the log
clearEvents()
Clears the current list of events
getDiagnostic(bit)
This gets the value in the diagnostic register
Parameters bit – The bit to get
Returns The current value of the requested bit

184 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

getDiagnosticRegister()
This gets the entire diagnostic register
Returns The diagnostic register collection
getEvents()
Returns an encoded collection of the event log.
Returns The encoded events packet
reset()
This clears all of the system counters and the diagnostic register
setDiagnostic(mapping)
This sets the value in the diagnostic register
Parameters mapping – Dictionary of key:value pairs to set

5.1.9 pymodbus.diag_message module

Diagnostic Record Read/Write

These need to be tied into a the current server context or linked to the appropriate data
class pymodbus.diag_message.DiagnosticStatusRequest(**kwargs)
Bases: [Link]
This is a base class for all of the diagnostic request functions
decode(data)
Base decoder for a diagnostic request
Parameters data – The data to decode into the function code
encode()
Base encoder for a diagnostic response we encode the data set in [Link]
Returns The encoded packet
function_code = 8
get_response_pdu_size()
Func_code (1 byte) + Sub function code (2 byte) + Data (2 * N bytes) :return:
class pymodbus.diag_message.DiagnosticStatusResponse(**kwargs)
Bases: [Link]
This is a base class for all of the diagnostic response functions
It works by performing all of the encoding and decoding of variable data and lets the higher classes define what
extra data to append and how to execute a request
decode(data)
Base decoder for a diagnostic response
Parameters data – The data to decode into the function code
encode()
Base encoder for a diagnostic response we encode the data set in [Link]
Returns The encoded packet
function_code = 8

5.1. pymodbus package 185

PyModbus Documentation, Release 2.5.0

class pymodbus.diag_message.ReturnQueryDataRequest(message=0, **kwargs)

Bases: pymodbus.diag_message.DiagnosticStatusRequest
The data passed in the request data field is to be returned (looped back) in the response. The entire response
message should be identical to the request.
execute(*args)
Executes the loopback request (builds the response)
Returns The populated loopback response message
sub_function_code = 0
class pymodbus.diag_message.ReturnQueryDataResponse(message=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusResponse
The data passed in the request data field is to be returned (looped back) in the response. The entire response
message should be identical to the request.
sub_function_code = 0
class pymodbus.diag_message.RestartCommunicationsOptionRequest(toggle=False,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusRequest
The remote device serial line port must be initialized and restarted, and all of its communications event counters
are cleared. If the port is currently in Listen Only Mode, no response is returned. This function is the only one
that brings the port out of Listen Only Mode. If the port is not currently in Listen Only Mode, a normal response
is returned. This occurs before the restart is executed.
execute(*args)
Clear event log and restart
Returns The initialized response message
sub_function_code = 1
class pymodbus.diag_message.RestartCommunicationsOptionResponse(toggle=False,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusResponse
The remote device serial line port must be initialized and restarted, and all of its communications event counters
are cleared. If the port is currently in Listen Only Mode, no response is returned. This function is the only one
that brings the port out of Listen Only Mode. If the port is not currently in Listen Only Mode, a normal response
is returned. This occurs before the restart is executed.
sub_function_code = 1
class pymodbus.diag_message.ReturnDiagnosticRegisterRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The contents of the remote device’s 16-bit diagnostic register are returned in the response
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 2
class pymodbus.diag_message.ReturnDiagnosticRegisterResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The contents of the remote device’s 16-bit diagnostic register are returned in the response
sub_function_code = 2

186 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

class pymodbus.diag_message.ChangeAsciiInputDelimiterRequest(data=0, **kwargs)

Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The character ‘CHAR’ passed in the request data field becomes the end of message delimiter for future messages
(replacing the default LF character). This function is useful in cases of a Line Feed is not required at the end of
ASCII messages.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 3
class pymodbus.diag_message.ChangeAsciiInputDelimiterResponse(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The character ‘CHAR’ passed in the request data field becomes the end of message delimiter for future messages
(replacing the default LF character). This function is useful in cases of a Line Feed is not required at the end of
ASCII messages.
sub_function_code = 3
class pymodbus.diag_message.ForceListenOnlyModeRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
Forces the addressed remote device to its Listen Only Mode for MODBUS communications. This isolates it
from the other devices on the network, allowing them to continue communicating without interruption from the
addressed remote device. No response is returned.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 4
class pymodbus.diag_message.ForceListenOnlyModeResponse(**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusResponse
Forces the addressed remote device to its Listen Only Mode for MODBUS communications. This isolates it
from the other devices on the network, allowing them to continue communicating without interruption from the
addressed remote device. No response is returned.
This does not send a response
should_respond = False
sub_function_code = 4
class pymodbus.diag_message.ClearCountersRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The goal is to clear ll counters and the diagnostic register. Also, counters are cleared upon power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 10
class pymodbus.diag_message.ClearCountersResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse

5.1. pymodbus package 187

PyModbus Documentation, Release 2.5.0

The goal is to clear ll counters and the diagnostic register. Also, counters are cleared upon power-up
sub_function_code = 10
class pymodbus.diag_message.ReturnBusMessageCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages that the remote device has detected on the communica-
tions systems since its last restart, clear counters operation, or power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 11
class pymodbus.diag_message.ReturnBusMessageCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages that the remote device has detected on the communica-
tions systems since its last restart, clear counters operation, or power-up
sub_function_code = 11
class pymodbus.diag_message.ReturnBusCommunicationErrorCountRequest(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of CRC errors encountered by the remote device since its last restart,
clear counter operation, or power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 12
class pymodbus.diag_message.ReturnBusCommunicationErrorCountResponse(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of CRC errors encountered by the remote device since its last restart,
clear counter operation, or power-up
sub_function_code = 12
class pymodbus.diag_message.ReturnBusExceptionErrorCountRequest(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of modbus exception responses returned by the remote device since
its last restart, clear counters operation, or power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 13
class pymodbus.diag_message.ReturnBusExceptionErrorCountResponse(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse

188 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

The response data field returns the quantity of modbus exception responses returned by the remote device since
its last restart, clear counters operation, or power-up
sub_function_code = 13
class pymodbus.diag_message.ReturnSlaveMessageCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages addressed to the remote device, or broadcast, that the
remote device has processed since its last restart, clear counters operation, or power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 14
class pymodbus.diag_message.ReturnSlaveMessageCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages addressed to the remote device, or broadcast, that the
remote device has processed since its last restart, clear counters operation, or power-up
sub_function_code = 14
class pymodbus.diag_message.ReturnSlaveNoResponseCountRequest(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages addressed to the remote device, or broadcast, that the
remote device has processed since its last restart, clear counters operation, or power-up
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 15
class pymodbus.diag_message.ReturnSlaveNoReponseCountResponse(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages addressed to the remote device, or broadcast, that the
remote device has processed since its last restart, clear counters operation, or power-up
sub_function_code = 15
class pymodbus.diag_message.ReturnSlaveNAKCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages addressed to the remote device for which it returned a
Negative Acknowledge (NAK) exception response, since its last restart, clear counters operation, or power-up.
Exception responses are described and listed in section 7 .
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 16
class pymodbus.diag_message.ReturnSlaveNAKCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse

5.1. pymodbus package 189

PyModbus Documentation, Release 2.5.0

The response data field returns the quantity of messages addressed to the remote device for which it returned a
Negative Acknowledge (NAK) exception response, since its last restart, clear counters operation, or power-up.
Exception responses are described and listed in section 7.
sub_function_code = 16
class pymodbus.diag_message.ReturnSlaveBusyCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages addressed to the remote device for which it returned a
Slave Device Busy exception response, since its last restart, clear counters operation, or power-up.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 17
class pymodbus.diag_message.ReturnSlaveBusyCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages addressed to the remote device for which it returned a
Slave Device Busy exception response, since its last restart, clear counters operation, or power-up.
sub_function_code = 17
class pymodbus.diag_message.ReturnSlaveBusCharacterOverrunCountRequest(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
The response data field returns the quantity of messages addressed to the remote device that it could not handle
due to a character overrun condition, since its last restart, clear counters operation, or power-up. A character
overrun is caused by data characters arriving at the port faster than they can be stored, or by the loss of a character
due to a hardware malfunction.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 18
class pymodbus.diag_message.ReturnSlaveBusCharacterOverrunCountResponse(data=0,
**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages addressed to the remote device that it could not handle
due to a character overrun condition, since its last restart, clear counters operation, or power-up. A character
overrun is caused by data characters arriving at the port faster than they can be stored, or by the loss of a character
due to a hardware malfunction.
sub_function_code = 18
class pymodbus.diag_message.ReturnIopOverrunCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
An IOP overrun is caused by data characters arriving at the port faster than they can be stored, or by the loss of
a character due to a hardware malfunction. This function is specific to the 884.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message

190 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

sub_function_code = 19
class pymodbus.diag_message.ReturnIopOverrunCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
The response data field returns the quantity of messages addressed to the slave that it could not handle due to an
884 IOP overrun condition, since its last restart, clear counters operation, or power-up.
sub_function_code = 19
class pymodbus.diag_message.ClearOverrunCountRequest(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
Clears the overrun error counter and reset the error flag
An error flag should be cleared, but nothing else in the specification mentions is, so it is ignored.
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
sub_function_code = 20
class pymodbus.diag_message.ClearOverrunCountResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
Clears the overrun error counter and reset the error flag
sub_function_code = 20
class pymodbus.diag_message.GetClearModbusPlusRequest(**kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleRequest
In addition to the Function code (08) and Subfunction code (00 15 hex) in the query, a two-byte Operation field
is used to specify either a ‘Get Statistics’ or a ‘Clear Statistics’ operation. The two operations are exclusive - the
‘Get’ operation cannot clear the statistics, and the ‘Clear’ operation does not return statistics prior to clearing
them. Statistics are also cleared on power-up of the slave device.
encode()
Base encoder for a diagnostic response we encode the data set in [Link]
Returns The encoded packet
execute(*args)
Execute the diagnostic request on the given device
Returns The initialized response message
get_response_pdu_size()
Returns a series of 54 16-bit words (108 bytes) in the data field of the response (this function differs from
the usual two-byte length of the data field). The data contains the statistics for the Modbus Plus peer
processor in the slave device. Func_code (1 byte) + Sub function code (2 byte) + Operation (2 byte) +
Data (108 bytes) :return:
sub_function_code = 21
class pymodbus.diag_message.GetClearModbusPlusResponse(data=0, **kwargs)
Bases: pymodbus.diag_message.DiagnosticStatusSimpleResponse
Returns a series of 54 16-bit words (108 bytes) in the data field of the response (this function differs from the
usual two-byte length of the data field). The data contains the statistics for the Modbus Plus peer processor in
the slave device.
sub_function_code = 21

5.1. pymodbus package 191

PyModbus Documentation, Release 2.5.0

5.1.10 [Link] module

Modbus Remote Events

An event byte returned by the Get Communications Event Log function can be any one of four types. The type is
defined by bit 7 (the high-order bit) in each byte. It may be further defined by bit 6.
class [Link]
Bases: [Link]
Remote device Initiated Communication Restart
The remote device stores this type of event byte when its communications port is restarted. The remote device
can be restarted by the Diagnostics function (code 08), with sub-function Restart Communications Option (code
00 01).
That function also places the remote device into a ‘Continue on Error’ or ‘Stop on Error’ mode. If the remote
device is placed into ‘Continue on Error’ mode, the event byte is added to the existing event log. If the remote
device is placed into ‘Stop on Error’ mode, the byte is added to the log and the rest of the log is cleared to zeros.
The event is defined by a content of zero.
decode(event)
Decodes the event message to its status bits
Parameters event – The event to decode
encode()
Encodes the status bits to an event message
Returns The encoded event message
value = 0
class [Link]
Bases: [Link]
Remote device Entered Listen Only Mode
The remote device stores this type of event byte when it enters the Listen Only Mode. The event is defined by a
content of 04 hex.
decode(event)
Decodes the event message to its status bits
Parameters event – The event to decode
encode()
Encodes the status bits to an event message
Returns The encoded event message
value = 4
class [Link]
Bases: object
decode(event)
Decodes the event message to its status bits
Parameters event – The event to decode
encode()
Encodes the status bits to an event message

192 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Returns The encoded event message

class [Link](**kwargs)
Bases: [Link]
Remote device MODBUS Receive Event
The remote device stores this type of event byte when a query message is received. It is stored before the remote
device processes the message. This event is defined by bit 7 set to logic ‘1’. The other bits will be set to a logic
‘1’ if the corresponding condition is TRUE. The bit layout is:

Bit Contents
----------------------------------
0 Not Used
2 Not Used
3 Not Used
4 Character Overrun
5 Currently in Listen Only Mode
6 Broadcast Receive
7 1

decode(event)
Decodes the event message to its status bits
Parameters event – The event to decode
encode()
Encodes the status bits to an event message
Returns The encoded event message
class [Link](**kwargs)
Bases: [Link]
Remote device MODBUS Send Event
The remote device stores this type of event byte when it finishes processing a request message. It is stored if the
remote device returned a normal or exception response, or no response.
This event is defined by bit 7 set to a logic ‘0’, with bit 6 set to a ‘1’. The other bits will be set to a logic ‘1’ if
the corresponding condition is TRUE. The bit layout is:

Bit Contents
-----------------------------------------------------------
0 Read Exception Sent (Exception Codes 1-3)
1 Slave Abort Exception Sent (Exception Code 4)
2 Slave Busy Exception Sent (Exception Codes 5-6)
3 Slave Program NAK Exception Sent (Exception Code 7)
4 Write Timeout Error Occurred
5 Currently in Listen Only Mode
6 1
7 0

decode(event)
Decodes the event message to its status bits
Parameters event – The event to decode
encode()
Encodes the status bits to an event message
Returns The encoded event message

5.1. pymodbus package 193

PyModbus Documentation, Release 2.5.0

5.1.11 [Link] module

Pymodbus Exceptions

Custom exceptions to be used in the Modbus code.

exception [Link](string)
Bases: Exception
Base modbus exception
isError()
Error
exception [Link](string=”, function_code=None)
Bases: [Link]
Error resulting from data i/o
exception [Link](string=”)
Bases: [Link]
Error resulting from invalid parameter
exception [Link](string=”)
Bases: [Link]
Error resulting from not implemented function
exception [Link](string=”)
Bases: [Link]
Error resulting from a bad connection
exception [Link](string=”)
Bases: [Link]
Error resulting from making a request to a slave that does not exist
exception [Link](string=”)
Bases: [Link]
Error resulting from invalid response received or decoded
exception [Link](string=”)
Bases: [Link]
Error resulting from failing to register a custom message request/response
exception [Link](string=”)
Bases: [Link]
Error resulting from modbus response timeout

5.1.12 [Link] module

Modbus Request/Response Decoder Factories

The following factories make it easy to decode request/response messages. To add a new request/response pair to be
decodeable by the library, simply add them to the respective function lookup table (order doesn’t matter, but it does
help keep things organized).

194 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Regardless of how many functions are added to the lookup, O(1) behavior is kept as a result of a pre-computed lookup
dictionary.
class [Link]
Bases: [Link]
Request Message Factory (Server)
To add more implemented functions, simply add them to the list
decode(message)
Wrapper to decode a request packet
Parameters message – The raw modbus request packet
Returns The decoded modbus message or None if error
lookupPduClass(function_code)
Use function_code to determine the class of the PDU.
Parameters function_code – The function code specified in a frame.
Returns The class of the PDU that has a matching function_code.
register(function=None)
Registers a function and sub function class with the decoder :param function: Custom function class to
register :return:
class [Link]
Bases: [Link]
Response Message Factory (Client)
To add more implemented functions, simply add them to the list
decode(message)
Wrapper to decode a response packet
Parameters message – The raw packet to decode
Returns The decoded modbus message or None if error
lookupPduClass(function_code)
Use function_code to determine the class of the PDU.
Parameters function_code – The function code specified in a frame.
Returns The class of the PDU that has a matching function_code.
register(function=None, sub_function=None, force=False)
Registers a function and sub function class with the decoder :param function: Custom function class to
register :param sub_function: Custom sub function class to register :param force: Force update the existing
class :return:

5.1.13 pymodbus.file_message module

File Record Read/Write Messages

Currently none of these messages are implemented

class pymodbus.file_message.FileRecord(**kwargs)
Bases: object
Represents a file record and its relevant data.

5.1. pymodbus package 195

PyModbus Documentation, Release 2.5.0

class pymodbus.file_message.ReadFileRecordRequest(records=None, **kwargs)

Bases: [Link]
This function code is used to perform a file record read. All request data lengths are provided in terms of number
of bytes and all record lengths are provided in terms of registers.
A file is an organization of records. Each file contains 10000 records, addressed 0000 to 9999 decimal or 0x0000
to 0x270f. For example, record 12 is addressed as 12. The function can read multiple groups of references. The
groups can be separating (non-contiguous), but the references within each group must be sequential. Each group
is defined in a seperate ‘sub-request’ field that contains seven bytes:

The reference type: 1 byte (must be 0x06)

The file number: 2 bytes
The starting record number within the file: 2 bytes
The length of the record to be read: 2 bytes

The quantity of registers to be read, combined with all other fields in the expected response, must not exceed
the allowable length of the MODBUS PDU: 235 bytes.
decode(data)
Decodes the incoming request
Parameters data – The data to decode into the address
encode()
Encodes the request packet
Returns The byte encoded packet
execute(context)
Run a read exeception status request against the store
Parameters context – The datastore to request from
Returns The populated response
function_code = 20
class pymodbus.file_message.ReadFileRecordResponse(records=None, **kwargs)
Bases: [Link]
The normal response is a series of ‘sub-responses,’ one for each ‘sub-request.’ The byte count field is the total
combined count of bytes in all ‘sub-responses.’ In addition, each ‘sub-response’ contains a field that shows its
own byte count.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 20
class pymodbus.file_message.WriteFileRecordRequest(records=None, **kwargs)
Bases: [Link]
This function code is used to perform a file record write. All request data lengths are provided in terms of
number of bytes and all record lengths are provided in terms of the number of 16 bit words.

196 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

decode(data)
Decodes the incoming request
Parameters data – The data to decode into the address
encode()
Encodes the request packet
Returns The byte encoded packet
execute(context)
Run the write file record request against the context
Parameters context – The datastore to request from
Returns The populated response
function_code = 21
class pymodbus.file_message.WriteFileRecordResponse(records=None, **kwargs)
Bases: [Link]
The normal response is an echo of the request.
decode(data)
Decodes the incoming request
Parameters data – The data to decode into the address
encode()
Encodes the response
Returns The byte encoded message
function_code = 21
class pymodbus.file_message.ReadFifoQueueRequest(address=0, **kwargs)
Bases: [Link]
This function code allows to read the contents of a First-In-First-Out (FIFO) queue of register in a remote device.
The function returns a count of the registers in the queue, followed by the queued data. Up to 32 registers can
be read: the count, plus up to 31 queued data registers.
The queue count register is returned first, followed by the queued data registers. The function reads the queue
contents, but does not clear them.
decode(data)
Decodes the incoming request
Parameters data – The data to decode into the address
encode()
Encodes the request packet
Returns The byte encoded packet
execute(context)
Run a read exeception status request against the store
Parameters context – The datastore to request from
Returns The populated response
function_code = 24

5.1. pymodbus package 197

PyModbus Documentation, Release 2.5.0

class pymodbus.file_message.ReadFifoQueueResponse(values=None, **kwargs)

Bases: [Link]
In a normal response, the byte count shows the quantity of bytes to follow, including the queue count bytes and
value register bytes (but not including the error check field). The queue count is the quantity of data registers in
the queue (not including the count register).
If the queue count exceeds 31, an exception response is returned with an error code of 03 (Illegal Data Value).
classmethod calculateRtuFrameSize(buffer)
Calculates the size of the message
Parameters buffer – A buffer containing the data that have been received.
Returns The number of bytes in the response.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 24

5.1.14 [Link] module

Pymodbus Interfaces

A collection of base classes that are used throughout the pymodbus library.
class [Link]
Bases: object
Singleton base class [Link]
class [Link]
Bases: object
Modbus Decoder Base Class
This interface must be implemented by a modbus message decoder factory. These factories are responsible for
abstracting away converting a raw packet into a request / response message object.
decode(message)
Wrapper to decode a given packet
Parameters message – The raw modbus request packet
Returns The decoded modbus message or None if error
lookupPduClass(function_code)
Use function_code to determine the class of the PDU.
Parameters function_code – The function code specified in a frame.
Returns The class of the PDU that has a matching function_code.
register(function=None)
Registers a function and sub function class with the decoder :param function: Custom function class to
register :return:

198 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

class [Link]
Bases: object
A framer strategy interface. The idea is that we abstract away all the detail about how to detect if a current
message frame exists, decoding it, sending it, etc so that we can plug in a new Framer object (tcp, rtu, ascii).
addToFrame(message)
Add the next message to the frame buffer
This should be used before the decoding while loop to add the received data to the buffer handle.
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet
The raw packet is built off of a fully populated modbus request / response message.
Parameters message – The request/response to send
Returns The built packet
checkFrame()
Check and decode the next frame
Returns True if we successful, False otherwise
getFrame()
Get the next frame from the buffer
Returns The frame data or ‘’
isFrameReady()
Check if we should continue decode logic
This is meant to be used in a while loop in the decoding phase to let the decoder know that there is still
data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result with current frame header
We basically copy the data back over from the current header to the result header. This may not be needed
for serial messages.
Parameters result – The response packet
processIncomingPacket(data, callback)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 / N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to

5.1. pymodbus package 199

PyModbus Documentation, Release 2.5.0

class [Link]
Bases: object
Interface for a modbus slave data context
Derived classes must implemented the following methods: reset(self) validate(self, fx, address, count=1)
getValues(self, fx, address, count=1) setValues(self, fx, address, values)
decode(fx)
Converts the function code to the datastore to
Parameters fx – The function we are working with
Returns one of [d(iscretes),i(nputs),h(olding),c(oils)
getValues(fx, address, count=1)
Get count values from datastore
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to retrieve
Returns The requested values from a:a+c
reset()
Resets all the datastores to their default values
setValues(fx, address, values)
Sets the datastore with the supplied values
Parameters
• fx – The function we are working with
• address – The starting address
• values – The new values to be set
validate(fx, address, count=1)
Validates the request to make sure it is in range
Parameters
• fx – The function we are working with
• address – The starting address
• count – The number of values to test
Returns True if the request in within range, False otherwise
class [Link]
Bases: object
This is an interface to a class that can build a payload for a modbus register write command. It should abstract
the codec for encoding data to the required format (bcd, binary, char, etc).
build()
Return the payload buffer as a list
This list is two bytes per element and can thus be treated as a list of registers.
Returns The payload buffer as a list

200 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

5.1.15 pymodbus.mei_message module

Encapsulated Interface (MEI) Transport Messages

class pymodbus.mei_message.ReadDeviceInformationRequest(read_code=None, ob-

ject_id=0, **kwargs)
Bases: [Link]
This function code allows reading the identification and additional information relative to the physical and
functional description of a remote device, only.
The Read Device Identification interface is modeled as an address space composed of a set of addressable data
elements. The data elements are called objects and an object Id identifies them.
decode(data)
Decodes data part of the message.
Parameters data – The incoming data
encode()
Encodes the request packet
Returns The byte encoded packet
execute(context)
Run a read exeception status request against the store
Parameters context – The datastore to request from
Returns The populated response
function_code = 43
sub_function_code = 14
class pymodbus.mei_message.ReadDeviceInformationResponse(read_code=None,
information=None,
**kwargs)
Bases: [Link]
classmethod calculateRtuFrameSize(buffer)
Calculates the size of the message
Parameters buffer – A buffer containing the data that have been received.
Returns The number of bytes in the response.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 43
sub_function_code = 14

5.1. pymodbus package 201

PyModbus Documentation, Release 2.5.0

5.1.16 pymodbus.other_message module

Diagnostic record read/write

Currently not all implemented
class pymodbus.other_message.ReadExceptionStatusRequest(**kwargs)
Bases: [Link]
This function code is used to read the contents of eight Exception Status outputs in a remote device. The function
provides a simple method for accessing this information, because the Exception Output references are known
(no output reference is needed in the function).
decode(data)
Decodes data part of the message.
Parameters data – The incoming data
encode()
Encodes the message
execute(context=None)
Run a read exeception status request against the store
Returns The populated response
function_code = 7
class pymodbus.other_message.ReadExceptionStatusResponse(status=0, **kwargs)
Bases: [Link]
The normal response contains the status of the eight Exception Status outputs. The outputs are packed into one
data byte, with one bit per output. The status of the lowest output reference is contained in the least significant
bit of the byte. The contents of the eight Exception Status outputs are device specific.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 7
class pymodbus.other_message.GetCommEventCounterRequest(**kwargs)
Bases: [Link]
This function code is used to get a status word and an event count from the remote device’s communication
event counter.
By fetching the current count before and after a series of messages, a client can determine whether the messages
were handled normally by the remote device.
The device’s event counter is incremented once for each successful message completion. It is not incremented
for exception responses, poll commands, or fetch event counter commands.
The event counter can be reset by means of the Diagnostics function (code 08), with a subfunction of Restart
Communications Option (code 00 01) or Clear Counters and Diagnostic Register (code 00 0A).
decode(data)
Decodes data part of the message.

202 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Parameters data – The incoming data

encode()
Encodes the message
execute(context=None)
Run a read exeception status request against the store
Returns The populated response
function_code = 11
class pymodbus.other_message.GetCommEventCounterResponse(count=0, **kwargs)
Bases: [Link]
The normal response contains a two-byte status word, and a two-byte event count. The status word will be all
ones (FF FF hex) if a previously-issued program command is still being processed by the remote device (a busy
condition exists). Otherwise, the status word will be all zeros.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 11
class pymodbus.other_message.GetCommEventLogRequest(**kwargs)
Bases: [Link]
This function code is used to get a status word, event count, message count, and a field of event bytes from the
remote device.
The status word and event counts are identical to that returned by the Get Communications Event Counter
function (11, 0B hex).
The message counter contains the quantity of messages processed by the remote device since its last restart,
clear counters operation, or power-up. This count is identical to that returned by the Diagnostic function (code
08), sub-function Return Bus Message Count (code 11, 0B hex).
The event bytes field contains 0-64 bytes, with each byte corresponding to the status of one MODBUS send
or receive operation for the remote device. The remote device enters the events into the field in chronological
order. Byte 0 is the most recent event. Each new byte flushes the oldest byte from the field.
decode(data)
Decodes data part of the message.
Parameters data – The incoming data
encode()
Encodes the message
execute(context=None)
Run a read exeception status request against the store
Returns The populated response
function_code = 12
class pymodbus.other_message.GetCommEventLogResponse(**kwargs)
Bases: [Link]

5.1. pymodbus package 203

PyModbus Documentation, Release 2.5.0

The normal response contains a two-byte status word field, a two-byte event count field, a two-byte message
count field, and a field containing 0-64 bytes of events. A byte count field defines the total length of the data in
these four field
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 12
class pymodbus.other_message.ReportSlaveIdRequest(**kwargs)
Bases: [Link]
This function code is used to read the description of the type, the current status, and other information specific
to a remote device.
decode(data)
Decodes data part of the message.
Parameters data – The incoming data
encode()
Encodes the message
execute(context=None)
Run a report slave id request against the store
Returns The populated response
function_code = 17
class pymodbus.other_message.ReportSlaveIdResponse(identifier=b’x00’, status=True,
**kwargs)
Bases: [Link]
The format of a normal response is shown in the following example. The data contents are specific to each type
of device.
decode(data)
Decodes a the response
Since the identifier is device dependent, we just return the raw value that a user can decode to whatever it
should be.
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 17

5.1.17 [Link] module

Modbus Payload Builders

A collection of utilities for building and decoding modbus messages payloads.

204 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

class [Link](payload=None, byteorder=’<’, wor-

dorder=’>’, repack=False)
Bases: [Link]
A utility that helps build payload messages to be written with the various modbus messages. It really is just a
simple wrapper around the struct module, however it saves time looking up the format strings. What follows is
a simple example:

builder = BinaryPayloadBuilder(byteorder=[Link])
builder.add_8bit_uint(1)
builder.add_16bit_uint(2)
payload = [Link]()

add_16bit_float(value)
Adds a 16 bit float to the buffer
Parameters value – The value to add to the buffer
add_16bit_int(value)
Adds a 16 bit signed int to the buffer
Parameters value – The value to add to the buffer
add_16bit_uint(value)
Adds a 16 bit unsigned int to the buffer
Parameters value – The value to add to the buffer
add_32bit_float(value)
Adds a 32 bit float to the buffer
Parameters value – The value to add to the buffer
add_32bit_int(value)
Adds a 32 bit signed int to the buffer
Parameters value – The value to add to the buffer
add_32bit_uint(value)
Adds a 32 bit unsigned int to the buffer
Parameters value – The value to add to the buffer
add_64bit_float(value)
Adds a 64 bit float(double) to the buffer
Parameters value – The value to add to the buffer
add_64bit_int(value)
Adds a 64 bit signed int to the buffer
Parameters value – The value to add to the buffer
add_64bit_uint(value)
Adds a 64 bit unsigned int to the buffer
Parameters value – The value to add to the buffer
add_8bit_int(value)
Adds a 8 bit signed int to the buffer
Parameters value – The value to add to the buffer
add_8bit_uint(value)
Adds a 8 bit unsigned int to the buffer

5.1. pymodbus package 205

PyModbus Documentation, Release 2.5.0

Parameters value – The value to add to the buffer

add_bits(values)
Adds a collection of bits to be encoded
If these are less than a multiple of eight, they will be left padded with 0 bits to make it so.
Parameters value – The value to add to the buffer
add_string(value)
Adds a string to the buffer
Parameters value – The value to add to the buffer
build()
Return the payload buffer as a list
This list is two bytes per element and can thus be treated as a list of registers.
Returns The payload buffer as a list
reset()
Reset the payload buffer
to_coils()
Convert the payload buffer into a coil layout that can be used as a context block.
Returns The coil layout to use as a block
to_registers()
Convert the payload buffer into a register layout that can be used as a context block.
Returns The register layout to use as a block
to_string()
Return the payload buffer as a string
Returns The payload buffer as a string
class [Link](payload, byteorder=’<’, wordorder=’>’)
Bases: object
A utility that helps decode payload messages from a modbus reponse message. It really is just a simple wrapper
around the struct module, however it saves time looking up the format strings. What follows is a simple example:

decoder = BinaryPayloadDecoder(payload)
first = decoder.decode_8bit_uint()
second = decoder.decode_16bit_uint()

classmethod bit_chunks(coils, size=8)

decode_16bit_float()
Decodes a 16 bit float from the buffer
decode_16bit_int()
Decodes a 16 bit signed int from the buffer
decode_16bit_uint()
Decodes a 16 bit unsigned int from the buffer
decode_32bit_float()
Decodes a 32 bit float from the buffer
decode_32bit_int()
Decodes a 32 bit signed int from the buffer

206 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

decode_32bit_uint()
Decodes a 32 bit unsigned int from the buffer
decode_64bit_float()
Decodes a 64 bit float(double) from the buffer
decode_64bit_int()
Decodes a 64 bit signed int from the buffer
decode_64bit_uint()
Decodes a 64 bit unsigned int from the buffer
decode_8bit_int()
Decodes a 8 bit signed int from the buffer
decode_8bit_uint()
Decodes a 8 bit unsigned int from the buffer
decode_bits()
Decodes a byte worth of bits from the buffer
decode_string(size=1)
Decodes a string from the buffer
Parameters size – The size of the string to decode
classmethod fromCoils(coils, byteorder=’<’, wordorder=’>’)
Initialize a payload decoder with the result of reading a collection of coils from a modbus device.
The coils are treated as a list of bit(boolean) values.
Parameters
• coils – The coil results to initialize with
• byteorder – The endianess of the payload
Returns An initialized PayloadDecoder
classmethod fromRegisters(registers, byteorder=’<’, wordorder=’>’)
Initialize a payload decoder with the result of reading a collection of registers from a modbus device.
The registers are treated as a list of 2 byte values. We have to do this because of how the data has already
been decoded by the rest of the library.
Parameters
• registers – The register results to initialize with
• byteorder – The Byte order of each word
• wordorder – The endianess of the word (when wordcount is >= 2)
Returns An initialized PayloadDecoder
reset()
Reset the decoder pointer back to the start
skip_bytes(nbytes)
Skip n bytes in the buffer
Parameters nbytes – The number of bytes to skip

5.1. pymodbus package 207

PyModbus Documentation, Release 2.5.0

5.1.18 [Link] module

Contains base classes for modbus request/response/error packets

class [Link](**kwargs)
Bases: [Link]
Base class for a modbus request PDU
doException(exception)
Builds an error response based on the function
Parameters exception – The exception to return
Raises An exception response
class [Link](**kwargs)
Bases: [Link]
Base class for a modbus response PDU
should_respond
A flag that indicates if this response returns a result back to the client issuing the request
_rtu_frame_size
Indicates the size of the modbus rtu response used for calculating how much to read.
isError()
Checks if the error is a success or failure
should_respond = True
class [Link]
Bases: [Link]
An enumeration of the valid modbus exceptions
Acknowledge = 5
GatewayNoResponse = 11
GatewayPathUnavailable = 10
IllegalAddress = 2
IllegalFunction = 1
IllegalValue = 3
MemoryParityError = 8
SlaveBusy = 6
SlaveFailure = 4
classmethod decode(code)
Given an error code, translate it to a string error name.
Parameters code – The code number to translate
class [Link](function_code, exception_code=None, **kwargs)
Bases: [Link]
Base class for a modbus exception PDU
ExceptionOffset = 128

208 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

decode(data)
Decodes a modbus exception response
Parameters data – The packet data to decode
encode()
Encodes a modbus exception response
Returns The encoded exception packet
class [Link](function_code, **kwargs)
Bases: [Link]
Defines the Modbus slave exception type ‘Illegal Function’ This exception code is returned if the slave:

- does not implement the function code or

- is not in a state that allows it to process the function

ErrorCode = 1
decode(data)
This is here so this failure will run correctly
Parameters data – Not used
execute(context)
Builds an illegal function request error response
Parameters context – The current context for the message
Returns The error response packet

5.1.19 pymodbus.register_read_message module

Register Reading Request/Response

class pymodbus.register_read_message.ReadHoldingRegistersRequest(address=None,
count=None,
**kwargs)
Bases: pymodbus.register_read_message.ReadRegistersRequestBase
This function code is used to read the contents of a contiguous block of holding registers in a remote device.
The Request PDU specifies the starting register address and the number of registers. In the PDU Registers are
addressed starting at zero. Therefore registers numbered 1-16 are addressed as 0-15.
execute(context)
Run a read holding request against a datastore
Parameters context – The datastore to request from
Returns An initialized response, exception message otherwise
function_code = 3
class pymodbus.register_read_message.ReadHoldingRegistersResponse(values=None,
**kwargs)
Bases: pymodbus.register_read_message.ReadRegistersResponseBase
This function code is used to read the contents of a contiguous block of holding registers in a remote device.
The Request PDU specifies the starting register address and the number of registers. In the PDU Registers are
addressed starting at zero. Therefore registers numbered 1-16 are addressed as 0-15.
function_code = 3

5.1. pymodbus package 209

PyModbus Documentation, Release 2.5.0

class pymodbus.register_read_message.ReadInputRegistersRequest(address=None,
count=None,
**kwargs)
Bases: pymodbus.register_read_message.ReadRegistersRequestBase
This function code is used to read from 1 to approx. 125 contiguous input registers in a remote device. The
Request PDU specifies the starting register address and the number of registers. In the PDU Registers are
addressed starting at zero. Therefore input registers numbered 1-16 are addressed as 0-15.
execute(context)
Run a read input request against a datastore
Parameters context – The datastore to request from
Returns An initialized response, exception message otherwise
function_code = 4
class pymodbus.register_read_message.ReadInputRegistersResponse(values=None,
**kwargs)
Bases: pymodbus.register_read_message.ReadRegistersResponseBase
This function code is used to read from 1 to approx. 125 contiguous input registers in a remote device. The
Request PDU specifies the starting register address and the number of registers. In the PDU Registers are
addressed starting at zero. Therefore input registers numbered 1-16 are addressed as 0-15.
function_code = 4
class pymodbus.register_read_message.ReadWriteMultipleRegistersRequest(**kwargs)
Bases: [Link]
This function code performs a combination of one read operation and one write operation in a single MODBUS
transaction. The write operation is performed before the read.
Holding registers are addressed starting at zero. Therefore holding registers 1-16 are addressed in the PDU as
0-15.
The request specifies the starting address and number of holding registers to be read as well as the starting
address, number of holding registers, and the data to be written. The byte count specifies the number of bytes to
follow in the write data field.”
decode(data)
Decode the register request packet
Parameters data – The request to decode
encode()
Encodes the request packet
Returns The encoded packet
execute(context)
Run a write single register request against a datastore
Parameters context – The datastore to request from
Returns An initialized response, exception message otherwise
function_code = 23
get_response_pdu_size()
Func_code (1 byte) + Byte Count(1 byte) + 2 * Quantity of Coils (n Bytes) :return:

210 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

class pymodbus.register_read_message.ReadWriteMultipleRegistersResponse(values=None,
**kwargs)
Bases: [Link]
The normal response contains the data from the group of registers that were read. The byte count field specifies
the quantity of bytes to follow in the read data field.
decode(data)
Decode the register response packet
Parameters data – The response to decode
encode()
Encodes the response packet
Returns The encoded packet
function_code = 23

5.1.20 pymodbus.register_write_message module

Register Writing Request/Response Messages

class pymodbus.register_write_message.WriteSingleRegisterRequest(address=None,
value=None,
**kwargs)
Bases: [Link]
This function code is used to write a single holding register in a remote device.
The Request PDU specifies the address of the register to be written. Registers are addressed starting at zero.
Therefore register numbered 1 is addressed as 0.
decode(data)
Decode a write single register packet packet request
Parameters data – The request to decode
encode()
Encode a write single register packet packet request
Returns The encoded packet
execute(context)
Run a write single register request against a datastore
Parameters context – The datastore to request from
Returns An initialized response, exception message otherwise
function_code = 6
get_response_pdu_size()
Func_code (1 byte) + Register Address(2 byte) + Register Value (2 bytes) :return:
class pymodbus.register_write_message.WriteSingleRegisterResponse(address=None,
value=None,
**kwargs)
Bases: [Link]
The normal response is an echo of the request, returned after the register contents have been written.

5.1. pymodbus package 211

PyModbus Documentation, Release 2.5.0

decode(data)
Decode a write single register packet packet request
Parameters data – The request to decode
encode()
Encode a write single register packet packet request
Returns The encoded packet
function_code = 6
class pymodbus.register_write_message.WriteMultipleRegistersRequest(address=None,
val-
ues=None,
**kwargs)
Bases: [Link]
This function code is used to write a block of contiguous registers (1 to approx. 120 registers) in a remote
device.
The requested written values are specified in the request data field. Data is packed as two bytes per register.
decode(data)
Decode a write single register packet packet request
Parameters data – The request to decode
encode()
Encode a write single register packet packet request
Returns The encoded packet
execute(context)
Run a write single register request against a datastore
Parameters context – The datastore to request from
Returns An initialized response, exception message otherwise
function_code = 16
get_response_pdu_size()
Func_code (1 byte) + Starting Address (2 byte) + Quantity of Reggisters (2 Bytes) :return:
class pymodbus.register_write_message.WriteMultipleRegistersResponse(address=None,
count=None,
**kwargs)
Bases: [Link]
“The normal response returns the function code, starting address, and quantity of registers written.
decode(data)
Decode a write single register packet packet request
Parameters data – The request to decode
encode()
Encode a write single register packet packet request
Returns The encoded packet
function_code = 16

212 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

class pymodbus.register_write_message.MaskWriteRegisterRequest(address=0,
and_mask=65535,
or_mask=0,
**kwargs)
Bases: [Link]
This function code is used to modify the contents of a specified holding register using a combination of an AND
mask, an OR mask, and the register’s current contents. The function can be used to set or clear individual bits
in the register.
decode(data)
Decodes the incoming request
Parameters data – The data to decode into the address
encode()
Encodes the request packet
Returns The byte encoded packet
execute(context)
Run a mask write register request against the store
Parameters context – The datastore to request from
Returns The populated response
function_code = 22
class pymodbus.register_write_message.MaskWriteRegisterResponse(address=0,
and_mask=65535,
or_mask=0,
**kwargs)
Bases: [Link]
The normal response is an echo of the request. The response is returned after the register has been written.
decode(data)
Decodes a the response
Parameters data – The packet data to decode
encode()
Encodes the response
Returns The byte encoded message
function_code = 22

5.1.21 [Link] module

Collection of transaction based abstractions

class [Link](client, **kwargs)
Bases: [Link]
Impelements a transaction for a manager where the results are returned in a FIFO manner.
addTransaction(request, tid=None)
Adds a transaction to the handler
This holds the requets in case it needs to be resent. After being sent, the request is removed.
Parameters

5.1. pymodbus package 213

PyModbus Documentation, Release 2.5.0

• request – The request to hold on to

• tid – The overloaded transaction id to use
delTransaction(tid)
Removes a transaction matching the referenced tid
Parameters tid – The transaction to remove
getTransaction(tid)
Returns a transaction matching the referenced tid
If the transaction does not exist, None is returned
Parameters tid – The transaction to retrieve
class [Link](client, **kwargs)
Bases: [Link]
Impelements a transaction for a manager where the results are keyed based on the supplied transaction id.
addTransaction(request, tid=None)
Adds a transaction to the handler
This holds the requets in case it needs to be resent. After being sent, the request is removed.
Parameters
• request – The request to hold on to
• tid – The overloaded transaction id to use
delTransaction(tid)
Removes a transaction matching the referenced tid
Parameters tid – The transaction to remove
getTransaction(tid)
Returns a transaction matching the referenced tid
If the transaction does not exist, None is returned
Parameters tid – The transaction to retrieve
class [Link](decoder, client=None)
Bases: [Link]
Modbus Socket Frame controller
Before each modbus TCP message is an MBAP header which is used as a message frame. It allows us to easily
separate messages as follows:
[ MBAP Header ] [ Function Code] [ Data ] [ tid ][ pid ][
˓→ length ][ uid ]
2b 2b 2b 1b 1b Nb

while len(message) > 0:

tid, pid, length`, uid = [Link](">HHHB", message)
request = message[0:7 + length - 1`]
message = [7 + length - 1:]

* length = uid + function code + data

* The -1 is to account for the uid byte

addToFrame(message)
Adds new packet data to the current frame buffer

214 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

Parameters message – The most recent packet

advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet
Parameters message – The populated request/response to send
checkFrame()
Check and decode the next frame Return true if we were successful
decode_data(data)
getFrame()
Return the next frame from the buffered data
Returns The next full frame buffer
getRawFrame()
Returns the complete buffer
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder factory know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result with the transport specific header information (pid, tid, uid, checksum, etc)
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
Returns
resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).
class [Link](decoder, client=None)
Bases: [Link]
Modbus TLS Frame controller

5.1. pymodbus package 215

PyModbus Documentation, Release 2.5.0

No prefix MBAP header before decrypted PDU is used as a message frame for Modbus Security Application
Protocol. It allows us to easily separate decrypted messages which is PDU as follows:
[ Function Code] [ Data ] 1b Nb
addToFrame(message)
Adds new packet data to the current frame buffer
Parameters message – The most recent packet
advanceFrame()
Skip over the current framed message This allows us to skip over the current message after we have
processed it or determined that it contains an error. It also has to reset the current frame header handle
buildPacket(message)
Creates a ready to send modbus packet
Parameters message – The populated request/response to send
checkFrame()
Check and decode the next frame Return true if we were successful
decode_data(data)
getFrame()
Return the next frame from the buffered data
Returns The next full frame buffer
getRawFrame()
Returns the complete buffer
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder factory know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result with the transport specific header information (no header before PDU in
decrypted message)
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
Returns

216 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

[ Start Wait ] [Address ][ Function Code] [ Data ][ CRC ][ End Wait ]

3.5 chars 1b 1b Nb 2b 3.5 chars

block-on-read:
read until 3.5 delay
check for errors
decode

The following table is a listing of the baud wait times for the specified baud rates:

5.1. pymodbus package 217

PyModbus Documentation, Release 2.5.0

Returns The frame data or ‘’

getRawFrame()
Returns the complete buffer
isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder know that there is still data in the buffer.
Returns True if ready, False otherwise
populateHeader(data=None)
Try to set the headers uid, len and crc.
This method examines self._buffer and writes meta information into self._header.
Beware that this method will raise an IndexError if self._buffer is not yet long enough.
populateResult(result)
Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
recvPacket(size)
Receives packet from the bus with specified len :param size: Number of bytes to read :return:
resetFrame()
Reset the entire message frame. This allows us to skip over errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).
sendPacket(message)
Sends packets on the bus with 3.5char delay between frames :param message: Message to be sent over the
bus :return:
class [Link](decoder, client=None)
Bases: [Link]
Modbus ASCII Frame Controller:

218 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

[ Start ][Address ][ Function ][ Data ][ LRC ][ End ]

1c 2c 2c Nc 2c 2c

* data can be 0 - 2x252 chars

* end is '\r\n' (Carriage return line feed), however the line feed
character can be changed via a special command
* start is ':'

5.1. pymodbus package 219

PyModbus Documentation, Release 2.5.0

• data – The new packet data

• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server))
• single – True or False (If True, ignore unit address validation)
resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).
class [Link](decoder, client=None)
Bases: [Link]
Modbus Binary Frame Controller:

[ Start ][Address ][ Function ][ Data ][ CRC ][ End ]

1b 1b 1b Nb 2b 1b

* data can be 0 - 2x252 chars

* end is '}'
* start is '{'

220 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

isFrameReady()
Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase
to let the decoder know that there is still data in the buffer.
Returns True if ready, False otherwise
populateResult(result)
Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters result – The response packet
processIncomingPacket(data, callback, unit, **kwargs)
The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That
is, checks for complete messages, and once found, will process all that exist. This handles the case when
we read N + 1 or 1 // N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters
• data – The new packet data
• callback – The function to send results to
• unit – Process if unit id matches, ignore otherwise (could be a list of unit ids (server) or
single unit id(client/server)
• single – True or False (If True, ignore unit address validation)
resetFrame()
Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to
know if we are simply out of sync or if there is an error in the stream as we have no way to check the start
or end of the message (python just doesn’t have the resolution to check for millisecond delays).

5.1.22 [Link] module

Modbus Utilities

A collection of utilities for packing data, unpacking data computing checksums, and decode checksums.
[Link].pack_bitstring(bits)
Creates a string out of an array of bits
Parameters bits – A bit array
example:

bits = [False, True, False, True]

result = pack_bitstring(bits)

[Link].unpack_bitstring(string)
Creates bit array out of a string
Parameters string – The modbus data packet to decode
example:

5.1. pymodbus package 221

PyModbus Documentation, Release 2.5.0

bytes = 'bytes to decode'

result = unpack_bitstring(bytes)

[Link](value)
Given a python object, return the default value of that object.
Parameters value – The value to get the default of
Returns The default value
[Link](data)
Computes a crc16 on the passed in string. For modbus, this is only used on the binary serial protocols (in this
case RTU).
The difference between modbus’s crc16 and a normal crc16 is that modbus starts the crc value out at 0xffff.
Parameters data – The data to create a crc16 of
Returns The calculated CRC
[Link](data, check)
Checks if the data matches the passed in CRC
Parameters
• data – The data to create a crc16 of
• check – The CRC to validate
Returns True if matched, False otherwise
[Link](data)
Used to compute the longitudinal redundancy check against a string. This is only used on the serial ASCII
modbus protocol. A full description of this implementation can be found in appendex B of the serial line
modbus description.
Parameters data – The data to apply a lrc to
Returns The calculated LRC
[Link](data, check)
Checks if the passed in data matches the LRC
Parameters
• data – The data to calculate
• check – The LRC to validate
Returns True if matched, False otherwise
[Link](data, byte_count_pos)
Calculates the size of the frame based on the byte count.
Parameters
• data – The buffer containing the frame.
• byte_count_pos – The index of the byte count in the buffer.
Returns The size of the frame.
The structure of frames with a byte count field is always the same:
• first, there are some header fields
• then the byte count field

222 Chapter 5. Pymodbus

PyModbus Documentation, Release 2.5.0

• then as many data bytes as indicated by the byte count,

• finally the CRC (two bytes).
To calculate the frame size, it is therefore sufficient to extract the contents of the byte count field, add the position
of this field, and finally increment the sum by three (one byte for the byte count field, two for the CRC).

5.1.23 [Link] module

Handle the version information here; you should only have to change the version tuple.
Since we are using twisted’s version class, we can also query the svn version as well using the local .entries file.

5.1. pymodbus package 223

PyModbus Documentation, Release 2.5.0

224 Chapter 5. Pymodbus

CHAPTER 6

Indices and tables

• genindex
• modindex
• search

225
PyModbus Documentation, Release 2.5.0

226 Chapter 6. Indices and tables

Python Module Index

p [Link], 192
pymodbus, 145 [Link], 194
pymodbus.bit_read_message, 175 [Link], 194
pymodbus.bit_write_message, 177 pymodbus.file_message, 195
[Link], 145 [Link], 172
[Link], 145 [Link].ascii_framer, 166
[Link], [Link].binary_framer, 167
146 [Link].rtu_framer, 168
[Link].socket_framer, 170
[Link],
146 [Link], 198
[Link],[Link], 172
147 [Link], 172
[Link],pymodbus.mei_message, 201
147 pymodbus.other_message, 202
[Link], [Link], 204
148 [Link], 208
[Link], 151 pymodbus.register_read_message, 209
[Link], 151 pymodbus.register_write_message, 211
[Link], 152 [Link], 175
[Link], [Link], 175
148 [Link], 172
[Link], [Link], 172
150 [Link], 174
[Link], 152 [Link], 213
[Link], 152 [Link], 221
[Link], 154 [Link], 223
[Link], 178
[Link], 179
[Link], 156
[Link], 161
[Link], 158
[Link].redis_datastore,
159
[Link].sql_datastore,
160
[Link], 162
[Link], 163
[Link], 182
pymodbus.diag_message, 185

227
PyModbus Documentation, Release 2.5.0

228 Python Module Index

Index

Symbols add_8bit_uint() (pymod-

_rtu_frame_size ([Link] [Link] method),
attribute), 208 205
add_bits() (pymod-
A [Link] method),
206
Acknowledge ([Link] at-
add_string() (pymod-
tribute), 208
[Link] method),
add() ([Link]
206
method), 183
addEvent() ([Link]
add_16bit_float() (pymod-
method), 184
[Link] method),
addToFrame() (pymod-
205
[Link].ascii_framer.ModbusAsciiFramer
add_16bit_int() (pymod-
method), 166
[Link] method),
addToFrame() (pymod-
205
[Link].binary_framer.ModbusBinaryFramer
add_16bit_uint() (pymod-
method), 167
[Link] method),
addToFrame() (pymod-
205
[Link].rtu_framer.ModbusRtuFramer
add_32bit_float() (pymod-
method), 169
[Link] method),
addToFrame() (pymod-
205
[Link].socket_framer.ModbusSocketFramer
add_32bit_int() (pymod-
method), 171
[Link] method),
addToFrame() ([Link]
205
method), 199
add_32bit_uint() (pymod-
addToFrame() (pymod-
[Link] method),
[Link] method),
205
219
add_64bit_float() (pymod-
addToFrame() (pymod-
[Link] method),
[Link]
205
method), 220
add_64bit_int() (pymod-
addToFrame() (pymod-
[Link] method),
[Link] method),
205
217
add_64bit_uint() (pymod-
addToFrame() (pymod-
[Link] method),
[Link] method),
205
214
add_8bit_int() (pymod-
addToFrame() (pymod-
[Link] method),
[Link] method),
205
216

229
PyModbus Documentation, Release 2.5.0

addTransaction() (pymod- Auto ([Link] attribute), 181

[Link]
method), 214 B
addTransaction() (pymod- Backoff ([Link] attribute), 179,
[Link] 180
method), 213 BaseModbusDataBlock (class in pymod-
advanceFrame() (pymod- [Link]), 163
[Link].ascii_framer.ModbusAsciiFramer BaseTornadoClient (class in pymod-
method), 166 [Link]), 148
advanceFrame() (pymod- BaseTornadoSerialClient (class in pymod-
[Link].binary_framer.ModbusBinaryFramer [Link]), 149
method), 167 Basic ([Link] at-
advanceFrame() (pymod- tribute), 182
[Link].rtu_framer.ModbusRtuFramer Baudrate ([Link] attribute),
method), 169 179, 180
advanceFrame() (pymod- Big ([Link] attribute), 181
[Link].socket_framer.ModbusSocketFramer BinaryPayloadBuilder (class in pymod-
method), 171 [Link]), 204
advanceFrame() (pymod- BinaryPayloadDecoder (class in pymod-
[Link] method), [Link]), 206
199 bit_chunks() (pymod-
advanceFrame() (pymod- [Link] class
[Link] method), method), 206
219 broadcast_enable ([Link]
advanceFrame() (pymod- attribute), 180, 181
[Link] build() ([Link]
method), 220 method), 200
advanceFrame() (pymod- build() ([Link]
[Link] method), method), 206
217 buildPacket() (pymod-
advanceFrame() (pymod- [Link].ascii_framer.ModbusAsciiFramer
[Link] method), method), 166
215 buildPacket() (pymod-
advanceFrame() (pymod- [Link].binary_framer.ModbusBinaryFramer
[Link] method), method), 167
216 buildPacket() (pymod-
async_io_factory() (in module pymod- [Link].rtu_framer.ModbusRtuFramer
[Link]), 146 method), 169
async_io_factory() (in module pymod- buildPacket() (pymod-
[Link]), 147 [Link].socket_framer.ModbusSocketFramer
async_io_factory() (in module pymod- method), 171
[Link]), 147 buildPacket() (pymod-
AsyncModbusSerialClient (class in pymod- [Link] method),
[Link]), 151 199
AsyncModbusSerialClient (class in pymod- buildPacket() (pymod-
[Link]), 148 [Link] method),
AsyncModbusTCPClient (class in pymod- 219
[Link]), 151 buildPacket() (pymod-
AsyncModbusTCPClient (class in pymod- [Link]
[Link]), 148 method), 220
AsyncModbusUDPClient (class in pymod- buildPacket() (pymod-
[Link]), 148 [Link] method),
AsyncModbusUDPClient (class in pymod- 217
[Link]), 152

230 Index
PyModbus Documentation, Release 2.5.0

buildPacket() (pymod- ClearCountersRequest (class in pymod-

[Link] method), bus.diag_message), 187
215 ClearCountersResponse (class in pymod-
buildPacket() (pymodbus.diag_message), 187
[Link] method), clearEvents() (pymod-
216 [Link] method),
byte2int() (in module [Link]), 179 184
Bytesize ([Link] attribute), 180ClearOverrunCountRequest (class in pymod-
bus.diag_message), 191
C ClearOverrunCountResponse (class in pymod-
calculateRtuFrameSize() (pymodbus.diag_message), 191
bus.file_message.ReadFifoQueueResponse ClearStatistics (pymod-
class method), 198 [Link] attribute),
calculateRtuFrameSize() (pymod- 182
bus.mei_message.ReadDeviceInformationResponse ClientDecoder (class in [Link]), 195
class method), 201 close() ([Link]
ChangeAsciiInputDelimiterRequest (class in method), 149
pymodbus.diag_message), 186 close() ([Link]
ChangeAsciiInputDelimiterResponse (class method), 149
in pymodbus.diag_message), 187 close() ([Link]
check() ([Link] method), 150
method), 183 close() ([Link]
checkCRC() (in module [Link]), 222 method), 155
checkFrame() (pymod- close() ([Link]
[Link].ascii_framer.ModbusAsciiFramer method), 154
method), 166 close() ([Link]
checkFrame() (pymod- method), 155
[Link].binary_framer.ModbusBinaryFramer close_fd() (pymod-
method), 168 [Link]
checkFrame() (pymod- method), 149
[Link].rtu_framer.ModbusRtuFramer CommunicationRestartEvent (class in pymod-
method), 169 [Link]), 192
checkFrame() (pymod- computeCRC() (in module [Link]), 222
[Link].socket_framer.ModbusSocketFramer computeLRC() (in module [Link]), 222
method), 171 connect() ([Link]
checkFrame() ([Link] method), 148
method), 199 connect() ([Link]
checkFrame() (pymod- method), 149
[Link] method), connect() ([Link]
219 method), 155
checkFrame() (pymod- connect() ([Link]
[Link] method), 154
method), 220 connect() ([Link]
checkFrame() (pymod- method), 155
[Link] method), connect() ([Link]
217 method), 155
checkFrame() (pymod- ConnectionException, 194
[Link] method), connectionLost() (pymod-
215 [Link]
checkFrame() (pymod- method), 150
[Link] method), connectionMade() (pymod-
216 [Link]
checkLRC() (in module [Link]), 222 method), 150
Counter ([Link] at-

Index 231
PyModbus Documentation, Release 2.5.0

tribute), 184 decode() (pymodbus.file_message.WriteFileRecordResponse

create() ([Link] method), 197
class method), 156 decode() ([Link]
create() ([Link] method), 198
class method), 156 decode() ([Link]
create() ([Link] method), 200
class method), 164 decode() (pymodbus.mei_message.ReadDeviceInformationRequest
create() ([Link] method), 201
class method), 165 decode() (pymodbus.mei_message.ReadDeviceInformationResponse
method), 201
D decode() (pymodbus.other_message.GetCommEventCounterRequest
datagramReceived() (pymod- method), 202
decode() (pymodbus.other_message.GetCommEventCounterResponse
[Link]
method), 151 method), 203
dataReceived() (pymod- decode() (pymodbus.other_message.GetCommEventLogRequest
[Link] method), 203
method), 150 decode() (pymodbus.other_message.GetCommEventLogResponse
decode() (pymodbus.bit_write_message.WriteMultipleCoilsRequestmethod), 204
method), 178 decode() (pymodbus.other_message.ReadExceptionStatusRequest
decode() (pymodbus.bit_write_message.WriteMultipleCoilsResponsemethod), 202
method), 178 decode() (pymodbus.other_message.ReadExceptionStatusResponse
decode() (pymodbus.bit_write_message.WriteSingleCoilRequest method), 202
method), 177 decode() (pymodbus.other_message.ReportSlaveIdRequest
decode() (pymodbus.bit_write_message.WriteSingleCoilResponse method), 204
method), 177 decode() (pymodbus.other_message.ReportSlaveIdResponse
decode() (pymodbus.diag_message.DiagnosticStatusRequest method), 204
method), 185 decode() ([Link] method),
decode() (pymodbus.diag_message.DiagnosticStatusResponse 208
method), 185 decode() ([Link]
decode() ([Link] method), 209
method), 192 decode() ([Link] class
decode() ([Link] method), 208
method), 192 decode() (pymodbus.register_read_message.ReadWriteMultipleRegisters
decode() ([Link] method), method), 210
192 decode() (pymodbus.register_read_message.ReadWriteMultipleRegisters
decode() ([Link] method), 211
method), 193 decode() (pymodbus.register_write_message.MaskWriteRegisterRequest
decode() ([Link] method), 213
method), 193 decode() (pymodbus.register_write_message.MaskWriteRegisterRespons
decode() ([Link] method), method), 213
195 decode() (pymodbus.register_write_message.WriteMultipleRegistersRequ
decode() ([Link] method), method), 212
195 decode() (pymodbus.register_write_message.WriteMultipleRegistersResp
decode() (pymodbus.file_message.ReadFifoQueueRequest method), 212
method), 197 decode() (pymodbus.register_write_message.WriteSingleRegisterRequest
decode() (pymodbus.file_message.ReadFifoQueueResponse method), 211
method), 198 decode() (pymodbus.register_write_message.WriteSingleRegisterRespon
decode() (pymodbus.file_message.ReadFileRecordRequest method), 211
method), 196 decode_16bit_float() (pymod-
decode() (pymodbus.file_message.ReadFileRecordResponse [Link] method),
method), 196 206
decode() (pymodbus.file_message.WriteFileRecordRequestdecode_16bit_int() (pymod-
method), 196 [Link] method),
206

232 Index
PyModbus Documentation, Release 2.5.0

decode_16bit_uint() (pymod- decode_data() (pymod-

[Link] method), [Link] method),
206 216
decode_32bit_float() (pymod- decode_string() (pymod-
[Link] method), [Link] method),
206 207
decode_32bit_int() (pymod- default() (in module [Link]), 222
[Link] method), default() ([Link]
206 method), 163
decode_32bit_uint() (pymod- Defaults (class in [Link]), 179
[Link] method), Delimiter ([Link] at-
206 tribute), 184
decode_64bit_float() (pymod- delTransaction() (pymod-
[Link] method), [Link]
207 method), 214
decode_64bit_int() (pymod- delTransaction() (pymod-
[Link] method), [Link]
207 method), 214
decode_64bit_uint() (pymod- DeviceInformation (class in [Link]),
[Link] method), 182
207 DeviceInformationFactory (class in pymod-
decode_8bit_int() (pymod- [Link]), 184
[Link] method), DiagnosticStatusRequest (class in pymod-
207 bus.diag_message), 185
decode_8bit_uint() (pymod- DiagnosticStatusResponse (class in pymod-
[Link] method), bus.diag_message), 185
207 DictTransactionManager (class in pymod-
decode_bits() (pymod- [Link]), 214
[Link] method), doException() ([Link]
207 method), 208
decode_data() (pymod-
[Link].ascii_framer.ModbusAsciiFramer E
method), 166 encode() (pymodbus.bit_write_message.WriteMultipleCoilsRequest
decode_data() (pymod- method), 178
[Link].binary_framer.ModbusBinaryFramer encode() (pymodbus.bit_write_message.WriteMultipleCoilsResponse
method), 168 method), 178
decode_data() (pymod- encode() (pymodbus.bit_write_message.WriteSingleCoilRequest
[Link].rtu_framer.ModbusRtuFramer method), 177
method), 169 encode() (pymodbus.bit_write_message.WriteSingleCoilResponse
decode_data() (pymod- method), 177
[Link].socket_framer.ModbusSocketFramer encode() ([Link]
method), 171 method), 183
decode_data() (pymod- encode() (pymodbus.diag_message.DiagnosticStatusRequest
[Link] method), method), 185
219 encode() (pymodbus.diag_message.DiagnosticStatusResponse
decode_data() (pymod- method), 185
[Link] encode() (pymodbus.diag_message.GetClearModbusPlusRequest
method), 220 method), 191
decode_data() (pymod- encode() ([Link]
[Link] method), method), 192
217 encode() ([Link]
decode_data() (pymod- method), 192
[Link] method), encode() ([Link] method),
215 192

Index 233
PyModbus Documentation, Release 2.5.0

encode() ([Link] Endian (class in [Link]), 181

method), 193 EnteredListenModeEvent (class in pymod-
encode() ([Link] [Link]), 192
method), 193 ErrorCode ([Link] at-
encode() (pymodbus.file_message.ReadFifoQueueRequest tribute), 209
method), 197 EventLoopThread (class in pymod-
encode() (pymodbus.file_message.ReadFifoQueueResponse [Link]), 152
method), 198 Events ([Link] at-
encode() (pymodbus.file_message.ReadFileRecordRequest tribute), 184
method), 196 ExceptionOffset (pymod-
encode() (pymodbus.file_message.ReadFileRecordResponse [Link] attribute), 208
method), 196 ExceptionResponse (class in [Link]), 208
encode() (pymodbus.file_message.WriteFileRecordRequest
execute() (pymodbus.bit_read_message.ReadCoilsRequest
method), 197 method), 176
encode() (pymodbus.file_message.WriteFileRecordResponse
execute() (pymodbus.bit_read_message.ReadDiscreteInputsRequest
method), 197 method), 176
encode() (pymodbus.mei_message.ReadDeviceInformationRequest
execute() (pymodbus.bit_write_message.WriteMultipleCoilsRequest
method), 201 method), 178
encode() (pymodbus.mei_message.ReadDeviceInformationResponse
execute() (pymodbus.bit_write_message.WriteSingleCoilRequest
method), 201 method), 177
encode() (pymodbus.other_message.GetCommEventCounterRequest
execute() ([Link]
method), 203 method), 148
encode() (pymodbus.other_message.GetCommEventCounterResponse
execute() ([Link]
method), 203 method), 149
encode() (pymodbus.other_message.GetCommEventLogRequest
execute() ([Link]
method), 203 method), 149
encode() (pymodbus.other_message.GetCommEventLogResponse
execute() ([Link]
method), 204 method), 150
encode() (pymodbus.other_message.ReadExceptionStatusRequest
execute() ([Link]
method), 202 method), 151
encode() (pymodbus.other_message.ReadExceptionStatusResponse
execute() (pymodbus.diag_message.ChangeAsciiInputDelimiterRequest
method), 202 method), 187
encode() (pymodbus.other_message.ReportSlaveIdRequestexecute() (pymodbus.diag_message.ClearCountersRequest
method), 204 method), 187
encode() (pymodbus.other_message.ReportSlaveIdResponse
execute() (pymodbus.diag_message.ClearOverrunCountRequest
method), 204 method), 191
encode() ([Link] method), execute() (pymodbus.diag_message.ForceListenOnlyModeRequest
209 method), 187
encode() (pymodbus.register_read_message.ReadWriteMultipleRegistersRequest
execute() (pymodbus.diag_message.GetClearModbusPlusRequest
method), 210 method), 191
encode() (pymodbus.register_read_message.ReadWriteMultipleRegistersResponse
execute() (pymodbus.diag_message.RestartCommunicationsOptionRequ
method), 211 method), 186
encode() (pymodbus.register_write_message.MaskWriteRegisterRequest
execute() (pymodbus.diag_message.ReturnBusCommunicationErrorCou
method), 213 method), 188
encode() (pymodbus.register_write_message.MaskWriteRegisterResponse
execute() (pymodbus.diag_message.ReturnBusExceptionErrorCountReq
method), 213 method), 188
encode() (pymodbus.register_write_message.WriteMultipleRegistersRequest
execute() (pymodbus.diag_message.ReturnBusMessageCountRequest
method), 212 method), 188
encode() (pymodbus.register_write_message.WriteMultipleRegistersResponse
execute() (pymodbus.diag_message.ReturnDiagnosticRegisterRequest
method), 212 method), 186
encode() (pymodbus.register_write_message.WriteSingleRegisterRequest
execute() (pymodbus.diag_message.ReturnIopOverrunCountRequest
method), 211 method), 190
encode() (pymodbus.register_write_message.WriteSingleRegisterResponse
execute() (pymodbus.diag_message.ReturnQueryDataRequest
method), 212 method), 186

234 Index
PyModbus Documentation, Release 2.5.0

execute() (pymodbus.diag_message.ReturnSlaveBusCharacterOverrunCountRequest
framer ([Link]
method), 190 attribute), 150
execute() (pymodbus.diag_message.ReturnSlaveBusyCountRequest
fromCoils() (pymod-
method), 190 [Link] class
execute() (pymodbus.diag_message.ReturnSlaveMessageCountRequest
method), 207
method), 189 fromRegisters() (pymod-
execute() (pymodbus.diag_message.ReturnSlaveNAKCountRequest [Link] class
method), 189 method), 207
execute() (pymodbus.diag_message.ReturnSlaveNoResponseCountRequest
function_code (pymod-
method), 189 bus.bit_read_message.ReadCoilsRequest
execute() (pymodbus.file_message.ReadFifoQueueRequest attribute), 176
method), 197 function_code (pymod-
execute() (pymodbus.file_message.ReadFileRecordRequest bus.bit_read_message.ReadCoilsResponse
method), 196 attribute), 176
execute() (pymodbus.file_message.WriteFileRecordRequest
function_code (pymod-
method), 197 bus.bit_read_message.ReadDiscreteInputsRequest
execute() (pymodbus.mei_message.ReadDeviceInformationRequest attribute), 176
method), 201 function_code (pymod-
execute() (pymodbus.other_message.GetCommEventCounterRequest bus.bit_read_message.ReadDiscreteInputsResponse
method), 203 attribute), 177
execute() (pymodbus.other_message.GetCommEventLogRequest
function_code (pymod-
method), 203 bus.bit_write_message.WriteMultipleCoilsRequest
execute() (pymodbus.other_message.ReadExceptionStatusRequestattribute), 178
method), 202 function_code (pymod-
execute() (pymodbus.other_message.ReportSlaveIdRequest bus.bit_write_message.WriteMultipleCoilsResponse
method), 204 attribute), 178
execute() ([Link] function_code (pymod-
method), 209 bus.bit_write_message.WriteSingleCoilRequest
execute() (pymodbus.register_read_message.ReadHoldingRegistersRequest
attribute), 177
method), 209 function_code (pymod-
execute() (pymodbus.register_read_message.ReadInputRegistersRequest
bus.bit_write_message.WriteSingleCoilResponse
method), 210 attribute), 178
execute() (pymodbus.register_read_message.ReadWriteMultipleRegistersRequest
function_code (pymod-
method), 210 bus.diag_message.DiagnosticStatusRequest
execute() (pymodbus.register_write_message.MaskWriteRegisterRequest
attribute), 185
method), 213 function_code (pymod-
execute() (pymodbus.register_write_message.WriteMultipleRegistersRequest
bus.diag_message.DiagnosticStatusResponse
method), 212 attribute), 185
execute() (pymodbus.register_write_message.WriteSingleRegisterRequest
function_code (pymod-
method), 211 bus.file_message.ReadFifoQueueRequest
Extended ([Link] at- attribute), 197
tribute), 182 function_code (pymod-
bus.file_message.ReadFifoQueueResponse
F attribute), 198
FifoTransactionManager (class in pymod- function_code (pymod-
[Link]), 213 bus.file_message.ReadFileRecordRequest
fileno() ([Link] attribute), 196
method), 149 function_code (pymod-
FileRecord (class in pymodbus.file_message), 195 bus.file_message.ReadFileRecordResponse
ForceListenOnlyModeRequest (class in pymod- attribute), 196
bus.diag_message), 187 function_code (pymod-
ForceListenOnlyModeResponse (class in pymodbus.file_message.WriteFileRecordRequest
bus.diag_message), 187 attribute), 197
function_code (pymod-

Index 235
PyModbus Documentation, Release 2.5.0

bus.file_message.WriteFileRecordResponse bus.register_write_message.MaskWriteRegisterResponse
attribute), 197 attribute), 213
function_code (pymod- function_code (pymod-
bus.mei_message.ReadDeviceInformationRequest bus.register_write_message.WriteMultipleRegistersRequest
attribute), 201 attribute), 212
function_code (pymod- function_code (pymod-
bus.mei_message.ReadDeviceInformationResponse bus.register_write_message.WriteMultipleRegistersResponse
attribute), 201 attribute), 212
function_code (pymod- function_code (pymod-
bus.other_message.GetCommEventCounterRequest bus.register_write_message.WriteSingleRegisterRequest
attribute), 203 attribute), 211
function_code (pymod- function_code (pymod-
bus.other_message.GetCommEventCounterResponse bus.register_write_message.WriteSingleRegisterResponse
attribute), 203 attribute), 212
function_code (pymod-
bus.other_message.GetCommEventLogRequest G
attribute), 203 GatewayNoResponse (pymod-
function_code (pymod- [Link] attribute), 208
bus.other_message.GetCommEventLogResponse GatewayPathUnavailable (pymod-
attribute), 204 [Link] attribute), 208
function_code (pymod- get() ([Link]
bus.other_message.ReadExceptionStatusRequest class method), 184
attribute), 202 get_factory() (in module pymod-
function_code (pymod- [Link]), 146
bus.other_message.ReadExceptionStatusResponseget_factory() (in module pymod-
attribute), 202 [Link]), 147
function_code (pymod- get_factory() (in module pymod-
bus.other_message.ReportSlaveIdRequest [Link]), 147
attribute), 204 get_response_pdu_size() (pymod-
function_code (pymodbus.bit_write_message.WriteMultipleCoilsRequest
bus.other_message.ReportSlaveIdResponse method), 178
attribute), 204 get_response_pdu_size() (pymod-
function_code (pymodbus.bit_write_message.WriteSingleCoilRequest
bus.register_read_message.ReadHoldingRegistersRequest method), 177
attribute), 209 get_response_pdu_size() (pymod-
function_code (pymodbus.diag_message.DiagnosticStatusRequest
bus.register_read_message.ReadHoldingRegistersResponse method), 185
attribute), 209 get_response_pdu_size() (pymod-
function_code (pymodbus.diag_message.GetClearModbusPlusRequest
bus.register_read_message.ReadInputRegistersRequest method), 191
attribute), 210 get_response_pdu_size() (pymod-
function_code (pymodbus.register_read_message.ReadWriteMultipleRegistersRequest
bus.register_read_message.ReadInputRegistersResponse method), 210
attribute), 210 get_response_pdu_size() (pymod-
function_code (pymodbus.register_write_message.WriteMultipleRegistersRequest
bus.register_read_message.ReadWriteMultipleRegistersRequest
method), 212
attribute), 210 get_response_pdu_size() (pymod-
function_code (pymodbus.register_write_message.WriteSingleRegisterRequest
bus.register_read_message.ReadWriteMultipleRegistersResponse
method), 211
attribute), 211 get_socket() (pymod-
function_code (pymod- [Link]
bus.register_write_message.MaskWriteRegisterRequest method), 148
attribute), 213 get_socket() (pymod-
function_code (pymod- [Link]

236 Index
PyModbus Documentation, Release 2.5.0

method), 148 [Link] method),

get_socket() (pymod- 215
[Link]
getFrame() (pymod-
method), 148 [Link] method),
get_socket() (pymod- 216
[Link]
getRawFrame() (pymod-
method), 149 [Link].rtu_framer.ModbusRtuFramer
get_socket() (pymod- method), 169
[Link]
getRawFrame() (pymod-
method), 149 [Link].socket_framer.ModbusSocketFramer
GetClearModbusPlusRequest (class in pymod- method), 171
bus.diag_message), 191 getRawFrame() (pymod-
GetClearModbusPlusResponse (class in pymod- [Link] method),
bus.diag_message), 191 218
GetCommEventCounterRequest (class in pymod- getRawFrame() (pymod-
bus.other_message), 202 [Link] method),
GetCommEventCounterResponse (class in pymod- 215
bus.other_message), 203 getRawFrame() (pymod-
GetCommEventLogRequest (class in pymod- [Link] method),
bus.other_message), 203 216
GetCommEventLogResponse (class in pymod- GetStatistics (pymod-
bus.other_message), 203 [Link] attribute),
getDiagnostic() (pymod- 182
[Link] method), getTransaction() (pymod-
184 [Link]
getDiagnosticRegister() (pymod- method), 214
[Link] method), getTransaction() (pymod-
184 [Link]
getEvents() ([Link] method), 214
method), 185 getValues() (pymod-
getFrame() (pymod- [Link]
[Link].ascii_framer.ModbusAsciiFramer method), 161
method), 166 getValues() (pymod-
getFrame() (pymod- [Link].redis_datastore.RedisSlaveContext
[Link].binary_framer.ModbusBinaryFramer method), 159
method), 168 getValues() (pymod-
getFrame() (pymod- [Link]
[Link].rtu_framer.ModbusRtuFramer method), 159
method), 169 getValues() (pymod-
getFrame() (pymod- [Link].sql_datastore.SqlSlaveContext
[Link].socket_framer.ModbusSocketFramer method), 160
method), 171 getValues() (pymod-
getFrame() ([Link] [Link]
method), 199 method), 158
getFrame() (pymod- getValues() (pymod-
[Link] method), [Link]
219 method), 156
getFrame() (pymod- getValues() (pymod-
[Link] [Link] method),
method), 220 157
getFrame() (pymod- getValues() (pymod-
[Link] method), [Link]
217 method), 157
getFrame() (pymod- getValues() (pymod-

Index 237
PyModbus Documentation, Release 2.5.0

[Link] is_socket_open() (pymod-

method), 162 [Link] method),
getValues() (pymod- 155
[Link] is_socket_open() (pymod-
method), 163 [Link] method),
getValues() (pymod- 155
[Link] is_socket_open() (pymod-
method), 164 [Link] method),
getValues() (pymod- 155
[Link] isError() ([Link]
method), 165 method), 194
getValues() (pymod- isError() ([Link] method),
[Link] method), 208
200 isFrameReady() (pymod-
[Link].ascii_framer.ModbusAsciiFramer
I method), 166
Identity ([Link] at- isFrameReady() (pymod-
tribute), 184 [Link].binary_framer.ModbusBinaryFramer
IgnoreMissingSlaves (pymod- method), 168
[Link] attribute), 180 isFrameReady() (pymod-
IllegalAddress ([Link] [Link].rtu_framer.ModbusRtuFramer
attribute), 208 method), 169
IllegalFunction (pymod- isFrameReady() (pymod-
[Link] attribute), 208 [Link].socket_framer.ModbusSocketFramer
IllegalFunctionRequest (class in pymod- method), 171
[Link]), 209 isFrameReady() (pymod-
IllegalValue ([Link] at- [Link] method),
tribute), 208 199
IModbusDecoder (class in [Link]), 198 isFrameReady() (pymod-
IModbusFramer (class in [Link]), 198 [Link] method),
IModbusSlaveContext (class in pymod- 219
[Link]), 199 isFrameReady() (pymod-
implements_to_string() (in module pymod- [Link]
[Link]), 179 method), 220
InstallManagementConsole() (in module py- isFrameReady() (pymod-
[Link]), 172 [Link] method),
int2byte() (in module [Link]), 179 218
inter_char_timeout (pymod- isFrameReady() (pymod-
[Link] attribute), [Link] method),
155 215
InvalidMessageReceivedException, 194 isFrameReady() (pymod-
io_loop ([Link] method),
attribute), 149 216
io_loop ([Link]
attribute), 149 K
io_loop_factory() (in module pymod- KeepReading ([Link] at-
[Link]), 146 tribute), 182
io_loop_factory() (in module pymod-
[Link]), 147 L
io_loop_factory() (in module pymod- last_frame_end (pymod-
[Link]), 147 [Link] at-
IPayloadBuilder (class in [Link]), tribute), 152
200 ListenOnly ([Link]
is_installed() (in module [Link]), 179 attribute), 184

238 Index
PyModbus Documentation, Release 2.5.0

Little ([Link] attribute), 181 ModbusRtuFramer (class in pymod-

lookupPduClass() (pymod- [Link].rtu_framer), 168
[Link] method), 195 ModbusRtuFramer (class in [Link]),
lookupPduClass() (pymod- 217
[Link] method), 195 ModbusSequentialDataBlock (class in pymod-
lookupPduClass() (pymod- [Link]), 156
[Link] method), ModbusSequentialDataBlock (class in pymod-
198 [Link]), 164
ModbusSerialClient (class in pymod-
M [Link]), 155
MajorMinorRevision (pymod- ModbusServerContext (class in pymod-
[Link] at- [Link]), 158
tribute), 183 ModbusServerContext (class in pymod-
mask_write_register() (pymod- [Link]), 161
[Link] ModbusSlaveContext (class in pymod-
method), 152 [Link]), 157
MaskWriteRegisterRequest (class in pymod- ModbusSlaveContext (class in pymod-
bus.register_write_message), 212 [Link]), 161
MaskWriteRegisterResponse (class in pymod- ModbusSocketFramer (class in pymod-
bus.register_write_message), 213 [Link].socket_framer), 170
MemoryParityError (pymod- ModbusSocketFramer (class in pymod-
[Link] attribute), 208 [Link]), 214
MessageRegisterException, 194 ModbusSparseDataBlock (class in pymod-
ModbusAccessControl (class in [Link]), [Link]), 156
183 ModbusSparseDataBlock (class in pymod-
ModbusAsciiFramer (class in pymod- [Link]), 165
[Link].ascii_framer), 166 ModbusStatus (class in [Link]), 181
ModbusAsciiFramer (class in pymod- ModbusTcpClient (class in [Link]),
[Link]), 218 154
ModbusBinaryFramer (class in pymod- ModbusTlsClient (class in [Link]),
[Link].binary_framer), 167 155
ModbusBinaryFramer (class in pymod- ModbusTlsFramer (class in [Link]),
[Link]), 220 215
ModbusClientFactory (class in pymod- ModbusUdpClient (class in [Link]),
[Link]), 151 155
ModbusClientMixin (class in pymod- ModbusUdpClientProtocol (class in pymod-
[Link]), 152 [Link]), 151
ModbusClientProtocol (class in pymod- Mode ([Link] attribute),
[Link]), 150 184
ModbusControlBlock (class in [Link]), ModelName ([Link]
184 attribute), 183
ModbusDeviceIdentification (class in pymod- MoreData (class in [Link]), 182
[Link]), 183
ModbusEvent (class in [Link]), 192 N
ModbusException, 194 NoSuchSlaveException, 194
ModbusExceptions (class in [Link]), 208 Nothing ([Link] attribute),
ModbusFramer (class in [Link]), 172 182
ModbusIOException, 194 NotImplementedException, 194
ModbusPlusOperation (class in pymod-
[Link]), 181 O
ModbusPlusStatistics (class in pymod- Off ([Link] attribute), 181
[Link]), 183 On ([Link] attribute), 181
ModbusRequest (class in [Link]), 208 on_receive() (pymod-
ModbusResponse (class in [Link]), 208 [Link]

Index 239
PyModbus Documentation, Release 2.5.0

method), 149 method), 168

on_receive() (pymod- processIncomingPacket() (pymod-
[Link] [Link].rtu_framer.ModbusRtuFramer
method), 149 method), 170
processIncomingPacket() (pymod-
P [Link].socket_framer.ModbusSocketFramer
pack_bitstring() (in module [Link]), method), 171
221 processIncomingPacket() (pymod-
ParameterException, 194 [Link] method),
Parity ([Link] attribute), 180 199
Plus ([Link] attribute), processIncomingPacket() (pymod-
184 [Link] method),
populateHeader() (pymod- 219
[Link].rtu_framer.ModbusRtuFramer processIncomingPacket() (pymod-
method), 169 [Link]
populateHeader() (pymod- method), 221
[Link] method), processIncomingPacket() (pymod-
218 [Link] method),
populateResult() (pymod- 218
[Link].ascii_framer.ModbusAsciiFramer processIncomingPacket() (pymod-
method), 166 [Link] method),
populateResult() (pymod- 215
[Link].binary_framer.ModbusBinaryFramer processIncomingPacket() (pymod-
method), 168 [Link] method),
populateResult() (pymod- 216
[Link].rtu_framer.ModbusRtuFramer ProductCode (pymod-
method), 170 [Link] at-
populateResult() (pymod- tribute), 183
[Link].socket_framer.ModbusSocketFramer ProductName (pymod-
method), 171 [Link] at-
populateResult() (pymod- tribute), 183
[Link] method), protocol ([Link]
199 attribute), 151
populateResult() (pymod- ProtocolId ([Link] attribute),
[Link] method), 179, 180
219 pymodbus (module), 145
populateResult() (pymod- pymodbus.bit_read_message (module), 175
[Link] pymodbus.bit_write_message (module), 177
method), 221 [Link] (module), 145
populateResult() (pymod- [Link] (module), 145
[Link] method), [Link]
218 (module), 146
populateResult() (pymod- [Link]
[Link] method), (module), 146
215 [Link]
populateResult() (pymod- (module), 147
[Link] method), [Link]
216 (module), 147
Port ([Link] attribute), 179, 180 [Link]
processIncomingPacket() (pymod- (module), 148
[Link].ascii_framer.ModbusAsciiFramer [Link]
method), 167 (module), 151
processIncomingPacket() (pymod- [Link] (mod-
[Link].binary_framer.ModbusBinaryFramer ule), 151

240 Index
PyModbus Documentation, Release 2.5.0

[Link] R
(module), 152 reactor_factory() (in module pymod-
[Link] [Link]), 146
(module), 148 reactor_factory() (in module pymod-
[Link] [Link]), 147
(module), 150 reactor_factory() (in module pymod-
[Link] (mod- [Link]), 148
ule), 152 read_coils() (pymod-
[Link] (module), 152 [Link]
[Link] (module), 154 method), 153
[Link] (module), 178 read_discrete_inputs() (pymod-
[Link] (module), 179 [Link]
[Link] (module), 156 method), 153
[Link] (module), 161 read_from_fd() (pymod-
[Link] (module), 158 [Link]
[Link].redis_datastore method), 149
(module), 159 read_holding_registers() (pymod-
[Link].sql_datastore [Link]
(module), 160 method), 153
[Link] (module), 162 read_input_registers() (pymod-
[Link] (module), 163 [Link]
[Link] (module), 182 method), 153
pymodbus.diag_message (module), 185 ReadCoilsRequest (class in pymod-
[Link] (module), 192 bus.bit_read_message), 176
[Link] (module), 194 ReadCoilsResponse (class in pymod-
[Link] (module), 194 bus.bit_read_message), 176
pymodbus.file_message (module), 195 ReadDeviceInformationRequest (class in py-
[Link] (module), 172 modbus.mei_message), 201
[Link].ascii_framer (module), 166 ReadDeviceInformationResponse (class in py-
[Link].binary_framer (module), modbus.mei_message), 201
167 ReadDiscreteInputsRequest (class in pymod-
[Link].rtu_framer (module), 168 bus.bit_read_message), 176
[Link].socket_framer (module), ReadDiscreteInputsResponse (class in pymod-
170 bus.bit_read_message), 176
[Link] (module), 198 ReadExceptionStatusRequest (class in pymod-
[Link] (module), 172 bus.other_message), 202
[Link] (module), 172 ReadExceptionStatusResponse (class in pymod-
pymodbus.mei_message (module), 201 bus.other_message), 202
pymodbus.other_message (module), 202 ReadFifoQueueRequest (class in pymod-
[Link] (module), 204 bus.file_message), 197
[Link] (module), 208 ReadFifoQueueResponse (class in pymod-
pymodbus.register_read_message (module), bus.file_message), 197
209 ReadFileRecordRequest (class in pymod-
pymodbus.register_write_message (module), bus.file_message), 195
211 ReadFileRecordResponse (class in pymod-
[Link] (module), 175 bus.file_message), 196
[Link] (module), 175 ReadHoldingRegistersRequest (class in pymod-
[Link] (module), 172 bus.register_read_message), 209
[Link] (module), 172 ReadHoldingRegistersResponse (class in py-
[Link] (module), 174 modbus.register_read_message), 209
[Link] (module), 213 ReadInputRegistersRequest (class in pymod-
[Link] (module), 221 bus.register_read_message), 210
[Link] (module), 223 ReadInputRegistersResponse (class in pymod-
bus.register_read_message), 210

Index 241
PyModbus Documentation, Release 2.5.0

ReadSize ([Link] attribute), 180 reset() ([Link]

readwrite_registers() (pymod- method), 159
[Link] reset() ([Link].sql_datastore.SqlSlaveContext
method), 153 method), 160
ReadWriteMultipleRegistersRequest (class reset() ([Link]
in pymodbus.register_read_message), 210 method), 158
ReadWriteMultipleRegistersResponse (class reset() ([Link]
in pymodbus.register_read_message), 210 method), 157
Ready ([Link] attribute), reset() ([Link]
181 method), 157
Reconnects ([Link] attribute), reset() ([Link]
179, 180 method), 162
recvPacket() ([Link] reset() ([Link]
method), 172 method), 164
recvPacket() (pymod- reset() ([Link]
[Link].rtu_framer.ModbusRtuFramer method), 165
method), 170 reset() ([Link]
recvPacket() (pymod- method), 185
[Link] method), reset() ([Link]
218 method), 183
RedisSlaveContext (class in pymod- reset() ([Link]
[Link]), 159 method), 200
RedisSlaveContext (class in pymod- reset() ([Link]
[Link].redis_datastore), method), 206
159 reset() ([Link]
register() (pymod- method), 207
[Link] resetFrame() (pymod-
method), 161 [Link].ascii_framer.ModbusAsciiFramer
register() (pymod- method), 167
[Link] method), resetFrame() (pymod-
157 [Link].binary_framer.ModbusBinaryFramer
register() ([Link] method), 168
method), 195 resetFrame() (pymod-
register() ([Link] [Link].rtu_framer.ModbusRtuFramer
method), 195 method), 170
register() ([Link] resetFrame() (pymod-
method), 198 [Link].socket_framer.ModbusSocketFramer
Regular ([Link] at- method), 171
tribute), 182 resetFrame() (pymod-
RemoteReceiveEvent (class in [Link]), [Link] method),
193 220
RemoteSendEvent (class in [Link]), 193 resetFrame() (pymod-
RemoteSlaveContext (class in pymod- [Link]
[Link]), 162 method), 221
remove() ([Link] resetFrame() (pymod-
method), 183 [Link] method),
ReportSlaveIdRequest (class in pymod- 218
bus.other_message), 204 resetFrame() (pymod-
ReportSlaveIdResponse (class in pymod- [Link] method),
bus.other_message), 204 215
reset() ([Link]() (pymod-
method), 161 [Link] method),
reset() ([Link].redis_datastore.RedisSlaveContext
216
method), 160 RestartCommunicationsOptionRequest (class

242 Index
PyModbus Documentation, Release 2.5.0

in pymodbus.diag_message), 186 S
RestartCommunicationsOptionResponse sendPacket() ([Link]
(class in pymodbus.diag_message), 186 method), 172
Retries ([Link] attribute), 179, sendPacket() (pymod-
180 [Link].rtu_framer.ModbusRtuFramer
RetryOnEmpty ([Link] at- method), 170
tribute), 179, 180 sendPacket() (pymod-
RetryOnInvalid ([Link] at- [Link] method),
tribute), 179, 180 218
ReturnBusCommunicationErrorCountRequest SerialIOStream (class in pymod-
(class in pymodbus.diag_message), 188 [Link]), 149
ReturnBusCommunicationErrorCountResponseServerDecoder (class in [Link]), 195
(class in pymodbus.diag_message), 188 setDiagnostic() (pymod-
ReturnBusExceptionErrorCountRequest [Link] method),
(class in pymodbus.diag_message), 188 185
ReturnBusExceptionErrorCountResponse setValues() (pymod-
(class in pymodbus.diag_message), 188 [Link]
ReturnBusMessageCountRequest (class in py- method), 161
modbus.diag_message), 188 setValues() (pymod-
ReturnBusMessageCountResponse (class in py- [Link].redis_datastore.RedisSlaveContext
modbus.diag_message), 188 method), 160
ReturnDiagnosticRegisterRequest (class in setValues() (pymod-
pymodbus.diag_message), 186 [Link]
ReturnDiagnosticRegisterResponse (class in method), 159
pymodbus.diag_message), 186 setValues() (pymod-
ReturnIopOverrunCountRequest (class in py- [Link].sql_datastore.SqlSlaveContext
modbus.diag_message), 190 method), 160
ReturnIopOverrunCountResponse (class in py- setValues() (pymod-
modbus.diag_message), 191 [Link]
ReturnQueryDataRequest (class in pymod- method), 158
bus.diag_message), 185 setValues() (pymod-
ReturnQueryDataResponse (class in pymod- [Link]
bus.diag_message), 186 method), 156
ReturnSlaveBusCharacterOverrunCountRequest setValues() (pymod-
(class in pymodbus.diag_message), 190 [Link] method),
ReturnSlaveBusCharacterOverrunCountResponse 157
(class in pymodbus.diag_message), 190 setValues() (pymod-
ReturnSlaveBusyCountRequest (class in pymod- [Link]
bus.diag_message), 190 method), 157
ReturnSlaveBusyCountResponse (class in py- setValues() (pymod-
modbus.diag_message), 190 [Link]
ReturnSlaveMessageCountRequest (class in py- method), 162
modbus.diag_message), 189 setValues() (pymod-
ReturnSlaveMessageCountResponse (class in [Link]
pymodbus.diag_message), 189 method), 164
ReturnSlaveNAKCountRequest (class in pymod- setValues() (pymod-
bus.diag_message), 189 [Link]
ReturnSlaveNAKCountResponse (class in pymod- method), 164
bus.diag_message), 189 setValues() (pymod-
ReturnSlaveNoReponseCountResponse (class [Link]
in pymodbus.diag_message), 189 method), 165
ReturnSlaveNoResponseCountRequest (class setValues() (pymod-
in pymodbus.diag_message), 189 [Link] method),
rtuFrameSize() (in module [Link]), 222 200

Index 243
PyModbus Documentation, Release 2.5.0

should_respond (pymod- method), 152

bus.diag_message.ForceListenOnlyModeResponseStopbits ([Link] attribute), 180
attribute), 187 StopServer() (in module pymod-
should_respond ([Link] [Link]), 173
attribute), 208 stream ([Link]
silent_interval (pymod- attribute), 149
[Link] at- stream ([Link]
tribute), 153 attribute), 149
silent_interval (pymod- sub_function_code (pymod-
[Link] attribute), bus.diag_message.ChangeAsciiInputDelimiterRequest
155 attribute), 187
Singleton (class in [Link]), 198 sub_function_code (pymod-
skip_bytes() (pymodbus.diag_message.ChangeAsciiInputDelimiterResponse
[Link] method), attribute), 187
207 sub_function_code (pymod-
SlaveBusy ([Link] at- bus.diag_message.ClearCountersRequest
tribute), 208 attribute), 187
SlaveFailure ([Link] at- sub_function_code (pymod-
tribute), 208 bus.diag_message.ClearCountersResponse
SlaveOff ([Link] at- attribute), 188
tribute), 181 sub_function_code (pymod-
SlaveOn ([Link] attribute), bus.diag_message.ClearOverrunCountRequest
181 attribute), 191
slaves() ([Link]
sub_function_code (pymod-
method), 161 bus.diag_message.ClearOverrunCountResponse
slaves() ([Link] attribute), 191
method), 158 sub_function_code (pymod-
Specific ([Link] at- bus.diag_message.ForceListenOnlyModeRequest
tribute), 182 attribute), 187
SqlSlaveContext (class in pymod- sub_function_code (pymod-
[Link]), 158 bus.diag_message.ForceListenOnlyModeResponse
SqlSlaveContext (class in pymod- attribute), 187
[Link].sql_datastore), 160 sub_function_code (pymod-
start() ([Link] bus.diag_message.GetClearModbusPlusRequest
method), 152 attribute), 191
StartSerialServer() (in module pymod- sub_function_code (pymod-
[Link]), 173 bus.diag_message.GetClearModbusPlusResponse
StartSerialServer() (in module pymod- attribute), 191
[Link]), 175 sub_function_code (pymod-
StartTcpServer() (in module pymodbus.diag_message.RestartCommunicationsOptionRequest
[Link]), 172 attribute), 186
StartTcpServer() (in module pymod- sub_function_code (pymod-
[Link]), 174 bus.diag_message.RestartCommunicationsOptionResponse
StartTlsServer() (in module pymod- attribute), 186
[Link]), 174 sub_function_code (pymod-
StartUdpServer() (in module pymodbus.diag_message.ReturnBusCommunicationErrorCountRequest
[Link]), 173 attribute), 188
StartUdpServer() (in module pymod- sub_function_code (pymod-
[Link]), 174 bus.diag_message.ReturnBusCommunicationErrorCountResponse
state ([Link] attribute), 188
attribute), 154 sub_function_code (pymod-
state ([Link] at- bus.diag_message.ReturnBusExceptionErrorCountRequest
tribute), 155 attribute), 188
stop() ([Link]
sub_function_code (pymod-

244 Index
PyModbus Documentation, Release 2.5.0

bus.diag_message.ReturnBusExceptionErrorCountResponsebus.diag_message.ReturnSlaveNoResponseCountRequest
attribute), 189 attribute), 189
sub_function_code (pymod- sub_function_code (pymod-
bus.diag_message.ReturnBusMessageCountRequest bus.mei_message.ReadDeviceInformationRequest
attribute), 188 attribute), 201
sub_function_code (pymod- sub_function_code (pymod-
bus.diag_message.ReturnBusMessageCountResponse bus.mei_message.ReadDeviceInformationResponse
attribute), 188 attribute), 201
sub_function_code (pymod- summary() ([Link]
bus.diag_message.ReturnDiagnosticRegisterRequest method), 184
attribute), 186 summary() ([Link]
sub_function_code (pymod- method), 183
bus.diag_message.ReturnDiagnosticRegisterResponse
attribute), 186 T
sub_function_code (pymod- Timeout ([Link] attribute), 179,
bus.diag_message.ReturnIopOverrunCountRequest 180
attribute), 190 TimeOutException, 194
sub_function_code (pymod- TLSPort ([Link] attribute), 179,
bus.diag_message.ReturnIopOverrunCountResponse 180
attribute), 191 to_coils() (pymod-
sub_function_code (pymod- [Link] method),
bus.diag_message.ReturnQueryDataRequest 206
attribute), 186 to_registers() (pymod-
sub_function_code (pymod- [Link] method),
bus.diag_message.ReturnQueryDataResponse 206
attribute), 186 to_string() (pymod-
sub_function_code (pymod- [Link] method),
bus.diag_message.ReturnSlaveBusCharacterOverrunCountRequest
206
attribute), 190 TransactionId ([Link]
sub_function_code (pymod- attribute), 179, 180
bus.diag_message.ReturnSlaveBusCharacterOverrunCountResponse
attribute), 190 U
sub_function_code (pymod- UnitId ([Link] attribute), 179,
bus.diag_message.ReturnSlaveBusyCountRequest 180
attribute), 190 unpack_bitstring() (in module pymod-
sub_function_code (pymod- [Link]), 221
bus.diag_message.ReturnSlaveBusyCountResponseupdate() ([Link]
attribute), 190 method), 184
sub_function_code (pymod- UserApplicationName (pymod-
bus.diag_message.ReturnSlaveMessageCountRequest [Link] at-
attribute), 189 tribute), 183
sub_function_code (pymod-
V
bus.diag_message.ReturnSlaveMessageCountResponse
attribute), 189
validate() (pymod-
sub_function_code (pymod-
[Link]
bus.diag_message.ReturnSlaveNAKCountRequest
method), 162
attribute), 189
validate() (pymod-
sub_function_code (pymod-
[Link].redis_datastore.RedisSlaveContext
bus.diag_message.ReturnSlaveNAKCountResponse
method), 160
attribute), 190
validate() (pymod-
sub_function_code (pymod-
[Link]
bus.diag_message.ReturnSlaveNoReponseCountResponse
method), 159
attribute), 189
sub_function_code (pymod-

Index 245
PyModbus Documentation, Release 2.5.0

validate() (pymod- method), 154

[Link].sql_datastore.SqlSlaveContext
write_to_fd() (pymod-
method), 161 [Link]
validate() (pymod- method), 149
[Link] WriteFileRecordRequest (class in pymod-
method), 158 bus.file_message), 196
validate() (pymod- WriteFileRecordResponse (class in pymod-
[Link] bus.file_message), 197
method), 156 WriteMultipleCoilsRequest (class in pymod-
validate() (pymodbus.bit_write_message), 178
[Link] method), WriteMultipleCoilsResponse (class in pymod-
158 bus.bit_write_message), 178
validate() (pymod- WriteMultipleRegistersRequest (class in py-
[Link] modbus.register_write_message), 212
method), 157 WriteMultipleRegistersResponse (class in py-
validate() (pymod- modbus.register_write_message), 212
[Link] WriteSingleCoilRequest (class in pymod-
method), 162 bus.bit_write_message), 177
validate() (pymod- WriteSingleCoilResponse (class in pymod-
[Link] bus.bit_write_message), 177
method), 164 WriteSingleRegisterRequest (class in pymod-
validate() (pymodbus.register_write_message), 211
[Link] WriteSingleRegisterResponse (class in pymod-
method), 164 bus.register_write_message), 211
validate() (pymod-
[Link] Z
method), 165 ZeroMode ([Link] attribute),
validate() (pymod- 180, 181
[Link] method),
200
value ([Link]
attribute), 192
value ([Link] at-
tribute), 192
VendorName (pymod-
[Link] at-
tribute), 183
VendorUrl ([Link]
attribute), 183

W
Waiting ([Link] attribute),
181
write_coil() (pymod-
[Link]
method), 154
write_coils() (pymod-
[Link]
method), 154
write_register() (pymod-
[Link]
method), 154
write_registers() (pymod-
[Link]

246 Index

También podría gustarte

Pymodbus Es
Aún no hay calificaciones
Pymodbus Es
250 páginas
Instrucciones OpenScape Personal V7
Aún no hay calificaciones
Instrucciones OpenScape Personal V7
250 páginas
PDF - Mif Espannol
Aún no hay calificaciones
PDF - Mif Espannol
420 páginas
Vsphere Esxi Vcenter Server 651 Virtual Machine Admin Guide
Aún no hay calificaciones
Vsphere Esxi Vcenter Server 651 Virtual Machine Admin Guide
276 páginas
Patrones de Diseño en Go
Aún no hay calificaciones
Patrones de Diseño en Go
126 páginas
Guía de Administración de vSphere 6.5
Aún no hay calificaciones
Guía de Administración de vSphere 6.5
285 páginas
Guía de Usuario de QGIS Server 3.34
Aún no hay calificaciones
Guía de Usuario de QGIS Server 3.34
122 páginas
Resumen de Papers para Primer Parcial
Aún no hay calificaciones
Resumen de Papers para Primer Parcial
25 páginas
Guía de Administración de Servicios Web
Aún no hay calificaciones
Guía de Administración de Servicios Web
70 páginas
Manual de Programación ABAP OO
Aún no hay calificaciones
Manual de Programación ABAP OO
145 páginas
Cambio Climático
Aún no hay calificaciones
Cambio Climático
99 páginas
Curso de Física Matemática y Unix
Aún no hay calificaciones
Curso de Física Matemática y Unix
379 páginas
Programaci Ón y Métodos Numéricos
Aún no hay calificaciones
Programaci Ón y Métodos Numéricos
304 páginas
Manual del Lanzador AMX: Guía Completa
Aún no hay calificaciones
Manual del Lanzador AMX: Guía Completa
96 páginas
La Biblia de Apache PDF
Aún no hay calificaciones
La Biblia de Apache PDF
845 páginas
Muestra Software Cafrers
Aún no hay calificaciones
Muestra Software Cafrers
25 páginas
Kumbia PHP Framework: Guía Completa
Aún no hay calificaciones
Kumbia PHP Framework: Guía Completa
227 páginas
Manual de Usuario para Moskitt 0.5.0.RC2
Aún no hay calificaciones
Manual de Usuario para Moskitt 0.5.0.RC2
86 páginas
Symfony2 Es Rev2.0.12
Aún no hay calificaciones
Symfony2 Es Rev2.0.12
797 páginas
01MAIR CFernandez
Aún no hay calificaciones
01MAIR CFernandez
77 páginas
Tutorial Python Org Ar en Latest
100% (1)
Tutorial Python Org Ar en Latest
124 páginas
Tutorial Completo de JavaServer Faces
100% (1)
Tutorial Completo de JavaServer Faces
123 páginas
Aplicación Web para Lesiones Cutáneas
Aún no hay calificaciones
Aplicación Web para Lesiones Cutáneas
63 páginas
Guía del API de Python/C 3.12.5
Aún no hay calificaciones
Guía del API de Python/C 3.12.5
399 páginas
Tutorial de JavaServer Faces JSF
Aún no hay calificaciones
Tutorial de JavaServer Faces JSF
123 páginas
Tutorial de JavaServer Faces
100% (1)
Tutorial de JavaServer Faces
123 páginas
Manual de Apache OFBiz para Desarrolladores
Aún no hay calificaciones
Manual de Apache OFBiz para Desarrolladores
108 páginas
Material Completo
Aún no hay calificaciones
Material Completo
203 páginas
Bashref Es
Aún no hay calificaciones
Bashref Es
203 páginas
Funciones Detalladas
Aún no hay calificaciones
Funciones Detalladas
24 páginas
AS400 Kit Desarrollo para Java - Rzaha
Aún no hay calificaciones
AS400 Kit Desarrollo para Java - Rzaha
224 páginas
Tutorial de Python 3.12.1
Aún no hay calificaciones
Tutorial de Python 3.12.1
165 páginas
Referencia del Lenguaje Python 3.13
Aún no hay calificaciones
Referencia del Lenguaje Python 3.13
222 páginas
Programación Con Objective-C
Aún no hay calificaciones
Programación Con Objective-C
171 páginas
Tutorial de Python 3.12.4
Aún no hay calificaciones
Tutorial de Python 3.12.4
169 páginas
Tutorial
Aún no hay calificaciones
Tutorial
175 páginas
C Api
Aún no hay calificaciones
C Api
349 páginas
Manual de Iniciación a Java
Aún no hay calificaciones
Manual de Iniciación a Java
84 páginas
Trans Java
Aún no hay calificaciones
Trans Java
312 páginas
Documentación del Lenguaje Julia
Aún no hay calificaciones
Documentación del Lenguaje Julia
229 páginas
Guía para nuevos desarrolladores Debian
Aún no hay calificaciones
Guía para nuevos desarrolladores Debian
60 páginas
Guía Completa de Python y Git
Aún no hay calificaciones
Guía Completa de Python y Git
73 páginas
Guia Iniciacion Lenguaje Java
Aún no hay calificaciones
Guia Iniciacion Lenguaje Java
189 páginas
Book Mobile
Aún no hay calificaciones
Book Mobile
695 páginas
JavaScript Book
Aún no hay calificaciones
JavaScript Book
695 páginas
Guía de Desarrollo en OpenERP 7.0
Aún no hay calificaciones
Guía de Desarrollo en OpenERP 7.0
71 páginas
Creando Apis Con Nodejs Express y Mongodb
Aún no hay calificaciones
Creando Apis Con Nodejs Express y Mongodb
183 páginas
Joomla Principiantes
Aún no hay calificaciones
Joomla Principiantes
267 páginas
Guía Completa de WinCC v7 y SCADA
Aún no hay calificaciones
Guía Completa de WinCC v7 y SCADA
470 páginas
Guía de Configuración de Verbio
Aún no hay calificaciones
Guía de Configuración de Verbio
59 páginas
Ubuntu Packaging Guide
Aún no hay calificaciones
Ubuntu Packaging Guide
60 páginas
Air Buildingapps
Aún no hay calificaciones
Air Buildingapps
323 páginas
PensarenC 1 PDF
Aún no hay calificaciones
PensarenC 1 PDF
451 páginas
Air Buildingapps
Aún no hay calificaciones
Air Buildingapps
323 páginas
Guía Completa de Programación en C
Aún no hay calificaciones
Guía Completa de Programación en C
356 páginas
Air Buildingapps Es ES
Aún no hay calificaciones
Air Buildingapps Es ES
326 páginas
Symfony2 Es PDF
100% (1)
Symfony2 Es PDF
812 páginas
Batari Basic Guia
Aún no hay calificaciones
Batari Basic Guia
44 páginas
Manual Koha 3.12 PDF
Aún no hay calificaciones
Manual Koha 3.12 PDF
775 páginas
Referencia Biblioteca ModBusMaster Arduino
100% (1)
Referencia Biblioteca ModBusMaster Arduino
52 páginas
Envío de datos LoRa a servidor HTTP
Aún no hay calificaciones
Envío de datos LoRa a servidor HTTP
9 páginas
Ciclos Límites en Motores de Combustión
Aún no hay calificaciones
Ciclos Límites en Motores de Combustión
11 páginas
Examen de Análisis Matemático III 2013
Aún no hay calificaciones
Examen de Análisis Matemático III 2013
4 páginas
Cambios de entalpía y entropía en N2
Aún no hay calificaciones
Cambios de entalpía y entropía en N2
2 páginas
Rol del Comunicador en Cambio Social
Aún no hay calificaciones
Rol del Comunicador en Cambio Social
38 páginas
P1 - F2 2016II - Solución
Aún no hay calificaciones
P1 - F2 2016II - Solución
4 páginas
Registro para Acceso a Educación Superior
Aún no hay calificaciones
Registro para Acceso a Educación Superior
1 página
Creación de Páginas Web con JavaScript
Aún no hay calificaciones
Creación de Páginas Web con JavaScript
16 páginas
Curso MTCTCE de EcaTel en Bolivia
Aún no hay calificaciones
Curso MTCTCE de EcaTel en Bolivia
298 páginas
Comentarios sobre el Decreto 806 de 2020
Aún no hay calificaciones
Comentarios sobre el Decreto 806 de 2020
42 páginas
Prueba Diagnóstica TIC 7° A y B
0% (1)
Prueba Diagnóstica TIC 7° A y B
3 páginas
Creación y Curación de Contenido Digital
Aún no hay calificaciones
Creación y Curación de Contenido Digital
11 páginas
2.SGD-Como Reiniciar Un Token
Aún no hay calificaciones
2.SGD-Como Reiniciar Un Token
8 páginas
Instalación del Huellero Medipass LME
Aún no hay calificaciones
Instalación del Huellero Medipass LME
14 páginas
Guía para Consultar Facturas en Pegaso
Aún no hay calificaciones
Guía para Consultar Facturas en Pegaso
6 páginas
Automatización de Redes con OSPF y Python
Aún no hay calificaciones
Automatización de Redes con OSPF y Python
12 páginas
Guía de Uso del SIU-Mapuche en UNER
Aún no hay calificaciones
Guía de Uso del SIU-Mapuche en UNER
19 páginas
Guía Completa de Laravel 5 para Desarrolladores
Aún no hay calificaciones
Guía Completa de Laravel 5 para Desarrolladores
135 páginas
Trucos Ocultos para Android
Aún no hay calificaciones
Trucos Ocultos para Android
327 páginas
Instrucciones para el Portal de Proveedores IRSA
Aún no hay calificaciones
Instrucciones para el Portal de Proveedores IRSA
6 páginas
Primeros Pasos en Ventas de Colágeno
Aún no hay calificaciones
Primeros Pasos en Ventas de Colágeno
16 páginas
Registro de Clientes SPB Colombia SAS
Aún no hay calificaciones
Registro de Clientes SPB Colombia SAS
3 páginas
Cómo verificar tus datos móviles restantes
Aún no hay calificaciones
Cómo verificar tus datos móviles restantes
1 página
Examen Tmfa Informatica L
Aún no hay calificaciones
Examen Tmfa Informatica L
40 páginas
Validación de Títulos Electrónicos UMNG
Aún no hay calificaciones
Validación de Títulos Electrónicos UMNG
22 páginas
Taller de Escaneo con Nessus SENA
Aún no hay calificaciones
Taller de Escaneo con Nessus SENA
9 páginas
7.4.2 Lab - Implement DHCPv4 - .Docxdham
Aún no hay calificaciones
7.4.2 Lab - Implement DHCPv4 - .Docxdham
8 páginas
Glosario de Términos de Redes y Conexiones
Aún no hay calificaciones
Glosario de Términos de Redes y Conexiones
15 páginas
Planeación Didáctica: Cultura Digital I
Aún no hay calificaciones
Planeación Didáctica: Cultura Digital I
29 páginas
Tutorial HTML
Aún no hay calificaciones
Tutorial HTML
83 páginas
Ingeniería de Requisitos en Software
Aún no hay calificaciones
Ingeniería de Requisitos en Software
80 páginas
Características y Aplicaciones del Motor Shunt
100% (2)
Características y Aplicaciones del Motor Shunt
36 páginas
Ahorra con BBVA Plan: Tu meta financiera
Aún no hay calificaciones
Ahorra con BBVA Plan: Tu meta financiera
5 páginas
Solucionario OAD 2022 Ud01 PDF
Aún no hay calificaciones
Solucionario OAD 2022 Ud01 PDF
19 páginas
Evolución de la Comunicación Histórica
Aún no hay calificaciones
Evolución de la Comunicación Histórica
3 páginas
Desarrollo de Aplicaciones Web con React
Aún no hay calificaciones
Desarrollo de Aplicaciones Web con React
8 páginas