Mars200/FrameworkLocal/RTModuleLibrary/SystemModules/EquipmentManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
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 MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.Core.Applications;
using MECF.Framework.RT.Core.IoProviders;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.ModuleLibrary.Commons;
using MECF.Framework.RT.ModuleLibrary.EfemModules;
using MECF.Framework.RT.ModuleLibrary.LPModules;
using MECF.Framework.RT.ModuleLibrary.SystemModules.Routines;
using SecsGem.Core.Application;

namespace MECF.Framework.RT.ModuleLibrary.SystemModules
{
    public enum RtState
    {
        Init,

        Initializing,
        Idle,

        Transfer,
        AutoRunning,

        AutoIdle,

        ReturnAllWafer,
        TMCycling,
        TMCyclePaused,

        Error,

    }

    public class EquipmentManager : FsmDevice, IEquipmentCommand
    {
        public enum MSG
        {
            MoveWafer,
            ReturnAllWafer,
            TMCycleStart,
            TMCyclePause,
            TMCycleResume,

            Stop,

            HOME,
            RESET,
            ABORT,
            ERROR,

            ToInit,


            SetAutoMode,
            SetManualMode,

            ResetIdleCleanTime,
            ResetIdlePurgeTime,

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

            JobDone,

            ModuleError,

            Map,

        }

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

        public bool IsAutoIdle
        {
            get
            {
                return FsmState == (int)RtState.AutoIdle;
            }
        }

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

        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);
            }
        }

        private bool _isInited;

        protected IRoutine _manualTransfer;
        protected IAutoTransfer _auto;
        protected IRoutine _homeAll;
        protected IRoutine _returnAll;
        protected IRoutine _tmCycle;

        private List<string> _modules;

        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(100, RtState.Init);

            BuildTransitionTable();

            SubscribeDataVariable();

            SubscribeOperation();

            InitRoutine();

            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)
                {
                    if (modulesValue.Module != ModuleName.TM.ToString() && modulesValue.Module != ModuleName.EFEM.ToString())
                    {
                        if (!SC.GetValue<bool>($"System.SetUp.{modulesValue.Module}.IsInstalled"))
                        {
                            continue;
                        }
                    }
                    modulesValue.Initialize();
                }
            }
        }

        protected virtual void InitRoutine()
        {

        }

        protected virtual void InitModules()
        {
        }

        protected virtual void InitDevices()
        {
        }


        //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.RESET, fStartReset, RtState.Idle);

            AnyStateTransition(MSG.ERROR, fError, RtState.Error);
            AnyStateTransition((int)FSM_MSG.ALARM, fError, (int)RtState.Error);

            //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.AutoIdle);
            Transition(RtState.AutoRunning, MSG.JobDone, null, RtState.AutoIdle);
            Transition(RtState.AutoRunning, MSG.CreateJob, FsmCreateJob, RtState.AutoRunning);
            //Transition(RtState.AutoRunning, MSG.FAJobCommand, FsmFAJobCommand, 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.Map, FsmMap, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.ResetIdleCleanTime, FsmResetIdleCleanTime, RtState.AutoRunning);
            Transition(RtState.AutoRunning, MSG.ResetIdlePurgeTime, FsmResetIdlePurgeTime, RtState.AutoRunning);
            EnterExitTransition<RtState, FSM_MSG>(RtState.AutoRunning, null, FSM_MSG.NONE, fExitAutoTransfer);


            Transition(RtState.AutoIdle, FSM_MSG.TIMER, FsmMonitorAutoIdle, RtState.AutoIdle);
            //Transition(RtState.AutoIdle, MSG.FAJobCommand, FsmFAJobCommand, 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.ABORT, FsmAbort, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.AbortJob, FsmAbortJob, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.Map, FsmMap, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.ResetIdleCleanTime, FsmResetIdleCleanTime, RtState.AutoIdle);
            Transition(RtState.AutoIdle, MSG.ResetIdlePurgeTime, FsmResetIdlePurgeTime, RtState.AutoIdle);


            //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 all wafer
            Transition(RtState.Idle, MSG.TMCycleStart, FsmStartTMCycle, RtState.TMCycling);
            Transition(RtState.TMCycling, MSG.TMCyclePause, null, RtState.TMCyclePaused);
            Transition(RtState.TMCyclePaused, MSG.TMCycleResume, null, RtState.TMCycling);
            Transition(RtState.TMCycling, FSM_MSG.TIMER, FsmMonitorTMCycle, RtState.Idle);
            Transition(RtState.TMCycling, MSG.ABORT, FsmAbortTMCycle, RtState.Idle);

            //Transfer sequence
            Transition(RtState.Idle, MSG.MoveWafer, fStartTransfer, RtState.Transfer);
            Transition(RtState.Transfer, FSM_MSG.TIMER, fTransfer, RtState.Idle);
            Transition(RtState.Transfer, MSG.ABORT, FsmAbort, RtState.Idle);
            EnterExitTransition<RtState, FSM_MSG>(RtState.Transfer, null, FSM_MSG.NONE, fExitTransfer);

        }

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

            DATA.Subscribe("System.IsIdle", () => IsIdle || IsInit|| IsAutoIdle);
            DATA.Subscribe("System.IsAlarm", () => IsAlarm);
            DATA.Subscribe("System.IsBusy", () => IsRunning);
            DATA.Subscribe("System.IsAutoRunning", () => IsRunning);
            DATA.Subscribe("System.IsAutoMode", () => IsAutoMode);
            DATA.Subscribe("System.IsConnectedWithHost", () => CheckSecsGemOnline(Singleton<SecGemApplication>.Instance.ControlState));
            DATA.Subscribe("System.IsDisconnectWithHost", () => CheckSecsGemOnline(Singleton<SecGemApplication>.Instance.ControlState));

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


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

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

                return 2;
            }, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 检验Secsgem在线情况
        /// </summary>
        /// <param name="controlState"></param>
        /// <returns></returns>
        private bool CheckSecsGemOnline(SecsGem.Core.EnumData.ControlState controlState)
        {
            if(controlState==SecsGem.Core.EnumData.ControlState.OnlineLocal||controlState==SecsGem.Core.EnumData.ControlState.OnlineRemote)
            {
                return true;
            }
            return false;
        }
        void SubscribeOperation()
        {
            OP.Subscribe("Create8InchWafer", InvokeCreate8InchWafer);
            OP.Subscribe("Create12InchWafer", InvokeCreate12InchWafer);
            OP.Subscribe("CreateWafer", InvokeCreateWafer);

            OP.Subscribe("DeleteWafer", InvokeDeleteWafer);

            OP.Subscribe("ReturnWafer", InvokeReturnWafer);

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

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

            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.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) =>
            {
                bool result= CheckToPostMessage((int)MSG.PauseJob, args[0]);
                //if(result)
                //{
                //    OP.DoOperation("E94PauseJob",args);
                //}
                return result;
            });
            OP.Subscribe("System.ResumeJob", (string cmd, object[] args) =>
            {
                bool result = CheckToPostMessage((int)MSG.ResumeJob, args[0]);
                //if(result)
                //{
                //    OP.DoOperation("E94ResumeJob", args);
                //}
                return result;
            });

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

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

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

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


        private void Instance_OnAlarmEvent(EventItem obj)
        {


        }

        #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 AutoTransfer

        private bool FsmMonitorAutoIdle(object[] param)
        {
            //fMonitorFAJob(param);
            //return true;
            Result ret = _auto.Monitor();

            if (!_auto.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)
        {
            //fMonitorFAJob(objs);

            Result ret = _auto.Monitor();

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

            return ret == Result.DONE;
        }

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

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

        #endregion


        #region  return all wafer

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

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

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

        #region  return all wafer

        private bool FsmAbortTMCycle(object[] param)
        {
            _tmCycle.Abort();
            return true;
        }

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

        private bool FsmStartTMCycle(object[] param)
        {
            return _tmCycle.Start(param) == 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)
            {
                if (modulesValue.Module != ModuleName.TM.ToString() &&
                    modulesValue.Module != ModuleName.EFEM.ToString() &&
                    !SC.GetValue<bool>($"System.SetUp.{modulesValue.Module}.IsInstalled"))
                    continue;

                modulesValue.Reset();
            }


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


            return false;
        }

        #endregion

        private bool FsmCreateJob(object[] param)
        {
            _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]);
            //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 FsmAbort(object[] param)
        {
            if (FsmState == (int)RtState.Transfer)
            {
                // _manualTransfer.Clear();
            }

            if (FsmState == (int)RtState.AutoRunning || FsmState == (int)RtState.AutoIdle)
            {
                _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 FsmMap(object[] param)
        {
            _auto.Map((string)param[0]);

            return true;
        }

        private bool FsmResetIdlePurgeTime(object[] param)
        {
            _auto.ResetIdlePurgeTime((string)param[0]);

            return true;
        }

        private bool FsmResetIdleCleanTime(object[] param)
        {
            _auto.ResetIdleCleanTime((string)param[0]);

            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 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
            {

                EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
                return false;
            }

            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 (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;
            //    }
            //}
            WaferSize ws = WaferSize.WS0;
            switch (SC.GetValueOrDefault<int>("System.DefaultCreateWaferSize"))
            {
                case 0:
                    ws = WaferSize.WS0;
                    break;
                case 4:
                    ws = WaferSize.WS4;
                    break;
                case 6:
                    ws = WaferSize.WS6;
                    break;
                case 8:
                    ws = WaferSize.WS8;
                    break;
                case 12:
                    ws = WaferSize.WS12;
                    break;
            }

            if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
            {
                var wafer = WaferManager.Instance.GetWafer(chamber,slot);
                if(wafer != null && !wafer.IsEmpty)
                {
                    EV.PostInfoLog("System", string.Format("{0} slot {1} already has wafer.create wafer is not valid", chamber, slot));
                }
                else if (WaferManager.Instance.CreateWafer(chamber, slot, state, ws) != 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;
            }


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


            //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));
                }
                else if (WaferManager.Instance.CreateWafer(chamber, slot, state, WaferSize.WS8) != 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;
            }


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


            //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));
                }
                else if (WaferManager.Instance.CreateWafer(chamber, slot, state, WaferSize.WS12) != 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;
            }


            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 bool InvokeEfemMap(string arg1, object[] arg2)
        {
            ModuleName target = ModuleHelper.Converter((string)arg2[0]);
            if (!ModuleHelper.IsLoadPort(target))
            {
                EV.PostWarningLog("System", $"Invalid map target {target}");
                return false;
            }

            for (int i = 0; i < 25; i++)
            {
                WaferInfo wafer = WaferManager.Instance.GetWafer(target, i);
                if (wafer.IsEmpty)
                    continue;
                if (wafer.ProcessState == EnumWaferProcessStatus.Completed ||
                    wafer.ProcessState == EnumWaferProcessStatus.Failed)
                {
                    EV.PostWarningLog("System", $"{target} wafer is processed, can not map again");
                    return false;
                }
            }


            if (IsAutoMode)
            {
                _auto.Map((string)arg2[0]);

                return true;
            }

            //EfemModule efem = Modules[ModuleName.EfemRobot] as EfemModule;

            //if (!efem.Map(ModuleHelper.Converter((string) arg2[0]), out string reason))
            //{
            //    EV.PostWarningLog(Module, reason);
            //}
            return true;
        }

        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();
        }

        string sourceModule = "";

        #region control job /process job nnotation
        /*
        private bool fMonitorFAJob(object[] param)
        {

            //Singleton<FAJobController>.Instance.MonitorJob();

            E40ProcessJob[] pjs = Singleton<FAJobController>.Instance.FAProcessJobs.Values.ToArray();
            E94ControlJob[] cjs = Singleton<FAJobController>.Instance.FAControlJobs.Values.ToArray();
            foreach (var pj in pjs)
            {
                if ((pj.PJstate == ProcessJobState.NONE || pj.PJstate == ProcessJobState.PROCESS_COMPLETE)
                    && Singleton<FAJobController>.Instance.FAProcessJobs.ContainsKey(pj.ObjtID))
                    Singleton<FAJobController>.Instance.FAProcessJobs.Remove(pj.ObjtID);

                if (pj.PJstate == ProcessJobState.ABORTING)
                    Singleton<FAJobController>.Instance.FAProcessJobs[pj.ObjtID].PJAborted();
                if (pj.PJstate == ProcessJobState.ABORTED)
                    Singleton<FAJobController>.Instance.FAProcessJobs.Remove(pj.ObjtID);
            }
            foreach (var cj in cjs)
            {
                if ((cj.state == ControlJobState.NONE || cj.state == ControlJobState.COMPLETED)
                    && Singleton<FAJobController>.Instance.FAControlJobs.ContainsKey(cj.ObjtID))
                    Singleton<FAJobController>.Instance.FAControlJobs.Remove(cj.ObjtID);
            }
            if (Singleton<FAJobController>.Instance.FAProcessJobs.Count == 0) return true;
            if (Singleton<FAJobController>.Instance.FAControlJobs.Count == 0) return true;




            foreach (var pj in pjs)
            {
                if (pj.PJstate == ProcessJobState.POOLED)
                {
                    foreach (var mtrlname in pj.PRMtlNameList)
                    {
                        string lp = CarrierManager.Instance.GetLocationByCarrierId(mtrlname.CarrierID);

                        if (lp == null)
                            continue;

                        if (Singleton<FAJobController>.Instance.FAloadports[lp].GetCarrierIDStatus() == CarrierIDStatus.ID_VERIFICATION_OK &&
                            Singleton<FAJobController>.Instance.FAloadports[lp].GetSlotMapStatus() == SlotMapStatus.SLOT_MAP_VERIFICATION_OK)
                        {
                            pj.MaterialPresentAndResourceReady();
                            AssignProcessJob(mtrlname, pj.RecID, pj.PRRecipeMethod, pj.RecVariableList, pj.ObjtID);
                        }

                    }
                }
            }
            foreach (var cj in cjs)
            {
                if (cj.state == ControlJobState.QUEUED)
                {
                    bool allPjSetUp = true;
                    cj.MtrlOutSpec = new List<MtrlOutSpecPair>();
                    foreach (var pj in cj.ProcessingCtrlSpec)
                    {
                        if (!Singleton<FAJobController>.Instance.FAProcessJobs.ContainsKey(pj))
                        {
                            allPjSetUp = false;
                            break;
                        }

                        if (Singleton<FAJobController>.Instance.FAProcessJobs[pj].PJstate != ProcessJobState.SETTING_UP)
                        {
                            allPjSetUp = false;
                            break;
                        }

                        foreach (var PRMtl in Singleton<FAJobController>.Instance.FAProcessJobs[pj].PRMtlNameList)
                        {
                            cj.MtrlOutSpec.Add(new MtrlOutSpecPair() { sourceCarID = PRMtl.CarrierID, DestCarID = PRMtl.CarrierID, sourceSlots = PRMtl.SlotID, destSlots = PRMtl.SlotID });
                        }

                    }

                    if (allPjSetUp)
                    {
                        cj.ProcessResourceReady();
                    }
                }

                if (cj.MtrlOutSpec == null || cj.MtrlOutSpec.Count == 0)
                    continue;

                //string sourceModule = "";
                //检查source ready
                if (cj.state == ControlJobState.SELECTED)
                {
                    bool sourceReady = true;
                    for (int i = 0; i < cj.MtrlOutSpec.Count; i++)
                    {
                        sourceModule = cj.MtrlOutSpec[i].sourceCarID;
                        if (!CheckCJMaterialSourceReady(cj.MtrlOutSpec[i]) || !CheckCJMaterialDestReady(cj.MtrlOutSpec[i]))
                        {
                            sourceReady = false;
                            break;
                        }
                    }
                    if (!sourceReady)
                        continue;


                    Task.Delay(500).ContinueWith(x =>
                    {
                        cj.MaterialArrived();
                    });


                    Task.Delay(1000).ContinueWith(x =>
                    {
                        foreach (var pj in cj.ProcessingCtrlSpec)
                        {
                            Singleton<FAJobController>.Instance.FAProcessJobs[pj].MaterialReadyForProcessing();
                        }
                    });

                }

                if (cj.state == ControlJobState.EXECUTING)
                {
                    cj.MtrlOutSpec.Clear();

                    AssignControlJob(cj.ObjtID, CarrierManager.Instance.GetLocationByCarrierId(sourceModule), cj.ProcessingCtrlSpec);
                }
            }
            return true;
        }

        public bool CheckCJMaterialSourceReady(MtrlOutSpecPair mtp)
        {
            string lp = CarrierManager.Instance.GetLocationByCarrierId(mtp.sourceCarID);
            if (string.IsNullOrEmpty(lp)) return false;
            if (Singleton<FAJobController>.Instance.FAloadports[lp].GetSlotMapStatus()
                != SlotMapStatus.SLOT_MAP_VERIFICATION_OK) return false;
            if (Singleton<FAJobController>.Instance.FAloadports[lp].GetCarrierIDStatus()
                != CarrierIDStatus.ID_VERIFICATION_OK) return false;
            foreach (var slot in mtp.sourceSlots)
            {
                var wafer = WaferManager.Instance.GetWafer((ModuleName)Enum.Parse(typeof(ModuleName), lp), slot - 1);
                if (wafer.IsEmpty) return false;
                if (wafer.SubstE90Status != EnumE90Status.NeedProcessing) return false;
            }
            return true;
        }
        public bool CheckCJMaterialDestReady(MtrlOutSpecPair mtp)
        {
            string lp = CarrierManager.Instance.GetLocationByCarrierId(mtp.DestCarID);
            if (string.IsNullOrEmpty(lp)) return false;
            if (Singleton<FAJobController>.Instance.FAloadports[lp].GetSlotMapStatus()
                != SlotMapStatus.SLOT_MAP_VERIFICATION_OK) return false;
            if (Singleton<FAJobController>.Instance.FAloadports[lp].GetCarrierIDStatus()
                != CarrierIDStatus.ID_VERIFICATION_OK) return false;
            return true;
        }


        public bool AssignProcessJob(ProcessMaterialName matrial, string recipe, ProcessRecipeMethod method, Dictionary<string, object> RecVariableList, string pjID)
        {
            string lp = CarrierManager.Instance.GetLocationByCarrierId(matrial.CarrierID);
            string[] slotsequence = new string[25];

            for (int i = 0; i < 25; i++)
            {
                if (matrial.SlotID.Contains(i + 1)) slotsequence[i] = recipe;
                else slotsequence[i] = "";
            }

            Dictionary<string, object> para = new Dictionary<string, object>();
            para.Add("JobId", pjID);
            para.Add("Module", lp);
            para.Add("SlotSequence", slotsequence);
            para.Add("AutoStart", true);

            //OP.DoOperation("System.CreateJob", new object[] { para });

            List<int> slot = new List<int>();
            foreach (var i in matrial.SlotID)
            {
                slot.Add(i - 1);
            }

            CheckToPostMessage((int)MSG.FAJobCommand, new object[] { "CreateProcessJob", pjID, recipe, slot, true });

            return true;
        }

        public bool AssignControlJob(string cjID, string module, List<string> pjList)
        {
            //OP.DoOperation("System.StartJob", new object[] { pjID });

            CheckToPostMessage((int)MSG.FAJobCommand, new object[] { "CreateControlJob", cjID, module, pjList, true });

            return true;
        }

        private bool FsmFAJobCommand(object[] param)
        {
            switch ((string)param[0])
            {
                case "CreateProcessJob":
                    _auto.CreateProcessJob((string)param[1], (string)param[2], (List<int>)param[3], (bool)param[4]);
                    break;
                case "CreateControlJob":
                    _auto.CreateControlJob((string)param[1], (string)param[2], (List<string>)param[3], (bool)param[4]);
                    CheckToPostMessage((int)MSG.StartJob, (string)param[1]);
                    break;
            }

            return true;
        }
        */
        #endregion

        public bool RegisterEvent(bool isAlarm, string eventname, string eventcontext)
        {
            return true;
        }

        public bool PostEvent(bool isAlarm, string eventname, Dictionary<string, string> dvid, Dictionary<string, object> objdvid)
        {
            return true;
        }

        public bool ExcuteCommand(string command, object[] paras, out string reason)
        {
            reason = "";
            int portID;
            string jobID;
            string lotId;
            object[] sequence;
            string[] slotsequence;
            LoadPortModuleBase lp;
            switch (command.ToUpper())
            {
                case "PP-SELECT":
                    if(!IsAutoMode)
                    {
                        reason = "system is not auto";
                        return false;
                    }
                    portID = int.Parse(paras[0].ToString());
                    jobID = paras[1].ToString();
                    lotId = paras[2].ToString();
                    sequence = (object[])paras[3];
                    slotsequence = new string[25];
                    for (int i = 0; i < 25; i++)
                    {
                        slotsequence[i] = sequence[i].ToString() == "*null*" ? "" : sequence[i].ToString();
                    }
                    Dictionary<string, object> para = new Dictionary<string, object>();
                    para.Add("JobId", jobID);
                    para.Add("LotId", lotId);
                    para.Add("Module", ((ModuleName)portID).ToString());
                    para.Add("SlotSequence", slotsequence);
                    para.Add("AutoStart", true);

                    return CheckToPostMessage((int)MSG.CreateJob, para);

                case "STARTJOB":
                    jobID = paras[0].ToString();
                    return CheckToPostMessage((int)MSG.StartJob, jobID);
                case "ABORTJOB":
                    jobID = paras[0].ToString();
                    return _auto.AbortJob(jobID);
                case "PAUSEJOB":
                    jobID = paras[0].ToString();
                    return _auto.PauseJob(jobID);
                case "RESUMEJOB":
                    jobID = paras[0].ToString();
                    return _auto.ResumeJob(jobID);
                case "STOPJOB":
                    jobID = paras[0].ToString();
                    return _auto.StopJob(jobID);
                case "LOAD":
                    portID = int.Parse(paras[0].ToString());
                    lp = Modules[(ModuleName)portID] as LoadPortModuleBase;
                    if (lp != null)
                    {
                        return lp.Load();
                    }

                    reason = $"Not Find LP{portID}";
                    return false;

                case "UNLOAD":
                    portID = int.Parse(paras[0].ToString());
                    lp = Modules[(ModuleName)portID] as LoadPortModuleBase;
                    if (lp != null)
                    {
                        return lp.Unload();
                    }

                    reason = $"Not Find LP{portID}";
                    return false;

                case "MAPCASSETTE":
                    portID = int.Parse(paras[0].ToString());
                    var efem = Modules[ModuleName.EFEM] as EfemModuleBase;
                    if (efem != null && (portID == 1 || portID == 2))
                    {
                        return efem.Map((ModuleName)portID, out reason);
                    }

                    reason = $"Not Find LP{portID}";
                    return false;
                case "READID":
                case "READRFID":
                case "READTAG":
                    portID = int.Parse(paras[0].ToString());
                    LoadPort lpDevice = DEVICE.GetDevice<LoadPort>("LP" + portID.ToString());
                    if (lpDevice != null)
                    {
                        return lpDevice.ReadRfId(out reason);
                    }
                    else
                    {
                        reason = $"Not Find LP{portID}";
                        return false;
                    }

                case "CLAMP":
                case "LOCK":
                    {
                        portID = int.Parse(paras[0].ToString());
                        lpDevice = DEVICE.GetDevice<LoadPort>("LP" + portID.ToString());
                        if (lpDevice != null)
                        {
                            return lpDevice.Clamp(out reason);
                        }
                        else
                        {
                            reason = $"Not Find LP{portID}";
                            return false;
                        }
                    }

                case "UNCLAMP":
                case "UNLOCK":
                    {
                        portID = int.Parse(paras[0].ToString());
                        lpDevice = DEVICE.GetDevice<LoadPort>("LP" + portID.ToString());
                        if (lpDevice != null)
                        {
                            return lpDevice.Unclamp(out reason);
                        }
                        else
                        {
                            reason = $"Not Find LP{portID}";
                            return false;
                        }
                    }

                case "WRITEID":
                case "WRITERFID":
                case "WRITETAG":
                    {
                        portID = int.Parse(paras[0].ToString());
                        string rfid = paras[1].ToString();
                        lpDevice = DEVICE.GetDevice<LoadPort>("LP" + portID.ToString());
                        if (lpDevice != null)
                        {
                            return lpDevice.WriteRfId(rfid, out reason);
                        }
                        else
                        {
                            reason = $"Not Find LP{portID}";
                            return false;
                        }
                    }

                
            }
            return true;
        }

        public string[] GetRecipeList(string param)
        {
            if (param == "SEQUENCE")
                return RecipeFileManager.Instance.GetSequenceNameList().ToArray();
            if (param == "PMA")
                return RecipeFileManager.Instance.GetRecipes("PMA", true).ToArray();
            if (param == "PMB")
                return RecipeFileManager.Instance.GetRecipes("PMB", true).ToArray();

            return RecipeFileManager.Instance.GetSequenceNameList().ToArray();
        }

        public string GetRecipeBody(string param, string recipename)
        {
            if (param == "SEQUENCE")
                return RecipeFileManager.Instance.GetSequence(recipename, false);
            if (param == "PMA")
                return RecipeFileManager.Instance.LoadRecipe("PMA", recipename, false);
            if (param == "PMB")
                return RecipeFileManager.Instance.LoadRecipe("PMB", recipename, false);

            return RecipeFileManager.Instance.GetSequence(recipename, false);
        }

        public string[] GetSequenceList()
        {
            return RecipeFileManager.Instance.GetSequenceNameList().ToArray();
        }

        public string GetSequenceBody(string ppid)
        {
            return RecipeFileManager.Instance.GetSequence(ppid, false);
        }

        public List<string> GetFormatedSequence(string ppid)
        {
            List<string> result = new List<string>();
            string reason = string.Empty;

            try
            {
                string content = "";
                if (ppid.StartsWith("PMA") || ppid.StartsWith("PMB") || ppid.StartsWith("PMC"))
                {
                    content = RecipeFileManager.Instance.LoadRecipe("", ppid, false);
                }
                else
                {
                    content = RecipeFileManager.Instance.GetSequence(ppid, false);
                }

                result.Add(content);
            }
            catch (Exception ex)
            {
                reason = ex.Message;
            }


            return result;
        }

        public bool deleteSequence(string ppid)
        {
            return RecipeFileManager.Instance.DeleteSequence(ppid);
        }

        public bool UpdateSequence(string ppid, string body)
        {
            return RecipeFileManager.Instance.SaveSequence(ppid, body, false);
        }

        public void ShowTerminalMessage(string message)
        {
        }

        /// <summary>
        /// 创建ProcessJob
        /// </summary>
        /// <param name="processJobId"></param>
        /// <param name="sequenceName"></param>
        /// <param name="carrierId"></param>
        /// <returns></returns>
        public bool CreateProcessJob(string processJobId, string sequenceName,string carrierId,out string reason)
        {
            if(!IsAutoMode)
            {
                reason = "system is not auto";
                return false;
            }

            return _auto.CreateProcessJob(processJobId, sequenceName,carrierId, out reason);
        }

        /// <summary>
        /// 更新processJob carrierSlot信息
        /// </summary>
        /// <param name="processJobId"></param>
        /// <param name="moduleName"></param>
        /// <param name="slots"></param>
        public void UpdateProcessJobCarrierSlot(string processJobId, string moduleName, List<int> slots)
        {
            _auto.UpdateProcessJobSlotWafer(processJobId, moduleName, slots);
        }
        /// <summary>
        /// 检验创建ControlJob的条件
        /// </summary>
        /// <returns></returns>
        public bool CheckCreateControlJobCondition(List<string> modules, out string reason)
        {
            if (!IsAutoMode)
            {
                reason = "system is not auto";
                return false;
            }
            return _auto.CheckCreateControlJobCondition(modules,out reason);
        }

        /// <summary>
        /// 创建ControlJob
        /// </summary>
        /// <param name="controlJobId"></param>
        /// <param name="moduleName"></param>
        /// <param name="carrierId"></param>
        /// <param name="processJobs"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        public void CreateControlJob(string controlJobId, string carrierId, List<string> processJobs)
        {
            _auto.CreateControlJob(controlJobId, carrierId, processJobs);
        }
        /// <summary>
        /// 更新ControlJob Module信息
        /// </summary>
        /// <param name="controlJobId"></param>
        /// <param name="moduleName"></param>
        public void UpdateControlJobModule(string controlJobId, string moduleName)
        {
            _auto.UpdateControlJobModule(controlJobId, moduleName);
        }
        /// <summary>
        /// 启动任务
        /// </summary>
        /// <param name="controlJob"></param>
        /// <returns></returns>
        public bool StartControlJob(string controlJob)
        {
            return CheckToPostMessage((int)MSG.StartJob, controlJob);
        }
        /// <summary>
        /// 停止任务
        /// </summary>
        /// <param name="controlJob"></param>
        /// <returns></returns>
        public bool StopControlJob(string controlJob)
        {
            return CheckToPostMessage((int)MSG.StopJob, controlJob);
        }
        /// <summary>
        /// 中止任务
        /// </summary>
        /// <param name="controlJob"></param>
        /// <returns></returns>
        public bool AbortControlJob(string controlJob)
        {
            return CheckToPostMessage((int)MSG.AbortJob, controlJob);
        }
        /// <summary>
        /// 暂停任务
        /// </summary>
        /// <param name="controlJob"></param>
        /// <returns></returns>
        public bool PauseControlJob(string controlJob)
        {
            return CheckToPostMessage((int)MSG.PauseJob, controlJob);
        }
        /// <summary>
        /// 启动任务
        /// </summary>
        /// <param name="controlJob"></param>
        /// <returns></returns>
        public bool ResumeControlJob(string controlJob)
        {
            return CheckToPostMessage((int)MSG.ResumeJob, controlJob);
        }
        /// <summary>
        /// 检验Auto
        /// </summary>
        /// <returns></returns>
        public bool CheckAuto()
        {
            return IsAutoMode;
        }

        /// <summary>
        /// 告警日志
        /// </summary>
        /// <param name="message"></param>
        public void WriteWarningLog(string message)
        {
            LOG.Warning($"EAP {message}");
        }
        /// <summary>
        /// 错误日志
        /// </summary>
        /// <param name="message"></param>
        public void WriteErrorLog(string message)
        {
            EV.PostAlarmLog("EAP", $"EAP {message}");
        }
        /// <summary>
        /// 正常日志
        /// </summary>
        /// <param name="message"></param>
        public void WriteInfoLog(string message)
        {
            LOG.Write($"EAP {message}" );
        }
    }
}