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

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

namespace Venus_RT.Modules.VCE
{
    public class UnloadRoutine : ModuleRoutineBase, IRoutine
    {
        public enum UnloadStep
        {
            CloseDoor,
            Vent,
            GotoUnload,
            OpenOutDoor,
            NotifyOver
        }
        VCEModuleBase _vce;
        TMBase _tm;
        int _timeout;
        SEMFVentRoutine ventRoutine;

        public UnloadRoutine(ModuleName module, VCEModuleBase vce) : base(module)
        {
            _vce = vce;
            switch (RtInstance.ConfigType)
            {
                case ConfigType.VenusSE:
                    _tm = DEVICE.GetDevice<HongHuTM>("TM");
                    break;
                case ConfigType.VenusDE:
                    _tm = DEVICE.GetDevice<HongHuDETM>("TM");
                    break;
            }
            ventRoutine = new SEMFVentRoutine(_tm, module);
        }

        public RState Start(params object[] objs)
        {
            _timeout = SC.GetValue<int>($"{Module}.MotionTimeout") * 1000;
            //if vce inner door not close cannot dot it as it will vent
            //if (!Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed)
            //{
            //    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, "VCE Unload Routine");
        }

        public RState Monitor()
        {
            Runner.Run(UnloadStep.GotoUnload, GotoUnload, CheckVceIdle, _timeout)
                  .Run(UnloadStep.CloseDoor, CloseDoor, CheckDoorIsClose)
                  .Run(UnloadStep.Vent, Vent, CheckVentOver)
                  .Run(UnloadStep.OpenOutDoor, OpenOutDoor, CheckVceIdle, _timeout)
                  .End(UnloadStep.NotifyOver, NullFun, 100);
            return Runner.Status;
        }

        private bool CloseDoor()
        {
            return _tm.TurnSlitDoor(Module, false);
        }

        private bool CheckDoorIsClose()
        {
            return Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed(Module);
        }

        private bool CheckVentOver()
        {
            RState ret = ventRoutine.Monitor();
            if (ret == RState.Failed || ret == RState.Timeout)
            {
                _vce.PostMsg(VceMSG.Error);
            }
            return ret == RState.End;
        }

        private bool Vent()
        {
            return ventRoutine.Start() == RState.Running;
        }

        private bool OpenOutDoor()
        {
            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 GotoUnload()
        {
            return _vce.GotoLP();
        }

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

        public void Abort()
        {
        }

    }
}