CyberX8/CyberX8_RT/Devices/Loader/LoaderInstallCRSRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using MECF.Framework.Common.CommonData.Loader;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.AXIS.CANOpen;
using CyberX8_RT.Modules.PUF;
using CyberX8_RT.Modules;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CyberX8_RT.Modules.Transporter;

namespace CyberX8_RT.Devices.Loader
{
    public class LoaderInstallCRSRoutine : RoutineBase, IRoutine
    {
        private enum InstallStep
        {
            DoorUnlock,
            DoorUnlockCheck,
            TiltGotoVertical,
            TiltGotoVerticalCheck,
            SwingGotoOpen,
            SwingGotoOpenWait,
            CRSGotoUnlock,
            CRSGotoUnlockWait,
            SwingGotoClose,
            SwingGotoCloseWait,
            DoorLockOn,
            DoorLockOnCheck,
            WSSideClampOn,
            WSSideClampOnCheck,
            WSClampOn,
            BernoulliN2On,
            BernoulliN2OnCheck,
            BernoulliBladderOn,
            BernoulliBladderOnCheck,
            TransBladderOn,
            TransBladderOnCheck,
            TranslateHighOff,
            TranslateHighOffCheck,
            CRSVacuumOn,
            CRSVacuumOnCheck,
            WSBladderOn,
            WSBladderOnCheck,
            VacuumLevel,
            VacuumLevelCheck,
            CRSGotoLock,
            CRSGotoLockWait,
            CRSVacuumOff,
            CRSVacuumOffCheck,
            WSBladderOff,
            WSBladderOffCheck,
            VacuumOffLevel,
            VacuumOffLevelCheck,
            CRSSwitchOn,
            CRSSwitchOnCheck,
            TransBladderOff,
            TransBladderOffCheck,
            LastTranslateHighOff,
            LastTranslateHighOffCheck,
            BernoulliN2Off,
            BernoulliN2OffCheck,
            HomingCRSAxis,
            HomingCRSAxisWait,
            CRSHomedGotoSetUp,
            CRSHomedGotoSetUpCheck,
            End
        }

        #region 内部变量
        private string _side = "";
        private LoaderCommonWaferHolderSideClampRoutine _waferHolderSideClampRoutine;
        private LoaderSideTransBladderRoutine _transBladderRoutine;
        private JetAxisBase _crsAxis;
        private LoaderSideBernoulliBladderRoutine _bernoulliBladderRoutine;
        private LoaderSideBernoulliN2PressureRoutine _bernoulliN2PressureRoutine;
        private LoaderSideTransHighRoutine _transHightRoutine;
        private LoaderSideVacuumRoutine _vacuumRoutine;
        private LoaderSideVacuumLevelCheckRoutine _vacuumLevelCheckRoutine;
        private LoaderSideWhBladderRoutine _whBladderRoutine;
        private LoaderSideUnloadVacuumLevelCheckRoutine _unloadVacuumLevelCheckRoutine;
        private LoaderSideDoorLockRoutine _doorLockRoutine;
        private JetAxisBase _shuttleAxis;
        private JetAxisBase _tiltAxis;
        private JetAxisBase _rotationAxis;
        private LoaderCommonDevice _loaderCommonDevice;
        private LoaderSideDevice _sideDevice;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public LoaderInstallCRSRoutine(string module,string side) : base(module)
        {
           _side = side;
        }
        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            //1.0 Door UnLock 
            Runner.Run(InstallStep.DoorUnlock, () => { return _doorLockRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.DoorUnlockCheck, () => { return CommonFunction.CheckRoutineEndState(_doorLockRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_doorLockRoutine); })
            //1.1 Tilt Goto Vertical
            .Run(InstallStep.TiltGotoVertical, () => { return _tiltAxis.PositionStation("VERT",false); }, NullFun, _delay_1ms)
            .WaitWithStopCondition(InstallStep.TiltGotoVerticalCheck, () => { return _tiltAxis.Status == RState.End; }, () => { return _tiltAxis.Status == RState.Failed; })
            //1.2 Swing Goto OPEN
            .Run(InstallStep.SwingGotoOpen, () => { return _shuttleAxis.PositionStation("OPEN", false); }, NullFun, _delay_1ms)
            .WaitWithStopCondition(InstallStep.SwingGotoOpenWait, () => { return _shuttleAxis.Status == RState.End; }, () => { return _shuttleAxis.Status == RState.Failed; })
            //1.3 CRS Goto Unlock
            .Run(InstallStep.CRSGotoUnlock, () => { return _crsAxis.PositionStation("Unlock",false); }, NullFun, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSGotoUnlockWait, () => { return _crsAxis.Status == RState.End; }, () => { return _crsAxis.Status == RState.Failed; })
            //1.4 Swing Goto CLOSE
            .Run(InstallStep.SwingGotoClose, () => { return _shuttleAxis.PositionStation("CLOSED", false); }, NullFun, _delay_1ms)
            .WaitWithStopCondition(InstallStep.SwingGotoCloseWait, () => { return _shuttleAxis.Status == RState.End; }, () => { return _shuttleAxis.Status == RState.Failed; })
            //1.5 Door Lock On
            .Run(InstallStep.DoorLockOn, () => { return _doorLockRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.DoorLockOnCheck, () => { return CommonFunction.CheckRoutineEndState(_doorLockRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_doorLockRoutine); })
            //1.6 WSSideClampOn
            .Run(InstallStep.WSSideClampOn, () => { return _waferHolderSideClampRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.WSSideClampOnCheck, () => { return CommonFunction.CheckRoutineEndState(_waferHolderSideClampRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_waferHolderSideClampRoutine); })
            //1.7 WSClampOn
            .Run(InstallStep.WSClampOn, () => { return _loaderCommonDevice.WaferHolderClampOnAction(); }, _delay_1ms)
            //1.8 BernoulliN2 On
            .Run(InstallStep.BernoulliN2On, () => { return _bernoulliN2PressureRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.BernoulliN2OnCheck, () => { return CommonFunction.CheckRoutineEndState(_bernoulliN2PressureRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_bernoulliN2PressureRoutine); })
            //1.9 BernoulliBladderOn
            .Run(InstallStep.BernoulliBladderOn, () => { return _bernoulliBladderRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.BernoulliBladderOnCheck, () => { return CommonFunction.CheckRoutineEndState(_bernoulliBladderRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_bernoulliBladderRoutine); })
            //2.0 Trans Bladder On
            .Run(InstallStep.TransBladderOn, () => { return _transBladderRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.TransBladderOnCheck, () => { return CommonFunction.CheckRoutineEndState(_transBladderRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_transBladderRoutine); })
            //2.0 Trans High Off
            .Run(InstallStep.TranslateHighOff, () => { return _transHightRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.TranslateHighOffCheck, () => { return CommonFunction.CheckRoutineEndState(_transHightRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_transHightRoutine); })
            //2.1 CRS Vacuum On
            .Run(InstallStep.CRSVacuumOn, () => { return _vacuumRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSVacuumOnCheck, () => { return CommonFunction.CheckRoutineEndState(_vacuumRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_vacuumRoutine); })
            //2.2 WS Bladder On
            .Run(InstallStep.WSBladderOn, () => { return _whBladderRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.WSBladderOnCheck, () => { return CommonFunction.CheckRoutineEndState(_whBladderRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_whBladderRoutine); })
            //2.3 CRS Vacuum Check
            .Run(InstallStep.VacuumLevel, () => { return _vacuumLevelCheckRoutine.Start(true) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.VacuumLevelCheck, () => { return CommonFunction.CheckRoutineEndState(_vacuumLevelCheckRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_vacuumLevelCheckRoutine); })
            //2.4 CRS Goto Lock
            .Run(InstallStep.CRSGotoLock, () => { return _crsAxis.PositionStation("Lock", false,0, 0, 0, false); }, NullFun, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSGotoLockWait, () => { return _crsAxis.Status == RState.End; }, () => { return _crsAxis.Status == RState.Failed; })
            //2.5 CRS Vacuum Off
            .Run(InstallStep.CRSVacuumOff, () => { return _vacuumRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSVacuumOffCheck, () => { return CommonFunction.CheckRoutineEndState(_vacuumRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_vacuumRoutine); })
            //2.6 WS Bladder Off
            .Run(InstallStep.WSBladderOff, () => { return _whBladderRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.WSBladderOffCheck, () => { return CommonFunction.CheckRoutineEndState(_whBladderRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_whBladderRoutine); })
            //2.7 CRS Vacuum Check
            .Run(InstallStep.VacuumOffLevel, () => { return _vacuumLevelCheckRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.VacuumOffLevelCheck, () => { return CommonFunction.CheckRoutineEndState(_vacuumLevelCheckRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_vacuumLevelCheckRoutine); })
            //2.8 CRS Switch On
            .Run(InstallStep.CRSSwitchOn, () => { _crsAxis.SwitchOn(); return true; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSSwitchOnCheck, () => { return _crsAxis.Status == RState.End; }, () => { return _crsAxis.Status == RState.Failed; })
            //2.9 Trans Bladder Off
            .Run(InstallStep.TransBladderOff, () => { return _transBladderRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.TransBladderOff, () => { return CommonFunction.CheckRoutineEndState(_transBladderRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_transBladderRoutine); })
            //2.9 Trans High Off
            .Run(InstallStep.LastTranslateHighOff, () => { return _transHightRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.LastTranslateHighOffCheck, () => { return CommonFunction.CheckRoutineEndState(_transHightRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_transHightRoutine); })
            //3.0 BernoulliN2 Off
            .Run(InstallStep.BernoulliN2Off, () => { return _bernoulliN2PressureRoutine.Start(false) == RState.Running; }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.BernoulliN2OffCheck, () => { return CommonFunction.CheckRoutineEndState(_bernoulliN2PressureRoutine); }, () => { return CommonFunction.CheckRoutineStopState(_bernoulliN2PressureRoutine); })
            //3.1 Home CRS Axis
            .Run(InstallStep.HomingCRSAxis, () => { return _crsAxis.Home(); }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.HomingCRSAxisWait, () => { return _crsAxis.Status == RState.End; }, () => { return _crsAxis.Status == RState.Failed; })
            .Run(InstallStep.CRSHomedGotoSetUp, () => { return _crsAxis.PositionStation("Setup",false); }, _delay_1ms)
            .WaitWithStopCondition(InstallStep.CRSHomedGotoSetUpCheck, () => { return _crsAxis.Status == RState.End; }, () => { return _crsAxis.Status == RState.Failed; })
            .End(InstallStep.End, NullFun, 10);
            return Runner.Status;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public RState Start(params object[] objs)
        {
            _shuttleAxis = GetShuttleAxis();
            _crsAxis = GetCrsAxis();
            _tiltAxis = GetTiltAxis(); 
            _loaderCommonDevice = DEVICE.GetDevice<LoaderCommonDevice>($"{Module}.Common");
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _sideDevice = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.{_side}");
            _waferHolderSideClampRoutine = new LoaderCommonWaferHolderSideClampRoutine($"{Module}");
            _vacuumRoutine = new LoaderSideVacuumRoutine($"{Module}.{_side}");
            _vacuumLevelCheckRoutine = new LoaderSideVacuumLevelCheckRoutine($"{Module}.{_side}");
            _unloadVacuumLevelCheckRoutine = new LoaderSideUnloadVacuumLevelCheckRoutine($"{Module}.{_side}");
            _doorLockRoutine = new LoaderSideDoorLockRoutine($"{Module}.{_side}");
            _whBladderRoutine = new LoaderSideWhBladderRoutine($"{Module}.{_side}");
            _transHightRoutine = new LoaderSideTransHighRoutine($"{Module}.{_side}");
            _bernoulliBladderRoutine = new LoaderSideBernoulliBladderRoutine($"{Module}.{_side}");
            _transBladderRoutine = new LoaderSideTransBladderRoutine($"{Module}.{_side}");
            _bernoulliN2PressureRoutine = new LoaderSideBernoulliN2PressureRoutine($"{Module}.{_side}");
            if(!CheckPreCondition())
            {
                return RState.Failed;
            }
            Runner.Start(Module, "InstallCRS");
            return RState.Running;
        }
        /// <summary>
        /// 获取Shuttle轴对象
        /// </summary>
        /// <returns></returns>
        private JetAxisBase GetShuttleAxis()
        {
            switch (_side)
            {
                case "SideA":
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.ShuttleA");
                default:
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.ShuttleB");
            }
        }
        /// <summary>
        /// 获取CRS轴对象
        /// </summary>
        /// <returns></returns>
        private JetAxisBase GetCrsAxis()
        {
            switch (_side)
            {
                case "SideA":
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.LSA");
                default:
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.LSB");
            }
        }
        /// <summary>
        /// 获取Tilt轴对象
        /// </summary>
        /// <returns></returns>
        private JetAxisBase GetTiltAxis()
        {
            switch (_side)
            {
                case "SideA":
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.TiltA");
                default:
                    return DEVICE.GetDevice<JetAxisBase>($"{Module}.TiltB");
            }
        }

        /// <summary>
        /// 检验前置条件
        /// </summary>
        /// <returns></returns>
        private bool CheckPreCondition()
        {
            if (!CheckHomeCondition())
            {
                return false;
            }
            if (!CheckInstallCRSAxisCondition())
            {
                return false;
            }

            if (!InstallCRSStatusCheck())
            {
                return false;
            }

            if (!InstallCRSVacuumCheck())
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 检验Home条件
        /// </summary>
        /// <returns></returns>
        private bool CheckHomeCondition()
        {
            //检验PUF、Loader Transporter,Robot均Homed
            if (ModuleHelper.IsInstalled(ModuleName.PUF1))
            {
                PUFEntity puf1Entity = Singleton<RouteManager>.Instance.GetModule<PUFEntity>(ModuleName.PUF1.ToString());
                if (!puf1Entity.IsHomed)
                {
                    LOG.WriteLog(eEvent.ERR_LOADER, Module.ToString(), "PUF1 is not homed");
                    return false;
                }
            }
            if (ModuleHelper.IsInstalled(ModuleName.PUF2))
            {
                PUFEntity puf2Entity = Singleton<RouteManager>.Instance.GetModule<PUFEntity>(ModuleName.PUF2.ToString());

                if (!puf2Entity.IsHomed)
                {
                    LOG.WriteLog(eEvent.ERR_LOADER, Module.ToString(), "PUF2 is not homed");
                    return false;
                }
            }
            return true;
        }



        /// <summary>
        /// 检验Install Axis条件
        /// </summary>
        /// <param name="side"></param>
        /// <returns></returns>
        private bool CheckInstallCRSAxisCondition()
        {
            double rotationPosition = _rotationAxis.MotionData.MotorPosition;
            if (!_rotationAxis.CheckPositionIsInStation(rotationPosition, "LOADA") &&
                !_rotationAxis.CheckPositionIsInStation(rotationPosition, "SERVICEB"))
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, $"rotation {rotationPosition} not in LOADA and SERVICEB");
                return false;
            }
            double shuttlePosition=_shuttleAxis.MotionData.MotorPosition;
            if (!_shuttleAxis.CheckPositionIsInStation(shuttlePosition, "OPEN") && 
                !_shuttleAxis.CheckPositionIsInStation(shuttlePosition, "OPENB"))
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, $"shuttle {shuttlePosition} not in OPEN or OPENB");
                return false;
            }
            double tiltPosition=_tiltAxis.MotionData.MotorPosition;
            if (!_tiltAxis.CheckPositionIsInStation(tiltPosition, "HORI"))
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, $"tilt {tiltPosition} not in HORI");
                return false;
            }
            double crsPosition= _crsAxis.MotionData.MotorPosition;
            if (_crsAxis.CheckPositionIsEmpty(crsPosition))
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, $"crs {crsPosition} not at station");
                return false;
            }
            return true;
        }

        /// <summary>
        /// Install CRS Status Check
        /// </summary>
        /// <param name="side"></param>
        /// <returns></returns>
        private bool InstallCRSStatusCheck()
        {
            //Facility:CDA,N2,Vaccum均Enable且在正常范围

            //Side WaferPresent
            LoaderSideData sideData = _sideDevice.SideData;
            if (sideData.WaferPresent)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "side wafer is present");
                return false;
            }
            if (sideData.DoorLowerLocked || sideData.DoorUpperLocked)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "Door Lock is on");
                return false;
            }
            return true;
        }
        /// <summary>
        /// CRS Vacuum Check
        /// </summary>
        /// <param name="side"></param>
        /// <returns></returns>
        private bool InstallCRSVacuumCheck()
        {
            //CRS Vacuum检验
            LoaderSideData sideData = _sideDevice.SideData;
            if (sideData.CRSVacuum)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "LS Vacuum is on");
                return false;
            }
            //WS Bladder
            if (sideData.WHBladder)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "WS Bladder is on");
                return false;
            }
            //Translate Bladder/High Pres,且Sensor处于Retracted
            if (sideData.TransBladder)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "TransBladder is on");
                return false;
            }
            if (sideData.TransHigh)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "Trans High is on");
                return false;
            }
            //Bernoulli N2
            if (sideData.BernoulliN2)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "Bernoulli N2 is on");
                return false;
            }
            //Wafer Shuttle Present
            LoaderCommonData commonData = _loaderCommonDevice.CommonData;
            if (!commonData.WaferHolderPresent)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "Wafer Shuttle is absent");
                return false;
            }
            //Drip Tray Fluid
            if (commonData.DripTrayFluid)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module, "Drip Tray Fluid is on");
                return false;
            }
            return true;
        }
    }
}