基于Qt实现高性能串口通讯应用程序，要求多线程，数据分包，高性能，高稳固 ...

2. 核心模块实现

2.1 线程安全的串口管理类

1. class SerialPortWorker : public QObject {
2.     Q_OBJECT
3. public:
4.     explicit SerialPortWorker(QObject *parent = nullptr)
5.         : m_serial(new QSerialPort), m_buffer(1024*1024) // 1MB环形缓冲区
6.     {
7.         connect(m_serial, &QSerialPort::readyRead,
8.             this, &SerialPortWorker::onDataReceived, Qt::DirectConnection);
9.     }
11. signals:
12.     void packetReady(QByteArray packet);
13.     void errorOccurred(QString err);
15. public slots:
16.     void startPort(const SerialSettings &settings) {
17.         QMutexLocker lock(&m_mutex);
18.         m_serial->setPortName(settings.portName);
19.         m_serial->setBaudRate(settings.baudRate);
20.         m_serial->setFlowControl(QSerialPort::HardwareControl);
21.         if(!m_serial->open(QIODevice::ReadWrite)) {
22.             emit errorOccurred(m_serial->errorString());
23.         }
24.         m_lastActiveTime = QDateTime::currentMSecsSinceEpoch();
25.     }
27. private slots:
28.     void onDataReceived() {
29.         const qint64 now = QDateTime::currentMSecsSinceEpoch();
30.         const QByteArray data = m_serial->readAll();
31.       
32.         // 写入环形缓冲区
33.         if(!m_buffer.write(data)) {
34.             emit errorOccurred("Buffer overflow");
35.             return;
36.         }
38.         // 分包处理（示例：固定头尾协议）
39.         while(m_buffer.size() >= 4) {
40.             if(m_buffer.peek(0) == 0xAA && m_buffer.peek(1) == 0x55) {
41.                 const int length = m_buffer.peek(2);
42.                 if(m_buffer.size() >= length + 4) {
43.                     QByteArray packet;
44.                     m_buffer.read(packet, length + 4);
45.                     if(packet.back() == 0x0D) { // 校验尾字节
46.                         emit packetReady(packet);
47.                     }
48.                 }
49.             } else {
50.                 m_buffer.skip(1); // 滑动窗口寻找包头
51.             }
52.         }
54.         m_lastActiveTime = now;
55.     }
57. private:
58.     QScopedPointer<QSerialPort> m_serial;
59.     RingBuffer m_buffer;
60.     QMutex m_mutex;
61.     qint64 m_lastActiveTime = 0;
62. };

复制代码

2.2 高性能环形缓冲区实现

1. class RingBuffer {
2. public:
3.     explicit RingBuffer(size_t capacity)
4.         : m_capacity(capacity),
5.           m_buffer(new char[capacity]) {}
6.   
7.     bool write(const QByteArray &data) {
8.         if(data.size() > freeSpace()) return false;
9.       
10.         std::lock_guard<std::mutex> lock(m_mutex);
11.         const size_t tailSpace = m_capacity - m_tail;
12.         if(data.size() <= tailSpace) {
13.             memcpy(m_buffer.data() + m_tail, data.data(), data.size());
14.         } else {
15.             memcpy(m_buffer.data() + m_tail, data.data(), tailSpace);
16.             memcpy(m_buffer.data(), data.data() + tailSpace, data.size() - tailSpace);
17.         }
18.         m_tail = (m_tail + data.size()) % m_capacity;
19.         return true;
20.     }
22.     void read(QByteArray &out, size_t len) {
23.         std::lock_guard<std::mutex> lock(m_mutex);
24.         out.resize(len);
25.         if(m_head + len <= m_capacity) {
26.             memcpy(out.data(), m_buffer.data() + m_head, len);
27.         } else {
28.             const size_t firstPart = m_capacity - m_head;
29.             memcpy(out.data(), m_buffer.data() + m_head, firstPart);
30.             memcpy(out.data() + firstPart, m_buffer.data(), len - firstPart);
31.         }
32.         m_head = (m_head + len) % m_capacity;
33.     }
35.     size_t size() const {
36.         return (m_tail >= m_head) ?
37.             (m_tail - m_head) :
38.             (m_capacity - m_head + m_tail);
39.     }
41. private:
42.     std::mutex m_mutex;
43.     std::unique_ptr<char[]> m_buffer;
44.     size_t m_capacity = 0;
45.     size_t m_head = 0;
46.     size_t m_tail = 0;
47. };

复制代码

4. 性能优化要点

• 零拷贝设计
  
  
  
  • 利用memcpy直接操纵环形缓冲区内存
    
  • 制止QByteArray的多次构造和析构
    
  
  
• 硬件加速
  1. // 主线程配置
  2. SerialSettings settings {
  3.     "/dev/ttyUSB0",
  4.     QSerialPort::Baud115200,
  5.     QSerialPort::Data8,
  6.     QSerialPort::NoParity,
  7.     QSerialPort::OneStop
  8. };
  10. QThread serialThread;
  11. SerialPortWorker worker;
  12. worker.moveToThread(&serialThread);
  14. // 错误处理和UI更新连接
  15. connect(&worker, &SerialPortWorker::packetReady,
  16.         this, &MainWindow::processPacket,
  17.         Qt::QueuedConnection);
  18. connect(&worker, &SerialPortWorker::errorOccurred,
  19.         this, &MainWindow::showError);
  21. QTimer::singleShot(0, &worker, [=](){
  22.     worker.startPort(settings);
  23. });
  24. serialThread.start();

  复制代码
• 实时性保障
  1. class WriteHandler : public QObject {
  2.     Q_OBJECT
  3. public slots:
  4.     void enqueueWrite(const QByteArray &data) {
  5.         QMutexLocker lock(&m_queueMutex);
  6.         m_writeQueue.enqueue(data);
  7.         if(!m_isWriting) {
  8.             QTimer::singleShot(1, this, &WriteHandler::processQueue);
  9.         }
  10.     }
  12. private slots:
  13.     void processQueue() {
  14.         QByteArray packet;
  15.         {
  16.             QMutexLocker lock(&m_queueMutex);
  17.             if(m_writeQueue.isEmpty()) {
  18.                 m_isWriting = false;
  19.                 return;
  20.             }
  21.             packet = m_writeQueue.dequeue();
  22.         }
  24.         qint64 bytesWritten = 0;
  25.         while(bytesWritten < packet.size()) {
  26.             const qint64 ret = m_port->write(packet.constData() + bytesWritten,
  27.                                            packet.size() - bytesWritten);
  28.             if(ret == -1) {
  29.                 emit writeFailed(m_port->errorString());
  30.                 return;
  31.             }
  32.             bytesWritten += ret;
  33.             if(!m_port->waitForBytesWritten(100)) {
  34.                 emit timeout("Write operation timeout");
  35.                 return;
  36.             }
  37.         }
  39.         QTimer::singleShot(1, this, &WriteHandler::processQueue);
  40.     }
  42. private:
  43.     QSerialPort* m_port;
  44.     QQueue<QByteArray> m_writeQueue;
  45.     QMutex m_queueMutex;
  46.     bool m_isWriting = false;
  47. };

  复制代码

5. 稳固性保障措施

<ol>心跳检测机制

1. // 在Linux平台启用DMA加速
2. m_serial->setReadBufferSize(1024*1024); // 1MB硬件缓冲区
3. m_serial->setDevicePolicy(QSerialPort::FlushOnAccess);

复制代码

错误规复流程

1. // 设置线程优先级
2. QThread::currentThread()->setPriority(QThread::TimeCriticalPriority);
3. // 禁用系统缓冲
4. m_serial->setDataTerminalReady(true);
5. m_serial->setRequestToSend(true);

复制代码

数据完备性校验
[code]bool verifyChecksum(const QByteArray &packet) {    quint8 sum = 0;    for(int i=2; i