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

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

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_MFCN2Data;
        private PMState m_PMCurrentState;

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

        private bool m_MFC7IsEnable;
        private bool m_MFC8IsEnable;


        #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;
        #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;
        #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 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);
            }
        }
        #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 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 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); }
        }
        #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 _GasPurgeCommand;
        public DelegateCommand GasPurgeCommand =>
            _GasPurgeCommand ?? (_GasPurgeCommand = new DelegateCommand(OnGasPurge));

        private DelegateCommand _GasCommand;
        public DelegateCommand GasCommand =>
            _GasCommand ?? (_GasCommand = new DelegateCommand(OnGas));
        #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();
         
            DispatcherTimer 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 OnExport()
        //{
        //    OpenFileDialog dialog = new OpenFileDialog();
        //    dialog.Filter = ".json|*.json";
        //    dialog.InitialDirectory = Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "LeakCheck");
        //    if (dialog.ShowDialog() == true)
        //    {
        //        string SelectedPath = dialog.FileName;
        //        LeakCheckResultList.Add (SerializeHelper.Instance.ReadFromJsonFile<PMLeakCheckResult>(SelectedPath));
        //    }
        //}
        
        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 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()
        {
            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");
        }
        #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"];
            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}.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");



        }
        #endregion
    }
}