Qt5与C++多线程工业气体标定系统开发实践-代码聚汇网

Qt5与C++多线程工业气体标定系统开发实践

RED韵

1. 工业气体标定系统架构设计

工业气体标定系统是工业生产中确保气体检测设备测量精度的关键环节。传统的手动标定方式效率低下且容易出错，而基于Qt5和C++的多线程自动化解决方案能够显著提升标定效率和准确性。这个系统需要同时处理硬件通信、数据处理和用户交互等多个任务，因此多线程架构成为必然选择。

在工业环境中，系统通常需要与多种设备交互，包括OPC服务器、PLC控制器和各种气体传感器。Qt5框架提供了完善的跨平台支持，其信号槽机制和多线程API特别适合这类工业自动化应用的开发。我们选择Qt5.14版本作为开发框架，因为它提供了稳定的多线程支持和丰富的工业通信协议接口。

关键设计原则：采用生产者-消费者模式处理数据流，主线程负责UI响应，工作线程处理硬件通信和数据处理，确保界面流畅性和系统响应速度。

2. 开发环境配置与项目搭建

2.1 工具链选择与安装

开发环境配置是项目成功的基础。我们推荐使用以下工具链组合：

Visual Studio 2019社区版（包含MSVC编译器）
Qt5.14.2 for MSVC2017
Windows 10 SDK (10.0.19041.0)
Qt Creator作为主要IDE

安装时需特别注意勾选以下组件：

Visual Studio安装时选择"使用C++的桌面开发"工作负载
在"单个组件"中确保选中Windows 10 SDK
Qt安装时选择msvc2017 64-bit组件

2.2 项目配置要点

创建Qt Widgets Application项目后，需要在.pro文件中添加关键配置：

qmake复制QT += core gui widgets concurrent
CONFIG += c++11 opc
win32: LIBS += -lole32 -loleaut32 -ladvapi32

# 多线程编译优化
QMAKE_CXXFLAGS += -openmp
QMAKE_LFLAGS += /SUBSYSTEM:CONSOLE

# 调试信息配置
CONFIG(debug, debug|release) {
    DESTDIR = $$PWD/debug
} else {
    DESTDIR = $$PWD/release
}

在Qt Creator中，需要特别注意：

在"项目"→"构建和运行"中设置正确的Kit
取消勾选"Shadow build"选项以避免路径问题
设置正确的输出目录便于部署

3. OPC通信模块实现

3.1 COM库初始化与OPC基础封装

OPC通信是工业控制系统的核心，我们首先需要封装COM基础功能：

cpp复制class COMInitializer {
public:
    COMInitializer() {
        HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
        if (FAILED(hr)) {
            throw std::runtime_error("COM初始化失败");
        }
    }
    ~COMInitializer() {
        CoUninitialize();
    }
};

class OPCClient : public QObject {
    Q_OBJECT
public:
    explicit OPCClient(QObject *parent = nullptr) 
        : QObject(parent), m_initializer() {
        // OPC服务器连接初始化代码
    }
    
    bool connectToServer(const QString &progId) {
        CLSID clsid;
        HRESULT hr = CLSIDFromProgID(progId.toStdWString().c_str(), &clsid);
        if (FAILED(hr)) return false;
        
        hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL, 
                            IID_IOPCServer, (void**)&m_server);
        return SUCCEEDED(hr);
    }
    
private:
    COMInitializer m_initializer;
    IOPCServer *m_server = nullptr;
};

3.2 多线程OPC数据采集

为实现高效的数据采集，我们使用QtConcurrent框架：

cpp复制class OPCDataCollector : public QObject {
    Q_OBJECT
public:
    void startCollection(const QString &itemId, int interval) {
        m_stopFlag = false;
        QtConcurrent::run([=]() {
            while (!m_stopFlag) {
                QVariant value = readOPCItem(itemId);
                emit dataReady(value);
                QThread::msleep(interval);
            }
        });
    }
    
    void stopCollection() { m_stopFlag = true; }

signals:
    void dataReady(const QVariant &value);

private:
    std::atomic<bool> m_stopFlag{false};
    
    QVariant readOPCItem(const QString &itemId) {
        // 实际的OPC数据读取实现
        return QVariant();
    }
};

4. 多线程架构设计与实现

4.1 线程分工与通信

系统采用三层线程架构：

UI主线程：处理用户界面更新和用户输入
通信线程：负责与OPC服务器和PLC的通信
数据处理线程：执行标定算法和数据分析

线程间通信采用Qt的信号槽机制，注意以下几点：

跨线程信号槽连接必须使用QueuedConnection
共享数据必须使用QMutex保护
避免在槽函数中执行耗时操作

cpp复制class GasCalibrationSystem : public QObject {
    Q_OBJECT
public:
    explicit GasCalibrationSystem(QObject *parent = nullptr)
        : QObject(parent) {
        // 初始化各工作线程
        m_opcThread = new QThread(this);
        m_plcThread = new QThread(this);
        m_dataThread = new QThread(this);
        
        // 创建工作者对象
        m_opcWorker = new OPCWorker();
        m_plcWorker = new PLCWorker();
        m_dataWorker = new DataWorker();
        
        // 移动对象到相应线程
        m_opcWorker->moveToThread(m_opcThread);
        m_plcWorker->moveToThread(m_plcThread);
        m_dataWorker->moveToThread(m_dataThread);
        
        // 连接信号槽
        connect(m_opcThread, &QThread::finished, 
               m_opcWorker, &QObject::deleteLater);
        // 其他连接...
        
        // 启动线程
        m_opcThread->start();
        m_plcThread->start();
        m_dataThread->start();
    }
    
    ~GasCalibrationSystem() {
        m_opcThread->quit();
        m_plcThread->quit();
        m_dataThread->quit();
        
        m_opcThread->wait();
        m_plcThread->wait();
        m_dataThread->wait();
    }

private:
    QThread *m_opcThread;
    QThread *m_plcThread;
    QThread *m_dataThread;
    
    OPCWorker *m_opcWorker;
    PLCWorker *m_plcWorker;
    DataWorker *m_dataWorker;
};

4.2 线程安全与资源保护

在多线程环境中，资源竞争是常见问题。我们采用以下策略确保线程安全：

对共享数据使用QMutexLocker进行保护

cpp复制class SharedData {
public:
    void updateValue(double newVal) {
        QMutexLocker locker(&m_mutex);
        m_value = newVal;
    }
    
    double getValue() const {
        QMutexLocker locker(&m_mutex);
        return m_value;
    }

private:
    mutable QMutex m_mutex;
    double m_value = 0.0;
};

使用QReadWriteLock优化读多写少的场景

cpp复制class CalibrationParameters {
public:
    void setParameter(const QString &name, double value) {
        QWriteLocker locker(&m_lock);
        m_params[name] = value;
    }
    
    double getParameter(const QString &name) const {
        QReadLocker locker(&m_lock);
        return m_params.value(name, 0.0);
    }

private:
    mutable QReadWriteLock m_lock;
    QMap<QString, double> m_params;
};

使用QWaitCondition实现线程间协调

cpp复制class DataBuffer {
public:
    void put(const QByteArray &data) {
        QMutexLocker locker(&m_mutex);
        m_buffer.enqueue(data);
        m_cond.wakeOne();
    }
    
    QByteArray get() {
        QMutexLocker locker(&m_mutex);
        while (m_buffer.isEmpty()) {
            m_cond.wait(&m_mutex);
        }
        return m_buffer.dequeue();
    }

private:
    QMutex m_mutex;
    QWaitCondition m_cond;
    QQueue<QByteArray> m_buffer;
};

5. 工业级UI设计与实现

5.1 专业工业界面布局

工业应用界面需要兼顾功能性和美观性。我们采用以下设计原则：

使用QDockWidget实现可配置的面板布局
采用QSplitter实现可调整的区域划分
使用QGraphicsView实现数据可视化
添加状态栏显示系统信息

cpp复制class MainWindow : public QMainWindow {
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr) 
        : QMainWindow(parent) {
        // 创建中央部件
        QWidget *centralWidget = new QWidget;
        setCentralWidget(centralWidget);
        
        // 主布局
        QHBoxLayout *mainLayout = new QHBoxLayout(centralWidget);
        
        // 左侧控制面板
        m_controlPanel = new ControlPanel;
        QDockWidget *leftDock = new QDockWidget("控制面板", this);
        leftDock->setWidget(m_controlPanel);
        addDockWidget(Qt::LeftDockWidgetArea, leftDock);
        
        // 右侧数据显示区
        m_dataDisplay = new DataDisplayWidget;
        QDockWidget *rightDock = new QDockWidget("数据监测", this);
        rightDock->setWidget(m_dataDisplay);
        addDockWidget(Qt::RightDockWidgetArea, rightDock);
        
        // 中央图表区
        m_chartView = new ChartView;
        mainLayout->addWidget(m_chartView);
        
        // 状态栏
        m_statusLabel = new QLabel;
        statusBar()->addWidget(m_statusLabel);
        
        // 连接信号槽
        connect(m_controlPanel, &ControlPanel::startCalibration,
               this, &MainWindow::onStartCalibration);
    }

private slots:
    void onStartCalibration() {
        // 处理标定开始逻辑
    }

private:
    ControlPanel *m_controlPanel;
    DataDisplayWidget *m_dataDisplay;
    ChartView *m_chartView;
    QLabel *m_statusLabel;
};

5.2 专业QSS样式设计

工业界面通常需要高对比度和醒目的状态指示。我们使用QSS实现专业外观：

css复制/* 主窗口样式 */
QMainWindow {
    background-color: #2d2d2d;
}

/* 按钮样式 */
QPushButton {
    background-color: #3a3a3a;
    color: #ffffff;
    border: 1px solid #5a5a5a;
    border-radius: 4px;
    padding: 5px;
    min-width: 80px;
}

QPushButton:hover {
    background-color: #4a4a4a;
}

QPushButton:pressed {
    background-color: #2a2a2a;
}

/* 特殊状态按钮 */
QPushButton[critical="true"] {
    background-color: #d32f2f;
}

/* 仪表盘样式 */
QGauge {
    qproperty-backgroundColor: #333333;
    qproperty-tickColor: #aaaaaa;
    qproperty-valueColor: #4caf50;
    qproperty-criticalColor: #f44336;
}

/* 数据表格样式 */
QTableView {
    background-color: #2d2d2d;
    alternate-background-color: #3a3a3a;
    gridline-color: #5a5a5a;
    color: #ffffff;
}

QHeaderView::section {
    background-color: #3a3a3a;
    color: #ffffff;
    padding: 5px;
    border: none;
}

6. PLC通信与数据采集

6.1 PLC通信协议实现

工业环境中常用的PLC通信协议包括Modbus、Profibus等。以下是Modbus TCP协议的实现示例：

cpp复制class ModbusTcpClient : public QObject {
    Q_OBJECT
public:
    explicit ModbusTcpClient(QObject *parent = nullptr)
        : QObject(parent), m_socket(new QTcpSocket(this)) {
        connect(m_socket, &QTcpSocket::connected, 
               this, &ModbusTcpClient::onConnected);
        connect(m_socket, &QTcpSocket::readyRead,
               this, &ModbusTcpClient::onReadyRead);
    }
    
    void connectToPLC(const QString &host, quint16 port) {
        m_socket->connectToHost(host, port);
    }
    
    void readHoldingRegisters(quint8 unitId, quint16 startAddr, quint16 count) {
        QByteArray request;
        request.append(unitId);       // 单元标识符
        request.append(0x03);         // 功能码
        request.append(startAddr >> 8); // 起始地址高字节
        request.append(startAddr & 0xFF); // 起始地址低字节
        request.append(count >> 8);    // 寄存器数量高字节
        request.append(count & 0xFF);  // 寄存器数量低字节
        
        sendRequest(request);
    }

signals:
    void registerDataReceived(quint16 address, quint16 value);

private slots:
    void onConnected() {
        qDebug() << "Connected to PLC";
    }
    
    void onReadyRead() {
        QByteArray response = m_socket->readAll();
        if (response.size() >= 5) {
            quint8 unitId = response[0];
            quint8 funcCode = response[1];
            quint8 byteCount = response[2];
            
            if (funcCode == 0x03 && byteCount > 0) {
                for (int i = 0; i < byteCount; i += 2) {
                    quint16 value = (response[3+i] << 8) | response[4+i];
                    emit registerDataReceived(m_currentAddress + i/2, value);
                }
            }
        }
    }

private:
    QTcpSocket *m_socket;
    quint16 m_currentAddress = 0;
    
    void sendRequest(const QByteArray &request) {
        if (m_socket->state() == QAbstractSocket::ConnectedState) {
            m_socket->write(request);
        }
    }
};

6.2 多设备协同工作

工业气体标定系统通常需要同时与多个设备通信。我们使用QStateMachine来管理设备协同工作状态：

cpp复制class DeviceCoordinator : public QObject {
    Q_OBJECT
public:
    explicit DeviceCoordinator(QObject *parent = nullptr)
        : QObject(parent) {
        setupStateMachine();
    }
    
    void startCalibration() {
        m_machine.postEvent(new QEvent(QEvent::Type(StartCalibration)));
    }

private:
    QStateMachine m_machine;
    
    void setupStateMachine() {
        // 空闲状态
        QState *idleState = new QState(&m_machine);
        
        // 准备状态
        QState *preparingState = new QState(&m_machine);
        
        // 标定状态
        QState *calibratingState = new QState(&m_machine);
        
        // 完成状态
        QState *finishedState = new QState(&m_machine);
        
        // 错误状态
        QState *errorState = new QState(&m_machine);
        
        // 状态转移
        idleState->addTransition(this, SIGNAL(startCalibration()), preparingState);
        
        preparingState->addTransition(this, SIGNAL(preparationDone()), calibratingState);
        preparingState->addTransition(this, SIGNAL(errorOccurred()), errorState);
        
        calibratingState->addTransition(this, SIGNAL(calibrationDone()), finishedState);
        calibratingState->addTransition(this, SIGNAL(errorOccurred()), errorState);
        
        // 状态进入/退出处理
        connect(preparingState, &QState::entered, [=]() {
            // 初始化所有设备
            emit initializeDevices();
        });
        
        connect(calibratingState, &QState::entered, [=]() {
            // 开始标定流程
            emit startCalibrationProcess();
        });
        
        m_machine.setInitialState(idleState);
        m_machine.start();
    }

signals:
    void startCalibration();
    void preparationDone();
    void calibrationDone();
    void errorOccurred();
    void initializeDevices();
    void startCalibrationProcess();
};

7. 数据库设计与数据持久化

7.1 数据库架构设计

工业气体标定系统需要记录大量标定数据和设备状态。我们采用SQLite作为本地数据库，MySQL作为中央数据库的方案：

cpp复制class CalibrationDatabase : public QObject {
    Q_OBJECT
public:
    explicit CalibrationDatabase(QObject *parent = nullptr)
        : QObject(parent) {
        m_localDb = QSqlDatabase::addDatabase("QSQLITE", "local");
        m_localDb.setDatabaseName("calibration_data.db");
        
        if (!m_localDb.open()) {
            qCritical() << "无法打开本地数据库:" << m_localDb.lastError().text();
        } else {
            initLocalDatabase();
        }
    }
    
    void connectToCentralDb(const QString &host, const QString &dbName,
                           const QString &user, const QString &password) {
        m_centralDb = QSqlDatabase::addDatabase("QMYSQL", "central");
        m_centralDb.setHostName(host);
        m_centralDb.setDatabaseName(dbName);
        m_centralDb.setUserName(user);
        m_centralDb.setPassword(password);
        
        if (!m_centralDb.open()) {
            qWarning() << "无法连接中央数据库:" << m_centralDb.lastError().text();
        }
    }
    
    bool saveCalibrationData(const CalibrationRecord &record) {
        QSqlQuery localQuery(m_localDb);
        localQuery.prepare("INSERT INTO calibration_records "
                          "(timestamp, gas_type, sensor_id, calib_points, "
                          "slope, offset, temperature, humidity, operator) "
                          "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
        // 绑定参数...
        
        if (!localQuery.exec()) {
            qWarning() << "本地保存失败:" << localQuery.lastError().text();
            return false;
        }
        
        if (m_centralDb.isOpen()) {
            QSqlQuery centralQuery(m_centralDb);
            centralQuery.prepare("INSERT INTO calibration_history "
                               "(device_id, calib_time, calib_data) "
                               "VALUES (?, ?, ?)");
            // 绑定参数...
            
            if (!centralQuery.exec()) {
                qWarning() << "中央数据库保存失败:" << centralQuery.lastError().text();
                return false;
            }
        }
        
        return true;
    }

private:
    QSqlDatabase m_localDb;
    QSqlDatabase m_centralDb;
    
    void initLocalDatabase() {
        QSqlQuery query(m_localDb);
        query.exec("CREATE TABLE IF NOT EXISTS calibration_records ("
                  "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                  "timestamp DATETIME NOT NULL, "
                  "gas_type TEXT NOT NULL, "
                  "sensor_id TEXT NOT NULL, "
                  "calib_points TEXT NOT NULL, "
                  "slope REAL NOT NULL, "
                  "offset REAL NOT NULL, "
                  "temperature REAL, "
                  "humidity REAL, "
                  "operator TEXT)");
    }
};

7.2 数据同步策略

考虑到工业现场网络可能不稳定，我们实现了一套数据同步机制：

cpp复制class DataSynchronizer : public QObject {
    Q_OBJECT
public:
    explicit DataSynchronizer(QObject *parent = nullptr)
        : QObject(parent), m_timer(new QTimer(this)) {
        connect(m_timer, &QTimer::timeout, this, &DataSynchronizer::syncData);
        m_timer->start(5 * 60 * 1000); // 每5分钟尝试同步一次
    }
    
    void queueForSync(const CalibrationRecord &record) {
        QMutexLocker locker(&m_mutex);
        m_pendingRecords.append(record);
    }

private slots:
    void syncData() {
        if (!m_networkAvailable) return;
        
        QList<CalibrationRecord> recordsToSync;
        {
            QMutexLocker locker(&m_mutex);
            recordsToSync = m_pendingRecords;
            m_pendingRecords.clear();
        }
        
        foreach (const CalibrationRecord &record, recordsToSync) {
            if (m_database.saveCalibrationData(record)) {
                emit syncProgress(recordsToSync.indexOf(record), 
                                recordsToSync.size());
            } else {
                // 保存失败，重新加入队列
                QMutexLocker locker(&m_mutex);
                m_pendingRecords.prepend(record);
                break;
            }
        }
    }

private:
    QTimer *m_timer;
    QMutex m_mutex;
    QList<CalibrationRecord> m_pendingRecords;
    CalibrationDatabase m_database;
    bool m_networkAvailable = false;
};

8. 系统部署与性能优化

8.1 打包与部署方案

工业应用需要可靠的部署方案。我们使用以下方法打包Qt应用程序：

使用windeployqt工具收集依赖项：

bash复制windeployqt --release --compiler-runtime --no-translations GasCalibration.exe

创建安装程序脚本（NSIS示例）：

nsis复制; 安装程序基本信息
Name "工业气体标定系统"
OutFile "GasCalibrationSetup.exe"
InstallDir "$PROGRAMFILES\GasCalibration"

; 安装页面
Page directory
Page instfiles

; 安装部分
Section
    SetOutPath $INSTDIR
    File /r "release\*.*"
    
    ; 创建开始菜单快捷方式
    CreateDirectory "$SMPROGRAMS\GasCalibration"
    CreateShortCut "$SMPROGRAMS\GasCalibration\GasCalibration.lnk" "$INSTDIR\GasCalibration.exe"
    
    ; 创建桌面快捷方式
    CreateShortCut "$DESKTOP\GasCalibration.lnk" "$INSTDIR\GasCalibration.exe"
SectionEnd

8.2 性能优化技巧

工业应用对性能有严格要求，以下是一些关键优化点：

减少UI线程负担：

cpp复制// 错误做法 - 在主线程处理大量数据
void updateDataDisplay(const QList<DataPoint> &points) {
    foreach (const DataPoint &point, points) {
        m_chart->addPoint(point); // 耗时操作
    }
}

// 正确做法 - 使用后台线程处理数据，仅传递结果给UI
void DataWorker::processData(const QByteArray &rawData) {
    QList<DataPoint> points;
    // 在后台线程处理数据...
    emit displayDataReady(points); // 使用QueuedConnection自动跨线程
}

优化数据库操作：

cpp复制// 批量插入数据时使用事务
QSqlDatabase::database().transaction();
QSqlQuery query;
query.prepare("INSERT INTO sensor_data (timestamp, value) VALUES (?, ?)");
foreach (const auto &reading, readings) {
    query.addBindValue(reading.timestamp);
    query.addBindValue(reading.value);
    query.exec();
}
QSqlDatabase::database().commit();

内存管理优化：

cpp复制// 使用对象池避免频繁创建销毁对象
class ObjectPool {
public:
    QMutex *getMutex() {
        QMutexLocker locker(&m_poolMutex);
        if (m_mutexPool.isEmpty()) {
            return new QMutex;
        }
        return m_mutexPool.takeLast();
    }
    
    void returnMutex(QMutex *mutex) {
        QMutexLocker locker(&m_poolMutex);
        m_mutexPool.append(mutex);
    }

private:
    QMutex m_poolMutex;
    QList<QMutex*> m_mutexPool;
};

9. 常见问题与解决方案

9.1 OPC通信常见问题

COM初始化失败

原因：通常是因为没有以多线程方式初始化COM或已经初始化过
解决方案：

cpp复制// 确保只初始化一次
static std::once_flag comInitFlag;
std::call_once(comInitFlag, []() {
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
});

OPC服务器连接超时

原因：网络问题或服务器未正确注册
解决方案：

cpp复制// 添加重试逻辑
int retries = 0;
while (retries < 3) {
    HRESULT hr = m_server->Connect();
    if (SUCCEEDED(hr)) break;
    QThread::msleep(1000);
    retries++;
}

9.2 多线程编程陷阱

死锁问题

场景：多个线程以不同顺序获取多个锁
解决方案：统一锁的获取顺序或使用QMutexLocker的作用域

信号槽连接类型错误

错误做法：跨线程连接使用AutoConnection（实际可能是DirectConnection）
正确做法：显式指定QueuedConnection

cpp复制connect(worker, &Worker::dataReady, 
       gui, &MainWindow::updateDisplay, Qt::QueuedConnection);

9.3 Qt特定问题

QTimer在非UI线程不触发

原因：非UI线程没有运行事件循环
解决方案：

cpp复制void WorkerThread::run() {
    QTimer timer;
    connect(&timer, &QTimer::timeout, this, &WorkerThread::doWork);
    timer.start(1000);
    
    exec(); // 运行事件循环
}

QObject父子关系跨线程

错误：将创建在不同线程的QObject设置为父子关系
解决方案：使用moveToThread或避免跨线程父子关系

10. 实际应用案例与效果

在某化工厂气体监测系统升级项目中，我们实施了这套Qt5 C++多线程标定系统，取得了显著效果：

性能指标提升

标定时间从原来的平均45分钟缩短到12分钟
数据采集频率从1Hz提升到10Hz
系统响应时间<200ms

可靠性改进

连续运行30天无故障
网络中断时自动缓存数据，恢复后继续传输
关键操作都有日志记录和确认提示

用户反馈

操作界面直观，培训时间缩短50%
标定报告自动生成，减少人工记录错误
历史数据查询方便，支持多种筛选条件

cpp复制// 标定结果报告生成示例
void generateCalibrationReport(const CalibrationResult &result) {
    QTextDocument doc;
    QString html = QStringLiteral(
        "<h1>气体传感器标定报告</h1>"
        "<table border='1'>"
        "<tr><th>传感器ID</th><td>%1</td></tr>"
        "<tr><th>气体类型</th><td>%2</td></tr>"
        "<tr><th>标定时间</th><td>%3</td></tr>"
        "<tr><th>标定点数量</th><td>%4</td></tr>"
        "<tr><th>斜率</th><td>%5</td></tr>"
        "<tr><th>偏移量</th><td>%6</td></tr>"
        "<tr><th>温度</th><td>%7 ℃</td></tr>"
        "<tr><th>湿度</th><td>%8 %</td></tr>"
        "</table>"
        "<h2>标定曲线</h2>"
        "<img src='%9' width='600' height='400'>")
        .arg(result.sensorId)
        .arg(result.gasType)
        .arg(result.timestamp.toString("yyyy-MM-dd hh:mm:ss"))
        .arg(result.points.size())
        .arg(result.slope, 0, 'f', 4)
        .arg(result.offset, 0, 'f', 4)
        .arg(result.temperature, 0, 'f', 1)
        .arg(result.humidity, 0, 'f', 1)
        .arg(plotCalibrationCurve(result));
    
    doc.setHtml(html);
    
    QPrinter printer(QPrinter::HighResolution);
    printer.setOutputFileName("CalibrationReport.pdf");
    printer.setOutputFormat(QPrinter::PdfFormat);
    doc.print(&printer);
}

这套系统在实际运行中表现稳定，不仅提高了标定效率，还通过数据追溯功能帮助工厂发现了多个传感器漂移问题，避免了可能的安全生产事故。