PunkHPX8/PunkHPX8_RT/Devices/Facilities/SystemFacilities.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Alarm;
using MECF.Framework.Common.Beckhoff.ModuleIO;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.TwinCat;
using System;
using System.Collections.Generic;

namespace PunkHPX8_RT.Devices.Facilities
{
    public class SystemFacilities : BaseDevice, IDevice
    {
        #region 常量

        private const string CDA_1_PRESSURE = "CDA_1_Pressure";
        private const string CDA_2_PRESSURE = "CDA_2_Pressure";
        private const string N2_1A_PRESSURE = "N2_1A_Pressure";
        private const string N2_1B_PRESSURE = "N2_1B_Pressure";
        private const string N2_2A_PRESSURE = "N2_2A_Pressure";
        private const string N2_2B_PRESSURE = "N2_2B_Pressure";
        private const string DI_WATER_PRESSURE = "DIWater_Pressure";
        private const string HOUSE_CHILLED_WATER_FLOW = "HouseChilledWaterFlow";
        private const string CDA_EXTERNAL_PRESSURE = "CDA_External_Pressure";
        private const string VACUUM_PRESSURE = "Vacuum_Pressure";
        private const string EXHAUST_PRESSURE1 = "Exhaust_Pressure1";
        private const string EXHAUST_PRESSURE2 = "Exhaust_Pressure2";
        private const string DIW_RETRUN_FLOW = "DIW_Return_Flow";
        private const string ERROR_MAX = "Error_Max";
        private const string ERROR_MIN = "Error_Min";
        private const string WARNING_MAX = "Warning_Max";
        private const string WARNING_MIN = "Warning_Min";
        private const string N2_1A_PRESSURE_VALUE = "Nitrogen1APressure";
        private const string N2_1B_PRESSURE_VALUE = "Nitrogen1BPressure";
        private const string N2_2A_PRESSURE_VALUE = "Nitrogen2APressure";
        private const string N2_2B_PRESSURE_VALUE = "Nitrogen2BPressure";
        private const string CDA_1_PRESSURE_VALUE = "CDA1Pressure";
        private const string CDA_2_PRESSURE_VALUE = "CDA2Pressure";
        private const string CDA_EXTERNAL_PRESSURE_VALUE = "ExternalCDAPressure";
        private const string DI_WATER_PRESSURE_VALUE = "DiWaterPressure";
        private const string HOUSE_CHILLED_WATER_PRESSURE_VALUE = "HouseChilledWaterPressure";
        private const string EXHAUST1_PRESSURE_VALUE = "Exhaust1Pressure";
        private const string EXHAUST2_PRESSURE_VALUE = "Exhaust2Pressure";
        private const string DIW_RETRUN_FLOW_VALUE = "DiwReturnFlow";
        private const string VACUUM_PRESSURE_VALUE = "VacuumPressure";


        private const string FFU_LOADER_ERROR = "FFULoaderError";
        private const string FFU_PROCESS_ERROR = "FFUProcessError";
        private const string FFU_LOADER_PRESSURE = "FFULoaderPressure";
        private const string FFU_PROCESS_PRESSURE = "FFUProcessPressure";
        private const string ARS_FLUID_DETECT = "ArsFluidDetect";
        private const string PROCESS_FLUID_DETECT = "ProcessFluidDetect";
        private const string SAMPLE_FLUID_DETECT = "SampleFluidDetect";
        private const string FACILITIES = "Facilities";
        private const string FACILITIES_DATA = "Facilities_Data";
        private const string N2_ENABLE = "N2Enable";
        private const string CDA_ENABLE = "CDAEnable";
        private const string EXTERNAL_CDA_ENABLE = "ExternalCDAEnable";
        private const string DI_WATER_ENABLE = "DiWaterEnable";
        private const string HOUSE_CHILLED_WATER_ENABLE = "HouseChilledWaterEnable";
        private const string VPW_DI_ENABLE = "VpwDiEnable";
        private const string DI_REPLEN_ENABLE = "DiReplenEnable";
        private const string DI_FILL_ENABLE = "DiFillEnable";
        private const string SRD_DI_ENABLE = "SrdDiwEnable";
        private const string SAMPLE_STATION_ENABLE = "SampleStationEnable";
        private const string FILTER_PURGE_ENABLE = "FilterPurgeEnable"; 
        private const string N2_BLANKET_PRESSURE_VALUE = "N2BlanketPressure";
        private const string N2_OVERFLOW_PRESSURE_VALUE = "N2OverflowPressure";
        private const string CLAMSHELL_CYLINDER_PRESSURE_VALUE = "ClamshellCylinderPressure";
        private const string TILT_CYLINDER_PRESSURE_VALUE = "TiltCylinderPressure";
        private const string FFU_PLATECELL_PRESSURE_ERROR = "FFUPlateCellPressureError";
        private const string FFU_CORRIDOR_PRESSURE_ERROR = "FFUCorridorPressureError";
        private const string FFU_PLATECELL_PRESSURE_PRESSURE = "FFUPlateCellPressure";
        private const string FFU_CORRIDOR_PRESSURE = "FFUCorridorPressure";
        #endregion

        #region 内部常量
        /// </summary>
        /// 定时器Job
        /// </summary>
        PeriodicJob _periodicJob = null;
        /// <summary>
        /// 数据集合
        /// </summary>
        private List<CommonLimitData> _facilitiesDataList = new List<CommonLimitData>();
        /// <summary>
        /// 数据字典
        /// </summary>
        private Dictionary<string, CommonLimitData> _facilitiesDataDic = new Dictionary<string, CommonLimitData>();
        /// <summary>
        /// N2可用性
        /// </summary>
        private bool _n2Enabled = false;
        /// <summary>
        /// CDA可用性
        /// </summary>
        private bool _cdaEnable = false;
        /// <summary>
        /// External CDA可用性
        /// </summary>
        private bool _externalCDAEnable = false;
        /// <summary>
        /// DI Water 可用性
        /// </summary>
        private bool _diWaterEnable = false;
        /// <summary>
        /// House Chilled Water可用性
        /// </summary>
        private bool _houseChilledWaterEnable = false;
        /// <summary>
        /// DI Replen可用性
        /// </summary>
        private bool _diReplenEnable = false;
        /// <summary>
        /// DI Fill可用性
        /// </summary>
        private bool _diFillEnable = false;
        /// <summary>
        /// Srd Di可用性
        /// </summary>
        private bool _srdDiEnable = false;
        /// <summary>
        /// Filter Purge可用性
        /// </summary>
        private bool _filterPurgeEnable = false;
        /// <summary>
        /// N2 Blanket 压力
        /// </summary>
        private double _n2BlaketPressure = 0;
        /// <summary>
        /// N2 Overflow 压力
        /// </summary>
        private double _n2OverflowPressure = 0;
        /// <summary>
        /// clamshellCylinder 压力
        /// </summary>
        private double _clamshellCylinderPressure = 0;
        /// <summary>
        /// tiltCylinder 压力
        /// </summary>
        private double _tiltCylinderPressure = 0;
        /// <summary>
        /// 变量是否初始化字典
        /// </summary>
        private Dictionary<string, bool> _variableInitializeDic = new Dictionary<string, bool>();

        #region Sample
        /// <summary>
        /// Sample Enable
        /// </summary>
        private bool _sampleEnable = false;
        /// <summary>
        /// 开始采样时间
        /// </summary>
        private DateTime _sampleStartime;
        /// <summary>
        /// 是否正在采样
        /// </summary>
        private bool _isSammpleing = false;

        #endregion

        #region FFU
        /// <summary>
        /// Loader FFU Error
        /// </summary>
        private bool _ffuLoaderError = false;
        /// <summary>
        /// Process FFU Error
        /// </summary>
        private bool _ffuProcessError = false;
        /// <summary>
        /// Loader FFU Pressure
        /// </summary>
        private double _ffuLoaderPressure;
        /// <summary>
        /// Process FFU Pressure
        /// </summary>
        private double _ffuProcessPressure;
        #endregion

        #region Fluid
        /// <summary>
        /// ARS Fluid Detect
        /// </summary>
        private bool _arsFluidDetect;
        /// <summary>
        /// Process Fluid Detect
        /// </summary>
        private bool _processFluidDetect;
        /// <summary>
        /// Sample Fluid Detect
        /// </summary>
        private bool _sampleFluidDetect;
        #endregion

        #region Counter
        /// <summary>
        /// 
        /// </summary>
        private CounterFlowData _diReplenFlowCounterData = new CounterFlowData();
        #endregion

        #endregion

        #region 属性
        /// <summary>
        /// 冰却水可用性
        /// </summary>
        public bool HouseChilledWaterEnable { get { return _houseChilledWaterEnable; } }
        /// <summary>
        /// N2可用性
        /// </summary>
        public bool N2Enable { get { return _n2Enabled; } }
        /// <summary>
        /// CDA可用性
        /// </summary>
        public bool CDAEnable { get { return _cdaEnable; } }
        /// <summary>
        /// SRD DI 可用性
        /// </summary>
        public bool SrdDiEnable { get { return _srdDiEnable; } }
        /// <summary>
        /// DI Replen Enable
        /// </summary>
        public bool DIReplenEnable { get { return _diReplenEnable; } }
        /// <summary>
        /// 所有io变量是否初始化
        /// </summary>
        public bool IOInitialized { get { return AllIoVariableInitialized(); } }
        /// <summary>
        /// SampleFluidDetect
        /// </summary>
        public bool SampleFluidDetect { get { return _sampleFluidDetect; } }
        /// <summary>
        /// Di Fill Enable
        /// </summary>
        public bool DIFillEnable { get { return _diFillEnable; } }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public SystemFacilities() : base("System", FACILITIES, FACILITIES, FACILITIES)
        {
        }
        /// <summary>
        /// 定时器
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            //if (_isSammpleing)
            //{
            //    int sampleAutoDisableTime = SC.GetValue<int>("Facilities.SampleAutoDisableTime");
            //    if ((DateTime.Now - _sampleStartime).TotalSeconds >= sampleAutoDisableTime)
            //    {
            //        SampleDisableOperation("", null);
            //    }
            //}                      
            return true;
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public bool Initialize()
        {
            InitialData();
            SubscribeValueAction();
            InitializeOperation();
            //_periodicJob = new PeriodicJob(200, OnTimer, $"{Module}.OnTimer", true);

            return true;
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitialData()
        {
            _facilitiesDataList.Add(InitialFacilitiesData(CDA_1_PRESSURE));
            _facilitiesDataDic[CDA_1_PRESSURE_VALUE] = _facilitiesDataList[0];
            _facilitiesDataList.Add(InitialFacilitiesData(CDA_2_PRESSURE));
            _facilitiesDataDic[CDA_2_PRESSURE_VALUE] = _facilitiesDataList[1];
            _facilitiesDataList.Add(InitialFacilitiesData(N2_1A_PRESSURE));
            _facilitiesDataDic[N2_1A_PRESSURE_VALUE] = _facilitiesDataList[2];
            _facilitiesDataList.Add(InitialFacilitiesData(N2_1B_PRESSURE));
            _facilitiesDataDic[N2_1B_PRESSURE_VALUE] = _facilitiesDataList[3];
            _facilitiesDataList.Add(InitialFacilitiesData(N2_2A_PRESSURE));
            _facilitiesDataDic[N2_2A_PRESSURE_VALUE] = _facilitiesDataList[4];
            _facilitiesDataList.Add(InitialFacilitiesData(N2_2B_PRESSURE));
            _facilitiesDataDic[N2_2B_PRESSURE_VALUE] = _facilitiesDataList[5];
            _facilitiesDataList.Add(InitialFacilitiesData(DI_WATER_PRESSURE));
            _facilitiesDataDic[DI_WATER_PRESSURE_VALUE] = _facilitiesDataList[6];
            _facilitiesDataList.Add(InitialFacilitiesData(HOUSE_CHILLED_WATER_FLOW));
            _facilitiesDataDic[HOUSE_CHILLED_WATER_FLOW] = _facilitiesDataList[7];
            _facilitiesDataList.Add(InitialFacilitiesData(CDA_EXTERNAL_PRESSURE));
            _facilitiesDataDic[CDA_EXTERNAL_PRESSURE_VALUE] = _facilitiesDataList[8];
            _facilitiesDataList.Add(InitialFacilitiesData(VACUUM_PRESSURE));
            _facilitiesDataDic[VACUUM_PRESSURE_VALUE] = _facilitiesDataList[9];
            _facilitiesDataList.Add(InitialFacilitiesData(EXHAUST_PRESSURE1));
            _facilitiesDataDic[EXHAUST1_PRESSURE_VALUE] = _facilitiesDataList[10];
            _facilitiesDataList.Add(InitialFacilitiesData(EXHAUST_PRESSURE2));
            _facilitiesDataDic[EXHAUST2_PRESSURE_VALUE] = _facilitiesDataList[11];
            _facilitiesDataList.Add(InitialFacilitiesData(DIW_RETRUN_FLOW));
            _facilitiesDataDic[DIW_RETRUN_FLOW_VALUE] = _facilitiesDataList[12];

            DATA.Subscribe($"{Module}.{Name}.{FACILITIES_DATA}", () => _facilitiesDataList, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_ENABLE}", () => _n2Enabled, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{CDA_ENABLE}", () => _cdaEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{EXTERNAL_CDA_ENABLE}", () => _externalCDAEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{DI_WATER_ENABLE}", () => _diWaterEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{HOUSE_CHILLED_WATER_ENABLE}", () => _houseChilledWaterEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{DI_FILL_ENABLE}", () => _diFillEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{DI_REPLEN_ENABLE}", () => _diReplenEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{SRD_DI_ENABLE}", () => _srdDiEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{FILTER_PURGE_ENABLE}", () => _filterPurgeEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_BLANKET_PRESSURE_VALUE}", () => _n2BlaketPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_OVERFLOW_PRESSURE_VALUE}", () => _n2OverflowPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{CLAMSHELL_CYLINDER_PRESSURE_VALUE}", () => _clamshellCylinderPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{TILT_CYLINDER_PRESSURE_VALUE}", () => _tiltCylinderPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{SAMPLE_STATION_ENABLE}", () => _sampleEnable, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{FFU_LOADER_ERROR}", () => _ffuLoaderError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{FFU_PROCESS_ERROR}", () => _ffuProcessError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{FFU_LOADER_PRESSURE}", () => _ffuLoaderPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{FFU_PROCESS_PRESSURE}", () => _ffuProcessPressure, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{ARS_FLUID_DETECT}", () => _arsFluidDetect, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{PROCESS_FLUID_DETECT}", () => _processFluidDetect, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{SAMPLE_FLUID_DETECT}", () => _sampleFluidDetect, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{CDA_1_PRESSURE_VALUE}", () => _facilitiesDataDic[CDA_1_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{CDA_2_PRESSURE_VALUE}", () => _facilitiesDataDic[CDA_2_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_1A_PRESSURE_VALUE}", () => _facilitiesDataDic[N2_1A_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_1B_PRESSURE_VALUE}", () => _facilitiesDataDic[N2_1B_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_2A_PRESSURE_VALUE}", () => _facilitiesDataDic[N2_2A_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{N2_2B_PRESSURE_VALUE}", () => _facilitiesDataDic[N2_2B_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{DI_WATER_PRESSURE_VALUE}", () => _facilitiesDataDic[DI_WATER_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{HOUSE_CHILLED_WATER_FLOW}", () => _facilitiesDataDic[HOUSE_CHILLED_WATER_FLOW].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{CDA_EXTERNAL_PRESSURE_VALUE}", () => _facilitiesDataDic[CDA_EXTERNAL_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{VACUUM_PRESSURE_VALUE}", () => _facilitiesDataDic[VACUUM_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{EXHAUST1_PRESSURE_VALUE}", () => _facilitiesDataDic[EXHAUST1_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{EXHAUST2_PRESSURE_VALUE}", () => _facilitiesDataDic[EXHAUST2_PRESSURE_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.{Name}.{DIW_RETRUN_FLOW_VALUE}", () => _facilitiesDataDic[DIW_RETRUN_FLOW_VALUE].Value, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Facilities数据对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private CommonLimitData InitialFacilitiesData(string name)
        {
            CommonLimitData facilitiesData = new CommonLimitData();
            facilitiesData.MaxError = SC.GetValue<double>($"{FACILITIES}.{name}.{ERROR_MAX}");
            facilitiesData.MinError = SC.GetValue<double>($"{FACILITIES}.{name}.{ERROR_MIN}");
            facilitiesData.MaxWarning = SC.GetValue<double>($"{FACILITIES}.{name}.{WARNING_MAX}");
            facilitiesData.MinWarning = SC.GetValue<double>($"{FACILITIES}.{name}.{WARNING_MIN}");
            return facilitiesData;
        }
        /// <summary>
        /// 订阅变量数值发生变化
        /// </summary>
        private void SubscribeValueAction()
        {
            BeckhoffIoSubscribeUpdateVariable(N2_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(CDA_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(EXTERNAL_CDA_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(DI_WATER_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(HOUSE_CHILLED_WATER_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(DI_REPLEN_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(DI_FILL_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(N2_1A_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(N2_1B_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(N2_2A_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(N2_2B_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(CDA_1_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(CDA_2_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(CDA_EXTERNAL_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(DI_WATER_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(HOUSE_CHILLED_WATER_FLOW);
            BeckhoffIoSubscribeUpdateVariable(HOUSE_CHILLED_WATER_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(EXHAUST1_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(EXHAUST2_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(DIW_RETRUN_FLOW_VALUE);
            BeckhoffIoSubscribeUpdateVariable(VACUUM_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(N2_BLANKET_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(N2_OVERFLOW_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(CLAMSHELL_CYLINDER_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(TILT_CYLINDER_PRESSURE_VALUE);
            BeckhoffIoSubscribeUpdateVariable(SRD_DI_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(SAMPLE_STATION_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(FILTER_PURGE_ENABLE);
            BeckhoffIoSubscribeUpdateVariable(FFU_LOADER_ERROR);
            BeckhoffIoSubscribeUpdateVariable(FFU_PROCESS_ERROR);
            BeckhoffIoSubscribeUpdateVariable(FFU_LOADER_PRESSURE);
            BeckhoffIoSubscribeUpdateVariable(FFU_PROCESS_PRESSURE);
            BeckhoffIoSubscribeUpdateVariable(ARS_FLUID_DETECT);
            BeckhoffIoSubscribeUpdateVariable(PROCESS_FLUID_DETECT);
            BeckhoffIoSubscribeUpdateVariable(SAMPLE_FLUID_DETECT);
        }

        /// <summary>
        /// 订阅IO变量
        /// </summary>
        /// <param name="variable"></param>
        private void BeckhoffIoSubscribeUpdateVariable(string variable)
        {
            _variableInitializeDic[variable] = false;
            IOModuleManager.Instance.SubscribeModuleVariable(Name, variable, UpdateVariableValue);
        }
        /// <summary>
        /// 初始化操作
        /// </summary>
        private void InitializeOperation()
        {
            OP.Subscribe($"{Module}.{Name}.N2Enable", N2EnableOperation);
            OP.Subscribe($"{Module}.{Name}.N2Disable", N2DisableOperation);
            OP.Subscribe($"{Module}.{Name}.CDAEnable", CDAEnableOperation);
            OP.Subscribe($"{Module}.{Name}.CDADisable", CDADisableOperation);
            OP.Subscribe($"{Module}.{Name}.ExternalCDAEnable", ExternalCDAEnableOperation);
            OP.Subscribe($"{Module}.{Name}.ExternalCDADisable", ExternalCDADisableOperation);
            OP.Subscribe($"{Module}.{Name}.DiWaterEnable", DiWaterEnableOperation);
            OP.Subscribe($"{Module}.{Name}.DiWaterDisable", DiWaterDisableOperation);
            OP.Subscribe($"{Module}.{Name}.HouseChilledWaterEnable", HouseChilledWaterEnableOperation);
            OP.Subscribe($"{Module}.{Name}.HouseChilledWaterDisable", HouseChilledWaterDisableOperation);
            OP.Subscribe($"{Module}.{Name}.DiFillEnable", DiFillEnableOperation);
            OP.Subscribe($"{Module}.{Name}.DiFillDisable", DiFillDisableOperation);
            OP.Subscribe($"{Module}.{Name}.DiReplenEnable", DiReplenEnableOperation);
            OP.Subscribe($"{Module}.{Name}.DiReplenDisable", DiReplenDisableOperation);
            OP.Subscribe($"{Module}.{Name}.SrdDiwEnable", SrdDiEnableOperation);
            OP.Subscribe($"{Module}.{Name}.SrdDiwDisable", SrdDiDisableOperation);
            OP.Subscribe($"{Module}.{Name}.FilterPurgeEnable", FilterPurgeEnableOperation);
            OP.Subscribe($"{Module}.{Name}.FilterPurgeDisable", FilterPurgeDisableOperation);
            OP.Subscribe($"{Module}.{Name}.SampleStationEnable", SampleEnableOperation);
            OP.Subscribe($"{Module}.{Name}.SampleStationDisable", SampleDisableOperation);
        }
        /// 更新变量数值
        /// </summary>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        private void UpdateVariableValue(string variable, object value)
        {
            
            if (_variableInitializeDic.ContainsKey(variable) && !_variableInitializeDic[variable])
            {
                _variableInitializeDic[variable] = true;
            }
            switch (variable)
            {
                case N2_ENABLE:
                    _n2Enabled = (bool)value;
                    break;
                case CDA_ENABLE:
                    _cdaEnable = (bool)value;
                    break;
                case EXTERNAL_CDA_ENABLE:
                    _externalCDAEnable = (bool)value;
                    break;
                case DI_WATER_ENABLE:
                    _diWaterEnable = (bool)value;
                    break;
                case HOUSE_CHILLED_WATER_ENABLE:
                    _houseChilledWaterEnable = (bool)value;
                    break;
                case DI_FILL_ENABLE:
                    _diFillEnable = (bool)value;
                    break;
                case DI_REPLEN_ENABLE:
                    _diReplenEnable = (bool)value;
                    break;
                case N2_1A_PRESSURE_VALUE:
                case N2_2A_PRESSURE_VALUE:
                case N2_1B_PRESSURE_VALUE:
                case N2_2B_PRESSURE_VALUE:
                case CDA_1_PRESSURE_VALUE:
                case CDA_2_PRESSURE_VALUE:
                case CDA_EXTERNAL_PRESSURE_VALUE:
                case DI_WATER_PRESSURE_VALUE:
                case HOUSE_CHILLED_WATER_FLOW:
                case EXHAUST1_PRESSURE_VALUE:
                case EXHAUST2_PRESSURE_VALUE:
                case VACUUM_PRESSURE_VALUE:
                case DIW_RETRUN_FLOW_VALUE:
                    _facilitiesDataDic[variable].Value = (double)value;
                    break;
                case N2_BLANKET_PRESSURE_VALUE:
                    _n2BlaketPressure = (double)value;
                    break;
                case N2_OVERFLOW_PRESSURE_VALUE:
                    _n2OverflowPressure = (double)value;
                    break;
                case CLAMSHELL_CYLINDER_PRESSURE_VALUE:
                    _clamshellCylinderPressure = (double)value;
                    break;
                case TILT_CYLINDER_PRESSURE_VALUE:
                    _tiltCylinderPressure = (double)value;
                    break;
                case SAMPLE_STATION_ENABLE:
                    _sampleEnable = (bool)value;
                    break;
                case SRD_DI_ENABLE:
                    _srdDiEnable = (bool)value;
                    break;
                case FILTER_PURGE_ENABLE:
                    _filterPurgeEnable = (bool)value;
                    break;
                case FFU_LOADER_ERROR:
                    _ffuLoaderError = (bool)value;
                    break;
                case FFU_PROCESS_ERROR:
                    _ffuProcessError = (bool)value;
                    break;
                case FFU_LOADER_PRESSURE:
                    _ffuLoaderPressure = (double)value;
                    break;
                case FFU_PROCESS_PRESSURE:
                    _ffuProcessPressure = (double)value;
                    break;
                case ARS_FLUID_DETECT:
                    _arsFluidDetect = (bool)value;
                    break;
                case SAMPLE_FLUID_DETECT:
                    _sampleFluidDetect = (bool)value;
                    if (!_sampleFluidDetect)
                    {
                        LOG.WriteLog(eEvent.WARN_Sensor, Module, "SampleFluidDetect is Activate");
                        if (_sampleEnable) SampleDisableOperation("", null);
                        if (_filterPurgeEnable) FilterPurgeDisableOperation("", null);
                    }
                    break;
                case PROCESS_FLUID_DETECT:
                    _processFluidDetect = (bool)value;
                    if (!_processFluidDetect)
                    {
                        LOG.WriteLog(eEvent.WARN_Sensor, Module, "ProcessFluidDetect is Activate");
                        AlarmListManager.Instance.AddWarn(Module, "ProcessFluidDetect", $"ProcessFluidDetect is Activate");
                    }
                    break;
            }
        }


        /// <summary>
        /// 是否所有IO变量初始化完成
        /// </summary>
        /// <returns></returns>
        private bool AllIoVariableInitialized()
        {
            foreach (string item in _variableInitializeDic.Keys)
            {
                if (!_variableInitializeDic[item])
                {
                    //LOG.WriteLog(eEvent.ERR_DRYER, Module, $"{item} is not initialized");
                    return false;
                }
            }
            return true;
        }

        #region 指令
        /// <summary>
        /// N2 Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool N2EnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{N2_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// N2 Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool N2DisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{N2_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// CDA Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool CDAEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{CDA_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// CDA Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CDADisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{CDA_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// External CDA Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ExternalCDAEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{EXTERNAL_CDA_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// External CDA Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ExternalCDADisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{EXTERNAL_CDA_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// DI Water Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DiWaterEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_WATER_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// DI Water Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DiWaterDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_WATER_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// House Chilled Water Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool HouseChilledWaterEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{HOUSE_CHILLED_WATER_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// House Chilled Water Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool HouseChilledWaterDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{HOUSE_CHILLED_WATER_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// DI Fill Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DiFillEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_FILL_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// Di Fill Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool DiFillDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_FILL_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// DI Replen Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool DiReplenEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_REPLEN_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// DI Replen Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool DiReplenDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{DI_REPLEN_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// srd DI Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool SrdDiEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{SRD_DI_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// Loader DI Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool SrdDiDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{SRD_DI_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// Filter Purge Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool FilterPurgeEnableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{FILTER_PURGE_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, true);
            }
            return true;
        }
        /// <summary>
        /// Filter Purge Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool FilterPurgeDisableOperation(string cmd, object param)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{FILTER_PURGE_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, false);
            }
            return true;
        }
        /// <summary>
        /// Sample Enable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool SampleEnableOperation(string cmd, object param)
        {
            _isSammpleing = true;
            _sampleStartime = DateTime.Now;
            SampeOperation(true);
            return true;
        }
        /// <summary>
        /// Sample Disable
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public bool SampleDisableOperation(string cmd, object param)
        {
            _isSammpleing = false;
            SampeOperation(false);
            return true;
        }
        /// <summary>
        /// Sample操作
        /// </summary>
        /// <param name="enable"></param>
        private void SampeOperation(bool enable)
        {
            string ioName = BeckhoffModuleIOManager.Instance.GetIoNameByInnerModuleName($"{Name}.{SAMPLE_STATION_ENABLE}");
            if (!string.IsNullOrEmpty(ioName))
            {
                IOModuleManager.Instance.WriteIoValue(ioName, enable);
            }
           
        }
        #endregion

        /// <summary>
        /// 检验Exhaust
        /// </summary>
        /// <returns></returns>
        public (bool result, string reason) CheckExhaustResult()
        {
            return CheckPressureData(EXHAUST1_PRESSURE_VALUE);
        }
        /// <summary>
        /// 检验冷却水
        /// </summary>
        /// <returns></returns>
        public (bool result, string reason) CheckHouseChilledWaterResult()
        {
            return CheckPressureData(HOUSE_CHILLED_WATER_FLOW);
        }
        /// <summary>
        /// 检验CDA
        /// </summary>
        /// <returns></returns>
        public (bool result, string reason) CheckCDA()
        {
            if (!CDAEnable)
            {
                return (false, "CDA is disable");
            }
            else
            {
                var cda1Result = CheckPressureData(CDA_1_PRESSURE_VALUE);
                if (!cda1Result.result)
                {
                    return cda1Result;
                }
                var cda2Result = CheckPressureData(CDA_2_PRESSURE_VALUE);
                if (!cda2Result.result)
                {
                    return cda2Result;
                }
            }
            return (true, "");
        }

        /// <summary>
        /// 检验CDA和N2
        /// </summary>
        /// <returns></returns>
        public (bool result, string reason) CheckCDAN2()
        {
            if (!CDAEnable)
            {
                return (false, "CDA is disable");
            }
            else
            {
                var cda1Result = CheckPressureData(CDA_1_PRESSURE_VALUE);
                if (!cda1Result.result)
                {
                    return cda1Result;
                }
                var cda2Result = CheckPressureData(CDA_2_PRESSURE_VALUE);
                if (!cda2Result.result)
                {
                    return cda2Result;
                }
            }

            if (!N2Enable)
            {
                return (false, "N2 is disable");
            }
            else
            {
                var n21AResult = CheckPressureData(N2_1A_PRESSURE_VALUE);
                if (!n21AResult.result)
                {
                    return n21AResult;
                }
                var n21BResult = CheckPressureData(N2_1B_PRESSURE_VALUE);
                if (!n21BResult.result)
                {
                    return n21BResult;
                }
                var n22AResult = CheckPressureData(N2_2A_PRESSURE_VALUE);
                if (!n22AResult.result)
                {
                    return n22AResult;
                }
                var n22BResult = CheckPressureData(N2_2B_PRESSURE_VALUE);
                if (!n22BResult.result)
                {
                    return n22BResult;
                }
            }
            return (true, "");
        }
        /// <summary>
        /// 检验CDA N2以及Vacuum状态
        /// </summary>
        /// <returns></returns>
        public (bool result, string reason) CheckCDAN2AndVacuum()
        {
            if (!CDAEnable)
            {
                return (false, "CDA is disable");
            }
            else
            {
                var cda1Result = CheckPressureData(CDA_1_PRESSURE_VALUE);
                if (!cda1Result.result)
                {
                    return cda1Result;
                }
                var cda2Result = CheckPressureData(CDA_2_PRESSURE_VALUE);
                if (!cda2Result.result)
                {
                    return cda2Result;
                }
            }

            if (!N2Enable)
            {
                return (false, "N2 is disable");
            }
            else
            {
                var n21AResult = CheckPressureData(N2_1A_PRESSURE_VALUE);
                if (!n21AResult.result)
                {
                    return n21AResult;
                }
                var n21BResult = CheckPressureData(N2_1B_PRESSURE_VALUE);
                if (!n21BResult.result)
                {
                    return n21BResult;
                }
                var n22AResult = CheckPressureData(N2_2A_PRESSURE_VALUE);
                if (!n22AResult.result)
                {
                    return n22AResult;
                }
                var n22BResult = CheckPressureData(N2_2B_PRESSURE_VALUE);
                if (!n22BResult.result)
                {
                    return n22BResult;
                }
                var vacuumResult = CheckPressureData(VACUUM_PRESSURE_VALUE);
                if (!vacuumResult.result)
                {
                    return vacuumResult;
                }
            }
            return (true, "");
        }

        /// <summary>
        /// 检验压力
        /// </summary>
        /// <param name="pressureName"></param>
        /// <returns></returns>
        private (bool result, string reason) CheckPressureData(string pressureName)
        {
            if (_facilitiesDataDic.ContainsKey(pressureName))
            {
                CommonLimitData facilitiesData = _facilitiesDataDic[(pressureName)];
                if (facilitiesData.IsError)
                {
                    return (false, $"{pressureName} data {facilitiesData.Value} is error value");
                }
                else if (facilitiesData.IsWarning)
                {
                    return (true, $"{pressureName} data {facilitiesData.Value} is warning");
                }
                else
                {
                    return (true, "");
                }
            }
            else
            {
                return (false, $"{pressureName} not in dictionary");
            }
        }
        /// <summary>
        /// 获取Common Limit 数据
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public CommonLimitData GetCommonLimitDataByName(string name)
        {
            return _facilitiesDataDic.ContainsKey(name) ? _facilitiesDataDic[name] : null;
        }

        #region IDevice接口
        public void Monitor()
        {
        }

        public void Reset()
        {
        }

        public void Terminate()
        {
        }
        #endregion
    }
}