CyberX8/CyberX8_RT/Modules/Loader/LoaderUnloadSideRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Routine;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.Loader;
using System;
using System.Collections.Generic;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.CommonData.Loader;
using MECF.Framework.Common.CommonData;
using Aitex.Core.RT.DataCenter;

namespace CyberX8_RT.Modules.Loader
{
    public class LoaderUnloadSideRoutine : RoutineBase, IRoutine
    {
        private enum UnloadStep
        {
            RotationGoToLOADA,
            RotationGoToLOADAWait,
            SideUnload,
            UnloadAllWait,
            End
        }

        #region 常量
        private const string SIDE_A = "SideA";
        private const string SIDE_B = "SideB";
        private const int LOTTRACK_TIME = 1000;
        #endregion

        #region 内部变量
        private JetAxisBase _rotationAxis;
        private string _side;
        private LoaderUnloadRoutine _sideUnloadRoutine;
        private bool _isSideUnloaded = false;
        private bool _isSideStop = false;
        /// <summary>
        /// lotTrack time
        /// </summary>
        private DateTime _lotTackTime = DateTime.Now;
        /// <summary>
        /// Loader Common
        /// </summary>
        private LoaderCommonDevice _loaderCommon;
        /// <summary>
        /// LoaderSide
        /// </summary>
        private LoaderSideDevice _loaderSide;
        /// <summary>
        /// Loader LotTrackData
        /// </summary>
        private List<LoaderLotTrackData> _datas = new List<LoaderLotTrackData>();
        #endregion

        #region 属性
        /// <summary>
        /// UnLoad LotTrackData
        /// </summary>
        public List<LoaderLotTrackData> UnloadLotTrackDatas { get { return _datas; } }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public LoaderUnloadSideRoutine(string module) : base(module)
        {
        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            LottrackRecord();
            Runner.Run(UnloadStep.RotationGoToLOADA,RotationGotoLOADA,_delay_1ms)
                .WaitWithStopCondition(UnloadStep.RotationGoToLOADAWait,CheckRotationPositionStatus,CheckRotationPositionRunStop)
                .Run(UnloadStep.SideUnload, () => StartUnloadRoutine(_sideUnloadRoutine,_isSideUnloaded), _delay_1ms)
                .WaitWithStopCondition(UnloadStep.UnloadAllWait, CheckUnloadAllRoutineEndStatus,CheckUnloadAllRoutineStopStatus)
                .End(UnloadStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// Rotation Goto LOADA
        /// </summary>
        /// <returns></returns>
        private bool RotationGotoLOADA()
        {
            bool result = _rotationAxis.PositionStation("LOADA", false);
            if (!result)
            {
                NotifyError(eEvent.ERR_LOADER, "rotation start goto LOADA failed", 0);
            }
            return result;
        }
        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Rotation是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionRunStop()
        {
            bool result = _rotationAxis.Status == RState.Failed || _rotationAxis.Status == RState.Timeout ;
            if (result)
            {
                NotifyError(eEvent.ERR_LOADER, "rotation goto position failed",0);
            }
            return result;
        }
        /// <summary>
        /// 启动Unload routine
        /// </summary>
        /// <param name="unloadRoutine"></param>
        /// <returns></returns>
        private bool StartUnloadRoutine(LoaderUnloadRoutine unloadRoutine,bool isSideUnloaded)
        {
            if (isSideUnloaded)
            {
                return true;
            }
            bool result= unloadRoutine.Start()==RState.Running;
            if(!result)
            {
                NotifyError(eEvent.ERR_LOADER, unloadRoutine.ErrorMsg, 0);
            }
            return result;
        }
        /// <summary>
        /// 检验UnloadAll完成状态
        /// </summary>
        /// <returns></returns>
        private bool CheckUnloadAllRoutineEndStatus()
        {
            bool sideResult = true;
            if (!_isSideUnloaded)
            {
                sideResult = CheckUnloadRoutineEndStatus(_sideUnloadRoutine);
            }
            return sideResult;
        }
        /// <summary>
        /// 检查UnloadAll停止状态
        /// </summary>
        /// <returns></returns>
        private bool CheckUnloadAllRoutineStopStatus()
        {
            bool sideComplete = false;
            if (!_isSideUnloaded&&!_isSideStop)
            {
                RState ret = _sideUnloadRoutine.Monitor();
                _isSideStop = ret == RState.Failed || ret == RState.Timeout;
                sideComplete = (ret != RState.Running);
                if (_isSideStop)
                {
                    NotifyError(eEvent.ERR_LOADER, $"unload A failed\r\n{_sideUnloadRoutine.ErrorMsg}", 1);
                }
            }
            return _isSideStop;
        }
        /// <summary>
        /// 检验routine完成状态
        /// </summary>
        /// <param name="unloadRoutine"></param>
        /// <returns></returns>
        private bool CheckUnloadRoutineEndStatus(LoaderUnloadRoutine unloadRoutine)
        {
            return unloadRoutine.Monitor() == RState.End;
        }
        /// <summary>
        /// 检验Routine结束状态
        /// </summary>
        /// <param name="unloadRoutine"></param>
        /// <returns></returns>
        private bool CheckUnloadRoutineStopStatus(LoaderUnloadRoutine unloadRoutine,string side) 
        {
            RState state=unloadRoutine.Monitor();
            if (state == RState.Failed || state == RState.Timeout)
            {
                NotifyError(eEvent.ERR_LOADER, $"{side} Unload failed", 0);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _side = objs[0].ToString();
            InitializeParameters();
            _loaderCommon = DEVICE.GetDevice<LoaderCommonDevice>($"{Module}.Common");
            _loaderSide = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.{_side}");
            return Runner.Start(Module, "Start UnloadAll");
        }
        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameters()
        {
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _sideUnloadRoutine = new LoaderUnloadRoutine(ModuleName.Loader1.ToString(), _side);
            _isSideUnloaded = false;
            _isSideStop = false;
        }
        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            InitializeParameters();
            List<Enum> preStepIds = new List<Enum>();
            return Runner.Retry(UnloadStep.RotationGoToLOADA,preStepIds,Module,"UnloadAll Retry");
        }

        /// <summary>
        /// 检验前面Unload完成状态
        /// </summary>
        /// <returns></returns>
        public bool CheckCompleteCondition(int index)
        {
            string side = _side == SIDE_A ? "A" : "B";
            if (!CheckSideUnloadCondition(side, index,true))
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 检验Side Unload情况 
        /// </summary>
        /// <param name="side"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private bool CheckSideUnloadCondition(string side, int index,bool showError)
        {
            JetAxisBase shuttleAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.Shuttle{side}");
            double shuttlePosition = shuttleAxis.MotionData.MotorPosition;
            if (!shuttleAxis.CheckPositionInStationIgnoreWaferSize(shuttlePosition, "OUT"))
            {
                if (showError)
                {
                    NotifyError(eEvent.ERR_LOADER, $"shuttle{side} {shuttlePosition} is not in Out", index);
                }
                return false;
            }
            JetAxisBase tiltAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.Tilt{side}");
            double tiltPosition = tiltAxis.MotionData.MotorPosition;
            if (!tiltAxis.CheckPositionInStationIgnoreWaferSize(tiltPosition, "HORI"))
            {
                if (showError)
                {
                    NotifyError(eEvent.ERR_LOADER, $"tilt{side} {tiltPosition} is not in HORI", index);
                    return false;
                }
            }
            JetAxisBase crsAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.LS{side}");
            double crsPosition = crsAxis.MotionData.MotorPosition;
            if (!crsAxis.CheckPositionInStationIgnoreWaferSize(crsPosition, "Unlock"))
            {
                if (showError)
                {
                    NotifyError(eEvent.ERR_LOADER, $"LS{side} {crsPosition} is not in Unlock", index);
                }
                return false;
            }
            return true;
        }
        /// <summary>
        /// 记录Lottrack
        /// </summary>
        private void LottrackRecord()
        {
            //记录Lottrack
            if (DateTime.Now.Subtract(_lotTackTime).TotalMilliseconds >= LOTTRACK_TIME)
            {
                AddLotTrackData();
                _lotTackTime = DateTime.Now;
            }
        }
        /// <summary>
        /// 获取Lot Track数据
        /// </summary>
        /// <returns></returns>
        private void AddLotTrackData()
        {
            LoaderLotTrackData data = new LoaderLotTrackData();
            data.TimeStamp = DateTime.Now;

            data.LoaderABernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
            data.LoaderABernoulliExtended = _loaderSide.SideData.BernoulliExtended;
            data.LoaderABernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
            data.LoaderABernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
            data.LoaderACRSVacuum = _loaderSide.SideData.CRSVacuum;
            data.LoaderACRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
            data.LoaderAWHPressure = _loaderSide.SideData.WHBladderPressure;
            data.LoaderATranslatePressure = _loaderSide.SideData.TransPressure;
            data.LoaderWHClamped = _loaderCommon.CommonData.WaferHolderClamp;

            _datas.Add(data);
        }
        
    }
}