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

using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Views;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Venus_MainPages.ViewModels
{
    internal class OverViewModel : BindableBase
    {
        #region 私有字段
        private bool m_PVN21ValveIsOpen;
        private bool m_PVN22ValveIsOpen;
        private bool m_N2ValveIsOpen;
        private bool m_PV11ValveIsOpen;
        private bool m_PV12ValveIsOpen;
        private bool m_PV21ValveIsOpen;
        private bool m_PV22ValveIsOpen;
        private bool m_PV31ValveIsOpen;
        private bool m_PV32ValveIsOpen;
        private bool m_PV41ValveIsOpen;
        private bool m_PV42ValveIsOpen;
        private bool m_MFC1ValveIsOpen;
        private bool m_MFC2ValveIsOpen;
        private bool m_MFC3ValveIsOpen;
        private bool m_MFC4ValveIsOpen;
        private bool m_MFC5ValveIsOpen;
        private bool m_MFC6ValveIsOpen;
        private bool m_MFC7ValveIsOpen;
        private bool m_MFC8ValveIsOpen;
        private bool m_GasFinalValveIsOpen;

        private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
        private bool m_PVHe1ValveIsOpen;
        private bool m_PVHe2ValveIsOpen;
        private bool m_TurboPumpPumpingValveIsOpen;
        private bool m_TurboPumpPurgeValveIsOpen;

        private bool m_BRFIsOn;
        private bool m_SRFIsOn;

        private double m_MfcGas1Setpoint;
        private double m_MfcGas2Setpoint;
        private double m_MfcGas3Setpoint;
        private double m_MfcGas4Setpoint;
        private double m_MfcGas5Setpoint;
        private double m_MfcGas6Setpoint;
        private double m_MfcGas7Setpoint;
        private double m_MfcGas8Setpoint;

        private float m_SRFFwdPowerSetpoint;
        private float m_BRFFwdPowerSetpoint;

        private float m_SRFMatchC1;
        private float m_SRFMatchC2;
        private float m_BRFMatchC1;
        private float m_BRFMatchC2;






        private AITPumpData m_MainPumpData = new AITPumpData();

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

        private string ModuleName;

        private List<string> m_RtConfigKeys;
        private Dictionary<string, object> m_RtConfigValues;

        private List<string> m_RtDataKeys;
        private Dictionary<string, object> m_RtDataValues;

        private int m_PositionValue;
        private bool m_IsPositionMode;

        private object[] _oldmfc = new object[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

        private string m_title = "123";

        private int m_ESCVoltage;

        #endregion

        #region  属性      
        public Dictionary<string, object> RtConfigValues
        {
            get { return m_RtConfigValues; }
            set { SetProperty(ref m_RtConfigValues, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool GasFinalValveIsOpen
        {
            get { return m_GasFinalValveIsOpen; }
            set { SetProperty(ref m_GasFinalValveIsOpen, value); }
        }
        public bool PVN21ValveIsOpen
        {
            get { return m_PVN21ValveIsOpen; }
            set { SetProperty(ref m_PVN21ValveIsOpen, value); }
        }
        public bool PVN22ValveIsOpen
        {
            get { return m_PVN22ValveIsOpen; }
            set { SetProperty(ref m_PVN22ValveIsOpen, value); }
        }
        public bool N2ValveIsOpen
        {
            get { return m_N2ValveIsOpen; }
            set { SetProperty(ref m_N2ValveIsOpen, value); }
        }
        public bool PV11ValveIsOpen
        {
            get { return m_PV11ValveIsOpen; }
            set { SetProperty(ref m_PV11ValveIsOpen, value); }
        }
        public bool PV12ValveIsOpen
        {
            get { return m_PV12ValveIsOpen; }
            set { SetProperty(ref m_PV12ValveIsOpen, value); }
        }
        public bool MFC1ValveIsOpen
        {
            get { return m_MFC1ValveIsOpen; }
            set { SetProperty(ref m_MFC1ValveIsOpen, value); }
        }
        public bool PV21ValveIsOpen
        {
            get { return m_PV21ValveIsOpen; }
            set { SetProperty(ref m_PV21ValveIsOpen, value); }
        }
        public bool PV22ValveIsOpen
        {
            get { return m_PV22ValveIsOpen; }
            set { SetProperty(ref m_PV22ValveIsOpen, value); }
        }
        public bool MFC2ValveIsOpen
        {
            get { return m_MFC2ValveIsOpen; }
            set { SetProperty(ref m_MFC2ValveIsOpen, value); }
        }
        public bool PV31ValveIsOpen
        {
            get { return m_PV31ValveIsOpen; }
            set { SetProperty(ref m_PV31ValveIsOpen, value); }
        }
        public bool PV32ValveIsOpen
        {
            get { return m_PV32ValveIsOpen; }
            set { SetProperty(ref m_PV32ValveIsOpen, value); }
        }
        public bool MFC3ValveIsOpen
        {
            get { return m_MFC3ValveIsOpen; }
            set { SetProperty(ref m_MFC3ValveIsOpen, value); }
        }
        public bool PV41ValveIsOpen
        {
            get { return m_PV41ValveIsOpen; }
            set { SetProperty(ref m_PV41ValveIsOpen, value); }
        }
        public bool PV42ValveIsOpen
        {
            get { return m_PV42ValveIsOpen; }
            set { SetProperty(ref m_PV42ValveIsOpen, value); }
        }
        public bool MFC4ValveIsOpen
        {
            get { return m_MFC4ValveIsOpen; }
            set { SetProperty(ref m_MFC4ValveIsOpen, value); }
        }
        public bool MFC5ValveIsOpen
        {
            get { return m_MFC5ValveIsOpen; }
            set { SetProperty(ref m_MFC5ValveIsOpen, value); }
        }
        public bool MFC6ValveIsOpen
        {
            get { return m_MFC6ValveIsOpen; }
            set { SetProperty(ref m_MFC6ValveIsOpen, value); }
        }
        public bool MFC7ValveIsOpen
        {
            get { return m_MFC7ValveIsOpen; }
            set { SetProperty(ref m_MFC7ValveIsOpen, value); }
        }
        public bool MFC8ValveIsOpen
        {
            get { return m_MFC8ValveIsOpen; }
            set { SetProperty(ref m_MFC8ValveIsOpen, value); }
        }
        public bool PVHe1ValveIsOpen
        {
            get { return m_PVHe1ValveIsOpen; }
            set { SetProperty(ref m_PVHe1ValveIsOpen, value); }
        }
        public bool PVHe2ValveIsOpen
        {
            get { return m_PVHe2ValveIsOpen; }
            set { SetProperty(ref m_PVHe2ValveIsOpen, value); }
        }
        public bool TurboPumpPumpingValveIsOpen
        {
            get { return m_TurboPumpPumpingValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPumpingValveIsOpen, value); }
        }
        public bool TurboPumpPurgeValveIsOpen
        {
            get { return m_TurboPumpPurgeValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPurgeValveIsOpen, value); }
        }
        public bool SoftPumpValveIsOpen
        {
            get { return m_SoftPumpValveIsOpen; }
            set { SetProperty(ref m_SoftPumpValveIsOpen, value); }
        }
        public bool FastPumpValveIsOpen
        {
            get { return m_FastPumpValveIsOpen; }
            set { SetProperty(ref m_FastPumpValveIsOpen, value); }
        }

        public AITPumpData MainPumpData
        {
            get { return m_MainPumpData; }
            set { SetProperty(ref m_MainPumpData, value); }
        }

        public bool PumpIsOpen
        {
            get { return m_PumpIsOpen; }
            set { SetProperty(ref m_PumpIsOpen, 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 string BasePressureSetPoint
        {
            get { return RtConfigValues[$"{ModuleName}.Pump.PumpBasePressure"].ToString(); }
        }

        public string PumpLimitSetPoint
        {
            get { return RtConfigValues[$"{ModuleName}.Pump.PumpTimeLimit"].ToString(); }
        }
        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 MfcGas1Setpoint
        {
            get { return m_MfcGas1Setpoint; }
            set { SetProperty(ref m_MfcGas1Setpoint, value); }
        }
        public double MfcGas2Setpoint
        {
            get { return m_MfcGas2Setpoint; }
            set { SetProperty(ref m_MfcGas2Setpoint, value); }
        }
        public double MfcGas3Setpoint
        {
            get { return m_MfcGas3Setpoint; }
            set { SetProperty(ref m_MfcGas3Setpoint, value); }
        }
        public double MfcGas4Setpoint
        {
            get { return m_MfcGas4Setpoint; }
            set { SetProperty(ref m_MfcGas4Setpoint, value); }
        }
        public double MfcGas5Setpoint
        {
            get { return m_MfcGas5Setpoint; }
            set { SetProperty(ref m_MfcGas5Setpoint, value); }
        }
        public double MfcGas6Setpoint
        {
            get { return m_MfcGas6Setpoint; }
            set { SetProperty(ref m_MfcGas6Setpoint, value); }
        }
        public double MfcGas7Setpoint
        {
            get { return m_MfcGas7Setpoint; }
            set { SetProperty(ref m_MfcGas7Setpoint, value); }
        }
        public double MfcGas8Setpoint
        {
            get { return m_MfcGas8Setpoint; }
            set { SetProperty(ref m_MfcGas8Setpoint, value); }
        }
        public string Title
        {
            get { return m_title; }
            set { SetProperty(ref m_title, 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 int ESCVoltage
        {
            get { return m_ESCVoltage; }
            set { SetProperty(ref m_ESCVoltage, value); }
        }
        public bool HVIsOn
        {
            get { return m_HVIsOn; }
            set { SetProperty(ref m_HVIsOn, 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 BRFMatchC2
        {
            get { return m_BRFMatchC2; }
            set { SetProperty(ref m_BRFMatchC2, 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 _GasCommand;
        public DelegateCommand GasCommand =>
            _GasCommand ?? (_GasCommand = new DelegateCommand(OnGas));

        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<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 _OpenButterflyValveViewCommand;
        public DelegateCommand OpenButterflyValveViewCommand =>
            _OpenButterflyValveViewCommand ?? (_OpenButterflyValveViewCommand = new DelegateCommand(OnOpenButterflyValveView));

        private DelegateCommand _GasSetPointCommand;
        public DelegateCommand GasSetPointCommand =>
            _GasSetPointCommand ?? (_GasSetPointCommand = new DelegateCommand(OnGasSetPoint));

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

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

        private DelegateCommand<object> _SetMatchModeCommand;
        public DelegateCommand<object> SetMatchModeCommand =>
            _SetMatchModeCommand ?? (_SetMatchModeCommand = new DelegateCommand<object>(OnSetMatchMode));
        #endregion

        #region 构造函数
        public OverViewModel()
        {
            //RTData.init();
            m_RtConfigKeys = new List<string>();
            m_RtDataKeys = new List<string>();

            m_IsATM = true;

            ModuleName = "PMA";
            addConfigKeys();
            addDataKeys();

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

            //GetRtAllData getRtAllData = new GetRtAllData();
            //IsPositionMode = true;
            Title = "PMA";

        }

      

        #endregion

        #region 命令方法

        private void OnPMInit()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Home");
        }
        private void OnGas()
        {
            object[] mfc = new object[8];
            string[] mfcSetPoint = new string[8];
            for (int index = 0; index < mfc.Length; index++)
            {
                mfc[index] = RtDataValues[$"{ModuleName}.MfcGas{index + 1}.SetPoint"];
            }
            //if (((Math.Abs((double)mfc[0] - (double)_oldmfc[0]) < 0.01) && (Math.Abs((double)mfc[1] - (double)_oldmfc[1]) < 0.01) && (Math.Abs((double)mfc[2] - (double)_oldmfc[2])) < 0.01)
            //   || ((Math.Abs((double)mfc[0]) <= 0.01 && Math.Abs((double)mfc[1]) <= 0.01 && Math.Abs((double)mfc[2]) <= 0.01)))
            //{
            //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            //    return;
            //}

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

        private void OnRf()
        {
            if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "RfPowering")
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.RfPower}");
        }

        private void OnPurge()
        {
            if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "Purge")
            {
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopPurge");
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Purge");
            }
        }

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

        }

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

            if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "IsPumpingOkForProcess")
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StopPump");
                return;
            }

            // 设置底压
            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")
            {
                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")
            {
                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 OnPinUpDown(object upDown)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetLiftPin", Convert.ToBoolean(upDown));
        }

        private async void OnSetSRf()
        {
            //await Task.Run(async () =>
            //{
            //    if (SRFIsOn == true)
            //    {
            //        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, false);

            //    }
            //    else
            //    {
            //        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match}.{AITRfOperation.SetMatchPosition}", SRFMatchC1, SRFMatchC2);
            //        //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match}.{AITRfOperation.SetMatchPositionC2}", SRFMatchC2);
            //        //var t = Task.Run(async delegate
            //        //{
            //        //    await Task.Delay(20000);
            //        //    return 42;
            //        //});
            //        //t.Wait();
            //        await Task.Delay(20000);
            //        InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, true);

            //    }
            //});
            
            if (SRFIsOn == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, false);

            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match}.{AITRfOperation.SetMatchPosition}", SRFMatchC1, SRFMatchC2);
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match}.{AITRfOperation.SetMatchPositionC2}", SRFMatchC2);
                var t = Task.Run(async delegate
                {
                    await Task.Delay(100);
                    return 42;
                });
                await t;
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSRf", SRFFwdPowerSetpoint, true);

            }



        }
        private async void OnSetBRf()
        {
            if (BRFIsOn == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBRf", BRFFwdPowerSetpoint, false);

            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.BiasMatch}.{AITRfOperation.SetMatchPosition}", BRFMatchC1,BRFMatchC2);
                //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.BiasMatch}.{AITRfOperation.SetMatchPositionC2}", BRFMatchC2);
                //Thread.Sleep(100);
                var t = Task.Run(async delegate
                {
                    await Task.Delay(100);
                    return 42;
                });
                await t;
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetBRf", BRFFwdPowerSetpoint, 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; 
            ButterflyValveView butterflyValveMessageBox = new ButterflyValveView();
            butterflyValveMessageBox.WindowStartupLocation = WindowStartupLocation.Manual;
            butterflyValveMessageBox.Left = 800;
            butterflyValveMessageBox.Top = 500;
            butterflyValveMessageBox.Show();
            butterflyValveMessageBox.Owner = _mainWindow;
        }

        private void OnGasSetPoint()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas1.SetPoint", MfcGas1Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas2.SetPoint", MfcGas2Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas3.SetPoint", MfcGas3Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas4.SetPoint", MfcGas4Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas5.SetPoint", MfcGas5Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas6.SetPoint", MfcGas6Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas7.SetPoint", MfcGas7Setpoint);
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.MfcGas8.SetPoint", MfcGas8Setpoint);
        }

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

        }

        private void OnSetMatchMode(object obj)
        {
            switch (obj.ToString())
            {
                case "SRFManual":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match.ToString()}.{AITRfOperation.SetMatchProcessMode}", EnumRfMatchTuneMode.Manual.ToString());
                    break;
                case "SRFAuto":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.Match.ToString()}.{AITRfOperation.SetMatchProcessMode}", EnumRfMatchTuneMode.Auto.ToString());
                    break;
                case "BRFManual":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.BiasMatch.ToString()}.{AITRfOperation.SetMatchProcessMode}", EnumRfMatchTuneMode.Manual.ToString());
                    break;
                case "BRFAuto":
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{VenusDevice.BiasMatch.ToString()}.{AITRfOperation.SetMatchProcessMode}", EnumRfMatchTuneMode.Auto.ToString());
                    break;
            }
        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {
            RtConfigValues = QueryDataClient.Instance.Service.PollConfig(m_RtConfigKeys);
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);


            PVN21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN21.IsOpen"];
            GasFinalValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveGasFinal.IsOpen"];
            PV11ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV11.IsOpen"];
            PV12ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV12.IsOpen"];
            PV21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV21.IsOpen"];
            PV22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV22.IsOpen"];
            PV31ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV31.IsOpen"];
            PV32ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV32.IsOpen"];
            PV41ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV41.IsOpen"];
            PV42ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV42.IsOpen"];
            MFC1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc1.IsOpen"];
            MFC2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc2.IsOpen"];
            MFC3ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc3.IsOpen"];
            MFC4ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc4.IsOpen"];
            MFC5ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc5.IsOpen"];
            MFC6ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc6.IsOpen"];
            MFC7ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc7.IsOpen"];
            MFC8ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc8.IsOpen"];
            N2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveN2.IsOpen"];
            SoftPumpValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveSoftPump.IsOpen"];
            FastPumpValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveFastPump.IsOpen"];
            PVHe1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVHe1.IsOpen"];
            PVHe2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVHe2.IsOpen"];
            PVN21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN21.IsOpen"];
            PVN22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN22.IsOpen"];
            HVIsOn= (bool)RtDataValues[$"{ModuleName}.ESCHV.IsOn"];


            TurboPumpPumpingValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveTurboPumpPumping.IsOpen"];
            TurboPumpPurgeValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveTurboPumpPurge.IsOpen"];


            PumpIsOpen = (bool)RtDataValues[$"{ModuleName}.PumpIsRunning"];
            TurboIsOpen = (bool)RtDataValues[$"{ModuleName}.TurboPumpIsRunning"];

            BRFIsOn = (bool)RtDataValues[$"{ModuleName}.BRfIsOn"];
            SRFIsOn = (bool)RtDataValues[$"{ModuleName}.SRfIsOn"];


            PositionValue = -((int)(((int)RtDataValues[$"{ModuleName}.GetPVPosition"]) * 0.09));



        }

        private void addConfigKeys()
        {
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas1.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas2.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas3.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas4.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas5.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas6.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas7.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas8.GasName");

            m_RtConfigKeys.Add($"{ModuleName}.Pump.PumpBasePressure");
            m_RtConfigKeys.Add($"{ModuleName}.Pump.PumpTimeLimit");
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.FsmState");

            m_RtDataKeys.Add($"{ModuleName}.MfcGas1.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas2.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas3.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas4.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas5.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas6.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas7.SetPoint");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas8.SetPoint");

            m_RtDataKeys.Add($"{ModuleName}.MfcGas1.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas2.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas3.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas4.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas5.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas6.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas7.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas8.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcHe.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcN2.FeedBack");


            m_RtDataKeys.Add($"{ModuleName}.ForelinePressure");
            m_RtDataKeys.Add($"{ModuleName}.ProcessHighPressure");
            m_RtDataKeys.Add($"{ModuleName}.ProcessLowPressure");

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

            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}.ValveMfc1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc3.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc4.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc5.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc6.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc7.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc8.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGasFinal.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveSoftPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveFastPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveN2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPurge.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGuage.IsOpen");


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

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

            m_RtDataKeys.Add($"{ModuleName}.SRfIsOn");
            m_RtDataKeys.Add($"{ModuleName}.SRfForwardPowerFeedBack");
            m_RtDataKeys.Add($"{ModuleName}.SRfReflectPower");
            m_RtDataKeys.Add($"{ModuleName}.BRfIsOn");
            m_RtDataKeys.Add($"{ModuleName}.BRfForwardPowerFeedBack");
            m_RtDataKeys.Add($"{ModuleName}.BRfReflectPower");

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

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

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

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

            




        }
        #endregion
    }
}