CyberX8/CyberX8_RT/Devices/Loader/LoaderLeakFirstFlowTestRoutine.cs

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

namespace CyberX8_RT.Devices.Loader
{
    public class LoaderLeakFirstFlowTestRoutine : RoutineBase, IRoutine
    {
        private enum LeakFlowTestStep
        {
            FlowClampOn,
            VacuumOn,
            Delay,
            CheckFlow,
            ReadFlow,
            FlowClampOff,
            VacuumOff,
            End
        }
        #region 内部变量
        private LoaderCommonDevice _loaderCommon;
        private LoaderSideDevice _loaderSideA;
        private LoaderSideDevice _loaderSideB;
        private int _checkFlowTime = 10000;
        private int _delayms = 1000;
        private double _major = 400;
        private double _minor = 50;
        private DateTime _dt = DateTime.Now;
        private List<LoaderFlowLotTrackData> _flowDatas = new List<LoaderFlowLotTrackData>();

        #endregion

        #region 属性
        /// <summary>
        /// Flow LotTrackData
        /// </summary>
        public List<LoaderFlowLotTrackData> FlowLotTrackDatas { get { return _flowDatas; } }
        #endregion
        public LoaderLeakFirstFlowTestRoutine(string module) : base(module)
        {
        }

        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }

        public RState Monitor()
        {
            Runner.Run(LeakFlowTestStep.FlowClampOn, FlowClampOn, _delay_1ms)
                  .Run(LeakFlowTestStep.VacuumOn, VacuumOn, _delay_1ms)
                  .Delay(LeakFlowTestStep.Delay,_delayms)
                  .Run(LeakFlowTestStep.CheckFlow,CheckFirstFlow,100)
                  .Run(LeakFlowTestStep.ReadFlow,NullFun,CheckComplete,_checkFlowTime,false)
                  .Run(LeakFlowTestStep.FlowClampOff, FlowClampOff, _delay_1ms)
                  .Run(LeakFlowTestStep.VacuumOff, VacuumOff, _delay_1ms)
                  .End(LeakFlowTestStep.End,NullFun);

            return Runner.Status; 
        }
        /// <summary>
        /// Flow Clamp off
        /// </summary>
        /// <returns></returns>
        private bool FlowClampOff()
        {
            return _loaderCommon.LeakFlowClampOffAction();
        }
        /// <summary>
        /// Flow Clamp On
        /// </summary>
        /// <returns></returns>
        private bool FlowClampOn()
        {
            return _loaderCommon.LeakFlowClampOnAction();
        }
        /// <summary>
        /// Vacuum On
        /// </summary>
        /// <returns></returns>
        private bool VacuumOn()
        {
            return _loaderCommon.LeakVacuumOnAction();
        }
        /// <summary>
        /// Vacuum Off
        /// </summary>
        /// <returns></returns>
        private bool VacuumOff()
        {
            return _loaderCommon.LeakVacuumOffAction();
        }
        /// <summary>
        /// 确认结束状态
        /// </summary>
        /// <returns></returns>
        private bool CheckEndState()
        {
            return _loaderCommon.Status == RState.End;
        }
        /// <summary>
        /// 确认第一条数据
        /// </summary>
        /// <returns></returns>
        private bool CheckFirstFlow()
        {
            if (_loaderCommon.CommonData.LeakFlow < _major)
            {
                LOG.WriteLog(eEvent.ERR_LOADER, Module.ToString(), $"Flow {_loaderCommon.CommonData.LeakFlow} is less limit {_major}");
                return false;
            }
            else
            {
                _dt = DateTime.Now;
                _flowDatas.Clear();
                AddLotTrackData();
                return true;
            }
        }
        /// <summary>
        /// 获取Lot Track数据
        /// </summary>
        /// <returns></returns>
        private void AddLotTrackData()
        {
            
            LoaderFlowLotTrackData data = new LoaderFlowLotTrackData();
            data.TimeStamp = DateTime.Now;
            data.Time = data.TimeStamp.ToString("mm:ss");

            data.LoaderWHClamped = _loaderCommon.CommonData.WaferHolderClamp;

            data.LoaderACRSVacuum=_loaderSideA.SideData.CRSVacuum;
            data.LoaderACRSVacuumAnlg = _loaderSideA.SideData.CRSVacuumValue;
            
            data.LoaderBCRSVacuum = _loaderSideB.SideData.CRSVacuum;
            data.LoaderBCRSVacuumAnlg = _loaderSideB.SideData.CRSVacuumValue;

            data.EnableFlowClamp = _loaderCommon.CommonData.LeakFlowClamp;
            data.EnableVacuum = _loaderCommon.CommonData.LeakVacuum; 
            data.FlowValue = _loaderCommon.CommonData.LeakFlow;

            _flowDatas.Add(data);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private bool CheckComplete()
        {
            if (DateTime.Now.Subtract(_dt).TotalMilliseconds >= 1000)
            {
                double flow = _loaderCommon.CommonData.LeakFlow;
                _dt = DateTime.Now;
                AddLotTrackData();
                if (flow < _minor)
                {
                    _loaderCommon.CommonData.FlowValues.AddRange(_flowDatas);
                    _loaderCommon.ExportFlowLotTrackDatas(_flowDatas);    
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return false;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _loaderCommon = DEVICE.GetDevice<LoaderCommonDevice>($"{Module}.Common");
            _loaderSideA = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.SideA");
            _loaderSideB = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.SideB");
            _loaderCommon.CommonData.FlowValues = new List<LoaderFlowLotTrackData>();
            if (SC.ContainsItem($"{Module}.LeakTestCutOffTime"))
            {
                _checkFlowTime = SC.GetValue<int>($"{Module}.LeakTestCutOffTime");
            }
            if (SC.ContainsItem($"{Module}.LeakTestLSOKLimit"))
            {
                _major = SC.GetValue<double>($"{Module}.LeakTestLSOKLimit");
            }
            if (SC.ContainsItem($"{Module}.LeakTestCutOffValue"))
            {
                _minor = SC.GetValue<double>($"{Module}.LeakTestCutOffValue");
            }
            Runner.Start(Module, "LeakFirstFlowTest");
            return RState.Running;
        }
    }
}