Kepler-Release/Venus/Venus_RT/Devices/TM/HongHuDETM.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.TMs;
using System;
using IoMfc = Venus_RT.Devices.IODevices.IoMfc;
using IoPressureMeter = Venus_RT.Devices.IODevices.IoPressureMeter;
using Venus_Core;
using Venus_RT.Modules;
using Venus_RT.Devices.IODevices;

namespace Venus_RT.Devices.TM
{
    public class HongHuDETM : TMBase
    {
        /// <summary>
        /// 针对VenusDE六边形设计
        /// </summary>
        #region io 信号抽象
        //控制阀信号
        private readonly IoValve _TMFastPumpValve;
        private readonly IoValve _TMSoftPumpValve;
        private readonly IoValve _VCEASoftPumpValve;
        private readonly IoValve _VCEAFastPumpValve;
        private readonly IoValve _VCEBSoftPumpValve;
        private readonly IoValve _VCEBFastPumpValve;
        private readonly IoValve _TMFastVentValve;
        private readonly IoValve _TMSoftVentValve;
        private readonly IoValve _VCEASoftVentValve;
        private readonly IoValve _VCEAFastVentValve;
        private readonly IoValve _VCEBSoftVentValve;
        private readonly IoValve _VCEBFastVentValve;

        //判断信号
        //private readonly IoSensor _VCEASlitDoorOpenEnable;
        //private readonly IoSensor _VCEBSlitDoorOpenEnable;
        //private readonly IoSensor _PMASlitDoorOpenEnable;
        //private readonly IoSensor _PMBSlitDoorOpenEnable;
        //private readonly IoSensor _PMCSlitDoorOpenEnable;
        //private readonly IoSensor _PMDSlitDoorOpenEnable;
        //private readonly IoSensor _VCEASlitDoorCloseEnable;
        //private readonly IoSensor _VCEBSlitDoorCloseEnable;
        //private readonly IoSensor _PMASlitDoorCloseEnable;
        //private readonly IoSensor _PMBSlitDoorCloseEnable;
        //private readonly IoSensor _PMCSlitDoorCloseEnable;
        //private readonly IoSensor _PMDSlitDoorCloseEnable;
        //private readonly IoSensor _TMExtendVCEAEnable;
        //private readonly IoSensor _TMExtendVCEBEnable;
        //private readonly IoSensor _TMExtendPMAEnable;
        //private readonly IoSensor _TMExtendPMBEnable;
        //private readonly IoSensor _TMExtendPMCEnable;
        //private readonly IoSensor _TMExtendPMDEnable;
        private readonly IoSensor _VCEAATMSensor;
        private readonly IoSensor _VCEBATMSensor;
        private readonly IoSensor _TMATMSensor;
        private readonly IoSensor _VCEACasSensor;
        private readonly IoSensor _VCEALOCKEDSensor;
        private readonly IoSensor _VCEBCasSensor;
        private readonly IoSensor _VCEBLOCKEDSensor;
        private readonly IoSensor _VCEAProtrusionSensor;
        private readonly IoSensor _VCEBProtrusionSensor;
        private readonly IoSensor _ROBOTNotExtendVCEA;
        private readonly IoSensor _ROBOTNotExtendVCEB;

        //控制门信号
        private readonly IoCylinder _VCEASlitDoor;
        private readonly IoCylinder _VCEBSlitDoor;
        private readonly IoCylinder _PMASlitDoor;
        private readonly IoCylinder _PMBSlitDoor;
        private readonly IoCylinder _PMCSlitDoor;
        private readonly IoCylinder _PMDSlitDoor;

        private readonly IoMfc _TMMfc;

        private readonly IoPressureMeter _TMPressure;
        //private readonly IoPressureMeter _TMPiplinePressure;
        private readonly IoPressureMeter _VCEAPressure;
        private readonly IoPressureMeter _VCEBPressure;
        //private readonly IoPressureMeter _VCEPiplinePressure;
        private readonly PumpBase _TMPump;
        private readonly PumpBase _VCEPump;

        private readonly IoSignalTower _SignalTower;

        //控压
        private readonly IoHongHuControl _PressureControl;

        //安装的module
        private string _allInstalledModules { get { return SC.GetStringValue("System.InstalledModules").ToString(); } }
        private double TMATMTargetPressure;
        private double TMVACTargetPressure;
        private double VCEAATMTargetPressure;
        private double VCEBATMTargetPressure;
        private double VCEAVACTargetPressure;
        private double VCEBVACTargetPressure;

        #endregion

        #region 暴露变量
        public override VentStatus VentStatus => _ventStatus;
        private VentStatus _ventStatus = VentStatus.Idle;
        public override bool IsPressureControl
        {
            get
            {
                if (_PressureControl != null)
                    return _PressureControl.IsProcessControl;
                return false;
            }
        }

        public override bool VCEACassPresent => _VCEACasSensor.Value;
        public override bool VCEBCassPresent => _VCEBCasSensor.Value;
        public override bool VCEALOCKED => _VCEALOCKEDSensor.Value;
        public override bool VCEBLOCKED => _VCEBLOCKEDSensor.Value;

        public override bool VCEAProtrusion => _VCEAProtrusionSensor.Value;
        public override bool VCEBProtrusion => _VCEBProtrusionSensor.Value;

        //ATM VAC信号
        public override bool IsTMATM => _TMATMSensor.Value && _TMPressure.Value >= TMATMTargetPressure;
        public override bool IsVCEAATM => _VCEAATMSensor.Value && _VCEAPressure.Value >= VCEAATMTargetPressure;
        public override bool IsVCEBATM => _VCEBATMSensor.Value && _VCEBPressure.Value >= VCEBATMTargetPressure;
        public override bool IsTMVAC => _TMPressure.Value <= TMVACTargetPressure;
        public override bool IsVCEAVAC => _VCEAPressure.Value <= VCEAVACTargetPressure;
        public override bool IsVCEBVAC => _VCEBPressure.Value <= VCEAVACTargetPressure;
        public bool? IsTMPumpRunning => _TMPump?.IsRunning;
        public bool? IsVCEPumpRunning => _VCEPump?.IsRunning;
        //valve开关状态
        public override bool IsTMFastPumpOpen => _TMFastPumpValve.Status;
        public override bool IsTMSoftPumpOpen => _TMSoftPumpValve.Status;
        public override bool IsTMFastVentOpen => _TMFastVentValve.Status;
        public override bool IsTMSoftVentOpen => _TMSoftVentValve.Status;
        public override bool IsVCEAFastPumpOpen => _VCEAFastPumpValve.Status;
        public override bool IsVCEBFastPumpOpen => _VCEBFastPumpValve.Status;
        public override bool IsVCEASoftPumpOpen => _VCEASoftPumpValve.Status;
        public override bool IsVCEBSoftPumpOpen => _VCEBSoftPumpValve.Status;
        public override bool IsVCEAFastVentOpen => _VCEAFastVentValve.Status;
        public override bool IsVCEBFastVentOpen => _VCEBFastVentValve.Status;
        public override bool IsVCEASoftVentOpen => _VCEASoftVentValve.Status;
        public override bool IsVCEBSoftVentOpen => _VCEBSoftVentValve.Status;


        public override bool IsTMVentValveOpen => IsTMFastVentOpen && IsTMSoftVentOpen;
        public override bool IsVCEAVentValveOpen => IsVCEAFastVentOpen && IsVCEASoftVentOpen;
        public override bool IsVCEBVentValveOpen => IsVCEBFastVentOpen && IsVCEBSoftVentOpen;


        //SlitDoor
        public override bool VCEASlitDoorClosed => _VCEASlitDoor.State == CylinderState.Close;
        public override bool VCEBSlitDoorClosed => _VCEBSlitDoor.State == CylinderState.Close;
        public override bool PMASlitDoorClosed
        {
            get
            {
                if (_allInstalledModules.Contains("PMA"))
                    return _PMASlitDoor.State == CylinderState.Close;
                else
                    return false;
            }
        }
        public override bool PMBSlitDoorClosed
        {
            get
            {
                if (_allInstalledModules.Contains("PMB"))
                    return _PMBSlitDoor.State == CylinderState.Close;
                else
                    return false;
            }
        }
        public override bool PMCSlitDoorClosed
        {
            get
            {
                if (_allInstalledModules.Contains("PMC"))
                    return _PMCSlitDoor.State == CylinderState.Close;
                else
                    return false;
            }
        }

        public override bool PMDSlitDoorClosed
        {
            get
            {
                if (_allInstalledModules.Contains("PMD"))
                    return _PMDSlitDoor.State == CylinderState.Close;
                else
                    return false;
            }
        }

        public bool VCEASlitDoorOpen => _VCEASlitDoor.State == CylinderState.Open;
        public bool VCEBSlitDoorOpen => _VCEBSlitDoor.State == CylinderState.Open;
        public bool PMASlitDoorOpen
        {
            get
            {
                if (_allInstalledModules.Contains("PMA"))
                    return _PMASlitDoor.State == CylinderState.Open;
                else
                    return false;
            }
        }
        public bool PMBSlitDoorOpen
        {
            get
            {
                if (_allInstalledModules.Contains("PMB"))
                    return _PMBSlitDoor.State == CylinderState.Open;
                else
                    return false;
            }
        }
        public bool PMCSlitDoorOpen
        {
            get
            {
                if (_allInstalledModules.Contains("PMC"))
                    return _PMCSlitDoor.State == CylinderState.Open;
                else
                    return false;
            }
        }

        public bool PMDSlitDoorOpen
        {
            get
            {
                if (_allInstalledModules.Contains("PMD"))
                    return _PMDSlitDoor.State == CylinderState.Open;
                else
                    return false;
            }
        }

        public override bool VCESlitDoorClosed(ModuleName vcename)
        {
            switch (vcename)
            {
                case ModuleName.VCEA:
                    return _VCEASlitDoor.State == CylinderState.Close;
                case ModuleName.VCEB:
                    return _VCEBSlitDoor.State == CylinderState.Close;
                default:
                    return false;
            }
        }
        

        public override bool AllPMSlitDoorClosed
        {
            get
            {
                bool PMAFlag = true;
                bool PMBFlag = true;
                bool PMCFlag = true;
                bool PMDFlag = true;
                if (_allInstalledModules.Contains("PMA"))
                    PMAFlag = PMASlitDoorClosed;
                if (_allInstalledModules.Contains("PMB"))
                    PMBFlag = PMBSlitDoorClosed;
                if (_allInstalledModules.Contains("PMC"))
                    PMCFlag = PMCSlitDoorClosed;
                if (_allInstalledModules.Contains("PMD"))
                    PMDFlag = PMDSlitDoorClosed;
                if (PMAFlag && PMBFlag && PMCFlag&&PMDFlag)
                    return true;
                else
                    return false;
            }
        }

        //public bool VCEASlitDoorOpenEnable => _VCEASlitDoorOpenEnable.Value;
        //public bool VCEBSlitDoorOpenEnable => _VCEBSlitDoorOpenEnable.Value;
        //public bool PMASlitDoorOpenEnable => _PMASlitDoorOpenEnable.Value;
        //public bool PMBSlitDoorOpenEnable => _PMBSlitDoorOpenEnable.Value;
        //public bool PMCSlitDoorOpenEnable => _PMCSlitDoorOpenEnable.Value;
        //public bool PMDSlitDoorOpenEnable => _PMDSlitDoorOpenEnable.Value;
        //public bool VCEASlitDoorCloseEnable => _VCEASlitDoorCloseEnable.Value;
        //public bool VCEBSlitDoorCloseEnable => _VCEBSlitDoorCloseEnable.Value;
        //public bool PMASlitDoorCloseEnable => _PMASlitDoorCloseEnable.Value;
        //public bool PMBSlitDoorCloseEnable => _PMBSlitDoorCloseEnable.Value;
        //public bool PMCSlitDoorCloseEnable => _PMCSlitDoorCloseEnable.Value;
        //public bool PMDSlitDoorCloseEnable => _PMDSlitDoorCloseEnable.Value;
        //Robot动作
        //public bool TMExtendVCEEnable => _TMExtendVCEEnable.Value;
        //public bool TMExtendPMAEnable => _TMExtendPMAEnable.Value;
        //public bool TMExtendPMBEnable => _TMExtendPMBEnable.Value;
        //public bool TMExtendPMCEnable => _TMExtendPMCEnable.Value;
        //public bool TMExtendPMDEnable => _TMExtendPMDEnable.Value;

        public override bool RobotNotExtendVCEA => _ROBOTNotExtendVCEA.Value;
        public override bool RobotNotExtendVCEB => _ROBOTNotExtendVCEB.Value;

        public override double TMPressure => _TMPressure.Value;
        public override double VCEAPressure => _VCEAPressure.Value;
        public override double VCEBPressure => _VCEBPressure.Value;


        public override PumpState PumpingState => _PumpingState;

        PumpState _PumpingState = PumpState.Idle;

        #endregion

        public HongHuDETM() : base(ModuleName.TM.ToString())
        {
            Module = ModuleName.TM.ToString();
            TMATMTargetPressure = SC.GetValue<double>($"{Module}.ATMTargetPressure");
            TMVACTargetPressure = SC.GetValue<double>($"{Module}.VACTargetPressure");
            VCEAATMTargetPressure = SC.GetValue<double>($"VCEA.ATMTargetPressure");
            VCEAVACTargetPressure = SC.GetValue<double>($"VCEA.VACTargetPressure");
            VCEBATMTargetPressure = SC.GetValue<double>($"VCEB.ATMTargetPressure");
            VCEBVACTargetPressure = SC.GetValue<double>($"VCEB.VACTargetPressure");
            _TMFastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMFastPumpValve}");
            _TMSoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMSoftPumpValve}");
            _VCEASoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEASoftPumpValve}");
            _VCEBSoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEBSoftPumpValve}");
            _VCEAFastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEAFastPumpValve}");
            _VCEBFastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEBFastPumpValve}");
            _TMFastVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMFastVentValve}");
            _TMSoftVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMSoftVentValve}");
            _VCEASoftVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEASoftVentValve}");
            _VCEBSoftVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEBSoftVentValve}");
            _VCEAFastVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEAFastVentValve}");
            _VCEBFastVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEBFastVentValve}");

            //_VCEASlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEASlitDoorOpenEnable}");
            //_VCEBSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEBSlitDoorOpenEnable}");
            //_PMASlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMASlitDoorOpenEnable}");
            //_PMBSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMBSlitDoorOpenEnable}");
            //_PMCSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMCSlitDoorOpenEnable}");
            //_PMDSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMDSlitDoorOpenEnable}");
            //
            //_VCEASlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEASlitDoorCloseEnable}");
            //_VCEBSlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEBSlitDoorCloseEnable}");
            //_PMASlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMASlitDoorCloseEnable}");
            //_PMBSlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMBSlitDoorCloseEnable}");

            _TMATMSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.TMATMSensor}");
            _VCEAATMSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEAATMSensor}");
            _VCEBATMSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEBATMSensor}");

            _VCEACasSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEACasSensor");
            _VCEALOCKEDSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEALOCKEDSensor");
            _VCEBCasSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEBCasSensor");
            _VCEBLOCKEDSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEBLOCKEDSensor");
            _VCEAProtrusionSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEAProtrusionSensor");
            _VCEBProtrusionSensor = DEVICE.GetDevice<IoSensor>($"{Module}.VCEBProtrusionSensor");
            _ROBOTNotExtendVCEA = DEVICE.GetDevice<IoSensor>($"{Module}.ROBOTNotExtendVCEA");
            _ROBOTNotExtendVCEB = DEVICE.GetDevice<IoSensor>($"{Module}.ROBOTNotExtendVCEB");


            _VCEASlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.VCEASlitDoor}");
            _VCEBSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.VCEBSlitDoor}");
            _PMASlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.PMASlitDoor}");
            _PMBSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.PMBSlitDoor}");
            if (_allInstalledModules.Contains("PMC"))
            {
                //_PMCSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMCSlitDoorOpenEnable}");
                _PMCSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.PMCSlitDoor}");
                //_PMCSlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMCSlitDoorCloseEnable}");
            }

            if (_allInstalledModules.Contains("PMD"))
            {
                //_PMDSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMDSlitDoorOpenEnable}");
                _PMDSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.PMDSlitDoor}");
                //_PMDSlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMDSlitDoorCloseEnable}");
            }

            _TMMfc = DEVICE.GetDevice<IoMfc>($"{Module}.TM_MFC1");
            _TMPressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.TMPressure");
            //_TMPiplinePressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.TMPipelinePressure");
            _VCEAPressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.VCEAPressure");
            _VCEBPressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.VCEBPressure");

            if (SC.GetValue<int>($"{Module}.DryPump.CommunicationType") == (int)CommunicationType.RS232)
            {
                if (SC.GetValue<int>($"{Module}.DryPump.MFG") == (int)DryPumpMFG.SKY)
                {
                    _TMPump = DEVICE.GetDevice<SkyPump>($"{Module}.{VenusDevice.MainPump}");
                }
                else if (SC.GetValue<int>($"{Module}.DryPump.MFG") == (int)DryPumpMFG.Edwards)
                {
                    _TMPump = DEVICE.GetDevice<EdwardsPump>($"{Module}.{VenusDevice.MainPump}");
                }
            }

            if (SC.GetValue<int>($"VCEA.DryPump.CommunicationType") == (int)CommunicationType.RS232)
            {
                if (SC.GetValue<int>($"VCEA.DryPump.MFG") == (int)DryPumpMFG.SKY)
                {
                    _VCEPump = DEVICE.GetDevice<SkyPump>($"VCEA.{VenusDevice.MainPump}");
                }
                else if (SC.GetValue<int>($"VCEA.DryPump.MFG") == (int)DryPumpMFG.Edwards)
                {
                    _VCEPump = DEVICE.GetDevice<EdwardsPump>($"VCEA.{VenusDevice.MainPump}");
                }
            }


            _SignalTower = DEVICE.GetDevice<IoSignalTower>($"{Module}.SignalTower");
            _PressureControl = DEVICE.GetDevice<IoHongHuControl>($"{Module}.PressureControl");

            DATA.Subscribe("System.SignalTower.DeviceData", () => _SignalTower.DeviceData);
            DATA.Subscribe($"{Module}.VCEASlitDoorClosed", () => VCEASlitDoorClosed);
            DATA.Subscribe($"{Module}.VCEBSlitDoorClosed", () => VCEBSlitDoorClosed);
            DATA.Subscribe($"{Module}.PMASlitDoorClosed", () => PMASlitDoorClosed);
            DATA.Subscribe($"{Module}.PMBSlitDoorClosed", () => PMBSlitDoorClosed);
            DATA.Subscribe($"{Module}.PMCSlitDoorClosed", () => PMCSlitDoorClosed);
            DATA.Subscribe($"{Module}.PMDSlitDoorClosed", () => PMDSlitDoorClosed);
            DATA.Subscribe($"{Module}.PumpIsRunning", () => IsTMPumpRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"VCEA.PumpIsRunning", () => IsVCEPumpRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TMIsATM", () => IsTMATM);
            DATA.Subscribe($"{Module}.VCEAIsATM", () => IsVCEAATM);
            DATA.Subscribe($"{Module}.VCEBIsATM", () => IsVCEBATM);

            OP.Subscribe($"{Module}.ControlPump", (cmd, args) =>
            {
                _TMPump.SetPumpOnOff((bool)args[0]);
                return true;
            });


            OP.Subscribe($"VCEA.ControlPump", (cmd, args) =>
            {
                _VCEPump.SetPumpOnOff((bool)args[0]);
                return true;
            });

            OP.Subscribe($"{Module}.SetSlitDoor", (cmd, args) =>
            {
                var module = (ModuleName)Enum.Parse(typeof(ModuleName), args[0].ToString());
                return TurnSlitDoor(module, (bool)args[1]);
            });
        }

        #region IO控制方法
        public override bool TryGetVent(ModuleName mod)
        {
            //Self
            if ((mod == ModuleName.VCEA && _ventStatus == VentStatus.VCEAVenting) || 
                (mod == ModuleName.VCEB && _ventStatus == VentStatus.VCEBVenting)||
                (mod == ModuleName.TM && _ventStatus == VentStatus.TMVenting))
                return true;

            //Idle
            if (mod == ModuleName.VCEA && _ventStatus == VentStatus.Idle)
            {
                _ventStatus = VentStatus.VCEAVenting;
                return true;
            }
            if (mod == ModuleName.VCEB && _ventStatus == VentStatus.Idle)
            {
                _ventStatus = VentStatus.VCEBVenting;
                return true;
            }
            if (mod == ModuleName.TM && _ventStatus == VentStatus.Idle)
            {
                _ventStatus = VentStatus.TMVenting;
                return true;
            }
            LOG.Write(eEvent.WARN_DEFAULT_WARN, mod, $"cannot Vent {mod}，as {_ventStatus}！");
            //locked
            return false;
        }

        

        public override void ReleaseVent(ModuleName Module)
        {
            if ((Module == ModuleName.VCEA && _ventStatus == VentStatus.VCEAVenting) || 
                (Module == ModuleName.VCEB && _ventStatus == VentStatus.VCEBVenting) ||
                (Module == ModuleName.TM && _ventStatus == VentStatus.TMVenting))
                _ventStatus = VentStatus.Idle;
        }
        public override void PressureControl(bool bCtrl)
        {
            if (!_PressureControl.IsProcessControl && bCtrl)
            {
                _PressureControl.SetMode(true);
            }

            if (_PressureControl.IsProcessControl && !bCtrl)
            {
                _PressureControl.SetMode(false);
            }
        }

        //slitdoor
        //2023/11/1 增加两边压差比较
        public override bool TurnSlitDoor(ModuleName mod, bool bOn)
        {
            double MaxPressureDifference = SC.GetValue<double>("System.PMTMMaxPressureDifference");
            switch (mod)
            {
                case ModuleName.VCEA:
                    if (bOn && IsVCEAATM && IsTMATM)
                    {
                        LOG.Write(eEvent.INFO_TM, ModuleName.TM, $"open door without Pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEAPressure.Value}");

                        return _VCEASlitDoor.SetCylinder(bOn, out _);
                    }
                    if (bOn && Math.Abs(_TMPressure.Value - _VCEAPressure.Value) > MaxPressureDifference)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, $"cannot open door cause pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEAPressure.Value}");
                        return false;
                    }
                    return _VCEASlitDoor.SetCylinder(bOn, out _);
                case ModuleName.VCEB:
                    if (bOn && IsVCEBATM && IsTMATM)
                    {
                        LOG.Write(eEvent.INFO_TM, ModuleName.TM, $"open door without Pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEBPressure.Value}");

                        return _VCEBSlitDoor.SetCylinder(bOn, out _);
                    }
                    if (bOn && Math.Abs(_TMPressure.Value - _VCEBPressure.Value) > MaxPressureDifference)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, $"cannot open door cause pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEBPressure.Value}");
                        return false;
                    }
                    return _VCEBSlitDoor.SetCylinder(bOn, out _);
                case ModuleName.PMA:
                    if (bOn && Singleton<RouteManager>.Instance.PMA.IsAtm && IsTMATM)
                        return _PMASlitDoor.SetCylinder(bOn, out _);
                    if (bOn && !CanOpenSlitDoor(mod, MaxPressureDifference))
                        return false;
                    return _PMASlitDoor.SetCylinder(bOn, out _);
                case ModuleName.PMB:
                    if (bOn && Singleton<RouteManager>.Instance.PMB.IsAtm && IsTMATM)
                        return _PMBSlitDoor.SetCylinder(bOn, out _);
                    if (bOn && !CanOpenSlitDoor(mod, MaxPressureDifference))
                        return false;
                    return _PMBSlitDoor.SetCylinder(bOn, out _);
                case ModuleName.PMC:
                    if (bOn && Singleton<RouteManager>.Instance.PMC.IsAtm && IsTMATM)
                        return _PMCSlitDoor.SetCylinder(bOn, out _);
                    if (bOn && !CanOpenSlitDoor(mod, MaxPressureDifference))
                        return false;
                    return _PMCSlitDoor.SetCylinder(bOn, out _);
                case ModuleName.PMD:
                    if (bOn && Singleton<RouteManager>.Instance.PMD.IsAtm && IsTMATM)
                        return _PMDSlitDoor.SetCylinder(bOn, out _);
                    if (bOn && !CanOpenSlitDoor(mod, MaxPressureDifference))
                        return false;
                    return _PMDSlitDoor.SetCylinder(bOn, out _);
            }
            return false;
        }

        //valve
        public override void TurnFastPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMFastPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEA:
                    _VCEAFastPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEB:
                    _VCEBFastPumpValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public override void TurnSoftPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMSoftPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEA:
                    _VCEASoftPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEB:
                    _VCEBSoftPumpValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public override void TurnFastVentValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMFastVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEA:
                    _VCEAFastVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEB:
                    _VCEBFastVentValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public override void TurnSoftVentValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMSoftVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEA:
                    _VCEASoftVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCEB:
                    _VCEBSoftVentValve.TurnValve(bOn, out string _);
                    break;
            }
        }
        public override bool CloseAllSlitDoor()
        {
            TurnSlitDoor(ModuleName.VCEA, false);
            TurnSlitDoor(ModuleName.VCEB, false);
            if (_allInstalledModules.Contains("PMA"))
                TurnSlitDoor(ModuleName.PMA, false);
            if (_allInstalledModules.Contains("PMB"))
                TurnSlitDoor(ModuleName.PMB, false);
            if (_allInstalledModules.Contains("PMC"))
                TurnSlitDoor(ModuleName.PMC, false);
            if (_allInstalledModules.Contains("PMD"))
                TurnSlitDoor(ModuleName.PMD, false);
            return true;
        }
        public override void HomeVceSlitDoor()
        {
            //由SlitDoor的状态对其下发同样的指令
            if (VCEASlitDoorClosed == true)
                TurnSlitDoor(ModuleName.VCEA, false);
            else
                TurnSlitDoor(ModuleName.VCEA, true);

            if (VCEBSlitDoorClosed == true)
                TurnSlitDoor(ModuleName.VCEB, false);
            else
                TurnSlitDoor(ModuleName.VCEB, true);
        }

        public override void CloseModuleAllValves(ModuleName module)
        {
            TurnFastPumpValve(module, false);
            TurnSoftPumpValve(module, false);
            TurnFastVentValve(module, false);
            TurnSoftVentValve(module, false);
        }

        public override void CloseVentValve()
        {
            _TMSoftVentValve.TurnValve(false, out _);
            _TMFastVentValve.TurnValve(false, out _);
            _VCEASoftVentValve.TurnValve(false, out _);
            _VCEBSoftVentValve.TurnValve(false, out _);
            _VCEAFastVentValve.TurnValve(false, out _);
            _VCEBFastVentValve.TurnValve(false, out _);
        }

        public override bool CheckSlitValveOpen(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.VCEA:
                    return VCEASlitDoorOpen;
                case ModuleName.VCEB:
                    return VCEBSlitDoorOpen;
                case ModuleName.PMA:
                    return PMASlitDoorOpen;
                case ModuleName.PMB:
                    return PMBSlitDoorOpen;
                case ModuleName.PMC:
                    return PMCSlitDoorOpen;
                case ModuleName.PMD:
                    return PMDSlitDoorOpen;
            }
            return false;
        }

        public override bool CheckSlitValveClose(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.VCEA:
                    return VCEASlitDoorClosed;
                case ModuleName.VCEB:
                    return VCEBSlitDoorClosed;
                case ModuleName.PMA:
                    return PMASlitDoorClosed;
                case ModuleName.PMB:
                    return PMBSlitDoorClosed;
                case ModuleName.PMC:
                    return PMCSlitDoorClosed;
                case ModuleName.PMD:
                    return PMDSlitDoorClosed;
            }
            return false;
        }

        public override bool CheckPumpValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return !IsTMFastPumpOpen && !IsTMSoftPumpOpen;
                case ModuleName.VCEA:
                    return !IsVCEAFastPumpOpen && !IsVCEASoftPumpOpen;
                case ModuleName.VCEB:
                    return !IsVCEBFastPumpOpen && !IsVCEBSoftPumpOpen;
            }
            return true;
        }

        public override bool CheckVentValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    if (IsTMVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Vent Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.VCEA:
                    if (IsVCEAVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.VCEA, "VCEA Vent Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.VCEB:
                    if (IsVCEBVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.VCEB, "VCEB Vent Valve not closed");
                        return false;
                    }
                    break;
            }

            return true;

        }

        public override void SetTMFlow(int flowValue)
        {
            _TMMfc.SetPoint = (flowValue);
        }

        public override double GetModulePressure(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return TMPressure;
                case ModuleName.VCEA:
                    return VCEAPressure;
                case ModuleName.VCEB:
                    return VCEBPressure;
            }

            return 0.0;
        }

        public override bool TryGetPump(ModuleName mod)
        {
            if (mod == ModuleName.TM)
                return true;

            //Self
            if ((mod == ModuleName.VCEA && _PumpingState == PumpState.VCEAUsing) || (mod == ModuleName.VCEB && _PumpingState == PumpState.VCEBUsing))
                return true;

            //Idle

            if (mod == ModuleName.VCEA && !IsVCEAFastPumpOpen && !IsVCEASoftPumpOpen && _PumpingState == PumpState.Idle)
            {
                _PumpingState = PumpState.VCEAUsing;
                return true;
            }
            if (mod == ModuleName.VCEB && !IsVCEBFastPumpOpen && !IsVCEBSoftPumpOpen && _PumpingState == PumpState.Idle)
            {
                _PumpingState = PumpState.VCEBUsing;
                return true;
            }
            LOG.Write(eEvent.WARN_DEFAULT_WARN, mod, "无法打开，另一个泵正在用！");
            //locked
            return false;
        }

        public override void ReleasePump(ModuleName Module)
        {
            //release pump (must do it by user)
            if ((Module == ModuleName.VCEA && _PumpingState == PumpState.VCEAUsing)|| (Module == ModuleName.VCEB && _PumpingState == PumpState.VCEBUsing))
                _PumpingState = PumpState.Idle;
        }



        #endregion

        #region 工具方法
        private bool CanOpenSlitDoor(ModuleName mod, double MaxPressureDifference)
        {
            if (Singleton<RouteManager>.Instance.GetPM(mod) == null || RouteManager.IsATMMode)
                return true;
            else
            {
                double PMPressure = Singleton<RouteManager>.Instance.GetPM(mod).ChamberPressure;
                if (Math.Abs(_TMPressure.Value - PMPressure) <= MaxPressureDifference || (Singleton<RouteManager>.Instance.GetPM(mod).IsAtm && IsTMATM))
                {
                    return true;
                }
                else
                {
                    LOG.Write(eEvent.ERR_TM, ModuleName.TM, $"cannot open door cause pressure, TM Pressure:{_TMPressure.Value} and {mod} pressure:{PMPressure}");
                    return false;
                }
            }

        }

        private double mbar2mtorrConvert(double mbar) => mbar * 0.75 * 1000;

        #endregion

    }
}