# Ubuntu/Debian安装
sudo apt-get install libmodbus-dev

# 编译示例
gcc -o modbus_test modbus_test.c -lmodbus

# 基本使用
#include <modbus.h>
modbus_t *ctx = modbus_new_tcp("192.168.1.100", 502);
modbus_connect(ctx);
uint16_t reg[10];
modbus_read_registers(ctx, 0, 10, reg);

// FreeModbus配置
#define MB_ASCII_ENABLED    1
#define MB_RTU_ENABLED      1
#define MB_TCP_ENABLED      0

// 回调函数实现
eMBErrorCode eMBRegInputCB(UCHAR *pucRegBuffer, USHORT usAddress, 
                           USHORT usNRegs) {
    // 处理输入寄存器读取
    return MB_ENOERR;
}

// 创建TCP主站
ModbusTCPMaster master = new ModbusTCPMaster("192.168.1.100");
master.connect();

// 读取保持寄存器
ReadMultipleRegistersRequest req = new ReadMultipleRegistersRequest(
    0,  // 起始地址
    10  // 寄存器数量
);
ReadMultipleRegistersResponse resp = 
    (ReadMultipleRegistersResponse) master.send(req);

// 获取数据
int[] registerValues = resp.getRegisterValues();

// 创建工厂实例
ModbusFactory factory = new ModbusFactory();

// TCP主站配置
TcpMaster master = factory.createTcpMaster(
    new TcpMasterConfig.Builder("192.168.1.100")
        .setPort(502)
        .setTimeout(3000)
        .build(),
    true  // 保持连接
);

// 批量读取优化
BatchRead<String> batch = new BatchRead<>();
batch.addLocator("temp1", new InputRegisterLocator(1, 0));
batch.addLocator("temp2", new InputRegisterLocator(1, 1));

BatchResults<String> results = master.send(batch);
Float temperature = results.getFloatValue("temp1");

# ModbusPal Python脚本示例
def generate_temperature(cycle):
    import math
    # 模拟温度波动
    base_temp = 25.0
    amplitude = 5.0
    period = 100  # 周期
    return base_temp + amplitude * math.sin(2 * math.pi * cycle / period)

# 安装
pip install uModbus

# 或从源码安装
git clone https://github.com/AdvancedClimateSystems/uModbus
cd uModbus
python setup.py install

from umodbus import client
import socket

# 创建TCP客户端
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('192.168.1.100', 502))

# 读取保持寄存器
message = client.read_holding_registers(
    slave_id=1,
    starting_address=0,
    quantity=10
)

response = client.send_message(message, sock)
print(f"寄存器值: {response}")

# 写入单个寄存器
write_message = client.write_single_register(
    slave_id=1,
    address=0,
    value=100
)
client.send_message(write_message, sock)

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

# 设置日志
log_to_stream(level=logging.DEBUG)

# 定义数据存储
data_store = {
    'coils': {0: True, 1: False, 2: True},
    'discrete_inputs': {0: False, 1: True},
    'holding_registers': {0: 100, 1: 200, 2: 300},
    'input_registers': {0: 400, 1: 500}
}

# 创建服务器
app = get_server(RequestHandler, data_store)

if __name__ == '__main__':
    try:
        app.serve_forever()
    finally:
        app.shutdown()
        app.server_close()

import modbus_tk
import modbus_tk.defines as cst
from modbus_tk import modbus_tcp

# 创建主站
master = modbus_tcp.TcpMaster(host="192.168.1.100")
master.set_timeout(5.0)

# 批量操作
try:
    # 读取多个数据类型
    coils = master.execute(1, cst.READ_COILS, 0, 10)
    inputs = master.execute(1, cst.READ_DISCRETE_INPUTS, 0, 8)
    holding = master.execute(1, cst.READ_HOLDING_REGISTERS, 0, 20)
    input_reg = master.execute(1, cst.READ_INPUT_REGISTERS, 0, 10)

    # 写入操作
    master.execute(1, cst.WRITE_SINGLE_COIL, 0, output_value=1)
    master.execute(1, cst.WRITE_SINGLE_REGISTER, 0, output_value=1000)
    master.execute(1, cst.WRITE_MULTIPLE_REGISTERS, 0, 
                   output_value=[100, 200, 300, 400])

except modbus_tk.modbus.ModbusError as e:
    print(f"Modbus错误: {e}")

Install-Package NModbus

using NModbus;
using System.Net.Sockets;

class Program
{
    static void Main()
    {
        // 创建TCP客户端
        TcpClient tcpClient = new TcpClient("192.168.1.100", 502);
        var factory = new ModbusFactory();
        IModbusMaster master = factory.CreateMaster(tcpClient);

        // 读取操作
        ushort[] holdingRegisters = master.ReadHoldingRegisters(1, 0, 10);
        bool[] coils = master.ReadCoils(1, 0, 16);
        bool[] inputs = master.ReadInputs(1, 0, 8);
        ushort[] inputRegisters = master.ReadInputRegisters(1, 0, 10);

        // 写入操作
        master.WriteSingleCoil(1, 0, true);
        master.WriteSingleRegister(1, 0, 1000);
        master.WriteMultipleRegisters(1, 0, new ushort[] {100, 200, 300});

        // 异步操作
        var task = master.ReadHoldingRegistersAsync(1, 0, 10);
        task.ContinueWith(t => {
            if (t.IsCompletedSuccessfully)
            {
                Console.WriteLine($"读取完成: {t.Result.Length}个寄存器");
            }
        });

        tcpClient.Close();
    }
}

// 1. 自定义传输层
public class CustomTransport : IModbusTransport
{
    // 实现自定义通信协议
}

// 2. 事件处理
master.ModbusSlaveRequest += (sender, args) => {
    Console.WriteLine($"请求: {args.Message.FunctionCode}");
};

// 3. 性能监控
var diagnostics = master.Diagnostics;
Console.WriteLine($"成功请求: {diagnostics.NumberOfSuccessRequests}");
Console.WriteLine($"失败请求: {diagnostics.NumberOfFailRequests}");

// 可视化配置
ASCommNET comm = new ASCommNET();
comm.Protocol = ProtocolType.ModbusTCP;
comm.Server = "192.168.1.100";
comm.Port = 502;

// 数据项管理
DataItem tempItem = new DataItem();
tempItem.Name = "Temperature";
tempItem.Address = "40001";  // 保持寄存器40001
tempItem.DataType = DataType.Int16;
tempItem.ScanRate = 1000;  // 1秒扫描一次

comm.DataItems.Add(tempItem);

// 事件驱动
tempItem.DataChanged += (sender, e) => {
    Console.WriteLine($"温度变化: {e.NewValue}°C");
};

// 启动通信
comm.Start();

#include <SimpleModbusMaster.h>
#include <SimpleModbusSlave.h>

// 主站配置
#define TOTAL_NO_OF_REGISTERS 10
unsigned int holdingRegs[TOTAL_NO_OF_REGISTERS];

// 从站配置
enum {
  TEMP_REGISTER,
  HUMIDITY_REGISTER,
  PRESSURE_REGISTER,
  HOLDING_REGS_SIZE
};

unsigned int holdingRegs[HOLDING_REGS_SIZE];

void setup() {
  // 初始化Modbus
  modbus_configure(&Serial, 9600, SERIAL_8N2, 1, 2, 
                   TOTAL_NO_OF_REGISTERS, holdingRegs);
  modbus_update();

  // 设置从站数据
  holdingRegs[TEMP_REGISTER] = 250;  // 25.0°C
  holdingRegs[HUMIDITY_REGISTER] = 600;  // 60.0%
  holdingRegs[PRESSURE_REGISTER] = 1013; // 1013 hPa
}

void loop() {
  // 主站读取
  modbus_update();

  // 处理接收到的数据
  if (holdingRegs[0] != 0) {
    // 执行相应操作
  }

  // 从站响应
  modbus_update(holdingRegs, HOLDING_REGS_SIZE);
}

// portserial.c - 串口驱动
BOOL xMBPortSerialInit(UCHAR ucPort, ULONG ulBaudRate, UCHAR ucDataBits, 
                       UCHAR ucStopBits, eMBParity eParity) {
    // 实现串口初始化
    return TRUE;
}

// porttimer.c - 定时器驱动
BOOL xMBPortTimersInit(USHORT usTimeOut50us) {
    // 实现定时器初始化
    return TRUE;
}

// 内存优化配置
#define MB_REG_HOLDING_START     0
#define MB_REG_HOLDING_NREGS     100
#define MB_REG_INPUT_START       0
#define MB_REG_INPUT_NREGS       100
#define MB_REG_COILS_START       0
#define MB_REG_COILS_SIZE        100
#define MB_REG_DISCRETE_START    0
#define MB_REG_DISCRETE_SIZE     100

# 读取保持寄存器
modpoll -m tcp -t 4 -r 100 -c 10 192.168.1.100

# 读取线圈状态
modpoll -m tcp -t 0 -r 0 -c 16 192.168.1.100

# 写入单个寄存器
modpoll -m tcp -t 4:hex -r 40001 -c 1 192.168.1.100 1234

# 轮询模式
modpoll -m tcp -t 4 -r 100 -c 5 -p 1000 192.168.1.100

# ASCII输出格式
modpoll -m tcp -t 4 -r 100 -c 10 -a 1 -f c 192.168.1.100