Files
ssp/pages/dashboardpage.cpp
T
lidg 407af2892d feat: 重构视觉取料流程及生产故障恢复
- 删除订单启动、暂停、复位相关 PLC 握手及无效反馈配置
- 清除报警改为仅写 clearAlarmCommand,不等待反馈
- 将拍照位移动、视觉处理和 RackPick 拆分为三个独立动作
- 增加 M850/M851 拍照位动作及 R60/M852 视觉结果流程
- 暂停改为等待当前机器人动作完成,视觉结果不确定时转人工确认
- 删除复位按钮,合并为恢复/重试按钮
- 普通 PAUSED 订单通过启动按钮继续
- 恢复前检查 PLC、安全状态、订单及动作命令反馈
- 支持在途动作接管、已完成动作收尾、安全重试和人工确认
- 故障状态保持订单 RUNNING,并持久化实际恢复阶段
- 恢复成功后仅清除本次软件故障对应的报警
- 更新小轴 PLC 地址、Modbus 配置和视觉集成文档
2026-10-29 17:20:14 +08:00

890 lines
36 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "dashboardpage.h"
#include "ui_dashboardpage.h"
#include "../services/orderservice.h"
#include "../services/trayservice.h"
#include "../services/workpieceservice.h"
#include "../repositories/productionrepository.h"
#include "uihelpers.h"
#include "../services/visionservice.h"
#include <QJsonDocument>
#include <QAbstractItemView>
#include <QDateTime>
#include <QFormLayout>
#include <QGridLayout>
#include <QGroupBox>
#include <QHeaderView>
#include <QLabel>
#include <QMessageBox>
#include <QSet>
#include <QtGlobal>
#include <QPushButton>
#include <QMetaObject>
#include <QResizeEvent>
#include <QSizePolicy>
#include <QTableWidgetItem>
#include <QTimer>
#include <QThread>
#include <QVBoxLayout>
namespace {
QString displayState(const QString &state)
{
if (state == "IDLE") return "待机";
if (state == "PREPARING") return "准备中";
if (state == "WAITING_DEVICE_READY") return "等待设备就绪";
if (state == "PHOTO_MOVING") return "移动到拍照位置";
if (state == "VISION_PROCESSING") return "相机视觉处理";
if (state == "RACK_PICKING") return "料架取料";
if (state == "FRONT_LOADING") return "正面上料";
if (state == "LOADING") return "上料";
if (state == "FRONT_CHECKING") return "正面检测";
if (state == "FRONT_UNLOADING") return "正面下料";
if (state == "FLIPPING") return "翻面";
if (state == "BACK_LOADING") return "反面上料";
if (state == "BACK_CHECKING") return "反面检测";
if (state == "BACK_UNLOADING") return "反面下料";
if (state == "RACK_PLACING") return "料架放料";
if (state == "JUDGING") return "结果判定";
if (state == "UNLOADING") return "下料";
if (state == "PAUSED") return "已暂停";
if (state == "ERROR") return "故障";
if (state == "COMPLETED") return "已完成";
if (state == "TIMEOUT_WARNING") return "工序耗时提示";
if (state == "TIMEOUT_PAUSED") return "等待人工恢复";
if (state == "RECOVERY_CHECKING") return "恢复检查";
if (state == "MANUAL_CONFIRM") return "等待人工确认";
if (state == "RETRYING") return "重试中";
if (state == "TERMINATING") return "终止中";
return state.isEmpty() ? "未采集" : state;
}
QString displayProcessStep(const QString &step)
{
return displayState(step);
}
QString displayProcessStatus(const QString &status)
{
if (status == "RUNNING") return "执行中";
if (status == "COMPLETED") return "已完成";
if (status == "FAILED") return "失败";
if (status == "PAUSED") return "已暂停";
if (status == "CANCELED") return "已取消";
return status.isEmpty() ? "未采集" : status;
}
QString displayOrderStatus(const QString &status)
{
if (status == "NOT_START") return "待启动";
if (status == "RUNNING") return "加工中";
if (status == "PAUSED") return "已暂停";
if (status == "FINISHED" || status == "COMPLETED") return "已完成";
if (status == "CANCELED") return "已取消";
return status.isEmpty() ? "未采集" : status;
}
void updateStatusCell(QLabel *cell, const QString &text, const QString &color,
bool highlighted = false)
{
if (!cell) {
return;
}
cell->setText(text);
cell->setStyleSheet(QString("QLabel { background: %1; border: %2; "
"border-radius: 3px; color: white; font-size: 11px; }")
.arg(color)
.arg(highlighted ? "3px solid #ffb300" : "1px solid #ffffff"));
}
QString boolStatus(bool valid, bool value, const QString &yes, const QString &no)
{
return !valid ? "未采集" : value ? yes : no;
}
}
DashboardPage::DashboardPage(QWidget *parent)
: QWidget(parent)
, ui(new Ui::DashboardPage)
, rackBox(nullptr)
, deviceStatusLabel(new QLabel("PLC:未采集 | 机器人:未采集 | 安全回路:未采集", this))
, inspectionMachineCell(nullptr)
, robotCell(nullptr)
, robotControlCabinetCell(nullptr)
, mainControlCabinetCell(nullptr)
, safetyDoor1Cell(nullptr)
, safetyDoor2Cell(nullptr)
, safetyDoor3Cell(nullptr)
, alarmCell(nullptr)
, markNgButton(new QPushButton("标记 NG", this))
, stopButton(new QPushButton("终止", this))
, processBox(new QGroupBox("工序耗时", this))
, currentProcessLabel(new QLabel("-", processBox))
, processElapsedLabel(new QLabel("00:00:00.000", processBox))
, processTotalElapsedLabel(new QLabel("00:00:00.000", processBox))
, processTable(new QTableWidget(processBox))
, processRefreshTimer(new QTimer(this))
, currentProcessElapsedMs(0)
, productionThread(new QThread(this))
, productionWorker(new ProductionWorker)
, productionState(ProductionService::Idle)
, currentOrderId(0)
, currentOrderStartable(false)
, currentOrderResumable(false)
, productionTrayNo(0)
, productionSlotNo(0)
{
ui->setupUi(this);
productionWorker->moveToThread(productionThread);
connect(productionThread, &QThread::finished,
productionWorker, &QObject::deleteLater);
connect(productionWorker, &ProductionWorker::shutdownReady,
productionThread, &QThread::quit, Qt::DirectConnection);
const QList<QLabel *> values = QList<QLabel *>()
<< ui->planValue << ui->pendingValue << ui->frontValue
<< ui->backValue << ui->okValue << ui->ngValue;
for (QLabel *label : values) {
label->setStyleSheet("font-size: 26px; font-weight: bold; color: #00897b;");
}
ui->startButton->setObjectName("primaryButton");
ui->nextButton->setVisible(false);
ui->recoveryButton->setVisible(false);
markNgButton->setObjectName("recoveryNgButton");
markNgButton->setVisible(false);
ui->buttonLayout->insertWidget(4, markNgButton);
stopButton->setObjectName("stopButton");
stopButton->setVisible(false);
ui->buttonLayout->insertWidget(6, stopButton);
deviceStatusLabel->setStyleSheet("color: #546e7a;");
ui->taskLayout->insertWidget(0, deviceStatusLabel);
QFormLayout *processSummaryLayout = new QFormLayout;
processSummaryLayout->addRow("当前工序:", currentProcessLabel);
processSummaryLayout->addRow("当前耗时:", processElapsedLabel);
processSummaryLayout->addRow("累计耗时:", processTotalElapsedLabel);
QVBoxLayout *processLayout = new QVBoxLayout(processBox);
processLayout->addLayout(processSummaryLayout);
processTable->setColumnCount(4);
processTable->setHorizontalHeaderLabels(
QStringList() << "工序" << "状态" << "次数" << "耗时");
processTable->horizontalHeader()->setStretchLastSection(true);
processTable->horizontalHeader()->setSectionResizeMode(
0, QHeaderView::Stretch);
processTable->verticalHeader()->setVisible(false);
processTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
processTable->setAlternatingRowColors(true);
processTable->setMinimumHeight(150);
processLayout->addWidget(processTable);
ui->taskLayout->insertWidget(6, processBox);
ui->recentLogTable->setColumnCount(5);
ui->recentLogTable->setHorizontalHeaderLabels(QStringList() << "时间" << "类型" << "模块" << "内容" << "状态");
ui->recentLogTable->horizontalHeader()->setStretchLastSection(true);
ui->recentLogTable->verticalHeader()->setVisible(false);
ui->recentLogTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->recentLogTable->setAlternatingRowColors(true);
ui->deviceLayout->setSpacing(10);
ui->deviceLayout->setColumnStretch(0, 1);
ui->deviceLayout->setColumnStretch(1, 1);
ui->deviceLayout->setColumnStretch(2, 2);
ui->deviceLayout->setColumnStretch(3, 2);
ui->deviceLayout->setColumnStretch(4, 2);
ui->deviceLayout->setColumnStretch(5, 1);
ui->deviceLayout->setRowStretch(0, 1);
ui->deviceLayout->setRowStretch(1, 1);
ui->deviceLayout->setRowStretch(2, 1);
ui->deviceLayout->setRowStretch(3, 1);
ui->deviceLayout->setRowStretch(4, 1);
ui->deviceLayout->setRowStretch(5, 1);
inspectionMachineCell = UiHelpers::makeStatusCell("检测机\n未采集", "#607d8b");
ui->deviceLayout->addWidget(inspectionMachineCell, 0, 0, 2, 2);
ui->deviceLayout->addWidget(UiHelpers::makeStatusCell("总控电脑", "#43a047"), 0, 3);
safetyDoor1Cell = UiHelpers::makeStatusCell("安全门 1\n未采集", "#607d8b");
ui->deviceLayout->addWidget(safetyDoor1Cell, 0, 4);
robotCell = UiHelpers::makeStatusCell("机器人\n未采集", "#607d8b");
robotCell->setFixedSize(82, 58);
ui->deviceLayout->addWidget(robotCell, 2, 3, 2, 2, Qt::AlignCenter);
robotControlCabinetCell = UiHelpers::makeStatusCell("机器人控制柜\n未采集", "#607d8b");
ui->deviceLayout->addWidget(robotControlCabinetCell, 3, 0);
mainControlCabinetCell = UiHelpers::makeStatusCell("总控柜\n未采集", "#607d8b");
ui->deviceLayout->addWidget(mainControlCabinetCell, 4, 0);
safetyDoor2Cell = UiHelpers::makeStatusCell("安全门 2\n未采集", "#607d8b");
ui->deviceLayout->addWidget(safetyDoor2Cell, 2, 5);
safetyDoor3Cell = UiHelpers::makeStatusCell("安全门 3\n未采集", "#607d8b");
ui->deviceLayout->addWidget(safetyDoor3Cell, 5, 0);
alarmCell = UiHelpers::makeStatusCell("PLC 报警\n未采集", "#607d8b");
ui->deviceLayout->addWidget(alarmCell, 5, 5);
rackBox = new QGroupBox("料架 2x3");
rackBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
QGridLayout *rackLayout = new QGridLayout(rackBox);
rackLayout->setContentsMargins(8, 18, 8, 8);
rackLayout->setSpacing(4);
for (int i = 0; i < 6; ++i) {
QLabel *trayCell = UiHelpers::makeSquareStatusCell(
QString("托盘 %1\n未采集").arg(i + 1), "#607d8b");
rackTrayCells.append(trayCell);
rackLayout->addWidget(trayCell, i / 3, i % 3, Qt::AlignCenter);
}
ui->deviceLayout->addWidget(rackBox, 4, 2, 2, 3);
updateRackSize();
connect(ui->startButton, &QPushButton::clicked,
this, &DashboardPage::startProduction);
connect(ui->pauseButton, &QPushButton::clicked,
this, &DashboardPage::pauseProduction);
connect(stopButton, &QPushButton::clicked,
this, &DashboardPage::stopProduction);
connect(ui->recoveryButton, &QPushButton::clicked,
this, &DashboardPage::recoverProduction);
connect(ui->clearAlarmButton, &QPushButton::clicked,
this, &DashboardPage::clearAlarm);
connect(markNgButton, &QPushButton::clicked,
this, &DashboardPage::markWorkpieceNg);
connect(productionWorker, &ProductionWorker::stateChanged,
this, &DashboardPage::onProductionStateChanged);
connect(productionWorker, &ProductionWorker::currentWorkpieceChanged,
this, &DashboardPage::onCurrentWorkpieceChanged);
connect(productionWorker, &ProductionWorker::currentWorkpieceSnapshotChanged,
this, &DashboardPage::onCurrentWorkpieceSnapshotChanged);
connect(productionWorker, &ProductionWorker::currentPositionChanged,
this, &DashboardPage::onCurrentPositionChanged);
connect(productionWorker, &ProductionWorker::productionError,
this, &DashboardPage::onProductionError);
connect(productionWorker, &ProductionWorker::productionFinished,
this, &DashboardPage::onProductionFinished);
connect(productionWorker, &ProductionWorker::processElapsedChanged,
this, &DashboardPage::onProcessElapsedChanged);
connect(productionWorker, &ProductionWorker::timeoutRecoveryRequired,
this, &DashboardPage::onTimeoutRecoveryRequired);
connect(productionWorker, &ProductionWorker::recoveryCompleted,
this, &DashboardPage::onRecoveryCompleted);
connect(productionWorker, &ProductionWorker::deviceStatusChanged,
this, &DashboardPage::onDeviceStatusChanged);
connect(productionWorker, &ProductionWorker::deviceCommunicationError,
this, [this](const QString &error) {
emit deviceCommunicationError(error);
});
productionThread->start();
QMetaObject::invokeMethod(productionWorker, "requestRestore",
Qt::QueuedConnection);
loadCurrentOrder();
processRefreshTimer->setInterval(1000);
connect(processRefreshTimer, &QTimer::timeout, this, [this]() {
refreshProcessRecords();
loadCurrentOrder();
});
processRefreshTimer->start();
refreshProcessRecords();
updateRackSummary();
}
DashboardPage::~DashboardPage()
{
if (productionThread->isRunning()) {
productionWorker->requestStopImmediate();
QMetaObject::invokeMethod(productionWorker, "requestShutdown",
Qt::QueuedConnection);
productionThread->wait();
}
delete ui;
}
void DashboardPage::attachVisionService(VisionService *service)
{
qRegisterMetaType<QJsonObject>("QJsonObject");
connect(productionWorker, &ProductionWorker::visionMeasureRequested,
service, &VisionService::measure, Qt::QueuedConnection);
connect(productionWorker, &ProductionWorker::visionCancelRequested,
service, &VisionService::cancel, Qt::QueuedConnection);
connect(productionWorker, &ProductionWorker::visionProductionActiveChanged,
service, &VisionService::setProductionActive, Qt::QueuedConnection);
connect(productionWorker, &ProductionWorker::visionProductionActiveChanged,
this, &DashboardPage::visionProductionActiveChanged, Qt::QueuedConnection);
connect(service, &VisionService::measurementFinished,
productionWorker, &ProductionWorker::receiveVisionResult, Qt::QueuedConnection);
connect(service, &VisionService::availabilityChanged,
productionWorker, &ProductionWorker::updateVisionAvailability, Qt::QueuedConnection);
connect(productionWorker, &ProductionWorker::visionCycleChanged, this,
[this](const QJsonObject &cycle) {
visionRecoveryRequired = cycle.value("recovery_required").toBool();
updateRecoveryButtons();
emit visionCycleChanged(cycle);
emit logRequested("生产日志", "视觉引导", "自动取料",
QString::fromUtf8(QJsonDocument(cycle).toJson(QJsonDocument::Compact)),
visionRecoveryRequired ? "待恢复" : "记录");
}, Qt::QueuedConnection);
QMetaObject::invokeMethod(productionWorker, "updateVisionAvailability", Qt::QueuedConnection,
Q_ARG(bool, service->isReady()), Q_ARG(bool, service->isBusy()), Q_ARG(QString, service->sessionId()));
QMetaObject::invokeMethod(productionWorker, "requestVisionSnapshot", Qt::QueuedConnection);
}
void DashboardPage::addLog(const QString &type, const QString &module, const QString &content,
const QString &status)
{
ui->recentLogTable->insertRow(0);
const QStringList values = QStringList()
<< QDateTime::currentDateTime().toString("HH:mm:ss")
<< type << module << content << status;
for (int col = 0; col < values.size(); ++col) {
ui->recentLogTable->setItem(0, col, new QTableWidgetItem(values.at(col)));
}
while (ui->recentLogTable->rowCount() > 8) {
ui->recentLogTable->removeRow(ui->recentLogTable->rowCount() - 1);
}
}
void DashboardPage::resizeEvent(QResizeEvent *event)
{
QWidget::resizeEvent(event);
updateRackSize();
}
void DashboardPage::updateRackSize()
{
if (!rackBox || rackTrayCells.isEmpty()) {
return;
}
const int spacing = 4;
const int leftMargin = 8;
const int rightMargin = 8;
const int topMargin = 18;
const int bottomMargin = 8;
const int maxRackHeight = qMax(150, ui->layoutGroup->height() / 3);
const int maxCellByHeight = (maxRackHeight - topMargin - bottomMargin - spacing) / 2;
const int maxCellByWidth = (ui->layoutGroup->width() - leftMargin - rightMargin - spacing * 2) / 3;
const int cellSide = qMax(52, qMin(maxCellByHeight, maxCellByWidth));
const int rackWidth = leftMargin + rightMargin + cellSide * 3 + spacing * 2;
const int rackHeight = topMargin + bottomMargin + cellSide * 2 + spacing;
for (QLabel *cell : rackTrayCells) {
cell->setFixedSize(cellSide, cellSide);
}
rackBox->setFixedSize(rackWidth, rackHeight);
}
void DashboardPage::startProduction()
{
if (productionState == ProductionService::Paused) {
if (!currentOrderResumable) return;
ui->startButton->setEnabled(false);
QMetaObject::invokeMethod(productionWorker, "requestResume",
Qt::QueuedConnection);
return;
}
if (productionState != ProductionService::Idle
&& productionState != ProductionService::Completed) {
return;
}
loadCurrentOrder();
if (!currentOrderStartable || currentOrderId <= 0) {
QMessageBox::information(this, "启动生产",
"没有可生产的订单,请先生成工件。");
return;
}
ui->startButton->setEnabled(false);
if (!QMetaObject::invokeMethod(
productionWorker, "requestStart", Qt::QueuedConnection,
Q_ARG(int, currentOrderId))) {
updateRecoveryButtons();
QMessageBox::warning(this, "启动生产",
"提交生产启动请求失败。");
}
}
void DashboardPage::pauseProduction()
{
QMetaObject::invokeMethod(productionWorker, "requestPause",
Qt::QueuedConnection);
}
void DashboardPage::stopProduction()
{
productionWorker->requestStopImmediate();
QMetaObject::invokeMethod(productionWorker, "requestStop",
Qt::QueuedConnection);
}
void DashboardPage::clearAlarm()
{
QMetaObject::invokeMethod(productionWorker, "requestClearAlarm",
Qt::QueuedConnection);
emit logRequested("报警日志", "控制面板", "清除报警",
"已请求 PLC 清除报警", "待处理");
}
void DashboardPage::onProductionStateChanged(ProductionService::State state,
const QString &name)
{
productionState = state;
const QString stateText = displayState(name);
ui->actionLabel->setText("生产状态:" + stateText);
loadCurrentOrder();
updateRecoveryButtons();
emit systemStateChanged(stateText);
emit currentStepChanged(stateText);
refreshProcessRecords();
updateProductionStats();
}
void DashboardPage::onCurrentWorkpieceChanged(int workpieceId,
const QString &barcode)
{
if (workpieceId <= 0) {
ui->workpieceLabel->setText("当前工件:-");
ui->trayLabel->setText("当前托盘:-");
currentProcessElapsedMs = 0;
emit currentWorkpieceChanged("-");
} else {
ui->workpieceLabel->setText(
QString("当前工件:%1").arg(barcode));
emit currentWorkpieceChanged(barcode);
}
refreshProcessRecords();
updateRecoveryButtons();
updateProductionStats();
}
void DashboardPage::onCurrentWorkpieceSnapshotChanged(
const Workpiece &workpiece)
{
productionWorkpiece = workpiece;
refreshProcessRecords();
updateProductionStats();
}
void DashboardPage::onCurrentPositionChanged(int trayNo, int slotNo)
{
productionTrayNo = trayNo;
productionSlotNo = slotNo;
ui->trayLabel->setText(trayNo > 0
? QString("当前托盘:%1,位置:%2").arg(trayNo).arg(slotNo)
: "当前托盘:-");
}
void DashboardPage::onProductionError(const QString &error)
{
ui->actionLabel->setText("生产故障:" + error);
updateRecoveryButtons();
emit systemStateChanged("故障");
emit logRequested("报警日志", "生产流程", "生产故障",
error, "失败");
}
void DashboardPage::onProductionFinished(int orderId)
{
emit logRequested("生产日志", "生产流程", "订单完成",
QString("订单 %1 已完成").arg(orderId), "成功");
loadCurrentOrder();
updateProductionStats();
updateRackSummary();
}
void DashboardPage::onProcessElapsedChanged(const QString &processStep,
int elapsedMs)
{
currentProcessElapsedMs = elapsedMs;
currentProcessLabel->setText(displayProcessStep(processStep));
processElapsedLabel->setText(formatDuration(elapsedMs));
updateCurrentProcessDuration(elapsedMs);
}
void DashboardPage::onTimeoutRecoveryRequired(const QString &state,
const QString &message)
{
ui->actionLabel->setText("需要人工恢复:" + message);
emit logRequested("操作日志", "生产流程", "人工恢复",
displayState(state) + ":" + message, "待处理");
}
void DashboardPage::onRecoveryCompleted(const QString &mode)
{
emit logRequested("生产日志", "生产流程", "恢复完成",
displayState(mode), "成功");
}
void DashboardPage::recoverProduction()
{
if ((productionState == ProductionService::ManualConfirm || visionRecoveryRequired)
&& QMessageBox::question(
this, "继续生产",
visionRecoveryRequired
? "请先核对机器人当前位置及本次取料是否已执行或撤销,并确认 M850 移动请求和 M851 到位反馈已复位。恢复不会清除 M852,也不会重发旧坐标。是否已完成现场核对?"
: "当前动作是否执行无法自动确认。请核对机器人位置、工件状态及对应命令/反馈信号,确认现场状态安全后再继续。",
QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
!= QMessageBox::Yes) {
return;
}
QMetaObject::invokeMethod(productionWorker, "requestRecover",
Qt::QueuedConnection);
}
void DashboardPage::markWorkpieceNg()
{
if (QMessageBox::question(
this, "标记工件 NG",
"确认将当前工件标记为 NG,并继续处理下一个工件吗?",
QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
!= QMessageBox::Yes) {
return;
}
QMetaObject::invokeMethod(productionWorker, "requestMarkNg",
Qt::QueuedConnection);
}
void DashboardPage::updateRecoveryButtons()
{
const ProductionService::State state = productionState;
const bool recoveryRequired = state == ProductionService::TimeoutPaused
|| state == ProductionService::ManualConfirm
|| state == ProductionService::Error || visionRecoveryRequired;
const bool running = state != ProductionService::Idle
&& state != ProductionService::Completed;
const bool terminating = state == ProductionService::Terminating;
const bool canStart = (((state == ProductionService::Idle
|| state == ProductionService::Completed)
&& currentOrderStartable)
|| (state == ProductionService::Paused
&& currentOrderResumable))
&& !visionRecoveryRequired;
ui->startButton->setEnabled(canStart);
ui->startButton->setText(state == ProductionService::Paused
? "继续" : "启动");
ui->recoveryButton->setVisible(recoveryRequired);
ui->recoveryButton->setEnabled(!terminating);
markNgButton->setVisible(recoveryRequired
&& productionWorkpiece.id > 0 && !visionRecoveryRequired);
stopButton->setVisible(running);
stopButton->setEnabled(!terminating);
stopButton->setText(terminating ? "终止中..." : "终止");
}
QString DashboardPage::formatDuration(int elapsedMs)
{
const int totalSeconds = qMax(0, elapsedMs) / 1000;
const int hours = totalSeconds / 3600;
const int minutes = (totalSeconds % 3600) / 60;
const int seconds = totalSeconds % 60;
const int milliseconds = qMax(0, elapsedMs) % 1000;
return QString("%1:%2:%3.%4")
.arg(hours, 2, 10, QLatin1Char('0'))
.arg(minutes, 2, 10, QLatin1Char('0'))
.arg(seconds, 2, 10, QLatin1Char('0'))
.arg(milliseconds, 3, 10, QLatin1Char('0'));
}
void DashboardPage::refreshProcessRecords()
{
const Workpiece workpiece = productionWorkpiece;
if (workpiece.id <= 0) {
currentProcessLabel->setText("-");
processElapsedLabel->setText(formatDuration(0));
processTotalElapsedLabel->setText(formatDuration(0));
processTable->setRowCount(0);
return;
}
QString error;
const QList<WorkpieceProcessRecord> records =
ProductionRepository().listProcessRecords(workpiece.id, &error);
if (!error.isEmpty()) {
return;
}
const QString currentStep = workpiece.processStep;
const qint64 nowMs = QDateTime::currentDateTime().toMSecsSinceEpoch();
int totalElapsedMs = 0;
processTable->setRowCount(records.size());
for (int row = 0; row < records.size(); ++row) {
const WorkpieceProcessRecord &record = records.at(row);
int durationMs = record.durationMs;
if (durationMs < 0 && record.startedAt.isValid()) {
if (record.processState == "RUNNING"
&& record.processStep == currentStep
&& currentProcessElapsedMs > 0) {
durationMs = currentProcessElapsedMs;
} else {
const qint64 elapsedMs = qMax<qint64>(
0, nowMs - record.startedAt.toMSecsSinceEpoch());
durationMs = static_cast<int>(
qMin<qint64>(elapsedMs, 2147483647));
}
}
if (durationMs >= 0) {
totalElapsedMs += durationMs;
}
QTableWidgetItem *stepItem = new QTableWidgetItem(
displayProcessStep(record.processStep));
stepItem->setData(Qt::UserRole, record.processStep);
processTable->setItem(row, 0, stepItem);
QTableWidgetItem *statusItem = new QTableWidgetItem(
displayProcessStatus(record.processState));
statusItem->setData(Qt::UserRole, record.processState);
processTable->setItem(row, 1, statusItem);
processTable->setItem(row, 2,
new QTableWidgetItem(
QString::number(record.attemptNo)));
processTable->setItem(row, 3,
new QTableWidgetItem(
durationMs >= 0
? formatDuration(durationMs) : "-"));
}
if (!currentStep.isEmpty()) {
currentProcessLabel->setText(displayProcessStep(currentStep));
}
processTotalElapsedLabel->setText(formatDuration(totalElapsedMs));
}
void DashboardPage::updateCurrentProcessDuration(int elapsedMs)
{
const Workpiece workpiece = productionWorkpiece;
if (workpiece.id <= 0) {
return;
}
for (int row = 0; row < processTable->rowCount(); ++row) {
QTableWidgetItem *stepItem = processTable->item(row, 0);
if (!stepItem || stepItem->data(Qt::UserRole).toString()
!= workpiece.processStep) {
continue;
}
QTableWidgetItem *statusItem = processTable->item(row, 1);
if (!statusItem || statusItem->data(Qt::UserRole).toString()
!= "RUNNING") {
continue;
}
processTable->setItem(row, 3,
new QTableWidgetItem(formatDuration(elapsedMs)));
break;
}
}
void DashboardPage::onDeviceStatusChanged(const DeviceStatus &status)
{
emit deviceStatusChanged(status);
const QString plcText = boolStatus(status.statusValid,
status.plcReady, "就绪", "未就绪");
const QString robotText = boolStatus(status.statusValid,
status.robotReady, "就绪", "未就绪");
const QString safetyText = !status.statusValid ? "未采集"
: status.safetyDoorClosed ? "正常" : "异常";
deviceStatusLabel->setText(
QString("PLC:%1 | 机器人:%2 | 安全回路:%3 | 急停:%4")
.arg(!status.statusValid ? "未采集"
: status.plcConnected ? "在线" : "离线")
.arg(robotText)
.arg(safetyText)
.arg(boolStatus(status.statusValid, status.emergencyStop,
"已触发", "正常")));
updateStatusCell(inspectionMachineCell,
QString("检测机\n%1").arg(boolStatus(
status.statusValid, status.inspectionMachineReady,
"就绪", "未就绪")),
!status.statusValid ? "#607d8b"
: status.inspectionMachineReady ? "#2e7d32" : "#d32f2f");
updateStatusCell(robotCell,
QString("机器人\n%1").arg(robotText),
!status.statusValid ? "#607d8b"
: status.robotReady ? "#2e7d32" : "#d32f2f");
updateStatusCell(robotControlCabinetCell,
QString("机器人控制柜\n%1").arg(boolStatus(
status.statusValid, status.robotControlCabinetReady,
"正常", "未就绪")),
!status.statusValid ? "#607d8b"
: status.robotControlCabinetReady ? "#2e7d32" : "#d32f2f");
updateStatusCell(mainControlCabinetCell,
QString("总控柜\n%1").arg(boolStatus(
status.statusValid, status.mainControlCabinetReady,
"正常", "未就绪")),
!status.statusValid ? "#607d8b"
: status.mainControlCabinetReady ? "#2e7d32" : "#d32f2f");
updateStatusCell(safetyDoor1Cell,
QString("安全门 1\n%1").arg(boolStatus(
status.statusValid, status.safetyDoor1Closed,
"关闭", "打开")),
!status.statusValid ? "#607d8b"
: status.safetyDoor1Closed ? "#2e7d32" : "#d32f2f");
updateStatusCell(safetyDoor2Cell,
QString("安全门 2\n%1").arg(boolStatus(
status.statusValid, status.safetyDoor2Closed,
"关闭", "打开")),
!status.statusValid ? "#607d8b"
: status.safetyDoor2Closed ? "#2e7d32" : "#d32f2f");
updateStatusCell(safetyDoor3Cell,
QString("安全门 3\n%1").arg(boolStatus(
status.statusValid, status.safetyDoor3Closed,
"关闭", "打开")),
!status.statusValid ? "#607d8b"
: status.safetyDoor3Closed ? "#2e7d32" : "#d32f2f");
updateStatusCell(alarmCell,
QString("PLC 报警\n%1").arg(boolStatus(
status.statusValid, status.activeAlarm,
"有报警", "无报警")),
!status.statusValid ? "#607d8b"
: status.activeAlarm ? "#d32f2f" : "#2e7d32");
updateRackSummary();
}
void DashboardPage::updateRackSummary()
{
QString error;
const QList<Tray> trays = TrayService::instance().listTrays(&error);
QSet<int> highlightedTrayIds;
if (error.isEmpty() && currentOrderId > 0) {
QString workpieceError;
const QList<Workpiece> workpieces =
WorkpieceService::instance().listByOrder(currentOrderId,
&workpieceError);
if (workpieceError.isEmpty()) {
for (const Workpiece &workpiece : workpieces) {
if (workpiece.trayId > 0) {
highlightedTrayIds.insert(workpiece.trayId);
}
}
}
}
for (int index = 0; index < rackTrayCells.size(); ++index) {
QLabel *cell = rackTrayCells.at(index);
if (!error.isEmpty() || index >= trays.size()) {
updateStatusCell(cell,
QString("托盘 %1\n未采集").arg(index + 1),
"#607d8b");
continue;
}
const Tray &tray = trays.at(index);
const QString status = tray.present ? tray.status : "离位";
const QString statusText = status == "OK" ? "已完成"
: status == "NG" ? "有 NG"
: status == "PROCESSING" ? "加工中"
: status == "PENDING" ? "待检测"
: tray.present ? "在位" : "离位";
const QString color = !tray.present ? "#90a4ae"
: status == "NG" ? "#d32f2f"
: status == "PROCESSING" ? "#1e88e5"
: status == "OK" ? "#2e7d32" : "#78909c";
updateStatusCell(cell,
QString("托盘 %1\n%2:%3/49")
.arg(index + 1)
.arg(statusText)
.arg(tray.loadedCount),
color, highlightedTrayIds.contains(tray.id));
}
}
void DashboardPage::loadCurrentOrder()
{
QString error;
Order order;
if (!OrderService::instance().findUnfinishedOrder(&order, &error)) {
currentOrderId = 0;
currentOrderStartable = false;
currentOrderResumable = false;
ui->orderLabel->setText("当前订单:读取失败");
updateProductionStats();
updateRackSummary();
emit logRequested("操作日志", "控制面板", "加载订单",
error, "失败");
return;
}
currentOrderId = order.id;
currentOrderStartable = false;
currentOrderResumable = false;
if (order.id <= 0) {
ui->orderLabel->setText("当前订单:暂无未完成订单");
emit currentOrderChanged("-");
updateProductionStats();
updateRackSummary();
updateRecoveryButtons();
return;
}
QString workpieceError;
const QList<Workpiece> workpieces =
WorkpieceService::instance().listByOrder(order.id, &workpieceError);
if (workpieceError.isEmpty()) {
currentOrderStartable = order.status == "NOT_START"
&& !workpieces.isEmpty();
currentOrderResumable = order.status == "PAUSED"
&& !workpieces.isEmpty();
}
ui->orderLabel->setText(QString("当前订单:%1(%2)")
.arg(order.no)
.arg(displayOrderStatus(order.status)));
emit currentOrderChanged(order.no);
updateProductionStats();
updateRackSummary();
updateRecoveryButtons();
}
void DashboardPage::updateProductionStats()
{
if (currentOrderId <= 0) {
ui->planValue->setText("0");
ui->pendingValue->setText("0");
ui->frontValue->setText("0");
ui->backValue->setText("0");
ui->okValue->setText("0");
ui->ngValue->setText("0");
return;
}
Order order;
QString error;
if (!OrderService::instance().findOrder(currentOrderId, &order, &error)) {
return;
}
const QList<Workpiece> workpieces =
WorkpieceService::instance().listByOrder(currentOrderId, &error);
if (!error.isEmpty()) {
return;
}
int pending = 0;
int frontChecking = 0;
int backChecking = 0;
int ok = 0;
int ng = 0;
for (const Workpiece &workpiece : workpieces) {
if (workpiece.state == "PENDING") {
++pending;
} else if (workpiece.processStep == "FRONT_CHECKING") {
++frontChecking;
} else if (workpiece.processStep == "BACK_CHECKING") {
++backChecking;
} else if (workpiece.state == "OK") {
++ok;
} else if (workpiece.state == "NG") {
++ng;
}
}
ui->planValue->setText(QString::number(order.planNum));
ui->pendingValue->setText(QString::number(pending));
ui->frontValue->setText(QString::number(frontChecking));
ui->backValue->setText(QString::number(backChecking));
ui->okValue->setText(QString::number(ok));
ui->ngValue->setText(QString::number(ng));
}