ELK/Furnace/FurnaceRT/Equipments/Systems/EquipmentManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Media;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using FurnaceRT.Devices;
using FurnaceRT.Equipments.CarrierRobots;
using FurnaceRT.Equipments.FIMSs;
using FurnaceRT.Equipments.Jobs;
using FurnaceRT.Equipments.LPs;
using FurnaceRT.Equipments.PMs;
using FurnaceRT.Equipments.PMs.RecipeExecutions;
using FurnaceRT.Equipments.Schedulers;
using FurnaceRT.Equipments.Stockers;
using FurnaceRT.Equipments.WaferRobots;
using FurnaceRT.Instances;
using MECF.Framework.Common.Alarms;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.FA.Core.FAControl;
using MECF.Framework.RT.Core.Applications;
using MECF.Framework.RT.Core.IoProviders;
using AutoTransfer = FurnaceRT.Equipments.Jobs.AutoTransfer;
using ReturnAllWafer = FurnaceRT.Equipments.Jobs.ReturnAllWafer;

namespace FurnaceRT.Equipments.Systems
{
    public enum RtState
    {
        Init,

        Initializing,
        Idle,

        Transfer,
        AutoRunning,

        AutoIdle,

        ReturnAllWafer,

        Error,

        Loading,
        Unloading,
        ChargeProcessDischarging,
        LoadProcessStockering,
        LoadProcessUnloading,
        ReturnWafer,
    }
    public enum TransferJobState
    {
        Idle,

        Error,

        Loading,
        Unloading,
    }

    public enum ProcessJobState
    {
        Idle,

        Error,

        Charging,
        Processing,
        Cooling,
        Discharging,
    }

    public partial class EquipmentManager : FsmDevice
    {
        public enum MSG
        {
            MoveWafer,
            ReturnAllWafer,

            Stop,

            HOME,
            RESET,
            ABORT,
            ERROR,

            ToInit,


            SetAutoMode,
            SetManualMode,

            CreateJob,
            PauseJob,
            ResumeJob,
            StartJob,
            StopJob,
            AbortJob,

            JobDone,

            ModuleError,

            Map,

            Load,
            Unload,
            ChargeProcessDischarge,
            LoadProcessStocker,
            LoadProcessUnload,
            CancelUnloadingJob,
            ToUnloading,
            ToLoading,

            CreateTransferJob,
            AbortTransferJob,
        }

        public Dictionary<ModuleName, ModuleFsmDevice> Modules { get; set; }

        public bool IsAutoMode
        {
            get
            {
                return FsmState == (int)RtState.AutoRunning || FsmState == (int)RtState.AutoIdle;
            }
        }
        public bool IsReturnWafer
        {
            get
            {
                return FsmState == (int)RtState.ReturnAllWafer || FsmState == (int)RtState.ReturnWafer;
            }
        }

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

        public bool IsIdle
        {
            get { return FsmState == (int)RtState.Idle; }
        }
        public bool IsAlarm
        {
            get { return FsmState == (int)RtState.Error; }
        }

        public bool IsRunning
        {
            get
            {
                return !IsAlarm && !IsIdle && !IsInit && (FsmState != (int)RtState.AutoIdle);
            }
        }
        public bool IsAlarmConditionBuzzerOn { get; set; }
        public TransferJobState TransferJobStatus { get; set; } = TransferJobState.Idle;

        public ProcessJobState ProcessJobStatus { get; set; } = ProcessJobState.Idle;

        private bool _isInited;

        protected IRoutine _manualTransfer;
        private AutoTransfer _auto = null;
        private TransferJob _transferJob = null;
        protected IRoutine _homeAll;
        protected IRoutine _returnAll;

        private string _batchType;
        private string _processJob;
        private string _processRecipe;
        private DeviceTimer _coolTimer = new DeviceTimer();
        private int _cycledCount = 0;
        private int _jobMSG = 0;
        private object[] _jobParas;
        private object _locker = new object();

        private List<string> _modules;
        private PeriodicJob _cycleJob;
        private RD_TRIG _plcConnectTrig = new RD_TRIG();

        public EquipmentManager()
        {
            Module = "System";
            Name = "System";
            Modules = new Dictionary<ModuleName, ModuleFsmDevice>();
            _modules = new List<string>() { "System" };
        }

        public override bool Initialize()
        {
            InitDevices();

            InitModules();

            EnumLoop<RtState>.ForEach((item) =>
            {
                MapState((int)item, item.ToString());
            });

            EnumLoop<MSG>.ForEach((item) =>
            {
                MapMessage((int)item, item.ToString());
            });
            EnableFsm(50, RtState.Init);

            BuildTransitionTable();

            SubscribeDataVariable();

            SubscribeOperation();

            InitRoutine();

            InitAlarmDefine();

            _auto = new AutoTransfer();
            _transferJob = new TransferJob();
            _cycleJob = new PeriodicJob(100, OnCycleTimer, Name, true);

            Singleton<EventManager>.Instance.OnAlarmEvent += Instance_OnAlarmEvent;

            return true;
        }

        protected void BuildModules(params ModuleFsmDevice[] modules)
        {
            if (modules != null && modules.Length > 0)
            {
                foreach (var moduleFsmDevice in modules)
                {
                    Modules[ModuleHelper.Converter(moduleFsmDevice.Module)] = moduleFsmDevice;
                }

                foreach (var modulesKey in Modules.Keys)
                {
                    _modules.Add(modulesKey.ToString());
                }

                foreach (var modulesValue in Modules.Values)
                {
                    modulesValue.Initialize();
                }
            }
        }

        protected virtual void InitRoutine()
        {
            _homeAll = new HomeAll();
            _returnAll = new ReturnAllWafer();

            _dbCallback = new SchedulerDBCallback();
        }

        //private PeriodicJob _job1;

        //Stopwatch _sw = new Stopwatch();

        //private bool OnJob1()
        //{
        //    _sw.Restart();

        //    BufferModule buffer = Modules[ModuleName.Buffer] as BufferModule;

        //    if (!buffer.CheckToPostMessage(BufferModule.MSG.InTransfer))
        //    {
        //        System.Diagnostics.Trace.Assert(false)
        //        System.Diagnostics.Trace.WriteLine("fail to in transfer");
        //    }

        //    if (buffer.IsIdle)
        //    {
        //        System.Diagnostics.Trace.Assert(false);
        //        System.Diagnostics.Trace.WriteLine("!!!==========>IsIdle");
        //    }
        //    //System.Diagnostics.Trace.Assert(buffer.IsIdle, $"in {buffer.StringFsmStatus}");

        //    while (buffer.IsIdle)
        //    {
        //        Thread.Sleep(5);
        //    }

        //    //buffer.NoteTransferStop(ModuleName.EfemRobot, Hand.Blade1, 0, EnumTransferType.Place);
        //    //Thread.Sleep(15);
        //    if (!buffer.CheckToPostMessage(BufferModule.MSG.TransferComplete))
        //    {
        //        System.Diagnostics.Trace.Assert(false);

        //        System.Diagnostics.Trace.WriteLine("fail to complete");
        //    }

        //    //if (!buffer.IsIdle)
        //    //{
        //    //    System.Diagnostics.Trace.WriteLine("not idle");
        //    //}
        //    System.Diagnostics.Trace.WriteLine($" === {_sw.ElapsedMilliseconds}");

        //    while (!buffer.IsIdle)
        //    {
        //        Thread.Sleep(5);
        //    }

        //    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);
            Transition(RtState.Error, MSG.ToInit, null, RtState.Init);

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

            //Reset
            AnyStateTransition(MSG.ERROR, fError, RtState.Error);
            AnyStateTransition((int)FSM_MSG.ALARM, fError, (int)RtState.Error);
            Transition(RtState.Error, MSG.RESET, fStartReset, RtState.Idle);
            Transition(RtState.Init, MSG.RESET, fStartReset, RtState.Init);
            Transition(RtState.Idle, MSG.RESET, fStartReset, RtState.Idle);
            Transition(RtState.AutoIdle, MSG.RESET, fStartReset, RtState.AutoIdle);
            Transition(RtState.AutoRunning, MSG.RESET, fStartReset, RtState.AutoRunning);
            Transition(RtState.ReturnWafer, MSG.RESET, fStartReset, RtState.ReturnWafer);

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

            Transition(RtState.AutoRunning, FSM_MSG.TIMER, fAutoTransfer, RtState.AutoRunning);

            Transition(RtState.AutoRunning, MSG.ABORT, FsmAbort, RtState.Idle);
            Transition(RtState.AutoRunning, MSG.JobDone, null, RtState.AutoIdle);

            Transition(RtState.Idle, MSG.CreateJob, FsmCreateJob, RtState.AutoRunning);
            Transition(RtState.Idle, MSG.LoadProcessUnload, FsmStartLoadProcessUnload, RtState.AutoRunning);
            Transition(RtState.Idle, MSG.LoadProcessStocker, FsmStartLoadProcessStocker, RtState.AutoRunning);

            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.ModuleError, FsmModuleError, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.Load, FsmStartLoad, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.Unload, FsmStartUnload, RtState.AutoRunning);
            Transition(RtState.Idle, MSG.CreateTransferJob, FsmCreateTransferJob, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.CreateTransferJob, FsmCreateTransferJob, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.AbortTransferJob, FsmAbortTransferJob, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.CancelUnloadingJob, FsmCancelUnloadingJob, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.LoadProcessUnload, FsmStartLoadProcessUnload, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.LoadProcessStocker, FsmStartLoadProcessStocker, 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.AutoRunning);
            Transition(RtState.AutoIdle, MSG.StartJob, FsmStartJob, RtState.AutoRunning);
            Transition(RtState.AutoIdle, MSG.ABORT, FsmAbort, RtState.Idle);
            Transition(RtState.AutoIdle, MSG.AbortJob, FsmAbortJob, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.Load, FsmStartLoad, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.Unload, FsmStartUnload, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.CreateTransferJob, FsmCreateTransferJob, RtState.AutoRunning);
            Transition(RtState.AutoIdle, MSG.AbortTransferJob, FsmAbortTransferJob, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.LoadProcessUnload, FsmStartLoadProcessUnload, RtState.AutoRunning);
            Transition(RtState.AutoIdle, MSG.LoadProcessStocker, FsmStartLoadProcessStocker, RtState.AutoRunning);

            EnterExitTransition<RtState, FSM_MSG>(RtState.AutoRunning, null, FSM_MSG.NONE, fExitAutoTransfer);

            //return all wafer
            //Transition(RtState.Idle, MSG.ReturnAllWafer, FsmStartReturnAllWafer, RtState.ReturnAllWafer);
            //Transition(RtState.ReturnAllWafer, FSM_MSG.TIMER, FsmMonitorReturnAllWafer, RtState.Idle);
            //Transition(RtState.ReturnAllWafer, MSG.ABORT, FsmAbortReturnAllWafer, RtState.Idle);

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


            //Transfer sequence
            Transition(RtState.Idle, MSG.MoveWafer, fStartTransfer, RtState.Transfer);
            Transition(RtState.Transfer, FSM_MSG.TIMER, fTransfer, RtState.Idle);

            EnterExitTransition<RtState, FSM_MSG>(RtState.Transfer, null, FSM_MSG.NONE, fExitTransfer);

            Transition(RtState.Transfer, MSG.ABORT, FsmAbort, RtState.Idle);

        }

        void SubscribeDataVariable()
        {
            DATA.Subscribe("Rt.Status", () => StringFsmStatus);
            DATA.Subscribe("System.IsInitialized", () => _isInited);

            DATA.Subscribe("System.IsIdle", () => IsIdle || IsInit || (FsmState == (int)RtState.AutoIdle));
            DATA.Subscribe("System.IsAlarm", () => IsAlarm);
            DATA.Subscribe("System.IsBusy", () => IsRunning);
            DATA.Subscribe("System.IsAutoRunning", () => IsRunning);
            DATA.Subscribe("System.IsAlarmConditionBuzzerOn", () => IsAlarmConditionBuzzerOn);

            DATA.Subscribe("System.Modules", () => _modules);
        }

        void SubscribeOperation()
        {
            OP.Subscribe("CreateWafer", InvokeCreateWafer);
            OP.Subscribe("CreateWaferFromTo", InvokeCreateWaferFromTo);
            OP.Subscribe("DeleteWafer", InvokeDeleteWafer);
            OP.Subscribe("DeleteWaferFromTo", InvokeDeleteWaferFromTo);
            OP.Subscribe("CreateCassetteWafer", InvokeCreateCassetteWafer);
            OP.Subscribe("DeleteCassetteWafer", InvokeDeleteCassetteWafer);
            OP.Subscribe("System.CreateCarrier", InvokeCreateCarrier);
            OP.Subscribe("System.DeleteCarrier", InvokeDeleteCarrier);
            OP.Subscribe("System.SetLotID", InvokeSetLotID);

            OP.Subscribe("System.DeleteAllWafer", InvokeDeleteAllWafer);
            OP.Subscribe("System.DeleteAllCarrier", InvokeDeleteAllCarrier);

            OP.Subscribe("ReturnWafer", InvokeReturnWafer);
            OP.Subscribe("System.SignalTower.SwitchOffBuzzer", InvokeSwitchOffBuzzer);

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

            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 (args.Length > 8)
                {
                    return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3],
                        (bool)args[4], (int)args[5], (bool)args[6], (int)args[7]);
                }
                else if (args.Length > 5)
                {
                    return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3], (bool)args[4]);
                }

                return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3]);
            });

            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("System.CoolingSkip", (string cmd, object[] args) =>
            {
                CoolingSkip();
                return true;
            });

            OP.Subscribe("System.ShutDown", InvokeShutDown);

            OP.Subscribe($"System.Load", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));
            OP.Subscribe($"System.Unload", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));
            OP.Subscribe($"System.ChargeProcessDischarge", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateJob, args));
            OP.Subscribe($"System.LoadProcessUnload", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.LoadProcessUnload, args));
            OP.Subscribe($"System.LoadProcessStocker", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.LoadProcessStocker, args));
            OP.Subscribe($"System.MonitorLoad", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));
            OP.Subscribe($"System.MonitorUnload", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));
            OP.Subscribe($"System.SDLoad", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));
            OP.Subscribe($"System.SDUnload", (string cmd, object[] args) => CheckToPostJobMessage((int)MSG.CreateTransferJob, args));

            OP.Subscribe($"{Module}.AlarmAction", (string cmd, object[] args) =>
            {
                Enum.TryParse(args[0].ToString(), out AlarmAction alarmAction);
                if (alarmAction == AlarmAction.ClearAll)
                {
                    CheckToPostMessage((int)MSG.RESET);
                    return true;
                }
                string eventName = null;
                if (args.Length > 1)
                    eventName = args[1].ToString();
                if (eventName != null)
                {
                    EV.ClearAlarmEvent(eventName);

                    var item = _triggeredAlarmList.FirstOrDefault(x => x.EventEnum == eventName);
                    if (item != null)
                    {
                        item.Reset();
                        _triggeredAlarmList.Remove(item);
                    }

                    if (item != null)
                    {
                        switch (alarmAction)
                        {
                            case AlarmAction.Retry:
                                {
                                    CheckToPostMessage((int)item.RetryMessage, item.RetryMessageParas);
                                }
                                break;
                            case AlarmAction.Abort:
                                {
                                    CheckToPostMessage((int)MSG.ABORT);
                                }
                                break;
                            case AlarmAction.Clear:
                                {
                                    int alarmCount = 0;
                                    var alarms = EV.GetAlarmEvent();
                                    foreach (var alarm in alarms)
                                    {
                                        if (alarm.Level == EventLevel.Alarm && alarm.Source == Name)
                                            alarmCount++;
                                    }
                                    if (alarmCount == 0)
                                        CheckToPostMessage((int)MSG.RESET);
                                }
                                break;
                            case AlarmAction.Continue:
                                {
                                    int alarmCount = 0;
                                    var alarms = EV.GetAlarmEvent();
                                    foreach (var alarm in alarms)
                                    {
                                        if (alarm.Level == EventLevel.Alarm && alarm.Source == Name)
                                            alarmCount++;
                                    }
                                    if (alarmCount == 0)
                                        CheckToPostMessage((int)MSG.RESET);
                                }
                                break;
                        }
                    }
                }

                return true;
            });
        }


        private void Instance_OnAlarmEvent(EventItem item)
        {
            if (item != null && item.Level == EventLevel.Alarm && (item.Source == Name || item.Source == Module))
            {
                DEVICE.GetDevice<SignalTowerBase>("System.SignalTower")?.Reset();
                LOG.Write($"{item.Source} {item.EventEnum} {item.Description}\n");
                PostMsg(MSG.ERROR);
            }
        }

        #region Init
        private bool FsmStartHome(object[] objs)
        {
            _isInited = false;
            return _homeAll.Start() == Result.RUN;
        }

        private bool FsmMonitorHome(object[] objs)
        {
            Result ret = _homeAll.Monitor();
            if (ret == Result.DONE)
            {
                _isInited = true;
                return true;
            }
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.ERROR);
            }
            return false;
        }

        private bool fError(object[] objs)
        {
            if (FsmState == (int)RtState.Transfer)
            {
            }

            return true;
        }


        #endregion
        #region job
        private bool FsmStartLoad(object[] param)
        {
            if (_transferJob.CreateJob(param) != Result.RUN)
            {
                return false;
            }

            return true;
        }

        private bool FsmStartUnload(object[] param)
        {
            if (_transferJob.CreateJob(param) != Result.RUN)
            {
                return false;
            }

            return true;
        }

        private bool FsmStartLoadProcessStocker(object[] param)
        {
            var paramDic = (Dictionary<string, object>)param[0];
            if (paramDic == null)
            {
                LoadProcessStockerStartFailedWarning.Set("Parameter not valid");
                return false;
            }

            paramDic["TransferType"] = "Loading";
            param[0] = paramDic;
            if (_transferJob.CreateJob(param) != Result.RUN)
            {
                return false;
            }
            if (_auto.CreateJob(param) != Result.RUN)
            {
                return false;
            }

            return true;
        }

        private bool FsmStartLoadProcessUnload(object[] param)
        {
            var paramDic = (Dictionary<string, object>)param[0];
            if (paramDic == null)
            {
                LoadProcessUnloadStartFailedWarning.Set("Parameter not valid");
                return false;
            }

            paramDic["TransferType"] = "Loading";
            param[0] = paramDic;
            if (_transferJob.CreateJob(param) != Result.RUN)
            {
                return false;
            }
            if (_auto.CreateJob(param) != Result.RUN)
            {
                return false;
            }
            paramDic["TransferType"] = "Unloading";
            param[0] = paramDic;
            if (_transferJob.CreateJob(param) != Result.RUN)
            {
                return false;
            }

            return true;
        }

        #endregion

        #region AutoTransfer

        private bool FsmMonitorAutoIdle(object[] param)
        {
            Result ret = _transferJob.Monitor();

            _auto.Monitor();

            if (!_auto.CheckAllJobDone() || !_transferJob.CheckAllJobDone())
            {
                return false;
            }

            return ret == Result.DONE;
        }

        private bool FsmStartSetManualMode(object[] objs)
        {
            if (_auto.HasJobRunning)
            {
                EV.PostWarningLog("System", "Can not change to manual mode, abort running job first");
                return false;
            }

            return true;
        }

        private bool fStartAutoTransfer(object[] objs)
        {
            Result ret = _auto.Start(objs);

            return ret == Result.RUN;
        }

        private bool fAutoTransfer(object[] objs)
        {
            Result ret = _transferJob.Monitor();

            _auto.Monitor();

            if (_auto.CheckAllJobDone() && _transferJob.CheckAllJobDone())
            {
                if (!CheckToPostMessage((int)MSG.JobDone))
                    return false;
            }

            return ret == Result.DONE;
        }

        private bool fExitAutoTransfer(object[] objs)
        {
            _auto.Clear();
            _transferJob.Clear();
            return true;
        }

        private bool fAbortAutoTransfer(object[] objs)
        {
            _auto.Clear();
            _transferJob.Clear();
            return true;
        }

        #endregion


        #region  return all wafer

        private bool FsmAbortReturnAllWafer(object[] param)
        {
            return true;
        }

        private bool FsmMonitorReturnAllWafer(object[] param)
        {
            return _returnAll.Monitor() == Result.DONE;
        }

        private bool FsmStartReturnAllWafer(object[] param)
        {
            return _returnAll.Start() == Result.RUN;
        }
        #endregion

        #region Transfer
        private bool fStartTransfer(object[] objs)
        {
            Result ret = _manualTransfer.Start(objs);
            if (ret == Result.FAIL || ret == Result.DONE)
                return false;
            return ret == Result.RUN;
        }


        private bool fTransfer(object[] objs)
        {
            Result ret = _manualTransfer.Monitor();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.ERROR);
                return false;
            }
            return ret == Result.DONE;
        }

        private bool fExitTransfer(object[] objs)
        {

            return true;
        }

        private bool fAbortTransfer(object[] objs)
        {
            return true;
        }
        #endregion

        #region reset

        private bool fStartReset(object[] objs)
        {
            EV.ClearAlarmEvent();

            Singleton<DeviceEntity>.Instance.PostMsg(DeviceEntity.MSG.RESET);

            IoProviderManager.Instance.Reset();

            foreach (var modulesValue in Modules.Values)
            {
                modulesValue.Reset();
            }

            _triggeredAlarmList.ForEach(x => x.Reset());
            _triggeredAlarmList.Clear();

            if (FsmState == (int)RtState.Error)
            {
                if (!_isInited)
                {
                    PostMsg(MSG.ToInit);
                    return false;
                }
                return true;
            }


            return false;
        }

        #endregion

        private bool FsmCreateJob(object[] param)
        {
            if (FsmState != (int)RtState.AutoRunning && CarrierManager.Instance.CheckHasCarrier(ModuleName.CarrierRobot, 0))
            {
                EV.PostWarningLog("System", $"FOUP robot already has a FOUP, create job failed");
                return false;
            }
            _auto.CreateJob((Dictionary<string, object>)param[0]);

            return true;
        }

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

        private bool FsmStopJob(object[] param)
        {
            _auto.StopJob((string)param[0]);
            Singleton<FAJobController>.Instance.CJAbort((string)param[0]);
            //CheckToPostMessage((int)MSG.StopJob);//
            return true;
        }

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

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

        private bool FsmStartJob(object[] param)
        {
            return _auto.StartJob((string)param[0]);
        }
        private bool FsmCreateTransferJob(object[] param)
        {
            if(FsmState != (int)RtState.AutoRunning && CarrierManager.Instance.CheckHasCarrier(ModuleName.CarrierRobot, 0))
            {
                EV.PostWarningLog("System", $"FOUP robot already has a FOUP, create job failed");
                return false;
            }
            _transferJob.CreateJob(param);

            return true;
        }
        private bool FsmAbortTransferJob(object[] param)
        {
            _transferJob.AbortJob((string)param[0]);
            return true;
        }
        private bool FsmCancelUnloadingJob(object[] param)
        {
            _transferJob.CancelUnloadingJob((string)param[0], (string)param[1]);
            return true;
        }
        private bool FsmAbort(object[] param)
        {
            if (FsmState == (int)RtState.Transfer)
            {
                // _manualTransfer.Clear();
            }

            if (FsmState == (int)RtState.ChargeProcessDischarging || FsmState == (int)RtState.LoadProcessStockering || FsmState == (int)RtState.LoadProcessUnloading)
            {
                _auto.PjUpdated();
                _auto.PjFinished("Job Abort");
            }

            if (FsmState == (int)RtState.AutoRunning)
            {
                _auto.Clear();
            }

            if (FsmState == (int)RtState.Initializing)
            {
                _homeAll.Abort();
            }

            return true;
        }
        private bool FsmModuleError(object[] param)
        {
            //_auto.ModuleError((string)param[0]);

            return true;
        }
        private bool FsmStartReturnWafer(object[] objs)
        {
            Result ret = _returnAll.Start();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.ERROR);
                return false;
            }
            return ret == Result.RUN;
        }

        private bool FsmMonitorReturnWafer(object[] objs)
        {
            Result ret = _returnAll.Monitor();
            if (ret == Result.FAIL)
            {
                PostMsg(MSG.ERROR);
                return false;
            }
            if (ret == Result.DONE)
            {
                _batchType = "";
                _processJob = "";
                _processRecipe = "";

                (Modules[ModuleName.CarrierRobot] as CarrierRobotModule).Home(out _);
                (Modules[ModuleName.WaferRobot] as WaferRobotModule).Home(out _);
            }
            return ret == Result.DONE;
        }
        private bool InvokeSwitchOffBuzzer(string arg1, object[] args)
        {
            DEVICE.GetDevice<SignalTowerBase>("System.SignalTower")?.SwitchOffBuzzer(true);
            IsAlarmConditionBuzzerOn = false;
            return true;
        }
        private bool InvokeReturnWafer(string arg1, object[] args)
        {
            ModuleName target = ModuleHelper.Converter(args[0].ToString());
            int slot = (int)args[1];

            if (ModuleHelper.IsLoadPort(target))
            {
                EV.PostInfoLog("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))
            {
                EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", target.ToString(), slot.ToString()));
                return false;
            }

            WaferInfo wafer = WaferManager.Instance.GetWafer(target, slot);
            if (wafer.IsEmpty)
            {
                EV.PostInfoLog("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);
        }
        private bool InvokeDeleteAllWafer(string arg1, object[] args)
        {
            foreach (var item in Modules.Values)
            {
                if ((item as PMModule) != null || (item as WaferRobotModule) != null)
                {
                    var wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(item.Module));
                    for (int i = 0; i < wafers.Length; i++)
                    {
                        if (!wafers[i].IsEmpty)
                            WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(item.Module), i);
                    }
                }
            }
            return true;
        }
        private bool InvokeDeleteAllCarrier(string arg1, object[] args)
        {
            foreach (var item in Modules.Values)
            {
                if ((item as LoadPortModule) != null || (item as StockerModule) != null || (item as FIMSModule) != null || (item as CarrierRobotModule) != null)
                {
                    if (CarrierManager.Instance.HasCarrier(item.Module.ToString()))
                    {
                        CarrierManager.Instance.DeleteCarrier(item.Module.ToString());

                        var wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(item.Module));
                        for (int i = 0; i < wafers.Length; i++)
                        {
                            if (!wafers[i].IsEmpty)
                                WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(item.Module), i);
                        }
                    }
                }
            }
            return true;
        }
        private bool InvokeDeleteWaferFromTo(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            int slotFrom = (int)args[1];
            int slotTo = (int)args[2];
            for (int slot = slotTo - 1; slot >= slotFrom - 1; slot--)
            {
                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
                    {
                        EV.PostInfoLog("System", string.Format("No wafer at {0} {1}, delete not valid", chamber.ToString(), slot + 1));
                    }
                }
                else
                {
                    DeleteWaferFailedWarning.Set(string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                    return false;
                }
            }
            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, false);
            }
            var wafers = WaferManager.Instance.GetWafers(chamber);
            if (wafers != null && carrier != null)
            {
                foreach (var wafer in wafers)
                {
                    if (wafer != null && !wafer.IsEmpty)
                    {
                        CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
                        break;
                    }
                }
            }

            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
                {
                    EV.PostInfoLog("System", string.Format("No wafer at {0} {1}, delete not valid", chamber.ToString(), slot + 1));
                }
            }
            else
            {
                DeleteWaferFailedWarning.Set(string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                return false;
            }

            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, false);
            }
            var wafers = WaferManager.Instance.GetWafers(chamber);
            if (wafers != null && carrier != null)
            {
                foreach (var wafer in wafers)
                {
                    if (wafer != null && !wafer.IsEmpty)
                    {
                        CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
                        break;
                    }
                }
            }

            return true;
        }
        private bool InvokeCreateWaferFromTo(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            ModuleName originChamber = chamber;
            int slotFrom = (int)args[1];
            int slotTo = (int)args[2];
            int originSlot = 1;
            WaferStatus state = WaferStatus.Normal;
            WaferType waferTye = WaferType.None;
            var strs = (string[])args[3];
            Enum.TryParse(strs[0].ToString(), out waferTye);
            originChamber = ModuleHelper.Converter(strs[1].ToString());
            originSlot = int.Parse(strs[2]);


            for (int slot = slotTo - 1; slot >= slotFrom - 1; slot--)
            {
                if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
                {
                    if (WaferManager.Instance.CheckHasWafer(chamber, slot))
                    {
                        EV.PostInfoLog("System", string.Format("{0} slot {1} already has wafer.create wafer is not valid", chamber, slot + 1));
                    }
                    else
                    {
                        if (originChamber == chamber && WaferManager.Instance.CreateWafer(chamber, slot, state, waferTye) != null)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
                        }
                        else if (originChamber != chamber && WaferManager.Instance.CreateWafer(chamber, slot, originChamber, originSlot, state, waferTye) != null)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
                        }
                    }
                }
                else
                {
                    EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                    return false;
                }
            }
            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
            }

            return true;
        }
        private bool InvokeCreateWafer(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            ModuleName originChamber = chamber;
            int slot = (int)args[1];
            int originSlot = 1;
            WaferStatus state = WaferStatus.Normal;
            WaferType waferTye = WaferType.None;
            if (args.Length > 2)
                Enum.TryParse(args[2].ToString(), out waferTye);
            if (args.Length > 3)
                originChamber = ModuleHelper.Converter(args[3].ToString());
            if (args.Length > 4)
                originSlot = (int)args[4];

            if (ModuleHelper.IsLoadPort(chamber))
            {
                //var lp = Modules[chamber] as LoadPortModule;
                //if (lp.LPDevice.CassetteState != LoadportCassetteState.Normal)
                //{
                //    EV.PostWarningLog("System", $"Can not create wafer at {chamber}.{slot + 1}, Cassette not placed.");
                //    return false;
                //}
            }

            if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
            {
                if (WaferManager.Instance.CheckHasWafer(chamber, slot))
                {
                    EV.PostInfoLog("System", string.Format("{0} slot {1} already has wafer.create wafer is not valid", chamber, slot + 1));
                }
                else
                {
                    if (originChamber == chamber && WaferManager.Instance.CreateWafer(chamber, slot, state, waferTye) != null)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
                    }
                    else if (originChamber != chamber && WaferManager.Instance.CreateWafer(chamber, slot, originChamber, originSlot, state, waferTye) != null)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
                    }
                }
            }
            else
            {
                EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                return false;
            }

            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
            }

            return true;
        }
        private bool InvokeCreateCassetteWafer(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier == null || carrier.IsEmpty)
            {
                EV.PostInfoLog(Module, $"{chamber} create wafer fail for carrier not exist.");
                return false;
            }
            if (args.Length > 3 && !carrier.CarrierType.ToString().Equals(CarrierType.None.ToString()) && !carrier.CarrierType.ToString().Equals(args[3].ToString()))
            {
                EV.PostInfoLog(Module, $"{chamber} type mismatch!");
                return false;
            }

            int slotFrom = (int)args[1];
            int slotTo = (int)args[2];
            WaferStatus state = WaferStatus.Normal;
            WaferType waferTye = WaferType.None;
            if (args.Length > 3)
                Enum.TryParse(args[3].ToString(), out waferTye);

            for (int slot = slotTo - 1; slot >= slotFrom - 1; slot--)
            {
                if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
                {
                    if (WaferManager.Instance.CheckHasWafer(chamber, slot))
                    {
                        EV.PostInfoLog(Module, string.Format("{0} slot {1} already has wafer.", chamber, slot + 1));
                        continue;
                    }
                    else if (WaferManager.Instance.CreateWafer(chamber, slot, state, waferTye) == null)
                    {
                        CreateWaferFailedWarning.Set(string.Format($"Create slot {slot + 1} wafer failed."));
                        return false;
                    }
                }
                else
                {
                    CreateWaferFailedWarning.Set(string.Format("Invalid slot，{0}，{1}", chamber.ToString(), (slot + 1).ToString()));
                    return false;
                }
            }


            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
            }

            EV.PostInfoLog(Module, $"Create wafer from {slotFrom} to {slotTo} successed.");

            return true;
        }
        private bool InvokeDeleteCassetteWafer(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            int slotFrom = (int)args[1];
            int slotTo = (int)args[2];
            if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slotFrom - 1) && WaferManager.Instance.IsWaferSlotLocationValid(chamber, slotTo - 1))
            {
                WaferManager.Instance.DeleteWafer(chamber, slotFrom - 1, slotTo - slotFrom + 1);
            }
            else
            {
                DeleteWaferFailedWarning.Set(string.Format($"Invalid slot，{chamber} slot from {slotFrom}, slot to {slotTo}"));
                return false;
            }

            var carrier = CarrierManager.Instance.GetCarrier(chamber);
            if (carrier != null)
            {
                CarrierManager.Instance.UpdateWaferIn(chamber, 0, false);
            }
            var wafers = WaferManager.Instance.GetWafers(chamber);
            if (wafers != null && carrier != null)
            {
                foreach (var wafer in wafers)
                {
                    if (wafer != null && !wafer.IsEmpty)
                    {
                        CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
                        break;
                    }
                }
            }

            EV.PostInfoLog(Module, $"Delete wafer from {slotFrom} to {slotTo} successed.");

            return true;
        }
        private CarrierType GetStockerType(string name)
        {
            var result = CarrierType.SD;
            var scName = name.Contains("LP") ? $"{name}Type" : $"{name}WaferType";
            string configType = SC.GetStringValue($"System.Stocker.{scName}");
            if (string.IsNullOrEmpty(configType))
            {
                return result;
            }

            result = configType.StartsWith(CarrierType.P.ToString()) ? CarrierType.P : (CarrierType)Enum.Parse(typeof(CarrierType), configType);

            return result;
        }
        public bool InvokeCreateCarrier(string arg1, object[] args)
        {
            ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
            int slot = (int)args[1];
            CarrierType carrierTye = GetStockerType(chamber.ToString());


            if (args.Length > 2)
            {

                var inputType = args[2].ToString();
                if (!carrierTye.ToString().Equals(CarrierType.None.ToString()) && !carrierTye.ToString().Equals(inputType))
                {
                    EV.PostInfoLog(Module, $"{chamber} type mismatch!");
                    return false;
                }
                Enum.TryParse(args[2].ToString(), out carrierTye);
            }


            if (CarrierManager.Instance.HasCarrier(args[0].ToString(), slot))
            {
                EV.PostInfoLog("System", $"{chamber} already has carrier.create is not valid");
            }
            else
            {
                CarrierManager.Instance.CreateCarrier(args[0].ToString(), carrierTye, args[0].ToString());

                EV.PostInfoLog("System", $"{chamber} create carrier");
            }

            var wafers = WaferManager.Instance.GetWafers(chamber);
            if (wafers != null)
            {
                foreach (var wafer in wafers)
                {
                    if (wafer != null && !wafer.IsEmpty)
                    {
                        CarrierManager.Instance.UpdateWaferIn(chamber, 0, true);
                        break;
                    }
                }
            }

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

            if (CarrierManager.Instance.HasCarrier(chamber.ToString()))
            {
                CarrierManager.Instance.DeleteCarrier(chamber.ToString());

                EV.PostInfoLog("System", $"Carrier deleted from {chamber}");

                var wafers = WaferManager.Instance.GetWafers(chamber);
                for (int i = 0; i < wafers.Length; i++)
                {
                    if (!wafers[i].IsEmpty)
                        WaferManager.Instance.DeleteWafer(chamber, i);
                }
            }
            else
            {
                EV.PostInfoLog("System", string.Format("No carrier at {0}, delete not valid", chamber.ToString()));
            }


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

            List<string> lotIdLst = new List<string>();
            foreach (var module in Modules.Keys)
            {
                if ((Modules[module] as StockerModule) == null)
                    continue;
                if (CarrierManager.Instance.HasCarrier(module.ToString()))
                {
                    lotIdLst.Add(CarrierManager.Instance.GetCarrier(module.ToString()).CarrierId);
                }
            }

            if (lotIdLst.Any(x => x == args[1].ToString()))
            {
                SetLotIDFailedWarning.Set($"Carrier ID={args[1]} of {chamber} is already exist");
                return false;
            }

            if (CarrierManager.Instance.HasCarrier(chamber.ToString()))
            {
                CarrierManager.Instance.UpdateCarrierId(chamber.ToString(), args[1].ToString());

                EV.PostInfoLog("System", $"Carrier {chamber} update carrier ID {args[1]}");

            }
            else
            {
                EV.PostInfoLog("System", string.Format("No carrier at {0}, update carrier ID not valid", chamber.ToString()));
            }

            return true;
        }
        private bool InvokeShutDown(string arg1, object[] arg2)
        {
            if (IsAlarm || IsIdle || IsInit)
            {
                EV.PostWarningLog(Module, $"System start shut down");

                EV.PostKickoutMessage("ShutDown");

                RtApplication.Instance.Terminate();

                return true;
            }

            EV.PostWarningLog(Module, $"System in {StringFsmStatus} mode, can not shut down");
            return false;
        }

        private void OnModuleError(string module)
        {
            if (FsmState == (int)RtState.AutoRunning)
            {
                ModuleName mod = ModuleHelper.Converter(module);

                PostMsg(MSG.ModuleError, module);
            }
        }


        public override void Monitor()
        {
            base.Monitor();
        }
        private bool CheckPWaferBatch(ModuleName module, string batch)
        {
            string stockerWaferType = batch == "A" ? "P1" : "P2";

            return SC.GetStringValue($"System.Stocker.{module}WaferType") == stockerWaferType;
        }

        private bool CheckMWaferBatch(ModuleName module, string batch)
        {
            string stockerWaferType = batch == "A" ? "M1" : "M2";

            return SC.GetStringValue($"System.Stocker.{module}WaferType") == stockerWaferType;
        }
        private bool CheckJobPause()
        {
            return _pauseTrig.R;
        }
        private bool CheckToPostJobMessage(int msg, params object[] args)
        {
            _cycledCount = 0;
            //只有LoadProcessUnload和ChargeProcessDischarge有cycle模式
            if (SC.GetValue<bool>("System.IsCycleMode") && (msg == (int)MSG.LoadProcessUnload || msg == (int)MSG.ChargeProcessDischarge))
            {
                lock (_locker)
                {
                    _jobMSG = msg;
                    _jobParas = args;
                }
            }
            else
            {
                lock (_locker)
                {
                    _jobMSG = 0;
                    _jobParas = null;
                }
            }
            return CheckToPostMessage(msg, args);
        }
        private bool OnCycleTimer()
        {
            if (!SC.GetValue<bool>("System.IsSimulatorMode"))
            {
                //_plcConnectTrig.CLK = !(IoProviderManager.Instance.Providers[0] as AdsPlcAdapter).IsPlcConnected;

                //if (_plcConnectTrig.R)
                //{
                //    PLCDisconnectAlarm.Set();
                //}
                //if (_plcConnectTrig.T)
                //{
                //    EV.ClearAlarmEvent(PLCDisconnectAlarm.Id);
                //    PLCDisconnectAlarm.Reset();
                //    PLCConnectRecoveryWarning.Set();
                //}
            }
            _cassetteRobotModule.Monitor();
            _waferRobotModule.Monitor();
            _lp1Module.Monitor();
            _lp2Module.Monitor();
            _lp3Module.Monitor();
            _lp4Module.Monitor();
            _fims1Module.Monitor();
            _fims2Module.Monitor();
            _boatModule.Monitor();

            foreach (var module in Modules.Keys)
            {
                if (!(Modules[module] is StockerModule))
                    continue;
                Modules[module].Monitor();
            }

            return true;
        }
        public List<ProcessJobInfo> GetProcessJobInfo()
        {
            return _auto.LstProcessJobs;
        }
        public List<Tuple<string, string, List<int>>> GetProcessingStockers()
        {
            return _auto.GetProcessingStockers();
        }
        public List<Tuple<string, string, List<int>>> GetAllPJStockers()
        {
            return _auto.GetAllPJStockers();
        }
        public List<CarrierPara> GetTransferJobStockers()
        {
            return _transferJob.GetTransferJobStockers();
        }
        public void ResetTask(ModuleName module)
        {
            _auto.ResetTask(module);
            _transferJob.ResetTask(module);
            (_returnAll as ReturnAllWafer).ResetTask(module);
        }
        private void CoolingSkip()
        {
            _auto.CoolingSkip();
        }
    }
}