255 lines
7.7 KiB
C#
255 lines
7.7 KiB
C#
using Aitex.Core.Common.DeviceData.IoDevice;
|
|
using Aitex.Core.RT.DataCenter;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.IOCore;
|
|
using Aitex.Core.RT.Log;
|
|
using Aitex.Core.RT.OperationCenter;
|
|
using Aitex.Core.RT.SCCore;
|
|
using Aitex.Core.Util;
|
|
using System;
|
|
using System.Xml;
|
|
|
|
namespace Aitex.Core.RT.Device.Devices
|
|
{
|
|
public class IoSCR : BaseDevice, IDevice
|
|
{
|
|
#region Variables
|
|
|
|
private readonly string _scResLimitMax;
|
|
|
|
private float _resLimitMax;
|
|
|
|
private readonly bool _isFloatAioType = true;
|
|
|
|
private readonly AIAccessor _aiVoltage;
|
|
private readonly AIAccessor _aiArms;
|
|
private readonly AIAccessor _aiPower;
|
|
private readonly DIAccessor _diStatus;
|
|
private DIAccessor _diAlarm;
|
|
|
|
private readonly DOAccessor _doStatus;
|
|
private readonly DOAccessor _doReset;
|
|
|
|
private readonly DeviceTimer _timer = new();
|
|
private string _infoText = "";
|
|
private R_TRIG _alarmTrig = new();
|
|
|
|
private readonly R_TRIG _trigResistance = new();
|
|
private readonly DeviceTimer _timerResistance = new();
|
|
|
|
private readonly IoPsuData _deviceData = new();
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public IoSCR(string module, XmlElement node, string ioModule = "") : base(module, node, ioModule)
|
|
{
|
|
_aiVoltage = ParseAiNode("aiVoltage", node, ioModule);
|
|
_aiArms = ParseAiNode("aiArms", node, ioModule);
|
|
_aiPower = ParseAiNode("aiPower", node, ioModule);
|
|
_diStatus = ParseDiNode("diStatus", node, ioModule);
|
|
|
|
_doReset = ParseDoNode("doReset", node, ioModule);
|
|
_doStatus = ParseDoNode("doStatus", node, ioModule);
|
|
_diAlarm = ParseDiNode("diAlarm", node, ioModule);
|
|
_infoText = node.GetAttribute("AlarmText");
|
|
|
|
_isFloatAioType = !string.IsNullOrEmpty(node.GetAttribute("aioType")) && (node.GetAttribute("aioType") == "float");
|
|
|
|
// 读取电阻上限设定值
|
|
_scResLimitMax = node.GetAttribute("scResLimitMax");
|
|
|
|
LoadConfig();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public float VoltageFeedBack => _aiVoltage == null ? 0 : (_isFloatAioType ? _aiVoltage.FloatValue : _aiVoltage.Value);
|
|
|
|
public float ArmsFeedBack => _aiArms == null ? 0 : (_isFloatAioType ? _aiArms.FloatValue : _aiArms.Value);
|
|
|
|
public float ResistanceLimitMax => _resLimitMax;
|
|
|
|
public float Resistance => ArmsFeedBack == 0 ? 0 : VoltageFeedBack / ArmsFeedBack;
|
|
|
|
public bool IsResistanceOutOfRange => IsResistanceTooHigh;
|
|
|
|
public bool IsResistanceTooHigh => Resistance > ResistanceLimitMax;
|
|
|
|
public float PowerFeedBack => _aiPower == null ? 0 : (_isFloatAioType ? _aiPower.FloatValue : _aiPower.Value);
|
|
|
|
public bool StatusFeedBack => _diStatus == null ? false : _diStatus.Value;
|
|
|
|
private IoPsuData DeviceData
|
|
{
|
|
get
|
|
{
|
|
_deviceData.IsAlarm = false;
|
|
_deviceData.OutputStatusFeedBack = StatusFeedBack;
|
|
_deviceData.OutputArmsFeedBack = ArmsFeedBack;
|
|
_deviceData.OutputPowerFeedBack = PowerFeedBack;
|
|
_deviceData.OutputVoltageFeedback = VoltageFeedBack;
|
|
_deviceData.ResistanceLimitMax = ResistanceLimitMax;
|
|
_deviceData.Resistance = Resistance;
|
|
_deviceData.IsResistanceOutOfRange = IsResistanceOutOfRange;
|
|
_deviceData.IsResistanceTooHigh = IsResistanceTooHigh;
|
|
return _deviceData;
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
/// <summary>
|
|
/// 加载必要的配置。
|
|
/// </summary>
|
|
private void LoadConfig()
|
|
{
|
|
const float DEF_RES_LIMIT_MAX_OHM = 3;
|
|
|
|
LoadSC($"{ScBasePath}.{_scResLimitMax}", $"PM.{Module}.Heater.{Name}ResistanceLimitMax",
|
|
DEF_RES_LIMIT_MAX_OHM, ref _resLimitMax, f => { _resLimitMax = f; });
|
|
}
|
|
|
|
public bool Initialize()
|
|
{
|
|
DATA.Subscribe($"{Module}.{Name}.VoltageFeedBack", () => VoltageFeedBack);
|
|
DATA.Subscribe($"{Module}.{Name}.ArmsFeedBack", () => ArmsFeedBack);
|
|
DATA.Subscribe($"{Module}.{Name}.Resistance", () => Resistance);
|
|
DATA.Subscribe($"{Module}.{Name}.PowerFeedBack", () => PowerFeedBack);
|
|
DATA.Subscribe($"{Module}.{Name}.StatusFeedBack", () => StatusFeedBack);
|
|
DATA.Subscribe($"{Module}.{Name}.DeviceData", () => DeviceData);
|
|
|
|
|
|
OP.Subscribe($"{Module}.{Name}.SetEnable", (function, args) =>
|
|
{
|
|
var isTrue = Convert.ToBoolean(args[0]);
|
|
SetEnable(isTrue, out _);
|
|
return true;
|
|
});
|
|
OP.Subscribe($"{Module}.{Name}.SetReset", (function, args) =>
|
|
{
|
|
var isTrue = Convert.ToBoolean(args[0]);
|
|
SetReset(isTrue, out _);
|
|
return true;
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
public bool SetEnable(bool setValue, out string reason)
|
|
{
|
|
if (!_doStatus.Check(setValue, out reason))
|
|
return false;
|
|
if (!_doStatus.SetValue(setValue, out reason))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool SetReset(bool setValue, out string reason)
|
|
{
|
|
if (!_doReset.Check(setValue, out reason))
|
|
return false;
|
|
if (!_doReset.SetValue(setValue, out reason))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_timer.Start(1000);
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool CheckSCREnable()
|
|
{
|
|
return _doStatus.Value;
|
|
}
|
|
|
|
public void Terminate()
|
|
{
|
|
}
|
|
|
|
protected override void HandleMonitor()
|
|
{
|
|
try
|
|
{
|
|
MonitorAlarm();
|
|
if (_timer.IsTimeout())
|
|
{
|
|
_timer.Stop();
|
|
}
|
|
else if (_timer.IsIdle())
|
|
{
|
|
if (_doReset.Value)
|
|
{
|
|
_doReset.Value = false;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LOG.Write(ex);
|
|
}
|
|
}
|
|
|
|
|
|
public void Reset()
|
|
{
|
|
|
|
}
|
|
|
|
private void MonitorAlarm()
|
|
{
|
|
//检查电阻值是否在合理范围
|
|
var dbResistorMax = SC.GetValue<double>($"PM.{Module}.Heater.{Name}ResistanceMax");
|
|
var timeOut = SC.GetValue<int>($"PM.{Module}.Heater.ResistanceCheckTimeOut");
|
|
|
|
if (Resistance > dbResistorMax && _timerResistance.IsIdle())
|
|
{
|
|
_timerResistance.Start(timeOut);
|
|
}
|
|
|
|
if (Resistance <= dbResistorMax)
|
|
{
|
|
_timerResistance.Stop();
|
|
}
|
|
|
|
_trigResistance.CLK = _timerResistance.IsTimeout();
|
|
if (_trigResistance.Q)
|
|
{
|
|
EV.PostWarningLog(Module, $"{Name} Resistance is out of range.Current Resistance is {Resistance}");
|
|
}
|
|
}
|
|
public double AETemp
|
|
{
|
|
get
|
|
{
|
|
var temp = new object();
|
|
if (SC.GetConfigItem("AETemp.EnableDevice").BoolValue)
|
|
{
|
|
temp = DATA.Poll($"{Module}.AETemp.Middle");
|
|
}
|
|
|
|
if (SC.GetConfigItem("AKunTemp.EnableDevice").BoolValue)
|
|
{
|
|
temp = DATA.Poll($"{Module}.AKunTemp.Middle");
|
|
}
|
|
|
|
return temp == null ? 0 : (double)temp;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|