CyberX8/CyberX8_RT/Modules/SRD/SRDProcessRecipeRoutine.cs

using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.SRD;
using System;
using System.Collections.Generic;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.CommonData.SRD;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Device;
using CyberX8_RT.Devices.Facilities;
using Aitex.Core.Util;
using CyberX8_RT.Modules.Transporter;
using MECF.Framework.Common.WaferHolder;

namespace CyberX8_RT.Modules.SRD
{
    public class SRDProcessRecipeRoutine : RoutineBase, IRoutine
    {
        #region 常量
        private const int LOTTRACK_TIME = 1000;
        #endregion

        private enum SRDProcessState
        {
            Ready,
            RunWafer,
            Unloading,
            End,
            InitialRunWaferStateMachine,
            InitialUnloadingStateMachine,
            CheckRunWaferStateMachineInitialStatus,
            CheckUnloadingStateMachineInitialStatus,
            StartRunWaferStateMachine,
            StartUnloadingStateMachine,
            CycleRun,
            CycleEnd
        }

        #region 内部变量
        /// <summary>
        /// 次数
        /// </summary>
        private int _cycleCount = 0;
        /// <summary>
        /// Rotation Axis
        /// </summary>
        private JetAxisBase _rotationAxis;
        /// <summary>
        /// Arm Axis
        /// </summary>
        private JetAxisBase _armAxis;
        /// <summary>
        /// SRD Recipe
        /// </summary>
        private SrdRecipe _srdRecipe;
        /// <summary>
        /// 设备对象
        /// </summary>
        private SrdCommonDevice _srdCommonDevice;
        /// <summary>
        /// Run wafer Recipe Routine
        /// </summary>
        private SRDRunWaferRecipeRoutine _runWaferRecipRoutine;
        /// <summary>
        /// Unload Routine
        /// </summary>
        private SRDUnloadRoutine _unloadRoutine;
        /// <summary>
        /// lock track time
        /// </summary>
        private DateTime _lotTackTime = DateTime.Now;
        /// <summary>
        /// LotTrack数据
        /// </summary>
        private List<SRDLotTrackData> _datas = new List<SRDLotTrackData>();
        /// <summary>
        /// LotTrack文件头数据
        /// </summary>
        private LotTrackFileHeaderCommonData _header = new LotTrackFileHeaderCommonData();        
        /// <summary>
        /// Facilities
        /// </summary>
        private SystemFacilities _facilities;
        #endregion

        #region 属性
        /// <summary>
        /// 当前子状态机
        /// </summary>
        public string CurrentStateMachine
        { 
            get { return GetCurrentStateMachine(); } 
        }
        /// <summary>
        /// 当前cycle次数
        /// </summary>
        public int AchievedCycle { get { return Runner.LoopCounter; } }
        /// <summary>
        /// 是否正在用水
        /// </summary>
        public bool IsUsingWater { get { return _runWaferRecipRoutine.IsUsingWater; } }
        /// <summary>
        /// LotTrack数据
        /// </summary>
        public List<SRDLotTrackData> SRDLotTrackDatas { get { return _datas; } }
        /// <summary>
        /// LotTrack文件头数据
        /// </summary>
        public LotTrackFileHeaderCommonData SRDLotTrackHeaderDatas { get { return _header; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public SRDProcessRecipeRoutine(string module, JetAxisBase rotationAxis, JetAxisBase armAxis, SrdCommonDevice srdCommon) : base(module)
        {
            _rotationAxis = rotationAxis;
            _armAxis = armAxis;
            _srdCommonDevice = srdCommon;
            _runWaferRecipRoutine = new SRDRunWaferRecipeRoutine(module);
            _unloadRoutine= new SRDUnloadRoutine(module);
        }
        /// <summary>
        /// 取消
        /// </summary>
        public void Abort()
        {
            if(_unloadRoutine.Monitor() == RState.Running)
            {
                _unloadRoutine.Abort();
            }
            if (_runWaferRecipRoutine.Monitor() == RState.Running)
            {
                _runWaferRecipRoutine.Abort();
            }          
            Runner.Stop("Manual Abort");
            if (_srdCommonDevice != null)
            {
                _srdCommonDevice.EnterErrorOperation();
            }
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public RState Monitor()
        {
            LottrackRecord();
            Runner.LoopStart(SRDProcessState.Ready, "Process Recipe Start", _cycleCount, NullFun, _delay_1ms)
                .LoopRun(SRDProcessState.StartRunWaferStateMachine, () => { return StartRunWaferRecipeStateMachine(); }, _delay_1ms)
                .LoopRunWithStopStatus(SRDProcessState.RunWafer, CheckRunWaferRecipeStateCompleteState, CheckRunWaferRecipeStateErrorState)

                .LoopRun(SRDProcessState.StartUnloadingStateMachine, () => { return StartUnloadingStateMachine(); }, _delay_1ms)
                .LoopRunWithStopStatus(SRDProcessState.Unloading, CheckUnloadingStateCompleteState, CheckUnloadingStateErrorState)

                .LoopEnd(SRDProcessState.CycleEnd, NullFun, _delay_1ms)             
                .End(SRDProcessState.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objects"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public RState Start(params object[] objects)
        {
            _srdRecipe = objects[0] as SrdRecipe;
            if (_srdRecipe == null)
            {
                LOG.WriteLog(eEvent.ERR_SRD, Module.ToString(), " recipe is null");
                return RState.Failed;
            }
            _cycleCount = (int)objects[1];
            if (_cycleCount == 0)
            {
                return RState.End;
            }
            
            _header.SoftWareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
            _header.Recipe = $"{_srdRecipe.Ppid}.srd.rcp";
            if (SC.ContainsItem("System.ToolID")) _header.ToolID = SC.GetStringValue("System.ToolID");
            _facilities = DEVICE.GetDevice<SystemFacilities>("System.Facilities");
            if (_facilities == null)
            {
                LOG.WriteLog(eEvent.ERR_SRD, Module, "Facility is null");
                return RState.Failed;
            }
            _datas.Clear();
            _lotTackTime = DateTime.Now;
            return Runner.Start(Module, "Process Recipe");
        }
        #region RunWaferStateMatcine      
        /// <summary>
        /// 启动状态机
        /// </summary>
        /// <param name="recipe"></param>
        /// <returns></returns>
        private bool StartRunWaferRecipeStateMachine()
        {
            bool result = _runWaferRecipRoutine.Start(_srdRecipe)==RState.Running;           
            if (result)
            {
                LOG.WriteLog(eEvent.INFO_SRD, Module.ToString(), $"Start Run Wafer State Machine, recipe[{_srdRecipe.Ppid}] times[{_cycleCount + 1}]");
            }
            else
            {
                NotifyError(eEvent.ERR_SRD, _runWaferRecipRoutine.ErrorMsg, 0);
            }
            return result;
        }
        /// <summary>
        /// 检验RunWafer状态机完成情况 
        /// </summary>
        /// <returns></returns>
        private bool CheckRunWaferRecipeStateCompleteState()
        {
            return CommonFunction.CheckRoutineEndState(_runWaferRecipRoutine);
        }
        /// <summary>
        /// 检验RunWafer状态机错误情况 
        /// </summary>
        /// <returns></returns>
        private bool CheckRunWaferRecipeStateErrorState()
        {
            bool result = CommonFunction.CheckRoutineStopState(_runWaferRecipRoutine);
            if (result)
            {
                AddLotTrackData(); 
                if (_srdCommonDevice != null)
                {
                    _srdCommonDevice.EnterErrorOperation();
                }
                NotifyError(eEvent.ERR_SRD, _runWaferRecipRoutine.ErrorMsg, 0);
            }
            return result;           
        }
        
        #endregion

        #region UnloadingStateMatcine        
        /// <summary>
        /// 启动状态机
        /// </summary>
        /// <param name="recipe"></param>
        /// <returns></returns>
        private bool StartUnloadingStateMachine()
        {
            bool result= _unloadRoutine.Start() == RState.Running;
            if (!result)
            {
                NotifyError(eEvent.ERR_SRD,_unloadRoutine.ErrorMsg, 0);
            }
            return result;
        }
        /// <summary>
        /// 检验Unloading状态机完成情况 
        /// </summary>
        /// <returns></returns>
        private bool CheckUnloadingStateCompleteState()
        {
            return CommonFunction.CheckRoutineEndState(_unloadRoutine);
        }
        /// <summary>
        /// 检验Unloading状态机错误情况 
        /// </summary>
        /// <returns></returns>
        private bool CheckUnloadingStateErrorState()
        {
            bool result= CommonFunction.CheckRoutineStopState(_unloadRoutine);
            if (result)
            {
                AddLotTrackData();
                NotifyError(eEvent.ERR_SRD, _unloadRoutine.ErrorMsg, 0);
            }
            return result;
        }
        /// <summary>
        /// 停止unloading状态机
        /// </summary>
        /// <returns></returns>
        private bool StopUnloadingStateMachine()
        {
            //_unloadingStateMachine.Stop();
            if (_rotationAxis.IsRun)
            {
                _rotationAxis.StopPositionOperation();
            }
            if (_armAxis.IsRun)
            {
                _armAxis.StopPositionOperation();
            }
            return true;
        }

        #endregion
              
        /// <summary>
        /// 获取当前子状态机
        /// </summary>
        private string GetCurrentStateMachine()
        {
            string result;
            if(Runner.CurrentStep.ToString() == "Ready")
            {
                result = "Ready";
            }
            else if(Runner.CurrentStep.ToString().Contains("RunWafer"))
            {
                result = _runWaferRecipRoutine.CurrentStep;
            }
            else if(Runner.CurrentStep.ToString().Contains("Unloading"))
            {
                result = _unloadRoutine.CurrentStep;
            }
            else
            {
                result = "End";
            }
            return result;
        }
        /// <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()
        {
            SRDLotTrackData data = new SRDLotTrackData();
            data.TimeStamp = DateTime.Now;
            data.StateMachine = GetCurrentStateMachine();
            data.ArmPosition = _armAxis.MotionData.MotorPosition;
            data.WaterPressure = _srdCommonDevice.CommonData.WaterPressure;
            data.WaferPresence =  $"{_srdCommonDevice.WaferPresence}:{_srdCommonDevice.CommonData.WaferPresence}";
            data.ChuckVacuumOn = _srdCommonDevice.CommonData.ChuckVacuum;
            data.ChuckVacuumPressure = _srdCommonDevice.CommonData.VacuumValue;
            data.ArmTorque = _armAxis.MotionData.ActualTorque;
            data.SpinTorque = _rotationAxis.MotionData.ActualTorque;
            data.RotationSpeed = _rotationAxis.MotionData.ActualVelocity;
            data.N2BelowOn = false;
            data.WaterAbove = _srdCommonDevice.CommonData.WaterAbove;
            data.WaterBelow = _srdCommonDevice.CommonData.WaterBelow;
            data.ExhaustOn = _srdCommonDevice.CommonData.ExhaustOn;
            data.LoaderDIEnable = _facilities.LoaderDiEnable;
            data.WaterFlow = 0;
            _datas.Add(data);
        }

        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            List<Enum> preStepIds = new List<Enum>();
            return Runner.Retry(SRDProcessState.Ready, preStepIds, Module, "RunRecipe Retry");
        }
        /// <summary>
        /// 检验前面完成状态
        /// </summary>
        /// <returns></returns>
        public bool CheckCompleteCondition(int index)
        {
            if (_armAxis.IsRun)
            {
                NotifyError(eEvent.ERR_SRD, "Arm axis is run", 0);
                return false;
            }
            if (!_armAxis.IsHomed)
            {
                NotifyError(eEvent.ERR_SRD, "Arm axis is not homed", 0);
                return false;
            }
            if (_rotationAxis.IsRun)
            {
                NotifyError(eEvent.ERR_SRD, "Rotation axis is run", 0);
                return false;
            }
            if (!_rotationAxis.IsHomed)
            {
                NotifyError(eEvent.ERR_SRD, "Rotation axis is not homed", 0);
                return false;
            }
            if (!_srdCommonDevice.CommonData.ChuckVacuum)
            {
                NotifyError(eEvent.ERR_SRD, "Vacuum is not released", 0);
                return false;
            }

            if (!_srdCommonDevice.CommonData.DoorOpened)
            {
                NotifyError(eEvent.ERR_SRD, "Door is not opened", 0);
                return false;
            }
            return true;
        }
    }
}