CyberX8/CyberX8_RT/Modules/PUF/PufSwapRoutine.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.WaferHolder;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.Loader;
using CyberX8_RT.Devices.PUF;
using CyberX8_RT.Modules.Loader;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace CyberX8_RT.Modules.PUF
{
    public class PufSwapRoutine : RoutineBase, IRoutine
    {
        private enum SwapStep
        {
            CheckPreStatus,
            RotationLoaderPickup,
            RotationLoaderPickupWait,
            ChuckOut,
            CheckChuckOut,
            SideAVacuumOn,
            ChuckIn,
            CheckChuckIn,
            StickDistanceCheck,
            RotationFlip,
            WaitRotationFlip,
            FlipSideB,
            WaitFlipSideB,
            PlaceToLoader,
            PlaceToLoaderWait,
            End
        }

        #region 常量 
        private const string CURRENT_STATION_LIST = "CurrentStationList";
        private const string WAFER_PRESENT = "WaferPresent";
        private const string SIDE_A = "SideA";
        #endregion

        #region 内部变量
        private LoaderEntity _loaderEntity;
        private JetAxisBase _flipAxis;
        private JetAxisBase _rotationAxis;
        private LoaderSideDevice _loaderSide;
        private PufVacuum _vacuum;
        private PufDistanceSensor _distanceSensor;
        private PufPlaceToLoaderRoutine _placeToLoaderRoutine;
        private PufChuckRoutine _chuckRoutine;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public PufSwapRoutine(string module) : base(module)
        {
            _placeToLoaderRoutine = new PufPlaceToLoaderRoutine(Module);
            _chuckRoutine = new PufChuckRoutine(Module);
        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(SwapStep.CheckPreStatus, CheckCondition, _delay_1ms)
                .Run(SwapStep.RotationLoaderPickup, () => { return AxisGotoPosition(_rotationAxis, "LoaderPickup", 0); }, _delay_1ms)
                .WaitWithStopCondition(SwapStep.RotationLoaderPickupWait, () => { return _rotationAxis.Status == RState.End; },
                    () => { return CheckRotationStopStatus(0); })
                .Run(SwapStep.ChuckOut, () => { return _chuckRoutine.Start(true) == RState.Running; }, NullFun, 100)
                .WaitWithStopCondition(SwapStep.CheckChuckOut, () => CommonFunction.CheckRoutineEndState(_chuckRoutine),
                    () => { return CheckChuckRoutineStopStatus(true, 0); })
                .Run(SwapStep.SideAVacuumOn, SideAVacuumOn, CheckSideAWaferPresent, 5000)
                .Wait(SwapStep.StickDistanceCheck, CheckStickDistanceStatus, 1000)
                .Run(SwapStep.ChuckIn, () => { return _chuckRoutine.Start(false) == RState.Running; }, NullFun, 100)
                .WaitWithStopCondition(SwapStep.CheckChuckOut, () => CommonFunction.CheckRoutineEndState(_chuckRoutine),
                    () => { return CheckChuckRoutineStopStatus(false, 1); })
                .Run(SwapStep.RotationFlip, () => { return AxisGotoPosition(_rotationAxis,"Flip",1); }, _delay_1ms)
                .WaitWithStopCondition(SwapStep.WaitRotationFlip, () => { return _rotationAxis.Status == RState.End; }, 
                    () => { return CheckRotationStopStatus(1); })
                .Run(SwapStep.FlipSideB, () => { return AxisGotoPosition(_flipAxis,"SideB", 1); }, _delay_1ms)
                .WaitWithStopCondition(SwapStep.WaitFlipSideB, () => { return _flipAxis.Status == RState.End; }, 
                    () => { return CheckFlipStopStatus(1); })
                .Run(SwapStep.PlaceToLoader, () => _placeToLoaderRoutine.Start("SideB") == RState.Running, _delay_1ms)
                .WaitWithStopCondition(SwapStep.PlaceToLoaderWait, ()=>CommonFunction.CheckRoutineEndState(_placeToLoaderRoutine),
                    CheckPlaceToRoutineStopStatus)
                .End(SwapStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// Side a打开真空
        /// </summary>
        /// <returns></returns>
        private bool SideAVacuumOn()
        {
            bool result= _vacuum.VacuumAOn();
            if (!result)
            {
                NotifyError(eEvent.ERR_PUF, "side A Vacuum on failed", 0);
            }
            return result;
        }
        /// <summary>
        /// 检验SideA是否存在Wafer
        /// </summary>
        /// <returns></returns>
        private bool CheckSideAWaferPresent()
        {
            bool result= _vacuum.ChuckAVacuumStatus == WAFER_PRESENT;
            if(result)
            {
                LoaderEntity loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
                if(loaderEntity!=null)
                {
                    WaferHolderInfo waferHolder = loaderEntity.WaferHolderInfo;
                    if(_loaderSide.Name==SIDE_A)
                    {
                        if (WaferManager.Instance.CheckHasWafer(ModuleName.Loader1, 0))
                        {
                            WaferManager.Instance.WaferMoved(ModuleName.Loader1, 0, ModuleHelper.Converter(Module), 0);
                        }
                        else
                        {
                            NotifyError(eEvent.ERR_PUF, "Loader sideA has no wafer",0);
                            return false;
                        }
                    }
                    else
                    {
                        if (WaferManager.Instance.CheckHasWafer(ModuleName.Loader1, 1))
                        {
                            WaferManager.Instance.WaferMoved(ModuleName.Loader1, 1, ModuleHelper.Converter(Module), 0);
                        }
                        else
                        {
                            NotifyError(eEvent.ERR_PUF, "Loader sideA has no wafer", 0);
                            return false;
                        }
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// Stick Distance检验结果
        /// </summary>
        /// <returns></returns>
        private bool CheckStickDistanceStatus()
        {
            bool result= _distanceSensor.CheckStickDistanceStatus();
            if (!result)
            {
                NotifyError(eEvent.ERR_PUF, "check stick distance failed", 0);
            }
            return result;
        }
        /// <summary>
        /// Axis goto position
        /// </summary>
        /// <param name="axis"></param>
        /// <param name="position"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private bool AxisGotoPosition(JetAxisBase axis,string position,int index)
        {
            bool result = axis.PositionStation(position);
            if(!result)
            {
                NotifyError(eEvent.ERR_PUF, $"{axis.Module} goto {position} failed",index);
            }
            return result;
        }
        /// <summary>
        /// 检验Flip异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckFlipStopStatus(int index)
        {
            bool result = _flipAxis.Status == RState.Failed || _flipAxis.Status == RState.Timeout;
            if (result)
            {
                NotifyError(eEvent.ERR_PUF, "flip motion failed", index);
            }
            return result;
        }
        /// <summary>
        /// 检验Rotation异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationStopStatus(int index)
        {
            bool result = _rotationAxis.Status == RState.Failed || _rotationAxis.Status == RState.Timeout;
            if (result)
            {
                NotifyError(eEvent.ERR_PUF, "rotation motion failed", index);
            }
            return result;
        }
        /// <summary>
        /// 检验PlaceToLoader异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckChuckRoutineStopStatus(bool chuck,int index)
        {
            bool result = CommonFunction.CheckRoutineStopState(_chuckRoutine);
            string chuckContent = chuck ? "Chuck Out" : "Chuck In";
            if (result)
            {
                NotifyError(eEvent.ERR_PUF,$"{chuckContent} failed", index);
            }
            return result;
        }
        /// <summary>
        /// 检验PlaceToLoader异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckPlaceToRoutineStopStatus()
        {
            bool result = CommonFunction.CheckRoutineStopState(_placeToLoaderRoutine);
            if (result)
            {
                NotifyError(eEvent.ERR_PUF, "place wafer failed", 2);
            }
            return result;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            InitializeParameters();
            return Runner.Start(Module, "Start Swap");
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameters()
        {
            _loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
            _flipAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Flip");
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _vacuum = DEVICE.GetDevice<PufVacuum>($"{Module}.Vacuum");
            _distanceSensor = DEVICE.GetDevice<PufDistanceSensor>($"{Module}.DistanceSensor");
            GetLoaderSide();
        }
        /// <summary>
        /// 检验条件
        /// </summary>
        /// <returns></returns>
        private bool CheckCondition()
        {
            //Loader1.Rotation 在LOADA
            bool isLoaderInstall = ModuleHelper.IsInstalled(ModuleName.Loader1);
            if (isLoaderInstall)
            {
                JetAxisBase loaderRotationAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.Rotation");
                double loaderRotationPosition = loaderRotationAxis.MotionData.MotorPosition;
                if (!loaderRotationAxis.CheckPositionIsInStation(loaderRotationPosition, "LOADA"))
                {
                    NotifyError(eEvent.ERR_PUF, $"Loader Rotation {loaderRotationPosition} is not in LOADA",-1);
                    return false;
                }
                if (Module == ModuleName.PUF1.ToString())
                {
                    //Loader1.SwingA 在Open
                    JetAxisBase loaderShuttleAAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.ShuttleA");
                    double loaderShuttleAPosition = loaderShuttleAAxis.MotionData.MotorPosition;
                    if (!loaderShuttleAAxis.CheckPositionIsInStation(loaderShuttleAPosition, "OPEN"))
                    {
                        NotifyError(eEvent.ERR_PUF, $"Loader ShuttleA {loaderShuttleAPosition} is not in OPEN",-1);
                        return false;
                    }
                    //Loader1.TiltA 在HORI
                    JetAxisBase loaderTiltAAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.TiltA");
                    double loaderTiltAPosition = loaderTiltAAxis.MotionData.MotorPosition;
                    if (!loaderTiltAAxis.CheckPositionIsInStation(loaderTiltAPosition, "HORI"))
                    {
                        NotifyError(eEvent.ERR_PUF, $"Loader TiltA {loaderTiltAPosition} is not in HORI",-1);
                        return false;
                    }
                }

                //Loader Handle Wafer状态确认
                // Lip Seal Vacuum "ON"
                if (!_loaderSide.SideData.CRSVacuum)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 LS Vacuum is off",-1);
                    return false;
                }
                //Bernoulli Bladder "ON",Retracted Green Light
                if (!_loaderSide.SideData.BernoulliBladder)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Bernoulli Bladder is off",-1);
                    return false;
                }
                if (_loaderSide.SideData.BernoulliExtended)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Bernoulli Retracted is off",-1);
                    return false;
                }
                //其他SideA/B均为OFF
                if (_loaderSide.SideData.BernoulliN2)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Bernoulli N2 is on",-1);
                    return false;
                }
                if (!_loaderSide.SideData.DoorUnlock)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Door is Locked",-1);
                    return false;
                }
                //if (_loaderSide.SideData.WHBladder)
                //{
                //    NotifyError(eEvent.ERR_PUF,, "Loader1 WS Bladder is on");
                //    return false;
                //}
                if (_loaderSide.SideData.TransBladder)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Translate Bladder is on",-1);
                    return false;
                }
                if (_loaderSide.SideData.TransHigh)
                {
                    NotifyError(eEvent.ERR_PUF, "Loader1 Translate High Pre is on",-1);
                    return false;
                }
            }
            double rotaionPosition = _rotationAxis.MotionData.MotorPosition;
            if (_rotationAxis.CheckPositionIsEmpty(rotaionPosition))
            {
                NotifyError(eEvent.ERR_PUF, $"rotation axis {rotaionPosition} is not at Station",-1);
                return false;
            }

            double flipPosition = _flipAxis.MotionData.MotorPosition;
            if (_flipAxis.CheckPositionIsEmpty(flipPosition))
            {
                NotifyError(eEvent.ERR_PUF, $"flip axis {flipPosition} is not at Station",-1);
                return false;
            }
            //A面
            if (_loaderSide.Name == SIDE_A)
            {
                if (WaferManager.Instance.CheckNoWafer(ModuleName.Loader1, 0))
                {
                    NotifyError(eEvent.ERR_PUF, "loader side A has no wafer",-1);
                    return false;
                }
            }
            else
            {
                if (WaferManager.Instance.CheckNoWafer(ModuleName.Loader1, 1))
                {
                    NotifyError(eEvent.ERR_PUF, "loader side B has no wafer",-1);
                    return false;
                }
            }

            return true;
        }
        /// <summary>
        /// 获取LoaderSide
        /// </summary>
        private void GetLoaderSide()
        {
            if (Module == ModuleName.PUF1.ToString())
            {
                _loaderSide = DEVICE.GetDevice<LoaderSideDevice>($"{ModuleName.Loader1}.SideA");
            }
            else
            {
                _loaderSide = DEVICE.GetDevice<LoaderSideDevice>($"{ModuleName.Loader1}.SideB");
            }
        }

        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            InitializeParameters();
            List<Enum> preStepIds = new List<Enum>();
            if (step == 0||step==-1)
            {
                return Runner.Retry(SwapStep.CheckPreStatus, preStepIds, Module, "Swap Retry");
            }
            else if (step == 1)
            {
                AddPreSteps(SwapStep.CheckChuckIn, preStepIds);
                return Runner.Retry(SwapStep.ChuckIn, preStepIds, Module, $"Swap step {SwapStep.ChuckIn} Retry");
            }
            else
            {
                AddPreSteps(SwapStep.PlaceToLoader, preStepIds);
                return Runner.Retry(SwapStep.PlaceToLoader, preStepIds, Module, $"Swap step {SwapStep.PlaceToLoader} Retry");
            }
        }
        /// <summary>
        /// 忽略前
        /// </summary>
        /// <param name="step"></param>
        /// <param name="preStepIds"></param>
        private void AddPreSteps(SwapStep step, List<Enum> preStepIds)
        {
            for (int i = 0; i < (int)step; i++)
            {
                preStepIds.Add((SwapStep)i);
            }
        }

        /// <summary>
        /// 检验完成情况 
        /// </summary>
        /// <returns></returns>
        public bool CheckCompleteCondition()
        {
            if (WaferManager.Instance.CheckHasWafer(Module, 1))
            {
                NotifyError(eEvent.ERR_PUF, "Side B has wafer", 0);
                return false;
            }
            if (Module == ModuleName.PUF1.ToString())
            {
                if (WaferManager.Instance.CheckNoWafer(ModuleName.Loader1, 0))
                {
                    NotifyError(eEvent.ERR_PUF, "Loader Side A has wafer", 0);
                    return false;
                }
            }
            else
            {
                if (WaferManager.Instance.CheckNoWafer(ModuleName.Loader1, 1))
                {
                    NotifyError(eEvent.ERR_PUF, "Loader Side B has wafer", 0);
                    return false;
                }
            }
            return true;
        }
    }
}