RS-232 与 RS-485 串口通信协议详解

一、什么是串口通信（零基础入门）

1.1 串行 vs 并行：一条路还是八条路

设备之间要传数据，本质是把一个个字节（8 个二进制位）从 A 搬到 B。搬运方式有两种：

1.2 单工、半双工、全双工

1.3 同步 vs 异步

接收方怎么知道每一位数据从什么时候开始？两种办法：

• 同步通信：收发双方共享一根时钟线，接收方按时钟节拍采样。典型：SPI、I2C。
• 异步通信：没有时钟线！双方事先约定好速率（波特率），靠帧格式中的起始位对齐节拍。典型：UART（RS-232/RS-485 底层都是 UART）。

二、RS-232 协议详解

2.1 概念与历史

RS-232（Recommended Standard 232）是美国电子工业协会（EIA）在 1960 年代发布的串行通信标准，最初用于连接电传打字机和调制解调器（Modem）。你可能在老电影里见过的"拨号上网的猫"，它们之间就是用 RS-232 连接的。

虽然已经 60 多岁了，RS-232 至今仍活跃在：

• 工业设备的调试控制台（Console 口）
• PLC、变频器等老设备的编程口
• GPS 模块、气体传感器等模块的输出接口
• 医疗设备、测量仪器（示波器、万用表）的通信口

2.2 电气特性：负逻辑的"怪脾气"

RS-232 最大的特点有两个：电压高和负逻辑。

2.3 接口与引脚：DB9 连接器

最常见的 RS-232 接口是 DB9（9 针 D 型接口）。老台式机后面的"串口"就是它。

2.4 RS-232 的能力与局限

三、串口帧格式：数据是怎么排队的

RS-232 和 RS-485 共用同一套 UART 帧格式。一个字节不是裸着上线，而是被包装成一帧：

3.1 帧格式四要素详解

3.2 波特率：每秒传多少位

四、RS-485 协议详解

4.1 概念：为工业而生

RS-485（TIA/EIA-485）是 1983 年发布的差分串行通信标准，专门解决 RS-232 的三大痛点：距离短、速率低、不能多机组网。

4.2 电气特性：A 线与 B 线

RS-485 用两根线（通常称为 A 和 B）传输一路差分信号：

五、差分信号：RS-485 抗干扰的秘密武器

5.1 单端 vs 差分：测电压的方式不同

5.2 为什么用双绞线

六、RS-485 总线拓扑与多机通信

6.1 半双工两线制与全双工四线制

6.2 一主多从：谁先说话？

半双工总线上所有设备共用一对线，两个设备同时发送会导致数据碰撞（总线冲突）。工业上普遍采用主从轮询（Master-Slave Polling）：

6.3 终端电阻：消除信号反射

七、UART：软件层与电气层的分界线

7.1 三层结构：一个字节从 MCU 到线缆的旅程

7.2 TTL 电平直连：什么时候不需要转换芯片

八、RS-232 vs RS-485 全面对比

九、Qt/C++ 实战：QSerialPort 串口编程

9.1 环境准备

# .pro 文件（qmake）
QT += serialport

# CMakeLists.txt（CMake）
find_package(Qt6 REQUIRED COMPONENTS SerialPort)
target_link_libraries(myapp PRIVATE Qt6::SerialPort)

9.2 枚举与打开串口

#include <QSerialPortInfo>
#include <QSerialPort>

// 1. 枚举系统所有串口
for (const auto &info : QSerialPortInfo::availablePorts()) {
    qDebug() << "端口:" << info.portName()      // COM3 / ttyUSB0
              << "描述:" << info.description()  // "USB-SERIAL CH340"
              << "厂商:" << info.manufacturer();
}

// 2. 创建并配置串口
QSerialPort *serial = new QSerialPort(this);
serial->setPortName("COM3");                      // Windows 用 COMx，Linux 用 /dev/ttyUSB0

// 3. 五大参数：波特率、数据位、校验、停止位、流控 —— 必须与对方一致！
serial->setBaudRate(QSerialPort::Baud115200);    // 波特率
serial->setDataBits(QSerialPort::Data8);         // 8 位数据
serial->setParity(QSerialPort::NoParity);        // 无校验
serial->setStopBits(QSerialPort::OneStop);       // 1 位停止位
serial->setFlowControl(QSerialPort::NoFlowControl); // 无流控

// 4. 以读写方式打开
if (serial->open(QIODevice::ReadWrite)) {
    qDebug() << "串口打开成功";
} else {
    qDebug() << "打开失败:" << serial->errorString();
}

9.3 异步读写：readyRead 信号

// 发送：write() 像 QFile 一样简单
QByteArray data = "Hello RS485\r\n";
serial->write(data);          // 异步写入，数据进入系统发送缓冲区
// serial->flush();          // 可选：强制立即发出（一般不需要）

// 接收：绝不推荐用死等（waitForReadyRead），推荐信号槽
connect(serial, &QSerialPort::readyRead, this, &MainWindow::onReadyRead);

void MainWindow::onReadyRead() {
    // readyRead 只保证"有数据"，不保证"来的是一整帧"！
    QByteArray chunk = serial->readAll();
    m_buffer.append(chunk);            // 先攒到缓冲区

    // 按协议帧格式拆包（示例：以 \r\n 结尾的 ASCII 帧）
    while (true) {
        int idx = m_buffer.indexOf("\r\n");
        if (idx < 0) break;
        QByteArray frame = m_buffer.left(idx);
        m_buffer.remove(0, idx + 2);
        processFrame(frame);          // 处理完整一帧
    }
}

9.4 完整示例：温湿度传感器串口读取

// SerialReader.h
#include <QObject>
#include <QSerialPort>

class SerialReader : public QObject {
    Q_OBJECT
public:
    explicit SerialReader(QObject *parent = nullptr);
    bool openPort(const QString &portName);

signals:
    void frameReceived(const QByteArray &frame);

private slots:
    void onReadyRead();
    void onError(QSerialPort::SerialPortError error);

private:
    QSerialPort m_serial;
    QByteArray  m_buffer;
};

// SerialReader.cpp
SerialReader::SerialReader(QObject *parent) : QObject(parent) {
    connect(&m_serial, &QSerialPort::readyRead,
            this, &SerialReader::onReadyRead);
    connect(&m_serial, &QSerialPort::errorOccurred,
            this, &SerialReader::onError);   // 监听拔线等异常
}

bool SerialReader::openPort(const QString &portName) {
    m_serial.setPortName(portName);
    m_serial.setBaudRate(QSerialPort::Baud9600);
    m_serial.setDataBits(QSerialPort::Data8);
    m_serial.setParity(QSerialPort::NoParity);
    m_serial.setStopBits(QSerialPort::OneStop);
    return m_serial.open(QIODevice::ReadWrite);
}

void SerialReader::onReadyRead() {
    m_buffer.append(m_serial.readAll());
    // 协议帧：AA 55 [len] [data...] [checksum]
    while (m_buffer.size() >= 4) {
        if (static_cast<quint8>(m_buffer[0]) != 0xAA ||
            static_cast<quint8>(m_buffer[1]) != 0x55) {
            m_buffer.remove(0, 1);          // 丢掉非法字节，重新找帧头
            continue;
        }
        quint8 len = static_cast<quint8>(m_buffer[2]);
        if (m_buffer.size() < 4 + len) break;  // 帧还没收全，等下次

        QByteArray frame = m_buffer.left(4 + len);
        m_buffer.remove(0, 4 + len);

        // 校验和验证：帧头到数据字节求和取低 8 位
        quint8 sum = 0;
        for (int i = 0; i < 3 + len; ++i) sum += static_cast<quint8>(frame[i]);
        if (sum == static_cast<quint8>(frame[3 + len]))
            emit frameReceived(frame);        // 校验通过，上抛完整帧
    }
}

void SerialReader::onError(QSerialPort::SerialPortError error) {
    if (error == QSerialPort::ResourceError) {  // 设备被拔出
        m_serial.close();
        qWarning() << "串口异常断开，尝试重连...";
    }
}

十、RS-485 方向控制与 Modbus 轮询实战

10.1 半双工的方向切换：DE/RE 引脚

RS-485 两线制是半双工，MAX485 类芯片用两个引脚控制收发方向（两个引脚通常短接在一起，用一个 IO 控制）：

10.2 Qt 实现：用 RTS 信号自动/手动控制方向

// ============ 方式一：硬件自动方向（推荐）============
// 很多 USB-RS485 转换器和工业级 485 芯片带自动收发切换，
// 程序完全不用管方向，像 RS-232 一样直接用！
serial->setRequestToSend(false);   // 自动方向芯片时无需任何处理

// ============ 方式二：RTS 信号控制（QSerialPort 内置支持）============
// Qt 支持用 RTS 线自动控制方向：设置后 Qt 会在写数据时自动拉高 RTS
serial->setFlowControl(QSerialPort::NoFlowControl);
serial->setRequestToSend(true);    // RTS 信号 = DE 使能（视转换器接法）

// ============ 方式三：GPIO 手动控制（嵌入式直连 MAX485 时）============
QByteArray ModbusMaster::transceive(const QByteArray &request)
{
    // 1. 切到发送方向
    m_dirGpio.setHigh();            // DE=1（Linux 下可能是 GPIO sysfs，或 RTS）
    m_serial.write(request);
    m_serial.flush();               // 等待数据全部写入驱动
    if (!m_serial.waitForBytesWritten(100))
        qWarning() << "发送超时";

    // 2. 关键：等待最后 1.5 个字节的移位时间，再切回接收！
    //    波特率 9600 时一个字符约 1.04ms，这里保守等 2ms
    QThread::msleep(2);
    m_dirGpio.setLow();             // DE=0，释放总线，切回接收

    // 3. 带超时等待从站应答
    QByteArray response;
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < 200) {           // Modbus 应答超时一般 100~500ms
        if (m_serial.waitForReadyRead(50)) {
            response.append(m_serial.readAll());
            // Modbus RTU：3.5 字符静默 = 帧结束（简化：150ms 无新数据认为收完）
            if (!response.isEmpty() && !m_serial.waitForReadyRead(20))
                break;
        }
    }
    return response;
}

10.3 Modbus RTU 主站轮询示例

// Modbus RTU 主站：轮询 3 个从站的温湿度寄存器
class ModbusPoller : public QObject {
    Q_OBJECT
public:
    void start(QSerialPort *s) { m_serial = s; pollNext(); }

private:
    void pollNext() {
        quint8 addr = m_slaves[m_index];          // 当前轮询的从站地址
        QByteArray req;
        req.append(char(addr));                   // 从站地址
        req.append(char(0x03));                   // 功能码：读保持寄存器
        req.append(char(0x00)); req.append(char(0x00)); // 起始地址 0
        req.append(char(0x00)); req.append(char(0x02)); // 读 2 个寄存器（温度+湿度）
        quint16 crc = crc16Modbus(req);           // 计算 CRC16
        req.append(char(crc & 0xFF));             // CRC 低字节在前
        req.append(char(crc >> 8));

        m_serial->write(req);                     // 发送请求（自动方向转换器无需管 DE）
        QTimer::singleShot(200, this, &ModbusPoller::onTimeout);  // 200ms 超时
    }

    void onTimeout() {
        QByteArray resp = m_serial->readAll();
        if (resp.size() >= 7 && checkCrc(resp)) {
            // 解析：温度 = 寄存器0 / 10.0，湿度 = 寄存器1 / 10.0
            short tempRaw = quint8(resp[3]) << 8 | quint8(resp[4]);
            short humRaw  = quint8(resp[5]) << 8 | quint8(resp[6]);
            qDebug() << "从站" << m_slaves[m_index]
                      << "温度:" << tempRaw / 10.0
                      << "湿度:" << humRaw / 10.0;
        } else {
            qWarning() << "从站" << m_slaves[m_index] << "无应答";
        }
        m_index = (m_index + 1) % m_slaves.size();
        QTimer::singleShot(50, this, &ModbusPoller::pollNext);  // 帧间隔后轮询下一站
    }

    QSerialPort *m_serial = nullptr;
    QVector<quint8> m_slaves = {1, 2, 3};  // 三个从站地址
    int m_index = 0;
};

十一、原生 C++ API：Windows 与 Linux

11.1 Linux：termios

// Linux 串口 = 一个设备文件 /dev/ttyUSB0，用 termios 配置
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>

int open_serial(const char *dev) {
    int fd = open(dev, O_RDWR | O_NOCTTY);     // 串口就是文件！
    struct termios tio{};
    tcgetattr(fd, &tio);

    cfsetispeed(&tio, B115200);                // 输入波特率
    cfsetospeed(&tio, B115200);                // 输出波特率
    tio.c_cflag &= ~PARENB;                    // 无校验
    tio.c_cflag &= ~CSTOPB;                    // 1 位停止位
    tio.c_cflag &= ~CSIZE; tio.c_cflag |= CS8; // 8 位数据
    tio.c_cflag |= CLOCAL | CREAD;             // 忽略调制解调器线，启用接收
    tio.c_lflag &= ~(ICANON | ECHO | ISIG);    // 原始模式（非行编辑）
    tio.c_iflag &= ~(IXON | IXOFF);            // 关闭软件流控
    tio.c_cc[VMIN]  = 0;                       // read 不阻塞等最小字节数
    tio.c_cc[VTIME] = 5;                       // 0.5 秒超时

    tcsetattr(fd, TCSANOW, &tio);
    return fd;
}

// 之后 read(fd, buf, n) / write(fd, buf, n) 与普通文件一致

11.2 Windows：Win32 API

// Windows 串口 = 一个设备 \\.\COM3，用 CreateFile 打开
#include <windows.h>

HANDLE open_serial(const wchar_t *port) {   // L"\\\\.\\COM3"
    HANDLE h = CreateFileW(port,
        GENERIC_READ | GENERIC_WRITE, 0, nullptr,
        OPEN_EXISTING, 0, nullptr);

    DCB dcb{}; dcb.DCBlength = sizeof(dcb);
    GetCommState(h, &dcb);
    dcb.BaudRate = CBR_115200;                 // 波特率
    dcb.ByteSize = 8;                          // 数据位
    dcb.Parity   = NOPARITY;                   // 无校验
    dcb.StopBits = ONESTOPBIT;                 // 1 位停止位
    SetCommState(h, &dcb);

    COMMTIMEOUTS to{};
    to.ReadTotalTimeoutConstant = 500;        // 读超时 500ms
    SetCommTimeouts(h, &to);
    return h;
}
// 之后 ReadFile(h,...) / WriteFile(h,...)

十二、应用场景与选型建议

十三、调试技巧与常见问题排查

13.1 常见故障排查表

13.2 调试工具链

// 1. 万用表快速判 485 空闲/活动：测 A-B 间电压
//    空闲态：差压通常 -0.2V ~ +0.2V 附近（可能悬浮）
//    有设备在发：差压在 ±1.5V ~ ±5V 之间跳变

// 2. 双串口自环测试（验证本机串口收发）：TX 接 RX
serial->write("LOOPBACK");
// 收到 "LOOPBACK" → 本机串口栈正常，问题在对端/线缆

// 3. 用两个 USB 转 TTL 模块对接，模拟两端设备联调
// 4. 抓包工具：串口监听（Windows: Serial Port Monitor / Device Monitoring Studio）
// 5. Modbus 调试：Modbus Poll / Modbus Slave（模拟主站/从站）

十四、总结