CyberX8/CyberX8_RT/Devices/SRD/SrdCommonDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData.SRD;
using MECF.Framework.Common.Persistent.Prewet;
using MECF.Framework.Common.Persistent.SRD;
using MECF.Framework.Common.TwinCat;
using CyberX8_Core;
using System.Reflection;
using CyberX8_RT.Modules.Rinse;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.SRD;
using CyberX8_RT.Devices.AXIS;
using MECF.Framework.Common.Persistent.Rinse;
using System.Security.Principal;
using MECF.Framework.Common.IOCore;

namespace CyberX8_RT.Devices.SRD
{
    public class SrdCommonDevice : BaseDevice, IDevice
    {
        /// <summary>
        /// Srd操作枚举
        /// </summary>
        private enum SrdCommonOperation
        {
            None,
            DoorClose,
            DoorOpen,
            ChuckVacuumOn,
            ChuckVacuumOff,
        }

        #region 常量
        private const string FLUID_CONTAINMENT = "FluidContainment";
        private const string VACUUM_VALUE = "VacuumValue";
        private const string WAFER_PRESENCE = "WaferPresence";
        private const string WAFER_PRESENCE_STATUS = "WaferPresenceStatus";
        private const string WATER_PRESSURE = "WaterPressure";
        private const string DOOR_CLOSE="DoorClose";
        private const string DOOR_CLOSED = "DoorClosed";
        private const string DOOR_OPENED = "DoorOpened";
        private const string WATER_ABOVE="WaterAbove";
        private const string WATER_BELOW = "WaterBelow";
        private const string CHUCK_VACUUM="ChuckVacuum";
        private const string EXHAUST_ON="ExhaustOn";
        private const string COMMON_DATA = "CommonData";
        private const string PERSISTENT_VALUE= "PersistentValue";

        private const string CHUCK_ATM_ON = "ChuckATMOn";
        private const string CHUCK_VACUUM_OK = "ChuckVacuumOK";
        private const string WAFER_PRESENT = "WaferPresent";
        private const string LIFT_UP = "LiftUp";
        private const string LIFT_UP_STATUS = "LiftUpStatus";
        private const string FLIPPER1_OUT_150_STATUS = "Flipper1Out150Status";
        private const string FLIPPER2_OUT_150_STATUS = "Flipper2Out150Status";
        private const string FLIPPER3_OUT_150_STATUS = "Flipper3Out150Status";
        private const string FLIPPER1_OUT_200_STATUS = "Flipper1Out200Status";
        private const string FLIPPER2_OUT_200_STATUS = "Flipper2Out200Status";
        private const string FLIPPER3_OUT_200_STATUS = "Flipper3Out200Status";
        private const string FLIPPERS_IN_150_STATUS = "FlippersIn150";
        private const string FLIPPERS_IN_200_STATUS = "FlippersIn200";
        private const string WATER_FLOW = "WaterFlow";
        private const string N2_ON= "N2On";
        #endregion

        #region 内部变量
        /// <summary>
        /// Common数据
        /// </summary>
        private SrdCommonData _commonData = new SrdCommonData();
        /// <summary>
        /// 状态
        /// </summary>
        private RState _status;
        /// <summary>
        /// 当前操作
        /// </summary>
        private SrdCommonOperation _currentOperation;
        /// <summary>
        /// Wafer Presence
        /// </summary>
        private string _waferPresence;
        /// <summary>
        /// Persistent Value对象
        /// </summary>
        private SRDPersistentValue _srdPersistentValue;
        /// <summary>
        /// IsWaferPresence
        /// </summary>
        private bool _isWaferPresence = true;
        /// <summary>
        /// Total Device
        /// </summary>
        private TotalSRDDevice _totalSRDDevice;
        #region Routine
        /// <summary>
        /// Close Routine
        /// </summary>
        private SrdCommonDoorCloseRoutine _doorCloseRoutine;
        /// <summary>
        /// Vacuum Routine
        /// </summary>
        private SrdCommonChuckVacuumRoutine _chuckVacuumRoutine;
        #endregion

        #endregion

        #region 属性
        /// <summary>
        /// Common数据
        /// </summary>
        public SrdCommonData CommonData
        {
            get { return _commonData; }
        }
        /// <summary>
        /// 状态
        /// </summary>
        public RState Status { get { return _status; } }
        /// <summary>
        /// Wafer Presence
        /// </summary>
        public string WaferPresence 
        {
            get { return _waferPresence; }
        }
        /// <summary>
        /// IsWaferPresence
        /// </summary>
        public bool IsWaferPresence
        {
            get { return _isWaferPresence; }
        }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="name"></param>
        public SrdCommonDevice(string moduleName) : base(moduleName, "Common", "Common", "Common")
        {
        }      
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitializeRoutine();
            SubscribeData();
            SubscribeValueAction();
            InitializeOperation();
            return true;
        }
        /// <summary>
        /// 初始化Routine
        /// </summary>
        private void InitializeRoutine()
        {
            _doorCloseRoutine = new SrdCommonDoorCloseRoutine(Module);
            _chuckVacuumRoutine = new SrdCommonChuckVacuumRoutine(Module);
        }
        /// <summary>
        /// 订阅数据
        /// </summary>
        private void SubscribeData()
        {
            _srdPersistentValue = SRDPersistentManager.Instance.GetModulePersistentValue(Module);
            if(_srdPersistentValue==null)
            {
                LOG.WriteLog(eEvent.ERR_SRD, Module, "Persistent Value Object is not exist");
            }
            DATA.Subscribe($"{Module}.{PERSISTENT_VALUE}", () => _srdPersistentValue, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{COMMON_DATA}", () => _commonData, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{WAFER_PRESENCE_STATUS}", () => _waferPresence, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.IsWaferPresence", () => IsWaferPresence, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            IOModuleManager.Instance.SubscribeModuleVariable(Module, VACUUM_VALUE, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, WAFER_PRESENCE, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, DOOR_CLOSE, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, DOOR_CLOSED, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, DOOR_OPENED, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, WATER_ABOVE, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, WATER_BELOW, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, CHUCK_VACUUM, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, EXHAUST_ON, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, CHUCK_ATM_ON, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, CHUCK_VACUUM_OK, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, WAFER_PRESENT, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, LIFT_UP, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, LIFT_UP_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER1_OUT_150_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER2_OUT_150_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER3_OUT_150_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER1_OUT_200_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER2_OUT_200_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPER3_OUT_200_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPERS_IN_150_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, FLIPPERS_IN_200_STATUS, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, WATER_FLOW, UpdateVariableValue);
            IOModuleManager.Instance.SubscribeModuleVariable(Module, N2_ON, UpdateVariableValue);

        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.{Name}.DoorClose", DoorCloseAction);
            OP.Subscribe($"{Module}.{Name}.DoorOpen", DoorOpenAction);
            OP.Subscribe($"{Module}.{Name}.WaterAboveOn", WaterAboveOnAction);
            OP.Subscribe($"{Module}.{Name}.WaterAboveOff", WaterAboveOffAction);
            OP.Subscribe($"{Module}.{Name}.WaterBelowOn", WaterBelowOnAction);
            OP.Subscribe($"{Module}.{Name}.WaterBelowOff", WaterBelowOffAction);
            OP.Subscribe($"{Module}.{Name}.ChuckVacuumOn", ChuckVacuumOnAction);
            OP.Subscribe($"{Module}.{Name}.ChuckVacuumOff", ChuckVacuumOffAction);
            OP.Subscribe($"{Module}.{Name}.ExhaustOn", ExhaustOnAction);
            OP.Subscribe($"{Module}.{Name}.ExhaustOff", ExhaustOffAction); 
            OP.Subscribe($"{Module}.KeyDown", KeyDownAction);
            
            OP.Subscribe($"{Module}.DisabledAction", DisabledOperation);
            OP.Subscribe($"{Module}.ManualAction", ManualOperation);
            OP.Subscribe($"{Module}.AutoAction", AutoOperation);
            OP.Subscribe($"{Module}.EngineeringModeAction", EngineeringModeOperation);
            OP.Subscribe($"{Module}.ProductionModeAction", ProductionModeOperation);

            OP.Subscribe($"{Module}.UpdateIsWaferPresenceAction", UpdateIsWaferPresenceAction);
        }

    

        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            if(!CommonData.IsDataInitialized)
            {
                CommonData.IsDataInitialized = true;
            }
            PropertyInfo property = CommonData.GetType().GetProperty(variable);
            if (property != null)
            {
                property.SetValue(CommonData, value);
            }

            UpdateWaferPresence(variable, value);

        }
        /// <summary>
        /// 更新Wafer Presence
        /// </summary>
        private void UpdateWaferPresence(string variable,object value)
        {
            if (variable == WAFER_PRESENCE&&value is double)
            {
                UpdateWaferPresence((double)value);
            }
        }
        /// <summary>
        /// 更新Wafer Presence
        /// </summary>
        /// <param name="waferPresence"></param>
        private void UpdateWaferPresence(double waferPresence)
        {
            if (_srdPersistentValue != null)
            {
                if (waferPresence > _srdPersistentValue.EmptyThreshold)
                {
                    _waferPresence = "Empty";
                }
                else if (waferPresence >= _srdPersistentValue.WellPlacedHighThreshold && waferPresence <= _srdPersistentValue.EmptyThreshold)
                {
                    _waferPresence = "PoorlyPlaced";
                }
                else if (waferPresence < _srdPersistentValue.WellPlacedLowThreshold)
                {
                    _waferPresence = "PoorlyPlaced";
                }
                else
                {
                    _waferPresence = "WellPlaced";
                }
            }
        }
        
        #region Operation

        #region OperationStatus
        /// <summary>
        /// DisabledAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DisabledOperation(string cmd, object[] args)
        {
            string currentOperation = "Disabled";
            SRDEntity srdEntity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(Module);
            if (srdEntity == null || _srdPersistentValue == null) return false;
            if (_srdPersistentValue.OperatingMode != "Disabled") srdEntity.EnterInit();
            SRDPersistentManager.Instance.UpdateOperationModeValue(Module,currentOperation);
            return true;
        }
        /// <summary>
        /// ManualAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ManualOperation(string cmd, object[] args)
        {
            string currentOperation = "Manual";
            SRDEntity srdEntity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(Module);
            if (srdEntity == null || _srdPersistentValue == null) return false;
            if (_srdPersistentValue.OperatingMode == "Auto" && srdEntity.IsBusy)
            {
                LOG.WriteLog(eEvent.ERR_SRD, Module, $"{Module} is Busy, can't change to manual mode");
                return false;
            }
            if (_srdPersistentValue.OperatingMode != "Manual") srdEntity.EnterInit();
            SRDPersistentManager.Instance.UpdateOperationModeValue(Module,currentOperation);
            return true;
        }
        /// <summary>
        /// AutoAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool AutoOperation(string cmd, object[] args)
        {
            string currentOperation = "Auto";
            SRDEntity srdEntity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(Module);
            if (srdEntity == null || _srdPersistentValue == null) return false;
            if (_srdPersistentValue.OperatingMode != "Auto") srdEntity.EnterInit();
            SRDPersistentManager.Instance.UpdateOperationModeValue(Module,currentOperation);
            return true;
        }
        /// <summary>
        /// EngineeringModeAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool EngineeringModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Engineering";
            SRDPersistentManager.Instance.UpdateRecipeOperationModeValue(Module, currentRecipeOperation);
            return true;
        }
        /// <summary>
        /// ProductionAction
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ProductionModeOperation(string cmd, object[] args)
        {
            string currentRecipeOperation = "Production";
            SRDPersistentManager.Instance.UpdateRecipeOperationModeValue(Module, currentRecipeOperation);
            return true;
        }
        #endregion

        #region keydown
        private bool KeyDownAction(string cmd, object[] args)
        {
            string variableName = args[0].ToString();
            PropertyInfo property = _srdPersistentValue.GetType().GetProperty(variableName);
            if(property!=null)
            {
                property.SetValue(_srdPersistentValue, args[1]);
            }
            SRDPersistentManager.Instance.UpdateModulePersistentValue(Module);
            UpdateWaferPresence(CommonData.WaferPresence);
            return true;
        }
        #endregion

        #region Door 
        /// <summary>
        /// Door Close操作
        /// </summary>
        public bool DoorCloseAction(string cmd, object[] args)
        {
            if (!JudgeRunningState(SrdCommonOperation.DoorClose))
            {
                _currentOperation = SrdCommonOperation.DoorClose;
                _status = _doorCloseRoutine.Start(true);
                return _status==RState.Running;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Door Open操作
        /// </summary>
        public bool DoorOpenAction(string cmd, object[] args)
        {
            if (!JudgeRunningState(SrdCommonOperation.DoorOpen))
            {
                _currentOperation = SrdCommonOperation.DoorOpen;
                _status = _doorCloseRoutine.Start(false);
                return _status==RState.Running;
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region Exhaust On
        /// <summary>
        /// Exhaust On
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool ExhaustOnAction(string cmd, object[] args)
        {
            return ExhaustOn();
        }
        /// <summary>
        /// Exhaust Off
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool ExhaustOffAction(string cmd, object[] args)
        {
            return ExhaustOff();
        }
        /// <summary>
        /// Exhaust On(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool ExhaustOn()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{EXHAUST_ON}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }

        /// <summary>
        /// Exhaust On(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool ExhaustOff()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{EXHAUST_ON}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        #endregion


        #region Chuck Vacuum 
        /// <summary>
        /// Chuck Vacuum操作
        /// </summary>
        public bool ChuckVacuumOnAction(string cmd, object[] args)
        {
            if (!JudgeRunningState(SrdCommonOperation.ChuckVacuumOn))
            {
                _currentOperation = SrdCommonOperation.ChuckVacuumOn;
                _status = _chuckVacuumRoutine.Start(false);
                return _status==RState.Running;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// chuck Vacuum Off操作
        /// </summary>
        public bool ChuckVacuumOffAction(string cmd, object[] args)
        {
            if (!JudgeRunningState(SrdCommonOperation.ChuckVacuumOff))
            {
                _currentOperation = SrdCommonOperation.ChuckVacuumOff;
                _status= _chuckVacuumRoutine.Start(true);
                return _status==RState.Running;
            }
            else
            {
                return false;
            }
        }
        #endregion
        #region Water Above 
        /// <summary>
        /// Water Above On操作
        /// </summary>
        public bool WaterAboveOnAction(string cmd, object[] args)
        {
            return WaterAboveOn();
        }
        /// <summary>
        /// water above Off操作
        /// </summary>
        public bool WaterAboveOffAction(string cmd, object[] args)
        {
            return WaterAboveOff();
        }
        /// <summary>
        /// Water Above On(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool WaterAboveOn()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WATER_ABOVE}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        /// <summary>
        /// Water Above Off(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool WaterAboveOff()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WATER_ABOVE}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        #endregion

        #region Water Below 
        /// <summary>
        /// Water Below On操作
        /// </summary>
        public bool WaterBelowOnAction(string cmd, object[] args)
        {
            return WaterBelowOn();
        }
        /// <summary>
        /// water Below Off操作
        /// </summary>
        public bool WaterBelowOffAction(string cmd, object[] args)
        {
            return WaterBelowOff();
        }
        /// <summary>
        /// Water Below On(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool WaterBelowOn()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WATER_BELOW}");
            return IOModuleManager.Instance.WriteIoValue(ioName, true);
        }
        /// <summary>
        /// Water Below Off(不确认信号)
        /// </summary>
        /// <returns></returns>
        public bool WaterBelowOff()
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Module}.{WATER_BELOW}");
            return IOModuleManager.Instance.WriteIoValue(ioName, false);
        }
        #endregion
        /// <summary>
        /// Update IsWaferPresence 标志位
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public bool UpdateIsWaferPresenceAction(string cmd, object[] args)
        {
            _isWaferPresence = (bool)args[0];
            return true; 
        }

        /// <summary>
        /// 判定运行状态
        /// </summary>
        /// <returns></returns>
        private bool JudgeRunningState(SrdCommonOperation operation)
        {
            if (_status == RState.Running)
            {
                EV.PostAlarmLog($"{Module}", eEvent.ERR_SRD, $"{Module} current execute {_currentOperation},cannot {operation}");
                return true;
            }
            return false;
        }

        /// <summary>
        /// ErrorOperation
        /// </summary>
        public void EnterErrorOperation()
        {
            //关闭风扇
            if (CommonData.ExhaustOn)
            {
                bool result = ExhaustOffAction("", null);
                if (!result)
                {
                    LOG.WriteLog(eEvent.ERR_SRD, Module, "EnterError: Exhaust Off is failed");
                }
            }
            //关闭WaterAbove
            if (CommonData.WaterAbove)
            {
                bool result = WaterAboveOff();
                if (!result)
                {
                    LOG.WriteLog(eEvent.INFO_SRD, Module, "EnterError: Water Above Off is failed");
                }
            }
            //关闭WaterBelow
            if (CommonData.WaterBelow)
            {
                bool result = WaterBelowOff();
                if (!result)
                {
                    LOG.WriteLog(eEvent.INFO_SRD, Module, "EnterError: Water Below Off is failed");
                }
            }
            //停电机
            JetAxisBase _armAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Arm");
            if (_armAxis != null && _armAxis.IsRun) _armAxis.StopPositionOperation();
            JetAxisBase _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            if (_rotationAxis != null && _rotationAxis.IsRun) _rotationAxis.StopPositionOperation();

        }
        #endregion

        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        public bool OnTimer()
        {
            if (_status == RState.Running)
            {
                if (_currentOperation != SrdCommonOperation.None)
                {
                    IRoutine routine = GetCurrentRoutine(_currentOperation);
                    if (routine != null)
                    {
                        CheckRoutineState(routine, _currentOperation);
                    }
                    else
                    {
                        EndOperation();
                    }
                }
            }
            //将公有的数据赋值于对象的数值
            if (_totalSRDDevice == null)
            {
                _totalSRDDevice = DEVICE.GetDevice<TotalSRDDevice>("SRD");
            }
            if (_totalSRDDevice != null)
            {
                CommonData.FluidContainment = _totalSRDDevice.FluidContainment;
                CommonData.WaterPressure = _totalSRDDevice.WaterPressure;
            }
            return true;
        }
        /// <summary>
        /// 获取当前操作对应的Routine
        /// </summary>
        /// <param name="currentOperation"></param>
        /// <returns></returns>
        private IRoutine GetCurrentRoutine(SrdCommonOperation currentOperation)
        {
            switch (currentOperation)
            {
                case SrdCommonOperation.DoorClose:
                case SrdCommonOperation.DoorOpen:
                    return _doorCloseRoutine;
                case SrdCommonOperation.ChuckVacuumOn:
                case SrdCommonOperation.ChuckVacuumOff:
                    return _chuckVacuumRoutine;
                default:
                    return null;
            }
        }
        /// <summary>
        /// 检验Routine状态
        /// </summary>
        /// <param name="routine"></param>
        /// <param name="currentOperation"></param>
        private void CheckRoutineState(IRoutine routine, SrdCommonOperation currentOperation)
        {
            RState state = routine.Monitor();
            if (state == RState.End)
            {
                EndOperation();
            }
            else if (state == RState.Failed || state == RState.Timeout)
            {
                LOG.WriteLog(eEvent.ERR_SRD, $"{Module}", $"{currentOperation} error");
                EndOperation();
            }
        }
        /// <summary>
        /// 结束操作
        /// </summary>
        private void EndOperation()
        {
            _status = RState.End;
            _currentOperation = SrdCommonOperation.None;
        }

        #region 设备接口
        /// <summary>
        /// 监控
        /// </summary>
        public void Monitor()
        {

        }

        public void Reset()
        {
        }

        public void Terminate()
        {
        }
        #endregion
    }
}