#include "productionservice.h" #include "../config/configmanager.h" #include "../repositories/productionrepository.h" #include "orderservice.h" #include "trayservice.h" #include "workpieceservice.h" #include "visionservice.h" #include #include #include #include #include #include #include #include namespace { const int ProductionTickIntervalMs = 50; } ProductionService &ProductionService::instance() { static ProductionService service; return service; } ProductionService::ProductionService(QObject *parent) : QObject(parent) , m_timer(new QTimer(this)) , m_deviceService(new DeviceService(this)) , m_state(Idle) , m_timeoutState(Idle) , m_runId(0) , m_orderId(0) , m_deviceStatusValid(false) , m_recoveryRetryCount(0) , m_processElapsedMs(0) , m_currentTrayNo(0) , m_currentSlotNo(0) , m_frontRawResult(0) , m_actionPending(false) , m_actionStarting(false) , m_actionPollPending(false) , m_actionCompleted(false) , m_actionCancelRequested(false) , m_inspectionStatusPending(false) , m_inspectionStatusReady(false) , m_starting(false) , m_plcStarted(false) , m_tickRunning(false) , m_pendingAction(DeviceService::RackPick) , m_stopRequested(false) , m_externalStopRequested(nullptr) , m_shutdownRequested(false) { connect(m_timer, &QTimer::timeout, this, &ProductionService::tick); connect(m_deviceService, &DeviceService::statusChanged, this, &ProductionService::onDeviceStatusChanged); connect(m_deviceService, &DeviceService::communicationError, this, &ProductionService::onCommunicationError); m_deviceService->startPolling(); } 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); } QString ProductionService::stateNameForState(State state) const { switch (state) { case Idle: return "IDLE"; case Preparing: return "PREPARING"; case WaitingDeviceReady: return "WAITING_DEVICE_READY"; case RackPicking: return "RACK_PICKING"; case FrontLoading: return "FRONT_LOADING"; case Loading: return "LOADING"; case FrontChecking: return "FRONT_CHECKING"; case FrontUnloading: return "FRONT_UNLOADING"; case Flipping: return "FLIPPING"; case BackLoading: return "BACK_LOADING"; case BackChecking: return "BACK_CHECKING"; case BackUnloading: return "BACK_UNLOADING"; case RackPlacing: return "RACK_PLACING"; case Judging: return "JUDGING"; case Unloading: return "UNLOADING"; case Paused: return "PAUSED"; case Error: return "ERROR"; case Completed: return "COMPLETED"; case TimeoutWarning: return "TIMEOUT_WARNING"; case TimeoutPaused: return "TIMEOUT_PAUSED"; case RecoveryChecking: return "RECOVERY_CHECKING"; case ManualConfirm: return "MANUAL_CONFIRM"; case Retrying: return "RETRYING"; case Terminating: return "TERMINATING"; } return "UNKNOWN"; } int ProductionService::orderId() const { return m_orderId; } int ProductionService::currentTrayNo() const { return m_currentTrayNo; } int ProductionService::currentSlotNo() const { return m_currentSlotNo; } QString ProductionService::inspectionMode() const { return m_inspectionMode; } Workpiece ProductionService::currentWorkpiece() const { return m_currentWorkpiece; } 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"; } return false; } if (m_state != Idle && m_state != Completed) { if (error) { *error = "Production service is already active"; } return false; } Order order; if (!OrderService::instance().findOrder(orderId, &order, error)) { return false; } if (order.status != "NOT_START") { if (error) { *error = "Only not-started orders can start production"; } return false; } m_inspectionMode = order.inspectionMode; m_currentTrayNo = 0; m_currentSlotNo = 0; m_frontRawResult = 0; m_actionPending = false; m_actionStarting = false; m_actionPollPending = false; m_actionCompleted = false; m_actionError.clear(); m_frontResultState.clear(); m_stopRequested.store(false); if (m_externalPauseRequested) m_externalPauseRequested->store(false); if (m_externalStopRequested) { m_externalStopRequested->store(false); } m_orderId = orderId; m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_deviceStatusValid = false; m_recoveryRetryCount = 0; m_lastError.clear(); m_starting = true; m_plcStarted = false; QString persistenceError; m_runId = ProductionRepository().createRun( m_orderId, "PREPARING", "PREPARING", order.inspectionMode, order.startTrayNo, order.startSlotNo, order.planNum, &persistenceError); if (m_runId <= 0) { m_orderId = 0; m_starting = false; if (error) { *error = "Failed to create production run: " + persistenceError; } return false; } setState(Preparing); m_deviceService->startPolling(); const int interval = ProductionTickIntervalMs; m_heartbeatTimer.restart(); m_timer->start(interval); m_deviceService->requestStatus( [this](bool success, const DeviceStatus &, const QString &statusError) { if (!success) { fail(statusError); return; } if (stopRequested()) { return; } QString safetyError; if (!checkRecoverySafety(&safetyError)) { fail(safetyError); return; } m_deviceService->setInspectionMode( m_inspectionMode, [this](bool modeSuccess, const QString &modeError) { if (!modeSuccess) { fail(modeError); return; } if (stopRequested()) { return; } m_deviceService->start( [this](bool startSuccess, const QString &startError) { if (!startSuccess) { fail(startError); return; } if (stopRequested()) { return; } m_plcStarted = true; QString orderError; if (!OrderService::instance().startOrder( m_orderId, &orderError)) { m_deviceService->pause( [](bool, const QString &) {}); fail(orderError); return; } m_starting = false; tick(); }); }); }); return true; } bool ProductionService::pause(QString *error) { if (!isActive()) { if (error) { *error = "Production service is not active"; } return false; } if (m_visionStage != VisionStage::Idle) { invalidateVision("已请求暂停生产"); m_timer->stop(); } cancelPendingProductionAction( [this](bool canceled, const QString &cancelError) { if (!canceled) { emit productionError(cancelError); return; } m_deviceService->pause( [this](bool paused, const QString &pauseError) { if (!paused) { emit productionError(pauseError); return; } QString orderError; if (!OrderService::instance().pauseOrder( m_orderId, &orderError)) { emit productionError(orderError); return; } pauseProcessTimer(); m_timer->stop(); setState(m_visionNeedsReconcile ? ManualConfirm : Paused); if (m_visionNeedsReconcile) emit timeoutRecoveryRequired("VISION", "视觉流程已中断,请核对 PLC 和机器人后恢复"); emitProcessElapsed(); }); }); return true; } 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"; } return false; } if (!checkRecoverySafety(error)) { return false; } if (m_externalPauseRequested) m_externalPauseRequested->store(false); m_deviceService->setInspectionMode( m_inspectionMode, [this](bool modeSuccess, const QString &modeError) { if (!modeSuccess) { emit productionError(modeError); return; } m_deviceService->start( [this](bool startSuccess, const QString &startError) { if (!startSuccess) { emit productionError(startError); return; } QString orderError; if (!OrderService::instance().resumeOrder( m_orderId, &orderError)) { emit productionError(orderError); return; } resumeProcessTimer(); State resumeState = Preparing; if (m_currentWorkpiece.id > 0) { resumeState = stateForProcessStep( m_currentWorkpiece.processStep); if (resumeState == Idle) { resumeState = WaitingDeviceReady; } } setState(resumeState); m_timer->start(ProductionTickIntervalMs); }); }); return true; } bool ProductionService::stop(QString *error) { if (m_state == Terminating) { return true; } if (m_state == Idle || m_state == Completed) { if (error) { *error = "Production service is not running"; } return false; } invalidateVision("操作员已终止生产"); m_lastError = "Production stopped by operator"; m_timer->stop(); setState(Terminating); auto failTermination = [this](const QString &terminationError) { m_lastError = terminationError.isEmpty() ? "PLC termination cleanup failed" : terminationError; m_stopRequested.store(false); if (m_externalStopRequested) { m_externalStopRequested->store(false); } setState(Error); persistAlarm("TERMINATION_FAILED", m_lastError); emit productionError(m_lastError); emit alarmRaised("TERMINATION_FAILED", m_lastError); finishShutdown(false, m_lastError); }; m_deviceService->terminate( [this, failTermination](bool cleaned, const QString &cleanupError) { if (!cleaned) { failTermination(cleanupError); return; } QString orderError; Order order; if (!OrderService::instance().findOrder( m_orderId, &order, &orderError)) { failTermination(orderError); return; } if (order.status == "RUNNING" && !OrderService::instance().pauseOrder( m_orderId, &orderError)) { failTermination(orderError); return; } if ((order.status == "RUNNING" || order.status == "PAUSED") && !OrderService::instance().cancelOrder( m_orderId, &orderError)) { failTermination(orderError); return; } QString persistenceError; if (m_runId > 0 && !ProductionRepository().finishRun( m_runId, "STOPPED", m_lastError, &persistenceError)) { failTermination(persistenceError); return; } persistRecoveryAction("STOP", m_lastError); setState(Idle); m_runId = 0; m_orderId = 0; m_currentWorkpiece = Workpiece(); m_starting = false; m_plcStarted = false; clearProcessTimer(); emit currentWorkpieceChanged(0, QString()); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(0, 0); m_stopRequested.store(false); if (m_externalStopRequested) { m_externalStopRequested->store(false); } finishShutdown(true, QString()); }); return true; } void ProductionService::shutdown(const DeviceService::OperationCallback &callback) { invalidateVision("生产线程正在退出"); if (m_shutdownRequested) { if (callback) { callback(false, "Production shutdown is already in progress"); } return; } m_shutdownRequested = true; m_shutdownCallback = callback; if (m_state != Idle && m_state != Completed) { QString stopError; if (!stop(&stopError)) { finishShutdown(false, stopError); } return; } m_timer->stop(); m_deviceService->terminate( [this](bool cleaned, const QString &cleanupError) { if (!cleaned) { finishShutdown(false, cleanupError); return; } setState(Idle); finishShutdown(true, QString()); }); } bool ProductionService::reset(QString *error) { if (m_visionNeedsReconcile) { if (error) *error = "请先人工核对视觉与 PLC 状态,再执行复位"; return false; } if (m_state != Error) { if (error) { *error = "Only failed production can be reset"; } return false; } cancelPendingProductionAction( [this](bool canceled, const QString &cancelError) { if (!canceled) { emit productionError(cancelError); return; } m_deviceService->reset( [this](bool resetSuccess, const QString &resetError) { if (!resetSuccess) { emit productionError(resetError); return; } m_deviceService->clearAlarm( [this](bool alarmCleared, const QString &alarmError) { if (!alarmCleared) { emit productionError(alarmError); return; } QString persistenceError; if (!ProductionRepository().clearActiveAlarms( QString(), "SYSTEM", &persistenceError)) { emit productionError(persistenceError); return; } QString workpieceError; if (m_currentWorkpiece.id > 0 && !WorkpieceService::instance().updateState( m_currentWorkpiece.id, "PENDING", "RECOVERY", &workpieceError)) { emit productionError(workpieceError); return; } m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_lastError.clear(); setState(Preparing); m_heartbeatTimer.restart(); m_timer->start(ProductionTickIntervalMs); }); }); }); return true; } bool ProductionService::clearAlarm(QString *error) { Q_UNUSED(error) m_deviceService->clearAlarm( [this](bool success, const QString &operationError) { if (!success) { emit productionError(operationError); return; } QString persistenceError; if (!ProductionRepository().clearActiveAlarms( QString(), "OPERATOR", &persistenceError)) { emit productionError(persistenceError); return; } }); return true; } bool ProductionService::restoreActiveRun(QString *error) { if (m_state != Idle) { return true; } ProductionRunSnapshot run; QString persistenceError; if (!ProductionRepository().findActiveRun(&run, &persistenceError)) { if (error) { *error = persistenceError; } return false; } if (run.id <= 0) { return true; } m_runId = run.id; m_orderId = run.orderId; m_inspectionMode = run.inspectionMode; m_recoveryRetryCount = run.recoveryRetryCount; m_lastError = run.lastError; if (run.currentWorkpieceId > 0) { QString workpieceError; if (!WorkpieceService::instance().findWorkpiece( run.currentWorkpieceId, &m_currentWorkpiece, &workpieceError)) { if (error) { *error = workpieceError; } return false; } emit currentWorkpieceChanged(m_currentWorkpiece.id, m_currentWorkpiece.barcode); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(m_currentTrayNo, m_currentSlotNo); startProcessTimer(m_currentWorkpiece.processStep); emitProcessElapsed(); } State persistedState = stateFromName(run.productionState); if (persistedState == Idle || persistedState == Completed || persistedState == Error) { persistedState = Preparing; } m_timeoutState = stateFromName(run.timeoutState); if (!isTimedState(m_timeoutState)) { 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(); emit timeoutRecoveryRequired( "STARTUP_RECOVERY", QString("Unfinished production run %1 requires recovery confirmation") .arg(run.id)); return true; } bool ProductionService::recover(QString *error) { if (m_visionNeedsReconcile) return recoverVision(error); if (m_state != TimeoutPaused && m_state != ManualConfirm) { if (error) { *error = "Production is not waiting for recovery"; } return false; } if (!checkRecoverySafety(error)) { return false; } QString operationError; if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } return false; } m_deviceService->setInspectionMode( m_inspectionMode, [this](bool modeSuccess, const QString &modeError) { if (!modeSuccess) { emit productionError(modeError); return; } m_deviceService->start( [this](bool startSuccess, const QString &startError) { if (!startSuccess) { emit productionError(startError); return; } persistRecoveryAction( "CONTINUE", QString("Continue recovery from %1").arg(stateName())); setState(RecoveryChecking); m_heartbeatTimer.restart(); m_timer->start(ProductionTickIntervalMs); tick(); }); }); return true; } bool ProductionService::retry(QString *error) { if (m_visionNeedsReconcile) { if (error) *error = "视觉结果不能自动重放,请使用人工核对恢复"; return false; } if (m_state != TimeoutPaused && m_state != ManualConfirm) { if (error) { *error = "Production is not waiting for a retry"; } return false; } if (!checkRecoverySafety(error)) { return false; } const ProductionConfig config = ConfigManager::instance().productionConfig(); if (m_recoveryRetryCount >= config.maxRecoveryRetries) { if (error) { *error = "Maximum timeout recovery retries reached"; } return false; } QString operationError; if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } return false; } const QString processStep = processStepForState(m_timeoutState); if (m_currentWorkpiece.id <= 0 || processStep.isEmpty()) { if (error) { *error = "Cannot retry without a current production step"; } return false; } m_deviceService->setInspectionMode( m_inspectionMode, [this, processStep](bool modeSuccess, const QString &modeError) { if (!modeSuccess) { emit productionError(modeError); return; } m_deviceService->start( [this, processStep](bool startSuccess, const QString &startError) { if (!startSuccess) { emit productionError(startError); return; } QString operationError; if (!updateCurrentProcessStep( processStep, &operationError, true)) { emit productionError(operationError); return; } ++m_recoveryRetryCount; persistRecoveryAction( "RETRY", QString("Retry production step %1").arg(processStep)); setState(Retrying); m_heartbeatTimer.restart(); m_timer->start(ProductionTickIntervalMs); }); }); return true; } 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"; } return false; } if (m_currentWorkpiece.id <= 0) { if (error) { *error = "No current workpiece can be marked as NG"; } return false; } if (!checkRecoverySafety(error)) { return false; } QString operationError; if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } return false; } m_deviceService->start( [this](bool startSuccess, const QString &startError) { if (!startSuccess) { emit productionError(startError); return; } const int durationMs = currentProcessElapsedMs(); const QString previousProcessStep = m_currentWorkpiece.processStep; QString operationError; if (!WorkpieceService::instance().completeWithInspection( m_currentWorkpiece.id, "NG", "COMPLETE", previousProcessStep, durationMs, -1, "NG", m_deviceStatus.currentStep, m_inspectionMode, "MANUAL", &operationError)) { emit productionError(operationError); return; } persistRecoveryAction( "MARK_NG", QString("Current workpiece %1 was manually marked as NG") .arg(m_currentWorkpiece.barcode)); m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_recoveryRetryCount = 0; m_lastError.clear(); emit currentWorkpieceChanged(0, QString()); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(0, 0); setState(Preparing); m_heartbeatTimer.restart(); m_timer->start(ProductionTickIntervalMs); }); return true; } void ProductionService::setState(State state) { if (m_state == state) { return; } const QString previousStateName = stateName(); 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() ? processStepForState(m_timeoutState) : processStepForState(state); QString persistenceError; ProductionRepository repository; if (!repository.updateRun( m_runId, runStateForState(state), stateName(), processStep, m_currentWorkpiece.id, isTimedState(m_timeoutState) ? stateNameForState(m_timeoutState) : QString(), m_recoveryRetryCount, m_lastError, &persistenceError) || !repository.insertStateHistory( m_runId, m_orderId, m_currentWorkpiece.id, previousStateName, stateName(), processStep, state == RecoveryChecking || state == ManualConfirm || state == Retrying ? "RECOVERY" : "SYSTEM", QString(), QString(), &persistenceError)) { qWarning() << "Failed to persist production state:" << persistenceError; } } } bool ProductionService::claimNextWorkpiece(QString *error) { Workpiece workpiece; if (!WorkpieceService::instance().claimNextPending(m_orderId, &workpiece, error)) { return false; } if (workpiece.id <= 0) { return finishOrder(error); } m_currentWorkpiece = workpiece; m_recoveryRetryCount = 0; m_currentTrayNo = 0; m_currentSlotNo = workpiece.trayPos; QString trayError; const QList trays = TrayService::instance().listTrays(&trayError); if (!trayError.isEmpty()) { if (error) { *error = trayError; } return false; } for (int index = 0; index < trays.size(); ++index) { if (trays.at(index).id == workpiece.trayId) { m_currentTrayNo = index + 1; break; } } if (m_currentTrayNo <= 0 || m_currentSlotNo < 1 || m_currentSlotNo > 49) { if (error) { *error = "Current workpiece tray position cannot be mapped to PLC"; } return false; } QString persistenceError; const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; if (!ProductionRepository().startWorkpieceProcess( m_orderId, workpiece.id, workpiece.processStep, m_inspectionMode, m_deviceStatus.currentStep, source, &persistenceError)) { if (error) { *error = persistenceError; } return false; } startProcessTimer(workpiece.processStep); emit currentWorkpieceChanged(workpiece.id, workpiece.barcode); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(m_currentTrayNo, m_currentSlotNo); emitProcessElapsed(); setState(WaitingDeviceReady); return true; } bool ProductionService::updateCurrentProcessStep(const QString &processStep, QString *error, bool forceRestart) { if (m_currentWorkpiece.id <= 0) { if (error) { *error = "No current workpiece"; } return false; } const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; const int durationMs = currentProcessElapsedMs(); if (!WorkpieceService::instance().updateProcessStepWithRecord( m_currentWorkpiece.id, processStep, m_inspectionMode, m_deviceStatus.currentStep, source, durationMs, error, forceRestart)) { return false; } m_currentWorkpiece.processStep = processStep; startProcessTimer(processStep); emitProcessElapsed(); return true; } bool ProductionService::processProductionAction( DeviceService::ProductionAction action, bool *completed, QString *error) { if (!completed) { if (error) { *error = "Action completion pointer is null"; } return false; } *completed = false; if (ConfigManager::instance().simulationMode()) { *completed = true; 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; m_actionStarting = true; m_actionPollPending = false; m_actionCompleted = false; m_actionError.clear(); m_deviceService->beginProductionAction( action, m_currentTrayNo, m_currentSlotNo, [this](bool success, const QString &actionError) { m_actionStarting = false; if (!success) { m_actionError = actionError; } else if (m_visionStage == VisionStage::Armed && !m_visionSuspended) { setVisionStage(VisionStage::WaitRequest, "等待机器人到位后的拍照请求 851"); } tryDeferredActionCancel(); }); return true; } if (m_pendingAction != action) { if (error) { *error = "PLC production action does not match current state"; } return false; } if (!m_actionError.isEmpty()) { if (error) { *error = m_actionError; } return false; } if (m_actionStarting || m_actionPollPending) { 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; } m_actionPollPending = true; m_deviceService->pollProductionAction( [this](bool success, bool completed, const QString &actionError) { m_actionPollPending = false; if (!success) { m_actionError = actionError; return; } if (completed) { m_actionCompleted = true; } tryDeferredActionCancel(); }); return true; } void ProductionService::cancelPendingProductionAction( const DeviceService::OperationCallback &callback) { if (!m_actionPending) { if (callback) { callback(true, QString()); } return; } if (m_actionStarting || m_actionPollPending) { m_actionCancelRequested = true; m_deferredCancelCallback = callback; return; } m_deviceService->cancelProductionAction( [this, callback](bool success, const QString &error) { if (success) { m_actionPending = false; m_actionCompleted = false; m_actionError.clear(); m_actionCancelRequested = false; } if (callback) { callback(success, error); } }); } void ProductionService::tryDeferredActionCancel() { if (!m_actionCancelRequested || m_actionStarting || m_actionPollPending) { return; } m_actionCancelRequested = false; const DeviceService::OperationCallback callback = m_deferredCancelCallback; m_deferredCancelCallback = DeviceService::OperationCallback(); if (!m_actionPending) { if (callback) { callback(true, QString()); } return; } m_deviceService->cancelProductionAction( [this, callback](bool success, const QString &error) { if (success) { m_actionPending = false; m_actionCompleted = false; m_actionError.clear(); } if (callback) { callback(success, error); } }); } bool ProductionService::executeCurrentAction( DeviceService::ProductionAction action, const QString &nextProcessStep, State nextState, QString *error) { if (m_currentWorkpiece.id <= 0) { if (error) { *error = "No current workpiece"; } return false; } bool completed = false; if (!processProductionAction(action, &completed, error)) { return false; } if (!completed) { return false; } if (!updateCurrentProcessStep(nextProcessStep, error)) { return false; } setState(nextState); return true; } bool ProductionService::recordInspection(const QString &side, int rawResult, const QString &resultState, QString *error) { const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; return WorkpieceService::instance().recordInspection( m_currentWorkpiece.id, side, rawResult, resultState, m_deviceStatus.currentStep, m_inspectionMode, source, QString("%1 inspection result").arg(side), error); } QString ProductionService::resultStateForRawResult(int rawResult) const { const ProductionConfig config = ConfigManager::instance().productionConfig(); if (rawResult == config.okResult) { return "OK"; } if (rawResult == config.ngResult) { return "NG"; } if (rawResult == config.errorResult) { return "ERROR"; } return "UNKNOWN"; } void ProductionService::startProcessTimer(const QString &processStep) { m_currentProcessStep = processStep; m_processElapsedMs = 0; if (processStep.trimmed().isEmpty()) { m_processTimer.invalidate(); return; } m_processTimer.restart(); } void ProductionService::pauseProcessTimer() { if (m_processTimer.isValid()) { m_processElapsedMs += static_cast(m_processTimer.elapsed()); m_processTimer.invalidate(); } } void ProductionService::resumeProcessTimer() { if (m_currentProcessStep.trimmed().isEmpty()) { return; } m_processTimer.restart(); } void ProductionService::clearProcessTimer() { m_processTimer.invalidate(); m_processElapsedMs = 0; m_currentProcessStep.clear(); } int ProductionService::currentProcessElapsedMs() const { if (!m_processTimer.isValid()) { return m_processElapsedMs; } return m_processElapsedMs + static_cast(m_processTimer.elapsed()); } void ProductionService::emitProcessElapsed() { if (m_currentProcessStep.trimmed().isEmpty()) { return; } emit processElapsedChanged(m_currentProcessStep, currentProcessElapsedMs()); } bool ProductionService::ensureOrderRunning(QString *error) { Order order; if (!OrderService::instance().findOrder(m_orderId, &order, error)) { return false; } if (order.status == "RUNNING") { return true; } if (order.status == "PAUSED") { return OrderService::instance().resumeOrder(m_orderId, error); } if (error) { *error = QString("Order cannot resume from state: %1").arg(order.status); } return false; } bool ProductionService::checkRecoverySafety(QString *error) const { if (!m_deviceStatusValid) { if (error) { *error = "Device status is not available"; } return false; } if (!m_deviceStatus.plcConnected) { if (error) { *error = "PLC is disconnected"; } return false; } if (!m_deviceStatus.plcReady) { if (error) { *error = "PLC is not ready"; } return false; } if (!m_deviceStatus.robotReady) { if (error) { *error = "Robot is not ready"; } return false; } if (!m_deviceStatus.safetyDoorClosed) { if (error) { *error = "Safety door is open"; } return false; } if (m_deviceStatus.emergencyStop) { if (error) { *error = "Emergency stop is active"; } return false; } if (ConfigManager::instance().productionConfig().usePlcErrorCode && m_deviceStatus.errorCode > 0) { if (error) { *error = QString("PLC error code: %1").arg(m_deviceStatus.errorCode); } return false; } return true; } bool ProductionService::mapPlcStepToState(State *state, QString *processStep) const { if (!state || !processStep) { return false; } const ProductionConfig config = ConfigManager::instance().productionConfig(); if (m_deviceStatus.currentStep == config.loadStep) { *state = Loading; *processStep = "LOADING"; return true; } if (m_deviceStatus.currentStep == config.frontCheckStep) { *state = FrontChecking; *processStep = "FRONT_CHECKING"; return true; } if (m_deviceStatus.currentStep == config.backCheckStep) { *state = BackChecking; *processStep = "BACK_CHECKING"; return true; } if (m_deviceStatus.currentStep == config.unloadStep || m_deviceStatus.currentStep == config.cycleCompleteStep) { *state = Judging; *processStep = "JUDGING"; return true; } return false; } void ProductionService::persistRecoveryAction(const QString &action, const QString &message) { if (m_runId <= 0) { return; } QString persistenceError; if (!ProductionRepository().insertStateHistory( m_runId, m_orderId, m_currentWorkpiece.id, stateName(), stateName(), processStepForState(m_state), "RECOVERY", action, message, &persistenceError)) { qWarning() << "Failed to persist recovery action:" << persistenceError; } } bool ProductionService::finishCurrentWorkpiece(const QString &state, const QString &processStep, QString *error) { if (m_currentWorkpiece.id <= 0) { if (error) { *error = "No current workpiece"; } return false; } const QString previousProcessStep = m_currentWorkpiece.processStep; const int processDurationMs = currentProcessElapsedMs(); const int rawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult : static_cast(m_deviceStatus.checkResult); const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; if (!WorkpieceService::instance().completeWithInspection( m_currentWorkpiece.id, state, processStep, previousProcessStep, processDurationMs, rawResult, state, m_deviceStatus.currentStep, m_inspectionMode, source, error)) { return false; } clearProcessTimer(); m_currentWorkpiece = Workpiece(); emit currentWorkpieceChanged(0, QString()); emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); emit currentPositionChanged(0, 0); setState(Preparing); return true; } bool ProductionService::finishOrder(QString *error) { if (!OrderService::instance().completeOrder(m_orderId, error)) { return false; } QString persistenceError; if (m_runId > 0 && !ProductionRepository().finishRun( m_runId, "COMPLETED", QString(), &persistenceError)) { if (error) { *error = persistenceError; } return false; } m_timer->stop(); setState(Completed); emit productionFinished(m_orderId); return true; } void ProductionService::tick() { if (m_state == Terminating) { return; } if (m_tickRunning) { return; } QScopedValueRollback tickGuard(m_tickRunning, true); if (stopRequested() && m_state != Idle && m_state != Completed) { QString stopError; stop(&stopError); return; } if (!isActive()) { return; } if (m_starting) { return; } if (!m_deviceStatusValid) { return; } if (m_heartbeatTimer.isValid() && m_heartbeatTimer.elapsed() >= 1000) { QString heartbeatError; if (!ProductionRepository().heartbeatRun(m_runId, &heartbeatError)) { qWarning() << "Failed to persist production heartbeat:" << heartbeatError; } m_heartbeatTimer.restart(); } if (m_state == RecoveryChecking) { QString recoveryError; if (!checkRecoverySafety(&recoveryError)) { m_lastError = recoveryError; return; } } else { if (!m_deviceStatus.plcConnected) { fail("PLC is disconnected"); return; } if (m_deviceStatus.emergencyStop) { fail("Emergency stop is active"); return; } if (!m_deviceStatus.safetyDoorClosed) { fail("Safety door is open"); return; } if (ConfigManager::instance().productionConfig().usePlcErrorCode && m_deviceStatus.errorCode > 0) { fail(QString("PLC error code: %1").arg(m_deviceStatus.errorCode)); return; } } if (m_state == Preparing) { QString error; if (!claimNextWorkpiece(&error)) { fail(error); } return; } if (m_state == WaitingDeviceReady) { if (m_deviceStatus.plcReady && m_deviceStatus.robotReady) { QString error; State nextState = stateForProcessStep( m_currentWorkpiece.processStep); if (nextState == Idle || nextState == WaitingDeviceReady) { if (!updateCurrentProcessStep("RACK_PICKING", &error)) { fail(error); return; } nextState = RackPicking; } if (error.isEmpty()) { setState(nextState); } } emitProcessElapsed(); return; } if (m_state == RecoveryChecking || m_state == Retrying) { tickProduction(); } else if (ConfigManager::instance().simulationMode()) { tickSimulation(); } else { tickProduction(); } emitProcessElapsed(); } void ProductionService::tickSimulation() { const int stepMs = qMax(1, ConfigManager::instance() .productionConfig().simulationStepMs); if (m_stateTimer.elapsed() < stepMs) { return; } QString error; if (!processProductionStep(m_state, &error) && !error.isEmpty()) { fail(error); } } void ProductionService::tickProduction() { if (m_state == RecoveryChecking) { QString error; if (!recoverFromPlcStep(&error) && !error.isEmpty()) { fail(error); } return; } if (m_state == Retrying) { setState(m_timeoutState); return; } QString error; if (!processProductionStep(m_state, &error) && !error.isEmpty()) { fail(error); } } bool ProductionService::processProductionStep(State state, QString *error) { switch (state) { case RackPicking: return executeCurrentAction(DeviceService::RackPick, "FRONT_LOADING", FrontLoading, error); case FrontLoading: return executeCurrentAction(DeviceService::FrontLoad, "FRONT_CHECKING", FrontChecking, error); case FrontChecking: { bool completed = false; if (!processProductionAction( DeviceService::Inspect, &completed, error)) { return false; } if (!completed) { return false; } if (!ConfigManager::instance().simulationMode()) { if (!m_inspectionStatusReady) { if (!m_inspectionStatusPending) { m_inspectionStatusPending = true; m_deviceService->requestStatus( [this](bool success, const DeviceStatus &, const QString &statusError) { m_inspectionStatusPending = false; m_inspectionStatusReady = success; m_inspectionStatusError = statusError; }); } if (m_inspectionStatusPending) { return true; } if (!m_inspectionStatusReady) { if (error) { *error = m_inspectionStatusError; } return false; } } } const int frontRawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult : static_cast(m_deviceStatus.checkResult); const QString frontResultState = resultStateForRawResult(frontRawResult); if (frontResultState == "UNKNOWN" || frontResultState == "ERROR") { if (error) { *error = QString("Invalid front inspection result: %1") .arg(frontRawResult); } return false; } if (!recordInspection("FRONT", frontRawResult, frontResultState, error)) { return false; } m_inspectionStatusReady = false; m_inspectionStatusError.clear(); m_frontRawResult = frontRawResult; m_frontResultState = frontResultState; if (!updateCurrentProcessStep("FRONT_UNLOADING", error)) { return false; } setState(FrontUnloading); return true; } case FrontUnloading: return executeCurrentAction( DeviceService::FrontUnload, m_inspectionMode == "AFTER_PLATING" ? "RACK_PLACING" : "FLIPPING", m_inspectionMode == "AFTER_PLATING" ? RackPlacing : Flipping, error); case Flipping: return executeCurrentAction(DeviceService::Flip, "BACK_LOADING", BackLoading, error); case BackLoading: return executeCurrentAction(DeviceService::BackLoad, "BACK_CHECKING", BackChecking, error); case BackChecking: { bool completed = false; if (!processProductionAction( DeviceService::Inspect, &completed, error)) { return false; } if (!completed) { return false; } if (!ConfigManager::instance().simulationMode()) { if (!m_inspectionStatusReady) { if (!m_inspectionStatusPending) { m_inspectionStatusPending = true; m_deviceService->requestStatus( [this](bool success, const DeviceStatus &, const QString &statusError) { m_inspectionStatusPending = false; m_inspectionStatusReady = success; m_inspectionStatusError = statusError; }); } if (m_inspectionStatusPending) { return true; } if (!m_inspectionStatusReady) { if (error) { *error = m_inspectionStatusError; } return false; } } } const int backRawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult : static_cast(m_deviceStatus.checkResult); const QString backResultState = resultStateForRawResult(backRawResult); if (backResultState == "UNKNOWN" || backResultState == "ERROR") { if (error) { *error = QString("Invalid back inspection result: %1") .arg(backRawResult); } return false; } if (!recordInspection("BACK", backRawResult, backResultState, error)) { return false; } m_inspectionStatusReady = false; m_inspectionStatusError.clear(); const QString finalState = m_frontResultState == "OK" && backResultState == "OK" ? "OK" : "NG"; if (!updateCurrentProcessStep("BACK_UNLOADING", error)) { return false; } m_frontResultState = finalState; setState(BackUnloading); break; } case BackUnloading: return executeCurrentAction(DeviceService::BackUnload, "RACK_PLACING", RackPlacing, error); case RackPlacing: { bool completed = false; if (!processProductionAction( DeviceService::RackPlace, &completed, error)) { return false; } if (!completed) { return false; } QString finalState = m_frontResultState; if (finalState != "OK" && finalState != "NG") { if (error) { *error = "Final inspection result is not available"; } return false; } return finishCurrentWorkpiece(finalState, "COMPLETE", error); } default: break; } return true; } bool ProductionService::recoverFromPlcStep(QString *error) { if (!checkRecoverySafety(error)) { return true; } if (ConfigManager::instance().simulationMode() && isTimedState(m_timeoutState)) { setState(m_timeoutState); emit recoveryCompleted("SIMULATION_STATE"); return true; } if (m_timeoutState == Preparing) { setState(Preparing); emit recoveryCompleted("PREPARING"); return true; } if (m_timeoutState == WaitingDeviceReady) { if (m_deviceStatus.plcReady && m_deviceStatus.robotReady) { if (m_currentWorkpiece.id > 0 && m_currentWorkpiece.processStep != "LOADING" && !updateCurrentProcessStep("LOADING", error)) { return false; } setState(Loading); } else { setState(WaitingDeviceReady); } emit recoveryCompleted("DEVICE_STATUS"); return true; } State recoveredState = Idle; QString processStep; if (!mapPlcStepToState(&recoveredState, &processStep)) { m_timer->stop(); setState(ManualConfirm); const QString message = QString("PLC current step %1 cannot be mapped automatically") .arg(m_deviceStatus.currentStep); emit timeoutRecoveryRequired(stateName(), message); return true; } if (m_currentWorkpiece.id > 0 && m_currentWorkpiece.processStep != processStep && !updateCurrentProcessStep(processStep, error)) { return false; } persistRecoveryAction( "PLC_STEP", QString("Recovered from PLC step %1 to %2") .arg(m_deviceStatus.currentStep).arg(processStep)); setState(recoveredState); emit recoveryCompleted("PLC_CURRENT_STEP"); return true; } bool ProductionService::isTimedState(State state) const { return state == Preparing || state == WaitingDeviceReady || state == RackPicking || state == FrontLoading || state == Loading || state == FrontChecking || state == FrontUnloading || state == Flipping || state == BackLoading || state == BackChecking || state == BackUnloading || state == RackPlacing || state == Judging; } QString ProductionService::processStepForState(State state) const { switch (state) { case Preparing: return "PREPARING"; case WaitingDeviceReady: return "WAITING_DEVICE_READY"; case RackPicking: return "RACK_PICKING"; case FrontLoading: return "FRONT_LOADING"; case Loading: return "LOADING"; case FrontChecking: return "FRONT_CHECKING"; case FrontUnloading: return "FRONT_UNLOADING"; case Flipping: return "FLIPPING"; case BackLoading: return "BACK_LOADING"; case BackChecking: return "BACK_CHECKING"; case BackUnloading: return "BACK_UNLOADING"; case RackPlacing: return "RACK_PLACING"; case Judging: return "JUDGING"; default: return QString(); } } ProductionService::State ProductionService::stateForProcessStep( const QString &processStep) const { if (processStep == "PREPARING") return Preparing; if (processStep == "WAITING_DEVICE_READY") return WaitingDeviceReady; if (processStep == "RACK_PICKING") return RackPicking; if (processStep == "FRONT_LOADING") return FrontLoading; if (processStep == "LOADING") return Loading; if (processStep == "FRONT_CHECKING") return FrontChecking; if (processStep == "FRONT_UNLOADING") return FrontUnloading; if (processStep == "FLIPPING") return Flipping; if (processStep == "BACK_LOADING") return BackLoading; if (processStep == "BACK_CHECKING") return BackChecking; if (processStep == "BACK_UNLOADING") return BackUnloading; if (processStep == "RACK_PLACING") return RackPlacing; if (processStep == "JUDGING") return Judging; return Idle; } QString ProductionService::runStateForState(State state) const { switch (state) { case Paused: return "PAUSED"; case Error: return "ERROR"; case Completed: return "COMPLETED"; case TimeoutPaused: case RecoveryChecking: case ManualConfirm: case Retrying: return "RECOVERY"; case Terminating: return "STOPPING"; case Idle: return "STOPPED"; default: return "RUNNING"; } } ProductionService::State ProductionService::stateFromName(const QString &name) const { if (name == "PREPARING") return Preparing; if (name == "WAITING_DEVICE_READY") return WaitingDeviceReady; if (name == "RACK_PICKING") return RackPicking; if (name == "FRONT_LOADING") return FrontLoading; if (name == "LOADING") return Loading; if (name == "FRONT_CHECKING") return FrontChecking; if (name == "FRONT_UNLOADING") return FrontUnloading; if (name == "FLIPPING") return Flipping; if (name == "BACK_LOADING") return BackLoading; if (name == "BACK_CHECKING") return BackChecking; if (name == "BACK_UNLOADING") return BackUnloading; if (name == "RACK_PLACING") return RackPlacing; if (name == "JUDGING") return Judging; if (name == "UNLOADING") return Unloading; if (name == "PAUSED") return Paused; if (name == "ERROR") return Error; if (name == "COMPLETED") return Completed; if (name == "TIMEOUT_WARNING") return TimeoutWarning; if (name == "TIMEOUT_PAUSED") return TimeoutPaused; if (name == "RECOVERY_CHECKING") return RecoveryChecking; if (name == "MANUAL_CONFIRM") return ManualConfirm; if (name == "RETRYING") return Retrying; if (name == "TERMINATING") return Terminating; return Idle; } void ProductionService::persistAlarm(const QString &code, const QString &message) { QString persistenceError; QString level = "ERROR"; QString source = "PRODUCTION"; if (code.contains("WARNING")) { level = "WARNING"; } else if (code == "EMERGENCY_STOP" || code == "SAFETY_DOOR_OPEN") { level = "CRITICAL"; source = "DEVICE"; } else if (code == "PLC_DISCONNECTED") { level = "CRITICAL"; source = "PLC"; } if (!ProductionRepository().insertAlarm( code, message, m_orderId, m_currentWorkpiece.id, level, source, &persistenceError)) { qWarning() << "Failed to persist alarm:" << persistenceError; } } void ProductionService::persistDeviceStatus(const DeviceStatus &status) { QString persistenceError; if (!ProductionRepository().insertDeviceStatus( "PLC", status.plcConnected, status.plcReady, status.robotReady, status.safetyDoorClosed, status.emergencyStop, status.currentStep, status.checkResult, status.errorCode, &persistenceError)) { qWarning() << "Failed to persist device status:" << persistenceError; } } void ProductionService::fail(const QString &error) { if (m_state == Terminating) { return; } 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( [this](bool success, const QString &cleanupError) { if (!success && !cleanupError.isEmpty()) { qWarning() << "PLC action cleanup failed:" << cleanupError; } }); m_timer->stop(); setState(Error); QString alarmCode = "PRODUCTION"; if (m_lastError == "PLC is disconnected" || m_lastError.startsWith("Failed to connect") || m_lastError.startsWith("Failed to read PLC")) { alarmCode = "PLC_DISCONNECTED"; } else if (m_lastError == "Emergency stop is active") { alarmCode = "EMERGENCY_STOP"; } else if (m_lastError == "Safety door is open") { alarmCode = "SAFETY_DOOR_OPEN"; } persistAlarm(alarmCode, m_lastError); emit productionError(m_lastError); emit alarmRaised(alarmCode, m_lastError); } void ProductionService::finishShutdown(bool success, const QString &error) { if (!m_shutdownRequested) { return; } const DeviceService::OperationCallback callback = m_shutdownCallback; m_shutdownCallback = DeviceService::OperationCallback(); m_shutdownRequested = false; if (callback) { callback(success, error); } } bool ProductionService::isActive() const { return m_state != Idle && m_state != Error && m_state != Completed && m_state != Paused && m_state != TimeoutPaused && m_state != ManualConfirm && m_state != Terminating; } bool ProductionService::stopRequested() const { return m_stopRequested.load() || (m_externalStopRequested && m_externalStopRequested->load()); } void ProductionService::onDeviceStatusChanged(const DeviceStatus &status) { const bool changed = !m_deviceStatusValid || status.statusValid != m_deviceStatus.statusValid || status.plcConnected != m_deviceStatus.plcConnected || status.plcReady != m_deviceStatus.plcReady || status.robotReady != m_deviceStatus.robotReady || status.safetyDoorClosed != m_deviceStatus.safetyDoorClosed || status.emergencyStop != m_deviceStatus.emergencyStop || status.inspectionMachineReady != m_deviceStatus.inspectionMachineReady || status.visionReady != m_deviceStatus.visionReady || status.robotControlCabinetReady != m_deviceStatus.robotControlCabinetReady || status.mainControlCabinetReady != m_deviceStatus.mainControlCabinetReady || status.safetyDoor1Closed != m_deviceStatus.safetyDoor1Closed || status.safetyDoor2Closed != m_deviceStatus.safetyDoor2Closed || status.safetyDoor3Closed != m_deviceStatus.safetyDoor3Closed || status.activeAlarm != m_deviceStatus.activeAlarm || status.currentStep != m_deviceStatus.currentStep || status.checkResult != m_deviceStatus.checkResult || status.errorCode != m_deviceStatus.errorCode; m_deviceStatus = status; m_deviceStatusValid = status.statusValid; emit deviceStatusChanged(status); if (changed) { persistDeviceStatus(status); } } void ProductionService::onCommunicationError(const QString &error) { emit deviceCommunicationError(error); if (m_state == RecoveryChecking || m_state == Terminating) { m_lastError = error; return; } if (isActive()) { fail(error); } }