#include "productionservice.h" #include "../config/configmanager.h" #include "../repositories/productionrepository.h" #include "orderservice.h" #include "workpieceservice.h" #include #include ProductionService &ProductionService::instance() { static ProductionService service; return service; } ProductionService::ProductionService(QObject *parent) : QObject(parent) , m_timer(new QTimer(this)) , m_state(Idle) , m_timeoutState(Idle) , m_runId(0) , m_orderId(0) , m_deviceStatusValid(false) , m_recoveryRetryCount(0) , m_processElapsedMs(0) { connect(m_timer, &QTimer::timeout, this, &ProductionService::tick); connect(&DeviceService::instance(), &DeviceService::statusChanged, this, &ProductionService::onDeviceStatusChanged); connect(&DeviceService::instance(), &DeviceService::communicationError, this, &ProductionService::onCommunicationError); } ProductionService::State ProductionService::state() const { return m_state; } 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 Loading: return "LOADING"; case FrontChecking: return "FRONT_CHECKING"; case BackChecking: return "BACK_CHECKING"; 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"; } return "UNKNOWN"; } int ProductionService::orderId() const { return m_orderId; } Workpiece ProductionService::currentWorkpiece() const { return m_currentWorkpiece; } bool ProductionService::start(int orderId, QString *error) { 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; } if (!DeviceService::instance().start(error) || !OrderService::instance().startOrder(orderId, error)) { return false; } m_orderId = orderId; m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_deviceStatusValid = false; m_recoveryRetryCount = 0; m_lastError.clear(); QString persistenceError; m_runId = ProductionRepository().createRun( m_orderId, "PREPARING", "PREPARING", &persistenceError); if (m_runId <= 0) { DeviceService::instance().pause(); OrderService::instance().pauseOrder(m_orderId); m_orderId = 0; if (error) { *error = "Failed to create production run: " + persistenceError; } return false; } setState(Preparing); DeviceService::instance().startPolling(); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_heartbeatTimer.restart(); m_timer->start(interval); tick(); return true; } bool ProductionService::pause(QString *error) { if (!isActive()) { if (error) { *error = "Production service is not active"; } return false; } if (!DeviceService::instance().pause(error) || !OrderService::instance().pauseOrder(m_orderId, error)) { return false; } pauseProcessTimer(); m_timer->stop(); setState(Paused); emitProcessElapsed(); return true; } bool ProductionService::resume(QString *error) { if (m_state != Paused) { if (error) { *error = "Production service is not paused"; } return false; } if (!checkRecoverySafety(error) || !DeviceService::instance().start(error) || !OrderService::instance().resumeOrder(m_orderId, error)) { return false; } resumeProcessTimer(); setState(m_currentWorkpiece.id > 0 ? WaitingDeviceReady : Preparing); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_timer->start(interval); return true; } bool ProductionService::stop(QString *error) { if (m_state == Idle || m_state == Completed) { if (error) { *error = "Production service is not running"; } return false; } QString operationError; if (m_state != Paused && m_state != TimeoutPaused && m_state != ManualConfirm && !DeviceService::instance().pause(&operationError)) { if (error) { *error = operationError; } return false; } Order order; if (!OrderService::instance().findOrder(m_orderId, &order, &operationError)) { if (error) { *error = operationError; } return false; } if (order.status == "RUNNING" && !OrderService::instance().pauseOrder(m_orderId, &operationError)) { if (error) { *error = operationError; } return false; } m_lastError = "Production stopped by operator"; m_timer->stop(); setState(Idle); QString persistenceError; if (m_runId > 0 && !ProductionRepository().finishRun( m_runId, "STOPPED", m_lastError, &persistenceError)) { if (error) { *error = persistenceError; } return false; } persistRecoveryAction("STOP", m_lastError); m_runId = 0; m_orderId = 0; m_currentWorkpiece = Workpiece(); clearProcessTimer(); emit currentWorkpieceChanged(0, QString()); return true; } bool ProductionService::reset(QString *error) { if (m_state != Error) { if (error) { *error = "Only failed production can be reset"; } return false; } if (!DeviceService::instance().reset(error) || !DeviceService::instance().clearAlarm(error)) { return false; } QString persistenceError; if (!ProductionRepository().clearActiveAlarms( QString(), "SYSTEM", &persistenceError)) { if (error) { *error = persistenceError; } return false; } if (m_currentWorkpiece.id > 0 && !WorkpieceService::instance().updateState( m_currentWorkpiece.id, "PENDING", "RECOVERY", error)) { return false; } m_currentWorkpiece = Workpiece(); clearProcessTimer(); m_lastError.clear(); setState(Preparing); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_heartbeatTimer.restart(); m_timer->start(interval); 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_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); 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; } 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_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) || !DeviceService::instance().start(&operationError)) { if (error) { *error = operationError; } return false; } persistRecoveryAction("CONTINUE", QString("Continue recovery from %1").arg(stateName())); setState(RecoveryChecking); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_heartbeatTimer.restart(); m_timer->start(interval); tick(); return m_state != Error; } bool ProductionService::retry(QString *error) { 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) || !DeviceService::instance().start(&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; } if (!updateCurrentProcessStep(processStep, &operationError, true)) { if (error) { *error = operationError; } return false; } ++m_recoveryRetryCount; persistRecoveryAction("RETRY", QString("Retry production step %1").arg(processStep)); setState(Retrying); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_heartbeatTimer.restart(); m_timer->start(interval); return true; } bool ProductionService::markCurrentWorkpieceNg(QString *error) { 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) || !DeviceService::instance().start(&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, "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()); setState(Preparing); const int interval = qMax(100, ConfigManager::instance() .modbusConfig().pollIntervalMs); m_heartbeatTimer.restart(); m_timer->start(interval); 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()); 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; QString persistenceError; const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; if (!ProductionRepository().startWorkpieceProcess( m_orderId, workpiece.id, workpiece.processStep, m_deviceStatus.currentStep, source, &persistenceError)) { if (error) { *error = persistenceError; } return false; } startProcessTimer(workpiece.processStep); emit currentWorkpieceChanged(workpiece.id, workpiece.barcode); 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_deviceStatus.currentStep, source, durationMs, error, forceRestart)) { return false; } m_currentWorkpiece.processStep = processStep; startProcessTimer(processStep); emitProcessElapsed(); return true; } void ProductionService::startProcessTimer(const QString &processStep) { m_currentProcessStep = processStep; m_processElapsedMs = 0; if (processStep.trimmed().isEmpty()) { m_processTimer.invalidate(); return; } m_processTimer.restart(); } void ProductionService::pauseProcessTimer() { if (m_processTimer.isValid()) { m_processElapsedMs += static_cast(m_processTimer.elapsed()); m_processTimer.invalidate(); } } void ProductionService::resumeProcessTimer() { if (m_currentProcessStep.trimmed().isEmpty()) { return; } m_processTimer.restart(); } void ProductionService::clearProcessTimer() { m_processTimer.invalidate(); m_processElapsedMs = 0; m_currentProcessStep.clear(); } int ProductionService::currentProcessElapsedMs() const { if (!m_processTimer.isValid()) { return m_processElapsedMs; } return m_processElapsedMs + static_cast(m_processTimer.elapsed()); } void ProductionService::emitProcessElapsed() { if (m_currentProcessStep.trimmed().isEmpty()) { return; } emit processElapsedChanged(m_currentProcessStep, currentProcessElapsedMs()); } bool ProductionService::ensureOrderRunning(QString *error) { Order order; if (!OrderService::instance().findOrder(m_orderId, &order, error)) { return false; } if (order.status == "RUNNING") { return true; } if (order.status == "PAUSED") { return OrderService::instance().resumeOrder(m_orderId, error); } if (error) { *error = QString("Order cannot resume from state: %1").arg(order.status); } return false; } bool ProductionService::checkRecoverySafety(QString *error) const { if (!m_deviceStatusValid) { if (error) { *error = "Device status is not available"; } return false; } if (!m_deviceStatus.plcConnected) { if (error) { *error = "PLC is disconnected"; } return false; } if (!m_deviceStatus.plcReady) { if (error) { *error = "PLC is not ready"; } return false; } if (!m_deviceStatus.robotReady) { if (error) { *error = "Robot is not ready"; } return false; } if (!m_deviceStatus.safetyDoorClosed) { if (error) { *error = "Safety door is open"; } return false; } if (m_deviceStatus.emergencyStop) { if (error) { *error = "Emergency stop is active"; } return false; } if (m_deviceStatus.errorCode > 0) { if (error) { *error = QString("PLC error code: %1").arg(m_deviceStatus.errorCode); } return false; } return true; } bool ProductionService::mapPlcStepToState(State *state, QString *processStep) const { if (!state || !processStep) { return false; } const ProductionConfig config = ConfigManager::instance().productionConfig(); if (m_deviceStatus.currentStep == config.loadStep) { *state = Loading; *processStep = "LOADING"; return true; } if (m_deviceStatus.currentStep == config.frontCheckStep) { *state = FrontChecking; *processStep = "FRONT_CHECKING"; return true; } if (m_deviceStatus.currentStep == config.backCheckStep) { *state = BackChecking; *processStep = "BACK_CHECKING"; return true; } if (m_deviceStatus.currentStep == config.unloadStep || m_deviceStatus.currentStep == config.cycleCompleteStep) { *state = Judging; *processStep = "JUDGING"; return true; } return false; } void ProductionService::persistRecoveryAction(const QString &action, const QString &message) { if (m_runId <= 0) { return; } QString persistenceError; if (!ProductionRepository().insertStateHistory( m_runId, m_orderId, m_currentWorkpiece.id, stateName(), stateName(), processStepForState(m_state), "RECOVERY", action, message, &persistenceError)) { qWarning() << "Failed to persist recovery action:" << persistenceError; } } bool ProductionService::finishCurrentWorkpiece(const QString &state, const QString &processStep, QString *error) { if (m_currentWorkpiece.id <= 0) { if (error) { *error = "No current workpiece"; } return false; } const QString previousProcessStep = m_currentWorkpiece.processStep; const int processDurationMs = currentProcessElapsedMs(); const int rawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult : static_cast(m_deviceStatus.checkResult); const QString source = ConfigManager::instance().simulationMode() ? "SIMULATION" : "PLC"; setState(Unloading); if (!WorkpieceService::instance().completeWithInspection( m_currentWorkpiece.id, state, processStep, previousProcessStep, processDurationMs, rawResult, state, m_deviceStatus.currentStep, source, error)) { return false; } clearProcessTimer(); m_currentWorkpiece = Workpiece(); emit currentWorkpieceChanged(0, QString()); 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 (!isActive()) { 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 (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; if (!updateCurrentProcessStep("LOADING", &error)) { fail(error); } else { setState(Loading); } } 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; } switch (m_state) { case Loading: { QString error; if (!updateCurrentProcessStep("FRONT_CHECKING", &error)) { fail(error); } else { setState(FrontChecking); } break; } case FrontChecking: { QString error; if (!updateCurrentProcessStep("BACK_CHECKING", &error)) { fail(error); } else { setState(BackChecking); } break; } case BackChecking: { QString error; if (!updateCurrentProcessStep("JUDGING", &error)) { fail(error); } else { setState(Judging); } break; } case Judging: { const ProductionConfig config = ConfigManager::instance().productionConfig(); QString resultState; if (config.simulationResult == config.okResult) { resultState = "OK"; } else if (config.simulationResult == config.ngResult) { resultState = "NG"; } QString error; if (resultState.isEmpty()) { fail("Invalid simulation inspection result"); } else if (!finishCurrentWorkpiece(resultState, "COMPLETE", &error)) { fail(error); } break; } default: break; } } void ProductionService::tickProduction() { if (m_state == TimeoutWarning) { QString error; if (!processProductionStep(m_timeoutState, &error) && !error.isEmpty()) { fail(error); } return; } 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) { const ProductionConfig config = ConfigManager::instance().productionConfig(); QString resultState; switch (state) { case Loading: if (m_deviceStatus.currentStep == config.frontCheckStep) { if (!updateCurrentProcessStep("FRONT_CHECKING", error)) { return false; } else { setState(FrontChecking); } } break; case FrontChecking: if (m_deviceStatus.currentStep == config.backCheckStep) { if (!updateCurrentProcessStep("BACK_CHECKING", error)) { return false; } else { setState(BackChecking); } } break; case BackChecking: if (m_deviceStatus.currentStep == config.unloadStep) { if (!updateCurrentProcessStep("JUDGING", error)) { return false; } else { setState(Judging); } } break; case Judging: if (m_deviceStatus.currentStep != config.cycleCompleteStep) { return true; } if (m_deviceStatus.checkResult == config.okResult) { resultState = "OK"; } else if (m_deviceStatus.checkResult == config.ngResult) { resultState = "NG"; } else if (m_deviceStatus.checkResult == config.errorResult) { if (error) { *error = QString("PLC inspection error result: %1") .arg(m_deviceStatus.checkResult); } return false; } else { if (error) { *error = QString("Unknown PLC inspection result: %1") .arg(m_deviceStatus.checkResult); } return false; } if (!finishCurrentWorkpiece(resultState, "COMPLETE", error)) { return false; } break; 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 == Loading || state == FrontChecking || state == BackChecking || state == Judging; } QString ProductionService::processStepForState(State state) const { switch (state) { case Preparing: return "PREPARING"; case WaitingDeviceReady: return "WAITING_DEVICE_READY"; case Loading: return "LOADING"; case FrontChecking: return "FRONT_CHECKING"; case BackChecking: return "BACK_CHECKING"; case Judging: return "JUDGING"; default: return QString(); } } 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 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 == "LOADING") return Loading; if (name == "FRONT_CHECKING") return FrontChecking; if (name == "BACK_CHECKING") return BackChecking; 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; 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 == Error) { return; } m_lastError = error.isEmpty() ? "Production failed" : error; 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); } bool ProductionService::isActive() const { return m_state != Idle && m_state != Error && m_state != Completed && m_state != Paused && m_state != TimeoutPaused && m_state != ManualConfirm; } void ProductionService::onDeviceStatusChanged(const DeviceStatus &status) { const bool changed = !m_deviceStatusValid || 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.currentStep != m_deviceStatus.currentStep || status.checkResult != m_deviceStatus.checkResult || status.errorCode != m_deviceStatus.errorCode; m_deviceStatus = status; m_deviceStatusValid = true; if (changed) { persistDeviceStatus(status); } } void ProductionService::onCommunicationError(const QString &error) { if (m_state == RecoveryChecking) { m_lastError = error; return; } if (isActive()) { fail(error); } }