PyModbus

https://pymodbus.readthedocs.io/en/latest/
Admin
PyModbus is a full Modbus protocol implementation offering a client, server and simulator with...
Tokens:98,050
Snippets:837
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup Section Configuration

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/library/simulator/config.rst.txt

Example configuration for the 'setup' section, defining register block sizes, shared block usage, and default values for different data types.

```json
"setup": {
    "co size": 10,
    "di size": 20,
    "hr size": 15,
    "ir size": 25,
    "shared blocks": true,
    "type exception": true,
    "defaults": {
        "value": {
            "bits": 0,
            "uint16": 0,
            "uint32": 0,
            "float32": 0.0,
            "string": " "
        },
        "action": {
            "bits": null,
            "uint16": "register",
            "uint32": "register",
            "float32": "register",
            "string": null
        }
    }
}
```

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

### Install Documentation Tools

Source: https://pymodbus.readthedocs.io/en/latest?badge=latest

Installs the necessary tools for building the project documentation. This command assumes you have pip installed.

```bash
pip install ".[documentation]"
```

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

### Simulator Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates a simulator using PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient


def run_simulator():
    client = ModbusTcpClient(host='127.0.0.1', port=5020)
    client.connect()
    # Example: Read holding registers
    result = client.read_holding_registers(1, 10)
    print(f"Simulator read result: {result}")
    client.close()


def main():
    run_simulator()


if __name__ == "__main__":
    main()

```

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

### Server Updating Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Shows how to implement a server that updates its data store in PyModbus. This example requires running from the examples directory.

```python
import asyncio

from pymodbus.server import AsyncModbusTcpServer
from pymodbus.device import ModbusDevice
from pymodbus.datastore import ModbusServerContext, ModbusSlaveContext


async def update_data(context):
    # Example: update a holding register every second
    while True:
        await asyncio.sleep(1)
        # Read current value
        current_value = context.getValues(1, 1)[0]
        # Increment and write back
        context.setValues(1, [current_value + 1])
        print(f"Updated register 1 to {current_value + 1}")


async def run_server():
    # Initialize datastore
    store = ModbusServerContext(single=True)

    # Initialize server
    server = AsyncModbusTcpServer(context=store, address=('127.0.0.1', 5020))

    # Start server and data update task
    asyncio.create_task(update_data(store))
    await server.serve_forever()


async def main():
    await run_server()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Server Asynchronous Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates setting up an asynchronous Modbus TCP server using PyModbus. This example requires running from the examples directory.

```python
import asyncio

from pymodbus.server import AsyncModbusTcpServer
from pymodbus.device import ModbusDevice
from pymodbus.datastore import ModbusServerContext, ModbusSlaveContext


async def run_server():
    # Initialize datastore
    store = ModbusServerContext(single=True)

    # Initialize server
    server = AsyncModbusTcpServer(context=store, address=('127.0.0.1', 5020))

    # Start server
    await server.serve_forever()


async def main():
    await run_server()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Client Calls Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates various client call methods in PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient
from pymodbus.exceptions import ConnectionException


def run_calls():
    client = ModbusTcpClient(host='127.0.0.1', port=5020)
    try:
        client.connect()
        # read a holding register (10)
        rr = client.read_holding_registers(1, 10)
        # write a single holding register (10)
        wr = client.write_holding_register(1, 0x01)
        # read multiple holding registers (10, 12)
        mr = client.read_holding_registers(10, 12)
        # write multiple holding registers (10, 12)
        mw = client.write_holding_registers(10, [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B])
    except ConnectionException as e:
        print(f"Unable to connect to {client.host}:{client.port} - {e}")
    finally:
        client.close()


def main():
    run_calls()


if __name__ == "__main__":
    main()

```

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

### Server Synchronous Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates setting up a synchronous Modbus TCP server using PyModbus. This example requires running from the examples directory.

```python
from pymodbus.server import ModbusTcpServer
from pymodbus.device import ModbusDevice
from pymodbus.datastore import ModbusServerContext, ModbusSlaveContext


def run_server():
    # Initialize datastore
    store = ModbusServerContext(single=True)

    # Initialize server
    server = ModbusTcpServer(context=store, address=('127.0.0.1', 5020))

    # Start server
    server.serve_forever()


def main():
    run_server()


if __name__ == "__main__":
    main()

```

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

### Solar Contribution Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

A user-contributed example demonstrating solar-related Modbus communication with PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient


def run_solar():
    client = ModbusTcpClient(host='127.0.0.1', port=5020)
    client.connect()
    # Example: Read solar inverter data
    result = client.read_holding_registers(0, 10)
    print(f"Solar data read result: {result}")
    client.close()


def main():
    run_solar()


if __name__ == "__main__":
    main()

```

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

### Simulator Datastore (Shared Storage) Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Illustrates a simulator using shared storage for its datastore in PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient
from pymodbus.datastore import ModbusSharedContext, ModbusSlaveContext


def run_simulator_share():
    # Initialize datastore with shared context
    store = ModbusSharedContext()
    client = ModbusTcpClient(host='127.0.0.1', port=5020, context=store)
    client.connect()
    # Example: Read holding registers
    result = client.read_holding_registers(1, 10)
    print(f"Simulator shared datastore read result: {result}")
    client.close()


def main():
    run_simulator_share()


if __name__ == "__main__":
    main()

```

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

### Pymodbus Asynchronous Client Example Usage

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This script provides an example of a pymodbus asynchronous client. It outlines the command-line arguments for configuring communication type, framer, log level, port, baud rate, and host. Ensure the corresponding server is started before running.

```python
client_async.py [-h] [-c {tcp,udp,serial,tls}]
                [-f {ascii,rtu,socket,tls}]
                [-l {critical,error,warning,info,debug}] [-p PORT]
                [--baudrate BAUDRATE] [--host HOST]

-h, --help
    show this help message and exit
-c, -comm {tcp,udp,serial,tls}
    set communication, default is tcp
-f, --framer {ascii,rtu,socket,tls}
    set framer, default depends on --comm
-l, --log {critical,error,warning,info,debug}
    set log level, default is info
-p, --port PORT
    set port
--baudrate BAUDRATE
    set serial device baud rate
--host HOST
    set host, default is 127.0.0.1

```

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

### Client Synchronous Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Provides an example of synchronous client operations in PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient
from pymodbus.exceptions import ConnectionException


def run_sync():
    client = ModbusTcpClient(host='127.0.0.1', port=5020)
    try:
        client.connect()
        # read a holding register (10)
        rr = client.read_holding_registers(1, 10)
        # write a single holding register (10)
        wr = client.write_holding_register(1, 0x01)
        # read multiple holding registers (10, 12)
        mr = client.read_holding_registers(10, 12)
        # write multiple holding registers (10, 12)
        mw = client.write_holding_registers(10, [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B])
    except ConnectionException as e:
        print(f"Unable to connect to {client.host}:{client.port} - {e}")
    finally:
        client.close()


def main():
    run_sync()


if __name__ == "__main__":
    main()

```

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

### Full TCP Server Configuration Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/library/simulator/config.rst.txt

A comprehensive example of a TCP server configuration, including identity details and optional parameters like ignore_missing_devices.

```json
{
       "server_list": {
            "server": {
                "comm": "tcp",
                "host": "0.0.0.0",
                "port": 5020,
                "ignore_missing_devices": false,
                "framer": "socket",
                "identity": {
                    "VendorName": "pymodbus",
                    "ProductCode": "PM",
                    "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                    "ProductName": "pymodbus Server",
                    "ModelName": "pymodbus Server",
                    "MajorMinorRevision": "3.1.0"
                }
            },
            "server_try_serial": {
                "comm": "serial",
                "port": "/dev/tty0",
                "stopbits": 1,
                "bytesize": 8,
                "parity": "N",
                "baudrate": 9600,
                "timeout": 3,
                "reconnect_delay": 2,
                "framer": "rtu",
                "identity": {
                    "VendorName": "pymodbus",
                    "ProductCode": "PM",
                    "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                    "ProductName": "pymodbus Server",
                    "ModelName": "pymodbus Server",
                    "MajorMinorRevision": "3.1.0"
                }
            },
            "server_try_tls": {
                "comm": "tls",
                "host": "0.0.0.0",
                "port": 5020,
                "certfile": "certificates/pymodbus_tls.crt",
                "keyfile": "certificates/pymodbus_tls.key",
                "ignore_missing_devices": false,
                "framer": "tls",
                "identity": {
                    "VendorName": "pymodbus",
                    "ProductCode": "PM",

```

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

### Client Asynchronous Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Provides an example of asynchronous client operations in PyModbus. This example requires running from the examples directory.

```python
import asyncio

from pymodbus.client import AsyncModbusTcpClient
from pymodbus.exceptions import ConnectionException


async def run_async():
    client = AsyncModbusTcpClient(host='127.0.0.1', port=5020)
    try:
        await client.connect()
        # read a holding register (10)
        rr = await client.read_holding_registers(1, 10)
        # write a single holding register (10)
        wr = await client.write_holding_register(1, 0x01)
        # read multiple holding registers (10, 12)
        mr = await client.read_holding_registers(10, 12)
        # write multiple holding registers (10, 12)
        mw = await client.write_holding_registers(10, [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B])
    except ConnectionException as e:
        print(f"Unable to connect to {client.host}:{client.port} - {e}")
    finally:
        client.close()


async def main():
    await run_async()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Device Setup Configuration

Source: https://pymodbus.readthedocs.io/en/latest/source/library/simulator/config.html

Configuration for device setup, including sizes for different data types and default values.

```json
{
    "device_list": {
        "device": {
            "setup": {
                "co size": 63000,
                "di size": 63000,
                "hr size": 63000,
                "ir size": 63000,
                "shared blocks": true,
                "type exception": true,
                "defaults": {
                    "value": {
                        "bits": 0,
                        "uint16": 0,
                        "uint32": 0,
                        "float32": 0.0,
                        "string": " "
                    },
                    "action": {
                        "bits": null,
                        "uint16": "increment",
                        "uint32": "increment",
                        "float32": "increment",
                        "string": null
                    }
                }
            }
        }
    }
}
```

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

### Simple Synchronous Client Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates basic synchronous client functionality in PyModbus. This example can be run directly.

```python
from pymodbus.client import ModbusTcpClient


def main():
    # Initialize the client
    client = ModbusTcpClient(host='127.0.0.1', port=5020)

    # Connect to the server
    client.connect()

    # Read holding registers (example)
    result = client.read_holding_registers(1, 10)

    # Process the result
    if not result.isError():
        print(f"Read registers: {result.registers}")
    else:
        print(f"Error reading registers: {result}")

    # Close the connection
    client.close()


if __name__ == "__main__":
    main()

```

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

### Pymodbus Synchronous Client Example Usage

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This script provides an example of a pymodbus single-threaded synchronous client. It outlines the command-line arguments for configuring communication type, framer, log level, port, baud rate, and host. Ensure the corresponding server is started before running.

```python
client_sync.py [-h] [-c {tcp,udp,serial,tls}]
                [-f {ascii,rtu,socket,tls}]
                [-l {critical,error,warning,info,debug}] [-p PORT]
                [--baudrate BAUDRATE] [--host HOST]

-h, --help
    show this help message and exit
-c, --comm {tcp,udp,serial,tls}
    set communication, default is tcp
-f, --framer {ascii,rtu,socket,tls}
    set framer, default depends on --comm
-l, --log {critical,error,warning,info,debug}
    set log level, default is info
-p, --port PORT
    set port
--baudrate BAUDRATE
    set serial device baud rate
--host HOST
    set host, default is 127.0.0.1

```

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

### Device Configuration - Basic Setup

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/library/simulator/config.rst.txt

Defines the basic setup for a device, including data sizes for different register types and general settings like shared blocks and type exceptions.

```json
{
        "server_list": {
            ...
        },
        "device_list": {
            "device": {
                "setup": {
                    "co size": 63000,
                    "di size": 63000,
                    "hr size": 63000,
                    "ir size": 63000,
                    "shared blocks": true,
                    "type exception": true,
                    "defaults": {
                        "value": {
                            "bits": 0,
                            "uint16": 0,
                            "uint32": 0,
                            "float32": 0.0,
                            "string": " "
                        },
                        "action": {
                            "bits": null,
                            "uint16": "register",
                            "uint32": "register",
                            "float32": "register",
                            "string": null
                        }
                    }
                },
                "invalid": [
                    1
                ],
                "write": [
                    5
                ],
                "bits": [
                    {"addr": 2, "value": 7}
                ],
                "uint16": [
                    {"addr": 3, "value": 17001},
                    2100
                ],
                "uint32": [
                    {"addr": 4, "value": 617001},
                    [3037, 3038]
                ],
                "float32": [
                    {"addr": 6, "value": 404.17},
                    [4100, 4101]
                ],
                "string": [
                    5047,
                    {"addr": [16, 20], "value": "A_B_C_D_E_"}
                ],
                "repeat": [
                ]
            },
            "device_try": {
                "setup": {
                    "co size": 63000,
                    "di size": 63000,
                    "hr size": 63000,
                    "ir size": 63000,
                    "shared blocks": true,
                    "type exception": true,
                    "defaults": {
                        "value": {
                            "bits": 0,
                            "uint16": 0,
                            "uint32": 0,
                            "float32": 0.0,
                            "string": " "
                        },
                        "action": {
                            "bits": null,
                            "uint16": "register",
                            "uint32": "register",
                            "float32": "register",
                            "string": null
                        }
                    }
                },
                "invalid": [
                    [0, 5],
                    77
                ],
                "write": [
                    10,
                    [61, 76]
                ],
                "bits": [
                    10,
                    1009,
                    [1116, 1119],
                    {"addr": 1144, "value": 1},
                    {"addr": [1148,1149], "value": 32117},
                    {"addr": [1208, 1306], "action": "random"}
                ],
                "uint16": [
                    11,
                    2027,
                    [2126, 2129],
                    {"addr": 2164, "value": 1},
                    {"addr": [2168,2169], "value": 32117},
                    {"addr": [2208, 2306], "action": null}
                ],
                "uint32": [
                    12,
                    3037,
                    [3136, 3139],
                    {"addr": 3174, "value": 1},
                    {"addr": [3188,3189], "value": 32514},
                    {"addr": [3308, 3406], "action": null},

```

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

### Simple Asynchronous Client Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates basic asynchronous client functionality in PyModbus. This example can be run directly.

```python
import asyncio

from pymodbus.client import AsyncModbusTcpClient


async def main():
    # Initialize the client
    client = AsyncModbusTcpClient(host='127.0.0.1', port=5020)

    # Connect to the server
    await client.connect()

    # Read holding registers (example)
    result = await client.read_holding_registers(1, 10)

    # Process the result
    if not result.isError():
        print(f"Read registers: {result.registers}")
    else:
        print(f"Error reading registers: {result}")

    # Close the connection
    client.close()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Server Tracer Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Shows how to implement a server-side tracer or hook in PyModbus to monitor requests and responses. This example requires running from the examples directory.

```python
import asyncio

from pymodbus.server import AsyncModbusTcpServer
from pymodbus.device import ModbusDevice
from pymodbus.datastore import ModbusServerContext, ModbusSlaveContext


def server_hook(context, unit):
    print(f"Server hook called for unit {unit} with context {context}")


async def run_server():
    # Initialize datastore
    store = ModbusServerContext(single=True)

    # Initialize server
    server = AsyncModbusTcpServer(context=store, address=('127.0.0.1', 5020), server_hook=server_hook)

    # Start server
    await server.serve_forever()


async def main():
    await run_server()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Server Data Model Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/simulator/datamodel.rst.txt

This example demonstrates how to set up the data model for the pymodbus simulator server. It includes definitions for SimData and SimDevice to represent registers and device parameters.

```python
from pymodbus.sim import SimServer
from pymodbus.device import ModbusDevice
from pymodbus.sim import SimData, SimDevice


# Define a data block for holding registers
# The first parameter is the starting address of the block
# The second parameter is the number of registers in the block
data_block = SimData(
    addr=0x00,
    count=100,
    data=[0x00] * 100
)

# Define a device with the data block
# The first parameter is the device address
# The second parameter is a list of SimData objects
device = SimDevice(address=1, data_blocks=[data_block])

# Define a server with the device
# The first parameter is the list of SimDevice objects
# The second parameter is the communication parameters
server = SimServer(devices=[device], comm_params=("tcp", 5020))

# Start the server
server.start()

# The server will run until it is stopped
# server.stop()
```

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

### Client Asynchronous Calls Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Illustrates advanced asynchronous client call patterns in PyModbus. This example requires running from the examples directory.

```python
import asyncio

from pymodbus.client import AsyncModbusTcpClient
from pymodbus.exceptions import ConnectionException


async def run_calls():
    client = AsyncModbusTcpClient(host='127.0.0.1', port=5020)
    try:
        await client.connect()
        # read a holding register (10)
        rr = await client.read_holding_registers(1, 10)
        # write a single holding register (10)
        wr = await client.write_holding_register(1, 0x01)
        # read multiple holding registers (10, 12)
        mr = await client.read_holding_registers(10, 12)
        # write multiple holding registers (10, 12)
        mw = await client.write_holding_registers(10, [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B])
    except ConnectionException as e:
        print(f"Unable to connect to {client.host}:{client.port} - {e}")
    finally:
        client.close()


async def main():
    await run_calls()


if __name__ == "__main__":
    asyncio.run(main())

```

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

### Pymodbus Server Datamodel Setup

Source: https://pymodbus.readthedocs.io/en/latest/source/simulator/datamodel.html

This script demonstrates the setup and configuration of the datamodel for a Pymodbus server or simulator. It includes defining various data types and register groups.

```python
#!/usr/bin/env python3
"""Pymodbus server datamodel examples.

This file shows examples of how to configure the datamodel for the server/simulator.

There are different examples showing the flexibility of the datamodel.

**REMARK** This code is experimental and not integrated into production.

"""

from pymodbus.simulator import DataType, SimData, SimDevice


def define_datamodel():
    """Define register groups.

    Coils and discrete inputs are modeled as bits representing a relay in the device.
    There are no real difference between coils and discrete inputs, but historically
    they have been divided. Please be aware the coils and discrete inputs are addressed differently
    in shared vs non-shared models.
    - In a non-shared model the address is the bit directly.
      It can be thought of as if 1 register == 1 bit.
    - In a shared model the address is the register containing the bits.
      1 register == 16bit, so a single bit CANNOT be addressed directly.

Holding registers and input registers are modeled as int/float/string representing a sensor in the device.
There are no real difference between holding registers and input registers, but historically they have
been divided.
Please be aware that 1 sensor might be modeled as several register because it needs more than
16 bit for accuracy (e.g. a INT32).
    """
    # SimData can be instantiated with positional or optional parameters:
    assert SimData(5, 10, 17, DataType.REGISTERS) == SimData(
        address=5, values=17, count=10, datatype=DataType.REGISTERS
    )

    # Define a group of coils/discrete inputs non-shared (address=15..31 each 1 bit)
    # block1 = SimData(address=15, count=16, values=True, datatype=DataType.BITS)
    # Define a group of coils/discrete inputs shared (address=15..31 each 16 bit)
    # block2 = SimData(address=15, count=16, values=0xFFFF, datatype=DataType.BITS)

    # Define a group of holding/input registers (remark NO difference between shared and non-shared)
    # block3 = SimData(10, 1, 123.4, datatype=DataType.FLOAT32)
    # block4 = SimData(17, count=5, values=123, datatype=DataType.INT64)
    block5 = SimData(1027, 1, "Hello ", datatype=DataType.STRING)

    block_def = SimData(0, count=1000, datatype=DataType.REGISTERS)

    # SimDevice can be instantiated with positional or optional parameters:
    assert SimDevice(
        5,
        [block_def, block5],
    ) == SimDevice(id=5, simdata=[block_def, block5])

    # SimDevice can define either a shared or a non-shared register model
    SimDevice(id=1, simdata=[block_def, block5])
    # SimDevice(2, False,
    #          block_coil=[block1],
    #          block_discrete=[block1],
    #          block_holding=[block2],
    #          block_input=[block3, block4])
    # Remark: it is legal to reuse SimData, the object is only used for configuration,
    # not for runtime.

    # id=0 in a SimDevice act as a "catch all". Requests to an unknown id is executed in this SimDevice.
    # SimDevice(0, block_shared=[block2])


def main():
    """Combine setup and run."""
    define_datamodel()


if __name__ == "__main__":
    main()

```

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

### Message Parser Example

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/examples.rst.txt

Demonstrates how to parse Modbus messages using PyModbus. This example requires running from the examples directory.

```python
from pymodbus.client import ModbusTcpClient
from pymodbus.exceptions import ConnectionException
from pymodbus.message import ModbusRequest, ModbusResponse


def run_message_parser():
    client = ModbusTcpClient(host='127.0.0.1', port=5020)
    try:
        client.connect()
        # Create a request
        request = ModbusRequest(function_code=3, address=1, count=10)
        # Execute and get response
        response = client.execute(request)
        # Parse the response
        print(f"Parsed response: {response}")
    except ConnectionException as e:
        print(f"Unable to connect to {client.host}:{client.port} - {e}")
    finally:
        client.close()


def main():
    run_message_parser()


if __name__ == "__main__":
    main()

```

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

### Asynchronous Server Example

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This example demonstrates a multi-threaded asynchronous server. It can be configured with various communication protocols, framers, and logging levels.

```python
from pymodbus.server.async_io import ModbusTcpServer, ModbusUdpServer, ModbusTlsServer
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.entrypoints import run_server

if __name__ == "__main__":
    run_server(
        ModbusTcpServer,
        "--port", 5020,
        "--comm", "tcp",
        "--framer", "tcp",
        "--log", "INFO",
    )

```

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

### Simulator Server/Client Example

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This example demonstrates how to use the pymodbus simulator as a server and interact with it using a client. It's useful for testing modbus communication without a physical device.

```python
from pymodbus.simulator import simulator

if __name__ == "__main__":
    simulator(port=5020)

```

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

### Synchronous Server Example

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This example demonstrates a single-threaded synchronous server. It is a simpler alternative to the asynchronous server but may be slower for certain operations.

```python
from pymodbus.server.sync_io import ModbusServer
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.entrypoints import run_server

if __name__ == "__main__":
    run_server(
        ModbusServer,
        "--port", 5020,
        "--comm", "tcp",
        "--framer", "tcp",
        "--log", "INFO",
    )

```

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

### run_forever

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts the modbus and http servers. Can optionally start only the modbus server.

```APIDOC
## Function: run_forever

### Description
Start modbus and http servers.

### Parameters
* `_only_start`: bool (default: False)
```

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

### Server Start Functions

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Functions for starting various types of Modbus servers, both synchronous and asynchronous.

```APIDOC
## Server Start Functions

### Description
Functions to initiate and start different Modbus server implementations.

### Functions
- `ServerAsyncStop()`
- `ServerStop()`
- `StartAsyncSerialServer()`
- `StartAsyncTcpServer()`
- `StartAsyncTlsServer()`
- `StartAsyncUdpServer()`
- `StartSerialServer()`
- `StartTcpServer()`
- `StartTlsServer()`
- `StartUdpServer()`
```

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

### Generate Documentation

Source: https://pymodbus.readthedocs.io/en/latest/index.html

Builds the HTML documentation for the project. Ensure you have installed the necessary documentation tools first.

```bash
cd doc
./build_html
```

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

### Comprehensive Server Configuration Examples

Source: https://pymodbus.readthedocs.io/en/latest/source/library/simulator/config.html

This snippet provides examples for configuring various Modbus server types including TCP, Serial, TLS, and UDP. It demonstrates detailed settings for each protocol, including identity information.

```json
{
   "server_list": {
        "server": {
            "comm": "tcp",
            "host": "0.0.0.0",
            "port": 5020,
            "ignore_missing_devices": false,
            "framer": "socket",
            "identity": {
                "VendorName": "pymodbus",
                "ProductCode": "PM",
                "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                "ProductName": "pymodbus Server",
                "ModelName": "pymodbus Server",
                "MajorMinorRevision": "3.1.0"
            }
        },
        "server_try_serial": {
            "comm": "serial",
            "port": "/dev/tty0",
            "stopbits": 1,
            "bytesize": 8,
            "parity": "N",
            "baudrate": 9600,
            "timeout": 3,
            "reconnect_delay": 2,
            "framer": "rtu",
            "identity": {
                "VendorName": "pymodbus",
                "ProductCode": "PM",
                "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                "ProductName": "pymodbus Server",
                "ModelName": "pymodbus Server",
                "MajorMinorRevision": "3.1.0"
            }
        },
        "server_try_tls": {
            "comm": "tls",
            "host": "0.0.0.0",
            "port": 5020,
            "certfile": "certificates/pymodbus_tls.crt",
            "keyfile": "certificates/pymodbus_tls.key",
            "ignore_missing_devices": false,
            "framer": "tls",
            "identity": {
                "VendorName": "pymodbus",
                "ProductCode": "PM",
                "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                "ProductName": "pymodbus Server",
                "ModelName": "pymodbus Server",
                "MajorMinorRevision": "3.1.0"
            }
        },
        "server_test_try_udp": {
            "comm": "udp",
            "host": "0.0.0.0",
            "port": 5020,
            "ignore_missing_devices": false,
            "framer": "socket",
            "identity": {
                "VendorName": "pymodbus",
                "ProductCode": "PM",
                "VendorUrl": "https://github.com/pymodbus-dev/pymodbus",
                "ProductName": "pymodbus Server",
                "ModelName": "pymodbus Server",
                "MajorMinorRevision": "3.1.0"
            }
        }
    }
}

```

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

### Start PyModbus Simulator

Source: https://pymodbus.readthedocs.io/en/latest/index.html

This command starts the PyModbus simulator. It can be configured using various flags to specify the data context and server type.

```bash
pymodbus.simulator --modbus_device device_try

```

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

### Server Tracer Example

Source: https://pymodbus.readthedocs.io/en/latest/source/examples.html

This example shows how to use the built-in request/response tracer to manipulate messages to and from the modbus server. This allows for custom handling of communication.

```python
from pymodbus.server.sync_io import ModbusServer
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.callback import callback, ModbusCallbackCollection
from pymodbus.constants import ExceptionResponse
from pymodbus.exceptions import NoSuchSlave
from pymodbus.message import ModbusRequest, ModbusResponse


class MyModbusCallbackCollection(ModbusCallbackCollection):
    def __init__(self):
        super().__init__()

    def _call(self, request):
        print(f"Received: {request}")
        response = request.do(self)
        print(f"Responded: {response}")
        return response


if __name__ == "__main__":
    callbacks = MyModbusCallbackCollection()
    server = ModbusServer(callbacks=callbacks)
    server.run_forever()

```

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

### Install PyModbus Development Tools in Editable Mode

Source: https://pymodbus.readthedocs.io/en/latest/index.html

Install PyModbus and its development dependencies in editable mode, recommended for making changes.

```bash
pip install -e ".[development]"
```

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

### start_modbus_server

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts the Modbus server as an asyncio task.

```APIDOC
## Function: start_modbus_server

### Description
Start Modbus server as asyncio task.

### Parameters
* `_app`: An application object.
```

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

### action_monitor

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts monitoring calls.

```APIDOC
## Function: action_monitor

### Description
Start monitoring calls.

### Parameters
* `_params_`: Any
* `_range_start_`: Any
* `_range_stop_`: Any
```

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

### Convert ModbusSequentialDataBlock to SimData/SimDevice

Source: https://pymodbus.readthedocs.io/en/latest/_sources/source/upgrade_40.rst.txt

Example demonstrating the conversion of ModbusSequentialDataBlock to the new SimData/SimDevice format for server context initialization.

```python
dev = ModbusDeviceContext(
                co=ModbusSequentialDataBlock(0x01, 15),
                di=ModbusSequentialDataBlock(0x01, [16]),
                hr=ModbusSequentialDataBlock(0x01, [17]),
                ir=ModbusSequentialDataBlock(0x01, [18])
    )
    server_context = ModbusServerContext(
                        devices={1: dev,
                                 0: dev
                                })
    await StartAsync**Server(context=server_context)
```

```python
from pymodbus.simulator import SimData, SimDevice, DataType

devices = [SimDevice(1, simdata=(
                        SimData(0x01, values=15, datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS)
                    )
                ),
                SimDevice(1, simdata=(
                        SimData(0x01, values=15, datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS),
                        SimData(0x01, values=[17], datatype=DataType.REGISTERS)
                    )
                )
    ]
    await StartAsync**Server(context=devices)
```

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

### StartAsyncTlsServer

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts and runs a TLS modbus server. Handles a single server. For multiple servers, use ModbusTlsServer.

```APIDOC
## Function: StartAsyncTlsServer

### Description
Start and run a tls modbus server.

### Tip
Only handles a single server!
Use ModbusTlsServer to allow multiple servers in one app.

### Parameters
* `_context`: ModbusServerContext | SimDevice | list[SimDevice]
* `_**kwargs`: For parameter explanation see ModbusTlsServer.
```

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

### Simulator REST API Response Example

Source: https://pymodbus.readthedocs.io/en/latest/source/library/simulator/restapi.html

This is an example response from the simulator's REST API, showing the configuration for simulation actions, function codes, and error handling. It indicates that the simulation action is active and lists available function codes.

```json
{
    "simulation_action": "ACTIVE",
    "range_start": null,
    "range_stop": null,
    "function_codes": [
        {
            "value": 3,
            "text": "read_holding_registers",
            "selected": false
        },
        {
            "value": 2,
            "text": "read_discrete_input",
            "selected": false
        },
        {
            "value": 4,
            "text": "read_input_registers",
            "selected": false
        },
        {
            "value": 1,
            "text": "read_coils",
            "selected": false
        },
        {
            "value": 15,
            "text": "write_coils",
            "selected": false
        },
        {
            "value": 16,
            "text": "write_registers",
            "selected": false
        },
        {
            "value": 6,
            "text": "write_register",
            "selected": false
        },
        {
            "value": 5,
            "text": "write_coil",
            "selected": false
        },
        {
            "value": 23,
            "text": "read_write_multiple_registers",
            "selected": false
        },
        {
            "value": 8,
            "text": "diagnostic_status",
            "selected": false
        },
        {
            "value": 7,
            "text": "read_exception_status",
            "selected": false
        },
        {
            "value": 11,
            "text": "get_event_counter",
            "selected": false
        },
        {
            "value": 12,
            "text": "get_event_log",
            "selected": false
        },
        {
            "value": 17,
            "text": "report_device_id",
            "selected": false
        },
        {
            "value": 20,
            "text": "read_file_record",
            "selected": false
        },
        {
            "value": 21,
            "text": "write_file_record",
            "selected": false
        },
        {
            "value": 22,
            "text": "mask_write_register",
            "selected": false
        },
        {
            "value": 24,
            "text": "read_fifo_queue",
            "selected": false
        },
        {
            "value": 43,
            "text": "read_device_information",
            "selected": false
        }
    ],
    "function_show_hex_checked": false,
    "function_show_decoded_checked": false,
    "function_response_normal_checked": true,
    "function_response_error_checked": false,
    "function_response_empty_checked": false,
    "function_response_junk_checked": false,
    "function_response_split_checked": true,
    "function_response_split_delay": 1,
    "function_response_cr_checked": false,
    "function_response_cr_pct": 0,
    "function_response_delay": 0,
    "function_response_junk": 0,
    "function_error": [
        {
            "value": 1,
            "text": "ILLEGAL_FUNCTION",
            "selected": false
        },
        {
            "value": 2,
            "text": "ILLEGAL_ADDRESS",
            "selected": false
        },
        {
            "value": 3,
            "text": "ILLEGAL_VALUE",
            "selected": false
        },
        {
            "value": 4,
            "text": "DEVICE_FAILURE",
            "selected": false
        },
        {
            "value": 5,
            "text": "ACKNOWLEDGE",
            "selected": false
        },
        {
            "value": 6,
            "text": "DEVICE_BUSY",
            "selected": false
        },
        {
            "value": 7,
            "text": "MEMORY_PARITY_ERROR",
            "selected": false
        },
        {
            "value": 10,
            "text": "GATEWAY_PATH_UNAVIABLE",
            "selected": false
        },
        {
            "value": 11,
            "text": "GATEWAY_NO_RESPONSE",
            "selected": false
        }
    ],
    "function_response_clear_after": 1,
    "call_rows": [],
    "foot": "not active",
    "result": "ok"
}
```

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

### StartAsyncTcpServer

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts and runs a TCP modbus server. Handles a single server. For multiple servers, use ModbusTcpServer.

```APIDOC
## Function: StartAsyncTcpServer

### Description
Start and run a tcp modbus server.

### Tip
Only handles a single server!
Use ModbusTcpServer to allow multiple servers in one app.

### Parameters
* `_context`: ModbusServerContext | SimDevice | list[SimDevice]
* `_**kwargs`: For parameter explanation see ModbusTcpServer.
```

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

### StartTlsServer

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts and runs a Modbus TLS server. This function is designed for single-server applications.

```APIDOC
## StartTlsServer

### Description
Starts and runs a Modbus TLS server. This function handles a single server instance.

### Method
N/A (Synchronous function, but context implies async operation is possible with other server types)

### Endpoint
N/A (Python function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **context** (ModbusServerContext | SimDevice | list[SimDevice]) - Datastore object.
* **kwargs** - Additional keyword arguments, see ModbusTlsServer for parameter explanations.
```

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

### StartAsyncUdpServer

Source: https://pymodbus.readthedocs.io/en/latest/source/server.html

Starts and runs an asynchronous UDP Modbus server. This function is intended for single-server applications.

```APIDOC
## StartAsyncUdpServer

### Description
Starts and runs an asynchronous UDP Modbus server. This function handles a single server instance.

### Method
async

### Endpoint
N/A (Python function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **context** (ModbusServerContext | SimDevice | list[SimDevice]) - Datastore object.
* **kwargs** - Additional keyword arguments, see ModbusUdpServer for parameter explanations.
```
Tokens:
Raw