Files
ssp/pages/dashboardpage.cpp
T

896 lines
36 KiB
C++
Raw Normal View History

2026-08-18 09:40:43 +08:00
#include "dashboardpage.h"
#include "ui_dashboardpage.h"
#include "../services/orderservice.h"
2026-08-24 17:28:59 +08:00
#include "../services/trayservice.h"
2026-08-18 09:40:43 +08:00
#include "../services/workpieceservice.h"
#include "../repositories/productionrepository.h"
#include "uihelpers.h"
2026-10-27 22:16:55 +08:00
#include "../services/visionservice.h"
#include <QJsonDocument>
2026-08-18 09:40:43 +08:00
#include <QAbstractItemView>
#include <QDateTime>
#include <QFormLayout>
#include <QGridLayout>
#include <QGroupBox>
#include <QHeaderView>
#include <QLabel>
#include <QMessageBox>
2026-10-19 11:17:12 +08:00
#include <QSet>
2026-08-18 09:40:43 +08:00
#include <QtGlobal>
#include <QPushButton>
2026-08-20 11:22:55 +08:00
#include <QMetaObject>
2026-08-18 09:40:43 +08:00
#include <QResizeEvent>
#include <QSizePolicy>
#include <QTableWidgetItem>
#include <QTimer>
2026-08-20 11:22:55 +08:00
#include <QThread>
2026-08-18 09:40:43 +08:00
#include <QVBoxLayout>
2026-08-24 17:28:59 +08:00
namespace {
QString displayState(const QString &state)
{
if (state == "IDLE") return "待机";
if (state == "PREPARING") return "准备中";
if (state == "WAITING_DEVICE_READY") 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;
}
2026-10-19 11:17:12 +08:00
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)
2026-08-24 17:28:59 +08:00
{
if (!cell) {
return;
}
cell->setText(text);
2026-10-19 11:17:12 +08:00
cell->setStyleSheet(QString("QLabel { background: %1; border: %2; "
2026-08-24 17:28:59 +08:00
"border-radius: 3px; color: white; font-size: 11px; }")
2026-10-19 11:17:12 +08:00
.arg(color)
.arg(highlighted ? "3px solid #ffb300" : "1px solid #ffffff"));
2026-08-24 17:28:59 +08:00
}
QString boolStatus(bool valid, bool value, const QString &yes, const QString &no)
{
return !valid ? "未采集" : value ? yes : no;
}
}
2026-08-18 09:40:43 +08:00
DashboardPage::DashboardPage(QWidget *parent)
: QWidget(parent)
, ui(new Ui::DashboardPage)
, rackBox(nullptr)
2026-08-24 17:28:59 +08:00
, deviceStatusLabel(new QLabel("PLC:未采集 | 机器人:未采集 | 安全回路:未采集", this))
, inspectionMachineCell(nullptr)
, robotCell(nullptr)
, robotControlCabinetCell(nullptr)
, mainControlCabinetCell(nullptr)
, safetyDoor1Cell(nullptr)
, safetyDoor2Cell(nullptr)
, safetyDoor3Cell(nullptr)
, alarmCell(nullptr)
, recoverButton(new QPushButton("恢复", this))
, retryButton(new QPushButton("重试", this))
, markNgButton(new QPushButton("标记 NG", this))
, stopButton(new QPushButton("终止", this))
, processBox(new QGroupBox("工序耗时", this))
2026-08-18 09:40:43 +08:00
, 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)
2026-08-20 11:22:55 +08:00
, productionThread(new QThread(this))
, productionWorker(new ProductionWorker)
, productionState(ProductionService::Idle)
2026-10-19 11:17:12 +08:00
, currentOrderId(0)
, currentOrderStartable(false)
2026-08-20 11:22:55 +08:00
, productionTrayNo(0)
, productionSlotNo(0)
2026-08-18 09:40:43 +08:00
{
ui->setupUi(this);
2026-08-20 11:22:55 +08:00
productionWorker->moveToThread(productionThread);
connect(productionThread, &QThread::finished,
productionWorker, &QObject::deleteLater);
connect(productionWorker, &ProductionWorker::shutdownReady,
productionThread, &QThread::quit, Qt::DirectConnection);
2026-08-20 11:22:55 +08:00
2026-08-18 09:40:43 +08:00
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);
recoverButton->setObjectName("recoveryButton");
recoverButton->setVisible(false);
ui->buttonLayout->insertWidget(3, recoverButton);
retryButton->setObjectName("recoveryRetryButton");
retryButton->setVisible(false);
ui->buttonLayout->insertWidget(4, retryButton);
markNgButton->setObjectName("recoveryNgButton");
markNgButton->setVisible(false);
ui->buttonLayout->insertWidget(5, markNgButton);
stopButton->setObjectName("stopButton");
stopButton->setVisible(false);
ui->buttonLayout->insertWidget(6, stopButton);
deviceStatusLabel->setStyleSheet("color: #546e7a;");
2026-10-19 11:17:12 +08:00
ui->taskLayout->insertWidget(0, deviceStatusLabel);
2026-08-18 09:40:43 +08:00
QFormLayout *processSummaryLayout = new QFormLayout;
2026-08-24 17:28:59 +08:00
processSummaryLayout->addRow("当前工序:", currentProcessLabel);
processSummaryLayout->addRow("当前耗时:", processElapsedLabel);
processSummaryLayout->addRow("累计耗时:", processTotalElapsedLabel);
2026-08-18 09:40:43 +08:00
QVBoxLayout *processLayout = new QVBoxLayout(processBox);
processLayout->addLayout(processSummaryLayout);
processTable->setColumnCount(4);
processTable->setHorizontalHeaderLabels(
2026-08-24 17:28:59 +08:00
QStringList() << "工序" << "状态" << "次数" << "耗时");
2026-08-18 09:40:43 +08:00
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);
2026-08-24 17:28:59 +08:00
inspectionMachineCell = UiHelpers::makeStatusCell("检测机\n未采集", "#607d8b");
ui->deviceLayout->addWidget(inspectionMachineCell, 0, 0, 2, 2);
2026-08-18 09:40:43 +08:00
ui->deviceLayout->addWidget(UiHelpers::makeStatusCell("总控电脑", "#43a047"), 0, 3);
2026-08-24 17:28:59 +08:00
safetyDoor1Cell = UiHelpers::makeStatusCell("安全门 1\n未采集", "#607d8b");
ui->deviceLayout->addWidget(safetyDoor1Cell, 0, 4);
robotCell = UiHelpers::makeStatusCell("机器人\n未采集", "#607d8b");
2026-08-18 09:40:43 +08:00
robotCell->setFixedSize(82, 58);
ui->deviceLayout->addWidget(robotCell, 2, 3, 2, 2, Qt::AlignCenter);
2026-08-24 17:28:59 +08:00
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);
2026-08-18 09:40:43 +08:00
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) {
2026-08-24 17:28:59 +08:00
QLabel *trayCell = UiHelpers::makeSquareStatusCell(
QString("托盘 %1\n未采集").arg(i + 1), "#607d8b");
2026-08-18 09:40:43 +08:00
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->resetButton, &QPushButton::clicked,
this, &DashboardPage::resetProduction);
connect(ui->clearAlarmButton, &QPushButton::clicked,
this, &DashboardPage::clearAlarm);
connect(recoverButton, &QPushButton::clicked,
this, &DashboardPage::recoverProduction);
connect(retryButton, &QPushButton::clicked,
this, &DashboardPage::retryRecovery);
connect(markNgButton, &QPushButton::clicked,
this, &DashboardPage::markWorkpieceNg);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::stateChanged,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onProductionStateChanged);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::currentWorkpieceChanged,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onCurrentWorkpieceChanged);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::currentWorkpieceSnapshotChanged,
this, &DashboardPage::onCurrentWorkpieceSnapshotChanged);
connect(productionWorker, &ProductionWorker::currentPositionChanged,
this, &DashboardPage::onCurrentPositionChanged);
connect(productionWorker, &ProductionWorker::productionError,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onProductionError);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::productionFinished,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onProductionFinished);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::processElapsedChanged,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onProcessElapsedChanged);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::timeoutRecoveryRequired,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onTimeoutRecoveryRequired);
2026-08-20 11:22:55 +08:00
connect(productionWorker, &ProductionWorker::recoveryCompleted,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onRecoveryCompleted);
connect(productionWorker, &ProductionWorker::deviceStatusChanged,
2026-08-18 09:40:43 +08:00
this, &DashboardPage::onDeviceStatusChanged);
connect(productionWorker, &ProductionWorker::deviceCommunicationError,
this, [this](const QString &error) {
emit deviceCommunicationError(error);
});
2026-08-18 09:40:43 +08:00
2026-08-20 11:22:55 +08:00
productionThread->start();
QMetaObject::invokeMethod(productionWorker, "requestRestore",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
2026-10-19 11:17:12 +08:00
loadCurrentOrder();
2026-08-18 09:40:43 +08:00
processRefreshTimer->setInterval(1000);
2026-10-19 11:17:12 +08:00
connect(processRefreshTimer, &QTimer::timeout, this, [this]() {
refreshProcessRecords();
loadCurrentOrder();
});
2026-08-18 09:40:43 +08:00
processRefreshTimer->start();
refreshProcessRecords();
2026-08-24 17:28:59 +08:00
updateRackSummary();
2026-08-18 09:40:43 +08:00
}
DashboardPage::~DashboardPage()
{
2026-08-20 11:22:55 +08:00
if (productionThread->isRunning()) {
productionWorker->requestStopImmediate();
QMetaObject::invokeMethod(productionWorker, "requestShutdown",
Qt::QueuedConnection);
2026-08-20 11:22:55 +08:00
productionThread->wait();
}
2026-08-18 09:40:43 +08:00
delete ui;
}
2026-10-27 22:16:55 +08:00
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);
}
2026-08-18 09:40:43 +08:00
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()
{
2026-08-24 17:28:59 +08:00
if (productionState != ProductionService::Idle
&& productionState != ProductionService::Completed) {
return;
}
2026-10-19 11:17:12 +08:00
loadCurrentOrder();
if (!currentOrderStartable || currentOrderId <= 0) {
2026-08-24 17:28:59 +08:00
QMessageBox::information(this, "启动生产",
"没有可生产的订单,请先生成工件。");
2026-08-18 09:40:43 +08:00
return;
}
2026-08-24 17:28:59 +08:00
ui->startButton->setEnabled(false);
if (!QMetaObject::invokeMethod(
2026-08-20 11:22:55 +08:00
productionWorker, "requestStart", Qt::QueuedConnection,
2026-10-19 11:17:12 +08:00
Q_ARG(int, currentOrderId))) {
2026-08-24 17:28:59 +08:00
updateRecoveryButtons();
QMessageBox::warning(this, "启动生产",
"提交生产启动请求失败。");
2026-08-18 09:40:43 +08:00
}
}
void DashboardPage::pauseProduction()
{
2026-10-27 22:16:55 +08:00
productionWorker->requestPauseImmediate();
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestPause",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::stopProduction()
{
productionWorker->requestStopImmediate();
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestStop",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::resetProduction()
{
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestReset",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::clearAlarm()
{
QMetaObject::invokeMethod(productionWorker, "requestClearAlarm",
Qt::QueuedConnection);
2026-08-24 17:28:59 +08:00
emit logRequested("报警日志", "控制面板", "清除报警",
"已请求 PLC 清除报警", "待处理");
2026-08-18 09:40:43 +08:00
}
2026-08-20 11:22:55 +08:00
void DashboardPage::onProductionStateChanged(ProductionService::State state,
2026-08-18 09:40:43 +08:00
const QString &name)
{
2026-08-20 11:22:55 +08:00
productionState = state;
2026-08-24 17:28:59 +08:00
const QString stateText = displayState(name);
ui->actionLabel->setText("生产状态:" + stateText);
2026-10-19 11:17:12 +08:00
loadCurrentOrder();
2026-08-18 09:40:43 +08:00
updateRecoveryButtons();
2026-08-24 17:28:59 +08:00
emit systemStateChanged(stateText);
emit currentStepChanged(stateText);
2026-08-18 09:40:43 +08:00
refreshProcessRecords();
updateProductionStats();
}
void DashboardPage::onCurrentWorkpieceChanged(int workpieceId,
const QString &barcode)
{
if (workpieceId <= 0) {
2026-08-24 17:28:59 +08:00
ui->workpieceLabel->setText("当前工件:-");
ui->trayLabel->setText("当前托盘:-");
2026-08-18 09:40:43 +08:00
currentProcessElapsedMs = 0;
2026-08-24 17:28:59 +08:00
emit currentWorkpieceChanged("-");
2026-08-18 09:40:43 +08:00
} else {
ui->workpieceLabel->setText(
2026-08-24 17:28:59 +08:00
QString("当前工件:%1").arg(barcode));
emit currentWorkpieceChanged(barcode);
2026-08-18 09:40:43 +08:00
}
refreshProcessRecords();
updateRecoveryButtons();
updateProductionStats();
}
2026-08-20 11:22:55 +08:00
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
2026-08-24 17:28:59 +08:00
? QString("当前托盘:%1,位置:%2").arg(trayNo).arg(slotNo)
: "当前托盘:-");
2026-08-20 11:22:55 +08:00
}
2026-08-18 09:40:43 +08:00
void DashboardPage::onProductionError(const QString &error)
{
2026-08-24 17:28:59 +08:00
ui->actionLabel->setText("生产故障:" + error);
updateRecoveryButtons();
emit systemStateChanged("故障");
emit logRequested("报警日志", "生产流程", "生产故障",
error, "失败");
2026-08-18 09:40:43 +08:00
}
void DashboardPage::onProductionFinished(int orderId)
{
2026-08-24 17:28:59 +08:00
emit logRequested("生产日志", "生产流程", "订单完成",
QString("订单 %1 已完成").arg(orderId), "成功");
2026-10-19 11:17:12 +08:00
loadCurrentOrder();
2026-08-18 09:40:43 +08:00
updateProductionStats();
2026-08-24 17:28:59 +08:00
updateRackSummary();
2026-08-18 09:40:43 +08:00
}
void DashboardPage::onProcessElapsedChanged(const QString &processStep,
int elapsedMs)
{
currentProcessElapsedMs = elapsedMs;
2026-08-24 17:28:59 +08:00
currentProcessLabel->setText(displayProcessStep(processStep));
2026-08-18 09:40:43 +08:00
processElapsedLabel->setText(formatDuration(elapsedMs));
updateCurrentProcessDuration(elapsedMs);
}
void DashboardPage::onTimeoutRecoveryRequired(const QString &state,
const QString &message)
{
2026-08-24 17:28:59 +08:00
ui->actionLabel->setText("需要人工恢复:" + message);
emit logRequested("操作日志", "生产流程", "人工恢复",
displayState(state) + ":" + message, "待处理");
2026-08-18 09:40:43 +08:00
}
void DashboardPage::onRecoveryCompleted(const QString &mode)
{
2026-08-24 17:28:59 +08:00
emit logRequested("生产日志", "生产流程", "恢复完成",
displayState(mode), "成功");
2026-08-18 09:40:43 +08:00
}
void DashboardPage::recoverProduction()
{
2026-10-27 22:16:55 +08:00
if ((productionState == ProductionService::ManualConfirm || visionRecoveryRequired)
2026-08-18 09:40:43 +08:00
&& QMessageBox::question(
2026-08-24 17:28:59 +08:00
this, "继续生产",
2026-10-27 22:16:55 +08:00
visionRecoveryRequired
? "请先核对机器人当前位置及本次 R60 目标是否已被消费或撤销,并确认 PLC 已复位 850、851。确认后 ssp 会清除自己的视觉输出并重新核对信号,不会重发旧坐标。是否已完成现场核对?"
: "请确认设备和 PLC 当前步骤安全后再继续生产。",
QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
2026-08-18 09:40:43 +08:00
!= QMessageBox::Yes) {
return;
}
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestRecover",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::retryRecovery()
{
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestRetry",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::markWorkpieceNg()
{
if (QMessageBox::question(
2026-08-24 17:28:59 +08:00
this, "标记工件 NG",
"确认将当前工件标记为 NG,并继续处理下一个工件吗?",
2026-08-18 09:40:43 +08:00
QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
!= QMessageBox::Yes) {
return;
}
2026-08-20 11:22:55 +08:00
QMetaObject::invokeMethod(productionWorker, "requestMarkNg",
Qt::QueuedConnection);
2026-08-18 09:40:43 +08:00
}
void DashboardPage::updateRecoveryButtons()
{
2026-08-20 11:22:55 +08:00
const ProductionService::State state = productionState;
2026-08-18 09:40:43 +08:00
const bool recoveryRequired = state == ProductionService::TimeoutPaused
2026-10-27 22:16:55 +08:00
|| state == ProductionService::ManualConfirm || visionRecoveryRequired;
2026-08-18 09:40:43 +08:00
const bool running = state != ProductionService::Idle
&& state != ProductionService::Completed;
const bool terminating = state == ProductionService::Terminating;
2026-10-19 11:17:12 +08:00
const bool canStart = (state == ProductionService::Idle
|| state == ProductionService::Completed)
2026-10-27 22:16:55 +08:00
&& currentOrderStartable && !visionRecoveryRequired;
2026-08-24 17:28:59 +08:00
ui->startButton->setEnabled(canStart);
2026-08-18 09:40:43 +08:00
recoverButton->setVisible(recoveryRequired);
2026-10-27 22:16:55 +08:00
retryButton->setVisible(recoveryRequired && !visionRecoveryRequired);
2026-08-18 09:40:43 +08:00
markNgButton->setVisible(recoveryRequired
2026-10-27 22:16:55 +08:00
&& productionWorkpiece.id > 0 && !visionRecoveryRequired);
2026-08-18 09:40:43 +08:00
stopButton->setVisible(running);
stopButton->setEnabled(!terminating);
2026-08-24 17:28:59 +08:00
stopButton->setText(terminating ? "终止中..." : "终止");
2026-10-27 22:16:55 +08:00
recoverButton->setText(visionRecoveryRequired ? "核对视觉恢复" : state == ProductionService::ManualConfirm
2026-08-24 17:28:59 +08:00
? "继续" : "恢复");
2026-08-18 09:40:43 +08:00
}
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()
{
2026-08-20 11:22:55 +08:00
const Workpiece workpiece = productionWorkpiece;
2026-08-18 09:40:43 +08:00
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;
}
2026-08-24 17:28:59 +08:00
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);
2026-08-18 09:40:43 +08:00
processTable->setItem(row, 2,
new QTableWidgetItem(
QString::number(record.attemptNo)));
processTable->setItem(row, 3,
new QTableWidgetItem(
durationMs >= 0
? formatDuration(durationMs) : "-"));
}
if (!currentStep.isEmpty()) {
2026-08-24 17:28:59 +08:00
currentProcessLabel->setText(displayProcessStep(currentStep));
2026-08-18 09:40:43 +08:00
}
processTotalElapsedLabel->setText(formatDuration(totalElapsedMs));
}
void DashboardPage::updateCurrentProcessDuration(int elapsedMs)
{
2026-08-20 11:22:55 +08:00
const Workpiece workpiece = productionWorkpiece;
2026-08-18 09:40:43 +08:00
if (workpiece.id <= 0) {
return;
}
for (int row = 0; row < processTable->rowCount(); ++row) {
QTableWidgetItem *stepItem = processTable->item(row, 0);
2026-08-24 17:28:59 +08:00
if (!stepItem || stepItem->data(Qt::UserRole).toString()
!= workpiece.processStep) {
2026-08-18 09:40:43 +08:00
continue;
}
QTableWidgetItem *statusItem = processTable->item(row, 1);
2026-08-24 17:28:59 +08:00
if (!statusItem || statusItem->data(Qt::UserRole).toString()
!= "RUNNING") {
2026-08-18 09:40:43 +08:00
continue;
}
processTable->setItem(row, 3,
new QTableWidgetItem(formatDuration(elapsedMs)));
break;
}
}
void DashboardPage::onDeviceStatusChanged(const DeviceStatus &status)
{
emit deviceStatusChanged(status);
2026-08-24 17:28:59 +08:00
const QString plcText = boolStatus(status.statusValid,
status.plcReady, "就绪", "未就绪");
const QString robotText = boolStatus(status.statusValid,
status.robotReady, "就绪", "未就绪");
const QString safetyText = !status.statusValid ? "未采集"
: status.safetyDoorClosed ? "正常" : "异常";
2026-08-18 09:40:43 +08:00
deviceStatusLabel->setText(
2026-08-24 17:28:59 +08:00
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);
2026-10-19 11:17:12 +08:00
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);
}
}
}
}
2026-08-24 17:28:59 +08:00
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),
2026-10-19 11:17:12 +08:00
color, highlightedTrayIds.contains(tray.id));
2026-08-24 17:28:59 +08:00
}
2026-08-18 09:40:43 +08:00
}
2026-10-19 11:17:12 +08:00
void DashboardPage::loadCurrentOrder()
2026-08-18 09:40:43 +08:00
{
QString error;
2026-10-19 11:17:12 +08:00
Order order;
if (!OrderService::instance().findUnfinishedOrder(&order, &error)) {
currentOrderId = 0;
currentOrderStartable = false;
ui->orderLabel->setText("当前订单:读取失败");
updateProductionStats();
updateRackSummary();
2026-08-24 17:28:59 +08:00
emit logRequested("操作日志", "控制面板", "加载订单",
error, "失败");
2026-08-18 09:40:43 +08:00
return;
}
2026-10-19 11:17:12 +08:00
currentOrderId = order.id;
currentOrderStartable = false;
if (order.id <= 0) {
ui->orderLabel->setText("当前订单:暂无未完成订单");
2026-08-24 17:28:59 +08:00
emit currentOrderChanged("-");
2026-08-18 09:40:43 +08:00
updateProductionStats();
2026-10-19 11:17:12 +08:00
updateRackSummary();
updateRecoveryButtons();
2026-08-18 09:40:43 +08:00
return;
}
2026-10-19 11:17:12 +08:00
QString workpieceError;
const QList<Workpiece> workpieces =
WorkpieceService::instance().listByOrder(order.id, &workpieceError);
if (workpieceError.isEmpty()) {
currentOrderStartable = order.status == "NOT_START"
&& !workpieces.isEmpty();
2026-08-18 09:40:43 +08:00
}
2026-10-19 11:17:12 +08:00
ui->orderLabel->setText(QString("当前订单:%1(%2)")
.arg(order.no)
.arg(displayOrderStatus(order.status)));
2026-08-24 17:28:59 +08:00
emit currentOrderChanged(order.no);
2026-08-18 09:40:43 +08:00
updateProductionStats();
2026-10-19 11:17:12 +08:00
updateRackSummary();
updateRecoveryButtons();
2026-08-18 09:40:43 +08:00
}
void DashboardPage::updateProductionStats()
{
2026-10-19 11:17:12 +08:00
if (currentOrderId <= 0) {
2026-08-18 09:40:43 +08:00
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;
2026-10-19 11:17:12 +08:00
if (!OrderService::instance().findOrder(currentOrderId, &order, &error)) {
2026-08-18 09:40:43 +08:00
return;
}
const QList<Workpiece> workpieces =
2026-10-19 11:17:12 +08:00
WorkpieceService::instance().listByOrder(currentOrderId, &error);
2026-08-18 09:40:43 +08:00
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));
}