skip to navigation
skip to content

uModbus 0.8.2

Implementation of the Modbus protocol in pure Python.


uModbus or (μModbus) is a pure Python implementation of the Modbus protocol as described in the MODBUS Application Protocol Specification V1.1b3. uModbus implements both a Modbus client (both TCP and RTU) and a Modbus server (both TCP and RTU). The “u” or “μ” in the name comes from the the SI prefix “micro-“. uModbus is very small and lightweight. The source can be found on GitHub. Documentation is available at Read the Docs.


Creating a Modbus TCP server is easy:

#!/usr/bin/env python
# scripts/examples/
import logging
from socketserver import TCPServer
from collections import defaultdict

from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream

# Add stream handler to logger 'uModbus'.

# A very simple data store which maps addresss against their values.
data_store = defaultdict(int)

# Enable values to be signed (default is False).

TCPServer.allow_reuse_address = True
app = get_server(TCPServer, ('localhost', 502), RequestHandler)

@app.route(slave_ids=[1], function_codes=[3, 4], addresses=list(range(0, 10)))
def read_data_store(slave_id, function_code, address):
    """" Return value of address. """
    return data_store[address]

@app.route(slave_ids=[1], function_codes=[6, 16], addresses=list(range(0, 10)))
def write_data_store(slave_id, function_code, address, value):
    """" Set value for address. """
    data_store[address] = value

if __name__ == '__main__':

Doing a Modbus request requires even less code:

#!/usr/bin/env python
# scripts/examples/
import socket

from umodbus import conf
from umodbus.client import tcp

# Enable values to be signed (default is False).

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 502))

# Returns a message or Application Data Unit (ADU) specific for doing
# Modbus TCP/IP.
message = tcp.write_multiple_coils(slave_id=1, starting_address=1, values=[1, 0, 1, 1])

# Response depends on Modbus function code. This particular returns the
# amount of coils written, in this case it is.
response = tcp.send_message(message, sock)



The following Modbus functions have been implemented:

  • 01: Read Coils
  • 02: Read Discrete Inputs
  • 03: Read Holding Registers
  • 04: Read Input Registers
  • 05: Write Single Coil
  • 06: Write Single Register
  • 15: Write Multiple Coils
  • 16: Write Multiple Registers

Other featues:

  • Support for signed and unsigned register values.


uModbus is far from complete. The next, unordered list shows what is going to be implemented in the future:

  • Support for all Modbus functions
  • Other Modbus ‘flavours’, so uModbus is able to handle 32 bit values.


uModbus software is licensed under Mozilla Public License. © 2016 Advanced Climate Systems.

File Type Py Version Uploaded on Size
uModbus-0.8.2-py2.py3-none-any.whl (md5) Python Wheel 2.7 2016-11-11 26KB
uModbus-0.8.2.tar.gz (md5) Source 2016-11-11 19KB