PunkHPX8/PunkHPX8_RT/Modules/PlatingCell/RotationBiDirectionRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.SubstrateTrackings;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.AXIS;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Modules.PlatingCell
{
    public class RotationBiDirectionRoutine : RoutineBase, IRoutine
    {
        private enum BiDirectionStep
        {
            StartBiDirection,
            LoopStart,
            LoopStartRotation,
            LoopStartRotationEnd,
            //LoopRotationWait,
            //LoopStopRotation,
            //LoopCheckStopRotation,
            LoopUpdateRemain1,
            LoopReverseRotationStart,
            LoopReverseRotationEnd,
            //LoopReverseRotationWait,
            //LooPStopRevserseRotation,
            //LoopCheckStopReverseRotation,
            LoopUpdateRemain2,
            LoopEnd,
            StartRemainRotation,
            //RemainRotationDelay,
            //StopRemainRotation,
            CheckStopRemainRotation,
            End
        }
        #region 常量
        private const int TARGETPOSITION = 10 * 60 * 60 * 100 * 6; //转速100rmp转10个小时的目的地
        private const int SPEED_RATIO = 1;
        #endregion

        #region 内部变量
        /// <summary>
        /// rotation axis
        /// </summary>
        private JetAxisBase _rotationAxis;
        /// <summary>
        /// 运行过程总时间
        /// </summary>
        private int _rotationTime;
        /// <summary>
        /// 转向频率
        /// </summary>
        private int _frequency;
        /// <summary>
        /// 速度，单位rpm
        /// </summary>
        private int _speed;
        /// <summary>
        /// 单步电镀过程中电机需要转向的次数
        /// </summary>
        private int _reverseTimes;
        /// <summary>
        /// 反转次数整除以外的时间
        /// </summary>
        private int _extralTime;
        /// <summary>
        /// 剩余反转次数
        /// </summary>
        private int _remainTimes;
        /// <summary>
        /// monitor部分的循环次数
        /// </summary>
        private int _cycleCount;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public RotationBiDirectionRoutine(string module) : base(module)
        {

        }

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(BiDirectionStep.StartBiDirection, NullFun, _delay_1ms)
                 .LoopStart(BiDirectionStep.LoopStart, "Rotation Bi-Direction Step Start", _cycleCount, NullFun, _delay_1ms)
                 .LoopRunIf(BiDirectionStep.LoopStartRotation, _cycleCount > 0,() => { return StratRotation(true); }, _delay_1ms)
                 .LoopRunIfWithStopStatus(BiDirectionStep.LoopStartRotationEnd, _cycleCount > 0, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                 //.LoopDelayIf(BiDirectionStep.LoopRotationWait, _cycleCount > 0, _frequency * 1000)
                 //.LoopRunIf(BiDirectionStep.LoopStopRotation, _cycleCount > 0, _rotationAxis.StopPositionOperation,_delay_1ms)
                 //.LoopRunIfWithStopStatus(BiDirectionStep.LoopCheckStopRotation, _cycleCount > 0, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                 .LoopRunIf(BiDirectionStep.LoopUpdateRemain1, _cycleCount > 0, UpdateRemain,  _delay_1ms)
                 .LoopRunIf(BiDirectionStep.LoopReverseRotationStart, _remainTimes != 0, () => { return StratRotation(false); }, _delay_1ms)
                   .LoopRunIfWithStopStatus(BiDirectionStep.LoopReverseRotationEnd, _cycleCount > 0, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                 //.LoopDelayIf(BiDirectionStep.LoopReverseRotationWait, _remainTimes != 0, _frequency * 1000)
                 //.LoopRunIf(BiDirectionStep.LooPStopRevserseRotation, _remainTimes != 0, _rotationAxis.StopPositionOperation, _delay_1ms)
                 //.LoopRunIfWithStopStatus(BiDirectionStep.LoopCheckStopReverseRotation, _remainTimes != 0, CheckRotationPositionStatusWithStateupdate, CheckRotationPositionRunStop)
                 //.LoopRunIf(BiDirectionStep.LoopUpdateRemain2, _remainTimes != 0,UpdateRemain, _delay_1ms)
                 .LoopEnd(BiDirectionStep.LoopEnd, NullFun, _delay_1ms)
                 //剩余旋转时间（如果翻转次数是偶数，则正转，否则反转）
                 .RunIf(BiDirectionStep.StartRemainRotation, _extralTime !=0, () => { return _reverseTimes % 2 == 0 ? StratRemainRotation(true, _extralTime) : StratRemainRotation(false, _extralTime); }, _delay_1ms) 
                 //.DelayIf(BiDirectionStep.RemainRotationDelay, _extralTime != 0,  _extralTime * 1000)
                 //.RunIf(BiDirectionStep.StopRemainRotation, _extralTime != 0, _rotationAxis.StopPositionOperation, _delay_1ms)
                 .WaitWithStopConditionIf(BiDirectionStep.CheckStopRemainRotation, _extralTime != 0, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                 .End(BiDirectionStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        private bool UpdateRemain()
        {
            _remainTimes--;
            return true;
        }
        /// <summary>
        /// rotation开始旋转
        /// </summary>
        /// <returns></returns>
        private bool StratRotation(bool isforwardRotate)
        {
            bool result = false;
            if (isforwardRotate) 
            {
                result = _rotationAxis.ProfilePosition((int)(_rotationAxis.MotionData.MotorPosition + _speed * SPEED_RATIO * 6 * _frequency), _speed * SPEED_RATIO * 6, 0, 0);
            }
            else
            {
                result = _rotationAxis.ProfilePosition((int)(_rotationAxis.MotionData.MotorPosition - _speed * SPEED_RATIO * 6 * _frequency), _speed * SPEED_RATIO * 6, 0, 0);
            }
            if (!result)
            {
                NotifyError(eEvent.ERR_PLATINGCELL, "Start Rotation is failed", 0);
                return false;
            }
            return true;
        }
        /// <summary>
        /// rotation开始旋转
        /// </summary>
        /// <returns></returns>
        private bool StratRemainRotation(bool isforwardRotate,int time)
        {
            bool result = false;
            if (isforwardRotate)
            {
                result = _rotationAxis.ProfilePosition(_speed * SPEED_RATIO * 6 * time, _speed * SPEED_RATIO * 6, 0, 0);
            }
            else
            {
                result = _rotationAxis.ProfilePosition(-(_speed * SPEED_RATIO * 6 * time), _speed * SPEED_RATIO * 6, 0, 0);
            }
            if (!result)
            {
                NotifyError(eEvent.ERR_PLATINGCELL, "Start Rotation is failed", 0);
                return false;
            }
            return true;
        }
        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Rotation移动状态(带状态更新)
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatusWithStateupdate()
        {
            bool result = _rotationAxis.Status == RState.End;
            if (result)
            {
                UpdateRemain();
            }
            return result;
        }
        /// <summary>
        /// 检验Rotation是否运动失败
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionRunStop()
        {
            return _rotationAxis.Status == RState.Failed || _rotationAxis.Status == RState.Timeout;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _rotationTime = (int)objs[0]; //单位s
            _frequency = (int)objs[1]; //单位s
            _speed = (int)objs[2]; //单位rmp
            if(_frequency > _rotationTime)
            {
                NotifyError(eEvent.ERR_PLATINGCELL, "frequency can not large than rotation time", 0);
                return RState.Failed;
            }
            _reverseTimes = _rotationTime / _frequency;
            if(_reverseTimes % 2 == 0)
            {
                _cycleCount = _reverseTimes / 2;
            }
            else
            {
                _cycleCount = _reverseTimes / 2 + 1;
            }
            _remainTimes = _reverseTimes;
            _extralTime = _rotationTime % _frequency;
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            return Runner.Start(Module, "Start  Bi-Direction rotation");
        }
    }
}