Kepler-Release/Venus/Venus_RT/Modules/VCE/LoadWithSMIFRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.ModuleLibrary.VceModules;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using Venus_Core;
using Venus_RT.Devices;
using Venus_RT.Devices.SMIF;
using Venus_RT.Devices.TM;
using Venus_RT.Devices.VCE;
using Venus_RT.Modules.TM;
using Venus_RT.Modules.TM.VenusEntity;
using static Venus_RT.Modules.VCE.LoadRoutine;

namespace Venus_RT.Modules.VCE
{

    public class LoadWithSMIFRoutine : ModuleRoutineBase, IRoutine
    {
        private enum LoadWithSMIFStep
        {
            VceGotoLP,
            VceOuterDoorOpen,
            SMIFLoad,
            CloseOutDoor,
            Mapping,
            ReadMap,
            VcePumpDown,
            OpenInnerDoor,
            NotifyOver
        }
        private TMBase _tm;
        private VCEModuleBase _vce;
        private ISMIF _smif;
        private int _VceMotionTimeout;
        private int _SMIFMotionTimeout;
        private SEMFPumpRoutine pumpRoutine;
        private bool _NeedPump = true;

        public LoadWithSMIFRoutine(ModuleName module, VCEModuleBase vce, ISMIF smif) : base(module)
        {
            _vce = vce;
            _smif = smif;

            switch (RtInstance.ConfigType)
            {
                case ConfigType.VenusSE:
                    _tm = DEVICE.GetDevice<HongHuTM>("TM");
                    break;
                case ConfigType.VenusDE:
                    _tm = DEVICE.GetDevice<HongHuDETM>("TM");
                    break;
            }
            pumpRoutine = new SEMFPumpRoutine(_tm, module);
            _NeedPump = !SC.GetValue<bool>("System.IsPumpBeforeJob");
        }


        public RState Start(params object[] objs)
        {
            _VceMotionTimeout = SC.GetValue<int>($"{Module}.MotionTimeout") * 1000;
            _SMIFMotionTimeout = SC.GetValue<int>($"{Module}.SMIF.MotionTimeout") * 1000;
            //如果不是ATM 不允许执行
            if (!Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module))
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE is not atm cannot load prepare! Please Vent it First!");
                return RState.Failed;
            }


            if (!Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed(Module))
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Inner Door is open! Please close it First!");
                return RState.Failed;
            }
            Reset();
            return Runner.Start(Module,"Start Load with smif");
        }

        public RState Monitor()
        {
            Runner
                .Run(LoadWithSMIFStep.VceGotoLP,        VceGotoLP,          CheckVceStageDownDone,          _VceMotionTimeout)
                .Run(LoadWithSMIFStep.VceOuterDoorOpen, VceOuterDoorOpen,   CheckVceOuterDoorOpenDone,      _VceMotionTimeout)
                .Run(LoadWithSMIFStep.SMIFLoad,         SMIFLoad,           CheckSMIFLoadDone,              _SMIFMotionTimeout)
                .Run(LoadWithSMIFStep.CloseOutDoor,     CloseOutDoor,       CheckVceIdle,                   _VceMotionTimeout)
                .RunIf(LoadWithSMIFStep.VcePumpDown,    _NeedPump,          PumpDown,                       CheckPumpOver,                  2*60*1000)
                .Run(LoadWithSMIFStep.Mapping,          Mapping,            CheckVceIdle,                   _VceMotionTimeout)
                .Run(LoadWithSMIFStep.ReadMap,          ReadMap,            CheckVceIdle,                   _VceMotionTimeout)
                .RunIf(LoadWithSMIFStep.OpenInnerDoor,  _NeedPump,          OpenInnerDoor,                  CheckInnerDoorOpen,             _VceMotionTimeout)
                .End(LoadWithSMIFStep.NotifyOver,       NullFun,                                            100);
            return Runner.Status;
        }

        private bool SMIFLoad()
        {
            //_smif.Load();
            return true;
        }

        private bool CheckSMIFLoadDone()
        { 
            return true;
        }

        private bool VceGotoLP()
        {
            return _vce.GotoLP();
        }

        private bool VceOuterDoorOpen()
        {
            if (Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module) && Singleton<RouteManager>.Instance.seTM.VCEPressure(Module) >= SC.GetValue<int>($"{Module}.OutDoorOpenPressure"))
            {
                return _vce.OpenDoor();
            }
            else
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"{Module} is not ATM or Pressure not arrive {SC.GetValue<int>($"{Module}.OutDoorOpenPressure")}");
                return false;
            }
        }
        private bool CheckVceStageDownDone()
        {
            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Stage Down failed");
            }
            return _vce.Status == RState.End;
        }

        private bool CheckVceOuterDoorOpenDone()
        {
            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE OuterDoor Open failed");
            }
            return _vce.Status == RState.End;
        }

        private bool CheckInnerDoorOpen()
        {
            return !_tm.VCESlitDoorClosed(Module);
        }

        private bool OpenInnerDoor()
        {
            return _tm.TurnSlitDoor(Module, true);
        }

        //
        private bool CheckPumpOver()
        {
            RState ret = pumpRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                Singleton<RouteManager>.Instance.VCE.PostMsg(VceMSG.Error);
            }
            return ret == RState.End;
        }

        private bool CheckVceIdle()
        {
            if (_vce.Status == RState.Failed || _vce.Status == RState.Timeout)
            {
                Singleton<RouteManager>.Instance.GetVCE(Module).PostMsg(VceMSG.Error);
                return false;
            }
            return _vce.Status == RState.End;
        }

        private bool PumpDown()
        {
            return pumpRoutine.Start() == RState.Running;
        }

        private bool ReadMap()
        {
            return _vce.ReadMap();
        }
        private bool Mapping()
        {
            return _vce.Map();
        }

        private bool CloseOutDoor()
        {
            return _vce.CloseDoor();
        }

        public void Abort()
        {

        }
    }
}