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

using MECF.Framework.Common.CommonData;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Threading.Tasks;
using Venus_Core;
using OpenSEMI.ClientBase;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;
using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.CommonData.DeviceData;
using MECF.Framework.Common.OperationCenter;
using Venus_MainPages.Views;
using System.Windows.Threading;
using RecipeStep = Venus_Core.RecipeStep;
using Aitex.Core.RT.Log;
using Venus_Themes.UserControls;
using Prism.Commands;
using MECF.Framework.Common.DataCenter;
using System.IO;
using System.Windows.Controls;
using System.Collections.ObjectModel;

namespace Venus_MainPages.ViewModels
{
    public class OverVenusDEViewModel : BindableBase
    {
        #region 私有字段
        private List<string> m_CurrentModuleRecipes = new List<string>();
        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_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_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_MFC9ValveIsOpen;
        private bool m_MFC10ValveIsOpen;
        private bool m_MFC11ValveIsOpen;
        private bool m_MFC12ValveIsOpen;
        private bool m_GasFinalValveIsOpen;
        //private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
        private bool m_HeIsOpen;
        private bool m_HeOutIsOpen;
        private bool m_PVHe1ValveIsOpen;
        private bool m_PVHe2ValveIsOpen;
        private bool m_PVHe3ValveIsOpen;
        private bool m_PVHe4ValveIsOpen;
        private bool m_HeISOValveIsOpen;
        private bool m_HeISOOutValveIsOpen;
        private bool m_PurgeValveIsOpen;


        private bool m_TurboPumpPumpingValveIsOpen;
        private bool m_TurboPumpPurgeValveIsOpen;
        private bool m_GuageValveIsOpen;
        private bool m_PendulumValveIsOpen;


        //private bool m_BRFIsOn;
        //private bool m_SRFIsOn;

        private double m_HeGasSetpoint;
        private double m_HeOutGasSetpoint;
        private int m_HePressureSetpoint;
        private bool m_Valve12Visible;
        private bool m_Valve11Visible;
        private float m_SRFFwdPowerSetpoint;
        private float m_MagnetSetpoint;
        private float m_BRFFwdPowerSetpoint;

        private float m_SRFMatchC1;
        private float m_SRFMatchC2;
        private float m_BRFMatchC1;
        private float m_BRFMatchC2;
        private float m_MagnetIntensity;
        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;
        private double m_MFC9SetPoint;
        private double m_MFC10SetPoint;
        private double m_MFC11SetPoint;
        private double m_MFC12SetPoint;
        private double m_N2SetPoint;
        private double m_TurboN2FlowSetPoint;





        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_MFCHeData;
        private AITMfcData m_MFCHeOutData;
        private AITMfcData m_MFCN2Data;

        private AITHeaterData m_ValveHeaterData;
        private AITMagnetData m_MagnetData;
        private AITHeaterData m_ForelineHeaterData;
        private AITHeaterData m_WallHeaterData;

        private AITRfData m_SRFData;
        private AITRfData m_BRFData;
        private AITMatchData m_BRMatch;

        private AITPendulumValveData m_PendulumValveData;

        private AITHVData m_ESCHVData;

        private PMState m_PMCurrentState;

        private bool m_BiasRFFanInterlock;
        private bool m_IsWLK;
        private bool m_IsWaterFlowOk;
        private bool m_IsTurboPumpInterlock;
        private bool m_IsCDAOK;
        private bool m_SensorGasBoxDoor;
        private bool m_SensorGasBoxPressure;

        private bool m_PumpIsOpen;
        private bool m_TurboIsOpen;
        private bool m_IsATM;
        private bool m_IsVAC;

        private bool m_load = false;
        private List<string> m_RtDataKeys;
        private Dictionary<string, object> m_RtDataValues;

        private int m_PositionValue;
        private bool m_IsPositionMode;

        private int m_ESCVoltage;

        private bool m_GasIsFlowing;
        private bool m_IsProcessing;


        private bool m_IsAutoMode;
        private string m_SelectedRecipe;

        private float m_ChillerTempSetpoint;
        private float m_WallTempSetpoint;

        private bool m_HeIsPressureMode = true;
        private bool m_HeOutIsPressureMode = true;

        private bool m_ChillerIsOn;
        private bool m_WallChillerIsOn;

        private float m_ChamberPressure;
        private float m_ProcessPressure;
        private float m_ForelinePressurePressure;
        private float m_ESCHePressure;
        private float m_ESCHeOutPressure;



        ButterflyValveView butterflyValveMessageBox;
        HeaterView heaterView;

        private int m_TurboPumpRotationalSpeed;

        private bool m_LiftPinIsUp;
        private bool m_IsSlitDoorClosed = true;
        private bool m_IsLinerDoorClosed;
        private bool m_IsLidClosed = true;

        private bool m_Is8Inch = false;
        private float m_ChillerTemperature;
        private float m_WallChillerTemperature;
        private float m_HVTemperature;


        private int m_ESCHVOutputVoltage;

        //private float m_SRfReflectPower;
        //private float m_SRfForwardPowerFeedBack;

        //private float m_BRfReflectPower;
        //private float m_BRfForwardPowerFeedBack;

        //private int m_MatchWorkMode;
        //private int m_BiasMatchWorkMode;

        private float m_MatchC1;
        private float m_MatchC2;
        private float m_BiasMatchC1;
        private float m_BiasMatchC2;
        private float m_BiasMatchVDC;

        private float m_PendulumValvePosition;

        private bool m_IsTurboPumpAtSpeed;
        private bool m_TurboPumpWaterFlowSwitch;

        private bool m_IsHasWafer;

        private Recipe m_CurrentRecipe = new Recipe();

        private RecipeResult m_CurrentRecipeResult = new RecipeResult();

        private RecipeStep m_CurrentRecipeStep = new RecipeStep();
        private int m_SelectedRecipeIndex = -1;
        private double m_ChamberPressureFeedBack;
        private ComboBoxItem m_SelectedRecipeType;
        private string m_WaferID;
        private string m_ModuleName;
        private int? currentRecipeNumber;

        #endregion
        #region  属性
        public List<string> CurrentModuleRecipes
        {
            get { return m_CurrentModuleRecipes; }
            set { SetProperty(ref m_CurrentModuleRecipes, value); }

        }
        public Recipe CurrentRecipe
        {
            get { return m_CurrentRecipe; }
            set { SetProperty(ref m_CurrentRecipe, value); }

        }
        public RecipeResult CurrentRecipeResult
        {
            get { return m_CurrentRecipeResult; }
            set { SetProperty(ref m_CurrentRecipeResult, value); }
        }

        public RecipeStep CurrentRecipeStep
        {
            get
            {
                if (m_CurrentRecipeStep != null && m_CurrentRecipeStep.LstUnit.Count > 4)
                    return m_CurrentRecipeStep;
                else
                {

                    m_CurrentRecipeStep = new RecipeStep();
                    if (m_CurrentRecipeStep != null && m_CurrentRecipeStep.LstUnit.Count > 4)
                        return m_CurrentRecipeStep;
                    else
                    {

                        m_CurrentRecipeStep = new RecipeStep();
                        m_CurrentRecipeStep.LstUnit.Add(new PressureByPressureModeUnit()
                        {
                            StartValue = 0,
                            ValvePositionPreset = 0,
                        });
                        m_CurrentRecipeStep.LstUnit.Add(new object());
                        m_CurrentRecipeStep.LstUnit.Add(new object());
                        m_CurrentRecipeStep.LstUnit.Add(new VenusDEGasControlUnit()
                        {
                            Gas1 = 0,
                            Gas2 = 0,
                            Gas3 = 0,
                            Gas4 = 0,
                            Gas5 = 0,
                            Gas6 = 0,
                            Gas7 = 0,
                            Gas8 = 0,
                            Gas9 = 0,
                            Gas10 = 0,
                            Gas11 = 0,
                            Gas12 = 0,
                        });
                        m_CurrentRecipeStep.LstUnit.Add(new ESCHVUnit()
                        {
                            ESCClampValtage = 0,
                            BacksideHelium = 0,
                        });
                        return m_CurrentRecipeStep;
                    }
                }
            }
            set { SetProperty(ref m_CurrentRecipeStep, value); }
        }
        public bool IsHasWafer
        {
            get { return m_IsHasWafer; }
            set { SetProperty(ref m_IsHasWafer, value); }
        }
        public bool IsTurboPumpAtSpeed
        {
            get { return m_IsTurboPumpAtSpeed; }
            set { SetProperty(ref m_IsTurboPumpAtSpeed, value); }
        }
        public bool Valve12Visible
        {
            get { return m_Valve12Visible; }
            set { SetProperty(ref m_Valve12Visible, value); }
        }
        public bool Valve11Visible
        {
            get { return m_Valve11Visible; }
            set { SetProperty(ref m_Valve11Visible, value); }
        }
        public bool TurboPumpWaterFlowSwitch
        {
            get { return m_TurboPumpWaterFlowSwitch; }
            set { SetProperty(ref m_TurboPumpWaterFlowSwitch, value); }
        }
        public float PendulumValvePosition
        {
            get { return m_PendulumValvePosition; }
            set { SetProperty(ref m_PendulumValvePosition, value); }
        }

        public float BiasMatchC1
        {
            get { return m_BiasMatchC1; }
            set
            {
                SetProperty(ref m_BiasMatchC1, value);
            }
        }
        public float BiasMatchC2
        {
            get { return m_BiasMatchC2; }
            set
            {
                SetProperty(ref m_BiasMatchC2, value);
            }
        }

        public float BiasMatchVDC
        {
            get { return m_BiasMatchVDC; }
            set
            {
                SetProperty(ref m_BiasMatchVDC, value);
            }
        }

        public float MatchC1
        {
            get { return m_MatchC1; }
            set
            {
                SetProperty(ref m_MatchC1, value);
            }
        }
        public float MatchC2
        {
            get { return m_MatchC2; }
            set
            {
                SetProperty(ref m_MatchC2, value);
            }
        }

        public AITPendulumValveData PendulumValveData
        {
            get { return m_PendulumValveData; }
            set
            {
                SetProperty(ref m_PendulumValveData, value);
            }
        }

        public AITHVData ESCHVData
        {
            get { return m_ESCHVData; }
            set
            {
                SetProperty(ref m_ESCHVData, value);
            }
        }
        public int ESCHVOutputVoltage
        {
            get { return m_ESCHVOutputVoltage; }
            set
            {
                SetProperty(ref m_ESCHVOutputVoltage, value);
            }
        }
        public float ChillerTemperature
        {
            get { return m_ChillerTemperature; }
            set
            {
                SetProperty(ref m_ChillerTemperature, value);
            }
        }
        public float WallChillerTemperature
        {
            get { return m_WallChillerTemperature; }
            set
            {
                SetProperty(ref m_WallChillerTemperature, value);
            }
        }
        public float HVTemperature
        {
            get { return m_HVTemperature; }
            set
            {
                SetProperty(ref m_HVTemperature, value);
            }
        }
        public bool IsLidClosed
        {
            get { return m_IsLidClosed; }
            set
            {
                SetProperty(ref m_IsLidClosed, value);
            }
        }

        public bool IsSlitDoorClosed
        {
            get { return m_IsSlitDoorClosed; }
            set
            {
                SetProperty(ref m_IsSlitDoorClosed, value);
            }
        }
        public bool IsLinerDoorClosed
        {
            get { return m_IsLinerDoorClosed; }
            set
            {
                SetProperty(ref m_IsLinerDoorClosed, value);
            }
        }

        public bool LiftPinIsUp
        {
            get { return m_LiftPinIsUp; }
            set
            {
                SetProperty(ref m_LiftPinIsUp, value);
            }
        }

        public bool Is8Inch
        {
            get { return m_Is8Inch; }
            set
            {
                SetProperty(ref m_Is8Inch, value);
            }
        }
        
        public int TurboPumpRotationalSpeed
        {
            get { return m_TurboPumpRotationalSpeed; }
            set
            {
                SetProperty(ref m_TurboPumpRotationalSpeed, value);
            }
        }

        public float ESCHePressure
        {
            get { return m_ESCHePressure; }
            set
            {
                SetProperty(ref m_ESCHePressure, value);
            }
        }

        public float ESCHeOutPressure
        {
            get { return m_ESCHeOutPressure; }
            set
            {
                SetProperty(ref m_ESCHeOutPressure, value);
            }
        }
        public float ChamberPressure
        {
            get { return m_ChamberPressure; }
            set
            {
                SetProperty(ref m_ChamberPressure, value);
            }
        }
        public float ProcessPressure
        {
            get { return m_ProcessPressure; }
            set
            {
                SetProperty(ref m_ProcessPressure, value);
            }
        }
        public float ForelinePressure
        {
            get { return m_ForelinePressurePressure; }
            set
            {
                SetProperty(ref m_ForelinePressurePressure, value);
            }
        }
        public bool BiasRFFanInterlock
        {
            get { return m_BiasRFFanInterlock; }
            set
            {
                SetProperty(ref m_BiasRFFanInterlock, value);
            }
        }
        public bool IsWLK
        {
            get { return m_IsWLK; }
            set
            {
                SetProperty(ref m_IsWLK, value);
            }
        }
        public bool IsWaterFlowOk
        {
            get { return m_IsWaterFlowOk; }
            set
            {
                SetProperty(ref m_IsWaterFlowOk, 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 IsCDAOK
        {
            get { return m_IsCDAOK; }
            set
            {
                SetProperty(ref m_IsCDAOK, value);
            }
        }
        public bool SensorGasBoxDoor
        {
            get { return m_SensorGasBoxDoor; }
            set
            {
                SetProperty(ref m_SensorGasBoxDoor, value);
            }
        }

        public bool SensorGasBoxPressure
        {
            get { return m_SensorGasBoxPressure; }
            set
            {
                SetProperty(ref m_SensorGasBoxPressure, value);
            }
        }

        public bool IsTurboPumpInterlock
        {
            get { return m_IsTurboPumpInterlock; }
            set
            {
                SetProperty(ref m_IsTurboPumpInterlock, value);
            }
        }
        public string ModuleName
        {
            get { return m_ModuleName; }
            set
            {
                SetProperty(ref m_ModuleName, 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 double N2SetPoint
        {
            get { return m_N2SetPoint; }
            set { SetProperty(ref m_N2SetPoint, value); }
        }
        public double TurboN2FlowSetPoint
        {
            get { return m_TurboN2FlowSetPoint; }
            set
            {
                if (value != m_TurboN2FlowSetPoint)
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcN2.SetPoint", value);
                }
                SetProperty(ref m_TurboN2FlowSetPoint, 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 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 AITMfcData MFCHeData
        {
            get { return m_MFCHeData; }
            set { SetProperty(ref m_MFCHeData, value); }
        }
        public AITMfcData MFCHeOutData
        {
            get { return m_MFCHeOutData; }
            set { SetProperty(ref m_MFCHeOutData, value); }
        }
        public AITMfcData MFCN2Data
        {
            get { return m_MFCN2Data; }
            set { SetProperty(ref m_MFCN2Data, value); }
        }
        public AITHeaterData ValveHeaterData
        {
            get { return m_ValveHeaterData; }
            set { SetProperty(ref m_ValveHeaterData, value); }
        }
        public AITMagnetData MagnetData
        {
            get { return m_MagnetData; }
            set { SetProperty(ref m_MagnetData, value); }
        }
        public AITHeaterData ForelineHeaterData
        {
            get { return m_ForelineHeaterData; }
            set { SetProperty(ref m_ForelineHeaterData, value); }
        }
        public AITHeaterData WallHeaterData
        {
            get { return m_WallHeaterData; }
            set { SetProperty(ref m_WallHeaterData, value); }
        }
        public int SelectedRecipeIndex
        {
            get { return m_SelectedRecipeIndex; }
            set { SetProperty(ref m_SelectedRecipeIndex, value); }
        }
        public AITRfData SRFData
        {
            get { return m_SRFData; }
            set { SetProperty(ref m_SRFData, value); }
        }
        public AITRfData BRFData
        {
            get { return m_BRFData; }
            set { SetProperty(ref m_BRFData, value); }
        }

        public AITMatchData BRMatch
        {
            get { return m_BRMatch; }
            set { SetProperty(ref m_BRMatch, value); }
        }
        public PMState PMCurrentState
        {
            get { return m_PMCurrentState; }
            set { SetProperty(ref m_PMCurrentState, 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 PurgeValveIsOpen
        {
            get { return m_PurgeValveIsOpen; }
            set { SetProperty(ref m_PurgeValveIsOpen, 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 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 HeIsOpen
        {
            get { return m_HeIsOpen; }
            set { SetProperty(ref m_HeIsOpen, value); }
        }
        public bool HeOutIsOpen
        {
            get { return m_HeOutIsOpen; }
            set { SetProperty(ref m_HeOutIsOpen, 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 PVHe4ValveIsOpen
        {
            get { return m_PVHe4ValveIsOpen; }
            set { SetProperty(ref m_PVHe4ValveIsOpen, value); }
        }
        public bool HeISOValveIsOpen
        {
            get { return m_HeISOValveIsOpen; }
            set { SetProperty(ref m_HeISOValveIsOpen, value); }
        }

        public bool HeISOOutValveIsOpen
        {
            get { return m_HeISOOutValveIsOpen; }
            set { SetProperty(ref m_HeISOOutValveIsOpen, 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); }
        }
        #endregion
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }



        public bool PumpIsOpen
        {
            get { return m_PumpIsOpen; }
            set { SetProperty(ref m_PumpIsOpen, value); }
        }

        public bool PendulumValveIsOpen
        {
            get { return m_PendulumValveIsOpen; }
            set { SetProperty(ref m_PendulumValveIsOpen, value); }
        }

        public bool TurboIsOpen
        {
            get { return m_TurboIsOpen; }
            set { SetProperty(ref m_TurboIsOpen, value); }
        }
        public bool IsATM
        {
            get { return m_IsATM; }
            set { SetProperty(ref m_IsATM, value); }
        }

        public bool IsVAC
        {
            get { return m_IsVAC; }
            set { SetProperty(ref m_IsVAC, value); }
        }


        //public bool BRFIsOn
        //{
        //    get { return m_BRFIsOn; }
        //    set { SetProperty(ref m_BRFIsOn, value); }
        //}
        //public bool SRFIsOn
        //{
        //    get { return m_SRFIsOn; }
        //    set { SetProperty(ref m_SRFIsOn, value); }
        //}

        public int PositionValue
        {
            get { return m_PositionValue; }
            set { SetProperty(ref m_PositionValue, value); }
        }
        public bool IsPositionMode
        {
            get { return m_IsPositionMode; }
            set { SetProperty(ref m_IsPositionMode, value); }
        }


        public double HeGasSetpoint
        {
            get { return m_HeGasSetpoint; }
            set
            {
                SetProperty(ref m_HeGasSetpoint, value);
            }
        }

        public double HeOutGasSetpoint
        {
            get { return m_HeOutGasSetpoint; }
            set
            {
                SetProperty(ref m_HeOutGasSetpoint, value);
            }
        }
        public int HePressureSetpoint
        {
            get { return m_HePressureSetpoint; }
            set
            {
                SetProperty(ref m_HePressureSetpoint, value);
            }
        }
        public float SRFFwdPowerSetpoint
        {
            get { return m_SRFFwdPowerSetpoint; }
            set { SetProperty(ref m_SRFFwdPowerSetpoint, value); }
        }
        public float BRFFwdPowerSetpoint
        {
            get { return m_BRFFwdPowerSetpoint; }
            set { SetProperty(ref m_BRFFwdPowerSetpoint, value); }
        }
        public float MagnetSetpoint
        {
            get { return m_MagnetSetpoint; }
            set { SetProperty(ref m_MagnetSetpoint, value); }
        }
        public int ESCVoltage
        {
            get { return m_ESCVoltage; }
            set { SetProperty(ref m_ESCVoltage, value); }
        }

        public float SRFMatchC1
        {
            get { return m_SRFMatchC1; }
            set { SetProperty(ref m_SRFMatchC1, value); }
        }
        public float SRFMatchC2
        {
            get { return m_SRFMatchC2; }
            set { SetProperty(ref m_SRFMatchC2, value); }
        }

        public float BRFMatchC1
        {
            get { return m_BRFMatchC1; }
            set { SetProperty(ref m_BRFMatchC1, value); }
        }
        public float MagnetIntensity
        {
            get { return m_MagnetIntensity; }
            set { SetProperty(ref m_MagnetIntensity, value); }
        }
        public float BRFMatchC2
        {
            get { return m_BRFMatchC2; }
            set { SetProperty(ref m_BRFMatchC2, value); }
        }
        public bool GasIsFlowing
        {
            get { return m_GasIsFlowing; }
            set { SetProperty(ref m_GasIsFlowing, value); }
        }
        public bool IsProcessing
        {
            get { return m_IsProcessing; }
            set { SetProperty(ref m_IsProcessing, value); }
        }
        public bool IsAutoMode
        {
            get { return m_IsAutoMode; }
            set { SetProperty(ref m_IsAutoMode, value); }
        }
        public string SelectedRecipe
        {
            get { return m_SelectedRecipe; }
            set { SetProperty(ref m_SelectedRecipe, value); }
        }

        public float ChillerTempSetpoint
        {
            get { return m_ChillerTempSetpoint; }
            set { SetProperty(ref m_ChillerTempSetpoint, value); }
        }

        public float WallTempSetpoint
        {
            get { return m_WallTempSetpoint; }
            set { SetProperty(ref m_WallTempSetpoint, value); }
        }

        public bool HeIsPressureMode
        {
            get { return m_HeIsPressureMode; }
            set { SetProperty(ref m_HeIsPressureMode, value); }
        }

        public bool HeOutIsPressureMode
        {
            get { return m_HeOutIsPressureMode; }
            set { SetProperty(ref m_HeOutIsPressureMode, value); }
        }
        public bool ChillerIsOn
        {
            get { return m_ChillerIsOn; }
            set { SetProperty(ref m_ChillerIsOn, value); }
        }
        public bool WallChillerIsOn
        {
            get { return m_WallChillerIsOn; }
            set { SetProperty(ref m_WallChillerIsOn, value); }
        }

        public double ChamberPressureFeedBack
        {
            get { return m_ChamberPressureFeedBack; }
            set { SetProperty(ref m_ChamberPressureFeedBack, value); }
        }

        public string WaferID
        {
            get { return m_WaferID; }
            set { SetProperty(ref m_WaferID, value); }
        }
        public ComboBoxItem SelectedRecipeType
        {
            get { return m_SelectedRecipeType; }
            set { SetProperty(ref m_SelectedRecipeType, value); }
        }
        #endregion
        #region 命令

        private DelegateCommand _PMInitCommnad;
        public DelegateCommand PMInitCommnad =>
            _PMInitCommnad ?? (_PMInitCommnad = new DelegateCommand(OnPMInit));

        private DelegateCommand _PMAbortCommnad;
        public DelegateCommand PMAbortCommnad =>
            _PMAbortCommnad ?? (_PMAbortCommnad = new DelegateCommand(OnPMAbort));

        private DelegateCommand _SwitchTypeCommand;
        public DelegateCommand SwitchTypeCommand =>
        _SwitchTypeCommand ?? (_SwitchTypeCommand = new DelegateCommand(OnSwitchType));

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

        private DelegateCommand _HeCommand;
        public DelegateCommand HeCommand =>
            _HeCommand ?? (_HeCommand = new DelegateCommand(OnHe));
        private DelegateCommand _HeOutCommand;
        public DelegateCommand HeOutCommand =>
            _HeOutCommand ?? (_HeOutCommand = new DelegateCommand(OnHeOut));

        private DelegateCommand _RfCommand;
        public DelegateCommand RfCommand =>
            _RfCommand ?? (_RfCommand = new DelegateCommand(OnRf));

        private DelegateCommand _PurgeCommand;
        public DelegateCommand PurgeCommand =>
            _PurgeCommand ?? (_PurgeCommand = new DelegateCommand(OnPurge));

        private DelegateCommand _VentCommand;
        public DelegateCommand VentCommand =>
            _VentCommand ?? (_VentCommand = new DelegateCommand(OnVent));

        private DelegateCommand _PumpCommand;
        public DelegateCommand PumpCommand =>
            _PumpCommand ?? (_PumpCommand = new DelegateCommand(OnPump));

        private DelegateCommand _OpenPumpCommand;
        public DelegateCommand OpenPumpCommand =>
            _OpenPumpCommand ?? (_OpenPumpCommand = new DelegateCommand(OnOpenPump));

        private DelegateCommand _ClosePumpCommand;
        public DelegateCommand ClosePumpCommand =>
            _ClosePumpCommand ?? (_ClosePumpCommand = new DelegateCommand(OnClosePump));

        private DelegateCommand _OpenTurboPumpCommand;
        public DelegateCommand OpenTurboPumpCommand =>
            _OpenTurboPumpCommand ?? (_OpenTurboPumpCommand = new DelegateCommand(OnOpenTurboPump));

        private DelegateCommand _CloseTurboPumpCommand;
        public DelegateCommand CloseTurboPumpCommand =>
            _CloseTurboPumpCommand ?? (_CloseTurboPumpCommand = new DelegateCommand(OnCloseTurboPump));

        private DelegateCommand _OpenPendulumValveCommand;
        public DelegateCommand OpenPendulumValveCommand =>
            _OpenPendulumValveCommand ?? (_OpenPendulumValveCommand = new DelegateCommand(OnOpenPendulumValve));

        private DelegateCommand _ClosePendulumValveCommand;
        public DelegateCommand ClosePendulumValveCommand =>
            _ClosePendulumValveCommand ?? (_ClosePendulumValveCommand = new DelegateCommand(OnClosePendulumValve));

        private DelegateCommand<object> _PinUpDownCommand;
        public DelegateCommand<object> PinUpDownCommand =>
            _PinUpDownCommand ?? (_PinUpDownCommand = new DelegateCommand<object>(OnPinUpDown));

        //private DelegateCommand _SetSRfCommand;
        //public DelegateCommand SetSRfCommand =>
        //    _SetSRfCommand ?? (_SetSRfCommand = new DelegateCommand(OnSetSRf));

        private DelegateCommand _SetBRfCommand;
        public DelegateCommand SetBRfCommand =>
            _SetBRfCommand ?? (_SetBRfCommand = new DelegateCommand(OnSetBRf));


        private DelegateCommand _SetMagnetCommand;
        public DelegateCommand SetMagnetCommand =>
            _SetMagnetCommand ?? (_SetMagnetCommand = new DelegateCommand(OnSetMagnet));

        private DelegateCommand _OpenButterflyValveViewCommand;
        public DelegateCommand OpenButterflyValveViewCommand =>
            _OpenButterflyValveViewCommand ?? (_OpenButterflyValveViewCommand = new DelegateCommand(OnOpenButterflyValveView));

        private DelegateCommand _HVCommand;
        public DelegateCommand HVCommand =>
            _HVCommand ?? (_HVCommand = new DelegateCommand(OnHV));

        private DelegateCommand _HVSetCommand;
        public DelegateCommand HVSetCommand =>
            _HVSetCommand ?? (_HVSetCommand = new DelegateCommand(OnHVSet));


        private DelegateCommand _LoadRecipeCommand;
        public DelegateCommand LoadRecipeCommand =>
            _LoadRecipeCommand ?? (_LoadRecipeCommand = new DelegateCommand(OnLoadRecipe));


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

        private DelegateCommand<object> _RunRecipeCommand;
        public DelegateCommand<object> RunRecipeCommand =>
            _RunRecipeCommand ?? (_RunRecipeCommand = new DelegateCommand<object>(OnRunRecipe));
        
        private DelegateCommand _SetChillerTempCommand;
        public DelegateCommand SetChillerTempCommand =>
            _SetChillerTempCommand ?? (_SetChillerTempCommand = new DelegateCommand(OnSetChillerTemp));

        private DelegateCommand _SetWallChillerTempCommand;
        public DelegateCommand SetWallChillerTempCommand =>
            _SetWallChillerTempCommand ?? (_SetWallChillerTempCommand = new DelegateCommand(OnSetWallChillerTemp));
        private DelegateCommand _OnOffChillerCommand;
        public DelegateCommand OnOffChillerCommand =>
            _OnOffChillerCommand ?? (_OnOffChillerCommand = new DelegateCommand(OnOffChiller));
        private DelegateCommand _OnOffWallChillerCommand;
        public DelegateCommand OnOffWallChillerCommand =>
            _OnOffWallChillerCommand ?? (_OnOffWallChillerCommand = new DelegateCommand(OnOffWallChiller));

        private DelegateCommand<object> _HeaterCommand;
        public DelegateCommand<object> HeaterCommand =>
            _HeaterCommand ?? (_HeaterCommand = new DelegateCommand<object>(OnHeater));

        private DelegateCommand _EndStepCommand;
        public DelegateCommand EndStepCommand =>
            _EndStepCommand ?? (_EndStepCommand = new DelegateCommand(OnEndStep));

        private DelegateCommand _OnlineCommand;
        public DelegateCommand OnlineCommand =>
            _OnlineCommand ?? (_OnlineCommand = new DelegateCommand(OnOnline));

        private DelegateCommand _OfflineCommand;
        public DelegateCommand OfflineCommand =>
            _OfflineCommand ?? (_OfflineCommand = new DelegateCommand(OnOffline));

        private DelegateCommand<object> _AbortRecipeCommnad;
        public DelegateCommand<object> AbortRecipeCommnad =>
            _AbortRecipeCommnad ?? (_AbortRecipeCommnad = new DelegateCommand<object>(OnAbortRecipe));
        #endregion

        #region 构造函数
        public OverVenusDEViewModel()
        {
            m_RtDataKeys = new List<string>();

            m_IsATM = true;

            ModuleName = "PMA";

            CurrentModuleRecipes = GetFilesNames(Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "Recipes", ModuleName, "Process")).ToList();

            Is8Inch = false;
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.2);
            timer.Tick += timer_Tick;
            timer.Start();
        }
        #endregion
        #region 命令方法
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", commonValveControl.Tag.ToString(), !commonValveControl.Status);
            }
        }
        private void OnPMInit()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Home");
        }
        private async void OnGas()
        {
            await Task.Run(async () =>
            {
                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);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas9.SetPoint", MFC9SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas10.SetPoint", MFC10SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas11.SetPoint", MFC11SetPoint);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas12.SetPoint", MFC12SetPoint);

                await Task.Delay(1000);
                object[] mfc = new object[12];
                string[] mfcSetPoint = new string[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;
                mfc[8] = MFC9Data.SetPoint;
                mfc[9] = MFC10Data.SetPoint;
                mfc[10] = MFC11Data.SetPoint;
                mfc[11] = MFC12Data.SetPoint;

                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.GasFlow}", mfc);

            });


        }
        private void OnHe()
        {
            if (HeIsOpen == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideHeFlow", 0.0d);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideHePressure", 0);

                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.PVHe3, false);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISO, false);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISOOut, false);
            }
            else
            {
                if (HeGasSetpoint == 0)
                    return;

                if (HeIsPressureMode)
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideHePressure", HeGasSetpoint);
                }
                else
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideHeFlow", HeGasSetpoint);
                }
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.PVHe3, true);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISO, true);
            }
        }

        private void OnHeOut()
        {
            if (HeOutIsOpen == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideOutHeFlow", 0.0d);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideOutHePressure", 0);

                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.PVHe4, false);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISO, false);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISOOut, false);
            }
            else
            {
                if (HeOutGasSetpoint == 0)
                    return;

                if (HeOutIsPressureMode)
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideOutHePressure", HeOutGasSetpoint);
                }
                else
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBacksideOutHeFlow", HeOutGasSetpoint);
                }
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.PVHe4, true);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", (int)ValveType.HeISOOut, true);
            }
        }
        private void OnRf()
        {
            if (PMCurrentState == PMState.RfPowering)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.RfPower}");
            }
        }

        private void OnPurge()
        {
            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString() ==PMState.Purge.ToString())
            //if (PMCurrentState == PMState.Purging || N2SetPoint<=0)
            //{
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcN2.SetPoint", 0);
            //    await Task.Delay(1000);
            //    //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopPurge");
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");

            //}
            //else
            //{
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcN2.SetPoint", N2SetPoint);
            //    await Task.Delay(1000);
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Purge");
            //}
            if (PMCurrentState == PMState.Purging)
            {
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcN2.SetPoint", 0);
                //await Task.Delay(1000);
                ////InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopPurge");
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");

            }
            else
            {
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcN2.SetPoint", N2SetPoint);
                //await Task.Delay(1000);
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Purge");
            }
        }

        private void OnVent()
        {
            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString()==PMState.Venting.ToString())
            if (PMCurrentState == PMState.Venting)
            {
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopVent");
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");

            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Vent");
            }

        }

        private void OnPump()
        {
            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == PMState.Pumping.ToString())
            if (PMCurrentState == PMState.Pumping)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }

            //if (PMCurrentState == PMState.pum)
            //{
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopPump");
            //    return;
            //}
            //string BasePressureSetPoint= RtConfigValues[$"{ModuleName}.Pump.PumpBasePressure"].ToString(); ;
            //{
            //    get { return RtConfigValues[$"{ModuleName}.Pump.PumpBasePressure"].ToString(); }
            //}

            //string PumpLimitSetPoint= RtConfigValues[$"{ModuleName}.Pump.PumpTimeLimit"].ToString();
            //{
            //    get { return RtConfigValues[$"{ModuleName}.Pump.PumpTimeLimit"].ToString(); }
            //}

            string BasePressureSetPoint = QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.Pump.PumpBasePressure").ToString();

            string PumpLimitSetPoint = QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.Pump.PumpTimeLimit").ToString();
            // 设置底压
            double basePressure = string.IsNullOrEmpty(BasePressureSetPoint) ? 0 : Convert.ToDouble(BasePressureSetPoint);

            if (basePressure <= 0.01 || basePressure >= 1000)
            {
                MessageBox.Show($"基准压力设定值 {basePressure} 无效，应该在0到1000毫托之间");
                return;
            }

            double pumpLimit = string.IsNullOrEmpty(PumpLimitSetPoint) ? 0 : Convert.ToDouble(PumpLimitSetPoint);

            if (pumpLimit <= 0.01 || pumpLimit >= 1200)
            {
                MessageBox.Show($"抽气时间应该在0到1200之间，当前设定值{pumpLimit}");
                return;
            }

            InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{ModuleName}.Pump.PumpBasePressure", basePressure.ToString());

            InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"{ModuleName}.Pump.PumpTimeLimit", pumpLimit.ToString());

            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Pump");
        }

        private void OnOpenPump()
        {

            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "LaunchingPump")
            if (PMCurrentState == PMState.LaunchingPump)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            //if (PumpIsOpen == true)
            //{
            //    return;
            //}
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StartPump");
        }
        private void OnClosePump()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ClosePump");

        }
        private void OnOpenTurboPump()
        {
            //TurboIsOpen = true;
            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "LaunchingTurbo")
            if (PMCurrentState == PMState.LaunchingTurboPump)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }

            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StartTurboPump");
        }

        private void OnCloseTurboPump()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.CloseTurboPump");
        }

        private void OnOpenPendulumValve()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.TurnPendulumValve", true);
        }
        private void OnClosePendulumValve()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.TurnPendulumValve", false);
        }
        private void OnPinUpDown(object upDown)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetLiftPin", Convert.ToBoolean(upDown));
        }

        //private async void OnSetSRf()
        //{

        //    if (SRFData.IsRfOn == true)
        //    {
        //        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, false);
        //    }
        //    else
        //    {
        //        if (GasIsFlowing == true)
        //        {
        //            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match}.{AITRfOperation.SetMatchPosition}", SRFMatchC1, SRFMatchC2);
        //            await Task.Delay(100);
        //            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, true);
        //        }
        //    }
        //}
        private async void OnSetBRf()
        {
            if (BRFData.IsRfOn == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBRf", BRFFwdPowerSetpoint, false);
            }
            else
            {
                if (GasIsFlowing == true)
                {
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.BiasMatch}.{AITRfOperation.SetMatchPosition}", BRFMatchC1, BRFMatchC2);
                    await Task.Delay(100);
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBRf", BRFFwdPowerSetpoint, true);
                }
            }
        }
        private async void OnSetMagnet()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetMagnet", MagnetIntensity, true);
        }

        private void OnPMAbort()
        {

            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Abort");
        }
        private void OnOpenButterflyValveView()
        {
            var _mainWindow = Application.Current.Windows.Cast<Window>().FirstOrDefault(window => window is Window) as Window;
            butterflyValveMessageBox = new ButterflyValveView(ModuleName.ToString());
            butterflyValveMessageBox.WindowStartupLocation = WindowStartupLocation.Manual;
            butterflyValveMessageBox.Left = 700;
            butterflyValveMessageBox.Top = 600;
            butterflyValveMessageBox.Show();
            butterflyValveMessageBox.Owner = _mainWindow;

        }
        //WallChiller
        private void OnLoadRecipe()
        {
            string recipeType = SelectedRecipeType.Content.ToString();
            CurrentModuleRecipes = GetFilesNames(Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "Recipes", ModuleName, recipeType)).ToList();
        }

        private void OnHV()
        {
            if (ESCHVData.IsOn == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetESCHVIsOn", false);

            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetESCHV", ESCVoltage);

                //await Task.Run(async () =>
                //{
                //    //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetESCHVIsOn", true);
                //    //await Task.Delay(1000);

                //});
            }


        }
        private void OnHVSet()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetESCHV", ESCVoltage);

        }

        private void OnSwitchType()
        {
            SelectedRecipeIndex = -1;
        }
        private void OnRunRecipe(object obj)
        {
            if (SelectedRecipeIndex == -1)
            {
                return;
            }
            string recipeName = CurrentModuleRecipes[SelectedRecipeIndex];
            string recipeType = SelectedRecipeType.Content.ToString();
            if (recipeName == null)
            {
                return;
            }
            ClearData();
            var recipePath = Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "Recipes", ModuleName, "Process", recipeName + ".rcp");
            CurrentRecipe = Recipe.Load(File.ReadAllText(recipePath));
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.RunRecipe}", recipeName, ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers[0].WaferID, "Process");
        }

        private void OnSetChillerTemp()
        {
            var value = (QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.Chiller.ChillerTemperatureOffset").ToString());
            float x;
            float.TryParse(value, out x);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.HeatChiller", ChillerType.Chiller.ToString(), ChillerTempSetpoint, x);
        }
        private void OnSetWallChillerTemp()
        {
            var value = (QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.WallChiller.ChillerTemperatureOffset").ToString());
            float x;
            float.TryParse(value, out x);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.HeatChiller", ChillerType.WallChiller.ToString(), WallTempSetpoint, x);
        }
        private void OnOffChiller()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.OnOffChiller", ChillerType.Chiller.ToString(), !ChillerIsOn);
        }

        private void OnOffWallChiller()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.OnOffChiller", ChillerType.WallChiller.ToString(), !WallChillerIsOn);
        }
        private void OnHeater(object obj)
        {
            if (IsAutoMode == true)
            {
                return;
            }
            AITHeaterData heaterData = obj as AITHeaterData;
            var _mainWindow = Application.Current.Windows.Cast<Window>().FirstOrDefault(window => window is Window) as Window;
            heaterView = new HeaterView(heaterData, ModuleName);
            heaterView.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            heaterView.Owner = _mainWindow;
            heaterView.Show();
        }

        private void OnEndStep()
        {
            if (CurrentRecipeResult?.RecipeStepNumber != null && CurrentRecipeResult?.RecipeStepNumber != CurrentRecipeResult?.RecipeStepCount)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ManualEndStep");
            }
            else if (CurrentRecipeResult?.RecipeStepNumber != null && CurrentRecipeResult?.RecipeStepNumber == CurrentRecipeResult?.RecipeStepCount)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Abort");
            }
        }
        private void OnOnline()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Online}");
        }
        private void OnOffline()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Offline}");
        }
        private async void OnAbortRecipe(object obj)
        {
            if (PMCurrentState != PMState.Processing)
            {
                return;
            }
            switch (obj.ToString())
            {
                case "0":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Abort");
                    break;
                case "1":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Abort");
                    await Task.Delay(1000);
                    if (CurrentRecipe.Header.DechuckRecipe != "")
                    {
                        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.RunRecipe}", CurrentRecipe.Header.DechuckRecipe, ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers[0].WaferID, RecipeType.DeChuck.ToString());
                    }

                    break;
                case "2":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Abort");
                    await Task.Delay(1000);
                    if (CurrentRecipe.Header.DechuckRecipe != "")
                    {
                        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.RunRecipe}", CurrentRecipe.Header.DechuckRecipe, ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers[0].WaferID, RecipeType.DeChuck.ToString());
                    }
                    await Task.Delay(3000);
                    while (PMCurrentState == PMState.Processing)
                    {
                        await Task.Delay(500);
                    }
                    InvokeClient.Instance.Service.DoOperation("ReturnWafer", ModuleName, 0);
                    break;
            }
        }
        #endregion
        #region 私有方法
        private void ClearData()
        {
            ESCVoltage = 0;
            SRFFwdPowerSetpoint = 0;
            SRFMatchC1 = 0;
            SRFMatchC2 = 0;
            BRFFwdPowerSetpoint = 0;
            BRFMatchC1 = 0;
            BRFMatchC2 = 0;
            HeGasSetpoint = 0;
            HeOutGasSetpoint = 0;
            MFC1SetPoint = 0;
            MFC2SetPoint = 0;
            MFC3SetPoint = 0;
            MFC4SetPoint = 0;
            MFC5SetPoint = 0;
            MFC6SetPoint = 0;
            MFC7SetPoint = 0;
            MFC8SetPoint = 0;
            MFC9SetPoint = 0;
            MFC10SetPoint = 0;
            MFC11SetPoint = 0;
            MFC12SetPoint = 0;
        }
        private IEnumerable<string> GetFilesNames(string path)
        {
            if (Directory.Exists(path))
            {
                return Directory.GetFiles(path, "*.rcp")?
          .Select(Path.GetFileNameWithoutExtension);
            }
            else
            {
                return new List<string>();
            }
        }



        void timer_Tick(object sender, EventArgs e)
        {
            try
            {
                RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

                if (RtDataValues == null)
                {
                    return;
                }

                if (!m_load)
                {
                    ChillerTempSetpoint = float.Parse(QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.Chiller.LastTemp").ToString());
                    WallTempSetpoint = float.Parse(QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.WallChiller.LastTemp").ToString());
                    if (QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.WaferSize").ToString() == "8")
                        Is8Inch = true;
                    else
                        Is8Inch = false;
                    m_load = true;
                }

                Valve12Visible = (bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.MfcGas12.Enable");
                Valve11Visible = (bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.MfcGas11.Enable");
                TurboN2FlowSetPoint = Convert.ToInt32(QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.TurboN2FlowSetPoint"));


                IsAutoMode = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsOnline");
                PVN21ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVN21.IsOpen");
                GasFinalValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveGasFinal.IsOpen");
                PV11ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV11.IsOpen");
                PV12ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV12.IsOpen");
                PV21ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV21.IsOpen");
                PV22ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV22.IsOpen");
                PV31ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV31.IsOpen");
                PV32ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV32.IsOpen");
                PV41ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV41.IsOpen");
                PV42ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV42.IsOpen");

                PV51ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV51.IsOpen");
                PV52ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV52.IsOpen");
                PV61ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV61.IsOpen");
                PV62ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV62.IsOpen");
                PV71ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV71.IsOpen");
                PV72ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV72.IsOpen");
                PV81ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV81.IsOpen");
                PV82ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV82.IsOpen");
                PV91ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV91.IsOpen");
                PV92ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePV92.IsOpen");
                PVA1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVA1.IsOpen");
                PVA2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVA2.IsOpen");
                PVB1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVB1.IsOpen");
                PVB2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVB2.IsOpen");
                PVC1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVC1.IsOpen");
                PVC2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVC2.IsOpen");

                MFC1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc1.IsOpen");
                MFC2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc2.IsOpen");
                MFC3ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc3.IsOpen");
                MFC4ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc4.IsOpen");
                MFC5ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc5.IsOpen");
                MFC6ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc6.IsOpen");
                MFC7ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc7.IsOpen");
                MFC8ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc8.IsOpen");
                MFC9ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc9.IsOpen");
                MFC10ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc10.IsOpen");
                MFC11ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc11.IsOpen");
                MFC12ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMfc12.IsOpen");
                N2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveN2.IsOpen");
                //SoftPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveSoftPump.IsOpen");
                FastPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveFastPump.IsOpen");
                GuageValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveGuage.IsOpen");
                PVHe1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe1.IsOpen");
                PVHe2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe2.IsOpen");
                PVN21ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVN21.IsOpen");
                PVN22ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVN22.IsOpen");
                TurboPumpPumpingValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveTurboPumpPumping.IsOpen");
                TurboPumpPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveTurboPumpPurge.IsOpen");
                PVHe3ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe3.IsOpen");
                PVHe4ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe4.IsOpen");
                HeISOValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveHeISO.IsOpen");
                HeISOOutValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveHeISOOut.IsOpen");

                HeIsOpen = PVHe1ValveIsOpen && HeISOValveIsOpen;
                HeOutIsOpen = PVHe1ValveIsOpen && HeISOOutValveIsOpen;

                PumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.PumpIsRunning");
                TurboIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.TurboPumpIsRunning");


                LiftPinIsUp = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.LiftPinIsUp");
                IsSlitDoorClosed = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsSlitDoorClosed");
                IsLinerDoorClosed = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsLinerDoorClosed");
                IsLidClosed = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsLidClosed");

                PendulumValvePosition = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.GetPVPosition");
                TurboPumpRotationalSpeed = Convert.ToInt32(RtDataValues[$"{ModuleName}.TurboPumpRotationalSpeed"].ToString());

                PositionValue = -((int)((PendulumValvePosition) * 0.09));


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

                GasIsFlowing = PMCurrentState == PMState.GasFlowing;
                IsProcessing = PMCurrentState == PMState.Processing;
                MFC1Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas1");
                MFC2Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas2");
                MFC3Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas3");
                MFC4Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas4");
                MFC5Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas5");
                MFC6Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas6");
                MFC7Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas7");
                MFC8Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas8");
                MFC9Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas9");
                MFC10Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas10");
                MFC11Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas11");
                MFC12Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcGas12");
                MFCHeData = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcHe");
                MFCHeOutData = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcHeOut");
                MFCN2Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcN2");

                // SRFData = CommonFunction.GetValue<AITRfData>(RtDataValues, $"{ModuleName}.{VenusDevice.Rf}.DeviceData");
                BRFData = CommonFunction.GetValue<AITRfData>(RtDataValues, $"{ModuleName}.{VenusDevice.BiasRf}.DeviceData");
                BRMatch = CommonFunction.GetValue<AITMatchData>(RtDataValues, $"{ModuleName}.{VenusDevice.BiasMatch}.DeviceData");
                PendulumValveData = CommonFunction.GetValue<AITPendulumValveData>(RtDataValues, $"{ModuleName}.{VenusDevice.PendulumValve}.DeviceData");
                ESCHVData = CommonFunction.GetValue<AITHVData>(RtDataValues, $"{ModuleName}.{VenusDevice.ESCHV}.DeviceData");
                SecondPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveSecondPurge.IsOpen");

                ValveHeaterData = (AITHeaterData)RtDataValues[$"{ModuleName}.ValveHeater.DeviceData"];
                MagnetData = CommonFunction.GetValue<AITMagnetData>(RtDataValues, $"{ModuleName}.AIoMagnet.DeviceData");
                ForelineHeaterData = (AITHeaterData)RtDataValues[$"{ModuleName}.ForelineHeater.DeviceData"];
                //WallHeaterData = (AITHeaterData)RtDataValues[$"{ModuleName}.WallHeater.DeviceData"];
                MainPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveMainPurge.IsOpen");
                ChamberPressure = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.ChamberPressure");
                ProcessPressure = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.ProcessPressure");
                ForelinePressure = float.Parse(RtDataValues[$"{ModuleName}.ForelinePressure"].ToString());
                ESCHePressure = float.Parse(RtDataValues[$"{ModuleName}.ESCHePressure"].ToString());
                ESCHeOutPressure = float.Parse(RtDataValues[$"{ModuleName}.ESCHeOutPressure"].ToString());

                ChillerTemperature = float.Parse(RtDataValues[$"{ModuleName}.Chiller.Temp"].ToString());
                HVTemperature = float.Parse(RtDataValues[$"{ModuleName}.{VenusDevice.ESCHV}.Temp"].ToString());
                if ((bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.WallChiller.EnableChiller"))
                {
                    WallChillerTemperature = float.Parse(RtDataValues[$"{ModuleName}.WallChiller.Temp"].ToString());
                    WallChillerIsOn = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.WallChiller.IsOn");
                }


                ChillerIsOn = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.Chiller.IsOn");
                BiasRFFanInterlock = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.SourceRFFanInterlock");
                IsWLK = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsWLK");
                IsWaterFlowOk = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsWaterFlowOk");
                IsTurboPumpInterlock = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsTurboPumpInterlock");
                IsCDAOK = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsCDA_OK");
                SensorGasBoxDoor = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IoSensor.GasBoxDoorSW.Value");
                SensorGasBoxPressure = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IoSensor.GasBoxPressureSW.Value");

                IsATM = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsATM");
                IsVAC = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsVAC");

                ESCHVOutputVoltage = CommonFunction.GetValue<int>(RtDataValues, $"{ModuleName}.ESCHV.OutputVoltage");
                PurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePurge.IsOpen");

                BiasMatchC1 = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.{VenusDevice.BiasMatch}.C1");
                BiasMatchC2 = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.{VenusDevice.BiasMatch}.C2");
                BiasMatchVDC = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.{VenusDevice.BiasMatch}.VDC");
                TurboPumpWaterFlowSwitch = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.TurboPumpWaterFlowSwitch.Value");
                IsTurboPumpAtSpeed = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.IsTurboPumpAtSpeed");
                IsHasWafer = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.HasWafer");
                WaferID = IsHasWafer ? ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers[0].SourceName : "";

                if (PMCurrentState == PMState.Processing || PMCurrentState == PMState.Clean)
                {


                    CurrentRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"{ModuleName}.CurrentRecipeResult");
                    if (CurrentRecipeResult.RecipeStepNumber != null && CurrentRecipeResult.RecipeStepNumber != currentRecipeNumber)

                    {
                        var recipePath = Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "Recipes", ModuleName, CurrentRecipeResult.RecipeType, CurrentRecipeResult.RecipeName + ".rcp");
                        CurrentRecipe = Recipe.Load(File.ReadAllText(recipePath));
                        CurrentRecipeStep = CurrentRecipe.Steps[Convert.ToInt32(CurrentRecipeResult.RecipeStepNumber) - 1];
                    }
                    currentRecipeNumber = CurrentRecipeResult.RecipeStepNumber;

                }
                else
                {
                    CurrentRecipeStep = new RecipeStep();
                    CurrentRecipeStep.LstUnit.Add(new object());
                    CurrentRecipeStep.LstUnit.Add(new object());
                    CurrentRecipeStep.LstUnit.Add(new object());
                    CurrentRecipeStep.LstUnit.Add(new object());
                    CurrentRecipeStep.LstUnit.Add(new object());
                }
                //else
                //{
                //    CurrentRecipeResult = null;
                //    CurrentRecipeStep = null;
                //}

                if (Math.Abs(100 - ProcessPressure) > 1 && ProcessPressure < 100)
                {
                    ChamberPressureFeedBack = ProcessPressure;
                }
                else
                {
                    ChamberPressureFeedBack = ChamberPressure;
                }
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex.Message, ex);
            }
        }
        public void addDataKeys()
        {
            m_RtDataKeys.Clear();
            m_RtDataKeys.Add($"{ModuleName}.IsOnline");
            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}.MfcHe");
            m_RtDataKeys.Add($"{ModuleName}.MfcHeOut");
            m_RtDataKeys.Add($"{ModuleName}.MfcN2");

            m_RtDataKeys.Add($"{ModuleName}.ForelinePressure");
            m_RtDataKeys.Add($"{ModuleName}.ChamberPressure");
            m_RtDataKeys.Add($"{ModuleName}.ProcessPressure");

            m_RtDataKeys.Add($"{ModuleName}.ChamberPressure");
            m_RtDataKeys.Add($"{ModuleName}.ESCHePressure");
            m_RtDataKeys.Add($"{ModuleName}.ESCHeOutPressure");

            m_RtDataKeys.Add($"{ModuleName}.IsATM");
            m_RtDataKeys.Add($"{ModuleName}.IsVAC");

            m_RtDataKeys.Add($"{ModuleName}.LiftPinIsUp");
            m_RtDataKeys.Add($"{ModuleName}.LiftPinIsDown");

            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");
            // m_RtDataKeys.Add($"{ModuleName}.ValveMfc12.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}.ValvePVHe3.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe4.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveHeISO.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveHeISOOut.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePurge.IsOpen");

            m_RtDataKeys.Add($"{ModuleName}.TurboPumpIsRunning");
            m_RtDataKeys.Add($"{ModuleName}.PumpIsRunning");

            m_RtDataKeys.Add($"{ModuleName}.IsSlitDoorClosed");
            m_RtDataKeys.Add($"{ModuleName}.IsLinerDoorClosed");
            m_RtDataKeys.Add($"{ModuleName}.IsLidClosed");

            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.Rf}.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.BiasRf}.DeviceData");


            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.Match}.C1");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.Match}.C2");
            // m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.Match}.WorkMode");

            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.BiasMatch}.C1");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.BiasMatch}.C2");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.BiasMatch}.VDC");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.BiasMatch}.DeviceData");

            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.PendulumValve}.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.ESCHV}.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.AIoMagnet.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.TurboPumpRotationalSpeed");

            m_RtDataKeys.Add($"{ModuleName}.GetPVPosition");

            m_RtDataKeys.Add($"{ModuleName}.Chiller.Temp");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.ESCHV}.Temp");

            //m_RtDataKeys.Add($"{ModuleName}.ESCHV.OutputVoltage");
            //m_RtDataKeys.Add($"{ModuleName}.ESCHV.IsOn");


            m_RtDataKeys.Add($"{ModuleName}.IsWaterFlowOk");
            m_RtDataKeys.Add($"{ModuleName}.IsWLK");
            m_RtDataKeys.Add($"{ModuleName}.IsCDA_OK");
            m_RtDataKeys.Add($"{ModuleName}.SourceRFFanInterlock");
            m_RtDataKeys.Add($"{ModuleName}.IsTurboPumpInterlock");

            m_RtDataKeys.Add($"{ModuleName}.IoSensor.GasBoxDoorSW.Value");
            m_RtDataKeys.Add($"{ModuleName}.IoSensor.GasBoxPressureSW.Value");

            //m_RtDataKeys.Add($"{ModuleName}.WallTempFeedBack");
            m_RtDataKeys.Add($"{ModuleName}.Chiller.IsOn");

            m_RtDataKeys.Add($"{ModuleName}.ValveHeater.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.ValveMainPurge.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveSecondPurge.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ForelineHeater.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.WallHeater.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.FsmState");

            m_RtDataKeys.Add($"{ModuleName}.IsTurboPumpAtSpeed");
            m_RtDataKeys.Add($"{ModuleName}.TurboPumpWaterFlowSwitch.Value");

            m_RtDataKeys.Add($"{ModuleName}.HasWafer");
            m_RtDataKeys.Add($"{ModuleName}.CurrentRecipeResult");

            if ((bool)QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.WallChiller.EnableChiller"))
            {
                m_RtDataKeys.Add($"{ModuleName}.WallChiller.Temp");
                m_RtDataKeys.Add($"{ModuleName}.WallChiller.IsOn");
            }
        }
        #endregion
    }
}