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;

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);
            SetDefaultValue(ModuleName.PMB);
            SetTMDefaultValue();

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

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

        private void SetDefaultValue(ModuleName mod)
        {
            // chamber
            IO.DI[$"{mod}.DI_PM_Lid_Closed"].Value = true;
            IO.DI[$"{mod}.DI_PM_ATM_SW"].Value = false;
            IO.DI[$"{mod}.DI_PM_VAC_SW"].Value = true;
            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_Process_VAC_Gauge_High_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Process_VAC_Gauge_Low_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Chamber_VAC_Gauge_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Foreline_Vacuum_Gauge_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Loadlock_Vacuum_Gauge_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_ESC_He_VAC_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_VAC_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", 5000);
            //SetAiValue($"{mod}.AI_Process_Pressure_High", 5000);
            //SetAiValue($"{mod}.AI_Process_Pressure_Low", 5000);
            //SetAiValue($"{mod}.AI_Chamber_Pressure", ATM_PRESSURE);
            SetAiValue($"{mod}.AI_Process_Pressure", PROCESS_GAUGE);

            SetAiValue($"{mod}.AI_Chamber_Pressure", 5000);
            SetAiValue($"{mod}.AI_Loadlock_Pressure", 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);
        }

        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;

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

        private bool OnMonitor()
        {
            try
            {
                  // 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);

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

                MonitorMFSlitDoor();
                ChangeTime(ModuleName.TM);


            }
            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 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)
        {
            // pressure
            string sAI_Foreline = "AI_Foreline_Pressure";

            // Loadlock pressure
            string sAI_LoadLockPressure = "AI_Loadlock_Pressure";

            // 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";
            string sAI_ProcessPressure = "AI_Process_Pressure";
            //float chamber_pressure = GetMockChamberPressure(mod);
            //float process_pressure = GetAiValue($"{mod}.AI_Process_Pressure");

            // 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", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_Pressure", 20);
            }

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

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

            // LoadLock压力值越界，复位
            float LoadLock_pressure1 = GetAiValue($"{mod}.{sAI_LoadLockPressure}");
            if (LoadLock_pressure1 > ATM_LoadLock_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Loadlock_Pressure", ATM_LoadLock_PRESSURE);
            }
            else if (LoadLock_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Loadlock_Pressure", 20);
            }


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

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

            //int p3 = (int)GetAiValue($"{mod}.AI_Process_Pressure");
            //int new_p3 = _rd.Next(p3 - 1, p3 + 1);
            //SetAiValue($"{mod}.AI_Process_Pressure", 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"));
            //    }
            //}
        }

        //float GetMockChamberPressure(ModuleName mod)
        //{
        //    return GetAiValue($"{mod}.AI_Chamber_Pressure");
        //}

        //void SetMockChamberPressure(ModuleName mod, float val)
        //{
        //    SetAiValue($"{mod}.AI_Chamber_Pressure", val);
        //}

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

            if (gasNum == 3)
            {
                sp = Math.Max(0, sp - 150);
            }

            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_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)
        {
            SetAiValue($"{module}.AI_Coolant_Outlet_Temp", Temp);
        }
    }
}