362 lines
14 KiB
Plaintext
362 lines
14 KiB
Plaintext
using System;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.DASFactory.Config;
|
|
|
|
namespace DTS.DASLib.Service
|
|
{
|
|
/// <inheritdoc />
|
|
/// <summary>
|
|
/// Base class for all DAS channels.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class DASChannel : IDASChannel, IXmlSerializable // (subset of sensor class)
|
|
{
|
|
public DFConstantsAndEnums.ConfigMode ConfigurationMode { get; set; }
|
|
|
|
/// <summary>
|
|
/// whether the channel should be put in Diagnostics mode or not
|
|
/// </summary>
|
|
public bool DiagnosticsMode { get; set; }
|
|
|
|
/// <summary>
|
|
/// Channel number with respect to it's containing module <see cref="OwningModule"/>
|
|
/// </summary>
|
|
public int ModuleChannelNumber { get; set; }
|
|
|
|
public int AbsoluteDisplayOrder { get; set; } = 1;
|
|
|
|
public double UnitConverision { get; set; } = 1D;
|
|
|
|
public bool AtCapacity { get; set; } = false;
|
|
|
|
public double CapacityOutputIsBasedOn { get; set; } = 1D;
|
|
|
|
public SensorConstants.SensUnits SensitivityUnits { get; set; } =
|
|
SensorConstants.SensUnits.NONE;
|
|
|
|
/// <summary>
|
|
/// A link back to the Module that contains this channel.
|
|
/// </summary>
|
|
[XmlIgnore]
|
|
public DASModule OwningModule { get; set; }
|
|
|
|
/// <summary>
|
|
/// The "stack channel number" of this channel with respect to the owning
|
|
/// DAS (0 based).
|
|
/// </summary>
|
|
public byte Number
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return OwningModule.OwningDAS.DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(OwningModule.ModuleArrayIndex, ModuleChannelNumber);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ApplicationException("encountered problem getting " + GetType().FullName + ".Number property value", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Array of (string, byte[]) for EID
|
|
/// </summary>
|
|
[XmlIgnore]
|
|
public IEID[] IDs { get; set; }
|
|
|
|
/// <summary>
|
|
/// time stamp of this event
|
|
/// </summary>
|
|
public DateTime EventStartTime { get; set; }
|
|
|
|
/// <summary>
|
|
/// <see cref="bool"/> value indicating whether or not this channel has registered a level trigger.
|
|
/// </summary>
|
|
public bool LevelTriggerSeen { get; set; }
|
|
|
|
public string IsoChannelName { get; set; }
|
|
public string ChannelGroupName { get; set; }
|
|
public string UserCode { get; set; }
|
|
public string UserChannelName { get; set; }
|
|
public string LinearSensorCalibration { get; set; }
|
|
/// <summary>
|
|
/// the number of samples to qualify over
|
|
/// </summary>
|
|
public int QualificationSamples { get; set; }
|
|
|
|
///// <summary>
|
|
///// Number of samples that T0 on DASes that did not directly experience the level trigger must be shifted
|
|
///// to time align with this channel's directly level triggered T0. A null value indicates that this channel
|
|
///// did not directly receive a level trigger.
|
|
///// </summary>
|
|
public int? LevelTriggerT0AdjustmentSamples { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
return ModuleChannelNumber.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this channel configured? 'Configured' means a sensor is connected and/or there is
|
|
/// information in the containg device's ConfigData object, put there with a call to
|
|
/// ConfigureService.Configure(...) in the API.
|
|
/// </summary>
|
|
/// <returns>True if it is configured, False otherwise.</returns>
|
|
public virtual bool IsConfigured()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// CTOR to populate a channel's owning module and channel WRT that module.
|
|
/// </summary>
|
|
/// <param name="owner">Module that contains this channel.</param>
|
|
/// <param name="channelNumber">ChannelNumber of this channel WRT owning module.</param>
|
|
public DASChannel(DASModule owner, int channelNumber)
|
|
{
|
|
ConfigurationMode = DFConstantsAndEnums.ConfigMode.Normal;
|
|
ModuleChannelNumber = channelNumber;
|
|
OwningModule = owner;
|
|
IDs = null;
|
|
EventStartTime = DateTime.Now;
|
|
DiagnosticsMode = false;
|
|
}
|
|
|
|
public DASChannel()
|
|
{
|
|
}
|
|
|
|
public virtual void WriteElementStart(XmlWriter writer)
|
|
{
|
|
writer.WriteStartElement("DASChannel");
|
|
//writer.WriteStartAttribute("type", "xsi");
|
|
var tgt = GetType();
|
|
writer.WriteAttributeString("xsi", "type", null, tgt.Name);
|
|
}
|
|
|
|
public virtual void WriteElementEnd(XmlWriter writer)
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
public virtual void WriteXmlCRC32(XmlWriter writer)
|
|
{
|
|
// ConfigurationMode
|
|
XMLHelper.PutString(writer, "ConfigurationMode", ConfigurationMode.ToString());
|
|
|
|
// ModuleChannelNumber
|
|
XMLHelper.PutInt(writer, "ModuleChannelNumber", ModuleChannelNumber);
|
|
XMLHelper.PutInt(writer, "AbsoluteDisplayOrder", AbsoluteDisplayOrder);
|
|
XMLHelper.PutBool(writer, "DiagnosticsMode", DiagnosticsMode);
|
|
XMLHelper.PutDouble(writer, "UnitConversion", UnitConverision);
|
|
// EventStartTime
|
|
//XMLHelper.PutString(writer, "EventStartTime", EventStartTime.ToString("o", XMLHelper.InvariantCulture));
|
|
}
|
|
public virtual void WriteXml(XmlWriter writer)
|
|
{
|
|
// ConfigurationMode
|
|
XMLHelper.PutString(writer, "ConfigurationMode", ConfigurationMode.ToString());
|
|
|
|
// ModuleChannelNumber
|
|
XMLHelper.PutInt(writer, "ModuleChannelNumber", ModuleChannelNumber);
|
|
|
|
XMLHelper.PutInt(writer, "AbsoluteDisplayOrder", AbsoluteDisplayOrder);
|
|
// EventStartTime
|
|
XMLHelper.PutString(writer, "EventStartTime", EventStartTime.ToString("o", XMLHelper.InvariantCulture));
|
|
|
|
//XMLHelper.PutString(writer, "QualificationSamples", QualificationSamples.ToString());
|
|
XMLHelper.PutInt(writer, "QualificationSamples", QualificationSamples);
|
|
|
|
XMLHelper.PutBool(writer, "DiagnosticsMode", DiagnosticsMode);
|
|
|
|
XMLHelper.PutDouble(writer, "UnitConversion", UnitConverision);
|
|
|
|
XMLHelper.PutBool(writer, "AtCapacity", AtCapacity);
|
|
|
|
XMLHelper.PutDouble(writer, "CapacityOutputIsBasedOn", CapacityOutputIsBasedOn);
|
|
|
|
XMLHelper.PutString(writer, "SensitivityUnits", SensitivityUnits.ToString());
|
|
|
|
XMLHelper.PutString(writer, "IsoChannelName", IsoChannelName);
|
|
XMLHelper.PutString(writer, "UserCode", UserCode);
|
|
XMLHelper.PutString(writer, "UserChannelName", UserChannelName);
|
|
XMLHelper.PutString(writer, "LinearSensorCalibration", LinearSensorCalibration);
|
|
if (!string.IsNullOrEmpty(UserValue1))
|
|
{
|
|
XMLHelper.PutString(writer, "UserValue1", UserValue1);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(UserValue2))
|
|
{
|
|
XMLHelper.PutString(writer, "UserValue2", UserValue2);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(UserValue3))
|
|
{
|
|
XMLHelper.PutString(writer, "UserValue3", UserValue3);
|
|
}
|
|
|
|
/*XMLHelper.PutInt(writer, "IdType", IdType);*/
|
|
}
|
|
private const string CONFIGUARATIONMODE_TAG = "ConfigurationMode";
|
|
private const string MODULECHANNELNUMBER_TAG = "ModuleChannelNumber";
|
|
private const string EVENTSTARTTIME_TAG = "EventStartTime";
|
|
private const string QUALIFICATIONSAMPLES_TAG = "QualificationSamples";
|
|
private const string DIAGNOSTICSMODE_TAG = "DiagnosticsMode";
|
|
private const string ABSOLUTEDISPLAYORDER_TAG = "AbsoluteDisplayOrder";
|
|
private const string UNITCONVERSION_TAG = "UnitConversion";
|
|
private const string ATCAPACITY_TAG = "AtCapacity";
|
|
private const string LINEARSENSORCALIBRATION_TAG = "LinearSensorCalibration";
|
|
private const string USERCHANNELNAME_TAG = "UserChannelName";
|
|
private const string USERCODE_TAG = "UserCode";
|
|
private const string ISOCHANNELNAME_TAG = "IsoChannelName";
|
|
private const string CAPACITYOUTPUTISBASEDON_TAG = "CapacityOutputIsBasedOn";
|
|
private const string SENSITIVITYUNITS_TAG = "SensitivityUnits";
|
|
private const string USERVALUE1_TAG = "UserValue1";
|
|
private const string USERVALUE2_TAG = "UserValue2";
|
|
private const string USERVALUE3_TAG = "UserValue3";
|
|
protected virtual void HandleElement(XmlReader reader)
|
|
{
|
|
switch (reader.Name)
|
|
{
|
|
case CONFIGUARATIONMODE_TAG:
|
|
var confMode = XMLHelper.GetString(reader);
|
|
ConfigurationMode = (DFConstantsAndEnums.ConfigMode)Enum.Parse(typeof(DFConstantsAndEnums.ConfigMode), confMode);
|
|
break;
|
|
case MODULECHANNELNUMBER_TAG:
|
|
ModuleChannelNumber = XMLHelper.GetInt(reader);
|
|
break;
|
|
case EVENTSTARTTIME_TAG:
|
|
var est = XMLHelper.GetString(reader);
|
|
EventStartTime = DateTime.Parse(est);
|
|
break;
|
|
case QUALIFICATIONSAMPLES_TAG:
|
|
QualificationSamples = XMLHelper.GetInt(reader);
|
|
break;
|
|
case DIAGNOSTICSMODE_TAG:
|
|
DiagnosticsMode = XMLHelper.GetBool(reader);
|
|
break;
|
|
case ABSOLUTEDISPLAYORDER_TAG:
|
|
try { AbsoluteDisplayOrder = XMLHelper.GetInt(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case UNITCONVERSION_TAG:
|
|
try { UnitConverision = XMLHelper.GetDouble(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case ATCAPACITY_TAG:
|
|
try { AtCapacity = XMLHelper.GetBool(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case LINEARSENSORCALIBRATION_TAG:
|
|
LinearSensorCalibration = XMLHelper.GetString(reader);
|
|
break;
|
|
case USERCHANNELNAME_TAG:
|
|
UserChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case USERCODE_TAG:
|
|
UserCode = XMLHelper.GetString(reader);
|
|
break;
|
|
case ISOCHANNELNAME_TAG:
|
|
IsoChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case CAPACITYOUTPUTISBASEDON_TAG:
|
|
try { CapacityOutputIsBasedOn = XMLHelper.GetDouble(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case SENSITIVITYUNITS_TAG:
|
|
var su = XMLHelper.GetString(reader);
|
|
SensitivityUnits = (SensorConstants.SensUnits)Enum.Parse(typeof(SensorConstants.SensUnits), su);
|
|
break;
|
|
case USERVALUE1_TAG:
|
|
try { UserValue1 = XMLHelper.GetString(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case USERVALUE2_TAG:
|
|
try { UserValue2 = XMLHelper.GetString(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
case USERVALUE3_TAG:
|
|
try { UserValue3 = XMLHelper.GetString(reader); }
|
|
catch (Exception) { }
|
|
break;
|
|
|
|
default:
|
|
// let child handle it
|
|
return;
|
|
}
|
|
}
|
|
public virtual void ReadXml(XmlReader reader)
|
|
{
|
|
// it must be an Element
|
|
if (reader.NodeType != XmlNodeType.Element)
|
|
{
|
|
throw new XmlException("DASChannel.ReadXml: Unknown input: " + reader.NodeType.ToString());
|
|
}
|
|
|
|
// skip our start tag
|
|
if (reader.Name == "DASChannel")
|
|
{
|
|
reader.Read();
|
|
}
|
|
|
|
// try to find our data
|
|
do
|
|
{
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
{
|
|
HandleElement(reader);
|
|
}
|
|
if (!reader.Read())
|
|
{
|
|
break;
|
|
}
|
|
} while (!(reader.Name.Equals("DASChannel") && reader.NodeType == XmlNodeType.EndElement));
|
|
|
|
// we're going to end with an EndElement, so clean up
|
|
if (reader.Name.Equals("DASChannel") && reader.NodeType == XmlNodeType.EndElement)
|
|
{
|
|
reader.Read();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns true if the channel is re-programable [can be switched from IEPE to analog]
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool CanReProgram()
|
|
{
|
|
if (null == OwningModule) { return false; }
|
|
if (null == OwningModule.OwningDAS) { return false; }
|
|
if (null == OwningModule.OwningDAS.DASInfo) { return false; }
|
|
if (null == OwningModule.OwningDAS.DASInfo.Modules) { return false; }
|
|
if (0 == OwningModule.OwningDAS.DASInfo.Modules.Length)
|
|
{
|
|
return false;
|
|
}
|
|
return OwningModule.OwningDAS.DASInfo.Modules[0].IsProgrammable;
|
|
}
|
|
public XmlSchema GetSchema()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public const int DEFAULT_ID_TYPE = 0;
|
|
public const int BRIDGE_ID_TYPE = 1;
|
|
public const int IEPE_ID_TYPE = 2;
|
|
public const int BRIDGE_G5_ID_TYPE = 3;
|
|
|
|
public int IdType { get; set; } = DEFAULT_ID_TYPE;
|
|
|
|
public string UserValue1 { get; set; } = "";
|
|
public string UserValue2 { get; set; } = "";
|
|
public string UserValue3 { get; set; } = "";
|
|
|
|
}
|
|
}
|