Simulate Modbus Slave Without PLC: 5 Methods Compared (2026)

pymodbus is the most mature Python Modbus library. Writing a Modbus slave (server) in Python gives you full flexibility — custom logic, dynamic register values, integration with databases, test automation frameworks, and CI/CD pipelines.

Installation

pip install pymodbus

Modbus TCP Slave — Minimal Example

import asyncio
from pymodbus.server import StartAsyncTcpServer
from pymodbus.datastore import (
    ModbusSequentialDataBlock,
    ModbusSlaveContext,
    ModbusServerContext,
)

def create_slave_context():
    # Initialize registers: coils, discrete inputs, holding regs, input regs
    # Arguments: address, count, value
    store = ModbusSlaveContext(
        di=ModbusSequentialDataBlock(0, [0] * 100),   # Discrete Inputs
        co=ModbusSequentialDataBlock(0, [0] * 100),   # Coils
        hr=ModbusSequentialDataBlock(0, [0] * 200),   # Holding Registers
        ir=ModbusSequentialDataBlock(0, [0] * 200),   # Input Registers
    )
    # Set some initial values (holding register 0-4)
    store.setValues(3, 0, [1234, 5678, 9012, 3456, 7890])
    return store

async def run_server():
    context = ModbusServerContext(
        slaves={1: create_slave_context()},  # unit ID 1
        single=False
    )
    print("Starting Modbus TCP slave on 0.0.0.0:502")
    await StartAsyncTcpServer(
        context=context,
        address=("0.0.0.0", 502)
    )

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

Modbus RTU Slave — Serial Port Example

import asyncio
from pymodbus.server import StartAsyncSerialServer
from pymodbus.datastore import ModbusSequentialDataBlock, ModbusSlaveContext, ModbusServerContext

async def run_rtu_server():
    store = ModbusSlaveContext(
        hr=ModbusSequentialDataBlock(0, [100, 200, 300, 400, 500] + [0]*195)
    )
    context = ModbusServerContext(slaves={1: store}, single=False)

    print("Starting Modbus RTU slave on COM3, 9600 baud")
    await StartAsyncSerialServer(
        context=context,
        port="COM3",           # Windows: COM3, COM4... Linux: /dev/ttyUSB0
        baudrate=9600,
        bytesize=8,
        parity="N",
        stopbits=1,
        framer="rtu"
    )

asyncio.run(run_rtu_server())

Adding Dynamic Register Values

One advantage of Python is dynamic register updates — simulate a running process:

import asyncio
import random
from pymodbus.server import StartAsyncTcpServer
from pymodbus.datastore import ModbusSequentialDataBlock, ModbusSlaveContext, ModbusServerContext

async def update_registers(context):
    """Update registers every second to simulate a running process."""
    counter = 0
    while True:
        await asyncio.sleep(1.0)
        counter += 1
        slave = context[1]  # unit ID 1
        # Simulate: temperature (reg 0), current (reg 1), power (reg 2)
        values = [
            int(220 + random.uniform(-5, 5)),   # voltage ~ 220V
            int(10 + random.uniform(-1, 1)),     # current ~ 10A
            counter % 65535,                      # energy accumulator
            int(random.uniform(20, 80)),         # temperature
        ]
        slave.setValues(3, 0, values)  # FC03 holding registers

async def run_server():
    store = ModbusSlaveContext(
        hr=ModbusSequentialDataBlock(0, [0] * 100)
    )
    context = ModbusServerContext(slaves={1: store}, single=False)

    await asyncio.gather(
        StartAsyncTcpServer(context=context, address=("0.0.0.0", 502)),
        update_registers(context)
    )

asyncio.run(run_server())

An Arduino (Uno, Mega, Nano) with a Modbus library acts as a real serial Modbus RTU slave device. This is useful when you need a physical RS485 connection — to test your RS485 wiring, terminators, and physical layer before the real PLC arrives.

Hardware Needed

• Arduino Uno, Mega, or Nano (~$5-25)
• RS485 module (MAX485 chip, ~$1-3) — if testing RS485 wiring
• OR: use Arduino's native USB-serial port for RS232 testing

Arduino Sketch (ModbusSlave Library)

#include <ModbusSlave.h>

// Modbus slave instance: Serial, unit ID=1, RS485 DE/RE pin=-1 (RS232 mode)
Modbus slave(Serial, 1, -1);

// Holding registers storage
uint16_t holdingRegisters[10] = {0};

// Callback to handle FC03/FC06/FC16 (read/write holding registers)
uint8_t readHoldingRegisters(uint8_t fc, uint16_t address, uint16_t length) {
    for (uint16_t i = 0; i < length; i++) {
        slave.writeRegisterToBuffer(i, holdingRegisters[address + i]);
    }
    return STATUS_OK;
}

uint8_t writeHoldingRegisters(uint8_t fc, uint16_t address, uint16_t length) {
    for (uint16_t i = 0; i < length; i++) {
        holdingRegisters[address + i] = slave.readRegisterFromBuffer(i);
    }
    return STATUS_OK;
}

void setup() {
    Serial.begin(9600, SERIAL_8N1);
    // Set initial register values
    holdingRegisters[0] = 1234;   // Temperature * 10 = 123.4°C
    holdingRegisters[1] = 2200;   // Voltage * 10 = 220.0V
    holdingRegisters[2] = 500;    // Current * 100 = 5.00A

    slave.cbVector[CB_READ_HOLDING_REGISTERS] = readHoldingRegisters;
    slave.cbVector[CB_WRITE_HOLDING_REGISTERS] = writeHoldingRegisters;
}

void loop() {
    slave.poll();

    // Simulate changing values
    static unsigned long lastUpdate = 0;
    if (millis() - lastUpdate > 1000) {
        holdingRegisters[0] = 1200 + random(100);  // Temperature fluctuation
        lastUpdate = millis();
    }
}

A Raspberry Pi running pymodbus is a solid option when you need a persistent Modbus slave on your network that doesn't tie up your workstation. The Pi can run 24/7, serve multiple test setups, and simulate both TCP and RTU (with USB-to-serial adapter).

Setup

# Install Python and pymodbus
sudo apt update && sudo apt install python3 python3-pip -y
pip3 install pymodbus

# For RTU via USB-serial adapter
pip3 install pyserial

# Create the server script (same code as Method 2)
# Run as a systemd service to start on boot:
sudo nano /etc/systemd/system/modbus-slave.service

[Unit]
Description=Modbus TCP Slave Simulator
After=network.target

[Service]
Type=simple
User=pi
ExecStart=/usr/bin/python3 /home/pi/modbus_slave.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

If you need to simulate not just Modbus registers but actual PLC ladder logic — rungs, function blocks, timers, counters — a virtual PLC is the right approach. CODESYS offers a free Windows runtime. OpenPLC is a fully open-source IEC 61131-3 compliant PLC implementation.

When to Use a Virtual PLC

• Your SCADA needs to test actual PLC program behavior (not just register values)
• You're testing HMI screens that must show correct animated logic states
• You need to validate interlocks, alarms, and sequencing logic
• Your customer's acceptance test requires seeing real PLC code running