CyberX8/CyberX8_RT/Devices/Safety/SafetyAllOnRoutine.cs

using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using CyberX8_Core;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.Loader;
using CyberX8_RT.Modules.PUF;
using CyberX8_RT.Modules.SRD;
using CyberX8_RT.Modules.Transporter;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;

namespace CyberX8_RT.Devices.Safety
{
    internal class SafetyAllOnRoutine : RoutineBase, IRoutine
    {
        private enum SafetyAllOnStep
        {
            Ready,
            SwitchOnProcessTransporter,
            WaitSwitchOnProcessTransporter,
            SwitchOnLoaderTransporter,
            WaitSwitchOnLoaderTransporter,
            SwitchOnLoader,
            WaitSwitchOnLoader,
            SwitchOnPuf1,
            WaitSwitchOnPuf1,
            SwitchOnPuf2,
            WaitSwitchOnPuf2,
            SwitchOnSRD1,
            WaitSwitchOnSRD1,
            SwitchOnSRD2,
            WaitSwitchOnSRD2,
            End
        }
        #region 内部变量
        private SafetyDevice _device;
        /// <summary>
        /// ProcessTransporter
        /// </summary>
        private TransporterEntity _processTransporterEntity;
        /// <summary>
        /// LoaderTransporter
        /// </summary>
        private TransporterEntity _loaderTransporterEntity;
        /// <summary>
        /// Puf1
        /// </summary>
        private PUFEntity _puf1Entity;
        /// <summary>
        /// Puf2
        /// </summary>
        private PUFEntity _puf2Entity;
        /// <summary>
        /// Loader
        /// </summary>
        private LoaderEntity _loaderEntity;
        /// <summary>
        /// SRD1
        /// </summary>
        private SRDEntity _srd1Entity;
        /// <summary>
        /// SRD2
        /// </summary>
        private SRDEntity _srd2Entity;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public SafetyAllOnRoutine(string module) : base(module)
        {
            
        }
        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop($"Safety All On Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(SafetyAllOnStep.Ready, CheckReady, _delay_1ms)
                .RunIf(SafetyAllOnStep.SwitchOnProcessTransporter,_processTransporterEntity!=null, SwitchOnProcessTransporter, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnProcessTransporter, CheckSwitchOnProcessTransporterComplete, CheckSwitchOnProcessTransporterError)
                .RunIf(SafetyAllOnStep.SwitchOnLoaderTransporter,_loaderTransporterEntity!=null, SwitchOnLoaderTransporter, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnLoaderTransporter, CheckSwitchOnLoaderTransporterComplete, CheckSwitchOnLoaderTransporterError)
                .RunIf(SafetyAllOnStep.SwitchOnPuf1,_puf1Entity!=null, SwitchOnPuf1, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnPuf1, CheckSwitchOnPuf1Complete, CheckSwitchOnPuf1Error)
                .RunIf(SafetyAllOnStep.SwitchOnPuf2,_puf2Entity!=null, SwitchOnPuf2, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnPuf2, CheckSwitchOnPuf2Complete, CheckSwitchOnPuf2Error)
                .RunIf(SafetyAllOnStep.SwitchOnLoader,_loaderEntity!=null, SwitchOnLoader, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnLoader, CheckSwitchOnLoaderComplete, CheckSwitchOnLoaderError)
                .RunIf(SafetyAllOnStep.SwitchOnSRD1, _srd1Entity!=null, SwitchOnSRD1, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnSRD1, CheckSwitchOnSRD1Complete, CheckSwitchOnSRD1Error)
                .RunIf(SafetyAllOnStep.SwitchOnSRD2, _srd2Entity!=null, SwitchOnSRD2, _delay_1ms)
                .WaitWithStopCondition(SafetyAllOnStep.WaitSwitchOnSRD2, CheckSwitchOnSRD2Complete, CheckSwitchOnSRD2Error)
                .End(SafetyAllOnStep.End, NullFun, _delay_1ms);

            return Runner.Status;
        }

        private bool CheckReady()
        {
            _processTransporterEntity = Singleton<RouteManager>.Instance.GetModule<TransporterEntity>(ModuleName.Transporter1.ToString());
            _loaderTransporterEntity = Singleton<RouteManager>.Instance.GetModule<TransporterEntity>(ModuleName.Transporter2.ToString());
            _puf1Entity = Singleton<RouteManager>.Instance.GetModule<PUFEntity>(ModuleName.PUF1.ToString());
            _puf2Entity = Singleton<RouteManager>.Instance.GetModule<PUFEntity>(ModuleName.PUF2.ToString());
            _loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
            _srd1Entity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(ModuleName.SRD1.ToString());
            _srd2Entity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(ModuleName.SRD2.ToString());
            return true;
        }
        #region ProcessTransporter
        /// <summary>
        /// Switch on ProcessTransporter Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnProcessTransporter()
        {
            return _processTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(eEvent.ERR_TRANSPORTER, ModuleName.Transporter1.ToString(), (int)TransporterMSG.SwitchOn);
        }
        /// <summary>
        /// 检查ProcessTransporter Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnProcessTransporterComplete()
        {
            if (_processTransporterEntity == null)
            {
                return true;
            }
            if (_processTransporterEntity.IsGantrySwitchOn && _processTransporterEntity.IsElevatorSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查ProcessTransporter Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnProcessTransporterError()
        {
            if(_processTransporterEntity==null)
            {
                return false;
            }
            if (_processTransporterEntity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On ProcessTransporter Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region LoaderTransporter
        /// <summary>
        /// Switch on LoaderTransporter Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnLoaderTransporter()
        {
            return _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(eEvent.ERR_TRANSPORTER, ModuleName.Transporter2.ToString(), (int)TransporterMSG.SwitchOn);
        }
        /// <summary>
        /// 检查LoaderTransporter Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnLoaderTransporterComplete()
        {
            if (_loaderTransporterEntity==null)
            {
                return true;
            }
            if (_loaderTransporterEntity.IsGantrySwitchOn && _loaderTransporterEntity.IsElevatorSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查LoaderTransporter Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnLoaderTransporterError()
        {
            if(_loaderTransporterEntity==null)
            {
                return false;
            }
            if (_loaderTransporterEntity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On ProcessTransporter Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region Puf1
        /// <summary>
        /// Switch on Puf1 Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnPuf1()
        {
            return _puf1Entity.CheckToPostMessage<PUFSTATE,PUFMSG>(eEvent.ERR_PUF, ModuleName.PUF1.ToString(), (int)PUFMSG.SwitchOn);
        }
        /// <summary>
        /// 检查Puf1 Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnPuf1Complete()
        {
            if (_puf1Entity==null)
            {
                return true;
            }
            if (_puf1Entity.IsRotationSwitchOn && _puf1Entity.IsVerticalSwitchOn && _puf1Entity.IsFlipSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查Puf1 Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnPuf1Error()
        {
            if (_puf1Entity == null)
            {
                return false;
            }
            if (_puf1Entity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On Puf1 Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region Puf2
        /// <summary>
        /// Switch on Puf2 Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnPuf2()
        {
            return _puf2Entity.CheckToPostMessage<PUFSTATE,PUFMSG>(eEvent.ERR_PUF, ModuleName.PUF2.ToString(), (int)PUFMSG.SwitchOn);
        }
        /// <summary>
        /// 检查Puf1 Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnPuf2Complete()
        {
            if (_puf2Entity == null)
            {
                return true;
            }
            if (_puf2Entity.IsRotationSwitchOn && _puf2Entity.IsVerticalSwitchOn && _puf2Entity.IsFlipSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查Puf2 Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnPuf2Error()
        {
            if (_puf2Entity == null)
            {
                return false;
            }
            if (_puf2Entity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On Puf2 Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region Loader
        /// <summary>
        /// Switch on Loader Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnLoader()
        {
            return _loaderEntity.CheckToPostMessage<LOADERSTATE,LoaderMSG>(eEvent.ERR_LOADER, ModuleName.Loader1.ToString(), (int)LoaderMSG.SwitchOnAll); ;
        }
        /// <summary>
        /// 检查Loader Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnLoaderComplete()
        {
            if (_loaderEntity==null)
            {
                return true;
            }

            if (_loaderEntity.IsRotationSwitchOn && _loaderEntity.IsTiltASwitchOn && _loaderEntity.IsTiltBSwitchOn 
                && _loaderEntity.IsShuttleASwitchOn && _loaderEntity.IsShuttleBSwitchOn && _loaderEntity.IsCrsASwitchOn && _loaderEntity.IsCrsBSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查Loader Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnLoaderError()
        {
            if(_loaderEntity==null)
            {
                return false;
            }
            if (_loaderEntity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On Loader Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region SRD1
        /// <summary>
        /// Switch on SRD1 Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnSRD1()
        {
            return _srd1Entity.CheckToPostMessage<SRDState,SRDMSG>(eEvent.ERR_SRD, ModuleName.SRD1.ToString(), (int)SRDMSG.SwitchOn);
        }
        /// <summary>
        /// 检查SRD1 Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnSRD1Complete()
        {
            if(_srd1Entity==null)
            {
                return true;
            }
            if (_srd1Entity.IsRotationSwitchOn && _srd1Entity.IsArmSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查SRD1 Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnSRD1Error()
        {
            if (_srd1Entity == null)
            {
                return false;
            }
            if (_srd1Entity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On SRD1 Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        #region SRD2
        /// <summary>
        /// Switch on SRD2 Motors
        /// </summary>
        /// <returns></returns>
        private bool SwitchOnSRD2()
        {
            return _srd2Entity.CheckToPostMessage<SRDState,SRDMSG>(eEvent.ERR_SRD, ModuleName.SRD2.ToString(), (int)SRDMSG.SwitchOn);
        }
        /// <summary>
        /// 检查SRD2 Motors switchon是否完成
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnSRD2Complete()
        {
            if(_srd2Entity == null)
            {
                return true;
            }
            if (_srd2Entity.IsRotationSwitchOn && _srd2Entity.IsArmSwitchOn)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查SRD2 Motors switchon是否出错
        /// </summary>
        /// <returns></returns>
        private bool CheckSwitchOnSRD2Error()
        {
            if(_srd2Entity == null)
            {
                return false;
            }
            if (_srd2Entity.IsError)
            {
                LOG.WriteLog(eEvent.ERR_SAFETY, Module, $"Switching On SRD2 Motors is failed");
                return true;
            }
            return false;
        }
        #endregion

        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _device = DEVICE.GetDevice<SafetyDevice>(Module);
            return Runner.Start(Module, $"Safety All On");
        }
    }
}