LGES-OC5-PtoP-Welder/Machines/ILSOS_PrismaticRD_PTOP/Sequences/SequenceManager.cs

using Aurora;
using Aurora.Api;
using ILSOS_PrismaticRD_PTOP.Sequences;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WeldingCommon;
using WeldingCommon.Devices;
using WeldingCommon.RMS;
using WeldingCommon.Sequences;
using WeldingCommon.Sequences.Main;
using WeldingCommon.Settings;

namespace ILSOS_PrismaticRD_PTOP.Sequences
{
    public class SequenceManager : CommonSequenceManager
    {
        private static readonly SequenceManager _SequenceManager;
        internal static SequenceManager Instance { get => _SequenceManager; }

        // Calibration Sequence
        SeqMarkGrid _SeqMarkGrid;
        SeqScannerCalibration _SeqScannerCalibration;

        // MainProcess Sequence
        SeqReceiveCellInfo _SeqReceiveCellInfo;
        SeqReportCellResult _SeqReportCellResult;
        SeqScoutFlyingVision _SeqScoutFlyingVision;
        SeqScoutNormal _SeqScoutNormal;
        SeqExecutePlcBitInterface _SeqExecutePlcBitInterface;
        SeqExecutePlcBitInterface _SeqExecutePlcBitInterfaceForStatusChange;
        SeqCheckWeldingComplete _SeqCheckWeldingComplete;
        SeqWaitWeldOrChangePage _SeqWaitWeldOrChangePage;

        // Manual Sequence
        SeqTeachingRun _SeqTeachingRun;
        SeqComponentTeachingRun _SeqComponentTeachingRun;

        private static Dictionary<string, SequenceBuilder> mapSequenceBuilders = new Dictionary<string, SequenceBuilder>();

        static SequenceManager()
        {
            _SequenceManager = new SequenceManager();
        }

        internal void UpdateSequenceStatus(SequenceSetting sequenceSetting, ISequenceEntry sequenceEntry)
        {
            ChangeRunState(sequenceEntry, CommonSequenceIds.PLCMonitor, true);
            //ChangeRunState(sequenceEntry, CommonSequenceIds.AlarmMonitor, sequenceSetting.AlarmMonitor);
            //ChangeRunState(sequenceEntry, CommonSequenceIds.AlarmMonitor, true);
            //ChangeRunState(sequenceEntry, SequenceIds.DeviceMonitor, sequenceSetting.DeviceMonitor);
            //ChangeRunState(sequenceEntry, SequenceIds.MESMonitor, sequenceSetting.MESMonitor);
        }

        private void ChangeRunState(ISequenceEntry sequenceEntry, string sequenceId, bool isRunning, object param = null)
        {
            if (isRunning) {
                if (sequenceEntry[sequenceId].RunState != SequenceRunState.Running) {
                    sequenceEntry[sequenceId].Start(param);
                }
            } else {
                if (sequenceEntry[sequenceId].RunState == SequenceRunState.Running) {
                    sequenceEntry[sequenceId].Stop();
                }
            }
        }

        internal static void RegisterSequence(IAuroraEnvironment aurora, SequenceRegister register)
        {
            _SequenceManager.Register(aurora, register);
        }

        public static void RegisterSequenceBuilder(SequenceRegister register, string seqId, SequenceBuilder builder)
        {
            mapSequenceBuilders.Add(seqId, builder);
        }

        public override void Register(IAuroraEnvironment aurora, SequenceRegister register)
        {
            register(CommonSequenceIds.PLCMonitor, PLCMonitor.Builder());
            //register(CommonSequenceIds.AlarmMonitor, AlarmMonitoring.Builder());
            //register(CommonSequenceIds.DeviceMonitor, DeviceMonitoring.Builder());
            base.Register(aurora, register);

            if (_SeqMarkGrid == null) {
                _SeqMarkGrid = new SeqMarkGrid();
            }
            register(CommonSequenceIds.SeqMarkGrid, _SeqMarkGrid.Builder());

            if (_SeqScannerCalibration == null) {
                _SeqScannerCalibration = new SeqScannerCalibration();
            }
            register(CommonSequenceIds.SeqScannerCalibration, _SeqScannerCalibration.Builder());

            if (_SeqReceiveCellInfo == null) {
                _SeqReceiveCellInfo = new SeqReceiveCellInfo();
            }
            register(CommonSequenceIds.SeqReceiveCellInfo, _SeqReceiveCellInfo.Builder());

            if (_SeqReportCellResult == null) {
                _SeqReportCellResult = new SeqReportCellResult();
            }
            register(CommonSequenceIds.SeqReportCellResult, _SeqReportCellResult.Builder());

            if (_SeqScoutFlyingVision == null) {
                _SeqScoutFlyingVision = new SeqScoutFlyingVision();
            }
            register(CommonSequenceIds.SeqScoutFlyingVision, _SeqScoutFlyingVision.Builder());

            if (_SeqScoutNormal == null) {
                _SeqScoutNormal = new SeqScoutNormal();
            }
            register(CommonSequenceIds.SeqScoutNormal, _SeqScoutNormal.Builder());


            if (_SeqExecutePlcBitInterface == null) {
                _SeqExecutePlcBitInterface = new SeqExecutePlcBitInterface();
            }
            register(CommonSequenceIds.SeqExecutePlcBitInterface, _SeqExecutePlcBitInterface.Builder());

            if (_SeqExecutePlcBitInterfaceForStatusChange == null) {
                _SeqExecutePlcBitInterfaceForStatusChange = new SeqExecutePlcBitInterface();
            }
            register(CommonSequenceIds.SeqExecutePlcBitInterfaceForStatusChange, _SeqExecutePlcBitInterfaceForStatusChange.Builder());

            if (_SeqCheckWeldingComplete == null) {
                _SeqCheckWeldingComplete = new SeqCheckWeldingComplete();
            }
            register(CommonSequenceIds.SeqCheckWeldingComplete, _SeqCheckWeldingComplete.Builder());

            if (_SeqTeachingRun == null) {
                _SeqTeachingRun = new SeqTeachingRun();
            }
            register(CommonSequenceIds.SeqTeachingRun, _SeqTeachingRun.Builder());

            if (_SeqComponentTeachingRun == null) {
                _SeqComponentTeachingRun = new SeqComponentTeachingRun();
            }
            register(CommonSequenceIds.SeqComponentTeachingRun, _SeqComponentTeachingRun.Builder());

            if (_SeqWaitWeldOrChangePage == null) {
                _SeqWaitWeldOrChangePage = new SeqWaitWeldOrChangePage();
            }
            register(CommonSequenceIds.SeqWaitWeldOrChangePage, _SeqWaitWeldOrChangePage.Builder());
        }

        // MainProcess Sequence
        public static SequenceBuilder GetSeqBuilder_SeqReceiveCellInfo() { return Instance._SeqReceiveCellInfo.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqReportCellResult() { return Instance._SeqReportCellResult.Builder(); }

        public static SequenceBuilder GetSeqBuilder_SeqScoutFlyingVision() { return Instance._SeqScoutFlyingVision.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqScoutNormal() { return Instance._SeqScoutNormal.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqExecutePlcBitInterface() { return Instance._SeqExecutePlcBitInterface.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqExecutePlcBitInterfaceForStatusChange() { return Instance._SeqExecutePlcBitInterfaceForStatusChange.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqCheckWeldingComplete() { return Instance._SeqCheckWeldingComplete.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqWaitWeldOrChangePage() { return Instance._SeqWaitWeldOrChangePage.Builder(); }

        // Manual Sequence
        public static SequenceBuilder GetSeqBuilder_SeqTeachingRun() { return Instance._SeqTeachingRun.Builder(); }
        public static SequenceBuilder GetSeqBuilder_SeqComponentTeachingRun() { return Instance._SeqComponentTeachingRun.Builder(); }

        public virtual void Terminate()
        {

        }
    }
}