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;

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

        private Random _rd = new Random();

        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>();


        public SimulatorSystem()
        {
            //_MockDevices.Add(ModuleName.PMB, new SkyPumpMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecGeneratorMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecMatchMock());

            // TODO
            
        }

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

        public void Initialize()
        {
    
                SetDefaultValue(ModuleName.PMA, SimulatorJetChamber.CurrentPMAChamber);
                SetDefaultValue(ModuleName.PMB, SimulatorJetChamber.CurrentPMBChamber);
                SetDefaultValue(ModuleName.PMC, SimulatorJetChamber.CurrentPMCChamber);
            SetTMDefaultValue();
            
          

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

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

        private void SetDefaultValue(ModuleName mod,JetChamber jetChamber)
        {

            switch (jetChamber)
            {
                case JetChamber.Venus:
                    IO.DI[$"{mod}.DI_PM_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_PM_ATM_SW"].Value = true;
                    IO.DI[$"{mod}.DI_PM_VAC_SW"].Value = false;
                    IO.DI[$"{mod}.DI_PCW_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_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"].Value = true;
                    IO.DI[$"{mod}.DI_Coolant_Inlet_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Coolant_Outlet_TC_Broken_Alarm"].Value = true;

                    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_Chamber_Pressure_760t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Foreline_Pressure_760t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_LL_Pressure_760t_Gauge_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_ESC_He_Pressure_100t_Gauge_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Valve_TC_Deviation_out_of_range"].Value = false;
                    IO.DI[$"{mod}.DI_Valve_Control_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_Valve_Monitor_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 = 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_SW_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_PN2_Pressure_SW"].Value = true;

                    IO.DI[$"{mod}.DI_MFC1_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC2_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC3_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC4_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC5_Pressure_SW"].Value = true;

                    IO.DI[$"{mod}.DI_MFC6_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC7_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_MFC8_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_He_Pressure_SW"].Value = true;
                    IO.DI[$"{mod}.DI_ESC_He_Pressure_100t_Gauge_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_Loadlock_Lid_Closed"].Value = true;
                    IO.DI[$"{mod}.DI_Loadlock_Arm_Extend_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Loadlock_Arm_Retract_POS"].Value = true;
                    IO.DI[$"{mod}.DI_Small_Wafer_In_POS"].Value = false;
                    IO.DI[$"{mod}.DI_Big_Wafer_In_POS"].Value = false;

                    IO.DI[$"{mod}.DI_Loadlock_ATM_SW"].Value = false;
                    IO.DI[$"{mod}.DI_Gas_Box_Door_SW"].Value = true;
                    IO.DI[$"{mod}.DI_Gas_Box_Pressure_SW"].Value = true;



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

                    SetAiValue($"{mod}.AI_Chamber_Pressure_10t", 5000);
                    SetAiValue($"{mod}.AI_LL_Pressure_760t", ATM_LoadLock_PRESSURE);

                    //// 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);
                    //if (mod == ModuleName.PMA)
                    //{
                    //    SetAiValue($"{mod}.AI_Coolant_Outlet_Temp", 29);
                    //}
                    //else if (mod == ModuleName.PMB)
                    //{
                    //    SetAiValue($"{mod}.AI_Coolant_Outlet_Temp", 30);
                    //}

                    // 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", 1000);
                    //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);


                    // 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:
                    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_Position"].Value = false;
                    IO.DI[$"{mod}.DI_Lift_Pin_Down_Position"].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_Position"].Value = false;
                    IO.DI[$"{mod}.DI_Slit_Door_Close_Position"].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_H-HT_Control_TC_Broken_Alarm"].Value = false;

                    IO.DI[$"{mod}.DI_CHB_Wall_Monitor_TC_Broken_Alarm"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_H-HT_Heater_On_FB"].Value = false;
                    IO.DI[$"{mod}.DI_CHB_H-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_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;

                    //// pressure
                    SetAiValue($"{mod}.AI_Foreline_Pressure_10t", 5001);
                    SetAiValue($"{mod}.AI_Process_Pressure_100mt", 1000);
                    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_H-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_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;


            // 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_CHB_Pressure", 5000);
            SetAiValue($"{mod}.AI_TM_Foreline_Pressure", 5001);
            SetAiValue($"{mod}.AI_LLA_CHB_Pressure", 5002);
            SetAiValue($"{mod}.AI_LLA_LLB_Foreline_Pressure", 5003);
            SetAiValue($"{mod}.AI_LLB_CHB_Pressure", 5004);


        }

        private bool OnMonitor()
        {
            try
            {

                switch (SimulatorJetChamber.CurrentPMAChamber)
                {
                    case JetChamber.Venus:
                        // PMA
                        MonitorSlitDoor(ModuleName.PMA);
                        MonitorPin(ModuleName.PMA);
                        MonitorPressure(ModuleName.PMA);
                        MonitorExtendAndRetract(ModuleName.PMA);
                        //MonitorTemperature(ModuleName.PMA);
                        MonitorGas(ModuleName.PMA);
                        //MonitorRF(ModuleName.PMA);
                        ChangeTime(ModuleName.PMA);
                        //MonitorIOPumpCtrl(ModuleName.PMA);
                        break;

                    case JetChamber.Kepler2300:
                    case JetChamber.Kepler2200A:
                    case JetChamber.Kepler2200B:
                        // PMA
                        MonitorSlitDoor(ModuleName.PMA);
                        MonitorPin(ModuleName.PMA);
                        MonitorPressure_Kepler(ModuleName.PMA);

                        //MonitorTemperature(ModuleName.PMA);
                        MonitorGas(ModuleName.PMA);
                        //MonitorRF(ModuleName.PMA);
                        ChangeTime(ModuleName.PMA);
                        //MonitorIOPumpCtrl(ModuleName.PMA);
                        MonitorLid(ModuleName.PMA);
                        break;
                }
                switch (SimulatorJetChamber.CurrentPMBChamber)
                {
                    case JetChamber.Venus:
                        // PMB
                        MonitorSlitDoor(ModuleName.PMB);
                        MonitorPin(ModuleName.PMB);
                        MonitorPressure(ModuleName.PMB);
                        //MonitorTemperature(ModuleName.PMB);
                        MonitorGas(ModuleName.PMB);
                        // MonitorRF(ModuleName.PMB);
                        ChangeTime(ModuleName.PMB);
                        //MonitorIOPumpCtrl(ModuleName.PMB);
                        break;

                    case JetChamber.Kepler2300:
                    case JetChamber.Kepler2200A:
                    case JetChamber.Kepler2200B:
                        // PMB
                        MonitorSlitDoor(ModuleName.PMB);
                        MonitorPin(ModuleName.PMB);
                        MonitorPressure_Kepler(ModuleName.PMB);
                        //MonitorTemperature(ModuleName.PMB);
                        MonitorGas(ModuleName.PMB);
                        // MonitorRF(ModuleName.PMB);
                        ChangeTime(ModuleName.PMB);
                        //MonitorIOPumpCtrl(ModuleName.PMB);
                        MonitorLid(ModuleName.PMB);

                        break;
                }
                //switch (SimulatorJetChamber.CurrentPMCChamber)
                //{
                //    case JetChamber.Venus:
                //        // PMC
                //        MonitorSlitDoor(ModuleName.PMC);
                //        MonitorPin(ModuleName.PMC);
                //        MonitorPressure(ModuleName.PMC);
                //        //MonitorTemperature(ModuleName.PMB);
                //        MonitorGas(ModuleName.PMC);
                //        // MonitorRF(ModuleName.PMB);
                //        ChangeTime(ModuleName.PMC);
                //        //MonitorIOPumpCtrl(ModuleName.PMB);
                //        break;

                //    case JetChamber.Kepler2300:
                //    case JetChamber.Kepler2200A:
                //    case JetChamber.Kepler2200B:
                //        // PMC
                //        MonitorSlitDoor(ModuleName.PMC);
                //        MonitorPin(ModuleName.PMC);
                //        MonitorPressure_Kepler(ModuleName.PMC);
                //        //MonitorTemperature(ModuleName.PMB);
                //        MonitorGas(ModuleName.PMC);
                //        // MonitorRF(ModuleName.PMB);
                //        ChangeTime(ModuleName.PMC);
                //        //MonitorIOPumpCtrl(ModuleName.PMB);
                //        MonitorLid(ModuleName.PMC);
                //        break;
                //}

                ChangeTime(ModuleName.TM);

                MonitorMFSlitDoor();
                MonitorMFPressure();


            }
            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 MonitorSlitDoor(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 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;
            }
        }

        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)
            {
                if (fast_pump_vlv.Value && soft_pump_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(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_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);
                    }
                    //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)
                {
                    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}") - 22000);
                        //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}") - 1100);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1100);
                    }
                    //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)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    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_760t", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure_760t", 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 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)
            {
                if (fast_pump_vlv.Value && soft_pump_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(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_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);
                    }
                    //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)
                {
                    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}") - 22000);
                        //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}") - 1100);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1100);
                    }
                    //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)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");

                    getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                    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 MonitorMFPressure()
        {

            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;
        }

        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(ModuleName.PMA, 1);
            this.SimulateMFC(ModuleName.PMA, 2);
            this.SimulateMFC(ModuleName.PMA, 3);
            this.SimulateMFC(ModuleName.PMA, 4);
            this.SimulateMFC(ModuleName.PMA, 5);
            this.SimulateMFC(ModuleName.PMA, 6);
            this.SimulateMFC(ModuleName.PMA, 7);
            this.SimulateMFC(ModuleName.PMA, 8);
            this.SimulateN2(ModuleName.PMA);
            this.SimulateHe(ModuleName.PMA);
        }

        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)mock_fb);

        }

        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)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;
        }

        public void Terminate()
        {
            _thread.Stop();
        }

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

            //}
        }
    }
}