Kepler-Release/Venus/Venus_RT/Modules/LLs/LLEntity.cs

using System;
using Aitex.Core.Util;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_RT.Modules.TM;
using Venus_RT.Devices;
using Venus_Core;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.SCCore;
using System.Threading.Tasks;
using System.Threading;

namespace Venus_RT.Modules
{
    class LLEntity : Entity, IEntity, IModuleEntity
    {
        public enum LLStatus
        {
            Not_Ready,
            Ready_For_TM,
            Ready_For_EFEM,
        }

        public enum STATE
        {
            Unknown,
            Init,
            Initializing,
            Idle,
            Error,
            Pumping,
            Venting,
            Purging,
            LeakCheck,
            Prepare_For_TM,
            Prepare_For_EFEM,
            Ready_For_TM,
            Ready_For_EFEM,
        }

        public enum MSG
        {
            Home,
            Online,
            Offline,
            Pump,
            Vent,
            AutoPump,
            AutoVent,
            Purge,
            CyclePurge,
            LeakCheck,
            Prepare_TM,
            Prepare_EFEM,
            TM_Exchange_Ready,
            EFEM_Exchange_Ready,
            Error,
            Abort,
        }

        public ModuleName Module { get; private set; }

        public LLStatus Status { get; private set; }

        public bool Check(int msg, out string reason, params object[] args)
        {
            throw new NotImplementedException();
        }
        public bool IsIdle
        {
            get { return fsm.State == (int)STATE.Idle; }
        }

        public bool IsError
        {
            get { return fsm.State == (int)STATE.Error; }
        }

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

        public bool IsBusy
        {
            get { return !IsInit && !IsError && !IsIdle; }
        }

        public bool IsOnline { get; internal set; }

        public bool IsVac { get { return _JetTM.IsModuleVaccum(Module); } }

        public bool IsATM { get { return _JetTM.IsModuleATM(Module); } }

        private readonly JetTM _JetTM;
        private readonly MFPumpRoutine _pumpingRoutine;
        private readonly MFVentRoutine _ventingRoutine;
        private readonly MFLeakCheckRoutine _leakCheckRoutine;
        private readonly MFPurgeRoutine _purgeRoutine;
        private readonly int _slotNumber = 4;
        private bool startControlPressureFlag = true;

        private int _controlPressureCheckPoint = 100;
        private int _controlPressureSetPoint = 90;
        private int _controlFlowSetPoint = 90;

        public LLEntity(ModuleName module)
        {
            Module = module;
            _JetTM = DEVICE.GetDevice<JetTM>("TM");

            _pumpingRoutine = new MFPumpRoutine(_JetTM, Module);
            _ventingRoutine = new MFVentRoutine(_JetTM, Module);
            _leakCheckRoutine = new MFLeakCheckRoutine(_JetTM, Module);
            _purgeRoutine = new MFPurgeRoutine(_JetTM, Module);


            _slotNumber = SC.GetValue<int>($"{module.ToString()}.SlotNumber");
            WaferManager.Instance.SubscribeLocation(Module, _slotNumber);

            InitFsmMap();
        }
        protected override bool Init()
        {

            OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home));
            OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump));
            OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent));
            OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.Purge));
            OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort));
            OP.Subscribe($"{Module}.{RtOperation.LeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck));
            OP.Subscribe($"{Module}.{RtOperation.Online}", (cmd, args) => CheckToPostMessage((int)MSG.Online));
            OP.Subscribe($"{Module}.{RtOperation.Offline}", (cmd, args) => CheckToPostMessage((int)MSG.Offline));


            DATA.Subscribe($"{Module}.FsmState", () => (((STATE)fsm.State).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.FsmPrevState", () => (((PMState)fsm.PrevState).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.FsmLastMessage", () => (((MSG)fsm.LastMsg).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsOnline", () => IsOnline, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            return true;
        }
        private void InitFsmMap()
        {
            fsm = new StateMachine<LLEntity>(Module.ToString(), (int)STATE.Init, 50);
            fsm.EnableRepeatedMsg(true);

            EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_TM, fnEnterTMReady, FSM_MSG.NONE, fnExitTMReady);
            EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_EFEM, fnEnterEFEMReady, FSM_MSG.NONE, fnExitEFEMReady);

            //AnyStateTransition(FSM_MSG.TIMER,   fnMonitor,          FSM_STATE.SAME);


            AnyStateTransition(MSG.Error, fnError, STATE.Error);
            AnyStateTransition(MSG.Online, fnOnline, FSM_STATE.SAME);
            AnyStateTransition(MSG.Offline, fnOffline, FSM_STATE.SAME);
            AnyStateTransition(MSG.Home, fnHome, STATE.Initializing);

            // Home
            Transition(STATE.Initializing, FSM_MSG.TIMER, fnHoming, STATE.Idle);

            Transition(STATE.Idle, FSM_MSG.TIMER, fnMonitor, STATE.Idle);
            Transition(STATE.Init, FSM_MSG.TIMER, fnMonitor, STATE.Init);

            //vent sequence
            Transition(STATE.Idle, MSG.Vent, FnStartVent, STATE.Venting);
            Transition(STATE.Venting, FSM_MSG.TIMER, FnVentTimeout, STATE.Idle);
            Transition(STATE.Venting, MSG.Abort, FnAbortVent, STATE.Idle);

            //Pump sequence
            Transition(STATE.Idle, MSG.Pump, FnStartPump, STATE.Pumping);
            Transition(STATE.Pumping, FSM_MSG.TIMER, FnPumpTimeout, STATE.Idle);
            Transition(STATE.Pumping, MSG.Abort, FnAbortPump, STATE.Idle);

            // Purge sequence
            Transition(STATE.Idle, MSG.Purge, FnStartPurge, STATE.Purging);
            Transition(STATE.Purging, FSM_MSG.TIMER, FnPurgeTimeout, STATE.Idle);
            Transition(STATE.Purging, MSG.Abort, FnAbortPurge, STATE.Idle);

            // Leak check sequence
            Transition(STATE.Idle, MSG.LeakCheck, FnStartLeakCheck, STATE.LeakCheck);
            Transition(STATE.LeakCheck, FSM_MSG.TIMER, FnLeakCheckTimeout, STATE.Idle);
            Transition(STATE.LeakCheck, MSG.Abort, FnAbortLeakCheck, STATE.Idle);

            // Prepare TM Transfer
            Transition(STATE.Idle, MSG.Prepare_TM, FnStartPrepareTM, STATE.Prepare_For_TM);
            Transition(STATE.Prepare_For_TM, FSM_MSG.TIMER, FnPreparaTMTimeout, STATE.Ready_For_TM);
            Transition(STATE.Prepare_For_TM, MSG.Prepare_TM, null, STATE.Prepare_For_TM);
            Transition(STATE.Prepare_For_TM, MSG.Abort, FnAbortPreparaTM, STATE.Idle);
            Transition(STATE.Ready_For_TM, MSG.TM_Exchange_Ready, null, STATE.Idle);
            Transition(STATE.Ready_For_TM, MSG.Prepare_TM, null, STATE.Ready_For_TM);
            Transition(STATE.Ready_For_TM, MSG.Abort, null, STATE.Idle);
            Transition(STATE.Ready_For_TM, MSG.AutoVent, FnTryAutoVent, STATE.Venting);

            // Prepare EFEM Transfer
            Transition(STATE.Idle, MSG.Prepare_EFEM, FnStartPrepareEFEM, STATE.Prepare_For_EFEM);
            Transition(STATE.Prepare_For_EFEM, FSM_MSG.TIMER, FnPrepareEFEMTimeout, STATE.Ready_For_EFEM);
            Transition(STATE.Prepare_For_EFEM, MSG.Abort, FnAbortPrepareEFEM, STATE.Idle);
            Transition(STATE.Ready_For_EFEM, MSG.EFEM_Exchange_Ready, null, STATE.Idle);
            Transition(STATE.Ready_For_EFEM, MSG.Prepare_EFEM, null, STATE.Ready_For_EFEM);
            Transition(STATE.Ready_For_EFEM, MSG.Abort, null, STATE.Idle);
            Transition(STATE.Ready_For_EFEM, MSG.AutoPump, FnTryAutoPump, STATE.Pumping);

            //AnyStateTransition(FSM_MSG.TIMER, LLControlPressureTimer_Elapsed, FSM_STATE.SAME);

            Running = true;
        }

        public int Invoke(string function, params object[] args)
        {
            switch (function)
            {
                case "Home":
                    CheckToPostMessage((int)MSG.Home);
                    return (int)MSG.Home;
            }

            return (int)FSM_MSG.NONE;
        }

        public bool CheckAcked(int msg)
        {
            return fsm.CheckExecuted(msg);
        }

        public bool CheckToPostMessage(int msg, params object[] args)
        {
            if (!fsm.FindTransition(fsm.State, msg))
            {
                LOG.Write(eEvent.WARN_FSM_WARN, Module, $"{Module} is in {(STATE)fsm.State} state，can not do {(MSG)msg}");
                return false;
            }

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

            return true;
        }

        public (int processed, int unprocessed) GetWaferProcessStatus()
        {
            int processedCount = 0;
            int unprocessCount = 0;
            for (int i = 0; i < _slotNumber; i++)
            {
                var wafer = WaferManager.Instance.GetWafer(Module, i);
                if (!wafer.IsEmpty)
                {
                    if (wafer.ProcessState == Aitex.Core.Common.EnumWaferProcessStatus.Completed)
                    {
                        processedCount++;
                    }
                    else
                    {
                        unprocessCount++;
                    }
                }
            }

            return (processedCount, unprocessCount);
        }

        private bool fnEnterTMReady(object[] param)
        {          
            if (RouteManager.IsATMMode)
            {
                Status = LLStatus.Ready_For_TM;

                return true;
            }

            startControlPressureFlag = false;
            _controlPressureCheckPoint = SC.GetValue<int>($"{Module}.ControlPressureCheckPoint");
            _controlPressureSetPoint = SC.GetValue<int>($"{Module}.ControlPressureSetPoint");
            _controlFlowSetPoint = SC.GetValue<int>($"{Module}.{Module}_MFC1.DefaultSetPoint");
            _JetTM.TurnFastPumpValve(Module, true);

            _JetTM.TurnPurgeValve(Module, true);

            if (Module == ModuleName.LLA)
            {
                _JetTM.SwitchLLAPressureMode(true);
                _JetTM.SetLLAPressure(_controlPressureSetPoint);
            }
            else if (Module == ModuleName.LLB)
            {
                _JetTM.SwitchLLBPressureMode(true);
                _JetTM.SetLLBPressure(_controlPressureSetPoint);
            }

            Status = LLStatus.Ready_For_TM;

            return true;
        }

        private bool fnExitTMReady(object[] param)
        {
            

            if (RouteManager.IsATMMode)
            {
                Status = LLStatus.Not_Ready;

                return true;
            }


            _JetTM.TurnFastPumpValve(Module, false);
            _JetTM.TurnPurgeValve(Module, false);

            if (Module == ModuleName.LLA)
            {
                _JetTM.SwitchLLAPressureMode(false);
                _JetTM.SetLLAPressure(0);
            }
            else if (Module == ModuleName.LLB)
            {
                _JetTM.SwitchLLBPressureMode(false);
                _JetTM.SetLLBPressure(0);
            }

            Status = LLStatus.Not_Ready;

            return true;
        }


        private bool fnEnterEFEMReady(object[] param)
        {
            Status = LLStatus.Ready_For_EFEM;
            return true;
        }

        private bool fnExitEFEMReady(object[] param)
        {
            Status = LLStatus.Not_Ready;
            return true;
        }

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

        private bool fnError(object[] param)
        {
            IsOnline = false;
            return true;
        }

        private bool fnOnline(object[] param)
        {
            IsOnline = true;
            return true;
        }

        private bool fnOffline(object[] param)
        {
            IsOnline = false;
            return true;
        }

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

        private bool fnHome(object[] param)
        {
            IsOnline = true;
            return true;
        }

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

        private bool FnStartVent(object[] param)
        {
            return _ventingRoutine.Start() == RState.Running;
        }

        private  bool FnTryAutoVent(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                PostMsg(MSG.TM_Exchange_Ready);
                return false;
            }

            return _ventingRoutine.Start() == RState.Running;
        }

        private bool FnVentTimeout(object[] param)
        {
            RState ret = _ventingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortVent(object[] param)
        {
            _ventingRoutine.Abort();
            return true;
        }

        private bool FnStartPump(object[] param)
        {
            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnPumpTimeout(object[] param)
        {
            RState ret = _pumpingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPump(object[] param)
        {
            _pumpingRoutine.Abort();
            return true;
        }

        private bool FnTryAutoPump(object[] param)
        {
            if (_JetTM.LLPumpStatus != JetTM.LLPumpState.Idle || RouteManager.IsATMMode)
            {
                PostMsg(MSG.EFEM_Exchange_Ready);
                return false;
            }

            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnStartPurge(object[] param)
        {
            return _purgeRoutine.Start() == RState.Running;
        }

        private bool FnPurgeTimeout(object[] param)
        {
            RState ret = _purgeRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPurge(object[] param)
        {
            _purgeRoutine.Abort();
            return true;
        }

        private bool FnStartLeakCheck(object[] param)
        {
            return _leakCheckRoutine.Start() == RState.Running;
        }

        private bool FnLeakCheckTimeout(object[] param)
        {
            RState ret = _leakCheckRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortLeakCheck(object[] param)
        {
            _leakCheckRoutine.Abort();
            return true;
        }

        private bool FnStartPrepareTM(object[] param)
        {
            if (RouteManager.IsATMMode)
                return true;

            return _pumpingRoutine.Start() == RState.Running;
        }

        private bool FnPreparaTMTimeout(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                if (fsm.ElapsedTime > 10000)
                {
                    LOG.Write(eEvent.ERR_TM, Module, $"Cannot transfer wafer as {Module} is not ATM.");
                    PostMsg(MSG.Error);
                    return true;
                }


                return _JetTM.IsModuleATM(Module);
            }

            RState ret = _pumpingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPreparaTM(object[] param)
        {
            _pumpingRoutine.Abort();
            return true;
        }

        private bool FnStartPrepareEFEM(object[] param)
        {
            if (RouteManager.IsATMMode)
                return true;

            return _ventingRoutine.Start() == RState.Running;
        }

        private bool FnPrepareEFEMTimeout(object[] param)
        {
            if (RouteManager.IsATMMode)
            {
                if (fsm.ElapsedTime > 10000)
                {
                    LOG.Write(eEvent.ERR_TM, Module, $"Cannot transfer wafer as {Module} is not ATM.");
                    PostMsg(MSG.Error);
                    return true;
                }

                return _JetTM.IsModuleATM(Module);
            }

            RState ret = _ventingRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                PostMsg(MSG.Error);
                return false;
            }

            return ret == RState.End;
        }

        private bool FnAbortPrepareEFEM(object[] param)
        {
            _ventingRoutine.Abort();
            return true;
        }
        private void _debugRoutine()
        {
            int flag = 0;
            // Test Home routine
            if (flag == 1)
            {
                PostMsg(MSG.Home);
            }
            else if (flag == 2)
            {
                PostMsg(MSG.Vent);
            }
            else if (flag == 3)
            {
                PostMsg(MSG.Pump);
            }
            //else if (flag == 4)
            //{
            //    PostMsg(MSG.PumpLoadLock);
            //}
            //else if (flag == 5)
            //{
            //    PostMsg(MSG.VentLoadLock);
            //}
            //else if (flag == 6)
            //{
            //    PostMsg(MSG.PurgeLoadLock);
            //}
            //else if (flag == 7)
            //{
            //    PostMsg(MSG.LaunchPump);
            //}
            //else if (flag == 8)
            //{
            //    PostMsg(MSG.LaunchTurboPump);
            //}
            //else if (flag == 9)
            //{
            //    PostMsg(MSG.LoadLockLeakCheck);
            //}
            else if (flag == 10)
            {
                PostMsg(MSG.CyclePurge);
            }
            //else if (flag == 11)
            //{
            //    PostMsg(MSG.GasLinePurge);
            //}
            //else if (flag == 12)
            //{
            //    PostMsg(MSG.LeakCheck);
            //}
            //else if (flag == 13)
            //{
            //    PostMsg(MSG.GasLeakCheck);
            //}
            //else if (flag == 14)
            //{
            //    PostMsg(MSG.LLPlace);
            //}
            //else if (flag == 15)
            //{
            //    PostMsg(MSG.LLPick);
            //}
            //else if (flag == 16)
            //{
            //    PostMsg(MSG.RunRecipe, "7777");
            //}
            //else if (flag == 17)
            //{
            //    PostMsg(MSG.MFCVerification, "MFC2", (double)50, 10);
            //}
        }
    }
}