2476 lines
86 KiB
C++
2476 lines
86 KiB
C++
#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 <QScopedValueRollback>
|
|
#include <QTimer>
|
|
#include <QUuid>
|
|
#include <cmath>
|
|
|
|
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<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 (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<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::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("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<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 == 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);
|
|
}
|
|
}
|