CyberX8/CyberX8_RT/Devices/Loader/LoaderSideCycleRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Routine;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CyberX8_RT.Devices.Loader
{
    public class LoaderSideCycleRoutine : RoutineBase, IRoutine
    {
        private enum LoaderSideCycleStep
        {
            LoopStart,
            LoopUnload,
            LoopUnloadWait,
            LoopLoad,
            LoopLoadWait,
            LoopFlowTest,
            LoopFlowTestWait,
            LoopEnd,
            End
        }

        #region 内部变量
        /// <summary>
        /// 面
        /// </summary>
        private string _side;
        /// <summary>
        /// Load Routine
        /// </summary>
        private LoaderLoadRoutine _loadRoutine;
        /// <summary>
        /// Unload Routine
        /// </summary>
        private LoaderUnloadRoutine _unloadRoutine;
        /// <summary>
        /// Common device对象
        /// </summary>
        private LoaderCommonDevice _commonDevice;
        /// <summary>
        /// 总次数
        /// </summary>
        private int _totalCycle;
        /// <summary>
        /// 忽略leaktest
        /// </summary>
        private bool _ignoreLeakTest;
        #endregion

        #region 属性
        /// <summary>
        /// 当前次数
        /// </summary>
        public int CurrentCycle { get { return Runner.LoopCounter+1; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public LoaderSideCycleRoutine(string module,string side) : base(module)
        {
            _side = side;
        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual Stop");
            if (Runner.CurrentStep.ToString() ==LoaderSideCycleStep.LoopFlowTest.ToString() 
                || Runner.CurrentStep.ToString() == LoaderSideCycleStep.LoopFlowTestWait.ToString())
            {
                _commonDevice.StopFlowTestAction();
            }
            else if (Runner.CurrentStep.ToString() == LoaderSideCycleStep.LoopLoad.ToString()
                || Runner.CurrentStep.ToString() == LoaderSideCycleStep.LoopLoadWait.ToString())
            {
                _loadRoutine.Abort();
            }
            else if (Runner.CurrentStep.ToString() == LoaderSideCycleStep.LoopUnload.ToString()
                || Runner.CurrentStep.ToString() == LoaderSideCycleStep.LoopUnloadWait.ToString())
            {
                _unloadRoutine.Abort();
            }
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.LoopStart(LoaderSideCycleStep.LoopStart, "Loader Cycle", _totalCycle, NullFun, _delay_1ms)
                .LoopRun(LoaderSideCycleStep.LoopUnload, StartUnload, _delay_1ms)
                .LoopRunWithStopStatus(LoaderSideCycleStep.LoopUnloadWait, () => CommonFunction.CheckRoutineEndState(_unloadRoutine),
                () => CommonFunction.CheckRoutineStopState(_unloadRoutine))
                .LoopRun(LoaderSideCycleStep.LoopLoad, StartLoad, _delay_1ms)
                .LoopRunWithStopStatus(LoaderSideCycleStep.LoopLoadWait, () => CommonFunction.CheckRoutineEndState(_loadRoutine),
                () => CommonFunction.CheckRoutineStopState(_loadRoutine))
                .LoopRunIf(LoaderSideCycleStep.LoopFlowTest,!_ignoreLeakTest, StartFlowTest, _delay_1ms)
                .LoopRunIfWithStopStatus(LoaderSideCycleStep.LoopFlowTestWait, !_ignoreLeakTest,() => _commonDevice.Status == RState.End, () => _commonDevice.Status == RState.Failed)
                .LoopEnd(LoaderSideCycleStep.LoopEnd, NullFun, _delay_1ms)
                .End(LoaderSideCycleStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// 启动Unload
        /// </summary>
        /// <returns></returns>
        private bool StartUnload()
        {
            return _unloadRoutine.Start()==RState.Running;
        }
        /// <summary>
        /// 启动Load
        /// </summary>
        /// <returns></returns>
        private bool StartLoad()
        {
            return _loadRoutine.Start()==RState.Running;
        }
        /// <summary>
        /// 启动Flowtest
        /// </summary>
        /// <returns></returns>
        private bool StartFlowTest()
        {
            return _commonDevice.StartFlowTestAction();
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _commonDevice = DEVICE.GetDevice<LoaderCommonDevice>($"{Module}.Common");
            _totalCycle = (int)objs[0];
            _ignoreLeakTest=(bool)objs[1];
            _loadRoutine = new LoaderLoadRoutine(Module, _side);
            _unloadRoutine= new LoaderUnloadRoutine(Module, _side);
            Runner.Start(Module, "Start Cycle");
            return RState.Running;
        }
    }
}