Kepler-Release/Venus/Venus_MainPages/ViewModels/GasLeakCheckViewModel.cs

using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;

namespace Venus_MainPages.ViewModels
{
    internal class GasLeakCheckViewModel : BindableBase
    {
        #region 私有字段
        private List<string> m_LeakCheckMode;
        private int m_LeakCheckModeSelectedIndex;
        private int m_VentTime;
        private int m_CheckTime;
        private double m_LeakRateUpperLimit;
        private int m_BasePressure;

        private bool[] m_GasIsCheck = new bool[9];
        public string ModuleName;
        private bool m_GasIsFlowing;
        private bool m_IsAutoMode;

        private AITMfcData m_MFC1Data;
        private AITMfcData m_MFC2Data;
        private AITMfcData m_MFC3Data;
        private AITMfcData m_MFC4Data;
        private AITMfcData m_MFC5Data;
        private AITMfcData m_MFC6Data;
        private AITMfcData m_MFC7Data;
        private AITMfcData m_MFC8Data;
        private AITMfcData m_MFC9Data;
        private AITMfcData m_MFC10Data;
        private AITMfcData m_MFC11Data;
        private AITMfcData m_MFC12Data;
        private AITMfcData m_MFCN2Data;
        private PMState m_PMCurrentState;

        private ObservableCollection<PMLeakCheckResult> m_LeakCheckResultList = new ObservableCollection<PMLeakCheckResult>();

        private bool m_MFC7IsEnable;
        private bool m_MFC8IsEnable;

        private JetChamber m_JetChamber;


        #region 阀
        private bool m_PVN21ValveIsOpen;
        private bool m_PVN22ValveIsOpen;
        private bool m_N2ValveIsOpen;
        private bool m_PV11ValveIsOpen;
        private bool m_PV12ValveIsOpen;
        private bool m_PV21ValveIsOpen;
        private bool m_PV22ValveIsOpen;
        private bool m_PV31ValveIsOpen;
        private bool m_PV32ValveIsOpen;
        private bool m_PV41ValveIsOpen;
        private bool m_PV42ValveIsOpen;
        private bool m_MFC1ValveIsOpen;
        private bool m_MFC2ValveIsOpen;
        private bool m_MFC3ValveIsOpen;
        private bool m_MFC4ValveIsOpen;
        private bool m_MFC5ValveIsOpen;
        private bool m_MFC6ValveIsOpen;
        private bool m_MFC7ValveIsOpen;
        private bool m_MFC8ValveIsOpen;
        private bool m_GasFinalValveIsOpen;
        private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
        private bool m_PVHe1ValveIsOpen;
        private bool m_PVHe2ValveIsOpen;
        private bool m_TurboPumpPumpingValveIsOpen;
        private bool m_TurboPumpPurgeValveIsOpen;
        private bool m_GuageValveIsOpen;

        private double m_MFC1SetPoint;
        private double m_MFC2SetPoint;
        private double m_MFC3SetPoint;
        private double m_MFC4SetPoint;
        private double m_MFC5SetPoint;
        private double m_MFC6SetPoint;
        private double m_MFC7SetPoint;
        private double m_MFC8SetPoint;

        //新增12路所需阀体 mfc等信息 在jetchamber确定后将其输入 否则指向为空 可能会导致异常
        private bool m_PV51ValveIsOpen;
        private bool m_PV52ValveIsOpen;
        private bool m_PV61ValveIsOpen;
        private bool m_PV62ValveIsOpen;
        private bool m_PV71ValveIsOpen;
        private bool m_PV72ValveIsOpen;
        private bool m_PV81ValveIsOpen;
        private bool m_PV82ValveIsOpen;
        private bool m_PV91ValveIsOpen;
        private bool m_PV92ValveIsOpen;
        private bool m_PVA1ValveIsOpen;
        private bool m_PVA2ValveIsOpen;
        private bool m_PVB1ValveIsOpen;
        private bool m_PVB2ValveIsOpen;
        private bool m_PVC1ValveIsOpen;
        private bool m_PVC2ValveIsOpen;
        private bool m_MFC9ValveIsOpen;
        private bool m_MFC10ValveIsOpen;
        private bool m_MFC11ValveIsOpen;
        private bool m_MFC12ValveIsOpen;
        private bool m_PVHe3ValveIsOpen;
        private bool m_HeISOValveIsOpen;
        private bool m_PV14ValveIsOpen;

        private bool m_Valve9Visible;
        private bool m_Valve10Visible;
        private bool m_Valve11Visible;
        private bool m_Valve12Visible;

        private double m_MFC9SetPoint;
        private double m_MFC10SetPoint;
        private double m_MFC11SetPoint;
        private double m_MFC12SetPoint;


        #endregion


        private List<string> m_RtDataKeys = new List<string>();
        private Dictionary<string, object> m_RtDataValues = new Dictionary<string, object>();
        private string m_currentStep;
        public TimeSpan? m_stepTime;
        private int stepTimeCountValue;
        private PressureType m_PressureType;
        private bool m_firstLoadFlag = true;
        #endregion

        #region  属性
        public bool IsAutoMode
        {
            get { return m_IsAutoMode; }
            set { SetProperty(ref m_IsAutoMode, value); }
        }
        public ObservableCollection<PMLeakCheckResult> LeakCheckResultList
        {
            get { return m_LeakCheckResultList; }
            set { SetProperty(ref m_LeakCheckResultList, value); }
        }
        public List<string> LeakCheckMode
        {
            get { return m_LeakCheckMode; }
            set { SetProperty(ref m_LeakCheckMode, value); }
        }

        public int LeakCheckModeSelectedIndex
        {
            get { return m_LeakCheckModeSelectedIndex; }
            set { SetProperty(ref m_LeakCheckModeSelectedIndex, value); }
        }

        public int VentTime
        {
            get { return m_VentTime; }
            set { SetProperty(ref m_VentTime, value); }
        }

        public int CheckTime
        {
            get { return m_CheckTime; }
            set { SetProperty(ref m_CheckTime, value); }
        }
        public int BasePressure
        {
            get { return m_BasePressure; }
            set { SetProperty(ref m_BasePressure, value); }
        }
        public double LeakRateUpperLimit
        {
            get { return m_LeakRateUpperLimit; }
            set { SetProperty(ref m_LeakRateUpperLimit, value); }
        }
        public bool[] GasIsCheck
        {
            get { return m_GasIsCheck; }
            set { SetProperty(ref m_GasIsCheck, value); }
        }
        public AITMfcData MFC1Data
        {
            get { return m_MFC1Data; }
            set { SetProperty(ref m_MFC1Data, value); }
        }
        public AITMfcData MFC2Data
        {
            get { return m_MFC2Data; }
            set { SetProperty(ref m_MFC2Data, value); }
        }
        public AITMfcData MFC3Data
        {
            get { return m_MFC3Data; }
            set { SetProperty(ref m_MFC3Data, value); }
        }
        public AITMfcData MFC4Data
        {
            get { return m_MFC4Data; }
            set { SetProperty(ref m_MFC4Data, value); }
        }
        public AITMfcData MFC5Data
        {
            get { return m_MFC5Data; }
            set { SetProperty(ref m_MFC5Data, value); }
        }
        public AITMfcData MFC6Data
        {
            get { return m_MFC6Data; }
            set { SetProperty(ref m_MFC6Data, value); }
        }
        public AITMfcData MFC7Data
        {
            get { return m_MFC7Data; }
            set { SetProperty(ref m_MFC7Data, value); }
        }
        public AITMfcData MFC8Data
        {
            get { return m_MFC8Data; }
            set { SetProperty(ref m_MFC8Data, value); }
        }
        public AITMfcData MFCN2Data
        {
            get { return m_MFCN2Data; }
            set { SetProperty(ref m_MFCN2Data, value); }
        }

        public double MFC1SetPoint
        {
            get { return m_MFC1SetPoint; }
            set { SetProperty(ref m_MFC1SetPoint, value); }
        }
        public double MFC2SetPoint
        {
            get { return m_MFC2SetPoint; }
            set { SetProperty(ref m_MFC2SetPoint, value); }
        }
        public double MFC3SetPoint
        {
            get { return m_MFC3SetPoint; }
            set { SetProperty(ref m_MFC3SetPoint, value); }
        }
        public double MFC4SetPoint
        {
            get { return m_MFC4SetPoint; }
            set { SetProperty(ref m_MFC4SetPoint, value); }
        }
        public double MFC5SetPoint
        {
            get { return m_MFC5SetPoint; }
            set { SetProperty(ref m_MFC5SetPoint, value); }
        }
        public double MFC6SetPoint
        {
            get { return m_MFC6SetPoint; }
            set { SetProperty(ref m_MFC6SetPoint, value); }
        }
        public double MFC7SetPoint
        {
            get { return m_MFC7SetPoint; }
            set { SetProperty(ref m_MFC7SetPoint, value); }
        }
        public double MFC8SetPoint
        {
            get { return m_MFC8SetPoint; }
            set { SetProperty(ref m_MFC8SetPoint, value); }
        }

        public double MFC9SetPoint
        {
            get { return m_MFC9SetPoint; }
            set { SetProperty(ref m_MFC9SetPoint, value); }
        }
        public double MFC10SetPoint
        {
            get { return m_MFC10SetPoint; }
            set { SetProperty(ref m_MFC10SetPoint, value); }
        }
        public double MFC11SetPoint
        {
            get { return m_MFC11SetPoint; }
            set { SetProperty(ref m_MFC11SetPoint, value); }
        }
        public double MFC12SetPoint
        {
            get { return m_MFC12SetPoint; }
            set { SetProperty(ref m_MFC12SetPoint, value); }
        }

        public AITMfcData MFC9Data
        {
            get { return m_MFC9Data; }
            set { SetProperty(ref m_MFC9Data, value); }
        }
        public AITMfcData MFC10Data
        {
            get { return m_MFC10Data; }
            set { SetProperty(ref m_MFC10Data, value); }
        }
        public AITMfcData MFC11Data
        {
            get { return m_MFC11Data; }
            set { SetProperty(ref m_MFC11Data, value); }
        }
        public AITMfcData MFC12Data
        {
            get { return m_MFC12Data; }
            set { SetProperty(ref m_MFC12Data, value); }
        }

        public PMState PMCurrentState
        {
            get { return m_PMCurrentState; }
            set
            {
                if ((m_PMCurrentState == PMState.GasBoxLeakCheck || m_PMCurrentState == PMState.LeakCheck) && value == PMState.Idle)
                {
                    var AllLeakCheckDa = QueryDataClient.Instance.Service.GetPMLeakCheckResult(ModuleName);
                    if (AllLeakCheckDa != null)
                    {
                        LeakCheckResultList = new ObservableCollection<PMLeakCheckResult>(AllLeakCheckDa);

                    }
                }
                SetProperty(ref m_PMCurrentState, value);
            }
        }
        public string CurrentStep
        {
            get { return m_currentStep; }
            set
            {
                if (value != m_currentStep)
                {
                    stepTimeCountValue = 0;
                }
                SetProperty(ref m_currentStep, value);
            }
        }
        public TimeSpan? StepTime
        {
            get { return m_stepTime; }
            set
            {
                SetProperty(ref m_stepTime, value);
            }
        }

        public JetChamber ChamberType
        {
            get { return m_JetChamber; }
            set
            {
                SetProperty(ref m_JetChamber, value);
            }
        }

        #region 阀
        public bool GasFinalValveIsOpen
        {
            get { return m_GasFinalValveIsOpen; }
            set { SetProperty(ref m_GasFinalValveIsOpen, value); }
        }
        public bool PVN21ValveIsOpen
        {
            get { return m_PVN21ValveIsOpen; }
            set { SetProperty(ref m_PVN21ValveIsOpen, value); }
        }
        public bool PVN22ValveIsOpen
        {
            get { return m_PVN22ValveIsOpen; }
            set { SetProperty(ref m_PVN22ValveIsOpen, value); }
        }
        public bool N2ValveIsOpen
        {
            get { return m_N2ValveIsOpen; }
            set { SetProperty(ref m_N2ValveIsOpen, value); }
        }
        public bool PV11ValveIsOpen
        {
            get { return m_PV11ValveIsOpen; }
            set { SetProperty(ref m_PV11ValveIsOpen, value); }
        }
        public bool PV12ValveIsOpen
        {
            get { return m_PV12ValveIsOpen; }
            set { SetProperty(ref m_PV12ValveIsOpen, value); }
        }
        public bool MFC1ValveIsOpen
        {
            get { return m_MFC1ValveIsOpen; }
            set { SetProperty(ref m_MFC1ValveIsOpen, value); }
        }
        public bool PV21ValveIsOpen
        {
            get { return m_PV21ValveIsOpen; }
            set { SetProperty(ref m_PV21ValveIsOpen, value); }
        }
        public bool PV22ValveIsOpen
        {
            get { return m_PV22ValveIsOpen; }
            set { SetProperty(ref m_PV22ValveIsOpen, value); }
        }
        public bool MFC2ValveIsOpen
        {
            get { return m_MFC2ValveIsOpen; }
            set { SetProperty(ref m_MFC2ValveIsOpen, value); }
        }
        public bool PV31ValveIsOpen
        {
            get { return m_PV31ValveIsOpen; }
            set { SetProperty(ref m_PV31ValveIsOpen, value); }
        }
        public bool PV32ValveIsOpen
        {
            get { return m_PV32ValveIsOpen; }
            set { SetProperty(ref m_PV32ValveIsOpen, value); }
        }
        public bool MFC3ValveIsOpen
        {
            get { return m_MFC3ValveIsOpen; }
            set { SetProperty(ref m_MFC3ValveIsOpen, value); }
        }
        public bool PV41ValveIsOpen
        {
            get { return m_PV41ValveIsOpen; }
            set { SetProperty(ref m_PV41ValveIsOpen, value); }
        }
        public bool PV42ValveIsOpen
        {
            get { return m_PV42ValveIsOpen; }
            set { SetProperty(ref m_PV42ValveIsOpen, value); }
        }
        public bool MFC4ValveIsOpen
        {
            get { return m_MFC4ValveIsOpen; }
            set { SetProperty(ref m_MFC4ValveIsOpen, value); }
        }
        public bool MFC5ValveIsOpen
        {
            get { return m_MFC5ValveIsOpen; }
            set { SetProperty(ref m_MFC5ValveIsOpen, value); }
        }
        public bool MFC6ValveIsOpen
        {
            get { return m_MFC6ValveIsOpen; }
            set { SetProperty(ref m_MFC6ValveIsOpen, value); }
        }
        public bool MFC7ValveIsOpen
        {
            get { return m_MFC7ValveIsOpen; }
            set { SetProperty(ref m_MFC7ValveIsOpen, value); }
        }
        public bool MFC8ValveIsOpen
        {
            get { return m_MFC8ValveIsOpen; }
            set { SetProperty(ref m_MFC8ValveIsOpen, value); }
        }

        public bool MFC9ValveIsOpen
        {
            get { return m_MFC9ValveIsOpen; }
            set { SetProperty(ref m_MFC9ValveIsOpen, value); }
        }
        public bool MFC10ValveIsOpen
        {
            get { return m_MFC10ValveIsOpen; }
            set { SetProperty(ref m_MFC10ValveIsOpen, value); }
        }
        public bool MFC11ValveIsOpen
        {
            get { return m_MFC11ValveIsOpen; }
            set { SetProperty(ref m_MFC11ValveIsOpen, value); }
        }
        public bool MFC12ValveIsOpen
        {
            get { return m_MFC12ValveIsOpen; }
            set { SetProperty(ref m_MFC12ValveIsOpen, value); }
        }
        public bool PVHe1ValveIsOpen
        {
            get { return m_PVHe1ValveIsOpen; }
            set { SetProperty(ref m_PVHe1ValveIsOpen, value); }
        }
        public bool PVHe2ValveIsOpen
        {
            get { return m_PVHe2ValveIsOpen; }
            set { SetProperty(ref m_PVHe2ValveIsOpen, value); }
        }

        public bool PVHe3ValveIsOpen
        {
            get { return m_PVHe3ValveIsOpen; }
            set { SetProperty(ref m_PVHe3ValveIsOpen, value); }
        }

        public bool HeISOValveIsOpen
        {
            get { return m_HeISOValveIsOpen; }
            set { SetProperty(ref m_HeISOValveIsOpen, value); }
        }
        private bool m_MainPurgeValveIsOpen;
        public bool MainPurgeValveIsOpen
        {
            get { return m_MainPurgeValveIsOpen; }
            set { SetProperty(ref m_MainPurgeValveIsOpen, value); }
        }

        private bool m_SecondPurgeValveIsOpen;
        public bool SecondPurgeValveIsOpen
        {
            get { return m_SecondPurgeValveIsOpen; }
            set { SetProperty(ref m_SecondPurgeValveIsOpen, value); }
        }
        public bool TurboPumpPumpingValveIsOpen
        {
            get { return m_TurboPumpPumpingValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPumpingValveIsOpen, value); }
        }
        public bool TurboPumpPurgeValveIsOpen
        {
            get { return m_TurboPumpPurgeValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPurgeValveIsOpen, value); }
        }
        public bool SoftPumpValveIsOpen
        {
            get { return m_SoftPumpValveIsOpen; }
            set { SetProperty(ref m_SoftPumpValveIsOpen, value); }
        }
        public bool FastPumpValveIsOpen
        {
            get { return m_FastPumpValveIsOpen; }
            set { SetProperty(ref m_FastPumpValveIsOpen, value); }
        }
        public bool GuageValveIsOpen
        {
            get { return m_GuageValveIsOpen; }
            set { SetProperty(ref m_GuageValveIsOpen, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool GasIsFlowing
        {
            get { return m_GasIsFlowing; }
            set { SetProperty(ref m_GasIsFlowing, value); }
        }
        #endregion
        public bool MFC7IsEnable
        {
            get { return m_MFC7IsEnable; }
            set { SetProperty(ref m_MFC7IsEnable, value); }
        }
        public bool MFC8IsEnable
        {
            get { return m_MFC8IsEnable; }
            set { SetProperty(ref m_MFC8IsEnable, value); }
        }

        public bool PV51ValveIsOpen
        {
            get { return m_PV51ValveIsOpen; }
            set { SetProperty(ref m_PV51ValveIsOpen, value); }
        }
        public bool PV52ValveIsOpen
        {
            get { return m_PV52ValveIsOpen; }
            set { SetProperty(ref m_PV52ValveIsOpen, value); }
        }
        public bool PV61ValveIsOpen
        {
            get { return m_PV61ValveIsOpen; }
            set { SetProperty(ref m_PV61ValveIsOpen, value); }
        }
        public bool PV62ValveIsOpen
        {
            get { return m_PV62ValveIsOpen; }
            set { SetProperty(ref m_PV62ValveIsOpen, value); }
        }
        public bool PV71ValveIsOpen
        {
            get { return m_PV71ValveIsOpen; }
            set { SetProperty(ref m_PV71ValveIsOpen, value); }
        }
        public bool PV72ValveIsOpen
        {
            get { return m_PV72ValveIsOpen; }
            set { SetProperty(ref m_PV72ValveIsOpen, value); }
        }
        public bool PV81ValveIsOpen
        {
            get { return m_PV81ValveIsOpen; }
            set { SetProperty(ref m_PV81ValveIsOpen, value); }
        }
        public bool PV82ValveIsOpen
        {
            get { return m_PV82ValveIsOpen; }
            set { SetProperty(ref m_PV82ValveIsOpen, value); }
        }
        public bool PV91ValveIsOpen
        {
            get { return m_PV91ValveIsOpen; }
            set { SetProperty(ref m_PV91ValveIsOpen, value); }
        }
        public bool PV92ValveIsOpen
        {
            get { return m_PV92ValveIsOpen; }
            set { SetProperty(ref m_PV92ValveIsOpen, value); }
        }
        public bool PVA1ValveIsOpen
        {
            get { return m_PVA1ValveIsOpen; }
            set { SetProperty(ref m_PVA1ValveIsOpen, value); }
        }
        public bool PVA2ValveIsOpen
        {
            get { return m_PVA2ValveIsOpen; }
            set { SetProperty(ref m_PVA2ValveIsOpen, value); }
        }
        public bool PVB1ValveIsOpen
        {
            get { return m_PVB1ValveIsOpen; }
            set { SetProperty(ref m_PVB1ValveIsOpen, value); }
        }
        public bool PVB2ValveIsOpen
        {
            get { return m_PVB2ValveIsOpen; }
            set { SetProperty(ref m_PVB2ValveIsOpen, value); }
        }
        public bool PVC1ValveIsOpen
        {
            get { return m_PVC1ValveIsOpen; }
            set { SetProperty(ref m_PVC1ValveIsOpen, value); }
        }
        public bool PVC2ValveIsOpen
        {
            get { return m_PVC2ValveIsOpen; }
            set { SetProperty(ref m_PVC2ValveIsOpen, value); }
        }

        public bool PV14ValveIsOpen
        {
            get { return m_PV14ValveIsOpen; }
            set { SetProperty(ref m_PV14ValveIsOpen, value); }
        }

        private bool m_GasIs8;
        private bool m_GasIs12;
        public bool GasIs8
        {
            get { return m_GasIs8; }
            set { SetProperty(ref m_GasIs8, value); }
        }
        public bool GasIs12
        {
            get { return m_GasIs12; }
            set { SetProperty(ref m_GasIs12, value); }
        }



        public PressureType PressureType
        {
            get { return m_PressureType; }
            set { SetProperty(ref m_PressureType, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _CheckCommand;
        public DelegateCommand CheckCommand =>
            _CheckCommand ?? (_CheckCommand = new DelegateCommand(OnCheck));


        private DelegateCommand _AbortCommand;
        public DelegateCommand AbortCommand =>
            _AbortCommand ?? (_AbortCommand = new DelegateCommand(OnAbort));

        //private DelegateCommand _ExportCommand;
        //public DelegateCommand ExportCommand =>
        //    _ExportCommand ?? (_ExportCommand = new DelegateCommand(OnExport));
        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(OnLoaded));

        private DelegateCommand<object> _ControlValveCommand;
        public DelegateCommand<object> ControlValveCommand =>
            _ControlValveCommand ?? (_ControlValveCommand = new DelegateCommand<object>(OnControlValve));
        
        private DelegateCommand<object> _Control12ValveCommand;
        public DelegateCommand<object> Control12ValveCommand =>
            _Control12ValveCommand ?? (_Control12ValveCommand = new DelegateCommand<object>(OnControl12Valve));

        private DelegateCommand _GasPurgeCommand;
        public DelegateCommand GasPurgeCommand =>
            _GasPurgeCommand ?? (_GasPurgeCommand = new DelegateCommand(OnGasPurge));

        private DelegateCommand _GasCommand;
        public DelegateCommand GasCommand =>
            _GasCommand ?? (_GasCommand = new DelegateCommand(OnGas));


        private DispatcherTimer timer;
        #endregion

        #region 构造函数
        public GasLeakCheckViewModel()
        {
            
            m_LeakCheckMode = new List<string>() { "ChamberOnly", "ChamberAndGasLine", "ChamberAndGasLineAndFAC" };
            m_LeakCheckModeSelectedIndex = 0;
            m_VentTime = 120;
            m_CheckTime = 180;
            m_LeakRateUpperLimit = 10;
            BasePressure = 100;

            

            addDataKeys();
            

            timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            timer.Start();


        }
        #endregion

        #region 命令方法
        private void OnCheck()
        {          
            if (LeakCheckModeSelectedIndex == 0)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.LeakCheck", VentTime, CheckTime, LeakRateUpperLimit);
            }
            else if (LeakCheckModeSelectedIndex == 1 || LeakCheckModeSelectedIndex == 2)
            {
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 1; i < 9; i++)
                {
                    if (GasIsCheck[i] == true)
                    {
                        var value = i.ToString();
                        stringBuilder.Append(value);
                        stringBuilder.Append(',');
                    }
                }
                if (stringBuilder.Length > 0)
                {
                    stringBuilder.Remove(stringBuilder.Length - 1, 1);
                }           
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GasLeakCheck", VentTime, CheckTime, LeakRateUpperLimit, stringBuilder.ToString(), GasIsCheck[0], LeakCheckMode[LeakCheckModeSelectedIndex]);
            }
        }
        private void OnAbort()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
        }
        
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", Convert.ToInt32(commonValveControl.Tag.ToString()), !commonValveControl.Status);
            }
        }

        private void OnControl12Valve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", commonValveControl.Tag.ToString(), !commonValveControl.Status);
            }
        }

        private void OnGasPurge()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GasLinePurge");
        }

        private async void OnGas()
        {                  
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas1.SetPoint", MFC1SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas2.SetPoint", MFC2SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas3.SetPoint", MFC3SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas4.SetPoint", MFC4SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas5.SetPoint", MFC5SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas6.SetPoint", MFC6SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas7.SetPoint", MFC7SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas8.SetPoint", MFC8SetPoint);

                await Task.Delay(500);

                object[] mfc = new object[8];
                mfc[0] = MFC1Data.SetPoint;
                mfc[1] = MFC2Data.SetPoint;
                mfc[2] = MFC3Data.SetPoint;
                mfc[3] = MFC4Data.SetPoint;
                mfc[4] = MFC5Data.SetPoint;
                mfc[5] = MFC6Data.SetPoint;
                mfc[6] = MFC7Data.SetPoint;
                mfc[7] = MFC8Data.SetPoint;

                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.GasFlow}", mfc);
        }
        private void OnLoaded()
        {
            if (m_firstLoadFlag==true)
            {
                ChamberType = (JetChamber)Enum.Parse(typeof(JetChamber), QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.ChamberType").ToString());
                GasIs8 = ChamberType != JetChamber.VenusSE && ChamberType != JetChamber.VenusDE;
                GasIs12 = ChamberType == JetChamber.VenusSE || ChamberType == JetChamber.VenusDE;
                var AllLeakCheckDa = QueryDataClient.Instance.Service.GetPMLeakCheckResult(ModuleName);
                if (AllLeakCheckDa != null)
                {
                    LeakCheckResultList = new ObservableCollection<PMLeakCheckResult>(AllLeakCheckDa);

                }
                MFC7IsEnable = (bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.MfcGas7.Enable");
                MFC8IsEnable = (bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.MfcGas8.Enable");

                var m_ChamberType = (JetChamber)Enum.Parse(typeof(JetChamber), QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.ChamberType").ToString());
                if (m_ChamberType == JetChamber.Kepler2200A || m_ChamberType == JetChamber.Kepler2200B)
                {
                    PressureType = PressureType.Pa;
                }
                m_firstLoadFlag = false;
                add12DataKeys();

            }
            

        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {          
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            N2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveN2.IsOpen"];
            GasFinalValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveGasFinal.IsOpen"];
            PV11ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV11.IsOpen"];
            PV12ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV12.IsOpen"];
            PV21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV21.IsOpen"];
            PV22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV22.IsOpen"];
            PV31ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV31.IsOpen"];
            PV32ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV32.IsOpen"];
            PV41ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV41.IsOpen"];
            PV42ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV42.IsOpen"];


            MFC1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc1.IsOpen"];
            MFC2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc2.IsOpen"];
            MFC3ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc3.IsOpen"];
            MFC4ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc4.IsOpen"];
            MFC5ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc5.IsOpen"];
            MFC6ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc6.IsOpen"];
            MFC7ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc7.IsOpen"];
            MFC8ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc8.IsOpen"];
            PVN21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN21.IsOpen"];
            PVN22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN22.IsOpen"];
            MFC1Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas1"];
            MFC2Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas2"];
            MFC3Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas3"];
            MFC4Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas4"];
            MFC5Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas5"];
            MFC6Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas6"];
            MFC7Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas7"];
            MFC8Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas8"];


            MFCN2Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcN2"];

            if (ChamberType == JetChamber.VenusSE)
            {
                MFC9Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas9"];
                MFC10Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas10"];
                MFC11Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas11"];
                MFC12Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas12"];
                //12 valve
                PV51ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV51.IsOpen"];
                PV52ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV52.IsOpen"];
                PV61ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV61.IsOpen"];
                PV62ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV62.IsOpen"];
                PV71ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV71.IsOpen"];
                PV72ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV72.IsOpen"];
                PV81ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV81.IsOpen"];
                PV82ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV82.IsOpen"];
                PV91ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV91.IsOpen"];
                PV92ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV92.IsOpen"];
                PVA1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVA1.IsOpen"];
                PVA2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVA2.IsOpen"];
                PVB1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVB1.IsOpen"];
                PVB2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVB2.IsOpen"];
                PVC1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVC1.IsOpen"];
                PVC2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVC2.IsOpen"];
                //12 mfc
                MFC9ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc9.IsOpen"];
                MFC10ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc10.IsOpen"];
                MFC11ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc11.IsOpen"];
                MFC12ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc12.IsOpen"];
                //purge
                MainPurgeValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMainPurge.IsOpen"];
                SecondPurgeValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveSecondPurge.IsOpen"];
                PV14ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV14.IsOpen"];
            }
            else if (ChamberType == JetChamber.VenusDE)
            {
                MFC9Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas9"];
                MFC10Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas10"];
                MFC11Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas11"];
                MFC12Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas12"];
                //12 valve
                PV51ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV51.IsOpen"];
                PV52ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV52.IsOpen"];
                PV61ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV61.IsOpen"];
                PV62ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV62.IsOpen"];
                PV71ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV71.IsOpen"];
                PV72ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV72.IsOpen"];
                PV81ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV81.IsOpen"];
                PV82ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV82.IsOpen"];
                PV91ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV91.IsOpen"];
                PV92ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV92.IsOpen"];
                PVA1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVA1.IsOpen"];
                PVA2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVA2.IsOpen"];
                PVB1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVB1.IsOpen"];
                PVB2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVB2.IsOpen"];
                PVC1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVC1.IsOpen"];
                PVC2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVC2.IsOpen"];
                //12 mfc
                MFC9ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc9.IsOpen"];
                MFC10ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc10.IsOpen"];
                MFC11ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc11.IsOpen"];

                //purge
                MainPurgeValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMainPurge.IsOpen"];
                SecondPurgeValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveSecondPurge.IsOpen"];
            }
            


            PMCurrentState = (PMState)Enum.Parse(typeof(PMState), RtDataValues[$"{ModuleName}.FsmState"].ToString());

            GasIsFlowing = (PMState)RtDataValues[$"{ModuleName}.FsmState"] == PMState.GasFlowing;
            IsAutoMode = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsOnline");
            if ((PMState)RtDataValues[$"{ModuleName}.FsmState"] == PMState.GasBoxLeakCheck)
            {
                CurrentStep = RtDataValues[$"{ModuleName}.GasLeakCheck.Step"]?.ToString();
                stepTimeCountValue += 1;
                StepTime=TimeSpan.FromSeconds(stepTimeCountValue);
                
            }
            else if ((PMState)RtDataValues[$"{ModuleName}.FsmState"] == PMState.LeakCheck)
            {
                CurrentStep = RtDataValues[$"{ModuleName}.LeakCheck.Step"]?.ToString();
                stepTimeCountValue += 1;
                StepTime = TimeSpan.FromSeconds(stepTimeCountValue);
            }
            else
            {
                CurrentStep = "";

                StepTime = null;
            }
        }
        public void addDataKeys()
        {
            m_RtDataKeys.Clear();
            m_RtDataKeys.Add("System.IsAutoMode");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas1");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas2");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas3");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas4");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas5");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas6");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas7");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas8");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas9");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas10");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas11");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas12");
            m_RtDataKeys.Add($"{ModuleName}.MfcN2");

            m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV11.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV12.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV31.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV32.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV41.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV42.IsOpen");


            m_RtDataKeys.Add($"{ModuleName}.ValveMfc1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc3.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc4.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc5.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc6.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc7.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc8.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGasFinal.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveSoftPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveFastPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveN2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPurge.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGuage.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.FsmState");
            m_RtDataKeys.Add($"{ModuleName}.GasLeakCheck.Step");
            m_RtDataKeys.Add($"{ModuleName}.LeakCheck.Step");
            m_RtDataKeys.Add($"{ModuleName}.IsOnline");


        }

        public void add12DataKeys()
        {
             if (ChamberType == JetChamber.VenusSE)
            {
                //12 valve
                m_RtDataKeys.Add($"{ModuleName}.ValvePV14.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV51.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV52.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV61.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV62.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV71.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV72.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV81.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV82.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV91.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV92.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVA1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVA2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVB1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVB2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVC1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVC2.IsOpen");
                //12 mfc
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc9.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc10.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc11.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc12.IsOpen");
                //purge
                m_RtDataKeys.Add($"{ModuleName}.ValveMainPurge.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveSecondPurge.IsOpen");
            }else if ( ChamberType == JetChamber.VenusDE)
            {
                m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV11.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV12.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV21.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV22.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV31.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV32.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV41.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV42.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV51.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV52.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV61.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV62.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV71.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV72.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV81.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV82.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV91.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePV92.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVA1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVA2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVB1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVB2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVC1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValvePVC2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc1.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc2.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc3.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc4.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc5.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc6.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc7.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc8.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc9.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc10.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveMfc11.IsOpen");
                //purge
                m_RtDataKeys.Add($"{ModuleName}.ValveMainPurge.IsOpen");
                m_RtDataKeys.Add($"{ModuleName}.ValveSecondPurge.IsOpen");
            }


        }
        #endregion
    }
}