CyberX8/CyberX8_RT/Modules/PUF/PufOnlyPlaceToLoaderRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
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.Loader;
using CyberX8_RT.Devices.PUF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.Common;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using CyberX8_RT.Modules.Loader;

namespace CyberX8_RT.Modules.PUF
{
    public class PufOnlyPlaceToLoaderRoutine : RoutineBase, IRoutine
    {
        private enum PlaceStep
        {
            LipSealGotoUnlock,
            LipSealGotoUnlockWait,
            VacuumLevelCheck,
            SideConditionRoutine,
            SideConditionRoutineWait,
            RotationGotoLoaderPlaceDown,
            RotationGotoLoaderPlaceDownWait,
            FirstPlaceVacuumCheck,
            FirstPlaceVacuumCheckWait,
            SecondPlaceVacuumCheck,
            SecondPlaceVacuumCheckWait,
            VacuumOff,
            End
        }
        #region 常量 
        private const string SideA = "SideA";
        private const string SideB = "SideB";
        private const string WAFER_ABSENT = "WaferAbsent";
        #endregion

        #region 内部变量
        private bool _isSecondPlaceVacuumCheck = false;
        private string _pufSide;
        private string _loaderSide;
        private JetAxisBase _flipAxis;
        private JetAxisBase _rotationAxis;
        private PufVacuum _vacuum;
        private JetAxisBase _loaderCrsAxis;
        private PufWaferPickSubRoutine _pufWaferPickSubRoutine;
        private PufPlaceVacuumCheckRoutine _pufPlaceVacuumCheckRoutine;
        private int _waferSize = 200;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public PufOnlyPlaceToLoaderRoutine(string module) : base(module)
        {
            _pufWaferPickSubRoutine = new PufWaferPickSubRoutine(module);
        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            if (_pufWaferPickSubRoutine != null)
            {
                _pufWaferPickSubRoutine.Abort();
            }
            _flipAxis.StopPositionOperation();
            _rotationAxis.StopPositionOperation();
            Runner.Stop("Manual Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(PlaceStep.LipSealGotoUnlock, LipSealGotoUnlock, _delay_1ms)
               .WaitWithStopCondition(PlaceStep.LipSealGotoUnlockWait, CheckLipSealEndStatus, CheckLipSealStopStatus)
               .Run(PlaceStep.VacuumLevelCheck, CheckWaferPresent, _delay_1ms)
               .RunConditionSubRoutine(PlaceStep.SideConditionRoutine, SideConditionIndex, new IRoutine[] { _pufWaferPickSubRoutine }, new object[] { _pufSide })
               .WaitConditionSubRoutine(PlaceStep.SideConditionRoutineWait)
               .Run(PlaceStep.RotationGotoLoaderPlaceDown, () => _rotationAxis.PositionStation("LoaderPutDown"), _delay_1ms)
               .WaitWithStopCondition(PlaceStep.RotationGotoLoaderPlaceDownWait, CheckRotationPositionStatus, CheckRotationPositionRunStop)
               .Run(PlaceStep.FirstPlaceVacuumCheck, () => StartPlaceVacuumCheckRoutine(false, 1), _delay_1ms)
               .WaitWithStopCondition(PlaceStep.FirstPlaceVacuumCheckWait, CheckFirstPlaceVacuumCheckRoutineStatus, () => { return false; })
               .Run(PlaceStep.SecondPlaceVacuumCheck, StartSecondPlaceVacuumCheckRoutine, _delay_1ms)
               .WaitWithStopCondition(PlaceStep.SecondPlaceVacuumCheckWait, CheckPlaceVacuumCheckRoutineEndStatus, CheckSecondPlaceVacuumCheckRoutineStopStatus)
               .Run(PlaceStep.VacuumOff, VacuumOff, _delay_1ms)
               .End(PlaceStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// LipSeal Goto Unlock
        /// </summary>
        /// <returns></returns>
        private bool LipSealGotoUnlock()
        {
            if (ModuleHelper.IsInstalled(ModuleName.Loader1))
            {
                return _loaderCrsAxis.PositionStation($"Unlock{_waferSize}");
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 检验Lip Seal完成状态
        /// </summary>
        /// <returns></returns>
        private bool CheckLipSealEndStatus()
        {
            if (ModuleHelper.IsInstalled(ModuleName.Loader1))
            {
                return _loaderCrsAxis.Status == RState.End;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 检验Lip Seal完成状态
        /// </summary>
        /// <returns></returns>
        private bool CheckLipSealStopStatus()
        {
            if (ModuleHelper.IsInstalled(ModuleName.Loader1))
            {
                bool result= _loaderCrsAxis.Status == RState.Failed;
                if (result)
                {
                    NotifyError(eEvent.ERR_PUF, $"lipsel axis goto unlock failed", 0);
                }
                return result;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 检验是否存在Wafer
        /// </summary>
        /// <returns></returns>
        private bool CheckWaferPresent()
        {
            if (_pufSide == SideA)
            {
                if (!_vacuum.ChuckAWaferPresent)
                {
                    LOG.WriteLog(eEvent.ERR_PUF, Module, $"{_pufSide} has no Wafer");
                    return false;
                }
            }
            else
            {
                if (!_vacuum.ChuckBWaferPresent)
                {
                    LOG.WriteLog(eEvent.ERR_PUF, Module, $"{_pufSide} has no Wafer");
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// Side条件获取SubRoutine索引
        /// </summary>
        /// <returns></returns>
        private int SideConditionIndex()
        {
            if (_flipAxis.CheckPositionIsInStation(_flipAxis.MotionData.MotorPosition, _pufSide))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Rotation是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionRunStop()
        {
            return _rotationAxis.Status == RState.Failed;
        }
        /// <summary>
        /// 启动Place Vacuum Check routine
        /// </summary>
        /// <returns></returns>
        private bool StartPlaceVacuumCheckRoutine(bool showError, int times)
        {
            return _pufPlaceVacuumCheckRoutine.Start(_pufSide, showError, times) == RState.Running;
        }
        /// <summary>
        ///  检验第一次Place Vacuum Check routine运行情况
        /// </summary>
        /// <returns></returns>
        private bool CheckFirstPlaceVacuumCheckRoutineStatus()
        {
            RState rsState = _pufPlaceVacuumCheckRoutine.Monitor();
            if (rsState == RState.End)
            {
                return true;
            }
            if (rsState == RState.Failed || rsState == RState.Timeout)
            {
                _isSecondPlaceVacuumCheck = true;
                return true;
            }
            return false;
        }
        /// <summary>
        /// 启动Place Vacuum Check routine完成状态
        /// </summary>
        /// <returns></returns>
        private bool CheckPlaceVacuumCheckRoutineEndStatus()
        {
            RState rsState = _pufPlaceVacuumCheckRoutine.Monitor();
            return rsState == RState.End;
        }
        /// <summary>
        /// 启动第二次Place Vacuum Check routine
        /// </summary>
        /// <returns></returns>
        private bool StartSecondPlaceVacuumCheckRoutine()
        {
            if (_isSecondPlaceVacuumCheck)
            {
                return StartPlaceVacuumCheckRoutine(true, 2);
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 检验第二次Place Vacuum Check routine错误状态
        /// </summary>
        /// <returns></returns>
        private bool CheckSecondPlaceVacuumCheckRoutineStopStatus()
        {
            RState rState = _pufPlaceVacuumCheckRoutine.Monitor();
            if (rState == RState.Failed || rState == RState.Timeout)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 关闭Vacuum
        /// </summary>
        /// <returns></returns>
        private bool VacuumOff()
        {
            if (_pufSide == "SideA")
            {
                return _vacuum.VacuumAOff();
            }
            else if (_pufSide == "SideB")
            {
                return _vacuum.VacuumBOff();
            }
            return false;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _pufSide = objs[0].ToString();
            _loaderSide = objs[1].ToString();
            _flipAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Flip");
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _vacuum = DEVICE.GetDevice<PufVacuum>($"{Module}.Vacuum");
            GetCrsAxis();
            _isSecondPlaceVacuumCheck = false;
            _pufPlaceVacuumCheckRoutine = new PufPlaceVacuumCheckRoutine(Module);

            LoaderEntity loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
            if (_loaderSide == SideA)
            {
                _waferSize = loaderEntity.SideAWaferSize;
            }
            else
            {
                _waferSize = loaderEntity.SideBWaferSize;
            }
            return Runner.Start(Module, "Start Place To Loader");
        }
        /// <summary>
        /// 获取lipseal Axis
        /// </summary>
        private void GetCrsAxis()
        {
            if (_loaderSide==SideA)
            {
                _loaderCrsAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.LSA");
            }
            else
            {
                _loaderCrsAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Loader1}.LSB");
            }
        }
    }
}