#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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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"); productionWorker->moveToThread(productionThread); connect(productionThread, &QThread::finished, productionWorker, &QObject::deleteLater); connect(productionWorker, &ProductionWorker::shutdownReady, productionThread, &QThread::quit, Qt::DirectConnection); const QList values = QList() << 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() << 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() << 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 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 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(¤tIdentity).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::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 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( 0, nowMs - record.startedAt.toMSecsSinceEpoch()); durationMs = static_cast( qMin(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 trays = TrayService::instance().listTrays(&error); QSet highlightedTrayIds; if (error.isEmpty() && currentOrderId > 0) { QString workpieceError; const QList 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 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 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)); }