Modbus RTU 与 Modbus TCP 协议详解

一、什么是 Modbus

Modbus是一种开放、简单、广泛使用的工业通信协议，由美国 Modicon 公司（现施耐德电气）于 1979 年发明，最初用于其生产的可编程逻辑控制器（PLC）之间通信。Modbus 是工业自动化领域事实上的标准，被誉为"工业界的 HTTP"——几乎所有工业设备都支持它。

Modbus 是应用层协议，独立于底层物理层和传输层。它有三大主流变体：

• Modbus RTU：基于 RS-232/RS-485 串行链路，二进制紧凑编码，是最常见的串行 Modbus
• Modbus ASCII：同样基于串行链路，但用 ASCII 字符（0-9, A-F）表示数据，可读性更好但效率低
• Modbus TCP：基于以太网 TCP/IP，去除 CRC（由 TCP 自带校验），用 MBAP 头替代从站地址

二、Modbus 与其他工业协议对比

Modbus 在工业通信生态中扮演"入门级"角色，与 EtherCAT、PROFINET、CANopen 等形成互补。

三、Modbus 通信模型：主从架构

Modbus 采用经典的主从（Master/Slave）架构。在 RTU 中叫"主站/从站"，在 TCP 中改叫"客户端/服务端"但本质相同：只有主站能主动发起请求，从站只能被动响应。

3.1 三种通信模式

3.2 一问一答的时序

四、Modbus 数据模型：四类数据

Modbus 把所有数据抽象为四类数据表，每类有不同的读写权限和数据宽度。这是 Modbus 设计上最优雅、最经典的部分。

4.1 大端字节序与 32 位数据

Modbus 寄存器宽度为 16 位，但很多实际数据（如 IEEE 754 浮点、32 位整数）需要 32 位。这时需要用两个连续寄存器存储一个 32 位数据，这就涉及字节序问题。

五、Modbus 功能码详解

功能码（Function Code）是请求帧的"动作指令"，告诉从站要做什么操作。功能码占 1 个字节，0x01~0x06 是最常用的 6 个。

5.1 异常响应与异常码

当从站无法处理请求时（如地址越界、功能码不支持），会返回异常响应——把功能码最高位置 1（异或 0x80），并附带异常码。

六、Modbus RTU：串行链路实现

Modbus RTU（Remote Terminal Unit）是 Modbus 在串行链路上的实现，物理层通常用 RS-485（多节点）或 RS-232（点对点）。它使用二进制紧凑编码，比 ASCII 模式效率高出一倍。

6.1 RTU 的帧定界难题

RTU 帧没有起始/结束标志符，依靠 3.5 个字符时间的空闲间隔作为帧边界。这是一个聪明但容易出错的设计。

七、Modbus RTU 帧结构

RTU 帧由从站地址、功能码、数据、CRC16四部分组成，无起始/结束标志，最紧凑高效。

7.1 三种帧类型对比

八、CRC16 校验：可靠性的基石

Modbus RTU 使用 CRC-16-Modbus算法（多项式 0xA001，即 0x8005 反转），对地址、功能码、数据全部计算 2 字节校验值，低字节在前传输。这是 RTU 抗干扰的关键。

8.1 CRC16 C 语言实现

// CRC-16-Modbus 算法（查表法，速度优先）
#include <stdint.h>

static const uint16_t crc_table[256] = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    // ...（共 256 项，此处省略，可在线生成）
};

uint16_t modbus_crc16(const uint8_t *data, size_t len) {
    uint16_t crc = 0xFFFF;
    while (len--) {
        crc = (crc >> 8) ^ crc_table[(crc ^ *data++) & 0xFF];
    }
    return crc;
}

// 用法：构造帧时附加 CRC（低字节在前）
uint8_t frame[8] = {0x01, 0x03, 0x00, 0x0A, 0x00, 0x02};
uint16_t crc = modbus_crc16(frame, 6);
frame[6] = crc & 0xFF;        // 低字节
frame[7] = (crc >> 8) & 0xFF;  // 高字节
// 结果：frame = 01 03 00 0A 00 02 25 CA

九、Modbus TCP：以太网实现

Modbus TCP（也叫 Modbus TCP/IP）于 1997 年发布，将 Modbus 应用层协议承载在标准 TCP/IP 协议栈之上，使用固定端口 502，让工业设备能直接接入 IT 网络。

9.1 Modbus TCP 的关键变化

9.2 TCP 网络拓扑

十、Modbus TCP 帧结构（MBAP 头）

Modbus TCP 帧由 MBAP 头（7 字节）+ PDU（协议数据单元）组成。MBAP 头替代了 RTU 的从站地址和 CRC。

十一、Modbus RTU vs TCP 全面对比

十二、Modbus 特性与能力矩阵

12.1 Modbus 的优势

• 简单：协议规范仅 100 多页，一周即可开发主从站
• 开放：无版权、无授权费、文档公开
• 普及：几乎所有工业设备（PLC、变频器、仪表、IO）都支持
• 稳定：40 多年验证，无重大缺陷
• 灵活：可承载于 RS-232/485/TCP/UDP 等多种底层
• 易调试：抓包工具丰富（Modbus Poll/Slave、Wireshark）

12.2 Modbus 的局限

• 无同步机制：无法满足多轴运动控制（不能与 EtherCAT DC 比）
• 主从模型：RTU 不能多主，从站无法主动上报
• 响应慢：RTU 9600bps 读 10 个寄存器约需 30ms
• 地址空间小：每类数据仅 9999 个
• 无安全机制：明文传输、无认证、无加密（Modbus TCP 可被嗅探）
• 数据模型简单：仅支持 Bit/Word，复杂数据需用户自定义拆分

十三、Modbus 应用场景全景

13.1 经典案例：电力监控系统

十四、代码实战：Qt/C++ Modbus RTU + TCP

Qt 提供了官方的 QtSerialBus 模块（含 Modbus RTU/TCP 主从端封装），但需要单独编译。下面我们用更通用的方式：RTU 用开源 libmodbus 库，TCP 用 Qt 网络模块自行实现，便于跨平台部署。

14.1 基于 libmodbus 的 RTU 主站封装

libmodbus 是 C 语言编写的轻量 Modbus 库，支持 RTU/TCP，被工业界广泛使用。我们用 Qt 包装它。

// ModbusRtuMaster.h —— 基于 libmodbus 的 Qt 封装
#ifndef MODBUSRTUMASTER_H
#define MODBUSRTUMASTER_H

#include <QObject>
#include <QTimer>
#include <QVector>
#include <QDebug>
#include "modbus.h"  // libmodbus 头文件

class ModbusRtuMaster : public QObject {
    Q_OBJECT
public:
    explicit ModbusRtuMaster(QObject *parent = nullptr) : QObject(parent), m_ctx(nullptr) {}
    ~ModbusRtuMaster() { if (m_ctx) modbus_free(m_ctx); }

    // 初始化串口
    bool init(const QString& port, int baud, int dataBits = 8,
                 int parity = 'N', int stopBits = 1) {
        // 创建 RTU 上下文："/dev/ttyUSB0" 或 "COM3"
        m_ctx = modbus_new_rtu(port.toLatin1().constData(),
                                       baud, parity, dataBits, stopBits);
        if (!m_ctx) return false;

        // 设置从站地址
        modbus_set_slave(m_ctx, 1);
        // 设置响应超时 500ms
        uint32_t tv_sec = 0, tv_usec = 500000;
        modbus_set_response_timeout(m_ctx, tv_sec, tv_usec);
        // 启用调试输出（开发期）
        modbus_set_debug(m_ctx, TRUE);

        if (modbus_connect(m_ctx) == -1) {
            modbus_free(m_ctx);
            m_ctx = nullptr;
            return false;
        }
        return true;
    }

    // 读保持寄存器（功能码 0x03）
    QVector<uint16_t> readHoldingRegisters(int slave, int addr, int num) {
        modbus_set_slave(m_ctx, slave);
        QVector<uint16_t> dest(num);
        int rc = modbus_read_registers(m_ctx, addr, num, dest.data());
        if (rc == -1) {
            qWarning() << "读寄存器失败:" <&slave << addr;
            return {};
        }
        return dest;
    }

    // 写单个寄存器（功能码 0x06）
    bool writeSingleRegister(int slave, int addr, uint16_t value) {
        modbus_set_slave(m_ctx, slave);
        return modbus_write_register(m_ctx, addr, value) != -1;
    }

    // 读线圈（功能码 0x01）
    QVector<uint8_t> readCoils(int slave, int addr, int num) {
        modbus_set_slave(m_ctx, slave);
        QVector<uint8_t> dest(num);
        int rc = modbus_read_bits(m_ctx, addr, num, dest.data());
        if (rc == -1) return {};
        return dest;
    }

    // 写多个线圈（功能码 0x0F）
    bool writeMultipleCoils(int slave, int addr,
                                   const QVector<uint8_t>& values) {
        modbus_set_slave(m_ctx, slave);
        return modbus_write_bits(m_ctx, addr, values.size(),
                                   values.constData()) != -1;
    }

private:
    modbus_t *m_ctx;
};

#endif

14.2 完整 Modbus TCP 客户端（纯 Qt 实现）

下面用 Qt 的 QTcpSocket 手工实现 Modbus TCP 客户端，体现协议帧构造原理。

// ModbusTcpClient.h —— 纯 Qt 实现的 Modbus TCP 客户端
#ifndef MODBUSTCPCLIENT_H
#define MODBUSTCPCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QQueue>
#include <QDebug>
#include <QDataStream>

struct ModbusRequest {
    quint16 transId;      // 事务 ID（配对用）
    quint8  unitId;        // 单元 ID
    quint8  funcCode;      // 功能码
    QByteArray payload;  // PDU 数据
};

class ModbusTcpClient : public QObject {
    Q_OBJECT
public:
    explicit ModbusTcpClient(QObject *parent = nullptr)
        : QObject(parent), m_transId(0) {
        connect(&m_socket, &QTcpSocket::readyRead,
                this, &ModbusTcpClient::onReadyRead);
        connect(&m_socket, &QTcpSocket::connected,
                this, &ModbusTcpClient::onConnected);
        connect(&m_socket, &QTcpSocket::disconnected,
                this, &ModbusTcpClient::onDisconnected);
    }

    // 连接服务端
    void connectToServer(const QString& host, quint16 port = 502) {
        m_socket.connectToHost(host, port);
    }

    // 读保持寄存器（0x03）
    quint16 readHoldingRegisters(quint8 unitId, quint16 addr, quint16 count) {
        QByteArray pdu;
        QDataStream ds(&pdu, QIODevice::WriteOnly);
        ds.setByteOrder(QDataStream::BigEndian);
        ds << addr << count;  // 起始地址 + 数量（4 字节）

        return sendRequest(unitId, 0x03, pdu);
    }

    // 写单个寄存器（0x06）
    quint16 writeSingleRegister(quint8 unitId, quint16 addr, quint16 value) {
        QByteArray pdu;
        QDataStream ds(&pdu, QIODevice::WriteOnly);
        ds.setByteOrder(QDataStream::BigEndian);
        ds << addr << value;

        return sendRequest(unitId, 0x06, pdu);
    }

signals:
    void responseReceived(quint16 transId, quint8 funcCode, const QByteArray& data);
    void errorOccurred(const QString& msg);

private slots:
    void onReadyRead() {
        while (m_socket.bytesAvailable() >= 9) {  // MBAP 头 7B + 至少 2B
            QByteArray mbap = m_socket.peek(7);
            QDataStream ds(mbap);
            ds.setByteOrder(QDataStream::BigEndian);
            quint16 transId, protoId, length;
            quint8 unitId;
            ds >> transId >> protoId >> length >> unitId;

            if (m_socket.bytesAvailable() < 7 + length - 1) break;

            m_socket.read(7);  // 丢弃 MBAP 头
            QByteArray pdu = m_socket.read(length - 1);

            quint8 funcCode = (quint8)pdu[0];
            QByteArray data = pdu.mid(1);

            if (funcCode & 0x80) {
                qWarning() << "Modbus 异常:" << (int)(pdu[1] & 0xFF);
                errorOccurred("Modbus 异常响应");
            } else {
                responseReceived(transId, funcCode, data);
            }
        }
    }

    void onConnected() { qDebug() << "Modbus TCP 已连接"; }
    void onDisconnected() { qDebug() << "Modbus TCP 已断开"; }

private:
    quint16 sendRequest(quint8 unitId, quint8 funcCode, const QByteArray& payload) {
        quint16 transId = ++m_transId;
        quint16 length = 1 + 1 + payload.size();  // 单元 ID + 功能码 + PDU

        QByteArray frame;
        QDataStream ds(&frame, QIODevice::WriteOnly);
        ds.setByteOrder(QDataStream::BigEndian);
        ds << transId            // 事务 ID（2B）
           << (quint16)0      // 协议 ID（2B，恒 0）
           << length             // 长度（2B）
           << unitId              // 单元 ID（1B）
           << funcCode            // 功能码（1B）
           << payload;           // 数据区

        m_socket.write(frame);
        m_socket.flush();
        return transId;
    }

    QTcpSocket m_socket;
    quint16 m_transId;
};

#endif

14.3 使用示例：电力仪表数据采集

// 电力采集主流程
#include "ModbusRtuMaster.h"
#include "ModbusTcpClient.h"
#include <QCoreApplication>
#include <QTimer>

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    // === RTU 示例：读 1 号仪表的电压、电流、功率 ===
    ModbusRtuMaster rtu;
    if (!rtu.init("COM3", 9600, 8, 'N', 1)) {
        qCritical() << "串口打开失败";
        return -1;
    }

    // 假设仪表寄存器表：
    // 0x4000 = 电压 (0.1V)，0x4001 = 电流 (0.01A)，0x4002 = 功率 (0.1W)
    auto regs = rtu.readHoldingRegisters(1, 0x4000, 3);
    if (regs.size() == 3) {
        qInfo() << "电压:" << regs[0] / 10.0 << "V";
        qInfo() << "电流:" << regs[1] / 100.0 << "A";
        qInfo() << "功率:" << regs[2] / 10.0 << "W";
    }

    // === TCP 示例：远程控制变频器启停 ===
    ModbusTcpClient tcp;
    QObject::connect(&tcp, &ModbusTcpClient::responseReceived,
        [](quint16 transId, quint8 funcCode, const QByteArray& data){
            qDebug() << "收到响应:" << transId << funcCode << data.toHex();
        });

    tcp.connectToServer("192.168.1.10", 502);

    // 延迟 1s 后发送命令
    QTimer::singleShot(1000, [&](){
        // 写寄存器 0x0001 = 0x0001（启动变频器）
        tcp.writeSingleRegister(0xFF, 0x0001, 0x0001);
    });

    return app.exec();
}

十五、调试技巧与常见问题

15.1 常用调试工具

15.2 八大常见故障

十六、总结

Modbus 是工业通信领域的"普通话"——简单、开放、普及。它不是最快的，不是最强的，但因为它足够简单、足够开放，成为了所有工业设备都支持的"最低公约数"。