From 4046471c1a36fd9197fcdff276663bf657e92aac Mon Sep 17 00:00:00 2001 From: lidg Date: Thu, 29 Oct 2026 21:12:15 +0800 Subject: [PATCH] =?UTF-8?q?feat(production):=20=E6=8C=81=E4=B9=85=E5=8C=96?= =?UTF-8?q?=E5=8A=A8=E4=BD=9C=E6=A3=80=E6=9F=A5=E7=82=B9=E5=B9=B6=E5=AE=8C?= =?UTF-8?q?=E5=96=84=E6=81=A2=E5=A4=8D=E9=87=8D=E8=AF=95=E6=B5=81=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - production_runs 新增动作阶段、尝试次数、版本及人工确认字段 - 提供兼容 PostgreSQL 9.5 的幂等升级脚本和数据库结构检查 - 工序推进、动作完成检查点和审计记录使用同一事务 - 机器人命令单次发送,完成反馈先持久化再清握手 - 已完成动作恢复仅补握手或数据库记录,避免重复执行 - 恢复/重试按钮固定显示在清除报警前,加入明确人工处理选项 - 记录人工决定、操作人及现场核对信息,拒绝过期确认 - 区分普通暂停继续、故障恢复与终止后的视觉锁解除 - 补齐视觉目标跨重启校验、异步失败及迟到回调防护 - 检测结果关联动作和尝试次数,重试清除旧结果缓存 --- db/schema.sql | 111 ++ pages/dashboardpage.cpp | 206 +++- pages/dashboardpage.h | 7 + pages/dashboardpage.ui | 2 +- repositories/productionrepository.cpp | 220 +++- repositories/productionrepository.h | 30 +- services/deviceservice.cpp | 139 ++- services/deviceservice.h | 7 +- services/productionservice.cpp | 1629 ++++++++++++++++--------- services/productionservice.h | 41 +- services/productionworker.cpp | 11 + services/productionworker.h | 3 + services/workpieceservice.cpp | 7 +- services/workpieceservice.h | 7 +- ssp.pro.user | 2 +- 15 files changed, 1763 insertions(+), 659 deletions(-) diff --git a/db/schema.sql b/db/schema.sql index 0f9fb3e..1f5d7fe 100644 --- a/db/schema.sql +++ b/db/schema.sql @@ -177,6 +177,117 @@ on production_runs(order_id); create index if not exists ix_production_runs_workpiece_id on production_runs(current_workpiece_id); +-- Independent action recovery checkpoints (PostgreSQL 9.5 compatible). +-- Keep NULL phases for historical rows: NULL does not mean NOT_SENT. +do $$ +declare + target_table regclass := 'production_runs'::regclass; + col record; +begin + for col in + select * + from (values + ('action_token', 'varchar(64)'), + ('action_type', 'varchar(32)'), + ('action_phase', 'varchar(32)'), + ('action_next_step', 'varchar(64)'), + ('action_attempt', 'integer not null default 0'), + ('action_lock_version', 'integer not null default 0'), + ('action_command_value', 'boolean'), + ('action_feedback_value', 'boolean'), + ('manual_decision', 'varchar(32)'), + ('manual_operator', 'varchar(64)'), + ('manual_decided_at', 'timestamp'), + ('action_updated_at', 'timestamp') + ) as columns_to_add(column_name, column_type) + loop + if not exists ( + select 1 from pg_attribute + where attrelid = target_table + and attname = col.column_name + and attnum > 0 and not attisdropped + ) then + execute 'alter table ' || target_table::text || + ' add column ' || quote_ident(col.column_name) || + ' ' || col.column_type; + end if; + end loop; +end; +$$ language plpgsql; + +comment on column production_runs.action_token + is '当前独立动作唯一标识;NULL表示尚无持久化动作检查点'; +comment on column production_runs.action_type + is '当前独立动作类型'; +comment on column production_runs.action_phase + is '当前动作持久化阶段;NULL表示未知,不可直接认定为未发送'; +comment on column production_runs.action_next_step + is '当前动作完成后待提交的下一工序'; +comment on column production_runs.action_attempt + is '当前动作尝试次数'; +comment on column production_runs.action_lock_version + is '动作检查点乐观锁版本号'; +comment on column production_runs.action_command_value + is '最近一次成功读取的动作命令值;NULL表示未知,恢复前必须重新读取PLC'; +comment on column production_runs.action_feedback_value + is '最近一次成功读取的动作反馈值;NULL表示未知,恢复前必须重新读取PLC'; +comment on column production_runs.manual_decision + is '当前动作最近一次人工确认决定;完整历史记录在production_state_history'; +comment on column production_runs.manual_operator + is '当前动作最近一次人工确认操作人'; +comment on column production_runs.manual_decided_at + is '当前动作最近一次人工确认时间'; +comment on column production_runs.action_updated_at + is '当前动作检查点更新时间,由应用程序写入'; + +do $$ +declare + target_table regclass := 'production_runs'::regclass; +begin + if not exists ( + select 1 from pg_class i + join pg_class t on t.relnamespace = i.relnamespace + where t.oid = target_table + and i.relname = 'ux_production_runs_action_token' + ) then + create unique index ux_production_runs_action_token + on production_runs(action_token) + where action_token is not null; + end if; +end; +$$ language plpgsql; + +do $$ +declare + target_table regclass := 'production_runs'::regclass; + rule record; +begin + for rule in + select * + from (values + ('ck_production_runs_action_type', + 'action_type is null or action_type in (''PHOTO_MOVE'', ''VISION'', ''RACK_PICK'', ''FRONT_LOAD'', ''INSPECT'', ''FRONT_UNLOAD'', ''FLIP'', ''BACK_LOAD'', ''BACK_UNLOAD'', ''RACK_PLACE'')'), + ('ck_production_runs_action_phase', + 'action_phase is null or action_phase in (''NOT_SENT'', ''SENDING'', ''COMMAND_CONFIRMED'', ''FEEDBACK_RECEIVED'', ''SIGNALS_CLEARED'', ''STEP_COMMITTED'', ''RESULT_WRITING'', ''RESULT_CONFIRMED'', ''MODE_WRITING'', ''MODE_CONFIRMED'')'), + ('ck_production_runs_manual_decision', + 'manual_decision is null or manual_decision in (''ACTION_COMPLETED'', ''ACTION_NOT_EXECUTED'', ''RETRY_VISION'', ''NORMAL_PICK'')'), + ('ck_production_runs_action_attempt', 'action_attempt >= 0'), + ('ck_production_runs_action_lock_version', 'action_lock_version >= 0') + ) as constraints_to_add(constraint_name, check_expression) + loop + if not exists ( + select 1 from pg_constraint + where conrelid = target_table + and conname = rule.constraint_name + ) then + execute 'alter table ' || target_table::text || + ' add constraint ' || quote_ident(rule.constraint_name) || + ' check (' || rule.check_expression || ')'; + end if; + end loop; +end; +$$ language plpgsql; + -- Production state history create table if not exists production_state_history ( id bigserial primary key, diff --git a/pages/dashboardpage.cpp b/pages/dashboardpage.cpp index b2ff0a4..1427a62 100644 --- a/pages/dashboardpage.cpp +++ b/pages/dashboardpage.cpp @@ -8,14 +8,20 @@ #include "uihelpers.h" #include "../services/visionservice.h" #include +#include #include #include +#include +#include +#include +#include #include #include #include #include #include +#include #include #include #include @@ -66,6 +72,36 @@ 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 == "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 "执行中"; @@ -138,6 +174,7 @@ DashboardPage::DashboardPage(QWidget *parent) , productionSlotNo(0) { ui->setupUi(this); + qRegisterMetaType("QJsonObject"); productionWorker->moveToThread(productionThread); connect(productionThread, &QThread::finished, @@ -154,10 +191,11 @@ DashboardPage::DashboardPage(QWidget *parent) ui->startButton->setObjectName("primaryButton"); ui->nextButton->setVisible(false); - ui->recoveryButton->setVisible(false); + ui->recoveryButton->setEnabled(false); markNgButton->setObjectName("recoveryNgButton"); markNgButton->setVisible(false); - ui->buttonLayout->insertWidget(4, markNgButton); + ui->buttonLayout->insertWidget(ui->buttonLayout->indexOf(ui->recoveryButton), + markNgButton); stopButton->setObjectName("stopButton"); stopButton->setVisible(false); ui->buttonLayout->insertWidget(6, stopButton); @@ -267,6 +305,13 @@ DashboardPage::DashboardPage(QWidget *parent) 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(this, &DashboardPage::recoveryDecisionSubmitted, + productionWorker, &ProductionWorker::requestRecoveryDecision, + Qt::QueuedConnection); connect(productionWorker, &ProductionWorker::deviceStatusChanged, this, &DashboardPage::onDeviceStatusChanged); connect(productionWorker, &ProductionWorker::deviceCommunicationError, @@ -291,6 +336,8 @@ DashboardPage::DashboardPage(QWidget *parent) DashboardPage::~DashboardPage() { + recoveryBusy = false; + if (recoveryDialog) recoveryDialog->reject(); if (productionThread->isRunning()) { productionWorker->requestStopImmediate(); QMetaObject::invokeMethod(productionWorker, "requestShutdown", @@ -302,7 +349,6 @@ DashboardPage::~DashboardPage() void DashboardPage::attachVisionService(VisionService *service) { - qRegisterMetaType("QJsonObject"); connect(productionWorker, &ProductionWorker::visionMeasureRequested, service, &VisionService::measure, Qt::QueuedConnection); connect(productionWorker, &ProductionWorker::visionCancelRequested, @@ -376,6 +422,7 @@ void DashboardPage::updateRackSize() void DashboardPage::startProduction() { + if (recoveryBusy || visionRecoveryRequired) return; if (productionState == ProductionService::Paused) { if (!currentOrderResumable) return; ui->startButton->setEnabled(false); @@ -414,6 +461,7 @@ void DashboardPage::pauseProduction() void DashboardPage::stopProduction() { productionWorker->requestStopImmediate(); + if (recoveryDialog) recoveryDialog->reject(); QMetaObject::invokeMethod(productionWorker, "requestStop", Qt::QueuedConnection); } @@ -430,6 +478,8 @@ 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(); @@ -518,19 +568,137 @@ void DashboardPage::onRecoveryCompleted(const QString &mode) void DashboardPage::recoverProduction() { - if ((productionState == ProductionService::ManualConfirm || visionRecoveryRequired) - && QMessageBox::question( - this, "继续生产", - visionRecoveryRequired - ? "请先核对机器人当前位置及本次取料是否已执行或撤销,并确认 M850 移动请求和 M851 到位反馈已复位。恢复不会清除 M852,也不会重发旧坐标。是否已完成现场核对?" - : "当前动作是否执行无法自动确认。请核对机器人位置、工件状态及对应命令/反馈信号,确认现场状态安全后再继续。", - QMessageBox::Yes | QMessageBox::No, QMessageBox::No) - != QMessageBox::Yes) { - return; + if (recoveryBusy || !ui->recoveryButton->isEnabled()) return; + onRecoveryBusyChanged(true); + ui->actionLabel->setText("正在检查设备状态和动作记录..."); + if (!QMetaObject::invokeMethod(productionWorker, "requestRecover", + Qt::QueuedConnection)) { + onRecoveryBusyChanged(false); + onProductionError("提交恢复检查请求失败"); } +} - QMetaObject::invokeMethod(productionWorker, "requestRecover", - Qt::QueuedConnection); +void DashboardPage::onRecoveryBusyChanged(bool busy) +{ + recoveryBusy = busy; + if (!busy && recoveryDialog) recoveryDialog->reject(); + updateRecoveryButtons(); +} + +void DashboardPage::onRecoveryDecisionRequired(const QJsonObject &context) +{ + if (!recoveryBusy || recoveryDialog) return; + + QDialog *dialog = new QDialog(this); + recoveryDialog = dialog; + dialog->setObjectName("recoveryDecisionDialog"); + dialog->setWindowTitle("恢复/重试 · 人工核对"); + dialog->setAttribute(Qt::WA_DeleteOnClose); + dialog->setWindowModality(Qt::WindowModal); + 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 = "仅解除视觉遗留锁(不恢复订单)"; + 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.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 (!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->open(); } void DashboardPage::markWorkpieceNg() @@ -561,14 +729,18 @@ void DashboardPage::updateRecoveryButtons() && currentOrderStartable) || (state == ProductionService::Paused && currentOrderResumable)) - && !visionRecoveryRequired; + && !visionRecoveryRequired && !recoveryBusy; ui->startButton->setEnabled(canStart); ui->startButton->setText(state == ProductionService::Paused ? "继续" : "启动"); - ui->recoveryButton->setVisible(recoveryRequired); - ui->recoveryButton->setEnabled(!terminating); + ui->recoveryButton->setVisible(true); + ui->recoveryButton->setEnabled(recoveryRequired && !terminating && !recoveryBusy); + ui->recoveryButton->setText(recoveryBusy ? "恢复检查中..." : "恢复/重试"); + ui->pauseButton->setEnabled(!recoveryBusy && !terminating); + ui->clearAlarmButton->setEnabled(!recoveryBusy && !terminating); markNgButton->setVisible(recoveryRequired && productionWorkpiece.id > 0 && !visionRecoveryRequired); + markNgButton->setEnabled(!recoveryBusy && !terminating); stopButton->setVisible(running); stopButton->setEnabled(!terminating); stopButton->setText(terminating ? "终止中..." : "终止"); diff --git a/pages/dashboardpage.h b/pages/dashboardpage.h index bb9c54f..9c61461 100644 --- a/pages/dashboardpage.h +++ b/pages/dashboardpage.h @@ -5,6 +5,7 @@ #include #include +#include class QTableWidget; class QGroupBox; @@ -14,6 +15,7 @@ class QPushButton; class QTimer; class QThread; class VisionService; +class QDialog; namespace Ui { class DashboardPage; } @@ -37,6 +39,7 @@ signals: void deviceCommunicationError(const QString &error); void visionCycleChanged(const QJsonObject &cycle); void visionProductionActiveChanged(bool active, bool maintenanceAllowed); + void recoveryDecisionSubmitted(const QJsonObject &decision); void logRequested(const QString &type, const QString &module, const QString &action, const QString &content, const QString &status); @@ -57,6 +60,8 @@ private slots: void onTimeoutRecoveryRequired(const QString &state, const QString &message); void onRecoveryCompleted(const QString &mode); void recoverProduction(); + void onRecoveryDecisionRequired(const QJsonObject &context); + void onRecoveryBusyChanged(bool busy); void markWorkpieceNg(); protected: @@ -103,6 +108,8 @@ private: int productionTrayNo; int productionSlotNo; bool visionRecoveryRequired = false; + bool recoveryBusy = false; + QPointer recoveryDialog; }; #endif // DASHBOARDPAGE_H diff --git a/pages/dashboardpage.ui b/pages/dashboardpage.ui index 3263c99..ca234b8 100644 --- a/pages/dashboardpage.ui +++ b/pages/dashboardpage.ui @@ -116,8 +116,8 @@ 启动 暂停 - 恢复/重试 下一步 + 恢复/重试 清除报警 diff --git a/repositories/productionrepository.cpp b/repositories/productionrepository.cpp index 8ae2f8b..3581d29 100644 --- a/repositories/productionrepository.cpp +++ b/repositories/productionrepository.cpp @@ -5,6 +5,8 @@ #include #include #include +#include +#include namespace { @@ -145,11 +147,7 @@ bool ProductionRepository::findActiveRun(ProductionRunSnapshot *run, QString *er } QSqlQuery query(DatabaseManager::instance().database()); - query.prepare("select id, order_id, current_workpiece_id, plan_num, " - "start_tray_no, start_slot_no, inspection_mode, run_state, " - "production_state, process_step, timeout_state, " - "recovery_retry_count, last_error " - "from production_runs " + query.prepare("select * from production_runs " "where run_state in ('RUNNING', 'PAUSED', 'RECOVERY') " "order by id desc limit 1"); if (!query.exec()) { @@ -174,13 +172,218 @@ bool ProductionRepository::findActiveRun(ProductionRunSnapshot *run, QString *er run->timeoutState = query.value("timeout_state").toString(); run->recoveryRetryCount = query.value("recovery_retry_count").toInt(); run->lastError = query.value("last_error").toString(); + run->action.token = query.value("action_token").toString(); + run->action.type = query.value("action_type").toString(); + run->action.phase = query.value("action_phase").toString(); + run->action.nextStep = query.value("action_next_step").toString(); + run->action.attempt = query.value("action_attempt").toInt(); + run->action.version = query.value("action_lock_version").toInt(); + run->action.command = query.value("action_command_value"); + run->action.feedback = query.value("action_feedback_value"); + run->action.manualDecision = query.value("manual_decision").toString(); + run->action.manualOperator = query.value("manual_operator").toString(); + run->action.manualDecidedAt = query.value("manual_decided_at").toDateTime(); return true; } +bool ProductionRepository::findRun(int runId, ProductionRunSnapshot *run, QString *error) +{ + if (!run || !ensureOpen(error)) return false; + QSqlQuery query(DatabaseManager::instance().database()); + query.prepare("select * from production_runs where id = :id"); + query.bindValue(":id", runId); + if (!query.exec()) { setError(query, error); return false; } + if (!query.next()) { if (error) *error = "Production run no longer exists"; return false; } + run->id = query.value("id").toInt(); + run->orderId = query.value("order_id").toInt(); + run->currentWorkpieceId = query.value("current_workpiece_id").toInt(); + run->planNum = query.value("plan_num").toInt(); + run->startTrayNo = query.value("start_tray_no").toInt(); + run->startSlotNo = query.value("start_slot_no").toInt(); + run->inspectionMode = query.value("inspection_mode").toString(); + run->runState = query.value("run_state").toString(); + run->productionState = query.value("production_state").toString(); + run->processStep = query.value("process_step").toString(); + run->timeoutState = query.value("timeout_state").toString(); + run->recoveryRetryCount = query.value("recovery_retry_count").toInt(); + run->lastError = query.value("last_error").toString(); + run->action.token = query.value("action_token").toString(); + run->action.type = query.value("action_type").toString(); + run->action.phase = query.value("action_phase").toString(); + run->action.nextStep = query.value("action_next_step").toString(); + run->action.attempt = query.value("action_attempt").toInt(); + run->action.version = query.value("action_lock_version").toInt(); + run->action.command = query.value("action_command_value"); + run->action.feedback = query.value("action_feedback_value"); + run->action.manualDecision = query.value("manual_decision").toString(); + run->action.manualOperator = query.value("manual_operator").toString(); + run->action.manualDecidedAt = query.value("manual_decided_at").toDateTime(); + return true; +} + +bool ProductionRepository::checkActionSchema(QString *error) +{ + if (!ensureOpen(error)) return false; + QSqlQuery query(DatabaseManager::instance().database()); + query.prepare("select action_token, action_type, action_phase, action_next_step, " + "action_attempt, action_lock_version, action_command_value, action_feedback_value, " + "manual_decision, manual_operator, manual_decided_at, action_updated_at " + "from production_runs where 1 = 0"); + if (!query.exec()) { + if (error) *error = "请先执行 db/migrations/2026-10-29-production-action-checkpoints.sql:" + query.lastError().text(); + return false; + } + if (DatabaseManager::instance().database().driverName() != "QPSQL") return true; + const QMap expectedTypes = { + {"action_token", "character varying(64)"}, + {"action_type", "character varying(32)"}, + {"action_phase", "character varying(32)"}, + {"action_next_step", "character varying(64)"}, + {"action_attempt", "integer"}, + {"action_lock_version", "integer"}, + {"action_command_value", "boolean"}, + {"action_feedback_value", "boolean"}, + {"manual_decision", "character varying(32)"}, + {"manual_operator", "character varying(64)"}, + {"manual_decided_at", "timestamp without time zone"}, + {"action_updated_at", "timestamp without time zone"} + }; + query.prepare("select a.attname, format_type(a.atttypid,a.atttypmod), a.attnotnull, " + "pg_get_expr(d.adbin,d.adrelid) from pg_attribute a " + "left join pg_attrdef d on d.adrelid=a.attrelid and d.adnum=a.attnum " + "where a.attrelid='production_runs'::regclass and a.attnum>0 and not a.attisdropped"); + if (!query.exec()) { setError(query, error); return false; } + int checked = 0; + while (query.next()) { + const QString name = query.value(0).toString(); + if (!expectedTypes.contains(name)) continue; + const bool counter = name == "action_attempt" || name == "action_lock_version"; + if (query.value(1).toString() != expectedTypes.value(name) + || query.value(2).toBool() != counter + || (counter && query.value(3).toString() != "0")) { + if (error) *error = "动作恢复字段类型、空值或默认值不匹配:" + name; + return false; + } + ++checked; + } + if (checked != expectedTypes.size()) { + if (error) *error = "动作恢复数据库字段不完整"; + return false; + } + const QMap expectedChecks = { + {"ck_production_runs_action_type", "CHECK (action_type IS NULL OR action_type = ANY ARRAY['PHOTO_MOVE','VISION','RACK_PICK','FRONT_LOAD','INSPECT','FRONT_UNLOAD','FLIP','BACK_LOAD','BACK_UNLOAD','RACK_PLACE'])"}, + {"ck_production_runs_action_phase", "CHECK (action_phase IS NULL OR action_phase = ANY ARRAY['NOT_SENT','SENDING','COMMAND_CONFIRMED','FEEDBACK_RECEIVED','SIGNALS_CLEARED','STEP_COMMITTED','RESULT_WRITING','RESULT_CONFIRMED','MODE_WRITING','MODE_CONFIRMED'])"}, + {"ck_production_runs_manual_decision", "CHECK (manual_decision IS NULL OR manual_decision = ANY ARRAY['ACTION_COMPLETED','ACTION_NOT_EXECUTED','RETRY_VISION','NORMAL_PICK'])"}, + {"ck_production_runs_action_attempt", "CHECK (action_attempt >= 0)"}, + {"ck_production_runs_action_lock_version", "CHECK (action_lock_version >= 0)"} + }; + auto normalizedCheck = [](QString definition) { + definition.remove(QRegularExpression("::(?:character varying|text)(?:\\[\\])?")); + definition.remove(QRegularExpression("[\\s()\\[\\]]")); + return definition; + }; + query.prepare("select conname, pg_get_constraintdef(oid) from pg_constraint " + "where conrelid='production_runs'::regclass and contype='c' and convalidated"); + if (!query.exec()) { setError(query, error); return false; } + checked = 0; + while (query.next()) { + const QString name = query.value(0).toString(); + if (!expectedChecks.contains(name)) continue; + if (normalizedCheck(query.value(1).toString()) != normalizedCheck(expectedChecks.value(name))) { + if (error) *error = "动作恢复约束定义不匹配:" + name; + return false; + } + ++checked; + } + if (checked != expectedChecks.size()) { + if (error) *error = "动作恢复数据库约束不完整,请执行检查点升级 SQL"; + return false; + } + query.prepare("select count(*) from pg_index i join pg_attribute a " + "on a.attrelid=i.indrelid and a.attnum=i.indkey[0] " + "where i.indrelid='production_runs'::regclass and i.indisunique and i.indisvalid " + "and i.indnatts=1 and a.attname='action_token' " + "and pg_get_expr(i.indpred,i.indrelid)='(action_token IS NOT NULL)'"); + if (!query.exec() || !query.next() || query.value(0).toInt() < 1) { + if (error) *error = "动作恢复唯一索引不完整,请执行检查点升级 SQL"; + return false; + } + return true; +} + +bool ProductionRepository::saveActionCheckpoint(int runId, int orderId, int workpieceId, + ProductionActionCheckpoint *action, QString *error) +{ + if (!action || !ensureOpen(error)) return false; + QSqlQuery query(DatabaseManager::instance().database()); + query.prepare("update production_runs set action_token=:token, action_type=:type, " + "action_phase=:phase, action_next_step=:next, action_attempt=:attempt, " + "action_lock_version=action_lock_version+1, action_command_value=:command, " + "action_feedback_value=:feedback, manual_decision=:decision, manual_operator=:operator, " + "manual_decided_at=:decided, action_updated_at=now(), updated_at=now() " + "where id=:id and order_id=:order_id and current_workpiece_id is not distinct from :workpiece " + "and action_lock_version=:version"); + query.bindValue(":token", action->token); + query.bindValue(":type", action->type); + query.bindValue(":phase", action->phase); + query.bindValue(":next", action->nextStep); + query.bindValue(":attempt", action->attempt); + query.bindValue(":command", action->command.isNull() ? QVariant(QVariant::Bool) : action->command); + query.bindValue(":feedback", action->feedback.isNull() ? QVariant(QVariant::Bool) : action->feedback); + query.bindValue(":decision", action->manualDecision); + query.bindValue(":operator", action->manualOperator); + query.bindValue(":decided", action->manualDecidedAt.isValid() ? QVariant(action->manualDecidedAt) : QVariant(QVariant::DateTime)); + query.bindValue(":id", runId); + query.bindValue(":order_id", orderId); + query.bindValue(":workpiece", nullableId(workpieceId)); + query.bindValue(":version", action->version); + if (!query.exec()) { setError(query, error); return false; } + if (query.numRowsAffected() != 1) { + if (error) *error = "动作检查点已改变,请重新读取恢复状态"; + return false; + } + ++action->version; + return true; +} + +bool ProductionRepository::findInspectionResult(int workpieceId, const QString &side, + int *rawResult, QString *resultState, QString *error, + const QString &actionToken, int actionAttempt) +{ + if (!rawResult || !resultState || (side != "FRONT" && side != "BACK")) { + if (error) *error = "Invalid inspection result request"; + return false; + } + if (!ensureOpen(error)) return false; + QSqlQuery query(DatabaseManager::instance().database()); + QString sql = "select raw_result, result_state from inspection_records " + "where workpiece_id=:id and inspection_side=:side and inspection_state='COMPLETED' " + "and created_at >= (select started_at from workpiece_process_records " + "where workpiece_id=:id and process_step=:step order by attempt_no desc limit 1) "; + if (!actionToken.isEmpty()) sql += "and message=:action_message "; + sql += "order by attempt_no desc limit 1"; + query.prepare(sql); + query.bindValue(":id", workpieceId); + query.bindValue(":side", side); + query.bindValue(":step", side == "FRONT" ? "FRONT_CHECKING" : "BACK_CHECKING"); + if (!actionToken.isEmpty()) + query.bindValue(":action_message", "action=" + actionToken + ";attempt=" + QString::number(actionAttempt)); + if (!query.exec()) { setError(query, error); return false; } + if (!query.next()) { if (error) *error = "检测结果尚未持久化,不能认定检测完成"; return false; } + if (query.value(0).isNull()) { + if (error) *error = "检测结果为空,不能认定检测完成"; + return false; + } + *rawResult = query.value(0).toInt(); + *resultState = query.value(1).toString(); + return *resultState == "OK" || *resultState == "NG"; +} + bool ProductionRepository::insertStateHistory( int runId, int orderId, int workpieceId, const QString &fromState, const QString &toState, const QString &processStep, const QString &source, - const QString &reason, const QString &message, QString *error) + const QString &reason, const QString &message, QString *error, + const QString &operatorName) { if (!ensureOpen(error)) { return false; @@ -189,9 +392,9 @@ bool ProductionRepository::insertStateHistory( QSqlQuery query(DatabaseManager::instance().database()); query.prepare("insert into production_state_history " "(production_run_id, order_id, workpiece_id, from_state, " - "to_state, process_step, source, reason, message) " + "to_state, process_step, source, reason, message, operator_name) " "values (:run_id, :order_id, :workpiece_id, :from_state, " - ":to_state, :process_step, :source, :reason, :message)"); + ":to_state, :process_step, :source, :reason, :message, :operator)"); query.bindValue(":run_id", nullableId(runId)); query.bindValue(":order_id", nullableId(orderId)); query.bindValue(":workpiece_id", nullableId(workpieceId)); @@ -201,6 +404,7 @@ bool ProductionRepository::insertStateHistory( query.bindValue(":source", source); query.bindValue(":reason", reason); query.bindValue(":message", message); + query.bindValue(":operator", operatorName); if (!query.exec()) { setError(query, error); return false; diff --git a/repositories/productionrepository.h b/repositories/productionrepository.h index 4868a37..0ba50ad 100644 --- a/repositories/productionrepository.h +++ b/repositories/productionrepository.h @@ -4,6 +4,22 @@ #include #include #include +#include + +struct ProductionActionCheckpoint +{ + QString token; + QString type; + QString phase; + QString nextStep; + int attempt = 0; + int version = 0; + QVariant command; + QVariant feedback; + QString manualDecision; + QString manualOperator; + QDateTime manualDecidedAt; +}; struct ProductionRunSnapshot { @@ -20,6 +36,7 @@ struct ProductionRunSnapshot QString timeoutState; int recoveryRetryCount = 0; QString lastError; + ProductionActionCheckpoint action; }; struct WorkpieceProcessRecord @@ -50,12 +67,23 @@ public: QString *error = nullptr); bool heartbeatRun(int runId, QString *error = nullptr); bool findActiveRun(ProductionRunSnapshot *run, QString *error = nullptr); + bool findRun(int runId, ProductionRunSnapshot *run, QString *error = nullptr); + bool checkActionSchema(QString *error = nullptr); + bool saveActionCheckpoint(int runId, int orderId, int workpieceId, + ProductionActionCheckpoint *action, + QString *error = nullptr); + bool findInspectionResult(int workpieceId, const QString &side, + int *rawResult, QString *resultState, + QString *error = nullptr, + const QString &actionToken = QString(), + int actionAttempt = 0); bool insertStateHistory(int runId, int orderId, int workpieceId, const QString &fromState, const QString &toState, const QString &processStep, const QString &source, const QString &reason, const QString &message, - QString *error = nullptr); + QString *error = nullptr, + const QString &operatorName = QString()); bool startWorkpieceProcess(int orderId, int workpieceId, const QString &processStep, diff --git a/services/deviceservice.cpp b/services/deviceservice.cpp index 7c291d7..708e452 100644 --- a/services/deviceservice.cpp +++ b/services/deviceservice.cpp @@ -523,35 +523,37 @@ void DeviceService::finishTermination(bool success, const QString &error) void DeviceService::beginProductionAction( ProductionAction action, int trayNo, int slotNo, - const OperationCallback &callback, const std::function &beforeSend) + const VisionWriteCallback &callback, const std::function &beforeSend) { if (m_terminationActive) { if (callback) { - callback(false, "PLC termination is in progress"); + callback(VisionWriteOutcome::NotSent, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { + const bool permitted = !beforeSend || beforeSend(); if (callback) { - callback(true, QString()); + callback(permitted ? VisionWriteOutcome::Confirmed : VisionWriteOutcome::NotSent, + permitted ? QString() : "Production action invalidated before transmission"); } return; } if (!ConfigManager::instance().productionEnabled()) { if (callback) { - callback(false, "Production control is disabled by configuration"); + callback(VisionWriteOutcome::NotSent, "Production control is disabled by configuration"); } return; } if (m_productionActionActive || m_productionActionBusy) { if (callback) { - callback(false, "A PLC production action is already active"); + callback(VisionWriteOutcome::NotSent, "A PLC production action is already active"); } return; } if (trayNo <= 0 || slotNo < 1 || slotNo > 49) { if (callback) { - callback(false, "PLC tray or slot position is invalid"); + callback(VisionWriteOutcome::NotSent, "PLC tray or slot position is invalid"); } return; } @@ -562,7 +564,7 @@ void DeviceService::beginProductionAction( &m_productionCommandAddress, &m_productionFeedbackAddress)) { if (callback) { - callback(false, "Unknown PLC production action"); + callback(VisionWriteOutcome::NotSent, "Unknown PLC production action"); } return; } @@ -576,50 +578,40 @@ void DeviceService::beginProductionAction( if (!success) { m_productionActionBusy = false; if (callback) { - callback(false, error); + callback(VisionWriteOutcome::NotSent, error); } return; } if (status.command || status.feedback) { m_productionActionBusy = false; if (callback) { - callback(false, + callback(VisionWriteOutcome::NotSent, "PLC command or feedback is still active before a new action"); } return; } auto sendCommand = - [this, callback](bool success, const QString &error) { - if (!success) { - m_productionActionBusy = false; - if (callback) { - callback(false, error); - } - return; - } - - m_productionActionActive = true; + [this, callback](VisionWriteOutcome outcome, const QString &error) { + // An unacknowledged command may already be running. Do not + // permit another action until it has been reconciled. + m_productionActionActive = outcome != VisionWriteOutcome::NotSent; m_productionActionBusy = false; if (callback) { - callback(true, QString()); + callback(outcome, error); } }; auto writeCommand = [this, sendCommand, beforeSend](bool success, const QString &error) { if (!success) { - sendCommand(false, error); + sendCommand(VisionWriteOutcome::NotSent, error); return; } - if (beforeSend) { - m_modbus->writeVisionCoil(m_productionCommandAddress, true, - [sendCommand](VisionWriteOutcome outcome, const QString &error) { - sendCommand(outcome == VisionWriteOutcome::Confirmed, error); - }, beforeSend); - } else { - m_modbus->writeCoil(m_productionCommandAddress, true, sendCommand); - } + // Action commands must never use the legacy automatic retry + // path, even when no persistence hook is supplied. + m_modbus->writeVisionCoil(m_productionCommandAddress, true, + sendCommand, beforeSend); }; if (action == PhotoMoveAction || action == RackPick @@ -706,7 +698,9 @@ void DeviceService::adoptProductionAction(ProductionAction action) m_productionActionActive = true; } -void DeviceService::pollProductionAction(const ActionCallback &callback) +void DeviceService::pollProductionAction( + const ActionCallback &callback, + const std::function &beforeClear) { if (m_terminationActive) { if (callback) { @@ -715,9 +709,9 @@ void DeviceService::pollProductionAction(const ActionCallback &callback) return; } if (ConfigManager::instance().simulationMode()) { - if (callback) { - callback(true, true, QString()); - } + finishProductionAction([callback](bool success, const QString &error) { + if (callback) callback(success, success, error); + }, beforeClear); return; } if (m_productionActionBusy) { @@ -736,7 +730,7 @@ void DeviceService::pollProductionAction(const ActionCallback &callback) m_productionActionBusy = true; m_modbus->readCoil( m_productionFeedbackAddress, - [this, callback](bool success, bool feedback, + [this, callback, beforeClear](bool success, bool feedback, const QString &error) { if (!success) { m_productionActionBusy = false; @@ -753,23 +747,62 @@ void DeviceService::pollProductionAction(const ActionCallback &callback) return; } - clearActionSignals( - [this, callback](bool cleared, const QString &clearError) { - m_productionActionBusy = false; - if (cleared) { - m_productionActionActive = false; - m_productionCommandAddress = -1; - m_productionFeedbackAddress = -1; - if (callback) { - callback(true, true, QString()); - } - } else if (callback) { - callback(false, false, clearError); - } - }); + QString checkpointError; + const bool saved = beforeClear && beforeClear(&checkpointError); + m_productionActionBusy = false; + if (!saved) { + if (!beforeClear) + checkpointError = "Action completion checkpoint hook is missing"; + // An empty error explicitly defers completion while the + // caller gathers asynchronous inspection data. + if (callback) callback(checkpointError.isEmpty(), false, checkpointError); + return; + } + finishProductionAction( + [callback](bool cleared, const QString &clearError) { + if (callback) callback(cleared, cleared, clearError); + }, [](QString *) { return true; }); }); } +void DeviceService::finishProductionAction( + const OperationCallback &callback, + const std::function &beforeClear) +{ + if (m_terminationActive || m_productionActionBusy) { + if (callback) callback(false, "PLC production action is busy or terminating"); + return; + } + const bool simulation = ConfigManager::instance().simulationMode(); + if (!simulation && !m_productionActionActive) { + if (callback) callback(false, "No PLC production action is active"); + return; + } + m_productionActionBusy = true; + QString checkpointError; + if (!beforeClear || !beforeClear(&checkpointError)) { + m_productionActionBusy = false; + if (callback) callback(false, checkpointError.isEmpty() + ? "Action completion checkpoint was not saved" + : checkpointError); + return; + } + auto finish = [this, callback](bool success, const QString &error) { + m_productionActionBusy = false; + if (success) { + m_productionActionActive = false; + m_productionCommandAddress = -1; + m_productionFeedbackAddress = -1; + } + if (callback) callback(success, error); + }; + if (simulation) { + finish(true, QString()); + return; + } + clearActionSignals(finish); +} + void DeviceService::cancelProductionAction(const OperationCallback &callback) { if (m_terminationActive) { @@ -830,14 +863,16 @@ void DeviceService::clearSignals(int commandAddress, int feedbackAddress, commandAddress, false, [this, feedbackAddress, callback](bool commandCleared, const QString &commandError) { + if (!commandCleared) { + if (callback) callback(false, commandError); + return; + } m_modbus->writeCoil( feedbackAddress, false, - [callback, commandCleared, commandError]( + [callback]( bool feedbackCleared, const QString &feedbackError) { if (callback) { - callback(commandCleared && feedbackCleared, - commandCleared ? feedbackError - : commandError); + callback(feedbackCleared, feedbackError); } }); }); diff --git a/services/deviceservice.h b/services/deviceservice.h index 301de03..1493e5b 100644 --- a/services/deviceservice.h +++ b/services/deviceservice.h @@ -84,9 +84,12 @@ public: const OperationCallback &callback); void terminate(const OperationCallback &callback); void beginProductionAction(ProductionAction action, int trayNo, - int slotNo, const OperationCallback &callback, + int slotNo, const VisionWriteCallback &callback, const std::function &beforeSend = {}); - void pollProductionAction(const ActionCallback &callback); + void pollProductionAction(const ActionCallback &callback, + const std::function &beforeClear); + void finishProductionAction(const OperationCallback &callback, + const std::function &beforeClear); void inspectProductionAction(ProductionAction action, const ActionStatusCallback &callback); void adoptProductionAction(ProductionAction action); diff --git a/services/productionservice.cpp b/services/productionservice.cpp index 2059616..5478ffe 100644 --- a/services/productionservice.cpp +++ b/services/productionservice.cpp @@ -2,6 +2,7 @@ #include "../config/configmanager.h" #include "../repositories/productionrepository.h" +#include "../db/databasemanager.h" #include "orderservice.h" #include "trayservice.h" #include "workpieceservice.h" @@ -52,7 +53,6 @@ ProductionService::ProductionService(QObject *parent) , m_actionStarting(false) , m_actionPollPending(false) , m_actionCompleted(false) - , m_actionWasSent(false) , m_actionCancelRequested(false) , m_inspectionStatusPending(false) , m_inspectionStatusReady(false) @@ -206,7 +206,7 @@ void ProductionService::publishVisionControl() { const bool locked = m_visionNeedsReconcile || (m_state != Idle && m_state != Completed); const bool maintenance = m_visionNeedsReconcile && !m_shutdownRequested - && !m_visionRecoveryChecking && !m_visionFaultCleanupPending + && !m_recoveryCheckPending && (m_state == Idle || m_state == ManualConfirm) && !m_actionStarting && !m_actionPollPending && !m_actionCancelRequested && !m_deviceService->productionActionActive(); @@ -260,6 +260,8 @@ void ProductionService::setVisionStage(VisionStage stage, const QString &message void ProductionService::prepareVision() { QString error; + if (!ensureActionCheckpoint(VisionProcessing, &error)) { visionFault(error); return; } + m_targetReady = false; const VisionConfig config = ConfigManager::instance().visionConfig(); if (!config.isValid(&error)) { visionFault(error); @@ -272,9 +274,8 @@ void ProductionService::prepareVision() m_visionRequest = QJsonObject(); m_visionResult = QJsonObject(); m_visionCommitStarted = false; - m_visionEnabled = config.enabled; + m_visionEnabled = config.enabled && !m_forceNormalPick; m_visionIoPending = false; - m_visionRecoveryChecking = false; // Persist before R60/M852 can be written so a crash cannot erase an in-flight result. if (!saveVisionRecoveryState(true, &error)) { visionFault(error); @@ -405,8 +406,19 @@ void ProductionService::onVisionResult(const QJsonObject &result) visionFault("R60 写入未确认,禁止继续取料:" + error); return; } + QString checkpointError; + if (!saveActionPhase("RESULT_CONFIRMED", &checkpointError)) { + visionFault(checkpointError); return; + } publishPickMode(true); - }, [this, generation]() { return visionCurrent(generation); }); + }, [this, generation]() { + if (!visionCurrent(generation)) return false; + QString checkpointError; + if (!saveActionPhase("RESULT_WRITING", &checkpointError)) { + visionFault(checkpointError); return false; + } + return true; + }); } void ProductionService::publishPickMode(bool useVision) @@ -414,17 +426,34 @@ void ProductionService::publishPickMode(bool useVision) const quint64 generation = m_visionGeneration; if (!visionCurrent(generation)) return; m_visionIoPending = true; + m_visionCommitStarted = true; setVisionStage(VisionStage::Publishing, useVision ? "写 M852=1,使用本次 R60" : "写 M852=0,使用普通取料"); m_deviceService->writeVisionSignal(DeviceService::ComparisonPick, useVision, - [this, generation](VisionWriteOutcome outcome, const QString &error) { + [this, generation, useVision](VisionWriteOutcome outcome, const QString &error) { if (!visionCurrent(generation)) return; m_visionIoPending = false; if (outcome != VisionWriteOutcome::Confirmed) { visionFault("M852 写入未确认,禁止启动 RackPick:" + error); return; } + QString checkpointError; + if (!saveActionPhase("MODE_CONFIRMED", &checkpointError)) { + visionFault(checkpointError); return; + } + m_targetReady = true; + m_targetWorkpieceId = m_currentWorkpiece.id; + m_targetUsesVision = useVision; + m_targetSession = m_visionSession; + m_forceNormalPick = false; setVisionStage(VisionStage::Complete, "取料模式已确认,允许普通 RackPick"); - }, [this, generation]() { return visionCurrent(generation); }); + }, [this, generation]() { + if (!visionCurrent(generation)) return false; + QString checkpointError; + if (!saveActionPhase("MODE_WRITING", &checkpointError)) { + visionFault(checkpointError); return false; + } + return true; + }); } void ProductionService::skipVision(const QString &reason) @@ -443,12 +472,12 @@ void ProductionService::skipVision(const QString &reason) void ProductionService::invalidateVision(const QString &reason) { - if (m_visionStage == VisionStage::Idle && !m_visionNeedsReconcile) return; + if (m_visionStage == VisionStage::Idle && !m_visionNeedsReconcile && !m_targetReady) return; + m_targetReady = false; ++m_visionGeneration; m_visionSuspended = true; m_visionNeedsReconcile = true; m_visionIoPending = false; - m_visionRecoveryChecking = false; QString persistenceError; if (!saveVisionRecoveryState(true, &persistenceError)) { m_lastError = persistenceError; @@ -476,7 +505,6 @@ void ProductionService::visionFault(const QString &reason) pauseProcessTimer(); setState(ManualConfirm); reportVision("等待人工核对", reason, true); - m_visionFaultCleanupPending = false; publishVisionControl(); m_recoveryAlarmCode = "VISION"; persistAlarm("VISION", reason); @@ -484,65 +512,10 @@ void ProductionService::visionFault(const QString &reason) emit productionError(reason); } -bool ProductionService::recoverVision(QString *error) -{ - if (m_visionRecoveryChecking) { - if (error) *error = "正在核对视觉恢复状态"; - return false; - } - if (!checkRecoverySafety(error)) return false; - if (m_visionFaultCleanupPending || m_deviceService->productionActionBusy() - || m_deviceService->productionActionActive()) { - if (error) *error = "请等待 PLC 操作结束后恢复"; - return false; - } - m_visionRecoveryChecking = true; - publishVisionControl(); - const quint64 generation = m_visionGeneration; - m_deviceService->readVisionHandshake( - [this, generation](bool success, const VisionHandshake &handshake, const QString &error) { - if (generation != m_visionGeneration || stopRequested()) { - m_visionRecoveryChecking = false; - publishVisionControl(); - return; - } - m_visionRecoveryChecking = false; - if (!success || handshake.photoMove || handshake.photoMoveFeedback) { - publishVisionControl(); - emit productionError("恢复视觉前要求 M850/M851 均已复位:" + error); - return; - } - QString persistenceError; - if (!saveVisionRecoveryState(false, &persistenceError)) { - publishVisionControl(); - emit productionError(persistenceError); - return; - } - persistRecoveryAction("VISION_CONFIRMED", "Operator confirmed the uncertain R60/M852 result; old target discarded"); - m_visionNeedsReconcile = false; - m_visionSuspended = false; - m_visionCommitStarted = false; - m_visionStage = VisionStage::Idle; - m_visionRequest = QJsonObject(); - m_visionResult = QJsonObject(); - QString stepError; - if (m_currentWorkpiece.id > 0 - && !updateCurrentProcessStep("VISION_PROCESSING", &stepError)) { - emit productionError(stepError); - return; - } - m_timeoutState = VisionProcessing; - m_actionWasSent = false; - reportVision("人工恢复完成", "已丢弃旧视觉目标,重新读取 R40 并测量", true); - publishVisionControl(); - ProductionActionStatus status; - continueRecovery(VisionProcessing, DeviceService::RackPick, status); - }); - return true; -} bool ProductionService::start(int orderId, QString *error) { + if (!ProductionRepository().checkActionSchema(error)) return false; const VisionConfig vision = ConfigManager::instance().visionConfig(); if (m_visionNeedsReconcile || (!ConfigManager::instance().simulationMode() && !vision.isValid(error))) { if (m_visionNeedsReconcile && error) @@ -581,7 +554,6 @@ bool ProductionService::start(int orderId, QString *error) m_actionStarting = false; m_actionPollPending = false; m_actionCompleted = false; - m_actionWasSent = false; m_actionError.clear(); m_pauseAfterCurrentAction = false; m_frontResultState.clear(); @@ -591,6 +563,11 @@ bool ProductionService::start(int orderId, QString *error) } m_orderId = orderId; + m_checkpoint = ProductionActionCheckpoint(); + m_restoredRun = false; + m_targetReady = false; + ++m_actionGeneration; + m_forceNormalPick = false; m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_deviceStatusValid = false; @@ -614,15 +591,20 @@ bool ProductionService::start(int orderId, QString *error) return false; } - setState(Preparing); + if (!setState(Preparing)) { if (error) *error = m_lastError; return false; } m_deviceService->startPolling(); const int interval = ProductionTickIntervalMs; m_heartbeatTimer.restart(); m_timer->start(interval); + const quint64 generation = m_actionGeneration; + const int runId = m_runId; + const int startingOrderId = m_orderId; m_deviceService->requestStatus( - [this](bool success, const DeviceStatus &, const QString &statusError) { + [this, generation, runId, startingOrderId](bool success, const DeviceStatus &, const QString &statusError) { + if (generation != m_actionGeneration || runId != m_runId + || startingOrderId != m_orderId || !m_starting || stopRequested()) return; if (!success) { fail(statusError); return; @@ -639,7 +621,9 @@ bool ProductionService::start(int orderId, QString *error) m_deviceService->setInspectionMode( m_inspectionMode, - [this](bool modeSuccess, const QString &modeError) { + [this, generation, runId, startingOrderId](bool modeSuccess, const QString &modeError) { + if (generation != m_actionGeneration || runId != m_runId + || startingOrderId != m_orderId || !m_starting || stopRequested()) return; if (!modeSuccess) { fail(modeError); return; @@ -675,8 +659,7 @@ bool ProductionService::pause(QString *error) if (m_state == VisionProcessing) { if (m_visionStage == VisionStage::Complete) { QString stepError; - if (!saveVisionRecoveryState(false, &stepError) - || !updateCurrentProcessStep("RACK_PICKING", &stepError)) { + if (!updateCurrentProcessStep("RACK_PICKING", &stepError)) { if (error) *error = stepError; return false; } @@ -684,7 +667,7 @@ bool ProductionService::pause(QString *error) m_visionCommitStarted = false; m_visionRequest = QJsonObject(); m_visionResult = QJsonObject(); - setState(RackPicking); + if (!setState(RackPicking)) { if (error) *error = m_lastError; return false; } return pauseAtActionBoundary(error); } if (m_visionCommitStarted) { @@ -707,13 +690,15 @@ bool ProductionService::pause(QString *error) bool ProductionService::pauseAtActionBoundary(QString *error) { + if (!actionTypeForState(m_state).isEmpty() + && !ensureActionCheckpoint(m_state, error)) return false; if (!OrderService::instance().pauseOrder(m_orderId, error)) { return false; } m_pauseAfterCurrentAction = false; pauseProcessTimer(); m_timer->stop(); - setState(Paused); + if (!setState(Paused)) { if (error) *error = m_lastError; return false; } emitProcessElapsed(); return true; } @@ -741,54 +726,61 @@ void ProductionService::abortVisionForPause() bool ProductionService::resume(QString *error) { + if (m_state != Paused || m_starting || m_recoveryCheckPending) { + if (error) *error = "当前订单不能继续或正在处理其他恢复操作"; + return false; + } + m_recoveryKeepPaused = true; + m_recoveryIdleUnlock = false; + if (!loadRecoverySnapshot(error)) return false; + if (m_currentWorkpiece.processStep == "RACK_PICKING" && !pickTargetValid()) + m_visionNeedsReconcile = true; if (m_visionNeedsReconcile) { - if (error) *error = "视觉流程需人工核对恢复,不能直接继续"; + if (error) *error = "视觉流程需人工核对,请点击恢复/重试后再继续"; + publishVisionControl(); + reportVision("等待人工核对", "视觉流程需人工核对后再继续", true); return false; } - if (m_state != Paused) { - if (error) { - *error = "Production service is not paused"; - } - return false; - } - - if (m_starting) { - if (error) *error = "Production resume is already in progress"; + if (m_currentWorkpiece.id > 0 && m_checkpoint.phase != "STEP_COMMITTED" + && m_checkpoint.phase != "NOT_SENT" + && m_currentWorkpiece.processStep != "WAITING_DEVICE_READY") { + if (error) *error = "暂停记录不在明确动作边界,必须先核对"; return false; } m_starting = true; + const quint64 generation = ++m_actionGeneration; m_deviceService->requestStatus( - [this](bool statusSuccess, const DeviceStatus &, const QString &statusError) { - QString safetyError; - if (!statusSuccess || !checkRecoverySafety(&safetyError)) { + [this, generation](bool success, const DeviceStatus &, const QString &statusError) { + if (generation != m_actionGeneration || stopRequested()) { m_starting = false; return; } + QString error; + if (!success || !checkRecoverySafety(&error)) { m_starting = false; - emit productionError(statusSuccess ? safetyError : statusError); + emit productionError(success ? error : statusError); return; } - m_deviceService->setInspectionMode( - m_inspectionMode, - [this](bool modeSuccess, const QString &modeError) { - if (!modeSuccess) { - m_starting = false; - emit productionError(modeError); - return; - } - QString orderError; - if (!OrderService::instance().resumeOrder(m_orderId, &orderError)) { - m_starting = false; - emit productionError(orderError); - return; - } - resumeProcessTimer(); - State resumeState = Preparing; - if (m_currentWorkpiece.id > 0) { - resumeState = stateForProcessStep(m_currentWorkpiece.processStep); - if (resumeState == Idle) resumeState = WaitingDeviceReady; - } - m_starting = false; - setState(resumeState); - m_timer->start(ProductionTickIntervalMs); - tick(); + m_deviceService->setInspectionMode(m_inspectionMode, + [this, generation](bool modeSuccess, const QString &modeError) { + if (generation != m_actionGeneration || stopRequested()) { m_starting = false; return; } + QString error; + if (!modeSuccess || !checkRecoverySafety(&error) + || (m_currentWorkpiece.processStep == "RACK_PICKING" && !pickTargetValid())) { + m_starting = false; + emit productionError(modeSuccess ? (error.isEmpty() ? "取料目标已失效" : error) : modeError); + return; + } + if (!OrderService::instance().resumeOrder(m_orderId, &error)) { + m_starting = false; + emit productionError(error); + return; + } + const State target = m_currentWorkpiece.id > 0 + ? stateForProcessStep(m_currentWorkpiece.processStep) : Preparing; + m_starting = false; + m_restoredRun = false; + if (!setState(target)) return; + resumeProcessTimer(); + m_timer->start(ProductionTickIntervalMs); + tick(); }); }); return true; @@ -796,6 +788,10 @@ bool ProductionService::resume(QString *error) bool ProductionService::stop(QString *error) { + m_forceNormalPick = false; + ++m_actionGeneration; + ++m_recoveryGeneration; + finishRecoveryCheck(); if (m_state == Terminating) { return true; } @@ -809,7 +805,11 @@ bool ProductionService::stop(QString *error) invalidateVision("操作员已终止生产"); m_lastError = "Production stopped by operator"; m_timer->stop(); - setState(Terminating); + if (!setState(Terminating)) { + // Stop may still clean the PLC, but no stale database snapshot may be written. + m_state = Terminating; + emit stateChanged(m_state, stateName()); + } auto failTermination = [this](const QString &terminationError) { m_lastError = terminationError.isEmpty() @@ -864,8 +864,9 @@ bool ProductionService::stop(QString *error) } persistRecoveryAction("STOP", m_lastError); - setState(Idle); + m_persistenceUncertain = false; m_runId = 0; + if (!setState(Idle)) { failTermination(m_lastError); return; } m_orderId = 0; m_currentWorkpiece = Workpiece(); m_starting = false; @@ -937,6 +938,7 @@ bool ProductionService::clearAlarm(QString *error) bool ProductionService::restoreActiveRun(QString *error) { + if (!ProductionRepository().checkActionSchema(error)) return false; if (m_state != Idle) { return true; } @@ -968,6 +970,16 @@ bool ProductionService::restoreActiveRun(QString *error) } return false; } + if (m_currentWorkpiece.orderId != run.orderId + || m_currentWorkpiece.processStep != run.processStep + || m_currentWorkpiece.state != "PROCESSING") { + m_persistenceUncertain = true; + m_state = ManualConfirm; + m_timer->stop(); + if (error) *error = "恢复快照与工件身份/工序不一致,请核对数据库记录"; + emit stateChanged(m_state, stateName()); + return false; + } emit currentWorkpieceChanged(m_currentWorkpiece.id, m_currentWorkpiece.barcode); m_currentSlotNo = m_currentWorkpiece.trayPos; @@ -994,44 +1006,24 @@ bool ProductionService::restoreActiveRun(QString *error) emitProcessElapsed(); } - State persistedState = stateFromName(run.productionState); - if (persistedState == Idle || persistedState == Completed) { - persistedState = Preparing; - } - m_timeoutState = stateFromName(run.timeoutState); - if (!isTimedState(m_timeoutState)) { - m_timeoutState = persistedState; - } - - const State recoveryState = isTimedState(m_timeoutState) - ? m_timeoutState - : persistedState; - if (recoveryState == VisionProcessing || m_visionNeedsReconcile) { - m_recoveryAlarmCode = "VISION"; + m_checkpoint = run.action; + m_restoredRun = true; + m_targetReady = false; + m_timeoutState = m_currentWorkpiece.id > 0 + ? stateForProcessStep(m_currentWorkpiece.processStep) : Preparing; + const bool unstartedPick = m_timeoutState == RackPicking + && (m_checkpoint.phase == "NOT_SENT" || m_checkpoint.phase == "STEP_COMMITTED"); + if (m_timeoutState == VisionProcessing || unstartedPick) { m_visionNeedsReconcile = true; m_visionSuspended = true; m_visionStage = VisionStage::Fault; - QString stateError; - if (!saveVisionRecoveryState(true, &stateError)) emit productionError(stateError); - reportVision("等待人工核对", "恢复未完成的视觉记录,需核对 R60/M852 写入状态", true); - } else if (m_lastError == "PLC is disconnected" - || m_lastError.startsWith("Failed to connect") - || m_lastError.startsWith("Failed to read PLC")) { - m_recoveryAlarmCode = "PLC_DISCONNECTED"; - } else if (m_lastError == "Emergency stop is active") { - m_recoveryAlarmCode = "EMERGENCY_STOP"; - } else if (m_lastError == "Safety door is open") { - m_recoveryAlarmCode = "SAFETY_DOOR_OPEN"; - } else if (!m_lastError.isEmpty()) { - m_recoveryAlarmCode = "PRODUCTION"; + m_recoveryAlarmCode = "VISION"; } - DeviceService::ProductionAction action; - m_actionWasSent = productionActionForState(recoveryState, &action); if (run.runState == "PAUSED") { - setState(Paused); - } else { - m_timeoutState = recoveryState; - setState(ManualConfirm); + if (!setState(Paused)) { if (error) *error = m_lastError; return false; } + } else if (!setState(ManualConfirm)) { + if (error) *error = m_lastError; + return false; } m_heartbeatTimer.restart(); m_timer->stop(); @@ -1043,83 +1035,449 @@ bool ProductionService::restoreActiveRun(QString *error) return true; } +bool ProductionService::loadRecoverySnapshot(QString *error) +{ + if (!ProductionRepository().checkActionSchema(error)) return false; + if (m_recoveryIdleUnlock) return true; + ProductionRunSnapshot run; + Order order; + if (!ProductionRepository().findRun(m_runId, &run, error) + || !OrderService::instance().findOrder(m_orderId, &order, error)) return false; + if (run.orderId != m_orderId || (order.status != "RUNNING" && order.status != "PAUSED") + || run.runState == "STOPPED" || run.runState == "COMPLETED") { + if (error) *error = "订单或运行记录不再允许恢复"; + return false; + } + if (order.status == "PAUSED") m_recoveryKeepPaused = true; + if (run.currentWorkpieceId > 0) { + Workpiece workpiece; + if (!WorkpieceService::instance().findWorkpiece(run.currentWorkpieceId, &workpiece, error)) + return false; + if (workpiece.orderId != m_orderId || workpiece.processStep != run.processStep + || workpiece.state != "PROCESSING") { + if (error) *error = "运行记录与工件工序不一致"; + return false; + } + m_currentWorkpiece = workpiece; + QString trayError; + const QList trays = TrayService::instance().listTrays(&trayError); + m_currentTrayNo = 0; + m_currentSlotNo = workpiece.trayPos; + for (int index = 0; index < trays.size(); ++index) + if (trays.at(index).id == workpiece.trayId) m_currentTrayNo = index + 1; + if (!trayError.isEmpty() || m_currentTrayNo <= 0 || m_currentSlotNo < 1 || m_currentSlotNo > 49) { + if (error) *error = "工件料盘/格位无法恢复:" + trayError; + return false; + } + } else { + const bool completedBoundary = run.action.type == "RACK_PLACE" + && run.action.phase == "STEP_COMMITTED" && run.action.nextStep == "COMPLETE"; + const bool unusedRun = run.action.token.isEmpty() && run.action.phase.isEmpty(); + if (run.processStep != "PREPARING" || (!completedBoundary && !unusedRun)) { + if (error) *error = "运行记录缺少当前工件"; + return false; + } + m_currentWorkpiece = Workpiece(); + } + m_checkpoint = run.action; + m_inspectionMode = run.inspectionMode; + m_persistenceUncertain = false; + return true; +} + +void ProductionService::finishRecoveryCheck(const QString &error) +{ + ++m_recoveryGeneration; + m_recoveryCheckPending = false; + m_manualContext = QJsonObject(); + emit recoveryBusyChanged(false); + publishVisionControl(); + if (!error.isEmpty()) { + m_timer->stop(); + pauseProcessTimer(); + m_lastError = error; + emit productionError(error); + } +} + bool ProductionService::recover(QString *error) { - if (m_state != Error && m_state != TimeoutPaused - && m_state != ManualConfirm) { - if (error) { - *error = "Production is not waiting for recovery"; - } - return false; - } if (m_recoveryCheckPending) { - if (error) *error = "Recovery check is already in progress"; + if (error) *error = "正在恢复,请等待当前操作结束"; return false; } + m_recoveryIdleUnlock = m_state == Idle && m_visionNeedsReconcile; + m_recoveryKeepPaused = m_state == Paused; + if (m_state != Error && m_state != TimeoutPaused && m_state != ManualConfirm + && !m_recoveryIdleUnlock && !(m_recoveryKeepPaused && m_visionNeedsReconcile)) { + if (error) *error = "普通暂停订单请使用启动/继续;当前没有可恢复故障"; + emit recoveryBusyChanged(false); + return false; + } + if (stopRequested() || m_shutdownRequested || m_deviceService->productionActionBusy()) { + if (error) *error = "仍有设备操作或终止请求,请稍后恢复"; + emit recoveryBusyChanged(false); + return false; + } + m_timer->stop(); + pauseProcessTimer(); m_recoveryCheckPending = true; + emit recoveryBusyChanged(true); + publishVisionControl(); + const quint64 generation = ++m_recoveryGeneration; m_deviceService->requestStatus( - [this](bool statusSuccess, const DeviceStatus &, - const QString &statusError) { - m_recoveryCheckPending = false; - QString safetyError; - if (!statusSuccess || !checkRecoverySafety(&safetyError)) { - emit productionError(statusSuccess ? safetyError : statusError); + [this, generation](bool success, const DeviceStatus &, const QString &statusError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + QString error; + if (!success || !checkRecoverySafety(&error) || !loadRecoverySnapshot(&error)) { + finishRecoveryCheck(success ? error : statusError); return; } - Order order; - QString orderError; - if (!OrderService::instance().findOrder(m_orderId, &order, - &orderError) - || order.status != "RUNNING") { - emit productionError(orderError.isEmpty() - ? "故障恢复要求订单保持 RUNNING;PAUSED 订单请使用启动按钮" - : orderError); + if (m_recoveryIdleUnlock) { checkVisionRecovery(); return; } + const State state = m_currentWorkpiece.id > 0 + ? stateForProcessStep(m_currentWorkpiece.processStep) : Preparing; + if (state == Preparing || state == WaitingDeviceReady) { + resumeRecoveredState(state); return; } - if (m_currentWorkpiece.id <= 0 - && m_timeoutState != Preparing) { - emit productionError("恢复所需的当前工件记录不完整"); - return; - } - if (m_visionNeedsReconcile) { - QString visionError; - if (!recoverVision(&visionError)) - emit productionError(visionError); - return; - } - - State recoveryState = isTimedState(m_timeoutState) - ? m_timeoutState - : stateForProcessStep(m_currentWorkpiece.processStep); - if (!isTimedState(recoveryState)) { - emit productionError("无法从持久化记录确定安全恢复位置"); + if (state == VisionProcessing + || (state == RackPicking && (m_checkpoint.phase == "NOT_SENT" || m_checkpoint.phase == "STEP_COMMITTED") + && !pickTargetValid())) { + checkVisionRecovery(); return; } DeviceService::ProductionAction action; - if (!productionActionForState(recoveryState, &action)) { - ProductionActionStatus status; - continueRecovery(recoveryState, DeviceService::RackPick, - status); + if (!productionActionForState(state, &action)) { + finishRecoveryCheck("无法确定当前独立动作"); return; } - m_deviceService->inspectProductionAction( - action, - [this, recoveryState, action]( - bool success, const ProductionActionStatus &status, - const QString &actionError) { - if (!success) { - emit productionError("读取当前动作命令/反馈失败:" - + actionError); - return; - } - continueRecovery(recoveryState, action, status); + m_deviceService->inspectProductionAction(action, + [this, generation, state, action](bool read, const ProductionActionStatus &status, const QString &readError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!read) { finishRecoveryCheck(readError); return; } + continueRecovery(state, action, status); }); }); return true; } +void ProductionService::requestManualDecision(State state, const ProductionActionStatus &status, + const QString &reason, const QStringList &options) +{ + m_timer->stop(); + m_timeoutState = state; + m_lastError = reason; + if (!m_recoveryKeepPaused && !m_recoveryIdleUnlock && !setState(ManualConfirm)) { + finishRecoveryCheck(m_lastError); + return; + } + QJsonArray choices; + for (const QString &option : options) choices.append(option); + choices.append("CANCEL"); + m_manualContext = QJsonObject{ + {"run_id", m_runId}, {"order_id", m_orderId}, {"workpiece_id", m_currentWorkpiece.id}, + {"action_token", m_checkpoint.token}, {"action_attempt", m_checkpoint.attempt}, + {"action_lock_version", m_checkpoint.version}, {"generation", QString::number(m_recoveryGeneration)}, + {"process_step", m_currentWorkpiece.processStep}, {"action_type", m_checkpoint.type}, + {"action_phase", m_checkpoint.phase}, {"command", status.command}, {"feedback", status.feedback}, + {"reason", reason}, {"options", choices}}; + emit recoveryDecisionRequired(m_manualContext); +} + +bool ProductionService::saveManualDecision(const QJsonObject &decision, QString *error) +{ + const QString choice = decision.value("decision").toString(); + DatabaseManager &database = DatabaseManager::instance(); + ProductionRepository repository; + ProductionActionCheckpoint next = m_checkpoint; + if (next.token.isEmpty()) { + next.token = QUuid::createUuid().toString(QUuid::WithoutBraces); + next.attempt = 1; + const State actionState = stateForProcessStep(m_currentWorkpiece.processStep); + next.type = actionTypeForState(actionState); + next.nextStep = nextStepForState(actionState); + } + if (choice == "ACTION_COMPLETED") next.phase = "FEEDBACK_RECEIVED"; + else if (choice == "ACTION_NOT_EXECUTED") { + next.phase = "NOT_SENT"; + next.command = false; + next.feedback = false; + } else if (choice == "RETRY_VISION" || choice == "NORMAL_PICK") { + next.type = "VISION"; + next.nextStep = "RACK_PICKING"; + next.phase = "NOT_SENT"; + ++next.attempt; + } + next.manualDecision = choice; + next.manualOperator = decision.value("operator_name").toString().trimmed(); + next.manualDecidedAt = QDateTime::currentDateTimeUtc(); + const QString details = QString::fromUtf8(QJsonDocument(decision).toJson(QJsonDocument::Compact)); + if (choice == "RETRY_VISION" || choice == "NORMAL_PICK") { + if (!WorkpieceService::instance().updateProcessStepWithRecord( + m_currentWorkpiece.id, "VISION_PROCESSING", m_inspectionMode, + m_deviceStatus.currentStep, "RECOVERY", currentProcessElapsedMs(), error, false, + [this, &next, &repository, &details, &choice](QString *commitError) { + return repository.saveActionCheckpoint(m_runId, m_orderId, m_currentWorkpiece.id, &next, commitError) + && repository.updateRun(m_runId, m_recoveryKeepPaused ? "PAUSED" : "RECOVERY", + m_recoveryKeepPaused ? "PAUSED" : "MANUAL_CONFIRM", "VISION_PROCESSING", + m_currentWorkpiece.id, QString(), m_recoveryRetryCount, m_lastError, commitError) + && repository.insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + stateName(), stateName(), "VISION_PROCESSING", "OPERATOR", choice, + details, commitError, next.manualOperator); + })) { + m_persistenceUncertain = true; + return false; + } + m_checkpoint = next; + m_currentWorkpiece.processStep = "VISION_PROCESSING"; + startProcessTimer("VISION_PROCESSING"); + pauseProcessTimer(); + return true; + } + if (!database.transaction(error) + || (!m_recoveryIdleUnlock && !repository.saveActionCheckpoint(m_runId, m_orderId, + m_currentWorkpiece.id, &next, error)) + || !repository.insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + stateName(), stateName(), m_currentWorkpiece.processStep, "OPERATOR", + choice, details, error, next.manualOperator) + || !database.commit(error)) { + database.rollback(); + m_persistenceUncertain = true; + return false; + } + if (!m_recoveryIdleUnlock) m_checkpoint = next; + return true; +} + +bool ProductionService::submitRecoveryDecision(const QJsonObject &decision, QString *error) +{ + if (!m_recoveryCheckPending || m_manualContext.isEmpty()) { + if (error) *error = "人工确认已失效,请重新点击恢复/重试"; + if (!m_recoveryCheckPending) emit recoveryBusyChanged(false); + return false; + } + const QStringList identity{"run_id", "order_id", "workpiece_id", "action_token", + "action_attempt", "action_lock_version", "generation", "process_step"}; + for (const QString &key : identity) { + if (decision.value(key) != m_manualContext.value(key)) { + if (error) *error = "人工确认上下文已过期"; + return false; + } + } + const QString choice = decision.value("decision").toString(); + if (choice == "CANCEL") { finishRecoveryCheck(); return true; } + if (!m_manualContext.value("options").toArray().contains(choice) + || !decision.value("field_confirmed").toBool() + || decision.value("operator_name").toString().trimmed().isEmpty() + || decision.value("operator_name").toString().size() > 64) { + if (error) *error = "请完成现场核对并填写操作人,不能使用当前不可用的决定"; + finishRecoveryCheck(); + return false; + } + m_manualContext = QJsonObject(); + const quint64 generation = m_recoveryGeneration; + const ProductionActionCheckpoint expected = m_checkpoint; + m_deviceService->requestStatus( + [this, generation, expected, decision, choice](bool success, const DeviceStatus &, const QString &statusError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + QString error; + if (!success || !checkRecoverySafety(&error) || !loadRecoverySnapshot(&error)) { + finishRecoveryCheck(success ? error : statusError); return; + } + if (!m_recoveryIdleUnlock && (m_checkpoint.token != expected.token + || m_checkpoint.version != expected.version || m_checkpoint.attempt != expected.attempt + || m_currentWorkpiece.id != decision.value("workpiece_id").toInt() + || m_orderId != decision.value("order_id").toInt() + || m_currentWorkpiece.processStep != decision.value("process_step").toString())) { + finishRecoveryCheck("人工确认期间动作记录已改变,请重新检查"); return; + } + if (choice == "RETRY_VISION" || choice == "NORMAL_PICK" || choice == "UNLOCK_VISION") { + checkVisionRecovery(decision); return; + } + const State state = stateForProcessStep(m_currentWorkpiece.processStep); + DeviceService::ProductionAction action; + if (!productionActionForState(state, &action)) { + finishRecoveryCheck("当前不是机器人独立动作"); return; + } + m_deviceService->inspectProductionAction(action, + [this, generation, decision, choice, state, action](bool read, const ProductionActionStatus &status, const QString &readError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!read || (status.command && !status.feedback) + || (choice == "ACTION_NOT_EXECUTED" && (status.command || status.feedback))) { + finishRecoveryCheck(read ? "动作仍可能在执行或信号已改变,禁止按人工决定推进" : readError); + return; + } + QString error; + if (action == DeviceService::Inspect && choice == "ACTION_COMPLETED") { + int raw = 0; QString result; + if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + state == FrontChecking ? "FRONT" : "BACK", &raw, &result, &error, + m_checkpoint.token, m_checkpoint.attempt)) { + finishRecoveryCheck(error); return; + } + } + if (!saveManualDecision(decision, &error)) { finishRecoveryCheck(error); return; } + ++m_actionGeneration; + m_actionError.clear(); + m_actionPending = false; + m_actionStarting = false; + m_actionPollPending = false; + m_inspectionStatusReady = false; + m_inspectionStatusPending = false; + m_inspectionStatusError.clear(); + m_restoredRun = false; + if (choice == "ACTION_NOT_EXECUTED" && m_deviceService->productionActionActive()) { + m_deviceService->cancelProductionAction([this, generation, state, action, status](bool cleared, const QString &clearError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!cleared) { finishRecoveryCheck(clearError); return; } + continueRecovery(state, action, status); + }); + } else { + continueRecovery(state, action, status); + } + }); + }); + return true; +} + +void ProductionService::checkVisionRecovery(const QJsonObject &decision) +{ + const quint64 generation = m_recoveryGeneration; + if (m_deviceService->productionActionBusy() || m_visionIoPending) { + finishRecoveryCheck("仍有 PLC 写入在途,不能重测或覆盖取料模式"); return; + } + m_deviceService->inspectProductionAction(DeviceService::PhotoMoveAction, + [this, generation, decision](bool photoRead, const ProductionActionStatus &photo, const QString &photoError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!photoRead || photo.command || photo.feedback) { + finishRecoveryCheck(photoRead ? "M850/M851尚未复位,请先核对拍照位动作" : photoError); return; + } + m_deviceService->inspectProductionAction(DeviceService::RackPick, + [this, generation, decision](bool read, const ProductionActionStatus &status, const QString &readError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!read || status.command || status.feedback) { + finishRecoveryCheck(read ? "RackPick信号非零,禁止重测或改取料模式" : readError); return; + } + const bool visionCheckpoint = m_checkpoint.type == "VISION" + && m_checkpoint.nextStep == "RACK_PICKING" + && QStringList{"NOT_SENT", "RESULT_WRITING", "RESULT_CONFIRMED", + "MODE_WRITING", "MODE_CONFIRMED"}.contains(m_checkpoint.phase); + const bool photoBoundary = m_checkpoint.type == "PHOTO_MOVE" + && m_checkpoint.phase == "STEP_COMMITTED" + && m_checkpoint.nextStep == "VISION_PROCESSING"; + const bool historicalVision = m_currentWorkpiece.processStep == "VISION_PROCESSING" + && m_checkpoint.token.isEmpty() && m_checkpoint.phase.isEmpty(); + const bool pickNotStarted = (m_currentWorkpiece.processStep == "VISION_PROCESSING" + && (visionCheckpoint || photoBoundary)) + || (m_currentWorkpiece.processStep == "RACK_PICKING" + && ((m_checkpoint.type == "RACK_PICK" && m_checkpoint.phase == "NOT_SENT") + || (m_checkpoint.type == "VISION" && m_checkpoint.phase == "STEP_COMMITTED"))); + if (!m_recoveryIdleUnlock && !pickNotStarted && !historicalVision) { + requestManualDecision(VisionProcessing, status, + "无法证明RackPick尚未开始;请先核对机器人动作,不能直接覆盖R60/M852", {}); + return; + } + if (decision.isEmpty()) { + requestManualDecision(VisionProcessing, status, + m_recoveryIdleUnlock ? "仅解除已终止任务的视觉遗留锁,不恢复订单" + : historicalVision + ? "历史记录没有视觉检查点,必须现场确认机器人仍在拍照位且RackPick尚未执行;确认后才建立新检查点" + : "现场确认机器人仍在拍照位且RackPick尚未执行,再选择处理方式", + m_recoveryIdleUnlock ? QStringList{"UNLOCK_VISION"} + : QStringList{"RETRY_VISION", "NORMAL_PICK"}); + return; + } + QString error; + if (!saveManualDecision(decision, &error)) { finishRecoveryCheck(error); return; } + ++m_visionGeneration; + m_deviceService->cancelVisionRequests("人工恢复作废旧视觉写入"); + m_targetReady = false; + if (m_recoveryIdleUnlock) { + if (!saveVisionRecoveryState(false, &error)) { finishRecoveryCheck(error); return; } + m_visionNeedsReconcile = false; + m_visionSuspended = false; + m_visionStage = VisionStage::Idle; + reportVision("视觉锁已解除", "订单保持终止状态", true); + publishVisionControl(); + finishRecoveryCheck(); + return; + } + if (!saveVisionRecoveryState(true, &error)) { finishRecoveryCheck(error); return; } + m_visionNeedsReconcile = false; + m_visionSuspended = false; + m_visionCommitStarted = false; + m_visionStage = VisionStage::Idle; + m_visionRequest = QJsonObject(); + m_visionResult = QJsonObject(); + m_forceNormalPick = decision.value("decision").toString() == "NORMAL_PICK"; + m_restoredRun = false; + if (m_deviceService->productionActionActive()) { + m_deviceService->cancelProductionAction([this, generation](bool success, const QString &clearError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!success) { finishRecoveryCheck(clearError); return; } + resumeRecoveredState(VisionProcessing); + }); + } else resumeRecoveredState(VisionProcessing); + }); + }); +} + +void ProductionService::resumeRecoveredState(State state) +{ + const quint64 generation = m_recoveryGeneration; + m_deviceService->setInspectionMode(m_inspectionMode, + [this, generation, state](bool success, const QString &modeError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + QString error; + if (!success || !checkRecoverySafety(&error)) { + finishRecoveryCheck(success ? error : modeError); return; + } + const State target = m_recoveryKeepPaused ? Paused : state; + DatabaseManager &database = DatabaseManager::instance(); + ProductionRepository repository; + if (!database.transaction(&error) + || !repository.updateRun(m_runId, runStateForState(target), stateNameForState(target), + m_currentWorkpiece.id > 0 ? m_currentWorkpiece.processStep : "PREPARING", + m_currentWorkpiece.id, QString(), m_recoveryRetryCount, QString(), &error) + || !repository.insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + stateName(), stateNameForState(target), m_currentWorkpiece.processStep, + "RECOVERY", "CONTINUE", m_checkpoint.token, &error) + || (!m_recoveryAlarmCode.isEmpty() + && !repository.clearActiveAlarms(m_recoveryAlarmCode, "RECOVERY", &error)) + || !database.commit(&error)) { + database.rollback(); + m_persistenceUncertain = true; + finishRecoveryCheck(error); return; + } + m_timeoutState = Idle; + m_lastError.clear(); + m_actionError.clear(); + m_pauseAfterCurrentAction = false; + m_state = target; + m_stateTimer.restart(); + emit stateChanged(m_state, stateName()); + publishVisionControl(); + m_recoveryAlarmCode.clear(); + m_plcStarted = true; + m_starting = false; + const bool keepPaused = m_recoveryKeepPaused; + finishRecoveryCheck(); + if (keepPaused) return; + resumeProcessTimer(); + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); + emit recoveryCompleted(stateNameForState(state)); + tick(); + }); +} + bool ProductionService::markCurrentWorkpieceNg(QString *error) { + if (m_checkpoint.type != "RACK_PLACE" || m_checkpoint.phase != "SIGNALS_CLEARED" + || m_recoveryCheckPending || m_actionStarting || m_actionPollPending) { + if (error) *error = "必须先通过恢复/重试确认工件已放回料架,不能跳过未完成动作"; + return false; + } if (m_visionNeedsReconcile) { if (error) *error = "请先处理未完成的视觉及机器人握手,再标记工件 NG"; return false; @@ -1148,67 +1506,188 @@ bool ProductionService::markCurrentWorkpieceNg(QString *error) return false; } - const int durationMs = currentProcessElapsedMs(); - const QString previousProcessStep = m_currentWorkpiece.processStep; - if (!WorkpieceService::instance().completeWithInspection( - m_currentWorkpiece.id, "NG", "COMPLETE", - previousProcessStep, durationMs, -1, "NG", - m_deviceStatus.currentStep, m_inspectionMode, "MANUAL", - &operationError)) { - if (error) *error = operationError; - return false; + if (!ProductionRepository().insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + stateName(), stateName(), m_currentWorkpiece.processStep, "OPERATOR", + "MARK_NG", "工件放回完成后人工标记NG", error)) return false; + if (!finishCurrentWorkpiece("NG", "COMPLETE", error)) return false; + if (m_state == Preparing && !m_persistenceUncertain) { + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); } - - persistRecoveryAction( - "MARK_NG", - QString("Current workpiece %1 was manually marked as NG") - .arg(m_currentWorkpiece.barcode)); - m_currentWorkpiece = Workpiece(); - clearProcessTimer(); - m_recoveryRetryCount = 0; - m_lastError.clear(); - emit currentWorkpieceChanged(0, QString()); - emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); - emit currentPositionChanged(0, 0); - setState(Preparing); - m_heartbeatTimer.restart(); - m_timer->start(ProductionTickIntervalMs); return true; } -void ProductionService::setState(State state) +QString ProductionService::actionTypeForState(State state) const { - if (m_state == state) { - return; + switch (state) { + case PhotoMoving: return "PHOTO_MOVE"; + case VisionProcessing: return "VISION"; + case RackPicking: return "RACK_PICK"; + case FrontLoading: return "FRONT_LOAD"; + case FrontChecking: case BackChecking: return "INSPECT"; + case FrontUnloading: return "FRONT_UNLOAD"; + case Flipping: return "FLIP"; + case BackLoading: return "BACK_LOAD"; + case BackUnloading: return "BACK_UNLOAD"; + case RackPlacing: return "RACK_PLACE"; + default: return QString(); } +} - const QString previousStateName = stateName(); +QString ProductionService::nextStepForState(State state) const +{ + switch (state) { + case PhotoMoving: return "VISION_PROCESSING"; + case VisionProcessing: return "RACK_PICKING"; + case RackPicking: return "FRONT_LOADING"; + case FrontLoading: return "FRONT_CHECKING"; + case FrontChecking: return "FRONT_UNLOADING"; + case FrontUnloading: return m_inspectionMode == "AFTER_PLATING" ? "RACK_PLACING" : "FLIPPING"; + case Flipping: return "BACK_LOADING"; + case BackLoading: return "BACK_CHECKING"; + case BackChecking: return "BACK_UNLOADING"; + case BackUnloading: return "RACK_PLACING"; + case RackPlacing: return "COMPLETE"; + default: return QString(); + } +} + +bool ProductionService::ensureActionCheckpoint(State state, QString *error) +{ + const QString type = actionTypeForState(state); + if (type.isEmpty() || m_runId <= 0 || m_currentWorkpiece.id <= 0) { + if (error) *error = "当前独立动作记录不完整"; + return false; + } + if (!m_checkpoint.phase.isEmpty() && m_checkpoint.phase != "STEP_COMMITTED") { + if (m_checkpoint.type != type || m_checkpoint.nextStep != nextStepForState(state)) { + if (error) *error = "动作检查点与当前工序不一致"; + return false; + } + return true; + } + if (m_restoredRun && m_checkpoint.phase.isEmpty()) { + if (error) *error = "历史运行记录没有动作检查点,必须人工核对"; + return false; + } + ProductionActionCheckpoint next; + next.version = m_checkpoint.version; + next.token = QUuid::createUuid().toString(QUuid::WithoutBraces); + next.type = type; + next.phase = "NOT_SENT"; + next.nextStep = nextStepForState(state); + next.attempt = 1; + if (!ProductionRepository().saveActionCheckpoint(m_runId, m_orderId, + m_currentWorkpiece.id, &next, error)) { + m_persistenceUncertain = true; + return false; + } + m_checkpoint = next; + ++m_actionGeneration; + m_actionPending = false; + m_actionCompleted = false; + m_actionStarting = false; + m_actionPollPending = false; + m_actionError.clear(); + m_inspectionStatusReady = false; + m_inspectionStatusPending = false; + m_inspectionStatusError.clear(); + return true; +} + +bool ProductionService::saveActionPhase(const QString &phase, QString *error) +{ + ProductionActionCheckpoint next = m_checkpoint; + next.phase = phase; + if (phase == "COMMAND_CONFIRMED") next.command = true; + if (phase == "FEEDBACK_RECEIVED") next.feedback = true; + if (phase == "SIGNALS_CLEARED") { next.command = false; next.feedback = false; } + if (!ProductionRepository().saveActionCheckpoint(m_runId, m_orderId, + m_currentWorkpiece.id, &next, error)) { + m_persistenceUncertain = true; + return false; + } + m_checkpoint = next; + return true; +} + +bool ProductionService::saveActionCompletion(ProductionActionCheckpoint *action, + const QString &nextStep, int nextWorkpieceId, QString *error) +{ + if (action->phase != "SIGNALS_CLEARED" && action->phase != "MODE_CONFIRMED") { + if (error) *error = "动作完成证据尚未持久化"; + return false; + } + action->phase = "STEP_COMMITTED"; + ProductionRepository repository; + return repository.saveActionCheckpoint(m_runId, m_orderId, m_currentWorkpiece.id, action, error) + && repository.updateRun(m_runId, "RUNNING", + nextWorkpieceId > 0 ? nextStep : "PREPARING", + nextWorkpieceId > 0 ? nextStep : "PREPARING", nextWorkpieceId, + QString(), m_recoveryRetryCount, QString(), error) + && repository.insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + m_currentWorkpiece.processStep, nextStep, nextStep, "SYSTEM", + "ACTION_COMMITTED", action->token, error); +} + +bool ProductionService::actionCallbackCurrent(quint64 generation, + const QString &token, int attempt) const +{ + return generation == m_actionGeneration && token == m_checkpoint.token + && attempt == m_checkpoint.attempt && !stopRequested() + && m_state != Terminating && m_state != Idle && m_state != Completed; +} + +bool ProductionService::pickTargetValid() const +{ + return m_targetReady && m_targetWorkpieceId == m_currentWorkpiece.id + && (!m_targetUsesVision || m_targetSession == m_availableVisionSession); +} + +bool ProductionService::setState(State state) +{ + const QString previous = stateName(); + if (m_persistenceUncertain) { + m_timer->stop(); + pauseProcessTimer(); + m_state = state == ManualConfirm ? ManualConfirm : Error; + emit stateChanged(m_state, stateName()); + return false; + } + if (m_state == state) return true; + if (m_runId > 0) { + QString processStep = m_currentWorkpiece.processStep; + if (processStep.isEmpty()) processStep = processStepForState(state); + if (processStep.isEmpty()) processStep = "PREPARING"; + QString persistenceError; + DatabaseManager &database = DatabaseManager::instance(); + ProductionRepository repository; + if (!database.transaction(&persistenceError) + || !repository.updateRun(m_runId, runStateForState(state), + stateNameForState(state), processStep, m_currentWorkpiece.id, + isTimedState(m_timeoutState) ? stateNameForState(m_timeoutState) : QString(), + m_recoveryRetryCount, m_lastError, &persistenceError) + || !repository.insertStateHistory(m_runId, m_orderId, m_currentWorkpiece.id, + previous, stateNameForState(state), processStep, + state == ManualConfirm ? "RECOVERY" : "SYSTEM", + QString(), QString(), &persistenceError) + || !database.commit(&persistenceError)) { + database.rollback(); + m_timer->stop(); + pauseProcessTimer(); + m_persistenceUncertain = true; + m_lastError = "保存生产状态失败:" + persistenceError; + m_state = state == ManualConfirm ? ManualConfirm : Error; + emit stateChanged(m_state, stateName()); + emit productionError(m_lastError); + return false; + } + } m_state = state; m_stateTimer.restart(); emit stateChanged(m_state, stateName()); publishVisionControl(); - - if (m_runId > 0) { - QString processStep = processStepForState(state); - if (processStep.isEmpty()) processStep = m_currentWorkpiece.processStep; - if (processStep.isEmpty()) processStep = processStepForState(m_timeoutState); - QString persistenceError; - ProductionRepository repository; - if (!repository.updateRun( - m_runId, runStateForState(state), stateName(), processStep, - m_currentWorkpiece.id, - isTimedState(m_timeoutState) ? stateNameForState(m_timeoutState) - : QString(), - m_recoveryRetryCount, m_lastError, &persistenceError) - || !repository.insertStateHistory( - m_runId, m_orderId, m_currentWorkpiece.id, - previousStateName, stateName(), processStep, - state == RecoveryChecking || state == ManualConfirm - || state == Retrying ? "RECOVERY" : "SYSTEM", - QString(), QString(), &persistenceError)) { - qWarning() << "Failed to persist production state:" << persistenceError; - } - } + return true; } bool ProductionService::claimNextWorkpiece(QString *error) @@ -1222,6 +1701,8 @@ bool ProductionService::claimNextWorkpiece(QString *error) } m_currentWorkpiece = workpiece; + m_restoredRun = false; + m_targetReady = false; m_recoveryRetryCount = 0; m_currentTrayNo = 0; m_currentSlotNo = workpiece.trayPos; @@ -1263,8 +1744,7 @@ bool ProductionService::claimNextWorkpiece(QString *error) emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(m_currentTrayNo, m_currentSlotNo); emitProcessElapsed(); - setState(WaitingDeviceReady); - return true; + return setState(WaitingDeviceReady); } bool ProductionService::updateCurrentProcessStep(const QString &processStep, @@ -1281,14 +1761,31 @@ bool ProductionService::updateCurrentProcessStep(const QString &processStep, const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; const int durationMs = currentProcessElapsedMs(); + ProductionActionCheckpoint next = m_checkpoint; + const bool completingAction = next.phase == "SIGNALS_CLEARED" || next.phase == "MODE_CONFIRMED"; if (!WorkpieceService::instance().updateProcessStepWithRecord( m_currentWorkpiece.id, processStep, m_inspectionMode, m_deviceStatus.currentStep, source, durationMs, error, - forceRestart)) { + forceRestart, [this, &next, completingAction, processStep](QString *commitError) { + if (completingAction) return saveActionCompletion(&next, processStep, + m_currentWorkpiece.id, commitError); + return ProductionRepository().updateRun(m_runId, runStateForState(m_state), + stateName(), processStep, m_currentWorkpiece.id, QString(), + m_recoveryRetryCount, m_lastError, commitError); + })) { + m_persistenceUncertain = true; return false; } m_currentWorkpiece.processStep = processStep; + m_timeoutState = Idle; + if (completingAction) { + m_checkpoint = next; + m_timeoutState = Idle; + m_actionPending = false; + m_actionCompleted = false; + m_inspectionStatusReady = false; + } startProcessTimer(processStep); emitProcessElapsed(); return true; @@ -1297,79 +1794,162 @@ bool ProductionService::updateCurrentProcessStep(const QString &processStep, bool ProductionService::processProductionAction( DeviceService::ProductionAction action, bool *completed, QString *error) { - if (!completed) { - if (error) { - *error = "Action completion pointer is null"; - } + if (!completed) return false; + *completed = false; + if (!ensureActionCheckpoint(m_state, error)) return false; + if (!m_actionError.isEmpty()) { + if (error) *error = m_actionError; return false; } - *completed = false; - - if (ConfigManager::instance().simulationMode()) { + if (m_checkpoint.phase == "SIGNALS_CLEARED") { *completed = true; return true; } - + if (ConfigManager::instance().simulationMode()) { + if (!saveActionPhase("SIGNALS_CLEARED", error)) return false; + *completed = true; + return true; + } + const quint64 generation = m_actionGeneration; + const QString token = m_checkpoint.token; + const int attempt = m_checkpoint.attempt; + auto current = [this, generation, token, attempt]() { + return actionCallbackCurrent(generation, token, attempt); + }; if (!m_actionPending) { + if (m_checkpoint.phase != "NOT_SENT") { + if (error) *error = "动作可能已发送,必须通过恢复流程核对,禁止重发"; + return false; + } + if (action == DeviceService::RackPick && !pickTargetValid()) { + m_visionNeedsReconcile = true; + publishVisionControl(); + reportVision("等待人工核对", "本次取料目标无有效会话", true); + if (error) *error = "本次取料目标无有效会话,请重新视觉识别或确认普通取料"; + return false; + } m_pendingAction = action; m_actionPending = true; m_actionStarting = true; m_actionPollPending = false; m_actionCompleted = false; m_actionError.clear(); - m_actionWasSent = true; - m_deviceService->beginProductionAction( - action, m_currentTrayNo, m_currentSlotNo, - [this](bool success, const QString &actionError) { + m_deviceService->beginProductionAction(action, m_currentTrayNo, m_currentSlotNo, + [this, current](VisionWriteOutcome outcome, const QString &actionError) { + if (!current()) return; m_actionStarting = false; - if (!success) { - m_actionError = actionError; + QString checkpointError; + if (outcome == VisionWriteOutcome::Confirmed) { + if (!saveActionPhase("COMMAND_CONFIRMED", &checkpointError)) + m_actionError = checkpointError; + } else { + if (outcome == VisionWriteOutcome::NotSent + && m_checkpoint.phase == "SENDING" + && !saveActionPhase("NOT_SENT", &checkpointError)) + m_actionError = checkpointError; + if (m_actionError.isEmpty()) m_actionError = actionError.isEmpty() + ? "动作命令未确认,请恢复核对" : actionError; } tryDeferredActionCancel(); + }, [this, current, action]() { + if (!current() || !isActive()) return false; + QString safetyError; + if (!checkRecoverySafety(&safetyError) + || (action == DeviceService::RackPick && !pickTargetValid())) { + m_actionError = safetyError.isEmpty() ? "取料目标已失效" : safetyError; + return false; + } + if (!saveActionPhase("SENDING", &m_actionError)) return false; + return true; }); return true; } - if (m_pendingAction != action) { - if (error) { - *error = "PLC production action does not match current state"; - } + if (error) *error = "PLC动作与当前检查点不一致"; return false; } - - if (!m_actionError.isEmpty()) { - if (error) { - *error = m_actionError; + if (m_actionStarting || m_actionPollPending) return true; + auto beforeClear = [this, current, action](QString *clearError) { + if (!current()) { if (clearError) *clearError = "动作上下文已失效"; return false; } + if (!isActive() || !checkRecoverySafety(clearError)) { + if (clearError && clearError->isEmpty()) *clearError = "生产已停止,保留完成反馈等待恢复"; + return false; } - return false; - } - - if (m_actionStarting || m_actionPollPending) { - return true; - } - - if (m_actionCompleted) { - *completed = true; - m_actionPending = false; - m_actionCompleted = false; - m_actionWasSent = false; - return true; - } - - m_actionPollPending = true; - m_deviceService->pollProductionAction( - [this](bool success, bool completed, - const QString &actionError) { - m_actionPollPending = false; - if (!success) { - m_actionError = actionError; + if (m_checkpoint.phase == "FEEDBACK_RECEIVED") return true; + if (action == DeviceService::Inspect) { + if (!m_inspectionStatusReady) { + if (!m_inspectionStatusPending) { + m_inspectionStatusPending = true; + m_deviceService->requestStatus( + [this, current](bool success, const DeviceStatus &status, const QString &statusError) { + if (!current()) return; + m_inspectionStatusPending = false; + m_inspectionStatusReady = success; + if (success) m_inspectionRawResult = status.checkResult; + m_inspectionStatusError = statusError; + if (!success) m_actionError = "读取完成检测结果失败:" + statusError; + }); + } + return false; // Empty error defers clearing until the fresh status arrives. + } + const int raw = m_inspectionRawResult; + const QString result = resultStateForRawResult(raw); + if (result != "OK" && result != "NG") { + if (clearError) *clearError = "完成反馈对应的检测结果无效"; + return false; + } + DatabaseManager &database = DatabaseManager::instance(); + ProductionRepository repository; + ProductionActionCheckpoint next = m_checkpoint; + next.phase = "FEEDBACK_RECEIVED"; + next.feedback = true; + if (!database.transaction(clearError) + || !repository.insertInspection(m_orderId, m_currentWorkpiece.id, + m_currentWorkpiece.processStep == "FRONT_CHECKING" ? "FRONT" : "BACK", + raw, result, m_inspectionMode, m_deviceStatus.currentStep, "PLC", + "action=" + next.token + ";attempt=" + QString::number(next.attempt), clearError) + || !repository.saveActionCheckpoint(m_runId, m_orderId, m_currentWorkpiece.id, &next, clearError) + || !database.commit(clearError)) { + database.rollback(); + m_persistenceUncertain = true; + return false; + } + m_checkpoint = next; + return true; + } + return saveActionPhase("FEEDBACK_RECEIVED", clearError); + }; + auto cleared = [this, current](bool success, bool finished, const QString &actionError) { + if (!current()) return; + m_actionPollPending = false; + if (!success) { m_actionError = actionError; return; } + if (finished) { + QString checkpointError; + if (!saveActionPhase("SIGNALS_CLEARED", &checkpointError)) { + m_actionError = checkpointError; return; } - if (completed) { - m_actionCompleted = true; + m_actionCompleted = true; + if (m_pendingAction == DeviceService::RackPick) { + if (!saveVisionRecoveryState(false, &checkpointError)) { + m_actionError = checkpointError; + return; + } + m_targetReady = false; + m_visionNeedsReconcile = false; + m_visionStage = VisionStage::Idle; } - tryDeferredActionCancel(); - }); + } + tryDeferredActionCancel(); + }; + m_actionPollPending = true; + if (m_checkpoint.phase == "FEEDBACK_RECEIVED") { + m_deviceService->finishProductionAction( + [cleared](bool success, const QString &clearError) { cleared(success, success, clearError); }, + beforeClear); + } else { + m_deviceService->pollProductionAction(cleared, beforeClear); + } return true; } @@ -1380,7 +1960,12 @@ bool ProductionService::processVisionAction(bool *completed, QString *error) return false; } *completed = false; + if (!ensureActionCheckpoint(VisionProcessing, error)) return false; if (ConfigManager::instance().simulationMode()) { + if (!saveActionPhase("MODE_CONFIRMED", error)) return false; + m_targetReady = true; + m_targetWorkpieceId = m_currentWorkpiece.id; + m_targetUsesVision = false; *completed = true; return true; } @@ -1393,11 +1978,6 @@ bool ProductionService::processVisionAction(bool *completed, QString *error) advanceVision(); return true; } - QString persistenceError; - if (!saveVisionRecoveryState(false, &persistenceError)) { - if (error) *error = persistenceError; - return false; - } m_visionStage = VisionStage::Idle; m_visionCommitStarted = false; m_visionRequest = QJsonObject(); @@ -1489,7 +2069,7 @@ bool ProductionService::executeCurrentAction( if (!updateCurrentProcessStep(nextProcessStep, error)) { return false; } - setState(nextState); + if (!setState(nextState)) { if (error) *error = m_lastError; return false; } if (m_pauseAfterCurrentAction && !pauseAtActionBoundary(error)) { return false; } @@ -1593,80 +2173,104 @@ bool ProductionService::productionActionForState( } void ProductionService::continueRecovery( - State state, DeviceService::ProductionAction action, - const ProductionActionStatus &status) + State state, DeviceService::ProductionAction action, const ProductionActionStatus &status) { - DeviceService::ProductionAction expectedAction; - const bool hasRobotAction = productionActionForState(state, &expectedAction); - if (hasRobotAction && expectedAction != action) { - emit productionError("恢复记录与 PLC 动作类型不一致"); + QString error; + bool freshBoundary = false; + if (m_checkpoint.phase == "STEP_COMMITTED") { + if (m_checkpoint.nextStep != m_currentWorkpiece.processStep) { + finishRecoveryCheck("已提交动作与下一工序不一致"); return; + } + m_restoredRun = false; + if (!ensureActionCheckpoint(state, &error)) { finishRecoveryCheck(error); return; } + freshBoundary = true; + } + const bool matching = m_checkpoint.type == actionTypeForState(state) + && m_checkpoint.nextStep == nextStepForState(state); + const QString phase = m_checkpoint.phase; + if (!phase.isEmpty() && !matching) { + requestManualDecision(state, status, "动作类型或下一工序与保存记录矛盾,请先核对记录", {}); return; } - - if (hasRobotAction && !status.command && !status.feedback - && m_actionWasSent) { - m_timeoutState = state; - m_lastError = "动作记录显示命令曾发送,但命令和反馈均为 0,无法确认是否执行"; - setState(ManualConfirm); - emit timeoutRecoveryRequired(stateNameForState(state), m_lastError); - emit productionError(m_lastError); + if (phase.isEmpty() + || (phase == "NOT_SENT" && (status.command || status.feedback)) + || ((phase == "SENDING" || phase == "COMMAND_CONFIRMED") + && !status.command && !status.feedback)) { + QStringList choices; + if ((!status.command || status.feedback) && !m_deviceService->productionActionBusy()) { + choices << "ACTION_COMPLETED"; + if (!status.command && !status.feedback) choices << "ACTION_NOT_EXECUTED"; + } + requestManualDecision(state, status, + "动作记录与当前信号无法确认是否执行;请核对机器人位置、工件和当前独立动作", + choices); return; } - - if (hasRobotAction && (status.command || status.feedback)) { - m_deviceService->adoptProductionAction(action); - m_pendingAction = action; - m_actionPending = true; - m_actionStarting = false; - m_actionPollPending = false; - m_actionCompleted = false; - m_actionError.clear(); - m_actionWasSent = true; - } else if (hasRobotAction) { - const ProductionConfig config = ConfigManager::instance().productionConfig(); - if (m_recoveryRetryCount >= config.maxRecoveryRetries) { - emit productionError("Maximum timeout recovery retries reached"); + if (phase == "SIGNALS_CLEARED") { + if (status.command || status.feedback) { + requestManualDecision(state, status, "检查点显示握手已清,但PLC信号非零,请核对", {}); return; } - ++m_recoveryRetryCount; + if (action == DeviceService::RackPick && m_visionNeedsReconcile) { + if (!saveVisionRecoveryState(false, &error)) { finishRecoveryCheck(error); return; } + m_visionNeedsReconcile = false; + m_visionStage = VisionStage::Idle; + } m_actionPending = false; - m_actionWasSent = false; - persistRecoveryAction( - "RETRY", - QString("Retry action at %1 before any command was sent") - .arg(stateNameForState(state))); + resumeRecoveredState(state); + return; } - - m_deviceService->setInspectionMode( - m_inspectionMode, - [this, state, hasRobotAction, status](bool success, - const QString &modeError) { - if (!success) { - emit productionError(modeError); + if (phase == "NOT_SENT") { + if (!freshBoundary && m_checkpoint.attempt >= ConfigManager::instance().productionConfig().maxRecoveryRetries + 1) { + finishRecoveryCheck("当前动作已达到最大重试次数"); return; + } + if (action == DeviceService::RackPick && !pickTargetValid()) { + checkVisionRecovery(); return; + } + if (!freshBoundary) { + ProductionActionCheckpoint retry = m_checkpoint; + ++retry.attempt; + if (!ProductionRepository().saveActionCheckpoint(m_runId, m_orderId, + m_currentWorkpiece.id, &retry, &error)) { + m_persistenceUncertain = true; + finishRecoveryCheck(error); return; } - QString persistenceError; - if (!m_recoveryAlarmCode.isEmpty() - && !ProductionRepository().clearActiveAlarms( - m_recoveryAlarmCode, "RECOVERY", &persistenceError)) { - emit productionError(persistenceError); - return; - } - m_recoveryAlarmCode.clear(); - m_lastError.clear(); - m_timeoutState = state; - m_pauseAfterCurrentAction = false; - persistRecoveryAction("CONTINUE", - QString("Resume from %1") - .arg(stateNameForState(state))); - setState(state); - m_actionWasSent = hasRobotAction && (status.command || status.feedback); - resumeProcessTimer(); - m_heartbeatTimer.restart(); - m_timer->start(ProductionTickIntervalMs); - emit recoveryCompleted(stateNameForState(state)); - tick(); - }); + m_checkpoint = retry; + } + ++m_actionGeneration; + m_actionPending = false; + m_actionStarting = false; + m_actionPollPending = false; + m_inspectionStatusReady = false; + m_inspectionStatusPending = false; + m_inspectionStatusError.clear(); + if (m_deviceService->productionActionActive()) { + const quint64 generation = m_recoveryGeneration; + m_deviceService->cancelProductionAction([this, generation, state](bool success, const QString &clearError) { + if (generation != m_recoveryGeneration || stopRequested()) return; + if (!success) { finishRecoveryCheck(clearError); return; } + resumeRecoveredState(state); + }); + } else resumeRecoveredState(state); + return; + } + if (phase != "FEEDBACK_RECEIVED" && phase != "SENDING" && phase != "COMMAND_CONFIRMED") { + finishRecoveryCheck("不能从当前动作检查点恢复"); return; + } + if (phase == "FEEDBACK_RECEIVED" && status.command && !status.feedback) { + requestManualDecision(state, status, "已完成证据与PLC正在执行信号矛盾,请先核对", {}); + return; + } + m_deviceService->adoptProductionAction(action); + m_pendingAction = action; + m_actionPending = true; + m_actionStarting = false; + m_actionPollPending = false; + m_actionCompleted = false; + m_actionError.clear(); + ++m_actionGeneration; + resumeRecoveredState(state); } bool ProductionService::ensureOrderRunning(QString *error) @@ -1735,36 +2339,6 @@ bool ProductionService::checkRecoverySafety(QString *error) const return true; } -bool ProductionService::mapPlcStepToState(State *state, QString *processStep) const -{ - if (!state || !processStep) { - return false; - } - - const ProductionConfig config = ConfigManager::instance().productionConfig(); - if (m_deviceStatus.currentStep == config.loadStep) { - *state = Loading; - *processStep = "LOADING"; - return true; - } - if (m_deviceStatus.currentStep == config.frontCheckStep) { - *state = FrontChecking; - *processStep = "FRONT_CHECKING"; - return true; - } - if (m_deviceStatus.currentStep == config.backCheckStep) { - *state = BackChecking; - *processStep = "BACK_CHECKING"; - return true; - } - if (m_deviceStatus.currentStep == config.unloadStep - || m_deviceStatus.currentStep == config.cycleCompleteStep) { - *state = Judging; - *processStep = "JUDGING"; - return true; - } - return false; -} void ProductionService::persistRecoveryAction(const QString &action, const QString &message) @@ -1801,19 +2375,29 @@ bool ProductionService::finishCurrentWorkpiece(const QString &state, const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; + ProductionActionCheckpoint next = m_checkpoint; if (!WorkpieceService::instance().completeWithInspection( m_currentWorkpiece.id, state, processStep, previousProcessStep, processDurationMs, rawResult, state, - m_deviceStatus.currentStep, m_inspectionMode, source, error)) { + m_deviceStatus.currentStep, m_inspectionMode, source, error, + [this, &next, processStep](QString *commitError) { + return saveActionCompletion(&next, processStep, 0, commitError); + })) { + m_persistenceUncertain = true; return false; } + m_checkpoint = next; + m_timeoutState = Idle; + m_actionPending = false; + m_actionCompleted = false; clearProcessTimer(); m_currentWorkpiece = Workpiece(); emit currentWorkpieceChanged(0, QString()); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(0, 0); - setState(Preparing); + if (!setState(Preparing)) { if (error) *error = m_lastError; return false; } + if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error); return true; } @@ -1834,7 +2418,7 @@ bool ProductionService::finishOrder(QString *error) } m_timer->stop(); - setState(Completed); + if (!setState(Completed)) { if (error) *error = m_lastError; return false; } emit productionFinished(m_orderId); return true; } @@ -1859,6 +2443,18 @@ void ProductionService::tick() if (!isActive()) { return; } + if (m_persistenceUncertain) { + const QString persistenceError = !m_actionError.isEmpty() ? m_actionError + : (!m_lastError.isEmpty() ? m_lastError : "动作检查点保存失败,必须重新读取恢复状态"); + m_timer->stop(); + pauseProcessTimer(); + m_lastError = persistenceError; + m_state = Error; + emit stateChanged(m_state, stateName()); + emit productionError(persistenceError); + publishVisionControl(); + return; + } if (m_starting) { return; @@ -1910,6 +2506,19 @@ void ProductionService::tick() return; } + DeviceService::ProductionAction timedAction; + if (productionActionForState(m_state, &timedAction) + && m_stateTimer.isValid() + && m_stateTimer.elapsed() > ConfigManager::instance().productionConfig().stateTimeoutMs) { + m_timeoutState = m_state; + m_lastError = "当前独立动作超时,请核对后恢复/重试"; + m_timer->stop(); + pauseProcessTimer(); + setState(TimeoutPaused); + emit timeoutRecoveryRequired(stateNameForState(m_timeoutState), m_lastError); + return; + } + if (m_state == WaitingDeviceReady) { if (m_deviceStatus.plcReady && m_deviceStatus.robotReady) { QString error; @@ -1988,7 +2597,7 @@ bool ProductionService::processProductionStep(State state, QString *error) if (!processVisionAction(&completed, error)) return false; if (!completed) return false; if (!updateCurrentProcessStep("RACK_PICKING", error)) return false; - setState(RackPicking); + if (!setState(RackPicking)) { if (error) *error = m_lastError; return false; } if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error); return true; } @@ -2000,60 +2609,22 @@ bool ProductionService::processProductionStep(State state, QString *error) "FRONT_CHECKING", FrontChecking, error); case FrontChecking: { bool completed = false; - if (!processProductionAction( - DeviceService::Inspect, &completed, error)) { + if (!processProductionAction(DeviceService::Inspect, &completed, error) || !completed) + return false; + int raw = ConfigManager::instance().productionConfig().simulationResult; + QString result = resultStateForRawResult(raw); + const QString side = "FRONT"; + if (ConfigManager::instance().simulationMode()) { + if (!recordInspection(side, raw, result, error)) return false; + } else if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + side, &raw, &result, error, m_checkpoint.token, m_checkpoint.attempt)) { return false; } - if (!completed) { - return false; - } - if (!ConfigManager::instance().simulationMode()) { - if (!m_inspectionStatusReady) { - if (!m_inspectionStatusPending) { - m_inspectionStatusPending = true; - m_deviceService->requestStatus( - [this](bool success, const DeviceStatus &, - const QString &statusError) { - m_inspectionStatusPending = false; - m_inspectionStatusReady = success; - m_inspectionStatusError = statusError; - }); - } - if (m_inspectionStatusPending) { - return true; - } - if (!m_inspectionStatusReady) { - if (error) { - *error = m_inspectionStatusError; - } - return false; - } - } - } - const int frontRawResult = ConfigManager::instance().simulationMode() - ? ConfigManager::instance().productionConfig().simulationResult - : static_cast(m_deviceStatus.checkResult); - const QString frontResultState = - resultStateForRawResult(frontRawResult); - if (frontResultState == "UNKNOWN" || frontResultState == "ERROR") { - if (error) { - *error = QString("Invalid front inspection result: %1") - .arg(frontRawResult); - } - return false; - } - if (!recordInspection("FRONT", frontRawResult, - frontResultState, error)) { - return false; - } - m_inspectionStatusReady = false; - m_inspectionStatusError.clear(); - m_frontRawResult = frontRawResult; - m_frontResultState = frontResultState; - if (!updateCurrentProcessStep("FRONT_UNLOADING", error)) { - return false; - } - setState(FrontUnloading); + m_frontRawResult = raw; + m_frontResultState = result; + if (!updateCurrentProcessStep("FRONT_UNLOADING", error)) return false; + if (!setState(FrontUnloading)) { if (error) *error = m_lastError; return false; } + if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error); return true; } case FrontUnloading: @@ -2070,63 +2641,26 @@ bool ProductionService::processProductionStep(State state, QString *error) "BACK_CHECKING", BackChecking, error); case BackChecking: { bool completed = false; - if (!processProductionAction( - DeviceService::Inspect, &completed, error)) { + if (!processProductionAction(DeviceService::Inspect, &completed, error) || !completed) + return false; + int raw = ConfigManager::instance().productionConfig().simulationResult; + QString result = resultStateForRawResult(raw); + const QString side = "BACK"; + if (ConfigManager::instance().simulationMode()) { + if (!recordInspection(side, raw, result, error)) return false; + } else if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + side, &raw, &result, error, m_checkpoint.token, m_checkpoint.attempt)) { return false; } - if (!completed) { - return false; - } - if (!ConfigManager::instance().simulationMode()) { - if (!m_inspectionStatusReady) { - if (!m_inspectionStatusPending) { - m_inspectionStatusPending = true; - m_deviceService->requestStatus( - [this](bool success, const DeviceStatus &, - const QString &statusError) { - m_inspectionStatusPending = false; - m_inspectionStatusReady = success; - m_inspectionStatusError = statusError; - }); - } - if (m_inspectionStatusPending) { - return true; - } - if (!m_inspectionStatusReady) { - if (error) { - *error = m_inspectionStatusError; - } - return false; - } - } - } - const int backRawResult = ConfigManager::instance().simulationMode() - ? ConfigManager::instance().productionConfig().simulationResult - : static_cast(m_deviceStatus.checkResult); - const QString backResultState = - resultStateForRawResult(backRawResult); - if (backResultState == "UNKNOWN" || backResultState == "ERROR") { - if (error) { - *error = QString("Invalid back inspection result: %1") - .arg(backRawResult); - } - return false; - } - if (!recordInspection("BACK", backRawResult, - backResultState, error)) { - return false; - } - m_inspectionStatusReady = false; - m_inspectionStatusError.clear(); - const QString finalState = - m_frontResultState == "OK" && backResultState == "OK" - ? "OK" : "NG"; - if (!updateCurrentProcessStep("BACK_UNLOADING", error)) { - return false; - } - m_frontResultState = finalState; - setState(BackUnloading); - break; + QString front; + int frontRaw = 0; + if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + "FRONT", &frontRaw, &front, error)) return false; + m_frontResultState = front == "OK" && result == "OK" ? "OK" : "NG"; + if (!updateCurrentProcessStep("BACK_UNLOADING", error)) return false; + if (!setState(BackUnloading)) { if (error) *error = m_lastError; return false; } + if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error); + return true; } case BackUnloading: return executeCurrentAction(DeviceService::BackUnload, @@ -2141,6 +2675,19 @@ bool ProductionService::processProductionStep(State state, QString *error) return false; } QString finalState = m_frontResultState; + if (finalState != "OK" && finalState != "NG") { + int raw = 0; + QString front; + if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + "FRONT", &raw, &front, error)) return false; + finalState = front; + if (m_inspectionMode != "AFTER_PLATING") { + QString back; + if (!ProductionRepository().findInspectionResult(m_currentWorkpiece.id, + "BACK", &raw, &back, error)) return false; + finalState = front == "OK" && back == "OK" ? "OK" : "NG"; + } + } if (finalState != "OK" && finalState != "NG") { if (error) { *error = "Final inspection result is not available"; @@ -2157,61 +2704,9 @@ bool ProductionService::processProductionStep(State state, QString *error) bool ProductionService::recoverFromPlcStep(QString *error) { - if (!checkRecoverySafety(error)) { - return true; - } - - if (ConfigManager::instance().simulationMode() - && isTimedState(m_timeoutState)) { - setState(m_timeoutState); - emit recoveryCompleted("SIMULATION_STATE"); - return true; - } - - if (m_timeoutState == Preparing) { - setState(Preparing); - emit recoveryCompleted("PREPARING"); - return true; - } - - if (m_timeoutState == WaitingDeviceReady) { - if (m_deviceStatus.plcReady && m_deviceStatus.robotReady) { - if (m_currentWorkpiece.id > 0 - && m_currentWorkpiece.processStep != "LOADING" - && !updateCurrentProcessStep("LOADING", error)) { - return false; - } - setState(Loading); - } else { - setState(WaitingDeviceReady); - } - emit recoveryCompleted("DEVICE_STATUS"); - return true; - } - - State recoveredState = Idle; - QString processStep; - if (!mapPlcStepToState(&recoveredState, &processStep)) { - m_timer->stop(); - setState(ManualConfirm); - const QString message = QString("PLC current step %1 cannot be mapped automatically") - .arg(m_deviceStatus.currentStep); - emit timeoutRecoveryRequired(stateName(), message); - return true; - } - - if (m_currentWorkpiece.id > 0 - && m_currentWorkpiece.processStep != processStep - && !updateCurrentProcessStep(processStep, error)) { - return false; - } - persistRecoveryAction( - "PLC_STEP", - QString("Recovered from PLC step %1 to %2") - .arg(m_deviceStatus.currentStep).arg(processStep)); - setState(recoveredState); - emit recoveryCompleted("PLC_CURRENT_STEP"); - return true; + m_timer->stop(); + if (error) *error = "请使用恢复/重试核对独立动作检查点,不能仅凭PLC工序跳转"; + return false; } bool ProductionService::isTimedState(State state) const diff --git a/services/productionservice.h b/services/productionservice.h index e0ec3d3..212d3cf 100644 --- a/services/productionservice.h +++ b/services/productionservice.h @@ -4,6 +4,7 @@ #include "deviceservice.h" #include "../models/workpiece.h" +#include "../repositories/productionrepository.h" #include #include @@ -64,6 +65,7 @@ public: bool stop(QString *error = nullptr); bool clearAlarm(QString *error = nullptr); bool recover(QString *error = nullptr); + bool submitRecoveryDecision(const QJsonObject &decision, QString *error = nullptr); bool markCurrentWorkpieceNg(QString *error = nullptr); bool restoreActiveRun(QString *error = nullptr); void shutdown(const DeviceService::OperationCallback &callback); @@ -89,6 +91,8 @@ signals: void timeoutWarning(const QString &state, int elapsedMs, int timeoutMs); void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); + void recoveryDecisionRequired(const QJsonObject &context); + void recoveryBusyChanged(bool busy); void visionMeasureRequested(const QJsonObject &request); void visionCancelRequested(const QString &requestId); void visionCycleChanged(const QJsonObject &cycle); @@ -118,14 +122,29 @@ private: void reportVision(const QString &phase, const QString &message, bool invalidated = false); void invalidateVision(const QString &reason); void visionFault(const QString &reason); - bool recoverVision(QString *error); void publishVisionControl(); bool saveVisionRecoveryState(bool pending, QString *error); void loadVisionRecoveryState(); ProductionService(const ProductionService &) = delete; ProductionService &operator=(const ProductionService &) = delete; - void setState(State state); + bool setState(State state); + QString actionTypeForState(State state) const; + QString nextStepForState(State state) const; + bool ensureActionCheckpoint(State state, QString *error); + bool saveActionPhase(const QString &phase, QString *error); + bool saveActionCompletion(ProductionActionCheckpoint *action, + const QString &nextStep, int nextWorkpieceId, + QString *error); + bool actionCallbackCurrent(quint64 generation, const QString &token, int attempt) const; + bool loadRecoverySnapshot(QString *error); + void finishRecoveryCheck(const QString &error = QString()); + void requestManualDecision(State state, const ProductionActionStatus &status, + const QString &reason, const QStringList &options); + void resumeRecoveredState(State state); + bool saveManualDecision(const QJsonObject &decision, QString *error); + void checkVisionRecovery(const QJsonObject &decision = QJsonObject()); + bool pickTargetValid() const; bool claimNextWorkpiece(QString *error); bool updateCurrentProcessStep(const QString &processStep, QString *error, bool forceRestart = false); @@ -157,7 +176,6 @@ private: QString resultStateForRawResult(int rawResult) const; bool ensureOrderRunning(QString *error); bool checkRecoverySafety(QString *error) const; - bool mapPlcStepToState(State *state, QString *processStep) const; void startProcessTimer(const QString &processStep); void pauseProcessTimer(); void resumeProcessTimer(); @@ -199,18 +217,31 @@ private: bool m_actionStarting; bool m_actionPollPending; bool m_actionCompleted; - bool m_actionWasSent; QString m_actionError; bool m_actionCancelRequested; DeviceService::OperationCallback m_deferredCancelCallback; bool m_inspectionStatusPending; bool m_inspectionStatusReady; + int m_inspectionRawResult = 0; QString m_inspectionStatusError; bool m_starting; bool m_plcStarted; bool m_tickRunning; bool m_pauseAfterCurrentAction; bool m_recoveryCheckPending; + quint64 m_actionGeneration = 0; + quint64 m_recoveryGeneration = 0; + ProductionActionCheckpoint m_checkpoint; + QJsonObject m_manualContext; + bool m_recoveryKeepPaused = false; + bool m_recoveryIdleUnlock = false; + bool m_targetReady = false; + int m_targetWorkpieceId = 0; + QString m_targetSession; + bool m_targetUsesVision = false; + bool m_forceNormalPick = false; + bool m_restoredRun = false; + bool m_persistenceUncertain = false; DeviceService::ProductionAction m_pendingAction; QString m_inspectionMode; QString m_frontResultState; @@ -235,8 +266,6 @@ private: bool m_visionSuspended = false; bool m_visionCommitStarted = false; bool m_visionNeedsReconcile = false; - bool m_visionRecoveryChecking = false; - bool m_visionFaultCleanupPending = false; QString m_visionStatePath; }; diff --git a/services/productionworker.cpp b/services/productionworker.cpp index a10c6cd..10fec3e 100644 --- a/services/productionworker.cpp +++ b/services/productionworker.cpp @@ -45,6 +45,10 @@ void ProductionWorker::ensureService() this, &ProductionWorker::timeoutRecoveryRequired); connect(m_service, &ProductionService::recoveryCompleted, this, &ProductionWorker::recoveryCompleted); + connect(m_service, &ProductionService::recoveryDecisionRequired, + this, &ProductionWorker::recoveryDecisionRequired); + connect(m_service, &ProductionService::recoveryBusyChanged, + this, &ProductionWorker::recoveryBusyChanged); } void ProductionWorker::requestStopImmediate() @@ -119,6 +123,13 @@ void ProductionWorker::requestRecover() reportFailure(m_service->recover(&error), error); } +void ProductionWorker::requestRecoveryDecision(const QJsonObject &decision) +{ + ensureService(); + QString error; + reportFailure(m_service->submitRecoveryDecision(decision, &error), error); +} + void ProductionWorker::requestMarkNg() { ensureService(); diff --git a/services/productionworker.h b/services/productionworker.h index ca0afea..26721db 100644 --- a/services/productionworker.h +++ b/services/productionworker.h @@ -21,6 +21,7 @@ public slots: void requestStop(); void requestClearAlarm(); void requestRecover(); + void requestRecoveryDecision(const QJsonObject &decision); void requestMarkNg(); void requestRestore(); void requestShutdown(); @@ -42,6 +43,8 @@ signals: void timeoutWarning(const QString &state, int elapsedMs, int timeoutMs); void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); + void recoveryDecisionRequired(const QJsonObject &context); + void recoveryBusyChanged(bool busy); void shutdownReady(); void visionMeasureRequested(const QJsonObject &request); void visionCancelRequested(const QString &requestId); diff --git a/services/workpieceservice.cpp b/services/workpieceservice.cpp index 9ab3d08..95e79cc 100644 --- a/services/workpieceservice.cpp +++ b/services/workpieceservice.cpp @@ -280,7 +280,7 @@ bool WorkpieceService::updateState(int id, const QString &state, bool WorkpieceService::updateProcessStepWithRecord( int id, const QString &processStep, const QString &inspectionMode, int plcStep, const QString &source, int durationMs, QString *error, - bool forceRestart) + bool forceRestart, const std::function &beforeCommit) { if (id <= 0 || processStep.trimmed().isEmpty()) { if (error) { @@ -344,6 +344,7 @@ bool WorkpieceService::updateProcessStepWithRecord( QString("工件 %1 工序更新为 %2") .arg(workpiece.barcode, processStep), &transactionError) + || (beforeCommit && !beforeCommit(&transactionError)) || !database.commit(&transactionError)) { database.rollback(); if (error) { @@ -358,7 +359,8 @@ bool WorkpieceService::completeWithInspection( int id, const QString &state, const QString &processStep, const QString &previousProcessStep, int durationMs, int rawResult, const QString &resultState, int plcStep, const QString &inspectionMode, - const QString &source, QString *error) + const QString &source, QString *error, + const std::function &beforeCommit) { if (id <= 0) { if (error) { @@ -408,6 +410,7 @@ bool WorkpieceService::completeWithInspection( QString("工件 %1 检测结果为 %2") .arg(workpiece.barcode, resultState), &transactionError) + || (beforeCommit && !beforeCommit(&transactionError)) || !database.commit(&transactionError)) { database.rollback(); if (error) { diff --git a/services/workpieceservice.h b/services/workpieceservice.h index fb08fb3..eda422e 100644 --- a/services/workpieceservice.h +++ b/services/workpieceservice.h @@ -4,6 +4,7 @@ #include "../models/workpiece.h" #include +#include class WorkpieceService { @@ -25,7 +26,8 @@ public: const QString &source, int durationMs, QString *error = nullptr, - bool forceRestart = false); + bool forceRestart = false, + const std::function &beforeCommit = {}); bool recordInspection(int id, const QString &side, int rawResult, const QString &resultState, int plcStep, const QString &inspectionMode, const QString &source, @@ -38,7 +40,8 @@ public: const QString &resultState, int plcStep, const QString &inspectionMode, const QString &source, - QString *error = nullptr); + QString *error = nullptr, + const std::function &beforeCommit = {}); private: WorkpieceService() = default; diff --git a/ssp.pro.user b/ssp.pro.user index 3d5a8f9..e90fab3 100644 --- a/ssp.pro.user +++ b/ssp.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId