Kepler-Release/Venus/Venus_RT/Devices/TM/HongHuTM.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 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.TM;
using Venus_RT.Devices.IODevices;

namespace Venus_RT.Devices
{
    public class HongHuTM : TMBase
    {
        /// <summary>
        /// 针对VenusSE设计
        /// </summary>
        #region io 信号抽象
        //控制阀信号
        private readonly IoValve _TMFastPumpValve;
        private readonly IoValve _TMSoftPumpValve;
        private readonly IoValve _VCESoftPumpValve;
        private readonly IoValve _VCEFastPumpValve;
        private readonly IoValve _TMFastVentValve;
        private readonly IoValve _TMSoftVentValve;
        private readonly IoValve _VCESoftVentValve;
        private readonly IoValve _VCEFastVentValve;

        //判断信号
        private readonly IoSensor _VCESlitDoorOpenEnable;
        private readonly IoSensor _PMASlitDoorOpenEnable;
        private readonly IoSensor _PMBSlitDoorOpenEnable;
        private readonly IoSensor _PMCSlitDoorOpenEnable;
        private readonly IoSensor _VCESlitDoorCloseEnable;
        private readonly IoSensor _PMASlitDoorCloseEnable;
        private readonly IoSensor _PMBSlitDoorCloseEnable;
        private readonly IoSensor _PMCSlitDoorCloseEnable;
        private readonly IoSensor _TMExtendVCEEnable;
        private readonly IoSensor _TMExtendPMAEnable;
        private readonly IoSensor _TMExtendPMBEnable;
        private readonly IoSensor _TMExtendPMCEnable;
        private readonly IoSensor _TMVACSensor;
        private readonly IoSensor _VCEVACSensor;
        private readonly IoSensor _VCEATMSensor;
        private readonly IoSensor _TMATMSensor;

        //控制门信号
        private readonly IoCylinder _VCESlitDoor;
        private readonly IoCylinder _PMASlitDoor;
        private readonly IoCylinder _PMBSlitDoor;
        private readonly IoCylinder _PMCSlitDoor;

        private readonly IoMfc _TMMfc;

        private readonly IoPressureMeter _TMPressure;
        //private readonly IoPressureMeter _TMPiplinePressure;
        private readonly IoPressureMeter _VCEPressure;
        //private readonly IoPressureMeter _VCEPiplinePressure;
        private readonly PumpBase _TMPump;

        
        private readonly IoHongHuControl _PressureControl;
        //控压


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

        #endregion

        #region 暴露变量
        public override bool IsPressureControl
        {
            get 
            {
                if (_PressureControl != null)
                    return _PressureControl.IsProcessControl;
                return false;
            }
        }
        //ATM VAC信号
        public override bool IsTMATM => _TMATMSensor.Value && _TMPressure.Value >= TMATMTargetPressure;
        public override bool IsVCEATM => _VCEATMSensor.Value &&_VCEPressure.Value >= VCEATMTargetPressure;
        public override bool IsTMVAC => _TMVACSensor.Value || _TMPressure.Value <= TMVACTargetPressure;
        public override bool IsVCEVAC => _VCEVACSensor.Value || _VCEPressure.Value <= VCEVACTargetPressure;
        public bool? IsTMPumpRunning => _TMPump?.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 bool IsVCEFastPumpOpen => _VCEFastPumpValve.Status;
        public bool IsVCESoftPumpOpen => _VCESoftPumpValve.Status;
        public bool IsVCEFastVentOpen => _VCEFastVentValve.Status;
        public bool IsVCESoftVentOpen => _VCESoftVentValve.Status;


        public override bool IsTMVentValveOpen => IsTMFastVentOpen && IsTMSoftVentOpen;
        public bool IsVCEVentValveOpen => IsVCEFastVentOpen && IsVCESoftVentOpen;


        //SlitDoor
        public override bool VCESlitDoorClosed(ModuleName vcename) => _VCESlitDoor.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 bool VCESlitDoorOpen => _VCESlitDoor.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 override bool AllPMSlitDoorClosed
        {
            get
            {
                bool PMAFlag = true;
                bool PMBFlag = true;
                bool PMCFlag = true;
                if (_allInstalledModules.Contains("PMA"))
                    PMAFlag = PMASlitDoorClosed;
                if (_allInstalledModules.Contains("PMB"))
                    PMBFlag = PMBSlitDoorClosed;
                if (_allInstalledModules.Contains("PMC"))
                    PMCFlag = PMCSlitDoorClosed;
                if (PMAFlag && PMBFlag && PMCFlag)
                    return true;
                else
                    return false;
            }
        }

        public bool VCESlitDoorOpenEnable => _VCESlitDoorOpenEnable.Value;
        public bool PMASlitDoorOpenEnable => _PMASlitDoorOpenEnable.Value;
        public bool PMBSlitDoorOpenEnable => _PMBSlitDoorOpenEnable.Value;
        public bool PMCSlitDoorOpenEnable => _PMCSlitDoorOpenEnable.Value;
        public bool VCESlitDoorCloseEnable => _VCESlitDoorCloseEnable.Value;
        public bool PMASlitDoorCloseEnable => _PMASlitDoorCloseEnable.Value;
        public bool PMBSlitDoorCloseEnable => _PMBSlitDoorCloseEnable.Value;
        public bool PMCSlitDoorCloseEnable => _PMCSlitDoorCloseEnable.Value;
        //Robot动作
        public bool TMExtendVCEEnable => _TMExtendVCEEnable.Value;
        public bool TMExtendPMAEnable => _TMExtendPMAEnable.Value;
        public bool TMExtendPMBEnable => _TMExtendPMBEnable.Value;
        public bool TMExtendPMCEnable => _TMExtendPMCEnable.Value;

        public override double TMPressure => _TMPressure.Value;
        public override double VCEPressure => _VCEPressure.Value;


        public override PumpState PumpingState => _PumpingState;

        PumpState _PumpingState = PumpState.Idle;

        #endregion

        public HongHuTM() : base(ModuleName.SETM.ToString())
        {
            TMATMTargetPressure = SC.GetValue<double>($"SETM.ATMTargetPressure");
            TMVACTargetPressure = SC.GetValue<double>($"SETM.VACTargetPressure");
            VCEATMTargetPressure = SC.GetValue<double>($"VCE1.ATMTargetPressure");
            VCEVACTargetPressure = SC.GetValue<double>($"VCE1.VACTargetPressure");
            Module = ModuleName.SETM.ToString();
            _TMFastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMFastPumpValve}");
            _TMSoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMSoftPumpValve}");
            _VCESoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCESoftPumpValve}");
            _VCEFastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEFastPumpValve}");
            _TMFastVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMFastVentValve}");
            _TMSoftVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.TMSoftVentValve}");
            _VCESoftVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCESoftVentValve}");
            _VCEFastVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.VCEFastVentValve}");

            _VCESlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCESlitDoorOpenEnable}");
            _PMASlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMASlitDoorOpenEnable}");
            _PMBSlitDoorOpenEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMBSlitDoorOpenEnable}");

            _VCESlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCESlitDoorCloseEnable}");
            _PMASlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMASlitDoorCloseEnable}");
            _PMBSlitDoorCloseEnable = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.PMBSlitDoorCloseEnable}");

            _TMVACSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.TMVACSensor}");
            _VCEVACSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEVACSensor}");
            _TMATMSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.TMATMSensor}");
            _VCEATMSensor = DEVICE.GetDevice<IoSensor>($"{Module}.{VenusDevice.VCEATMSensor}");
            _VCESlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.VCESlitDoor}");


            _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}");
            }

            _TMMfc = DEVICE.GetDevice<IoMfc>($"{Module}.TM_MFC1");
            _TMPressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.TMPressure");
            //_TMPiplinePressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.TMPipelinePressure");
            _VCEPressure = DEVICE.GetDevice<IoPressureMeter>($"{Module}.VCEPressure");

            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}");
                }
            }

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

            DATA.Subscribe($"{Module}.VCESlitDoorClosed", () => VCESlitDoorClosed(ModuleName.VCE1));
            DATA.Subscribe($"{Module}.PMASlitDoorClosed", () => PMASlitDoorClosed);
            DATA.Subscribe($"{Module}.PMBSlitDoorClosed", () => PMBSlitDoorClosed);
            DATA.Subscribe($"{Module}.PMCSlitDoorClosed", () => PMCSlitDoorClosed);
            DATA.Subscribe($"{Module}.PumpIsRunning", () => IsTMPumpRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.TMIsATM", ()=> IsTMATM);
            DATA.Subscribe($"{Module}.VCEIsATM", ()=> IsVCEATM);

            OP.Subscribe($"{Module}.ControlPump", (cmd, args) =>
            {
                _TMPump.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控制方法


        //slitdoor
        //2023/11/1 增加两边压差比较
        public override void PressureControl(bool bCtrl)
        {
            if (!_PressureControl.IsProcessControl && bCtrl)
            {
                _PressureControl.SetMode(true);
            }

            if (_PressureControl.IsProcessControl && !bCtrl)
            {
                _PressureControl.SetMode(false);
            }
        }
        private bool IsPressureReady(ModuleName _targetModule)
        {
            double ControlPressure = SC.GetValue<int>($"{_targetModule}.ControlPressureSetPoint");
            //double PMPressure = Singleton<RouteManager>.Instance.GetPM(_targetModule).ChamberPressure;
            double PMPressure = (double)DATA.Poll($"{_targetModule}.ChamberPressure");
            double range = SC.GetValue<int>($"{_targetModule}.ControlPressureOffset");
            if ((PMPressure >= (ControlPressure - range)) && (PMPressure <= (ControlPressure + range)))
            {
                return true;
            }
            else return false;
        }
        public override bool TurnSlitDoor(ModuleName mod, bool bOn)
        {
            double MaxPressureDifference = SC.GetValue<double>("System.PMTMMaxPressureDifference");
            switch (mod)
            {
                case ModuleName.VCE1:
                    if (bOn && IsVCEATM && IsTMATM)
                    {
                        LOG.Write(eEvent.INFO_TM, ModuleName.SETM, $"open door without Pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEPressure.Value}");

                        return _VCESlitDoor.SetCylinder(bOn, out _);
                    }
                    if (bOn && Math.Abs(_TMPressure.Value - _VCEPressure.Value)> MaxPressureDifference)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.SETM, $"cannot open door cause pressure, TM Pressure:{_TMPressure.Value} and VCE Pressure:{_VCEPressure.Value}");
                        return false;
                    }
                    return _VCESlitDoor.SetCylinder(bOn, out _);
                case ModuleName.PMA:
                    if (bOn && Singleton<RouteManager>.Instance.PMA.IsAtm && IsTMATM)
                        return _PMASlitDoor.SetCylinder(bOn, out _);
                    if (bOn && !CanOpenSlitDoor(mod, MaxPressureDifference)&& !IsPressureReady(mod))
                        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)&& !IsPressureReady(mod))
                        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) && !IsPressureReady(mod))
                        return false;
                    return _PMCSlitDoor.SetCylinder(bOn, out _);
            }
            return false;
        }

        //valve
        public override void TurnFastPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    _TMFastPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCE1:
                    _VCEFastPumpValve.TurnValve(bOn, out string _);
                    break;
            }
        }

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

        public override void TurnSoftPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    _TMSoftPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCE1:
                    _VCESoftPumpValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public override void TurnFastVentValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    _TMFastVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCE1:
                    _VCEFastVentValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public override void TurnSoftVentValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    _TMSoftVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.VCE1:
                    _VCESoftVentValve.TurnValve(bOn, out string _);
                    break;
            }
        }
        public override bool CloseAllSlitDoor()
        {
            TurnSlitDoor(ModuleName.VCE1, 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);
            return true;
        }
        public override void HomeVceSlitDoor()
        {
            //由SlitDoor的状态对其下发同样的指令
            if (VCESlitDoorClosed(ModuleName.VCE1) == true)
                TurnSlitDoor(ModuleName.VCE1, false);
            else
                TurnSlitDoor(ModuleName.VCE1, true);
        }

        public override void CloseVentValve()
        {
            _TMSoftVentValve.TurnValve(false, out _);
            _TMFastVentValve.TurnValve(false, out _);
            _VCESoftVentValve.TurnValve(false, out _);
            _VCEFastVentValve.TurnValve(false, out _);
        }

        public override bool CheckSlitValveOpen(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.VCE1:
                    return VCESlitDoorOpen;
                case ModuleName.PMA:
                    return PMASlitDoorOpen;
                case ModuleName.PMB:
                    return PMBSlitDoorOpen;
                case ModuleName.PMC:
                    return PMCSlitDoorOpen;
            }
            return false;
        }

        public override bool CheckSlitValveClose(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.VCE1:
                    return VCESlitDoorClosed(ModuleName.VCE1);
                case ModuleName.PMA:
                    return PMASlitDoorClosed;
                case ModuleName.PMB:
                    return PMBSlitDoorClosed;
                case ModuleName.PMC:
                    return PMCSlitDoorClosed;
            }
            return false;
        }

        public override bool CheckPumpValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    return !IsTMFastPumpOpen && !IsTMSoftPumpOpen;
                case ModuleName.VCE1:
                    return !IsVCEFastPumpOpen && !IsVCESoftPumpOpen;
            }
            return true;
        }

        public override bool CheckVentValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.SETM:
                    if (IsTMVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.SETM, "TM Vent Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.VCE1:
                    if (IsVCEVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.VCE1, "VCE1 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.SETM:
                    return TMPressure;
                case ModuleName.VCE1:
                    return VCEPressure;
            }

            return 0.0;
        }

        public override bool TryGetPump(ModuleName mod)
        {
            //Self
            if ((mod == ModuleName.VCE1 && _PumpingState == PumpState.VCEUsing) || (mod == ModuleName.SETM && _PumpingState == PumpState.TMUsing))
                return true;

            //Idle
            if (mod == ModuleName.SETM && !IsTMFastPumpOpen && !IsTMSoftPumpOpen && _PumpingState == PumpState.Idle)
            {
                _PumpingState = PumpState.TMUsing;
                return true;
            }

            if (mod == ModuleName.VCE1 && !IsVCEFastPumpOpen && !IsVCESoftPumpOpen && _PumpingState == PumpState.Idle)
            {
                _PumpingState = PumpState.VCEUsing;
                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.SETM && _PumpingState == PumpState.TMUsing) || (Module == ModuleName.VCE1 && _PumpingState == PumpState.VCEUsing))
                _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.SETM, $"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

    }
}