#ifndef PRODUCTIONSERVICE_H #define PRODUCTIONSERVICE_H #include "deviceservice.h" #include "../models/workpiece.h" #include "../repositories/productionrepository.h" #include #include #include #include class QTimer; class ProductionService : public QObject { Q_OBJECT public: enum State { Idle, Preparing, WaitingDeviceReady, PhotoMoving, VisionProcessing, RackPicking, FrontLoading, Loading, FrontChecking, FrontUnloading, Flipping, BackLoading, BackChecking, BackUnloading, ReverseFlipping, RackPlacing, Judging, Unloading, Paused, Error, Completed, TimeoutWarning, TimeoutPaused, RecoveryChecking, ManualConfirm, Retrying, Terminating }; Q_ENUM(State) struct Snapshot { bool initialized = false; int runId = 0; int orderId = 0; State state = Idle; QString stateName; bool terminationRequired = false; bool visionRecoveryRequired = false; QString error; }; Snapshot snapshot() const; static ProductionService &instance(); State state() const; QString stateName() const; int orderId() const; int currentTrayNo() const; int currentSlotNo() const; QString inspectionMode() const; Workpiece currentWorkpiece() const; bool start(int orderId, QString *error = nullptr); bool pause(QString *error = nullptr); bool resume(QString *error = nullptr); bool stop(QString *error = nullptr, bool finishOrder = false); bool stopOrder(int orderId, QString *error = nullptr); bool stopConfirmedOrder(int runId, int orderId, QString *error = nullptr); bool clearAlarm(QString *error = nullptr); bool recover(QString *error = nullptr); bool submitRecoveryDecision(const QJsonObject &decision, QString *error = nullptr); bool markCurrentWorkpieceNg(QString *error = nullptr); bool restoreActiveRun(QString *error = nullptr); void shutdown(const DeviceService::OperationCallback &callback); void setExternalStopFlag(std::atomic_bool *flag); void requestStopImmediate(); public slots: void onVisionAvailability(bool ready, bool busy, const QString &session); void onVisionResult(const QJsonObject &result); void publishVisionSnapshot(); signals: void snapshotChanged(const ProductionService::Snapshot &snapshot); void stateChanged(ProductionService::State state, const QString &name); void deviceStatusChanged(const DeviceStatus &status); void deviceCommunicationError(const QString &error); void currentWorkpieceChanged(int workpieceId, const QString &barcode); void currentWorkpieceSnapshotChanged(const Workpiece &workpiece); void currentPositionChanged(int trayNo, int slotNo); void productionFinished(int orderId); void productionError(const QString &error); void alarmRaised(const QString &code, const QString &message); void processElapsedChanged(const QString &processStep, int elapsedMs); void timeoutWarning(const QString &state, int elapsedMs, int timeoutMs); void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); void recoveryDecisionRequired(const QJsonObject &context); void recoveryBusyChanged(bool busy); void visionMeasureRequested(const QJsonObject &request); void visionCancelRequested(const QString &requestId); void visionCycleChanged(const QJsonObject &cycle); void visionProductionActiveChanged(bool active, bool maintenanceAllowed); private slots: void tick(); void onDeviceStatusChanged(const DeviceStatus &status); void onCommunicationError(const QString &error); public: explicit ProductionService(QObject *parent = nullptr); ~ProductionService() override; private: friend class VisionProductionTest; enum class VisionStage { Idle, ReadingPose, Measuring, WritingPose, Publishing, Complete, Fault }; void prepareVision(); void advanceVision(); void beginVisionMeasurement(); void publishPickMode(bool useVision); void skipVision(const QString &reason); bool visionCurrent(quint64 generation) const; void setVisionStage(VisionStage stage, const QString &message); void reportVision(const QString &phase, const QString &message, bool invalidated = false); void invalidateVision(const QString &reason); void visionFault(const QString &reason); void publishVisionControl(); bool saveVisionRecoveryState(bool pending, QString *error); void loadVisionRecoveryState(); ProductionService(const ProductionService &) = delete; ProductionService &operator=(const ProductionService &) = delete; bool setState(State state); void publishState(); bool restoreRun(QString *error); QString actionTypeForState(State state) const; QString nextStepForState(State state) const; bool ensureActionCheckpoint(State state, QString *error); bool saveActionPhase(const QString &phase, QString *error); bool saveActionCompletion(ProductionActionCheckpoint *action, const QString &nextStep, int nextWorkpieceId, QString *error); bool actionCallbackCurrent(quint64 generation, const QString &token, int attempt) const; bool loadRecoverySnapshot(QString *error); void finishRecoveryCheck(const QString &error = QString()); void requestManualDecision(State state, const ProductionActionStatus &status, const QString &reason, const QStringList &options); void resumeRecoveredState(State state); bool saveManualDecision(const QJsonObject &decision, QString *error); void checkVisionRecovery(const QJsonObject &decision = QJsonObject()); bool pickTargetValid() const; bool claimNextWorkpiece(QString *error); bool updateCurrentProcessStep(const QString &processStep, QString *error, bool forceRestart = false); bool finishCurrentWorkpiece(const QString &state, const QString &processStep, QString *error); bool finishOrder(QString *error); bool finalizeRun(bool completed, bool finishOrder, QString *error); void tickSimulation(); void tickProduction(); bool processProductionStep(State state, QString *error); bool recoverFromPlcStep(QString *error); bool processProductionAction(DeviceService::ProductionAction action, bool *completed, QString *error); bool processVisionAction(bool *completed, QString *error); void cancelPendingProductionAction( const DeviceService::OperationCallback &callback); void tryDeferredActionCancel(); bool executeCurrentAction(DeviceService::ProductionAction action, const QString &nextProcessStep, State nextState, QString *error); bool pauseAtActionBoundary(QString *error = nullptr); void abortVisionForPause(); bool productionActionForState(State state, DeviceService::ProductionAction *action) const; void continueRecovery(State state, DeviceService::ProductionAction action, const ProductionActionStatus &status); bool recordInspection(const QString &side, int rawResult, const QString &resultState, QString *error); QString resultStateForRawResult(int rawResult) const; bool ensureOrderRunning(QString *error); bool checkRecoverySafety(QString *error) const; void startProcessTimer(const QString &processStep); void pauseProcessTimer(); void resumeProcessTimer(); void clearProcessTimer(); int currentProcessElapsedMs() const; void emitProcessElapsed(); void persistRecoveryAction(const QString &action, const QString &message); bool isTimedState(State state) const; QString stateNameForState(State state) const; QString processStepForState(State state) const; State stateForProcessStep(const QString &processStep) const; QString runStateForState(State state) const; State stateFromName(const QString &name) const; void persistAlarm(const QString &code, const QString &message); void persistDeviceStatus(const DeviceStatus &status); void fail(const QString &error); void finishShutdown(bool success, const QString &error); bool isActive() const; bool stopRequested() const; QTimer *m_timer; DeviceService *m_deviceService; QElapsedTimer m_stateTimer; QElapsedTimer m_processTimer; QElapsedTimer m_heartbeatTimer; State m_state; bool m_initialized = false; bool m_terminationRequired = false; State m_timeoutState; int m_runId; int m_orderId; Workpiece m_currentWorkpiece; DeviceStatus m_deviceStatus; bool m_deviceStatusValid; int m_recoveryRetryCount; int m_processElapsedMs; int m_currentTrayNo; int m_currentSlotNo; int m_frontRawResult; bool m_actionPending; bool m_actionStarting; bool m_actionPollPending; bool m_actionCompleted; QString m_actionError; bool m_actionCancelRequested; DeviceService::OperationCallback m_deferredCancelCallback; bool m_inspectionStatusPending; bool m_inspectionStatusReady; int m_inspectionRawResult = 0; QString m_inspectionStatusError; bool m_starting; bool m_plcStarted; bool m_tickRunning; bool m_pauseAfterCurrentAction; bool m_recoveryCheckPending; quint64 m_actionGeneration = 0; quint64 m_recoveryGeneration = 0; ProductionActionCheckpoint m_checkpoint; QJsonObject m_manualContext; bool m_recoveryKeepPaused = false; bool m_recoveryIdleUnlock = false; bool m_targetReady = false; int m_targetWorkpieceId = 0; QString m_targetSession; bool m_targetUsesVision = false; bool m_forceNormalPick = false; bool m_restoredRun = false; bool m_persistenceUncertain = false; DeviceService::ProductionAction m_pendingAction; QString m_inspectionMode; QString m_frontResultState; QString m_recoveryAlarmCode; QString m_currentProcessStep; QString m_lastError; std::atomic_bool m_stopRequested; std::atomic_bool *m_externalStopRequested; bool m_shutdownRequested; DeviceService::OperationCallback m_shutdownCallback; VisionStage m_visionStage = VisionStage::Idle; QElapsedTimer m_visionTimer; QJsonObject m_visionRequest; QJsonObject m_visionResult; quint64 m_visionGeneration = 0; int m_visionWorkpieceId = 0; int m_visionTrayNo = 0; QString m_visionSession; QString m_availableVisionSession; bool m_visionEnabled = false; bool m_visionIoPending = false; bool m_visionSuspended = false; bool m_visionCommitStarted = false; bool m_visionNeedsReconcile = false; QString m_visionStatePath; }; Q_DECLARE_METATYPE(ProductionService::State) Q_DECLARE_METATYPE(ProductionService::Snapshot) Q_DECLARE_METATYPE(Workpiece) #endif // PRODUCTIONSERVICE_H