1. Qt C++ 串口调试助手:不是“能发能收”就叫工具,而是多线程不卡、协议可插拔、数据不丢的工业级现场搭档
你写过一个能打开串口、发几个字节、收到回显就弹窗提示的“调试器”吗?我写过——上线三天就被产线同事退回,说“点个按钮要等两秒”“发一串指令,第三帧就没了”“换了个新设备协议,得重编整个exe”。后来才明白:真正的串口调试助手,从来不是语法练习题,而是嵌入式现场的“神经末梢延伸器”。它必须扛住波特率跳变(9600 ↔ 921600)、应对粘包/断帧/校验错、支持私有协议热插拔,且UI响应不能被后台解析线程拖垮。这篇实战笔记,就带你从零搭起一个Qt C++ 多线程串口调试助手,核心聚焦在「协议解析插件化」这一工业现场最痛的环节——不硬编码、不改源码、不重启,换协议只换一个 .so 或 .dll。适合刚用 Qt 写过 QSerialPort 示例、但没处理过真实产线数据流的开发者;也适合想把实验室 Demo 升级为交付级工具的工程师。文中所有代码、参数、踩坑点,均来自某跨平台工业诊断系统实际落地项目。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 协议解析为何必须解耦?从“硬编码崩溃”到“插件式存活”的工程真相
2.1 硬编码协议的三重死亡陷阱:粘包、误判、不可维护
刚接手串口模块时,我见过最典型的“硬编码协议”写法:在 QSerialPort::readyRead() 槽函数里,直接 readAll() 拿到原始 QByteArray,然后用 if (data.startsWith(...)) 判断帧头,再 mid() 截取长度字段,最后 left() 取载荷。逻辑看似清晰,但一上产线就崩:
- 粘包即崩溃:高速串口(如 2Mbps)下,
readyRead()一次可能触发多次,每次readAll()返回的数据块,大概率是“半帧+整帧+半帧”。硬编码逻辑若没做滑动窗口,就会把第二帧的前半截当无效数据丢弃,导致后续所有帧偏移错位。 - 误判即雪崩:载荷中出现
0xAA55(比如传感器上报的 ADC 值),硬编码startsWith(0xAA55)会把它当成新帧头,强行切帧,结果解析出一堆乱码,且无法恢复。 - 不可维护即废弃:客户新增一个“心跳包”(帧头
0x7E+ 长度1+ 校验XOR),你得改if判断、改长度解析逻辑、改校验算法,重新编译、打包、下发——而产线设备可能正连着 200 台 PLC 跑着关键流程。
提示:这不是理论风险。某次固件升级后,设备协议从“帧头+长度+载荷+和校验”改为“帧头+长度+载荷+CRC16”,硬编码版本因校验逻辑未同步,连续 3 天误报“通信中断”,实际是数据全对但校验失败被静默丢弃。
2.2 插件式解析的设计哲学:接口契约 + 运行时加载 + 生命周期自治
要破局,必须把协议解析从 UI 线程、串口读取线程、数据展示线程中彻底剥离。我们定义一个极简但强约束的 C++ 接口:
cpp复制// IProtocolParser.h
#ifndef IPROTOCOLPARSER_H
#define IPROTOCOLPARSER_H
#include <QByteArray>
#include <QList>
#include <QString>
class IProtocolParser {
public:
virtual ~IProtocolParser() = default;
// 【核心契约】输入:待解析的原始字节流(可含多帧、半帧);输出:成功解析出的完整帧列表
// 注意:buffer 是引用传入,函数内可修改其内容(如移除已解析部分)
virtual QList<QByteArray> parse(QByteArray &buffer) = 0;
// 【核心契约】输入:用户构造的载荷;输出:按协议封装后的完整帧(含帧头、长度、校验等)
virtual QByteArray build(const QByteArray &payload) = 0;
// 【元数据契约】返回协议名称,用于 UI 下拉框显示和日志标记
virtual QString name() const = 0;
// 【可选契约】返回协议描述,用于帮助文档或 tooltip
virtual QString description() const { return ""; }
};
#endif // IPROTOCOLPARSER_H
这个接口的威力在于三点:
parse()的buffer引用参数,强制实现者必须自己管理滑动窗口——你不能假设每次调用都是“干净新数据”,必须处理buffer中残留的半帧;build()封装了所有协议细节,UI 层只需关心“我要发什么数据”,不用管0xAA55在哪、长度字段是大端还是小端;name()和description()让协议成为可发现、可描述的一等公民,为后续“协议市场”打下基础。
2.3 工程落地:Qt 插件机制如何加载 .so/.dll 并安全调用
Qt 的 QPluginLoader 是加载协议插件的黄金路径。它要求插件导出一个继承自 QObject 的工厂类,并用 Q_INTERFACES 声明接口。我们定义插件工厂:
cpp复制// ProtocolPluginInterface.h
#ifndef PROTOCOLPLUGININTERFACE_H
#define PROTOCOLPLUGININTERFACE_H
#include <QObject>
#include "IProtocolParser.h"
// 插件工厂接口:负责创建具体协议解析器实例
class ProtocolPluginInterface : public QObject {
Q_OBJECT
Q_INTERFACES(IProtocolParser)
public:
virtual ~ProtocolPluginInterface() = default;
virtual IProtocolParser* createParser() = 0;
};
#endif // PROTOCOLPLUGININTERFACE_H
一个具体插件(如 libFrameParser.so)的实现骨架如下:
cpp复制// FramePlugin.cpp
#include "FramePlugin.h"
#include "FrameParser.h"
#include <QDebug>
// 必须导出此宏,让 Qt 插件系统识别
Q_EXPORT_PLUGIN2(frameparser, FramePlugin)
FramePlugin::FramePlugin(QObject *parent) : QObject(parent) {}
IProtocolParser* FramePlugin::createParser() {
return new FrameParser(); // 返回堆上新对象,由调用方管理生命周期
}
主程序加载逻辑(放在 MainWindow 构造函数中):
cpp复制// MainWindow.cpp
#include <QPluginLoader>
#include <QDir>
#include <QFileInfo>
void MainWindow::loadProtocolPlugins() {
// 1. 定义插件目录(建议与 exe 同级的 ./plugins/protocols/)
QDir pluginDir("./plugins/protocols/");
if (!pluginDir.exists()) {
qWarning() << "Plugin directory not found:" << pluginDir.path();
return;
}
// 2. 查找所有符合命名规则的动态库(Linux: *.so, Windows: *.dll)
QStringList filters;
#ifdef Q_OS_WIN
filters << "*.dll";
#else
filters << "*.so";
#endif
pluginDir.setNameFilters(filters);
// 3. 遍历并加载每个插件
for (const QString &fileName : pluginDir.entryList(filters)) {
QString fullPath = pluginDir.absoluteFilePath(fileName);
QPluginLoader loader(fullPath);
QObject *plugin = loader.instance(); // 实例化插件对象
if (plugin) {
ProtocolPluginInterface *interface = qobject_cast<ProtocolPluginInterface*>(plugin);
if (interface) {
IProtocolParser *parser = interface->createParser();
if (parser) {
m_parsers.append(qMakePair(fileName, parser));
ui->protocolComboBox->addItem(parser->name(), fileName);
qDebug() << "Loaded protocol plugin:" << fileName << "as" << parser->name();
} else {
qWarning() << "Plugin" << fileName << "failed to create parser";
}
} else {
qWarning() << "Plugin" << fileName << "does not implement ProtocolPluginInterface";
}
} else {
qWarning() << "Failed to load plugin:" << fileName << loader.errorString();
}
}
// 4. 若无插件,默认加载内置解析器(如 FrameParser)
if (m_parsers.isEmpty()) {
m_parsers.append(qMakePair("builtin", new FrameParser()));
ui->protocolComboBox->addItem("Built-in Frame Parser", "builtin");
}
}
关键细节说明:
QPluginLoader::instance()返回的是插件 DLL/SO 的实例,不是QPluginLoader自身。必须用qobject_cast转成你的接口类型;createParser()返回的是new出来的堆对象,主程序必须负责delete。我们用QList<QPair<QString, IProtocolParser*>>存储,析构时统一释放;- 插件目录路径
./plugins/protocols/是硬编码的,但可通过配置文件或命令行参数覆盖,这是工程化第一步。
3. 手把手实现一个工业级帧解析器:滑动窗口、大端长度、和校验容错全解析
3.1 核心逻辑拆解:为什么 while (buffer.size() >= 4) 是生死线?
FrameParser::parse() 的第一行 while (buffer.size() >= 4) 看似简单,实则是整个解析器的“呼吸节奏”。它意味着:我们只承诺解析出“至少包含帧头+长度字段”的最小单元,绝不假设 buffer 里有完整帧。这直接对抗粘包问题。
cpp复制// FrameParser.cpp
#include "FrameParser.h"
#include <QByteArray>
#include <QList>
#include <QDebug>
QList<QByteArray> FrameParser::parse(QByteArray &buffer) {
QList<QByteArray> frames;
// 主循环:只要 buffer 里还有足够字节找帧头,就继续滑动
while (buffer.size() >= 4) {
// 步骤1:检查帧头(0xAA55)
if (static_cast<quint8>(buffer[0]) != 0xAA ||
static_cast<quint8>(buffer[1]) != 0x55) {
// 帧头不匹配:滑动一位,丢弃第一个字节(可能是干扰或半帧残留)
buffer.remove(0, 1);
continue; // 立即重试,不退出循环
}
// 步骤2:解析长度字段(第2、3字节,大端序)
quint16 len = (static_cast<quint8>(buffer[2]) << 8) |
static_cast<quint8>(buffer[3]);
// 步骤3:检查 buffer 是否足够容纳“帧头(2)+长度(2)+载荷(len)+校验(1)”
// 注意:这里 len 是纯载荷长度,不包括帧头、长度、校验
if (buffer.size() < 4 + len + 1) {
// 数据不足:等待更多字节到来,跳出循环,保留当前 buffer
break;
}
// 步骤4:提取完整候选帧(4字节头+长+len+1字节校验)
QByteArray candidate = buffer.left(4 + len + 1);
// 步骤5:计算和校验(从帧头开始,到校验字节前一个)
quint8 sum = 0;
for (int i = 0; i < candidate.size() - 1; ++i) {
sum += static_cast<quint8>(candidate[i]);
}
// 步骤6:校验通过则确认为有效帧,加入结果列表
if (sum == static_cast<quint8>(candidate.back())) {
frames.append(candidate);
} else {
// 校验失败:整帧丢弃!不尝试“修正”或“跳过单字节”,避免雪崩
qWarning() << "Frame checksum failed, discarded";
}
// 步骤7:从 buffer 中移除已处理的完整帧
buffer.remove(0, 4 + len + 1);
}
return frames;
}
逐行参数与设计意图:
buffer.remove(0, 1):这是滑动窗口的精髓。当0xAA55不在开头时,我们只丢弃第一个字节,而不是整个 buffer。因为下一个字节0x55可能就是下一帧的帧头(0x55后面跟着0xAA?不,但0x55后面跟着0xXX,而0xXX后面可能才是0xAA55)。暴力清空 buffer 会导致数据丢失。buffer.size() < 4 + len + 1:这是“等待”逻辑。如果 buffer 里只有0xAA55 00 10(表示载荷应为 16 字节),但后面只跟了 5 字节,我们就break,让readyRead()下次触发时带着新数据再进来。这保证了“宁可慢,不可错”。candidate.back():QByteArray::back()返回最后一个字节,即校验字节。static_cast<quint8>确保无符号运算,避免负数溢出。frames.append(candidate):只添加校验成功的帧。失败帧被qWarning记录,但绝不污染frames列表——下游(如数据显示、日志保存)只处理可信数据。
3.2 build() 方法:如何把用户输入的“字符串”变成带校验的二进制帧?
build() 是 parse() 的逆过程,但它更简单,因为输入是受控的(用户构造的 payload)。核心是填充、计算、拼接:
cpp复制QByteArray FrameParser::build(const QByteArray &payload) {
// 1. 构造帧头:0xAA 0x55
QByteArray frame;
frame.append(0xAA);
frame.append(0x55);
// 2. 写入长度字段(大端序,2字节)
quint16 len = static_cast<quint16>(payload.size());
frame.append(static_cast<char>((len >> 8) & 0xFF)); // 高字节
frame.append(static_cast<char>(len & 0xFF)); // 低字节
// 3. 写入载荷
frame.append(payload);
// 4. 计算和校验(对帧头+长度+载荷求和)
quint8 sum = 0;
for (int i = 0; i < frame.size(); ++i) {
sum += static_cast<quint8>(frame[i]);
}
// 5. 追加校验字节
frame.append(static_cast<char>(sum));
return frame;
}
关键点:
payload.size()直接作为长度值,无需额外校验——因为这是用户可控输入;>> 8和& 0xFF是标准的大端拆分,确保0x1234变成0x12 0x34;- 校验计算范围是
frame当前所有字节(不含校验字节本身),所以frame.append(payload)后立即计算,再append(sum)。
3.3 name() 与 description():让协议在 UI 中“活”起来
这两个方法看似简单,却是用户体验的关键:
cpp复制QString FrameParser::name() const {
return "Frame Header (0xAA55)";
}
QString FrameParser::description() const {
return "Standard industrial frame: [0xAA][0x55][LEN_H][LEN_L][PAYLOAD...][CHECKSUM]. "
"Supports variable payload length up to 65535 bytes. Checksum is simple byte sum.";
}
它们被用于:
QComboBox::addItem(name(), userData):下拉框显示友好名称,userData存储插件文件名,方便后续加载;QToolTip::showText():鼠标悬停时显示详细描述,省去查文档;- 日志系统:
qInfo() << "Parsed frame with" << parser->name();,日志可读性大幅提升。
4. 多线程串口读取:为什么 QSerialPort 不能在主线程里 readAll()?
4.1 主线程阻塞的灾难现场:从“界面卡死”到“数据丢失”
QSerialPort 默认是异步的,readyRead() 信号在数据到达时触发。但很多新手会犯一个致命错误:在 readyRead() 槽函数里,直接调用 serial->readAll(),然后立刻用 parse() 解析,再 ui->textEdit->append() 显示。这在低速(9600bps)下可能“看起来”正常,但一旦波特率升到 115200 或更高,问题爆发:
- UI 卡死:
parse()解析逻辑(尤其是复杂协议)可能耗时几毫秒,而高速串口每秒产生数千帧。readyRead()信号会高频触发,槽函数持续占用主线程,QApplication::processEvents()无法执行,按钮点击无响应,窗口拖拽卡顿。 - 数据丢失:
QSerialPort的内部接收缓冲区(通常 4KB)是有限的。如果readyRead()槽函数执行太慢,新数据涌入时旧数据还没被readAll()取走,缓冲区溢出,QSerialPort会静默丢弃后续数据——你永远收不到readyRead()信号,因为数据根本没进缓冲区。
提示:这不是猜测。用逻辑分析仪抓过真实波形:当 UI 卡顿时,串口线上数据流是连续的,但
QSerialPort的bytesAvailable()在卡顿期间始终为 0,证明数据已被硬件层丢弃。
4.2 正确解法:工作线程 + 信号队列 + 移动对象
Qt 推荐的线程模型是“移动对象到线程”,而非继承 QThread。我们创建一个 SerialWorker 对象,将其 moveToThread(),并通过信号/槽与主线程通信:
cpp复制// SerialWorker.h
#ifndef SERIALWORKER_H
#define SERIALWORKER_H
#include <QObject>
#include <QSerialPort>
#include <QByteArray>
#include <QList>
#include "IProtocolParser.h"
class SerialWorker : public QObject {
Q_OBJECT
public:
explicit SerialWorker(QObject *parent = nullptr);
void setSerialPort(QSerialPort *port);
void setParser(IProtocolParser *parser);
signals:
void dataReceived(const QList<QByteArray> &frames); // 解析后的帧列表
void errorOccurred(const QString &error);
public slots:
void startReading(); // 启动读取循环
void stopReading(); // 停止读取
private slots:
void onReadyRead(); // 串口有数据到达
private:
QSerialPort *m_serial;
IProtocolParser *m_parser;
QByteArray m_readBuffer; // 工作线程私有的接收缓冲区
};
#endif // SERIALWORKER_H
SerialWorker 的核心实现(onReadyRead()):
cpp复制// SerialWorker.cpp
#include "SerialWorker.h"
#include <QThread>
#include <QTimer>
#include <QDebug>
SerialWorker::SerialWorker(QObject *parent) : QObject(parent), m_serial(nullptr), m_parser(nullptr) {}
void SerialWorker::setSerialPort(QSerialPort *port) {
m_serial = port;
// 关键:将串口对象也移动到此线程(如果它还没移动)
if (m_serial && m_serial->thread() != this->thread()) {
m_serial->moveToThread(this->thread());
}
}
void SerialWorker::setParser(IProtocolParser *parser) {
m_parser = parser;
}
void SerialWorker::startReading() {
if (!m_serial || !m_parser) {
emit errorOccurred("Serial port or parser not set");
return;
}
// 连接串口的 readyRead 信号到本对象的槽
connect(m_serial, &QSerialPort::readyRead, this, &SerialWorker::onReadyRead, Qt::DirectConnection);
// DirectConnection 确保信号在工作线程中执行,而非排队到主线程
}
void SerialWorker::stopReading() {
if (m_serial) {
disconnect(m_serial, &QSerialPort::readyRead, this, &SerialWorker::onReadyRead);
}
}
void SerialWorker::onReadyRead() {
if (!m_serial || !m_parser) return;
// 1. 从串口读取所有可用数据,追加到工作线程缓冲区
QByteArray newData = m_serial->readAll();
m_readBuffer.append(newData);
// 2. 调用协议解析器解析缓冲区
QList<QByteArray> parsedFrames = m_parser->parse(m_readBuffer);
// 3. 如果解析出帧,发射信号通知主线程
if (!parsedFrames.isEmpty()) {
emit dataReceived(parsedFrames);
}
// 注意:m_readBuffer 中未解析的部分(半帧)自动保留,下次 onReadyRead 继续处理
}
主线程(MainWindow)的配合:
cpp复制// MainWindow.cpp
void MainWindow::setupSerialWorker() {
// 1. 创建工作线程和 worker 对象
m_workerThread = new QThread(this);
m_serialWorker = new SerialWorker();
// 2. 将 worker 移动到新线程
m_serialWorker->moveToThread(m_workerThread);
// 3. 连接信号(主线程槽函数)
connect(m_workerThread, &QThread::started, m_serialWorker, &SerialWorker::startReading);
connect(m_serialWorker, &SerialWorker::dataReceived, this, &MainWindow::onDataReceived);
connect(m_serialWorker, &SerialWorker::errorOccurred, this, &MainWindow::onWorkerError);
// 4. 启动线程
m_workerThread->start();
}
void MainWindow::onDataReceived(const QList<QByteArray> &frames) {
// 此槽函数在主线程执行,安全更新 UI
for (const QByteArray &frame : frames) {
// 将二进制帧转为十六进制字符串显示
QString hexStr = frame.toHex(' ').toUpper();
ui->receivedTextEdit->append(QString("[%1] %2")
.arg(QTime::currentTime().toString("hh:mm:ss.zzz"))
.arg(hexStr));
}
}
关键设计点:
Qt::DirectConnection:强制onReadyRead()在工作线程中执行,避免信号排队到主线程造成阻塞;m_readBuffer是工作线程私有变量,parse()修改它不会影响主线程;dataReceived信号携带的是QList<QByteArray>,这是QMetaType注册过的类型,Qt 会自动序列化传递,安全可靠;m_serial->moveToThread()是可选但推荐的,确保串口操作完全在工作线程,避免跨线程调用风险。
4.3 避坑 / 常见问题 / 排查:多线程串口的五个血泪教训
-
现象:程序启动后,
readyRead()信号从未触发,串口灯常亮但无数据。
原因:QSerialPort对象创建在主线程,但SerialWorker被moveToThread()后,connect()时若未指定Qt::DirectConnection,信号默认是QueuedConnection,而QSerialPort的readyRead()信号是在主线程发出的,工作线程无法接收排队信号。
解决:connect(m_serial, &QSerialPort::readyRead, this, &SerialWorker::onReadyRead, Qt::DirectConnection);—— 必须显式指定。 -
现象:高速串口下,
onReadyRead()被频繁调用,但m_readBuffer越来越大,最终 OOM(内存溢出)。
原因:parse()解析速度跟不上数据流入速度,m_readBuffer中积累了大量未解析的半帧,且没有设置最大缓冲区限制。
解决:在onReadyRead()开头添加缓冲区大小检查:if (m_readBuffer.size() > 1024 * 1024) { qWarning() << "Read buffer overflow, clearing"; m_readBuffer.clear(); }。1MB 是经验值,可根据协议最大帧长调整。 -
现象:切换协议插件后,新协议解析出错,但旧协议还能用。
原因:m_parser指针未及时更新。SerialWorker的setParser()被调用,但onReadyRead()中仍使用旧指针,而旧插件 DLL 已被卸载,指针悬空。
解决:在setParser()中,先delete旧m_parser(如果非空),再赋新值;同时确保插件 DLL 在整个程序生命周期内不被卸载(Qt 插件默认不卸载,除非你主动调用unload())。 -
现象:
QSerialPort::open()成功,但bytesAvailable()始终为 0,readyRead()不触发。
原因:串口参数(波特率、数据位、停止位、校验位)与设备不匹配。open()只检查硬件连接,不验证通信参数。
解决:在open()后,立即serial->setBaudRate()、setDataBits()等设置,并用serial->isReadable()辅助判断;更可靠的是发送一个已知响应的命令(如AT\r\n),看是否收到回显。 -
现象:程序退出时崩溃,堆栈指向
QSerialPort的析构函数。
原因:QSerialPort对象仍在工作线程中,而主线程已开始析构,QThread被销毁,QSerialPort的析构在无效线程上下文中执行。
解决:在MainWindow::closeEvent()中,先调用m_serialWorker->stopReading(),再m_workerThread->quit(),然后m_workerThread->wait()等待线程安全退出,最后再deletem_serialWorker和m_workerThread。
5. 协议插件开发实战:从零编写一个 CRC16 校验的 Modbus RTU 插件
5.1 Modbus RTU 协议精要:为什么它比 0xAA55 更复杂?
Modbus RTU 是工业现场最常用的协议之一,其帧结构为:[Address][Function][Data...][CRC_L][CRC_H]。与 0xAA55 帧相比,它有三大差异:
- 无固定帧头:靠地址字节(1字节)和功能码(1字节)识别,地址范围
0x01-0xFF,功能码如0x03(读保持寄存器); - 长度不显式:帧长由地址、功能码、数据长度共同决定,需解析功能码才能知道数据域长度;
- CRC16 校验:非简单和校验,而是基于多项式
0xA001的循环冗余校验,计算复杂,必须查表或专用算法。
因此,一个健壮的 Modbus RTU 解析器,必须能:
- 识别合法地址和功能码组合;
- 根据功能码动态计算预期帧长;
- 正确计算和验证 CRC16。
5.2 编写 ModbusRtuParser:复用框架,专注协议逻辑
我们继承 IProtocolParser,只重写 parse() 和 build():
cpp复制// ModbusRtuParser.h
#ifndef MODBUSRTUPARSER_H
#define MODBUSRTUPARSER_H
#include "IProtocolParser.h"
#include <QByteArray>
#include <QList>
class ModbusRtuParser : public IProtocolParser {
public:
QList<QByteArray> parse(QByteArray &buffer) override;
QByteArray build(const QByteArray &payload) override;
QString name() const override;
QString description() const override;
private:
// CRC16 查表法(标准 Modbus 多项式 0xA001)
static quint16 crc16(const QByteArray &data);
// 判断帧是否完整(根据功能码推算)
bool isCompleteFrame(const QByteArray &frame) const;
};
#endif // MODBUSRTUPARSER_H
parse() 的核心逻辑(ModbusRtuParser.cpp):
cpp复制#include "ModbusRtuParser.h"
#include <QByteArray>
#include <QList>
#include <QDebug>
QList<QByteArray> ModbusRtuParser::parse(QByteArray &buffer) {
QList<QByteArray> frames;
// Modbus RTU 帧最小长度:地址(1) + 功能码(1) + CRC(2) = 4 字节
while (buffer.size() >= 4) {
// 步骤1:检查地址字节(0x01-0xFF,0x00 为广播,一般不用于请求)
quint8 address = static_cast<quint8>(buffer[0]);
if (address == 0x00 || address > 0xFF) {
// 地址非法:滑动一位
buffer.remove(0, 1);
continue;
}
// 步骤2:检查功能码(常见:0x01,0x02,0x03,0x04,0x05,0x06,0x10)
quint8 function = static_cast<quint8>(buffer[1]);
if (function == 0x00 || function > 0x7F) {
buffer.remove(0, 1);
continue;
}
// 步骤3:根据功能码,计算预期最小帧长
int minFrameLen = 0;
switch (function) {
case 0x01: case 0x02: // 读线圈/离散输入:返回字节数 + 数据
minFrameLen = 5; // 地址+功能+字节数+数据+CRC
break;
case 0x03: case 0x04: // 读保持/输入寄存器:返回字节数 + 数据*2
minFrameLen = 5;
break;
case 0x05: case 0x06: // 写单个线圈/寄存器:返回原请求
minFrameLen = 8; // 请求6字节 + CRC2
break;
case 0x10: // 写多个寄存器:请求 + 数据
minFrameLen = 8;
break;
default:
// 未知功能码,按最小帧长(地址+功能+CRC)尝试
minFrameLen = 4;
}
// 步骤4:检查 buffer 是否足够容纳最小帧
if (buffer.size() < minFrameLen) {
break; // 等待更多数据
}
// 步骤5:提取候选帧(从地址开始,到 CRC 结束)
// Modbus RTU 帧结尾是 CRC_L + CRC_H,共2字节
QByteArray candidate = buffer.left(buffer.size() >= 6 ? buffer.size() : minFrameLen);
// 但我们需要精确到 CRC 结尾,所以先假设最大可能长度,再校验
// 更稳妥做法:从 buffer 开头,尝试不同长度(4,5,6,...)直到 CRC 匹配或超限
// 这里简化:取 buffer 前 256 字节(Modbus 最大帧长)进行穷举
int maxTryLen = qMin(256, buffer.size());
bool foundValid = false;
for (int len = minFrameLen; len <= maxTryLen; ++len) {
if (len < 4) continue;
if (buffer.size() < len) break;
QByteArray tryFrame = buffer.left(len);
if (tryFrame.size() < 4) continue;
// CRC 校验:取 tryFrame 去掉最后2字节,计算 CRC,对比最后2字节
QByteArray dataPart = tryFrame.left(tryFrame.size() - 2);
quint16 calcCrc = crc16(dataPart);
quint16 recvCrc = static_cast<quint16>(static_cast<quint8>(tryFrame[tryFrame.size()-2])) |
(static_cast<quint16>(static_cast<quint8>(tryFrame[tryFrame.size()-1])) << 8);
if (calcCrc == recvCrc) {
// 校验通过,确认为有效帧
frames.append(tryFrame);
buffer.remove(0, len);
foundValid = true;
break; // 退出 for 循环,回到 while 继续
}
}
if (!foundValid) {
// 未找到有效帧:滑动一位,避免死循环
buffer.remove(0, 1);
}
}
return frames;
}
// CRC16 计算(查表法,标准 Modbus)
quint16 ModbusRtuParser::crc16(const QByteArray &data) {
static const quint16 table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
// ... (完整256项表,此处省略,实际代码中需填满)
0x8201, 0x02C0, 0x0380, 0x8341, 0x0100, 0x81C1, 0x8081, 0x0040
};
quint16 crc = 0xFFFF;
for (int i = 0; i < data.size(); ++i) {
quint8 byte = static_cast<quint8>(data[i]);
crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF];
}
return crc;
}
QString ModbusRtuParser
