Kepler-Release/Venus/Venus_RT/Devices/JetKepler2200BPM.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using System;
using Venus_Core;
using Venus_RT.Devices.IODevices;
using IoMfc = Venus_RT.Devices.IODevices.IoMfc;
using IoHeartbeat = Venus_RT.Devices.IODevices.IoHeartbeat;
using System.Threading.Tasks;
using System.Diagnostics;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;

namespace Venus_RT.Devices
{
    class JetKepler2200BPM : JetPMBase
    {
        private readonly IoLid _Lid;
        //private readonly IoLid _LidLoadlock;

        private readonly IoCylinder _slitDoor;
        //private readonly IoCylinder _LiftPin;
        //private readonly IoCylinder _LoadLockArm;

        private readonly IoValve _PVN21Valve;
        private readonly IoValve _PVN22Valve;
        private readonly IoValve _PV11Valve;
        private readonly IoValve _PV12Valve;
        private readonly IoValve _PV21Valve;
        private readonly IoValve _PV22Valve;
        private readonly IoValve _PV31Valve;
        private readonly IoValve _PV32Valve;
        private readonly IoValve _PV41Valve;
        private readonly IoValve _PV42Valve;
        private readonly IoValve _N2Valve;
        private readonly IoValve _O2Valve;

        private readonly IoValve _PurgeValve;

        private readonly IoValve _Mfc1Valve;
        private readonly IoValve _Mfc2Valve;
        private readonly IoValve _Mfc3Valve;
        private readonly IoValve _Mfc4Valve;
        private readonly IoValve _Mfc5Valve;
        private readonly IoValve _Mfc6Valve;
        private readonly IoValve _Mfc7Valve;
        private readonly IoValve _Mfc8Valve;
        //private readonly IoValve _PVHe1Valve;
        //private readonly IoValve _PVHe2Valve;
        private readonly IoValve _GasFinalValve;
        private readonly IoValve _SoftPumpValve;
        private readonly IoValve _FastPumpValve;
        private readonly IoValve _TurboPumpPumpingValve;
        private readonly IoValve _TurboPumpPurgeValve;
        private readonly IoValve _GuageValve;
        //private readonly IoValve _LoadlockVentValve;
        //private readonly IoValve _LoadlockPumpingValve;

        private readonly IoValve _N2Purge1Valve;
        private readonly IoValve _N2Purge2Valve;
        private readonly IoValve _PenningGuageValve;



        private readonly IoSensor _ATM_sw;
        private readonly IoSensor _CDAPressure;
        //private readonly IoSensor _ATM_Loadlock_sw;
        private readonly IoSensor _N2Pressure_sw;
        private readonly IoSensor _VAC_sw;
        private readonly IoSensor _WLK_sw;
        private readonly IoSensor _Water_Flow;
        private readonly IoSensor _RFG_Interlock;
        //private readonly IoSensor _PM_Lid_Closed;
        private readonly IoSensor _Source_RF_Match_Interlock;
        //private readonly IoSensor _PM_SlitDoor_Closed;
        private readonly IoSensor _TurboPumpInterlock;
        private readonly IoSensor _GasBoxDoor;
        private readonly IoSensor _GasBoxPressure;
        private readonly IoSensor _GasBoxN2Flow_sw;
        private readonly IoSensor _N2PurgePressure_sw;
        private readonly IoSensor _RFBox_Interlock;

        private readonly IoSensor _WaferTransferPosi_sw;




        private readonly IoHeartbeat _Heartbeat;

        private readonly IoHighTemperatureHeater _highTemperatureHeater;
        //private readonly F_TRIG _GasBoxN2FlowSwitchTrigger = new F_TRIG();
        private readonly Stopwatch _GasBoxN2FlowSwitchStopWatch = new Stopwatch();


        private readonly PumpBase _MainPump;
        private readonly AdixenTurboPump _TurboPump;
        private readonly PendulumValve _pendulumValve;


        private readonly RfPowerBase _Generator;//srf=>AdTecGenerator
        private readonly RfMatchBase _Match;
        private readonly RfMatchBase _RFBox;


        //private readonly RfPowerBase _GeneratorBias;//brf=>CometRF
        //private readonly RfMatchBase _BiasMatch;

        //private readonly IoSignalTower _SignalTower;

        //private readonly IoHeater _ForelineTC;
        private readonly IoHeater _WallTC;

        private readonly IoPressureControl _pressureController;

        private readonly IoGasStick[] _gasLines;
        private readonly IoGasStick _gasLineN2;
        //private readonly IoBacksideHe _backsideHe;



        private readonly double _foreline_interlock_pressure = 750;

        private Stopwatch _GasRFStopWatch = new Stopwatch();
        private bool _GasFlag = false;
        //private PressureType _PressureType;
        private double processPressureLimit;

        // 盖子的状态
        public override bool IsLidClosed => _Lid.OFFFeedback;
        //public override bool IsLidLoadlockClosed => _LidLoadlock.OFFFeedback;

        public override bool IsSlitDoorClosed => _slitDoor.State == CylinderState.Close;

        public override bool IsPumpRunning => _MainPump.IsRunning;
        public override bool IsISOOpen => _TurboPumpPumpingValve.Status;
        public override bool IsTurboPumpRunning => _TurboPump.IsRunning;
        public override bool IsTurboPumpAtSpeed => _TurboPump.AtSpeed;
        public override float TurboPumpSpeed => _TurboPump.Speed;
        public override bool HasPumpError => _MainPump.IsError || !_MainPump.IsRunning;

        public override bool HasTurboPumpError => _TurboPump.IsError || !_TurboPump.IsRunning;

        public override bool IsCDA_OK => _CDAPressure.Value;

        public override bool IsFastPumpOpened => _FastPumpValve.Status;
        public override bool IsSoftPumpOpened => _SoftPumpValve.Status;
        public override bool IsMfc1ValveOpened => _Mfc1Valve.Status;
        public override bool IsMfc2ValveOpened => _Mfc2Valve.Status;
        public override bool IsMfc3ValveOpened => _Mfc3Valve.Status;
        public override bool IsMfc4ValveOpened => _Mfc4Valve.Status;
        public override bool IsMfc5ValveOpened => _Mfc5Valve.Status;
        public override bool IsMfc6ValveOpened => _Mfc6Valve.Status;
        public override bool IsMfc7ValveOpened => _Mfc7Valve.Status;
        public override bool IsMfc8ValveOpened => _Mfc8Valve.Status;

        public override bool IsGuageValveOpened => _GuageValve.Status;

        // 压力信号
        public override bool IsATM => _ATM_sw.Value;

        public override bool PVN22ValveIsOpen => _PVN22Valve.Status;
        //public override bool LiftPinIsDown => false;
        //public override bool LiftPinIsUp => false;

        //public override bool IsATMLoadlock => _ATM_Loadlock_sw.Value;
        //public override bool IsVACLoadLock => LoadlockPressure <= 1000;
        public override bool IsVAC => _VAC_sw.Value;
        public override bool IsWaterFlowOk => _Water_Flow.Value;
        public override bool IsWLK => _WLK_sw.Value;
        public override bool IsRFGInterlockOn => _RFG_Interlock.Value;
        //public override bool PMLidClosed => _PM_Lid_Closed.Value;
        public override bool TurboPumpInterlock => _TurboPumpInterlock.Value;
        public override bool SourceRFMatchInterlock => _Source_RF_Match_Interlock.Value;
        //public override bool SlitDoorClosed => _PM_SlitDoor_Closed.Value;
        public override HighTemperatureHeaterPosition HighTemperatureHeaterPosition => _highTemperatureHeater.CurrentPosition;

        public override double CalculationPressure
        {
            get
            {
                if (_GuageValve.Status)
                {
                    return ProcessPressure;
                }
                else
                {
                    return ChamberPressure;
                }
            }
        }
        public override double ProcessPressure => _pendulumValve.Pressure;
        public override double ChamberPressure => _pressureController.PressureGauge.Value;
        public override double ForelinePressure => _pressureController.ForelineGauge.Value;
        public override double TargetPressure => ChamberPressure;

        public override float ReflectPower => _Generator.ReflectPower;

        public override float ForwardPower => _Generator.ForwardPower;

        public override float RFMatchC1 => _Match != null ? _Match.TunePosition1 : 0;
        public override float RFMatchC2 => _Match != null ? _Match.TunePosition2 : 0;
        public override float RFBoxC1 => _RFBox != null ? _RFBox.TunePosition1 : 0;

        public override double MFC1FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas1").FeedBack;
        public override double MFC2FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas2").FeedBack;
        public override double MFC3FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas3").FeedBack;
        public override double MFC4FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas4").FeedBack;
        public override double MFC5FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas5").FeedBack;
        public override double MFC6FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas6").FeedBack;
        public override double MFC7FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas7").FeedBack;
        public override double MFC8FeedBack => DEVICE.GetDevice<IoMfc>($"{Module}.MfcGas8").FeedBack;
        public override float ChamberTemperature => _highTemperatureHeater.HighTemperatureHighHeaterTemperature;

        public override float PendulumPressure => _pendulumValve.Pressure;
        public override float PendulumPosition => _pendulumValve.Position;

        public new ModuleName Module { get; }

        //public override bool CheckAtm()
        //{
        //    return _ATM_sw.Value && ChamberPressure > 700000;
        //}
        public override bool CheckSlitDoorOpen()
        {
            return _slitDoor.State == CylinderState.Open;
        }

        public override bool CheckSlitDoorClose()
        {
            return _slitDoor.State == CylinderState.Close;
        }

        public override double TotalGasSetpoint
        {
            get
            {
                double sum = 0;
                foreach (var gas in _gasLines)
                {
                    sum += gas.FlowSP;
                }
                return sum;
            }
        }

        public override bool HasGasOutOfRange
        {
            get
            {
                foreach (var gas in _gasLines)
                {
                    if (!gas.IsOutOfRange)
                        return false;
                }
                return true;
            }
        }

        public override bool PendulumValveIsOpen()
        {
            return _pendulumValve.IsOpen;
        }
        public override bool IsBiasRFAble()
        {
            return false;
        }

        #region 构造函数
        public JetKepler2200BPM(ModuleName moduleName) : base(moduleName)
        {
            Module = moduleName;
            _Lid = DEVICE.GetDevice<IoLid>($"{Module}.{VenusDevice.Lid}");
            //_LidLoadlock = DEVICE.GetDevice<IoLid>($"{Module}.{VenusDevice.LidLoadlock}");

            _slitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.SlitDoor}");
            //_LiftPin = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.LiftPin}");
            //_LoadLockArm = DEVICE.GetDevice<IoCylinder>($"{Module}.{VenusDevice.LoadLockArm}");

            _PVN21Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePVN21}");
            _PVN22Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePVN22}");
            _PV11Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV11}");
            _PV12Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV12}");
            _PV21Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV21}");
            _PV22Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV22}");
            _PV31Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV31}");
            _PV32Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV32}");
            _PV41Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV41}");
            _PV42Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePV42}");
            _N2Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveN2}");
            _O2Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveO2}");

            _PurgeValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePurge}");

            _Mfc1Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc1}");
            _Mfc2Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc2}");
            _Mfc3Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc3}");
            _Mfc4Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc4}");
            _Mfc5Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc5}");
            _Mfc6Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc6}");
            _Mfc7Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc7}");
            _Mfc8Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveMfc8}");
            //_PVHe1Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePVHe1}");
            //_PVHe2Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePVHe2}");
            _GasFinalValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveGasFinal}");
            _SoftPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveSoftPump}");
            _FastPumpValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveFastPump}");
            _TurboPumpPumpingValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveTurboPumpPumping}");
            _TurboPumpPurgeValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveTurboPumpPurge}");
            _GuageValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveGuage}");
            _N2Purge1Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveN2Purge1}");
            _N2Purge2Valve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveN2Purge2}");
            _PenningGuageValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValvePenningGauge}");

            //_LoadlockVentValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveLoadlockVent}");
            //_LoadlockPumpingValve = DEVICE.GetDevice<IoValve>($"{Module}.{VenusDevice.ValveLoadlockPumping}");
            _ATM_sw = DEVICE.GetDevice<IoSensor>($"{Module}.SensorATMSwitch");
            //_ATM_Loadlock_sw = DEVICE.GetDevice<IoSensor>($"{Module}.SensorLoadlockATMSwitch");
            _N2Pressure_sw = DEVICE.GetDevice<IoSensor>($"{Module}.N2PressureOk");
            _VAC_sw = DEVICE.GetDevice<IoSensor>($"{Module}.SensorVacSwitch");
            _Water_Flow = DEVICE.GetDevice<IoSensor>($"{Module}.SensorWaterFlowOk");
            _WLK_sw = DEVICE.GetDevice<IoSensor>($"{Module}.SensorWaterLeakOk");
            _CDAPressure = DEVICE.GetDevice<IoSensor>($"{Module}.SensorCDAPressureOk");
            _RFG_Interlock = DEVICE.GetDevice<IoSensor>($"{Module}.GeneratorInterlock");
            _RFBox_Interlock = DEVICE.GetDevice<IoSensor>($"{Module}.RFBoxInterlock");

            
            //_PM_Lid_Closed = DEVICE.GetDevice<IoSensor>($"{Module}.SensorPMLidClosed");
            _Source_RF_Match_Interlock = DEVICE.GetDevice<IoSensor>($"{Module}.RFMatchInterlock");
            //_PM_SlitDoor_Closed = DEVICE.GetDevice<IoSensor>($"{Module}.SensorSlitDoorClosed");
            _TurboPumpInterlock = DEVICE.GetDevice<IoSensor>($"{Module}.TurboPumpInterlock");
            _GasBoxDoor = DEVICE.GetDevice<IoSensor>($"{Module}.GasBoxDoorSW");
            _GasBoxPressure = DEVICE.GetDevice<IoSensor>($"{Module}.GasBoxPressureSW");
            _GasBoxN2Flow_sw = DEVICE.GetDevice<IoSensor>($"{Module}.GasBoxN2FlowSwitch");
            _N2PurgePressure_sw = DEVICE.GetDevice<IoSensor>($"{Module}.N2PurgePressureSwitch");
            //_ForelineTC = DEVICE.GetDevice<IoHeater>($"{Module}.ForelineHeater");
            _WallTC = DEVICE.GetDevice<IoHeater>($"{Module}.WallHeater");
            _WaferTransferPosi_sw= DEVICE.GetDevice<IoSensor>($"{Module}.WaferTransferPosi");

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

            _CDAPressure = DEVICE.GetDevice<IoSensor>($"{Module}.SensorCDAPressureOk");
            _pressureController = DEVICE.GetDevice<IoPressureControl>($"{Module}.{VenusDevice.PressureControl}");

            _gasLines = new IoGasStick[8];
            for (int index = 0; index < 8; index++)
            {
                _gasLines[index] = DEVICE.GetDevice<IoGasStick>($"{Module}.GasStick{index + 1}");
            }

            _gasLineN2 = DEVICE.GetDevice<IoGasStick>($"{Module}.GasStickN2");
            //_backsideHe = DEVICE.GetDevice<IoBacksideHe>($"{Module}.BacksideHelium");

            _highTemperatureHeater = DEVICE.GetDevice<IoHighTemperatureHeater>($"{Module}.HighTemperatureHeater");

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

            //_ESCHV = DEVICE.GetDevice<ESC5HighVoltage>($"{Module}.{VenusDevice.ESCHV}");
            _TurboPump = DEVICE.GetDevice<AdixenTurboPump>($"{Module}.{VenusDevice.TurboPump}");
            _pendulumValve = DEVICE.GetDevice<PendulumValve>($"{Module}.{VenusDevice.PendulumValve}");

            //if (SC.GetValue<bool>($"{Module}.Chiller.EnableChiller") &&
            //    SC.GetValue<int>($"{Module}.Chiller.CommunicationType") == (int)CommunicationType.RS232)
            //{
            //    if (SC.GetValue<int>($"{Module}.Chiller.MFG") == (int)ChillerMFG.SMC)
            //    {
            //        _Chiller = DEVICE.GetDevice<SMCChiller>($"{Module}.{VenusDevice.Chiller}");
            //    }
            //    else if (SC.GetValue<int>($"{Module}.Chiller.MFG") == (int)ChillerMFG.AIRSYS)
            //    {
            //        _Chiller = DEVICE.GetDevice<AIRSYSChiller>($"{Module}.{VenusDevice.Chiller}");
            //    }
            //}


            // RS223 AdTec Generator
            if (SC.GetValue<int>($"{Module}.Rf.CommunicationType") == (int)CommunicationType.RS232 &&
                SC.GetValue<int>($"{Module}.Rf.MFG") == (int)GeneratorMFG.AdTec)
            {
                _Generator = DEVICE.GetDevice<AdTecGenerator>($"{Module}.{VenusDevice.Rf}");
            }
            _Heartbeat = DEVICE.GetDevice<IoHeartbeat>($"{Module}.{VenusDevice.Heartbeat}");
            // Ethernet Comet Generator Bias
            //if (SC.GetValue<bool>($"{Module}.BiasRf.EnableBiasRF"))
            //{
            //    if (SC.GetValue<int>($"{Module}.BiasRf.CommunicationType") == (int)CommunicationType.Ethernet &&
            //        SC.GetValue<int>($"{Module}.BiasRf.MFG") == (int)GeneratorMFG.Comet)
            //    {
            //        _GeneratorBias = DEVICE.GetDevice<CometRF>($"{Module}.{VenusDevice.BiasRf}");
            //    }
            //    else if (SC.GetValue<int>($"{Module}.BiasRf.MFG") == (int)GeneratorMFG.AdTec)
            //    {
            //        _GeneratorBias = DEVICE.GetDevice<AdTecGenerator>($"{Module}.{VenusDevice.BiasRf}");
            //    }
            //}

            if (SC.GetValue<int>($"{Module}.Match.CommunicationType") == (int)CommunicationType.RS232 &&
                SC.GetValue<int>($"{Module}.Match.MFG") == (int)MatchMFG.AdTec)
            {
                _Match = DEVICE.GetDevice<AdTecMatch>($"{Module}.{VenusDevice.Match}");
            }
            else if (
                SC.GetValue<int>($"{Module}.Match.MFG") == (int)MatchMFG.Revtech)
            {
                _Match = DEVICE.GetDevice<RevtechMatch>($"{Module}.{VenusDevice.Match}");
            }


            //if (SC.GetValue<bool>($"{Module}.BiasMatch.EnableBiasMatch") &&
            //    SC.GetValue<int>($"{Module}.BiasMatch.CommunicationType") == (int)CommunicationType.RS232 &&
            //    SC.GetValue<int>($"{Module}.BiasMatch.MFG") == (int)MatchMFG.AdTec)
            //{
            //    _BiasMatch = DEVICE.GetDevice<AdTecMatch>($"{Module}.{VenusDevice.BiasMatch}");
            //}
            //else if (SC.GetValue<bool>($"{Module}.BiasMatch.EnableBiasMatch") &&
            //    SC.GetValue<int>($"{Module}.BiasMatch.MFG") == (int)MatchMFG.Revtech)
            //{
            //    _BiasMatch = DEVICE.GetDevice<RevtechMatch>($"{Module}.{VenusDevice.BiasMatch}");
            //}
            if (SC.GetValue<bool>($"{Module}.RFBox.EnableMatch") &&
               SC.GetValue<int>($"{Module}.RFBox.CommunicationType") == (int)CommunicationType.RS232 &&
               SC.GetValue<int>($"{Module}.RFBox.MFG") == (int)MatchMFG.AdTec)
            {
                _RFBox = DEVICE.GetDevice<AdTecMatch>($"{Module}.{VenusDevice.RFBox}");
            }
            else if (SC.GetValue<bool>($"{Module}.RFBox.EnableMatch") &&
                SC.GetValue<int>($"{Module}.RFBox.MFG") == (int)MatchMFG.Revtech)
            {
                _RFBox = DEVICE.GetDevice<RevtechMatch>($"{Module}.{VenusDevice.RFBox}");
            }
            _foreline_interlock_pressure = SC.GetValue<int>($"{Module}.PendulumValve.ForelinePressureLimit");

            _GasRFStopWatch.Stop();

            processPressureLimit = 260;//unit Pa
            _GasBoxN2FlowSwitchStopWatch.Start();
            //_PressureType = (PressureType)SC.GetValue<int>("System.PressureUnitType");
            DATA.Subscribe($"{Name}.PenningPressure", () => _pressureController.PenningGauge.Value);





        }

        #endregion

        public async override void CloseValves(int? delayTime = null)
        {
            _PVN21Valve.TurnValve(false, out _);
            // _PVN22Valve.TurnValve(false, out _);
            _PV11Valve.TurnValve(false, out _);
            _PV12Valve.TurnValve(false, out _);
            _PV21Valve.TurnValve(false, out _);
            _PV22Valve.TurnValve(false, out _);
            _PV31Valve.TurnValve(false, out _);
            _PV32Valve.TurnValve(false, out _);
            _PV41Valve.TurnValve(false, out _);
            _PV42Valve.TurnValve(false, out _);

            //_PVHe1Valve.TurnValve(false, out _);
            //_PVHe2Valve.TurnValve(false, out _);
            _SoftPumpValve.TurnValve(false, out _);
            _FastPumpValve.TurnValve(false, out _);
            //_TurboPumpPumpingValve.TurnValve(false, out _);
            _TurboPumpPurgeValve.TurnValve(false, out _);
            //_GuageValve.TurnValve(false, out _);


            _N2Valve.TurnValve(false, out _);
            _O2Valve.TurnValve(false, out _);

            _N2Purge1Valve.TurnValve(false, out _);
            _N2Purge2Valve.TurnValve(false, out _);



            _FastPumpValve.TurnValve(false, out _);

            _Mfc1Valve.TurnValve(false, out _);
            _Mfc2Valve.TurnValve(false, out _);
            _Mfc3Valve.TurnValve(false, out _);
            _Mfc4Valve.TurnValve(false, out _);
            _Mfc5Valve.TurnValve(false, out _);
            _Mfc6Valve.TurnValve(false, out _);
            _Mfc7Valve.TurnValve(false, out _);
            _Mfc8Valve.TurnValve(false, out _);

            foreach (var stick in _gasLines)
            {
                stick.Stop();
            }
            if (delayTime != null)
            {
                await Task.Delay((int)delayTime);
            }
            _GasFinalValve.TurnValve(false, out _);
            _PurgeValve.TurnValve(false, out _);
        }

        public override void TurnDryPump(bool on)
        {
            //_pressureController.StartPump(on);
            _MainPump?.SetPumpOnOff(on);
        }

        public override void TurnTurboPump(bool on)
        {
            _TurboPump?.SetPumpOnOff(on);
        }

        public override void OpenValve(ValveType vlvType, bool on)
        {
            switch (vlvType)
            {

                case ValveType.PVN21:
                    _PVN21Valve.TurnValve(on, out _);
                    break;
                case ValveType.PVN22:
                    _PVN22Valve.TurnValve(on, out _);

                    break;
                case ValveType.PV11:
                    _PV11Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV12:
                    _PV12Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV21:
                    _PV21Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV22:
                    _PV22Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV31:
                    _PV31Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV32:
                    _PV32Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV41:
                    _PV41Valve.TurnValve(on, out _);
                    break;
                case ValveType.PV42:
                    _PV42Valve.TurnValve(on, out _);
                    break;
                case ValveType.N2:
                    _N2Valve.TurnValve(on, out _);
                    break;
                case ValveType.Purge:
                    _PurgeValve.TurnValve(on, out _);
                    break;

                case ValveType.GasFinal:
                    _GasFinalValve.TurnValve(on, out _);
                    break;
                case ValveType.SoftPump:
                    _SoftPumpValve.TurnValve(on, out _);
                    break;
                case ValveType.FastPump:
                    _FastPumpValve.TurnValve(on, out _);
                    break;
                case ValveType.TurboPumpPumping:
                    _TurboPumpPumpingValve.TurnValve(on, out _);
                    break;
                case ValveType.TurboPumpPurge:
                    _TurboPumpPurgeValve.TurnValve(on, out _);
                    break;
                case ValveType.Guage:
                    _GuageValve.TurnValve(on, out _);
                    break;
                //case ValveType.LoadlockVent:
                //    _LoadlockVentValve.TurnValve(on, out _);
                //    break;
                //case ValveType.LoadlockPumping:
                //    _LoadlockPumpingValve.TurnValve(on, out _);
                //    break;
                case ValveType.Mfc1:
                    _Mfc1Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc2:
                    _Mfc2Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc3:
                    _Mfc3Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc4:
                    _Mfc4Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc5:
                    _Mfc5Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc6:
                    _Mfc6Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc7:
                    _Mfc7Valve.TurnValve(on, out _);
                    break;
                case ValveType.Mfc8:
                    _Mfc8Valve.TurnValve(on, out _);
                    break;
                case ValveType.O2:
                    _O2Valve.TurnValve(on, out _);
                    break;
                case ValveType.N2Purge1:
                    _N2Purge1Valve.TurnValve(on, out _);
                    break;
                case ValveType.N2Purge2:
                    _N2Purge2Valve.TurnValve(on, out _);
                    break;
                case ValveType.PenningGauge:
                    _PenningGuageValve.TurnValve(on, out _);
                    break;
                    //default:
                    //    throw new ArgumentOutOfRangeException($"Argument error {vlvType}-{on}");

            }
        }

        public override void Monitor()
        {
            //if (_Heartbeat.IsUnConnect)
            //{
            //    return;
            //}
           
            foreach (var gas in _gasLines)
            {
                gas.Monitor();
            }

            CheckPermanentInterlock();
            //if (_GasBoxN2FlowSwitchStopWatch.ElapsedMilliseconds > 10 * 1000)
            //{
            //    _GasBoxN2FlowSwitchStopWatch.Stop();
            //}
            CheckHighTemperatureHeaterInterlock();

        }

        private void CheckHighTemperatureHeaterInterlock()
        {
            if (_highTemperatureHeater.HighTemperatureHeaterIsOn == false)
            {
                return;
            }
            if (_GasBoxN2Flow_sw.Value)
            {
                _GasBoxN2FlowSwitchStopWatch.Reset();
            }
            else
            {
                _GasBoxN2FlowSwitchStopWatch.Start();
            }

            if (_GasBoxN2FlowSwitchStopWatch.ElapsedMilliseconds > 10 * 1000 && _GasBoxN2FlowSwitchStopWatch.IsRunning)
            {
                _GasBoxN2FlowSwitchStopWatch.Reset();
                var limitTemperature = SC.GetValue<double>($"{Module}.HighTemperatureHeater.N2WarningTemperatureLimit");


                if (limitTemperature < ChamberTemperature)
                {
                    SetHighTemperatureHeaterTemperature((int)limitTemperature);
                    LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"Gas Box N2 Flow Trigger Warning,HighTemperatureHeater Cool Down to {limitTemperature} ℃");
                }
                
            }
        }
        protected override void CheckPermanentInterlock()
        {
            if (ChamberPressure >= processPressureLimit && _GuageValve.SetPoint)
            {
                _GuageValve.TurnValve(false, out _);
                LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"Process pressure:{ChamberPressure} exceed {processPressureLimit} Pa, Guage Valve (DO-31) closed automaticlly.");
            }

            if (ChamberPressure < processPressureLimit && !_GuageValve.SetPoint)
            {
                _GuageValve.TurnValve(true, out _);
                LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"Process pressure:{ChamberPressure} less than {processPressureLimit} Pa, Guage Valve (DO-31) open automaticlly.");
            }
        }

        public override async void CheckIdleInterlock(int delaytime)
        {
            if (ForelinePressure > _foreline_interlock_pressure)
            {
                await Task.Delay(500);
                if (ForelinePressure < _foreline_interlock_pressure)
                {
                    return;
                }
                if (_TurboPumpPumpingValve.SetPoint || _TurboPumpPurgeValve.SetPoint || _pendulumValve.IsOpen)
                {
                    _pendulumValve.TurnValve(false);
                    _TurboPumpPurgeValve.TurnValve(false, out _);
                    _TurboPumpPumpingValve.TurnValve(false, out _);

                    LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"Foreline pressure:{ForelinePressure} exceed {_foreline_interlock_pressure} Pa, Pendulum valve & PV6 & PV7 closed automaticlly.");
                }
            }
            if (_TurboPumpPumpingValve.SetPoint == false && _pendulumValve.IsOpen)
            {
                _pendulumValve.TurnValve(false);
                LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"ISO Valve Closed, Pendulum valve  closed automaticlly.");

            }
        }


        public override void Home()
        {
            _Generator?.ReConnect();
            _Match?.ReConnect();
            _MainPump?.ReConnect();
            _TurboPump?.ReConnect();
            _pendulumValve?.ReConnect();
            _RFBox?.ReConnect();
        }

        public override bool HomeIsOK(out string reason)
        {
            if (!IsSlitDoorClosed)
            {
                reason = "Door is not open";
                return false;
            }
            if (!_highTemperatureHeater.LiftIsOK())
            {
                reason = "HighTemperatureHeater Lift is not OK";
                return false;
            }
            if (SC.GetValue<bool>($"{Module}.{VenusDevice.PendulumValve}.NoCheck"))
            {
                reason = "PendulumValve No Check is not Close";
                return false;
            }
            reason = "";
            return true;
        }


        public override bool FlowGas(int gasNum, double val)
        {
            if (_gasLines.Length <= gasNum)
                return false;

            //double value = (val / _gasLines[gasNum]._mfc.Scale) * 100;
            //double setPoint =Math.Round( value / 8000 * _gasLines[gasNum]._mfc.Scale,2);
            _gasLines[gasNum].Flow(val);
            return true;
        }
        public override bool PumpGas(int gasNum)
        {
            if (_gasLines.Length <= gasNum)
                return false;
            switch (gasNum)
            {
                case 0:
                    OpenValve(ValveType.PV12, true);
                    break;
                case 1:
                    OpenValve(ValveType.PV22, true);
                    break;
                case 2:
                    OpenValve(ValveType.PV32, true);
                    break;
                case 3:
                    OpenValve(ValveType.PV42, true);
                    break;
            }
            _gasLines[gasNum].Pump();
            OpenValve(ValveType.N2Purge2, true);
            return true;
        }
        public override bool PurgeGas(int gasNum)
        {
            if (_gasLines.Length <= gasNum)
                return false;
            switch (gasNum)
            {
                case 0:
                    OpenValve(ValveType.PV12, true);
                    break;
                case 1:
                    OpenValve(ValveType.PV22, true);
                    break;
                case 2:
                    OpenValve(ValveType.PV32, true);
                    break;
                case 3:
                    OpenValve(ValveType.PV42, true);
                    break;
            }
            _gasLines[gasNum].Pump();
            OpenValve(ValveType.PVN21, true);
            return true;
        }
        public override bool StopGas(int gasNum)
        {
            if (_gasLines.Length <= gasNum)
                return false;

            _gasLines[gasNum].Stop();
            return true;
        }

        public override bool FlowN2(double val)
        {
            _gasLineN2.Flow(val);
            return true;
        }

        public override bool StopN2()
        {
            _gasLineN2.Stop();
            return true;
        }

        public override void StopAllGases()
        {
            foreach (var line in _gasLines)
            {
                line.Stop();
            }
        }

        public override bool TurnPendulumValve(bool on)
        {
            return _pendulumValve.TurnValve(on);
        }

        public override bool SetPVPressure(float pressure)
        {
            return _pendulumValve.SetPressure(pressure);
        }

        public override bool SetPVPostion(float position)
        {
            return _pendulumValve.SetPosition(position);
        }

        public override float GetPVPosition()
        {
            return _pendulumValve.Position;
        }



        public override void SetGeneratorCommunicationMode(int mode)
        {
            _Generator?.SetCommunicationMode(mode);
        }

        public override bool GeneratorPowerOn(bool on)
        {
            if (_Generator == null) return false;

            if (on && !IsRFGInterlockOn)
            {
                LOG.Write(eEvent.ERR_RF, Module, "射频电源 Interlock条件不满足");
                return false;
            }

            return _Generator.SetPowerOnOff(on, out _);
        }

        public override bool GeneratorSetpower(float val)
        {
            if (_Generator == null)
            {
                LOG.Write(eEvent.ERR_RF, Module, $"Cannot Set RF Power as No Device");

                return false;
            } 

            if (Math.Abs(val) > 0.01)
                _Generator.SetPower((ushort)val);
            return true;
        }


        public override bool SetRFBoxC1Position(float c1)
        {
            if (_RFBox == null)
            {
                LOG.Write(eEvent.ERR_RFBox, Module, $"Cannot Set RFBox C1 as No Device");
                return false;
            } 

            if (!_RFBox_Interlock.Value)
            {
                LOG.Write(eEvent.ERR_RFBox, Module, $"Cannot Set RFBox C1 as RF Box Interlock");
                return false;
            }
            
            _RFBox.SetMatchPositionC1(c1, out _);
            return true;
        }
        public override bool SetWallTCTemperature(float value)
        {
            return _WallTC.RampTemp(value);
        }


        public override bool SetMatchPosition(float c1, float c2)
        {
            if (_Match == null) return false;
            string reason = string.Empty;
            _Match.SetMatchPosition(c1, c2, out reason);
            return true;
        }

        public override bool SetMatchWorkMode(MatchWorkMode matchWorkMode)
        {
            if (_Match == null) return false;
            if (matchWorkMode == MatchWorkMode.Auto)
            {
                return _Match.SetMatchMode(EnumRfMatchTuneMode.Auto, out _);
            }
            else if (matchWorkMode == MatchWorkMode.Manual)
            {
                return _Match.SetMatchMode(EnumRfMatchTuneMode.Manual, out _);
            }
            return false;
        }

        public override bool CheckGeneratorAndHVInterlock(VenusDevice device)
        {
            eEvent evt = device == VenusDevice.Rf ? eEvent.ERR_RF : eEvent.ERR_ESC_HV;
            if (!IsLidClosed)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as PM Lid is Open.");
                return false;
            }

            if (!IsVAC)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as PM is not Vacuum.");
                return false;
            }

            if (!IsWaterFlowOk)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Water Flow is OFF.");
                return false;
            }

            if (!IsRFGInterlockOn)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Generator Interlock is OFF.");
                return false;
            }

            if (!SlitDoorClosed)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Slit Door is open.");
                return false;
            }

            return true;
        }

        public override bool StartControlPressure(int pressureSetpoint, int flowSetpoint)
        {
            OpenValve(ValveType.Purge, true);
            //OpenValve(ValveType.N2, true);
            OpenValve(ValveType.PVN22, true);
            OpenValve(ValveType.GasFinal, false);


            OpenValve(ValveType.TurboPumpPumping, true);


            TurnPendulumValve(true);
            SetPVPressure(pressureSetpoint);
            return true;
        }
        public async override void AbortControlPressure()
        {
            //OpenValve(ValveType.N2, false);
            OpenValve(ValveType.PVN22, false);
            OpenValve(ValveType.TurboPumpPumping, true);

            //SetPVPressure(0);
            TurnPendulumValve(true);
            //SetPVPostion(1000);
            await Task.Delay(0);
            OpenValve(ValveType.Purge, false);
            //return true;
        }
        public override bool HighTemperatureHeaterGotoPosition(HighTemperatureHeaterPosition highTemperatureHeaterPosition)
        {
            return _highTemperatureHeater.GotoPosition(highTemperatureHeaterPosition);
        }
        public override bool SetHighTemperatureHeaterTemperature(int temperature)
        {
            _highTemperatureHeater.HighTemperatureHighHeaterTemperature = temperature;
            return true;
        }
        public override bool SetHighTemperatureHeaterRatio(int ratio)
        {
            _highTemperatureHeater.HighTemperatureHeaterRatio = ratio;
            return true;
        }
        public override bool PreparePlace()
        {
            //if (!SetSlitDoor(true, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Open failed:{reason}");
            //    return false;
            //}
            return _highTemperatureHeater.GotoPosition(HighTemperatureHeaterPosition.Position1);
        }
        public override bool PreparePick()
        {
            //if (!SetSlitDoor(true, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Open failed:{reason}");
            //    return false;
            //}

            return _highTemperatureHeater.GotoPosition(HighTemperatureHeaterPosition.Position1);
        }
        public override bool PreparePlaceIsOK()
        {
            return _highTemperatureHeater.CurrentPosition == HighTemperatureHeaterPosition.Position1 && _WaferTransferPosi_sw.Value;
        }
        public override bool PreparePickIsOK()
        {
            return _highTemperatureHeater.CurrentPosition == HighTemperatureHeaterPosition.Position1 && _WaferTransferPosi_sw.Value;
        }
        public override bool EndPlace()
        {
            //if (!SetSlitDoor(false, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}");
            //    return false;
            //}
            if (!_highTemperatureHeater.GotoPosition(HighTemperatureHeaterPosition.Position2))
            {
                LOG.Write(eEvent.ERR_PM, Module, $"Set High Temperature Heater To Position2 failed");
                return false;
            }
            return true;
        }
        public override bool EndPick()
        {
            //if (!SetSlitDoor(false, out string reason))
            //{
            //    LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}");
            //    return false;
            //}
            return true;
        }
        public override bool EndPlaceIsOK()
        {
            return _highTemperatureHeater.CurrentPosition == HighTemperatureHeaterPosition.Position2;
        }
        public override bool EndPickIsOK()
        {
            return CheckSlitDoorClose();
        }
        public override void RTCloseEvent()
        {
            if (_Generator.IsPowerOn)
            {
                GeneratorPowerOn(false);
            }
            if (PendulumValveIsOpen())
            {
                TurnPendulumValve(false);
            }
        }
        public override bool RFInterlock(VenusDevice device)
        {
            eEvent evt = eEvent.ERR_RF;

            if (!IsWaterFlowOk)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Water Flow is OFF.");
                return false;
            }

            if (!IsRFGInterlockOn)
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Generator Interlock is OFF.");
                return false;
            }


            if (GasIsOff())
            {
                LOG.Write(evt, Module, $"Cannot Power ON {device} as Gas is OFF.");
                return false;
            }
            return true;
        }
        private bool GasIsOff()
        {
            if ((IsMfc1ValveOpened == false && IsMfc2ValveOpened == false && IsMfc3ValveOpened == false && IsMfc4ValveOpened == false && IsMfc5ValveOpened == false && IsMfc6ValveOpened == false && IsMfc7ValveOpened == false && IsMfc8ValveOpened==false && _GasFlag == false) || (MFC1FeedBack < 1 && MFC2FeedBack < 1 && MFC3FeedBack < 1 && MFC4FeedBack < 1 && MFC5FeedBack < 1 && MFC6FeedBack < 1 && MFC7FeedBack < 1 && MFC8FeedBack < 1 && _GasFlag == false))
            {
                if (_GasRFStopWatch.IsRunning == false)
                {
                    _GasRFStopWatch.Start();
                }
                if (_GasRFStopWatch.ElapsedMilliseconds > 1500 && _GasRFStopWatch.ElapsedMilliseconds < 2500)
                {
                    //var item = _GasRFStopWatch.ElapsedMilliseconds;
                    _GasRFStopWatch.Reset();
                    _GasFlag = true;
                    return true;
                }
            }
            else
            {
                _GasRFStopWatch.Reset();
                _GasFlag = false;
            }
            return false;
        }
        public override void PMInError()
        {
            CloseValves();
            GeneratorPowerOn(false);
            GeneratorBiasPowerOn(false);
        }
    }
}