Qt企业级串口通信实战：高效稳定的工业级应用开发指南

目录

一、前言

二、问题代码剖析

2.1 典型缺陷示例

2.2 企业级应用必备特性对比

三、关键优化策略与代码实现

3.1 增强型串口管理类

问题1：explicit关键字的作用

3.2 智能错误恢复机制

3.3 数据分帧处理算法

四、性能优化实测数据

五、工业级应用场景

六、实例代码

6.1进阶版

6.2最终版

一、前言

        在工业控制、物联网终端、智能硬件等领域，串口通信的稳定性和容错性直接决定了系统可靠性。本文通过重构一个Qt串口模块，揭秘如何实现使用QT完成企业级串口程序的编写。一个稳定可靠的串口应具备以下特性：

✅ 1、完善的硬件热插拔检测

✅ 2、智能化的错误恢复机制

✅ 3、完整的数据收发生命周期监控

✅ 4、支持多波特率/数据位动态切换

✅ 5、毫秒级响应的大数据吞吐控制

二、问题代码剖析

2.1 典型缺陷示例

// 问题1：指针未初始化导致崩溃风险
WidSerial::~WidSerial()
{
    delete ui; // m_comMain未释放！
}

// 问题2：未验证波特率有效性
void WidSerial::on_btnComOpen_clicked()
{
    m_comMain->setBaudRate(ui->cmbBaudRate->currentText().toInt());
}

// 问题3：未处理数据分帧问题
void WidSerial::slotComDataRecv()
{
    QByteArray byteNow = m_comMain->readAll();
}

2.2 企业级应用必备特性对比

三、关键优化策略与代码实现

3.1 增强型串口管理类

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

    // 带超时的阻塞式发送
    bool writeData(const QByteArray &data, int timeoutMs = 3000);
    
    // 自动波特率协商
    bool autoDetectBaudRate();

signals:
    void errorOccurred(int errorCode, const QString &description);
    void dataValidated(const QByteArray &validData); // 校验通过的数据

private:
    QSerialPort *m_port;
    QMutex m_mutex; // 线程安全锁
    CRC16 m_crc;    // 数据校验器
};

问题1：explicit关键字的作用

防止隐式类型转换：

        当你声明一个构造函数时，如果没有使用 explicit 关键字，编译器会允许隐式地将其他类型转换为该构造函数的类型。例如，如果你没有使用 explicit，那么编译器会自动进行类型转换，将一个整数或其他类型的对象传递给该构造函数。

明确创建对象时传递的参数类型：

       使用 explicit 修饰构造函数后，编译器会阻止这种隐式转换，只能通过显式调用构造函数来进行类型转换。这避免了一些可能导致错误的隐式转换，使代码更易于理解和维护。

例如：

class MainWindow : public QMainWindow { public: MainWindow(int x) { // 构造函数 } };

        可以这样隐式地创建 MainWindow 对象，这段代码虽然可以编译，但它的行为不易察觉且可能产生难以发现的错误，特别是在大型项目中。

MainWindow window = 10; // 编译器会将 10 转换为 MainWindow(int) 类型调用构造函数

加上explicit后：

MainWindow window = 10; // 编译错误：不能将整数隐式转换为 MainWindow 对象
MainWindow window(10); // 正确，显式调用构造函数

        通常，建议对于只有单一参数的构造函数使用 explicit，特别是在设计类时，防止不小心引入隐式类型转换。

3.2 智能错误恢复机制

void WidSerial::handleComError(QSerialPort::SerialPortError error)
{
    static int retryCount = 0;
    
    if(error == QSerialPort::ResourceError){
        if(retryCount++ < MAX_RETRY){
            QTimer::singleShot(1000, this, [this](){
                if(autoReconnect()){
                    emit logMessage("自动重连成功");
                    retryCount = 0;
                }
            });
        } else {
            emit fatalError(tr("连续重连失败，请检查硬件"));
        }
    }
}

3.3 数据分帧处理算法

graph TD
    A[接收原始数据] --> B{缓存队列是否为空?}
    B -->|是| C[追加新数据]
    B -->|否| D[合并数据]
    D --> E[查找帧头0xAA]
    E --> F[检测帧长度]
    F --> G{数据足够一帧?}
    G -->|是| H[提取完整帧]
    G -->|否| I[等待更多数据]
    H --> J[CRC校验]
    J -->|成功| K[提交有效数据]
    J -->|失败| L[丢弃错误帧]

四、性能优化实测数据

对100万条随机数据包进行压力测试：

五、工业级应用场景

1. PLC控制：实现Modbus RTU协议
2. 智能电表：DL/T645规约解析
3. GPS终端：NMEA-0183数据处理
4. 医疗设备：ISO/IEEE 11073通信

六、实例代码

6.1进阶版

#ifndef WIDSERIAL_H
#define WIDSERIAL_H

#include <QWidget>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QMessageBox>
#include <QDebug>
#include "quiwidget.h"

namespace Ui {
class WidSerial;
}

class WidSerial : public QWidget
{
    Q_OBJECT

public:
    explicit WidSerial(QWidget *parent = 0);
    ~WidSerial();

    //  串口变量
    QSerialPort* m_comMain = NULL;

    //  串口是否已连接
    bool IsComConnected();

    //  设置波特率
    void SetBaudrate(int nBaudrate);

    //  获取波特率
    int GetBaudrate();

    //  设置串口
    void SetUART(QString strCom);

    //  读取串口
    QString GetUART();

public slots:
    void on_btnScanPort_clicked();

    void on_btnComOpen_clicked();


private:
    Ui::WidSerial *ui;

public slots:
    //  串口数据接收
    void slotComDataRecv();
    void handleComError(QSerialPort::SerialPortError error);

public:
    //  串口数据发送
    void OnSendComData(QByteArray byteSend);
    bool isComOpen();
signals:
    //  打印信息信号
    void signalShowAppend(int type, QString strDebug, int nSmType = SM_ALL, bool clear = false);
    //  接收数据信号
    void signalRecvData(QByteArray byteNow);
    //  串口已连接信号
    void signalComConnect();
    //  串口已断开信号
    void signalComDisConnect();
};

#endif // WIDSERIAL_H

/*
#include "widserial.h"
#include "ui_widserial.h"
WidSerial::WidSerial(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::WidSerial)
{
    ui->setupUi(this);

    //  扫描一次串口
    on_btnScanPort_clicked();

}

WidSerial::~WidSerial()
{
    delete ui;

}

void WidSerial::on_btnScanPort_clicked()
{
    const auto infos = QSerialPortInfo::availablePorts();

    ui->cmbComPortList->clear();
    for(const QSerialPortInfo &info : infos)
    {
        ui->cmbComPortList->addItem(info.portName() + " | " + info.description());
    }

    // 先来判断对象是不是为空
    if(m_comMain == NULL)
    {
        // 新建串口对象
        m_comMain = new QSerialPort();

        // 注册回调函数
        QObject::connect(m_comMain, SIGNAL(readyRead()), this, SLOT(slotComDataRecv()));
    }
}

void WidSerial::on_btnComOpen_clicked()
{
    // 判断是要打开串口，还是关闭串口
    if(m_comMain->isOpen())
    {
        // 串口已经打开，现在来关闭串口
        m_comMain->close();

        ui->btnComOpen->setText("连接");

        //  发送串口断开信号
        emit signalComDisConnect();
    }
    else
    {
        // 判断是否有可用串口
        if(ui->cmbComPortList->count() != 0)
        {
            // 串口已经关闭，现在来打开串口
            // 设置串口名称
            QStringList sections = ui->cmbComPortList->currentText().split(QRegExp("[ ]"), QString::KeepEmptyParts); //把每一个块装进一个QStringList中
            m_comMain->setPortName(sections[0]);
            // 设置波特率
            //m_comMain->setBaudRate(QSerialPort::Baud115200);
            m_comMain->setBaudRate(ui->cmbBaudRate->currentText().toInt());
            // 设置数据位数
            m_comMain->setDataBits(QSerialPort::Data8);
            // 设置奇偶校验
            m_comMain->setParity(QSerialPort::NoParity);
            // 设置停止位
            m_comMain->setStopBits(QSerialPort::OneStop);
            // 设置流控制
            m_comMain->setFlowControl(QSerialPort::NoFlowControl);
            // 打开串口
            if (true == m_comMain->open(QIODevice::ReadWrite))
            {
                // 设置串口缓冲区大小
                m_comMain->setReadBufferSize(1024);

                //qDebug()<<"串口在关闭状态，现在打开了" + ui->cmbComPortList->currentText();

                ui->btnComOpen->setText("断开");

                //  发送串口已连接信号
                emit signalComConnect();
            }
            else
            {
                //QMessageBox::warning(this,tr("警告"),tr("串口打开失败！\n请检查是否串口已被其他程序占用！"),QMessageBox::Ok);
                QString errorMsg = m_comMain->errorString();
                QMessageBox::warning(this, tr("警告"), tr("串口打开失败！\n错误信息: %1").arg(errorMsg), QMessageBox::Ok);
            }
        }
        else
        {
            //qDebug()<<"没有可用串口，请重新尝试扫描串口";
            // 警告对话框
            QMessageBox::warning(this,tr("警告"),tr("没有可用串口，请重新尝试扫描串口！"),QMessageBox::Ok);

        }
    }
}

//  串口数据接收
void WidSerial::slotComDataRecv()
{
    // 如果本次数据帧接受错误，那么先不接受
    if(m_comMain->bytesAvailable() >= 1)
    {
        QByteArray byteNow = m_comMain->readAll();

        //  打印接收的详细数据
        emit signalShowAppend(SHOW_RECV, QString("[%1]接收到[%2 bytes] : %3").arg(m_comMain->portName()).arg(byteNow.size()).arg(QUIHelper::byteArrayToHexStr(byteNow)));
        //  传送数据到处理函数
        emit signalRecvData(byteNow);
    }
}

//  串口数据发送
void WidSerial::OnSendComData(QByteArray byteSend)
{
    if (false == IsComConnected())
    {
        emit signalShowAppend(SHOW_ERR, QString("串口未打开！"));
        return;
    }

    // 把发送的数据显示到界面上
    int nSendCount = m_comMain->write(byteSend);

    if (nSendCount > 0)
    {
        //  打印发送的详细数据
        emit signalShowAppend(SHOW_SEND, QString("发送串口[%1][%2 bytes] : %3").arg(m_comMain->portName()).arg(nSendCount).arg(QUIHelper::byteArrayToHexStr(byteSend)));
    }
    else
    {
        //  打印发送的详细数据
        emit signalShowAppend(SHOW_ERR, QString("发送串口数据失败[%1][%2 bytes] : %3").arg(m_comMain->portName()).arg(nSendCount).arg(QUIHelper::byteArrayToHexStr(byteSend)));
    }
}



//  串口是否已连接
bool WidSerial::IsComConnected()
{
    if (m_comMain)
    {
        return m_comMain->isOpen();
    }

    return false;
}

//  设置波特率
void WidSerial::SetBaudrate(int nBaudrate)
{
    ui->cmbBaudRate->setCurrentText(QString("%1").arg(nBaudrate));
}

//  获取波特率
int WidSerial::GetBaudrate()
{
    return ui->cmbBaudRate->currentText().toInt();
}

//  设置串口
void WidSerial::SetUART(QString strCom)
{
    ui->cmbComPortList->setCurrentText(strCom);
}

//  读取串口
QString WidSerial::GetUART()
{
    return ui->cmbComPortList->currentText();
}

bool WidSerial::isComOpen()
{
    //串口已经打开
    if (m_comMain->isOpen())
    {
        return true;
    }
    return false; // 如果 m_comMain 并不存在，返回 false
}
*/
#include "widserial.h"
#include "ui_widserial.h"
#include <QDateTime>
WidSerial::WidSerial(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::WidSerial)
{
    ui->setupUi(this);

    //  扫描一次串口
    on_btnScanPort_clicked();
}

WidSerial::~WidSerial()
{   //1.析构函数需要释放对应的串口变量指针，不然会导致内存泄漏
    if (m_comMain) {
        if (m_comMain->isOpen()) {
            m_comMain->close();
        }
        //2.删除之前需要做出判断，确认其是否打开，否则在销毁对象时可能引发一些未定义的行为，所以删除之前要确保串口被正常关闭
        delete m_comMain;
    }
    //3.直接delete ui是否可行？ 若没有动态分配内存（即通过new创建它）就可以直接delete
    delete ui;
}


void WidSerial::on_btnScanPort_clicked()
{
    const auto infos = QSerialPortInfo::availablePorts();

    ui->cmbComPortList->clear();
    for(const QSerialPortInfo &info : infos)
    {
        ui->cmbComPortList->addItem(info.portName() + " | " + info.description());
        // 将端口名作为item的data，显示名称是组合的字符串
        //ui->cmbComPortList->addItem(info.portName() + " | " + info.description(), info.portName());
        //qDebug() << "3 Port Name: " << info.portName();
        //qDebug() << "3 Port  Description: " << info.description();
    }
    // 4.首次使用或对象未创建时初始化串口 不需要每次扫描都新建对象，如果之前创建，但未打开，这时候多次点击不需要重复创建
    if (m_comMain == NULL) {
        //2.new创建的是动态分配的内存，是在堆上分配的内存，堆上分配的内存不会自动释放，需要在析构函数中显示地释放它
        m_comMain = new QSerialPort(this);
        connect(m_comMain, &QSerialPort::readyRead, this, &WidSerial::slotComDataRecv);
        //5.串口在创建时应该监听硬件错误
        connect(m_comMain, &QSerialPort::errorOccurred, this, &WidSerial::handleComError);
    }
}
// 打开/关闭串口
/*
void WidSerial::on_btnComOpen_clicked()
{
    if (m_comMain->isOpen()) {
        m_comMain->close();
        ui->btnComOpen->setText("连接");
        emit signalComDisConnect();
    } else {
        if (ui->cmbComPortList->count() == 0) {
            QMessageBox::warning(this, "错误", "无可用串口！");
            return;
        }

        QString portName = ui->cmbComPortList->currentData().toString();
        bool baudOk;
        qDebug() << "1. BaudOk: " << baudOk;
        int baudRate = ui->cmbBaudRate->currentText().toInt(&baudOk);
        qDebug() << "Port Name: " << portName;
        qDebug() << "2.Baud Rate: " << baudRate << ", BaudOk: " << baudOk;
        // 验证端口是否存在
        QSerialPortInfo portInfo;
        const auto infos = QSerialPortInfo::availablePorts();
        for (const auto &info : infos) {
             qDebug() << "Checking port: " << info.portName();
            if (info.portName() == portName) {
                portInfo = info;
                break;
            }
        }
        if (portInfo.isNull()) {
            QMessageBox::warning(this, "错误", "串口不存在！");
            return;
        }

        // 配置串口参数
        m_comMain->setPort(portInfo);
        m_comMain->setBaudRate(baudRate);
        m_comMain->setDataBits(QSerialPort::Data8);
        m_comMain->setParity(QSerialPort::NoParity);
        m_comMain->setStopBits(QSerialPort::OneStop);
        m_comMain->setFlowControl(QSerialPort::NoFlowControl);

        if (m_comMain->open(QIODevice::ReadWrite)) {
            ui->btnComOpen->setText("断开");
            emit signalComConnect();
        } else {
            QMessageBox::warning(this, "错误", "[打开失败]: " + m_comMain->errorString());
        }
    }
}
*/
void WidSerial::on_btnComOpen_clicked()
{
    // 判断是要打开串口，还是关闭串口
    if(m_comMain->isOpen())
    {
        // 串口已经打开，现在来关闭串口
        m_comMain->close();
        ui->btnComOpen->setText("连接");
        //  发送串口已连接信号
        emit signalComDisConnect();
    }
    else
    {
        // 判断是否有可用串口
        if(ui->cmbComPortList->count() != 0)
        {
            // 串口已经关闭，现在来打开串口
            // 设置串口名称
            QStringList sections = ui->cmbComPortList->currentText().split(QRegExp("[ ]"), QString::KeepEmptyParts); //把每一个块装进一个QStringList中

            qDebug() << "Sections list contents:";
            for (const QString &section : sections) {
                qDebug() << section[0];
                QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
                qDebug() << currentTime << "尝试设置串口为:" << QString("%1").arg(section[0]);
            }
            m_comMain->setPortName(sections[0]);
            // 设置波特率
            //m_comMain->setBaudRate(QSerialPort::Baud115200);
            m_comMain->setBaudRate(ui->cmbBaudRate->currentText().toInt());
            qDebug() << "77 Setting baud rate to:" << ui->cmbBaudRate->currentText().toInt();
            // 设置数据位数
            m_comMain->setDataBits(QSerialPort::Data8);
            // 设置奇偶校验
            m_comMain->setParity(QSerialPort::NoParity);
            // 设置停止位
            m_comMain->setStopBits(QSerialPort::OneStop);
            // 设置流控制
            m_comMain->setFlowControl(QSerialPort::NoFlowControl);
            // 打开串口
            if (true == m_comMain->open(QIODevice::ReadWrite))
            {
                qDebug()<<"串口在关闭状态，现在打开了" + ui->cmbComPortList->currentText();
                ui->btnComOpen->setText("断开");

                //  发送串口已连接信号
                emit signalComConnect();
            }
            else
            {
               //QMessageBox::warning(this, "错误", "[打开失败]: " + m_comMain->errorString());
            }
        }
        else
        {
            qDebug()<<"没有可用串口，请重新扫描串口";
            // 警告对话框
            QMessageBox::warning(this,tr("警告"),tr("没有可用串口，请重新尝试扫描串口！"),QMessageBox::Ok);

        }
    }
}

//  串口数据接收
void WidSerial::slotComDataRecv()
{
    QByteArray data = m_comMain->readAll();
    if (data.isEmpty()) {
        // 处理接收到空数据的情况
        return;
    }
    //  打印接收的详细数据 万一接收不到呢，这时怎么处理
    emit signalShowAppend(SHOW_RECV, QString("77接收[%1][%2 bytes] : %3").arg(m_comMain->portName()).arg(data.size()).arg(QUIHelper::byteArrayToHexStr(data)));
    //qDebug()<< QString("接收[%1][%2 bytes] : %3").arg(m_comMain->portName()).arg(byteNow.size()).arg(QUIHelper::byteArrayToHexStr(byteNow));
    //  传送数据到处理函数
    emit signalRecvData(data);

}

// 发送数据
void WidSerial::OnSendComData(QByteArray byteSend) {
    // 检查串口是否已连接
    if (!IsComConnected()) {
        emit signalShowAppend(SHOW_ERR, QString("串口未连接[%1] : %2").arg(m_comMain->portName()).arg(QUIHelper::byteArrayToHexStr(byteSend)));
        return;
    }

    // 发送数据并获取实际写入的字节数
    qint64 bytesWritten = m_comMain->write(byteSend);

    // 检查发送是否成功
    if (bytesWritten == -1) {
        // 发送失败，输出失败信息
        emit signalShowAppend(SHOW_ERR, QString("发送失败[%1][%2 bytes] : %3")
                               .arg(m_comMain->portName())
                               .arg(byteSend.size())
                               .arg(m_comMain->errorString()));
    } else if (bytesWritten < byteSend.size()) {
        // 部分发送成功，输出部分发送信息
        // 8.万一在发送数据过程中拔掉串口，此时就会部分发送数据
        emit signalShowAppend(SHOW_ERR, QString("部分发送[%1][%2/%3 bytes] : %4")
                               .arg(m_comMain->portName())
                               .arg(bytesWritten)
                               .arg(byteSend.size())
                               .arg(QUIHelper::byteArrayToHexStr(byteSend)));
    } else {
        // 完全发送成功，输出成功信息
        emit signalShowAppend(SHOW_SEND, QString("发送成功[%1][%2 bytes] : %3")
                               .arg(m_comMain->portName())
                               .arg(bytesWritten)
                               .arg(QUIHelper::byteArrayToHexStr(byteSend)));
    }
}

//  设置波特率
void WidSerial::SetBaudrate(int nBaudrate)
{
    ui->cmbBaudRate->setCurrentText(QString("%1").arg(nBaudrate));
    QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
    qDebug() << currentTime << "尝试设置波特率为:" << QString("%1").arg(nBaudrate);
}

//  获取波特率
int WidSerial::GetBaudrate()
{
    return ui->cmbBaudRate->currentText().toInt();
}

//  设置串口
void WidSerial::SetUART(QString strCom)
{
    ui->cmbComPortList->setCurrentText(strCom);
    qDebug() << "尝试设置串口为:" << strCom;
    QString currentTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
    qDebug() << currentTime << "尝试设置串口为:" << QString("%1").arg(strCom);
}

//  读取串口
QString WidSerial::GetUART()
{
    return ui->cmbComPortList->currentText();
}
// 5.错误处理 监测硬件串口错误，让程序及时知道串口已经断开，不然没法及时更新UI或重新连接
//问：串口在运行过程中拔掉通过该函数我能及时知道么？
void WidSerial::handleComError(QSerialPort::SerialPortError error) {
    if (error == QSerialPort::NoError) return;
    //1.关闭前要确保串口对象已存在且未关闭，若在串口为空或关闭的情况下调用close，可能引发崩溃
    if (m_comMain && m_comMain->isOpen()) {
        m_comMain->close();
    }

    ui->btnComOpen->setText("连接");
    emit signalComDisConnect();
    QString errorMsg = QString("错误: %1").arg(m_comMain->errorString());
    if (error == QSerialPort::ResourceError) {
        errorMsg = "串口已拔掉或硬件错误: " + m_comMain->errorString();
        QMessageBox::warning(this, tr("错误"), errorMsg, QMessageBox::Ok);
    } else {
        errorMsg = "打开失败: " + m_comMain->errorString();
        QMessageBox::warning(this, tr("错误"), errorMsg, QMessageBox::Ok);
    }
    emit signalShowAppend(3, errorMsg);
}
//  串口是否已连接
//6. 以下2个函数很相似，有何不同？
//第二个函数在m_comMain为空时，会导致程序崩溃
bool WidSerial::IsComConnected()
{
    if (m_comMain)
    //这个函数更安全，先检查m_comMain是否存在，所以即使是为空，也不会崩溃，而是返回false
    {
        return m_comMain->isOpen();
    }

    return false;
}
//目前该程序未调用该函数
bool WidSerial::isComOpen()
{
    //串口已经打开
    if (m_comMain->isOpen())
    //这里的代码没有先检查m_comMain是否为空指针就直接调用，若为空指针，这个调用会导致程序崩溃，因为访问了空指针的成员函数
    {
        return true;
    }
    return false; // 6.如果 m_comMain 并不存在或者已关闭，均会返回 false，虽在这份代码中无所谓，但确是有一个隐患
}

6.2最终版

// widserial.h
#ifndef WIDSERIAL_H
#define WIDSERIAL_H

#include <QWidget>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QMutex>
#include <memory>

namespace Ui {
class WidSerial;
}

class WidSerial : public QWidget
{
    Q_OBJECT

public:
    explicit WidSerial(QWidget *parent = nullptr);
    ~WidSerial();

    // 核心接口
    bool connectPort(const QString& port, int baudrate);
    void disconnectPort();
    void sendData(const QByteArray& data);

    // 状态查询
    bool isConnected() const;
    QString currentPort() const;
    int currentBaudrate() const;

signals:
    void dataReceived(const QByteArray& data);
    void statusChanged(bool connected);
    void errorOccurred(int code, const QString& msg);
    void commStatsUpdated(quint64 sent, quint64 received);

private slots:
    void on_btnScanPort_clicked();
    void on_btnComOpen_clicked();
    void handlePortError(QSerialPort::SerialPortError error);

private:
    void initializePort();
    bool validateSettings() const;
    void processIncomingData();
    void attemptReconnect();
    void updateStatistics(qint64 sent = 0, qint64 received = 0);

    Ui::WidSerial *ui;
    std::unique_ptr<QSerialPort> m_port;
    mutable QMutex m_portMutex;
    QByteArray m_recvBuffer;
    
    // 统计信息
    quint64 m_bytesSent = 0;
    quint64 m_bytesReceived = 0;
    QTimer m_statsTimer;
    
    // 重连机制
    int m_reconnectAttempts = 0;
    static constexpr int MAX_RECONNECT_ATTEMPTS = 5;
};

#endif // WIDSERIAL_H

// widserial.cpp
#include "widserial.h"
#include "ui_widserial.h"
#include <QDateTime>
#include <QSettings>
#include <QTimer>

WidSerial::WidSerial(QWidget *parent) 
    : QWidget(parent)
    , ui(new Ui::WidSerial)
{
    ui->setupUi(this);
    
    // 初始化统计定时器
    m_statsTimer.setInterval(1000);
    connect(&m_statsTimer, &QTimer::timeout, this, [this](){
        emit commStatsUpdated(m_bytesSent, m_bytesReceived);
    });
    m_statsTimer.start();

    // 加载历史配置
    QSettings settings;
    ui->cmbBaudRate->setCurrentText(settings.value("Baudrate", "115200").toString());
    
    on_btnScanPort_clicked();
}

WidSerial::~WidSerial()
{
    QMutexLocker locker(&m_portMutex);
    if(m_port && m_port->isOpen()) {
        m_port->close();
    }
    
    // 保存配置
    QSettings settings;
    settings.setValue("Baudrate", currentBaudrate());
    
    delete ui;
}

bool WidSerial::connectPort(const QString& port, int baudrate)
{
    QMutexLocker locker(&m_portMutex);
    
    if(!m_port) {
        m_port = std::make_unique<QSerialPort>();
        connect(m_port.get(), &QSerialPort::readyRead, 
                this, &WidSerial::processIncomingData);
        connect(m_port.get(), &QSerialPort::errorOccurred,
                this, &WidSerial::handlePortError);
    }

    m_port->setPortName(port);
    m_port->setBaudRate(baudrate);
    m_port->setDataBits(QSerialPort::Data8);
    m_port->setParity(QSerialPort::NoParity);
    m_port->setStopBits(QSerialPort::OneStop);
    m_port->setFlowControl(QSerialPort::NoFlowControl);

    if(m_port->open(QIODevice::ReadWrite)) {
        m_port->setReadBufferSize(4096);
        emit statusChanged(true);
        return true;
    }
    
    emit errorOccurred(QSerialPort::OpenError, m_port->errorString());
    return false;
}

void WidSerial::disconnectPort()
{
    QMutexLocker locker(&m_portMutex);
    
    if(m_port && m_port->isOpen()) {
        m_port->close();
        emit statusChanged(false);
    }
}

void WidSerial::sendData(const QByteArray& data)
{
    QMutexLocker locker(&m_portMutex);
    
    if(!m_port || !m_port->isOpen()) {
        emit errorOccurred(QSerialPort::NotOpenError, "Port not open");
        return;
    }

    const qint64 bytesWritten = m_port->write(data);
    if(bytesWritten == -1) {
        emit errorOccurred(m_port->error(), m_port->errorString());
    } else if(bytesWritten < data.size()) {
        emit errorOccurred(QSerialPort::WriteError, "Partial data written");
    } else {
        m_bytesSent += bytesWritten;
        updateStatistics(bytesWritten);
    }
}

bool WidSerial::isConnected() const
{
    QMutexLocker locker(&m_portMutex);
    return m_port && m_port->isOpen();
}

QString WidSerial::currentPort() const
{
    QMutexLocker locker(&m_portMutex);
    return m_port ? m_port->portName() : QString();
}

int WidSerial::currentBaudrate() const
{
    return ui->cmbBaudRate->currentText().toInt();
}

void WidSerial::on_btnScanPort_clicked()
{
    ui->cmbComPortList->clear();
    
    const auto ports = QSerialPortInfo::availablePorts();
    for(const auto& port : ports) {
        ui->cmbComPortList->addItem(
            QString("%1 - %2").arg(port.portName()).arg(port.description()),
            port.portName()
        );
    }
}

void WidSerial::on_btnComOpen_clicked()
{
    if(isConnected()) {
        disconnectPort();
        ui->btnComOpen->setText(tr("Connect"));
    } else {
        const QString port = ui->cmbComPortList->currentData().toString();
        const int baudrate = ui->cmbBaudRate->currentText().toInt();
        
        if(connectPort(port, baudrate)) {
            ui->btnComOpen->setText(tr("Disconnect"));
        }
    }
}

void WidSerial::handlePortError(QSerialPort::SerialPortError error)
{
    if(error == QSerialPort::NoError) return;

    const QString errorMsg = m_port ? m_port->errorString() : "Unknown error";
    
    switch(error) {
    case QSerialPort::ResourceError:
        emit errorOccurred(error, tr("Hardware error: %1").arg(errorMsg));
        attemptReconnect();
        break;
    case QSerialPort::TimeoutError:
        emit errorOccurred(error, tr("Timeout: %1").arg(errorMsg));
        break;
    default:
        emit errorOccurred(error, tr("Error %1: %2").arg(error).arg(errorMsg));
    }
}

void WidSerial::processIncomingData()
{
    QMutexLocker locker(&m_portMutex);
    
    while(m_port->bytesAvailable() > 0) {
        const QByteArray chunk = m_port->readAll();
        m_recvBuffer.append(chunk);
        m_bytesReceived += chunk.size();
        updateStatistics(0, chunk.size());
    }

    // 简单帧处理（示例）
    int frameEnd = m_recvBuffer.indexOf('\n');
    while(frameEnd != -1) {
        const QByteArray frame = m_recvBuffer.left(frameEnd + 1);
        m_recvBuffer = m_recvBuffer.mid(frameEnd + 1);
        emit dataReceived(frame.trimmed());
        frameEnd = m_recvBuffer.indexOf('\n');
    }
}

void WidSerial::attemptReconnect()
{
    if(++m_reconnectAttempts <= MAX_RECONNECT_ATTEMPTS) {
        QTimer::singleShot(2000, this, [this](){
            if(connectPort(currentPort(), currentBaudrate())) {
                m_reconnectAttempts = 0;
            } else {
                attemptReconnect();
            }
        });
    } else {
        m_reconnectAttempts = 0;
        emit errorOccurred(-1, tr("Maximum reconnect attempts reached"));
    }
}

void WidSerial::updateStatistics(qint64 sent, qint64 received)
{
    static quint64 lastUpdate = 0;
    const quint64 now = QDateTime::currentMSecsSinceEpoch();
    
    // 限制更新频率（每秒最多10次）
    if(now - lastUpdate > 100) {
        emit commStatsUpdated(m_bytesSent, m_bytesReceived);
        lastUpdate = now;
    }
}

主要优化点说明：

1. 线程安全设计：

   • 使用QMutex保护所有串口操作

   • 采用std::unique_ptr管理串口对象生命周期

   • 异步重连机制

2. 企业级错误处理：

   • 错误分级（普通错误、硬件错误、超时等）

   • 自动重连机制（最多尝试5次）

   • 详细的错误信号传递

3. 性能优化：

   • 4KB读缓冲区

   • 数据分块读取处理

   • 统计信息限速更新

4. 协议处理：

   • 接收缓冲区管理

   • 简单帧解析（以\n为结尾符）

   • 支持扩展复杂协议解析

5. 配置管理：

   • 自动保存/加载波特率设置

   • 端口信息缓存机制

6. 资源管理：

   • 智能指针自动释放资源

   • 析构时安全关闭端口

   • 定时器统一管理