diff --git a/.gitignore b/.gitignore index 016f806..d2c4bc0 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ /tests/ +*.vision-state.json diff --git a/config.ini b/config.ini index 2d527ce..40e050f 100644 --- a/config.ini +++ b/config.ini @@ -81,28 +81,28 @@ simulation=false productionEnabled=true [vision] -; Enable only after the complete PLC/robot contract has been verified. +; Recognition switch only; the M850/M851 photo-position stage always precedes RackPick. enabled=false -contractConfirmed=false +contractConfirmed=true photoPoseReadyConfirmed=true executablePath=E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-integration/bin/VisionGuide.exe ipcName=ssp_visionguide_v1 startupTimeoutMs=15000 initializeTimeoutMs=60000 requestTimeoutMs=15000 -robotAckTimeoutMs=10000 photoPoseR=40 graspPoseR=60 lowWordFirst=true -robotReceivedCoil=850 -photoRequestCoil=851 -comparingCoil=852 -comparisonErrorCoil=853 -comparisonPassedCoil=854 -; Accepted initial contract: request/ack PLC-owned; other 3 ssp-owned. -handshakeProtocol=request_compare_result_ack_v1 -writableSignals=comparing, comparisonError, comparisonPassed -actionNames=RackPick +photoMoveCoil=850 +photoArrivedCoil=851 +comparisonPickCoil=852 +; ssp clears M850/M851 after arrival; M852 is overwritten before each RackPick and retained. [visionTrayMap] -; Explicit ssp tray number = VisionGuide tray number, for example 1=1. +; All six physical trays use VisionGuide configuration 1. +1=1 +2=1 +3=1 +4=1 +5=1 +6=1 diff --git a/config/configmanager.cpp b/config/configmanager.cpp index 96987dc..7842d70 100644 --- a/config/configmanager.cpp +++ b/config/configmanager.cpp @@ -9,12 +9,11 @@ bool VisionConfig::isValid(QString *error) const { QStringList errors; - if (!enabled || !contractConfirmed || !photoPoseReadyConfirmed) { - errors.append("Vision PLC contract is disabled or not confirmed"); + if (!contractConfirmed || !photoPoseReadyConfirmed) { + errors.append("Photo-position PLC contract is not confirmed"); } if (ipcName.trimmed().isEmpty() || startupTimeoutMs <= 0 - || initializeTimeoutMs <= 0 || requestTimeoutMs <= 5000 - || robotAckTimeoutMs <= 0) { + || initializeTimeoutMs <= 0 || requestTimeoutMs <= 5000) { errors.append("Vision IPC name or timeouts are invalid"); } if (photoPoseR < 0 || photoPoseR > 32756 || photoPoseR % 2 @@ -22,8 +21,7 @@ bool VisionConfig::isValid(QString *error) const || qAbs(photoPoseR - graspPoseR) < 12) { errors.append("Vision REAL blocks must be distinct, even, 12-word R ranges"); } - const int coils[] = {robotReceivedCoil, photoRequestCoil, comparingCoil, - comparisonErrorCoil, comparisonPassedCoil}; + const int coils[] = {photoMoveCoil, photoArrivedCoil, comparisonPickCoil}; QSet unique; for (int coil : coils) { if (coil < 0 || coil > 65535 || unique.contains(coil)) { @@ -32,24 +30,6 @@ bool VisionConfig::isValid(QString *error) const } unique.insert(coil); } - const QSet outputs = {"comparing", "comparisonError", "comparisonPassed"}; - const QSet configured(writableSignals.begin(), writableSignals.end()); - if (handshakeProtocol != "request_compare_result_ack_v1" || configured != outputs - || writableSignals.size() != outputs.size()) { - errors.append("Vision handshake ownership and protocol are not confirmed"); - } - const QStringList knownActions = {"RackPick", "FrontUnload", "BackUnload"}; - if (actionNames.isEmpty()) { - errors.append("Vision production actions are not configured"); - } - for (const QString &action : actionNames) { - if (!knownActions.contains(action)) { - errors.append("Vision action must be a confirmed pickup action: " + action); - } - } - if (trayMap.isEmpty()) { - errors.append("Vision tray mapping is not configured"); - } for (auto it = trayMap.constBegin(); it != trayMap.constEnd(); ++it) { if (it.key() < 1 || it.value() < 1 || it.value() > 99) { errors.append("Vision tray mapping is invalid"); @@ -220,20 +200,12 @@ bool ConfigManager::load(const QString &filePath) m_visionConfig.startupTimeoutMs = settings.value("vision/startupTimeoutMs", m_visionConfig.startupTimeoutMs).toInt(); m_visionConfig.initializeTimeoutMs = settings.value("vision/initializeTimeoutMs", m_visionConfig.initializeTimeoutMs).toInt(); m_visionConfig.requestTimeoutMs = settings.value("vision/requestTimeoutMs", m_visionConfig.requestTimeoutMs).toInt(); - m_visionConfig.robotAckTimeoutMs = settings.value("vision/robotAckTimeoutMs", m_visionConfig.robotAckTimeoutMs).toInt(); m_visionConfig.photoPoseR = settings.value("vision/photoPoseR", 40).toInt(); m_visionConfig.graspPoseR = settings.value("vision/graspPoseR", 60).toInt(); m_visionConfig.lowWordFirst = settings.value("vision/lowWordFirst", true).toBool(); - m_visionConfig.robotReceivedCoil = settings.value("vision/robotReceivedCoil", -1).toInt(); - m_visionConfig.photoRequestCoil = settings.value("vision/photoRequestCoil", -1).toInt(); - m_visionConfig.comparingCoil = settings.value("vision/comparingCoil", -1).toInt(); - m_visionConfig.comparisonErrorCoil = settings.value("vision/comparisonErrorCoil", -1).toInt(); - m_visionConfig.comparisonPassedCoil = settings.value("vision/comparisonPassedCoil", -1).toInt(); - m_visionConfig.handshakeProtocol = settings.value("vision/handshakeProtocol").toString(); - m_visionConfig.writableSignals = settings.value("vision/writableSignals").toStringList(); - m_visionConfig.actionNames = settings.value("vision/actionNames").toStringList(); - m_visionConfig.writableSignals.removeAll(QString()); - m_visionConfig.actionNames.removeAll(QString()); + m_visionConfig.photoMoveCoil = settings.value("vision/photoMoveCoil", 850).toInt(); + m_visionConfig.photoArrivedCoil = settings.value("vision/photoArrivedCoil", 851).toInt(); + m_visionConfig.comparisonPickCoil = settings.value("vision/comparisonPickCoil", 852).toInt(); settings.beginGroup("visionTrayMap"); for (const QString &key : settings.childKeys()) { bool validKey = false; diff --git a/config/configmanager.h b/config/configmanager.h index 1d3b210..496576d 100644 --- a/config/configmanager.h +++ b/config/configmanager.h @@ -18,18 +18,12 @@ struct VisionConfig int startupTimeoutMs = 15000; int initializeTimeoutMs = 60000; int requestTimeoutMs = 15000; - int robotAckTimeoutMs = 10000; int photoPoseR = 40; int graspPoseR = 60; bool lowWordFirst = true; - int robotReceivedCoil = -1; - int photoRequestCoil = -1; - int comparingCoil = -1; - int comparisonErrorCoil = -1; - int comparisonPassedCoil = -1; - QString handshakeProtocol; - QStringList writableSignals; - QStringList actionNames; + int photoMoveCoil = 850; + int photoArrivedCoil = 851; + int comparisonPickCoil = 852; QMap trayMap; bool isValid(QString *error = nullptr) const; diff --git a/docs/2026-10-27-visionguide-process-implementation-steps.md b/docs/2026-10-27-visionguide-process-implementation-steps.md index c4391b3..948f6fc 100644 --- a/docs/2026-10-27-visionguide-process-implementation-steps.md +++ b/docs/2026-10-27-visionguide-process-implementation-steps.md @@ -1,5 +1,7 @@ # 方案二:按模块实施 R40 → VisionGuide → R60 +> 历史实施记录:2026-10-28 起,PLC 五信号握手和视觉失败策略已由 `superpowers/specs/2026-10-28-photo-position-pick-design.md` 及 `visionguide-integration-status.md` 顶部的新协议替代。当前 M850=移动请求、M851=到位反馈、M852=取料模式;普通 RackPick 在这些准备操作完成后才启动。 + 更新:2026-10-27。状态:模块 A–F 已实施,ssp 的 Qt 5.14.1 / MinGW 32 位工程已编译,VisionGuide 独立 MSVC x64 工程已编译;PLC、IPC、生产流程已完成无硬件模拟测试。未连接真实 PLC/相机/机器人;现场验收尚待完成。实际交付与测试见 `docs/visionguide-integration-status.md`。 ## 1. 已确定目标与边界 diff --git a/docs/superpowers/specs/2026-10-28-photo-position-pick-design.md b/docs/superpowers/specs/2026-10-28-photo-position-pick-design.md new file mode 100644 index 0000000..9d46a58 --- /dev/null +++ b/docs/superpowers/specs/2026-10-28-photo-position-pick-design.md @@ -0,0 +1,15 @@ +# 拍照到位与取料模式(已确认) + +本文件替代旧 850–854 五信号流程。ssp 与 VisionGuide 同机、同用户,以现有本机 IPC 通信。 + +每次料架取料(即使关闭视觉识别)先写托盘号和格位,再置 M850。收到 M851 后由 ssp 依次清 M850、M851,再决定是否识别;此期间机器人保持拍照位,R40 为本次 XYZABC。仅此准备阶段完成后才启动原 RackPick。 + +识别开关使用 vision/enabled。关闭时写 M852=0;开启且识别成功时先确认整组 R60 写入,再写 M852=1;初始化失败、测量失败、无效结果、超时或视觉连接不可用时不写 R60,记录原因并写 M852=0。缺少料盘映射视为本次视觉不可用,不猜测配置号。确认 M852 写入后才能启动 RackPick;M852 在动作后保持,不清零。M853、M854 不再使用。 + +PLC 通信错误、到位超时、R60 或 M852 写入未确认仍停止并要求核对;不能把 PLC 写入失败当作视觉失败放行。暂停、停止、进程重启和旧请求的保护继续保留,恢复不依赖相机就绪。恢复仅核对 M850/M851,不清 M852,不重发旧 R60。 + +VisionGuide 在 SDK 初始化、程序启动后自动执行一次相机连接、参数应用和白平衡。收到测量请求时,若相机未初始化成功,重试初始化一次;成功继续同一请求,失败返回关联该请求的结构化错误。启动初始化过程中允许暂存一个测量请求,禁止并发初始化/采图。客户端必须允许向未就绪但已连接的服务发送测量,等待预算包含启动初始化、一次重试与测量。 + +PLC 坐标仍为 6 个 float32(12 字),支持负数;沿用现有字序配置、固定视觉参数和标定规则。本轮不连接真实设备、不自动提交 Git。 + +验证:模拟 PLC 检查托盘/格位→M850→M851→清位→R40/测量→R60→M852→RackPick 顺序、关闭视觉、各类视觉失败降级、M852 保持及逐次覆盖、PLC 失败阻断、暂停/停止/迟到结果/恢复。IPC 验证未就绪测量及初始化中的单请求;相机替身验证初始化成功、失败重试与白平衡。编译 ssp 与 VisionGuide。 diff --git a/docs/visionguide-integration-status.md b/docs/visionguide-integration-status.md index aef164f..75bb732 100644 --- a/docs/visionguide-integration-status.md +++ b/docs/visionguide-integration-status.md @@ -1,7 +1,29 @@ # VisionGuide 独立进程接入交付记录 +## 2026-10-28:按最新确认改为拍照到位前置流程 + +本节是当前执行协议;下方早期记录中的 850–854 五信号握手、视觉必须 ready 才能启动生产、视觉失败即人工锁定均已被本节替代。 + +- 普通 RackPick 前独立执行:写托盘号/格位 → M850=1 → 等 M851=1 → ssp 清 M850、M851 → 决定是否识别。关闭视觉也执行这个到位流程。 +- vision/enabled 只控制识别。成功且 R60 整组写入确认后写 M852=1;关闭、视觉未连接、缺少料盘映射、初始化重试失败、识别失败、无效/超出 float 范围的坐标、视觉超时或断线时不写 R60,记录原因并写 M852=0。M852 写入确认后才启动普通 RackPick。动作结束保持 M852,下次显式覆盖。M853/M854 不再使用。 +- PLC 到位超时、握手读写失败、R40 通信失败、R60/M852 写入未确认仍要求人工核对;不得按视觉失败放行。保留暂停、终止、跨重启恢复锁与原子状态文件。恢复不要求视觉就绪,也不清 M852。 +- VisionGuide 启动时自动连接左右相机、应用参数及一次白平衡。收到测量请求时相机未初始化成功则再初始化一次,成功继续同一请求,失败返回 INITIALIZATION 错误。初始化期间允许一个待处理测量,重复请求不重复执行。 +- ssp 允许向已连接但未就绪的服务发送测量;请求预算为 requestTimeoutMs + 2 × initializeTimeoutMs,包含可能尚未结束的启动初始化和一次重试。采图/识别的 5 秒截止保持不变。 +- 新配置为 photoMoveCoil=850、photoArrivedCoil=851、comparisonPickCoil=852;旧五线圈配置和 handshakeProtocol 不再使用。根配置启用已确认的新 PLC 协议,识别开关仍为 enabled=false;现场填写 visionTrayMap 并设 enabled=true 后使用视觉结果。 +- 实施说明:docs/superpowers/specs/2026-10-28-photo-position-pick-design.md。测试采用本地 FakePlc、假视觉服务及相机管理器替身,未连接真实设备。 +- 本轮验证:ssp 生产流程 47 passed、IPC 14 passed、PLC 11 passed;VisionGuide 启动初始化/重试 8 passed、IPC 9 passed、白平衡状态 6 passed、抓取/资源门控 7 passed,共 102 passed。ssp Qt 5.14.1 MinGW 32/64 位全工程与 VisionGuide Qt 5.14.1 MSVC 库 / VS2022 v143 全工程编译通过。结果保存在各 build 目录的 contract-results.txt / contract-build.log;启动测试在 build-ssp-startup-test。 +- 两套 ssp 测试构建目录旁的 config.ini 已同步新信号配置,识别开关保持关闭;未运行生产 exe。测试源仍在既有忽略规则下的 tests 目录内,本次没有提交 Git。 + 日期:2026-10-27。已实现软件,未运行真实 PLC、相机或机器人。 +## 2026-10-28:恢复与白平衡状态修复 + +- 视觉故障后,PLC 暂停已确认或任务已终止到 Idle 时,允许重新连接、断开和初始化相机。恢复未完成订单时先执行并确认 PLC 暂停。维护期间仍禁止生产测量、手动诊断和启动生产;初始化成功不会解除人工核对锁。正在执行握手恢复时关闭维护入口,普通 PLC 状态轮询不阻止维护。 +- 视觉事务开始前,使用 QSaveFile 原子写入配置文件旁的 `<配置文件名>.vision-state.json`(默认 `config.ini.vision-state.json`)。正常取料动作完成或人工核对成功后才写入完成状态。退出、终止和重新启动不丢失待核对状态;记录损坏时保持锁定;写入失败时不发取料命令、不解除恢复锁。部署升级应保留这个运行状态文件及其配置路径,不用模板覆盖或删除它;该文件已加入 Git 忽略。 +- 手动再次执行白平衡会立即使对应相机的初始化缓存失效,并同步刷新 IPC 就绪状态。允许重复执行;再次通过初始化确认白平衡完成后才恢复生产就绪。命令失败时同样保持未就绪。 +- 本轮离线验证:ssp IPC 12 passed;生产流程 35 passed(含终止后重启、测量中退出、恢复记录损坏/写入失败、状态轮询与维护交错、启动恢复暂停确认);VisionGuide 白平衡状态 6 passed(相机管理器替身,无真实采图)、既有抓取/资源测试 7 passed。 +- ssp Qt 5.14.1 / MinGW 32 位和64位全工程编译通过;VisionGuide Qt 5.14.1 msvc2017_64 库 / VS2022 v143 全工程编译通过。仍未验证 v141 编译器或真实硬件。新增测试仍保留在用户要求忽略的 tests 目录中,未提交 Git。 + ## 已实现模块 - ssp–PLC:R40/R60 各六个 REAL、12 个寄存器整组读写;低字在前/高字在前编解码校验;视觉写入无自动重试;区分未发送、确认成功、发送后状态不明。保留原单 REAL API。 diff --git a/docs/visionguide-ipc-protocol.md b/docs/visionguide-ipc-protocol.md index c0a20d4..fa6e0a5 100644 --- a/docs/visionguide-ipc-protocol.md +++ b/docs/visionguide-ipc-protocol.md @@ -14,14 +14,16 @@ | --- | --- | | hello | 协议握手及进程 session;不初始化设备 | | get_status | 返回 ready/resource_busy 以及可选 initialization 对象 | -| initialize | 左右相机及算法初始化;accepted 后返回 ok/error | -| measure | 本次拍照、识别、抓取计算;accepted 后返回终态 | +| initialize | 显式初始化/维护入口;accepted 后返回 ok/error;VisionGuide 启动也自动执行相机初始化 | +| measure | 本次拍照、识别、抓取计算;相机未初始化成功时先重试一次初始化,成功继续同一请求,失败返回 error/INITIALIZATION;accepted 后返回终态 | | cancel | 带 target_request_id,取消该测量;cancel 本身独立应答,测量返回 cancelled | | show_window | 显示原视觉调试窗口 | | shutdown | 正常关闭(ssp 只对自己启动的进程发送) | 服务端主动状态消息使用 `type:"status"`、`request_id:""`、当前 session。业务失败不丢失关联上下文。相同测量编号不得重新采图。 +状态增加 `initialization_in_progress` bool。启动初始化时 `resource_busy:true`,允许接收一个测量请求等待初始化结束,其他测量仍返回 BUSY。ssp 不以 ready=false 直接拒绝测量;测量请求可触发一次初始化重试。客户端总等待预算为 `requestTimeoutMs + 2 * initializeTimeoutMs`,不改变采图/识别的 5 秒截止。初始化失败返回结构化 `status:"error"`、`error_code:"INITIALIZATION"`、`robot_valid:false`,保留 request_id/context。ssp 将视觉失败转换为 M852=0 的普通取料路径,不写 R60。 + 状态响应还提供字符串 `server_process_id`。ssp 只有在该值与自身 QProcess 启动的子进程 PID 一致时才发送 shutdown;连接外部实例时退出仅断开。 ## measure 请求 @@ -61,4 +63,4 @@ ## ssp 线程接口 -VisionService 及其 QLocalSocket/QProcess 在 GUI 线程中创建使用。生产线程通过 queued connection 传 `QJsonObject` 值快照:`measure(request)`、`cancel(requestId)`,接收 `measurementFinished(result)`、`availabilityChanged(ready,busy,session)`。无阻塞等待,退出不依赖生产线程等 GUI 回答。`setProductionActive(bool)` 使诊断入口与生产互斥;自动请求使用 `measure`,页面使用 `diagnose`。 +VisionService 及其 QLocalSocket/QProcess 在 GUI 线程中创建使用。生产线程通过 queued connection 传 `QJsonObject` 值快照:`measure(request)`、`cancel(requestId)`,接收 `measurementFinished(result)`、`availabilityChanged(ready,busy,session)`。无阻塞等待,退出不依赖生产线程等 GUI 回答。`setProductionActive(active, maintenanceAllowed)` 使诊断入口与生产互斥;待人工核对时保持 active,只有 PLC 暂停已确认或任务已终止到 Idle 才允许维护连接和初始化,仍禁止测量。自动请求使用 `measure`,页面使用 `diagnose`。此变更仅为 ssp 内部线程接口,线上的 IPC 协议版本仍为 1。 diff --git a/modbus/modbustcpmanager.cpp b/modbus/modbustcpmanager.cpp index 3756d68..1ad50ae 100644 --- a/modbus/modbustcpmanager.cpp +++ b/modbus/modbustcpmanager.cpp @@ -300,6 +300,17 @@ void ModbusTcpManager::writeVisionCoil(int address, bool value, enqueue(request); } +void ModbusTcpManager::writeVisionHoldingRegister(int address, quint16 value, + const VisionWriteCallback &callback, + const std::function &beforeSend) +{ + Request request(QModbusDataUnit::HoldingRegisters, address, 1, {value}, true, {}); + request.vision = true; + request.writeCallback = callback; + request.beforeSend = beforeSend; + enqueue(request); +} + void ModbusTcpManager::cancelVisionRequests(const QString &reason) { if (m_cancelingVision) { diff --git a/modbus/modbustcpmanager.h b/modbus/modbustcpmanager.h index a3d511c..00f4b0f 100644 --- a/modbus/modbustcpmanager.h +++ b/modbus/modbustcpmanager.h @@ -61,6 +61,8 @@ public: const std::function &callback); void writeVisionCoil(int address, bool value, const VisionWriteCallback &callback, const std::function &beforeSend = {}); + void writeVisionHoldingRegister(int address, quint16 value, const VisionWriteCallback &callback, + const std::function &beforeSend); void cancelVisionRequests(const QString &reason); void abortAll(const QString &reason); bool isBusy() const; diff --git a/models/visionresult.h b/models/visionresult.h index 3a96f1e..124cb9e 100644 --- a/models/visionresult.h +++ b/models/visionresult.h @@ -23,11 +23,9 @@ struct RobotPose struct VisionHandshake { - bool robotReceived = false; - bool photoRequest = false; - bool comparing = false; - bool comparisonError = false; - bool comparisonPassed = false; + bool photoMove = false; + bool photoArrived = false; + bool comparisonPick = false; }; enum class VisionWriteOutcome diff --git a/pages/dashboardpage.cpp b/pages/dashboardpage.cpp index cb5f3a5..233865d 100644 --- a/pages/dashboardpage.cpp +++ b/pages/dashboardpage.cpp @@ -530,7 +530,7 @@ void DashboardPage::recoverProduction() && QMessageBox::question( this, "继续生产", visionRecoveryRequired - ? "请先核对机器人当前位置及本次 R60 目标是否已被消费或撤销,并确认 PLC 已复位 850、851。确认后 ssp 会清除自己的视觉输出并重新核对信号,不会重发旧坐标。是否已完成现场核对?" + ? "请先核对机器人当前位置及本次取料是否已执行或撤销,并确认 M850 移动请求和 M851 到位反馈已复位。恢复不会清除 M852,也不会重发旧坐标。是否已完成现场核对?" : "请确认设备和 PLC 当前步骤安全后再继续生产。", QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) { diff --git a/pages/dashboardpage.h b/pages/dashboardpage.h index 445f9af..6b6ec98 100644 --- a/pages/dashboardpage.h +++ b/pages/dashboardpage.h @@ -36,7 +36,7 @@ signals: void deviceStatusChanged(const DeviceStatus &status); void deviceCommunicationError(const QString &error); void visionCycleChanged(const QJsonObject &cycle); - void visionProductionActiveChanged(bool active); + void visionProductionActiveChanged(bool active, bool maintenanceAllowed); void logRequested(const QString &type, const QString &module, const QString &action, const QString &content, const QString &status); diff --git a/pages/visionpage.cpp b/pages/visionpage.cpp index 50a66d0..7d45ec1 100644 --- a/pages/visionpage.cpp +++ b/pages/visionpage.cpp @@ -170,7 +170,7 @@ void VisionPage::setProductionActive(bool active) void VisionPage::refreshControls() { - m_initialize->setEnabled(!m_productionActive && !m_service->isBusy() && !m_service->sessionId().isEmpty()); + m_initialize->setEnabled(m_service->canInitialize()); m_diagnose->setEnabled(!m_productionActive && m_service->isReady() && !m_service->isBusy()); m_tray->setEnabled(!m_productionActive); for (QDoubleSpinBox *axis : m_diagnosticPose) axis->setEnabled(!m_productionActive); diff --git a/services/deviceservice.cpp b/services/deviceservice.cpp index 06c2ef0..01a584a 100644 --- a/services/deviceservice.cpp +++ b/services/deviceservice.cpp @@ -706,7 +706,7 @@ void DeviceService::pollFeedback(int commandAddress, int feedbackAddress, void DeviceService::beginProductionAction( ProductionAction action, int trayNo, int slotNo, - const OperationCallback &callback) + const OperationCallback &callback, const std::function &beforeSend) { if (m_terminationActive) { if (callback) { @@ -752,7 +752,7 @@ void DeviceService::beginProductionAction( m_productionActionBusy = true; m_modbus->readCoil( m_productionFeedbackAddress, - [this, action, trayNo, slotNo, addresses, callback]( + [this, action, trayNo, slotNo, addresses, callback, beforeSend]( bool success, bool feedback, const QString &error) { if (!success) { m_productionActionBusy = false; @@ -787,14 +787,20 @@ void DeviceService::beginProductionAction( } }; - auto writeCommand = [this, sendCommand](bool success, + auto writeCommand = [this, sendCommand, beforeSend](bool success, const QString &error) { if (!success) { sendCommand(false, error); return; } - m_modbus->writeCoil( - m_productionCommandAddress, true, sendCommand); + 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); + } }; if (action == RackPick || action == RackPlace) { @@ -980,6 +986,34 @@ bool DeviceService::checkVisionAccess(QString *error) const return ConfigManager::instance().visionConfig().isValid(error); } +void DeviceService::moveToPhotoPosition(int trayNo, int slotNo, + const VisionWriteCallback &callback, + const std::function &beforeSend) +{ + QString error; + if (!checkVisionAccess(&error) || trayNo < 1 || trayNo > 65535 || slotNo < 1 || slotNo > 49) { + if (callback) callback(VisionWriteOutcome::NotSent, + error.isEmpty() ? "Invalid photo-position tray/slot" : error); + return; + } + const ModbusAddressMap addresses = m_modbus->config().addressMap; + m_modbus->writeVisionHoldingRegister(addresses.trayNumber, quint16(trayNo), + [this, addresses, slotNo, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { + if (outcome != VisionWriteOutcome::Confirmed) { + if (callback) callback(outcome, error); + return; + } + m_modbus->writeVisionHoldingRegister(addresses.slotNumber, quint16(slotNo), + [this, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { + if (outcome != VisionWriteOutcome::Confirmed) { + if (callback) callback(outcome, error); + return; + } + writeVisionSignal(PhotoMove, true, callback, beforeSend); + }, beforeSend); + }, beforeSend); +} + void DeviceService::readRobotPhotoPose(const PoseCallback &callback) { QString error; @@ -1035,20 +1069,16 @@ void DeviceService::readVisionHandshake(const HandshakeCallback &callback) return; } const VisionConfig config = ConfigManager::instance().visionConfig(); - if (config.photoRequestCoil == config.robotReceivedCoil + 1 - && config.comparingCoil == config.robotReceivedCoil + 2 - && config.comparisonErrorCoil == config.robotReceivedCoil + 3 - && config.comparisonPassedCoil == config.robotReceivedCoil + 4) { + if (config.photoArrivedCoil == config.photoMoveCoil + 1 + && config.comparisonPickCoil == config.photoMoveCoil + 2) { const quint64 generation = m_visionGeneration; - m_modbus->readCoils(config.robotReceivedCoil, 5, + m_modbus->readCoils(config.photoMoveCoil, 3, [this, callback, generation](bool success, const QVector &values, const QString &text) { VisionHandshake state; - if (success && values.size() == 5 && generation == m_visionGeneration) { - state.robotReceived = values.at(0); - state.photoRequest = values.at(1); - state.comparing = values.at(2); - state.comparisonError = values.at(3); - state.comparisonPassed = values.at(4); + if (success && values.size() == 3 && generation == m_visionGeneration) { + state.photoMove = values.at(0); + state.photoArrived = values.at(1); + state.comparisonPick = values.at(2); if (callback) callback(true, state, QString()); } else if (callback) { callback(false, state, text.isEmpty() ? "Vision handshake read canceled or incomplete" : text); @@ -1066,14 +1096,12 @@ void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &st if (callback) callback(false, VisionHandshake(), "Vision handshake read canceled"); return; } - if (index == 5) { + if (index == 3) { if (callback) callback(true, state, QString()); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); - const int addresses[] = {config.robotReceivedCoil, config.photoRequestCoil, - config.comparingCoil, config.comparisonErrorCoil, - config.comparisonPassedCoil}; + const int addresses[] = {config.photoMoveCoil, config.photoArrivedCoil, config.comparisonPickCoil}; m_modbus->readVisionCoil(addresses[index], [this, index, state, generation, callback](bool success, bool value, const QString &error) { if (!success) { @@ -1082,11 +1110,9 @@ void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &st } VisionHandshake next = state; switch (index) { - case 0: next.robotReceived = value; break; - case 1: next.photoRequest = value; break; - case 2: next.comparing = value; break; - case 3: next.comparisonError = value; break; - case 4: next.comparisonPassed = value; break; + case 0: next.photoMove = value; break; + case 1: next.photoArrived = value; break; + case 2: next.comparisonPick = value; break; } readVisionHandshakeStep(index + 1, next, generation, callback); }); @@ -1103,15 +1129,16 @@ void DeviceService::writeVisionSignal(VisionSignal signal, bool value, } const VisionConfig config = ConfigManager::instance().visionConfig(); int address = -1; - QString name; switch (signal) { - case Comparing: address = config.comparingCoil; name = "comparing"; break; - case ComparisonError: address = config.comparisonErrorCoil; name = "comparisonError"; break; - case ComparisonPassed: address = config.comparisonPassedCoil; name = "comparisonPassed"; break; + case PhotoMove: address = config.photoMoveCoil; break; + case PhotoArrived: + if (!value) address = config.photoArrivedCoil; // Only PLC may publish arrival. + break; + case ComparisonPick: address = config.comparisonPickCoil; break; default: break; } - if (address < 0 || !config.writableSignals.contains(name)) { - if (callback) callback(VisionWriteOutcome::NotSent, "Vision coil is not owned by ssp"); + if (address < 0) { + if (callback) callback(VisionWriteOutcome::NotSent, "Unsupported photo-position output"); return; } m_modbus->writeVisionCoil(address, value, callback, beforeSend); diff --git a/services/deviceservice.h b/services/deviceservice.h index 812fcbc..d170c21 100644 --- a/services/deviceservice.h +++ b/services/deviceservice.h @@ -48,7 +48,7 @@ public: using HandshakeCallback = std::function; using VisionWriteCallback = std::function; - enum VisionSignal { Comparing, ComparisonError, ComparisonPassed }; + enum VisionSignal { PhotoMove, PhotoArrived, ComparisonPick }; enum ProductionAction { @@ -78,11 +78,14 @@ public: const OperationCallback &callback); void terminate(const OperationCallback &callback); void beginProductionAction(ProductionAction action, int trayNo, - int slotNo, const OperationCallback &callback); + int slotNo, const OperationCallback &callback, + const std::function &beforeSend = {}); void pollProductionAction(const ActionCallback &callback); void cancelProductionAction(const OperationCallback &callback); bool productionActionActive() const; bool productionActionBusy() const; + void moveToPhotoPosition(int trayNo, int slotNo, const VisionWriteCallback &callback, + const std::function &beforeSend); void readRobotPhotoPose(const PoseCallback &callback); void writeRobotGraspPose(const RobotPose &pose, const VisionWriteCallback &callback, const std::function &beforeSend = {}); diff --git a/services/productionservice.cpp b/services/productionservice.cpp index 0e76600..8d2fe16 100644 --- a/services/productionservice.cpp +++ b/services/productionservice.cpp @@ -11,10 +11,16 @@ #include #include #include +#include +#include +#include +#include +#include #include #include #include #include +#include namespace { @@ -57,6 +63,11 @@ ProductionService::ProductionService(QObject *parent) , m_externalStopRequested(nullptr) , m_shutdownRequested(false) { + const QString configPath = ConfigManager::instance().filePath(); + m_visionStatePath = QFileInfo(configPath.isEmpty() + ? QDir(QCoreApplication::applicationDirPath()).filePath("config.ini") : configPath) + .absoluteFilePath() + ".vision-state.json"; + loadVisionRecoveryState(); connect(m_timer, &QTimer::timeout, this, &ProductionService::tick); connect(m_deviceService, &DeviceService::statusChanged, this, &ProductionService::onDeviceStatusChanged); @@ -165,17 +176,55 @@ void ProductionService::requestStopImmediate() bool ProductionService::requiresVision(DeviceService::ProductionAction action) const { return action == DeviceService::RackPick - && ConfigManager::instance().visionConfig().enabled && !ConfigManager::instance().simulationMode(); } +bool ProductionService::saveVisionRecoveryState(bool pending, QString *error) +{ + const QJsonObject state{{"version", 1}, {"pending", pending}, + {"run_id", m_runId}, {"workpiece_id", m_currentWorkpiece.id}, + {"updated_at", QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)}}; + const QByteArray bytes = QJsonDocument(state).toJson(QJsonDocument::Compact); + QSaveFile file(m_visionStatePath); + if (!file.open(QIODevice::WriteOnly) || file.write(bytes) != bytes.size() || !file.commit()) { + if (error) *error = "无法保存视觉恢复状态,禁止继续生产:" + file.errorString(); + return false; + } + return true; +} + +void ProductionService::loadVisionRecoveryState() +{ + if (!QFileInfo::exists(m_visionStatePath)) return; + QFile file(m_visionStatePath); + const bool opened = file.open(QIODevice::ReadOnly); + const QJsonObject state = opened ? QJsonDocument::fromJson(file.readAll()).object() : QJsonObject(); + const bool valid = state.value("version").toDouble() == 1 && state.value("pending").isBool(); + if (valid && !state.value("pending").toBool()) return; + m_visionNeedsReconcile = true; + m_visionSuspended = true; + m_visionStage = VisionStage::Fault; + m_lastError = valid ? "上次视觉事务尚未完成,请核对机器人和 PLC 后恢复" + : "视觉恢复记录无法读取或已损坏,请核对机器人和 PLC 后恢复"; +} + +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_state == Idle || (m_state == ManualConfirm && m_visionPauseConfirmed)) + && !m_actionStarting && !m_actionPollPending && !m_actionCancelRequested + && !m_deviceService->productionActionActive(); + emit visionProductionActiveChanged(locked, maintenance); +} + bool ProductionService::visionCurrent(quint64 generation) const { return generation == m_visionGeneration && !m_visionSuspended && !stopRequested() && !(m_externalPauseRequested && m_externalPauseRequested->load()) && isActive() && m_currentWorkpiece.id == m_visionWorkpieceId - && m_currentTrayNo == m_visionTrayNo && m_visionReady - && m_availableVisionSession == m_visionSession + && m_currentTrayNo == m_visionTrayNo && m_deviceStatusValid && m_deviceStatus.plcConnected && m_deviceStatus.safetyDoorClosed && !m_deviceStatus.emergencyStop; } @@ -205,18 +254,15 @@ void ProductionService::setVisionStage(VisionStage stage, const QString &message QString name; switch (stage) { case VisionStage::Idle: name = "待机"; break; - case VisionStage::Preflight: name = "检查握手复位"; break; - case VisionStage::Armed: name = "允许料架取料"; break; - case VisionStage::WaitRequest: name = "等待拍照请求"; break; - case VisionStage::SettingBusy: name = "开始比对"; break; + case VisionStage::Preflight: name = "检查拍照请求复位"; break; + case VisionStage::Moving: name = "请求移动到拍照位"; break; + case VisionStage::WaitArrival: name = "等待到达拍照位"; break; + case VisionStage::Clearing: name = "清除拍照请求和到位信号"; break; case VisionStage::ReadingPose: name = "读取 R40 位姿"; break; case VisionStage::Measuring: name = "识别及抓取计算"; break; case VisionStage::WritingPose: name = "写入 R60"; break; - case VisionStage::Publishing: name = "发布比对通过"; break; - case VisionStage::WaitAck: name = "等待机器人接收"; break; - case VisionStage::WaitReset: name = "等待请求及接收复位"; break; - case VisionStage::Clearing: name = "清除本轮输出"; break; - case VisionStage::Complete: name = "视觉握手完成"; break; + case VisionStage::Publishing: name = "写入是否比对取料"; break; + case VisionStage::Complete: name = "取料准备完成"; break; case VisionStage::Fault: name = "等待人工核对"; break; } reportVision(name, message); @@ -226,9 +272,8 @@ void ProductionService::prepareVision() { QString error; const VisionConfig config = ConfigManager::instance().visionConfig(); - if (!config.isValid(&error) || config.visionTrayNo(m_currentTrayNo) < 1 - || !m_visionReady || m_visionBusy || m_availableVisionSession.isEmpty()) { - visionFault(error.isEmpty() ? "视觉未就绪或缺少料盘配置对应关系" : error); + if (!config.isValid(&error)) { + visionFault(error); return; } ++m_visionGeneration; @@ -238,8 +283,15 @@ void ProductionService::prepareVision() m_visionRequest = QJsonObject(); m_visionResult = QJsonObject(); m_visionCommitStarted = false; + m_visionEnabled = config.enabled; m_visionIoPending = false; m_visionRecoveryChecking = false; + m_visionPauseConfirmed = false; + // Persist before any pickup motion, so a crash cannot erase an in-flight transaction. + if (!saveVisionRecoveryState(true, &error)) { + visionFault(error); + return; + } setVisionStage(VisionStage::Preflight, "核对上一轮相机握手已全部复位"); advanceVision(); } @@ -252,17 +304,18 @@ void ProductionService::advanceVision() return; } const VisionConfig config = ConfigManager::instance().visionConfig(); - const int limit = m_visionStage == VisionStage::Measuring ? config.requestTimeoutMs - : (m_visionStage == VisionStage::WaitAck || m_visionStage == VisionStage::WaitReset) - ? config.robotAckTimeoutMs : ConfigManager::instance().productionConfig().stateTimeoutMs; + const qint64 limit = m_visionStage == VisionStage::Measuring + ? qint64(config.requestTimeoutMs) + 2LL * config.initializeTimeoutMs + : ConfigManager::instance().productionConfig().stateTimeoutMs; if (m_visionTimer.isValid() && m_visionTimer.elapsed() > limit) { - visionFault("视觉流程等待超时,请核对 PLC 与机器人状态后人工恢复", - !m_visionCommitStarted); + if (m_visionStage == VisionStage::Measuring) + skipVision("视觉等待超时"); + else + visionFault("拍照到位或 PLC 操作等待超时,请核对机器人状态"); return; } if (m_visionIoPending) return; - if (m_visionStage != VisionStage::Preflight && m_visionStage != VisionStage::WaitRequest - && m_visionStage != VisionStage::WaitAck && m_visionStage != VisionStage::WaitReset) return; + if (m_visionStage != VisionStage::Preflight && m_visionStage != VisionStage::WaitArrival) return; const quint64 generation = m_visionGeneration; m_visionIoPending = true; m_deviceService->readVisionHandshake( @@ -277,51 +330,43 @@ void ProductionService::advanceVision() void ProductionService::handleVisionHandshake(const VisionHandshake &handshake) { if (m_visionStage == VisionStage::Preflight) { - if (handshake.robotReceived || handshake.photoRequest || handshake.comparing - || handshake.comparisonError || handshake.comparisonPassed) { - visionFault("取料开始前已有相机握手信号置位,需人工核对复位"); + // M852 deliberately retains the previous pick mode. + if (handshake.photoMove || handshake.photoArrived) { + visionFault("拍照移动开始前 M850/M851 尚未复位,需人工核对"); return; } - setVisionStage(VisionStage::Armed, "握手已复位,允许发送料架取料命令使机器人到达拍照位"); - } else if (m_visionStage == VisionStage::WaitRequest) { - if (handshake.robotReceived || handshake.comparing || handshake.comparisonError - || handshake.comparisonPassed) { - visionFault("新拍照请求前出现旧接收确认或非预期比对输出"); - return; - } - if (!handshake.photoRequest) return; const quint64 generation = m_visionGeneration; - setVisionStage(VisionStage::SettingBusy, "机器人已到位停稳,置位相机比对中"); m_visionIoPending = true; - m_deviceService->writeVisionSignal(DeviceService::Comparing, true, + setVisionStage(VisionStage::Moving, "写托盘号和格位,然后置 M850"); + m_deviceService->moveToPhotoPosition(m_currentTrayNo, m_currentSlotNo, [this, generation](VisionWriteOutcome outcome, const QString &error) { if (!visionCurrent(generation)) return; m_visionIoPending = false; if (outcome != VisionWriteOutcome::Confirmed) { - visionFault("相机比对中信号写入未确认:" + error); return; + visionFault("移动到拍照位置请求未确认:" + error); + return; } - beginVisionMeasurement(); + setVisionStage(VisionStage::WaitArrival, "等待机器人 M851 到位反馈"); }, [this, generation]() { return visionCurrent(generation); }); - } else if (m_visionStage == VisionStage::WaitAck) { - if (!handshake.photoRequest || !handshake.comparisonPassed || handshake.comparisonError) { - visionFault("机器人接收确认前,PLC 已改变拍照请求或结果握手"); - return; - } - if (handshake.robotReceived) - setVisionStage(VisionStage::WaitReset, "机器人已接收目标,等待 850、851 复位"); - } else if (m_visionStage == VisionStage::WaitReset) { - if (handshake.comparisonError || !handshake.comparisonPassed) { - visionFault("请求及接收复位完成前,结果握手被改变"); return; - } - if (!handshake.robotReceived && !handshake.photoRequest) { - setVisionStage(VisionStage::Clearing, "接收及请求已复位,清除 ssp 本轮比对输出"); - clearVisionOutputs(0, m_visionGeneration); - } + } else if (m_visionStage == VisionStage::WaitArrival) { + if (!handshake.photoArrived) return; + setVisionStage(VisionStage::Clearing, "机器人已到位,清 M850/M851"); + clearVisionOutputs(0, m_visionGeneration); } } void ProductionService::beginVisionMeasurement() { + const VisionConfig config = ConfigManager::instance().visionConfig(); + if (!m_visionEnabled) { + publishPickMode(false); + return; + } + if (config.visionTrayNo(m_currentTrayNo) < 1 || m_availableVisionSession.isEmpty()) { + skipVision("缺少视觉料盘映射或视觉进程未连接"); + return; + } + m_visionSession = m_availableVisionSession; const quint64 generation = m_visionGeneration; setVisionStage(VisionStage::ReadingPose, "从 R40 整组读取本次拍照 XYZABC"); m_visionIoPending = true; @@ -330,7 +375,7 @@ void ProductionService::beginVisionMeasurement() if (!visionCurrent(generation)) return; m_visionIoPending = false; if (!success || !pose.isValid()) { - visionFault("R40 拍照位姿读取失败:" + error, true); return; + visionFault("R40 拍照位姿读取失败:" + error); return; } QJsonArray values; for (double value : pose.xyzabc) values.append(value); @@ -354,17 +399,17 @@ void ProductionService::beginVisionMeasurement() void ProductionService::onVisionAvailability(bool ready, bool busy, const QString &session) { - m_visionReady = ready; - m_visionBusy = busy; + Q_UNUSED(ready) + Q_UNUSED(busy) m_availableVisionSession = session; - if (m_visionStage != VisionStage::Idle && m_visionStage != VisionStage::Fault - && (!ready || session != m_visionSession)) - visionFault("VisionGuide 已断开、未就绪或进程会话改变"); + if (m_visionStage == VisionStage::Measuring && session != m_visionSession + && visionCurrent(m_visionGeneration)) + skipVision("VisionGuide 连接中断或进程会话改变"); } void ProductionService::publishVisionSnapshot() { - emit visionProductionActiveChanged(m_visionNeedsReconcile || (m_state != Idle && m_state != Completed)); + publishVisionControl(); reportVision(m_visionNeedsReconcile ? "等待人工核对" : "待机", m_visionNeedsReconcile ? m_lastError : "等待下一次料架取料"); } @@ -375,15 +420,18 @@ void ProductionService::onVisionResult(const QJsonObject &result) || result.value("request_id") != m_visionRequest.value("request_id")) return; if (result.value("context") != m_visionRequest.value("context") || result.value("server_session_id").toString() != m_visionSession) { - visionFault("视觉结果与本次取料上下文不一致", true); return; + skipVision("视觉结果与本次取料上下文不一致"); return; } RobotPose target, camera; for (const QJsonValue &value : result.value("robot_pose").toArray()) { - if (!value.isDouble()) { visionFault("机器人坐标格式无效", true); return; } + if (!value.isDouble() || !std::isfinite(value.toDouble()) + || qAbs(value.toDouble()) > std::numeric_limits::max()) { + skipVision("机器人坐标无效或超出 PLC float 范围"); return; + } target.xyzabc.append(value.toDouble()); } for (const QJsonValue &value : result.value("camera_pose").toArray()) { - if (!value.isDouble()) { visionFault("相机坐标格式无效", true); return; } + if (!value.isDouble()) { skipVision("相机坐标格式无效"); return; } camera.xyzabc.append(value.toDouble()); } if (result.value("status").toString() != "ok" || !result.value("robot_valid").toBool() @@ -394,61 +442,74 @@ void ProductionService::onVisionResult(const QJsonObject &result) || !result.value("score").isDouble() || !std::isfinite(result.value("score").toDouble()) || result.value("score").toDouble() < .70 || result.value("score").toDouble() > 1.0 || result.value("calibration_fingerprint").toString().isEmpty()) { - visionFault("视觉结果校验失败,禁止写入 R60:" + result.value("message").toString(), true); return; + skipVision("视觉识别失败或结果无效:" + result.value("message").toString()); return; } m_visionResult = result; const quint64 generation = m_visionGeneration; - // Re-read the request/ack before committing, while the robot holds the photo pose. m_visionIoPending = true; - setVisionStage(VisionStage::WritingPose, "提交 R60 前再次核对拍照请求和接收信号"); - m_deviceService->readVisionHandshake( - [this, generation, target](bool success, const VisionHandshake &handshake, const QString &error) { + m_visionCommitStarted = true; + setVisionStage(VisionStage::WritingPose, "整组写入 R60,确认后选择比对取料"); + m_deviceService->writeRobotGraspPose(target, + [this, generation](VisionWriteOutcome outcome, const QString &error) { if (!visionCurrent(generation)) return; - if (!success || !handshake.photoRequest || handshake.robotReceived - || !handshake.comparing || handshake.comparisonPassed || handshake.comparisonError) { - m_visionIoPending = false; - visionFault("提交 R60 前机器人请求发生变化:" + error); return; + m_visionIoPending = false; + if (outcome != VisionWriteOutcome::Confirmed) { + visionFault("R60 写入未确认,禁止继续取料:" + error); + return; } - m_visionCommitStarted = true; - reportVision("写入 R60", "整组写入抓取坐标,尚未收到机器人接收确认"); - m_deviceService->writeRobotGraspPose(target, - [this, generation](VisionWriteOutcome outcome, const QString &error) { - if (!visionCurrent(generation)) return; - if (outcome != VisionWriteOutcome::Confirmed) { - m_visionIoPending = false; - visionFault("R60 写入未确认,禁止自动重发目标:" + error); return; - } - setVisionStage(VisionStage::Publishing, "R60 写入已确认,置位比对通过"); - m_deviceService->writeVisionSignal(DeviceService::ComparisonPassed, true, - [this, generation](VisionWriteOutcome outcome, const QString &error) { - if (!visionCurrent(generation)) return; - m_visionIoPending = false; - if (outcome != VisionWriteOutcome::Confirmed) { - visionFault("比对通过信号发布未确认:" + error); return; - } - setVisionStage(VisionStage::WaitAck, "结果已发布,等待机器人接收成功信号 850"); - }, [this, generation]() { return visionCurrent(generation); }); - }, [this, generation]() { return visionCurrent(generation); }); - }); + publishPickMode(true); + }, [this, generation]() { return visionCurrent(generation); }); +} + +void ProductionService::publishPickMode(bool useVision) +{ + const quint64 generation = m_visionGeneration; + if (!visionCurrent(generation)) return; + m_visionIoPending = true; + setVisionStage(VisionStage::Publishing, useVision ? "写 M852=1,使用本次 R60" : "写 M852=0,使用普通取料"); + m_deviceService->writeVisionSignal(DeviceService::ComparisonPick, useVision, + [this, generation](VisionWriteOutcome outcome, const QString &error) { + if (!visionCurrent(generation)) return; + m_visionIoPending = false; + if (outcome != VisionWriteOutcome::Confirmed) { + visionFault("M852 写入未确认,禁止启动 RackPick:" + error); + return; + } + setVisionStage(VisionStage::Complete, "取料模式已确认,允许普通 RackPick"); + }, [this, generation]() { return visionCurrent(generation); }); +} + +void ProductionService::skipVision(const QString &reason) +{ + if (!visionCurrent(m_visionGeneration)) return; + const QString requestId = m_visionRequest.value("request_id").toString(); + m_visionResult = QJsonObject(); + // Change stage before cancellation can deliver a synchronous terminal callback. + setVisionStage(VisionStage::Publishing, reason + ";本次改为普通取料"); + reportVision("视觉跳过", reason + ";本次不使用 R60", true); + qWarning().noquote() << "Vision fallback:" << reason; + persistRecoveryAction("VISION_FALLBACK", reason); + emit visionCancelRequested(requestId); + publishPickMode(false); } void ProductionService::clearVisionOutputs(int index, quint64 generation) { if (!visionCurrent(generation)) return; - if (index == 3) { + if (index == 2) { m_visionIoPending = false; - setVisionStage(VisionStage::Complete, "机器人接收及信号复位完成,继续等待原取料动作完成"); + beginVisionMeasurement(); return; } - const DeviceService::VisionSignal outputs[] = {DeviceService::ComparisonPassed, - DeviceService::ComparisonError, DeviceService::Comparing}; + const DeviceService::VisionSignal outputs[] = {DeviceService::PhotoMove, DeviceService::PhotoArrived}; m_visionIoPending = true; m_deviceService->writeVisionSignal(outputs[index], false, [this, index, generation](VisionWriteOutcome outcome, const QString &error) { if (!visionCurrent(generation)) return; if (outcome != VisionWriteOutcome::Confirmed) { m_visionIoPending = false; - visionFault("比对输出复位未确认:" + error); return; + visionFault("M850/M851 清除未确认:" + error); + return; } clearVisionOutputs(index + 1, generation); }, [this, generation]() { return visionCurrent(generation); }); @@ -462,49 +523,45 @@ void ProductionService::invalidateVision(const QString &reason) m_visionNeedsReconcile = true; m_visionIoPending = false; m_visionRecoveryChecking = false; + m_visionPauseConfirmed = false; + QString persistenceError; + if (!saveVisionRecoveryState(true, &persistenceError)) { + m_lastError = persistenceError; + emit productionError(persistenceError); + } emit visionCancelRequested(m_visionRequest.value("request_id").toString()); m_deviceService->cancelVisionRequests(reason); m_visionStage = VisionStage::Fault; reportVision("等待人工核对", reason + (m_visionCommitStarted ? ";R60 或有效信号可能已经到达机器人,需现场核对" : QString()), true); - emit visionProductionActiveChanged(true); + emit visionProductionActiveChanged(true, false); } -void ProductionService::visionFault(const QString &reason, bool reportComparisonError) +void ProductionService::visionFault(const QString &reason) { if (m_visionStage == VisionStage::Fault) return; - const bool mayReport = reportComparisonError && !m_visionCommitStarted - && m_visionStage != VisionStage::Idle && m_visionStage != VisionStage::Preflight; m_timeoutState = m_state; m_lastError = reason; - invalidateVision(reason); // A preflight rejection also requires an explicit operator recovery. m_visionNeedsReconcile = true; + invalidateVision(reason); m_visionSuspended = true; m_visionStage = VisionStage::Fault; m_timer->stop(); pauseProcessTimer(); + m_visionFaultCleanupPending = true; setState(ManualConfirm); reportVision("等待人工核对", reason, true); - if (mayReport) { - const quint64 generation = m_visionGeneration; - m_deviceService->writeVisionSignal(DeviceService::ComparisonError, true, - [this](VisionWriteOutcome outcome, const QString &error) { - if (outcome != VisionWriteOutcome::Confirmed) - reportVision("等待人工核对", "比对错误输出未确认:" + error, true); - }, [this, generation]() { - return generation == m_visionGeneration && !stopRequested() - && !(m_externalPauseRequested && m_externalPauseRequested->load()); - }); - } - m_visionFaultCleanupPending = true; cancelPendingProductionAction([this](bool success, const QString &error) { if (!success) { m_visionFaultCleanupPending = false; + publishVisionControl(); emit productionError("PLC 动作取消失败:" + error); return; } m_deviceService->pause([this](bool paused, const QString &error) { m_visionFaultCleanupPending = false; + m_visionPauseConfirmed = paused; + publishVisionControl(); if (!paused) emit productionError("PLC 暂停失败:" + error); }); }); @@ -520,26 +577,27 @@ bool ProductionService::recoverVision(QString *error) return false; } if (!checkRecoverySafety(error)) return false; - if (!m_visionReady || m_visionBusy || m_visionFaultCleanupPending || m_deviceService->productionActionBusy() + if (m_visionFaultCleanupPending || m_deviceService->productionActionBusy() || m_deviceService->productionActionActive()) { - if (error) *error = "请等待 PLC 操作结束且 VisionGuide 就绪后恢复"; + if (error) *error = "请等待 PLC 操作结束后恢复"; return false; } if (m_externalPauseRequested) m_externalPauseRequested->store(false); m_visionRecoveryChecking = true; - m_visionRecoverySession = m_availableVisionSession; + 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_externalPauseRequested && m_externalPauseRequested->load()) - || !m_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) { + || (m_externalPauseRequested && m_externalPauseRequested->load())) { m_visionRecoveryChecking = false; + publishVisionControl(); return; } m_visionRecoveryChecking = false; - if (!success || handshake.photoRequest || handshake.robotReceived) { - emit productionError("人工恢复要求机器人接收成功和拍照请求均已复位:" + error); + if (!success || handshake.photoMove || handshake.photoArrived) { + publishVisionControl(); + emit productionError("人工恢复要求M850 移动请求和 M851 到位反馈均已复位:" + error); return; } m_visionRecoveryChecking = true; @@ -551,27 +609,26 @@ bool ProductionService::recoverVision(QString *error) void ProductionService::resetVisionForRecovery(int index, quint64 generation) { if (generation != m_visionGeneration || stopRequested() - || (m_externalPauseRequested && m_externalPauseRequested->load()) - || !m_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) { + || (m_externalPauseRequested && m_externalPauseRequested->load())) { m_visionRecoveryChecking = false; + publishVisionControl(); return; } - if (index < 3) { - const DeviceService::VisionSignal outputs[] = {DeviceService::ComparisonPassed, - DeviceService::ComparisonError, DeviceService::Comparing}; + if (index < 2) { + const DeviceService::VisionSignal outputs[] = {DeviceService::PhotoMove, DeviceService::PhotoArrived}; m_deviceService->writeVisionSignal(outputs[index], false, [this, index, generation](VisionWriteOutcome outcome, const QString &error) { if (generation != m_visionGeneration) return; if (outcome != VisionWriteOutcome::Confirmed) { m_visionRecoveryChecking = false; + publishVisionControl(); emit productionError("视觉恢复时输出复位未确认:" + error); return; } resetVisionForRecovery(index + 1, generation); }, [this, generation]() { return generation == m_visionGeneration && !stopRequested() - && !(m_externalPauseRequested && m_externalPauseRequested->load()) - && m_visionReady && !m_visionBusy && m_availableVisionSession == m_visionRecoverySession; + && !(m_externalPauseRequested && m_externalPauseRequested->load()); }); return; } @@ -579,10 +636,12 @@ void ProductionService::resetVisionForRecovery(int index, quint64 generation) [this, generation](bool success, const VisionHandshake &handshake, const QString &error) { m_visionRecoveryChecking = false; if (generation != m_visionGeneration || stopRequested() - || (m_externalPauseRequested && m_externalPauseRequested->load()) - || !m_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) return; - if (!success || handshake.photoRequest || handshake.robotReceived || handshake.comparing - || handshake.comparisonError || handshake.comparisonPassed) { + || (m_externalPauseRequested && m_externalPauseRequested->load())) { + publishVisionControl(); + return; + } + if (!success || handshake.photoMove || handshake.photoArrived) { + publishVisionControl(); emit productionError("视觉恢复核对期间握手信号未保持复位:" + error); return; } @@ -593,12 +652,24 @@ void ProductionService::resetVisionForRecovery(int index, quint64 generation) || (mapped != FrontChecking && mapped != BackChecking)) { m_lastError = "当前 PLC 步骤不能明确恢复视觉中断的取料动作。请先终止当前任务,核对机器人后再执行视觉恢复;不会自动重发取料或 R60。"; setState(ManualConfirm); + publishVisionControl(); reportVision("等待人工核对", m_lastError, true); emit timeoutRecoveryRequired("VISION", m_lastError); return; } } + QString persistenceError; + if (!saveVisionRecoveryState(false, &persistenceError)) { + publishVisionControl(); + emit productionError(persistenceError); + return; + } persistRecoveryAction("VISION_CONFIRMED", "Operator verified the robot and PLC; handshake is reset; old target discarded"); + if (stopRequested() || (m_externalPauseRequested && m_externalPauseRequested->load())) { + if (!saveVisionRecoveryState(true, &persistenceError)) emit productionError(persistenceError); + publishVisionControl(); + return; + } m_visionNeedsReconcile = false; m_visionSuspended = false; m_visionCommitStarted = false; @@ -607,7 +678,7 @@ void ProductionService::resetVisionForRecovery(int index, quint64 generation) m_visionResult = QJsonObject(); if (m_externalPauseRequested) m_externalPauseRequested->store(false); reportVision("人工恢复完成", "现场核对及信号复位完成,已丢弃旧视觉目标", true); - emit visionProductionActiveChanged(m_state != Idle && m_state != Completed); + publishVisionControl(); if (m_state == Idle || m_state == Completed) return; QString recoveryError; if (!recover(&recoveryError)) emit productionError(recoveryError); @@ -617,16 +688,11 @@ void ProductionService::resetVisionForRecovery(int index, quint64 generation) bool ProductionService::start(int orderId, QString *error) { const VisionConfig vision = ConfigManager::instance().visionConfig(); - if (m_visionNeedsReconcile || (vision.enabled && !vision.isValid(error))) { + if (m_visionNeedsReconcile || (!ConfigManager::instance().simulationMode() && !vision.isValid(error))) { if (m_visionNeedsReconcile && error) *error = "请先人工核对并恢复上次视觉握手,再启动生产"; return false; } - if (vision.enabled && !ConfigManager::instance().simulationMode() - && (!m_visionReady || m_visionBusy)) { - if (error) *error = "请先初始化 VisionGuide,等待视觉就绪后启动生产"; - return false; - } if (orderId <= 0) { if (error) { *error = "Order id must be greater than 0"; @@ -789,6 +855,7 @@ bool ProductionService::pause(QString *error) pauseProcessTimer(); m_timer->stop(); + m_visionPauseConfirmed = true; setState(m_visionNeedsReconcile ? ManualConfirm : Paused); if (m_visionNeedsReconcile) emit timeoutRecoveryRequired("VISION", "视觉流程已中断,请核对 PLC 和机器人后恢复"); @@ -1113,11 +1180,29 @@ bool ProductionService::restoreActiveRun(QString *error) m_visionNeedsReconcile = true; m_visionSuspended = true; m_visionStage = VisionStage::Fault; + QString stateError; + if (!saveVisionRecoveryState(true, &stateError)) emit productionError(stateError); reportVision("等待人工核对", "恢复未完成的生产记录,需核对相机与机器人握手", true); } setState(ManualConfirm); m_heartbeatTimer.restart(); m_timer->stop(); + if (m_visionNeedsReconcile) { + // Startup recovery must confirm a PLC pause before camera maintenance is offered. + const quint64 generation = m_visionGeneration; + m_visionFaultCleanupPending = true; + publishVisionControl(); + m_deviceService->pause([this, generation](bool paused, const QString &pauseError) { + m_visionFaultCleanupPending = false; + if (generation != m_visionGeneration || m_state != ManualConfirm) { + publishVisionControl(); + return; + } + m_visionPauseConfirmed = paused; + publishVisionControl(); + if (!paused) emit productionError("启动恢复时 PLC 暂停未确认:" + pauseError); + }); + } emit timeoutRecoveryRequired( "STARTUP_RECOVERY", QString("Unfinished production run %1 requires recovery confirmation") @@ -1324,7 +1409,7 @@ void ProductionService::setState(State state) m_state = state; m_stateTimer.restart(); emit stateChanged(m_state, stateName()); - emit visionProductionActiveChanged(m_visionNeedsReconcile || (m_state != Idle && m_state != Completed)); + publishVisionControl(); if (m_runId > 0) { const QString processStep = processStepForState(state).isEmpty() @@ -1454,11 +1539,11 @@ bool ProductionService::processProductionAction( prepareVision(); return true; } - if (m_visionStage == VisionStage::Preflight) { + if (m_visionStage != VisionStage::Complete) { advanceVision(); return true; } - if (m_visionStage == VisionStage::Fault) return true; + if (!visionCurrent(m_visionGeneration)) return true; } if (!m_actionPending) { @@ -1468,17 +1553,20 @@ bool ProductionService::processProductionAction( m_actionPollPending = false; m_actionCompleted = false; m_actionError.clear(); + const quint64 generation = m_visionGeneration; + const std::function beforeSend = requiresVision(action) + ? std::function([this, generation]() { + return visionCurrent(generation) && m_visionStage == VisionStage::Complete; + }) : std::function(); m_deviceService->beginProductionAction( action, m_currentTrayNo, m_currentSlotNo, [this](bool success, const QString &actionError) { m_actionStarting = false; if (!success) { m_actionError = actionError; - } else if (m_visionStage == VisionStage::Armed && !m_visionSuspended) { - setVisionStage(VisionStage::WaitRequest, "等待机器人到位后的拍照请求 851"); } tryDeferredActionCancel(); - }); + }, beforeSend); return true; } @@ -1500,12 +1588,15 @@ bool ProductionService::processProductionAction( return true; } - if (requiresVision(action) && m_visionStage != VisionStage::Complete) { - advanceVision(); - return true; - } - if (m_actionCompleted) { + if (requiresVision(action)) { + QString persistenceError; + if (!visionCurrent(m_visionGeneration) || !saveVisionRecoveryState(false, &persistenceError) + || !visionCurrent(m_visionGeneration)) { + visionFault(persistenceError.isEmpty() ? "取料完成期间状态改变,需人工核对" : persistenceError); + return true; + } + } *completed = true; m_actionPending = false; m_actionCompleted = false; diff --git a/services/productionservice.h b/services/productionservice.h index ac8d8cb..4112dae 100644 --- a/services/productionservice.h +++ b/services/productionservice.h @@ -93,7 +93,7 @@ signals: void visionMeasureRequested(const QJsonObject &request); void visionCancelRequested(const QString &requestId); void visionCycleChanged(const QJsonObject &cycle); - void visionProductionActiveChanged(bool active); + void visionProductionActiveChanged(bool active, bool maintenanceAllowed); private slots: void tick(); @@ -107,23 +107,27 @@ public: private: friend class VisionProductionTest; enum class VisionStage { - Idle, Preflight, Armed, WaitRequest, SettingBusy, ReadingPose, - Measuring, WritingPose, Publishing, WaitAck, WaitReset, Clearing, - Complete, Fault + Idle, Preflight, Moving, WaitArrival, Clearing, ReadingPose, + Measuring, WritingPose, Publishing, Complete, Fault }; bool requiresVision(DeviceService::ProductionAction action) const; void prepareVision(); void advanceVision(); void handleVisionHandshake(const VisionHandshake &handshake); void beginVisionMeasurement(); + void publishPickMode(bool useVision); + void skipVision(const QString &reason); void clearVisionOutputs(int index, quint64 generation); bool visionCurrent(quint64 generation) const; void setVisionStage(VisionStage stage, const QString &message); void reportVision(const QString &phase, const QString &message, bool invalidated = false); void invalidateVision(const QString &reason); - void visionFault(const QString &reason, bool reportComparisonError = false); + void visionFault(const QString &reason); bool recoverVision(QString *error); void resetVisionForRecovery(int index, quint64 generation); + void publishVisionControl(); + bool saveVisionRecoveryState(bool pending, QString *error); + void loadVisionRecoveryState(); ProductionService(const ProductionService &) = delete; ProductionService &operator=(const ProductionService &) = delete; @@ -220,15 +224,15 @@ private: int m_visionTrayNo = 0; QString m_visionSession; QString m_availableVisionSession; - bool m_visionReady = false; - bool m_visionBusy = false; + bool m_visionEnabled = false; bool m_visionIoPending = false; bool m_visionSuspended = false; bool m_visionCommitStarted = false; bool m_visionNeedsReconcile = false; bool m_visionRecoveryChecking = false; bool m_visionFaultCleanupPending = false; - QString m_visionRecoverySession; + bool m_visionPauseConfirmed = false; + QString m_visionStatePath; std::atomic_bool *m_externalPauseRequested = nullptr; }; diff --git a/services/productionworker.h b/services/productionworker.h index f6b2810..296751f 100644 --- a/services/productionworker.h +++ b/services/productionworker.h @@ -49,7 +49,7 @@ signals: void visionMeasureRequested(const QJsonObject &request); void visionCancelRequested(const QString &requestId); void visionCycleChanged(const QJsonObject &cycle); - void visionProductionActiveChanged(bool active); + void visionProductionActiveChanged(bool active, bool maintenanceAllowed); private: void ensureService(); diff --git a/services/visionservice.cpp b/services/visionservice.cpp index a1894b0..71a045f 100644 --- a/services/visionservice.cpp +++ b/services/visionservice.cpp @@ -151,6 +151,10 @@ QJsonObject VisionService::standardConvention() bool VisionService::isReady() const { return m_ready && !m_session.isEmpty(); } bool VisionService::isBusy() const { return m_busy || !m_request.isEmpty() || !m_initializeId.isEmpty(); } +bool VisionService::canInitialize() const +{ + return !m_session.isEmpty() && !isBusy() && (!m_productionActive || m_maintenanceAllowed); +} QString VisionService::sessionId() const { return m_session; } void VisionService::connectService() @@ -166,7 +170,7 @@ void VisionService::connectService() void VisionService::disconnectService() { - if (m_productionActive) { + if (m_productionActive && !m_maintenanceAllowed) { emit logMessage("请先停止生产,再断开视觉控制连接"); return; } @@ -350,7 +354,7 @@ void VisionService::handleMessage(const QJsonObject &message) void VisionService::initialize() { - if (m_session.isEmpty() || isBusy() || m_productionActive) { + if (!canInitialize()) { emit logMessage("初始化需要已连接、资源空闲且生产已停止"); return; } @@ -375,7 +379,9 @@ void VisionService::requestMeasurement(QJsonObject request, bool diagnostic) const QJsonObject context = request.value("context").toObject(); const double tray = context.value("tray_no").toDouble(); if (id.isEmpty() || m_cancelledRequests.contains(id)) error = "请求编号为空或已取消"; - else if (!isReady() || isBusy()) error = "视觉未就绪或仍在处理上一任务"; + else if (m_session.isEmpty() || !m_request.isEmpty() || !m_initializeId.isEmpty() + || (m_busy && !m_backendInitializing)) error = "视觉未连接或仍在处理上一任务"; + else if (m_maintenanceAllowed) error = "视觉维护期间只允许初始化,请完成人工核对后再测量"; else if (diagnostic == m_productionActive) error = "诊断与自动生产不可同时执行"; else if (!diagnostic && request.value("server_session_id").toString() != m_session) error = "生产请求会话已失效"; else if (!validPose(request.value("robot_pose"))) error = "拍照位姿须为6个有限数值"; @@ -412,7 +418,7 @@ void VisionService::requestMeasurement(QJsonObject request, bool diagnostic) failConnection("发送视觉测量请求失败"); return; } - m_requestTimer->start(m_config.requestTimeoutMs); + m_requestTimer->start(int(qMin(2147483647, qint64(m_config.requestTimeoutMs) + 2LL * m_config.initializeTimeoutMs))); } bool VisionService::validateResult(const QJsonObject &result, QString *error) const @@ -447,10 +453,11 @@ void VisionService::cancel(const QString &requestId) failMeasurement("CANCELLED", "本次视觉结果已取消,等待底层资源释放"); } -void VisionService::setProductionActive(bool active) +void VisionService::setProductionActive(bool active, bool maintenanceAllowed) { m_productionActive = active; - if (!m_request.isEmpty() && ((active && m_diagnostic) || (!active && !m_diagnostic))) + m_maintenanceAllowed = active && maintenanceAllowed; + if (!m_request.isEmpty() && (m_maintenanceAllowed || (active && m_diagnostic) || (!active && !m_diagnostic))) cancel(m_request.value("request_id").toString()); publishAvailability(); } @@ -527,6 +534,7 @@ void VisionService::failConnection(const QString &message) void VisionService::updateAvailability(const QJsonObject &message) { + m_backendInitializing = message.value("initialization_in_progress").toBool(); m_ready = message.value("ready").toBool(); m_busy = message.value("resource_busy").toBool(); emit statusChanged(message); diff --git a/services/visionservice.h b/services/visionservice.h index a7447ab..9a1de6f 100644 --- a/services/visionservice.h +++ b/services/visionservice.h @@ -22,6 +22,7 @@ public: static QJsonObject standardConvention(); bool isReady() const; bool isBusy() const; + bool canInitialize() const; QString sessionId() const; public slots: @@ -32,7 +33,7 @@ public slots: void measure(const QJsonObject &request); void diagnose(const QJsonObject &request); void cancel(const QString &requestId); - void setProductionActive(bool active); + void setProductionActive(bool active, bool maintenanceAllowed = false); void showWindow(); void shutdown(); @@ -77,7 +78,9 @@ private: QJsonObject m_request; bool m_ready; bool m_busy; + bool m_backendInitializing = false; bool m_productionActive; + bool m_maintenanceAllowed = false; bool m_diagnostic; bool m_connecting; bool m_shuttingDown; diff --git a/ssp.pro.user b/ssp.pro.user index ad76d57..1045882 100644 --- a/ssp.pro.user +++ b/ssp.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId @@ -542,7 +542,7 @@ false true - E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_32_bit-Debug + 1