Kepler-Release/Venus/Venus_Simulator/Instances/SimulatorSystem.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Simulator.Core.Driver;
using System;
using System.Collections.Generic;
using Venus_Simulator.Devices;
using System.Threading;
using Venus_Core;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
using System.Diagnostics.Eventing.Reader;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;

namespace Venus_Simulator.Instances
{
    public class SimulatorSystem : Singleton<SimulatorSystem>
    {
        private PeriodicJob _thread;

        private Random _rd = new Random();
        ConfigType type;
        private RD_TRIG _trigATM = new RD_TRIG();
        private RD_TRIG _trigVAC = new RD_TRIG();

        private R_TRIG _trigLLExtend = new R_TRIG();
        private R_TRIG _trigLLRetract = new R_TRIG();
        private static int count = 0;

        private readonly float ATM_THRESHOLD = 750000;
        private readonly float ATM_PRESSURE = 760000;
        private readonly float ATM_LoadLock_PRESSURE = 760000;
        private readonly uint VAC_SW_PRESSURE = 9500;
        private readonly uint PROCESS_GAUGE = 10000;

        private Dictionary<ModuleName, DeviceSimulator> _MockDevices = new Dictionary<ModuleName, DeviceSimulator>();

        private Dictionary<ModuleName, JetChamber> jetChambers = new Dictionary<ModuleName, JetChamber>();
        public SimulatorSystem()
        {
            //_MockDevices.Add(ModuleName.PMB, new SkyPumpMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecGeneratorMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecMatchMock());

            // TODO
            type = (ConfigType)QueryDataClient.Instance.Service.GetData("System.ConfigType");
            jetChambers.Add(ModuleName.PMA, SimulatorJetChamber.CurrentPMAChamber);
            jetChambers.Add(ModuleName.PMB, SimulatorJetChamber.CurrentPMBChamber);
            jetChambers.Add(ModuleName.PMC, SimulatorJetChamber.CurrentPMCChamber);
            jetChambers.Add(ModuleName.PMD, SimulatorJetChamber.CurrentPMDChamber);

        }

        ~SimulatorSystem()
        {
            _thread?.Stop();
        }

        public void Initialize()
        {

            SetDefaultValue(ModuleName.PMA, SimulatorJetChamber.CurrentPMAChamber);
            SetDefaultValue(ModuleName.PMB, SimulatorJetChamber.CurrentPMBChamber);
            SetDefaultValue(ModuleName.PMC, SimulatorJetChamber.CurrentPMCChamber);
            SetDefaultValue(ModuleName.PMD, SimulatorJetChamber.CurrentPMDChamber);
            if (type == ConfigType.Kepler2200 || type == ConfigType.Kepler2300 || type == ConfigType.Other)
            {
                SetTMDefaultValue();
            }
            else if (type == ConfigType.VenusSE)
            {
                SetSETMDefaultValue();
            }
            else if (type == ConfigType.VenusDE)
            {
                SetDETMDefaultValue();
            }

                    
            Singleton<DataManager>.Instance.Initialize(false);

            _thread = new PeriodicJob(500, OnMonitor, nameof(SimulatorSystem), true);
        }

        private void SetDefaultValue(ModuleName mod, JetChamber jetChamber)
        {

            switch (jetChamber)
            {
                case JetChamber.VenusSE:
                    IO.DI[$"{mod}.DI_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_ATM_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_PM_VAC_Switch"].Value = false;
                    IO.DI[$"{mod}.DI_ESC_Coolant_Flow_SW"].Value = true;
                    IO.DI[$"{mod}.DI_Water_Leak_Sensor"].Value = true;

                    IO.DI[$"{mod}.DI_CDA_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Lift_Pin_Up_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Lift_Pin_Down_POS"].Value = true;
                    //IO.DI[$"{mod}.DI_RF_Generator_Interlock"].Value = true;
                    //IO.DI[$"{mod}.DI_Source_RF_Fan"].Value = true;

                    IO.DI[$"{mod}.DI_RF_HV_Interlock_OK"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Interlock"].Value = true;
                    IO.DI[$"{mod}.DI_Coolant_Inlet_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Coolant_Outlet_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Chamber_Pressure_10t_Gauge_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Process_Pressure_100mt_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Pressure_10t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Valve_Control_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Foreline_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Heater_On_FB"].Value = false;

                    IO.DI[$"{mod}.DI_CHB_Wall_TC_Deviation_out_of_range"].Value = true;
                    IO.DI[$"{mod}.DI_CHB_Wall_Control_TC_Broken_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_CHB_Wall_Monitor_TC_Broken_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_CHB_Wall_Heater_On_FB"].Value = true;
                    IO.DI[$"{mod}.DI_CHB_Wall_OT_Switch_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_PN2_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC1_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC2_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC3_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC4_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC5_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC6_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC7_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC8_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC9_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC10_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC11_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC12_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_He_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_He_Pressure_100t_Gauge_Alarm"].Value = true;



                    IO.DI[$"{mod}.DI_Gas_Box_Door_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Gas_Box_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_SOURCE_RF_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_TM_ROB_NOT_EXTEND_TO_PM"].Value = true;
                    IO.DI[$"{mod}.DI_TM_Slit_Door_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_Source_Match_interlock_ok"].Value = true;
                    IO.DI[$"{mod}.DI_Bias_Match_interlock_ok"].Value = true;

                    IO.DI[$"{mod}.DI_GASLINE_TC_Deviation_out_of_range"].Value = true;
                    IO.DI[$"{mod}.DI_GASLINE_Control_TC_Broken_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_GASLINE_Monitor_TC_Broken_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_GASLINE_Heater_On_FB"].Value = true;

                    IO.DI[$"{mod}.DI_CTRL_BOX_1#FAN_OK"].Value = true;
                    IO.DI[$"{mod}.DI_CTRL_BOX_2#FAN_OK"].Value = true;
                    IO.DI[$"{mod}.DI_POWER_BOX_FAN_OK"].Value = true;

                    //// pressure

                    SetAiValue($"{mod}.AI_Process_Pressure_100mt", 100);
                    //SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
                    SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 5001);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5000);

                    //// Temperature

                    SetAiValue($"{mod}.AI_Valve_Control_TC_Temp", 28);
                    //SetAiValue($"{mod}.AI_Valve_Monitor_TC_Temp", 27);
                    SetAiValue($"{mod}.AI_Fline_Control_TC_Temp", 28);
                    //SetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp", 27);
                    SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", 28);
                    SetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp", 27);
                    SetAiValue($"{mod}.AI_Coolant_Inlet_Temp", 28);


                    // Datetime
                    SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
                    SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
                    SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
                    SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
                    SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
                    SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);

                    break;

                case JetChamber.VenusDE:
                    IO.DI[$"{mod}.DI_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_ATM_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_PM_VAC_Switch"].Value = false;
                    IO.DI[$"{mod}.DI_ESC_Coolant_Flow_SW"].Value = true;
                    IO.DI[$"{mod}.DI_Water_Leak_Sensor"].Value = true;

                    IO.DI[$"{mod}.DI_Lift_Pin_Up_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Lift_Pin_Down_POS"].Value = true;
                    IO.DI[$"{mod}.DI_CDA_Pressure_Switch"].Value = true;
                    //IO.DI[$"{mod}.DI_RF_Generator_Interlock"].Value = true;
                    //IO.DI[$"{mod}.DI_Source_RF_Fan"].Value = true;

                    IO.DI[$"{mod}.DI_RF_HV_Interlock_OK"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Interlock"].Value = true;
                    IO.DI[$"{mod}.DI_Liner_Door_Open_Position"].Value = true;
                    IO.DI[$"{mod}.DI_Liner_Door_Close_Position"].Value = false;
                    IO.DI[$"{mod}.DI_ESC_Coolant_Inlet_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Magnets_Coils_ON_FB"].Value = false;

                    IO.DI[$"{mod}.DI_ESC_Coolant_Outlet_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Chamber_Pressure_10t_Gauge_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Process_Pressure_1t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Pressure_10t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Valve_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Valve_Heater_On_FB"].Value = false;

                    IO.DI[$"{mod}.DI_Foreline_TC_Deviation_out_of_range"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Monitor_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Heater_On_FB"].Value = false;

                    //IO.DI[$"{mod}.DI_CHB_Wall_TC_Deviation_out_of_range"].Value = true;
                    //IO.DI[$"{mod}.DI_CHB_Wall_Control_TC_Broken_Alarm"].Value = true;
                    //IO.DI[$"{mod}.DI_CHB_Wall_Monitor_TC_Broken_Alarm"].Value = true;
                    //IO.DI[$"{mod}.DI_CHB_Wall_Heater_On_FB"].Value = true;
                    //IO.DI[$"{mod}.DI_CHB_Wall_OT_Switch_Alarm"].Value = true;
                    IO.DI[$"{mod}.DI_PN2_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC1_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC2_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC3_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC4_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC5_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC6_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC7_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC8_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC9_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC10_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC11_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC12_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_He_Pressure_Switch"].Value = true;
                    //IO.DI[$"{mod}.DI_ESC_He_Pressure_100t_Gauge_Alarm"].Value = true;



                    IO.DI[$"{mod}.DI_Gas_Box_Door_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Gas_Box_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_BIAS_RF_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_CHB_Coolant_Flow_SW"].Value = true;

                    //IO.DI[$"{mod}.DI_SOURCE_RF_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_TM_ROB_NOT_EXTEND_TO_PM"].Value = true;
                    IO.DI[$"{mod}.DI_TM_Slit_Door_Closed"].Value = true;
                    //IO.DI[$"{mod}.DI_Source_Match_interlock_ok"].Value = true;
                    IO.DI[$"{mod}.DI_Bias_Match_interlock_ok"].Value = true;

                    //IO.DI[$"{mod}.DI_GASLINE_TC_Deviation_out_of_range"].Value = true;
                    //IO.DI[$"{mod}.DI_GASLINE_Control_TC_Broken_Alarm"].Value = true;
                    //IO.DI[$"{mod}.DI_GASLINE_Monitor_TC_Broken_Alarm"].Value = true;
                    //IO.DI[$"{mod}.DI_GASLINE_Heater_On_FB"].Value = true;

                    IO.DI[$"{mod}.DI_CTRL_BOX_1#FAN_OK"].Value = true;
                    IO.DI[$"{mod}.DI_CTRL_BOX_2#FAN_OK"].Value = true;
                    IO.DI[$"{mod}.DI_POWER_BOX_FAN_OK"].Value = true;
                    IO.DI[$"{mod}.DI_MAGNET_BOX_FAN_OK"].Value = true;

                    //// pressure

                    SetAiValue($"{mod}.AI_Process_Pressure_1t", 100);
                    //SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
                    SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 5001);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5000);

                    //// Temperature

                    SetAiValue($"{mod}.AI_Valve_Control_TC_Temp", 28);
                    //SetAiValue($"{mod}.AI_Gasline_Control_TC_Temp", 27);
                    SetAiValue($"{mod}.AI_Fline_Control_TC_Temp", 28);
                    SetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp", 28);
                    //SetAiValue($"{mod}.AI_Gasline_Monitor_TC_Temp", 27);
                    SetAiValue($"{mod}.AI_CHB_Coolant_Inlet_Temp", 28);
                    SetAiValue($"{mod}.AI_CHB_Coolant_Outlet_Temp", 27);
                    SetAiValue($"{mod}.AI_ESC_Coolant_Inlet_Temp", 28);
                    SetAiValue($"{mod}.AI_ESC_Coolant_Outlet_Temp", 28);


                    // Datetime
                    SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
                    SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
                    SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
                    SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
                    SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
                    SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);

                    break;
                case JetChamber.Kepler2300:
                    // chamber
                    IO.DI[$"{mod}.DI_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_ATM_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_VAC_Switch"].Value = false;

                    IO.DI[$"{mod}.DI_Water_Leak_Sensor"].Value = true;

                    IO.DI[$"{mod}.DI_Lift_Pin_Up_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Lift_Pin_Down_POS"].Value = true;
                    IO.DI[$"{mod}.DI_Source_RF_Generator_Interlock"].Value = true;
                    IO.DI[$"{mod}.DI_Source_RF_Fan"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Interlock"].Value = true;

                    IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = true;
                    IO.DI[$"{mod}.DI_CDA_Pressure_Switch"].Value = true;





                    IO.DI[$"{mod}.DI_S_Valve_TC_Deviation_out_of_range"].Value = false;
                    IO.DI[$"{mod}.DI_S_Valve_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_S_Valve_Monitor_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_S_Valve_Heater_On_FB"].Value = false;

                    IO.DI[$"{mod}.DI_Foreline_TC_Deviation_out_of_range"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Monitor_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Heater_On_FB"].Value = false;

                    IO.DI[$"{mod}.DI_CHB_Wall_TC_Deviation_out_of_range"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_Wall_Control_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_CHB_Wall_Monitor_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_Wall_Heater_On_FB"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_Wall_OT_Switch_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_PN2_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC1_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC2_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC3_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC4_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC5_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC6_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC7_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC8_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_He_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_He_Pressure_100t_Guage_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Gas_Box_Door_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Gas_Box_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Source_RF_Water_Flow_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_S_Valve_OT_Switch_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_OT_Switch_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Arm_Not_Extend_to_PM"].Value = true;
                    IO.DI[$"{mod}.DI_EFEM_Door_Colse"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_Inner_Coolant_Flow_SW"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_Outer_Coolant_Flow_SW"].Value = true;


                    //// pressure
                    SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 5001);
                    //SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5000);
                    SetAiValue($"{mod}.AI_Process_Pressure_100mt", 100);
                    //SetAiValue($"{mod}.AI_Chamber_Pressure_760t", ATM_PRESSURE);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);



                    //// Temperature

                    SetAiValue($"{mod}.AI_S_Valve_Control_TC_Temp", 28);

                    SetAiValue($"{mod}.AI_Foreline_Control_TC_Temp", 28);

                    SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", 28);

                    SetAiValue($"{mod}.AI_ESC_inner_coolant_outlet_TC_Temp", 20);
                    SetAiValue($"{mod}.AI_ESC_outer_coolant_outlet_TC_Temp", 30);
                    SetAiValue($"{mod}.AI_Top_Plate_coolant_outlet_TC_Temp", 40);



                    // Datetime
                    SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
                    SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
                    SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
                    SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
                    SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
                    SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);
                    break;

                case JetChamber.Kepler2200A:
                case JetChamber.Kepler2200B:

                    IO.DI[$"{mod}.DI_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_ATM_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_VAC_Switch"].Value = false;

                    IO.DI[$"{mod}.DI_Water_Leak_Sensor"].Value = true;

                    IO.DI[$"{mod}.DI_Source_RF_Generator_Interlock"].Value = true;
                    IO.DI[$"{mod}.DI_Source_RF_Match_Interlock"].Value = true;
                    IO.DI[$"{mod}.DI_Turbo_Pump_Interlock"].Value = true;


                    IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = true;
                    IO.DI[$"{mod}.DI_CDA_Pressure_Switch"].Value = true;



                    IO.DI[$"{mod}.DI_CHB_M-HT_Control_TC_Broken_Alarm"].Value = false;


                    IO.DI[$"{mod}.DI_CHB_M-HT_Heater_On_FB"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_M-HT_OT_Switch_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_PN2_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC1_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC2_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC3_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC4_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC5_Pressure_Switch"].Value = true;

                    IO.DI[$"{mod}.DI_MFC6_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC7_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_MFC8_Pressure_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_N2_Purge_Pressure_Switch"].Value = true;


                    IO.DI[$"{mod}.DI_Gas_Box_Door_Switch"].Value = true;
                    IO.DI[$"{mod}.DI_Lid_Up_Limit_Pos_SW"].Value = true;
                    //IO.DI[$"{mod}.DI_S_Valve_OT_Switch_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Lid_Down_Limit_Pos_SW"].Value = true;
                    IO.DI[$"{mod}.DI_Gas_Box_Pressure_Switch"].Value = true;
                    //IO.DI[$"{mod}.DI_TM_Safety_Door_Colse"].Value = true;

                    IO.DI[$"{mod}.DI_Arm_Not_Extend_to_PM"].Value = true;
                    //IO.DI[$"{mod}.DI_Source_RF_Water_Flow_Switch"].Value = true;
                    //// pressure
                    SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 5001);
                    //SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5000);
                    SetAiValue($"{mod}.AI_Process_Pressure_2t", 100);
                    SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);

                    //// Temperature

                    // SetAiValue($"{mod}.AI_S_Valve_Control_TC_Temp", 28);



                    SetAiValue($"{mod}.AI_CHB_M-HT_Control_TC_Temp", 28);


                    // Datetime
                    SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
                    SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
                    SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
                    SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
                    SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
                    SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);
                    break;
            }

        }
        private void SetTMDefaultValue()
        {
            ModuleName mod = ModuleName.TM;

            IO.DI[$"{mod}.DI_TM_Power_On"].Value = true;
            IO.DI[$"{mod}.DI_TM_In_Safety"].Value = true;
            IO.DI[$"{mod}.DI_Water_Leak_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_PMA"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_PMB"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_PMC"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_PMD"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_LLA"].Value = true;
            IO.DI[$"{mod}.DI_TM_RB_Not_Extend_LLB"].Value = true;
            IO.DI[$"{mod}.DI_EFEM_RB_Not_Extend_LLA"].Value = true;
            IO.DI[$"{mod}.DI_EFEM_RB_Not_Extend_LLB"].Value = true;
            IO.DI[$"{mod}.DI_EFEM_Side_Door_Closed"].Value = true;
            IO.DI[$"{mod}.DI_TM_CHB_PCW_Flow_Switch"].Value = true;
            IO.DI[$"{mod}.DI_LLA_PCW_Flow_Switch"].Value = true;
            IO.DI[$"{mod}.DI_LLB_PCW_Flow_Switch"].Value = true;
            IO.DI[$"{mod}.DI_TM_CHB_Door_Closed"].Value = true;

            IO.DI[$"{mod}.DI_LLA_Lid_Door_Closed"].Value = true;
            IO.DI[$"{mod}.DI_LLB_Lid_Door_Closed"].Value = true;

            IO.DI[$"{mod}.DI_LLA_E_Slit_Door_open_Position"].Value = false;
            IO.DI[$"{mod}.DI_LLA_E_Slit_Door_close_Position"].Value = true;
            IO.DI[$"{mod}.DI_LLA_T_Slit_Door_open_Position"].Value = false;
            IO.DI[$"{mod}.DI_LLA_T_Slit_Door_close_Position"].Value = true;
            IO.DI[$"{mod}.DI_LLB_E_Slit_Door_open_Position"].Value = false;
            IO.DI[$"{mod}.DI_LLB_E_Slit_Door_close_Position"].Value = true;
            IO.DI[$"{mod}.DI_LLB_T_Slit_Door_open_Position"].Value = false;
            IO.DI[$"{mod}.DI_LLB_T_Slit_Door_close_Position"].Value = true;


            IO.DI[$"{mod}.DI_PMA_SlitDoor_Open_Position"].Value = false;
            IO.DI[$"{mod}.DI_PMA_SlitDoor_Close_Position"].Value = true;

            IO.DI[$"{mod}.DI_PMB_SlitDoor_Open_Position"].Value = false;
            IO.DI[$"{mod}.DI_PMB_SlitDoor_Close_Position"].Value = true;

            IO.DI[$"{mod}.DI_PMC_SlitDoor_Open_Position"].Value = false;
            IO.DI[$"{mod}.DI_PMC_SlitDoor_Close_Position"].Value = true;

            IO.DI[$"{mod}.DI_PMD_SlitDoor_Open_Position"].Value = false;
            IO.DI[$"{mod}.DI_PMD_SlitDoor_Close_Position"].Value = true;

            IO.DI[$"{mod}.DI_CDA_Pressure_Switch"].Value = true;
            IO.DI[$"{mod}.DI_Vaccum_Pressure_Switch"].Value = true;
            IO.DI[$"{mod}.DI_N2_Pressure_Switch"].Value = true;

            IO.DI[$"{mod}.DI_TM_Chamber_VAC_Gauge_Alarm"].Value = true;
            IO.DI[$"{mod}.DI_TM_Foreline_VAC_Gauge_Alarm"].Value = true;
            IO.DI[$"{mod}.DI_LLA_Chamber_VAC_Gauge_Alarm"].Value = true;
            IO.DI[$"{mod}.DI_LLA_Foreline_VAC_Gauge_Alarm"].Value = true;
            IO.DI[$"{mod}.DI_LLB_Chamber_VAC_Gauge_Alarm"].Value = true;
            IO.DI[$"{mod}.DI_LLB_Foreline_VAC_Gauge_Alarm"].Value = true;

            IO.DI[$"{mod}.DI_TM_ATM_Switch"].Value = true;
            IO.DI[$"{mod}.DI_LLA_ATM_Switch"].Value = true;
            IO.DI[$"{mod}.DI_LLB_ATM_Switch"].Value = true;

            IO.DI[$"{mod}.DI_PMA_Lid_Closed"].Value = true;
            IO.DI[$"{mod}.DI_PMB_Lid_Closed"].Value = true;
            IO.DI[$"{mod}.DI_PMC_Lid_Closed"].Value = true;
            IO.DI[$"{mod}.DI_PMD_Lid_Closed"].Value = true;




            // Datetime
            SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
            SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
            SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
            SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
            SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
            SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);


            SetAiValue($"{mod}.AI_TM_Foreline_Pressure", 100);
            SetAiValue($"{mod}.AI_LLA_Foreline_Pressure", 150);
            SetAiValue($"{mod}.AI_LLB_Foreline_Pressure", 200);


            if (SystemConfig.Instance.GetValue<bool>("System.IsATMMode"))
            {
                SetAiValue($"{mod}.AI_TM_CHB_Pressure", 760000);
                SetAiValue($"{mod}.AI_LLA_CHB_Pressure", 760000);
                SetAiValue($"{mod}.AI_LLB_CHB_Pressure", 760000);
            }
            else
            {
                SetAiValue($"{mod}.AI_TM_CHB_Pressure", 5000);
                SetAiValue($"{mod}.AI_LLA_CHB_Pressure", 5002);
                SetAiValue($"{mod}.AI_LLB_CHB_Pressure", 5004);
            }

        }
        private void SetSETMDefaultValue()
        {
            ModuleName mod = ModuleName.SETM;

            IO.DI[$"{mod}.DI_System_CDA_Pressure_OK"].Value = true;
            IO.DI[$"{mod}.DI_LID_DOOR_CLOSED"].Value = true;
            IO.DI[$"{mod}.DI_VCE_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMA_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMB_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_VCE_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_VCE_Wafer_Senser"].Value = true;
            IO.DI[$"{mod}.DI_PMA_Wafer_Senser"].Value = true;
            IO.DI[$"{mod}.DI_PMB_Wafer_Senser"].Value = true;
            IO.DI[$"{mod}.DI_PMC_Wafer_Senser"].Value = true;
            IO.DI[$"{mod}.DI_AC_RACK_FAN_OK"].Value = true;
            IO.DI[$"{mod}.DI_AC_RACK_Smoke_SW1"].Value = false;
            IO.DI[$"{mod}.DI_AC_RACK_Smoke_SW2"].Value = false;
            IO.DI[$"{mod}.DI_FA_Smoke_SW"].Value = false;
            IO.DI[$"{mod}.DI_Gas_Treatment_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_SYSTEM_N2_Pressure_SW"].Value = true;
            IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Open_Pos"].Value = false;
            IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Close_Pos"].Value = true;
            IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Open_Pos"].Value = false;
            IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Close_Pos"].Value = true;
            IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Open_Pos"].Value = false;
            IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Close_Pos"].Value = true;
            IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Open_Pos"].Value = false;
            IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Close_Pos"].Value = true;
            IO.DI[$"{mod}.DI_TM_HE_Pressure_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_N2_Pressure_SW"].Value = true;
            IO.DI[$"{mod}.DI_PMC_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PCW_Leak_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_CDA_Pressure_SW"].Value = true;
            IO.DI[$"{mod}.DI_VCE_VAC_SW"].Value = false;
            IO.DI[$"{mod}.DI_TM_VAC_SW"].Value = false;           
            IO.DI[$"{mod}.DI_TM_ROBOT_NOT_EXTEND_VCE"].Value = true;          
            IO.DI[$"{mod}.DI_TM_ROBOT_NOT_EXTEND_PMA"].Value = true;
            IO.DI[$"{mod}.DI_TM_ROBOT_NOT_EXTEND_PMB"].Value = true;
            IO.DI[$"{mod}.DI_TM_ROBOT_NOT_EXTEND_PMC"].Value = true;

            SetAiValue($"{mod}.AI_MFC_Flow", 3000);
            SetAiValue($"{mod}.AI_VCE_Pressure", 3000);
            SetAiValue($"{mod}.AI_Foreline_Pressure", 3000);
            SetAiValue($"{mod}.AI_TM_Pressure", 20);
        }
        private void SetDETMDefaultValue()
        {
            ModuleName mod = ModuleName.DETM;

            IO.DI[$"{mod}.DI_Smif1_Ready_to_load"].Value = true;
            IO.DI[$"{mod}.DI_Smif1_Ready_to_unload"].Value = true;
            IO.DI[$"{mod}.DI_Smif2_Ready_to_load"].Value = true;
            IO.DI[$"{mod}.DI_Smif2_Ready_to_unload"].Value = true;
            IO.DI[$"{mod}.DI_PMA_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMB_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMC_SLIT_DOOR_OPEN_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_VCEA_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_VCEB_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_PMA_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_PMB_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_PMC_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_ROBOT_TO_PMD_RETRACT"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_PMA_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_PMB_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_PMC_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_PMD_Wafer_Sensor"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_SlitDoor_Open_POS"].Value = false;
            IO.DI[$"{mod}.DI_VCEA_SlitDoor_Close_POS"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_SlitDoor_Open_POS"].Value = false;
            IO.DI[$"{mod}.DI_VCEB_SlitDoor_Close_POS"].Value = true;
            IO.DI[$"{mod}.DI_TM_N2_1_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_N2_2_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_CDA_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_He_SW"].Value = true;
            IO.DI[$"{mod}.DI_LEAK"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_TM_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_AC_RACK_FAN_OK"].Value = true;
            IO.DI[$"{mod}.DI_AC_RACK_SMOKE_Out1"].Value = false;
            IO.DI[$"{mod}.DI_AC_RACK_SMOKE_Out2"].Value = false;
            IO.DI[$"{mod}.DI_FACTORY_SMOKE_Out"].Value = false;
            IO.DI[$"{mod}.DI_Abnormal_Exhaust_Gas"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_Cassette_Present"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_Cassette_Present"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_ADR_LOCKED"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_ADR_LOCKED"].Value = true;
            IO.DI[$"{mod}.DI_TM_LID_Close"].Value = true;
            IO.DI[$"{mod}.DI_LEFT_SMIF_READY"].Value = true;
            IO.DI[$"{mod}.DI_LEFT_SMIF_POD_INPLACE"].Value = true;
            IO.DI[$"{mod}.DI_RIGHT_SMIF_POD_INPLACE"].Value = true;
            IO.DI[$"{mod}.DI_LEFT_SMIF_ERROR"].Value = true;
            IO.DI[$"{mod}.DI_RIGHT_SMIF_ERROR"].Value = true;
            IO.DI[$"{mod}.DI_VCEA_EXTEND_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_VCEB_EXTEND_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMA_EXTEND_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMB_EXTEND_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_PMC_EXTEND_ENABLE"].Value = true;
            IO.DI[$"{mod}.DI_Safty_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_TM_Soft_Pump"].Value = true;
            IO.DI[$"{mod}.DI_TM_Soft_Vent"].Value = true;


            SetAiValue($"{mod}.AI_MFC_Flow", 3000);
            SetAiValue($"{mod}.AI_Left_VCE_Pressure", 3000);
            SetAiValue($"{mod}.AI_Right_VCE_Pressure", 3000);
            SetAiValue($"{mod}.AI_VCE_Foreline_Pressure", 20);
            SetAiValue($"{mod}.AI_TM_Foreline_Pressure", 20);
            SetAiValue($"{mod}.AI_TM_Pressure", 20);
        }

        private bool OnMonitor()
        {
            try
            {
                foreach (var item in jetChambers)
                {
                    switch (item.Value)
                    {
                       
                        case JetChamber.Kepler2300:
                            MonitorSlitDoorInTM(item.Key);
                            MonitorPin(item.Key);
                            MonitorPressure_Kepler(item.Key);

                            //MonitorTemperature(item.Key);
                            MonitorGas(item.Key);
                            this.SimulateHe(item.Key);

                            //MonitorRF(item.Key);
                            ChangeTime(item.Key);
                            //MonitorIOPumpCtrl(item.Key);
                            MonitorLid(item.Key);
                            break;
                        case JetChamber.Kepler2200A:
                        case JetChamber.Kepler2200B:

                            MonitorSlitDoorInTM(item.Key);
                            MonitorPressure_Kepler2200A(item.Key);
                            //MonitorTemperature(item.Key);
                            MonitorGas(item.Key);
                            // MonitorRF(item.Key);
                            ChangeTime(item.Key);
                            //MonitorIOPumpCtrl(item.Key);
                            MonitorLid(item.Key);
                            MonitorIOHighTemperatureHeater(item.Key);
                            MonitorKepler2200Heater(item.Key);
                            break;

                        case JetChamber.VenusSE:
                            MonitorPin(item.Key);
                            //MonitorVenuSESlitDoor(item.Key);
                            MonitorSEPressure(item.Key);
                            MonitorSEGas(item.Key);
                            ChangeTime(item.Key);
                            this.SimulateSEHe(item.Key);
                            break;
                        case JetChamber.VenusDE:
                            MonitorPin(item.Key);
                            MonitorDEGas(item.Key);
                            //MonitorVenuDESlitDoor(item.Key);
                            MonitorDEPressure(item.Key);
                            ChangeTime(item.Key);
                            MonitorLinerDoor(item.Key);
                            this.SimulateDEHe(item.Key);
                            break;
                    }
                }

                ChangeTime(ModuleName.TM);

                if (type == ConfigType.Kepler2200 || type == ConfigType.Kepler2300 || type == ConfigType.Other)
                {
                    MonitorMFSlitDoor();
                    MonitorMFPressure();
                }
                else if (type == ConfigType.VenusSE)
                {
                    MonitorSEMFSlitDoor();
                    MonitorSEMFPressure();
                }
                else if (type == ConfigType.VenusDE)
                {
                    MonitorDEMFSlitDoor();
                    MonitorDEMFPressure();
                }

            }
            catch (Exception e)
            {
                LOG.WriteExeption(e);
            }
            return true;
        }

        private void ChangeTime(ModuleName mod)
        {

            // Heartbeat with PLC
            SetAiValue($"{mod}.AI_Heartbeat_FB", GetAoValue($"{mod}.AO_Heartbeat"));

            SetAiValue($"{mod}.AI_Year", DateTime.Now.Year);
            SetAiValue($"{mod}.AI_Month", DateTime.Now.Month);
            SetAiValue($"{mod}.AI_Day", DateTime.Now.Day);
            SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
            SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
            SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);


        }
        //void MonitorVenuSESlitDoor(ModuleName mod)
        //{

        //}
        void MonitorSlitDoorInPM(ModuleName mod)
        {
            // slit door open
            if (IO.DO[$"{mod}.DO_Slit_Door_Open"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = false;
            }

            // slit door close
            if (IO.DO[$"{mod}.DO_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = true;
            }
        }
        void MonitorLinerDoor(ModuleName mod)
        {
            // slit door open
            if (IO.DO[$"{mod}.DO_PM_Liner_Door_Open"].Value)
            {
                IO.DI[$"{mod}.DI_Liner_Door_Open_Position"].Value = true;
                IO.DI[$"{mod}.DI_Liner_Door_Close_Position"].Value = false;
            }

            // slit door close
            if (IO.DO[$"{mod}.DO_PM_Liner_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_Liner_Door_Open_Position"].Value = false;
                IO.DI[$"{mod}.DI_Liner_Door_Close_Position"].Value = true;
            }
        }
        void MonitorSlitDoorInTM(ModuleName mod)
        {
            // slit door open
            if (IO.DO[$"TM.DO_{mod}_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = false;
            }

            // slit door close
            if (IO.DO[$"TM.DO_{mod}_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_Slit_Door_Close_POS"].Value = true;
            }
        }
        void MonitorMFSlitDoor()
        {
            ModuleName mod = ModuleName.TM;
            // LLA T door open
            if (IO.DO[$"{mod}.DO_LLA_Slit_Door_T_Open"].Value)
            {
                IO.DI[$"{mod}.DI_LLA_T_Slit_Door_open_Position"].Value = true;
                IO.DI[$"{mod}.DI_LLA_T_Slit_Door_close_Position"].Value = false;
            }

            // LLB T door open
            if (IO.DO[$"{mod}.DO_LLB_Slit_Door_T_Open"].Value)
            {
                IO.DI[$"{mod}.DI_LLB_T_Slit_Door_open_Position"].Value = true;
                IO.DI[$"{mod}.DI_LLB_T_Slit_Door_close_Position"].Value = false;
            }

            // LLA E door open
            if (IO.DO[$"{mod}.DO_LLA_Slit_Door_E_Open"].Value)
            {
                IO.DI[$"{mod}.DI_LLA_E_Slit_Door_open_Position"].Value = true;
                IO.DI[$"{mod}.DI_LLA_E_Slit_Door_close_Position"].Value = false;
            }

            // LLB E door open
            if (IO.DO[$"{mod}.DO_LLB_Slit_Door_E_Open"].Value)
            {
                IO.DI[$"{mod}.DI_LLB_E_Slit_Door_open_Position"].Value = true;
                IO.DI[$"{mod}.DI_LLB_E_Slit_Door_close_Position"].Value = false;
            }

            // LLA T door close
            if (IO.DO[$"{mod}.DO_LLA_Slit_Door_T_Close"].Value)
            {
                IO.DI[$"{mod}.DI_LLA_T_Slit_Door_open_Position"].Value = false;
                IO.DI[$"{mod}.DI_LLA_T_Slit_Door_close_Position"].Value = true;
            }

            // LLB T door close
            if (IO.DO[$"{mod}.DO_LLB_Slit_Door_T_Close"].Value)
            {
                IO.DI[$"{mod}.DI_LLB_T_Slit_Door_open_Position"].Value = false;
                IO.DI[$"{mod}.DI_LLB_T_Slit_Door_close_Position"].Value = true;
            }

            // LLA E door close
            if (IO.DO[$"{mod}.DO_LLA_Slit_Door_E_Close"].Value)
            {
                IO.DI[$"{mod}.DI_LLA_E_Slit_Door_open_Position"].Value = false;
                IO.DI[$"{mod}.DI_LLA_E_Slit_Door_close_Position"].Value = true;
            }

            // LLB E door close
            if (IO.DO[$"{mod}.DO_LLB_Slit_Door_E_Close"].Value)
            {
                IO.DI[$"{mod}.DI_LLB_E_Slit_Door_open_Position"].Value = false;
                IO.DI[$"{mod}.DI_LLB_E_Slit_Door_close_Position"].Value = true;
            }

            // PMA slitdoor door close/open
            if (IO.DO[$"{mod}.DO_PMA_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Open_Position"].Value = false;
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Close_Position"].Value = true;
            }
            if (IO.DO[$"{mod}.DO_PMA_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Open_Position"].Value = true;
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Close_Position"].Value = false;
            }

            // PMB slitdoor door close/open
            if (IO.DO[$"{mod}.DO_PMB_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Open_Position"].Value = false;
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Close_Position"].Value = true;
            }
            if (IO.DO[$"{mod}.DO_PMB_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Open_Position"].Value = true;
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Close_Position"].Value = false;
            }

            // PMC slitdoor door close/open
            if (IO.DO[$"{mod}.DO_PMC_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Open_Position"].Value = false;
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Close_Position"].Value = true;
            }
            if (IO.DO[$"{mod}.DO_PMC_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Open_Position"].Value = true;
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Close_Position"].Value = false;
            }

            // PMD slitdoor door close/open
            if (IO.DO[$"{mod}.DO_PMD_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_PMD_SlitDoor_Open_Position"].Value = false;
                IO.DI[$"{mod}.DI_PMD_SlitDoor_Close_Position"].Value = true;
            }
            if (IO.DO[$"{mod}.DO_PMD_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_PMD_SlitDoor_Open_Position"].Value = true;
                IO.DI[$"{mod}.DI_PMD_SlitDoor_Close_Position"].Value = false;
            }

        }
        void MonitorSEMFSlitDoor()
        {
            ModuleName mod = ModuleName.SETM;
            // VCE T door open
            if (IO.DO[$"{mod}.DO_VCE_Slit_Door_Open"].Value)
            {
                IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Open_Pos"].Value = true;
                IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Close_Pos"].Value = false;
            }

            // VCE T door Close
            if (IO.DO[$"{mod}.DO_VCE_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Open_Pos"].Value = false;
                IO.DI[$"{mod}.DI_VCE_TM_Slit_Door_Close_Pos"].Value = true;
            }
            //pma
            if (IO.DO[$"{mod}.DO_PMA_Slit_Door_Open"].Value)
            {

                IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Open_Pos"].Value = true;
                IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Close_Pos"].Value = false;
            }

            if (IO.DO[$"{mod}.DO_PMA_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Open_Pos"].Value = false;
                IO.DI[$"{mod}.DI_TM_PMA_Slit_Door_Close_Pos"].Value = true;
            }

            //pmb
            if (IO.DO[$"{mod}.DO_PMB_Slit_Door_Open"].Value)
            {

                IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Open_Pos"].Value = true;
                IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Close_Pos"].Value = false;
            }

            if (IO.DO[$"{mod}.DO_PMB_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Open_Pos"].Value = false;
                IO.DI[$"{mod}.DI_TM_PMB_Slit_Door_Close_Pos"].Value = true;
            }

            //pmc
            if (IO.DO[$"{mod}.DO_PMC_Slit_Door_Open"].Value)
            {

                IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Open_Pos"].Value = true;
                IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Close_Pos"].Value = false;
            }

            if (IO.DO[$"{mod}.DO_PMC_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Open_Pos"].Value = false;
                IO.DI[$"{mod}.DI_TM_PMC_Slit_Door_Close_Pos"].Value = true;
            }
        }
        void MonitorDEMFSlitDoor()
        {
            ModuleName mod = ModuleName.DETM;
            // VCE L door open
            if (IO.DO[$"{mod}.DO_VCEA_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_VCEA_SlitDoor_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_VCEA_SlitDoor_Close_POS"].Value = false;
            }
            // VCE R door open
            if (IO.DO[$"{mod}.DO_VCEB_SlitDoor_Open"].Value)
            {
                IO.DI[$"{mod}.DI_VCEB_SlitDoor_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_VCEB_SlitDoor_Close_POS"].Value = false;
            }
            // VCE L door Close
            if (IO.DO[$"{mod}.DO_VCEA_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_VCEA_SlitDoor_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_VCEA_SlitDoor_Close_POS"].Value = true;
            }
            // VCE R door Close
            if (IO.DO[$"{mod}.DO_VCEB_SlitDoor_Close"].Value)
            {                       
                IO.DI[$"{mod}.DI_VCEB_SlitDoor_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_VCEB_SlitDoor_Close_POS"].Value = true;
            }
            //pma
            if (IO.DO[$"{mod}.DO_PMA_SlitDoor_Open"].Value)
            {

                IO.DI[$"{mod}.DI_PMA_SlitDoor_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Close_POS"].Value = false;
            }

            if (IO.DO[$"{mod}.DO_PMA_SlitDoor_Close"].Value)
            {
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_PMA_SlitDoor_Close_POS"].Value = true;
            }

            //pmb
            if (IO.DO[$"{mod}.DO_PMB_SlitDoor_Open"].Value)
            {                      
                                   
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Close_POS"].Value = false;
            }                      
                                   
            if (IO.DO[$"{mod}.DO_PMB_SlitDoor_Close"].Value)
            {                      
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_PMB_SlitDoor_Close_POS"].Value = true;
            }

            //pmc
            if (IO.DO[$"{mod}.DO_PMC_SlitDoor_Open"].Value)
            {                      
                                   
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Open_POS"].Value = true;
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Close_POS"].Value = false;
            }                      
                                   
            if (IO.DO[$"{mod}.DO_PMC_SlitDoor_Close"].Value)
            {                      
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Open_POS"].Value = false;
                IO.DI[$"{mod}.DI_PMC_SlitDoor_Close_POS"].Value = true;
            }
        }

        void MonitorPin(ModuleName mod)
        {
            // lift pin up
            if (IO.DO[$"{mod}.DO_Lift_Pin_Up"].Value != IO.DO[$"{mod}.DO_Lift_Pin_Down"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Pin_Up_POS"].Value = IO.DO[$"{mod}.DO_Lift_Pin_Up"].Value;
                IO.DI[$"{mod}.DI_Lift_Pin_Down_POS"].Value = IO.DO[$"{mod}.DO_Lift_Pin_Down"].Value;
            }
        }
        void MonitorLid(ModuleName mod)
        {

            // lift pin up
            if (IO.DO[$"{mod}.DO_Lid_Up"].Value != IO.DO[$"{mod}.DO_Lid_Down"].Value)
            {
                IO.DI[$"{mod}.DI_Lid_Closed"].Value = IO.DO[$"{mod}.DO_Lid_Down"].Value;
            }
        }
        void MonitorExtendAndRetract(ModuleName mod)
        {
            // Extend
            _trigLLExtend.CLK = IO.DO[$"{mod}.DO_Loadlock_Arm_Extend"].Value;
            if (_trigLLExtend.Q)
            {
                _trigLLRetract.RST = true;
                Thread.Sleep(500);
                IO.DI[$"{mod}.DI_Loadlock_Arm_Extend_POS"].Value = true;
                IO.DI[$"{mod}.DI_Loadlock_Arm_Retract_POS"].Value = false;
                IO.DI[$"{mod}.DI_Small_Wafer_In_POS"].Value = false;
                IO.DI[$"{mod}.DI_Big_Wafer_In_POS"].Value = false;
            }

            // Retract
            _trigLLRetract.CLK = IO.DO[$"{mod}.DO_Loadlock_Arm_Retract"].Value;
            if (_trigLLRetract.Q)
            {
                count++;
                _trigLLExtend.RST = true;
                Thread.Sleep(500);
                IO.DI[$"{mod}.DI_Loadlock_Arm_Extend_POS"].Value = false;
                IO.DI[$"{mod}.DI_Loadlock_Arm_Retract_POS"].Value = true;
                if (count == 1)
                {
                    IO.DI[$"{mod}.DI_Small_Wafer_In_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Big_Wafer_In_POS"].Value = false;
                }
                else if (count == 2)
                {
                    count = 0;
                    IO.DI[$"{mod}.DI_Small_Wafer_In_POS"].Value = true;
                    IO.DI[$"{mod}.DI_Big_Wafer_In_POS"].Value = false;
                }
            }

        }

        void MonitorPressure(ModuleName mod)
        {
            string sAI_Foreline = "AI_Foreline_Pressure_760t";



            // Loadlock pressure
            string sAI_LoadLockPressure = "AI_LL_Pressure_760t";

            // Foreline

            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }

            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]
            string sAI_ChamberPressure = "AI_Chamber_Pressure_10t";
            string sAI_ProcessPressure = "AI_Chamber_Pressure_Virtual";
            //float chamber_pressure = GetMockChamberPressure(mod);
            //float process_pressure = GetAiValue($"{mod}.AI_Chamber_Pressure_Virtual");

            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];
            DOAccessor turbo_pump_vlv = IO.DO[$"{mod}.DO_Turbo_Pump_Pumping_Valve"];

            if (fast_pump_vlv.Value || soft_pump_vlv.Value || turbo_pump_vlv.Value)
            {
                //任意泵打开
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (fast_pump_vlv.Value && soft_pump_vlv.Value)
                {//开双泵
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 30000 > 0 ? getAiValue_ChamberPressure - 30000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1500 > 0 ? getAiValue_ProcessPressure - 1500 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_vlv.Value)//开
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 25000 > 0 ? getAiValue_ChamberPressure - 25000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1300 > 0 ? getAiValue_ProcessPressure - 1300 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(12000, 13000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(120, 130));
                }
                else if (soft_pump_vlv.Value)
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 10000 > 0 ? getAiValue_ChamberPressure - 10000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1100 > 0 ? getAiValue_ProcessPressure - 1100 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(13000, 14000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(100, 110));
                }
                else if (turbo_pump_vlv.Value)
                {

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;

                    if ((getAiValue_ChamberPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", getAiValue_ChamberPressure - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", 0);

                    if ((getAiValue_ProcessPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", 0);
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_N2_Valve"];
            //DOAccessor purge_vlv = IO.DO[$"{mod}.DO_Chamber_purge_valve"];

            //if (vent_vlv.Value || purge_vlv.Value)
            //{
            //    if (vent_vlv.Value && purge_vlv.Value)
            //    {
            //        float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            //        float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            //        if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
            //        {
            //            SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 30000);
            //            //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
            //        }
            //        else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
            //        {
            //            getAiValue_ProcessPressure = getAiValue_ChamberPressure;
            //            SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1500);
            //            SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1500);
            //        }
            //        //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(45000, 50000));
            //        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(150, 160));
            //    }
            //    else
            //
            if (vent_vlv.Value)
            {
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                }
                else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                {
                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                }
                else
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                }
                //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(25000, 30000));
                //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(130, 150));
            }


            // Loadlock Pumping Valve
            DOAccessor Loadlock_pump_vlv = IO.DO[$"{mod}.DO_Loadlock_Pumping_Valve"];
            if (Loadlock_pump_vlv.Value)
            {
                SetAiValue($"{mod}.{sAI_LoadLockPressure}", GetAiValue($"{mod}.{sAI_LoadLockPressure}") - 30000);
            }

            // Loadlock vent 
            DOAccessor Loadlock_vent_vlv = IO.DO[$"{mod}.DO_Loadlock_Vent_Valve"];
            if (Loadlock_vent_vlv.Value)
            {
                SetAiValue($"{mod}.{sAI_LoadLockPressure}", GetAiValue($"{mod}.{sAI_LoadLockPressure}") + 30000);
            }

            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 20);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", 20);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 10000)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_760t", 10000);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_760t", 150);
            }




            // 模拟压力计漂移
            //int p1 = (int)GetMockChamberPressure(mod);
            //int new_p1 = _rd.Next(p1 - 2, p1 + 2);
            //SetAiValue($"{mod}.AI_Chamber_Pressure_760t", new_p1);

            //int p2 = (int)GetAiValue($"{mod}.AI_Foreline_Pressure_10t");
            //int new_p2 = _rd.Next(p2 - 1, p2 + 1);
            //SetAiValue($"{mod}.AI_Foreline_Pressure_10t", new_p2);

            //int p3 = (int)GetAiValue($"{mod}.AI_Chamber_Pressure_Virtual");
            //int new_p3 = _rd.Next(p3 - 1, p3 + 1);
            //SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", new_p3);

            // 根据当前压力值设定信号
            //float chamber_pressure2 = GetMockChamberPressure(mod);

            // ATM switch
            IO.DI[$"{mod}.DI_PM_ATM_SW"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_PM_VAC_SW"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;

            // Throttle valve

            //var pos_sp = IO.AO[$"{mod}.AO_Throttle_Valve_Pressure_Setpoint"].Value;
            //var mock_pos_fb = _rd.Next(pos_sp - 2, pos_sp + 2);
            ////IO.AI[$"{mod}.AI_Throttle_Valve_Real_Pressure"].Value = (short)mock_pos_fb;
            //SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", mock_pos_fb);

            // 压力值
            //if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") < GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
            //{
            //    short increase = (short)_rd.Next(20, 30);
            //    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") + increase);
            //    if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") > GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
            //    {
            //        SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"));
            //    }
            //}
            //else
            //{
            //    short increase = (short)_rd.Next(20, 30);

            //    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") - increase);
            //    if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") < GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
            //    {
            //        SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"));
            //    }
            //}

            //// 位置值
            //if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") < GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
            //{
            //    short increase = (short)_rd.Next(20, 30);
            //    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") + increase);
            //    if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") > GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
            //    {
            //        SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"));
            //    }
            //}
            //else
            //{
            //    short increase = (short)_rd.Next(20, 30);

            //    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") - increase);
            //    if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") < GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
            //    {
            //        SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"));
            //    }
            //}
        }
        void MonitorSEPressure(ModuleName mod)
        {
            string sAI_Foreline = "AI_Foreline_Pressure_10t";
            string sAI_ChamberPressure = "AI_Chamber_Pressure_10t";
            string sAI_ProcessPressure = "AI_Chamber_Pressure_Virtual";




            // Foreline

            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }

            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]


            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];
            DOAccessor turbo_pump_vlv = IO.DO[$"{mod}.DO_Turbo_Pump_Pumping_Valve"];

            if (fast_pump_vlv.Value || soft_pump_vlv.Value || turbo_pump_vlv.Value)
            {
                //任意泵打开
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (fast_pump_vlv.Value && soft_pump_vlv.Value)
                {//开双泵
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 30000 > 0 ? getAiValue_ChamberPressure - 30000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);

                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1500 > 0 ? getAiValue_ProcessPressure - 1500 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                }
                else if (fast_pump_vlv.Value)//开
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 25000 > 0 ? getAiValue_ChamberPressure - 25000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1300 > 0 ? getAiValue_ProcessPressure - 1300 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                }
                else if (soft_pump_vlv.Value)
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 10000 > 0 ? getAiValue_ChamberPressure - 10000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1100 > 0 ? getAiValue_ProcessPressure - 1100 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                }
                else if (turbo_pump_vlv.Value)
                {

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;

                    if ((getAiValue_ChamberPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", getAiValue_ChamberPressure - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", 0);

                    if ((getAiValue_ProcessPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", 0);

                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_N2_Valve"];
            if (vent_vlv.Value)
            {
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                }
                else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                {
                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                }
                else
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                }
            }


            // Loadlock Pumping Valve

            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", 5);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 1999)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 1999);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 150);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_ATM_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_PM_VAC_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;


        }

        void MonitorDEPressure(ModuleName mod)
        {
            string sAI_Foreline = "AI_Foreline_Pressure_10t";
            string sAI_ChamberPressure = "AI_Chamber_Pressure_10t";
            string sAI_ProcessPressure = "AI_Chamber_Pressure_Virtual";




            // Foreline

            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }

            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]


            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            //DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];
            DOAccessor turbo_pump_vlv = IO.DO[$"{mod}.DO_Turbo_Pump_Pumping_Valve"];

            if (fast_pump_vlv.Value || turbo_pump_vlv.Value)
            {
                //任意泵打开
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (fast_pump_vlv.Value)
                {//开双泵
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 25000 > 0 ? getAiValue_ChamberPressure - 25000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1300 > 0 ? getAiValue_ProcessPressure - 1300 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                }
                else if (turbo_pump_vlv.Value)
                {

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;

                    if ((getAiValue_ChamberPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", getAiValue_ChamberPressure - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", 0);

                    if ((getAiValue_ProcessPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", 0);

                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_N2_Valve"];
            if (vent_vlv.Value)
            {
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                }
                else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                {
                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                }
                else
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                }
            }


            // Loadlock Pumping Valve

            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", 5);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 10000)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 10000);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 150);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_ATM_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_PM_VAC_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;


        }
        void MonitorPressure_Kepler(ModuleName mod)
        {
            string sAI_Foreline = "AI_Foreline_Pressure_10t";





            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }

            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]
            string sAI_ChamberPressure = "AI_Chamber_Pressure_10t";
            string sAI_ProcessPressure = "AI_Chamber_Pressure_Virtual";
            //float chamber_pressure = GetMockChamberPressure(mod);
            //float process_pressure = GetAiValue($"{mod}.AI_Chamber_Pressure_Virtual");

            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];
            DOAccessor turbo_pump_vlv = IO.DO[$"{mod}.DO_Turbo_Pump_Pumping_Valve"];

            if (fast_pump_vlv.Value || soft_pump_vlv.Value || turbo_pump_vlv.Value)
            {
                //任意泵打开
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (fast_pump_vlv.Value && soft_pump_vlv.Value)
                {//开双泵
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 30000 > 0 ? getAiValue_ChamberPressure - 30000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1500 > 0 ? getAiValue_ProcessPressure - 1500 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_vlv.Value)//开
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 25000 > 0 ? getAiValue_ChamberPressure - 25000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1300 > 0 ? getAiValue_ProcessPressure - 1300 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(12000, 13000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(120, 130));
                }
                else if (soft_pump_vlv.Value)
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 10000 > 0 ? getAiValue_ChamberPressure - 10000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1100 > 0 ? getAiValue_ProcessPressure - 1100 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(13000, 14000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(100, 110));
                }
                else if (turbo_pump_vlv.Value)
                {

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;

                    if ((getAiValue_ChamberPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", getAiValue_ChamberPressure - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", 0);

                    if ((getAiValue_ProcessPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", 0);
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_N2_Valve"];


            if (vent_vlv.Value)
            {
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                }
                else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                {
                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                }
                else
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                }
                //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(25000, 30000));
                //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(130, 150));
            }


            // Loadlock Pumping Valve


            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 20);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", 20);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 10000)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 10000);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 150);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_ATM_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_VAC_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;

        }

        void MonitorPressure_Kepler2200A(ModuleName mod)
        {
            string sAI_Foreline = "AI_Foreline_Pressure_10t";

            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }
            //SetAiValue($"{mod}.{sAI_Foreline}", 3000);
            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]
            string sAI_ChamberPressure = "AI_Chamber_Pressure_10t";
            string sAI_ProcessPressure = "AI_Chamber_Pressure_Virtual";
            //float chamber_pressure = GetMockChamberPressure(mod);
            //float process_pressure = GetAiValue($"{mod}.AI_Chamber_Pressure_Virtual");

            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];
            DOAccessor turbo_pump_vlv = IO.DO[$"{mod}.DO_Turbo_Pump_Pumping_Valve"];

            if (fast_pump_vlv.Value || soft_pump_vlv.Value || turbo_pump_vlv.Value)
            {
                //任意泵打开
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (fast_pump_vlv.Value && soft_pump_vlv.Value)
                {//开双泵
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 30000 > 0 ? getAiValue_ChamberPressure - 30000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1500 > 0 ? getAiValue_ProcessPressure - 1500 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }

                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_vlv.Value)//开
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 25000 > 0 ? getAiValue_ChamberPressure - 25000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1300 > 0 ? getAiValue_ProcessPressure - 1300 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(12000, 13000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(120, 130));
                }
                else if (soft_pump_vlv.Value)
                {
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        float targetChamberPressure = getAiValue_ChamberPressure - 10000 > 0 ? getAiValue_ChamberPressure - 10000 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        float targetChamberPressure = getAiValue_ProcessPressure - 1100 > 0 ? getAiValue_ProcessPressure - 1100 : 0;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", targetChamberPressure);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", targetChamberPressure);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(13000, 14000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(100, 110));
                }
                else if (turbo_pump_vlv.Value)
                {

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;

                    if ((getAiValue_ChamberPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", getAiValue_ChamberPressure - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", 0);

                    if ((getAiValue_ProcessPressure - 500) >= 0)
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    else
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", 0);
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 500);
                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_N2_Valve"];
            DOAccessor gas_final_vlv = IO.DO[$"{mod}.DO_Gas_Final_Valve"];



            if (vent_vlv.Value && gas_final_vlv.Value)
            {
                float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                }
                else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                {
                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                }
                else
                {
                    SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                }
                //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(25000, 30000));
                //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(130, 150));
            }


            // Loadlock Pumping Valve


            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 20);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_Virtual", 20);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 10000)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 10000);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 150);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_ATM_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_VAC_Switch"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;

            SetAiValue($"{mod}.AI_Process_Pressure_2t", 1995);

        }
        void MonitorSEMFPressure()
        {
            ModuleName mod = ModuleName.SETM;
            string VCE_ChamberPressure = "AI_VCE_Pressure";
            string TM_AI_ChamberPressure = "AI_TM_Pressure";

            DOAccessor TM_fast_pump_vlv = IO.DO[$"{mod}.DO_TM_Fast_Pumping"];
            DOAccessor TM_soft_pump_vlv = IO.DO[$"{mod}.DO_TM_Soft_Pumping"];

            DOAccessor TM_fast_Vent_vlv = IO.DO[$"{mod}.DO_TM_Fast_Vent"];
            DOAccessor TM_soft_Vent_vlv = IO.DO[$"{mod}.DO_TM_Soft_Vent"];


            DOAccessor VCE_fast_pump_vlv = IO.DO[$"{mod}.DO_VCE_Fast_Pumping"];
            DOAccessor VCE_soft_pump_vlv = IO.DO[$"{mod}.DO_VCE_Soft_Pumping"];

            DOAccessor VCE_fast_Vent_vlv = IO.DO[$"{mod}.DO_VCE_Fast_Vent"];
            DOAccessor VCE_soft_Vent_vlv = IO.DO[$"{mod}.DO_VCE_Soft_Vent"];
            float getAiValue_VCE_ChamberPressure = GetAiValue($"{mod}.{VCE_ChamberPressure}");
            float getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");

            if (TM_fast_pump_vlv.Value || TM_soft_pump_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 1500);
                }
            }

            if (TM_fast_Vent_vlv.Value || TM_soft_Vent_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 1500);
                }
            }
            if (VCE_fast_pump_vlv.Value || VCE_soft_pump_vlv.Value)
            {
                if (getAiValue_VCE_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{VCE_ChamberPressure}", GetAiValue($"{mod}.{VCE_ChamberPressure}") - 30000);
                }
                else if (getAiValue_VCE_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{VCE_ChamberPressure}", GetAiValue($"{mod}.{VCE_ChamberPressure}") - 1500);
                }
            }

            if (VCE_fast_Vent_vlv.Value || VCE_soft_Vent_vlv.Value)
            {
                if (getAiValue_VCE_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{VCE_ChamberPressure}", GetAiValue($"{mod}.{VCE_ChamberPressure}") + 30000);
                }
                else if (getAiValue_VCE_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{VCE_ChamberPressure}", GetAiValue($"{mod}.{VCE_ChamberPressure}") + 1500);
                }
            }
            getAiValue_VCE_ChamberPressure = GetAiValue($"{mod}.{VCE_ChamberPressure}");

            if (getAiValue_VCE_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{VCE_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_VCE_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{VCE_ChamberPressure}", 20);
            }

            getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");

            if (getAiValue_TM_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_TM_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", 20);
            }
            IO.DI[$"{mod}.DI_VCE_VAC_SW"].Value = GetAiValue($"{mod}.{VCE_ChamberPressure}") < VAC_SW_PRESSURE;

            // VAC switch
            IO.DI[$"{mod}.DI_TM_VAC_SW"].Value = GetAiValue($"{mod}.{TM_AI_ChamberPressure}") < VAC_SW_PRESSURE;

        }

        void MonitorDEMFPressure()
        {
            ModuleName mod = ModuleName.DETM;
            string AI_Left_VCE_Pressure = "AI_Left_VCE_Pressure";
            string AI_Right_VCE_Pressure = "AI_Right_VCE_Pressure";
            string TM_AI_ChamberPressure = "AI_TM_Pressure";

            DOAccessor TM_fast_pump_vlv = IO.DO[$"{mod}.DO_TM_Fast_Pump"];
            DOAccessor TM_soft_pump_vlv = IO.DO[$"{mod}.DO_TM_Soft_Pump"];

            DOAccessor TM_fast_Vent_vlv = IO.DO[$"{mod}.DO_TM_Fast_Vent"];
            DOAccessor TM_soft_Vent_vlv = IO.DO[$"{mod}.DO_TM_Soft_Vent"];


            DOAccessor DO_VCEA_Fast_Pump = IO.DO[$"{mod}.DO_VCEA_Fast_Pump"];
            DOAccessor DO_VCEA_Soft_Pump = IO.DO[$"{mod}.DO_VCEA_Soft_Pump"];

            DOAccessor DO_VCEB_Fast_Pump = IO.DO[$"{mod}.DO_VCEB_Fast_Pump"];
            DOAccessor DO_VCEB_Soft_Pump = IO.DO[$"{mod}.DO_VCEB_Soft_Pump"];

            DOAccessor DO_VCEA_Fast_Vent = IO.DO[$"{mod}.DO_VCEA_Fast_Vent"];
            DOAccessor DO_VCEA_Soft_Vent = IO.DO[$"{mod}.DO_VCEA_Soft_Vent"];

            DOAccessor DO_VCEB_Fast_Vent = IO.DO[$"{mod}.DO_VCEB_Fast_Vent"];
            DOAccessor DO_VCEB_Soft_Vent = IO.DO[$"{mod}.DO_VCEB_Soft_Vent"];

            float getAiValue_AI_Left_VCE_Pressure = GetAiValue($"{mod}.{AI_Left_VCE_Pressure}");
            float getAiValue_AI_Right_VCE_Pressure = GetAiValue($"{mod}.{AI_Right_VCE_Pressure}");
            float getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");



            if (DO_VCEA_Fast_Pump.Value || DO_VCEA_Soft_Pump.Value)
            {
                if (getAiValue_AI_Left_VCE_Pressure > 10000)
                {
                    SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", GetAiValue($"{mod}.{AI_Left_VCE_Pressure}") - 30000);
                }
                else if (getAiValue_AI_Left_VCE_Pressure <= 10000)
                {
                    SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", GetAiValue($"{mod}.{AI_Left_VCE_Pressure}") - 1500);
                }
            }

            if (DO_VCEB_Fast_Pump.Value || DO_VCEB_Soft_Pump.Value)
            {
                if (getAiValue_AI_Right_VCE_Pressure > 10000)
                {
                    SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", GetAiValue($"{mod}.{AI_Right_VCE_Pressure}") - 30000);
                }
                else if (getAiValue_AI_Right_VCE_Pressure <= 10000)
                {
                    SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", GetAiValue($"{mod}.{AI_Right_VCE_Pressure}") - 1500);
                }
            }

            if (TM_fast_pump_vlv.Value || TM_soft_pump_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 1500);
                }
            }


            if (DO_VCEA_Fast_Vent.Value || DO_VCEA_Soft_Vent.Value)
            {
                if (getAiValue_AI_Left_VCE_Pressure > 10000)
                {
                    SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", GetAiValue($"{mod}.{AI_Left_VCE_Pressure}") + 30000);
                }
                else if (getAiValue_AI_Left_VCE_Pressure <= 10000)
                {
                    SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", GetAiValue($"{mod}.{AI_Left_VCE_Pressure}") + 1500);
                }
            }

            if (DO_VCEB_Fast_Vent.Value || DO_VCEB_Soft_Vent.Value)
            {
                if (getAiValue_AI_Right_VCE_Pressure > 10000)
                {
                    SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", GetAiValue($"{mod}.{AI_Right_VCE_Pressure}") + 30000);
                }
                else if (getAiValue_AI_Right_VCE_Pressure <= 10000)
                {
                    SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", GetAiValue($"{mod}.{AI_Right_VCE_Pressure}") + 1500);
                }
            }


            if (TM_fast_Vent_vlv.Value || TM_soft_Vent_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 1500);
                }
            }

            getAiValue_AI_Left_VCE_Pressure = GetAiValue($"{mod}.{AI_Left_VCE_Pressure}");

            if (getAiValue_AI_Left_VCE_Pressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", ATM_PRESSURE);
            }
            else if (getAiValue_AI_Left_VCE_Pressure < 20)
            {
                SetAiValue($"{mod}.{AI_Left_VCE_Pressure}", 20);
            }

            getAiValue_AI_Right_VCE_Pressure = GetAiValue($"{mod}.{AI_Right_VCE_Pressure}");

            if (getAiValue_AI_Right_VCE_Pressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", ATM_PRESSURE);
            }
            else if (getAiValue_AI_Right_VCE_Pressure < 20)
            {
                SetAiValue($"{mod}.{AI_Right_VCE_Pressure}", 20);
            }

            getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");

            if (getAiValue_TM_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_TM_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", 20);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_TM_ATM_SW"].Value = GetAiValue($"{mod}.{TM_AI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch

            // ATM switch
            IO.DI[$"{mod}.DI_VCEA_ATM_SW"].Value = GetAiValue($"{mod}.{AI_Left_VCE_Pressure}") > ATM_THRESHOLD;


            // ATM switch
            IO.DI[$"{mod}.DI_VCEB_ATM_SW"].Value = GetAiValue($"{mod}.{AI_Right_VCE_Pressure}") > ATM_THRESHOLD;


        }
        void MonitorMFPressure()
        {
            //if (SimulatorJetTM.CurrentTM == JetTMType.Venus)
            //{
            string LLA_AI_ChamberPressure = "AI_LLA_CHB_Pressure";
            string LLB_AI_ChamberPressure = "AI_LLB_CHB_Pressure";
            string TM_AI_ChamberPressure = "AI_TM_CHB_Pressure";


            ModuleName mod = ModuleName.TM;

            DOAccessor LLA_fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve_LLA"];
            DOAccessor LLA_soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve_LLA"];

            DOAccessor LLB_fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve_LLB"];
            DOAccessor LLB_soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve_LLB"];

            DOAccessor TM_fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve_TM"];
            DOAccessor TM_soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve_TM"];

            DOAccessor LLA_fast_Vent_vlv = IO.DO[$"{mod}.DO_Vent_Valve_LLA"];
            DOAccessor LLA_soft_Vent_vlv = IO.DO[$"{mod}.DO_Purge_Valve_LLA"];

            DOAccessor LLB_fast_Vent_vlv = IO.DO[$"{mod}.DO_Vent_Valve_LLB"];
            DOAccessor LLB_soft_Vent_vlv = IO.DO[$"{mod}.DO_Purge_Valve_LLB"];

            DOAccessor TM_fast_Vent_vlv = IO.DO[$"{mod}.DO_Vent_Valve_TM"];
            DOAccessor TM_soft_Vent_vlv = IO.DO[$"{mod}.DO_Purge_Valve_TM"];

            float getAiValue_LLA_ChamberPressure = GetAiValue($"{mod}.{LLA_AI_ChamberPressure}");
            float getAiValue_LLB_ChamberPressure = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}");
            float getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");



            if (LLA_fast_pump_vlv.Value || LLA_soft_pump_vlv.Value)
            {
                if (getAiValue_LLA_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 30000);
                }
                else if (getAiValue_LLA_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 1500);
                }
            }

            if (LLB_fast_pump_vlv.Value || LLB_soft_pump_vlv.Value)
            {
                if (getAiValue_LLB_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 30000);
                }
                else if (getAiValue_LLB_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 1500);
                }
            }

            if (TM_fast_pump_vlv.Value || TM_soft_pump_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") - 1500);
                }
            }


            if (LLA_fast_Vent_vlv.Value || LLA_soft_Vent_vlv.Value)
            {
                if (getAiValue_LLA_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 30000);
                }
                else if (getAiValue_LLA_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 1500);
                }
            }

            if (LLB_fast_Vent_vlv.Value || LLB_soft_Vent_vlv.Value)
            {
                if (getAiValue_LLB_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 30000);
                }
                else if (getAiValue_LLB_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 1500);
                }
            }


            if (TM_fast_Vent_vlv.Value || TM_soft_Vent_vlv.Value)
            {
                if (getAiValue_TM_ChamberPressure > 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 30000);
                }
                else if (getAiValue_TM_ChamberPressure <= 10000)
                {
                    SetAiValue($"{mod}.{TM_AI_ChamberPressure}", GetAiValue($"{mod}.{TM_AI_ChamberPressure}") + 1500);
                }
            }

            getAiValue_LLA_ChamberPressure = GetAiValue($"{mod}.{LLA_AI_ChamberPressure}");

            if (getAiValue_LLA_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_LLA_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", 20);
            }

            getAiValue_LLB_ChamberPressure = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}");

            if (getAiValue_LLB_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_LLB_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", 20);
            }

            getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");

            if (getAiValue_TM_ChamberPressure > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", ATM_PRESSURE);
            }
            else if (getAiValue_TM_ChamberPressure < 20)
            {
                SetAiValue($"{mod}.{TM_AI_ChamberPressure}", 20);
            }

            // ATM switch
            IO.DI[$"{mod}.DI_TM_ATM_Switch"].Value = GetAiValue($"{mod}.{TM_AI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_TM_VAC_Switch"].Value = GetAiValue($"{mod}.{TM_AI_ChamberPressure}") < VAC_SW_PRESSURE;

            // ATM switch
            IO.DI[$"{mod}.DI_LLA_ATM_Switch"].Value = GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_LLA_VAC_Switch"].Value = GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") < VAC_SW_PRESSURE;

            // ATM switch
            IO.DI[$"{mod}.DI_LLB_ATM_Switch"].Value = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_LLB_VAC_Switch"].Value = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") < VAC_SW_PRESSURE;
            // }
            //else if (SimulatorJetTM.CurrentTM == JetTMType.VenusSE)
            //{
            //    ModuleName mod = ModuleName.TM;

            //    //float getAiValue_LLA_ChamberPressure = GetAiValue($"{mod}.{LLA_AI_ChamberPressure}");
            //    //float getAiValue_LLB_ChamberPressure = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}");
            //    //float getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");
            //}
        }

        void SetAiValue(string name, float value)
        {
            byte[] flow = BitConverter.GetBytes(value);
            short high1 = BitConverter.ToInt16(flow, 0);
            short low1 = BitConverter.ToInt16(flow, 2);

            IO.AI[name].Buffer[IO.AI[name].Index] = BitConverter.ToInt16(flow, 0);
            IO.AI[name].Buffer[IO.AI[name].Index + 1] = BitConverter.ToInt16(flow, 2);

            byte[] high = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index + 1]);
            float readback = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
        }

        float GetAiValue(string name)
        {
            byte[] high = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index + 1]);
            float flow = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
            return flow;
        }

        float GetAoValue(string name)
        {
            byte[] high = BitConverter.GetBytes(IO.AO[name].Buffer[IO.AO[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AO[name].Buffer[IO.AO[name].Index + 1]);
            float flow = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
            return flow;
        }

        void MonitorTemperature(ModuleName mod)
        {
            //IO.DI[$"{mod}.DI_Substrate_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value;
            IO.DI[$"{mod}.DI_Foreline_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_Forline_Heater_On"].Value;
            IO.DI[$"{mod}.DI_CHB_Wall_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value;
            IO.DI[$"{mod}.DI_Foreline_TC_Deviation_out_of_range"].Value = false;
            IO.DI[$"{mod}.DI_Substrate_TC_Deviation_out_of_range"].Value = false;

            // 底座
            //if (IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value &&
            //    GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") < GetAoValue($"{mod}.AO_Substrate_Temperature_Setpoint"))
            //{
            //    SetAiValue($"{mod}.AI_Substrate_Control_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") + _rd.Next(1, 2));
            //    SetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp") + _rd.Next(1, 2));
            //}
            //else if (IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value &&
            //         GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") > GetAoValue($"{mod}.AO_Substrate_Temperature_Setpoint"))
            //{
            //    SetAiValue($"{mod}.AI_Substrate_Control_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") - _rd.Next(1, 2));
            //    SetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp") - _rd.Next(1, 2));
            //}

            // Foreline
            if (IO.DO[$"{mod}.DO_Forline_Heater_On"].Value &&
                GetAiValue($"{mod}.AI_Fline_Control_TC_Temp") < GetAoValue($"{mod}.AO_Foreline_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Fline_Control_TC_Temp", GetAiValue($"{mod}.AI_Fline_Control_TC_Temp") + _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp") + _rd.Next(1, 2));
            }
            else if (IO.DO[$"{mod}.DO_Forline_Heater_On"].Value &&
                     GetAiValue($"{mod}.AI_Fline_Control_TC_Temp") > GetAoValue($"{mod}.AO_Foreline_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Fline_Control_TC_Temp", GetAiValue($"{mod}.AI_Fline_Control_TC_Temp") - _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Fline_Monitor_TC_Temp") - _rd.Next(1, 2));
            }


            // Wall
            if (IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value &&
                GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") < GetAoValue($"{mod}.AO_CHB_Wall_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") + _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp") + _rd.Next(1, 2));
            }
            else if (IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value &&
                     GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") > GetAoValue($"{mod}.AO_CHB_Wall_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") - _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp") - _rd.Next(1, 2));
            }
        }

        void MonitorGas(ModuleName mod)
        {
            // gas
            this.SimulateMFC(mod, 1);
            this.SimulateMFC(mod, 2);
            this.SimulateMFC(mod, 3);
            this.SimulateMFC(mod, 4);
            this.SimulateMFC(mod, 5);
            this.SimulateMFC(mod, 6);
            this.SimulateMFC(mod, 7);
            this.SimulateMFC(mod, 8);
            this.SimulateN2(mod);
        }

        void MonitorSEGas(ModuleName mod)
        {
            SimulateMFC(mod, 1);
            SimulateMFC(mod, 2);
            SimulateMFC(mod, 3);
            SimulateMFC(mod, 4);
            SimulateMFC(mod, 5);
            SimulateMFC(mod, 6);
            SimulateMFC(mod, 7);
            SimulateMFC(mod, 8);
            SimulateMFC(mod, 9);
            SimulateMFC(mod, 10);
            SimulateMFC(mod, 11);
            SimulateMFC(mod, 12);
        }
        void MonitorDEGas(ModuleName mod)
        {
            SimulateMFC(mod, 1);
            SimulateMFC(mod, 2);
            SimulateMFC(mod, 3);
            SimulateMFC(mod, 4);
            SimulateMFC(mod, 5);
            SimulateMFC(mod, 6);
            SimulateMFC(mod, 7);
            SimulateMFC(mod, 8);
            SimulateMFC(mod, 9);
            SimulateMFC(mod, 10);
            SimulateMFC(mod, 11);
            SimulateMFC(mod, 12);
        }
        private void SimulateMFC(ModuleName mod, byte gasNum)
        {
            var sp = GetAoValue($"{mod}.AO_MFC{gasNum}_Flow_Setpoint");



            //var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            SetAiValue($"{mod}.AI_MFC{gasNum}_Flow", (float)sp);

        }

        private void SimulateN2(ModuleName mod)
        {
            var sp = GetAoValue($"{mod}.AO_Turbo_Pump_N2_Flow_Setpoint");

            //var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            SetAiValue($"{mod}.AI_Turbo_Pump_N2_Flow", (float)sp);
        }
        private void SimulateSEHe(ModuleName mod)
        {
            var sp = GetAoValue($"{mod}.AO_ESC_He_Pressure_Setpoint");

            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            SetAiValue($"{mod}.AI_He_Flow", (float)mock_fb);
        }
        private void SimulateDEHe(ModuleName mod)
        {
            var sp = GetAoValue($"{mod}.AO_ESC_He_Pressure_Setpoint1");

            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            SetAiValue($"{mod}.AI_MFC_He1_Flow", (float)mock_fb);
        }
        private void SimulateHe(ModuleName mod)
        {
            var sp = GetAoValue($"{mod}.AO_He_Flow_Setpoint");

            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            SetAiValue($"{mod}.AI_ESC_He_Flow", (float)mock_fb);
        }

        void MonitorRF(ModuleName mod)
        {
            // RF generator
            var sp = GetAoValue($"{mod}.AO_Generator_Power_Setpoint");
            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            //var mock_sp = _rd.Next(sp - 3, sp + 3);
            SetAiValue($"{mod}.AI_Generator_Forward_Power", (float)mock_fb);

            //IO.DI[$"{mod}.DI_Generator_Power_Status"].Value = IO.DO[$"{mod}.DO_Generator_Power_ON"].Value;
        }

        void MonitorIOPumpCtrl(ModuleName mod)
        {
            if (IO.DO[$"{mod}.DO_Pump_Run"].Value) IO.DI[$"{mod}.DI_Dry_Pump_Running"].Value = true;
            if (IO.DO[$"{mod}.DO_Pump_Stop"].Value) IO.DI[$"{mod}.DI_Dry_Pump_Running"].Value = false;
        }
        void MonitorIOHighTemperatureHeater(ModuleName mod)
        {
            if (IO.DO[$"{mod}.DO_Lift_Servo_Go_Position1"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = true;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = false;
            }
            if (IO.DO[$"{mod}.DO_Lift_Servo_Go_Position2"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = true;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = false;
            }
            if (IO.DO[$"{mod}.DO_Lift_Servo_Go_Position3"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = true;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = false;
            }
            if (IO.DO[$"{mod}.DO_Lift_Servo_Go_Position4"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = true;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = false;
            }
            if (IO.DO[$"{mod}.DO_Lift_Servo_Go_Position5"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = true;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = false;
            }
            if (IO.DO[$"{mod}.DO_Lift_Servo_Origin"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position1_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position2_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position3_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position4_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_Go_Position5_Complete"].Value = false;
                IO.DI[$"{mod}.DI_Lift_Servo_with_origin"].Value = true;
            }

            IO.DI[$"{mod}.DI_CHB_M-HT_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_CHB_M-HT_Heater_On"].Value;

            var sp = GetAoValue($"{mod}.AO_CHB_M-HT_Temperature_Setpoint");
            var mock_fb = _rd.Next((int)sp - 1, (int)sp + 1) + _rd.NextDouble();

            //var mock_sp = _rd.Next(sp - 3, sp + 3);
            SetAiValue($"{mod}.AI_CHB_M-HT_Control_TC_Temp", (float)mock_fb);
        }
        void MonitorKepler2200Heater(ModuleName mod)
        {
            var pendulumHeaterSetpoint = GetAoValue($"{mod}.AO_P_Valve_Temperature_Setpoint");
            SetAiValue($"{mod}.AI_P_Valve_Control_TC_Temp", (float)pendulumHeaterSetpoint);
        }
        public void Terminate()
        {
            _thread.Stop();
        }

        public void SetCoolantOutletTemp(string module, int Temp)
        {
            //if (SimulatorJetChamber.CurrentChamber == JetChamber.Venus)
            //{ 
            //SetAiValue($"{module}.AI_Coolant_Outlet_Temp", Temp);

            //}
        }



    }
}