From 407af2892db5c9e0e953e8bd9988dc5f86d781d2 Mon Sep 17 00:00:00 2001 From: lidg Date: Thu, 29 Oct 2026 17:20:14 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E9=87=8D=E6=9E=84=E8=A7=86=E8=A7=89?= =?UTF-8?q?=E5=8F=96=E6=96=99=E6=B5=81=E7=A8=8B=E5=8F=8A=E7=94=9F=E4=BA=A7?= =?UTF-8?q?=E6=95=85=E9=9A=9C=E6=81=A2=E5=A4=8D=20-=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E8=AE=A2=E5=8D=95=E5=90=AF=E5=8A=A8=E3=80=81=E6=9A=82=E5=81=9C?= =?UTF-8?q?=E3=80=81=E5=A4=8D=E4=BD=8D=E7=9B=B8=E5=85=B3=20PLC=20=E6=8F=A1?= =?UTF-8?q?=E6=89=8B=E5=8F=8A=E6=97=A0=E6=95=88=E5=8F=8D=E9=A6=88=E9=85=8D?= =?UTF-8?q?=E7=BD=AE=20-=20=E6=B8=85=E9=99=A4=E6=8A=A5=E8=AD=A6=E6=94=B9?= =?UTF-8?q?=E4=B8=BA=E4=BB=85=E5=86=99=20clearAlarmCommand=EF=BC=8C?= =?UTF-8?q?=E4=B8=8D=E7=AD=89=E5=BE=85=E5=8F=8D=E9=A6=88=20-=20=E5=B0=86?= =?UTF-8?q?=E6=8B=8D=E7=85=A7=E4=BD=8D=E7=A7=BB=E5=8A=A8=E3=80=81=E8=A7=86?= =?UTF-8?q?=E8=A7=89=E5=A4=84=E7=90=86=E5=92=8C=20RackPick=20=E6=8B=86?= =?UTF-8?q?=E5=88=86=E4=B8=BA=E4=B8=89=E4=B8=AA=E7=8B=AC=E7=AB=8B=E5=8A=A8?= =?UTF-8?q?=E4=BD=9C=20-=20=E5=A2=9E=E5=8A=A0=20M850/M851=20=E6=8B=8D?= =?UTF-8?q?=E7=85=A7=E4=BD=8D=E5=8A=A8=E4=BD=9C=E5=8F=8A=20R60/M852=20?= =?UTF-8?q?=E8=A7=86=E8=A7=89=E7=BB=93=E6=9E=9C=E6=B5=81=E7=A8=8B=20-=20?= =?UTF-8?q?=E6=9A=82=E5=81=9C=E6=94=B9=E4=B8=BA=E7=AD=89=E5=BE=85=E5=BD=93?= =?UTF-8?q?=E5=89=8D=E6=9C=BA=E5=99=A8=E4=BA=BA=E5=8A=A8=E4=BD=9C=E5=AE=8C?= =?UTF-8?q?=E6=88=90=EF=BC=8C=E8=A7=86=E8=A7=89=E7=BB=93=E6=9E=9C=E4=B8=8D?= =?UTF-8?q?=E7=A1=AE=E5=AE=9A=E6=97=B6=E8=BD=AC=E4=BA=BA=E5=B7=A5=E7=A1=AE?= =?UTF-8?q?=E8=AE=A4=20-=20=E5=88=A0=E9=99=A4=E5=A4=8D=E4=BD=8D=E6=8C=89?= =?UTF-8?q?=E9=92=AE=EF=BC=8C=E5=90=88=E5=B9=B6=E4=B8=BA=E6=81=A2=E5=A4=8D?= =?UTF-8?q?/=E9=87=8D=E8=AF=95=E6=8C=89=E9=92=AE=20-=20=E6=99=AE=E9=80=9A?= =?UTF-8?q?=20PAUSED=20=E8=AE=A2=E5=8D=95=E9=80=9A=E8=BF=87=E5=90=AF?= =?UTF-8?q?=E5=8A=A8=E6=8C=89=E9=92=AE=E7=BB=A7=E7=BB=AD=20-=20=E6=81=A2?= =?UTF-8?q?=E5=A4=8D=E5=89=8D=E6=A3=80=E6=9F=A5=20PLC=E3=80=81=E5=AE=89?= =?UTF-8?q?=E5=85=A8=E7=8A=B6=E6=80=81=E3=80=81=E8=AE=A2=E5=8D=95=E5=8F=8A?= =?UTF-8?q?=E5=8A=A8=E4=BD=9C=E5=91=BD=E4=BB=A4=E5=8F=8D=E9=A6=88=20-=20?= =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=9C=A8=E9=80=94=E5=8A=A8=E4=BD=9C=E6=8E=A5?= =?UTF-8?q?=E7=AE=A1=E3=80=81=E5=B7=B2=E5=AE=8C=E6=88=90=E5=8A=A8=E4=BD=9C?= =?UTF-8?q?=E6=94=B6=E5=B0=BE=E3=80=81=E5=AE=89=E5=85=A8=E9=87=8D=E8=AF=95?= =?UTF-8?q?=E5=92=8C=E4=BA=BA=E5=B7=A5=E7=A1=AE=E8=AE=A4=20-=20=E6=95=85?= =?UTF-8?q?=E9=9A=9C=E7=8A=B6=E6=80=81=E4=BF=9D=E6=8C=81=E8=AE=A2=E5=8D=95?= =?UTF-8?q?=20RUNNING=EF=BC=8C=E5=B9=B6=E6=8C=81=E4=B9=85=E5=8C=96?= =?UTF-8?q?=E5=AE=9E=E9=99=85=E6=81=A2=E5=A4=8D=E9=98=B6=E6=AE=B5=20-=20?= =?UTF-8?q?=E6=81=A2=E5=A4=8D=E6=88=90=E5=8A=9F=E5=90=8E=E4=BB=85=E6=B8=85?= =?UTF-8?q?=E9=99=A4=E6=9C=AC=E6=AC=A1=E8=BD=AF=E4=BB=B6=E6=95=85=E9=9A=9C?= =?UTF-8?q?=E5=AF=B9=E5=BA=94=E7=9A=84=E6=8A=A5=E8=AD=A6=20-=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0=E5=B0=8F=E8=BD=B4=20PLC=20=E5=9C=B0=E5=9D=80=E3=80=81?= =?UTF-8?q?Modbus=20=E9=85=8D=E7=BD=AE=E5=92=8C=E8=A7=86=E8=A7=89=E9=9B=86?= =?UTF-8?q?=E6=88=90=E6=96=87=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config.ini | 67 +- config/configmanager.cpp | 26 +- config/configmanager.h | 2 +- docs/plc-signal-audit-2026-10-29.md | 165 +++++ docs/visionguide-integration-status.md | 32 +- modbus/modbusaddress.cpp | 7 - modbus/modbusaddress.h | 42 +- models/visionresult.h | 2 +- pages/dashboardpage.cpp | 68 +- pages/dashboardpage.h | 5 +- pages/dashboardpage.ui | 2 +- services/deviceservice.cpp | 317 +++----- services/deviceservice.h | 28 +- services/productionservice.cpp | 954 +++++++++++-------------- services/productionservice.h | 26 +- services/productionworker.cpp | 21 - services/productionworker.h | 4 - 17 files changed, 839 insertions(+), 929 deletions(-) create mode 100644 docs/plc-signal-audit-2026-10-29.md diff --git a/config.ini b/config.ini index 40e050f..91f8aa5 100644 --- a/config.ini +++ b/config.ini @@ -17,14 +17,9 @@ pollIntervalMs=1000 feedbackTimeoutMs=2000 reconnectDelayMs=200 reconnectAttempts=2 -startCommand=0 -pauseCommand=1 -resetCommand=2 + +; Coils clearAlarmCommand=3 -startFeedback=10 -pauseFeedback=11 -resetFeedback=12 -clearAlarmFeedback=13 plcReady=100 robotReady=101 safetyDoorClosed=102 @@ -40,25 +35,40 @@ activeAlarm=507 currentStep=200 checkResult=201 errorCode=202 -rackPickCommand=300 -rackPickFeedback=310 -frontLoadCommand=301 -frontLoadFeedback=311 + +;robot signals +rackPickCommand=800 +rackPickFeedback=807 +frontLoadCommand=803 +frontLoadFeedback=810 inspectionCommand=302 inspectionFeedback=312 -frontUnloadCommand=303 -frontUnloadFeedback=313 -flipCommand=304 -flipFeedback=314 -backLoadCommand=305 -backLoadFeedback=315 -backUnloadCommand=306 -backUnloadFeedback=316 -rackPlaceCommand=307 -rackPlaceFeedback=317 -inspectionMode=320 -trayNumber=400 -slotNumber=401 +frontUnloadCommand=802 +frontUnloadFeedback=809 +flipCommand=804 +flipFeedback=811 +backLoadCommand=806 +backLoadFeedback=813 +backUnloadCommand=805 +backUnloadFeedback=812 +rackPlaceCommand=801 +rackPlaceFeedback=808 +inspectionMode=814 + +photoMoveCoil=850 +photoMoveCoilFeedback=851 +comparisonPickCoil=852 + + +;holdregister +slotNumber=800 +trayNumber=801 +slotRowNumber=802 +slotColumNumber=803 +; R indices, not raw Modbus addresses (R40=12328, R60=12348). +photoPoseR=40 +graspPoseR=60 +lowWordFirst=true [production] loadStep=1 @@ -82,7 +92,7 @@ productionEnabled=true [vision] ; Recognition switch only; the M850/M851 photo-position stage always precedes RackPick. -enabled=false +enabled=true contractConfirmed=true photoPoseReadyConfirmed=true executablePath=E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-integration/bin/VisionGuide.exe @@ -90,13 +100,6 @@ ipcName=ssp_visionguide_v1 startupTimeoutMs=15000 initializeTimeoutMs=60000 requestTimeoutMs=15000 -photoPoseR=40 -graspPoseR=60 -lowWordFirst=true -photoMoveCoil=850 -photoArrivedCoil=851 -comparisonPickCoil=852 -; ssp clears M850/M851 after arrival; M852 is overwritten before each RackPick and retained. [visionTrayMap] ; All six physical trays use VisionGuide configuration 1. diff --git a/config/configmanager.cpp b/config/configmanager.cpp index 7842d70..892307f 100644 --- a/config/configmanager.cpp +++ b/config/configmanager.cpp @@ -21,7 +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[] = {photoMoveCoil, photoArrivedCoil, comparisonPickCoil}; + const int coils[] = {photoMoveCoil, photoMoveCoilFeedback, comparisonPickCoil}; QSet unique; for (int coil : coils) { if (coil < 0 || coil > 65535 || unique.contains(coil)) { @@ -84,14 +84,7 @@ bool ConfigManager::load(const QString &filePath) m_modbusConfig.reconnectAttempts = settings.value("modbus/reconnectAttempts", m_modbusConfig.reconnectAttempts).toInt(); ModbusAddressMap &addresses = m_modbusConfig.addressMap; - addresses.startCommand = settings.value("modbus/startCommand", addresses.startCommand).toInt(); - addresses.pauseCommand = settings.value("modbus/pauseCommand", addresses.pauseCommand).toInt(); - addresses.resetCommand = settings.value("modbus/resetCommand", addresses.resetCommand).toInt(); addresses.clearAlarmCommand = settings.value("modbus/clearAlarmCommand", addresses.clearAlarmCommand).toInt(); - addresses.startFeedback = settings.value("modbus/startFeedback", addresses.startFeedback).toInt(); - addresses.pauseFeedback = settings.value("modbus/pauseFeedback", addresses.pauseFeedback).toInt(); - addresses.resetFeedback = settings.value("modbus/resetFeedback", addresses.resetFeedback).toInt(); - addresses.clearAlarmFeedback = settings.value("modbus/clearAlarmFeedback", addresses.clearAlarmFeedback).toInt(); addresses.plcReady = settings.value("modbus/plcReady", addresses.plcReady).toInt(); addresses.robotReady = settings.value("modbus/robotReady", addresses.robotReady).toInt(); addresses.safetyDoorClosed = settings.value("modbus/safetyDoorClosed", addresses.safetyDoorClosed).toInt(); @@ -200,12 +193,17 @@ 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.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.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(); + // PLC settings belong to modbus; retain vision keys for existing installations. + m_visionConfig.photoPoseR = settings.value("modbus/photoPoseR", settings.value("vision/photoPoseR", 40)).toInt(); + m_visionConfig.graspPoseR = settings.value("modbus/graspPoseR", settings.value("vision/graspPoseR", 60)).toInt(); + m_visionConfig.lowWordFirst = settings.value("modbus/lowWordFirst", settings.value("vision/lowWordFirst", true)).toBool(); + m_visionConfig.photoMoveCoil = settings.value("modbus/photoMoveCoil", settings.value("vision/photoMoveCoil", 850)).toInt(); + m_visionConfig.photoMoveCoilFeedback = settings.value( + "modbus/photoMoveCoilFeedback", + settings.value("modbus/photoArrivedCoil", + settings.value("vision/photoMoveCoilFeedback", + settings.value("vision/photoArrivedCoil", 851)))).toInt(); + m_visionConfig.comparisonPickCoil = settings.value("modbus/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 496576d..028bad4 100644 --- a/config/configmanager.h +++ b/config/configmanager.h @@ -22,7 +22,7 @@ struct VisionConfig int graspPoseR = 60; bool lowWordFirst = true; int photoMoveCoil = 850; - int photoArrivedCoil = 851; + int photoMoveCoilFeedback = 851; int comparisonPickCoil = 852; QMap trayMap; diff --git a/docs/plc-signal-audit-2026-10-29.md b/docs/plc-signal-audit-2026-10-29.md new file mode 100644 index 0000000..2134d5f --- /dev/null +++ b/docs/plc-signal-audit-2026-10-29.md @@ -0,0 +1,165 @@ +# ssp 与小轴 PLC 信号核对 + +日期:2026-10-29。依据:`E:/QTCode/ssp/项目信号表/小轴信号.xlsx`,Sheet1,C4:H87;以及当前 `config.ini`、`ModbusAddressMap`、`DeviceService`、`ProductionService`。 + +用户补充确认:使用 M850/M851/M852;D800 为保持寄存器地址 800;M816 是 PLC 给 ssp 的运行状态;M814 由 ssp 写,0=镀前、1=镀后。 + +## 1. 本次落实及结论 + +- 将 `photoPoseR`、`graspPoseR`、`lowWordFirst`、`photoMoveCoil`、`photoMoveCoilFeedback`、`comparisonPickCoil` 的 INI 入口统一放到 `[modbus]`;M851 兼容旧 `photoArrivedCoil` 键。 +- 更新已确认的普通流程点位。代码默认 `trayNumber=802` 与点表一致;当前用户 `config.ini` 保留其 `trayNumber=801` 覆盖值,尚未同步,需现场最终确认。相机已有 5 个逻辑点位保持确认地址。 +- 未定义的 25 个点位保留原占位地址并列在下方,不能据此直接认定已具备现场联机条件。 +- 本次只调整配置入口和已明确的地址;连续状态读取是下文建议,尚未改写读取逻辑。原始 Excel 未修改。 +- 为控制修改范围,内部相机 PLC 字段暂保留在 `VisionConfig`,不改现有调用接口;用户配置统一从 `[modbus]` 管理。 + +## 2. 已对应的信号 + +### 普通流程 + +命令由 ssp 写入;完成信号由 PLC 置位,当前 ssp 完成处理后会清除命令和完成位。表中“软件读完成”未说明清除责任,联调时应确认 PLC 允许这个清除动作、完成位保持到被清除。 + +| ssp 动作 | 命令配置:旧 → 新 | 完成配置:旧 → 新 | Excel 行 | +|---|---|---|---| +| RackPick 托盘取料 | rackPickCommand:300 → M800 | rackPickFeedback:310 → M807 | 4、11 | +| RackPlace 托盘放料 | rackPlaceCommand:307 → M801 | rackPlaceFeedback:317 → M808 | 5、12 | +| FrontUnload 正面取 | frontUnloadCommand:303 → M802 | frontUnloadFeedback:313 → M809 | 6、13 | +| FrontLoad 正面放 | frontLoadCommand:301 → M803 | frontLoadFeedback:311 → M810 | 7、14 | +| Flip 翻转 | flipCommand:304 → M804 | flipFeedback:314 → M811 | 8、15 | +| BackUnload 反面取 | backUnloadCommand:306 → M805 | backUnloadFeedback:316 → M812 | 9、16 | +| BackLoad 反面放 | backLoadCommand:305 → M806 | backLoadFeedback:315 → M813 | 10、17 | + +| 配置 | 原值 | 已确认地址 | 用途 | Excel 行 | +|---|---|---|---|---| +| inspectionMode | 线圈 320 | M814,线圈 814 | ssp 写,0=镀前,1=镀后 | 18 | +| slotNumber | 保持寄存器 401 | D800,保持寄存器 800 | ssp 写工位/格位,当前代码允许 1~49 | 58 | +| trayNumber | 保持寄存器 400 | D802,保持寄存器 802 | ssp 写物理料盘号 | 60 | + +FrontLoad/BackLoad 是往检测工位放料;FrontUnload/BackUnload 是从检测工位取料,按这一方向对应点表。 + +### 相机前置流程 + +| `[modbus]` 配置 | PLC 地址 | Modbus 地址及方式 | 方向/责任 | Excel 行 | +|---|---|---|---|---| +| photoMoveCoil=850 | M850 | 线圈 850,FC05 写 | ssp 请求移动;到位后 ssp 清零 | 36 | +| photoMoveCoilFeedback=851 | M851 | 线圈 851,FC01 读、FC05 清 | PLC 置位;ssp 读到到位后清零 | 37 | +| comparisonPickCoil=852 | M852 | 线圈 852,FC05 写 | ssp 每次 RackPick 前覆盖,完成后保留 | 38 | +| photoPoseR=40 | R40~R51 | 保持寄存器 12328~12339,FC03 一次读 12 字 | PLC 提供 6 个 float32;M851 置位前完成更新 | 75~80 | +| graspPoseR=60 | R60~R71 | 保持寄存器 12348~12359,FC10 一次写 12 字 | 测量成功才由 ssp 写 6 个 float32 | 82~87 | + +`lowWordFirst=true` 控制每个 float 的低 16 位字在前,支持负数;与单个 Modbus 字内部的网络字节序是两回事。点表本身没有明确字序,部署前用已知含负数坐标核对。 + +注意:`photoPoseR=40`、`graspPoseR=60` 填 R 编号,代码会加 `0x3000`;不能填成 12328、12348。D800 的配置直接填 800,不加 R 偏移。M800 与 D800 是不同地址空间,不冲突。 + +`[vision]` 继续放识别开关、IPC 名称、程序路径、超时和协议确认开关;六个物理料盘的 `[visionTrayMap]` 继续全部映射到配置 1。 + +## 3. ssp 使用、点表未定义的 25 个信号 + +“未定义”指没有可确认的同语义点位;下列地址是当前代码/配置的占位值,不能当成 PLC 实际协议。当前 `plcReady` 等状态会影响状态读取及生产准入,不能仅补齐相机点位就跳过这些核对。 + +| 类别 | 配置名 | 当前占位地址 | ssp 用途/方向 | +|---|---|---|---| +| 控制 | clearAlarmCommand | 线圈 3 | 写清报警命令 | +| 就绪/安全 | plcReady | 线圈 100 | 读 PLC 就绪;M816“运行中”不能直接等同 | +| 就绪/安全 | robotReady | 线圈 101 | 读机器人就绪;M818“运行状态”不能直接等同 | +| 就绪/安全 | safetyDoorClosed | 线圈 102 | 读总安全门关闭 | +| 就绪/安全 | emergencyStop | 线圈 103 | 读急停状态,当前 true 表示急停生效 | +| 设备状态 | inspectionMachineReady | 线圈 500 | 读检测机就绪 | +| 设备状态 | visionReady | 线圈 501 | 读 PLC 侧视觉就绪;与 IPC 服务就绪是两路来源 | +| 设备状态 | robotControlCabinetReady | 线圈 502 | 读机器人控制柜就绪 | +| 设备状态 | mainControlCabinetReady | 线圈 503 | 读主控柜就绪 | +| 设备状态 | safetyDoor1Closed | 线圈 504 | 读安全门 1 关闭 | +| 设备状态 | safetyDoor2Closed | 线圈 505 | 读安全门 2 关闭 | +| 设备状态 | safetyDoor3Closed | 线圈 506 | 读安全门 3 关闭 | +| 设备状态 | activeAlarm | 线圈 507 | 读报警存在 | +| 检测握手 | inspectionCommand | 线圈 302 | 写检测触发 | +| 检测握手 | inspectionFeedback | 线圈 312 | 读检测完成,处理后清零 | +| 结果 | currentStep | 保持寄存器 200 | 读 PLC 当前步骤 | +| 结果 | checkResult | 保持寄存器 201 | 读检测结果,当前约定 1=OK、2=NG、3=错误 | +| 结果 | errorCode | 保持寄存器 202 | 读错误码;usePlcErrorCode=false 时不读取 | + +统计:基础地址映射 42 个点,已对应 17 个,待定义 25 个;另有相机 3 个线圈和 2 组 REAL 数据。每组 REAL 按一个逻辑点统计,不按 12 个字重复计数。 + +### 表中有、ssp 暂未接入的点 + +| PLC 点 | 表内含义 | 当前情况 | +|---|---|---| +| M815 | 收到任务完成信号清除数据 | 未映射;需明确谁置位、谁清除及何时清哪些数据 | +| M816 | PLC开始运行 | 用户已明确为 PLC → ssp 的运行状态;未单独接入 | +| M817 | PLC任务执行中 | 未单独接入 | +| M818 | 机器人运行状态 | 未单独接入;不当作机器人就绪 | +| M820~M825 | 六个托盘到位接近开关 | 未单独读取;当前写 trayNumber 不代表已检查到位 | + +M819、D801、D803~D809 未命名,不视为已分配业务信号。是否用 M816/M817 取代现有应答机制属于协议变化,需要另行确认,不能只改地址。 + +## 4. 点表需要修订的地方 + +1. 第 38 行 M852 已是“是否比对取料”;第 40 行仍重复定义 M852 为旧“相机拍照比对”,第 41~42 行保留 M853/M854。以本次确认的 M850/M851/M852 为准,旧定义建议标为废弃。 +2. 第 62~67 行 D804~D809 的 Modbus 地址全部写成 803,属于重复。若沿用 D800=800 的映射规则应分别为 804~809,但这些空白点要先明确用途再分配。 +3. 第 75 行“R40-R52(12个INT)”应写 R40~R51;第 82 行“R60-R72(12个INT)”应写 R60~R71。6 个 REAL 各占 2 字;最后一个 REAL 起始分别为 R50/R70。 +4. 第 83~87 行相机反馈的 PLC 地址列为空,建议补齐 R62/R64/R66/R68/R70,与现有 Modbus 地址对应。 +5. 建议补充每个点的写入方、有效电平、复位方、保持条件、结果枚举及 REAL 字序。仅有“软件读”不足以完整描述握手。 + +## 5. 连续读取分析 + +### 现状与不移动地址的优化 + +普通状态轮询 `DeviceService::readStatusStep()`:12 个线圈逐个 FC01 读取,currentStep/checkResult 各一次 FC03,共 **14 次请求**;开启错误码后为 **15 次**。共享串行请求队列,慢响应会累积等待;pollIntervalMs=1000 不保证一轮恰好 1 秒。 + +| 当前配置地址 | 读取内容 | 现状请求数 | 建议请求数 | +|---|---|---|---| +| 线圈 100~103 | PLC/机器人就绪、总门、急停 | 4 | 1 次 FC01,数量 4 | +| 线圈 500~507 | 其他设备、安全门、报警 | 8 | 1 次 FC01,数量 8 | +| 保持寄存器 200~201 或 202 | 步骤、结果、可选错误码 | 2 或 3 | 1 次 FC03,数量 2 或 3 | +| 合计 | 一轮普通状态 | 14 或 15 | **3 次** | + +这是基于当前占位布局的技术分析,实际部署应使用 PLC 确认地址。代码已有批量 `readCoils`,普通状态流程还没有使用;保持寄存器需要补普通批量读取入口。先固定真实点表再实施最简单。 + +相机部分已经批量处理:M850~M852 一次读 3 位;R40 一次读 12 字,R60 一次写 12 字。普通动作当前只轮询正在执行的一个完成位,间隔 50ms,不必为凑连续读取而重复轮询所有完成位。 + +### 按现有小轴点表分区 + +| 区间 | 建议角色 | 读取策略 | +|---|---|---| +| M800~M806 | 7 个动作命令 | 按动作写,不周期读写整组 | +| M807~M813 | 7 个动作完成 | 活跃动作按需读;需要总览时可读 7 位 | +| M814~M818 | 模式、任务清除、PLC/任务/机器人状态 | 按各点责任使用,避免整组覆盖写 | +| M820~M825 | 6 个托盘到位 | 接入后一次 FC01 读 6 位 | +| M850~M852 | 拍照握手及比对取料 | 保持一次读 3 位,M852 每次取料前单独写 | +| D800、D802 | 工位号、料盘号 | 保持独立写,完成后才发 M850/普通动作命令 | +| R40~R51、R60~R71 | 输入/输出坐标 | 分别读写 12 字,不跨中间空隙合并写 | + +如果 PLC 明确 M819 可读,M807~M825 可一次读 19 位,涵盖完成/运行/料盘状态。否则拆开读;不要默认空白区间一定支持读取。 + +### 待补信号的地址建议(仅方案,未写入配置) + +优先保留已确认的 M800~M825、M850~M852、D800/D802 和 R40/R60。以下区间只在这份表中未定义,不代表 PLC 程序里一定空闲,须由 PLC 方核准。 + +| 建议区间 | 建议顺序 | 作用 | +|---|---|---| +| M826~M837 | plcReady、robotReady、safetyDoorClosed、emergencyStop、inspectionMachineReady、visionReady、robotControlCabinetReady、mainControlCabinetReady、safetyDoor1Closed、safetyDoor2Closed、safetyDoor3Closed、activeAlarm | 12 个普通状态连续,一次读 | +| M838 | clearAlarmCommand | 清报警单次置 1,不等待反馈;地址仍待 PLC 方确认 | +| M839~M845 | 暂留 | 启动、暂停、复位及其反馈已从 ssp 协议删除 | +| M846~M847 | inspectionCommand、inspectionFeedback | 检测握手 | +| M848~M849 | 暂留 | 无当前业务分配 | +| D804~D806 | currentStep、checkResult、errorCode | 3 个结果字连续;先纠正点表地址列并确认占用 | + +采用此方案后,普通状态为 M826~M837 一次 FC01,加 D804~D805/806 一次 FC03,即 **2 次请求**;若还需运行状态和托盘到位总览,可在 PLC 确认 M819 可读后,将 M807~M837 一次读 31 位。M850~M852 继续按需读取,便于保留拍照事务的时序和取消处理。 + +INI 行按“地址空间 → 地址升序”排列便于人工核对;仅调整行顺序不会减少通讯请求,实际优化必须修改读取代码。FC01 的 M 区和 FC03 的 D/R 区不能混为一次读取;读取失败仍应将本轮状态视为无效。批量读也不保证采样期间 PLC 状态完全不变,完成位应保持到约定的清除时刻。 + +## 6. 取料流程核对 + +1. ssp 写 D802 料盘号、D800 工位号,写入确认后置 M850=1。 +2. PLC/机器人到拍照位置,将 6 个当前位置 float 写好 R40~R51,再置 M851=1。 +3. ssp 读到到位后清 M850/M851,需要识别时读取 R40 并向 VisionGuide 发测量请求。 +4. 识别成功:确认整组写 R60~R71,再确认写 M852=1;未启用或识别失败:不写 R60,确认写 M852=0。 +5. ssp 进入普通 RackPick,命令 M800;PLC 完成反馈 M807。M852 保留,下一次取料前由 ssp 覆盖。 + +相机测量失败继续普通取料;PLC 到位/读写失败、R60/M852 写入是否成功不确定,仍属于 PLC 握手故障,不能伪装成相机测量失败继续运行。 + +## 7. 验证 + +- 本机 FakePlc:PLC/配置 13 passed;拍照前置及生产取料流程 47 passed。生产测试中的动作、反馈及 D 地址同步到本次已确认点表。 +- 覆盖旧 `[vision]` 配置回退、新 `[modbus]` 优先、移除配置恢复默认、错误新值不回退,以及新默认点位的地址空间不冲突。 +- 根配置的 20 个标量点位逐一对照 Excel PLC 地址列通过,另外核对 R40/R60 及全部六个新配置键位置;ssp 32/64 位全工程编译通过,`git diff --check` 通过。 +- 测试源位于既有忽略目录 `tests/vision_plc`、`tests/vision_production`;未自动添加至 Git。未连接真实 PLC、相机或机器人。 diff --git a/docs/visionguide-integration-status.md b/docs/visionguide-integration-status.md index 098a266..fc474cb 100644 --- a/docs/visionguide-integration-status.md +++ b/docs/visionguide-integration-status.md @@ -1,5 +1,19 @@ # VisionGuide 独立进程接入交付记录 +## 2026-10-29:PLC 配置归属及小轴点表核对 + +- R40/R60、REAL 字序、M850/M851/M852 的 INI 配置统一移至 `[modbus]`;M851 配置名为 `photoMoveCoilFeedback`,兼容读取旧 `photoArrivedCoil`。`vision/enabled` 仍是识别开关。 +- 已明确的七组取放/翻转命令与完成反馈改为 M800–M813;镀金状态为 M814(0=镀前、1=镀后);工位号为保持寄存器 800。点表及代码默认料盘号为 802,但当前用户 `config.ini` 覆盖为 801,本次保留该配置,待现场最终确认。 +- M816 是 PLC 提供的运行状态,不替代 ssp 的启动命令,也不直接等同于就绪。另有 25 个 ssp 使用的信号尚未在点表中定义,保留原占位配置,不能据此认定现场点位已齐全。 +- 全量对照、表内冲突和连续读取建议见 [PLC 信号核对](plc-signal-audit-2026-10-29.md)。本次不修改 PLC 程序、原始 Excel 或普通状态读取逻辑。 + +## 2026-10-29:订单控制、独立动作与恢复/重试 + +- 删除 `startCommand/startFeedback`、`pauseCommand/pauseFeedback`、`resetCommand/resetFeedback` 和 `clearAlarmFeedback`。订单启动、暂停、恢复不再等待 PLC 控制反馈;清报警只把 `clearAlarmCommand` 写为 1,成功后清除 ssp 活动报警。 +- M850/M851、视觉处理、M800/M807 分别是 `PHOTO_MOVING`、`VISION_PROCESSING`、`RACK_PICKING` 三个独立动作。M850/M851 完成并清零后才进入视觉;视觉成功写 R60/M852=1,关闭或识别失败写 M852=0;之后才开始 RackPick。 +- 暂停不取消正在运行的机器人动作。机器人动作正常完成并清命令/反馈后暂停;视觉尚未提交 R60/M852 时立即作废并暂停,恢复后重新读取 R40;提交状态不确定时转人工确认。 +- 原“复位”改为单一“恢复/重试”。它只处理 `Error/TimeoutPaused/ManualConfirm`,先刷新设备状态并读取当前动作命令/反馈:在途动作继续轮询,已完成动作清信号并前进,明确未发送才重试,曾发送但双 0 则保持人工确认。普通 `PAUSED` 订单由“启动”按钮继续。 + ## 2026-10-28:单实例与启动复用 - VisionGuide 默认开启 `ssp_visionguide_v1` IPC。SDK 初始化及主窗口创建前,以固定用户数据目录下的 QLockFile 保证同用户单实例;重复启动正常退出,不初始化相机。`--ipc-name` 仍可覆盖端点名,但不绕过单实例锁。升级时先关闭不支持该锁的旧版本。 @@ -16,7 +30,7 @@ - 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 后使用视觉结果。 +- 新配置为 photoMoveCoil=850、photoMoveCoilFeedback=851、comparisonPickCoil=852;旧五线圈配置和 handshakeProtocol 不再使用。根配置已启用识别,六个实物料盘均映射到 VisionGuide 配置 1。 - 实施说明: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。 @@ -36,18 +50,16 @@ - ssp–PLC:R40/R60 各六个 REAL、12 个寄存器整组读写;低字在前/高字在前编解码校验;视觉写入无自动重试;区分未发送、确认成功、发送后状态不明。保留原单 REAL API。 - ssp–VisionGuide:异步 QLocalSocket、QProcess、四字节大端长度与 JSON、会话/请求/工件/料盘/代次校验、取消与迟到结果拒绝;单个测量在途。 - VisionGuide:独立线程通信;左右相机参数及一次白平衡初始化;新测量页左相机识别后自动计算抓取;冻结 R40 位姿及料盘参数;原 UI/OPC 与自动流程互斥。 -- ssp 生产:只在 RackPick 料架取料中执行视觉子流程。先确认旧握手全低,再发原取料运动命令,收到 851 才读取 R40;有效结果写 R60,写应答确认后才置 854;等 850 及 850/851 复位,再清 ssp 输出,继续原动作反馈。 -- 界面及恢复:新增“视觉引导”页显示三组坐标、初始化及流程状态;与生产线程 queued 传值。暂停/停止立即作废旧请求;提交后不确定状态保持人工恢复锁,停止到 Idle 也不能直接开启新订单。恢复按钮要求现场核对,先读 850/851,再清 ssp 输出并重读全部握手;旧坐标不重发。 +- ssp 生产:普通 RackPick 前依次执行三个独立阶段:M850/M851 移动到拍照位、视觉处理、M800/M807 RackPick。到位阶段完成后清 M850/M851;视觉成功写 R60/M852=1,关闭或测量失败写 M852=0。 +- 界面及恢复:新增“视觉引导”页显示三组坐标、初始化及流程状态;与生产线程 queued 传值。暂停等待当前机器人动作完成,未提交结果的视觉请求可作废;结果提交状态不明时转人工确认。“恢复/重试”只处理故障状态,普通暂停由“启动/继续”恢复。 ## 线圈及固定参数 | 线圈 | 含义 | 控制方 | |---|---|---| -| 850 | 机器人接收结果成功 | PLC/机器人 | -| 851 | 请求拍照,机器人已停稳且 R40 已更新 | PLC/机器人 | -| 852 | 相机拍照比对中 | ssp | -| 853 | 相机数据比对错误 | ssp | -| 854 | 相机比对通过,R60 可用 | ssp | +| 850 | 移动到拍照位置命令 | ssp | +| 851 | 移动到拍照位置完成反馈 | PLC/机器人,ssp 到位后清零 | +| 852 | 是否比对取料;1=使用 R60,0=普通取料 | ssp,每次取料前覆盖并保持 | 测量固定:左相机、高精细化、5 秒采图/识别截止、MinScore 0.70、Greediness 0.80、YOLO 中心选择、相机显示模型原点、模型 +Z 抓取偏移 4.40 mm。偏移只在 VisionGuide 应用一次。整体通信和机器人确认使用独立超时。 @@ -65,7 +77,7 @@ | VisionGuide IPC | 8 passed;`E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-ipc-test/results-final.txt` | | VisionGuide 抓取/资源门控 | 7 passed;`E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-grasp-test/results-final-ready.txt` | -生产测试包含真实异步 Modbus 管理器与本地 FakePlc,覆盖 R60/854 已排队而暂停槽尚未执行时的发送前门控。内存订单/报警夹具仅用于验证流程,没有做 PostgreSQL 全库回归。相机识别质量、真实白平衡完成和机器人目标消费尚未现场验收。没有通过 GUI 操作 Qt Creator;验证为对应 Qt/MinGW 的 qmake 和 make 构建。用户现有 `ssp.pro.user` 保存的活动 Kit 为 MinGW 64 位,本次保留该文件既有修改,并补齐 32/64 位两套构建验证。 +生产测试包含真实异步 Modbus 管理器与本地 FakePlc,覆盖 R60/M852 写入门控及独立动作恢复。内存订单/报警夹具仅用于验证流程,没有做 PostgreSQL 全库回归。相机识别质量、真实白平衡完成和机器人目标消费尚未现场验收。没有通过 GUI 操作 Qt Creator;验证为对应 Qt/MinGW 的 qmake 和 make 构建。用户现有 `ssp.pro.user` 保存的活动 Kit 为 MinGW 64 位,本次保留该文件既有修改,并补齐 32/64 位两套构建验证。 ## 配置与使用 @@ -77,7 +89,7 @@ 视觉故障后若活动订单的 PLC 步骤仍处于取料/上料等无法明确恢复的状态,人工恢复会保留锁定并提示先终止当前任务、核对机器人后再恢复,不会进入旧的 Loading 空状态或先发 PLC 启动。仅已明确进入现有正面/反面检测步骤时可接回原恢复流程。 -VisionGuide 原测量页已有 1–99 料盘配置选择,现场文件目前保存配置 1 和 2;它是标定/法向/示教/高度设置编号,不自动等同 ssp 实物料盘号。本次未修改其用户配置。 +VisionGuide 当前只使用配置 1;ssp 的六个实物料盘均映射到该配置。该编号代表标定/法向/示教/高度设置,不等同于实物料盘号。 ## 待现场验收 diff --git a/modbus/modbusaddress.cpp b/modbus/modbusaddress.cpp index 8c4e9cf..db19c8b 100644 --- a/modbus/modbusaddress.cpp +++ b/modbus/modbusaddress.cpp @@ -16,14 +16,7 @@ bool isValidAddress(int address) bool ModbusAddressMap::isValid(QString *error) const { const QList > coilAddresses = QList >() - << qMakePair(QString("startCommand"), startCommand) - << qMakePair(QString("pauseCommand"), pauseCommand) - << qMakePair(QString("resetCommand"), resetCommand) << qMakePair(QString("clearAlarmCommand"), clearAlarmCommand) - << qMakePair(QString("startFeedback"), startFeedback) - << qMakePair(QString("pauseFeedback"), pauseFeedback) - << qMakePair(QString("resetFeedback"), resetFeedback) - << qMakePair(QString("clearAlarmFeedback"), clearAlarmFeedback) << qMakePair(QString("plcReady"), plcReady) << qMakePair(QString("robotReady"), robotReady) << qMakePair(QString("safetyDoorClosed"), safetyDoorClosed) diff --git a/modbus/modbusaddress.h b/modbus/modbusaddress.h index 1b00108..44b0edc 100644 --- a/modbus/modbusaddress.h +++ b/modbus/modbusaddress.h @@ -5,16 +5,8 @@ struct ModbusAddressMap { - int startCommand = 0; - int pauseCommand = 1; - int resetCommand = 2; int clearAlarmCommand = 3; - int startFeedback = 10; - int pauseFeedback = 11; - int resetFeedback = 12; - int clearAlarmFeedback = 13; - int plcReady = 100; int robotReady = 101; int safetyDoorClosed = 102; @@ -35,27 +27,27 @@ struct ModbusAddressMap int checkResult = 201; int errorCode = 202; - int rackPickCommand = 300; - int frontLoadCommand = 301; + int rackPickCommand = 800; + int frontLoadCommand = 803; int inspectionCommand = 302; - int frontUnloadCommand = 303; - int flipCommand = 304; - int backLoadCommand = 305; - int backUnloadCommand = 306; - int rackPlaceCommand = 307; + int frontUnloadCommand = 802; + int flipCommand = 804; + int backLoadCommand = 806; + int backUnloadCommand = 805; + int rackPlaceCommand = 801; - int rackPickFeedback = 310; - int frontLoadFeedback = 311; + int rackPickFeedback = 807; + int frontLoadFeedback = 810; int inspectionFeedback = 312; - int frontUnloadFeedback = 313; - int flipFeedback = 314; - int backLoadFeedback = 315; - int backUnloadFeedback = 316; - int rackPlaceFeedback = 317; + int frontUnloadFeedback = 809; + int flipFeedback = 811; + int backLoadFeedback = 813; + int backUnloadFeedback = 812; + int rackPlaceFeedback = 808; - int inspectionMode = 320; - int trayNumber = 400; - int slotNumber = 401; + int inspectionMode = 814; + int trayNumber = 802; + int slotNumber = 800; bool isValid(QString *error = nullptr) const; }; diff --git a/models/visionresult.h b/models/visionresult.h index 124cb9e..462cdf5 100644 --- a/models/visionresult.h +++ b/models/visionresult.h @@ -24,7 +24,7 @@ struct RobotPose struct VisionHandshake { bool photoMove = false; - bool photoArrived = false; + bool photoMoveFeedback = false; bool comparisonPick = false; }; diff --git a/pages/dashboardpage.cpp b/pages/dashboardpage.cpp index 233865d..b2ff0a4 100644 --- a/pages/dashboardpage.cpp +++ b/pages/dashboardpage.cpp @@ -35,6 +35,8 @@ QString displayState(const QString &state) if (state == "IDLE") return "待机"; if (state == "PREPARING") return "准备中"; if (state == "WAITING_DEVICE_READY") return "等待设备就绪"; + if (state == "PHOTO_MOVING") return "移动到拍照位置"; + if (state == "VISION_PROCESSING") return "相机视觉处理"; if (state == "RACK_PICKING") return "料架取料"; if (state == "FRONT_LOADING") return "正面上料"; if (state == "LOADING") return "上料"; @@ -117,8 +119,6 @@ DashboardPage::DashboardPage(QWidget *parent) , safetyDoor2Cell(nullptr) , safetyDoor3Cell(nullptr) , alarmCell(nullptr) - , recoverButton(new QPushButton("恢复", this)) - , retryButton(new QPushButton("重试", this)) , markNgButton(new QPushButton("标记 NG", this)) , stopButton(new QPushButton("终止", this)) , processBox(new QGroupBox("工序耗时", this)) @@ -133,6 +133,7 @@ DashboardPage::DashboardPage(QWidget *parent) , productionState(ProductionService::Idle) , currentOrderId(0) , currentOrderStartable(false) + , currentOrderResumable(false) , productionTrayNo(0) , productionSlotNo(0) { @@ -153,15 +154,10 @@ DashboardPage::DashboardPage(QWidget *parent) ui->startButton->setObjectName("primaryButton"); ui->nextButton->setVisible(false); - recoverButton->setObjectName("recoveryButton"); - recoverButton->setVisible(false); - ui->buttonLayout->insertWidget(3, recoverButton); - retryButton->setObjectName("recoveryRetryButton"); - retryButton->setVisible(false); - ui->buttonLayout->insertWidget(4, retryButton); + ui->recoveryButton->setVisible(false); markNgButton->setObjectName("recoveryNgButton"); markNgButton->setVisible(false); - ui->buttonLayout->insertWidget(5, markNgButton); + ui->buttonLayout->insertWidget(4, markNgButton); stopButton->setObjectName("stopButton"); stopButton->setVisible(false); ui->buttonLayout->insertWidget(6, stopButton); @@ -247,14 +243,10 @@ DashboardPage::DashboardPage(QWidget *parent) this, &DashboardPage::pauseProduction); connect(stopButton, &QPushButton::clicked, this, &DashboardPage::stopProduction); - connect(ui->resetButton, &QPushButton::clicked, - this, &DashboardPage::resetProduction); + connect(ui->recoveryButton, &QPushButton::clicked, + this, &DashboardPage::recoverProduction); connect(ui->clearAlarmButton, &QPushButton::clicked, this, &DashboardPage::clearAlarm); - connect(recoverButton, &QPushButton::clicked, - this, &DashboardPage::recoverProduction); - connect(retryButton, &QPushButton::clicked, - this, &DashboardPage::retryRecovery); connect(markNgButton, &QPushButton::clicked, this, &DashboardPage::markWorkpieceNg); connect(productionWorker, &ProductionWorker::stateChanged, @@ -384,6 +376,13 @@ void DashboardPage::updateRackSize() void DashboardPage::startProduction() { + if (productionState == ProductionService::Paused) { + if (!currentOrderResumable) return; + ui->startButton->setEnabled(false); + QMetaObject::invokeMethod(productionWorker, "requestResume", + Qt::QueuedConnection); + return; + } if (productionState != ProductionService::Idle && productionState != ProductionService::Completed) { return; @@ -408,7 +407,6 @@ void DashboardPage::startProduction() void DashboardPage::pauseProduction() { - productionWorker->requestPauseImmediate(); QMetaObject::invokeMethod(productionWorker, "requestPause", Qt::QueuedConnection); } @@ -420,12 +418,6 @@ void DashboardPage::stopProduction() Qt::QueuedConnection); } -void DashboardPage::resetProduction() -{ - QMetaObject::invokeMethod(productionWorker, "requestReset", - Qt::QueuedConnection); -} - void DashboardPage::clearAlarm() { QMetaObject::invokeMethod(productionWorker, "requestClearAlarm", @@ -531,7 +523,7 @@ void DashboardPage::recoverProduction() this, "继续生产", visionRecoveryRequired ? "请先核对机器人当前位置及本次取料是否已执行或撤销,并确认 M850 移动请求和 M851 到位反馈已复位。恢复不会清除 M852,也不会重发旧坐标。是否已完成现场核对?" - : "请确认设备和 PLC 当前步骤安全后再继续生产。", + : "当前动作是否执行无法自动确认。请核对机器人位置、工件状态及对应命令/反馈信号,确认现场状态安全后再继续。", QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) { return; @@ -541,12 +533,6 @@ void DashboardPage::recoverProduction() Qt::QueuedConnection); } -void DashboardPage::retryRecovery() -{ - QMetaObject::invokeMethod(productionWorker, "requestRetry", - Qt::QueuedConnection); -} - void DashboardPage::markWorkpieceNg() { if (QMessageBox::question( @@ -565,23 +551,27 @@ void DashboardPage::updateRecoveryButtons() { const ProductionService::State state = productionState; const bool recoveryRequired = state == ProductionService::TimeoutPaused - || state == ProductionService::ManualConfirm || visionRecoveryRequired; + || state == ProductionService::ManualConfirm + || state == ProductionService::Error || visionRecoveryRequired; const bool running = state != ProductionService::Idle && state != ProductionService::Completed; const bool terminating = state == ProductionService::Terminating; - const bool canStart = (state == ProductionService::Idle - || state == ProductionService::Completed) - && currentOrderStartable && !visionRecoveryRequired; + const bool canStart = (((state == ProductionService::Idle + || state == ProductionService::Completed) + && currentOrderStartable) + || (state == ProductionService::Paused + && currentOrderResumable)) + && !visionRecoveryRequired; ui->startButton->setEnabled(canStart); - recoverButton->setVisible(recoveryRequired); - retryButton->setVisible(recoveryRequired && !visionRecoveryRequired); + ui->startButton->setText(state == ProductionService::Paused + ? "继续" : "启动"); + ui->recoveryButton->setVisible(recoveryRequired); + ui->recoveryButton->setEnabled(!terminating); markNgButton->setVisible(recoveryRequired && productionWorkpiece.id > 0 && !visionRecoveryRequired); stopButton->setVisible(running); stopButton->setEnabled(!terminating); stopButton->setText(terminating ? "终止中..." : "终止"); - recoverButton->setText(visionRecoveryRequired ? "核对视觉恢复" : state == ProductionService::ManualConfirm - ? "继续" : "恢复"); } QString DashboardPage::formatDuration(int elapsedMs) @@ -808,6 +798,7 @@ void DashboardPage::loadCurrentOrder() if (!OrderService::instance().findUnfinishedOrder(&order, &error)) { currentOrderId = 0; currentOrderStartable = false; + currentOrderResumable = false; ui->orderLabel->setText("当前订单:读取失败"); updateProductionStats(); updateRackSummary(); @@ -818,6 +809,7 @@ void DashboardPage::loadCurrentOrder() currentOrderId = order.id; currentOrderStartable = false; + currentOrderResumable = false; if (order.id <= 0) { ui->orderLabel->setText("当前订单:暂无未完成订单"); emit currentOrderChanged("-"); @@ -833,6 +825,8 @@ void DashboardPage::loadCurrentOrder() if (workpieceError.isEmpty()) { currentOrderStartable = order.status == "NOT_START" && !workpieces.isEmpty(); + currentOrderResumable = order.status == "PAUSED" + && !workpieces.isEmpty(); } ui->orderLabel->setText(QString("当前订单:%1(%2)") diff --git a/pages/dashboardpage.h b/pages/dashboardpage.h index 6b6ec98..bb9c54f 100644 --- a/pages/dashboardpage.h +++ b/pages/dashboardpage.h @@ -44,7 +44,6 @@ private slots: void startProduction(); void pauseProduction(); void stopProduction(); - void resetProduction(); void clearAlarm(); void onProductionStateChanged(ProductionService::State state, const QString &name); @@ -58,7 +57,6 @@ private slots: void onTimeoutRecoveryRequired(const QString &state, const QString &message); void onRecoveryCompleted(const QString &mode); void recoverProduction(); - void retryRecovery(); void markWorkpieceNg(); protected: @@ -86,8 +84,6 @@ private: QLabel *safetyDoor2Cell; QLabel *safetyDoor3Cell; QLabel *alarmCell; - QPushButton *recoverButton; - QPushButton *retryButton; QPushButton *markNgButton; QPushButton *stopButton; QGroupBox *processBox; @@ -102,6 +98,7 @@ private: ProductionService::State productionState; int currentOrderId; bool currentOrderStartable; + bool currentOrderResumable; Workpiece productionWorkpiece; int productionTrayNo; int productionSlotNo; diff --git a/pages/dashboardpage.ui b/pages/dashboardpage.ui index f46392d..3263c99 100644 --- a/pages/dashboardpage.ui +++ b/pages/dashboardpage.ui @@ -116,7 +116,7 @@ 启动 暂停 - 复位 + 恢复/重试 下一步 清除报警 diff --git a/services/deviceservice.cpp b/services/deviceservice.cpp index 01a584a..7c291d7 100644 --- a/services/deviceservice.cpp +++ b/services/deviceservice.cpp @@ -8,10 +8,9 @@ namespace { -const int FeedbackPollIntervalMs = 50; - bool actionAddresses(DeviceService::ProductionAction action, const ModbusAddressMap &addresses, + const VisionConfig &vision, int *commandAddress, int *feedbackAddress) { if (!commandAddress || !feedbackAddress) { @@ -19,6 +18,10 @@ bool actionAddresses(DeviceService::ProductionAction action, } switch (action) { + case DeviceService::PhotoMoveAction: + *commandAddress = vision.photoMoveCoil; + *feedbackAddress = vision.photoMoveCoilFeedback; + return true; case DeviceService::RackPick: *commandAddress = addresses.rackPickCommand; *feedbackAddress = addresses.rackPickFeedback; @@ -70,8 +73,6 @@ DeviceService::DeviceService(QObject *parent) , m_productionFeedbackAddress(-1) , m_terminationActive(false) , m_terminationSignalIndex(0) - , m_controlCommandAddress(-1) - , m_controlFeedbackAddress(-1) { connect(m_pollTimer, &QTimer::timeout, this, &DeviceService::pollStatus); @@ -349,84 +350,6 @@ DeviceStatus DeviceService::simulatedStatus() const return status; } -void DeviceService::start(const OperationCallback &callback) -{ - if (m_terminationActive) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - - if (ConfigManager::instance().simulationMode()) { - if (callback) { - callback(true, QString()); - } - return; - } - if (!ConfigManager::instance().productionEnabled()) { - if (callback) { - callback(false, "Production control is disabled by configuration"); - } - return; - } - - const ModbusAddressMap &addresses = m_modbus->config().addressMap; - executeCommand(addresses.startCommand, addresses.startFeedback, callback); -} - -void DeviceService::pause(const OperationCallback &callback) -{ - if (m_terminationActive) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - - if (ConfigManager::instance().simulationMode()) { - if (callback) { - callback(true, QString()); - } - return; - } - if (!ConfigManager::instance().productionEnabled()) { - if (callback) { - callback(false, "Production control is disabled by configuration"); - } - return; - } - - const ModbusAddressMap &addresses = m_modbus->config().addressMap; - executeCommand(addresses.pauseCommand, addresses.pauseFeedback, callback); -} - -void DeviceService::reset(const OperationCallback &callback) -{ - if (m_terminationActive) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - - if (ConfigManager::instance().simulationMode()) { - if (callback) { - callback(true, QString()); - } - return; - } - if (!ConfigManager::instance().productionEnabled()) { - if (callback) { - callback(false, "Production control is disabled by configuration"); - } - return; - } - - const ModbusAddressMap &addresses = m_modbus->config().addressMap; - executeCommand(addresses.resetCommand, addresses.resetFeedback, callback); -} - void DeviceService::clearAlarm(const OperationCallback &callback) { if (m_terminationActive) { @@ -449,9 +372,22 @@ void DeviceService::clearAlarm(const OperationCallback &callback) return; } - const ModbusAddressMap &addresses = m_modbus->config().addressMap; - executeCommand(addresses.clearAlarmCommand, - addresses.clearAlarmFeedback, callback); + if (m_controlRequestPending || m_productionActionBusy) { + if (callback) { + callback(false, "Another PLC operation is already active"); + } + return; + } + + m_controlRequestPending = true; + m_modbus->writeCoil( + m_modbus->config().addressMap.clearAlarmCommand, true, + [this, callback](bool success, const QString &error) { + m_controlRequestPending = false; + if (callback) { + callback(success, error); + } + }); } void DeviceService::setInspectionMode(const QString &mode, @@ -517,7 +453,6 @@ void DeviceService::terminate(const OperationCallback &callback) m_pollTimer->stop(); const QList> currentSignals = QList>() - << qMakePair(m_controlCommandAddress, m_controlFeedbackAddress) << qMakePair(m_productionCommandAddress, m_productionFeedbackAddress); for (const QPair &signalPair : currentSignals) { @@ -546,16 +481,7 @@ void DeviceService::clearNextTerminationSignal() return; } if (m_terminationSignalIndex >= m_terminationSignals.size()) { - const ModbusAddressMap &addresses = m_modbus->config().addressMap; - executeCommand( - addresses.pauseCommand, addresses.pauseFeedback, - [this](bool success, const QString &error) { - if (!success) { - finishTermination(false, error); - return; - } - finishTermination(true, QString()); - }, true); + finishTermination(true, QString()); return; } @@ -587,8 +513,6 @@ void DeviceService::finishTermination(bool success, const QString &error) m_productionActionActive = false; m_productionActionBusy = false; if (success) { - m_controlCommandAddress = -1; - m_controlFeedbackAddress = -1; m_productionCommandAddress = -1; m_productionFeedbackAddress = -1; } @@ -597,113 +521,6 @@ void DeviceService::finishTermination(bool success, const QString &error) } } -void DeviceService::executeCommand(int commandAddress, int feedbackAddress, - const OperationCallback &callback, - bool allowDuringTermination) -{ - if (m_terminationActive && !allowDuringTermination) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - if (m_controlRequestPending || m_productionActionBusy) { - if (callback) { - callback(false, "Another PLC operation is already active"); - } - return; - } - - m_controlRequestPending = true; - m_controlCommandAddress = commandAddress; - m_controlFeedbackAddress = feedbackAddress; - writeCommandAndWaitFeedback(commandAddress, feedbackAddress, - [this, commandAddress, feedbackAddress, - callback](bool success, - const QString &error) { - m_controlRequestPending = false; - if (success - && m_controlCommandAddress - == commandAddress - && m_controlFeedbackAddress - == feedbackAddress) { - m_controlCommandAddress = -1; - m_controlFeedbackAddress = -1; - } - if (callback) { - callback(success, error); - } - }, allowDuringTermination); -} - -void DeviceService::writeCommandAndWaitFeedback( - int commandAddress, int feedbackAddress, - const OperationCallback &callback, bool allowDuringTermination) -{ - if (m_terminationActive && !allowDuringTermination) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - m_modbus->writeCoil( - commandAddress, true, - [this, commandAddress, feedbackAddress, callback, - allowDuringTermination](bool success, - const QString &error) { - if (!success) { - if (callback) { - callback(false, error); - } - return; - } - pollFeedback(commandAddress, feedbackAddress, callback, - allowDuringTermination); - }); -} - -void DeviceService::pollFeedback(int commandAddress, int feedbackAddress, - const OperationCallback &callback, - bool allowDuringTermination) -{ - if (m_terminationActive && !allowDuringTermination) { - if (callback) { - callback(false, "PLC termination is in progress"); - } - return; - } - m_modbus->readCoil( - feedbackAddress, - [this, commandAddress, feedbackAddress, callback, - allowDuringTermination]( - bool success, bool feedback, - const QString &error) { - if (!success) { - if (callback) { - callback(false, error); - } - return; - } - if (!feedback) { - QTimer::singleShot( - FeedbackPollIntervalMs, this, - [this, commandAddress, feedbackAddress, callback, - allowDuringTermination]() { - pollFeedback(commandAddress, feedbackAddress, callback, - allowDuringTermination); - }); - return; - } - - clearSignals(commandAddress, feedbackAddress, - [callback](bool cleared, const QString &clearError) { - if (callback) { - callback(cleared, clearError); - } - }); - }); -} - void DeviceService::beginProductionAction( ProductionAction action, int trayNo, int slotNo, const OperationCallback &callback, const std::function &beforeSend) @@ -740,7 +557,8 @@ void DeviceService::beginProductionAction( } const ModbusAddressMap &addresses = m_modbus->config().addressMap; - if (!actionAddresses(action, addresses, + const VisionConfig vision = ConfigManager::instance().visionConfig(); + if (!actionAddresses(action, addresses, vision, &m_productionCommandAddress, &m_productionFeedbackAddress)) { if (callback) { @@ -750,10 +568,11 @@ void DeviceService::beginProductionAction( } m_productionActionBusy = true; - m_modbus->readCoil( - m_productionFeedbackAddress, + inspectProductionAction( + action, [this, action, trayNo, slotNo, addresses, callback, beforeSend]( - bool success, bool feedback, const QString &error) { + bool success, const ProductionActionStatus &status, + const QString &error) { if (!success) { m_productionActionBusy = false; if (callback) { @@ -761,11 +580,11 @@ void DeviceService::beginProductionAction( } return; } - if (feedback) { + if (status.command || status.feedback) { m_productionActionBusy = false; if (callback) { callback(false, - "PLC feedback is still active before a new action"); + "PLC command or feedback is still active before a new action"); } return; } @@ -803,7 +622,8 @@ void DeviceService::beginProductionAction( } }; - if (action == RackPick || action == RackPlace) { + if (action == PhotoMoveAction || action == RackPick + || action == RackPlace) { m_modbus->writeHoldingRegister( addresses.trayNumber, static_cast(trayNo), @@ -825,6 +645,67 @@ void DeviceService::beginProductionAction( }); } +void DeviceService::inspectProductionAction( + ProductionAction action, const ActionStatusCallback &callback) +{ + ProductionActionStatus emptyStatus; + if (m_terminationActive) { + if (callback) callback(false, emptyStatus, + "PLC termination is in progress"); + return; + } + if (ConfigManager::instance().simulationMode()) { + if (callback) callback(true, emptyStatus, QString()); + return; + } + + int commandAddress = -1; + int feedbackAddress = -1; + if (!actionAddresses(action, m_modbus->config().addressMap, + ConfigManager::instance().visionConfig(), + &commandAddress, &feedbackAddress)) { + if (callback) callback(false, emptyStatus, + "Unknown PLC production action"); + return; + } + + m_modbus->readCoil( + commandAddress, + [this, feedbackAddress, callback](bool commandRead, bool command, + const QString &commandError) { + if (!commandRead) { + if (callback) callback(false, ProductionActionStatus(), + commandError); + return; + } + m_modbus->readCoil( + feedbackAddress, + [callback, command](bool feedbackRead, bool feedback, + const QString &feedbackError) { + ProductionActionStatus status; + status.command = command; + status.feedback = feedback; + if (callback) callback(feedbackRead, status, + feedbackError); + }); + }); +} + +void DeviceService::adoptProductionAction(ProductionAction action) +{ + int commandAddress = -1; + int feedbackAddress = -1; + if (m_productionActionBusy + || !actionAddresses(action, m_modbus->config().addressMap, + ConfigManager::instance().visionConfig(), + &commandAddress, &feedbackAddress)) { + return; + } + m_productionCommandAddress = commandAddress; + m_productionFeedbackAddress = feedbackAddress; + m_productionActionActive = true; +} + void DeviceService::pollProductionAction(const ActionCallback &callback) { if (m_terminationActive) { @@ -1069,7 +950,7 @@ void DeviceService::readVisionHandshake(const HandshakeCallback &callback) return; } const VisionConfig config = ConfigManager::instance().visionConfig(); - if (config.photoArrivedCoil == config.photoMoveCoil + 1 + if (config.photoMoveCoilFeedback == config.photoMoveCoil + 1 && config.comparisonPickCoil == config.photoMoveCoil + 2) { const quint64 generation = m_visionGeneration; m_modbus->readCoils(config.photoMoveCoil, 3, @@ -1077,7 +958,7 @@ void DeviceService::readVisionHandshake(const HandshakeCallback &callback) VisionHandshake state; if (success && values.size() == 3 && generation == m_visionGeneration) { state.photoMove = values.at(0); - state.photoArrived = values.at(1); + state.photoMoveFeedback = values.at(1); state.comparisonPick = values.at(2); if (callback) callback(true, state, QString()); } else if (callback) { @@ -1101,7 +982,7 @@ void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &st return; } const VisionConfig config = ConfigManager::instance().visionConfig(); - const int addresses[] = {config.photoMoveCoil, config.photoArrivedCoil, config.comparisonPickCoil}; + const int addresses[] = {config.photoMoveCoil, config.photoMoveCoilFeedback, config.comparisonPickCoil}; m_modbus->readVisionCoil(addresses[index], [this, index, state, generation, callback](bool success, bool value, const QString &error) { if (!success) { @@ -1111,7 +992,7 @@ void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &st VisionHandshake next = state; switch (index) { case 0: next.photoMove = value; break; - case 1: next.photoArrived = value; break; + case 1: next.photoMoveFeedback = value; break; case 2: next.comparisonPick = value; break; } readVisionHandshakeStep(index + 1, next, generation, callback); @@ -1131,8 +1012,8 @@ void DeviceService::writeVisionSignal(VisionSignal signal, bool value, int address = -1; switch (signal) { case PhotoMove: address = config.photoMoveCoil; break; - case PhotoArrived: - if (!value) address = config.photoArrivedCoil; // Only PLC may publish arrival. + case PhotoMoveFeedback: + if (!value) address = config.photoMoveCoilFeedback; // Only PLC may publish arrival. break; case ComparisonPick: address = config.comparisonPickCoil; break; default: break; diff --git a/services/deviceservice.h b/services/deviceservice.h index d170c21..301de03 100644 --- a/services/deviceservice.h +++ b/services/deviceservice.h @@ -32,6 +32,12 @@ struct DeviceStatus Q_DECLARE_METATYPE(DeviceStatus) +struct ProductionActionStatus +{ + bool command = false; + bool feedback = false; +}; + class QTimer; class DeviceService : public QObject @@ -44,14 +50,17 @@ public: std::function; using ActionCallback = std::function; + using ActionStatusCallback = + std::function; using PoseCallback = std::function; using HandshakeCallback = std::function; using VisionWriteCallback = std::function; - enum VisionSignal { PhotoMove, PhotoArrived, ComparisonPick }; + enum VisionSignal { PhotoMove, PhotoMoveFeedback, ComparisonPick }; enum ProductionAction { + PhotoMoveAction, RackPick, FrontLoad, Inspect, @@ -70,9 +79,6 @@ public: bool isPolling() const; void requestStatus(const StatusCallback &callback); - void start(const OperationCallback &callback); - void pause(const OperationCallback &callback); - void reset(const OperationCallback &callback); void clearAlarm(const OperationCallback &callback); void setInspectionMode(const QString &mode, const OperationCallback &callback); @@ -81,6 +87,9 @@ public: int slotNo, const OperationCallback &callback, const std::function &beforeSend = {}); void pollProductionAction(const ActionCallback &callback); + void inspectProductionAction(ProductionAction action, + const ActionStatusCallback &callback); + void adoptProductionAction(ProductionAction action); void cancelProductionAction(const OperationCallback &callback); bool productionActionActive() const; bool productionActionBusy() const; @@ -104,15 +113,6 @@ private: void readStatusStep(int index, const DeviceStatus &status); void finishStatusRequest(bool success, const DeviceStatus &status, const QString &error); - void executeCommand(int commandAddress, int feedbackAddress, - const OperationCallback &callback, - bool allowDuringTermination = false); - void writeCommandAndWaitFeedback(int commandAddress, int feedbackAddress, - const OperationCallback &callback, - bool allowDuringTermination = false); - void pollFeedback(int commandAddress, int feedbackAddress, - const OperationCallback &callback, - bool allowDuringTermination = false); void clearSignals(int commandAddress, int feedbackAddress, const OperationCallback &callback); void clearActionSignals(const OperationCallback &callback); @@ -136,8 +136,6 @@ private: QList> m_terminationSignals; int m_terminationSignalIndex; OperationCallback m_terminationCallback; - int m_controlCommandAddress; - int m_controlFeedbackAddress; quint64 m_visionGeneration = 0; }; diff --git a/services/productionservice.cpp b/services/productionservice.cpp index 8d2fe16..2059616 100644 --- a/services/productionservice.cpp +++ b/services/productionservice.cpp @@ -52,12 +52,15 @@ 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) , m_starting(false) , m_plcStarted(false) , m_tickRunning(false) + , m_pauseAfterCurrentAction(false) + , m_recoveryCheckPending(false) , m_pendingAction(DeviceService::RackPick) , m_stopRequested(false) , m_externalStopRequested(nullptr) @@ -108,6 +111,8 @@ QString ProductionService::stateNameForState(State state) const case Idle: return "IDLE"; case Preparing: return "PREPARING"; case WaitingDeviceReady: return "WAITING_DEVICE_READY"; + case PhotoMoving: return "PHOTO_MOVING"; + case VisionProcessing: return "VISION_PROCESSING"; case RackPicking: return "RACK_PICKING"; case FrontLoading: return "FRONT_LOADING"; case Loading: return "LOADING"; @@ -163,22 +168,11 @@ void ProductionService::setExternalStopFlag(std::atomic_bool *flag) m_externalStopRequested = flag; } -void ProductionService::setExternalPauseFlag(std::atomic_bool *flag) -{ - m_externalPauseRequested = flag; -} - void ProductionService::requestStopImmediate() { m_stopRequested.store(true); } -bool ProductionService::requiresVision(DeviceService::ProductionAction action) const -{ - return action == DeviceService::RackPick - && !ConfigManager::instance().simulationMode(); -} - bool ProductionService::saveVisionRecoveryState(bool pending, QString *error) { const QJsonObject state{{"version", 1}, {"pending", pending}, @@ -213,7 +207,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_state == Idle || (m_state == ManualConfirm && m_visionPauseConfirmed)) + && (m_state == Idle || m_state == ManualConfirm) && !m_actionStarting && !m_actionPollPending && !m_actionCancelRequested && !m_deviceService->productionActionActive(); emit visionProductionActiveChanged(locked, maintenance); @@ -222,7 +216,6 @@ void ProductionService::publishVisionControl() 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_deviceStatusValid && m_deviceStatus.plcConnected @@ -254,10 +247,6 @@ void ProductionService::setVisionStage(VisionStage stage, const QString &message QString name; switch (stage) { case VisionStage::Idle: 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; @@ -286,14 +275,12 @@ void ProductionService::prepareVision() 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. + // Persist before R60/M852 can be written so a crash cannot erase an in-flight result. if (!saveVisionRecoveryState(true, &error)) { visionFault(error); return; } - setVisionStage(VisionStage::Preflight, "核对上一轮相机握手已全部复位"); - advanceVision(); + beginVisionMeasurement(); } void ProductionService::advanceVision() @@ -311,48 +298,9 @@ void ProductionService::advanceVision() if (m_visionStage == VisionStage::Measuring) skipVision("视觉等待超时"); else - visionFault("拍照到位或 PLC 操作等待超时,请核对机器人状态"); + visionFault("视觉 PLC 操作等待超时,请核对写入状态"); return; } - if (m_visionIoPending) return; - if (m_visionStage != VisionStage::Preflight && m_visionStage != VisionStage::WaitArrival) return; - const quint64 generation = m_visionGeneration; - m_visionIoPending = true; - m_deviceService->readVisionHandshake( - [this, generation](bool success, const VisionHandshake &handshake, const QString &error) { - if (!visionCurrent(generation)) return; - m_visionIoPending = false; - if (!success) { visionFault("读取视觉握手失败:" + error); return; } - handleVisionHandshake(handshake); - }); -} - -void ProductionService::handleVisionHandshake(const VisionHandshake &handshake) -{ - if (m_visionStage == VisionStage::Preflight) { - // M852 deliberately retains the previous pick mode. - if (handshake.photoMove || handshake.photoArrived) { - visionFault("拍照移动开始前 M850/M851 尚未复位,需人工核对"); - return; - } - const quint64 generation = m_visionGeneration; - m_visionIoPending = 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; - } - setVisionStage(VisionStage::WaitArrival, "等待机器人 M851 到位反馈"); - }, [this, generation]() { return visionCurrent(generation); }); - } else if (m_visionStage == VisionStage::WaitArrival) { - if (!handshake.photoArrived) return; - setVisionStage(VisionStage::Clearing, "机器人已到位,清 M850/M851"); - clearVisionOutputs(0, m_visionGeneration); - } } void ProductionService::beginVisionMeasurement() @@ -493,28 +441,6 @@ void ProductionService::skipVision(const QString &reason) publishPickMode(false); } -void ProductionService::clearVisionOutputs(int index, quint64 generation) -{ - if (!visionCurrent(generation)) return; - if (index == 2) { - m_visionIoPending = false; - beginVisionMeasurement(); - return; - } - 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("M850/M851 清除未确认:" + error); - return; - } - clearVisionOutputs(index + 1, generation); - }, [this, generation]() { return visionCurrent(generation); }); -} - void ProductionService::invalidateVision(const QString &reason) { if (m_visionStage == VisionStage::Idle && !m_visionNeedsReconcile) return; @@ -523,7 +449,6 @@ 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; @@ -549,22 +474,11 @@ void ProductionService::visionFault(const QString &reason) m_visionStage = VisionStage::Fault; m_timer->stop(); pauseProcessTimer(); - m_visionFaultCleanupPending = true; setState(ManualConfirm); reportVision("等待人工核对", reason, 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); - }); - }); + m_visionFaultCleanupPending = false; + publishVisionControl(); + m_recoveryAlarmCode = "VISION"; persistAlarm("VISION", reason); emit timeoutRecoveryRequired("VISION", reason); emit productionError(reason); @@ -582,107 +496,49 @@ bool ProductionService::recoverVision(QString *error) if (error) *error = "请等待 PLC 操作结束后恢复"; return false; } - if (m_externalPauseRequested) m_externalPauseRequested->store(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_externalPauseRequested && m_externalPauseRequested->load())) { + if (generation != m_visionGeneration || stopRequested()) { m_visionRecoveryChecking = false; publishVisionControl(); return; } m_visionRecoveryChecking = false; - if (!success || handshake.photoMove || handshake.photoArrived) { + if (!success || handshake.photoMove || handshake.photoMoveFeedback) { publishVisionControl(); - emit productionError("人工恢复要求M850 移动请求和 M851 到位反馈均已复位:" + error); + emit productionError("恢复视觉前要求 M850/M851 均已复位:" + error); return; } - m_visionRecoveryChecking = true; - resetVisionForRecovery(0, m_visionGeneration); - }); - return true; -} - -void ProductionService::resetVisionForRecovery(int index, quint64 generation) -{ - if (generation != m_visionGeneration || stopRequested() - || (m_externalPauseRequested && m_externalPauseRequested->load())) { - m_visionRecoveryChecking = false; - publishVisionControl(); - return; - } - 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()); - }); - return; - } - m_deviceService->readVisionHandshake( - [this, generation](bool success, const VisionHandshake &handshake, const QString &error) { - m_visionRecoveryChecking = false; - if (generation != m_visionGeneration || stopRequested() - || (m_externalPauseRequested && m_externalPauseRequested->load())) { - publishVisionControl(); - return; - } - if (!success || handshake.photoMove || handshake.photoArrived) { - publishVisionControl(); - emit productionError("视觉恢复核对期间握手信号未保持复位:" + error); - return; - } - if (m_state != Idle && m_state != Completed) { - State mapped = Idle; - QString processStep; - if (!mapPlcStepToState(&mapped, &processStep) - || (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; - } + 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(); - if (m_externalPauseRequested) m_externalPauseRequested->store(false); - reportVision("人工恢复完成", "现场核对及信号复位完成,已丢弃旧视觉目标", true); + 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(); - if (m_state == Idle || m_state == Completed) return; - QString recoveryError; - if (!recover(&recoveryError)) emit productionError(recoveryError); + ProductionActionStatus status; + continueRecovery(VisionProcessing, DeviceService::RackPick, status); }); + return true; } bool ProductionService::start(int orderId, QString *error) @@ -725,10 +581,11 @@ 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(); m_stopRequested.store(false); - if (m_externalPauseRequested) m_externalPauseRequested->store(false); if (m_externalStopRequested) { m_externalStopRequested->store(false); } @@ -739,6 +596,7 @@ bool ProductionService::start(int orderId, QString *error) m_deviceStatusValid = false; m_recoveryRetryCount = 0; m_lastError.clear(); + m_recoveryAlarmCode.clear(); m_starting = true; m_plcStarted = false; @@ -790,30 +648,16 @@ bool ProductionService::start(int orderId, QString *error) return; } - m_deviceService->start( - [this](bool startSuccess, - const QString &startError) { - if (!startSuccess) { - fail(startError); - return; - } - if (stopRequested()) { - return; - } + m_plcStarted = true; + QString orderError; + if (!OrderService::instance().startOrder( + m_orderId, &orderError)) { + fail(orderError); + return; + } - m_plcStarted = true; - QString orderError; - if (!OrderService::instance().startOrder( - m_orderId, &orderError)) { - m_deviceService->pause( - [](bool, const QString &) {}); - fail(orderError); - return; - } - - m_starting = false; - tick(); - }); + m_starting = false; + tick(); }); }); return true; @@ -828,43 +672,73 @@ bool ProductionService::pause(QString *error) return false; } - if (m_visionStage != VisionStage::Idle) { - invalidateVision("已请求暂停生产"); - m_timer->stop(); - } - cancelPendingProductionAction( - [this](bool canceled, const QString &cancelError) { - if (!canceled) { - emit productionError(cancelError); - return; + if (m_state == VisionProcessing) { + if (m_visionStage == VisionStage::Complete) { + QString stepError; + if (!saveVisionRecoveryState(false, &stepError) + || !updateCurrentProcessStep("RACK_PICKING", &stepError)) { + if (error) *error = stepError; + return false; } + m_visionStage = VisionStage::Idle; + m_visionCommitStarted = false; + m_visionRequest = QJsonObject(); + m_visionResult = QJsonObject(); + setState(RackPicking); + return pauseAtActionBoundary(error); + } + if (m_visionCommitStarted) { + visionFault("暂停时 R60/M852 写入状态不确定,需人工核对"); + return true; + } + abortVisionForPause(); + if (m_visionNeedsReconcile) { + if (error) *error = m_lastError; + return false; + } + return pauseAtActionBoundary(error); + } + if (m_actionPending || m_actionStarting || m_actionPollPending) { + m_pauseAfterCurrentAction = true; + return true; + } + return pauseAtActionBoundary(error); +} - m_deviceService->pause( - [this](bool paused, const QString &pauseError) { - if (!paused) { - emit productionError(pauseError); - return; - } - - QString orderError; - if (!OrderService::instance().pauseOrder( - m_orderId, &orderError)) { - emit productionError(orderError); - return; - } - - pauseProcessTimer(); - m_timer->stop(); - m_visionPauseConfirmed = true; - setState(m_visionNeedsReconcile ? ManualConfirm : Paused); - if (m_visionNeedsReconcile) - emit timeoutRecoveryRequired("VISION", "视觉流程已中断,请核对 PLC 和机器人后恢复"); - emitProcessElapsed(); - }); - }); +bool ProductionService::pauseAtActionBoundary(QString *error) +{ + if (!OrderService::instance().pauseOrder(m_orderId, error)) { + return false; + } + m_pauseAfterCurrentAction = false; + pauseProcessTimer(); + m_timer->stop(); + setState(Paused); + emitProcessElapsed(); return true; } +void ProductionService::abortVisionForPause() +{ + ++m_visionGeneration; + emit visionCancelRequested(m_visionRequest.value("request_id").toString()); + m_deviceService->cancelVisionRequests("生产在视觉动作边界暂停"); + m_visionIoPending = false; + m_visionSuspended = false; + m_visionCommitStarted = false; + m_visionStage = VisionStage::Idle; + m_visionRequest = QJsonObject(); + m_visionResult = QJsonObject(); + QString persistenceError; + if (!saveVisionRecoveryState(false, &persistenceError)) { + m_lastError = persistenceError; + m_visionNeedsReconcile = true; + setState(ManualConfirm); + emit productionError(persistenceError); + } + reportVision("视觉已作废", "暂停前未提交 R60/M852,恢复后重新读取 R40 并测量", true); +} + bool ProductionService::resume(QString *error) { if (m_visionNeedsReconcile) { @@ -878,44 +752,43 @@ bool ProductionService::resume(QString *error) return false; } - if (!checkRecoverySafety(error)) { + if (m_starting) { + if (error) *error = "Production resume is already in progress"; return false; } - if (m_externalPauseRequested) m_externalPauseRequested->store(false); - - m_deviceService->setInspectionMode( - m_inspectionMode, - [this](bool modeSuccess, const QString &modeError) { + m_starting = true; + m_deviceService->requestStatus( + [this](bool statusSuccess, const DeviceStatus &, const QString &statusError) { + QString safetyError; + if (!statusSuccess || !checkRecoverySafety(&safetyError)) { + m_starting = false; + emit productionError(statusSuccess ? safetyError : statusError); + return; + } + m_deviceService->setInspectionMode( + m_inspectionMode, + [this](bool modeSuccess, const QString &modeError) { if (!modeSuccess) { + m_starting = false; emit productionError(modeError); return; } - - m_deviceService->start( - [this](bool startSuccess, const QString &startError) { - if (!startSuccess) { - emit productionError(startError); - return; - } - - QString orderError; - if (!OrderService::instance().resumeOrder( - m_orderId, &orderError)) { - emit productionError(orderError); - return; - } - - resumeProcessTimer(); - State resumeState = Preparing; - if (m_currentWorkpiece.id > 0) { - resumeState = stateForProcessStep( - m_currentWorkpiece.processStep); - if (resumeState == Idle) { - resumeState = WaitingDeviceReady; - } - } - setState(resumeState); - m_timer->start(ProductionTickIntervalMs); + 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(); }); }); return true; @@ -946,6 +819,7 @@ bool ProductionService::stop(QString *error) m_externalStopRequested->store(false); } setState(Error); + m_recoveryAlarmCode = "TERMINATION_FAILED"; persistAlarm("TERMINATION_FAILED", m_lastError); emit productionError(m_lastError); emit alarmRaised("TERMINATION_FAILED", m_lastError); @@ -1041,70 +915,6 @@ void ProductionService::shutdown(const DeviceService::OperationCallback &callbac }); } -bool ProductionService::reset(QString *error) -{ - if (m_visionNeedsReconcile) { - if (error) *error = "请先人工核对视觉与 PLC 状态,再执行复位"; - return false; - } - if (m_state != Error) { - if (error) { - *error = "Only failed production can be reset"; - } - return false; - } - - cancelPendingProductionAction( - [this](bool canceled, const QString &cancelError) { - if (!canceled) { - emit productionError(cancelError); - return; - } - - m_deviceService->reset( - [this](bool resetSuccess, const QString &resetError) { - if (!resetSuccess) { - emit productionError(resetError); - return; - } - - m_deviceService->clearAlarm( - [this](bool alarmCleared, - const QString &alarmError) { - if (!alarmCleared) { - emit productionError(alarmError); - return; - } - - QString persistenceError; - if (!ProductionRepository().clearActiveAlarms( - QString(), "SYSTEM", - &persistenceError)) { - emit productionError(persistenceError); - return; - } - - QString workpieceError; - if (m_currentWorkpiece.id > 0 - && !WorkpieceService::instance().updateState( - m_currentWorkpiece.id, "PENDING", - "RECOVERY", &workpieceError)) { - emit productionError(workpieceError); - return; - } - - m_currentWorkpiece = Workpiece(); - clearProcessTimer(); - m_lastError.clear(); - setState(Preparing); - m_heartbeatTimer.restart(); - m_timer->start(ProductionTickIntervalMs); - }); - }); - }); - return true; -} - bool ProductionService::clearAlarm(QString *error) { Q_UNUSED(error) @@ -1160,6 +970,24 @@ bool ProductionService::restoreActiveRun(QString *error) } emit currentWorkpieceChanged(m_currentWorkpiece.id, m_currentWorkpiece.barcode); + m_currentSlotNo = m_currentWorkpiece.trayPos; + const QList trays = TrayService::instance().listTrays( + &workpieceError); + if (!workpieceError.isEmpty()) { + if (error) *error = workpieceError; + return false; + } + for (int index = 0; index < trays.size(); ++index) { + if (trays.at(index).id == m_currentWorkpiece.trayId) { + m_currentTrayNo = index + 1; + break; + } + } + if (m_currentTrayNo <= 0 || m_currentSlotNo < 1 + || m_currentSlotNo > 49) { + if (error) *error = "恢复记录中的托盘或工位无法映射到 PLC"; + return false; + } emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(m_currentTrayNo, m_currentSlotNo); startProcessTimer(m_currentWorkpiece.processStep); @@ -1167,8 +995,7 @@ bool ProductionService::restoreActiveRun(QString *error) } State persistedState = stateFromName(run.productionState); - if (persistedState == Idle || persistedState == Completed - || persistedState == Error) { + if (persistedState == Idle || persistedState == Completed) { persistedState = Preparing; } m_timeoutState = stateFromName(run.timeoutState); @@ -1176,156 +1003,116 @@ bool ProductionService::restoreActiveRun(QString *error) m_timeoutState = persistedState; } - if (requiresVision(DeviceService::RackPick)) { + const State recoveryState = isTimedState(m_timeoutState) + ? m_timeoutState + : persistedState; + if (recoveryState == VisionProcessing || m_visionNeedsReconcile) { + m_recoveryAlarmCode = "VISION"; m_visionNeedsReconcile = true; m_visionSuspended = true; m_visionStage = VisionStage::Fault; QString stateError; if (!saveVisionRecoveryState(true, &stateError)) emit productionError(stateError); - reportVision("等待人工核对", "恢复未完成的生产记录,需核对相机与机器人握手", true); + 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"; + } + DeviceService::ProductionAction action; + m_actionWasSent = productionActionForState(recoveryState, &action); + if (run.runState == "PAUSED") { + setState(Paused); + } else { + m_timeoutState = recoveryState; + setState(ManualConfirm); } - 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") - .arg(run.id)); + if (run.runState != "PAUSED") + emit timeoutRecoveryRequired( + "STARTUP_RECOVERY", + QString("Unfinished production run %1 requires recovery confirmation") + .arg(run.id)); return true; } bool ProductionService::recover(QString *error) { - if (m_visionNeedsReconcile) return recoverVision(error); - if (m_state != TimeoutPaused && m_state != ManualConfirm) { + if (m_state != Error && m_state != TimeoutPaused + && m_state != ManualConfirm) { if (error) { *error = "Production is not waiting for recovery"; } return false; } - - if (!checkRecoverySafety(error)) { + if (m_recoveryCheckPending) { + if (error) *error = "Recovery check is already in progress"; return false; } - - QString operationError; - if (!ensureOrderRunning(&operationError)) { - if (error) { - *error = operationError; - } - return false; - } - - m_deviceService->setInspectionMode( - m_inspectionMode, - [this](bool modeSuccess, const QString &modeError) { - if (!modeSuccess) { - emit productionError(modeError); + m_recoveryCheckPending = true; + 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); return; } - m_deviceService->start( - [this](bool startSuccess, const QString &startError) { - if (!startSuccess) { - emit productionError(startError); - return; - } - persistRecoveryAction( - "CONTINUE", - QString("Continue recovery from %1").arg(stateName())); - setState(RecoveryChecking); - m_heartbeatTimer.restart(); - m_timer->start(ProductionTickIntervalMs); - tick(); - }); - }); - return true; -} - -bool ProductionService::retry(QString *error) -{ - if (m_visionNeedsReconcile) { - if (error) *error = "视觉结果不能自动重放,请使用人工核对恢复"; - return false; - } - if (m_state != TimeoutPaused && m_state != ManualConfirm) { - if (error) { - *error = "Production is not waiting for a retry"; - } - return false; - } - - if (!checkRecoverySafety(error)) { - return false; - } - - const ProductionConfig config = ConfigManager::instance().productionConfig(); - if (m_recoveryRetryCount >= config.maxRecoveryRetries) { - if (error) { - *error = "Maximum timeout recovery retries reached"; - } - return false; - } - - QString operationError; - if (!ensureOrderRunning(&operationError)) { - if (error) { - *error = operationError; - } - return false; - } - const QString processStep = processStepForState(m_timeoutState); - if (m_currentWorkpiece.id <= 0 || processStep.isEmpty()) { - if (error) { - *error = "Cannot retry without a current production step"; - } - return false; - } - m_deviceService->setInspectionMode( - m_inspectionMode, - [this, processStep](bool modeSuccess, const QString &modeError) { - if (!modeSuccess) { - emit productionError(modeError); + Order order; + QString orderError; + if (!OrderService::instance().findOrder(m_orderId, &order, + &orderError) + || order.status != "RUNNING") { + emit productionError(orderError.isEmpty() + ? "故障恢复要求订单保持 RUNNING;PAUSED 订单请使用启动按钮" + : orderError); + return; + } + if (m_currentWorkpiece.id <= 0 + && m_timeoutState != Preparing) { + emit productionError("恢复所需的当前工件记录不完整"); + return; + } + if (m_visionNeedsReconcile) { + QString visionError; + if (!recoverVision(&visionError)) + emit productionError(visionError); return; } - m_deviceService->start( - [this, processStep](bool startSuccess, - const QString &startError) { - if (!startSuccess) { - emit productionError(startError); + State recoveryState = isTimedState(m_timeoutState) + ? m_timeoutState + : stateForProcessStep(m_currentWorkpiece.processStep); + if (!isTimedState(recoveryState)) { + emit productionError("无法从持久化记录确定安全恢复位置"); + return; + } + DeviceService::ProductionAction action; + if (!productionActionForState(recoveryState, &action)) { + ProductionActionStatus status; + continueRecovery(recoveryState, DeviceService::RackPick, + status); + return; + } + m_deviceService->inspectProductionAction( + action, + [this, recoveryState, action]( + bool success, const ProductionActionStatus &status, + const QString &actionError) { + if (!success) { + emit productionError("读取当前动作命令/反馈失败:" + + actionError); return; } - - QString operationError; - if (!updateCurrentProcessStep( - processStep, &operationError, true)) { - emit productionError(operationError); - return; - } - - ++m_recoveryRetryCount; - persistRecoveryAction( - "RETRY", - QString("Retry production step %1").arg(processStep)); - setState(Retrying); - m_heartbeatTimer.restart(); - m_timer->start(ProductionTickIntervalMs); + continueRecovery(recoveryState, action, status); }); }); return true; @@ -1361,41 +1148,31 @@ bool ProductionService::markCurrentWorkpieceNg(QString *error) return false; } - m_deviceService->start( - [this](bool startSuccess, const QString &startError) { - if (!startSuccess) { - emit productionError(startError); - return; - } + 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; + } - const int durationMs = currentProcessElapsedMs(); - const QString previousProcessStep = - m_currentWorkpiece.processStep; - QString operationError; - if (!WorkpieceService::instance().completeWithInspection( - m_currentWorkpiece.id, "NG", "COMPLETE", - previousProcessStep, durationMs, -1, "NG", - m_deviceStatus.currentStep, m_inspectionMode, "MANUAL", - &operationError)) { - emit productionError(operationError); - return; - } - - 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); - }); + 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; } @@ -1412,9 +1189,9 @@ void ProductionService::setState(State state) publishVisionControl(); if (m_runId > 0) { - const QString processStep = processStepForState(state).isEmpty() - ? processStepForState(m_timeoutState) - : processStepForState(state); + 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( @@ -1533,19 +1310,6 @@ bool ProductionService::processProductionAction( return true; } - if (requiresVision(action)) { - if (m_visionNeedsReconcile || m_visionSuspended) return true; - if (m_visionStage == VisionStage::Idle) { - prepareVision(); - return true; - } - if (m_visionStage != VisionStage::Complete) { - advanceVision(); - return true; - } - if (!visionCurrent(m_visionGeneration)) return true; - } - if (!m_actionPending) { m_pendingAction = action; m_actionPending = true; @@ -1553,11 +1317,7 @@ 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_actionWasSent = true; m_deviceService->beginProductionAction( action, m_currentTrayNo, m_currentSlotNo, [this](bool success, const QString &actionError) { @@ -1566,7 +1326,7 @@ bool ProductionService::processProductionAction( m_actionError = actionError; } tryDeferredActionCancel(); - }, beforeSend); + }); return true; } @@ -1589,23 +1349,10 @@ bool ProductionService::processProductionAction( } 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; - if (requiresVision(action)) { - m_visionStage = VisionStage::Idle; - m_visionCommitStarted = false; - m_visionRequest = QJsonObject(); - m_visionResult = QJsonObject(); - } + m_actionWasSent = false; return true; } @@ -1626,6 +1373,39 @@ bool ProductionService::processProductionAction( return true; } +bool ProductionService::processVisionAction(bool *completed, QString *error) +{ + if (!completed) { + if (error) *error = "Vision completion pointer is null"; + return false; + } + *completed = false; + if (ConfigManager::instance().simulationMode()) { + *completed = true; + return true; + } + if (m_visionNeedsReconcile || m_visionSuspended) return true; + if (m_visionStage == VisionStage::Idle) { + prepareVision(); + return true; + } + if (m_visionStage != VisionStage::Complete) { + 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(); + m_visionResult = QJsonObject(); + *completed = true; + return true; +} + void ProductionService::cancelPendingProductionAction( const DeviceService::OperationCallback &callback) { @@ -1710,6 +1490,9 @@ bool ProductionService::executeCurrentAction( return false; } setState(nextState); + if (m_pauseAfterCurrentAction && !pauseAtActionBoundary(error)) { + return false; + } return true; } @@ -1790,6 +1573,102 @@ void ProductionService::emitProcessElapsed() emit processElapsedChanged(m_currentProcessStep, currentProcessElapsedMs()); } +bool ProductionService::productionActionForState( + State state, DeviceService::ProductionAction *action) const +{ + if (!action) return false; + switch (state) { + case PhotoMoving: *action = DeviceService::PhotoMoveAction; return true; + case RackPicking: *action = DeviceService::RackPick; return true; + case FrontLoading: *action = DeviceService::FrontLoad; return true; + case FrontChecking: + case BackChecking: *action = DeviceService::Inspect; return true; + case FrontUnloading: *action = DeviceService::FrontUnload; return true; + case Flipping: *action = DeviceService::Flip; return true; + case BackLoading: *action = DeviceService::BackLoad; return true; + case BackUnloading: *action = DeviceService::BackUnload; return true; + case RackPlacing: *action = DeviceService::RackPlace; return true; + default: return false; + } +} + +void ProductionService::continueRecovery( + State state, DeviceService::ProductionAction action, + const ProductionActionStatus &status) +{ + DeviceService::ProductionAction expectedAction; + const bool hasRobotAction = productionActionForState(state, &expectedAction); + if (hasRobotAction && expectedAction != action) { + emit productionError("恢复记录与 PLC 动作类型不一致"); + 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); + 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"); + return; + } + ++m_recoveryRetryCount; + m_actionPending = false; + m_actionWasSent = false; + persistRecoveryAction( + "RETRY", + QString("Retry action at %1 before any command was sent") + .arg(stateNameForState(state))); + } + + m_deviceService->setInspectionMode( + m_inspectionMode, + [this, state, hasRobotAction, status](bool success, + const QString &modeError) { + if (!success) { + emit productionError(modeError); + 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(); + }); +} + bool ProductionService::ensureOrderRunning(QString *error) { Order order; @@ -2037,11 +1916,11 @@ void ProductionService::tick() State nextState = stateForProcessStep( m_currentWorkpiece.processStep); if (nextState == Idle || nextState == WaitingDeviceReady) { - if (!updateCurrentProcessStep("RACK_PICKING", &error)) { + if (!updateCurrentProcessStep("PHOTO_MOVING", &error)) { fail(error); return; } - nextState = RackPicking; + nextState = PhotoMoving; } if (error.isEmpty()) { setState(nextState); @@ -2100,6 +1979,19 @@ void ProductionService::tickProduction() bool ProductionService::processProductionStep(State state, QString *error) { switch (state) { + case PhotoMoving: + return executeCurrentAction(DeviceService::PhotoMoveAction, + "VISION_PROCESSING", VisionProcessing, + error); + case VisionProcessing: { + bool completed = false; + if (!processVisionAction(&completed, error)) return false; + if (!completed) return false; + if (!updateCurrentProcessStep("RACK_PICKING", error)) return false; + setState(RackPicking); + if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error); + return true; + } case RackPicking: return executeCurrentAction(DeviceService::RackPick, "FRONT_LOADING", FrontLoading, error); @@ -2325,6 +2217,7 @@ bool ProductionService::recoverFromPlcStep(QString *error) bool ProductionService::isTimedState(State state) const { return state == Preparing || state == WaitingDeviceReady + || state == PhotoMoving || state == VisionProcessing || state == RackPicking || state == FrontLoading || state == Loading || state == FrontChecking || state == FrontUnloading || state == Flipping @@ -2338,6 +2231,8 @@ QString ProductionService::processStepForState(State state) const switch (state) { case Preparing: return "PREPARING"; case WaitingDeviceReady: return "WAITING_DEVICE_READY"; + case PhotoMoving: return "PHOTO_MOVING"; + case VisionProcessing: return "VISION_PROCESSING"; case RackPicking: return "RACK_PICKING"; case FrontLoading: return "FRONT_LOADING"; case Loading: return "LOADING"; @@ -2358,6 +2253,8 @@ ProductionService::State ProductionService::stateForProcessStep( { if (processStep == "PREPARING") return Preparing; if (processStep == "WAITING_DEVICE_READY") return WaitingDeviceReady; + if (processStep == "PHOTO_MOVING") return PhotoMoving; + if (processStep == "VISION_PROCESSING") return VisionProcessing; if (processStep == "RACK_PICKING") return RackPicking; if (processStep == "FRONT_LOADING") return FrontLoading; if (processStep == "LOADING") return Loading; @@ -2378,7 +2275,7 @@ QString ProductionService::runStateForState(State state) const case Paused: return "PAUSED"; case Error: - return "ERROR"; + return "RECOVERY"; case Completed: return "COMPLETED"; case TimeoutPaused: @@ -2399,6 +2296,8 @@ ProductionService::State ProductionService::stateFromName(const QString &name) c { if (name == "PREPARING") return Preparing; if (name == "WAITING_DEVICE_READY") return WaitingDeviceReady; + if (name == "PHOTO_MOVING") return PhotoMoving; + if (name == "VISION_PROCESSING") return VisionProcessing; if (name == "RACK_PICKING") return RackPicking; if (name == "FRONT_LOADING") return FrontLoading; if (name == "LOADING") return Loading; @@ -2470,14 +2369,12 @@ void ProductionService::fail(const QString &error) return; } + if (isTimedState(m_state)) { + m_timeoutState = m_state; + } m_lastError = error.isEmpty() ? "Production failed" : error; - cancelPendingProductionAction( - [this](bool success, const QString &cleanupError) { - if (!success && !cleanupError.isEmpty()) { - qWarning() << "PLC action cleanup failed:" << cleanupError; - } - }); m_timer->stop(); + pauseProcessTimer(); setState(Error); QString alarmCode = "PRODUCTION"; if (m_lastError == "PLC is disconnected" @@ -2489,6 +2386,7 @@ void ProductionService::fail(const QString &error) } else if (m_lastError == "Safety door is open") { alarmCode = "SAFETY_DOOR_OPEN"; } + m_recoveryAlarmCode = alarmCode; persistAlarm(alarmCode, m_lastError); emit productionError(m_lastError); emit alarmRaised(alarmCode, m_lastError); diff --git a/services/productionservice.h b/services/productionservice.h index 4112dae..e0ec3d3 100644 --- a/services/productionservice.h +++ b/services/productionservice.h @@ -22,6 +22,8 @@ public: Idle, Preparing, WaitingDeviceReady, + PhotoMoving, + VisionProcessing, RackPicking, FrontLoading, Loading, @@ -60,15 +62,12 @@ public: bool pause(QString *error = nullptr); bool resume(QString *error = nullptr); bool stop(QString *error = nullptr); - bool reset(QString *error = nullptr); bool clearAlarm(QString *error = nullptr); bool recover(QString *error = nullptr); - bool retry(QString *error = nullptr); bool markCurrentWorkpieceNg(QString *error = nullptr); bool restoreActiveRun(QString *error = nullptr); void shutdown(const DeviceService::OperationCallback &callback); void setExternalStopFlag(std::atomic_bool *flag); - void setExternalPauseFlag(std::atomic_bool *flag); void requestStopImmediate(); public slots: @@ -107,24 +106,19 @@ public: private: friend class VisionProductionTest; enum class VisionStage { - Idle, Preflight, Moving, WaitArrival, Clearing, ReadingPose, - Measuring, WritingPose, Publishing, Complete, Fault + Idle, 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 recoverVision(QString *error); - void resetVisionForRecovery(int index, quint64 generation); void publishVisionControl(); bool saveVisionRecoveryState(bool pending, QString *error); void loadVisionRecoveryState(); @@ -144,12 +138,20 @@ private: bool recoverFromPlcStep(QString *error); bool processProductionAction(DeviceService::ProductionAction action, bool *completed, QString *error); + bool processVisionAction(bool *completed, QString *error); void cancelPendingProductionAction( const DeviceService::OperationCallback &callback); void tryDeferredActionCancel(); bool executeCurrentAction(DeviceService::ProductionAction action, const QString &nextProcessStep, State nextState, QString *error); + bool pauseAtActionBoundary(QString *error = nullptr); + void abortVisionForPause(); + bool productionActionForState(State state, + DeviceService::ProductionAction *action) const; + void continueRecovery(State state, + DeviceService::ProductionAction action, + const ProductionActionStatus &status); bool recordInspection(const QString &side, int rawResult, const QString &resultState, QString *error); QString resultStateForRawResult(int rawResult) const; @@ -197,6 +199,7 @@ private: bool m_actionStarting; bool m_actionPollPending; bool m_actionCompleted; + bool m_actionWasSent; QString m_actionError; bool m_actionCancelRequested; DeviceService::OperationCallback m_deferredCancelCallback; @@ -206,9 +209,12 @@ private: bool m_starting; bool m_plcStarted; bool m_tickRunning; + bool m_pauseAfterCurrentAction; + bool m_recoveryCheckPending; DeviceService::ProductionAction m_pendingAction; QString m_inspectionMode; QString m_frontResultState; + QString m_recoveryAlarmCode; QString m_currentProcessStep; QString m_lastError; std::atomic_bool m_stopRequested; @@ -231,9 +237,7 @@ private: bool m_visionNeedsReconcile = false; bool m_visionRecoveryChecking = false; bool m_visionFaultCleanupPending = false; - bool m_visionPauseConfirmed = false; QString m_visionStatePath; - std::atomic_bool *m_externalPauseRequested = nullptr; }; Q_DECLARE_METATYPE(ProductionService::State) diff --git a/services/productionworker.cpp b/services/productionworker.cpp index 71c4f13..a10c6cd 100644 --- a/services/productionworker.cpp +++ b/services/productionworker.cpp @@ -4,7 +4,6 @@ ProductionWorker::ProductionWorker(QObject *parent) : QObject(parent) , m_service(nullptr) , m_stopRequested(false) - , m_pauseRequested(false) { } @@ -16,7 +15,6 @@ void ProductionWorker::ensureService() m_service = new ProductionService(this); m_service->setExternalStopFlag(&m_stopRequested); - m_service->setExternalPauseFlag(&m_pauseRequested); connect(m_service, &ProductionService::visionMeasureRequested, this, &ProductionWorker::visionMeasureRequested); connect(m_service, &ProductionService::visionCancelRequested, this, &ProductionWorker::visionCancelRequested); connect(m_service, &ProductionService::visionCycleChanged, this, &ProductionWorker::visionCycleChanged); @@ -54,11 +52,6 @@ void ProductionWorker::requestStopImmediate() m_stopRequested.store(true); } -void ProductionWorker::requestPauseImmediate() -{ - m_pauseRequested.store(true); -} - void ProductionWorker::updateVisionAvailability(bool ready, bool busy, const QString &session) { ensureService(); @@ -112,13 +105,6 @@ void ProductionWorker::requestStop() reportFailure(m_service->stop(&error), error); } -void ProductionWorker::requestReset() -{ - ensureService(); - QString error; - reportFailure(m_service->reset(&error), error); -} - void ProductionWorker::requestClearAlarm() { ensureService(); @@ -133,13 +119,6 @@ void ProductionWorker::requestRecover() reportFailure(m_service->recover(&error), error); } -void ProductionWorker::requestRetry() -{ - ensureService(); - QString error; - reportFailure(m_service->retry(&error), error); -} - void ProductionWorker::requestMarkNg() { ensureService(); diff --git a/services/productionworker.h b/services/productionworker.h index 296751f..ca0afea 100644 --- a/services/productionworker.h +++ b/services/productionworker.h @@ -13,17 +13,14 @@ class ProductionWorker : public QObject public: explicit ProductionWorker(QObject *parent = nullptr); void requestStopImmediate(); - void requestPauseImmediate(); public slots: void requestStart(int orderId); void requestPause(); void requestResume(); void requestStop(); - void requestReset(); void requestClearAlarm(); void requestRecover(); - void requestRetry(); void requestMarkNg(); void requestRestore(); void requestShutdown(); @@ -57,7 +54,6 @@ private: ProductionService *m_service; std::atomic_bool m_stopRequested; - std::atomic_bool m_pauseRequested; }; #endif // PRODUCTIONWORKER_H