ELK/Furnace/FurnaceRT/Equipments/PMs/PMModuleDevice.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using MECF.Framework.Common.Event;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using MECF.Framework.Common.SubstrateTrackings;
using Aitex.Core.Common;
using FurnaceRT.Equipments.Systems;
using Aitex.Core.RT.IOCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.Core.IoProviders;
using MECF.Framework.Common.Device.Bases;
using FurnaceRT.Equipments.Boats;
using IoHeater = FurnaceRT.Devices.IoHeater;
using IoPressureMeter = FurnaceRT.Devices.IoPressureMeter;
using FurnaceRT.Devices;
using Aitex.Core.RT.Log;
using FurnaceRT.Equipments.PMs.Devices;
using Aitex.Core.RT.SCCore;
using static Aitex.Core.RT.Device.Unit.IoBoat;

namespace FurnaceRT.Equipments.PMs
{
    public partial class PMModule
    {

        // -------------------------------------------------------------------------
        #region AlarmSignal
        [Tag("AlarmSignalO2ConcentrationHI")]
        public IoAlarmSignal AlarmSignalO2ConcentrationHI { get; set; }

        [Tag("AlarmSignalO2ConcentrationLow")]
        public IoAlarmSignal AlarmSignalO2ConcentrationLow { get; set; }

        [Tag("AlarmSignalO2ConcentrationEcho1")]
        public IoAlarmSignal AlarmSignalO2ConcentrationEcho1 { get; set; }
        [Tag("AlarmSignalO2ConcentrationEcho2")]
        public IoAlarmSignal AlarmSignalO2ConcentrationEcho2 { get; set; }
        [Tag("AlarmSignalSMK1DetectorSensorOperates")]
        public IoAlarmSignal AlarmSignalSMK1DetectorSensorOperates { get; set; }
        [Tag("AlarmSignalSMK1DetectorSensorFireAlarm")]
        public IoAlarmSignal AlarmSignalSMK1DetectorSensorFireAlarm { get; set; }
        [Tag("AlarmSignalSMK1DetectorSensorFault")]
        public IoAlarmSignal AlarmSignalSMK1DetectorSensorFault { get; set; }
        [Tag("AlarmSignalHCLGasLeak1stAlarm")]
        public IoAlarmSignal AlarmSignalHCLGasLeak1stAlarm { get; set; }
        [Tag("AlarmSignalHCLGasLeak2ndAlarm")]
        public IoAlarmSignal AlarmSignalHCLGasLeak2ndAlarm { get; set; }
        [Tag("AlarmSignalNH3GasLeak1stAlarm")]
        public IoAlarmSignal AlarmSignalNH3GasLeak1stAlarm { get; set; }
        [Tag("AlarmSignalNH3GasLeak2ndAlarm")]
        public IoAlarmSignal AlarmSignalNH3GasLeak2ndAlarm { get; set; }
        [Tag("AlarmSignalF2GasLeak1stAlarm")]
        public IoAlarmSignal AlarmSignalF2GasLeak1stAlarm { get; set; }
        [Tag("AlarmSignalF2GasLeak2ndAlarm")]
        public IoAlarmSignal AlarmSignalF2GasLeak2ndAlarm { get; set; }
        [Tag("AlarmSignalGasLeakFault")]
        public IoAlarmSignal AlarmSignalGasLeakFault { get; set; }
        [Tag("AlarmSignalTS34RotationTempSW")]
        public IoAlarmSignal AlarmSignalTS34RotationTempSW { get; set; }
        [Tag("AlarmSignalTS30CapInsideTempSW")]
        public IoAlarmSignal AlarmSignalTS30CapInsideTempSW { get; set; }
        [Tag("AlarmSignalTS31CapOutsideTempSW")]
        public IoAlarmSignal AlarmSignalTS31CapOutsideTempSW { get; set; }
        [Tag("AlarmSignalGasBoxLowerDoorSW")]
        public IoAlarmSignal AlarmSignalGasBoxLowerDoorSW { get; set; }
        [Tag("AlarmSignalGasBoxUpperDoorSW")]
        public IoAlarmSignal AlarmSignalGasBoxUpperDoorSW { get; set; }
        [Tag("AlarmSignalEXHBoxWaterLeak")]
        public IoAlarmSignal AlarmSignalEXHBoxWaterLeak { get; set; }
        [Tag("AlarmSignalOPPanelEMO1")]
        public IoAlarmSignal AlarmSignalOPPanelEMO1 { get; set; }
        [Tag("AlarmSignalOPPanelEMO2")]
        public IoAlarmSignal AlarmSignalOPPanelEMO2 { get; set; }
        [Tag("AlarmSignalMainFurnaceCellingTS306")]
        public IoAlarmSignal AlarmSignalMainFurnaceCellingTS306 { get; set; }
        [Tag("AlarmSignalHeaterRoomSWS11S12")]
        public IoAlarmSignal AlarmSignalHeaterRoomSWS11S12 { get; set; }
        [Tag("AlarmSignalFilterBox1DoorSwitch")]
        public IoAlarmSignal AlarmSignalFilterBox1DoorSwitch { get; set; }
        [Tag("AlarmSignalLABacksideDoorSwitch")]
        public IoAlarmSignal AlarmSignalLABacksideDoorSwitch { get; set; }
        [Tag("AlarmSignalRHCTS305")]
        public IoAlarmSignal AlarmSignalRHCTS305 { get; set; }
        [Tag("AlarmSignalGasBoxExhaust1stAlarmMS2")]
        public IoAlarmSignal AlarmSignalGasBoxExhaust1stAlarmMS2 { get; set; }
        [Tag("AlarmSignalGasBoxExhaust2ndAlarmMS2")]
        public IoAlarmSignal AlarmSignalGasBoxExhaust2ndAlarmMS2 { get; set; }
        [Tag("AlarmSignalMachineEMO1")]
        public IoAlarmSignal AlarmSignalMachineEMO1 { get; set; }
        [Tag("AlarmSignalMachineEMO2")]
        public IoAlarmSignal AlarmSignalMachineEMO2 { get; set; }
        [Tag("AlarmSignalT101TempStatus")]
        public IoAlarmSignal AlarmSignalT101TempStatus { get; set; }
        [Tag("AlarmSignalT102TempStatus")]
        public IoAlarmSignal AlarmSignalT102TempStatus { get; set; }
        [Tag("AlarmSignalT103TempStatus")]
        public IoAlarmSignal AlarmSignalT103TempStatus { get; set; }
        [Tag("AlarmSignalBufferMotorHardwareInterlockAlarm")]
        public IoAlarmSignal AlarmSignalBufferMotorHardwareInterlockAlarm { get; set; }
        [Tag("AlarmSignalBoatLiftMotorHardwareInterlockAlarm")]
        public IoAlarmSignal AlarmSignalBoatLiftMotorHardwareInterlockAlarm { get; set; }

        [Tag("AlarmSignalHFReconciliationPressureMinAbnormal")]
        public IoAlarmSignal AlarmSignalHFReconciliationPressureMinAbnormal { get; set; }
        [Tag("AlarmSignalMagneticFluidLeak")]
        public IoAlarmSignal AlarmSignalMagneticFluidLeak { get; set; }
        [Tag("AlarmSignalCoolingWaterLeak")]
        public IoAlarmSignal AlarmSignalCoolingWaterLeak { get; set; }
        [Tag("AlarmSignalMachineEMS1")]
        public IoAlarmSignal AlarmSignalMachineEMS1 { get; set; }
        [Tag("AlarmSignalMachineEMS2")]
        public IoAlarmSignal AlarmSignalMachineEMS2 { get; set; }
        [Tag("AlarmSignalFBLightCurtainFault")]
        public IoAlarmSignal AlarmSignalFBLightCurtainFault { get; set; }
        [Tag("AlarmSignalFBLightCurtainOSSD1")]
        public IoAlarmSignal AlarmSignalFBLightCurtainOSSD1 { get; set; }
        [Tag("AlarmSignalFBLightCurtainOSSD2")]
        public IoAlarmSignal AlarmSignalFBLightCurtainOSSD2 { get; set; }
        [Tag("AlarmSignalFBEMO1")]
        public IoAlarmSignal AlarmSignalFBEMO1 { get; set; }
        [Tag("AlarmSignalFBEMO2")]
        public IoAlarmSignal AlarmSignalFBEMO2 { get; set; }
        [Tag("AlarmSignalDoorOverride")]
        public IoAlarmSignal AlarmSignalDoorOverride { get; set; }
        [Tag("AlarmSignalFBFrontDoorSwitch")]
        public IoAlarmSignal AlarmSignalFBFrontDoorSwitch { get; set; }
        [Tag("AlarmSignalGLBoxPG1CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG1CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG1CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG1CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG2CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG2CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG2CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG2CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG3CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG3CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG3CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG3CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG4CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG4CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG4CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG4CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG5CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG5CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG5CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG5CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG6CNT1Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG6CNT1Alarm { get; set; }
        [Tag("AlarmSignalGLBoxPG6CNT2Alarm")]
        public IoAlarmSignal AlarmSignalGLBoxPG6CNT2Alarm { get; set; }
        [Tag("AlarmSignalGLBoxVG21Status")]
        public IoAlarmSignal AlarmSignalGLBoxVG21Status { get; set; }
        [Tag("AlarmSignalGLBoxVG21Output1")]
        public IoAlarmSignal AlarmSignalGLBoxVG21Output1 { get; set; }
        [Tag("AlarmSignalGLBoxVG21Output2")]
        public IoAlarmSignal AlarmSignalGLBoxVG21Output2 { get; set; }
        [Tag("AlarmSignalGLBoxVG22Status")]
        public IoAlarmSignal AlarmSignalGLBoxVG22Status { get; set; }
        [Tag("AlarmSignalGLBoxVG22Output1")]
        public IoAlarmSignal AlarmSignalGLBoxVG22Output1 { get; set; }
        [Tag("AlarmSignalGLBoxVG22Output2")]
        public IoAlarmSignal AlarmSignalGLBoxVG22Output2 { get; set; }
        [Tag("AlarmSignalHeatingExhaust1stAlarmMS1")]
        public IoAlarmSignal AlarmSignalHeatingExhaust1stAlarmMS1 { get; set; }
        [Tag("AlarmSignalHeatingExhaust2ndAlarmMS1")]
        public IoAlarmSignal AlarmSignalHeatingExhaust2ndAlarmMS1 { get; set; }
        [Tag("AlarmSignalScavengeExhaust1stAlarmMS3")]
        public IoAlarmSignal AlarmSignalScavengeExhaust1stAlarmMS3 { get; set; }
        [Tag("AlarmSignalScavengeExhaust2ndAlarmMS3")]
        public IoAlarmSignal AlarmSignalScavengeExhaust2ndAlarmMS3 { get; set; }
        [Tag("AlarmSignalValveBoxExhaust1stAlarmMS4")]
        public IoAlarmSignal AlarmSignalValveBoxExhaust1stAlarmMS4 { get; set; }
        [Tag("AlarmSignalValveBoxExhaust2ndAlarmMS4")]
        public IoAlarmSignal AlarmSignalValveBoxExhaust2ndAlarmMS4 { get; set; }
        [Tag("AlarmSignalLoadingAreaExhaust1stAlarmMS5")]
        public IoAlarmSignal AlarmSignalLoadingAreaExhaust1stAlarmMS5 { get; set; }
        [Tag("AlarmSignalLoadingAreaExhaust2ndAlarmMS5")]
        public IoAlarmSignal AlarmSignalLoadingAreaExhaust2ndAlarmMS5 { get; set; }
        [Tag("AlarmSignalFrontBodyExhaust1stAlarmMS6")]
        public IoAlarmSignal AlarmSignalFrontBodyExhaust1stAlarmMS6 { get; set; }
        [Tag("AlarmSignalFrontBodyExhaust2ndAlarmMS6")]
        public IoAlarmSignal AlarmSignalFrontBodyExhaust2ndAlarmMS6 { get; set; }
        [Tag("AlarmSignalLAExhaust1stAlarmMS7")]
        public IoAlarmSignal AlarmSignalLAExhaust1stAlarmMS7 { get; set; }
        [Tag("AlarmSignalLAExhaust2ndAlarmMS7")]
        public IoAlarmSignal AlarmSignalLAExhaust2ndAlarmMS7 { get; set; }
        [Tag("AlarmSignalRHC1stAlarmMS8")]
        public IoAlarmSignal AlarmSignalRHC1stAlarmMS8 { get; set; }
        [Tag("AlarmSignalRHC2ndAlarmMS8")]
        public IoAlarmSignal AlarmSignalRHC2ndAlarmMS8 { get; set; }
        [Tag("AlarmSignalREV1stAlarmMS9")]
        public IoAlarmSignal AlarmSignalREV1stAlarmMS9 { get; set; }
        [Tag("AlarmSignalREV2ndAlarmMS9")]
        public IoAlarmSignal AlarmSignalREV2ndAlarmMS9 { get; set; }
        [Tag("AlarmSignalREV1stAlarmMS10")]
        public IoAlarmSignal AlarmSignalREV1stAlarmMS10 { get; set; }
        [Tag("AlarmSignalREV2ndAlarmMS10")]
        public IoAlarmSignal AlarmSignalREV2ndAlarmMS10 { get; set; }
        [Tag("AlarmSignalOPBoxPS11Out1")]
        public IoAlarmSignal AlarmSignalOPBoxPS11Out1 { get; set; }
        [Tag("AlarmSignalOPBoxPS11Out2")]
        public IoAlarmSignal AlarmSignalOPBoxPS11Out2 { get; set; }
        [Tag("AlarmSignalRHCFlowAlarmFL901")]
        public IoAlarmSignal AlarmSignalRHCFlowAlarmFL901 { get; set; }
        [Tag("AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902")]
        public IoAlarmSignal AlarmSignalCoolingWaterFlowAlarmOfFurnaceFL902 { get; set; }
        [Tag("AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903")]
        public IoAlarmSignal AlarmSignalCoolingWaterFlowAlarmOfShuttleFL903 { get; set; }
        [Tag("AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904")]
        public IoAlarmSignal AlarmSignalCoolingWaterFlowAlarmOfBoatRotationFL904 { get; set; }
        [Tag("AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905")]
        public IoAlarmSignal AlarmSignalCoolingWaterFlowAlarmOfFlangeFL905 { get; set; }
        [Tag("AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFL906")]
        public IoAlarmSignal AlarmSignalCoolingWaterFlowAlarmOfLoadingAreaFL906 { get; set; }
        [Tag("AlarmSignalVG11LowAlarm")]
        public IoAlarmSignal AlarmSignalVG11LowAlarm { get; set; }
        [Tag("AlarmSignalVG11HighAlarm")]
        public IoAlarmSignal AlarmSignalVG11HighAlarm { get; set; }
        [Tag("AlarmSignalVG12LowAlarm")]
        public IoAlarmSignal AlarmSignalVG12LowAlarm { get; set; }
        [Tag("AlarmSignalVG12HighAlarm")]
        public IoAlarmSignal AlarmSignalVG12HighAlarm { get; set; }
        [Tag("AlarmSignalVG13LowAlarm")]
        public IoAlarmSignal AlarmSignalVG13LowAlarm { get; set; }
        [Tag("AlarmSignalVG13HighAlarm")]
        public IoAlarmSignal AlarmSignalVG13HighAlarm { get; set; }
        [Tag("AlarmSignalPG12OUT1")]
        public IoAlarmSignal AlarmSignalPG12OUT1 { get; set; }
        [Tag("AlarmSignalPG12OUT2")]
        public IoAlarmSignal AlarmSignalPG12OUT2 { get; set; }
        [Tag("AlarmSignalPG13OUT1")]
        public IoAlarmSignal AlarmSignalPG13OUT1 { get; set; }
        [Tag("AlarmSignalPG13OUT2")]
        public IoAlarmSignal AlarmSignalPG13OUT2 { get; set; }
        [Tag("AlarmSignalPS14OUT1")]
        public IoAlarmSignal AlarmSignalPS14OUT1 { get; set; }
        [Tag("AlarmSignalPS14OUT2")]
        public IoAlarmSignal AlarmSignalPS14OUT2 { get; set; }
        [Tag("AlarmSignalCoolingWaterPressureOut1")]
        public IoAlarmSignal AlarmSignalCoolingWaterPressureOut1 { get; set; }
        [Tag("AlarmSignalCoolingWaterPressureOut2")]
        public IoAlarmSignal AlarmSignalCoolingWaterPressureOut2 { get; set; }
        [Tag("AlarmSignalAirFlowFL70")]
        public IoAlarmSignal AlarmSignalAirFlowFL70 { get; set; }
        [Tag("AlarmSignalAirFlowFL71")]
        public IoAlarmSignal AlarmSignalAirFlowFL71 { get; set; }
        [Tag("AlarmSignalAirFlowFL72")]
        public IoAlarmSignal AlarmSignalAirFlowFL72 { get; set; }
        [Tag("AlarmSignalWaterFlowFL62")]
        public IoAlarmSignal AlarmSignalWaterFlowFL62 { get; set; }
        [Tag("AlarmSignalUPSFault")]
        public IoAlarmSignal AlarmSignalUPSFault { get; set; }
        [Tag("AlarmSignalUPSAlarm")]
        public IoAlarmSignal AlarmSignalUPSAlarm { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG14CNT1")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG14CNT1 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG14CNT2")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG14CNT2 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG15CNT1")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG15CNT1 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG15CNT2")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG15CNT2 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG16CNT1")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG16CNT1 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG16CNT2")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG16CNT2 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG70CNT1")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG70CNT1 { get; set; }
        [Tag("AlarmSignalN2PurgeBOXPG70CNT2")]
        public IoAlarmSignal AlarmSignalN2PurgeBOXPG70CNT2 { get; set; }
        [Tag("AlarmSignalPS17ValueLowLimitAlarm")]
        public IoAlarmSignal AlarmSignalPS17ValueLowLimitAlarm { get; set; }
        [Tag("AlarmSignalVaccumPumpWarning")]
        public IoAlarmSignal AlarmSignalVaccumPumpWarning { get; set; }
        [Tag("AlarmSignalVaccumPumpAlarm")]
        public IoAlarmSignal AlarmSignalVaccumPumpAlarm { get; set; }
        [Tag("AlarmSignalFilterBox1Fan1Alarm")]
        public IoAlarmSignal AlarmSignalFilterBox1Fan1Alarm { get; set; }
        [Tag("AlarmSignalFilterBox1Fan2Alarm")]
        public IoAlarmSignal AlarmSignalFilterBox1Fan2Alarm { get; set; }
        [Tag("AlarmSignalStepperMotorAlarm")]
        public IoAlarmSignal AlarmSignalStepperMotorAlarm { get; set; }
        [Tag("AlarmSignalRFAlarm")]
        public IoAlarmSignal AlarmSignalRFAlarm { get; set; }
        [Tag("AlarmSignalForelineHeaterJacketLightAlarm")]
        public IoAlarmSignal AlarmSignalForelineHeaterJacketLightAlarm { get; set; }
        [Tag("AlarmSignalForelineHeaterJacketHeavyAlarm")]
        public IoAlarmSignal AlarmSignalForelineHeaterJacketHeavyAlarm { get; set; }
        [Tag("AlarmSignalScrubberWarning")]
        public IoAlarmSignal AlarmSignalScrubberWarning { get; set; }
        [Tag("AlarmSignalScrubberAlarm")]
        public IoAlarmSignal AlarmSignalScrubberAlarm { get; set; }
        [Tag("AlarmSignalNegLmtPosBoatZAxis")]
        public IoAlarmSignal AlarmSignalNegLmtPosBoatZAxis { get; set; }
        [Tag("AlarmSignalPotLmtPosBoatZAxis")]
        public IoAlarmSignal AlarmSignalPotLmtPosBoatZAxis { get; set; }
        [Tag("AlarmSignalLAFFUCommAlarm")]
        public IoAlarmSignal AlarmSignalLAFFUCommAlarm { get; set; }
        [Tag("AlarmSignalMINI8CommAlarm")]
        public IoAlarmSignal AlarmSignalMINI8CommAlarm { get; set; }
        [Tag("AlarmSignaMainWaterFlowAlarm")]
        public IoAlarmSignal AlarmSignaMainWaterFlowAlarm { get; set; }
        [Tag("AlarmSignalFurnaceMainCircuitBreakerStatusMonitor")]
        public IoAlarmSignal AlarmSignalFurnaceMainCircuitBreakerStatusMonitor { get; set; }
        [Tag("AlarmSignalPumpDown")]
        public IoAlarmSignal AlarmSignalPumpDown { get; set; }
        [Tag("AlarmSignalPS13HStatus")]
        public IoAlarmSignal AlarmSignalPS13HStatus { get; set; }
        [Tag("AlarmSignalPS13LStatus")]
        public IoAlarmSignal AlarmSignalPS13LStatus { get; set; }
        [Tag("AlarmSignalFFU1DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU1DataWriteError { get; set; }
        [Tag("AlarmSignalFFU2DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU2DataWriteError { get; set; }
        [Tag("AlarmSignalFFU3DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU3DataWriteError { get; set; }
        [Tag("AlarmSignalFFU4DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU4DataWriteError { get; set; }
        [Tag("AlarmSignalFFU5DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU5DataWriteError { get; set; }
        [Tag("AlarmSignalFFU6DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU6DataWriteError { get; set; }
        [Tag("AlarmSignalFFU7DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU7DataWriteError { get; set; }
        [Tag("AlarmSignalFFU8DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU8DataWriteError { get; set; }
        [Tag("AlarmSignalFFU9DataWriteError")]
        public IoAlarmSignal AlarmSignalFFU9DataWriteError { get; set; }
        [Tag("AlarmSignalDG1Output1")]
        public IoAlarmSignal AlarmSignalDG1Output1 { get; set; }
        [Tag("AlarmSignalDG1Output2")]
        public IoAlarmSignal AlarmSignalDG1Output2 { get; set; }
        [Tag("AlarmSignalAV91_1RHCAirInOpened")]
        public IoAlarmSignal AlarmSignalAV91_1RHCAirInOpened { get; set; }
        [Tag("AlarmSignalAV91_2RHCAirInOpened")]
        public IoAlarmSignal AlarmSignalAV91_2RHCAirInOpened { get; set; }
        [Tag("AlarmSignalAV91_3RHCAirInOpened")]
        public IoAlarmSignal AlarmSignalAV91_3RHCAirInOpened { get; set; }
        [Tag("AlarmSignalAV91_4RHCAirInOpened")]
        public IoAlarmSignal AlarmSignalAV91_4RHCAirInOpened { get; set; }
        [Tag("AlarmSignalBlowerPower")]
        public IoAlarmSignal AlarmSignalBlowerPower { get; set; }
        [Tag("AlarmSignalRFSetPowerReached")]
        public IoAlarmSignal AlarmSignalRFSetPowerReached { get; set; }
        [Tag("AlarmSignalN2FlowInFOUPAbnormal")]
        public IoAlarmSignal AlarmSignalN2FlowInFOUPAbnormal { get; set; }
        [Tag("AlarmSignalCapHeaterAbnormal")]
        public IoAlarmSignal AlarmSignalCapHeaterAbnormal { get; set; }
        [Tag("AlarmSignalHeaterUOverTemp")]
        public IoAlarmSignal AlarmSignalHeaterUOverTemp { get; set; }
        [Tag("AlarmSignalHeaterCUOverTemp")]
        public IoAlarmSignal AlarmSignalHeaterCUOverTemp { get; set; }
        [Tag("AlarmSignalHeaterCOverTemp")]
        public IoAlarmSignal AlarmSignalHeaterCOverTemp { get; set; }
        [Tag("AlarmSignalHeaterCLOverTemp")]
        public IoAlarmSignal AlarmSignalHeaterCLOverTemp { get; set; }
        [Tag("AlarmSignalHeaterLOverTemp")]
        public IoAlarmSignal AlarmSignalHeaterLOverTemp { get; set; }
        [Tag("AlarmSignaBoatRAxisAlarm")]
        public IoAlarmSignal AlarmSignaBoatRAxisAlarm { get; set; }
        [Tag("AlarmSignaBoatRAxisWarning")]
        public IoAlarmSignal AlarmSignaBoatRAxisWarning { get; set; }
        [Tag("AlarmSignaBoatZAxisWarning")]
        public IoAlarmSignal AlarmSignaBoatZAxisWarning { get; set; }
        [Tag("AlarmSignaBoatZAxisAlarm")]
        public IoAlarmSignal AlarmSignaBoatZAxisAlarm { get; set; }
        [Tag("AlarmSignaGasHeaterSensorBreakOutAlarm")]
        public IoAlarmSignal AlarmSignaGasHeaterSensorBreakOutAlarm { get; set; }
        [Tag("AlarmSignaTempLimitAlarm")]
        public IoAlarmSignal AlarmSignaTempLimitAlarm { get; set; }

        [Tag("AlarmSignalLAO2CheckOTWarning")]
        public IoAlarmSignal AlarmSignalLAO2CheckOTWarning { get; set; }
        [Tag("AlarmSignalFIMS1O2CheckOTWarning")]
        public IoAlarmSignal AlarmSignalFIMS1O2CheckOTWarning { get; set; }
        [Tag("AlarmSignalFIMS2O2CheckOTWarning")]
        public IoAlarmSignal AlarmSignalFIMS2O2CheckOTWarning { get; set; }

        [Tag("AlarmSignalHeaterUCascadePVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterUCascadePVSBrk { get; set; }

        [Tag("AlarmSignalHeaterUHeaterPVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterUHeaterPVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCUCascadePVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCUCascadePVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCUHeaterPVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCUHeaterPVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCCascadePVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCCascadePVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCHeaterPVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCHeaterPVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCLCascadePVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCLCascadePVSBrk { get; set; }

        [Tag("AlarmSignalHeaterCLHeaterPVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterCLHeaterPVSBrk { get; set; }

        [Tag("AlarmSignalHeaterLCascadePVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterLCascadePVSBrk { get; set; }

        [Tag("AlarmSignalHeaterLHeaterPVSBrk")]
        public IoAlarmSignal AlarmSignalHeaterLHeaterPVSBrk { get; set; }

        #endregion
        public AITSensorData SensorRecipeOK { get; set; }
        public AITSensorData SensorPROCManualOK { get; set; }
        [Tag("SensorVG11Status")]
        public IoSensor SensorVG11Status { get; set; }
        [Tag("SensorVG12Status")]
        public IoSensor SensorVG12Status { get; set; }
        [Tag("SensorVG13Status")]
        public IoSensor SensorVG13Status { get; set; }
        [Tag("SensorVACDEPOOK")]
        public IoSensor SensorVACDEPOOK { get; set; }
        [Tag("SensorVACHFOK")]
        public IoSensor SensorVACHFOK { get; set; }
        [Tag("SensorVACF2OK")]
        public IoSensor SensorVACF2OK { get; set; }
        //[Tag("SensorNH3PressureOK")]
        //public IoAlarmSignal SignalLeak { get; set; }

        //[Tag("SignalExhaustAlarm")]
        //public IoAlarmSignal SignalExhaustAlarm { get; set; }

        //[Tag("SignalLeakBroken")]
        //public IoAlarmSignal SignalLeakBroken { get; set; }


        //[Tag("EmoAlarm")]
        //public IoAlarmSignal EmoAlarm { get; set; }
        // -------------------------------------------------------------------------
        //[Tag("ChamberLiftPin")]
        //public IoLift2 ChamberLiftPin { get; set; }

        // -------------------------------------------------------------------------
        //[Tag("ChamberDoor")]
        //public IoDoor2 ChamberDoor { get; set; }

        //[Tag("MFM61")]
        //public IoMFM MFM61 { get; set; }
        //[Tag("MfmNB")]
        //public IoMFM MfmNB { get; set; }

        [Tag("ValveAV1")]
        public IoValve ValveAV1 { get; set; }
        [Tag("ValveAV2")]
        public IoValve ValveAV2 { get; set; }
        [Tag("ValveAV3")]
        public IoValve ValveAV3 { get; set; }
        [Tag("ValveAV4")]
        public IoValve ValveAV4 { get; set; }
        [Tag("ValveAV5")]
        public IoValve ValveAV5 { get; set; }
        [Tag("ValveAV6")]
        public IoValve ValveAV6 { get; set; }
        [Tag("ValveAV7")]
        public IoValve ValveAV7 { get; set; }
        [Tag("ValveAV8")]
        public IoValve ValveAV8 { get; set; }
        [Tag("ValveAV9")]
        public IoValve ValveAV9 { get; set; }
        [Tag("ValveAV10")]
        public IoValve ValveAV10 { get; set; }
        [Tag("ValveAV11")]
        public IoValve ValveAV11 { get; set; }
        [Tag("ValveAV12")]
        public IoValve ValveAV12 { get; set; }
        [Tag("ValveAV13")]
        public IoValve ValveAV13 { get; set; }
        [Tag("ValveAV14")]
        public IoValve ValveAV14 { get; set; }
        [Tag("ValveAV15")]
        public IoValve ValveAV15 { get; set; }
        [Tag("ValveAV16")]
        public IoValve ValveAV16 { get; set; }
        [Tag("ValveAV17")]
        public IoValve ValveAV17 { get; set; }
        [Tag("ValveAV18")]
        public IoValve ValveAV18 { get; set; }
        [Tag("ValveAV19")]
        public IoValve ValveAV19 { get; set; }
        [Tag("ValveAV20")]
        public IoValve ValveAV20 { get; set; }
        [Tag("ValveAV21")]
        public IoValve ValveAV21 { get; set; }
        [Tag("ValveAV22")]
        public IoValve ValveAV22 { get; set; }
        [Tag("ValveAV23")]
        public IoValve ValveAV23 { get; set; }
        [Tag("ValveAV24")]
        public IoValve ValveAV24 { get; set; }
        [Tag("ValveAV25")]
        public IoValve ValveAV25 { get; set; }
        [Tag("ValveAV26")]
        public IoValve ValveAV26 { get; set; }
        [Tag("ValveAV27")]
        public IoValve ValveAV27 { get; set; }
        [Tag("ValveAV28")]
        public IoValve ValveAV28 { get; set; }
        [Tag("ValveAV29")]
        public IoValve ValveAV29 { get; set; }
        [Tag("ValveAV30")]
        public IoValve ValveAV30 { get; set; }
        [Tag("ValveAV31")]
        public IoValve ValveAV31 { get; set; }
        [Tag("ValveAV32")]
        public IoValve ValveAV32 { get; set; }
        [Tag("ValveAV33")]
        public IoValve ValveAV33 { get; set; }
        [Tag("ValveAV34")]
        public IoValve ValveAV34 { get; set; }
        [Tag("ValveAV35")]
        public IoValve ValveAV35 { get; set; }
        [Tag("ValveAV36")]
        public IoValve ValveAV36 { get; set; }
        [Tag("ValveAV37")]
        public IoValve ValveAV37 { get; set; }
        [Tag("ValveAV38")]
        public IoValve ValveAV38 { get; set; }
        [Tag("ValveAV39")]
        public IoValve ValveAV39 { get; set; }

        [Tag("ValveAV40")]
        public IoValve ValveAV40 { get; set; }
        [Tag("ValveAV41")]
        public IoValve ValveAV41 { get; set; }
        [Tag("ValveAV42")]
        public IoValve ValveAV42 { get; set; }
        [Tag("ValveAV43")]
        public IoValve ValveAV43 { get; set; }
        [Tag("ValveAV44")]
        public IoValve ValveAV44 { get; set; }
        [Tag("ValveAV45")]
        public IoValve ValveAV45 { get; set; }
        [Tag("ValveAV46")]
        public IoValve ValveAV46 { get; set; }
        [Tag("ValveAV47")]
        public IoValve ValveAV47 { get; set; }
        [Tag("ValveAV48")]
        public IoValve ValveAV48 { get; set; }
        [Tag("ValveAV49")]
        public IoValve ValveAV49 { get; set; }
        [Tag("ValveAV50")]
        public IoValve ValveAV50 { get; set; }
        [Tag("ValveAV51")]
        public IoValve ValveAV51 { get; set; }
        [Tag("ValveAV52")]
        public IoValve ValveAV52 { get; set; }
        [Tag("ValveAV53")]
        public IoValve ValveAV53 { get; set; }
        [Tag("ValveAV54")]
        public IoValve ValveAV54 { get; set; }
        [Tag("ValveAV55")]
        public IoValve ValveAV55 { get; set; }
        [Tag("ValveAV56")]
        public IoValve ValveAV56 { get; set; }
        [Tag("ValveAV57")]
        public IoValve ValveAV57 { get; set; }
        [Tag("ValveAV58")]
        public IoValve ValveAV58 { get; set; }
        [Tag("ValveAV59")]
        public IoValve ValveAV59 { get; set; }
        [Tag("ValveAV60")]
        public IoValve ValveAV60 { get; set; }
        [Tag("ValveAV61")]
        public IoValve ValveAV61 { get; set; }
        [Tag("ValveAV62")]
        public IoValve ValveAV62 { get; set; }
        [Tag("ValveAV63")]
        public IoValve ValveAV63 { get; set; }
        [Tag("ValveAV64")]
        public IoValve ValveAV64 { get; set; }
        [Tag("ValveAV65")]
        public IoValve ValveAV65 { get; set; }

        [Tag("ValveAV202LADoor")]
        public IoValve ValveAV202LADoor { get; set; }
        [Tag("ValveAV66")]
        public IoValve ValveAV66 { get; set; }
        [Tag("ValveAV67")]
        public IoValve ValveAV67 { get; set; }
        [Tag("ValveAV68")]
        public IoValve ValveAV68 { get; set; }
        [Tag("ValveAV69")]
        public IoValve ValveAV69 { get; set; }
        [Tag("ValveAV70")]
        public IoValve ValveAV70 { get; set; }
        [Tag("ValveAV71")]
        public IoValve ValveAV71 { get; set; }
        [Tag("ValveAV72")]
        public IoValve ValveAV72 { get; set; }
        [Tag("ValveAV73")]
        public IoValve ValveAV73 { get; set; }
        [Tag("ValveAV74")]
        public IoValve ValveAV74 { get; set; }
        [Tag("ValveAV75")]
        public IoValve ValveAV75 { get; set; }
        [Tag("ValveAV76")]
        public IoValve ValveAV76 { get; set; }
        [Tag("ValveAV77")]
        public IoValve ValveAV77 { get; set; }
        [Tag("ValveAV78")]
        public IoValve ValveAV78 { get; set; }
        [Tag("ValveAV79")]
        public IoValve ValveAV79 { get; set; }
        [Tag("ValveAV80")]
        public IoValve ValveAV80 { get; set; }
        [Tag("ValveAV81")]
        public IoValve ValveAV81 { get; set; }
        [Tag("ValveAV82")]
        public IoValve ValveAV82 { get; set; }
        [Tag("ValveAV83")]
        public IoValve ValveAV83 { get; set; }
        [Tag("ValveAV84")]
        public IoValve ValveAV84 { get; set; }
        [Tag("ValveAV85")]
        public IoValve ValveAV85 { get; set; }
        [Tag("ValveAV86")]
        public IoValve ValveAV86 { get; set; }
        [Tag("ValveAV87")]
        public IoValve ValveAV87 { get; set; }
        [Tag("ValveAV88")]
        public IoValve ValveAV88 { get; set; }
        [Tag("ValveAV89")]
        public IoValve ValveAV89 { get; set; }
        [Tag("ValveAV90")]
        public IoValve ValveAV90 { get; set; }
        [Tag("ValveAV91")]
        public IoValve ValveAV91 { get; set; }
        [Tag("ValveAV92")]
        public IoValve ValveAV92 { get; set; }
        [Tag("ValveAV93")]
        public IoValve ValveAV93 { get; set; }
        [Tag("ValveAV94")]
        public IoValve ValveAV94 { get; set; }
        [Tag("ValveAV95")]
        public IoValve ValveAV95 { get; set; }
        [Tag("ValveAV96")]
        public IoValve ValveAV96 { get; set; }
        [Tag("ValveAV97")]
        public IoValve ValveAV97 { get; set; }
        [Tag("ValveAV98")]
        public IoValve ValveAV98 { get; set; }
        [Tag("ValveAV99")]
        public IoValve ValveAV99 { get; set; }
        [Tag("ValveAV100")]
        public IoValve ValveAV100 { get; set; }
        [Tag("ValveAV101")]
        public IoValve ValveAV101 { get; set; }
        [Tag("ValveAV102")]
        public IoValve ValveAV102 { get; set; }
        [Tag("ValveAV103")]
        public IoValve ValveAV103 { get; set; }
        [Tag("ValveAV104")]
        public IoValve ValveAV104 { get; set; }
        [Tag("ValveAV105")]
        public IoValve ValveAV105 { get; set; }
        [Tag("ValveAV106")]
        public IoValve ValveAV106 { get; set; }
        [Tag("ValveAV107")]
        public IoValve ValveAV107 { get; set; }
        [Tag("ValveAV108")]
        public IoValve ValveAV108 { get; set; }
        [Tag("ValveAV109")]
        public IoValve ValveAV109 { get; set; }
        [Tag("ValveAV110")]
        public IoValve ValveAV110 { get; set; }
        [Tag("ValveAV111")]
        public IoValve ValveAV111 { get; set; }
        [Tag("ValveAV112")]
        public IoValve ValveAV112 { get; set; }
        [Tag("ValveAV113")]
        public IoValve ValveAV113 { get; set; }
        [Tag("ValveAV114")]
        public IoValve ValveAV114 { get; set; }
        [Tag("ValveAV115")]
        public IoValve ValveAV115 { get; set; }
        [Tag("ValveAV116")]
        public IoValve ValveAV116 { get; set; }
        [Tag("ValveAV117")]
        public IoValve ValveAV117 { get; set; }
        [Tag("ValveAV118")]
        public IoValve ValveAV118 { get; set; }
        [Tag("ValveAV119")]
        public IoValve ValveAV119 { get; set; }
        [Tag("ValveAV120")]
        public IoValve ValveAV120 { get; set; }
        [Tag("ValveAV121")]
        public IoValve ValveAV121 { get; set; }
        [Tag("ValveAV122")]
        public IoValve ValveAV122 { get; set; }
        [Tag("ValveAV123")]
        public IoValve ValveAV123 { get; set; }
        [Tag("ValveAV124")]
        public IoValve ValveAV124 { get; set; }
        [Tag("ValveAV125")]
        public IoValve ValveAV125 { get; set; }
        [Tag("ValveAV126")]
        public IoValve ValveAV126 { get; set; }
        [Tag("ValveAV127")]
        public IoValve ValveAV127 { get; set; }
        [Tag("ValveAV128")]
        public IoValve ValveAV128 { get; set; }
        [Tag("ValveAV129")]
        public IoValve ValveAV129 { get; set; }
        [Tag("ValveAV130")]
        public IoValve ValveAV130 { get; set; }
        [Tag("ValveAV131")]
        public IoValve ValveAV131 { get; set; }
        [Tag("ValveAV132")]
        public IoValve ValveAV132 { get; set; }
        [Tag("ValveAV133")]
        public IoValve ValveAV133 { get; set; }
        [Tag("ValveAV134")]
        public IoValve ValveAV134 { get; set; }
        [Tag("ValveAV135")]
        public IoValve ValveAV135 { get; set; }
        [Tag("ValveAV136")]
        public IoValve ValveAV136 { get; set; }
        [Tag("ValveAV230")]
        public IoValve ValveAV230 { get; set; }

        [Tag("ValveCommonBoxPressureRegulatingCylinder")]
        public IoValve ValveCommonBoxPressureRegulatingCylinder { get; set; }

        [Tag("ValveLABacksideDoorCylinderControl")]
        public IoValve ValveLABacksideDoorCylinderControl { get; set; }
        [Tag("ValveLAExhaustDamper")]
        public IoValve ValveLAExhaustDamper { get; set; }
        [Tag("ValveLADamper")]
        public IoValve ValveLADamper { get; set; }
        [Tag("ValveFIMS1N2Purge")]
        public IoValve ValveFIMS1N2Purge { get; set; }
        [Tag("ValveFIMS2N2Purge")]
        public IoValve ValveFIMS2N2Purge { get; set; }
        [Tag("ValveSV61")]
        public IoValve ValveSV61 { get; set; }
        [Tag("ValveSV62")]
        public IoValve ValveSV62 { get; set; }
        [Tag("ValveSV63")]
        public IoValve ValveSV63 { get; set; }
        [Tag("ValveSV64")]
        public IoValve ValveSV64 { get; set; }
        [Tag("AGVPump")]
        public IoValve AGVPump { get; set; }
        [Tag("AGV2Pump")]
        public IoValve AGV2Pump { get; set; }
        [Tag("BothPump")]
        public IoValve BothPump { get; set; }

        [Tag("BothPump1")]
        public IoValve BothPump1 { get; set; }

        [Tag("BothPump2")]
        public IoValve BothPump2 { get; set; }

        [Tag("ValveBlowerPowerOn")]
        public IoValve ValveBlowerPowerOn { get; set; }

        [Tag("HMNT")]
        public IoValve HMNT { get; set; }

        [Tag("CMNT")]
        public IoValve CMNT { get; set; }

        [Tag("HREF")]
        public IoValve HREF { get; set; }

        [Tag("CREF")]
        public IoValve CREF { get; set; }

        [Tag("HZERO")]
        public IoValve HZERO { get; set; }

        [Tag("CZERO")]
        public IoValve CZERO { get; set; }

        // -------------------------------------------------------------------------
        [Tag("PressureGLBoxPG1")]
        public IoPressureMeter PressureGLBoxPG1 { get; set; }
        [Tag("PressureGLBoxPG2")]
        public IoPressureMeter PressureGLBoxPG2 { get; set; }
        [Tag("PressureGLBoxPG3")]
        public IoPressureMeter PressureGLBoxPG3 { get; set; }
        [Tag("PressureGLBoxPG4")]
        public IoPressureMeter PressureGLBoxPG4 { get; set; }
        [Tag("PressureGLBoxPG5")]
        public IoPressureMeter PressureGLBoxPG5 { get; set; }
        [Tag("PressureGLBoxPG6")]
        public IoPressureMeter PressureGLBoxPG6 { get; set; }
        [Tag("PressureGasBoxUpperVG21")]
        public IoPressureMeter PressureGasBoxUpperVG21 { get; set; }
        [Tag("PressureGasBoxUpperVG22")]
        public IoPressureMeter PressureGasBoxUpperVG22 { get; set; }
        [Tag("ConcentrationO2")]
        public IoPressureMeter ConcentrationO2 { get; set; }
        [Tag("GasBoxExhaustMS2")]
        public IoPressureMeter GasBoxExhaustMS2 { get; set; }
        [Tag("ScavengerExhaustMS3")]
        public IoPressureMeter ScavengerExhaustMS3 { get; set; }
        [Tag("ExhaustBoxExhaustMS4")]
        public IoPressureMeter ExhaustBoxExhaustMS4 { get; set; }
        [Tag("LoadingAreaExhaustMS5")]
        public IoPressureMeter LoadingAreaExhaustMS5 { get; set; }
        [Tag("FrontBodyExhaustMS6")]
        public IoPressureMeter FrontBodyExhaustMS6 { get; set; }
        [Tag("LAExhaustMS7")]
        public IoPressureMeter LAExhaustMS7 { get; set; }
        [Tag("RHCExhaustMS8")]
        public IoPressureMeter RHCExhaustMS8 { get; set; }
        [Tag("RHCFlowFL901")]
        public IoPressureMeter RHCFlowFL901 { get; set; }
        [Tag("CoolingWaterFlowOfFurnaceFL902")]
        public IoPressureMeter CoolingWaterFlowOfFurnaceFL902 { get; set; }
        [Tag("CoolingWateFlowOfShuttleFL903")]
        public IoPressureMeter CoolingWateFlowOfShuttleFL903 { get; set; }
        [Tag("CoolingWaterFlowOfBoatRotationFL904")]
        public IoPressureMeter CoolingWaterFlowOfBoatRotationFL904 { get; set; }
        [Tag("CoolingWaterFlowOfFlangeFL905")]
        public IoPressureMeter CoolingWaterFlowOfFlangeFL905 { get; set; }
        [Tag("CoolingWaterFlowOfLoadingAreaFL906")]
        public IoPressureMeter CoolingWaterFlowOfLoadingAreaFL906 { get; set; }
        [Tag("VG11")]
        public IoPressureMeter VG11 { get; set; }
        [Tag("VG12")]
        public IoPressureMeter VG12 { get; set; }
        [Tag("VG13")]
        public IoPressureMeter VG13 { get; set; }
        [Tag("VG21")]
        public IoPressureMeter VG21 { get; set; }
        [Tag("VG22")]
        public IoPressureMeter VG22 { get; set; }
        [Tag("PG12")]
        public IoPressureMeter PG12 { get; set; }
        [Tag("PG13")]
        public IoPressureMeter PG13 { get; set; }
        [Tag("PS13")]
        public IoPressureMeter PS13 { get; set; }
        [Tag("N24PurgePressure")]
        public IoPressureMeter N24PurgePressure { get; set; }
        [Tag("N25PurgePressure")]
        public IoPressureMeter N25PurgePressure { get; set; }
        [Tag("N26PurgePressure")]
        public IoPressureMeter N26PurgePressure { get; set; }
        [Tag("N27PurgePressure")]
        public IoPressureMeter N27PurgePressure { get; set; }

        [Tag("PS11")]
        public IoPressureMeter PS11 { get; set; }
        [Tag("PS17")]
        public IoPressureMeter PS17 { get; set; }
        // -------------------------------------------------------------------------
        [Tag("FIMS1")]
        public IoFIMS FIMS1 { get; set; }
        [Tag("FIMS2")]
        public IoFIMS FIMS2 { get; set; }

        //[Tag("ValvePV12")]
        //public IoValve ValvePV12 { get; set; }

        //[Tag("ValvePV13")]
        //public IoValve ValvePV13 { get; set; }

        //[Tag("ValvePV14")]
        //public IoValve ValvePV14 { get; set; }

        //[Tag("ValvePV15")]
        //public IoValve ValvePV15 { get; set; }

        //[Tag("ValvePV16")]
        //public IoValve ValvePV16 { get; set; }

        //[Tag("ValvePV17")]
        //public IoValve ValvePV17 { get; set; }
        [Tag("MFC1")]
        public IoMFC MFC1 { get; set; }
        [Tag("MFC2")]
        public IoMFC MFC2 { get; set; }
        [Tag("MFC3")]
        public IoMFC MFC3 { get; set; }
        [Tag("MFC4")]
        public IoMFC MFC4 { get; set; }
        [Tag("MFC5")]
        public IoMFC MFC5 { get; set; }
        [Tag("MFC6")]
        public IoMFC MFC6 { get; set; }
        [Tag("MFC7")]
        public IoMFC MFC7 { get; set; }
        [Tag("MFC8")]
        public IoMFC MFC8 { get; set; }
        [Tag("MFC9")]
        public IoMFC MFC9 { get; set; }
        [Tag("MFC10")]
        public IoMFC MFC10 { get; set; }
        [Tag("MFC11")]
        public IoMFC MFC11 { get; set; }
        [Tag("MFC12")]
        public IoMFC MFC12 { get; set; }
        [Tag("MFC13")]
        public IoMFC MFC13 { get; set; }
        [Tag("MFC14")]
        public IoMFC MFC14 { get; set; }
        [Tag("MFC15")]
        public IoMFC MFC15 { get; set; }
        [Tag("MFC16")]
        public IoMFC MFC16 { get; set; }
        [Tag("MFC17")]
        public IoMFC MFC17 { get; set; }
        [Tag("MFC31")]
        public IoMFC MFC31 { get; set; }
        [Tag("MFC32")]
        public IoMFC MFC32 { get; set; }
        [Tag("MFC51")]
        public IoMFC MFC51 { get; set; }
        [Tag("MFC57")]
        public IoMFC MFC57 { get; set; }

        //[Tag("GasLineA")]
        //public IoGasStick2 GasLineA { get; set; }
        //[Tag("GasLineB")]
        //public IoGasStick2 GasLineB { get; set; }
        //[Tag("GasLineC")]
        //public IoGasStick2 GasLineC { get; set; }
        //[Tag("GasLineNX")]
        //public IoGasStick2 GasLineNX { get; set; }
        //[Tag("GasLineNY")]
        //public IoGasStick2 GasLineNY { get; set; }
        //[Tag("GasLineN1")]
        //public IoGasStick2 GasLineN1 { get; set; }
        //[Tag("GasLineN2")]
        //public IoGasStick2 GasLineN2 { get; set; }
        //[Tag("GasLineN3")]
        //public IoGasStick2 GasLineN3 { get; set; }
        //[Tag("GasLineM1")]
        //public IoGasStick2 GasLineM1 { get; set; }
        //[Tag("GasLineM2")]
        //public IoGasStick2 GasLineM2 { get; set; }
        //[Tag("GasLineD1")]
        //public IoGasStick2 GasLineD1 { get; set; }
        //[Tag("GasLineJ1")]
        //public IoGasStick2 GasLineJ1 { get; set; }

        // -------------------------------------------------------------------------
        [Tag("Shutter")]
        public IoShutter Shutter { get; set; }
        [Tag("FFU1")] public IoFFU FFU1 { get; set; }
        [Tag("FFU2")] public IoFFU FFU2 { get; set; }
        [Tag("FFU3")] public IoFFU FFU3 { get; set; }
        [Tag("FFU4")] public IoFFU FFU4 { get; set; }
        [Tag("FFU5")] public IoFFU FFU5 { get; set; }
        [Tag("FFU6")] public IoFFU FFU6 { get; set; }
        [Tag("FFU7")] public IoFFU FFU7 { get; set; }
        [Tag("FFU8")] public IoFFU FFU8 { get; set; }
        [Tag("FFU9")] public IoFFU FFU9 { get; set; }
        // -------------------------------------------------------------------------
        [Tag("APC")]
        public IoAPC APC { get; set; }


        // -------------------------------------------------------------------------
        //[Tag("MainPump")]
        //public IoPump MainPump { get; set; }
        //[Tag("IoPump")]
        //public IoPump IoPump { get; set; }

        // -------------------------------------------------------------------------
        //[Tag("VG2Pressure")]
        //public IoPressureMeter VG2Pressure { get; set; }
        //[Tag("PT52")]
        //public IoPressureMeter PT52 { get; set; }

        //[Tag("PT53")]
        //public IoPressureMeter PT53 { get; set; }

        //[Tag("PT10")]
        //public IoPressureMeter PT10 { get; set; }

        //[Tag("PT20")]
        //public IoPressureMeter PT20 { get; set; }

        //[Tag("PT30")]
        //public IoPressureMeter PT30 { get; set; }

        //[Tag("O2Detector1")]
        //public IoPressureMeter O2Detector1 { get; set; }

        //[Tag("O2Detector2")]
        //public IoPressureMeter O2Detector2 { get; set; }


        // -------------------------------------------------------------------------
        [Tag("TrigFurnaceLZoneHeatingEnable")]
        public IoTrigger TrigFurnaceLZoneHeatingEnable { get; set; }
        [Tag("TrigFurnaceCLZoneHeatingEnable")]
        public IoTrigger TrigFurnaceCLZoneHeatingEnable { get; set; }
        [Tag("TrigFurnaceCZoneHeatingEnable")]
        public IoTrigger TrigFurnaceCZoneHeatingEnable { get; set; }
        [Tag("TrigFurnaceCUZoneHeatingEnable")]
        public IoTrigger TrigFurnaceCUZoneHeatingEnable { get; set; }
        [Tag("TrigFurnaceUZoneHeatingEnable")]
        public IoTrigger TrigFurnaceUZoneHeatingEnable { get; set; }
        [Tag("TrigVGUnitConversion")]
        public IoTrigger TrigVGUnitConversion { get; set; }
        [Tag("TrigForlineHeaterOn")]
        public IoTrigger TrigForlineHeaterOn { get; set; }
        [Tag("TrigHTR1SWON")]
        public IoTrigger TrigHTR1SWON { get; set; }
        [Tag("TrigHTR2SWON")]
        public IoTrigger TrigHTR2SWON { get; set; }
        [Tag("TrigHTR3SWON")]
        public IoTrigger TrigHTR3SWON { get; set; }

        [Tag("TrigDEPOSW")]
        public IoTrigger TrigDEPOSW { get; set; }

        [Tag("TrigCREFON")]
        public IoTrigger TrigCREFON { get; set; }

        [Tag("TrigSIREFON")]
        public IoTrigger TrigSIREFON { get; set; }

        [Tag("TrigHFCleanSwitchB")]
        public IoTrigger TrigHFCleanSwitchB { get; set; }
        [Tag("TrigF2CleanSwitchB")]
        public IoTrigger TrigF2CleanSwitchB { get; set; }
        public IoHeater HeaterU { get; set; }
        public IoHeater HeaterCU { get; set; }
        public IoHeater HeaterC { get; set; }
        public IoHeater HeaterCL { get; set; }
        public IoHeater HeaterL { get; set; }

        //private Dictionary<string, IoMFC> _gasMFCs;
        //public Dictionary<string, IoMFC> GasMFCs => _gasMFCs;
        [Tag("TrigAV71ExternalHeater")]
        public IoTrigger TrigAV71ExternalHeater { get; set; }
        [Tag("TrigAV71RingHeater")]
        public IoTrigger TrigAV71RingHeater { get; set; }
        [Tag("TrigHeaterAllEnable")]
        public IoTrigger TrigHeaterAllEnable { get; set; }
        [Tag("TrigGasLineHeaterMemoryChange")]
        public IoTrigger TrigGasLineHeaterMemoryChange { get; set; }
        #region N2Purge
        [Tag("TrigN2PurgeLAO2CheckFirstEnable")]
        public IoTrigger TrigN2PurgeLAO2CheckFirstEnable { get; set; }
        [Tag("TrigN2PurgeFIMS1O2CheckEnable")]
        public IoTrigger TrigN2PurgeFIMS1O2CheckEnable { get; set; }
        [Tag("TrigN2PurgeFIMS2O2CheckEnable")]
        public IoTrigger TrigN2PurgeFIMS2O2CheckEnable { get; set; }
        [Tag("TrigN2PurgeProcess")]
        public IoTrigger TrigN2PurgeProcess { get; set; }
        [Tag("TrigN2PurgeLAO2OverTime")]
        public IoTrigger TrigN2PurgeLAO2OverTime { get; set; }
        [Tag("TrigN2PurgeLAO2CheckTime")]
        public IoTrigger TrigN2PurgeLAO2CheckTime { get; set; }
        [Tag("TrigN2PurgeFOUPO2OverTime")]
        public IoTrigger TrigN2PurgeFOUPO2OverTime { get; set; }
        [Tag("TrigN2PurgeFOUPO2CheckTime")]
        public IoTrigger TrigN2PurgeFOUPO2CheckTime { get; set; }
        [Tag("TrigN2PurgeExchangeLATOFOUPWaitTime")]
        public IoTrigger TrigN2PurgeExchangeLATOFOUPWaitTime { get; set; }
        [Tag("TrigN2PurgeExchangeFOUPTOLAWaitTime")]
        public IoTrigger TrigN2PurgeExchangeFOUPTOLAWaitTime { get; set; }
        [Tag("TrigN2PurgeExchangeFOUPTOFOUPWaitTime")]
        public IoTrigger TrigN2PurgeExchangeFOUPTOFOUPWaitTime { get; set; }
        [Tag("TrigN2PurgeLAO2CheckSV")]
        public IoTrigger TrigN2PurgeLAO2CheckSV { get; set; }
        [Tag("TrigN2PurgeFOUPO2CheckSV")]
        public IoTrigger TrigN2PurgeFOUPO2CheckSV { get; set; }
        #endregion
        #region IoHeaterBand
        [Tag("CapHeater")]
        public IoHeaterBand CapHeater { get; set; }
        [Tag("APCExternalHeater")]
        public IoHeaterBand APCExternalHeater { get; set; }
        [Tag("APCRingHeater")]
        public IoHeaterBand APCRingHeater { get; set; }
        #endregion
        // -------------------------------------------------------------------------
        [Tag("BoatElevatorServo")]
        public IoFurnaceMotor ZAxisDevice { get; set; }
        [Tag("BoatRotationServo")]
        public IoFurnaceMotor RAxisDevice { get; set; }
        [Tag("APC")]
        public IoAPC APCDevice { get; set; }

        [Tag("TrigGasLineHeaterUnit1PowerOn")]
        public IoTrigger2 TrigGasLine1PowerOn { get; set; }
        [Tag("TrigGasLineHeaterUnit2PowerOn")]
        public IoTrigger2 TrigGasLine2PowerOn { get; set; }
        [Tag("TrigGasLineHeaterUnit3PowerOn")]
        public IoTrigger2 TrigGasLine3PowerOn { get; set; }
        [Tag("TrigGasLineHeaterUnit4PowerOn")]
        public IoTrigger2 TrigGasLine4PowerOn { get; set; }

        [Tag("TrigGasLineHeaterUnit6PowerOn")]
        public IoTrigger2 TrigGasLine6PowerOn { get; set; }

        [Tag("TrigGasLineHeaterUnit7PowerOn")]
        public IoTrigger2 TrigGasLine7PowerOn { get; set; }

        Func<MemberInfo, bool> _hasTagAttribute;
        Func<object, bool> _isTagAttribute;

        public override double ChamberPressure
        {
            get
            {
                return 0;
            }
        }

        //public IAdsPlc Plc { get; set; }

        private List<IDevice> _allModuleDevice = new List<IDevice>();

        private List<IoMFC> _processMFCs = new List<IoMFC>();
        private List<IoHeater> _heaters = new List<IoHeater>();
        private List<IoValve> _valves = new List<IoValve>();
        private List<IoFFU> _fFUs = new List<IoFFU>();

        private List<IoGasStick2> _gasSticks;
        public List<IoGasStick2> GasSticks => _gasSticks;
        private List<AlarmEventItem> _triggeredAlarmList = new List<AlarmEventItem>();
        private List<IoAlarmSignal> _alarmSignals = new List<IoAlarmSignal>();
        private FurnaceSignalTower _signalTowerDevice;
        private int _alarmNumber;

        private List<IoAlarmSignal> _inCommandLst;
        private Dictionary<string, RD_TRIG> _inCommandTirgs = new Dictionary<string, RD_TRIG>();

        private IoTrigger _trigTHPowerEN;
        private IoTrigger _trigHECPowerONLamp;
        private List<HeaterBase> _HTR1Group = new List<HeaterBase>();
        private List<HeaterBase> _HTR2Group = new List<HeaterBase>();
        private List<HeaterBase> _HTR3Group = new List<HeaterBase>();
        public void InitDevice()
        {
            _isTagAttribute = attribute => attribute is TagAttribute;
            _hasTagAttribute = mi => mi.GetCustomAttributes(false).Any(_isTagAttribute);
            var properties = this.GetType().GetProperties().Where(_hasTagAttribute);
            foreach (var field in properties)
            {
                TagAttribute tag = field.GetCustomAttributes(false).First(_isTagAttribute) as TagAttribute;
                IDevice device = DEVICE.GetDevice<IDevice>($"{Module}.{tag.Tag}");
                if (device == null)
                    device = DEVICE.GetDevice<IDevice>($"PM1.{tag.Tag}");
                if (device == null)
                    device = DEVICE.GetDevice<IDevice>($"System.{tag.Tag}");

                if (device != null)
                {
                    _allModuleDevice.Add(device);

                    PropertyInfo pi = (PropertyInfo)field;

                    var convertedValue = Convert.ChangeType(device, pi.PropertyType);

                    System.Diagnostics.Debug.Assert(convertedValue != null);

                    pi.SetValue(this, convertedValue);

                    if (device is IoAlarmSignal)
                    {
                        _alarmSignals.Add(device as IoAlarmSignal);
                    }

                    device.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;

                    if (device is IoMFC && device.Name != "MFC57")
                        _processMFCs.Add(device as IoMFC);
                    if (device is IoHeater)
                        _heaters.Add(device as IoHeater);
                    else if (device is IoValve)
                        _valves.Add(device as IoValve);
                    else if (device is HeaterBase)
                        _HTR2Group.Add(device as HeaterBase);
                    else if (device is IoFFU)
                        _fFUs.Add(device as IoFFU);
                }
                else
                {

                }
            }

            for (int i = 1; i < 10; i++)
            {
                for (int ch = 1; ch < 40; ch++)
                {
                    var device = DEVICE.GetDevice<HeaterBase>($"PM1.GaslineHeaterUnit{i}CH{ch}");
                    if (device != null)
                    {
                        if ((i == 4 && ch == 1) || (i == 4 && ch == 2) || (i == 4 && ch == 3) || (i == 4 && ch == 4))
                        {
                            //这几个从_HTR2Group中删除
                            //_HTR2Group.Add(device);
                            continue;
                        }
                        else
                            _HTR1Group.Add(device);
                    }
                }

            }
            for (int i = 1; i < 20; i++)
            {
                var device = DEVICE.GetDevice<HeaterBase>($"PM1.ForelineHeater{i}");
                if (device != null)
                {
                    _HTR2Group.Add(device);
                }
            }


            //Singleton<DeviceController>.Instance.Start(Singleton<DeviceManager>.Instance);
            //FlowmeterLists = DEVICE.GetDevice<IoFlowMeter>().Where(o => o.Module == Module).ToList();
            HeaterU = DEVICE.GetDevice<IoHeater>($"System.HeaterU");
            HeaterCU = DEVICE.GetDevice<IoHeater>($"System.HeaterCU");
            HeaterC = DEVICE.GetDevice<IoHeater>($"System.HeaterC");
            HeaterCL = DEVICE.GetDevice<IoHeater>($"System.HeaterCL");
            HeaterL = DEVICE.GetDevice<IoHeater>($"System.HeaterL");
            _heaters = new List<IoHeater>()
            {
                HeaterU,
                HeaterCU,
                HeaterC,
                HeaterCL,
                HeaterL,
            };
            foreach (var heater in _heaters)
            {
                if (heater != null)
                {
                    heater.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
                }
            }


            Singleton<InterlockManager>.Instance.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            this.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;

            foreach (var pv in Singleton<IoProviderManager>.Instance.Providers)
            {
                if ((pv as IoProvider) != null)
                    (pv as IoProvider).OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            }

            _gasSticks = new List<IoGasStick2>()
            {
                //GasLineA,
                //GasLineB,
                //GasLineC,
                //GasLineNX,
                //GasLineNY,
                //GasLineN1,
                //GasLineN2,
                //GasLineN3,
                //GasLineM1,
                //GasLineM2,
                //GasLineD1,
                //GasLineJ1,
            };
            _signalTowerDevice = DEVICE.GetDevice<FurnaceSignalTower>($"{ModuleName.System}.{ModuleName.SignalTower}");

            _trigTHPowerEN = DEVICE.GetDevice<IoTrigger>($"PM1.TrigTHPowerEN");
            _trigHECPowerONLamp = DEVICE.GetDevice<IoTrigger>($"{Module}.TrigHECPowerONLamp");

            _inCommandLst = new List<IoAlarmSignal>()
            {
                //SensorHECPowerONSW,
                //  SensorTHBreakOK,
            };
            //SensorLidClosed.OnSignalChanged += SensorLidClosed_OnSignalChanged;
            _n2PurgeSequenceAction = new Dictionary<string, Tuple<R_TRIG, List<Tuple<IoValve, bool>>>>()
            {
                {"N2PurgeAIRTo20PPM",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,true),
                              Tuple.Create(ValveAV57,true),
                              Tuple.Create(ValveAV65,false), //AV65
                              Tuple.Create(ValveAV66,false),
                              Tuple.Create(ValveLADamper,true), //AV227
                              Tuple.Create(ValveAV58,false),
                              Tuple.Create(ValveAV59,false),
                              Tuple.Create(ValveFIMS1N2Purge,false), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,false), //AV64
                              Tuple.Create(ValveSV61,false),
                              Tuple.Create(ValveSV62,false),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,false), //AV201
                          })
                },
                {"N2PurgeUnder20PPM",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,true),
                              Tuple.Create(ValveAV57,false),
                              Tuple.Create(ValveAV65,false), //AV65
                              Tuple.Create(ValveAV66,false),
                              Tuple.Create(ValveLADamper,true), //AV227
                              Tuple.Create(ValveAV58,false),
                              Tuple.Create(ValveAV59,false),
                              Tuple.Create(ValveFIMS1N2Purge,false), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,false), //AV64
                              Tuple.Create(ValveSV61,false),
                              Tuple.Create(ValveSV62,false),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,false), //AV201
                          })
                },
                {"AIR",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,false),
                              Tuple.Create(ValveAV57,false),
                              Tuple.Create(ValveAV65,true), //AV65
                              Tuple.Create(ValveAV66,true),
                              Tuple.Create(ValveLADamper,true), //AV227
                              Tuple.Create(ValveAV58,false),
                              Tuple.Create(ValveAV59,false),
                              Tuple.Create(ValveFIMS1N2Purge,false), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,false), //AV64
                              Tuple.Create(ValveSV61,false),
                              Tuple.Create(ValveSV62,false),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,true), //AV201
                          })
                },
                {"DoorOpen",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,false),
                              Tuple.Create(ValveAV57,false),
                              Tuple.Create(ValveAV65,true), //AV65
                              Tuple.Create(ValveAV66,true),
                              Tuple.Create(ValveLADamper,false), //AV227
                              Tuple.Create(ValveAV58,false),
                              Tuple.Create(ValveAV59,false),
                              Tuple.Create(ValveFIMS1N2Purge,false), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,false), //AV64
                              Tuple.Create(ValveSV61,false),
                              Tuple.Create(ValveSV62,false),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,true), //AV201
                          })
                },
                {"Foup1",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,true),
                              Tuple.Create(ValveAV57,false),
                              Tuple.Create(ValveAV65,false), //AV65
                              Tuple.Create(ValveAV66,false),
                              Tuple.Create(ValveLADamper,true), //AV227
                              Tuple.Create(ValveAV58,true),
                              Tuple.Create(ValveAV59,false),
                              Tuple.Create(ValveFIMS1N2Purge,true), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,false), //AV64
                              Tuple.Create(ValveSV61,true),
                              Tuple.Create(ValveSV62,false),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,false), //AV201
                          })
                },
                {"Foup2",Tuple.Create(new R_TRIG(),
                          new List<Tuple<IoValve, bool>>()
                          {
                              Tuple.Create(ValveAV56,true),
                              Tuple.Create(ValveAV57,false),
                              Tuple.Create(ValveAV65,false), //AV65
                              Tuple.Create(ValveAV66,false),
                              Tuple.Create(ValveLADamper,true), //AV227
                              Tuple.Create(ValveAV58,false),
                              Tuple.Create(ValveAV59,true),
                              Tuple.Create(ValveFIMS1N2Purge,false), //AV63
                              Tuple.Create(ValveFIMS2N2Purge,true), //AV64
                              Tuple.Create(ValveSV61,true),
                              Tuple.Create(ValveSV62,true),
                              Tuple.Create(ValveCommonBoxPressureRegulatingCylinder,false), //AV201
                          })
                },
            };
            _n2PurgeSequenceStatus = new Dictionary<string, Func<bool>>()
            {
                {"N2PurgeAIRTo20PPM",()=> GetN2PurgeAIRTo20PPMStatus()},
                {"N2PurgeUnder20PPM",()=> GetN2PurgeUnder20PPMStatus()},
                {"AIR",()=> GetN2PurgeAIRStatus()},
                {"DoorOpen",()=> GetN2PurgeDoorOpenStatus()},
                {"Foup1",()=> GetN2PurgeFoup1Status()},
                {"Foup2",()=> GetN2PurgeFoup2Status()},
            };

            TrigFurnaceUZoneHeatingEnable.SetTrigger(true, out _);
            TrigFurnaceCUZoneHeatingEnable.SetTrigger(true, out _);
            TrigFurnaceCZoneHeatingEnable.SetTrigger(true, out _);
            TrigFurnaceCLZoneHeatingEnable.SetTrigger(true, out _);
            TrigFurnaceLZoneHeatingEnable.SetTrigger(true, out _);
        }

        private void SensorLidClosed_OnSignalChanged(IoSensor sender, bool isTriggered)
        {
            if (!isTriggered)
            {
                EV.PostWarningLog(Module, $"Lid Open.");
            }
        }

        private void PlcDisconnected()
        {
            CheckToPostMessage(MSG.Disconnected);
        }

        private void PlcConnected()
        {
            if (IsInit)
                return;

            if (FsmState.Equals((int)STATE.NotConnected))
                CheckToPostMessage(MSG.Connected);
        }

        public void OnModuleDeviceAlarmStateChanged(string deviceId, AlarmEventItem alarmItem)
        {
            if (alarmItem.IsTriggered)
            {
                EventLevel level = alarmItem.Level;

                string description = alarmItem.AdditionalDescription;

                //description += $" {(!string.IsNullOrEmpty(_recipeRunningInfo.RecipeName) ? $"Recipe:{_recipeRunningInfo.RecipeName}," : "")}Step:{(IsProcessing ? _recipeRunningInfo.StepName : "Standby")}";
                //alarmItem.AdditionalDescription += $" {(!string.IsNullOrEmpty(_recipeRunningInfo.RecipeName) ? $"Recipe:{_recipeRunningInfo.RecipeName}," : "")}Step:{(IsProcessing ? _recipeRunningInfo.StepName : "Standby")}";
                alarmItem.AdditionalDescription = description;
                alarmItem.OccuringTime = DateTime.Now;

                _triggeredAlarmList.Add(alarmItem);

                if (IsProcessing)
                {
                    if (level == EventLevel.Alarm)
                    {
                        EV.PostAlarmLog(Module, alarmItem);
                    }
                    else
                    {
                        EV.PostWarningLog(Module, alarmItem);
                    }
                }
                else
                {
                    if (level == EventLevel.Alarm)
                    {
                        try
                        {
                            //if (!(bool)Aitex.Core.RT.DataCenter.DATA.Poll($"{alarmItem.EventEnum}.ignoreSaveDB")) {
                            //    EV.PostAlarmLog(Module, alarmItem);
                            //}
                               
                        }
                        catch (Exception ex)
                        {
                            EV.WriteEvent(ex.Message.ToString());
                        }
                    }
                    else
                    {
                        EV.PostWarningLog(Module, alarmItem);
                    }
                }
            }
            else
            {
            }
        }

        public override bool CheckAcked(int entityTaskToken)
        {
            return true;
        }


        #region pump device operation
        public override bool TurnOnPump(out string reason)
        {
            reason = string.Empty;
            return true /*MainPump.SetPump(out reason, 0, true)*/;
        }

        public override bool CheckPumpIsOn()
        {
            return true/*MainPump.IsRunning*/;
        }

        #endregion

        public bool CheckIsConnected()
        {
            return true;
        }

        public bool CheckHasAlarm()
        {
            foreach (var device in _allModuleDevice)
            {
                if (device != null && device.HasAlarm)
                    return true;
            }

            return false;
        }

        public override bool CheckSlitValveClose()
        {
            return true;
        }

        public override bool CheckLidClosed()
        {
            return true;
        }

        public override bool CheckPrepareProcess()
        {
            return _isPrepareProcess;
        }

        public override bool CheckProcessFinished()
        {
            bool isFinished = true;
            var wafers = WaferManager.Instance.GetWafers(_module);
            if (wafers == null)
            {
                return false;
            }
            foreach (var wafer in wafers)
            {
                if (wafer.IsEmpty)
                    continue;
                if (wafer.ProcessState != EnumWaferProcessStatus.Completed && wafer.ProcessState != EnumWaferProcessStatus.Failed)
                    isFinished = false;
            }
            return isFinished;
        }

        public override bool CheckStandbyCondition()
        {
            return true;
            return CheckExternalSensorCondition() && CheckTempStabilizeCondition() &&
                CheckReachTempCondition() && CheckPressureStablilizeCondition() &&
                CheckReachPressureCondition() && CheckFinishAutoProfileCondition();
        }

        #region conditionCheck
        private bool SeBypassStandbyFactor(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            if (param != null && param.Length > 0)
            {
                var condition = param[0].ToString();
                if (_conditionCheckDic.ContainsKey(condition))
                {
                    _conditionCheckDic[condition] = true;
                }
            }
            return true;
        }
        private bool SetConditionCheck(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            _conditionCheckDic.Clear();
            _conditionCheckItemDic.Clear();
            _isExternalSensorConditionBypass = false;
            _isTempStabilizeConditionBypass = false;
            _isPressureStabilizeConditionBypass = false;
            _isReachTempConditionBypass = false;
            _isReachPressureConditionBypass = false;
            _isFinishAutoProfileConditionBypass = false;
            if (param.Length > 0)
            {
                var conditions = param[0].ToString().Split(';').ToList();
                foreach (var condition in conditions)
                {
                    var arry = condition.Split(':');
                    if (arry.Length > 1)
                    {
                        switch (arry[0])
                        {
                            case "ExternalSensor":
                                SetExternalSensorCondition("Wait For External Sensor", arry[1]);
                                break;
                            case "TempStabilize":
                                SetTempStabilizeCondition("Wait For Temperature Stablilize", arry[1]);
                                break;
                            case "ReachTemp":
                                SetReachTempCondition("Wait For Reach Temperature", arry[1]);
                                break;
                            case "ReachPressure":
                                SetReachPressureCondition("Wait For Reach Pressure", arry[1]);
                                break;
                            case "PressureStabilize":
                                SetPressureStabilizeCondition("Wait For Pressure Stablilize", arry[1]);
                                break;
                            case "FinishAutoProfile":
                                SetFinishAutoProfileCondition("Wait For Finish Auto Profile", arry[1]);
                                break;
                            case "None":
                            case "none":
                                break;
                        }
                    }
                }
            }

            return true;
        }
        private void SetExternalSensorCondition(string title, string para)
        {
            var conditions = para.ToLower().Split(',').ToList();
            if (conditions.Any(x => !x.Contains("none")))
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
            }
        }
        private void SetTempStabilizeCondition(string title, string para)
        {
            if (para.ToLower() != "none")
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
                foreach (var heater in _heaters)
                {
                    //heater.SetStableParameters(para);
                }
            }
        }
        private void SetReachTempCondition(string title, string para)
        {
            if (para.ToLower() != "none")
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
            }
        }
        private void SetReachPressureCondition(string title, string para)
        {
            if (para.ToLower() != "none")
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
            }
        }
        private void SetFinishAutoProfileCondition(string title, string para)
        {
            if (para.ToLower() != "none")
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
            }
        }
        private void SetPressureStabilizeCondition(string title, string para)
        {
            if (para.ToLower() != "none")
            {
                _conditionCheckDic.Add(title, false);
                _conditionCheckItemDic.Add(title, para);
                //APC.SetStableParameters(para);
            }
        }
        public bool CheckExternalSensorCondition()
        {
            var key = "Wait For External Sensor";
            if (_conditionCheckDic.ContainsKey(key))
            {
                if (_conditionCheckItemDic.ContainsKey(key))
                {
                    var items = _conditionCheckItemDic[key].Split(',').ToList();
                    bool isMatch = true;
                    foreach (var item in items)
                    {
                        var sensorAndResult = item.Split('.');
                        if (sensorAndResult.Length > 1 && sensorAndResult[1].ToLower() != "none")
                        {
                            var sensorDevice = DEVICE.GetDevice<IoSensor>($"{Module}.{sensorAndResult[0]}");
                            if (sensorDevice == null)
                                sensorDevice = DEVICE.GetDevice<IoSensor>($"System.{sensorAndResult[0]}");
                            if (sensorDevice != null)
                            {
                                isMatch = sensorAndResult[1].ToLower() == "on" ? sensorDevice.Value : !sensorDevice.Value;
                            }

                            if (!isMatch)
                                break;
                        }
                    }

                    _conditionCheckDic[key] = isMatch;
                }

                if (_isExternalSensorConditionBypass)
                    _conditionCheckDic[key] = true;

                return _conditionCheckDic[key];
            }
            else
            {
                return true;
            }
        }
        public bool CheckTempStabilizeCondition()
        {
            var key = "Wait For Temperature Stablilize";

            return true;
        }
        public bool CheckReachTempCondition()
        {
            var key = "Wait For Reach Temperature";

            return true;

        }
        public bool CheckPressureStablilizeCondition()
        {
            var key = "Wait For Pressure Stablilize";
            if (_conditionCheckDic.ContainsKey(key))
            {
                //_conditionCheckDic[key] = APC.IsStable;
                if (_isPressureStabilizeConditionBypass)
                    _conditionCheckDic[key] = true;

                return _conditionCheckDic[key];
            }
            else
            {
                return true;
            }
        }
        public bool CheckReachPressureCondition()
        {
            var key = "Wait For Reach Pressure";
            if (_conditionCheckDic.ContainsKey(key))
            {
                if (_conditionCheckItemDic.ContainsKey(key))
                {
                    var itemArry = _conditionCheckItemDic[key].Split(',');
                    if (itemArry != null && itemArry.Length > 1)
                    {
                        float.TryParse(itemArry[1], out float pressure);
                        if (itemArry[0] == "WaitMoreThan")
                        {
                            //_conditionCheckDic[key] = APC.PressureFeedback > pressure;
                        }
                        else if (itemArry[0] == "WaitLessThan")
                        {
                            //_conditionCheckDic[key] = APC.PressureFeedback < pressure;
                        }
                    }
                }

                if (_isReachPressureConditionBypass)
                    _conditionCheckDic[key] = true;

                return _conditionCheckDic[key];
            }
            else
            {
                return true;
            }
        }
        public bool CheckFinishAutoProfileCondition()
        {
            var key = "Wait For Finish Auto Profile";
            if (_conditionCheckDic.ContainsKey(key))
            {
                if (_isFinishAutoProfileConditionBypass)
                    _conditionCheckDic[key] = true;

                return _conditionCheckDic[key];
            }
            else
            {
                return true;
            }
        }
        #endregion

        private bool SetBoatZAxisMotion(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            //if (AutoDoor.UpDownStatus != ASUpDownStatus.Down || AutoDoor.OpenCloseStatus != ASOpenCloseStatus.Open)
            //{
            //    (Singleton<EquipmentManager>.Instance.Modules[ModuleName.Boat] as BoatModule).BoatZAxisMoveFailedForInterlock.Set();
            //    return false;
            //}

            return true;
            //return BoatDevice.ZAxisMoveTo(param[0].ToString(), out reason);
        }

        private bool SetBoatRAxisMotion(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            return true;
        }

        private bool SetAutoShutterUp(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            bool.TryParse(param[0].ToString(), out bool isUp);
            //if (BoatDevice.BoatCurrentPosition != BoatPosition.HomePosition && BoatDevice.BoatCurrentPosition != BoatPosition.ProcessPosition)
            //{
            //    AutoShutter.AutoShutterMoveFailedForInterlock.Set();
            //    return false;
            //}
            //return AutoDoor.SetUp(isUp, out reason);
            return true;
        }

        private bool SetAutoShutterOpen(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            bool.TryParse(param[0].ToString(), out bool isOpen);
            var ZAxisDevice = DEVICE.GetDevice<IoFurnaceMotor>($"PM1.BoatElevatorServo");
            if (!ZAxisDevice.CheckServoAtPosition(BoatPosition.HomePosition.ToString()))
            {
                ShutterMoveFailedForInterlock.Set();
                return true;
            }
            return Shutter.SetOpen(isOpen, out reason);
        }

        private bool SetAutoShutterRotateOpen(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            bool.TryParse(param[0].ToString(), out bool isOpen);
            //if (BoatDevice.BoatCurrentPosition != BoatPosition.HomePosition && BoatDevice.BoatCurrentPosition != BoatPosition.ProcessPosition)
            //{
            //    AutoShutter.AutoShutterMoveFailedForInterlock.Set();
            //    return false;
            //}
            //return AutoDoor.SetShutterRotateOpen(isOpen, out reason);
            return true;
        }
        private bool SetCommand(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            var command = param[0].ToString();
            switch (command)
            {
                case "Hold":
                    _processRoutine.PauseRecipe();
                    break;
                case "Hold + Buzzer":
                    _processRoutine.PauseRecipe();
                    BuzzerOn();
                    break;
                case "Buzzer":
                    BuzzerOn();
                    break;
                case "Leak Check1":
                case "Leak Check2":
                case "Leak Check3":
                    int.TryParse(command.Replace("Leak Check", ""), out int index);
                    SetLeakCheckTableIndex(index);
                    break;
            }
            return true;
        }

        public bool SetSensorRecipeOK(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            SensorRecipeOK.Value = true;
            //SensorPROCManualOK.Value = false;
            return true;
        }

        public bool SetSensorPROCManualOK(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            SensorRecipeOK.Value = false;
            //SensorPROCManualOK.Value = true;
            return true;
        }

        public bool SetEditRecipeName(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            EditRecipeName = param[0].ToString();
            return true;
        }

        public bool SetEditRecipeStepName(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            EditRecipeStepName = param[0].ToString();
            return true;
        }

        private void BuzzerOn()
        {
            _signalTowerDevice.IsAutoSetLight = false;
            _signalTowerDevice.SetLight(LightType.Buzzer1, TowerLightStatus.On);
        }

        public bool CheckBoatState()
        {
            return (Singleton<EquipmentManager>.Instance.Modules[ModuleName.Boat] as BoatModule).IsReady;
        }

        //#region Temperature/Pressure Tolerance

        //#region Heater Tolerance Alarm

        //public bool CheckHeaterBottomToleranceAlaram()
        //{
        //    return Heater2.DeviceData.IsLspModeFeedBack ? Heater2.CheckToleranceAlarm() : Heater1.CheckToleranceAlarm();
        //}

        //public bool CheckHeaterCenterBottomToleranceAlaram()
        //{
        //    return Heater4.DeviceData.IsLspModeFeedBack ? Heater4.CheckToleranceAlarm() : Heater3.CheckToleranceAlarm();
        //}

        //public bool CheckHeaterCenterToleranceAlaram()
        //{
        //    return Heater6.DeviceData.IsLspModeFeedBack ? Heater6.CheckToleranceAlarm() : Heater5.CheckToleranceAlarm();
        //}

        //public bool CheckHeaterCenterTopToleranceAlaram()
        //{
        //    return Heater8.DeviceData.IsLspModeFeedBack ? Heater8.CheckToleranceAlarm() : Heater7.CheckToleranceAlarm();
        //}

        //public bool CheckHeaterTopToleranceAlaram()
        //{
        //    return Heater10.DeviceData.IsLspModeFeedBack ? Heater10.CheckToleranceAlarm() : Heater9.CheckToleranceAlarm();
        //}

        //public void SetHeaterBottomToleranceAlaram()
        //{
        //    if (Heater2.DeviceData.IsLspModeFeedBack)
        //        Heater2.SetToleranceAlarm();
        //    else
        //        Heater1.SetToleranceAlarm();
        //}

        //public void SetHeaterCenterBottomToleranceAlaram()
        //{
        //    if (Heater4.DeviceData.IsLspModeFeedBack)
        //        Heater4.SetToleranceAlarm();
        //    else
        //        Heater3.SetToleranceAlarm();
        //}

        //public void SetHeaterCenterToleranceAlaram()
        //{
        //    if (Heater6.DeviceData.IsLspModeFeedBack)
        //        Heater6.SetToleranceAlarm();
        //    else
        //        Heater5.SetToleranceAlarm();
        //}

        //public void SetHeaterCenterTopToleranceAlaram()
        //{
        //    if (Heater8.DeviceData.IsLspModeFeedBack)
        //        Heater8.SetToleranceAlarm();
        //    else
        //        Heater7.SetToleranceAlarm();
        //}

        //public void SetHeaterTopToleranceAlaram()
        //{
        //    if (Heater10.DeviceData.IsLspModeFeedBack)
        //        Heater10.SetToleranceAlarm();
        //    else
        //        Heater9.SetToleranceAlarm();
        //}

        //#endregion

        //#region Heater Tolerance Warning

        //public bool CheckHeaterBottomToleranceWarning()
        //{
        //    return Heater2.DeviceData.IsLspModeFeedBack ? Heater2.CheckToleranceWarning() : Heater1.CheckToleranceWarning();
        //}

        //public bool CheckHeaterCenterBottomToleranceWarning()
        //{
        //    return Heater4.DeviceData.IsLspModeFeedBack ? Heater4.CheckToleranceWarning() : Heater3.CheckToleranceWarning();
        //}

        //public bool CheckHeaterCenterToleranceWarning()
        //{
        //    return Heater6.DeviceData.IsLspModeFeedBack ? Heater6.CheckToleranceWarning() : Heater5.CheckToleranceWarning();
        //}

        //public bool CheckHeaterCenterTopToleranceWarning()
        //{
        //    return Heater8.DeviceData.IsLspModeFeedBack ? Heater8.CheckToleranceWarning() : Heater7.CheckToleranceWarning();
        //}

        //public bool CheckHeaterTopToleranceWarning()
        //{
        //    return Heater10.DeviceData.IsLspModeFeedBack ? Heater10.CheckToleranceWarning() : Heater9.CheckToleranceWarning();
        //}

        //public void SetHeaterBottomToleranceWarning()
        //{
        //    if (Heater2.DeviceData.IsLspModeFeedBack)
        //        Heater2.SetToleranceWarning();
        //    else
        //        Heater1.SetToleranceWarning();
        //}

        //public void SetHeaterCenterBottomToleranceWarning()
        //{
        //    if (Heater4.DeviceData.IsLspModeFeedBack)
        //        Heater4.SetToleranceWarning();
        //    else
        //        Heater3.SetToleranceWarning();
        //}

        //public void SetHeaterCenterToleranceWarning()
        //{
        //    if (Heater6.DeviceData.IsLspModeFeedBack)
        //        Heater6.SetToleranceWarning();
        //    else
        //        Heater5.SetToleranceWarning();
        //}

        //public void SetHeaterCenterTopToleranceWarning()
        //{
        //    if (Heater8.DeviceData.IsLspModeFeedBack)
        //        Heater8.SetToleranceWarning();
        //    else
        //        Heater7.SetToleranceWarning();
        //}

        //public void SetHeaterTopToleranceWarning()
        //{
        //    if (Heater10.DeviceData.IsLspModeFeedBack)
        //        Heater10.SetToleranceWarning();
        //    else
        //        Heater9.SetToleranceWarning();
        //}

        //#endregion

        //#region Pressure Tolerance Alarm

        ////public bool CheckPressureToleranceAlaram()
        ////{
        ////    return APC.CheckToleranceAlarm();
        ////}

        ////public void SetPressureToleranceAlaram()
        ////{
        ////    APC.SetToleranceAlarm();
        ////}

        //#endregion

        //#region Pressure Tolerance Warning

        ////public bool CheckPressureToleranceWarning()
        ////{
        ////    return APC.CheckToleranceWarning();
        ////}

        ////public void SetPressureToleranceWarning()
        ////{
        ////    APC.SetToleranceWarning();
        ////}

        //#endregion

        //#region Reset Tolerance

        //public void ResetToleranceAlarm()
        //{
        //    foreach (var heater in _heaters)
        //    {
        //        heater.Reset();
        //    }

        //    foreach (var key in _gasMFCs.Keys)
        //    {
        //        _gasMFCs[key].Reset();
        //    }

        //    //APC.Reset();
        //}

        //public void ResetToleranceAlarmChecker()
        //{
        //    foreach (var heater in _heaters)
        //    {
        //        heater.ResetAlarmChecker();
        //        heater.ResetWarningChecker();
        //    }

        //    foreach (var key in _gasMFCs.Keys)
        //    {
        //        _gasMFCs[key].ResetAlarmChecker();
        //        _gasMFCs[key].ResetWarningChecker();
        //    }

        //    //APC.ResetAlarmChecker();
        //    //APC.ResetWarningChecker();
        //}

        //#endregion

        //#endregion

        private bool SetN2PurgeMode(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            var mode = param[0].ToString();
            switch (mode)
            {
                case "Auto":
                    {
                        _N2PurgeMode = N2PurgeMode.Auto;
                        break;
                    }
                case "Manual_N2Purge":
                    {
                        _N2PurgeMode = N2PurgeMode.Manual_N2Purge;
                        break;
                    }
                case "Manual_ATM":
                    {
                        _N2PurgeMode = N2PurgeMode.Manual_ATM;
                        break;
                    }
                case "Manual_Maintenance":
                    {
                        _N2PurgeMode = N2PurgeMode.Manual_Maintenance;
                        break;
                    }
                case "Auto_Check":
                    {
                        _N2PurgeMode = N2PurgeMode.Auto_Check;
                        break;
                    }
            }
            return true;
        }
        private void SetHeaterControlParameters(object[] param)
        {
            //Mode参数;Correct Table;PID Table
            //"Heater;Parameter\\TempCorrection\\tempCorrect,2,Name2;Parameter\\TempPID\\tempPID,3,Name3"
            if (param == null || param.Length == 0)
            {
                EV.PostWarningLog(Module, $"Invalid heater parameter");
                return;
            }
            var paras = param[0].ToString().Split(';');
            if (paras == null || paras.Length < 3)
            {
                EV.PostWarningLog(Module, $"Invalid heater parameter");
                return;
            }

            var controlMode = paras[0];
            var correct = paras[1];
            var pid = paras[2];
            HeaterU.SetControlMode(controlMode);
            HeaterCU.SetControlMode(controlMode);
            HeaterC.SetControlMode(controlMode);
            HeaterCL.SetControlMode(controlMode);
            HeaterL.SetControlMode(controlMode);
            SetHeaterCorrectParameters(correct);
            SetHeaterPIDParameters(pid);
        }
        private void SetHeaterCorrectParameters(string correct)
        {
            HeaterU.SetCorrectParameters(correct);
            HeaterCU.SetCorrectParameters(correct);
            HeaterC.SetCorrectParameters(correct);
            HeaterCL.SetCorrectParameters(correct);
            HeaterL.SetCorrectParameters(correct);
        }
        private void SetHeaterPIDParameters(string pid)
        {
            HeaterU.SetPIDParameters(pid);
            HeaterCU.SetPIDParameters(pid);
            HeaterC.SetPIDParameters(pid);
            HeaterCL.SetPIDParameters(pid);
            HeaterL.SetPIDParameters(pid);
        }
        private bool SetCEXHEnable(object[] param)
        {
            if (param != null && param.Length > 0)
            {
                bool.TryParse(param[0].ToString(), out bool isEnable);
                _fFUs.ForEach(a => a.SetSwitch(isEnable));
            }
            return true;
        }
        private bool SetHTR1Enable(object[] param)
        {
            if (param != null && param.Length > 0)
            {
                bool.TryParse(param[0].ToString(), out bool isEnable);
                SC.SetItemValue($"PM1.IsHTR1Enable", isEnable);
                if (SC.GetStringValue("System.SetUp.ToolType") == "ELK")
                {
                    TrigGasLine1PowerOn?.SetTrigger(isEnable, out _);
                    TrigGasLine2PowerOn?.SetTrigger(isEnable, out _);
                    TrigGasLine3PowerOn?.SetTrigger(isEnable, out _);
                }
                TrigHeaterAllEnable?.SetTrigger(isEnable, out _);
            }
            return true;
        }
        private bool SetHTR2Enable(object[] param)
        {
            if (param != null && param.Length > 0)
            {
                bool.TryParse(param[0].ToString(), out bool isEnable);

                if (SC.GetStringValue("System.SetUp.ToolType") == "ELK")
                {
                    TrigGasLine4PowerOn?.SetTrigger(isEnable, out _);
                    TrigGasLine6PowerOn?.SetTrigger(isEnable, out _);
                    TrigGasLine7PowerOn?.SetTrigger(isEnable, out _);
                }
                SC.SetItemValue($"PM1.IsHTR2Enable", isEnable);
            }
            return true;
        }
        private bool SetHTR3Enable(object[] param)
        {
            if (param != null && param.Length > 0)
            {
                bool.TryParse(param[0].ToString(), out bool isEnable);
                SC.SetItemValue($"PM1.IsHTR3Enable", isEnable);
            }
            return true;
        }
    }
}