Files
ssp/services/productionservice.cpp
T
lidg 407af2892d feat: 重构视觉取料流程及生产故障恢复
- 删除订单启动、暂停、复位相关 PLC 握手及无效反馈配置
- 清除报警改为仅写 clearAlarmCommand,不等待反馈
- 将拍照位移动、视觉处理和 RackPick 拆分为三个独立动作
- 增加 M850/M851 拍照位动作及 R60/M852 视觉结果流程
- 暂停改为等待当前机器人动作完成,视觉结果不确定时转人工确认
- 删除复位按钮,合并为恢复/重试按钮
- 普通 PAUSED 订单通过启动按钮继续
- 恢复前检查 PLC、安全状态、订单及动作命令反馈
- 支持在途动作接管、已完成动作收尾、安全重试和人工确认
- 故障状态保持订单 RUNNING,并持久化实际恢复阶段
- 恢复成功后仅清除本次软件故障对应的报警
- 更新小轴 PLC 地址、Modbus 配置和视觉集成文档
2026-10-29 17:20:14 +08:00

2465 lines
83 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "productionservice.h"
#include "../config/configmanager.h"
#include "../repositories/productionrepository.h"
#include "orderservice.h"
#include "trayservice.h"
#include "workpieceservice.h"
#include "visionservice.h"
#include <QDebug>
#include <QDateTime>
#include <QJsonArray>
#include <QJsonDocument>
#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QSaveFile>
#include <QScopedValueRollback>
#include <QTimer>
#include <QUuid>
#include <cmath>
#include <limits>
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_actionWasSent(false)
, m_actionCancelRequested(false)
, m_inspectionStatusPending(false)
, m_inspectionStatusReady(false)
, m_starting(false)
, m_plcStarted(false)
, m_tickRunning(false)
, m_pauseAfterCurrentAction(false)
, m_recoveryCheckPending(false)
, m_pendingAction(DeviceService::RackPick)
, m_stopRequested(false)
, m_externalStopRequested(nullptr)
, m_shutdownRequested(false)
{
const QString configPath = ConfigManager::instance().filePath();
m_visionStatePath = QFileInfo(configPath.isEmpty()
? QDir(QCoreApplication::applicationDirPath()).filePath("config.ini") : configPath)
.absoluteFilePath() + ".vision-state.json";
loadVisionRecoveryState();
connect(m_timer, &QTimer::timeout, this, &ProductionService::tick);
connect(m_deviceService, &DeviceService::statusChanged,
this, &ProductionService::onDeviceStatusChanged);
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 PhotoMoving: return "PHOTO_MOVING";
case VisionProcessing: return "VISION_PROCESSING";
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::requestStopImmediate()
{
m_stopRequested.store(true);
}
bool ProductionService::saveVisionRecoveryState(bool pending, QString *error)
{
const QJsonObject state{{"version", 1}, {"pending", pending},
{"run_id", m_runId}, {"workpiece_id", m_currentWorkpiece.id},
{"updated_at", QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs)}};
const QByteArray bytes = QJsonDocument(state).toJson(QJsonDocument::Compact);
QSaveFile file(m_visionStatePath);
if (!file.open(QIODevice::WriteOnly) || file.write(bytes) != bytes.size() || !file.commit()) {
if (error) *error = "无法保存视觉恢复状态,禁止继续生产:" + file.errorString();
return false;
}
return true;
}
void ProductionService::loadVisionRecoveryState()
{
if (!QFileInfo::exists(m_visionStatePath)) return;
QFile file(m_visionStatePath);
const bool opened = file.open(QIODevice::ReadOnly);
const QJsonObject state = opened ? QJsonDocument::fromJson(file.readAll()).object() : QJsonObject();
const bool valid = state.value("version").toDouble() == 1 && state.value("pending").isBool();
if (valid && !state.value("pending").toBool()) return;
m_visionNeedsReconcile = true;
m_visionSuspended = true;
m_visionStage = VisionStage::Fault;
m_lastError = valid ? "上次视觉事务尚未完成,请核对机器人和 PLC 后恢复"
: "视觉恢复记录无法读取或已损坏,请核对机器人和 PLC 后恢复";
}
void ProductionService::publishVisionControl()
{
const bool locked = m_visionNeedsReconcile || (m_state != Idle && m_state != Completed);
const bool maintenance = m_visionNeedsReconcile && !m_shutdownRequested
&& !m_visionRecoveryChecking && !m_visionFaultCleanupPending
&& (m_state == Idle || m_state == ManualConfirm)
&& !m_actionStarting && !m_actionPollPending && !m_actionCancelRequested
&& !m_deviceService->productionActionActive();
emit visionProductionActiveChanged(locked, maintenance);
}
bool ProductionService::visionCurrent(quint64 generation) const
{
return generation == m_visionGeneration && !m_visionSuspended && !stopRequested()
&& isActive() && m_currentWorkpiece.id == m_visionWorkpieceId
&& m_currentTrayNo == m_visionTrayNo
&& 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::ReadingPose: name = "读取 R40 位姿"; break;
case VisionStage::Measuring: name = "识别及抓取计算"; break;
case VisionStage::WritingPose: name = "写入 R60"; break;
case VisionStage::Publishing: 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)) {
visionFault(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_visionEnabled = config.enabled;
m_visionIoPending = false;
m_visionRecoveryChecking = false;
// Persist before R60/M852 can be written so a crash cannot erase an in-flight result.
if (!saveVisionRecoveryState(true, &error)) {
visionFault(error);
return;
}
beginVisionMeasurement();
}
void ProductionService::advanceVision()
{
if (m_visionSuspended || m_visionStage == VisionStage::Fault) return;
if (!visionCurrent(m_visionGeneration)) {
visionFault("当前工件、视觉进程会话或设备状态已改变");
return;
}
const VisionConfig config = ConfigManager::instance().visionConfig();
const qint64 limit = m_visionStage == VisionStage::Measuring
? qint64(config.requestTimeoutMs) + 2LL * config.initializeTimeoutMs
: ConfigManager::instance().productionConfig().stateTimeoutMs;
if (m_visionTimer.isValid() && m_visionTimer.elapsed() > limit) {
if (m_visionStage == VisionStage::Measuring)
skipVision("视觉等待超时");
else
visionFault("视觉 PLC 操作等待超时,请核对写入状态");
return;
}
}
void ProductionService::beginVisionMeasurement()
{
const VisionConfig config = ConfigManager::instance().visionConfig();
if (!m_visionEnabled) {
publishPickMode(false);
return;
}
if (config.visionTrayNo(m_currentTrayNo) < 1 || m_availableVisionSession.isEmpty()) {
skipVision("缺少视觉料盘映射或视觉进程未连接");
return;
}
m_visionSession = m_availableVisionSession;
const quint64 generation = m_visionGeneration;
setVisionStage(VisionStage::ReadingPose, "从 R40 整组读取本次拍照 XYZABC");
m_visionIoPending = true;
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); 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)
{
Q_UNUSED(ready)
Q_UNUSED(busy)
m_availableVisionSession = session;
if (m_visionStage == VisionStage::Measuring && session != m_visionSession
&& visionCurrent(m_visionGeneration))
skipVision("VisionGuide 连接中断或进程会话改变");
}
void ProductionService::publishVisionSnapshot()
{
publishVisionControl();
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) {
skipVision("视觉结果与本次取料上下文不一致"); return;
}
RobotPose target, camera;
for (const QJsonValue &value : result.value("robot_pose").toArray()) {
if (!value.isDouble() || !std::isfinite(value.toDouble())
|| qAbs(value.toDouble()) > std::numeric_limits<float>::max()) {
skipVision("机器人坐标无效或超出 PLC float 范围"); return;
}
target.xyzabc.append(value.toDouble());
}
for (const QJsonValue &value : result.value("camera_pose").toArray()) {
if (!value.isDouble()) { skipVision("相机坐标格式无效"); 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()) {
skipVision("视觉识别失败或结果无效:" + result.value("message").toString()); return;
}
m_visionResult = result;
const quint64 generation = m_visionGeneration;
m_visionIoPending = true;
m_visionCommitStarted = true;
setVisionStage(VisionStage::WritingPose, "整组写入 R60,确认后选择比对取料");
m_deviceService->writeRobotGraspPose(target,
[this, generation](VisionWriteOutcome outcome, const QString &error) {
if (!visionCurrent(generation)) return;
m_visionIoPending = false;
if (outcome != VisionWriteOutcome::Confirmed) {
visionFault("R60 写入未确认,禁止继续取料:" + error);
return;
}
publishPickMode(true);
}, [this, generation]() { return visionCurrent(generation); });
}
void ProductionService::publishPickMode(bool useVision)
{
const quint64 generation = m_visionGeneration;
if (!visionCurrent(generation)) return;
m_visionIoPending = true;
setVisionStage(VisionStage::Publishing, useVision ? "写 M852=1,使用本次 R60" : "写 M852=0,使用普通取料");
m_deviceService->writeVisionSignal(DeviceService::ComparisonPick, useVision,
[this, generation](VisionWriteOutcome outcome, const QString &error) {
if (!visionCurrent(generation)) return;
m_visionIoPending = false;
if (outcome != VisionWriteOutcome::Confirmed) {
visionFault("M852 写入未确认,禁止启动 RackPick:" + error);
return;
}
setVisionStage(VisionStage::Complete, "取料模式已确认,允许普通 RackPick");
}, [this, generation]() { return visionCurrent(generation); });
}
void ProductionService::skipVision(const QString &reason)
{
if (!visionCurrent(m_visionGeneration)) return;
const QString requestId = m_visionRequest.value("request_id").toString();
m_visionResult = QJsonObject();
// Change stage before cancellation can deliver a synchronous terminal callback.
setVisionStage(VisionStage::Publishing, reason + ";本次改为普通取料");
reportVision("视觉跳过", reason + ";本次不使用 R60", true);
qWarning().noquote() << "Vision fallback:" << reason;
persistRecoveryAction("VISION_FALLBACK", reason);
emit visionCancelRequested(requestId);
publishPickMode(false);
}
void ProductionService::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;
QString persistenceError;
if (!saveVisionRecoveryState(true, &persistenceError)) {
m_lastError = persistenceError;
emit productionError(persistenceError);
}
emit visionCancelRequested(m_visionRequest.value("request_id").toString());
m_deviceService->cancelVisionRequests(reason);
m_visionStage = VisionStage::Fault;
reportVision("等待人工核对", reason + (m_visionCommitStarted
? ";R60 或有效信号可能已经到达机器人,需现场核对" : QString()), true);
emit visionProductionActiveChanged(true, false);
}
void ProductionService::visionFault(const QString &reason)
{
if (m_visionStage == VisionStage::Fault) return;
m_timeoutState = m_state;
m_lastError = reason;
// A preflight rejection also requires an explicit operator recovery.
m_visionNeedsReconcile = true;
invalidateVision(reason);
m_visionSuspended = true;
m_visionStage = VisionStage::Fault;
m_timer->stop();
pauseProcessTimer();
setState(ManualConfirm);
reportVision("等待人工核对", reason, true);
m_visionFaultCleanupPending = false;
publishVisionControl();
m_recoveryAlarmCode = "VISION";
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_visionFaultCleanupPending || m_deviceService->productionActionBusy()
|| m_deviceService->productionActionActive()) {
if (error) *error = "请等待 PLC 操作结束后恢复";
return false;
}
m_visionRecoveryChecking = true;
publishVisionControl();
const quint64 generation = m_visionGeneration;
m_deviceService->readVisionHandshake(
[this, generation](bool success, const VisionHandshake &handshake, const QString &error) {
if (generation != m_visionGeneration || stopRequested()) {
m_visionRecoveryChecking = false;
publishVisionControl();
return;
}
m_visionRecoveryChecking = false;
if (!success || handshake.photoMove || handshake.photoMoveFeedback) {
publishVisionControl();
emit productionError("恢复视觉前要求 M850/M851 均已复位:" + error);
return;
}
QString persistenceError;
if (!saveVisionRecoveryState(false, &persistenceError)) {
publishVisionControl();
emit productionError(persistenceError);
return;
}
persistRecoveryAction("VISION_CONFIRMED", "Operator confirmed the uncertain R60/M852 result; old target discarded");
m_visionNeedsReconcile = false;
m_visionSuspended = false;
m_visionCommitStarted = false;
m_visionStage = VisionStage::Idle;
m_visionRequest = QJsonObject();
m_visionResult = QJsonObject();
QString stepError;
if (m_currentWorkpiece.id > 0
&& !updateCurrentProcessStep("VISION_PROCESSING", &stepError)) {
emit productionError(stepError);
return;
}
m_timeoutState = VisionProcessing;
m_actionWasSent = false;
reportVision("人工恢复完成", "已丢弃旧视觉目标,重新读取 R40 并测量", true);
publishVisionControl();
ProductionActionStatus status;
continueRecovery(VisionProcessing, DeviceService::RackPick, status);
});
return true;
}
bool ProductionService::start(int orderId, QString *error)
{
const VisionConfig vision = ConfigManager::instance().visionConfig();
if (m_visionNeedsReconcile || (!ConfigManager::instance().simulationMode() && !vision.isValid(error))) {
if (m_visionNeedsReconcile && error)
*error = "请先人工核对并恢复上次视觉握手,再启动生产";
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_actionWasSent = false;
m_actionError.clear();
m_pauseAfterCurrentAction = false;
m_frontResultState.clear();
m_stopRequested.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_recoveryAlarmCode.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_plcStarted = true;
QString orderError;
if (!OrderService::instance().startOrder(
m_orderId, &orderError)) {
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_state == VisionProcessing) {
if (m_visionStage == VisionStage::Complete) {
QString stepError;
if (!saveVisionRecoveryState(false, &stepError)
|| !updateCurrentProcessStep("RACK_PICKING", &stepError)) {
if (error) *error = stepError;
return false;
}
m_visionStage = VisionStage::Idle;
m_visionCommitStarted = false;
m_visionRequest = QJsonObject();
m_visionResult = QJsonObject();
setState(RackPicking);
return pauseAtActionBoundary(error);
}
if (m_visionCommitStarted) {
visionFault("暂停时 R60/M852 写入状态不确定,需人工核对");
return true;
}
abortVisionForPause();
if (m_visionNeedsReconcile) {
if (error) *error = m_lastError;
return false;
}
return pauseAtActionBoundary(error);
}
if (m_actionPending || m_actionStarting || m_actionPollPending) {
m_pauseAfterCurrentAction = true;
return true;
}
return pauseAtActionBoundary(error);
}
bool ProductionService::pauseAtActionBoundary(QString *error)
{
if (!OrderService::instance().pauseOrder(m_orderId, error)) {
return false;
}
m_pauseAfterCurrentAction = false;
pauseProcessTimer();
m_timer->stop();
setState(Paused);
emitProcessElapsed();
return true;
}
void ProductionService::abortVisionForPause()
{
++m_visionGeneration;
emit visionCancelRequested(m_visionRequest.value("request_id").toString());
m_deviceService->cancelVisionRequests("生产在视觉动作边界暂停");
m_visionIoPending = false;
m_visionSuspended = false;
m_visionCommitStarted = false;
m_visionStage = VisionStage::Idle;
m_visionRequest = QJsonObject();
m_visionResult = QJsonObject();
QString persistenceError;
if (!saveVisionRecoveryState(false, &persistenceError)) {
m_lastError = persistenceError;
m_visionNeedsReconcile = true;
setState(ManualConfirm);
emit productionError(persistenceError);
}
reportVision("视觉已作废", "暂停前未提交 R60/M852,恢复后重新读取 R40 并测量", true);
}
bool ProductionService::resume(QString *error)
{
if (m_visionNeedsReconcile) {
if (error) *error = "视觉流程需人工核对恢复,不能直接继续";
return false;
}
if (m_state != Paused) {
if (error) {
*error = "Production service is not paused";
}
return false;
}
if (m_starting) {
if (error) *error = "Production resume is already in progress";
return false;
}
m_starting = true;
m_deviceService->requestStatus(
[this](bool statusSuccess, const DeviceStatus &, const QString &statusError) {
QString safetyError;
if (!statusSuccess || !checkRecoverySafety(&safetyError)) {
m_starting = false;
emit productionError(statusSuccess ? safetyError : statusError);
return;
}
m_deviceService->setInspectionMode(
m_inspectionMode,
[this](bool modeSuccess, const QString &modeError) {
if (!modeSuccess) {
m_starting = false;
emit productionError(modeError);
return;
}
QString orderError;
if (!OrderService::instance().resumeOrder(m_orderId, &orderError)) {
m_starting = false;
emit productionError(orderError);
return;
}
resumeProcessTimer();
State resumeState = Preparing;
if (m_currentWorkpiece.id > 0) {
resumeState = stateForProcessStep(m_currentWorkpiece.processStep);
if (resumeState == Idle) resumeState = WaitingDeviceReady;
}
m_starting = false;
setState(resumeState);
m_timer->start(ProductionTickIntervalMs);
tick();
});
});
return true;
}
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);
m_recoveryAlarmCode = "TERMINATION_FAILED";
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::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);
m_currentSlotNo = m_currentWorkpiece.trayPos;
const QList<Tray> trays = TrayService::instance().listTrays(
&workpieceError);
if (!workpieceError.isEmpty()) {
if (error) *error = workpieceError;
return false;
}
for (int index = 0; index < trays.size(); ++index) {
if (trays.at(index).id == m_currentWorkpiece.trayId) {
m_currentTrayNo = index + 1;
break;
}
}
if (m_currentTrayNo <= 0 || m_currentSlotNo < 1
|| m_currentSlotNo > 49) {
if (error) *error = "恢复记录中的托盘或工位无法映射到 PLC";
return false;
}
emit currentWorkpieceSnapshotChanged(m_currentWorkpiece);
emit currentPositionChanged(m_currentTrayNo, m_currentSlotNo);
startProcessTimer(m_currentWorkpiece.processStep);
emitProcessElapsed();
}
State persistedState = stateFromName(run.productionState);
if (persistedState == Idle || persistedState == Completed) {
persistedState = Preparing;
}
m_timeoutState = stateFromName(run.timeoutState);
if (!isTimedState(m_timeoutState)) {
m_timeoutState = persistedState;
}
const State recoveryState = isTimedState(m_timeoutState)
? m_timeoutState
: persistedState;
if (recoveryState == VisionProcessing || m_visionNeedsReconcile) {
m_recoveryAlarmCode = "VISION";
m_visionNeedsReconcile = true;
m_visionSuspended = true;
m_visionStage = VisionStage::Fault;
QString stateError;
if (!saveVisionRecoveryState(true, &stateError)) emit productionError(stateError);
reportVision("等待人工核对", "恢复未完成的视觉记录,需核对 R60/M852 写入状态", true);
} else if (m_lastError == "PLC is disconnected"
|| m_lastError.startsWith("Failed to connect")
|| m_lastError.startsWith("Failed to read PLC")) {
m_recoveryAlarmCode = "PLC_DISCONNECTED";
} else if (m_lastError == "Emergency stop is active") {
m_recoveryAlarmCode = "EMERGENCY_STOP";
} else if (m_lastError == "Safety door is open") {
m_recoveryAlarmCode = "SAFETY_DOOR_OPEN";
} else if (!m_lastError.isEmpty()) {
m_recoveryAlarmCode = "PRODUCTION";
}
DeviceService::ProductionAction action;
m_actionWasSent = productionActionForState(recoveryState, &action);
if (run.runState == "PAUSED") {
setState(Paused);
} else {
m_timeoutState = recoveryState;
setState(ManualConfirm);
}
m_heartbeatTimer.restart();
m_timer->stop();
if (run.runState != "PAUSED")
emit timeoutRecoveryRequired(
"STARTUP_RECOVERY",
QString("Unfinished production run %1 requires recovery confirmation")
.arg(run.id));
return true;
}
bool ProductionService::recover(QString *error)
{
if (m_state != Error && m_state != TimeoutPaused
&& m_state != ManualConfirm) {
if (error) {
*error = "Production is not waiting for recovery";
}
return false;
}
if (m_recoveryCheckPending) {
if (error) *error = "Recovery check is already in progress";
return false;
}
m_recoveryCheckPending = true;
m_deviceService->requestStatus(
[this](bool statusSuccess, const DeviceStatus &,
const QString &statusError) {
m_recoveryCheckPending = false;
QString safetyError;
if (!statusSuccess || !checkRecoverySafety(&safetyError)) {
emit productionError(statusSuccess ? safetyError : statusError);
return;
}
Order order;
QString orderError;
if (!OrderService::instance().findOrder(m_orderId, &order,
&orderError)
|| order.status != "RUNNING") {
emit productionError(orderError.isEmpty()
? "故障恢复要求订单保持 RUNNING;PAUSED 订单请使用启动按钮"
: orderError);
return;
}
if (m_currentWorkpiece.id <= 0
&& m_timeoutState != Preparing) {
emit productionError("恢复所需的当前工件记录不完整");
return;
}
if (m_visionNeedsReconcile) {
QString visionError;
if (!recoverVision(&visionError))
emit productionError(visionError);
return;
}
State recoveryState = isTimedState(m_timeoutState)
? m_timeoutState
: stateForProcessStep(m_currentWorkpiece.processStep);
if (!isTimedState(recoveryState)) {
emit productionError("无法从持久化记录确定安全恢复位置");
return;
}
DeviceService::ProductionAction action;
if (!productionActionForState(recoveryState, &action)) {
ProductionActionStatus status;
continueRecovery(recoveryState, DeviceService::RackPick,
status);
return;
}
m_deviceService->inspectProductionAction(
action,
[this, recoveryState, action](
bool success, const ProductionActionStatus &status,
const QString &actionError) {
if (!success) {
emit productionError("读取当前动作命令/反馈失败:"
+ actionError);
return;
}
continueRecovery(recoveryState, action, status);
});
});
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;
}
const int durationMs = currentProcessElapsedMs();
const QString previousProcessStep = m_currentWorkpiece.processStep;
if (!WorkpieceService::instance().completeWithInspection(
m_currentWorkpiece.id, "NG", "COMPLETE",
previousProcessStep, durationMs, -1, "NG",
m_deviceStatus.currentStep, m_inspectionMode, "MANUAL",
&operationError)) {
if (error) *error = operationError;
return false;
}
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());
publishVisionControl();
if (m_runId > 0) {
QString processStep = processStepForState(state);
if (processStep.isEmpty()) processStep = m_currentWorkpiece.processStep;
if (processStep.isEmpty()) processStep = processStepForState(m_timeoutState);
QString persistenceError;
ProductionRepository repository;
if (!repository.updateRun(
m_runId, runStateForState(state), stateName(), processStep,
m_currentWorkpiece.id,
isTimedState(m_timeoutState) ? stateNameForState(m_timeoutState)
: QString(),
m_recoveryRetryCount, m_lastError, &persistenceError)
|| !repository.insertStateHistory(
m_runId, m_orderId, m_currentWorkpiece.id,
previousStateName, stateName(), processStep,
state == RecoveryChecking || state == ManualConfirm
|| state == Retrying ? "RECOVERY" : "SYSTEM",
QString(), QString(), &persistenceError)) {
qWarning() << "Failed to persist production state:" << persistenceError;
}
}
}
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<Tray> 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 (!m_actionPending) {
m_pendingAction = action;
m_actionPending = true;
m_actionStarting = true;
m_actionPollPending = false;
m_actionCompleted = false;
m_actionError.clear();
m_actionWasSent = true;
m_deviceService->beginProductionAction(
action, m_currentTrayNo, m_currentSlotNo,
[this](bool success, const QString &actionError) {
m_actionStarting = false;
if (!success) {
m_actionError = actionError;
}
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 (m_actionCompleted) {
*completed = true;
m_actionPending = false;
m_actionCompleted = false;
m_actionWasSent = false;
return true;
}
m_actionPollPending = true;
m_deviceService->pollProductionAction(
[this](bool success, bool completed,
const QString &actionError) {
m_actionPollPending = false;
if (!success) {
m_actionError = actionError;
return;
}
if (completed) {
m_actionCompleted = true;
}
tryDeferredActionCancel();
});
return true;
}
bool ProductionService::processVisionAction(bool *completed, QString *error)
{
if (!completed) {
if (error) *error = "Vision completion pointer is null";
return false;
}
*completed = false;
if (ConfigManager::instance().simulationMode()) {
*completed = true;
return true;
}
if (m_visionNeedsReconcile || m_visionSuspended) return true;
if (m_visionStage == VisionStage::Idle) {
prepareVision();
return true;
}
if (m_visionStage != VisionStage::Complete) {
advanceVision();
return true;
}
QString persistenceError;
if (!saveVisionRecoveryState(false, &persistenceError)) {
if (error) *error = persistenceError;
return false;
}
m_visionStage = VisionStage::Idle;
m_visionCommitStarted = false;
m_visionRequest = QJsonObject();
m_visionResult = QJsonObject();
*completed = true;
return true;
}
void ProductionService::cancelPendingProductionAction(
const DeviceService::OperationCallback &callback)
{
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);
if (m_pauseAfterCurrentAction && !pauseAtActionBoundary(error)) {
return false;
}
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<int>(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<int>(m_processTimer.elapsed());
}
void ProductionService::emitProcessElapsed()
{
if (m_currentProcessStep.trimmed().isEmpty()) {
return;
}
emit processElapsedChanged(m_currentProcessStep, currentProcessElapsedMs());
}
bool ProductionService::productionActionForState(
State state, DeviceService::ProductionAction *action) const
{
if (!action) return false;
switch (state) {
case PhotoMoving: *action = DeviceService::PhotoMoveAction; return true;
case RackPicking: *action = DeviceService::RackPick; return true;
case FrontLoading: *action = DeviceService::FrontLoad; return true;
case FrontChecking:
case BackChecking: *action = DeviceService::Inspect; return true;
case FrontUnloading: *action = DeviceService::FrontUnload; return true;
case Flipping: *action = DeviceService::Flip; return true;
case BackLoading: *action = DeviceService::BackLoad; return true;
case BackUnloading: *action = DeviceService::BackUnload; return true;
case RackPlacing: *action = DeviceService::RackPlace; return true;
default: return false;
}
}
void ProductionService::continueRecovery(
State state, DeviceService::ProductionAction action,
const ProductionActionStatus &status)
{
DeviceService::ProductionAction expectedAction;
const bool hasRobotAction = productionActionForState(state, &expectedAction);
if (hasRobotAction && expectedAction != action) {
emit productionError("恢复记录与 PLC 动作类型不一致");
return;
}
if (hasRobotAction && !status.command && !status.feedback
&& m_actionWasSent) {
m_timeoutState = state;
m_lastError = "动作记录显示命令曾发送,但命令和反馈均为 0,无法确认是否执行";
setState(ManualConfirm);
emit timeoutRecoveryRequired(stateNameForState(state), m_lastError);
emit productionError(m_lastError);
return;
}
if (hasRobotAction && (status.command || status.feedback)) {
m_deviceService->adoptProductionAction(action);
m_pendingAction = action;
m_actionPending = true;
m_actionStarting = false;
m_actionPollPending = false;
m_actionCompleted = false;
m_actionError.clear();
m_actionWasSent = true;
} else if (hasRobotAction) {
const ProductionConfig config = ConfigManager::instance().productionConfig();
if (m_recoveryRetryCount >= config.maxRecoveryRetries) {
emit productionError("Maximum timeout recovery retries reached");
return;
}
++m_recoveryRetryCount;
m_actionPending = false;
m_actionWasSent = false;
persistRecoveryAction(
"RETRY",
QString("Retry action at %1 before any command was sent")
.arg(stateNameForState(state)));
}
m_deviceService->setInspectionMode(
m_inspectionMode,
[this, state, hasRobotAction, status](bool success,
const QString &modeError) {
if (!success) {
emit productionError(modeError);
return;
}
QString persistenceError;
if (!m_recoveryAlarmCode.isEmpty()
&& !ProductionRepository().clearActiveAlarms(
m_recoveryAlarmCode, "RECOVERY", &persistenceError)) {
emit productionError(persistenceError);
return;
}
m_recoveryAlarmCode.clear();
m_lastError.clear();
m_timeoutState = state;
m_pauseAfterCurrentAction = false;
persistRecoveryAction("CONTINUE",
QString("Resume from %1")
.arg(stateNameForState(state)));
setState(state);
m_actionWasSent = hasRobotAction && (status.command || status.feedback);
resumeProcessTimer();
m_heartbeatTimer.restart();
m_timer->start(ProductionTickIntervalMs);
emit recoveryCompleted(stateNameForState(state));
tick();
});
}
bool ProductionService::ensureOrderRunning(QString *error)
{
Order order;
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<int>(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<bool> 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("PHOTO_MOVING", &error)) {
fail(error);
return;
}
nextState = PhotoMoving;
}
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 PhotoMoving:
return executeCurrentAction(DeviceService::PhotoMoveAction,
"VISION_PROCESSING", VisionProcessing,
error);
case VisionProcessing: {
bool completed = false;
if (!processVisionAction(&completed, error)) return false;
if (!completed) return false;
if (!updateCurrentProcessStep("RACK_PICKING", error)) return false;
setState(RackPicking);
if (m_pauseAfterCurrentAction) return pauseAtActionBoundary(error);
return true;
}
case RackPicking:
return executeCurrentAction(DeviceService::RackPick,
"FRONT_LOADING", FrontLoading, error);
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<int>(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<int>(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 == PhotoMoving || state == VisionProcessing
|| 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 PhotoMoving: return "PHOTO_MOVING";
case VisionProcessing: return "VISION_PROCESSING";
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 == "PHOTO_MOVING") return PhotoMoving;
if (processStep == "VISION_PROCESSING") return VisionProcessing;
if (processStep == "RACK_PICKING") return RackPicking;
if (processStep == "FRONT_LOADING") return FrontLoading;
if (processStep == "LOADING") return Loading;
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 "RECOVERY";
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 == "PHOTO_MOVING") return PhotoMoving;
if (name == "VISION_PROCESSING") return VisionProcessing;
if (name == "RACK_PICKING") return RackPicking;
if (name == "FRONT_LOADING") return FrontLoading;
if (name == "LOADING") return Loading;
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;
}
if (isTimedState(m_state)) {
m_timeoutState = m_state;
}
m_lastError = error.isEmpty() ? "Production failed" : error;
m_timer->stop();
pauseProcessTimer();
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";
}
m_recoveryAlarmCode = alarmCode;
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);
}
}