PLC Modbus 轮询卡顿？在 Qt 中实现异步读写队列与优先级调度，实测吞吐提升 3 倍-育师

在 Qt 里用异步队列 + 优先级调度，彻底解决轮询卡顿，实测吞吐能从 80 帧/秒干到 240+ 帧/秒，3 倍提升不吹牛。

## 为什么卡：同步轮询是原罪

传统的 Modbus 轮询代码长这样，看着简单，实则埋雷。

```cpp
// 错误示范：同步阻塞轮询
void Worker::poll() {
while (m_running) {
QThread::msleep(50); // 让出线程，但GUI该卡还是卡
QModbusDataUnit unit(ReadCoils, 0, 100);
m_modbus->sendReadRequest(unit, 1); // 阻塞等待直到超时
if (m_modbus->waitForResponse(1000)) {
// 处理响应
} else {
// 重试逻辑，这里一卡就是1秒
}
}
}

```

坑点在哪？`waitForResponse(1000)` 是同步阻塞的，PLC 响应慢时，这个函数不会立刻返回。
更致命的是如果你在 GUI 线程里干这事，界面直接白屏。
**别告诉我你没干过这事**——Qt 的 `QModbusClient::waitForResponse` 文档里白纸黑字写着“This function will block normally”，谁用谁知道。

## 解药：异步写队列，别让请求裸奔

核心思路：所有 Modbus 请求进队列，由一个 `QThread` 专门消费，绝不阻塞主线程。
先定义请求结构体，带上优先级和超时标志。

```cpp
struct ModbusRequest {
enum Priority { Low, High, Emergency };
QModbusDataUnit::RegisterType type;
int startAddr;
int count;
Priority priority;
int timeoutMs; // 每个请求独立超时，避免全局拖垮
int retryCount; // 自动重试次数
std::function<void(QModbusDataUnit)> callback; // 完成回调，在QT主线程执行
};

```

实现一个 `ModbusQueue` 类，内部用 `QList` 做优先队列，每来一个请求按优先级插队。
这样紧急写操作（比如急停位）不会被 100 个读操作挤在最后面。

```cpp
class ModbusQueue : public QObject {
Q_OBJECT
public:
void enqueue(const ModbusRequest& req) {
QMutexLocker locker(&m_mutex);
if (req.priority == ModbusRequest::Emergency) {
// 紧急请求插到队首，但不覆盖已有紧急请求
m_queue.prepend(req);
} else {
// 低优先级排后面，高优先级排前面
auto it = m_queue.end();
for (auto r = m_queue.begin(); r != m_queue.end(); ++r) {
if (r->priority < req.priority) {
it = r;
break;
}
}
m_queue.insert(it, req);
}
}
bool tryDequeue(ModbusRequest& req) {
QMutexLocker locker(&m_mutex);
if (m_queue.isEmpty()) return false;
req = m_queue.takeFirst();
return true;
}
private:
QList<ModbusRequest> m_queue;
QMutex m_mutex;
};

```

**坑点1**：`QMutexLocker` 行尾加分号，这是最常见的低级错误，编译器不会报错，但锁会失效。
**坑点2**：这里用了 `prepend` 和 `insert` 的组合，别用 `std::priority_queue`，因为你需要动态调整优先级（比如重试时提升优先级）。

## 核心：异步调度器，超时重试不卡UI

有了队列，还得有个消费者线程。它从队列取请求，发异步请求，然后等待信号——而不是阻塞。

```cpp
class ModbusScheduler : public QObject {
Q_OBJECT
public:
ModbusScheduler(QModbusClient* client, ModbusQueue* queue)
: m_client(client), m_queue(queue) {
// 连接响应信号
connect(m_client, &QModbusClient::responseReceived,
this, &ModbusScheduler::onResponse);
connect(m_client, &QModbusClient::errorOccurred,
this, &ModbusScheduler::onError);
}

void start() {
QThread* thread = new QThread(this);
QObject::connect(thread, &QThread::started, this,
[this]() { this->pollNext(); });
moveToThread(thread);
thread->start();
}

private slots:
void pollNext() {
// 关键：必须从队列取请求，然后发异步请求
ModbusRequest req;
if (m_queue->tryDequeue(req)) {
m_currentReq = req;
QModbusDataUnit unit(req.type, req.startAddr, req.count);
m_client->sendReadRequest(unit, 1);
// 启动超时定时器，独立于请求
m_timeoutTimer->start(req.timeoutMs);
} else {
// 队列空了，睡10ms避免CPU空转
QTimer::singleShot(10, this, &ModbusScheduler::pollNext);
}
}

void onResponse(QModbusDataUnit unit) {
m_timeoutTimer->stop();
// 处理数据，通过信号发回主线程，不直接改UI
emit dataReady(m_currentReq.startAddr, unit.values());
pollNext(); // 继续下一个请求
}

void onError(QModbusDevice::Error error) {
if (m_currentReq.retryCount > 0) {
m_currentReq.retryCount--;
// 重试请求，但提高优先级
m_currentReq.priority = ModbusRequest::High;
m_queue->enqueue(m_currentReq);
} else {
emit requestFailed(m_currentReq.startAddr);
}
pollNext();
}

private:
QModbusClient* m_client;
ModbusQueue* m_queue;
QTimer* m_timeoutTimer;
ModbusRequest m_currentReq;
};

```

**坑点3**：`sendReadRequest` 是异步的，返回后不能立刻发下一个请求——必须等 `responseReceived` 信号。
如果不等，Modbus 从站会认为你发非法报文，直接断连。这就是为什么 `pollNext()` 只能在 `onResponse` 或 `onError` 里调用。
**坑点4**：超时定时器不能对静态值。PLC 在程序扫描周期长的站点，读保持寄存器可能耗时 100ms+，你固定 50ms 超时会导致频繁重试，反而增加负载。

## 数据回GUI：信号通道，别手痒去`this->ui`

调度器跑在独立线程，数据要通过 `emit` 发到主线程，然后在主线程里更新界面。

```cpp
class MainWindow : public QMainWindow {
Q_OBJECT
public:
MainWindow() {
auto* scheduler = new ModbusScheduler(&m_client, &m_queue);
scheduler->start();
connect(scheduler, &ModbusScheduler::dataReady, this,
[this](int addr, QVariantList values) {
// 这个lambda在GUI线程执行，安全更新UI
ui->tableWidget->setItem(0, 0,
new QTableWidgetItem(values.at(0).toString()));
});
}
};

```

**坑点5**：别把 `QModbusClient` 对象误放主线程，否则信号跨线程连接会变得异常慢。在 `start()` 前把 `m_client` `moveToThread` 到调度线程——我这里为了简化没写，但你记得做。
实测：这样改完后，UI 全程流畅，即使 PLC 有 2 秒无响应，界面不卡，无响应会在后台重试，逻辑正确。

## 性能对比：80 到 240，真实数据

别听我吹，上个简单基准。同一台工控机 i5-7500，同一个西门子 S7-1200，读 10 个保持寄存器。

|------|---------------|--------|-------|

| 同步轮询 50ms间隔 | 82 | 15% | 严重 |

| 异步队列无优先级 | 210 | 9% | 无 |

| 异步队列 + 优先级 | 246 | 11% | 无 |

数据流水线是：`pollNext()` 立刻发下一个请求，不需要等当前响应处理完再发——前提是 Modbus 从站支持 pipeline（S7-1200 OK）。如果你的从站不支持，这个数字会打折扣，但关键是不卡了。

### 附：不支持pipeline的PLC怎么办

如果从站是老旧台达或者三菱 FX，不支持连续发送报文，你需要在 `onResponse` 里加 `QThread::msleep(10)` 做一些延时，否则会丢帧。但即便这样，吞吐也有 150+，且 UI 稳定。

## 总结：这套路的核心就三句话

1. **永远别在 GUI 线程做 Modbus 同步请求**——这是你卡顿的根源。

2. **用队列解耦请求生命周期**，优先级插队保证了急停操作能及时响应。