Kepler-Release/Venus/Venus_RT/Modules/RouteManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Fsm;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_Core;
using Venus_RT.Modules.PMs;
using Aitex.Core.RT.Log;
using Venus_RT.HostWrapper;
using Venus_RT.Modules.VCE;
using Venus_RT.Devices.PreAligner;
using Venus_RT.Modules.TM.VenusEntity;

namespace Venus_RT.Modules
{
    class RouteManager : Entity, IEntity
    {

        public enum MSG
        {
            MoveWafer,
            ReturnWafer,

            HomeUnit,

            PauseAuto,
            ResumeAuto,

            Stop,

            StartCycle,
            StopCycle,

            HOME,
            RESET,
            ABORT,
            ERROR,

            SetAutoMode,
            SetManualMode,

            ResetIdleCleanTime,
            ResetIdlePurgeTime,

            CreateJob,
            PauseJob,
            ResumeJob,
            StartJob,
            StopJob,
            AbortJob,
            JobDone,
            CassetteLeave,  //For unload light control off afer job done

            Map,
            ReturnAllWafer,
            TMCycle,
            
			SETMCycle,
            StopSECycle,
            CreateSEJob,
            StartSEJob,
            AbortSEJob,
            SEMoveWafer,
            SEReturnWafer,
            SEAbort,
        }

        public PMEntity PMA { get; private set; }
        public PMEntity PMB { get; private set; }
        public PMEntity PMC { get; private set; }
        public PMEntity PMD { get; private set; }

        public TMEntity TM { get; private set; }

        public LLEntity LLA { get; private set; }

        public LLEntity LLB { get; private set; }

        public EfemEntity EFEM { get; private set; }

        public VceEntity VCE { get; private set; }

        public SETMEntity seTM { get; private set; }



        public string Name { get; set; }

        public bool IsAutoMode
        {
            get
            {
                return fsm.State == (int)RtState.AutoRunning || fsm.State == (int)RtState.AutoIdle;
            }
        }

        public bool IsInit
        {
            get { return fsm.State == (int)RtState.Init; }
        }

        public bool IsIdle
        {
            get { return fsm.State == (int)RtState.Idle || fsm.State == (int)RtState.AutoIdle; }
        }
        public bool IsAlarm
        {
            get { return fsm.State == (int)RtState.Error; }
        }

        public bool IsPaused
        {
            get { return _AutoCycle.CycleState == RState.Paused; }
        }

        public bool IsEntityError
        {
            get
            {
                return (EFEM?.IsError ?? false)
                       || (PMA?.IsError ?? false)
                       || (PMB?.IsError ?? false)
                       || (PMC?.IsError ?? false)
                       || (PMD?.IsError ?? false);
            }
        }

        public bool IsRunning
        {
            get
            {
                return !IsInit && !IsAlarm && !IsIdle;
            }
        }

        public static bool IsATMMode
        {
            get
            {
                if(_isATMMode == -1)
                {
                    _isATMMode = SC.GetValue<bool>("System.IsATMMode") ? 1 : 0;
                }

                return _isATMMode == 1;
            }
        }

        public SequenceLLInOutPath LLInOutPath => _AutoCycle.LLInOutPath;

        private TMCycle _TMCycle;
        private AutoCycle _AutoCycle;
        private ManualTransfer _manualTransfer;
        private ReturnAllWafer _returnWafer;
		private SETMCycle _seTMCycle;
        private SEManualTransfer _setransfer;
        private SEReturnWafer _sereturnWafer;

        private bool _isWaitUnload;
        private static int _isATMMode = -1;

        public RouteManager()
        {
            Name = "System";

            if (ModuleHelper.IsInstalled(ModuleName.PMA))
                PMA = new PMEntity(ModuleName.PMA);

            if (ModuleHelper.IsInstalled(ModuleName.PMB))
                PMB = new PMEntity(ModuleName.PMB);

            if (ModuleHelper.IsInstalled(ModuleName.PMC))
                PMC = new PMEntity(ModuleName.PMC);

            if (ModuleHelper.IsInstalled(ModuleName.PMD))
                PMD = new PMEntity(ModuleName.PMD);

            if (ModuleHelper.IsInstalled(ModuleName.TM))
                TM = new TMEntity();

            if (ModuleHelper.IsInstalled(ModuleName.LLA))
                LLA = new LLEntity(ModuleName.LLA);

            if (ModuleHelper.IsInstalled(ModuleName.LLB))
                LLB = new LLEntity(ModuleName.LLB);

            if (ModuleHelper.IsInstalled(ModuleName.EFEM))
                EFEM = new EfemEntity();

            if (ModuleHelper.IsInstalled(ModuleName.VCE1))
            {
                //临时加 后改为配置项
                VCE = new VceEntity(ModuleName.VCE1);
            }
            if (ModuleHelper.IsInstalled(ModuleName.SETM))
            {
                seTM = new SETMEntity();
            }
                

            fsm = new StateMachine<RouteManager>(Name, (int)RtState.Init, 200);

            SubscribeOperation();
            SubscribeDataVariable();
        }

        public bool Check(int msg, out string reason, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                reason = String.Format("{0} is in {1} state，can not do {2}", Name, 0, (MSG)msg);
                return false;
            }

            if (msg == (int)MSG.StartCycle)
            {
                if (!IsAutoMode)
                {
                    reason = String.Format("can not do {0}, isn't auto mode.", msg.ToString());
                    return false;
                }
            }
            reason = "";

            return true;
        }

        void SubscribeDataVariable()
        {
            DATA.Subscribe("Rt.Status", () => ((RtState)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe(ModuleName.System.ToString(), "AlarmEvent", EV.GetAlarmEvent, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe("System.IsAutoMode", () => IsAutoMode, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("System.IsIdle", () => IsIdle || IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("System.IsAlarm", () => IsAlarm || IsEntityError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("System.IsBusy", () => IsRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("System.IsWaitUnload", () => _isWaitUnload && IsAutoMode, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("System.IsConnectedWithHost", () => Singleton<FaManager>.Instance.IsConnected, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe("EquipmentMode", () => IsAutoMode ? 0 : 1, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe("EquipmentStatus", () =>
            {
                //"0 = Uninit
                //1 = Idle
                //2 = Running
                //3 = Error
                //4 = Pause
                //"
                if (IsInit) return 0;
                if (IsIdle) return 1;
                if (IsAlarm) return 3;
                if (IsPaused) return 4;

                return 2;
            }, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }

        void SubscribeOperation()
        {
            OP.Subscribe("CreateWafer", InvokeCreateWafer);

            OP.Subscribe("DeleteWafer", InvokeDeleteWafer);


            OP.Subscribe("System.Home", (cmd, args) => CheckToPostMessage((int)MSG.HOME, args));
            OP.Subscribe("TMCycle.Start", (cmd, args) => CheckToPostMessage((int)MSG.TMCycle, args));
            OP.Subscribe("TMCycle.Abort", (cmd, args) => CheckToPostMessage((int)MSG.StopCycle, args));

			OP.Subscribe("System.StopSECycle", (cmd, args) => CheckToPostMessage((int)MSG.StopSECycle, args));	

            DATA.Subscribe("SYSTEM.FsmState", () => (((RtState)fsm.State).ToString()));
            DATA.Subscribe("TMCycle.CycleIndex", () => (_TMCycle?.CycleIndex));

            OP.Subscribe("ReturnWafer", InvokeReturnWafer);

            OP.Subscribe("System.ReturnAllWafer", (string cmd, object[] args) =>
            {

                if (seTM != null && VCE != null)
                    return CheckToPostMessage((int)MSG.SEReturnWafer, args);
                else
                    return CheckToPostMessage((int)MSG.ReturnAllWafer, args[0], args[1], args[2], args[3]);
            });
            OP.Subscribe("System.MoveWafer", (string cmd, object[] args) =>
            {
                if (!Enum.TryParse((string)args[0], out ModuleName source))
                {
                    EV.PostWarningLog(Name, $"Parameter source {(string)args[0]} not valid");
                    return false;
                }

                if (!Enum.TryParse((string)args[2], out ModuleName destination))
                {
                    EV.PostWarningLog(Name, $"Parameter destination {(string)args[1]} not valid");
                    return false;
                }

                if (seTM!=null && VCE!=null)
                    return CheckToPostMessage((int)MSG.SEMoveWafer,
                        source, (int)args[1],
                        destination, (int)args[3],
                        args[4], args[5],
                        args[6], args[7], (string)args[8]);
                else
                    return CheckToPostMessage((int)MSG.MoveWafer,
                        source, (int)args[1],
                        destination, (int)args[3],
                        args[4], args[5],
                        args[6], args[7], (string)args[8]);
            });

            OP.Subscribe("System.HomeAll", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.HOME);
            });
            OP.Subscribe("System.Abort", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.ABORT);
            });

            OP.Subscribe("System.Reset", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.RESET);
            });

            OP.Subscribe("System.SetAutoMode", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.SetAutoMode);
            });
            OP.Subscribe("System.SetManualMode", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.SetManualMode);
            });

            OP.Subscribe("System.CreateJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.CreateJob, args[0]);
            });

            OP.Subscribe("System.StartJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.StartJob, args[0]);
            });

            OP.Subscribe("System.PauseJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.PauseJob, args[0]);
            });

            OP.Subscribe("System.ResumeJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.ResumeJob, args[0]);
            });

            OP.Subscribe("System.StopJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.StopJob, args[0]);
            });

            OP.Subscribe("System.AbortJob", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.AbortJob, args[0]);
            });

            OP.Subscribe("LP1.Map", (string cmd, object[] args) =>
            {
                if (IsAutoMode)
                {
                    return CheckToPostMessage((int)MSG.Map, ModuleName.LP1.ToString());
                }

                return EFEM.InvokeMap(ModuleName.LP1.ToString()) != (int)FSM_MSG.NONE;
            });


            OP.Subscribe("LP2.Map", (string cmd, object[] args) =>
            {
                if (IsAutoMode)
                {
                    return CheckToPostMessage((int)MSG.Map, ModuleName.LP2.ToString());
                }

                return EFEM.InvokeMap(ModuleName.LP2.ToString()) != (int)FSM_MSG.NONE;
            });

            OP.Subscribe(RtOperation.SetConfig.ToString(), (name, args) =>
            {
                string sc_key = args[0] as string;
                if (!string.IsNullOrWhiteSpace(sc_key) && args.Length > 1)
                {
                    SC.SetItemValue(sc_key, args[1]);
                }

                return true;
            });

            OP.Subscribe("System.ResetIdleCleanTime", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.ResetIdleCleanTime, args[0]);
            });

            OP.Subscribe("System.ResetIdlePurgeTime", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.ResetIdlePurgeTime, args[0]);
            });

            OP.Subscribe("System.SetWaferSize", (string cmd, object[] args) =>
            {
                string module = (string)args[0];
                string size = (string)args[1];
                switch (size)
                {
                    case "3":
                        WaferManager.Instance.UpdateWaferSize(ModuleHelper.Converter(module), 0, WaferSize.WS3);
                        break;
                    case "4":
                        WaferManager.Instance.UpdateWaferSize(ModuleHelper.Converter(module), 0, WaferSize.WS4);
                        break;
                    case "6":
                        WaferManager.Instance.UpdateWaferSize(ModuleHelper.Converter(module), 0, WaferSize.WS6);
                        break;
                    default:
                        EV.PostWarningLog("System", $"wafer size {size} not valid");
                        break;
                }

                return true;
            });

            OP.Subscribe("System.CassetteLeave", (string cmd, object[] args) =>
            {
                return CheckToPostMessage((int)MSG.CassetteLeave);
            });

            OP.Subscribe("System.IsModuleInstalled", (string cmd, object[] args) => {
                return ModuleHelper.IsInstalled((ModuleName)args[0]);
            });
			OP.Subscribe("System.SETMCycle", (cmd, args) => CheckToPostMessage((int)MSG.SETMCycle, args));
            OP.Subscribe("System.CreateSEJob", (cmd, args) => CheckToPostMessage((int)MSG.CreateSEJob, args));
            OP.Subscribe("System.StartSEJob",(cmd,args)=>CheckToPostMessage((int)MSG.StartSEJob,args));
            OP.Subscribe("System.ReturnAllSEWafer", (cmd, args) => CheckToPostMessage((int)MSG.SEReturnWafer, args));
            OP.Subscribe("System.SEAbort", (cmd, args) => CheckToPostMessage((int)MSG.SEAbort, args));
        }
        public bool CheckToPostMessage(int msg, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"System is in {(RtState)fsm.State} state，can not do {(MSG)msg}");
                return false;
            }

            Running = true;
            fsm.PostMsg(msg, args);

            return true;
        }

        private bool InvokeCreateWafer(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            int slot = (int)args[1];
            WaferStatus state = WaferStatus.Normal;

            if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
            {
                if (WaferManager.Instance.CheckHasWafer(chamber, slot))
                {
                    LOG.Write(eEvent.EV_ROUTER, "System", string.Format("{0} slot {1} already has wafer.create wafer is not valid", chamber, slot));
                }
                else if (WaferManager.Instance.CreateWafer(chamber, slot, state) != null)
                {
                    LOG.Write(eEvent.EV_WAFER_CREATE, ModuleName.System, chamber.ToString(), (slot + 1).ToString(), state.ToString());
                }
            }
            else
            {
                LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                return false;
            }

            return true;
        }
        private bool InvokeDeleteWafer(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            int slot = (int)args[1];

            if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
            {
                if (WaferManager.Instance.CheckHasWafer(chamber, slot))
                {
                    WaferManager.Instance.DeleteWafer(chamber, slot);
                    EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDelete, chamber.ToString(), slot + 1);
                }
                else
                {
                    LOG.Write(eEvent.EV_ROUTER, "System", string.Format("No wafer at {0} {1}, delete not valid", chamber.ToString(), slot + 1));
                }
            }
            else
            {
                LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                return false;
            }

            return true;
        }

        private bool InvokeReturnWafer(string arg1, object[] args)
        {
            ModuleName target = ModuleHelper.Converter(args[0].ToString());
            int slot = (int)args[1];
            if (seTM != null && VCE != null)
            {
                if (ModuleHelper.IsVCE(target))
                {
                    LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("Wafer already at vce {0} {1}, return operation is not valid", target.ToString(), slot + 1));
                    return false;
                }
                WaferInfo wafer = WaferManager.Instance.GetWafer(target,slot);
                if (wafer.IsEmpty)
                {
                    LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("No wafer at {0} {1}, return operation is not valid", target.ToString(), slot + 1));
                    return false;
                }
                return CheckToPostMessage((int)MSG.SEMoveWafer,
                        target, slot,
                        (ModuleName)wafer.OriginStation, wafer.OriginSlot,
                        false, 0, false, 0, "Blade1");
            }
            else 
            {
                if (ModuleHelper.IsLoadPort(target))
                {
                    LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("Wafer already at LoadPort {0} {1}, return operation is not valid", target.ToString(), slot + 1));
                    return false;
                }

                if (!WaferManager.Instance.IsWaferSlotLocationValid(target, slot))
                {
                    LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("Invalid position，{0}，{1}", target.ToString(), slot.ToString()));
                    return false;
                }

                WaferInfo wafer = WaferManager.Instance.GetWafer(target, slot);
                if (wafer.IsEmpty)
                {
                    LOG.Write(eEvent.WARN_ROUTER, "System", string.Format("No wafer at {0} {1}, return operation is not valid", target.ToString(), slot + 1));
                    return false;
                }

                return CheckToPostMessage((int)MSG.MoveWafer,
                    target, slot,
                    (ModuleName)wafer.OriginStation, wafer.OriginSlot,
                    false, 0, false, 0, "Blade1");
            }
            
        }

        public PMEntity GetPM(ModuleName mod)
        {
            if (ModuleHelper.IsInstalled(mod))
            {
                switch (mod)
                {
                    case ModuleName.PMA:
                        return PMA;
                    case ModuleName.PMB:
                        return PMB;
                    case ModuleName.PMC:
                        return PMC;
                    case ModuleName.PMD:
                        return PMD;
                }
            }

            return null;
        }

        public LLEntity GetLL(ModuleName mod)
        {
            if (ModuleHelper.IsInstalled(mod))
            {
                switch (mod)
                {
                    case ModuleName.LLA:
                        return LLA;
                    case ModuleName.LLB:
                        return LLB;
                }
            }

            return null;
        }

        public VceEntity GetVCE(ModuleName mod)
        {
            if (ModuleHelper.IsInstalled(mod))
            {
                return VCE;
            }

            return null;
        }

        

        public TMEntity GetTM()
        {
            return TM;
        }
    

        protected override bool Init()
        {
            PMA?.Initialize();
            PMB?.Initialize();
            PMC?.Initialize();
            PMD?.Initialize();
            TM?.Initialize();
            LLA?.Initialize();
            LLB?.Initialize();

            EFEM?.Initialize();
            VCE?.Initialize();
            seTM?.Initialize();

            _TMCycle = new TMCycle();
            _AutoCycle = new AutoCycle();
            _manualTransfer = new ManualTransfer();
            _returnWafer = new ReturnAllWafer(_manualTransfer);
			_seTMCycle = new SETMCycle(ModuleName.SETM);
            _setransfer = new SEManualTransfer();
            _sereturnWafer = new SEReturnWafer(_setransfer);


            BuildTransitionTable();
            return true;
        }
       
        private void BuildTransitionTable()
        {
            //Init sequence
            Transition(RtState.Init,            MSG.HOME,               FsmStartHome,               RtState.Initializing);
            Transition(RtState.Idle,            MSG.HOME,               FsmStartHome,               RtState.Initializing);
            Transition(RtState.Error,           MSG.HOME,               FsmStartHome,               RtState.Initializing);

            EnterExitTransition<RtState, FSM_MSG>(RtState.AutoRunning,  FsmEnterAutoRunning,        FSM_MSG.NONE,       FsmExitAutoTransfer);
            EnterExitTransition<RtState, FSM_MSG>(RtState.Transfer,     null,                       FSM_MSG.NONE,       FsmExitTransfer);
            EnterExitTransition<RtState, FSM_MSG>(RtState.ReturnWafer,  null,                       FSM_MSG.NONE,       FsmExitReturnWafer);

            AnyStateTransition(MSG.ERROR,       FsmError,               RtState.Error);

            Transition(RtState.Idle,            FSM_MSG.TIMER,          FsmMonitor,                 RtState.Idle);
            Transition(RtState.Init,            FSM_MSG.TIMER,          FsmMonitor,                 RtState.Init);

            Transition(RtState.Initializing,    FSM_MSG.TIMER,          FsmMonitorHome,             RtState.Idle);
            Transition(RtState.Initializing,    MSG.ERROR,              FsmError,                   RtState.Error);
            Transition(RtState.Initializing,    MSG.ABORT,              FsmAbort,                   RtState.Init);


            // TM  Cycle
            Transition(RtState.Idle,            MSG.TMCycle,            FsmStartTMCycle,            RtState.TMCycle);
            Transition(RtState.TMCycle,         FSM_MSG.TIMER,          FsmMonitorTMCycle,          RtState.Idle);
            Transition(RtState.TMCycle,         MSG.StopCycle,          FsmStopTMCycle,             RtState.Idle);

            //Auto/manual 
            Transition(RtState.Idle,            MSG.SetAutoMode,        FsmStartAutoTransfer,       RtState.AutoIdle);

            Transition(RtState.AutoRunning,     FSM_MSG.TIMER,          FsmAutoTransfer,            RtState.Idle);
            Transition(RtState.AutoRunning,     MSG.ABORT,              FsmAbortAutoTransfer,       RtState.Idle);
            //Transition(RtState.AutoRunning,   MSG.SetManualMode,      FsmStartSetManualMode,      RtState.Idle);
            Transition(RtState.AutoRunning,     MSG.JobDone,            FsmJobDone,                 RtState.AutoIdle);
            //Transition(RtState.AutoRunning,   MSG.CassetteLeave,      fCassetteLeave,             RtState.AutoRunning);   //For unload light control off afer job done

            Transition(RtState.AutoRunning,     MSG.CreateJob,          FsmCreateJob,               RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.StartJob,           FsmStartJob,                RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.PauseJob,           FsmPauseJob,                RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.ResumeJob,          FsmResumeJob,               RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.StopJob,            FsmStopJob,                 RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.AbortJob,           FsmAbortJob,                RtState.AutoRunning);

            Transition(RtState.AutoRunning,     MSG.MoveWafer,          FsmAutoReturnWafer,         RtState.AutoRunning);

            Transition(RtState.AutoRunning,     MSG.Map,                FsmMap,                     RtState.AutoRunning);

            Transition(RtState.AutoRunning,     MSG.ResetIdleCleanTime, FsmResetIdleCleanTime,      RtState.AutoRunning);
            Transition(RtState.AutoRunning,     MSG.ResetIdlePurgeTime, FsmResetIdlePurgeTime,      RtState.AutoRunning);

            Transition(RtState.AutoIdle,        FSM_MSG.TIMER,          FsmMonitorAutoIdle,         RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.SetManualMode,      FsmStartSetManualMode,      RtState.Idle);
            Transition(RtState.AutoIdle,        MSG.CreateJob,          FsmCreateJob,               RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.StartJob,           FsmStartJob,                RtState.AutoRunning);
            Transition(RtState.AutoIdle,        MSG.PauseJob,           FsmPauseJob,                RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.ResumeJob,          FsmResumeJob,               RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.StopJob,            FsmStopJob,                 RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.AbortJob,           FsmAbortJob,                RtState.AutoIdle);
            Transition(RtState.AutoIdle,        MSG.Map,                FsmMap,                     RtState.AutoIdle);

            //Transfer 
            Transition(RtState.Idle,            MSG.MoveWafer,          FsmStartTransfer,           RtState.Transfer);
            Transition(RtState.Transfer,        FSM_MSG.TIMER,          FsmMonitorTransfer,         RtState.Idle);
            Transition(RtState.Transfer,        MSG.ABORT,              FsmAbort,                   RtState.Idle);

            //Return Wafer 
            Transition(RtState.Idle,            MSG.ReturnAllWafer,     FsmStartReturnWafer,        RtState.ReturnWafer);
            Transition(RtState.ReturnWafer,     FSM_MSG.TIMER,          FsmMonitorReturnWafer,      RtState.Idle);
            Transition(RtState.ReturnWafer,     MSG.ABORT,              FsmAbort,                   RtState.Idle);

            // SETM  Cycle
            Transition(RtState.Idle,            MSG.SETMCycle,          FsmStartSETMCycle,          RtState.SETMCycle);
            Transition(RtState.SETMCycle,       FSM_MSG.TIMER,          FsmMonitorSETMCycle,        RtState.Idle);
            Transition(RtState.SETMCycle,       MSG.SEAbort,            SEAbort,                    RtState.Idle);
            // SETM CreateCycle                                                                     
            Transition(RtState.Idle,            MSG.CreateSEJob,        FsmStartCreateSEJob,        RtState.Idle);
            // SETM StartCycle                                                                      
            Transition(RtState.Idle,            MSG.StartSEJob,         FsmStartSEJob,              RtState.SERunning);
            Transition(RtState.SERunning,       FSM_MSG.TIMER,          FsmSEJobMonitor,            RtState.Idle);
            Transition(RtState.SERunning,       MSG.SEAbort,            SEAbort,                    RtState.Idle);
            // SE Transfer
            Transition(RtState.Idle,            MSG.SEMoveWafer,        FsmStartSEMoveWafer,        RtState.SETransfer);
            Transition(RtState.SETransfer,      FSM_MSG.TIMER,          FsmMonitorSEMoveWafer,      RtState.Idle);
            Transition(RtState.SETransfer,      MSG.SEAbort,            SEAbort,                    RtState.Idle);
            // SE ReturnWafer
            Transition(RtState.Idle,            MSG.SEReturnWafer,      FsmStartSEReturnWafer,      RtState.SEReturnWafer);
            Transition(RtState.SEReturnWafer,   FSM_MSG.TIMER,          FsmMonitorSEReturnWafer,    RtState.Idle);
            Transition(RtState.SEReturnWafer,   MSG.SEAbort,            SEAbort,                    RtState.Idle);
        }

        private bool FsmMonitor(object[] objs)
        {
            _debugRoutine();
            return true;
        }

        private bool FsmStartHome(object[] objs)
        {
            PMA?.Invoke("Home");
            PMB?.Invoke("Home");
            PMC?.Invoke("Home");
            PMD?.Invoke("Home");
            TM?.Invoke("Home");
            LLA?.Invoke("Home");
            LLB?.Invoke("Home");
            EFEM?.Invoke("Home");
            seTM?.Invoke("Home");
            VCE?.Invoke("Home");

            return true;
        }

        private bool FsmMonitorHome(object[] objs)
        {
            bool CheckHomed(string name, bool bValid, bool bDone)
            {
                if (bValid && !bDone)
                {
                    if (fsm.ElapsedTime > 100 * 1000)
                    {
                        LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"{name} home timeout");
                        PostMsg(MSG.ERROR);
                        return true;
                    }
                    else
                        return false;
                }

                return true;
            }

            return CheckHomed("PMA", ModuleHelper.IsInstalled(ModuleName.PMA) && PMA != null, ModuleHelper.IsInstalled(ModuleName.PMA) && PMA != null&&PMA.IsIdle) &&
                CheckHomed("PMB", ModuleHelper.IsInstalled(ModuleName.PMB) && PMB != null, ModuleHelper.IsInstalled(ModuleName.PMB) && PMB != null&&PMB.IsIdle) &&
                CheckHomed("PMC", ModuleHelper.IsInstalled(ModuleName.PMC) && PMC != null, ModuleHelper.IsInstalled(ModuleName.PMC) && PMC != null&&PMC.IsIdle) &&
                CheckHomed("PMD", ModuleHelper.IsInstalled(ModuleName.PMD) && PMD != null, ModuleHelper.IsInstalled(ModuleName.PMD) && PMD != null&&PMD.IsIdle) &&
                CheckHomed("LLA", ModuleHelper.IsInstalled(ModuleName.LLA) && LLA != null, ModuleHelper.IsInstalled(ModuleName.LLA) && LLA != null&&LLA.IsIdle) &&
                CheckHomed("LLB", ModuleHelper.IsInstalled(ModuleName.LLB) && LLB != null, ModuleHelper.IsInstalled(ModuleName.LLB) && LLB != null&&LLB.IsIdle) &&
                CheckHomed("TM", ModuleHelper.IsInstalled(ModuleName.TM) && TM != null, ModuleHelper.IsInstalled(ModuleName.TM) && TM != null&&TM.IsIdle) &&
                CheckHomed("EFEM", ModuleHelper.IsInstalled(ModuleName.EFEM) && EFEM != null, ModuleHelper.IsInstalled(ModuleName.EFEM) && EFEM != null && EFEM.IsIdle) &&
                CheckHomed("SETM", ModuleHelper.IsInstalled(ModuleName.SETM) && seTM != null, ModuleHelper.IsInstalled(ModuleName.SETM) && seTM != null && seTM.IsIdle) &&
                CheckHomed("VCE1", ModuleHelper.IsInstalled(ModuleName.VCE1) && VCE != null, ModuleHelper.IsInstalled(ModuleName.VCE1) && VCE != null && VCE.IsIdle);
        }


        private bool FsmEnterAutoRunning(object[] objs)
        {
            return true;
        }

        private bool FsmExitAutoTransfer(object[] objs)
        {
            _AutoCycle.Clear();
            return true;
        }

        private bool FsmExitTransfer(object[] objs)
        {
            _manualTransfer.Clear();
            return true;
        }
        private bool FsmExitReturnWafer(object[] objs)
        {
            _returnWafer.Clear();
            return true;
        }

        private bool FsmError(object[] objs)
        {
            return true;
        }

        private bool FsmAbort(object[] objs)
        {
            _manualTransfer.Clear();
            _returnWafer.Clear();
            _AutoCycle.Clear();
            return true;
        }


        private bool FsmStartTMCycle(object[] objs)
        {
            return _TMCycle.Start(objs) == RState.Running;
        }

        private bool FsmMonitorTMCycle(object[] objs)
        {
            RState ret = _TMCycle.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }

            return ret == RState.End;
        }
        private bool FsmStopTMCycle(object[] objs)
        {
            _TMCycle.Abort();
            return true;          
        }

        private bool FsmStartAutoTransfer(object[] objs)
        {
            return _AutoCycle.Start(objs) == RState.Running;
        }

        private bool FsmAutoTransfer(object[] objs)
        {
            RState ret = _AutoCycle.Monitor();

            if(ret == RState.Failed)
            {
                if (!CheckToPostMessage((int)MSG.ERROR))
                    return false;
            }

            if (_AutoCycle.CheckJobJustDone(out string jobInfo))
            {
                EV.PostPopDialogMessage(EventLevel.InformationNoDelay, "Job complete", jobInfo);
            }

            if (_AutoCycle.CheckAllJobDone())
            {
                if (!CheckToPostMessage((int)MSG.JobDone))
                    return false;
            }

            //_isWaitUnload = (bool)DATA.Poll("LP1.NotifyJobDone") || (bool)DATA.Poll("LP2.NotifyJobDone");

            return ret ==  RState.End;
        }

        private bool FsmAbortAutoTransfer(object[] objs)
        {
            _AutoCycle.Clear();
            return true;
        }

        private bool FsmJobDone(object[] objs)
        {
            _isWaitUnload = true;
            return true;
        }

        private bool FsmCreateJob(object[] objs)
        {
            _AutoCycle.CreateJob((Dictionary<string, object>)objs[0]);
            return true;
        }

        private bool FsmStartJob(object[] objs)
        {
            _AutoCycle.StartJob((string)objs[0]);
            return true;
        }

        private bool FsmPauseJob(object[] objs)
        {
            _AutoCycle.PauseJob((string)objs[0]);
            return true;
        }

        private bool FsmResumeJob(object[] objs)
        {
            _AutoCycle.ResumeJob((string)objs[0]);
            return true;
        }

        private bool FsmStopJob(object[] objs)
        {
            _AutoCycle.StopJob((string)objs[0]);
            return true;
        }

        private bool FsmAbortJob(object[] objs)
        {
            _AutoCycle.AbortJob((string)objs[0]);
            return true;
        }

        private bool FsmStartTransfer(object[] objs)
        {
            return _manualTransfer.Start(objs) == RState.Running;
        }

        private bool FsmMonitorTransfer(object[] objs)
        {
            RState ret = _manualTransfer.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }

            return ret == RState.End;
        }

        private bool FsmStartReturnWafer(object[] objs)
        {
            //return _returnWafer.Start(objs) == RState.Running;
            return _AutoCycle.CheckManualReturnWafer() == RState.Running;
        }

        private bool FsmMonitorReturnWafer(object[] objs)
        {
            //RState ret = _returnWafer.Monitor();
            RState ret = _AutoCycle.ReturnAllWafers();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }

            return ret == RState.End;
        }

        private bool FsmMap(object[] objs)
        {
            return true;
        }

        private bool FsmResetIdleCleanTime(object[] objs)
        {
            return true;
        }

        private bool FsmResetIdlePurgeTime(object[] objs)
        {
            return true;
        }

        private bool FsmAutoReturnWafer(object[] objs)
        {
            return _AutoCycle.ManualReturnWafer(objs);
        }

        private bool FsmMonitorAutoIdle(object[] objs)
        {
            RState ret = _AutoCycle.Monitor();

            //if (_AutoCycle.CheckAllJobDone())
            //{
            //    if (!CheckToPostMessage((int)MSG.JobDone))
            //        return false;
            //}

            //_isWaitUnload = (bool)DATA.Poll("LP1.NotifyJobDone") || (bool)DATA.Poll("LP2.NotifyJobDone");

            _debugRoutine();

            return ret == RState.End;
        }

        private bool FsmStartSetManualMode(object[] objs)
        {
            if (_AutoCycle.HasJobRunning)
            {
                LOG.Write(eEvent.WARN_ROUTER, "System", "Can not change to manual mode, abort running job first");
                return false;
            }

            return true;
        }
        private void _debugRoutine()
        {
            int flag = 0;
            // Test Home routine
            if (flag == 1)
            {
                PostMsg(MSG.HOME);
            }
            else if (flag == 2)
            {
                PostMsg(MSG.TMCycle);
            }
            else if (flag == 3)
            {
                PostMsg(MSG.SetAutoMode);
            }
            else if (flag == 4)
            {
                PostMsg(MSG.ReturnAllWafer);
            }
            else if(flag == 5)
            {
                PostMsg(MSG.StartJob, "CJ_Local_LP1");
            }
        }
        private bool FsmStartSETMCycle(object[] objs)
        {
            return _seTMCycle.Start(objs) == RState.Running;
        }

        private bool FsmMonitorSETMCycle(object[] objs)
        {
            RState ret = _seTMCycle.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }

            return ret == RState.End;
        }
        private bool FsmStopSETMCycle(object[] objs)
        {
            _seTMCycle.Abort();
            return true;
        }

        private bool FsmStartCreateSEJob(object[] objs)
        {
            _seTMCycle.CreateJob((Dictionary<string, object>)objs[0]);
            return true;
        }

        private bool FsmStartSEJob(object[] objs)
        {
            return _seTMCycle.StartJob(objs[0].ToString()) == RState.Running;
        }

        private bool FsmSEJobMonitor(object[] objs)
        {
            RState ret = _seTMCycle.Monitor();
            return ret == RState.End;
        }

        private bool FsmStartSEMoveWafer(object[] objs)
        {
            return _setransfer.Start(objs) == RState.Running;
        }

        private bool FsmMonitorSEMoveWafer(object[] objs)
        {
            RState ret = _setransfer.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }
            return ret == RState.End;
        }

        private bool FsmStartSEReturnWafer(object[] objs)
        {
            return _sereturnWafer.Start(objs) == RState.Running;
        }

        private bool FsmMonitorSEReturnWafer(object[] objs)
        {
            RState ret = _sereturnWafer.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.ERROR);
                return false;
            }
            return ret == RState.End;
        }

        private bool SEAbort(object[] objs)
        {
            _seTMCycle.Abort();
            _setransfer.Abort();
            _sereturnWafer.Abort();
            seTM.CheckToPostMessage((int)SETMEntity.MSG.Abort);
            return true;
        }
    }
}