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 _scH2OSensorMassWarningThreshold; private SCItem _scH2OSensorMassWarningTime; private SCItem _scN2PurgeFlowWarning; private SCItem _scN2PurgeFlowWarningTime; private SCItem _scExhaustPressurePreWarningThreshold; private SCItem _scExhaustPressurePreWarningTime; private SCItem _scEnableWaterFlow; private SCItem _scWaterFlowMinValue; private SCItem _scWaterFlowMaxValue; private SCItem _scWaterFlowOutOfToleranceWarningTime; private SCItem _scWaterFlowOutOfToleranceAlarmTime; private SCItem _scEnableN2Pressure; private SCItem _scN2PressureMinValue; private SCItem _scN2PressureMaxValue; private SCItem _scN2PressureOutOfToleranceWarningTime; private SCItem _scN2PressureOutOfToleranceAlarmTime; private SCItem _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; } } }