diff --git a/config.ini b/config.ini index f503c80..2d527ce 100644 --- a/config.ini +++ b/config.ini @@ -79,3 +79,30 @@ usePlcErrorCode=false [system] simulation=false productionEnabled=true + +[vision] +; Enable only after the complete PLC/robot contract has been verified. +enabled=false +contractConfirmed=false +photoPoseReadyConfirmed=true +executablePath=E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-integration/bin/VisionGuide.exe +ipcName=ssp_visionguide_v1 +startupTimeoutMs=15000 +initializeTimeoutMs=60000 +requestTimeoutMs=15000 +robotAckTimeoutMs=10000 +photoPoseR=40 +graspPoseR=60 +lowWordFirst=true +robotReceivedCoil=850 +photoRequestCoil=851 +comparingCoil=852 +comparisonErrorCoil=853 +comparisonPassedCoil=854 +; Accepted initial contract: request/ack PLC-owned; other 3 ssp-owned. +handshakeProtocol=request_compare_result_ack_v1 +writableSignals=comparing, comparisonError, comparisonPassed +actionNames=RackPick + +[visionTrayMap] +; Explicit ssp tray number = VisionGuide tray number, for example 1=1. diff --git a/config/configmanager.cpp b/config/configmanager.cpp index fedd543..96987dc 100644 --- a/config/configmanager.cpp +++ b/config/configmanager.cpp @@ -4,6 +4,67 @@ #include #include #include +#include + +bool VisionConfig::isValid(QString *error) const +{ + QStringList errors; + if (!enabled || !contractConfirmed || !photoPoseReadyConfirmed) { + errors.append("Vision PLC contract is disabled or not confirmed"); + } + if (ipcName.trimmed().isEmpty() || startupTimeoutMs <= 0 + || initializeTimeoutMs <= 0 || requestTimeoutMs <= 5000 + || robotAckTimeoutMs <= 0) { + errors.append("Vision IPC name or timeouts are invalid"); + } + if (photoPoseR < 0 || photoPoseR > 32756 || photoPoseR % 2 + || graspPoseR < 0 || graspPoseR > 32756 || graspPoseR % 2 + || qAbs(photoPoseR - graspPoseR) < 12) { + errors.append("Vision REAL blocks must be distinct, even, 12-word R ranges"); + } + const int coils[] = {robotReceivedCoil, photoRequestCoil, comparingCoil, + comparisonErrorCoil, comparisonPassedCoil}; + QSet unique; + for (int coil : coils) { + if (coil < 0 || coil > 65535 || unique.contains(coil)) { + errors.append("Vision coil addresses must be configured and distinct"); + break; + } + unique.insert(coil); + } + const QSet outputs = {"comparing", "comparisonError", "comparisonPassed"}; + const QSet configured(writableSignals.begin(), writableSignals.end()); + if (handshakeProtocol != "request_compare_result_ack_v1" || configured != outputs + || writableSignals.size() != outputs.size()) { + errors.append("Vision handshake ownership and protocol are not confirmed"); + } + const QStringList knownActions = {"RackPick", "FrontUnload", "BackUnload"}; + if (actionNames.isEmpty()) { + errors.append("Vision production actions are not configured"); + } + for (const QString &action : actionNames) { + if (!knownActions.contains(action)) { + errors.append("Vision action must be a confirmed pickup action: " + action); + } + } + if (trayMap.isEmpty()) { + errors.append("Vision tray mapping is not configured"); + } + for (auto it = trayMap.constBegin(); it != trayMap.constEnd(); ++it) { + if (it.key() < 1 || it.value() < 1 || it.value() > 99) { + errors.append("Vision tray mapping is invalid"); + } + } + if (error) { + *error = errors.join("; "); + } + return errors.isEmpty(); +} + +int VisionConfig::visionTrayNo(int sspTrayNo) const +{ + return trayMap.value(sspTrayNo, -1); +} ConfigManager &ConfigManager::instance() { @@ -149,6 +210,38 @@ bool ConfigManager::load(const QString &filePath) settings.value("production/usePlcErrorCode", m_productionConfig.usePlcErrorCode).toBool(); + // Reload from safe defaults so removing a key cannot retain an old contract. + m_visionConfig = VisionConfig(); + m_visionConfig.enabled = settings.value("vision/enabled", false).toBool(); + m_visionConfig.contractConfirmed = settings.value("vision/contractConfirmed", false).toBool(); + m_visionConfig.photoPoseReadyConfirmed = settings.value("vision/photoPoseReadyConfirmed", false).toBool(); + m_visionConfig.executablePath = settings.value("vision/executablePath").toString(); + m_visionConfig.ipcName = settings.value("vision/ipcName", m_visionConfig.ipcName).toString(); + m_visionConfig.startupTimeoutMs = settings.value("vision/startupTimeoutMs", m_visionConfig.startupTimeoutMs).toInt(); + m_visionConfig.initializeTimeoutMs = settings.value("vision/initializeTimeoutMs", m_visionConfig.initializeTimeoutMs).toInt(); + m_visionConfig.requestTimeoutMs = settings.value("vision/requestTimeoutMs", m_visionConfig.requestTimeoutMs).toInt(); + m_visionConfig.robotAckTimeoutMs = settings.value("vision/robotAckTimeoutMs", m_visionConfig.robotAckTimeoutMs).toInt(); + m_visionConfig.photoPoseR = settings.value("vision/photoPoseR", 40).toInt(); + m_visionConfig.graspPoseR = settings.value("vision/graspPoseR", 60).toInt(); + m_visionConfig.lowWordFirst = settings.value("vision/lowWordFirst", true).toBool(); + m_visionConfig.robotReceivedCoil = settings.value("vision/robotReceivedCoil", -1).toInt(); + m_visionConfig.photoRequestCoil = settings.value("vision/photoRequestCoil", -1).toInt(); + m_visionConfig.comparingCoil = settings.value("vision/comparingCoil", -1).toInt(); + m_visionConfig.comparisonErrorCoil = settings.value("vision/comparisonErrorCoil", -1).toInt(); + m_visionConfig.comparisonPassedCoil = settings.value("vision/comparisonPassedCoil", -1).toInt(); + m_visionConfig.handshakeProtocol = settings.value("vision/handshakeProtocol").toString(); + m_visionConfig.writableSignals = settings.value("vision/writableSignals").toStringList(); + m_visionConfig.actionNames = settings.value("vision/actionNames").toStringList(); + m_visionConfig.writableSignals.removeAll(QString()); + m_visionConfig.actionNames.removeAll(QString()); + settings.beginGroup("visionTrayMap"); + for (const QString &key : settings.childKeys()) { + bool validKey = false; + const int tray = key.toInt(&validKey); + m_visionConfig.trayMap.insert(validKey ? tray : -1, settings.value(key).toInt()); + } + settings.endGroup(); + m_simulationMode = settings.value("system/simulation", m_simulationMode).toBool(); m_productionEnabled = settings.value("system/productionEnabled", m_productionEnabled).toBool(); return settings.status() == QSettings::NoError; @@ -174,6 +267,11 @@ ProductionConfig ConfigManager::productionConfig() const return m_productionConfig; } +VisionConfig ConfigManager::visionConfig() const +{ + return m_visionConfig; +} + bool ConfigManager::simulationMode() const { return m_simulationMode; @@ -187,6 +285,15 @@ bool ConfigManager::productionEnabled() const bool ConfigManager::validate(QString *error) const { QStringList errors; + if (m_visionConfig.enabled) { + QString visionError; + if (!m_visionConfig.isValid(&visionError)) { + errors.append(visionError); + } + if (m_modbusConfig.serverAddress == 0) { + errors.append("Vision PLC writes cannot use Modbus broadcast address 0"); + } + } if (m_modbusConfig.host.trimmed().isEmpty()) { errors.append("Modbus host is empty"); } diff --git a/config/configmanager.h b/config/configmanager.h index 8618f6e..1d3b210 100644 --- a/config/configmanager.h +++ b/config/configmanager.h @@ -5,6 +5,36 @@ #include "../modbus/modbusconfig.h" #include +#include +#include + +struct VisionConfig +{ + bool enabled = false; + bool contractConfirmed = false; + bool photoPoseReadyConfirmed = false; + QString executablePath; + QString ipcName = "ssp_visionguide_v1"; + int startupTimeoutMs = 15000; + int initializeTimeoutMs = 60000; + int requestTimeoutMs = 15000; + int robotAckTimeoutMs = 10000; + int photoPoseR = 40; + int graspPoseR = 60; + bool lowWordFirst = true; + int robotReceivedCoil = -1; + int photoRequestCoil = -1; + int comparingCoil = -1; + int comparisonErrorCoil = -1; + int comparisonPassedCoil = -1; + QString handshakeProtocol; + QStringList writableSignals; + QStringList actionNames; + QMap trayMap; + + bool isValid(QString *error = nullptr) const; + int visionTrayNo(int sspTrayNo) const; +}; struct ProductionConfig { @@ -35,6 +65,7 @@ public: DbConfig databaseConfig() const; ModbusConfig modbusConfig() const; ProductionConfig productionConfig() const; + VisionConfig visionConfig() const; bool simulationMode() const; bool productionEnabled() const; bool validate(QString *error = nullptr) const; @@ -50,6 +81,7 @@ private: DbConfig m_databaseConfig; ModbusConfig m_modbusConfig; ProductionConfig m_productionConfig; + VisionConfig m_visionConfig; bool m_simulationMode; bool m_productionEnabled; }; diff --git a/docs/2026-10-27-visionguide-process-implementation-steps.md b/docs/2026-10-27-visionguide-process-implementation-steps.md new file mode 100644 index 0000000..c4391b3 --- /dev/null +++ b/docs/2026-10-27-visionguide-process-implementation-steps.md @@ -0,0 +1,252 @@ +# 方案二:按模块实施 R40 → VisionGuide → R60 + +更新:2026-10-27。状态:模块 A–F 已实施,ssp 的 Qt 5.14.1 / MinGW 32 位工程已编译,VisionGuide 独立 MSVC x64 工程已编译;PLC、IPC、生产流程已完成无硬件模拟测试。未连接真实 PLC/相机/机器人;现场验收尚待完成。实际交付与测试见 `docs/visionguide-integration-status.md`。 + +## 1. 已确定目标与边界 + +- ssp:`E:/QTCode/ssp/ssp`,保留 Qt Creator 4.11.0、Qt 5.14.1、MinGW、C++11。 +- VisionGuide:`E:/QTCode/VisionGuide/VisionGuide_Qt/source`,独立 MSVC x64 进程,使用本项目源码和算法,不调用 demo/相机资料中的 SDK。 +- 信号表:`E:/QTCode/ssp/项目信号表/小轴信号.xlsx`,Sheet1。 +- 自动生产位姿来源已确定:机器人到位后由 ssp 读取 R40 起始的 XYZABC,作为本次拍照位姿传给 VisionGuide。 +- 按用户最新约定,五个握手信号按顺序使用 Modbus 线圈 850–854;PLC/机器人控制 850、851,ssp 控制 852–854。 +- 仅料架取料 RackPick 触发拍照;正面检测位取回、反面检测位取回和放料均不触发。用户已确认 851 有效表示机器人停稳且 R40 已更新。 +- VisionGuide 执行左相机测量并计算抓取 XYZABC,返回两组坐标;ssp 仅把有效的机器人抓取坐标写到 R60。 +- 启动/初始化:连接左右相机 → 应用现有相机参数 → 左右相机各执行一次自动白平衡 → 校验模型及料盘配置 → 就绪。不是每次测量都重做白平衡。 +- 相机测量固定使用用户指定值:左相机、高精细化 least_squares_high、截止5秒、MinScore=0.70、Greediness=0.80、YOLO中心选择、相机显示模型原点、抓取偏移4.40mm。 +- 4.40mm沿模型+Z应用一次,不能被“模型原点显示”取消,也不能在ssp回写时再次补偿。 +- 第一版保留原视觉调试界面,不抽取通用视觉库,不传输实时视频。正常生产坐标不依赖人工输入框。 + +## 2. 阶段0:事实依据、允许API与未决项 + +### 2.1 源码和本地API + +| 依据 | 复用方式/已确认事实 | +| --- | --- | +| ssp modbus/modbustcpmanager.cpp:150、175 | 已有 readRReal/writeRReal,0x3000+R编号,低16位字先,memcpy转换float;现有用户修改要保留 | +| ssp modbus/modbustcpmanager.h 的 Request | 已支持 count 和 QVector,可最小扩展整组读写,无需另写Modbus栈 | +| ssp modbus/modbustcpmanager.cpp:305 | Qt客户端统一配置 retryCount,新增视觉提交命令需区分发送前失败和写后应答不明 | +| ssp services/deviceservice.cpp:62、694 | 拥有现有PLC连接,沿用异步回调和队列;这里封装R40/R60与视觉线圈握手 | +| ssp services/productionservice.cpp:911 | processProductionAction()维持进行中动作,视觉握手宜作为该动作期间的子流程 | +| ssp services/productionworker.cpp:10 | ProductionService在生产线程内创建 | +| ssp pages/dashboardpage.cpp:298 | 析构会等待生产线程,新增退出流程不能要求GUI在wait期间回复 | +| VisionGuide MeasurementOptionsPanel.cpp:274、352、381 | start/complete/calculateGrasp是现有流程,抓取计算尚未自动串联,busy时calculateGrasp直接返回 | +| VisionGuide MeasurementGuidanceSetup.cpp:148、188 | 料盘恢复会覆盖offset,远程快照必须明确采用4.40并检查实际生效值 | +| VisionGuide CameraPanel.cpp:228、259 | 复用相机参数与白平衡逻辑;目前成功状态不完整,需返回左右分别成功/失败 | +| VisionGuide CameraManager.cpp:319 | applyWhiteBalanceOnce仅提交BalanceWhiteAuto=Once,不证明算法已经完成;按SDK能力核验状态 | +| VisionGuide MainWindow.cpp:85 | 新测量页创建位置,适合接线IPC,不走旧OPC测量链 | +| VisionGuide CameraManager.cpp:247 | 采图会阻塞,通信不得依赖GUI线程立即响应 | + +允许的 Qt 5.14.1 API已核对本机头文件: +- QtNetwork/qlocalserver.h:listen、newConnection、nextPendingConnection、UserAccessOption。 +- QtNetwork/qlocalsocket.h:connectToServer、connected/disconnected、QIODevice::readyRead、error(QLocalSocket::LocalSocketError)。不是较新版本的QLocalSocket::errorOccurred。 +- QtCore/qprocess.h:start(program, arguments)、setWorkingDirectory、setProcessEnvironment、errorOccurred、finished(int,ExitStatus)。 +- QtSerialBus使用现有QModbusDataUnit/QModbusTcpClient异步路径。坐标使用功能码0x03读保持寄存器、0x10写多个保持寄存器;五个握手信号复用readCoil/readCoils和writeCoil,使用0x01读线圈、0x05写单线圈。 +头文件根目录:C:/Qt/Qt5.14.1/5.14.1/mingw73_32/include。 + +### 2.2 地址映射 + +顺序XYZABC由用户给定;信号表列出REAL[6]和逐项Modbus起始地址。每个REAL占两个16位寄存器。 + +| 分量 | 当前机器人R起点 | Modbus起点 | 抓取反馈R起点 | Modbus起点 | +| --- | --- | --- | --- | --- | +| X | R40 | 12328 | R60 | 12348 | +| Y | R42 | 12330 | R62 | 12350 | +| Z | R44 | 12332 | R64 | 12352 | +| A | R46 | 12334 | R66 | 12354 | +| B | R48 | 12336 | R68 | 12356 | +| C | R50 | 12338 | R70 | 12358 | + +来源:Sheet1 C75:H87。反馈R62等由R60起点和逐项Modbus地址推导。 +**待确认:**注释写R40–R52/R60–R72但又注明12个INT;按逐项起点计算实际12字应为R40–R51/R60–R71。方案按“6个REAL/12个字”描述,但真机读写长度在确认前不执行。现有代码低字在前是软件事实,不能替代PLC实测。 + +相关握手信号按用户最新要求统一采用线圈访问。原信号表位置(Sheet1 C50:H54)仅保留用于追溯,不作为线圈地址使用: + +| 信号 | 原表标注(仅追溯) | 实施访问类型 | Modbus线圈地址 | +| --- | --- | --- | --- | +| 机器人接收结果成功 | D100.14 | Coil / bool | 850,PLC/机器人控制 | +| 请求相机拍照 | D100.15 | Coil / bool | 851,PLC/机器人控制 | +| 相机拍照比对 | D106.0 | Coil / bool | 852,ssp 控制 | +| 相机数据比对错误 | D112.12 | Coil / bool | 853,ssp 控制 | +| 相机比对通过 | D112.15 | Coil / bool | 854,ssp 控制 | + +不再为这五个信号设计 D 寄存器整字读改写或掩码写。用户同意先实现如下顺序,后续可按现场协议修改:851 到位请求 → ssp 置 852 → R40 读取/视觉计算 → R60 整组写入确认 → ssp 置 854 → 等待 850 → 等待 850、851 均复位 → ssp 清 852–854。失败置 853 的路径不会发布 854;未确认写入则进入人工核对,不自动重发。 + +### 2.3 真机实施前需要补齐的信息 + +1. 确认上述12字范围及REAL高低字序;与机器人界面的正数、负数和小数样本对照。 +2. 用户已确认 851 有效保证机器人已停稳且 R40 已更新;现场还需核验拍照期间保持稳定,一次 Modbus 块读本身不提供 PLC 扫描快照。 +3. 850–854 地址、置位方和上述握手顺序已确认先按此实施;现场需验证接收位保持时间足够供 ssp 轮询观察,以及机器人只在 854 有效后消费 R60。 +4. R40单位、坐标系、工具和ABC顺序须匹配新流程的mm/deg、world、TOOL1、Rz(A)Ry(B)Rx(C);不一致时先定义转换。 +5. 实际曝光、增益、带宽沿用当前有效配置,不发明数值。料盘高度策略及示教沿用对应料盘配置;若当前配置不完整,返回未就绪。 +6. 仅 RackPick 料架取料拍照已确定。ssp 实物料盘与 VisionGuide 测量配置编号的映射仍待确认,不能假定同号。现有主生产 PLC 地址有占位定义,与本表并非全部一致;本次不顺手重配全部信号。 + +前四项是连接真机读写/握手前的明确依赖。通信、模块接口、模拟测试和离线回归可以先开展;本计划不把未回复的问题视为已确认。 + +## 3. 模块A:ssp—PLC通信 + +**责任:**从PLC获取当前拍照位姿、写入抓取目标并提供握手数据,VisionGuide不直接连PLC。 + +**文件:** +- 修改 modbus/modbustcpmanager.h/.cpp:扩展连续R REAL读写,复用已有队列和编解码。 +- 修改 services/deviceservice.h/.cpp:新增业务接口和握手状态读取。 +- 修改 modbus/modbusaddress.h/.cpp、config/configmanager.h/.cpp、config.ini:增加R坐标地址、五个具名线圈地址及超时配置。未配置线圈用明确的未配置状态表示,不能默认到地址0;未配置时禁止相关真机访问。R地址配置避免同时保存R编号和绝对地址导致重复加0x3000。 +- 新增 models/visionresult.h:集中放小型RobotPose/任务/结果值结构,不做通用协议框架。 + +拟新增接口名称(不是当前已存在): +- ModbusTcpManager::readRReals(startR, count, callback)。 +- ModbusTcpManager::writeRReals(startR, values, callback)。 +- DeviceService::readRobotPhotoPose(callback)。 +- DeviceService::writeRobotGraspPose(pose, callback)。 +- DeviceService::readVisionHandshake(callback)。 +- 结果提交/失败通知接口在握手顺序确认后定义。 + +**细节:** +- R40一次读取12个字,解码6个REAL;R60一次功能码0x10写12个字。避免六次单轴操作导致混合新旧坐标。 +- 模块入口检查地址边界、数量、回调/接收返回值、有限数值。VisionGuide内部double回写float32时检查溢出,记录精度变化;JSON不用截成界面三位小数。 +- 单位保持mm/deg,复用memcpy,不用违反别名规则的指针强转。Modbus字内字节序由Qt处理,PLC的高低16位字顺序单独按确认值处理。 +- 五个握手信号均用bool线圈接口,读取使用readCoil/readCoils,写入使用writeCoil。仅在实际映射连续且范围已确认时合并读取;每次写入只操作协议规定由ssp控制的目标线圈。 +- 按协议先准备无效状态/握手 → 写整组R60 → 确认数据写入 → 发布结果有效 → 等机器人接收。不能把Modbus应答当机器人已取到目标。 +- 发送后超时进入“写入/提交状态不确定”,禁止直接继续动作或换新坐标重发。数据重写只在确认缓冲尚未消费时允许;结果提交不盲目自动重试。重试策略只改相关视觉请求,不改变所有既有PLC命令。 +- 停止/cancel无法撤销已经发送的Modbus写入,需核对PLC状态;取消后尚在本地队列的视觉写入不得继续发出。 + +**验证:**模拟PLC测试地址、完整XYZABC、负数/小数/极值、数量错误、NaN/Inf、字序、整组写、五个线圈的独立读写、不影响其他线圈和应答丢失。接真机后读取R40对照示教器;R60受控验证必须在握手确认后进行。 + +## 4. 模块B:ssp—VisionGuide通信 + +**责任:**启动/连接独立视觉程序、发送测量请求、返回结构化结果、超时和会话管理,不读写PLC。 + +**文件:**新增 services/visionservice.h/.cpp;修改 config/configmanager.h/.cpp、config.ini、ssp.pro(QT += network)。 + +通信固定QLocalSocket;QProcess管理自身启动的进程。视觉状态与PLC visionReady分开。客户端归属GUI线程,全部异步;ProductionWorker用queued signal传递值对象,不跨线程调用socket。 + +协议:4字节大端长度+UTF-8 JSON,上限1MiB。命令hello/get_status/initialize/measure/cancel/show_window/shutdown。每条含protocol_version、request_id、server_session_id。一个在途测量,busy不排队;重复编号不重复采集,重连不自动重发。 + +measure请求最小包含: +- 工件/任务上下文、料盘编号、来自R40的XYZABC。 +- R40读取时刻、来源plc_r40、静止/拍照请求的关联信息;这不是硬件曝光时间戳。 +- camera_mode=left_only、refinement=least_squares_high、deadline_ms=5000、min_score=.70、greediness=.80、yolo_selection=center、pose_display=model_origin、grasp_offset_mm=4.40。 +- require_robot_pose=true;world/tool/角度约定经现场确认后传入。 + +结果最小包含: +- 相同request/session/workpiece/tray以及视觉run编号。 +- 相机模型原点坐标、pose_type、score、source=LEFT、camera_valid。 +- 左路计算的抓取XYZABC、world/tool/旋转约定、robot_valid、所用参数和标定/料盘指纹。 +- capture_begin/end、measure_elapsed_ms、grasp_elapsed_ms、status及error_code/message。 +- 独立报告资源是否空闲。camera_valid不代表robot_valid,两者不可替代。 + +5秒严格对应用户设置的**测量页采图/识别截止**,不包括进程启动、加载模型、PLC读写及机器人接收。抓取计算、IPC与整次交易另外设置有界等待;不得默默把全部流程限成5秒或在超时后使用旧结果。具体整体等待值根据联调确定。 + +**验证:**用假服务端/客户端测试分包、多包、异常字段、版本/会话不符、重复请求、取消、迟到结果、启动失败和重连。只解析并发信号,不因收到JSON就在此模块直接写R60。 + +## 5. 模块C:VisionGuide通信 + +**责任:**接收ssp命令并路由给现有业务,主动返回状态和结果。 + +**文件:**新增 VisionIpcServer.h/.cpp;修改 main.cpp、MainWindow.h/.cpp、VisionGuide.pro、tools/Stage-QtCreatorRuntime.ps1。 + +- QLocalServer单控制连接,同用户访问;参数--ipc-name/--background。保留QApplication和原窗口,不新增Windows服务。 +- 服务端及socket在专用QThread里创建/销毁,避免现有同步采图阻塞心跳;通过queued signal传递值类型消息。 +- initialize、measure和cancel由MainWindow协调调用实际业务函数,不能靠查找按钮模拟click,也不读取界面显示文字当结果。 +- 就绪分为通信在线、初始化中、相机已配置、模型已加载、料盘机器人配置有效;心跳存活不代表算法有进展。 +- 请求接受后返回accepted,正常/失败/超时/取消只发布一个终态。取消/超时先使请求失效,底层退出前维持busy;不QThread::terminate。 +- 自动控制期间,旧测量、OPC UA、相机参数和标定入口统一门控。显示窗口不会自动允许抢占资源。 +- 部署新增对应MSVC版本Qt5Network DLL。后台启动错误输出并退出,不弹隐藏模态框;只正常关闭有明确归属的实例。 + +**验证:**真实IPC连接、新程序会话、采图期间心跳、单客户端、重复请求不重测、UI/旧OPC无法同时采图、关闭/断线清理。 + +## 6. 模块D:VisionGuide初始化与测量 + +**文件:**修改 CameraPanel.h/.cpp、CameraManager.h/.cpp(仅必要的参数/完成状态反馈)、MeasurementOptionsPanel.h/.cpp、MeasurementGuidanceSetup.cpp;MainWindow负责组织。 + +### 初始化 + +复用现有代码,公开一个返回逐项状态的初始化入口: + +连接左、右相机 → 分别应用曝光/增益/带宽参数 → 左、右各发一次自动白平衡 → 确认初始化结果 → 模型/标定/料盘有效 → ready。 + +onApplyParams当前忽略部分返回值,需汇总左右结果,任一失败不能宣称两台均就绪。applyWhiteBalanceOnce只写Once,按SDK现有能力确认白平衡完成及必要采集条件;不能直接把“写命令成功”当“白平衡完成”。重复initialize在同一已成功相机连接代次幂等,不反复白平衡;重新连接后重新完成该相机初始化。驱动安装属于部署前提,不在每次启动自动安装驱动。 + +### 测量与机器人坐标 + +将start/complete/calculateGrasp最少量提取为原按钮和远程入口共用的调用路径: + +检查左右初始化结果和左路算法就绪 → 按请求料盘取配置 → 固定R40拍照位姿及参数快照 → 用左相机新采图 → 原YOLO/精细化匹配 → 用本次R40位姿计算左路抓取XYZABC → 返回两组结果。 + +- 左相机模式不启用双目融合,右相机已连接不等于本次参与识别。 +- 精细化显式用least_squares_high,不用很高或标准。现有默认MinScore=.60、Greediness=.85必须改为自动任务的.70/.80。 +- 载入料盘配置后明确将本次偏移设为4.40;检查实际生效值,不能被历史profile覆盖。原标定/法向/固定D/高度策略按选中料盘保留,不假设新的高度规则。 +- R40位置显示到界面仅供核对,计算直接使用快照,不依赖输入框后来改值。相机模型原点与抓取点是不同输出。 +- 原calculateGrasp在busy时返回,需提取接收快照并返回结果的函数,不在complete里调用原按钮槽后假定成功。 +- 复用新测量页的坐标规则,不混用旧CoordTransformPanel或旧OPC的相机回退结果。仅相机成功返回失败/partial,不给ssp写R60资格。 +- 旧请求、超时结果及取消结果不得从线程回调重新变有效;绘图/归档放在结果之后,不因保存图像失败重复测量。 + +**验证:**同一左图、R40位姿样本、料盘和参数,与原手动操作结果逐项比较;确认高/0.70/0.80/5秒/原点/4.40确实生效,偏移只应用一次。连接和白平衡用真机单独验证,离线测试不假装硬件已就绪。 + +## 7. 模块E:ssp生产流程 + +**文件:**修改 services/productionservice.h/.cpp、services/productionworker.h/.cpp、services/deviceservice.h/.cpp,以及 pages/dashboardpage.h/.cpp、widget.h/.cpp的线程接线。 + +保留已有取放料主状态,在实际需要视觉的动作执行期间增加私有VisionStage子阶段,不为每个网络步骤新增数据库顶层状态: + +``` +等待有效拍照请求/到位静止 + → 读取R40完整XYZABC + → 提交VisionGuide + → 等待并校验相机和抓取结果 + → 写R60整组XYZABC + → 按协议发布结果有效 + → 等待机器人接收确认 + → 完成清零/重新允许下一请求 + → 继续原动作反馈轮询 +``` + +业务主线依据机器人到位后的拍照请求推进,不能先阻塞取料命令等待视觉,否则机器人可能永远到不了拍照点。用户已确认 851 请求拍照有效表示机器人停稳且 R40 已更新,因此仅在料架取料中以 851 触发;850 作为机器人接收反馈。PLC/机器人复位 850、851 后 ssp 清除 852–854,具体顺序按本版已同意的握手执行。 + +- 拍照请求持续高只产生一个周期,busy期间不重复采图;等待确认和请求复位后才允许下一次。 +- 启动/重连遇到已经为高的请求或旧接收位,先恢复核对,不当成新请求或新确认。不能让上一周期ack完成本周期。 +- 测量上下文绑定当前工件、料盘、步骤、请求号、进程会话和本地generation。视觉回调与PLC回调都检查它;IPC请求号并不自动形成PLC侧交易号。 +- R60提交前检查工件仍有效、未暂停/停止、PLC/视觉会话一致、robot_valid和来源正确。读取失败、测量失败或超时不写目标、不发布成功。 +- 请求尚未提交PLC时暂停/停止可作废;R60/有效位已经发出后不能假装取消撤销了机器人动作,需进入恢复核对。写入超时不能当作“肯定没写入”。 +- 进程重启不自动续用内存坐标,进入已有RecoveryChecking/ManualConfirm并核对PLC。首版不增加自动跨重启续跑;若将来要求则另加持久化交易阶段。 +- 单一DeviceService队列拥有PLC访问,VisionService只处理IPC;GUI与生产线程用queued信号传值,结果元类型注册。生产线程退出不得等待已阻塞GUI的IPC确认。 + +**验证:**模拟完整动作过程:到位/请求 → R40 → 视觉 → R60 → 有效 → ack/复位,验证持续高只测一次、旧ack不能成功、新工件不能用旧结果、R60写失败不发布有效、暂停/停止每个阶段正确进入终止或恢复状态。 + +## 8. 模块F:ssp界面、配置与部署 + +**文件:**新增 pages/visionpage.h/.cpp,修改 widget.h/.cpp、pages/dashboardpage.h/.cpp、config/configmanager.h/.cpp、config.ini、ssp.pro。 + +页面显示三组数据:R40拍照XYZABC、相机识别位姿、R60目标抓取XYZABC;并显示请求/工件/料盘、参数、耗时、初始化分项、PLC读写/机器人确认状态和失败原因。自动模式R40位姿只读。手动诊断测量与自动生产互斥,诊断结果不自动写R60。 + +配置按职责保存:ssp管理exe路径/IPC/PLC映射和等待;用户指定测量参数在一个权威配置中定义并随请求发送,VisionGuide校验、回显有效参数。曝光、增益、标定和料盘设置仍由VisionGuide管理。不重复维护两个互相覆盖的默认参数源。 + +保持PLC visionReady含义,独立显示视觉进程/初始化ready。日志记录每次交易R40、参数、相机结果、R60、握手结果和错误,不把每个心跳写入业务日志。失败后旧值可灰显但不能显示为本次可用。 + +部署保持完整VisionGuide包结构,清理子进程继承的错误Qt插件环境,不混用MSVC/MinGW DLL。ssp仍在旧Creator编译,VisionGuide单独构建。正常退出只关闭自己启动的视觉进程,外部实例只断开。 + +**验证:**旧Creator打开并构建ssp、数据库/原PLC行为回归、窗口不卡顿、状态不混淆、独立部署、缺失DLL/模型/相机的明确诊断。 + +## 9. 实施顺序及每步验收 + +| 步骤 | 实施模块 | 交付与验证 | +| --- | --- | --- | +| 0 | 协议准备 | 固定五个线圈地址、word order、R40冻结和线圈握手顺序;记录现有构建/单REAL行为,保留用户改动 | +| 1 | A:PLC底层 | 连续6 REAL编解码及块请求、握手读接口;模拟PLC验证。未确认的真机写位暂不执行 | +| 2 | B+C:双端通信 | 假结果跑通握手/参数/结果/取消/重连;检查32位ssp到64位VisionGuide | +| 3 | D:初始化 | 两台连接、参数应用、白平衡一次及ready状态;真机按步骤验证 | +| 4 | D:测量 | 固定用户参数,自动串联左路识别和抓取计算;离线对比原程序 | +| 5 | E:ssp流程 | 视觉子流程、R40读取和R60提交/确认;模拟机器人循环及每阶段故障测试 | +| 6 | F:界面配置 | 三组坐标、状态、错误、日志和启动退出;原界面/数据库/PLC回归 | +| 7 | 综合验证 | 确认点表协议后真实到位读取R40,真实视觉计算,受控写R60并验证接收和复位 | + +阶段0的未决硬件项只阻止依赖它们的真实读写/握手,接口设计、模拟测试、双端通信和离线算法对比可继续。最终验收必须区分:编译通过、模拟通过、离线一致、真机坐标读写通过、机器人动作确认通过;不能用其中一项代替全部。 + +## 10. 成功标准 + +1. ssp原Qt Creator/Qt/MinGW构建成功,VisionGuide保持独立MSVC x64。 +2. 左右相机初始化可报告各阶段成功/失败,正常测量不重复白平衡。 +3. 固定左相机、高、5秒、.70/.80、中心、原点、4.40参数实际生效。 +4. R40一组真实坐标绑定唯一一次采图;机器人坐标与原VisionGuide同输入结果一致。 +5. 只有本次有效左路抓取坐标整组写入R60,经正确有效握手和机器人接收后才能认为本轮完成。 +6. 超时/暂停/停止/断线/旧请求/写应答丢失均不会把旧坐标当新成功,也不会误触发重复测量或动作。 +7. 既有用户修改保留,范围外逻辑不顺手重构,不自动commit。 diff --git a/docs/visionguide-integration-status.md b/docs/visionguide-integration-status.md new file mode 100644 index 0000000..aef164f --- /dev/null +++ b/docs/visionguide-integration-status.md @@ -0,0 +1,57 @@ +# VisionGuide 独立进程接入交付记录 + +日期:2026-10-27。已实现软件,未运行真实 PLC、相机或机器人。 + +## 已实现模块 + +- 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 输出并重读全部握手;旧坐标不重发。 + +## 线圈及固定参数 + +| 线圈 | 含义 | 控制方 | +|---|---|---| +| 850 | 机器人接收结果成功 | PLC/机器人 | +| 851 | 请求拍照,机器人已停稳且 R40 已更新 | PLC/机器人 | +| 852 | 相机拍照比对中 | ssp | +| 853 | 相机数据比对错误 | ssp | +| 854 | 相机比对通过,R60 可用 | ssp | + +测量固定:左相机、高精细化、5 秒采图/识别截止、MinScore 0.70、Greediness 0.80、YOLO 中心选择、相机显示模型原点、模型 +Z 抓取偏移 4.40 mm。偏移只在 VisionGuide 应用一次。整体通信和机器人确认使用独立超时。 + +## 构建和验证 + +| 项目 | 结果与位置 | +|---|---| +| ssp 全工程(32 位) | Qt 5.14.1 / MinGW 7.3 32 位编译链接成功;`tmp/build-ssp-vision-client/ssp.exe`,日志 `production-build.log` | +| ssp 全工程(64 位,当前保存的 Kit) | Qt 5.14.1 / MinGW 7.3 64 位完整编译链接成功;`tmp/build-ssp-vision-64/ssp.exe`,PE 类型 AMD64;日志 `tmp/build-ssp-vision-64/build.log`。产物旁已复制根目录 `config.ini`,未运行该 exe | +| VisionGuide 全工程 | Qt 5.14.1 msvc2017_64 库 + 本机 VS2022 v143 编译器成功;`E:/QTCode/VisionGuide/VisionGuide_Qt/source/build-ssp-integration/bin/VisionGuide.exe`。本机未验证 VS2017 v141 编译器 | +| PLC 测试 | `tests/vision_plc`,11 passed;`tmp/vision_plc_build/final-results.txt` | +| ssp IPC 测试 | `tests/vision_ipc`,11 passed;`tmp/build-vision-ipc/test-results.txt` | +| 生产流程测试 | `tests/vision_production`,28 passed、0 failed;`tmp/build-vision-production/final-results.txt`;无硬件且无业务数据库连接 | +| 32 位 ssp / 64 位服务通信 | 6 passed;`tmp/build-cross-client/final-results.txt`;真实双端通信代码、假相机业务 | +| 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 位两套构建验证。 + +## 配置与使用 + +1. Qt Creator 4.11.0 继续打开 `ssp.pro`,选择原 Qt 5.14.1 MinGW kit;新增 Qt Network 仍是 Qt 5.14 API。 +2. 将根目录 `config.ini` 放到生成的 `ssp.exe` 同目录。当前测试构建目录已复制一份;Creator 使用其他构建目录时也要复制,默认配置读取 exe 同目录。 +3. `vision/executablePath` 指向完整 VisionGuide 运行目录中的 exe。当前构建路径可用于开发;部署后按实际路径修改。保留其 `visionguide.package.json`、`qt.conf` 和完整模型/标定资源关系,不能把 MSVC DLL 混入 ssp 的 MinGW 目录。 +4. 初次先在视觉页面启动/连接 VisionGuide,执行初始化。调试时“显示窗口”后“断开”可释放自动控制;自动生产期间诊断互斥。启动/初始化按钮会调用实际相机,需在设备测试阶段操作。 +5. `enabled=false`、`contractConfirmed=false` 保留,料盘映射不猜测。上线前填写 `[visionTrayMap]`,核对 REAL 字序、单位 mm/deg、world/TOOL1、`Rz(A)Ry(B)Rx(C)` 和12字范围后再开启。多个 ssp 料盘可按现场需要映射到同一视觉配置。 + +视觉故障后若活动订单的 PLC 步骤仍处于取料/上料等无法明确恢复的状态,人工恢复会保留锁定并提示先终止当前任务、核对机器人后再恢复,不会进入旧的 Loading 空状态或先发 PLC 启动。仅已明确进入现有正面/反面检测步骤时可接回原恢复流程。 + +VisionGuide 原测量页已有 1–99 料盘配置选择,现场文件目前保存配置 1 和 2;它是标定/法向/示教/高度设置编号,不自动等同 ssp 实物料盘号。本次未修改其用户配置。 + +## 待现场验收 + +确认以上坐标约定和料盘映射,读 R40 对照示教器,检查两台初始化与白平衡、固定参数和抓取结果一致,再受控执行 R60 写入及握手。PLC 应保持请求/接收电平供轮询观察;本版没有 PLC 交易序号,未观察到完整握手会进入人工核对,不以旧确认推进。 + +未自动提交 Git;原 `ssp.pro.user` 和既有单 REAL 修改保留。 diff --git a/docs/visionguide-ipc-protocol.md b/docs/visionguide-ipc-protocol.md new file mode 100644 index 0000000..c0a20d4 --- /dev/null +++ b/docs/visionguide-ipc-protocol.md @@ -0,0 +1,64 @@ +# ssp / VisionGuide 本机通信协议 v1 + +两端使用 Qt 5.14 的 QLocalSocket / QLocalServer。每帧为 4 字节无符号大端长度,随后为 UTF-8 JSON object;长度必须为 1..1048576。支持分包和连续多帧,非法帧断开。一次只允许一个控制客户端、一个测量。消息不含图像。 + +## 公共字段 + +所有请求/响应含 `protocol_version:1`、字符串 `type`、字符串 `request_id`、字符串 `server_session_id`。服务进程每次启动产生新 session。`hello` 请求的 session 为空;响应提供本进程 session。后续请求必须使用该 session。所有 request_id 不重复使用;断线不自动重发,旧 session / 已终止请求的结果不可使用。 + +响应 `status` 为 `ok`、`accepted`、`error`、`cancelled` 或 `timeout`,包含 `ready` 和 `resource_busy` 两个独立 bool。失败含字符串 `error_code`、`message`。`accepted` 不是终态;每个测量最多一个终态。终态取消不代表底层已退出,资源未释放时 `resource_busy` 仍为 true。 + +## 命令 + +| type | 含义 | +| --- | --- | +| hello | 协议握手及进程 session;不初始化设备 | +| get_status | 返回 ready/resource_busy 以及可选 initialization 对象 | +| initialize | 左右相机及算法初始化;accepted 后返回 ok/error | +| measure | 本次拍照、识别、抓取计算;accepted 后返回终态 | +| cancel | 带 target_request_id,取消该测量;cancel 本身独立应答,测量返回 cancelled | +| show_window | 显示原视觉调试窗口 | +| shutdown | 正常关闭(ssp 只对自己启动的进程发送) | + +服务端主动状态消息使用 `type:"status"`、`request_id:""`、当前 session。业务失败不丢失关联上下文。相同测量编号不得重新采图。 + +状态响应还提供字符串 `server_process_id`。ssp 只有在该值与自身 QProcess 启动的子进程 PID 一致时才发送 shutdown;连接外部实例时退出仅断开。 + +## measure 请求 + +```json +{ + "protocol_version":1,"type":"measure","request_id":"unique-id","server_session_id":"session", + "context":{"workpiece_id":"42","task_id":"run/action","tray_no":1,"generation":"1"}, + "robot_pose":[1.0,2.0,3.0,4.0,5.0,6.0], + "pose_source":"plc_r40","pose_read_at":"2026-10-27T10:00:00.000Z", + "convention":{"frame":"world","tool":"TOOL1","rotation":"Rz(A)Ry(B)Rx(C)","linear_unit":"mm","angular_unit":"deg"}, + "parameters":{"camera_mode":"left_only","refinement":"least_squares_high","deadline_ms":5000,"min_score":0.70,"greediness":0.80,"yolo_selection":"center","pose_display":"model_origin","grasp_offset_mm":4.40}, + "require_robot_pose":true +} +``` + +`robot_pose` 是恰好 6 个有限数,顺序 XYZABC。`pose_source` 自动生产为 `plc_r40`,手动只读诊断为 `diagnostic`。context 的 id 为非空字符串,tray_no 为 1..99 整数。context 整体须原样返回。服务端检查固定 parameters 和 convention 后使用冻结快照,不以 UI 后来改动覆盖快照。5 秒仅为采图/识别截止;客户端整次请求另设超时。 + +## measure 成功响应 + +公共字段中 `type:"measure"`、`status:"ok"`;再含以下字段: + +| 字段 | 内容 | +| --- | --- | +| context | 请求 context 原样返回 | +| camera_pose / robot_pose | 各 6 个有限 double;相机原点位姿 / 机器人抓取 XYZABC | +| camera_valid / robot_valid | 独立 bool,成功自动提交必须两者 true | +| source / pose_type | `LEFT` / `model_origin` | +| score | 有限数且不低于请求 min_score | +| parameters / convention | 本次实际使用值,必须与请求匹配 | +| calibration_fingerprint | 非空标定/料盘配置指纹 | +| run_id | 非空视觉运行标识 | +| capture_begin / capture_end | UTC ISO 时间字符串 | +| measure_elapsed_ms / grasp_elapsed_ms | 非负整数 | + +只得到 camera_pose 时返回 error/partial 类错误,`robot_valid:false`,绝不复制相机坐标冒充机器人坐标。客户端只发布经过校验的结构化结果;R60 写入由生产流程决定。 + +## ssp 线程接口 + +VisionService 及其 QLocalSocket/QProcess 在 GUI 线程中创建使用。生产线程通过 queued connection 传 `QJsonObject` 值快照:`measure(request)`、`cancel(requestId)`,接收 `measurementFinished(result)`、`availabilityChanged(ready,busy,session)`。无阻塞等待,退出不依赖生产线程等 GUI 回答。`setProductionActive(bool)` 使诊断入口与生产互斥;自动请求使用 `measure`,页面使用 `diagnose`。 diff --git a/modbus/modbustcpmanager.cpp b/modbus/modbustcpmanager.cpp index 3c6e2cf..3756d68 100644 --- a/modbus/modbustcpmanager.cpp +++ b/modbus/modbustcpmanager.cpp @@ -6,6 +6,26 @@ #include #include +#include +#include +#include + +namespace { + +const int RRegisterBase = 0x3000; +const int MaxRRealAddress = 32766; + +bool isValidRRealAddress(int address) +{ + return address >= 0 && address <= MaxRRealAddress + && address % 2 == 0; +} + +} + +static_assert(sizeof(float) == sizeof(quint32), + "R REAL requires a 32-bit float"); + ModbusTcpManager::ModbusTcpManager(const ModbusConfig &config, QObject *parent) : QObject(parent) @@ -37,28 +57,82 @@ void ModbusTcpManager::readCoil( int address, const std::function &callback) { - enqueue({QModbusDataUnit::Coils, address, 0, false, - [callback](bool success, quint16 value, const QString &error) { + enqueue({QModbusDataUnit::Coils, address, 1, {}, false, + [callback](bool success, const QVector &values, + const QString &error) { if (callback) { - callback(success, value != 0, error); + callback(success, + success && values.first() != 0, + error); } }}); } +void ModbusTcpManager::readCoils( + int startAddress, quint16 count, + const std::function &, const QString &)> &callback, + bool visionRequest) +{ + if (count == 0 || count > 2000) { + if (callback) { + callback(false, {}, + "Modbus coil count must be between 1 and 2000"); + } + return; + } + + if (startAddress < 0 || startAddress > 0xffff + || static_cast(startAddress) + count > 0x10000u) { + if (callback) { + callback(false, {}, "Modbus coil address range is invalid"); + } + return; + } + + Request request(QModbusDataUnit::Coils, startAddress, count, {}, false, + [callback](bool success, const QVector &values, + const QString &error) { + if (!callback) { + return; + } + + QVector coils; + if (success) { + coils.reserve(values.size()); + for (quint16 value : values) { + coils.append(value != 0); + } + } + callback(success, coils, error); + }); + request.vision = visionRequest; + enqueue(request); +} + void ModbusTcpManager::readHoldingRegister( int address, const std::function &callback) { - enqueue({QModbusDataUnit::HoldingRegisters, address, 0, false, callback}); + enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {}, false, + [callback](bool success, const QVector &values, + const QString &error) { + if (callback) { + callback(success, + success ? values.first() : 0, + error); + } + }}); } void ModbusTcpManager::writeCoil( int address, bool value, const std::function &callback) { - enqueue({QModbusDataUnit::Coils, address, - static_cast(value ? 1 : 0), true, - [callback](bool success, quint16, const QString &error) { + enqueue({QModbusDataUnit::Coils, address, 1, + {static_cast(value ? 1 : 0)}, true, + [callback](bool success, const QVector &, + const QString &error) { if (callback) { callback(success, error); } @@ -69,14 +143,204 @@ void ModbusTcpManager::writeHoldingRegister( int address, quint16 value, const std::function &callback) { - enqueue({QModbusDataUnit::HoldingRegisters, address, value, true, - [callback](bool success, quint16, const QString &error) { + enqueue({QModbusDataUnit::HoldingRegisters, address, 1, {value}, true, + [callback](bool success, const QVector &, + const QString &error) { if (callback) { callback(success, error); } }}); } +bool ModbusTcpManager::readRReal( + int rAddress, + const std::function &callback) +{ + if (!isValidRRealAddress(rAddress) || m_aborting) { + return false; + } + + enqueue({QModbusDataUnit::HoldingRegisters, + RRegisterBase + rAddress, 2, {}, false, + [callback](bool success, const QVector &values, + const QString &error) { + float value = 0.0f; + if (success) { + const quint32 bits = quint32(values.at(0)) + | (quint32(values.at(1)) << 16); + std::memcpy(&value, &bits, sizeof(value)); + } + if (callback) { + callback(success, value, error); + } + }}); + return true; +} + +bool ModbusTcpManager::writeRReal( + int rAddress, float value, + const std::function &callback) +{ + if (!isValidRRealAddress(rAddress) || m_aborting) { + return false; + } + + quint32 bits = 0; + std::memcpy(&bits, &value, sizeof(bits)); + enqueue({QModbusDataUnit::HoldingRegisters, + RRegisterBase + rAddress, 2, + {static_cast(bits & 0xffffu), + static_cast(bits >> 16)}, + true, + [callback](bool success, const QVector &, + const QString &error) { + if (callback) { + callback(success, error); + } + }}); + return true; +} + +bool ModbusTcpManager::readRReals( + int rAddress, int count, + const std::function &, const QString &)> &callback, + bool lowWordFirst) +{ + if (!isValidRRealAddress(rAddress) || count < 1 || count > 62 + || rAddress + count * 2 > MaxRRealAddress + 2 + || m_aborting || m_cancelingVision) { + return false; + } + Request request(QModbusDataUnit::HoldingRegisters, + RRegisterBase + rAddress, quint16(count * 2), {}, false, + [callback, count, lowWordFirst](bool success, const QVector &words, + const QString &error) { + QVector values; + QString text = error; + if (success && words.size() != count * 2) { + success = false; + text = "R REAL response length does not match the request"; + } + if (success) { + for (int i = 0; i < count; ++i) { + const quint32 bits = quint32(words.at(i * 2 + (lowWordFirst ? 0 : 1))) + | (quint32(words.at(i * 2 + (lowWordFirst ? 1 : 0))) << 16); + float value = 0; + std::memcpy(&value, &bits, sizeof(value)); + if (!std::isfinite(value)) { + success = false; + text = "R REAL response contains NaN or infinity"; + break; + } + values.append(double(value)); + } + } + if (callback) { + callback(success, success ? values : QVector(), text); + } + }); + request.vision = true; + enqueue(request); + return true; +} + +bool ModbusTcpManager::writeRReals(int rAddress, const QVector &values, + const VisionWriteCallback &callback, + bool lowWordFirst, const std::function &beforeSend) +{ + if (!isValidRRealAddress(rAddress) || values.isEmpty() || values.size() > 61 + || rAddress + values.size() * 2 > MaxRRealAddress + 2 + || m_aborting || m_cancelingVision) { + return false; + } + QVector words; + for (double value : values) { + if (!std::isfinite(value) || qAbs(value) > std::numeric_limits::max()) { + return false; + } + const float real = float(value); + quint32 bits = 0; + std::memcpy(&bits, &real, sizeof(bits)); + const quint16 low = quint16(bits & 0xffffu); + const quint16 high = quint16(bits >> 16); + words.append(lowWordFirst ? low : high); + words.append(lowWordFirst ? high : low); + } + Request request(QModbusDataUnit::HoldingRegisters, + RRegisterBase + rAddress, quint16(words.size()), words, true, {}); + request.vision = true; + request.writeCallback = callback; + request.beforeSend = beforeSend; + enqueue(request); + return true; +} + +void ModbusTcpManager::readVisionCoil( + int address, const std::function &callback) +{ + Request request(QModbusDataUnit::Coils, address, 1, {}, false, + [callback](bool success, const QVector &values, const QString &error) { + if (callback) { + callback(success, success && values.value(0) != 0, error); + } + }); + request.vision = true; + enqueue(request); +} + +void ModbusTcpManager::writeVisionCoil(int address, bool value, + const VisionWriteCallback &callback, + const std::function &beforeSend) +{ + Request request(QModbusDataUnit::Coils, address, 1, + {quint16(value ? 1 : 0)}, true, {}); + request.vision = true; + request.writeCallback = callback; + request.beforeSend = beforeSend; + enqueue(request); +} + +void ModbusTcpManager::cancelVisionRequests(const QString &reason) +{ + if (m_cancelingVision) { + return; + } + m_cancelingVision = true; + const QString text = reason.isEmpty() ? "Vision PLC request canceled" : reason; + QQueue retained; + QVector canceled; + while (!m_requests.isEmpty()) { + const Request request = m_requests.dequeue(); + if (!request.vision) { + retained.enqueue(request); + } else { + canceled.append(request); + } + } + m_requests = retained; + if (m_hasCurrentRequest && m_currentRequest.vision) { + const Request request = m_currentRequest; + canceled.prepend(request); + m_currentRequest.callback = ValuesCompletion(); + m_currentRequest.writeCallback = VisionWriteCallback(); + if (!request.sent) { + m_hasCurrentRequest = false; + m_currentRequest = Request(); + } + } + // Detach every callback before invoking user code, which may abort all work. + // A sent request must drain; cancellation cannot retract the wire write. + for (const Request &request : canceled) { + if (request.callback) request.callback(false, {}, text); + if (request.writeCallback) { + request.writeCallback(request.sent ? VisionWriteOutcome::Uncertain + : VisionWriteOutcome::NotSent, text); + } + } + m_cancelingVision = false; + startNext(); +} + void ModbusTcpManager::abortAll(const QString &reason) { if (m_aborting) { @@ -98,19 +362,27 @@ void ModbusTcpManager::abortAll(const QString &reason) } if (m_hasCurrentRequest) { - const Completion callback = m_currentRequest.callback; + const ValuesCompletion callback = m_currentRequest.callback; + const VisionWriteCallback writeCallback = m_currentRequest.writeCallback; + const bool sent = m_currentRequest.sent; m_currentRequest = Request(); m_hasCurrentRequest = false; setError(text); if (callback) { - callback(false, 0, text); + callback(false, {}, text); + } + if (writeCallback) { + writeCallback(sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent, text); } } while (!m_requests.isEmpty()) { Request request = m_requests.dequeue(); if (request.callback) { - request.callback(false, 0, text); + request.callback(false, {}, text); + } + if (request.writeCallback) { + request.writeCallback(VisionWriteOutcome::NotSent, text); } } @@ -130,18 +402,32 @@ bool ModbusTcpManager::isBusy() const void ModbusTcpManager::enqueue(const Request &request) { - if (m_aborting) { + if (request.vision && request.write && m_config.serverAddress == 0) { + if (request.writeCallback) { + request.writeCallback(VisionWriteOutcome::NotSent, + "Vision writes require a non-broadcast Modbus address"); + } + return; + } + if (m_aborting || (m_cancelingVision && request.vision)) { if (request.callback) { - request.callback(false, 0, "Modbus request was canceled"); + request.callback(false, {}, "Modbus request was canceled"); + } + if (request.writeCallback) { + request.writeCallback(VisionWriteOutcome::NotSent, "Modbus request was canceled"); } return; } - if (request.address < 0) { + if (request.address < 0 || request.address > 65535 + || request.address + request.count > 65536) { if (request.callback) { - request.callback(false, 0, + request.callback(false, {}, "Modbus address must be greater than or equal to 0"); } + if (request.writeCallback) { + request.writeCallback(VisionWriteOutcome::NotSent, "Modbus address range is invalid"); + } return; } @@ -151,7 +437,7 @@ void ModbusTcpManager::enqueue(const Request &request) void ModbusTcpManager::startNext() { - if (m_aborting || m_hasCurrentRequest || m_requests.isEmpty()) { + if (m_aborting || m_cancelingVision || m_hasCurrentRequest || m_requests.isEmpty()) { return; } @@ -200,38 +486,56 @@ void ModbusTcpManager::startCurrentRequest() if (m_aborting || !m_hasCurrentRequest || m_connecting || m_reply) { return; } + if (m_currentRequest.beforeSend + && !m_currentRequest.beforeSend()) { + finishCurrent(false, {}, "Vision request invalidated before transmission"); + return; + } QModbusDataUnit unit( static_cast( m_currentRequest.registerType), - m_currentRequest.address, 1); + m_currentRequest.address, m_currentRequest.count); + // Qt applies retries when sendWriteRequest queues the request. Only vision + // writes disable retries; legacy commands retain the existing policy. + m_client->setNumberOfRetries(m_currentRequest.vision && m_currentRequest.write + ? 0 : m_config.retryCount); if (m_currentRequest.write) { - unit.setValue(0, m_currentRequest.value); + unit.setValues(m_currentRequest.values); m_reply = m_client->sendWriteRequest(unit, m_config.serverAddress); } else { m_reply = m_client->sendReadRequest(unit, m_config.serverAddress); } if (!m_reply) { - finishCurrent(false, 0, + finishCurrent(false, {}, m_client->errorString().isEmpty() ? "Failed to create Modbus request" : m_client->errorString()); return; } + m_currentRequest.sent = true; + connect(m_reply, &QModbusReply::finished, this, &ModbusTcpManager::onReplyFinished); + if (m_reply->isFinished()) { + // Broadcast replies can already be complete when returned by Qt. + QMetaObject::invokeMethod(m_reply, "finished", Qt::QueuedConnection); + } } -void ModbusTcpManager::finishCurrent(bool success, quint16 value, +void ModbusTcpManager::finishCurrent(bool success, + const QVector &values, const QString &error) { if (!m_hasCurrentRequest) { return; } - const Completion callback = m_currentRequest.callback; + const ValuesCompletion callback = m_currentRequest.callback; + const VisionWriteCallback writeCallback = m_currentRequest.writeCallback; + const bool sent = m_currentRequest.sent; m_currentRequest = Request(); m_hasCurrentRequest = false; if (!success) { @@ -241,7 +545,12 @@ void ModbusTcpManager::finishCurrent(bool success, quint16 value, } if (callback) { - callback(success, value, error); + callback(success, values, error); + } + if (writeCallback) { + writeCallback(success ? VisionWriteOutcome::Confirmed + : (sent ? VisionWriteOutcome::Uncertain : VisionWriteOutcome::NotSent), + error); } if (!m_aborting) { startNext(); @@ -270,7 +579,7 @@ void ModbusTcpManager::handleConnectionFailure(const QString &error) return; } - finishCurrent(false, 0, + finishCurrent(false, {}, error.isEmpty() ? "Failed to connect to PLC" : error); } @@ -336,26 +645,30 @@ void ModbusTcpManager::onReplyFinished() m_reply = nullptr; const bool success = reply->error() == QModbusDevice::NoError; - quint16 value = 0; + QVector values; QString error; if (!success) { - error = reply->errorString(); + error = reply->errorString().isEmpty() + ? QString("Modbus reply failed with error %1").arg(int(reply->error())) + : reply->errorString(); } else if (!m_currentRequest.write) { const QModbusDataUnit result = reply->result(); - if (result.valueCount() < 1) { - error = "Modbus read returned an empty result"; + if (result.valueCount() != m_currentRequest.count) { + error = QString("Modbus read returned %1 values; expected %2") + .arg(result.valueCount()) + .arg(m_currentRequest.count); } else { - value = result.value(0); + values = result.values(); } } reply->deleteLater(); - if (!error.isEmpty()) { - finishCurrent(false, 0, error); + if (!success || !error.isEmpty()) { + finishCurrent(false, {}, error); return; } - finishCurrent(true, value, QString()); + finishCurrent(true, values, QString()); } void ModbusTcpManager::onConnectTimeout() diff --git a/modbus/modbustcpmanager.h b/modbus/modbustcpmanager.h index ef686e9..a3d511c 100644 --- a/modbus/modbustcpmanager.h +++ b/modbus/modbustcpmanager.h @@ -2,11 +2,13 @@ #define MODBUSTCPMANAGER_H #include "modbusconfig.h" +#include "../models/visionresult.h" #include #include #include #include +#include #include #include @@ -20,6 +22,7 @@ class ModbusTcpManager : public QObject public: using Completion = std::function; + using VisionWriteCallback = std::function; explicit ModbusTcpManager(const ModbusConfig &config, QObject *parent = nullptr); @@ -29,6 +32,11 @@ public: void readCoil(int address, const std::function &callback); + void readCoils( + int startAddress, quint16 count, + const std::function &, const QString &)> &callback, + bool visionRequest = false); void readHoldingRegister( int address, const std::function &callback); @@ -37,24 +45,46 @@ public: void writeHoldingRegister( int address, quint16 value, const std::function &callback); + bool readRReal( + int rAddress, + const std::function &callback); + bool writeRReal( + int rAddress, float value, + const std::function &callback); + bool readRReals(int rAddress, int count, + const std::function &, const QString &)> &callback, + bool lowWordFirst = true); + bool writeRReals(int rAddress, const QVector &values, + const VisionWriteCallback &callback, bool lowWordFirst = true, + const std::function &beforeSend = {}); + void readVisionCoil(int address, + const std::function &callback); + void writeVisionCoil(int address, bool value, const VisionWriteCallback &callback, + const std::function &beforeSend = {}); + void cancelVisionRequests(const QString &reason); void abortAll(const QString &reason); bool isBusy() const; private: + using ValuesCompletion = std::function &, const QString &)>; + struct Request { Request() : registerType(0) , address(-1) - , value(0) + , count(0) , write(false) { } - Request(int type, int requestAddress, quint16 requestValue, - bool requestWrite, const Completion &requestCallback) + Request(int type, int requestAddress, quint16 requestCount, + const QVector &requestValues, bool requestWrite, + const ValuesCompletion &requestCallback) : registerType(type) , address(requestAddress) - , value(requestValue) + , count(requestCount) + , values(requestValues) , write(requestWrite) , callback(requestCallback) { @@ -62,16 +92,22 @@ private: int registerType; int address; - quint16 value; + quint16 count; + QVector values; bool write; - Completion callback; + ValuesCompletion callback; + bool vision = false; + bool sent = false; + VisionWriteCallback writeCallback; + std::function beforeSend; }; void enqueue(const Request &request); void startNext(); void ensureConnected(); void startCurrentRequest(); - void finishCurrent(bool success, quint16 value, const QString &error); + void finishCurrent(bool success, const QVector &values, + const QString &error); void handleConnectionFailure(const QString &error); void ensureClient(); void setError(const QString &text); @@ -92,6 +128,7 @@ private: bool m_hasCurrentRequest; bool m_connecting; bool m_aborting; + bool m_cancelingVision = false; int m_connectAttempts; QString m_lastErrorText; }; diff --git a/models/visionresult.h b/models/visionresult.h new file mode 100644 index 0000000..3a96f1e --- /dev/null +++ b/models/visionresult.h @@ -0,0 +1,44 @@ +#ifndef VISIONRESULT_H +#define VISIONRESULT_H + +#include +#include +#include + +struct RobotPose +{ + QVector xyzabc; + + bool isValid() const + { + if (xyzabc.size() != 6) + return false; + for (double value : xyzabc) { + if (!std::isfinite(value)) + return false; + } + return true; + } +}; + +struct VisionHandshake +{ + bool robotReceived = false; + bool photoRequest = false; + bool comparing = false; + bool comparisonError = false; + bool comparisonPassed = false; +}; + +enum class VisionWriteOutcome +{ + NotSent, + Confirmed, + Uncertain +}; + +Q_DECLARE_METATYPE(RobotPose) +Q_DECLARE_METATYPE(VisionHandshake) +Q_DECLARE_METATYPE(VisionWriteOutcome) + +#endif // VISIONRESULT_H diff --git a/pages/dashboardpage.cpp b/pages/dashboardpage.cpp index 40bc4c0..cb5f3a5 100644 --- a/pages/dashboardpage.cpp +++ b/pages/dashboardpage.cpp @@ -6,6 +6,8 @@ #include "../services/workpieceservice.h" #include "../repositories/productionrepository.h" #include "uihelpers.h" +#include "../services/visionservice.h" +#include #include #include @@ -306,6 +308,35 @@ DashboardPage::~DashboardPage() delete ui; } +void DashboardPage::attachVisionService(VisionService *service) +{ + qRegisterMetaType("QJsonObject"); + connect(productionWorker, &ProductionWorker::visionMeasureRequested, + service, &VisionService::measure, Qt::QueuedConnection); + connect(productionWorker, &ProductionWorker::visionCancelRequested, + service, &VisionService::cancel, Qt::QueuedConnection); + connect(productionWorker, &ProductionWorker::visionProductionActiveChanged, + service, &VisionService::setProductionActive, Qt::QueuedConnection); + connect(productionWorker, &ProductionWorker::visionProductionActiveChanged, + this, &DashboardPage::visionProductionActiveChanged, Qt::QueuedConnection); + connect(service, &VisionService::measurementFinished, + productionWorker, &ProductionWorker::receiveVisionResult, Qt::QueuedConnection); + connect(service, &VisionService::availabilityChanged, + productionWorker, &ProductionWorker::updateVisionAvailability, Qt::QueuedConnection); + connect(productionWorker, &ProductionWorker::visionCycleChanged, this, + [this](const QJsonObject &cycle) { + visionRecoveryRequired = cycle.value("recovery_required").toBool(); + updateRecoveryButtons(); + emit visionCycleChanged(cycle); + emit logRequested("生产日志", "视觉引导", "自动取料", + QString::fromUtf8(QJsonDocument(cycle).toJson(QJsonDocument::Compact)), + visionRecoveryRequired ? "待恢复" : "记录"); + }, Qt::QueuedConnection); + QMetaObject::invokeMethod(productionWorker, "updateVisionAvailability", Qt::QueuedConnection, + Q_ARG(bool, service->isReady()), Q_ARG(bool, service->isBusy()), Q_ARG(QString, service->sessionId())); + QMetaObject::invokeMethod(productionWorker, "requestVisionSnapshot", Qt::QueuedConnection); +} + void DashboardPage::addLog(const QString &type, const QString &module, const QString &content, const QString &status) { @@ -377,6 +408,7 @@ void DashboardPage::startProduction() void DashboardPage::pauseProduction() { + productionWorker->requestPauseImmediate(); QMetaObject::invokeMethod(productionWorker, "requestPause", Qt::QueuedConnection); } @@ -494,11 +526,13 @@ void DashboardPage::onRecoveryCompleted(const QString &mode) void DashboardPage::recoverProduction() { - if (productionState == ProductionService::ManualConfirm + if ((productionState == ProductionService::ManualConfirm || visionRecoveryRequired) && QMessageBox::question( this, "继续生产", - "请确认设备和 PLC 当前步骤安全后再继续生产。", - QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) + visionRecoveryRequired + ? "请先核对机器人当前位置及本次 R60 目标是否已被消费或撤销,并确认 PLC 已复位 850、851。确认后 ssp 会清除自己的视觉输出并重新核对信号,不会重发旧坐标。是否已完成现场核对?" + : "请确认设备和 PLC 当前步骤安全后再继续生产。", + QMessageBox::Yes | QMessageBox::No, QMessageBox::No) != QMessageBox::Yes) { return; } @@ -531,22 +565,22 @@ void DashboardPage::updateRecoveryButtons() { const ProductionService::State state = productionState; const bool recoveryRequired = state == ProductionService::TimeoutPaused - || state == ProductionService::ManualConfirm; + || state == ProductionService::ManualConfirm || 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; + && currentOrderStartable && !visionRecoveryRequired; ui->startButton->setEnabled(canStart); recoverButton->setVisible(recoveryRequired); - retryButton->setVisible(recoveryRequired); + retryButton->setVisible(recoveryRequired && !visionRecoveryRequired); markNgButton->setVisible(recoveryRequired - && productionWorkpiece.id > 0); + && productionWorkpiece.id > 0 && !visionRecoveryRequired); stopButton->setVisible(running); stopButton->setEnabled(!terminating); stopButton->setText(terminating ? "终止中..." : "终止"); - recoverButton->setText(state == ProductionService::ManualConfirm + recoverButton->setText(visionRecoveryRequired ? "核对视觉恢复" : state == ProductionService::ManualConfirm ? "继续" : "恢复"); } diff --git a/pages/dashboardpage.h b/pages/dashboardpage.h index f71f805..445f9af 100644 --- a/pages/dashboardpage.h +++ b/pages/dashboardpage.h @@ -13,6 +13,7 @@ class QLabel; class QPushButton; class QTimer; class QThread; +class VisionService; namespace Ui { class DashboardPage; } @@ -25,6 +26,7 @@ public: ~DashboardPage(); void addLog(const QString &type, const QString &module, const QString &content, const QString &status); + void attachVisionService(VisionService *service); signals: void systemStateChanged(const QString &state); @@ -33,6 +35,8 @@ signals: void currentWorkpieceChanged(const QString &workpiece); void deviceStatusChanged(const DeviceStatus &status); void deviceCommunicationError(const QString &error); + void visionCycleChanged(const QJsonObject &cycle); + void visionProductionActiveChanged(bool active); void logRequested(const QString &type, const QString &module, const QString &action, const QString &content, const QString &status); @@ -101,6 +105,7 @@ private: Workpiece productionWorkpiece; int productionTrayNo; int productionSlotNo; + bool visionRecoveryRequired = false; }; #endif // DASHBOARDPAGE_H diff --git a/pages/visionpage.cpp b/pages/visionpage.cpp new file mode 100644 index 0000000..50a66d0 --- /dev/null +++ b/pages/visionpage.cpp @@ -0,0 +1,177 @@ +#include "visionpage.h" +#include "../services/visionservice.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +VisionPage::VisionPage(VisionService *service, QWidget *parent) + : QWidget(parent), m_service(service), m_productionActive(false) +{ + QVBoxLayout *layout = new QVBoxLayout(this); + layout->setContentsMargins(18, 18, 18, 18); + QHBoxLayout *buttons = new QHBoxLayout; + QPushButton *start = new QPushButton("启动视觉程序", this); + QPushButton *connectButton = new QPushButton("连接已有视觉程序", this); + m_initialize = new QPushButton("初始化左右相机", this); + QPushButton *show = new QPushButton("打开视觉调试窗口", this); + QPushButton *disconnectButton = new QPushButton("断开并释放调试控制", this); + buttons->addWidget(start); + buttons->addWidget(connectButton); + buttons->addWidget(m_initialize); + buttons->addWidget(show); + buttons->addWidget(disconnectButton); + buttons->addStretch(); + layout->addLayout(buttons); + m_status = new QLabel("视觉进程:未连接", this); + m_initialization = new QLabel("相机初始化:未执行", this); + m_initialization->setWordWrap(true); + m_cycle = new QLabel("自动流程:未开始", this); + m_cycle->setWordWrap(true); + m_result = new QLabel("本次结果:无", this); + m_result->setWordWrap(true); + layout->addWidget(m_status); + layout->addWidget(m_initialization); + layout->addWidget(new QLabel("左相机 · 高精细化 · 测量截止 5 秒 · MinScore 0.70 · Greediness 0.80 · 中心选择 · 模型原点 · 抓取偏移 4.40 mm", this)); + layout->addWidget(m_cycle); + layout->addWidget(m_result); + m_poses = new QTableWidget(3, 6, this); + m_poses->setHorizontalHeaderLabels(QStringList() << "X" << "Y" << "Z" << "A" << "B" << "C"); + m_poses->setVerticalHeaderLabels(QStringList() << "R40 拍照位姿" << "相机模型原点" << "R60 抓取目标"); + m_poses->setEditTriggers(QAbstractItemView::NoEditTriggers); + m_poses->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch); + for (int row = 0; row < 3; ++row) + for (int col = 0; col < 6; ++col) + m_poses->setItem(row, col, new QTableWidgetItem("—")); + layout->addWidget(m_poses); + layout->addWidget(new QLabel("机器人坐标单位:mm / °。相机姿态沿用 VisionGuide 原始类型;显示抓取目标不代表 PLC 已写入或机器人已接收。", this)); + + QGroupBox *diagnostic = new QGroupBox("手动诊断(只测量,不写 R60)", this); + QGridLayout *form = new QGridLayout(diagnostic); + form->addWidget(new QLabel("视觉料盘", diagnostic), 0, 0); + m_tray = new QSpinBox(diagnostic); + m_tray->setRange(1, 99); + form->addWidget(m_tray, 0, 1); + const QStringList axes = QStringList() << "X" << "Y" << "Z" << "A" << "B" << "C"; + for (int i = 0; i < 6; ++i) { + form->addWidget(new QLabel(axes.at(i), diagnostic), 1, i); + m_diagnosticPose[i] = new QDoubleSpinBox(diagnostic); + m_diagnosticPose[i]->setRange(-1000000, 1000000); + m_diagnosticPose[i]->setDecimals(6); + form->addWidget(m_diagnosticPose[i], 2, i); + } + m_diagnose = new QPushButton("使用上述拍照位姿测量", diagnostic); + form->addWidget(m_diagnose, 3, 0, 1, 3); + layout->addWidget(diagnostic); + layout->addStretch(); + connect(start, &QPushButton::clicked, service, &VisionService::startService); + connect(connectButton, &QPushButton::clicked, service, &VisionService::connectService); + connect(m_initialize, &QPushButton::clicked, service, &VisionService::initialize); + connect(show, &QPushButton::clicked, service, &VisionService::showWindow); + connect(disconnectButton, &QPushButton::clicked, service, &VisionService::disconnectService); + connect(m_diagnose, &QPushButton::clicked, this, [this]() { + QJsonArray pose; + for (QDoubleSpinBox *axis : m_diagnosticPose) pose.append(axis->value()); + const QString id = QUuid::createUuid().toString(QUuid::WithoutBraces); + QJsonObject request{{"request_id", id}, {"robot_pose", pose}, + {"context", QJsonObject{{"workpiece_id", "diagnostic"}, {"task_id", "diagnostic"}, + {"tray_no", m_tray->value()}, {"generation", id}}}, + {"pose_source", "diagnostic"}, {"pose_read_at", QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)}, + {"parameters", VisionService::standardParameters()}, {"convention", VisionService::standardConvention()}, + {"require_robot_pose", true}}; + m_service->diagnose(request); + }); + connect(service, &VisionService::availabilityChanged, this, [this](bool ready, bool busy, const QString &session) { + m_status->setText(session.isEmpty() ? "视觉进程:未连接" + : QString("视觉进程:在线;初始化%1;资源%2").arg(ready ? "就绪" : "未就绪", busy ? "忙" : "空闲")); + if (session.isEmpty()) invalidateResult(); + refreshControls(); + }); + connect(service, &VisionService::statusChanged, this, [this](const QJsonObject &status) { + if (status.contains("initialization")) { + const QJsonObject initialization = status.value("initialization").toObject(); + QStringList details; + for (const QString &camera : QStringList() << "left" << "right") { + const QJsonObject state = initialization.value(camera).toObject(); + details.append(QString("%1:连接%2 / 参数%3 / 白平衡%4") + .arg(camera == "left" ? "左相机" : "右相机", + state.value("connected").toBool() ? "完成" : "未完成", + state.value("parameters_applied").toBool() ? "完成" : "未完成", + state.value("white_balance_finished").toBool() ? "完成" : "未完成")); + } + m_initialization->setText(details.join(";")); + } + }); + connect(service, &VisionService::requestStarted, this, [this](const QJsonObject &request) { + invalidateResult(); + m_poses->verticalHeaderItem(0)->setText(request.value("pose_source").toString() == "diagnostic" + ? "诊断拍照位姿" : "R40 拍照位姿"); + showPose(0, request.value("robot_pose")); + const QJsonObject context = request.value("context").toObject(); + m_cycle->setText(QString("请求 %1;工件 %2;视觉料盘 %3;等待测量结果%4") + .arg(request.value("request_id").toString(), context.value("workpiece_id").toString()) + .arg(context.value("tray_no").toInt()) + .arg(request.value("pose_source").toString() == "diagnostic" ? "(诊断)" : "")); + }); + connect(service, &VisionService::measurementFinished, this, [this](const QJsonObject &result) { + if (result.value("status").toString() != "ok") { + invalidateResult(); + m_result->setText("本次结果不可用:" + result.value("message").toString()); + return; + } + showPose(1, result.value("camera_pose")); + showPose(2, result.value("robot_pose")); + m_result->setText(QString("视觉计算成功;匹配分数 %1;测量 %2 ms;抓取计算 %3 ms;等待生产流程确认提交状态") + .arg(result.value("score").toDouble(), 0, 'f', 3) + .arg(result.value("measure_elapsed_ms").toInt()).arg(result.value("grasp_elapsed_ms").toInt())); + if (result.value("context").toObject().value("task_id").toString() == "diagnostic") + m_result->setText(m_result->text().replace("等待生产流程确认提交状态", "诊断结果,未写入 PLC")); + }); + refreshControls(); +} + +void VisionPage::showPose(int row, const QJsonValue &pose) +{ + const QJsonArray values = pose.toArray(); + for (int i = 0; i < 6; ++i) + m_poses->item(row, i)->setText(values.size() == 6 ? QString::number(values.at(i).toDouble(), 'g', 12) : "—"); +} + +void VisionPage::invalidateResult() +{ + showPose(1, QJsonArray()); + showPose(2, QJsonArray()); + m_result->setText("本次结果:不可用"); +} + +void VisionPage::updateCycle(const QJsonObject &cycle) +{ + m_cycle->setText("自动流程:" + cycle.value("phase").toString() + ";" + cycle.value("message").toString()); + if (cycle.contains("photo_pose")) showPose(0, cycle.value("photo_pose")); + if (cycle.contains("robot_pose")) showPose(2, cycle.value("robot_pose")); + if (cycle.value("invalidated").toBool()) invalidateResult(); +} + +void VisionPage::setProductionActive(bool active) +{ + m_productionActive = active; + refreshControls(); +} + +void VisionPage::refreshControls() +{ + m_initialize->setEnabled(!m_productionActive && !m_service->isBusy() && !m_service->sessionId().isEmpty()); + m_diagnose->setEnabled(!m_productionActive && m_service->isReady() && !m_service->isBusy()); + m_tray->setEnabled(!m_productionActive); + for (QDoubleSpinBox *axis : m_diagnosticPose) axis->setEnabled(!m_productionActive); +} diff --git a/pages/visionpage.h b/pages/visionpage.h new file mode 100644 index 0000000..df1cde6 --- /dev/null +++ b/pages/visionpage.h @@ -0,0 +1,42 @@ +#ifndef VISIONPAGE_H +#define VISIONPAGE_H + +#include +#include + +class QLabel; +class QPushButton; +class QTableWidget; +class QDoubleSpinBox; +class QSpinBox; +class VisionService; + +class VisionPage : public QWidget +{ + Q_OBJECT +public: + explicit VisionPage(VisionService *service, QWidget *parent = nullptr); + +public slots: + void updateCycle(const QJsonObject &cycle); + void setProductionActive(bool active); + +private: + void showPose(int row, const QJsonValue &pose); + void invalidateResult(); + void refreshControls(); + + VisionService *m_service; + QLabel *m_status; + QLabel *m_initialization; + QLabel *m_cycle; + QLabel *m_result; + QTableWidget *m_poses; + QPushButton *m_initialize; + QPushButton *m_diagnose; + QSpinBox *m_tray; + QDoubleSpinBox *m_diagnosticPose[6]; + bool m_productionActive; +}; + +#endif // VISIONPAGE_H diff --git a/services/deviceservice.cpp b/services/deviceservice.cpp index 0b74ddc..06c2ef0 100644 --- a/services/deviceservice.cpp +++ b/services/deviceservice.cpp @@ -4,6 +4,7 @@ #include "../modbus/modbustcpmanager.h" #include +#include namespace { @@ -91,6 +92,18 @@ void DeviceService::startPolling() pollStatus(); } +DeviceService::~DeviceService() +{ + m_pollTimer->stop(); + m_terminationActive = true; + m_terminationCallback = OperationCallback(); + ++m_visionGeneration; + // Modbus abort invokes pending callbacks; keep our state alive until they drain. + m_modbus->abortAll("Device service is shutting down"); + delete m_modbus; + m_modbus = nullptr; +} + void DeviceService::stopPolling() { m_pollTimer->stop(); @@ -952,3 +965,160 @@ bool DeviceService::productionActionBusy() const { return m_productionActionBusy || m_modbus->isBusy(); } + +bool DeviceService::checkVisionAccess(QString *error) const +{ + if (m_terminationActive || ConfigManager::instance().simulationMode() + || !ConfigManager::instance().productionEnabled()) { + if (error) *error = "Vision PLC access is disabled during termination or simulation"; + return false; + } + if (m_modbus->config().serverAddress == 0) { + if (error) *error = "Vision PLC writes require an addressed response, not broadcast"; + return false; + } + return ConfigManager::instance().visionConfig().isValid(error); +} + +void DeviceService::readRobotPhotoPose(const PoseCallback &callback) +{ + QString error; + if (!checkVisionAccess(&error)) { + if (callback) callback(false, RobotPose(), error); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + const quint64 generation = m_visionGeneration; + if (!m_modbus->readRReals(config.photoPoseR, 6, + [this, callback, generation](bool success, const QVector &values, const QString &text) { + RobotPose pose; + pose.xyzabc = values; + if (callback) { + callback(success && generation == m_visionGeneration && pose.isValid(), pose, + generation == m_visionGeneration ? text : "Vision pose read canceled"); + } + }, config.lowWordFirst)) { + if (callback) callback(false, RobotPose(), "Invalid R40 read request"); + } +} + +void DeviceService::writeRobotGraspPose(const RobotPose &pose, + const VisionWriteCallback &callback, + const std::function &beforeSend) +{ + QString error; + if (!checkVisionAccess(&error) || !pose.isValid()) { + if (callback) callback(VisionWriteOutcome::NotSent, + error.isEmpty() ? "Invalid robot grasp pose" : error); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + if (!m_modbus->writeRReals(config.graspPoseR, pose.xyzabc, callback, config.lowWordFirst, beforeSend)) { + if (callback) callback(VisionWriteOutcome::NotSent, "Invalid or overflowing R60 REAL request"); + return; + } + for (int axis = 0; axis < pose.xyzabc.size(); ++axis) { + const double rounded = double(float(pose.xyzabc.at(axis))); + if (rounded != pose.xyzabc.at(axis)) { + qInfo().nospace() << "Vision R60 axis " << axis << " REAL rounding: " + << QString::number(pose.xyzabc.at(axis), 'g', 17) << " -> " + << QString::number(rounded, 'g', 17); + } + } +} + +void DeviceService::readVisionHandshake(const HandshakeCallback &callback) +{ + QString error; + if (!checkVisionAccess(&error)) { + if (callback) callback(false, VisionHandshake(), error); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + if (config.photoRequestCoil == config.robotReceivedCoil + 1 + && config.comparingCoil == config.robotReceivedCoil + 2 + && config.comparisonErrorCoil == config.robotReceivedCoil + 3 + && config.comparisonPassedCoil == config.robotReceivedCoil + 4) { + const quint64 generation = m_visionGeneration; + m_modbus->readCoils(config.robotReceivedCoil, 5, + [this, callback, generation](bool success, const QVector &values, const QString &text) { + VisionHandshake state; + if (success && values.size() == 5 && generation == m_visionGeneration) { + state.robotReceived = values.at(0); + state.photoRequest = values.at(1); + state.comparing = values.at(2); + state.comparisonError = values.at(3); + state.comparisonPassed = values.at(4); + if (callback) callback(true, state, QString()); + } else if (callback) { + callback(false, state, text.isEmpty() ? "Vision handshake read canceled or incomplete" : text); + } + }, true); + return; + } + readVisionHandshakeStep(0, VisionHandshake(), m_visionGeneration, callback); +} + +void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &state, + quint64 generation, const HandshakeCallback &callback) +{ + if (generation != m_visionGeneration) { + if (callback) callback(false, VisionHandshake(), "Vision handshake read canceled"); + return; + } + if (index == 5) { + if (callback) callback(true, state, QString()); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + const int addresses[] = {config.robotReceivedCoil, config.photoRequestCoil, + config.comparingCoil, config.comparisonErrorCoil, + config.comparisonPassedCoil}; + m_modbus->readVisionCoil(addresses[index], + [this, index, state, generation, callback](bool success, bool value, const QString &error) { + if (!success) { + if (callback) callback(false, VisionHandshake(), error); + return; + } + VisionHandshake next = state; + switch (index) { + case 0: next.robotReceived = value; break; + case 1: next.photoRequest = value; break; + case 2: next.comparing = value; break; + case 3: next.comparisonError = value; break; + case 4: next.comparisonPassed = value; break; + } + readVisionHandshakeStep(index + 1, next, generation, callback); + }); +} + +void DeviceService::writeVisionSignal(VisionSignal signal, bool value, + const VisionWriteCallback &callback, + const std::function &beforeSend) +{ + QString error; + if (!checkVisionAccess(&error)) { + if (callback) callback(VisionWriteOutcome::NotSent, error); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + int address = -1; + QString name; + switch (signal) { + case Comparing: address = config.comparingCoil; name = "comparing"; break; + case ComparisonError: address = config.comparisonErrorCoil; name = "comparisonError"; break; + case ComparisonPassed: address = config.comparisonPassedCoil; name = "comparisonPassed"; break; + default: break; + } + if (address < 0 || !config.writableSignals.contains(name)) { + if (callback) callback(VisionWriteOutcome::NotSent, "Vision coil is not owned by ssp"); + return; + } + m_modbus->writeVisionCoil(address, value, callback, beforeSend); +} + +void DeviceService::cancelVisionRequests(const QString &reason) +{ + ++m_visionGeneration; + m_modbus->cancelVisionRequests(reason); +} diff --git a/services/deviceservice.h b/services/deviceservice.h index 7c414f4..812fcbc 100644 --- a/services/deviceservice.h +++ b/services/deviceservice.h @@ -7,6 +7,7 @@ #include #include #include +#include "../models/visionresult.h" struct DeviceStatus { @@ -43,6 +44,11 @@ public: std::function; using ActionCallback = std::function; + using PoseCallback = std::function; + using HandshakeCallback = std::function; + using VisionWriteCallback = std::function; + + enum VisionSignal { Comparing, ComparisonError, ComparisonPassed }; enum ProductionAction { @@ -57,6 +63,7 @@ public: }; explicit DeviceService(QObject *parent = nullptr); + ~DeviceService() override; void startPolling(); void stopPolling(); @@ -76,6 +83,13 @@ public: void cancelProductionAction(const OperationCallback &callback); bool productionActionActive() const; bool productionActionBusy() const; + void readRobotPhotoPose(const PoseCallback &callback); + void writeRobotGraspPose(const RobotPose &pose, const VisionWriteCallback &callback, + const std::function &beforeSend = {}); + void readVisionHandshake(const HandshakeCallback &callback); + void writeVisionSignal(VisionSignal signal, bool value, const VisionWriteCallback &callback, + const std::function &beforeSend = {}); + void cancelVisionRequests(const QString &reason); signals: void statusChanged(const DeviceStatus &status); @@ -102,6 +116,9 @@ private: void clearNextTerminationSignal(); void finishTermination(bool success, const QString &error); void finishActionPoll(bool completed, const ActionCallback &callback); + bool checkVisionAccess(QString *error) const; + void readVisionHandshakeStep(int index, const VisionHandshake &state, + quint64 generation, const HandshakeCallback &callback); QTimer *m_pollTimer; class ModbusTcpManager *m_modbus; @@ -118,6 +135,7 @@ private: OperationCallback m_terminationCallback; int m_controlCommandAddress; int m_controlFeedbackAddress; + quint64 m_visionGeneration = 0; }; #endif // DEVICESERVICE_H diff --git a/services/productionservice.cpp b/services/productionservice.cpp index 3bc51b3..0e76600 100644 --- a/services/productionservice.cpp +++ b/services/productionservice.cpp @@ -5,10 +5,16 @@ #include "orderservice.h" #include "trayservice.h" #include "workpieceservice.h" +#include "visionservice.h" #include +#include +#include +#include #include #include +#include +#include namespace { @@ -64,6 +70,22 @@ ProductionService::State ProductionService::state() const return m_state; } +ProductionService::~ProductionService() +{ + m_timer->stop(); + m_state = Terminating; + m_stopRequested.store(true); + ++m_visionGeneration; + m_visionSuspended = true; + m_actionCancelRequested = false; + m_deferredCancelCallback = DeviceService::OperationCallback(); + m_shutdownCallback = DeviceService::OperationCallback(); + m_shutdownRequested = false; + // Drain request callbacks while this object's value members still exist. + delete m_deviceService; + m_deviceService = nullptr; +} + QString ProductionService::stateName() const { return stateNameForState(m_state); @@ -130,13 +152,481 @@ 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().visionConfig().enabled + && !ConfigManager::instance().simulationMode(); +} + +bool ProductionService::visionCurrent(quint64 generation) const +{ + return generation == m_visionGeneration && !m_visionSuspended && !stopRequested() + && !(m_externalPauseRequested && m_externalPauseRequested->load()) + && isActive() && m_currentWorkpiece.id == m_visionWorkpieceId + && m_currentTrayNo == m_visionTrayNo && m_visionReady + && m_availableVisionSession == m_visionSession + && m_deviceStatusValid && m_deviceStatus.plcConnected + && m_deviceStatus.safetyDoorClosed && !m_deviceStatus.emergencyStop; +} + +void ProductionService::reportVision(const QString &phase, const QString &message, bool invalidated) +{ + QJsonObject cycle{{"phase", phase}, {"message", message}, {"invalidated", invalidated}, + {"recovery_required", m_visionNeedsReconcile}, + {"request_id", m_visionRequest.value("request_id")}, + {"context", m_visionRequest.value("context")}}; + if (!m_visionRequest.isEmpty()) cycle.insert("photo_pose", m_visionRequest.value("robot_pose")); + if (!m_visionResult.isEmpty()) cycle.insert("robot_pose", m_visionResult.value("robot_pose")); + if (!m_visionResult.isEmpty()) { + cycle.insert("camera_pose", m_visionResult.value("camera_pose")); + cycle.insert("parameters", m_visionResult.value("parameters")); + cycle.insert("calibration_fingerprint", m_visionResult.value("calibration_fingerprint")); + cycle.insert("measure_elapsed_ms", m_visionResult.value("measure_elapsed_ms")); + cycle.insert("grasp_elapsed_ms", m_visionResult.value("grasp_elapsed_ms")); + } + emit visionCycleChanged(cycle); +} + +void ProductionService::setVisionStage(VisionStage stage, const QString &message) +{ + m_visionStage = stage; + m_visionTimer.restart(); + QString name; + switch (stage) { + case VisionStage::Idle: name = "待机"; break; + case VisionStage::Preflight: name = "检查握手复位"; break; + case VisionStage::Armed: name = "允许料架取料"; break; + case VisionStage::WaitRequest: name = "等待拍照请求"; break; + case VisionStage::SettingBusy: name = "开始比对"; break; + case VisionStage::ReadingPose: name = "读取 R40 位姿"; break; + case VisionStage::Measuring: name = "识别及抓取计算"; break; + case VisionStage::WritingPose: name = "写入 R60"; break; + case VisionStage::Publishing: name = "发布比对通过"; break; + case VisionStage::WaitAck: name = "等待机器人接收"; break; + case VisionStage::WaitReset: name = "等待请求及接收复位"; break; + case VisionStage::Clearing: name = "清除本轮输出"; break; + case VisionStage::Complete: name = "视觉握手完成"; break; + case VisionStage::Fault: name = "等待人工核对"; break; + } + reportVision(name, message); +} + +void ProductionService::prepareVision() +{ + QString error; + const VisionConfig config = ConfigManager::instance().visionConfig(); + if (!config.isValid(&error) || config.visionTrayNo(m_currentTrayNo) < 1 + || !m_visionReady || m_visionBusy || m_availableVisionSession.isEmpty()) { + visionFault(error.isEmpty() ? "视觉未就绪或缺少料盘配置对应关系" : error); + return; + } + ++m_visionGeneration; + m_visionWorkpieceId = m_currentWorkpiece.id; + m_visionTrayNo = m_currentTrayNo; + m_visionSession = m_availableVisionSession; + m_visionRequest = QJsonObject(); + m_visionResult = QJsonObject(); + m_visionCommitStarted = false; + m_visionIoPending = false; + m_visionRecoveryChecking = false; + setVisionStage(VisionStage::Preflight, "核对上一轮相机握手已全部复位"); + advanceVision(); +} + +void ProductionService::advanceVision() +{ + if (m_visionSuspended || m_visionStage == VisionStage::Fault) return; + if (!visionCurrent(m_visionGeneration)) { + visionFault("当前工件、视觉进程会话或设备状态已改变"); + return; + } + const VisionConfig config = ConfigManager::instance().visionConfig(); + const int limit = m_visionStage == VisionStage::Measuring ? config.requestTimeoutMs + : (m_visionStage == VisionStage::WaitAck || m_visionStage == VisionStage::WaitReset) + ? config.robotAckTimeoutMs : ConfigManager::instance().productionConfig().stateTimeoutMs; + if (m_visionTimer.isValid() && m_visionTimer.elapsed() > limit) { + visionFault("视觉流程等待超时,请核对 PLC 与机器人状态后人工恢复", + !m_visionCommitStarted); + return; + } + if (m_visionIoPending) return; + if (m_visionStage != VisionStage::Preflight && m_visionStage != VisionStage::WaitRequest + && m_visionStage != VisionStage::WaitAck && m_visionStage != VisionStage::WaitReset) 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) { + if (handshake.robotReceived || handshake.photoRequest || handshake.comparing + || handshake.comparisonError || handshake.comparisonPassed) { + visionFault("取料开始前已有相机握手信号置位,需人工核对复位"); + return; + } + setVisionStage(VisionStage::Armed, "握手已复位,允许发送料架取料命令使机器人到达拍照位"); + } else if (m_visionStage == VisionStage::WaitRequest) { + if (handshake.robotReceived || handshake.comparing || handshake.comparisonError + || handshake.comparisonPassed) { + visionFault("新拍照请求前出现旧接收确认或非预期比对输出"); + return; + } + if (!handshake.photoRequest) return; + const quint64 generation = m_visionGeneration; + setVisionStage(VisionStage::SettingBusy, "机器人已到位停稳,置位相机比对中"); + m_visionIoPending = true; + m_deviceService->writeVisionSignal(DeviceService::Comparing, true, + [this, generation](VisionWriteOutcome outcome, const QString &error) { + if (!visionCurrent(generation)) return; + m_visionIoPending = false; + if (outcome != VisionWriteOutcome::Confirmed) { + visionFault("相机比对中信号写入未确认:" + error); return; + } + beginVisionMeasurement(); + }, [this, generation]() { return visionCurrent(generation); }); + } else if (m_visionStage == VisionStage::WaitAck) { + if (!handshake.photoRequest || !handshake.comparisonPassed || handshake.comparisonError) { + visionFault("机器人接收确认前,PLC 已改变拍照请求或结果握手"); + return; + } + if (handshake.robotReceived) + setVisionStage(VisionStage::WaitReset, "机器人已接收目标,等待 850、851 复位"); + } else if (m_visionStage == VisionStage::WaitReset) { + if (handshake.comparisonError || !handshake.comparisonPassed) { + visionFault("请求及接收复位完成前,结果握手被改变"); return; + } + if (!handshake.robotReceived && !handshake.photoRequest) { + setVisionStage(VisionStage::Clearing, "接收及请求已复位,清除 ssp 本轮比对输出"); + clearVisionOutputs(0, m_visionGeneration); + } + } +} + +void ProductionService::beginVisionMeasurement() +{ + const quint64 generation = m_visionGeneration; + setVisionStage(VisionStage::ReadingPose, "从 R40 整组读取本次拍照 XYZABC"); + m_visionIoPending = true; + m_deviceService->readRobotPhotoPose( + [this, generation](bool success, const RobotPose &pose, const QString &error) { + if (!visionCurrent(generation)) return; + m_visionIoPending = false; + if (!success || !pose.isValid()) { + visionFault("R40 拍照位姿读取失败:" + error, true); return; + } + QJsonArray values; + for (double value : pose.xyzabc) values.append(value); + const VisionConfig config = ConfigManager::instance().visionConfig(); + m_visionRequest = QJsonObject{ + {"protocol_version", 1}, {"type", "measure"}, + {"request_id", QUuid::createUuid().toString(QUuid::WithoutBraces)}, + {"server_session_id", m_visionSession}, {"robot_pose", values}, + {"pose_source", "plc_r40"}, + {"pose_read_at", QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)}, + {"require_robot_pose", true}, {"parameters", VisionService::standardParameters()}, + {"convention", VisionService::standardConvention()}, + {"context", QJsonObject{{"workpiece_id", QString::number(m_visionWorkpieceId)}, + {"task_id", QString::number(m_runId) + "/RackPick"}, + {"tray_no", config.visionTrayNo(m_visionTrayNo)}, + {"generation", QString::number(generation)}}}}; + setVisionStage(VisionStage::Measuring, "等待左相机识别并计算机器人抓取坐标"); + emit visionMeasureRequested(m_visionRequest); + }); +} + +void ProductionService::onVisionAvailability(bool ready, bool busy, const QString &session) +{ + m_visionReady = ready; + m_visionBusy = busy; + m_availableVisionSession = session; + if (m_visionStage != VisionStage::Idle && m_visionStage != VisionStage::Fault + && (!ready || session != m_visionSession)) + visionFault("VisionGuide 已断开、未就绪或进程会话改变"); +} + +void ProductionService::publishVisionSnapshot() +{ + emit visionProductionActiveChanged(m_visionNeedsReconcile || (m_state != Idle && m_state != Completed)); + reportVision(m_visionNeedsReconcile ? "等待人工核对" : "待机", + m_visionNeedsReconcile ? m_lastError : "等待下一次料架取料"); +} + +void ProductionService::onVisionResult(const QJsonObject &result) +{ + if (m_visionStage != VisionStage::Measuring || !visionCurrent(m_visionGeneration) + || result.value("request_id") != m_visionRequest.value("request_id")) return; + if (result.value("context") != m_visionRequest.value("context") + || result.value("server_session_id").toString() != m_visionSession) { + visionFault("视觉结果与本次取料上下文不一致", true); return; + } + RobotPose target, camera; + for (const QJsonValue &value : result.value("robot_pose").toArray()) { + if (!value.isDouble()) { visionFault("机器人坐标格式无效", true); return; } + target.xyzabc.append(value.toDouble()); + } + for (const QJsonValue &value : result.value("camera_pose").toArray()) { + if (!value.isDouble()) { visionFault("相机坐标格式无效", true); return; } + camera.xyzabc.append(value.toDouble()); + } + if (result.value("status").toString() != "ok" || !result.value("robot_valid").toBool() + || !result.value("camera_valid").toBool() || !target.isValid() || !camera.isValid() + || result.value("source").toString() != "LEFT" || result.value("pose_type").toString() != "model_origin" + || result.value("parameters") != m_visionRequest.value("parameters") + || result.value("convention") != m_visionRequest.value("convention") + || !result.value("score").isDouble() || !std::isfinite(result.value("score").toDouble()) + || result.value("score").toDouble() < .70 || result.value("score").toDouble() > 1.0 + || result.value("calibration_fingerprint").toString().isEmpty()) { + visionFault("视觉结果校验失败,禁止写入 R60:" + result.value("message").toString(), true); return; + } + m_visionResult = result; + const quint64 generation = m_visionGeneration; + // Re-read the request/ack before committing, while the robot holds the photo pose. + m_visionIoPending = true; + setVisionStage(VisionStage::WritingPose, "提交 R60 前再次核对拍照请求和接收信号"); + m_deviceService->readVisionHandshake( + [this, generation, target](bool success, const VisionHandshake &handshake, const QString &error) { + if (!visionCurrent(generation)) return; + if (!success || !handshake.photoRequest || handshake.robotReceived + || !handshake.comparing || handshake.comparisonPassed || handshake.comparisonError) { + m_visionIoPending = false; + visionFault("提交 R60 前机器人请求发生变化:" + error); return; + } + m_visionCommitStarted = true; + reportVision("写入 R60", "整组写入抓取坐标,尚未收到机器人接收确认"); + m_deviceService->writeRobotGraspPose(target, + [this, generation](VisionWriteOutcome outcome, const QString &error) { + if (!visionCurrent(generation)) return; + if (outcome != VisionWriteOutcome::Confirmed) { + m_visionIoPending = false; + visionFault("R60 写入未确认,禁止自动重发目标:" + error); return; + } + setVisionStage(VisionStage::Publishing, "R60 写入已确认,置位比对通过"); + m_deviceService->writeVisionSignal(DeviceService::ComparisonPassed, true, + [this, generation](VisionWriteOutcome outcome, const QString &error) { + if (!visionCurrent(generation)) return; + m_visionIoPending = false; + if (outcome != VisionWriteOutcome::Confirmed) { + visionFault("比对通过信号发布未确认:" + error); return; + } + setVisionStage(VisionStage::WaitAck, "结果已发布,等待机器人接收成功信号 850"); + }, [this, generation]() { return visionCurrent(generation); }); + }, [this, generation]() { return visionCurrent(generation); }); + }); +} + +void ProductionService::clearVisionOutputs(int index, quint64 generation) +{ + if (!visionCurrent(generation)) return; + if (index == 3) { + m_visionIoPending = false; + setVisionStage(VisionStage::Complete, "机器人接收及信号复位完成,继续等待原取料动作完成"); + return; + } + const DeviceService::VisionSignal outputs[] = {DeviceService::ComparisonPassed, + DeviceService::ComparisonError, DeviceService::Comparing}; + m_visionIoPending = true; + m_deviceService->writeVisionSignal(outputs[index], false, + [this, index, generation](VisionWriteOutcome outcome, const QString &error) { + if (!visionCurrent(generation)) return; + if (outcome != VisionWriteOutcome::Confirmed) { + m_visionIoPending = false; + visionFault("比对输出复位未确认:" + error); return; + } + clearVisionOutputs(index + 1, generation); + }, [this, generation]() { return visionCurrent(generation); }); +} + +void ProductionService::invalidateVision(const QString &reason) +{ + if (m_visionStage == VisionStage::Idle && !m_visionNeedsReconcile) return; + ++m_visionGeneration; + m_visionSuspended = true; + m_visionNeedsReconcile = true; + m_visionIoPending = false; + m_visionRecoveryChecking = false; + emit visionCancelRequested(m_visionRequest.value("request_id").toString()); + m_deviceService->cancelVisionRequests(reason); + m_visionStage = VisionStage::Fault; + reportVision("等待人工核对", reason + (m_visionCommitStarted + ? ";R60 或有效信号可能已经到达机器人,需现场核对" : QString()), true); + emit visionProductionActiveChanged(true); +} + +void ProductionService::visionFault(const QString &reason, bool reportComparisonError) +{ + if (m_visionStage == VisionStage::Fault) return; + const bool mayReport = reportComparisonError && !m_visionCommitStarted + && m_visionStage != VisionStage::Idle && m_visionStage != VisionStage::Preflight; + m_timeoutState = m_state; + m_lastError = reason; + invalidateVision(reason); + // A preflight rejection also requires an explicit operator recovery. + m_visionNeedsReconcile = true; + m_visionSuspended = true; + m_visionStage = VisionStage::Fault; + m_timer->stop(); + pauseProcessTimer(); + setState(ManualConfirm); + reportVision("等待人工核对", reason, true); + if (mayReport) { + const quint64 generation = m_visionGeneration; + m_deviceService->writeVisionSignal(DeviceService::ComparisonError, true, + [this](VisionWriteOutcome outcome, const QString &error) { + if (outcome != VisionWriteOutcome::Confirmed) + reportVision("等待人工核对", "比对错误输出未确认:" + error, true); + }, [this, generation]() { + return generation == m_visionGeneration && !stopRequested() + && !(m_externalPauseRequested && m_externalPauseRequested->load()); + }); + } + m_visionFaultCleanupPending = true; + cancelPendingProductionAction([this](bool success, const QString &error) { + if (!success) { + m_visionFaultCleanupPending = false; + emit productionError("PLC 动作取消失败:" + error); return; + } + m_deviceService->pause([this](bool paused, const QString &error) { + m_visionFaultCleanupPending = false; + if (!paused) emit productionError("PLC 暂停失败:" + error); + }); + }); + persistAlarm("VISION", reason); + emit timeoutRecoveryRequired("VISION", reason); + emit productionError(reason); +} + +bool ProductionService::recoverVision(QString *error) +{ + if (m_visionRecoveryChecking) { + if (error) *error = "正在核对视觉恢复状态"; + return false; + } + if (!checkRecoverySafety(error)) return false; + if (!m_visionReady || m_visionBusy || m_visionFaultCleanupPending || m_deviceService->productionActionBusy() + || m_deviceService->productionActionActive()) { + if (error) *error = "请等待 PLC 操作结束且 VisionGuide 就绪后恢复"; + return false; + } + if (m_externalPauseRequested) m_externalPauseRequested->store(false); + m_visionRecoveryChecking = true; + m_visionRecoverySession = m_availableVisionSession; + const quint64 generation = m_visionGeneration; + m_deviceService->readVisionHandshake( + [this, generation](bool success, const VisionHandshake &handshake, const QString &error) { + if (generation != m_visionGeneration || stopRequested() + || (m_externalPauseRequested && m_externalPauseRequested->load()) + || !m_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) { + m_visionRecoveryChecking = false; + return; + } + m_visionRecoveryChecking = false; + if (!success || handshake.photoRequest || handshake.robotReceived) { + emit productionError("人工恢复要求机器人接收成功和拍照请求均已复位:" + 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_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) { + m_visionRecoveryChecking = false; + return; + } + if (index < 3) { + const DeviceService::VisionSignal outputs[] = {DeviceService::ComparisonPassed, + DeviceService::ComparisonError, DeviceService::Comparing}; + 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; + emit productionError("视觉恢复时输出复位未确认:" + error); + return; + } + resetVisionForRecovery(index + 1, generation); + }, [this, generation]() { + return generation == m_visionGeneration && !stopRequested() + && !(m_externalPauseRequested && m_externalPauseRequested->load()) + && m_visionReady && !m_visionBusy && m_availableVisionSession == m_visionRecoverySession; + }); + 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()) + || !m_visionReady || m_visionBusy || m_availableVisionSession != m_visionRecoverySession) return; + if (!success || handshake.photoRequest || handshake.robotReceived || handshake.comparing + || handshake.comparisonError || handshake.comparisonPassed) { + 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); + reportVision("等待人工核对", m_lastError, true); + emit timeoutRecoveryRequired("VISION", m_lastError); + return; + } + } + persistRecoveryAction("VISION_CONFIRMED", "Operator verified the robot and PLC; handshake is reset; 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); + emit visionProductionActiveChanged(m_state != Idle && m_state != Completed); + if (m_state == Idle || m_state == Completed) return; + QString recoveryError; + if (!recover(&recoveryError)) emit productionError(recoveryError); + }); +} + bool ProductionService::start(int orderId, QString *error) { + const VisionConfig vision = ConfigManager::instance().visionConfig(); + if (m_visionNeedsReconcile || (vision.enabled && !vision.isValid(error))) { + if (m_visionNeedsReconcile && error) + *error = "请先人工核对并恢复上次视觉握手,再启动生产"; + return false; + } + if (vision.enabled && !ConfigManager::instance().simulationMode() + && (!m_visionReady || m_visionBusy)) { + if (error) *error = "请先初始化 VisionGuide,等待视觉就绪后启动生产"; + return false; + } if (orderId <= 0) { if (error) { *error = "Order id must be greater than 0"; @@ -172,6 +662,7 @@ bool ProductionService::start(int orderId, QString *error) m_actionError.clear(); m_frontResultState.clear(); m_stopRequested.store(false); + if (m_externalPauseRequested) m_externalPauseRequested->store(false); if (m_externalStopRequested) { m_externalStopRequested->store(false); } @@ -271,6 +762,10 @@ 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) { @@ -294,7 +789,9 @@ bool ProductionService::pause(QString *error) pauseProcessTimer(); m_timer->stop(); - setState(Paused); + setState(m_visionNeedsReconcile ? ManualConfirm : Paused); + if (m_visionNeedsReconcile) + emit timeoutRecoveryRequired("VISION", "视觉流程已中断,请核对 PLC 和机器人后恢复"); emitProcessElapsed(); }); }); @@ -303,6 +800,10 @@ bool ProductionService::pause(QString *error) bool ProductionService::resume(QString *error) { + if (m_visionNeedsReconcile) { + if (error) *error = "视觉流程需人工核对恢复,不能直接继续"; + return false; + } if (m_state != Paused) { if (error) { *error = "Production service is not paused"; @@ -313,6 +814,7 @@ bool ProductionService::resume(QString *error) if (!checkRecoverySafety(error)) { return false; } + if (m_externalPauseRequested) m_externalPauseRequested->store(false); m_deviceService->setInspectionMode( m_inspectionMode, @@ -364,6 +866,7 @@ bool ProductionService::stop(QString *error) return false; } + invalidateVision("操作员已终止生产"); m_lastError = "Production stopped by operator"; m_timer->stop(); setState(Terminating); @@ -441,6 +944,7 @@ bool ProductionService::stop(QString *error) void ProductionService::shutdown(const DeviceService::OperationCallback &callback) { + invalidateVision("生产线程正在退出"); if (m_shutdownRequested) { if (callback) { callback(false, "Production shutdown is already in progress"); @@ -472,6 +976,10 @@ 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"; @@ -601,6 +1109,12 @@ bool ProductionService::restoreActiveRun(QString *error) m_timeoutState = persistedState; } + if (requiresVision(DeviceService::RackPick)) { + m_visionNeedsReconcile = true; + m_visionSuspended = true; + m_visionStage = VisionStage::Fault; + reportVision("等待人工核对", "恢复未完成的生产记录,需核对相机与机器人握手", true); + } setState(ManualConfirm); m_heartbeatTimer.restart(); m_timer->stop(); @@ -613,6 +1127,7 @@ bool ProductionService::restoreActiveRun(QString *error) bool ProductionService::recover(QString *error) { + if (m_visionNeedsReconcile) return recoverVision(error); if (m_state != TimeoutPaused && m_state != ManualConfirm) { if (error) { *error = "Production is not waiting for recovery"; @@ -659,6 +1174,10 @@ bool ProductionService::recover(QString *error) 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"; @@ -729,6 +1248,10 @@ bool ProductionService::retry(QString *error) bool ProductionService::markCurrentWorkpieceNg(QString *error) { + if (m_visionNeedsReconcile) { + if (error) *error = "请先处理未完成的视觉及机器人握手,再标记工件 NG"; + return false; + } if (m_state != TimeoutPaused && m_state != ManualConfirm) { if (error) { *error = "Production is not waiting for manual recovery"; @@ -801,6 +1324,7 @@ void ProductionService::setState(State state) m_state = state; m_stateTimer.restart(); emit stateChanged(m_state, stateName()); + emit visionProductionActiveChanged(m_visionNeedsReconcile || (m_state != Idle && m_state != Completed)); if (m_runId > 0) { const QString processStep = processStepForState(state).isEmpty() @@ -924,6 +1448,19 @@ 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::Preflight) { + advanceVision(); + return true; + } + if (m_visionStage == VisionStage::Fault) return true; + } + if (!m_actionPending) { m_pendingAction = action; m_actionPending = true; @@ -937,6 +1474,8 @@ bool ProductionService::processProductionAction( m_actionStarting = false; if (!success) { m_actionError = actionError; + } else if (m_visionStage == VisionStage::Armed && !m_visionSuspended) { + setVisionStage(VisionStage::WaitRequest, "等待机器人到位后的拍照请求 851"); } tryDeferredActionCancel(); }); @@ -961,10 +1500,21 @@ bool ProductionService::processProductionAction( return true; } + if (requiresVision(action) && m_visionStage != VisionStage::Complete) { + advanceVision(); + return true; + } + if (m_actionCompleted) { *completed = true; m_actionPending = false; m_actionCompleted = false; + if (requiresVision(action)) { + m_visionStage = VisionStage::Idle; + m_visionCommitStarted = false; + m_visionRequest = QJsonObject(); + m_visionResult = QJsonObject(); + } return true; } @@ -1824,6 +2374,10 @@ void ProductionService::fail(const QString &error) if (m_state == Error) { return; } + if (m_visionStage != VisionStage::Idle && m_visionStage != VisionStage::Fault) { + visionFault(error); + return; + } m_lastError = error.isEmpty() ? "Production failed" : error; cancelPendingProductionAction( diff --git a/services/productionservice.h b/services/productionservice.h index 75b1b67..ac8d8cb 100644 --- a/services/productionservice.h +++ b/services/productionservice.h @@ -7,6 +7,7 @@ #include #include +#include #include class QTimer; @@ -67,8 +68,14 @@ public: 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: + void onVisionAvailability(bool ready, bool busy, const QString &session); + void onVisionResult(const QJsonObject &result); + void publishVisionSnapshot(); + signals: void stateChanged(ProductionService::State state, const QString &name); void deviceStatusChanged(const DeviceStatus &status); @@ -83,6 +90,10 @@ signals: void timeoutWarning(const QString &state, int elapsedMs, int timeoutMs); void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); + void visionMeasureRequested(const QJsonObject &request); + void visionCancelRequested(const QString &requestId); + void visionCycleChanged(const QJsonObject &cycle); + void visionProductionActiveChanged(bool active); private slots: void tick(); @@ -91,8 +102,28 @@ private slots: public: explicit ProductionService(QObject *parent = nullptr); + ~ProductionService() override; private: + friend class VisionProductionTest; + enum class VisionStage { + Idle, Preflight, Armed, WaitRequest, SettingBusy, ReadingPose, + Measuring, WritingPose, Publishing, WaitAck, WaitReset, Clearing, + Complete, Fault + }; + bool requiresVision(DeviceService::ProductionAction action) const; + void prepareVision(); + void advanceVision(); + void handleVisionHandshake(const VisionHandshake &handshake); + void beginVisionMeasurement(); + void clearVisionOutputs(int index, quint64 generation); + bool visionCurrent(quint64 generation) const; + void setVisionStage(VisionStage stage, const QString &message); + void reportVision(const QString &phase, const QString &message, bool invalidated = false); + void invalidateVision(const QString &reason); + void visionFault(const QString &reason, bool reportComparisonError = false); + bool recoverVision(QString *error); + void resetVisionForRecovery(int index, quint64 generation); ProductionService(const ProductionService &) = delete; ProductionService &operator=(const ProductionService &) = delete; @@ -180,6 +211,25 @@ private: std::atomic_bool *m_externalStopRequested; bool m_shutdownRequested; DeviceService::OperationCallback m_shutdownCallback; + VisionStage m_visionStage = VisionStage::Idle; + QElapsedTimer m_visionTimer; + QJsonObject m_visionRequest; + QJsonObject m_visionResult; + quint64 m_visionGeneration = 0; + int m_visionWorkpieceId = 0; + int m_visionTrayNo = 0; + QString m_visionSession; + QString m_availableVisionSession; + bool m_visionReady = false; + bool m_visionBusy = false; + bool m_visionIoPending = false; + bool m_visionSuspended = false; + bool m_visionCommitStarted = false; + bool m_visionNeedsReconcile = false; + bool m_visionRecoveryChecking = false; + bool m_visionFaultCleanupPending = false; + QString m_visionRecoverySession; + std::atomic_bool *m_externalPauseRequested = nullptr; }; Q_DECLARE_METATYPE(ProductionService::State) diff --git a/services/productionworker.cpp b/services/productionworker.cpp index ce41dca..71c4f13 100644 --- a/services/productionworker.cpp +++ b/services/productionworker.cpp @@ -4,6 +4,7 @@ ProductionWorker::ProductionWorker(QObject *parent) : QObject(parent) , m_service(nullptr) , m_stopRequested(false) + , m_pauseRequested(false) { } @@ -15,6 +16,11 @@ 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); + connect(m_service, &ProductionService::visionProductionActiveChanged, this, &ProductionWorker::visionProductionActiveChanged); connect(m_service, &ProductionService::stateChanged, this, &ProductionWorker::stateChanged); connect(m_service, &ProductionService::deviceStatusChanged, @@ -48,6 +54,29 @@ 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(); + m_service->onVisionAvailability(ready, busy, session); +} + +void ProductionWorker::receiveVisionResult(const QJsonObject &result) +{ + ensureService(); + m_service->onVisionResult(result); +} + +void ProductionWorker::requestVisionSnapshot() +{ + ensureService(); + m_service->publishVisionSnapshot(); +} + void ProductionWorker::reportFailure(bool success, const QString &error) { if (!success && !error.isEmpty()) { diff --git a/services/productionworker.h b/services/productionworker.h index 219e3e3..f6b2810 100644 --- a/services/productionworker.h +++ b/services/productionworker.h @@ -13,6 +13,7 @@ class ProductionWorker : public QObject public: explicit ProductionWorker(QObject *parent = nullptr); void requestStopImmediate(); + void requestPauseImmediate(); public slots: void requestStart(int orderId); @@ -26,6 +27,9 @@ public slots: void requestMarkNg(); void requestRestore(); void requestShutdown(); + void updateVisionAvailability(bool ready, bool busy, const QString &session); + void receiveVisionResult(const QJsonObject &result); + void requestVisionSnapshot(); signals: void stateChanged(ProductionService::State state, const QString &name); @@ -42,6 +46,10 @@ signals: void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); void shutdownReady(); + void visionMeasureRequested(const QJsonObject &request); + void visionCancelRequested(const QString &requestId); + void visionCycleChanged(const QJsonObject &cycle); + void visionProductionActiveChanged(bool active); private: void ensureService(); @@ -49,6 +57,7 @@ private: ProductionService *m_service; std::atomic_bool m_stopRequested; + std::atomic_bool m_pauseRequested; }; #endif // PRODUCTIONWORKER_H diff --git a/services/visionservice.cpp b/services/visionservice.cpp new file mode 100644 index 0000000..a1894b0 --- /dev/null +++ b/services/visionservice.cpp @@ -0,0 +1,539 @@ +#include "visionservice.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +const quint32 MaxMessageSize = 1024 * 1024; +QString newId() { return QUuid::createUuid().toString(QUuid::WithoutBraces); } + +bool validPose(const QJsonValue &value) +{ + if (!value.isArray() || value.toArray().size() != 6) + return false; + for (const QJsonValue &axis : value.toArray()) { + if (!axis.isDouble() || !std::isfinite(axis.toDouble())) + return false; + } + return true; +} + +bool nonnegativeInteger(const QJsonValue &value) +{ + return value.isDouble() && std::isfinite(value.toDouble()) + && value.toDouble() >= 0 && std::floor(value.toDouble()) == value.toDouble(); +} +} + +VisionService::VisionService(const VisionConfig &config, QObject *parent) + : QObject(parent), m_config(config), m_socket(new QLocalSocket(this)) + , m_process(new QProcess(this)), m_connectTimer(new QTimer(this)) + , m_pollTimer(new QTimer(this)), m_requestTimer(new QTimer(this)) + , m_initializeTimer(new QTimer(this)), m_ready(false), m_busy(false) + , m_productionActive(false), m_diagnostic(false), m_connecting(false) + , m_shuttingDown(false) +{ + qRegisterMetaType("QJsonObject"); + m_connectTimer->setInterval(200); + m_pollTimer->setInterval(1000); + m_requestTimer->setSingleShot(true); + m_initializeTimer->setSingleShot(true); + connect(m_connectTimer, &QTimer::timeout, this, &VisionService::connectAttempt); + connect(m_socket, &QLocalSocket::connected, this, [this]() { + m_connectTimer->stop(); + m_buffer.clear(); + m_session.clear(); + m_helloId = sendCommand("hello"); + m_lastReply.start(); + m_pollTimer->start(); + }); + connect(m_socket, &QLocalSocket::readyRead, this, &VisionService::readMessages); + connect(m_socket, &QLocalSocket::disconnected, this, [this]() { + if (!m_connecting) + failConnection("视觉进程连接已断开"); + }); + // Qt 5.14 exposes error(...), not the newer errorOccurred socket signal. + connect(m_socket, QOverload::of(&QLocalSocket::error), + this, [this](QLocalSocket::LocalSocketError) { + if (!m_connecting) + failConnection(m_socket->errorString()); + }); + connect(m_pollTimer, &QTimer::timeout, this, [this]() { + const int limit = m_session.isEmpty() ? m_config.startupTimeoutMs : 5000; + if (m_lastReply.isValid() && m_lastReply.elapsed() > limit) { + failConnection("视觉进程未回应状态查询"); + return; + } + if (!m_session.isEmpty()) { + for (auto it = m_commands.constBegin(); it != m_commands.constEnd(); ++it) { + if (it.value() == "get_status") + return; + } + sendCommand("get_status"); + } + }); + connect(m_requestTimer, &QTimer::timeout, this, [this]() { + const QString id = m_request.value("request_id").toString(); + if (!id.isEmpty()) { + m_cancelledRequests.insert(id); + sendCommand("cancel", QJsonObject{{"target_request_id", id}}); + failMeasurement("CLIENT_TIMEOUT", "视觉测量及抓取计算等待超时,结果已作废"); + } + }); + connect(m_initializeTimer, &QTimer::timeout, this, [this]() { + failConnection("视觉初始化等待超时,请核对视觉程序状态后重新连接"); + }); + connect(m_process, &QProcess::errorOccurred, this, [this](QProcess::ProcessError) { + emit logMessage("视觉进程启动/运行失败:" + m_process->errorString()); + if (m_process->state() == QProcess::NotRunning) + failConnection(m_process->errorString()); + }); + connect(m_process, QOverload::of(&QProcess::finished), + this, [this](int code, QProcess::ExitStatus) { + emit logMessage(QString("视觉子进程已退出,退出码 %1").arg(code)); + if (m_serverProcessId == QString::number(m_process->processId()) || m_connecting) + failConnection("视觉子进程已退出"); + }); + connect(m_process, &QProcess::readyReadStandardError, this, [this]() { + const QString text = QString::fromLocal8Bit(m_process->readAllStandardError()).trimmed(); + if (!text.isEmpty()) emit logMessage(text.left(4096)); + }); + connect(m_process, &QProcess::readyReadStandardOutput, this, [this]() { + m_process->readAllStandardOutput(); + }); +} + +VisionService::~VisionService() +{ + QElapsedTimer deadline; + deadline.start(); + shutdown(); + // Destruction cannot rely on the GUI event loop to deliver shutdown or reap + // the child. Normal operation stays asynchronous; only teardown is bounded. + m_socket->disconnect(this); + m_process->disconnect(this); + while (m_socket->bytesToWrite() > 0 && deadline.elapsed() < 3000) { + if (!m_socket->waitForBytesWritten(int(3000 - deadline.elapsed()))) + break; + } + // This QProcess only owns the child we spawned, never an attached instance. + if (m_process->state() != QProcess::NotRunning + && !m_process->waitForFinished(qMax(0, int(3000 - deadline.elapsed())))) { + m_process->kill(); + m_process->waitForFinished(1000); + } +} + +QJsonObject VisionService::standardParameters() +{ + return {{"camera_mode", "left_only"}, {"refinement", "least_squares_high"}, + {"deadline_ms", 5000}, {"min_score", 0.70}, {"greediness", 0.80}, + {"yolo_selection", "center"}, {"pose_display", "model_origin"}, + {"grasp_offset_mm", 4.40}}; +} + +QJsonObject VisionService::standardConvention() +{ + return {{"frame", "world"}, {"tool", "TOOL1"}, {"rotation", "Rz(A)Ry(B)Rx(C)"}, + {"linear_unit", "mm"}, {"angular_unit", "deg"}}; +} + +bool VisionService::isReady() const { return m_ready && !m_session.isEmpty(); } +bool VisionService::isBusy() const { return m_busy || !m_request.isEmpty() || !m_initializeId.isEmpty(); } +QString VisionService::sessionId() const { return m_session; } + +void VisionService::connectService() +{ + if (m_connecting || m_socket->state() == QLocalSocket::ConnectedState) + return; + m_shuttingDown = false; + m_connecting = true; + m_connectElapsed.start(); + m_connectTimer->start(); + connectAttempt(); +} + +void VisionService::disconnectService() +{ + if (m_productionActive) { + emit logMessage("请先停止生产,再断开视觉控制连接"); + return; + } + if (!m_request.isEmpty()) cancel(m_request.value("request_id").toString()); + m_connecting = false; + m_connectTimer->stop(); + m_pollTimer->stop(); + m_socket->disconnectFromServer(); + if (m_socket->state() == QLocalSocket::UnconnectedState) + failConnection("视觉控制连接已断开,可在视觉窗口手动调试"); +} + +void VisionService::startService() +{ + if (m_process->state() != QProcess::NotRunning || m_connecting + || m_socket->state() == QLocalSocket::ConnectedState) + return; + const QFileInfo executable(m_config.executablePath); + if (!executable.isFile()) { + emit logMessage("请在 config.ini 配置有效的 VisionGuide executablePath"); + return; + } + QProcessEnvironment environment = QProcessEnvironment::systemEnvironment(); + environment.remove("QT_PLUGIN_PATH"); + environment.remove("QT_QPA_PLATFORM_PLUGIN_PATH"); + environment.remove("QML2_IMPORT_PATH"); + environment.remove("QML_IMPORT_PATH"); + QStringList cleanPath; + for (const QString &entry : environment.value("PATH").split(';', QString::SkipEmptyParts)) { + // Qt kits injected by Creator must not override the MSVC runtime beside the child. + if (!QFileInfo(QDir(entry).filePath("Qt5Core.dll")).exists() + && !entry.contains("mingw", Qt::CaseInsensitive)) + cleanPath.append(entry); + } + cleanPath.prepend(executable.absolutePath()); + environment.insert("PATH", cleanPath.join(';')); + m_process->setProcessEnvironment(environment); + m_process->setWorkingDirectory(executable.absolutePath()); + m_process->start(executable.absoluteFilePath(), + QStringList() << "--ipc-name" << m_config.ipcName << "--background"); + connectService(); +} + +void VisionService::connectAttempt() +{ + if (m_connectElapsed.elapsed() >= m_config.startupTimeoutMs) { + failConnection("连接视觉进程超时,请核对程序路径和 IPC 名称"); + return; + } + if (m_socket->state() == QLocalSocket::UnconnectedState) + m_socket->connectToServer(m_config.ipcName); +} + +QString VisionService::sendCommand(const QString &type, QJsonObject payload) +{ + const QString id = newId(); + payload.insert("protocol_version", 1); + payload.insert("type", type); + payload.insert("request_id", id); + payload.insert("server_session_id", m_session); + m_commands.insert(id, type); + if (!sendMessage(payload)) { + m_commands.remove(id); + return QString(); + } + return id; +} + +bool VisionService::sendMessage(const QJsonObject &message) +{ + if (m_socket->state() != QLocalSocket::ConnectedState) + return false; + const QByteArray payload = QJsonDocument(message).toJson(QJsonDocument::Compact); + if (payload.isEmpty() || payload.size() > int(MaxMessageSize)) + return false; + QByteArray frame(4, 0); + qToBigEndian(quint32(payload.size()), reinterpret_cast(frame.data())); + frame.append(payload); + return m_socket->write(frame) == frame.size(); +} + +void VisionService::readMessages() +{ + m_buffer.append(m_socket->readAll()); + while (m_buffer.size() >= 4) { + const quint32 size = qFromBigEndian(reinterpret_cast(m_buffer.constData())); + if (size == 0 || size > MaxMessageSize) { + failConnection("视觉通信帧长度无效"); + return; + } + if (m_buffer.size() < int(size) + 4) + return; + QJsonParseError error; + const QJsonDocument document = QJsonDocument::fromJson(m_buffer.mid(4, int(size)), &error); + m_buffer.remove(0, int(size) + 4); + if (error.error != QJsonParseError::NoError || !document.isObject()) { + failConnection("视觉通信 JSON 无效"); + return; + } + handleMessage(document.object()); + if (m_socket->state() != QLocalSocket::ConnectedState) + return; + } +} + +void VisionService::handleMessage(const QJsonObject &message) +{ + const QString type = message.value("type").toString(); + const QString id = message.value("request_id").toString(); + const QString session = message.value("server_session_id").toString(); + const QString status = message.value("status").toString(); + if (message.value("protocol_version").toDouble() != 1 || !message.value("request_id").isString() + || session.isEmpty() || !message.value("ready").isBool() + || !message.value("resource_busy").isBool()) { + failConnection("视觉通信版本或公共字段无效"); + return; + } + if (type == "hello") { + if (id != m_helloId || m_helloId.isEmpty() || !m_session.isEmpty() || status != "ok") { + failConnection("视觉握手响应无效"); + return; + } + m_session = session; + m_serverProcessId = message.value("server_process_id").toString(); + m_commands.remove(id); + m_helloId.clear(); + m_connecting = false; + m_lastReply.restart(); + updateAvailability(message); + emit logMessage("视觉通信已连接,等待初始化/就绪"); + return; + } + // The server may publish its initial state immediately after accepting the socket. + // Only hello establishes the session; an earlier status must not establish it. + if (m_session.isEmpty() && type == "status" && id.isEmpty()) + return; + if (session != m_session || m_session.isEmpty()) { + failConnection("视觉进程会话已变化,本次结果不可用"); + return; + } + if (type == "measure") { + if (m_request.isEmpty() || id != m_request.value("request_id").toString()) + return; // Cancelled, timed-out and previous-cycle results cannot become current. + if (status == "accepted") { + m_busy = true; + publishAvailability(); + return; + } + if (status != "ok" && status != "error" && status != "cancelled" && status != "timeout") { + failConnection("未知的视觉测量终态"); + return; + } + m_lastReply.restart(); + updateAvailability(message); + QString error; + if (status == "ok" && !validateResult(message, &error)) { + failMeasurement("INVALID_RESULT", error); + return; + } + finishMeasurement(message); + return; + } + if (type == "status") { + if (!id.isEmpty()) return; + } else { + if (!m_commands.contains(id) || m_commands.value(id) != type) + return; + if (status != "accepted") m_commands.remove(id); + } + m_lastReply.restart(); + updateAvailability(message); + if (type == "initialize" && id == m_initializeId && status != "accepted") { + m_initializeTimer->stop(); + m_initializeId.clear(); + emit logMessage(status == "ok" ? "视觉初始化完成" : "视觉初始化失败:" + message.value("message").toString()); + publishAvailability(); + } + if (status == "error") + emit logMessage(message.value("error_code").toString() + ":" + message.value("message").toString()); +} + +void VisionService::initialize() +{ + if (m_session.isEmpty() || isBusy() || m_productionActive) { + emit logMessage("初始化需要已连接、资源空闲且生产已停止"); + return; + } + m_ready = false; + m_initializeId = sendCommand("initialize"); + if (!m_initializeId.isEmpty()) m_initializeTimer->start(m_config.initializeTimeoutMs); + publishAvailability(); +} + +void VisionService::measure(const QJsonObject &request) { requestMeasurement(request, false); } +void VisionService::diagnose(const QJsonObject &request) { requestMeasurement(request, true); } + +void VisionService::requestMeasurement(QJsonObject request, bool diagnostic) +{ + const QString id = request.value("request_id").toString(); + if (!id.isEmpty() && (m_completedRequests.contains(id) + || (!m_request.isEmpty() && m_request.value("request_id").toString() == id))) { + emit logMessage("忽略重复的视觉请求编号:" + id); + return; + } + QString error; + const QJsonObject context = request.value("context").toObject(); + const double tray = context.value("tray_no").toDouble(); + if (id.isEmpty() || m_cancelledRequests.contains(id)) error = "请求编号为空或已取消"; + else if (!isReady() || isBusy()) error = "视觉未就绪或仍在处理上一任务"; + else if (diagnostic == m_productionActive) error = "诊断与自动生产不可同时执行"; + else if (!diagnostic && request.value("server_session_id").toString() != m_session) error = "生产请求会话已失效"; + else if (!validPose(request.value("robot_pose"))) error = "拍照位姿须为6个有限数值"; + else if (context.value("workpiece_id").toString().isEmpty() + || context.value("task_id").toString().isEmpty() + || context.value("generation").toString().isEmpty() + || tray < 1 || tray > 99 || std::floor(tray) != tray) error = "工件/任务/料盘上下文无效"; + else if (request.value("parameters").toObject() != standardParameters() + || request.value("convention").toObject() != standardConvention()) error = "测量参数或机器人坐标约定不匹配"; + else if (!request.value("require_robot_pose").toBool() + || request.value("pose_source").toString() != (diagnostic ? "diagnostic" : "plc_r40") + || !QDateTime::fromString(request.value("pose_read_at").toString(), Qt::ISODate).isValid()) error = "拍照位姿来源或采集时间无效"; + if (!error.isEmpty()) { + if (!id.isEmpty()) m_completedRequests.insert(id); + QJsonObject result = request; + result.insert("type", "measure"); + result.insert("status", "error"); + result.insert("error_code", "REQUEST_REJECTED"); + result.insert("message", error); + result.insert("robot_valid", false); + emit measurementFinished(result); + emit logMessage(error); + return; + } + request.insert("protocol_version", 1); + request.insert("type", "measure"); + request.insert("server_session_id", m_session); + m_request = request; + m_diagnostic = diagnostic; + m_busy = true; + emit requestStarted(request); + publishAvailability(); + if (!sendMessage(request)) { + failConnection("发送视觉测量请求失败"); + return; + } + m_requestTimer->start(m_config.requestTimeoutMs); +} + +bool VisionService::validateResult(const QJsonObject &result, QString *error) const +{ + const QDateTime begin = QDateTime::fromString(result.value("capture_begin").toString(), Qt::ISODate); + const QDateTime end = QDateTime::fromString(result.value("capture_end").toString(), Qt::ISODate); + const bool valid = result.value("context").toObject() == m_request.value("context").toObject() + && result.value("camera_valid").isBool() && result.value("camera_valid").toBool() + && result.value("robot_valid").isBool() && result.value("robot_valid").toBool() + && validPose(result.value("camera_pose")) && validPose(result.value("robot_pose")) + && result.value("source").toString() == "LEFT" + && result.value("pose_type").toString() == "model_origin" + && result.value("parameters").toObject() == m_request.value("parameters").toObject() + && result.value("convention").toObject() == m_request.value("convention").toObject() + && result.value("score").isDouble() && std::isfinite(result.value("score").toDouble()) + && result.value("score").toDouble() >= 0.70 && result.value("score").toDouble() <= 1.0 + && !result.value("calibration_fingerprint").toString().isEmpty() + && !result.value("run_id").toString().isEmpty() + && begin.isValid() && end.isValid() && begin <= end + && nonnegativeInteger(result.value("measure_elapsed_ms")) + && nonnegativeInteger(result.value("grasp_elapsed_ms")); + if (!valid && error) *error = "视觉结果坐标、上下文、参数或有效性校验失败,禁止提交机器人"; + return valid; +} + +void VisionService::cancel(const QString &requestId) +{ + if (requestId.isEmpty()) return; + m_cancelledRequests.insert(requestId); + if (m_request.value("request_id").toString() != requestId) return; + sendCommand("cancel", QJsonObject{{"target_request_id", requestId}}); + failMeasurement("CANCELLED", "本次视觉结果已取消,等待底层资源释放"); +} + +void VisionService::setProductionActive(bool active) +{ + m_productionActive = active; + if (!m_request.isEmpty() && ((active && m_diagnostic) || (!active && !m_diagnostic))) + cancel(m_request.value("request_id").toString()); + publishAvailability(); +} + +void VisionService::showWindow() +{ + if (!m_session.isEmpty()) sendCommand("show_window"); +} + +void VisionService::shutdown() +{ + if (m_shuttingDown) return; + m_shuttingDown = true; + if (!m_request.isEmpty()) cancel(m_request.value("request_id").toString()); + if (m_process->state() != QProcess::NotRunning + && m_serverProcessId == QString::number(m_process->processId()) && !m_session.isEmpty()) { + sendCommand("shutdown"); + m_socket->flush(); + QTimer::singleShot(3000, m_process, [this]() { + if (m_process->state() != QProcess::NotRunning) m_process->kill(); + }); + } + m_connecting = false; + m_connectTimer->stop(); + m_pollTimer->stop(); + m_initializeTimer->stop(); + m_socket->disconnectFromServer(); + m_ready = false; + m_session.clear(); + publishAvailability(); +} + +void VisionService::failMeasurement(const QString &code, const QString &message) +{ + if (m_request.isEmpty()) return; + QJsonObject result = m_request; + result.insert("status", "error"); + result.insert("error_code", code); + result.insert("message", message); + result.insert("camera_valid", false); + result.insert("robot_valid", false); + result.insert("resource_busy", m_busy); + finishMeasurement(result); +} + +void VisionService::finishMeasurement(const QJsonObject &result) +{ + m_requestTimer->stop(); + m_completedRequests.insert(result.value("request_id").toString()); + m_request = QJsonObject(); + emit measurementFinished(result); + publishAvailability(); +} + +void VisionService::failConnection(const QString &message) +{ + const bool hadConnection = m_connecting || !m_session.isEmpty() || !m_request.isEmpty(); + m_connecting = false; + m_connectTimer->stop(); + m_pollTimer->stop(); + m_initializeTimer->stop(); + m_ready = false; + m_busy = false; + m_initializeId.clear(); + m_commands.clear(); + m_session.clear(); + m_serverProcessId.clear(); + m_buffer.clear(); + failMeasurement("DISCONNECTED", message); + m_socket->abort(); + publishAvailability(); + if (hadConnection && !m_shuttingDown) emit logMessage(message); +} + +void VisionService::updateAvailability(const QJsonObject &message) +{ + m_ready = message.value("ready").toBool(); + m_busy = message.value("resource_busy").toBool(); + emit statusChanged(message); + publishAvailability(); +} + +void VisionService::publishAvailability() +{ + emit availabilityChanged(isReady(), isBusy(), m_session); +} diff --git a/services/visionservice.h b/services/visionservice.h new file mode 100644 index 0000000..a7447ab --- /dev/null +++ b/services/visionservice.h @@ -0,0 +1,86 @@ +#ifndef VISIONSERVICE_H +#define VISIONSERVICE_H + +#include "../config/configmanager.h" +#include +#include +#include +#include +#include + +class QLocalSocket; +class QProcess; +class QTimer; + +class VisionService : public QObject +{ + Q_OBJECT +public: + explicit VisionService(const VisionConfig &config, QObject *parent = nullptr); + ~VisionService() override; + static QJsonObject standardParameters(); + static QJsonObject standardConvention(); + bool isReady() const; + bool isBusy() const; + QString sessionId() const; + +public slots: + void connectService(); + void disconnectService(); + void startService(); + void initialize(); + void measure(const QJsonObject &request); + void diagnose(const QJsonObject &request); + void cancel(const QString &requestId); + void setProductionActive(bool active); + void showWindow(); + void shutdown(); + +signals: + void measurementFinished(const QJsonObject &result); + void requestStarted(const QJsonObject &request); + void statusChanged(const QJsonObject &status); + void availabilityChanged(bool ready, bool busy, const QString &session); + void logMessage(const QString &message); + +private: + void connectAttempt(); + void readMessages(); + void handleMessage(const QJsonObject &message); + void requestMeasurement(QJsonObject request, bool diagnostic); + QString sendCommand(const QString &type, QJsonObject payload = QJsonObject()); + bool sendMessage(const QJsonObject &message); + void failConnection(const QString &message); + void failMeasurement(const QString &code, const QString &message); + void finishMeasurement(const QJsonObject &result); + void updateAvailability(const QJsonObject &message); + bool validateResult(const QJsonObject &result, QString *error) const; + void publishAvailability(); + + VisionConfig m_config; + QLocalSocket *m_socket; + QProcess *m_process; + QTimer *m_connectTimer; + QTimer *m_pollTimer; + QTimer *m_requestTimer; + QTimer *m_initializeTimer; + QElapsedTimer m_connectElapsed; + QElapsedTimer m_lastReply; + QByteArray m_buffer; + QString m_session; + QString m_serverProcessId; + QString m_helloId; + QString m_initializeId; + QHash m_commands; + QSet m_cancelledRequests; + QSet m_completedRequests; + QJsonObject m_request; + bool m_ready; + bool m_busy; + bool m_productionActive; + bool m_diagnostic; + bool m_connecting; + bool m_shuttingDown; +}; + +#endif // VISIONSERVICE_H diff --git a/ssp.pro b/ssp.pro index e85e5ba..846d4e5 100644 --- a/ssp.pro +++ b/ssp.pro @@ -1,4 +1,4 @@ -QT += core gui sql serialbus +QT += core gui sql serialbus network greaterThan(QT_MAJOR_VERSION, 4): QT += widgets @@ -31,6 +31,7 @@ SOURCES += \ pages/rackpage.cpp \ pages/squaretraybutton.cpp \ pages/uihelpers.cpp \ + pages/visionpage.cpp \ repositories/logrepository.cpp \ repositories/orderrepository.cpp \ repositories/productionrepository.cpp \ @@ -45,6 +46,7 @@ SOURCES += \ services/qualityservice.cpp \ services/trayservice.cpp \ services/workpieceservice.cpp \ + services/visionservice.cpp \ widget.cpp HEADERS += \ @@ -59,6 +61,7 @@ HEADERS += \ models/qualityrecord.h \ models/tray.h \ models/workpiece.h \ + models/visionresult.h \ pages/dashboardpage.h \ pages/devicepage.h \ pages/logpage.h \ @@ -67,6 +70,7 @@ HEADERS += \ pages/rackpage.h \ pages/squaretraybutton.h \ pages/uihelpers.h \ + pages/visionpage.h \ repositories/logrepository.h \ repositories/orderrepository.h \ repositories/productionrepository.h \ @@ -81,6 +85,7 @@ HEADERS += \ services/qualityservice.h \ services/trayservice.h \ services/workpieceservice.h \ + services/visionservice.h \ widget.h FORMS += \ diff --git a/ssp.pro.user b/ssp.pro.user index f5a87cc..ad76d57 100644 --- a/ssp.pro.user +++ b/ssp.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId @@ -63,6 +63,249 @@ ProjectExplorer.Project.Target.0 + + Desktop Qt 5.14.1 MinGW 64-bit + Desktop Qt 5.14.1 MinGW 64-bit + qt.qt5.5141.win64_mingw73_kit + 0 + 0 + 0 + + E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Debug + + + true + QtProjectManager.QMakeBuildStep + true + + false + false + false + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Release + + + true + QtProjectManager.QMakeBuildStep + false + + false + false + true + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + + + E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Profile + + + true + QtProjectManager.QMakeBuildStep + true + + false + true + true + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Build + Build + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Clean + Clean + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + + 3 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + dwarf + + cpu-cycles + + + 250 + + -e + cpu-cycles + --call-graph + dwarf,4096 + -F + 250 + + -F + true + 4096 + false + false + 1000 + + true + + false + false + false + false + true + 0.01 + 10 + true + kcachegrind + 1 + 25 + + 1 + true + false + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + Qt4ProjectManager.Qt4RunConfiguration:E:/QTCode/ssp/ssp/ssp.pro + E:/QTCode/ssp/ssp/ssp.pro + + false + + false + true + true + false + false + true + + E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Debug + + 1 + + + + ProjectExplorer.Project.Target.1 Desktop Qt 5.14.1 MinGW 32-bit Desktop Qt 5.14.1 MinGW 32-bit @@ -304,249 +547,6 @@ 1 - - ProjectExplorer.Project.Target.1 - - Desktop Qt 5.14.1 MinGW 64-bit - Desktop Qt 5.14.1 MinGW 64-bit - qt.qt5.5141.win64_mingw73_kit - 0 - 0 - 0 - - E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Debug - - - true - QtProjectManager.QMakeBuildStep - true - - false - false - false - - - true - Qt4ProjectManager.MakeStep - - false - - - false - - 2 - Build - Build - ProjectExplorer.BuildSteps.Build - - - - true - Qt4ProjectManager.MakeStep - - true - clean - - false - - 1 - Clean - Clean - ProjectExplorer.BuildSteps.Clean - - 2 - false - - Debug - Qt4ProjectManager.Qt4BuildConfiguration - 2 - - - E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Release - - - true - QtProjectManager.QMakeBuildStep - false - - false - false - true - - - true - Qt4ProjectManager.MakeStep - - false - - - false - - 2 - Build - Build - ProjectExplorer.BuildSteps.Build - - - - true - Qt4ProjectManager.MakeStep - - true - clean - - false - - 1 - Clean - Clean - ProjectExplorer.BuildSteps.Clean - - 2 - false - - Release - Qt4ProjectManager.Qt4BuildConfiguration - 0 - - - E:/QTCode/ssp/build-ssp-Desktop_Qt_5_14_1_MinGW_64_bit-Profile - - - true - QtProjectManager.QMakeBuildStep - true - - false - true - true - - - true - Qt4ProjectManager.MakeStep - - false - - - false - - 2 - Build - Build - ProjectExplorer.BuildSteps.Build - - - - true - Qt4ProjectManager.MakeStep - - true - clean - - false - - 1 - Clean - Clean - ProjectExplorer.BuildSteps.Clean - - 2 - false - - Profile - Qt4ProjectManager.Qt4BuildConfiguration - 0 - - 3 - - - 0 - Deploy - Deploy - ProjectExplorer.BuildSteps.Deploy - - 1 - ProjectExplorer.DefaultDeployConfiguration - - 1 - - - dwarf - - cpu-cycles - - - 250 - - -e - cpu-cycles - --call-graph - dwarf,4096 - -F - 250 - - -F - true - 4096 - false - false - 1000 - - true - - false - false - false - false - true - 0.01 - 10 - true - kcachegrind - 1 - 25 - - 1 - true - false - true - valgrind - - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 11 - 12 - 13 - 14 - - 2 - - Qt4ProjectManager.Qt4RunConfiguration:E:/QTCode/ssp/ssp/ssp.pro - E:/QTCode/ssp/ssp/ssp.pro - - false - - false - true - true - false - false - true - - - - 1 - - ProjectExplorer.Project.TargetCount 2 diff --git a/widget.cpp b/widget.cpp index 4974d93..90aa5c5 100644 --- a/widget.cpp +++ b/widget.cpp @@ -8,7 +8,10 @@ #include "pages/qualitypage.h" #include "pages/rackpage.h" #include "pages/uihelpers.h" +#include "pages/visionpage.h" #include "services/logservice.h" +#include "services/visionservice.h" +#include "config/configmanager.h" #include #include @@ -26,6 +29,8 @@ Widget::Widget(QWidget *parent) , dashboardPage(nullptr) , logPage(nullptr) , qualityPage(nullptr) + , visionService(nullptr) + , visionPage(nullptr) , systemStateLabel(nullptr) , currentOrderLabel(nullptr) , currentWorkpieceLabel(nullptr) @@ -51,6 +56,7 @@ Widget::Widget(QWidget *parent) Widget::~Widget() { + if (visionService) visionService->shutdown(); delete ui; } @@ -113,7 +119,7 @@ void Widget::setupMainArea(QVBoxLayout *rootLayout) navList = new QListWidget; navList->setFixedWidth(170); navList->addItems(QStringList() << "控制面板" << "订单管理" << "料架/托盘" - << "设备状态" << "日志" << "质量管理"); + << "设备状态" << "日志" << "质量管理" << "视觉引导"); navList->setCurrentRow(0); bodyLayout->addWidget(navList); @@ -123,6 +129,11 @@ void Widget::setupMainArea(QVBoxLayout *rootLayout) DevicePage *devicePage = new DevicePage(this); logPage = new LogPage(this); qualityPage = new QualityPage(this); + visionService = new VisionService(ConfigManager::instance().visionConfig(), this); + visionPage = new VisionPage(visionService, this); + connect(dashboardPage, &DashboardPage::visionCycleChanged, visionPage, &VisionPage::updateCycle); + connect(dashboardPage, &DashboardPage::visionProductionActiveChanged, visionPage, &VisionPage::setProductionActive); + dashboardPage->attachVisionService(visionService); pageStack = new QStackedWidget; pageStack->addWidget(dashboardPage); @@ -131,6 +142,7 @@ void Widget::setupMainArea(QVBoxLayout *rootLayout) pageStack->addWidget(devicePage); pageStack->addWidget(logPage); pageStack->addWidget(qualityPage); + pageStack->addWidget(visionPage); bodyLayout->addWidget(pageStack, 1); rootLayout->addLayout(bodyLayout, 1); @@ -169,6 +181,9 @@ void Widget::setupMainArea(QVBoxLayout *rootLayout) connect(dashboardPage, &DashboardPage::logRequested, this, &Widget::appendLog); connect(orderPage, &OrderPage::logRequested, this, &Widget::appendLog); connect(rackPage, &RackPage::logRequested, this, &Widget::appendLog); + connect(visionService, &VisionService::logMessage, this, [this](const QString &message) { + appendLog("生产日志", "视觉引导", "通信/测量", message, "记录"); + }); } void Widget::appendLog(const QString &type, const QString &module, const QString &action, diff --git a/widget.h b/widget.h index a987ef0..7c4af30 100644 --- a/widget.h +++ b/widget.h @@ -14,6 +14,8 @@ class LogPage; class QualityPage; class QStackedWidget; class QVBoxLayout; +class VisionPage; +class VisionService; class Widget : public QWidget { @@ -36,6 +38,8 @@ private: DashboardPage *dashboardPage; LogPage *logPage; QualityPage *qualityPage; + VisionService *visionService; + VisionPage *visionPage; QLabel *systemStateLabel; QLabel *currentOrderLabel; QLabel *currentWorkpieceLabel;