Triton160/Common/Core/RT/Device/Unit/IoPump.cs

using System;
using System.Xml;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;

namespace Aitex.Core.RT.Device.Unit
{
    public class IoPump : BaseDevice, IDevice
    {
        [Subscription(AITPumpProperty.EnableDryPump)]
        public bool IsDryPumpEnabled
        {
            get
            {
                return _scEnableDryPump == null || _scEnableDryPump.Value;
            }
        }
        [Subscription(AITPumpProperty.EnableWaterFlow)]
        public bool EnableWaterFlow
        {
            get
            {
                return _scEnableWaterFlow != null && _scEnableWaterFlow.Value;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowWarning)]
        public bool WaterFlowWarning
        {
            get
            {
                return _checkWaterFlowWarning.Result;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowAlarm)]
        public bool WaterFlowAlarm
        {
            get
            {
                if (IsEnableWaterFlowAlarm)
                    return _diWaterFlowAlarm.Value;
                else
                    return false;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowAlarmSetPoint)]
        public bool WaterFlowAlarmSetPoint
        {
            get
            {
                return _doWaterFlowAlarm != null && _doWaterFlowAlarm.Value;
            }
            set
            {
                if (_doWaterFlowAlarm != null)
                {
                    string reason;
                    if (!_doWaterFlowAlarm.SetValue(value, out reason))
                    {
                        LOG.Write(reason);
                    }
                }
            }
        }
        [Subscription(AITPumpProperty.WaterFlowWarningTime)]
        public float WaterFlowWarningTime
        {
            get
            {
                return _scWaterFlowOutOfToleranceWarningTime == null ? 0 : (float)_scWaterFlowOutOfToleranceWarningTime.Value;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowAlarmTime)]
        public float WaterFlowAlarmTime
        {
            get
            {
                return _scWaterFlowOutOfToleranceAlarmTime == null ? 0 : (float)_scWaterFlowOutOfToleranceAlarmTime.Value;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowValue)]
        public double WaterFlowValue
        {
            get
            {
                return _aiWaterFlow == null ? 0 : _aiWaterFlow.Value;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowMinValue)]
        public double WaterFlowMinValue
        {
            get
            {
                return _scWaterFlowMinValue == null ? 0 : (float)_scWaterFlowMinValue.Value;
            }
        }
        [Subscription(AITPumpProperty.WaterFlowMaxValue)]
        public double WaterFlowMaxValue
        {
            get
            {
                return _scWaterFlowMaxValue == null ? 0 : (float)_scWaterFlowMaxValue.Value;
            }
        }

        [Subscription(AITPumpProperty.EnableN2Pressure)]
        public bool EnableN2Pressure
        {
            get
            {
                if (_scEnableN2Pressure == null || _scN2PressureMinValue == null || _scN2PressureMaxValue == null ||
                    _scN2PressureOutOfToleranceWarningTime == null || _scN2PressureOutOfToleranceAlarmTime == null)
                    return false;

                return _scEnableN2Pressure != null && _scEnableN2Pressure.Value;
            }
        }

        [Subscription(AITPumpProperty.N2PressureWarning)]
        public bool N2PressureWarning
        {
            get
            {
                return _checkN2PressureWarning.Result;
            }
        }

        [Subscription(AITPumpProperty.N2PressureValue)]
        public float N2PressureValue
        {
            get
            {
                return _aiN2Pressure == null ? 0 : _aiN2Pressure.Value;
            }
        }
        [Subscription(AITPumpProperty.N2PressureWarningTime)]
        public float N2PressureWarningTime
        {
            get
            {
                return _scN2PressureOutOfToleranceWarningTime == null ? 0 : (float)_scN2PressureOutOfToleranceWarningTime.Value;
            }
        }
        [Subscription(AITPumpProperty.N2PressureAlarmTime)]
        public float N2PressureAlarmTime
        {
            get
            {
                return _scN2PressureOutOfToleranceAlarmTime == null ? 0 : (float)_scN2PressureOutOfToleranceAlarmTime.Value;
            }
        }
        [Subscription(AITPumpProperty.N2PressureMinValue)]
        public float N2PressureMinValue
        {
            get
            {
                return _scN2PressureMinValue == null ? 0 : (float)_scN2PressureMinValue.Value;
            }
        }
        [Subscription(AITPumpProperty.N2PressureMaxValue)]
        public float N2PressureMaxValue
        {
            get
            {
                return _scN2PressureMaxValue == null ? 0 : (float)_scN2PressureMaxValue.Value;
            }
        }
        [Subscription(AITPumpProperty.N2PressureAlarm)]
        public bool N2PressureAlarm
        {
            get
            {
                return _diN2Alarm.Value;
            }
        }

        [Subscription(AITPumpProperty.N2PressureAlarmSetPoint)]
        public bool N2PressureAlarmSetPoint
        {
            get
            {
                return _doN2PressureAlarm != null && _doN2PressureAlarm.Value;
            }
            set
            {
                if (_doN2PressureAlarm != null)
                {
                    string reason;
                    if (!_doN2PressureAlarm.SetValue(value, out reason))
                    {
                        LOG.Write(reason);
                    }
                }
            }
        }

        public int LocalRemoteMode
        {
            get
            {
                return _doLocalRemote.Value ? 1 : 0;
            }
        }

        public bool HasError
        {
            get
            {
                return IsPumpTempAlarm || IsPumpOverloadAlarm;
            }
        }

        public bool HasWarning
        {
            get
            {
                return IsPumpN2FlowWarning || IsPumpTempWarning || IsWaterFlowWarning;
            }
        }

        [Subscription(AITPumpProperty.IsRunning)]
        public bool IsRunning
        {
            get
            {
                if (_diRunning != null)
                    return _diRunning.Value;

                if (_diPowerOn != null)
                    return _diPowerOn.Value;

                return true; //默认常开
            }
        }

        public bool IsWarning
        {
            get
            {
                return _diWarning != null && _diWarning.Value;
            }
        }

        public bool IsPumpTempWarning
        {
            get
            {
                return _diPumpTempWaring != null && _diPumpTempWaring.Value;
            }
        }

        public bool IsPumpN2FlowWarning
        {
            get
            {
                return _diPumpN2FlowWarning != null && _diPumpN2FlowWarning.Value;
            }
        }

        public bool IsError
        {
            get
            {
                return _diError != null && _diError.Value;
            }
        }

        public bool IsWaterFlowWarning
        {
            get
            {
                return _diWaterFlowWarning != null && _diWaterFlowWarning.Value;
            }
        }

        public bool IsPumpTempAlarm
        {
            get
            {
                return _diPumpTempAlarm != null && _diPumpTempAlarm.Value;
            }
        }

        public bool IsPumpOverloadAlarm
        {
            get
            {
                return _diOverloadAlarm != null && _diOverloadAlarm.Value;
            }
        }

        public double H2OSensorMassWarningThreshold
        {
            get
            {
                return _aiH2OSensorMassWarningThreshold == null ? 0 : _aiH2OSensorMassWarningThreshold.Value;
            }

            set
            {
                if (_scH2OSensorMassWarningThreshold == null)
                    return;

                double result = value;
                result = Math.Max(_scH2OSensorMassWarningThreshold.RangeLowLimit, result);
                result = Math.Min(_scH2OSensorMassWarningThreshold.RangeUpLimit, result);

                _scH2OSensorMassWarningThreshold.Value = result;
                //_aoH2OSensorMassWarningThreshold.Value = (float)value;
            }
        }

        public double H2OSensorMassWarningTime
        {
            get
            {
                return _aiH2OSensorMassWarningTime == null ? 0 : _aiH2OSensorMassWarningTime.Value;
            }
            set
            {
                if (_scH2OSensorMassWarningTime == null)
                    return;

                double result = value;
                result = Math.Max(_scH2OSensorMassWarningTime.RangeLowLimit, result);
                result = Math.Min(_scH2OSensorMassWarningTime.RangeUpLimit, result);

                _scH2OSensorMassWarningTime.Value = result;
                //_aoH2OSensorMassWarningTime.Value = (float) value;
            }
        }

        public double N2PurgeFlow
        {
            get
            {
                return _aiN2PurgeFlow == null ? 0 : _aiN2PurgeFlow.Value;
            }
        }

        public double N2PurgeFlowWarningThreshold
        {
            get
            {
                return _aiN2PurgeFlowWarningThreshold == null ? 0 : _aiN2PurgeFlowWarningThreshold.Value;
            }
            set
            {
                if (_scN2PurgeFlowWarning == null)
                    return;

                double result = value;
                result = Math.Max(_scN2PurgeFlowWarning.RangeLowLimit, result);
                result = Math.Min(_scN2PurgeFlowWarning.RangeUpLimit, result);

                _scN2PurgeFlowWarning.Value = result;
                //_aoN2PurgeFlowWarning.Value = (float) value;
            }
        }

        public double N2PurgeFlowWarningTime
        {
            get
            {
                return _aiN2PurgeFlowWarningTime == null ? 0 : _aiN2PurgeFlowWarningTime.Value;
            }
            set
            {
                if (_scN2PurgeFlowWarningTime == null)
                    return;

                double result = value;
                result = Math.Max(_scN2PurgeFlowWarningTime.RangeLowLimit, result);
                result = Math.Min(_scN2PurgeFlowWarningTime.RangeUpLimit, result);

                _scN2PurgeFlowWarningTime.Value = result;
                //_aoN2PurgeFlowWarningTime.Value = (float) value;
            }
        }

        public double ExhaustPressure
        {
            get
            {
                return _aiExhaustPressure == null ? 0 : _aiExhaustPressure.Value;
            }
        }

        public double ExhaustPressurePreWarningThreshold
        {
            get
            {
                return _aiExhaustPressurePreWarningThreshold == null ? 0 : _aiExhaustPressurePreWarningThreshold.Value;
            }
            set
            {
                if (_scExhaustPressurePreWarningThreshold == null)
                    return;

                double result = value;
                result = Math.Max(_scExhaustPressurePreWarningThreshold.RangeLowLimit, result);
                result = Math.Min(_scExhaustPressurePreWarningThreshold.RangeUpLimit, result);

                _scExhaustPressurePreWarningThreshold.Value = result;
                //_aoExhaustPressurePreWarningThreshold.Value = (float) value;
            }
        }

        public double ExhaustPressurePreWarningTime
        {
            get
            {
                return _aiExhaustPressurePreWarningTime == null ? 0 : _aiExhaustPressurePreWarningTime.Value;
            }
            set
            {
                if (_scExhaustPressurePreWarningTime == null)
                    return;

                double result = value;
                result = Math.Max(_scExhaustPressurePreWarningTime.RangeLowLimit, result);
                result = Math.Min(_scExhaustPressurePreWarningTime.RangeUpLimit, result);

                _scExhaustPressurePreWarningTime.Value = result;
                //_aoExhaustPressurePreWarningTime.Value = (float) value;
            }
        }

        public bool IsStartButtonPushed
        {
            get
            {
                return _diStart != null && _diStart.Value;
            }
        }

        public bool IsStopButtonPushed
        {
            get
            {
                return _diStop != null && _diStop.Value;
            }
        }

        private bool IsEnableWaterFlowAlarm = true;

        private DIAccessor _diRunning = null;
        private DIAccessor _diPumpTempWaring = null;
        private DIAccessor _diPumpN2FlowWarning = null;
        private DIAccessor _diPumpTempAlarm = null;
        private DIAccessor _diWaterFlowWarning = null;
        private DIAccessor _diOverloadAlarm;
        private DIAccessor _diPowerOn;
        private DIAccessor _diStart;
        private DIAccessor _diStop;
        private DIAccessor _diError;
        private DIAccessor _diWarning;
        private DIAccessor _diWaterFlowAlarm;
        private DIAccessor _diN2Warning;
        private DIAccessor _diN2Alarm;
        private DIAccessor _diExhaustPressureWarning;
        private DIAccessor _diExhaustPressureAlarm;
        private DIAccessor _diLogicWaterFlowAlarm;
        private DIAccessor _diLogicN2PressureAlarm;
        private DIAccessor _diLever1PumpCBAlarm;
        private DIAccessor _diROOTSPumpCBAlarm;

        private DOAccessor _doStart;
        private DOAccessor _doLocalRemote;
        private DOAccessor _doWarningReset;
        private DOAccessor _doWaterFlowAlarm;
        private DOAccessor _doN2PressureAlarm;

       

        private AOAccessor _aoH2OSensorMassWarningThreshold;
        private AOAccessor _aoH2OSensorMassWarningTime;
        private AOAccessor _aoN2PurgeFlowWarning;
        private AOAccessor _aoN2PurgeFlowWarningTime;
        private AOAccessor _aoExhaustPressurePreWarningThreshold;
        private AOAccessor _aoExhaustPressurePreWarningTime;
        private AOAccessor _aoWaterFlowAlarmMinValue;
        private AOAccessor _aoWaterFlowAlarmMaxValue;
        private AOAccessor _aoN2PressureAlarmMinValue;
        private AOAccessor _aoN2PressureAlarmMaxValue;

        private AIAccessor _aiWaterFlow;
        private AIAccessor _aiN2Pressure;
        private AIAccessor _aiH2OSensorMassWarningThreshold;
        private AIAccessor _aiH2OSensorMassWarningTime;
        private AIAccessor _aiN2PurgeFlow;
        private AIAccessor _aiN2PurgeFlowWarningThreshold;
        private AIAccessor _aiN2PurgeFlowWarningTime;
        private AIAccessor _aiExhaustPressure;
        private AIAccessor _aiExhaustPressurePreWarningThreshold;
        private AIAccessor _aiExhaustPressurePreWarningTime;

        private SCItem<double> _scH2OSensorMassWarningThreshold;
        private SCItem<double> _scH2OSensorMassWarningTime;
        private SCItem<double> _scN2PurgeFlowWarning;
        private SCItem<double> _scN2PurgeFlowWarningTime;
        private SCItem<double> _scExhaustPressurePreWarningThreshold;
        private SCItem<double> _scExhaustPressurePreWarningTime;
        private SCItem<bool> _scEnableWaterFlow;
        private SCItem<double> _scWaterFlowMinValue;
        private SCItem<double> _scWaterFlowMaxValue;
        private SCItem<double> _scWaterFlowOutOfToleranceWarningTime;
        private SCItem<double> _scWaterFlowOutOfToleranceAlarmTime;
        private SCItem<bool> _scEnableN2Pressure;
        private SCItem<double> _scN2PressureMinValue;
        private SCItem<double> _scN2PressureMaxValue;
        private SCItem<double> _scN2PressureOutOfToleranceWarningTime;
        private SCItem<double> _scN2PressureOutOfToleranceAlarmTime;
        private SCItem<bool> _scEnableDryPump;

        private R_TRIG _trigWarning = new R_TRIG();
        private R_TRIG _trigError = new R_TRIG();
        private R_TRIG _trigWaterFlowSensorWarning = new R_TRIG();
        private R_TRIG _trigWaterFlowSensorAlarm = new R_TRIG();
        private R_TRIG _trigN2Warning = new R_TRIG();
        private R_TRIG _trigN2Alarm = new R_TRIG();
        private R_TRIG _trigExhaustPressureWarning = new R_TRIG();
        private R_TRIG _trigExhaustPressureAlarm = new R_TRIG();

        private R_TRIG _trigLever1PumpCBAlarm=new R_TRIG();
        private R_TRIG _trigdiROOTSPumpCBAlarm = new R_TRIG();

        ToleranceChecker _checkN2PressureWarning = new ToleranceChecker();
        ToleranceChecker _checkN2PressureAlarm = new ToleranceChecker();
        ToleranceChecker _checkWaterFlowWarning = new ToleranceChecker();
        ToleranceChecker _checkWaterFlowAlarm = new ToleranceChecker();

        public IoPump(string module, XmlElement node)
        {
            base.Module = module;
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _diError = ParseDiNode("diAlarm", node);
            _diRunning = ParseDiNode("diRunning", node);
            _diWarning = ParseDiNode("diWarning", node);
            _diOverloadAlarm = ParseDiNode("diOverloadAlarm", node);
            _diPowerOn = ParseDiNode("diPowerOn", node);
            _diStart = ParseDiNode("diStart", node);
            _diStop = ParseDiNode("diStop", node);
            _diPumpTempWaring = ParseDiNode("diPumpTempWaring", node);
            _diPumpTempAlarm = ParseDiNode("diPumpTempAlarm", node);

            _diWaterFlowWarning = ParseDiNode("diWaterFlowWarning", node);
            _diWaterFlowAlarm = ParseDiNode("diWaterFlowAlarm", node);
            _diN2Warning = ParseDiNode("diN2Warning", node);
            _diN2Alarm = ParseDiNode("diN2Alarm", node);

            _diExhaustPressureWarning = ParseDiNode("diExhaustPressureWarning", node);
            _diExhaustPressureAlarm = ParseDiNode("diExhaustPressureAlarm", node);

            _diLogicWaterFlowAlarm = ParseDiNode("diLogicWaterFlowAlarm", node);
            _diLogicN2PressureAlarm = ParseDiNode("diLogicN2PressureAlarm", node);

            _diLever1PumpCBAlarm= ParseDiNode("diLever1PumpCBAlarm", node);
            _diROOTSPumpCBAlarm= ParseDiNode("diROOTSPumpCBAlarm", node);

            _doStart = ParseDoNode("doStartStop", node);
            _doLocalRemote = ParseDoNode("doLocalRemote", node);
            _doWarningReset = ParseDoNode("doReset", node);
            _doN2PressureAlarm = ParseDoNode("doN2PressureAlarm", node);
            _doWaterFlowAlarm = ParseDoNode("doWaterFlowAlarm", node);

            _aoH2OSensorMassWarningThreshold = ParseAoNode("aoH2OSensorMassWarningThreshold", node);
            _aoH2OSensorMassWarningTime = ParseAoNode("aoH2OSensorMassWarningTime", node);
            _aoN2PurgeFlowWarning = ParseAoNode("aoN2PurgeFlowWarning", node);
            _aoN2PurgeFlowWarningTime = ParseAoNode("aoN2PurgeFlowWarningTime", node);
            _aoExhaustPressurePreWarningThreshold = ParseAoNode("aoExhaustPressurePreWarningThreshold", node);
            _aoExhaustPressurePreWarningTime = ParseAoNode("aoExhaustPressurePreWarningTime", node);

            _aoWaterFlowAlarmMinValue = ParseAoNode("aoWaterFlowAlarmMinValue", node);
            _aoWaterFlowAlarmMaxValue = ParseAoNode("aoWaterFlowAlarmMaxValue", node);
            _aoN2PressureAlarmMinValue = ParseAoNode("aoN2PressureAlarmMinValue", node);
            _aoN2PressureAlarmMaxValue = ParseAoNode("aoN2PressureAlarmMaxValue", node);

            _aiWaterFlow = ParseAiNode("aiWaterFlow", node);
            _aiN2Pressure = ParseAiNode("aiN2Pressure", node);

            _aiH2OSensorMassWarningThreshold = ParseAiNode("aiH2OSensorMassWarningThreshold", node);
            _aiH2OSensorMassWarningTime = ParseAiNode("aiH2OSensorMassWarningTime", node);
            _aiN2PurgeFlow = ParseAiNode("aiN2PurgeFlow", node);
            _aiN2PurgeFlowWarningThreshold = ParseAiNode("aiN2PurgeFlowWarningThreshold", node);
            _aiN2PurgeFlowWarningTime = ParseAiNode("aiN2PurgeFlowWarningTime", node);

            _aiExhaustPressure = ParseAiNode("aiExhaustPressure", node);
            _aiExhaustPressurePreWarningThreshold = ParseAiNode("aiExhaustPressurePreWarningThreshold", node);
            _aiExhaustPressurePreWarningTime = ParseAiNode("aiExhaustPressurePreWarningTime", node);

            _scH2OSensorMassWarningThreshold = ParseScNodeDouble("scH2OSensorMassWarningThreshold", node);
            _scH2OSensorMassWarningTime = ParseScNodeDouble("scH2OSensorMassWarningTime", node);
            _scN2PurgeFlowWarning = ParseScNodeDouble("scN2PurgeFlowWarning", node);
            _scN2PurgeFlowWarningTime = ParseScNodeDouble("scN2PurgeFlowWarningTime", node);
            _scExhaustPressurePreWarningThreshold = ParseScNodeDouble("scExhaustPressurePreWarningThreshold", node);
            _scExhaustPressurePreWarningTime = ParseScNodeDouble("scExhaustPressurePreWarningTime", node);

            _scEnableDryPump = ParseScNodeBool("scEnableDryPump", node);

            _scEnableWaterFlow = ParseScNodeBool("scEnableWaterFlow", node);
            _scWaterFlowMinValue = ParseScNodeDouble("scWaterFlowMinValue", node);
            _scWaterFlowMaxValue = ParseScNodeDouble("scWaterFlowMaxValue", node);
            _scWaterFlowOutOfToleranceWarningTime = ParseScNodeDouble("scWaterFlowOutOfToleranceWarningTime", node);
            _scWaterFlowOutOfToleranceAlarmTime = ParseScNodeDouble("scWaterFlowOutOfToleranceAlarmTime", node);

            _scEnableN2Pressure = ParseScNodeBool("scEnableN2Pressure", node);
            _scN2PressureMinValue = ParseScNodeDouble("scN2PressureMinValue", node);
            _scN2PressureMaxValue = ParseScNodeDouble("scN2PressureMaxValue", node);
            _scN2PressureOutOfToleranceWarningTime = ParseScNodeDouble("scN2PressureOutOfToleranceWarningTime", node);
            _scN2PressureOutOfToleranceAlarmTime = ParseScNodeDouble("scN2PressureOutOfToleranceAlarmTime", node);
        }

        void SetConfigValue()
        {
            if (_aoWaterFlowAlarmMinValue != null && _scWaterFlowMinValue != null)
                _aoWaterFlowAlarmMinValue.Value = (float)_scWaterFlowMinValue.Value;
            if (_aoWaterFlowAlarmMaxValue != null && _scWaterFlowMaxValue != null)
                _aoWaterFlowAlarmMaxValue.Value = (float)_scWaterFlowMaxValue.Value;
            if (_aoN2PressureAlarmMinValue != null && _scN2PressureMinValue != null)
                _aoN2PressureAlarmMinValue.Value = (float)_scN2PressureMinValue.Value;
            if (_aoN2PressureAlarmMaxValue != null && _scN2PressureMaxValue != null)
                _aoN2PressureAlarmMaxValue.Value = (float)_scN2PressureMaxValue.Value;
        }

        public bool Initialize()
        {
            IsEnableWaterFlowAlarm = true;

            SetConfigValue();

            DATA.Subscribe(string.Format("Device.{0}.{1}", Module, Name), () => {
                AITPumpData data = new AITPumpData() {
                    DeviceName = Name,
                    DeviceSchematicId = DeviceID,
                    DisplayName = Display,
                    IsError = HasError,
                    IsWarning = HasWarning,
                    IsOn = IsRunning,
                    WaterFlow = WaterFlowValue,
                    IsDryPumpEnable = IsDryPumpEnabled,
                    IsN2PressureEnable = EnableN2Pressure,
                    IsWaterFlowEnable = EnableWaterFlow,
                    WaterFlowWarning = WaterFlowWarning,
                    WaterFlowAlarm = WaterFlowAlarm,
                    N2PressureAlarm = N2PressureAlarm,
                    N2PressureWarning = N2PressureWarning,
                };

                return data;
            }, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DEVICE.Register(String.Format("{0}.{1}", Name, AITPumpOperation.WaterFlowAlarm), (out string reason, int time, object[] param) =>
            {
                reason = "";
                bool isOn = Convert.ToBoolean(param[0]);
                IsEnableWaterFlowAlarm = isOn;

                return true;
            });

            DEVICE.Register(String.Format("{0}.{1}", Name, AITPumpOperation.SetOnOff), (out string reason, int time, object[] param) => {
                bool isOn = Convert.ToBoolean((string)param[0]);

                if (IsError)
                {
                    reason = string.Format("Pump is in error state, reset before turn {0}", isOn ? "ON" : "OFF");
                    return false;
                }

                reason = string.Empty;

                if (_doStart != null)
                {
                    _doStart.Value = isOn;
                }
                else
                {
                    reason = string.Format("Pump designed for using in manual control mode, can not turn {0}", isOn ? "ON" : "OFF");
                    return false;
                }

                return true;
            });
            return true;
        }

        public void Terminate()
        {
        }

        void MonitorN2Pressure()
        {
            if (!IsDryPumpEnabled)
                return;

            if (!EnableN2Pressure)
                return;

            //_checkN2PressureWarning.Monitor(N2PressureValue, N2PressureMinValue, N2PressureMaxValue, N2PressureWarningTime);
            //if (_checkN2PressureWarning.Trig)
            //{
            //    EV.PostMessage(Module, EventEnum.DefaultWarning, string.Format("{0} N2 pressure out of tolerance [{1}, {2}] for {3} seconds", Display, N2PressureMinValue, N2PressureMaxValue, N2PressureWarningTime));
            //}

            //_checkN2PressureAlarm.Monitor(N2PressureValue, N2PressureMinValue, N2PressureMaxValue, N2PressureAlarmTime);
            //if (_checkN2PressureAlarm.Trig)
            //{
            //    EV.PostMessage(Module, EventEnum.DefaultAlarm, string.Format("{0} N2 pressure out of tolerance [{1}, {2}] for {3} seconds", Display, N2PressureMinValue, N2PressureMaxValue, N2PressureAlarmTime));
            //}

            if (_diLogicN2PressureAlarm != null)
                _diLogicN2PressureAlarm.RawData = N2PressureAlarm;

            N2PressureAlarmSetPoint = N2PressureAlarm;
        }

        void MonitorWaterFlow()
        {
            if (!IsDryPumpEnabled)
                return;
            if (!EnableWaterFlow)
                return;

            _checkWaterFlowWarning.Monitor(WaterFlowValue, WaterFlowMinValue, WaterFlowMaxValue, WaterFlowWarningTime);
            if (_checkWaterFlowWarning.Trig)
            {
                EV.PostMessage(Module, EventEnum.DefaultWarning, string.Format("{0} Cooling Water Flow Out Of Tolerance [{1}, {2}] for {3} seconds", Display, WaterFlowMinValue, WaterFlowMaxValue, WaterFlowWarningTime));
            }

            _checkWaterFlowAlarm.Monitor(WaterFlowValue, WaterFlowMinValue, WaterFlowMaxValue, WaterFlowAlarmTime);
            if (_checkWaterFlowAlarm.Trig)
            {
                EV.PostMessage(Module, EventEnum.DefaultAlarm, string.Format("{0} Cooling Water Flow Out Of Tolerance [{1}, {2}] for {3} seconds", Display, WaterFlowMinValue, WaterFlowMaxValue, WaterFlowAlarmTime));
            }

            if (_diLogicWaterFlowAlarm != null)
                _diLogicWaterFlowAlarm.RawData = WaterFlowAlarm;


            WaterFlowAlarmSetPoint = WaterFlowAlarm;
        }

        public void Monitor()
        {
            try
            {
                SetConfigValue();

                //MonitorN2Pressure();
                //MonitorWaterFlow();

                if (_scH2OSensorMassWarningThreshold != null && _aoH2OSensorMassWarningThreshold != null)
                    _aoH2OSensorMassWarningThreshold.Value = (float)_scH2OSensorMassWarningThreshold.Value;

                if (_scH2OSensorMassWarningTime != null && _aoH2OSensorMassWarningTime != null)
                    _aoH2OSensorMassWarningTime.Value = (float)_scH2OSensorMassWarningTime.Value;

                if (_scN2PurgeFlowWarning != null && _aoN2PurgeFlowWarning != null)
                    _aoN2PurgeFlowWarning.Value = (float)_scN2PurgeFlowWarning.Value;

                if (_scN2PurgeFlowWarningTime != null && _aoN2PurgeFlowWarningTime != null)
                    _aoN2PurgeFlowWarningTime.Value = (float)_scN2PurgeFlowWarningTime.Value;

                if (_scExhaustPressurePreWarningThreshold != null && _aoExhaustPressurePreWarningThreshold != null)
                    _aoExhaustPressurePreWarningThreshold.Value = (float)_scExhaustPressurePreWarningThreshold.Value;

                if (_scExhaustPressurePreWarningTime != null && _aoExhaustPressurePreWarningTime != null)
                    _aoExhaustPressurePreWarningTime.Value = (float)_scExhaustPressurePreWarningTime.Value;

                _trigWarning.CLK = IsWarning;
                if (_trigWarning.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultWarning, "Dry Pump Warning");
                }

                _trigError.CLK = IsError;
                if (_trigError.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Dry Pump Error");
                }

                _trigWaterFlowSensorWarning.CLK = _diWaterFlowWarning != null && _diWaterFlowWarning.Value;
                if (_trigWaterFlowSensorWarning.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultWarning, "Dry Pump water flow warning");
                }

                _trigWaterFlowSensorAlarm.CLK = _diWaterFlowAlarm != null && _diWaterFlowAlarm.Value && IsEnableWaterFlowAlarm;
                if (_trigWaterFlowSensorAlarm.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Dry Pump water flow alarm");
                }

                _trigN2Warning.CLK = _diN2Warning != null && _diN2Warning.Value;
                if (_trigN2Warning.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultWarning, "Dry Pump N2 flow warning");
                }
                _trigN2Alarm.CLK = _diN2Alarm != null && _diN2Alarm.Value;
                if (_trigN2Alarm.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Dry Pump N2 flow alarm");
                }
                _trigExhaustPressureWarning.CLK = _diExhaustPressureWarning != null && _diExhaustPressureWarning.Value;
                if (_trigExhaustPressureWarning.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultWarning, "Dry Pump exhaust pressure warning");
                }
                _trigExhaustPressureAlarm.CLK = _diExhaustPressureAlarm != null && _diExhaustPressureAlarm.Value;
                if (_trigExhaustPressureAlarm.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Dry Pump exhaust pressure alarm");
                }

                //_trigLever1PumpCBAlarm.CLK = _diLever1PumpCBAlarm != null && _diLever1PumpCBAlarm.Value;
                //if (_trigLever1PumpCBAlarm.Q)
                //{
                //    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Lever1 Pump CB Alarm");
                //}

                _trigLever1PumpCBAlarm.CLK = _diLever1PumpCBAlarm != null && _diLever1PumpCBAlarm.Value;
                if (_trigLever1PumpCBAlarm.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Lever1 Pump Circuit Broaker Trip Alarm");
                }

                _trigdiROOTSPumpCBAlarm.CLK=_diROOTSPumpCBAlarm != null && _diROOTSPumpCBAlarm.Value;
                if (_trigdiROOTSPumpCBAlarm.Q)
                {
                    EV.PostMessage(Module, EventEnum.DefaultAlarm, "Roots Pump Circuit Broaker Trip Alarm");
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public void Reset()
        {
            if ((IsWarning || IsError) && _doWarningReset != null)
                _doWarningReset.Value = true;

            _trigWarning.RST = true;
            _trigError.RST = true;

            _trigWaterFlowSensorWarning.RST = true;
            _trigWaterFlowSensorAlarm.RST = true;
            _trigdiROOTSPumpCBAlarm.RST = true;

            _trigN2Warning.RST = true;
            _trigN2Alarm.RST = true;
            _trigExhaustPressureWarning.RST = true;
            _trigExhaustPressureAlarm.RST = true;

            _checkN2PressureAlarm.RST = true;
            _checkN2PressureWarning.RST = true;
            _checkWaterFlowAlarm.RST = true;
            _checkWaterFlowWarning.RST = true;

            _trigLever1PumpCBAlarm.RST = true;
        }
    }
}