串口通信全景详解

一、什么是串口通信

串口通信（Serial Communication）是指数据一位一位地按顺序传输的通信方式。与之相对的是并行通信，多位数据同时通过多根线传输。

串口是嵌入式开发中最基础、最常用的通信接口。从 Arduino 的 Serial.print()，到工业 PLC 的 Modbus，再到你电脑曾经的 COM 口，底层都是串口通信。

二、串行 vs 并行：为什么串口赢了

早期计算机用并行口（LPT 打印口、IDE 硬盘）因为看起来"8 根线同时传 8 位 = 8 倍速度"。但并行最终被串行取代，原因有三：

三、通信三要素：方向、时钟、电平

3.1 方向：单工 / 半双工 / 全双工

3.2 时钟：同步 vs 异步

3.3 电平：TTL / RS-232 / RS-485 / RS-422

这是串口种类最多的维度。同一个 UART 协议，配上不同电平标准，就变成了不同"串口"：

四、UART：串口的大脑

UART（Universal Asynchronous Receiver/Transmitter，通用异步收发器）是串口通信的协议核心。它不是一种电平，而是规定了数据如何打包成帧、如何收发。

4.1 UART 硬件结构

• 发送器 TX：将并行数据转成串行位流，自动加起始位/停止位
• 接收器 RX：检测起始位，按约定波特率采样，还原并行数据
• 波特率发生器：产生收发时钟，决定"语速"
• FIFO（可选）：缓冲收发数据，减少 CPU 中断频率

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

UART 的核心是帧格式。一个 UART 帧由 4 部分组成：

5.1 各字段详解

5.2 常见配置

串口配置通常写成 波特率-数据位-校验-停止位 格式：

• 115200-8-N-1：最常用。115200 波特率，8 数据位，无校验，1 停止位
• 9600-8-E-1：工业常用。9600 波特率，偶校验
• 9600-7-E-1：Modbus RTU 标准配置

六、波特率：通信的"语速"

波特率（Baud Rate）是每秒传输的码元数。在 UART 中，1 个码元 = 1 bit，所以波特率 = 比特率。常见值：9600、115200、921600 等。

6.1 常见波特率与场景

七、TTL 串口：MCU 的母语

TTL 串口是 MCU（单片机）直接输出的串口电平。0V 表示逻辑 0，3.3V 或 5V 表示逻辑 1。

7.1 TTL 串口的三种电压

八、RS-232：经典的 DB9 串口

RS-232是 1960 年代的标准，用 负逻辑：-3V~-15V 表示逻辑 1，+3V~+15V 表示逻辑 0。采用 DB9 接口（9 针 D 型连接器）。

8.1 DB9 接口引脚

九、RS-485：工业总线的王者

RS-485采用差分信号传输，用两根线 A 和 B，信号靠电压差判断。最多 32~256 节点，传输距离 1200 米。

十、RS-422：全双工差分方案

RS-422是 RS-485 的"全双工版本"。用两对差分线（4 根），一对发（TX+/TX-），一对收（RX+/RX-），同时收发。

十一、全家族对比与选型

11.1 选型决策树

十二、串口硬件：接口与线缆

12.1 常见物理接口

12.2 电平转换芯片

十三、Qt/C++ 实战代码

13.1 Qt 串口通信基础

// SerialPort.h —— Qt 串口封装
#ifndef SERIALPORT_H
#define SERIALPORT_H

#include <QObject>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QByteArray>

class SerialPort : public QObject {
    Q_OBJECT
public:
    explicit SerialPort(QObject *parent = nullptr);
    ~SerialPort();

    // 列举可用串口
    static QStringList listPorts();

    // 打开串口
    bool open(const QString &portName,
              qint32 baudRate = 115200,
              QSerialPort::DataBits dataBits = QSerialPort::Data8,
              QSerialPort::Parity parity = QSerialPort::NoParity,
              QSerialPort::StopBits stopBits = QSerialPort::OneStop);

    void close();
    bool isOpen() const;
    qint64 write(const QByteArray &data);

signals:
    void dataReceived(const QByteArray &data);
    void errorOccurred(const QString &error);

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

private:
    QSerialPort *m_serial;
    QByteArray m_buffer;  // 接收缓冲区
};

#endif

// SerialPort.cpp —— 实现
#include "SerialPort.h"
#include <QDebug>

QStringList SerialPort::listPorts() {
    QStringList ports;
    for (const QSerialPortInfo &info : QSerialPortInfo::availablePorts()) {
        ports << QString("%1 (%2 - %3)")
                   .arg(info.portName())
                   .arg(info.description())
                   .arg(info.manufacturer());
    }
    return ports;
}

SerialPort::SerialPort(QObject *parent) : QObject(parent), m_serial(new QSerialPort(this)) {
    connect(m_serial, &QSerialPort::readyRead, this, &SerialPort::onReadyRead);
    connect(m_serial, &QSerialPort::errorOccurred, this, &SerialPort::onErrorOccurred);
}

SerialPort::~SerialPort() { if (m_serial->isOpen()) m_serial->close(); }

bool SerialPort::open(const QString &portName, qint32 baudRate,
                  QSerialPort::DataBits dataBits,
                  QSerialPort::Parity parity,
                  QSerialPort::StopBits stopBits) {
    m_serial->setPortName(portName);
    m_serial->setBaudRate(baudRate);
    m_serial->setDataBits(dataBits);
    m_serial->setParity(parity);
    m_serial->setStopBits(stopBits);
    m_serial->setFlowControl(QSerialPort::NoFlowControl);

    if (!m_serial->open(QIODevice::ReadWrite)) {
        emit errorOccurred(m_serial->errorString());
        return false;
    }
    return true;
}

void SerialPort::close() { m_serial->close(); }
bool SerialPort::isOpen() const { return m_serial->isOpen(); }

qint64 SerialPort::write(const QByteArray &data) {
    return m_serial->write(data);
}

void SerialPort::onReadyRead() {
    QByteArray data = m_serial->readAll();
    m_buffer.append(data);

    // 按换行符分包（常见协议以 \n 或 \r\n 分隔）
    int idx;
    while ((idx = m_buffer.indexOf('\n')) >= 0) {
        QByteArray line = m_buffer.left(idx + 1);
        m_buffer.remove(0, idx + 1);
        emit dataReceived(line.trimmed());
    }
}

void SerialPort::onErrorOccurred(QSerialPort::SerialPortError error) {
    if (error != QSerialPort::NoError) {
        emit errorOccurred(m_serial->errorString());
    }
}

13.2 实战：NMEA GPS 数据解析

// main.cpp —— 读取 GPS 模块 NMEA 数据
#include <QCoreApplication>
#include "SerialPort.h"
#include <QDebug>
#include <QRegularExpression>

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

    SerialPort serial;

    // GPS 模块通常 9600 波特率
    if (!serial.open("COM3", 9600)) {
        qDebug() << "打开串口失败";
        return -1;
    }

    QObject::connect(&serial, &SerialPort::dataReceived, [](const QByteArray &line) {
        QString msg = QString::fromUtf8(line);

        // 解析 NMEA GPRMC 语句：$GPRMC,时间,状态,纬度,N,经度,E,速度,航向,日期
        if (msg.startsWith("$GPRMC")) {
            QStringList parts = msg.split(',');
            if (parts.size() >= 10) {
                QString status = parts[2]; // A=有效, V=无效
                QString lat = parts[3];  // 纬度 ddmm.mmmm
                QString lon = parts[5];  // 经度 dddmm.mmmm
                QString speed = parts[7]; // 速度（节）

                if (status == "A") {
                    qDebug() << "GPS有效:" << "Lat=" << lat << "Lon=" << lon
                             << "Speed=" << speed << "knots";
                }
            }
        }
    });

    QObject::connect(&serial, &SerialPort::errorOccurred, [](const QString &err) {
        qDebug() << "串口错误:" << err;
    });

    qDebug() << "GPS 监听已启动...";
    return app.exec();
}

13.3 RS-485 方向控制

// RS-485 半双工需要控制收发方向
// DE/RE 引脚：高=发送，低=接收

void sendRs485(QSerialPort *serial, const QByteArray &data) {
    // 1. 拉高 RTS（DE=1），进入发送模式
    serial->setRequestToSend(true);

    // 2. 发送数据
    serial->write(data);
    serial->flush();

    // 3. 等待最后一个字节发送完毕
    while (serial->bytesToWrite() > 0) {
        serial->waitForBytesWritten(100);
    }

    // 4. 关键延时：等待最后一个位真正离开移位寄存器
    QThread::msleep(2);

    // 5. 拉低 RTS（DE=0），切回接收模式
    serial->setRequestToSend(false);
}

// 完整的 Modbus RTU 主站轮询示例
class ModbusMaster : public QObject {
    Q_OBJECT
public:
    explicit ModbusMaster(QSerialPort *s, QObject *p = nullptr)
        : QObject(p), m_serial(s) {
        connect(m_serial, &QSerialPort::readyRead, this, &ModbusMaster::onRead);
    }

    void readHoldingRegisters(quint8 slave, quint16 addr, quint16 count) {
        QByteArray req;
        req.append(char(slave));     // 从站地址
        req.append(char(0x03));      // 功能码：读保持寄存器
        req.append(char((addr >> 8) & 0xFF));
        req.append(char(addr & 0xFF));
        req.append(char((count >> 8) & 0xFF));
        req.append(char(count & 0xFF));
        quint16 crc = crc16Modbus(req);
        req.append(char(crc & 0xFF));
        req.append(char((crc >> 8) & 0xFF));

        sendRs485(m_serial, req);  // 485 方向控制发送
    }

private slots:
    void onRead() {
        QByteArray resp = m_serial->readAll();
        if (resp.size() >= 5) {
            quint8 slave = resp[0];
            quint8 func = resp[1];
            quint8 byteCount = resp[2];
            qDebug() << "从站" << slave << "功能码" << QString::number(func, 16);
        }
    }

private:
    QSerialPort *m_serial;

    // Modbus CRC16 计算
    quint16 crc16Modbus(const QByteArray &data) {
        quint16 crc = 0xFFFF;
        for (int i = 0; i < data.size(); i++) {
            crc ^= (quint8)data[i];
            for (int j = 0; j < 8; j++) {
                if (crc & 1) crc = (crc >> 1) ^ 0xA001;
                else crc >>= 1;
            }
        }
        return crc;
    }
};

十四、应用场景全景

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

15.1 调试三板斧

1. 先确认物理层：万用表测 TX/RX 引脚有无电压跳变，排除接线问题
2. 用串口助手回环测试：TX 短接 RX，发什么收什么 → 证明本机串口正常
3. 抓包对比：用逻辑分析仪或串口监控工具，看实际波形和数据

15.2 常见问题速查

15.3 常用调试工具

十六、总结