Modbus RTU协议 + 调试工具 + java工具类一文全解

春风若有怜花意，可否容我再少年

Modbus RTU通信协议指令学习

Modbus RTU协议是一种紧凑的，采用二进制表示数据的方式，带有循环冗余校验的校验和。

读取指令格式

使用过程中03功能码比较常用，所以以03读取为例

读请求：

01 03 00 00 00 02 C4 0B
01 : 设备地址，设备地址为1
03 : 功能码，当前为03读请求
00 00 : 寄存器起始地址，从00 00寄存器开始读取
00 02 : 读取寄存器长度，读取2个长度，对应回复4个字节
C4 0B : CRC校验和

读请求回复：

01 03 04 00 0C 00 02 BB F1
01 : 设备地址，设备地址为1
03 : 功能码，当前为03读取回复
04 : 数据长度，包含4个字节的数据
00 0C : 寄存器1数值
00 02 : 寄存器2数值
BB F1 : CRC校验和

 主节点发送帧格式：

从节点应答帧格式：

注意：

• MSB表示高字节，LSB表示低字节

• 每个寄存器存放两个字节，对寄存器数据类型为1个字节的数据，要求存放在低字节

写指令格式

使用过程中10功能码可以写入一个或多个寄存器，所以以10写入为例

写请求：

01 10 00 00 00 02 04 00 00 00 0A 73 A8
01 : 设备地址，设备地址为1
10 : 功能码，当前为10写入请求
00 00 : 寄存器起始地址，从00 00寄存器开始写入
00 02 : 写入寄存器长度，写入2个长度，对应后面4个字节数据
04 : 数据长度，包含4个字节的数据
00 00 : 寄存器1数值
00 0A : 寄存器2数值
73 A8 : CRC校验和

 写请求回复：

01 10 00 00 00 02 41 C8
01 : 设备地址，设备地址为1
10 : 功能码
00 00 : 寄存器起始地址
00 02 : 写入寄存器长度，写入2个长度
41 C8 : CRC校验和

 主节点发送帧格式（写单个寄存器）：

 从节点正常应答帧格式：

 主节点发送帧格式（写多个寄存器）：

 从节点正常应答帧格式：

Modbus通信工具学习

虚拟串口调试工具

Configure Virtual Serial Port Driver

模拟两个串口，COM2、COM3

Modbus Poll

可以理解为Modbus程序端，模拟程序给设备发送各种指令。

常用功能：

1. connection：设置连接方式

 2. Setup Read/Write设置通信设备的地址、功能码、寄存器起始地址、长度、采集间隔等信息。

Modbus Slave

可以理解为Modbus的设备端，模拟设备响应程序发送的指令。

1. connection：设置连接方式

 2. setup Definition设置通信设备的地址、功能码、寄存器起始地址、长度等信息。

通信测试

点击图中红色框中的按钮，查看实时指令

TX：发送的指令

RX：响应的指令

Modbus-Java工具包

1. modbus4j：支持Modbus-RTU、Modbus-ASCII和Modbus-TCP三种协议，支持Modbus-RTU over Serial、Modbus-RTU over TCP/UDP、Modbus-ASCII over Serial 和 Modbus-TCP over TCP/UDP。但是该工具是同步的不支持异步，实时性要求不强可以使用。

2. jlibmodbus：支持Modbus-RTU和Modbus-TCP两种协议，支持Modbus-RTU over Serial 、Modbus-RTU over TCP、Modbus-TCP over TCP，Modbus-TCP内部通过socket实现支持异步。Modbus-RTU Serial通过RXTX实现。

3. modbus-master-tcp：支持Modbus-TCP一种协议，支持Modbus-TCP over TCP，内部通过netty实现支持异步。可以执行扩展使其支持Modbus-RTU over TCP和Modbus-RTU over Serial。

注意：以上三个工具包的所有连接都没有断线重连功能，所以使用时需要自行解决断线重连问题。

Modbus4J

maven依赖坐标

<dependency>
    <groupId>com.infiniteautomation</groupId>
    <artifactId>modbus4j</artifactId>
    <version>3.0.3</version>
</dependency>

Java工具类

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ReadMultipleRegistersRequest;
import com.serotonin.modbus4j.msg.ReadMultipleRegistersResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;
import com.serotonin.modbus4j.msg.WriteRegistersResponse;

public class ModbusUtils {
    private ModbusMaster modbusMaster;

    /**
    * 创建ModbusMaster实例并设置主机和端口
    */
    public ModbusUtils(String host, int port) {
        ModbusFactory modbusFactory = new ModbusFactory();
        modbusMaster = modbusFactory.createTcpMaster(true);
        modbusMaster.setHost(host);
        modbusMaster.setPort(port);
    }

    /**
    * 初始化ModbusMaster并建立与Modbus设备的连接
    */
    public void connect() throws ModbusInitException {
        modbusMaster.init();
    }

    /**
    * 关闭与Modbus设备的连接
    */
    public void disconnect() {
        modbusMaster.destroy();
    }

    /**
    * 读取Modbus设备寄存器的值
    * slaveId 设备序列号
    * startOffset 读取寄存器开始的地址
    * numberOfRegisters 读取连续的几个寄存器
    */
    public int[] readHoldingRegisters(int slaveId, int startOffset, int numberOfRegisters) throws ModbusTransportException {
        ReadMultipleRegistersRequest request = new ReadMultipleRegistersRequest(slaveId, startOffset, numberOfRegisters);
        ReadMultipleRegistersResponse response = (ReadMultipleRegistersResponse) modbusMaster.send(request);
        return response.getIntData();
    }

    /**
    * 向Modbus设备的保持寄存器写入值
    * slaveId 设备序列号
    * startOffset 写入寄存器开始的地址
    * values 写入寄存器里的值
    */
    public void writeHoldingRegisters(int slaveId, int startOffset, int[] values) throws ModbusTransportException {
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, values);
        modbusMaster.send(request);
    }
}

调用测试

public class Main {
    public static void main(String[] args) {
        ModbusUtils modbusUtils = new ModbusUtils("192.168.0.1", 502);

        try {
            modbusUtils.connect();

            // 读取保持寄存器
            int[] values = modbusUtils.readHoldingRegisters(1, 0, 5);
            System.out.println("读取的保持寄存器值：" + Arrays.toString(values));

            // 写入保持寄存器
            int[] writeValues = {10, 20, 30};
            modbusUtils.writeHoldingRegisters(1, 0, writeValues);
            System.out.println("写入保持寄存器成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            modbusUtils.disconnect();
        }
    }
}