Files
ssp/pages/dashboardpage.cpp
T
2026-11-12 09:26:26 +08:00

1496 lines
65 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 <QJsonArray>
#include <QAbstractItemView>
#include <QDateTime>
#include <QCheckBox>
#include <QComboBox>
#include <QDialog>
#include <QDialogButtonBox>
#include <QEvent>
#include <QFormLayout>
#include <QGroupBox>
#include <QLabel>
#include <QLineEdit>
#include <QMessageBox>
#include <QSet>
#include <QtGlobal>
#include <QPushButton>
#include <QMetaObject>
#include <QPixmap>
#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 == "REVERSE_FLIPPING") return "反向翻面";
if (state == "BACK_LOADING") return "反面上料";
if (state == "BACK_CHECKING") return "反面检测";
if (state == "BACK_UNLOADING") return "反面下料";
if (state == "PLACE_PHOTO_MOVING") return "放料前移动到拍照位置";
if (state == "PLACE_SLOT_INSPECTING") 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 displayRecoveryAction(const QString &action)
{
if (action == "PHOTO_MOVE") return "移动到拍照位置";
if (action == "VISION") return "相机视觉处理";
if (action == "RACK_PICK") return "料架取料";
if (action == "FRONT_LOAD") return "正面上料";
if (action == "INSPECT") return "检测";
if (action == "FRONT_UNLOAD") return "正面下料";
if (action == "FLIP") return "翻面";
if (action == "REVERSE_FLIP") return "反向翻面";
if (action == "BACK_LOAD") return "反面上料";
if (action == "BACK_UNLOAD") return "反面下料";
if (action == "RACK_PLACE") return "料架放料";
return action.isEmpty() ? "未知" : action;
}
QString displayActionPhase(const QString &phase)
{
if (phase == "NOT_SENT") return "命令尚未发送";
if (phase == "SENDING") return "命令发送结果待核对";
if (phase == "COMMAND_CONFIRMED") return "命令写入已确认";
if (phase == "FEEDBACK_RECEIVED") return "已收到完成反馈";
if (phase == "SIGNALS_CLEARED") return "完成握手已清零";
if (phase == "STEP_COMMITTED") return "下一工序已保存";
if (phase == "RESULT_WRITING") return "坐标写入结果待核对";
if (phase == "RESULT_CONFIRMED") return "坐标写入已确认";
if (phase == "MODE_WRITING") return "取料模式写入结果待核对";
if (phase == "MODE_CONFIRMED") return "取料模式写入已确认";
return phase.isEmpty() ? "未知" : phase;
}
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;
}
QString displayInspectionMode(const QString &mode)
{
if (mode == "BEFORE_PLATING") return "镀金前";
if (mode == "AFTER_PLATING") return "镀金后";
return mode.isEmpty() ? "未设置" : mode;
}
void updateStatusCell(QLabel *cell, const QString &text, const QString &color,
bool highlighted = false)
{
if (!cell) {
return;
}
cell->setText(text);
const QString border = highlighted
? "3px solid #ffb300"
: QString("1px solid %1").arg(color);
const bool compact = cell->property("compactStatus").toBool();
cell->setStyleSheet(QString("QLabel { background: rgba(18, 31, 38, 190); "
"border: %1; border-radius: 3px; color: white; "
"font-size: %2px; padding: %3; }")
.arg(border)
.arg(compact ? 9 : 11)
.arg(compact ? "2px" : "4px 6px"));
}
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)
, layoutCanvas(nullptr)
, layoutBackground(nullptr)
, rackBox(nullptr)
, deviceStatusLabel(new QLabel("PLC:未采集 | 机器人:未采集 | 安全回路:未采集", this))
, inspectionMachineCell(nullptr)
, robotCell(nullptr)
, robotControlCabinetCell(nullptr)
, mainControlCabinetCell(nullptr)
, safetyDoor1Cell(nullptr)
, safetyDoor2Cell(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);
qRegisterMetaType<QJsonObject>("QJsonObject");
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->setEnabled(false);
markNgButton->setObjectName("recoveryNgButton");
markNgButton->setVisible(false);
ui->buttonLayout->insertWidget(ui->buttonLayout->indexOf(ui->recoveryButton),
markNgButton);
stopButton->setObjectName("stopButton");
stopButton->setVisible(true);
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);
processBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
processTable->setColumnCount(4);
processTable->setHorizontalHeaderLabels(
QStringList() << "工序" << "状态" << "次数" << "耗时");
UiHelpers::configureTableColumns(
processTable, QList<int>() << 180 << 120 << 70 << 100);
processTable->verticalHeader()->setVisible(false);
processTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
processTable->setAlternatingRowColors(true);
processTable->setMinimumHeight(150);
processTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
processLayout->addWidget(processTable, 1);
ui->taskSpacer->changeSize(0, 0, QSizePolicy::Minimum, QSizePolicy::Fixed);
ui->taskLayout->insertWidget(6, processBox, 1);
ui->layoutGroup->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
ui->taskGroup->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
ui->middleLayout->setStretch(0, 1);
ui->middleLayout->setStretch(1, 1);
ui->mainLayout->setStretch(0, 0);
ui->mainLayout->setStretch(1, 4);
ui->mainLayout->setStretch(2, 1);
ui->recentLogTable->setColumnCount(5);
ui->recentLogTable->setHorizontalHeaderLabels(QStringList() << "时间" << "类型" << "模块" << "内容" << "状态");
UiHelpers::configureTableColumns(
ui->recentLogTable, QList<int>() << 80 << 100 << 100 << 300 << 80,
3, 60);
ui->recentLogTable->verticalHeader()->setVisible(false);
ui->recentLogTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->recentLogTable->setAlternatingRowColors(true);
ui->deviceLayout->setContentsMargins(8, 8, 8, 8);
ui->deviceLayout->setSpacing(0);
ui->layoutGroup->setMinimumSize(480, 500);
ui->layoutGroup->installEventFilter(this);
layoutCanvas = new QWidget(ui->layoutGroup);
layoutCanvas->setObjectName("deviceLayoutCanvas");
layoutCanvas->setMinimumSize(440, 441);
layoutCanvas->setStyleSheet(
"QWidget#deviceLayoutCanvas { background: #dfe4e8; }");
ui->deviceLayout->addWidget(layoutCanvas, 0, 0, Qt::AlignCenter);
layoutBackground = new QLabel(layoutCanvas);
layoutBackground->setAlignment(Qt::AlignCenter);
layoutBackground->setStyleSheet("background: #dfe4e8;");
inspectionMachineCell = UiHelpers::makeStatusCell("检测机\n未采集", "#607d8b");
inspectionMachineCell->setParent(layoutCanvas);
safetyDoor1Cell = UiHelpers::makeStatusCell("安全门 1\n未采集", "#607d8b");
safetyDoor1Cell->setParent(layoutCanvas);
robotCell = UiHelpers::makeStatusCell("机器人\n未采集", "#607d8b");
robotCell->setParent(layoutCanvas);
robotControlCabinetCell = UiHelpers::makeStatusCell("机器人控制柜\n未采集", "#607d8b");
robotControlCabinetCell->setParent(layoutCanvas);
mainControlCabinetCell = UiHelpers::makeStatusCell("总控柜\n未采集", "#607d8b");
mainControlCabinetCell->setParent(layoutCanvas);
safetyDoor2Cell = UiHelpers::makeStatusCell("安全门 2\n未采集", "#607d8b");
safetyDoor2Cell->setParent(layoutCanvas);
alarmCell = UiHelpers::makeStatusCell("PLC 报警\n未采集", "#607d8b");
alarmCell->setParent(layoutCanvas);
rackBox = new QGroupBox("料架 2x3", layoutCanvas);
rackBox->setObjectName("deviceRack");
rackBox->setStyleSheet(
"QGroupBox#deviceRack { border: 0; background: transparent; color: white; "
"font-size: 11px; font-weight: bold; }"
"QGroupBox#deviceRack::title { subcontrol-origin: margin; "
"background: rgba(18, 31, 38, 190); border: 1px solid #2e7d32; "
"border-radius: 3px; padding: 3px 8px; }");
for (int i = 0; i < 6; ++i) {
QLabel *trayCell = UiHelpers::makeSquareStatusCell(
QString("托盘 %1\n未采集").arg(i + 1), "#607d8b");
trayCell->setParent(rackBox);
trayCell->setMinimumSize(0, 0);
trayCell->setProperty("compactStatus", true);
rackTrayCells.append(trayCell);
}
updateStatusCell(inspectionMachineCell, "检测机\n未采集", "#607d8b");
updateStatusCell(robotCell, "机器人\n未采集", "#607d8b");
updateStatusCell(robotControlCabinetCell, "机器人控制柜\n未采集", "#607d8b");
updateStatusCell(mainControlCabinetCell, "总控柜\n未采集", "#607d8b");
updateStatusCell(safetyDoor1Cell, "安全门 1\n未采集", "#607d8b");
updateStatusCell(safetyDoor2Cell, "安全门 2\n未采集", "#607d8b");
updateStatusCell(alarmCell, "PLC 报警\n未采集", "#607d8b");
for (int i = 0; i < rackTrayCells.size(); ++i) {
updateStatusCell(rackTrayCells.at(i),
QString("托盘 %1\n未采集").arg(i + 1), "#607d8b");
}
QTimer::singleShot(0, this, [this]() { updateDeviceLayout(); });
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::snapshotChanged,
this, &DashboardPage::onProductionSnapshot);
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::recoveryDecisionRequired,
this, &DashboardPage::onRecoveryDecisionRequired);
connect(productionWorker, &ProductionWorker::recoveryBusyChanged,
this, &DashboardPage::onRecoveryBusyChanged);
connect(productionWorker, &ProductionWorker::resetContextReady,
this, &DashboardPage::onResetContextReady);
connect(productionWorker, &ProductionWorker::alarmOperationBusyChanged,
this, &DashboardPage::onAlarmOperationBusyChanged);
connect(productionWorker, &ProductionWorker::alarmOperationFinished,
this, &DashboardPage::onAlarmOperationFinished);
connect(this, &DashboardPage::recoveryDecisionSubmitted,
productionWorker, &ProductionWorker::requestRecoveryDecision,
Qt::QueuedConnection);
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()
{
closing = true;
if (alarmDialog) alarmDialog->reject();
recoveryBusy = false;
if (recoveryDialog) recoveryDialog->reject();
if (productionThread->isRunning()) {
productionWorker->requestStopImmediate();
QMetaObject::invokeMethod(productionWorker, "requestShutdown",
Qt::QueuedConnection);
productionThread->wait();
}
delete ui;
}
void DashboardPage::attachVisionService(VisionService *service)
{
connect(productionWorker, &ProductionWorker::visionMeasureRequested,
service, &VisionService::measure, Qt::QueuedConnection);
connect(productionWorker, &ProductionWorker::visionGroovesRequested,
service, &VisionService::recognizeGrooves, 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::groovesRecognized,
productionWorker, &ProductionWorker::receiveGroovesResult, 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) {
QTableWidgetItem *item = new QTableWidgetItem(values.at(col));
if (col == 3) item->setTextAlignment(Qt::AlignCenter);
ui->recentLogTable->setItem(0, col, item);
}
while (ui->recentLogTable->rowCount() > 8) {
ui->recentLogTable->removeRow(ui->recentLogTable->rowCount() - 1);
}
}
bool DashboardPage::eventFilter(QObject *watched, QEvent *event)
{
if (watched == ui->layoutGroup
&& (event->type() == QEvent::Resize
|| event->type() == QEvent::Show
|| event->type() == QEvent::LayoutRequest)) {
QTimer::singleShot(0, this, [this]() { updateDeviceLayout(); });
}
return QWidget::eventFilter(watched, event);
}
void DashboardPage::resizeEvent(QResizeEvent *event)
{
QWidget::resizeEvent(event);
QTimer::singleShot(0, this, [this]() { updateDeviceLayout(); });
}
void DashboardPage::updateDeviceLayout()
{
if (!layoutCanvas || !layoutBackground || !rackBox
|| rackTrayCells.size() != 6) {
return;
}
static const QPixmap sourcePixmap(":/layout/Layout.png");
if (sourcePixmap.isNull()) {
return;
}
const QSize available = ui->deviceLayout->contentsRect().size();
if (available.width() <= 0 || available.height() <= 0) {
return;
}
const qreal imageRatio = qreal(sourcePixmap.width()) / sourcePixmap.height();
int canvasWidth = available.width();
int canvasHeight = qRound(canvasWidth / imageRatio);
if (canvasHeight > available.height()) {
canvasHeight = available.height();
canvasWidth = qRound(canvasHeight * imageRatio);
}
const QSize canvasSize(qMax(1, canvasWidth), qMax(1, canvasHeight));
if (layoutCanvas->size() != canvasSize) {
layoutCanvas->setFixedSize(canvasSize);
}
layoutBackground->setGeometry(layoutCanvas->rect());
layoutBackground->setPixmap(sourcePixmap.scaled(
canvasSize, Qt::KeepAspectRatio, Qt::SmoothTransformation));
layoutBackground->lower();
const int width = canvasSize.width();
const int height = canvasSize.height();
const auto place = [width, height](QWidget *widget, qreal x, qreal y,
qreal relativeWidth, int minimumWidth) {
if (!widget) {
return;
}
const int widgetWidth = qMin(width,
qMax(minimumWidth, qRound(width * relativeWidth)));
const int widgetHeight = qMin(height,
qMax(30, widget->sizeHint().height()));
const int left = qBound(0, qRound(width * x), width - widgetWidth);
const int top = qBound(0, qRound(height * y), height - widgetHeight);
widget->setGeometry(left, top, widgetWidth, widgetHeight);
widget->raise();
};
place(inspectionMachineCell, 0.09, 0.09, 0.27, 100);
place(safetyDoor1Cell, 0.435, 0.025, 0.13, 72);
place(robotCell, 0.67, 0.29, 0.21, 86);
place(robotControlCabinetCell, 0.07, 0.57, 0.17, 84);
place(mainControlCabinetCell, 0.07, 0.77, 0.15, 76);
place(safetyDoor2Cell, 0.38, 0.93, 0.12, 72);
place(alarmCell, 0.86, 0.93, 0.125, 82);
const int rackX = qRound(width * 0.53);
const int rackY = qRound(height * 0.615);
const int rackWidth = qMin(width - rackX, qRound(width * 0.36));
const int rackHeight = qMin(height - rackY, qRound(height * 0.30));
rackBox->setGeometry(rackX, rackY, rackWidth, rackHeight);
rackBox->raise();
const int trayWidth = qMin(rackWidth, qMax(1, qRound(rackWidth * 0.30)));
const int trayHeight = qMin(rackHeight,
qMax(30, qRound(rackHeight * 0.22)));
const qreal trayX[] = {0.03, 0.35, 0.67};
const qreal trayY[] = {0.28, 0.70};
for (int i = 0; i < rackTrayCells.size(); ++i) {
const int left = qBound(0, qRound(rackWidth * trayX[i % 3]),
rackWidth - trayWidth);
const int top = qBound(0, qRound(rackHeight * trayY[i / 3]),
rackHeight - trayHeight);
rackTrayCells.at(i)->setGeometry(left, top, trayWidth, trayHeight);
rackTrayCells.at(i)->raise();
}
}
void DashboardPage::startProduction()
{
if (!ui->startButton->isEnabled()) return;
if (!productionSnapshot.initialized) return;
if (recoveryBusy || visionRecoveryRequired) return;
if (productionState == ProductionService::Paused) {
if (!currentOrderResumable) return;
if (!confirmControlOperation("继续订单", "安全检查通过后,从保存的动作边界继续此暂停订单。")) 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;
}
if (!confirmControlOperation("启动订单", "设备检查通过后,启动此订单并执行下述首件工件。")) return;
ui->startButton->setEnabled(false);
if (!QMetaObject::invokeMethod(
productionWorker, "requestStart", Qt::QueuedConnection,
Q_ARG(int, selectedOrderId))) {
updateRecoveryButtons();
QMessageBox::warning(this, "启动生产",
"提交生产启动请求失败。");
}
}
void DashboardPage::pauseProduction()
{
if (!ui->pauseButton->isEnabled()
|| !confirmControlOperation("暂停订单", "机器人当前独立动作完成及握手结束后暂停;未提交的视觉请求作废。")) return;
QMetaObject::invokeMethod(productionWorker, "requestPause",
Qt::QueuedConnection);
}
void DashboardPage::stopProduction()
{
if (!productionSnapshot.initialized) return;
const bool active = productionState != ProductionService::Idle
&& productionState != ProductionService::Completed;
const int confirmedRunId = active ? productionSnapshot.runId : 0;
const int confirmedOrderId = active ? productionSnapshot.orderId : selectedOrderId;
if (!stopButton->isEnabled()
|| !confirmControlOperation("终止订单", "终止后剩余工件不再执行。无测量记录时自动删除订单、关联工件及动作记录,并释放料位;已有测量记录时保留订单和历史数据。此操作不是机器人急停。")) return;
if (recoveryDialog) recoveryDialog->reject();
QMetaObject::invokeMethod(productionWorker, "requestStopOrder",
Qt::QueuedConnection, Q_ARG(int, confirmedRunId),
Q_ARG(int, confirmedOrderId));
}
void DashboardPage::clearAlarm()
{
if (closing || controlConfirmationOpen || !ui->clearAlarmButton->isEnabled()) return;
alarmContextPending = true;
updateRecoveryButtons();
if (!QMetaObject::invokeMethod(productionWorker, "requestResetContext", Qt::QueuedConnection)) {
QJsonObject context;
context.insert("valid", false);
context.insert("error", "提交复位目标查询失败");
onResetContextReady(context);
}
}
void DashboardPage::onResetContextReady(const QJsonObject &context)
{
if (closing || !alarmContextPending) return;
alarmContextPending = false;
QDialog *dialog = new QDialog(this);
alarmDialog = dialog;
dialog->setObjectName("clearAlarmResetDialog");
dialog->setWindowTitle("清除报警");
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->setWindowModality(Qt::WindowModal);
dialog->setMinimumWidth(560);
QVBoxLayout *layout = new QVBoxLayout(dialog);
const bool valid = context.value("valid").toBool();
QString target;
if (!valid) {
target = "无法核实旧任务,暂不能复位;仍可仅清除报警。\n原因:"
+ context.value("error").toString();
} else if (context.value("run_id").toInt() > 0) {
target = QString("将结束的旧任务:订单 %1(ID %2),运行 %3")
.arg(context.value("order_no").toString())
.arg(context.value("order_id").toInt())
.arg(context.value("run_id").toInt());
} else {
target = "没有活动旧任务:仅清理遗留状态,不删除订单。";
}
if (!context.value("preserved_order_no").toString().isEmpty())
target += "\n保留的未开始订单:" + context.value("preserved_order_no").toString();
QLabel *details = new QLabel(target + "\n\n是否同时复位自动线?\n"
"复位将结束旧生产任务、清除遗留动作及视觉状态,回到待机。"
"不会继续旧订单,也不会自动启动新订单。\n"
"旧任务无测量记录:删除旧订单、关联工件及动作/运行记录,释放其料位。\n"
"旧任务已有测量记录:结束旧任务,保留订单和历史数据。\n"
"新建未开始订单、正常完成订单均保留。\n"
"软件复位不代替机器人急停或回原点。", dialog);
details->setTextFormat(Qt::PlainText);
details->setWordWrap(true);
details->setTextInteractionFlags(Qt::TextSelectableByMouse);
layout->addWidget(details);
QCheckBox *confirmed = new QCheckBox("已确认机器人停止,现场位置允许结束旧任务", dialog);
confirmed->setObjectName("resetFieldConfirmed");
confirmed->setEnabled(valid);
layout->addWidget(confirmed);
QDialogButtonBox *buttons = new QDialogButtonBox(dialog);
QPushButton *reset = buttons->addButton("是,清警并复位", QDialogButtonBox::YesRole);
QPushButton *clear = buttons->addButton("否,仅清除报警", QDialogButtonBox::NoRole);
QPushButton *cancel = buttons->addButton("取消", QDialogButtonBox::RejectRole);
reset->setObjectName("resetProductionButton");
clear->setObjectName("clearAlarmOnlyButton");
cancel->setObjectName("cancelClearAlarmButton");
reset->setEnabled(false);
reset->setAutoDefault(false);
cancel->setAutoDefault(false);
clear->setDefault(true);
layout->addWidget(buttons);
connect(confirmed, &QCheckBox::toggled, dialog, [reset, valid](bool checked) {
reset->setEnabled(valid && checked);
});
connect(reset, &QPushButton::clicked, dialog, [dialog]() { dialog->done(2); });
connect(clear, &QPushButton::clicked, dialog, &QDialog::accept);
connect(cancel, &QPushButton::clicked, dialog, &QDialog::reject);
connect(dialog, &QDialog::finished, this,
[this, context, confirmed](int result) {
alarmDialog = nullptr;
if (closing) return;
const bool resetRequested = result == 2;
if (result != QDialog::Accepted && !resetRequested) {
updateRecoveryButtons();
return;
}
if (resetRequested && (!context.value("valid").toBool() || !confirmed->isChecked())) {
updateRecoveryButtons();
return;
}
alarmRequestPending = true;
if (resetRequested) {
recoveryBusy = false;
if (recoveryDialog) recoveryDialog->reject();
}
updateRecoveryButtons();
ui->actionLabel->setText(resetRequested ? "正在清警并复位..." : "正在清除报警...");
QJsonObject request = context;
request.insert("field_confirmed", confirmed->isChecked());
const bool submitted = resetRequested
? QMetaObject::invokeMethod(productionWorker, "requestReset", Qt::QueuedConnection,
Q_ARG(QJsonObject, request))
: QMetaObject::invokeMethod(productionWorker, "requestClearAlarm", Qt::QueuedConnection);
if (!submitted)
onAlarmOperationFinished(resetRequested, false, "提交清警/复位请求失败");
});
updateRecoveryButtons();
dialog->open();
clear->setFocus();
}
void DashboardPage::onAlarmOperationBusyChanged(bool busy)
{
if (closing) return;
alarmOperationBusy = busy;
updateRecoveryButtons();
}
void DashboardPage::onAlarmOperationFinished(bool resetRequested, bool success,
const QString &message)
{
if (closing) return;
alarmRequestPending = false;
alarmOperationBusy = false;
if (resetRequested && success) {
loadCurrentOrder();
refreshProcessRecords();
updateProductionStats();
updateRackSummary();
emit productionDataChanged();
}
updateRecoveryButtons();
ui->actionLabel->setText(message);
emit logRequested("报警日志", "控制面板", resetRequested ? "清警并复位" : "清除报警",
message, success ? "成功" : "失败");
QMessageBox *result = new QMessageBox(success ? QMessageBox::Information : QMessageBox::Warning,
resetRequested ? "清警并复位" : "清除报警", message, QMessageBox::Ok, this);
result->setAttribute(Qt::WA_DeleteOnClose);
result->setTextFormat(Qt::PlainText);
result->open();
}
QString DashboardPage::controlOperationContext(QString *identity) const
{
QString error;
Order order;
ProductionRunSnapshot run;
if (currentOrderId > 0
&& !OrderService::instance().findOrder(currentOrderId, &order, &error)) return QString();
const bool active = productionState != ProductionService::Idle
&& productionState != ProductionService::Completed;
if (active && productionSnapshot.runId > 0) {
if (!ProductionRepository().findRun(productionSnapshot.runId, &run, &error))
return QString();
} else if (!ProductionRepository().findActiveRun(&run, &error)) return QString();
if (run.id > 0 && run.orderId != currentOrderId) return QString();
Workpiece piece;
if (run.currentWorkpieceId > 0) {
if (!WorkpieceService::instance().findWorkpiece(run.currentWorkpieceId, &piece, &error)
|| piece.orderId != currentOrderId) return QString();
} else if (order.id > 0) {
const QList<Workpiece> pieces = WorkpieceService::instance().listByOrder(order.id, &error);
if (!error.isEmpty()) return QString();
for (const Workpiece &candidate : pieces) {
if (candidate.state == "PENDING") { piece = candidate; break; }
}
}
int trayNo = 0;
if (piece.trayId > 0) {
const QList<Tray> trays = TrayService::instance().listTrays(&error);
if (!error.isEmpty()) return QString();
for (int i = 0; i < trays.size(); ++i) {
if (trays.at(i).id == piece.trayId) { trayNo = i + 1; break; }
}
}
QString step = piece.processStep;
if (run.currentWorkpieceId <= 0 && piece.id > 0) step = "WAITING_DEVICE_READY";
const QString position = piece.id > 0
? QString("工件:%1\n料盘:%2,格位:%3(第 %4 行,第 %5 列)\n工序:%6")
.arg(piece.barcode).arg(trayNo).arg(piece.trayPos)
.arg((piece.trayPos - 1) / 7 + 1).arg((piece.trayPos - 1) % 7 + 1)
.arg(displayProcessStep(step))
: QString("工件:暂无当前或待加工工件");
QString text = order.id > 0
? QString("订单:%1\n订单状态:%2(%3暂停订单)\n%4")
.arg(order.no, displayOrderStatus(order.status),
order.status == "PAUSED" ? "是" : "不是", position)
: QString("当前没有未完成订单");
if (run.id > 0) {
text += QString("\n生产状态:%1\n动作记录:%2 / %3\n记录的下一工序:%4")
.arg(displayState(run.productionState), displayRecoveryAction(run.action.type),
displayActionPhase(run.action.phase), displayProcessStep(run.action.nextStep));
} else if (piece.id > 0) {
text += "\n开始步骤:等待设备就绪 → 移动到拍照位置";
}
// Exclude elapsed time: only changes affecting the confirmed operation invalidate it.
const QJsonObject snapshot{
{"order", order.id}, {"status", order.status}, {"run", run.id},
{"state", int(productionState)}, {"run_state", run.productionState},
{"piece", piece.id}, {"tray", trayNo}, {"slot", piece.trayPos}, {"step", step},
{"token", run.action.token}, {"attempt", run.action.attempt},
{"version", run.action.version}, {"phase", run.action.phase},
{"next", run.action.nextStep}, {"busy", recoveryBusy},
{"vision_recovery", visionRecoveryRequired}};
if (identity) *identity = QString::fromUtf8(QJsonDocument(snapshot).toJson(QJsonDocument::Compact));
return text;
}
bool DashboardPage::confirmControlOperation(const QString &title, const QString &effect)
{
if (controlConfirmationOpen || alarmContextPending || alarmDialog
|| alarmRequestPending || alarmOperationBusy || productionSnapshot.resetInProgress) return false;
QString identity;
const QString context = controlOperationContext(&identity);
if (context.isEmpty()) {
QMessageBox::warning(this, title, "无法读取一致的订单和动作记录,请刷新状态后再操作。");
return false;
}
controlConfirmationOpen = true;
QMessageBox question(QMessageBox::Question, title,
context + "\n\n" + effect + "\n\n是否执行本步操作?",
QMessageBox::Yes | QMessageBox::No, this);
question.setObjectName("controlConfirmation");
question.setTextFormat(Qt::PlainText);
question.button(QMessageBox::Yes)->setText("执行");
question.button(QMessageBox::No)->setText("取消");
question.setDefaultButton(QMessageBox::No);
question.setEscapeButton(QMessageBox::No);
const int answer = question.exec();
controlConfirmationOpen = false;
if (answer != QMessageBox::Yes) return false;
QString currentIdentity;
if (controlOperationContext(&currentIdentity).isEmpty() || currentIdentity != identity) {
QMessageBox::information(this, title, "订单、工件或动作状态已经变化,本次操作未执行,请重新确认。");
return false;
}
return true;
}
void DashboardPage::onProductionSnapshot(const ProductionService::Snapshot &snapshot)
{
productionSnapshot = snapshot;
visionRecoveryRequired = snapshot.visionRecoveryRequired;
onProductionStateChanged(snapshot.state, snapshot.stateName);
if (!snapshot.initialized) {
ui->actionLabel->setText(snapshot.error.isEmpty()
? "正在检查上次生产状态..." : "初始化失败:" + snapshot.error);
} else if (!snapshot.error.isEmpty()) {
ui->actionLabel->setText("生产状态:" + snapshot.error);
}
}
void DashboardPage::onProductionStateChanged(ProductionService::State state,
const QString &name)
{
productionState = state;
if (state == ProductionService::Terminating && recoveryDialog)
recoveryDialog->reject();
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 (recoveryBusy || productionSnapshot.resetRequired || !ui->recoveryButton->isEnabled()) return;
if (!productionSnapshot.initialized) {
onRecoveryBusyChanged(true);
QMetaObject::invokeMethod(productionWorker, "requestRestore", Qt::QueuedConnection);
return;
}
if (!confirmControlOperation("恢复/重试", "先读取设备及动作记录,检查能否安全恢复;状态不明确时再由人工选择。本次确认不保证立即继续生产。")) return;
onRecoveryBusyChanged(true);
ui->actionLabel->setText("正在检查设备状态和动作记录...");
if (!QMetaObject::invokeMethod(productionWorker, "requestRecover",
Qt::QueuedConnection)) {
onRecoveryBusyChanged(false);
onProductionError("提交恢复检查请求失败");
}
}
void DashboardPage::onRecoveryBusyChanged(bool busy)
{
recoveryBusy = busy;
if (!busy && recoveryDialog) recoveryDialog->reject();
updateRecoveryButtons();
}
void DashboardPage::onRecoveryDecisionRequired(const QJsonObject &context)
{
if (closing || !recoveryBusy || recoveryDialog
|| productionSnapshot.resetInProgress) return;
QDialog *dialog = new QDialog(this);
recoveryDialog = dialog;
dialog->setObjectName("recoveryDecisionDialog");
dialog->setWindowTitle("恢复/重试 · 人工核对");
dialog->setAttribute(Qt::WA_DeleteOnClose);
dialog->setWindowModality(Qt::NonModal);
dialog->setMinimumWidth(520);
QVBoxLayout *layout = new QVBoxLayout(dialog);
const auto signalText = [](const QJsonValue &value) {
return value.isBool() ? (value.toBool() ? QString("1") : QString("0"))
: QString("未知");
};
QLabel *details = new QLabel(
QString("订单:%1 工件:%2\n工序:%3\n动作:%4 检查点:%5\n"
"命令:%6 反馈:%7\n原因:%8")
.arg(context.value("order_id").toInt())
.arg(context.value("workpiece_id").toInt())
.arg(displayProcessStep(context.value("process_step").toString()))
.arg(displayRecoveryAction(context.value("action_type").toString()))
.arg(displayActionPhase(context.value("action_phase").toString()))
.arg(signalText(context.value("command")))
.arg(signalText(context.value("feedback")))
.arg(context.value("reason").toString()), dialog);
details->setTextFormat(Qt::PlainText);
details->setWordWrap(true);
details->setTextInteractionFlags(Qt::TextSelectableByMouse);
layout->addWidget(details);
QFormLayout *form = new QFormLayout;
QComboBox *choice = new QComboBox(dialog);
choice->setObjectName("recoveryDecisionChoice");
choice->addItem("请选择处理方式", QString());
const QJsonArray options = context.value("options").toArray();
for (const QJsonValue &option : options) {
const QString code = option.toString();
QString label;
if (code == "ACTION_COMPLETED") label = "确认动作已完成";
else if (code == "ACTION_NOT_EXECUTED") label = "确认动作未执行,重新执行";
else if (code == "RETRY_VISION") label = "重新视觉识别";
else if (code == "NORMAL_PICK") label = "改为普通取料";
else if (code == "UNLOCK_VISION") label = "仅解除视觉遗留锁(不恢复订单)";
else if (code == "RETRY_SLOT_INSPECTION") label = "确认凹槽已清理,重新识别";
if (!label.isEmpty()) choice->addItem(label, code);
}
QLineEdit *operatorName = new QLineEdit(dialog);
operatorName->setObjectName("recoveryOperatorName");
operatorName->setMaxLength(64);
operatorName->setPlaceholderText("填写现场核对人的姓名或工号");
QLineEdit *note = new QLineEdit(dialog);
note->setObjectName("recoveryDecisionNote");
note->setMaxLength(512);
note->setPlaceholderText("记录机器人位置、工件状态等核对情况");
form->addRow("处理方式:", choice);
form->addRow("操作人:", operatorName);
form->addRow("核对备注:", note);
layout->addLayout(form);
QCheckBox *confirmed = new QCheckBox("请先选择处理方式,再完成现场核对", dialog);
confirmed->setObjectName("recoveryFieldConfirmed");
confirmed->setEnabled(false);
layout->addWidget(confirmed);
QDialogButtonBox *buttons = new QDialogButtonBox(
QDialogButtonBox::Ok | QDialogButtonBox::Cancel, dialog);
QPushButton *submit = buttons->button(QDialogButtonBox::Ok);
submit->setText("提交核对结果");
submit->setEnabled(false);
submit->setAutoDefault(false);
QPushButton *cancel = buttons->button(QDialogButtonBox::Cancel);
cancel->setText("暂不处理");
cancel->setDefault(true);
layout->addWidget(buttons);
const auto updateSubmit = [choice, operatorName, confirmed, submit]() {
submit->setEnabled(!choice->currentData().toString().isEmpty()
&& !operatorName->text().trimmed().isEmpty()
&& confirmed->isChecked());
};
connect(choice, QOverload<int>::of(&QComboBox::currentIndexChanged), dialog,
[choice, confirmed, updateSubmit](int) {
const QString code = choice->currentData().toString();
confirmed->setChecked(false);
confirmed->setEnabled(!code.isEmpty());
if (code == "ACTION_COMPLETED")
confirmed->setText("已确认机器人停止、动作已到终点、工件位置正确");
else if (code == "ACTION_NOT_EXECUTED")
confirmed->setText("已确认机器人停止且在原起点,尚未取放或加工");
else if (code == "UNLOCK_VISION")
confirmed->setText("已核对机器人停止、取料状态明确,原订单不再继续");
else if (code == "RETRY_SLOT_INSPECTION")
confirmed->setText("已确认机器人停止,目标凹槽已清理,可以重新识别");
else if (!code.isEmpty())
confirmed->setText("已确认机器人停止在拍照位,RackPick 尚未开始");
else
confirmed->setText("请先选择处理方式,再完成现场核对");
updateSubmit();
});
connect(operatorName, &QLineEdit::textChanged, dialog, updateSubmit);
connect(confirmed, &QCheckBox::toggled, dialog, updateSubmit);
connect(buttons, &QDialogButtonBox::accepted, dialog, &QDialog::accept);
connect(buttons, &QDialogButtonBox::rejected, dialog, &QDialog::reject);
connect(dialog, &QDialog::finished, this,
[this, context, choice, operatorName, note, confirmed](int result) {
recoveryDialog = nullptr;
if (closing || !recoveryBusy) return;
QJsonObject decision = context;
decision.insert("decision", result == QDialog::Accepted
? choice->currentData().toString() : QString("CANCEL"));
decision.insert("operator_name", operatorName->text().trimmed());
decision.insert("note", note->text().trimmed());
decision.insert("field_confirmed", confirmed->isChecked());
emit recoveryDecisionSubmitted(decision);
});
cancel->setFocus();
dialog->show();
updateRecoveryButtons();
}
void DashboardPage::markWorkpieceNg()
{
if (!markNgButton->isEnabled()) return;
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 bool alarmBlocked = closing || alarmContextPending || alarmDialog
|| alarmRequestPending || alarmOperationBusy || productionSnapshot.resetInProgress;
if (recoveryDialog) recoveryDialog->setEnabled(!alarmBlocked);
const bool terminating = productionState == ProductionService::Terminating;
if (!productionSnapshot.initialized) {
ui->startButton->setEnabled(false);
ui->pauseButton->setEnabled(false);
stopButton->setEnabled(false);
ui->clearAlarmButton->setEnabled(!alarmBlocked && !terminating);
markNgButton->setEnabled(false);
ui->recoveryButton->setEnabled(!productionSnapshot.error.isEmpty() && !recoveryBusy
&& !alarmBlocked && !productionSnapshot.resetRequired);
ui->recoveryButton->setText("重新检查生产状态");
return;
}
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 canStart = (((state == ProductionService::Idle
|| state == ProductionService::Completed)
&& currentOrderStartable)
|| (state == ProductionService::Paused
&& currentOrderResumable))
&& !visionRecoveryRequired && !recoveryBusy && !alarmBlocked;
ui->startButton->setEnabled(canStart);
ui->startButton->setToolTip(visionRecoveryRequired
? "上次视觉任务尚未清理,请先解除视觉遗留锁或恢复/终止当前任务" : QString());
ui->startButton->setText(state == ProductionService::Paused
? "继续" : "启动");
ui->recoveryButton->setVisible(true);
ui->recoveryButton->setEnabled(recoveryRequired && !terminating && !recoveryBusy && !alarmBlocked
&& !productionSnapshot.terminationRequired && !productionSnapshot.resetRequired);
ui->recoveryButton->setText(recoveryBusy ? "恢复检查中..."
: state == ProductionService::Idle && visionRecoveryRequired
? "解除视觉遗留锁" : "恢复/重试");
ui->pauseButton->setEnabled(running && !recoveryRequired
&& state != ProductionService::Paused
&& !recoveryBusy && !terminating && !alarmBlocked);
ui->clearAlarmButton->setEnabled(!terminating && !alarmBlocked);
markNgButton->setVisible(recoveryRequired
&& productionWorkpiece.id > 0 && !visionRecoveryRequired);
markNgButton->setEnabled(!recoveryBusy && !terminating && !alarmBlocked
&& !productionSnapshot.terminationRequired);
stopButton->setVisible(true);
stopButton->setEnabled(currentOrderId > 0 && !terminating && !alarmBlocked);
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)
{
deviceStatus = status;
emit deviceStatusChanged(status);
const bool offline = !status.statusValid || !status.plcConnected;
const QString plcText = offline ? "离线" : "就绪";
const QString robotText = offline ? "离线"
: status.emergencyStop ? "急停"
: status.robotAlarm ? "报警"
: status.robotRunning ? "运行中"
: status.robotIdle ? "空闲" : "未就绪";
const QString safetyText = offline ? "离线"
: status.safetyDoorClosed ? "正常" : "异常";
const QString emergencyText = offline ? "离线"
: status.emergencyStop ? "已触发" : "正常";
deviceStatusLabel->setText(
QString("PLC:%1 | 机器人:%2 | 安全回路:%3 | 急停:%4")
.arg(plcText)
.arg(robotText)
.arg(safetyText)
.arg(emergencyText));
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),
offline ? "#607d8b"
: status.emergencyStop || status.robotAlarm
? "#d32f2f"
: status.robotRunning || status.robotIdle
? "#2e7d32" : "#d32f2f");
updateStatusCell(robotControlCabinetCell,
QString("机器人控制柜\n%1").arg(
offline ? "离线" : "就绪"),
offline ? "#607d8b" : "#2e7d32");
updateStatusCell(mainControlCabinetCell,
QString("总控柜\n%1").arg(
offline ? "离线" : "就绪"),
offline ? "#607d8b" : "#2e7d32");
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(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 bool sensorAvailable = deviceStatus.statusValid
&& deviceStatus.plcConnected;
const bool present = !sensorAvailable || deviceStatus.trayPresent[index];
if (!present) {
updateStatusCell(cell,
QString("托盘 %1\n不在位:0/49").arg(index + 1),
"#90a4ae",
highlightedTrayIds.contains(tray.id));
continue;
}
const QString status = tray.status;
const QString statusText = status == "OK" ? "已完成"
: status == "NG" ? "有 NG"
: status == "PROCESSING" ? "加工中"
: status == "PENDING" ? "待检测"
: "有托盘";
const QString color = 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;
const bool active = productionSnapshot.orderId > 0
&& productionState != ProductionService::Idle
&& productionState != ProductionService::Completed;
const bool loaded = active
? OrderService::instance().findOrder(productionSnapshot.orderId, &order, &error)
: OrderService::instance().findUnfinishedOrder(&order, &error);
if (!loaded) {
currentOrderId = active ? productionSnapshot.orderId : 0;
selectedOrderId = 0;
currentOrderStartable = false;
currentOrderResumable = false;
ui->orderLabel->setText(active
? QString("当前生产订单 %1:记录缺失或读取失败,请核对").arg(currentOrderId)
: QString("当前订单:读取失败"));
updateRecoveryButtons();
updateProductionStats();
updateRackSummary();
emit logRequested("操作日志", "控制面板", "加载订单",
error, "失败");
return;
}
currentOrderId = order.id;
selectedOrderId = active ? 0 : 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,%3)")
.arg(order.no)
.arg(displayOrderStatus(order.status))
.arg(displayInspectionMode(order.inspectionMode)));
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));
}