CyberX8/CyberX8_RT/Modules/PUF/PufBackToParkRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Routine;
using MECF.Framework.Common.Routine;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Log;
using System.Windows.Media.Animation;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.Equipment;
using CyberX8_RT.Devices.PUF;

namespace CyberX8_RT.Modules.PUF
{
    public class PufBackToParkRoutine : RoutineBase, IRoutine
    {
        private enum BackToParkStep
        {
            ChuckIn,
            WaitChuck,
            RotationHomeStation,
            WaitRotationHomeStation,
            FlipSideA,
            WaitFlipSideA,
            End
        }
        #region 内部变量
        private JetAxisBase _flipAxis;
        private JetAxisBase _rotationAxis;
        private PufVacuum _pufVacuum;
        private PufChuckRoutine _chuckRoutine;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public PufBackToParkRoutine(string module) : base(module)
        {
            _chuckRoutine=new PufChuckRoutine(module);
            _pufVacuum = DEVICE.GetDevice<PufVacuum>($"{Module}.Vacuum");
        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("manual abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(BackToParkStep.ChuckIn, () => _chuckRoutine.Start(false)==RState.Running, _delay_1ms)
                .WaitWithStopCondition(BackToParkStep.WaitChuck, ()=>CommonFunction.CheckRoutineEndState(_chuckRoutine),
                    CheckChuckStopStatus)
                .Run(BackToParkStep.RotationHomeStation, () => AxisGotoPosition(_rotationAxis, "Home", 0), _delay_1ms)
                .WaitWithStopCondition(BackToParkStep.WaitRotationHomeStation, CheckRotationPositionStatus, CheckRotationStopStatus)
                .RunIf(BackToParkStep.FlipSideA,Module==ModuleName.PUF1.ToString(),() => AxisGotoPosition(_flipAxis,"SideA", 0), _delay_1ms)
                .WaitWithStopConditionIf(BackToParkStep.WaitFlipSideA, Module == ModuleName.PUF1.ToString(), CheckFlipPositionStatus, CheckFlipStopStatus)
                .End(BackToParkStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// 检验chuck routine停止状态
        /// </summary>
        /// <returns></returns>
        private bool CheckChuckStopStatus()
        {
            bool result=CommonFunction.CheckRoutineStopState(_chuckRoutine);
            if (!result)
            {
                NotifyError(eEvent.ERR_PUF, _chuckRoutine.ErrorMsg, 0);
            }
            return result;
        }

        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Flip移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckFlipPositionStatus()
        {
            return _flipAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Flip异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckFlipStopStatus()
        {
            bool result = _flipAxis.Status == RState.Failed || _flipAxis.Status == RState.Timeout;
            if (result)
            {
                NotifyError(eEvent.ERR_PUF, "flip motion failed", 0);
            }
            return result;
        }
        /// <summary>
        /// 检验Rotation异常状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationStopStatus()
        {
            bool result = _rotationAxis.Status == RState.Failed || _rotationAxis.Status == RState.Timeout;
            if (result)
            {
                NotifyError(eEvent.ERR_PUF, "rotation motion failed", 0);
            }
            return result;
        }
        /// <summary>
        /// Axis goto position
        /// </summary>
        /// <param name="axis"></param>
        /// <param name="position"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private bool AxisGotoPosition(JetAxisBase axis, string position, int index)
        {
            bool result = axis.PositionStation(position);
            if (!result)
            {
                NotifyError(eEvent.ERR_PUF, $"{axis.Module} goto {position} failed", index);
            }
            return result;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            InitializeParameters();
            return Runner.Start(Module, "start back to park station");
        }

        /// <summary>
        /// 初始化参数
        /// </summary>
        private void InitializeParameters()
        {
            _flipAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Flip");
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
        }
        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            InitializeParameters();
            List<Enum> preStepIds = new List<Enum>();
            return Runner.Retry(BackToParkStep.ChuckIn, preStepIds, Module, "Back to park Retry");
        }
        /// <summary>
        /// 检验完成情况 
        /// </summary>
        /// <returns></returns>
        public bool CheckCompleteCondition()
        {
            double rotationPosition = _rotationAxis.MotionData.MotorPosition;
            if (!_rotationAxis.CheckPositionIsInStation(rotationPosition, "Home"))
            {
                NotifyError(eEvent.ERR_PUF, $"rotation {rotationPosition} not in Home", 0);
                return false;
            }
            double flipPosition = _flipAxis.MotionData.MotorPosition;
            if (!_flipAxis.CheckPositionIsInStation(flipPosition, "SideA"))
            {
                NotifyError(eEvent.ERR_PUF, $"flip {flipPosition} not in SideA", 0);
                return false;
            }
            if (!_pufVacuum.CheckChuckIn())
            {
                NotifyError(eEvent.ERR_PUF, $"Chuck status is not chuck in", 0);
                return false;
            }
            return true;
        }
    }
}