1402 lines
62 KiB
C#
1402 lines
62 KiB
C#
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.DAS.Concepts.DAS.Channel;
|
|
using DTS.Common.Enums;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.DASFactory;
|
|
using DTS.Common.Interface.DASFactory.Diagnostics;
|
|
using DTS.Common.Interface.Sensors.SoftwareFilters;
|
|
using DTS.Common.Utilities.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
namespace DTS.DASLib.Service
|
|
{
|
|
/// <summary>
|
|
/// Analog input channel. This class contains the properties of a channel
|
|
/// connected to an analog sensor. Casting a channel as this type will provide
|
|
/// access to the Analog Sensor specific properties of the channel.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class AnalogInputDASChannel :
|
|
InputDASChannel,
|
|
IAnalogInputDASChannel,
|
|
ILevelTriggerable,
|
|
IEngineeringUnitAware,
|
|
ILinearized,
|
|
IInversionAware
|
|
{
|
|
public enum Fields
|
|
{
|
|
TypeOfBridge = 0,
|
|
BridgeResistanceOhms,
|
|
SensorCapacityEU,
|
|
SensorPolarity,
|
|
DesiredRangeWithHeadroomEU,
|
|
SensitivityMilliVoltsPerEU,
|
|
IsProportionalToExcitation,
|
|
IsInverted,
|
|
Excitation,
|
|
EngineeringUnits,
|
|
SerialNumber,
|
|
Description,
|
|
ZeroMethod,
|
|
ZeroAverageStartSeconds,
|
|
ZeroAverageStopSeconds,
|
|
InitialEU,
|
|
ShuntIsEnabled,
|
|
VoltageInsertCheckEnabled,
|
|
CalSignalIsEnabled,
|
|
RemoveOffset,
|
|
VerifyOffset,
|
|
OffsetToleranceLowMv,
|
|
OffsetToleranceHighMv,
|
|
ISOCode,
|
|
LevelTrigger,
|
|
SoftwareFrequency,
|
|
IEPEChannel,
|
|
Unipolar,
|
|
UnsupersampledSampleRate
|
|
};
|
|
[NonSerialized]
|
|
public const Fields FIRST_FIELD = Fields.TypeOfBridge;
|
|
[NonSerialized]
|
|
public const Fields LAST_FIELD = Fields.IEPEChannel;
|
|
/// <summary>
|
|
/// Type of Wheatstone Bridge in the sensor; half, full, etc.
|
|
/// </summary>
|
|
public SensorConstants.BridgeType TypeOfBridge { get; set; }
|
|
|
|
/// <summary>
|
|
/// 14042 Flash Clear turns of excitation for s6
|
|
/// this allows for ILevelTriggerable channels to store and cache a sample average for checking
|
|
/// level triggered
|
|
/// </summary>
|
|
double? ILevelTriggerable.SampleAverageADC { get; set; } = null;
|
|
|
|
/// <summary>
|
|
/// used during TDAS diagnostics, it's a throw away value that's computed during configuration
|
|
/// then compared to during measure shunt.
|
|
/// </summary>
|
|
public int ShuntTargetADC { get; set; } = Convert.ToInt32(.8D * short.MaxValue);
|
|
public SensorConstants.BridgeType[] SupportedBridges { get; set; }
|
|
|
|
/// <summary>
|
|
/// the types of digital input modes supported by the channel.
|
|
/// by default all digital modes are supported, and some hardware restrict the list (notably the g5)
|
|
/// </summary>
|
|
public DigitalInputModes[] SupportedDigitalInputModes { get; set; }
|
|
|
|
/// <summary>
|
|
/// IEPE Coupling mode (AC, AC/DC)
|
|
/// correct voltage base on this property.
|
|
/// </summary>
|
|
public SensorConstants.CouplingModes CouplingMode { get; set; }
|
|
|
|
/// <summary>
|
|
/// whether to use AC coupling when a bridge mode is on channel (full/half/quarter bridges)
|
|
/// 18294 Implement Bridge AC/DC coupling(fw update dependent)
|
|
/// </summary>
|
|
public bool ACCouplingModeEnabled { get; set; }
|
|
|
|
/// <summary>
|
|
/// Resistance of the Bridge in the sensor.
|
|
/// </summary>
|
|
public double BridgeResistanceOhms { get; set; }
|
|
|
|
/// <summary>
|
|
/// used to store 2D/3D IR-TRACC ZeroPoint Voltage data
|
|
/// </summary>
|
|
public double ZeroPoint { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
/// Bi-Polar maximum tolerance of sensor in Engineering Units.
|
|
/// </summary>
|
|
public double SensorCapacityEU { get; set; }
|
|
|
|
/// <summary>
|
|
/// Sensor capacity specified in sensor database.
|
|
/// </summary>
|
|
public double SensorCapacity { get; set; }
|
|
|
|
/// <summary>
|
|
/// Sensor polarity specified in sensor database.
|
|
/// </summary>
|
|
public string SensorPolarity { get; set; }
|
|
|
|
/// <summary>
|
|
/// The desired Bi-Polar range of readings (in Engineering Units)
|
|
/// from this sensor for this test or event. This must be
|
|
/// within the SensorCapacityEU of the sensor.
|
|
/// </summary>
|
|
public double DesiredRangeWithHeadroomEU { get; set; }
|
|
|
|
/// <summary>
|
|
/// Sensitivity of the sensor in Millivots per Engineering Unit
|
|
/// as specified by the sensor's manufacturer or hardware settings.
|
|
/// </summary>
|
|
public double SensitivityMilliVoltsPerEU { get; set; } = 0D;
|
|
|
|
|
|
public double SensitivityMilliVoltsPerEUNormalized => SensitivityMilliVoltsPerEU
|
|
* (IsProportionalToExcitation && SensitivityUnits != SensorConstants.SensUnits.mVperEU
|
|
? Test.Module.Channel.Sensor.GetExcitationVoltageMagnitudeFromEnum(Excitation) : 1.0)
|
|
/ (AtCapacity ? CapacityOutputIsBasedOn : 1.0);
|
|
|
|
/// <summary>
|
|
/// Are sensor readings proportional to excitation voltage?
|
|
/// </summary>
|
|
public bool IsProportionalToExcitation { get; set; }
|
|
|
|
public bool IsSupported(ExcitationVoltageOptions.ExcitationVoltageOption o)
|
|
{
|
|
foreach (var se in SupportedExcitation) { if (se == o) { return true; } }
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is this sensor's output inverted?
|
|
/// </summary>
|
|
public bool IsInverted { get; set; }
|
|
|
|
public string OriginalChannelName { get; set; }
|
|
public string ChannelName2 { get; set; }
|
|
|
|
/// <summary>
|
|
/// refers to a unique id for a logical channel in the test
|
|
/// for now this is using TestObjectChannel.GetId()
|
|
/// which is in the form of TestObjectSerial_ChannelType_ChannelId
|
|
/// </summary>
|
|
public string ChannelId { get; set; }
|
|
|
|
public string HardwareChannelName { get; set; }
|
|
|
|
public string DIUnits { get; set; }
|
|
public DigitalInputModes DigitalMode { get; set; }
|
|
|
|
private DigitalInputScaleMultiplier _digitalScaleMultiplier = new DigitalInputScaleMultiplier();
|
|
public DigitalInputScaleMultiplier DigitalMultiplier
|
|
{
|
|
get => _digitalScaleMultiplier ?? (_digitalScaleMultiplier = new DigitalInputScaleMultiplier());
|
|
set => _digitalScaleMultiplier = value;
|
|
}
|
|
|
|
public DTS.Common.Classes.Sensors.LinearizationFormula LinearizationFormula { get; set; }
|
|
/// <summary>
|
|
/// The excitation voltage to apply to the sensor. Firmware will provide the
|
|
/// correct voltage base on this property.
|
|
/// </summary>
|
|
public ExcitationVoltageOptions.ExcitationVoltageOption Excitation { get; set; }
|
|
|
|
public ExcitationVoltageOptions.ExcitationVoltageOption[] SupportedExcitation { get; set; }
|
|
/// <summary>
|
|
/// String representation of the Engineering Units this sensor reads, for example
|
|
/// "g" or "m/s/s" or "meters per second", etc. Not mathematically relevant, only
|
|
/// used for display.
|
|
/// </summary>
|
|
public string EngineeringUnits { get; set; }
|
|
|
|
/// <summary>
|
|
/// Serial number of the sensor.
|
|
/// </summary>
|
|
public string SerialNumber { get; set; }
|
|
|
|
/// <summary>
|
|
/// Manufacturer of the sensor.
|
|
/// </summary>
|
|
public string Manufacturer { get; set; }
|
|
|
|
/// <summary>
|
|
/// Model of the sensor.
|
|
/// </summary>
|
|
public string Model { get; set; }
|
|
|
|
/// <summary>
|
|
/// A text description of the sensor.
|
|
/// </summary>
|
|
public string Description { get; set; }
|
|
|
|
/// <summary>
|
|
/// How will this sensor be zeroed?
|
|
/// </summary>
|
|
public ZeroMethodType ZeroMethod { get; set; }
|
|
|
|
/// <summary>
|
|
/// Start time for the zero window relative to T=0
|
|
/// used if ZeroMethod is AverageOverTime.
|
|
/// </summary>
|
|
public double ZeroAverageStartSeconds { get; set; }
|
|
|
|
/// <summary>
|
|
/// Stop time for the zero window relative to T=0
|
|
/// used if ZeroMethod is AverageOverTime.
|
|
/// </summary>
|
|
public double ZeroAverageStopSeconds { get; set; }
|
|
|
|
/// <summary>
|
|
/// The initial EU value
|
|
/// </summary>
|
|
public double InitialEU { get; set; }
|
|
|
|
public string InitialOffset { get; set; }
|
|
|
|
public bool Unipolar { get; set; }
|
|
/// <summary>
|
|
/// Should the shunt be enabled?
|
|
/// </summary>
|
|
public bool ShuntIsEnabled { get; set; }
|
|
|
|
/// <summary>
|
|
/// some DAS require holding zeromV in adc in the xml configuration (slice2)
|
|
/// this is here to hold that information
|
|
/// </summary>
|
|
public short ZeromVInADC { get; set; }
|
|
|
|
/// <summary>
|
|
/// should voltage insertion (gain) check be enabled?
|
|
/// </summary>
|
|
public bool VoltageInsertionCheckEnabled { get; set; }
|
|
|
|
public bool IEPEChannel { get; set; }
|
|
public bool DigitalInputChannel { get; set; }
|
|
public bool CalSignalIsEnabled { get; set; }
|
|
/// <summary>
|
|
/// Setting this true will flag the hardware to compensate for the offset of the sensor
|
|
/// during a call to DiagnosticsService.Diagnose(...).
|
|
/// </summary>
|
|
public bool RemoveOffset { get; set; }
|
|
|
|
/// <summary>
|
|
/// Should we verify the measured offset to the limits?
|
|
/// </summary>
|
|
public bool VerifyOffset { get; set; }
|
|
|
|
/// <summary>
|
|
/// The lower limit on allowed offset for the connected sensor.
|
|
/// </summary>
|
|
public double OffsetToleranceLowMilliVolts { get; set; }
|
|
|
|
/// <summary>
|
|
/// The upper limit on allowed offset for the connected sensor.
|
|
/// </summary>
|
|
public double OffsetToleranceHighMilliVolts { get; set; }
|
|
|
|
public DateTime LastCalibrationDate { get; set; }
|
|
|
|
public DateTime CalDueDate { get; set; }
|
|
/// <summary>
|
|
/// The ISO code for this channel.
|
|
/// </summary>
|
|
public string ISOCode { get; set; }
|
|
|
|
/// <summary>
|
|
/// Not available on slice or G5. Remove for now?
|
|
/// </summary>
|
|
public bool BypassAAFilter { get; set; }
|
|
|
|
public string SensorID { get; set; }
|
|
/// <summary>
|
|
/// Get the channel diagnostics results (if available) for this channel.
|
|
/// </summary>
|
|
public IDiagnosticResult Diagnostics
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
IDiagnosticResult[] allChannelDiagnostics;
|
|
IEnumerable<IDiagnosticResult> theseChannelDiagnostics;
|
|
if (null == (allChannelDiagnostics = OwningModule.OwningDAS.ChannelDiagnosticsResults))
|
|
throw new NoDiagnosticsAvailable("No diagnostics available (for any channel)");
|
|
if (null == (theseChannelDiagnostics = (allChannelDiagnostics.Where(r => r.DASChannelNumber == Number))))
|
|
throw new NoDiagnosticsAvailable("No diagnostics available (for this channel)");
|
|
if (theseChannelDiagnostics.Count() > 1)
|
|
throw new TooManyDiagnosticsAvailable("Several diagnostics results were found for the specified channel; only one was expected");
|
|
if (theseChannelDiagnostics.Count() < 1)
|
|
{
|
|
throw new NoDiagnosticsAvailable("No diagnostics available (for this channel)");
|
|
}
|
|
return theseChannelDiagnostics.First();
|
|
}
|
|
|
|
catch (Exception ex)
|
|
{
|
|
throw new ApplicationException("encountered problem getting diagnostics for channel " + (Description ?? "<NULL>"), ex);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// some channels should not be refreshed from the database prior to running configuration, for example sensors that are part of a group
|
|
/// should not be updated from database
|
|
/// </summary>
|
|
|
|
public bool UpdateChannelFromDatabase { get; set; } = true;
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
/// <summary>
|
|
/// Get/set the "trigger below" threshold. Set to "null" to deactivate.
|
|
/// </summary>
|
|
public double? TriggerBelowThresholdEu
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
/// <summary>
|
|
/// Get/set the "trigger above" threshold. Set to "null" to deactivate.
|
|
/// </summary>
|
|
public double? TriggerAboveThresholdEu
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool AlreadyLevelTriggered
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public LevelTriggerTypes LevelTriggerType
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public double MeasuredEULevelTriggerCheck
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>
|
|
/// Temporary fix that'll be addressed in 1.1
|
|
/// </summary>
|
|
public double SoftwareFilterFrequency { get; set; }
|
|
|
|
/// <summary>
|
|
/// Fb 13120 For now continue using SoftwareFilterFrequency needs to be refactored to use SoftwareFilterClass instead
|
|
/// </summary>
|
|
public IFilterClass SoftwareFilterClass { get; set; }
|
|
|
|
/// <summary>
|
|
/// Get/set the <see cref="DTS.DASLib.Service.DiagnosticsResult"/> for this channel.
|
|
/// </summary>
|
|
public IDiagnosticResult DiagnosticInformation
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
var cals = from cal in OwningModule.OwningDAS.ChannelDiagnosticsResults
|
|
where cal.DASChannelNumber == Number
|
|
select cal;
|
|
|
|
// make sure we only got one
|
|
var diagnosticsResults = cals as IDiagnosticResult[] ?? cals.ToArray();
|
|
if (diagnosticsResults.Length > 1)
|
|
{
|
|
// "SensorDBTables.GetCalibrationBySerialNumberAndDate: Duplicate entries for {0} and {1}"
|
|
throw new ApplicationException("found duplicate calibration records for channel");
|
|
}
|
|
return diagnosticsResults.Any() ? diagnosticsResults.ToArray()[0] : null;
|
|
}
|
|
|
|
catch (Exception ex)
|
|
{
|
|
throw new ApplicationException("encountered problem getting value for " + GetType().FullName + ".CalibrationInformation property", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get/set the <see cref="double"/> measured excitation voltage.
|
|
/// </summary>
|
|
public double? MeasuredExcitationVolts
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return DiagnosticInformation.MeasuredExcitationMilliVolts / 1000.0;
|
|
}
|
|
|
|
catch (Exception ex)
|
|
{
|
|
throw new ApplicationException("encountered problem getting " + GetType().FullName + ".MeasuredExcitationVoltage property value", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get/set the <see cref="double"/> factory excitation voltage.
|
|
/// </summary>
|
|
public double? FactoryExcitationVolts
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return DiagnosticInformation.ExpectedExcitationMilliVolts / 1000.0;
|
|
}
|
|
|
|
catch (Exception ex)
|
|
{
|
|
throw new ApplicationException("encountered problem getting " + GetType().FullName + ".FactoryExcitationVoltage property value", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public double ScalefactorMilliVoltsPerADC { get; set; }
|
|
public double ScalefactorEngineeringUnitsPerADC { get; set; }
|
|
|
|
public double NoiseAsPercentOfFullScale { get; set; }
|
|
|
|
/// <summary>
|
|
/// If this channel is supersampled, what the regular sampling rate is
|
|
/// </summary>
|
|
public double UnsupersampledSampleRate { get; set; }
|
|
|
|
/// <summary>
|
|
/// A string representation of the channel object.
|
|
/// </summary>
|
|
/// <returns>Checks the description and serial number, in that order, and returns as a string the first
|
|
/// of those that is not null or empty. If both are bad it calls the ToString() method of
|
|
/// the base class. This will result in the ModuleChannelNumber being returned as a string.</returns>
|
|
public override string ToString()
|
|
{
|
|
if (!string.IsNullOrEmpty(Description.Trim()))
|
|
return Description.Trim();
|
|
if (!string.IsNullOrEmpty(SerialNumber.Trim()))
|
|
return SerialNumber.Trim();
|
|
return base.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// A constructor to initialize this object with a containing module and a channel number.
|
|
/// </summary>
|
|
/// <param name="owner"></param>
|
|
/// <param name="channelNumber"></param>
|
|
public AnalogInputDASChannel(DASModule owner, int channelNumber)
|
|
: base(owner, channelNumber)
|
|
{
|
|
VoltageInsertionCheckEnabled = true;
|
|
TypeOfBridge = SensorConstants.BridgeType.FullBridge;
|
|
BridgeResistanceOhms = 350;
|
|
ZeroPoint = 0;
|
|
DesiredRangeWithHeadroomEU = 0;
|
|
SensitivityMilliVoltsPerEU = 1;
|
|
IsProportionalToExcitation = true;
|
|
IsInverted = false;
|
|
LinearizationFormula = new DTS.Common.Classes.Sensors.LinearizationFormula();
|
|
DigitalMode = DigitalInputModes.CCNC;
|
|
DigitalMultiplier = new DigitalInputScaleMultiplier();
|
|
Excitation = ExcitationVoltageOptions.ExcitationVoltageOption.Volt5;
|
|
SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 };
|
|
|
|
SupportedBridges = new[] { SensorConstants.BridgeType.FullBridge,
|
|
SensorConstants.BridgeType.HalfBridge};
|
|
SupportedDigitalInputModes = new[] { DigitalInputModes.CCNC, DigitalInputModes.CCNO,
|
|
DigitalInputModes.THL, DigitalInputModes.TLH};
|
|
|
|
EngineeringUnits = "g";
|
|
SerialNumber = "";
|
|
Description = "";
|
|
ZeroMethod = ZeroMethodType.UsePreEventDiagnosticsZero;
|
|
ZeroAverageStartSeconds = 0;
|
|
ZeroAverageStopSeconds = 0;
|
|
InitialEU = 0;
|
|
InitialOffset = "";
|
|
ShuntIsEnabled = true;
|
|
VoltageInsertionCheckEnabled = true;
|
|
CalSignalIsEnabled = false;
|
|
IEPEChannel = false;
|
|
RemoveOffset = false;
|
|
VerifyOffset = false;
|
|
OffsetToleranceLowMilliVolts = -100;
|
|
OffsetToleranceHighMilliVolts = 100;
|
|
ISOCode = "";
|
|
IsoChannelName = "";
|
|
UserCode = "";
|
|
UserChannelName = "";
|
|
BypassAAFilter = false;
|
|
ScalefactorMilliVoltsPerADC = 1.0;
|
|
ScalefactorEngineeringUnitsPerADC = 1.0;
|
|
UnitConverision = 1.0;
|
|
NoiseAsPercentOfFullScale = 0.0;
|
|
LastCalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
CalDueDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
SensorID = "";
|
|
CouplingMode = SensorConstants.CouplingModes.AC;
|
|
ACCouplingModeEnabled = false;
|
|
Unipolar = false;
|
|
AtCapacity = false;
|
|
CapacityOutputIsBasedOn = 1.000;
|
|
SensitivityUnits = SensorConstants.SensUnits.NONE;
|
|
UnsupersampledSampleRate = 0;
|
|
//http://manuscript.dts.local/f/cases/19006/StatusInvalidCommand-error-running-diagnostics-with-SLICE-PRO-DIM
|
|
// Need to confirm configuration if POST test Diag because the DAS could have been disconnected.
|
|
DigitalInputChannel = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Basic constructor for this object.
|
|
/// </summary>
|
|
public AnalogInputDASChannel()
|
|
{
|
|
SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 };
|
|
SupportedBridges = new[] { SensorConstants.BridgeType.FullBridge,
|
|
SensorConstants.BridgeType.HalfBridge};
|
|
SupportedDigitalInputModes = new[]
|
|
{
|
|
DigitalInputModes.CCNC,
|
|
DigitalInputModes.CCNO,
|
|
DigitalInputModes.THL,
|
|
DigitalInputModes.TLH
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the channel has a serial number in the SerialNumber field, it is "Configured".
|
|
/// </summary>
|
|
public override bool IsConfigured()
|
|
{
|
|
return !string.IsNullOrEmpty(SerialNumber);
|
|
}
|
|
|
|
public override void WriteElementEnd(XmlWriter writer)
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
public override void WriteXml(XmlWriter writer)
|
|
{
|
|
base.WriteXml(writer);
|
|
|
|
// TypeOfBridge
|
|
XMLHelper.PutString(writer, "TypeOfBridge", TypeOfBridge.ToString());
|
|
|
|
// BridgeResistanceOhms
|
|
XMLHelper.PutDouble(writer, "BridgeResistanceOhms", BridgeResistanceOhms);
|
|
|
|
// ZeroPoint
|
|
XMLHelper.PutDouble(writer, "ZeroPoint", ZeroPoint);
|
|
|
|
// SensorCapacityEU
|
|
XMLHelper.PutDouble(writer, "SensorCapacityEU", SensorCapacityEU);
|
|
|
|
// DesiredRangeWithHeadroomEU
|
|
XMLHelper.PutDouble(writer, "DesiredRangeWithHeadroomEU", DesiredRangeWithHeadroomEU);
|
|
|
|
// SensitivityMilliVoltsPerEU
|
|
XMLHelper.PutDouble(writer, "SensitivityMilliVoltsPerEU", SensitivityMilliVoltsPerEU);
|
|
|
|
// IsProportionalToExcitation
|
|
XMLHelper.PutBool(writer, "IsProportionalToExcitation", IsProportionalToExcitation);
|
|
|
|
// IsInverted
|
|
XMLHelper.PutBool(writer, "IsInverted", IsInverted);
|
|
|
|
//LinearizationFormula
|
|
if (null != LinearizationFormula) { XMLHelper.PutString(writer, "LinearizationFormula", LinearizationFormula.ToSerializeString()); }
|
|
|
|
XMLHelper.PutString(writer, "DigitalMultiplier", DigitalMultiplier.ToSerializeDbString());
|
|
|
|
XMLHelper.PutString(writer, "DigitalMode", DigitalMode.ToString());
|
|
// Excitation
|
|
XMLHelper.PutString(writer, "Excitation", Excitation.ToString());
|
|
|
|
XMLHelper.PutString(writer, "SupportedExcitation", GetSupportedExcitationSerialized());
|
|
|
|
XMLHelper.PutString(writer, "SupportedBridges", GetSupportedBridgesSerialized());
|
|
// EngineeringUnits
|
|
XMLHelper.PutString(writer, "EngineeringUnits", EngineeringUnits);
|
|
|
|
// SerialNumber
|
|
XMLHelper.PutString(writer, "SerialNumber", SerialNumber);
|
|
|
|
// Description
|
|
XMLHelper.PutString(writer, "Description", Description);
|
|
|
|
// Manufacturer
|
|
XMLHelper.PutString(writer, "Manufacturer", Manufacturer);
|
|
|
|
// Model
|
|
XMLHelper.PutString(writer, "Model", Model);
|
|
|
|
// ZeroMethod
|
|
//XMLHelper.PutString(writer, "ZeroMethod", ZeroMethod.ToString());
|
|
switch (ZeroMethod)
|
|
{
|
|
case ZeroMethodType.UsePreEventDiagnosticsZero:
|
|
XMLHelper.PutString(writer, "ZeroMethod", "UsePreCalZero");
|
|
break;
|
|
default:
|
|
XMLHelper.PutString(writer, "ZeroMethod", ZeroMethod.ToString());
|
|
break;
|
|
}
|
|
|
|
// ZeroAverageStartSeconds
|
|
XMLHelper.PutDouble(writer, "ZeroAverageStartSeconds", ZeroAverageStartSeconds);
|
|
|
|
// ZeroAverageStopSeconds
|
|
XMLHelper.PutDouble(writer, "ZeroAverageStopSeconds", ZeroAverageStopSeconds);
|
|
|
|
// InitialEU
|
|
XMLHelper.PutDouble(writer, "InitialEU", InitialEU);
|
|
XMLHelper.PutInt(writer, "ZeromVInADC", ZeromVInADC);
|
|
XMLHelper.PutString(writer, "InitialOffset", InitialOffset);
|
|
|
|
XMLHelper.PutBool(writer, "Unipolar", Unipolar);
|
|
// ShuntIsEnabled
|
|
XMLHelper.PutBool(writer, "ShuntIsEnabled", ShuntIsEnabled);
|
|
|
|
//VoltageInsertionCheckIsEnabled
|
|
XMLHelper.PutBool(writer, "VoltageInsertionCheckEnabled", VoltageInsertionCheckEnabled);
|
|
|
|
// CalSignalIsEnabled
|
|
XMLHelper.PutBool(writer, "CalSignalIsEnabled", CalSignalIsEnabled);
|
|
|
|
// IEPEChannel
|
|
XMLHelper.PutBool(writer, "IEPEChannel", IEPEChannel);
|
|
|
|
// DigitalInputChannel
|
|
//http://manuscript.dts.local/f/cases/19006/StatusInvalidCommand-error-running-diagnostics-with-SLICE-PRO-DIM
|
|
// Need to confirm configuration if POST test Diag because the DAS could have been disconnected.
|
|
XMLHelper.PutBool(writer, DIGITIALINPUTCHANNEL_TAG, DigitalInputChannel);
|
|
|
|
XMLHelper.PutString(writer, "CouplingMode", CouplingMode.ToString());
|
|
|
|
//18294 Implement Bridge AC / DC coupling(fw update dependent)
|
|
XMLHelper.PutBool(writer, ACCOUPLINGMODEENABLED_TAG, ACCouplingModeEnabled);
|
|
|
|
// RemoveOffset
|
|
XMLHelper.PutBool(writer, "RemoveOffset", RemoveOffset);
|
|
|
|
// VerifyOffset
|
|
XMLHelper.PutBool(writer, "VerifyOffset", VerifyOffset);
|
|
|
|
// OffsetToleranceLowMilliVolts
|
|
XMLHelper.PutDouble(writer, "OffsetToleranceLowMilliVolts", OffsetToleranceLowMilliVolts);
|
|
|
|
// OffsetToleranceHighMilliVolts
|
|
XMLHelper.PutDouble(writer, "OffsetToleranceHighMilliVolts", OffsetToleranceHighMilliVolts);
|
|
|
|
// ISOCode
|
|
XMLHelper.PutString(writer, "ISOCode", ISOCode);
|
|
|
|
// BypassAAFilter
|
|
XMLHelper.PutBool(writer, "BypassAAFilter", BypassAAFilter);
|
|
|
|
// TriggerAboveThresholdEu
|
|
XMLHelper.PutOptionalDouble(writer, "TriggerAboveThresholdEu", TriggerAboveThresholdEu);
|
|
|
|
// TriggerBelowThresholdEu
|
|
XMLHelper.PutOptionalDouble(writer, "TriggerBelowThresholdEu", TriggerBelowThresholdEu);
|
|
|
|
XMLHelper.PutString(writer, "LevelTriggerType", LevelTriggerType.ToString());
|
|
// SoftwareFilterFrequency
|
|
XMLHelper.PutDouble(writer, "SoftwareFilterFrequency", SoftwareFilterFrequency);
|
|
|
|
// ScalefactorMilliVoltsPerADC
|
|
XMLHelper.PutDouble(writer, "ScalefactorMilliVoltsPerADC", ScalefactorMilliVoltsPerADC);
|
|
|
|
// UnitConversion
|
|
XMLHelper.PutDouble(writer, "UnitConversion", UnitConverision);
|
|
|
|
// AtCapacity
|
|
XMLHelper.PutBool(writer, "AtCapacity", AtCapacity);
|
|
|
|
//IsoChannelName
|
|
XMLHelper.PutString(writer, "IsoChannelName", IsoChannelName);
|
|
|
|
//UserCode
|
|
XMLHelper.PutString(writer, "UserCode", UserCode);
|
|
|
|
//UserChannelName
|
|
XMLHelper.PutString(writer, "UserChannelName", UserChannelName);
|
|
|
|
// CapacityOutputIsBasedOn
|
|
XMLHelper.PutDouble(writer, "CapacityOutputIsBasedOn", CapacityOutputIsBasedOn);
|
|
|
|
// SensitivityUnits
|
|
XMLHelper.PutString(writer, "SensitivityUnits", SensitivityUnits.ToString());
|
|
|
|
//NoiseAsPercentOfFullScale
|
|
XMLHelper.PutDouble(writer, NOISEASPERCENTOFFULLSCALE_TAG, NoiseAsPercentOfFullScale);
|
|
|
|
XMLHelper.PutString(writer, "LastCalibrationDate", LastCalibrationDate.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
XMLHelper.PutString(writer, "CalDueDate", CalDueDate.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
XMLHelper.PutString(writer, "SensorID", SensorID);
|
|
XMLHelper.PutString(writer, "OriginalChannelName", OriginalChannelName);
|
|
XMLHelper.PutString(writer, "ChannelName2", ChannelName2);
|
|
XMLHelper.PutString(writer, "ChannelId", ChannelId);
|
|
XMLHelper.PutString(writer, "ChannelGroupName", ChannelGroupName);
|
|
XMLHelper.PutString(writer, "HardwareChannelName", HardwareChannelName);
|
|
|
|
// SensorCapacity
|
|
XMLHelper.PutDouble(writer, "SensorCapacity", SensorCapacity);
|
|
|
|
// SensorPolarity
|
|
XMLHelper.PutString(writer, "SensorPolarity", SensorPolarity);
|
|
// UnsupersampledSampleRate
|
|
XMLHelper.PutDouble(writer, "UnsupersampledSampleRate", UnsupersampledSampleRate);
|
|
}
|
|
public string GetSupportedExcitationSerialized()
|
|
{
|
|
var sb = new StringBuilder();
|
|
foreach (var e in SupportedExcitation)
|
|
{
|
|
if (sb.Length > 0) { sb.Append(_SEPARATOR); }
|
|
sb.Append(e);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
private const string _SEPARATOR = "@";
|
|
public string GetSupportedDigitalInputModesSerialized()
|
|
{
|
|
var sb = new StringBuilder();
|
|
foreach (var s in SupportedDigitalInputModes)
|
|
{
|
|
if (sb.Length > 0) { sb.Append(_SEPARATOR); }
|
|
sb.Append(s);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public string GetSupportedBridgesSerialized()
|
|
{
|
|
var sb = new StringBuilder();
|
|
foreach (var e in SupportedBridges)
|
|
{
|
|
if (sb.Length > 0) { sb.Append(_SEPARATOR); }
|
|
sb.Append(e);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
public override void WriteXmlCRC32(XmlWriter writer)
|
|
{
|
|
base.WriteXmlCRC32(writer);
|
|
|
|
// TypeOfBridge
|
|
XMLHelper.PutString(writer, "TypeOfBridge", TypeOfBridge.ToString());
|
|
|
|
// BridgeResistanceOhms
|
|
XMLHelper.PutDouble(writer, "BridgeResistanceOhms", BridgeResistanceOhms);
|
|
|
|
// ZeroPoint
|
|
XMLHelper.PutDouble(writer, "ZeroPoint", ZeroPoint);
|
|
|
|
// SensorCapacityEU
|
|
XMLHelper.PutDouble(writer, "SensorCapacityEU", SensorCapacityEU);
|
|
|
|
// DesiredRangeWithHeadroomEU
|
|
XMLHelper.PutDouble(writer, "DesiredRangeWithHeadroomEU", DesiredRangeWithHeadroomEU);
|
|
|
|
// SensitivityMilliVoltsPerEU
|
|
XMLHelper.PutDouble(writer, "SensitivityMilliVoltsPerEU", SensitivityMilliVoltsPerEU);
|
|
|
|
// IsProportionalToExcitation
|
|
XMLHelper.PutBool(writer, "IsProportionalToExcitation", IsProportionalToExcitation);
|
|
|
|
if (null != LinearizationFormula)
|
|
{
|
|
XMLHelper.PutString(writer, "LinearizationFormula", LinearizationFormula.ToSerializeString());
|
|
}
|
|
|
|
XMLHelper.PutString(writer, "DigitalMultiplier", DigitalMultiplier.ToSerializeDbString());
|
|
XMLHelper.PutString(writer, "DigitalMode", DigitalMode.ToString());
|
|
|
|
// IsInverted
|
|
XMLHelper.PutBool(writer, "IsInverted", IsInverted);
|
|
|
|
// Excitation
|
|
XMLHelper.PutString(writer, "Excitation", Excitation.ToString());
|
|
|
|
XMLHelper.PutString(writer, "SupportedExcitation", GetSupportedExcitationSerialized());
|
|
XMLHelper.PutString(writer, "SupportedBridges", GetSupportedBridgesSerialized());
|
|
|
|
// EngineeringUnits
|
|
XMLHelper.PutString(writer, "EngineeringUnits", EngineeringUnits);
|
|
|
|
// SerialNumber
|
|
XMLHelper.PutString(writer, "SerialNumber", SerialNumber);
|
|
|
|
// Description
|
|
XMLHelper.PutString(writer, "Description", Description);
|
|
|
|
// ZeroMethod
|
|
//XMLHelper.PutString(writer, "ZeroMethod", ZeroMethod.ToString());
|
|
switch (ZeroMethod)
|
|
{
|
|
case ZeroMethodType.UsePreEventDiagnosticsZero:
|
|
XMLHelper.PutString(writer, "ZeroMethod", "UsePreCalZero");
|
|
break;
|
|
default:
|
|
XMLHelper.PutString(writer, "ZeroMethod", ZeroMethod.ToString());
|
|
break;
|
|
}
|
|
|
|
// ZeroAverageStartSeconds
|
|
XMLHelper.PutDouble(writer, "ZeroAverageStartSeconds", ZeroAverageStartSeconds);
|
|
|
|
// ZeroAverageStopSeconds
|
|
XMLHelper.PutDouble(writer, "ZeroAverageStopSeconds", ZeroAverageStopSeconds);
|
|
|
|
XMLHelper.PutString(writer, "InitialOffset", InitialOffset);
|
|
// InitialEU
|
|
XMLHelper.PutDouble(writer, "InitialEU", InitialEU);
|
|
XMLHelper.PutInt(writer, "ZeromVInADC", ZeromVInADC);
|
|
XMLHelper.PutBool(writer, "Unipolar", Unipolar);
|
|
// ShuntIsEnabled
|
|
XMLHelper.PutBool(writer, "ShuntIsEnabled", ShuntIsEnabled);
|
|
|
|
//VoltageInsertionCheckEnabled
|
|
XMLHelper.PutBool(writer, "VoltageInsertionCheckEnabled", VoltageInsertionCheckEnabled);
|
|
|
|
// CalSignalIsEnabled
|
|
XMLHelper.PutBool(writer, "CalSignalIsEnabled", CalSignalIsEnabled);
|
|
|
|
// RemoveOffset
|
|
XMLHelper.PutBool(writer, "RemoveOffset", RemoveOffset);
|
|
|
|
XMLHelper.PutBool(writer, "IEPEChannel", IEPEChannel);
|
|
|
|
// DigitalInputChannel
|
|
//http://manuscript.dts.local/f/cases/19006/StatusInvalidCommand-error-running-diagnostics-with-SLICE-PRO-DIM
|
|
// Need to confirm configuration if POST test Diag because the DAS could have been disconnected.
|
|
XMLHelper.PutBool(writer, DIGITIALINPUTCHANNEL_TAG, DigitalInputChannel);
|
|
|
|
XMLHelper.PutString(writer, "CouplingMode", CouplingMode.ToString());
|
|
|
|
//18294 Implement Bridge AC / DC coupling(fw update dependent)
|
|
XMLHelper.PutBool(writer, ACCOUPLINGMODEENABLED_TAG, ACCouplingModeEnabled);
|
|
|
|
// VerifyOffset
|
|
XMLHelper.PutBool(writer, "VerifyOffset", VerifyOffset);
|
|
|
|
// OffsetToleranceLowMilliVolts
|
|
XMLHelper.PutDouble(writer, "OffsetToleranceLowMilliVolts", OffsetToleranceLowMilliVolts);
|
|
|
|
// OffsetToleranceHighMilliVolts
|
|
XMLHelper.PutDouble(writer, "OffsetToleranceHighMilliVolts", OffsetToleranceHighMilliVolts);
|
|
|
|
// ISOCode
|
|
XMLHelper.PutString(writer, "ISOCode", ISOCode);
|
|
|
|
// BypassAAFilter
|
|
XMLHelper.PutBool(writer, "BypassAAFilter", BypassAAFilter);
|
|
|
|
// TriggerAboveThresholdEu
|
|
XMLHelper.PutOptionalDouble(writer, "TriggerAboveThresholdEu", TriggerAboveThresholdEu);
|
|
|
|
// TriggerBelowThresholdEu
|
|
XMLHelper.PutOptionalDouble(writer, "TriggerBelowThresholdEu", TriggerBelowThresholdEu);
|
|
|
|
XMLHelper.PutString(writer, "LevelTriggerType", LevelTriggerType.ToString());
|
|
// SoftwareFilterFrequency
|
|
//XMLHelper.PutDouble(writer, "SoftwareFilterFrequency", SoftwareFilterFrequency);
|
|
|
|
// ScalefactorMilliVoltsPerADC
|
|
//XMLHelper.PutDouble(writer, "ScalefactorMilliVoltsPerADC", ScalefactorMilliVoltsPerADC);
|
|
|
|
//NoiseAsPercentOfFullScale
|
|
//XMLHelper.PutDouble(writer, NOISEASPERCENTOFFULLSCALE_TAG, NoiseAsPercentOfFullScale);
|
|
|
|
XMLHelper.PutString(writer, "LastCalibrationDate", LastCalibrationDate.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
XMLHelper.PutString(writer, "CalDueDate", CalDueDate.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
XMLHelper.PutString(writer, "SensorID", SensorID);
|
|
XMLHelper.PutString(writer, "OriginalChannelName", OriginalChannelName);
|
|
XMLHelper.PutString(writer, "ChannelName2", ChannelName2);
|
|
XMLHelper.PutString(writer, "ChannelId", ChannelId);
|
|
XMLHelper.PutString(writer, "ChannelGroupName", ChannelGroupName);
|
|
XMLHelper.PutString(writer, "HardwareChannelName", HardwareChannelName);
|
|
|
|
// SensorCapacity
|
|
XMLHelper.PutDouble(writer, "SensorCapacity", SensorCapacity);
|
|
|
|
// SensorPolarity
|
|
XMLHelper.PutString(writer, "SensorPolarity", SensorPolarity);
|
|
}
|
|
private const string NOISEASPERCENTOFFULLSCALE_TAG = "NoiseAsPercentOfFullScale";
|
|
private ExcitationVoltageOptions.ExcitationVoltageOption[] DeserializeSupportedExcitation(string s)
|
|
{
|
|
var options = new List<ExcitationVoltageOptions.ExcitationVoltageOption>();
|
|
var tokens = s.Split('@');
|
|
foreach (var token in tokens)
|
|
{
|
|
options.Add((ExcitationVoltageOptions.ExcitationVoltageOption)Enum.Parse(typeof(ExcitationVoltageOptions.ExcitationVoltageOption), token));
|
|
}
|
|
return options.ToArray();
|
|
}
|
|
private DigitalInputModes[] DeserializeSupportedDigitalInputModes(string s)
|
|
{
|
|
var options = new List<DigitalInputModes>();
|
|
var tokens = s.Split('@');
|
|
foreach (var token in tokens)
|
|
{
|
|
options.Add((DigitalInputModes)Enum.Parse(typeof(DigitalInputModes), token));
|
|
}
|
|
return options.ToArray();
|
|
}
|
|
private SensorConstants.BridgeType[] DeserializeSupportedBridges(string s)
|
|
{
|
|
var options = new List<SensorConstants.BridgeType>();
|
|
var tokens = s.Split('@');
|
|
foreach (var token in tokens)
|
|
{
|
|
options.Add((SensorConstants.BridgeType)Enum.Parse(typeof(SensorConstants.BridgeType), token));
|
|
}
|
|
return options.ToArray();
|
|
}
|
|
private const string TYPEOFBRIDGE_TAG = "TypeOfBridge";
|
|
private const string BRIDGERESISTANCE_TAG = "BridgeResistanceOhms";
|
|
private const string ZEROPOINT_TAG = "ZeroPoint";
|
|
private const string SENSORCAPACITYEU_TAG = "SensorCapacityEU";
|
|
private const string SENSORCAPACITY_TAG = "SensorCapacity";
|
|
private const string SENSORPOLARITY_TAG = "SensorPolarity";
|
|
private const string DIGITALMULTIPLIER_TAG = "DigitalMultiplier";
|
|
private const string DIGITALMODE_TAG = "DigitalMode";
|
|
private const string DESIREDRANGEWITHHEADROOM_TAG = "DesiredRangeWithHeadroomEU";
|
|
private const string DESIREDRANGEEU_TAG = "DesiredRangeEU";
|
|
private const string LINEARIZATIONFORMULA_TAG = "LinearizationFormula";
|
|
private const string SENSITIVITYMILLIVOLTSPEREU_TAG = "SensitivityMilliVoltsPerEU";
|
|
private const string ISPROPORTIONAL_TAG = "IsProportionalToExcitation";
|
|
private const string ISINVERTED_TAG = "IsInverted";
|
|
private const string EXCITATION_TAG = "Excitation";
|
|
private const string SUPPORTEDEXCITATION_TAG = "SupportedExcitation";
|
|
private const string SUPPORTEDDIGITALINPUTMODES_TAG = "SupportedDigitalInputModes";
|
|
private const string SUPPORTEDBRIDGES_TAG = "SupportedBridges";
|
|
private const string ENGINEERINGUNITS_TAG = "EngineeringUnits";
|
|
private const string SERIALNUMBER_TAG = "SerialNumber";
|
|
private const string DESCRIPTION_TAG = "Description";
|
|
private const string MANUFACTURER_TAG = "Manufacturer";
|
|
private const string MODEL_TAG = "Model";
|
|
private const string ZEROMETHOD_TAG = "ZeroMethod";
|
|
private const string ZEROAVERAGESTARTSECONDS_TAG = "ZeroAverageStartSeconds";
|
|
private const string ZEROAVERAGESTOPSECONDS_TAG = "ZeroAverageStopSeconds";
|
|
private const string INITIALOFFSET_TAG = "InitialOffset";
|
|
private const string INITIALEU_TAG = "InitialEU";
|
|
private const string ZEROMVINADC_TAG = "ZeromVInADC";
|
|
private const string UNIPOLAR_TAG = "Unipolar";
|
|
private const string SHUNTISENABLED_TAG = "ShuntIsEnabled";
|
|
private const string IEPECHANNEL_TAG = "IEPEChannel";
|
|
//http://manuscript.dts.local/f/cases/19006/StatusInvalidCommand-error-running-diagnostics-with-SLICE-PRO-DIM
|
|
// Need to confirm configuration if POST test Diag because the DAS could have been disconnected.
|
|
private const string DIGITIALINPUTCHANNEL_TAG = "DigitalInputChannel";
|
|
private const string COUPLINGMODE_TAG = "CouplingMode";
|
|
private const string ACCOUPLINGMODEENABLED_TAG = "ACCouplingModeEnabled";
|
|
private const string VOLTAGEINSERTIONCHECKENABLED_TAG = "VoltageInsertionCheckEnabled";
|
|
private const string CALSIGNALISENABLED_TAG = "CalSignalIsEnabled";
|
|
private const string REMOVEOFFSET_TAG = "RemoveOffset";
|
|
private const string VERIFYOFFSET_TAG = "VerifyOffset";
|
|
private const string OFFSETTOLERANCELOWMV_TAG = "OffsetToleranceLowMilliVolts";
|
|
private const string OFFSETTOLERANCEHIGHMV_TAG = "OffsetToleranceHighMilliVolts";
|
|
private const string ISOCODE_TAG = "ISOCode";
|
|
private const string BYPASSAAFILTER_TAG = "BypassAAFilter";
|
|
private const string ISOCHANNELNAME_TAG = "IsoChannelName";
|
|
private const string USERCODE_TAG = "UserCode";
|
|
private const string USERCHANNELNAME_TAG = "UserChannelName";
|
|
private const string LEVELTRIGGERTYPE_TAG = "LevelTriggerType";
|
|
private const string TRIGGERABOVEEU_TAG = "TriggerAboveThresholdEu";
|
|
private const string TRIGGERBELOWEU_TAG = "TriggerBelowThresholdEu";
|
|
private const string SOFTWAREFILTERHZ_TAG = "SoftwareFilterFrequency";
|
|
private const string SCALEFACTORMVPERADC_TAG = "ScalefactorMilliVoltsPerADC";
|
|
private const string UNITCONVERSION_TAG = "UnitConversion";
|
|
private const string ATCAPACITY_TAG = "AtCapacity";
|
|
private const string CAPACITYOUTPUT_TAG = "CapacityOutputIsBasedOn";
|
|
private const string SENSITIVITY_TAG = "SensitivityUnits";
|
|
private const string LASTCALIBRATIONDATE_TAG = "LastCalibrationDate";
|
|
private const string CALDUEDATE_TAG = "CalDueDate";
|
|
private const string SENSORID_TAG = "SensorID";
|
|
private const string CHANNELID_TAG = "ChannelId";
|
|
private const string CHANNELGROUPNAME_TAG = "ChannelGroupName";
|
|
private const string ORIGINALCHANNELNAME_TAG = "OriginalChannelName";
|
|
private const string CHANNELNAME2_TAG = "ChannelName2";
|
|
private const string HARDWARECHANNELNAME_TAG = "HardwareChannelName";
|
|
private const string UNSUPERSAMPLEDSAMPLERATE_TAG = "UnsupersampledSampleRate";
|
|
|
|
protected override void HandleElement(XmlReader reader)
|
|
{
|
|
base.HandleElement(reader);
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
{
|
|
var value = string.Empty;
|
|
switch (reader.Name)
|
|
{
|
|
case TYPEOFBRIDGE_TAG:
|
|
value = XMLHelper.GetString(reader);
|
|
TypeOfBridge = (SensorConstants.BridgeType)Enum.Parse(typeof(SensorConstants.BridgeType), value);
|
|
break;
|
|
case BRIDGERESISTANCE_TAG:
|
|
BridgeResistanceOhms = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ZEROPOINT_TAG:
|
|
ZeroPoint = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SENSORCAPACITYEU_TAG:
|
|
SensorCapacityEU = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SENSORCAPACITY_TAG:
|
|
SensorCapacity = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SENSORPOLARITY_TAG:
|
|
SensorPolarity = XMLHelper.GetString(reader);
|
|
break;
|
|
case DIGITALMULTIPLIER_TAG:
|
|
try
|
|
{
|
|
DigitalMultiplier = new DigitalInputScaleMultiplier();
|
|
DigitalMultiplier.FromDbSerializeString(XMLHelper.GetString(reader));
|
|
}
|
|
catch (Exception) { }
|
|
break;
|
|
case DIGITALMODE_TAG:
|
|
{
|
|
DigitalInputModes mode;
|
|
Enum.TryParse(XMLHelper.GetString(reader), out mode);
|
|
DigitalMode = mode;
|
|
}
|
|
break;
|
|
case DESIREDRANGEEU_TAG:
|
|
case DESIREDRANGEWITHHEADROOM_TAG: // old
|
|
DesiredRangeWithHeadroomEU = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case LINEARIZATIONFORMULA_TAG:
|
|
LinearizationFormula = new DTS.Common.Classes.Sensors.LinearizationFormula();
|
|
LinearizationFormula.FromSerializeString(XMLHelper.GetString(reader));
|
|
break;
|
|
case SENSITIVITYMILLIVOLTSPEREU_TAG:
|
|
SensitivityMilliVoltsPerEU = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ISPROPORTIONAL_TAG:
|
|
IsProportionalToExcitation = XMLHelper.GetBool(reader);
|
|
break;
|
|
case ISINVERTED_TAG:
|
|
IsInverted = XMLHelper.GetBool(reader);
|
|
break;
|
|
case EXCITATION_TAG:
|
|
value = XMLHelper.GetString(reader);
|
|
Excitation = (ExcitationVoltageOptions.ExcitationVoltageOption)Enum.Parse(typeof(ExcitationVoltageOptions.ExcitationVoltageOption), value);
|
|
break;
|
|
case SUPPORTEDEXCITATION_TAG:
|
|
SupportedExcitation = DeserializeSupportedExcitation(XMLHelper.GetString(reader));
|
|
break;
|
|
case SUPPORTEDDIGITALINPUTMODES_TAG:
|
|
SupportedDigitalInputModes = DeserializeSupportedDigitalInputModes(XMLHelper.GetString(reader));
|
|
break;
|
|
case SUPPORTEDBRIDGES_TAG:
|
|
SupportedBridges = DeserializeSupportedBridges(XMLHelper.GetString(reader));
|
|
break;
|
|
case ENGINEERINGUNITS_TAG:
|
|
EngineeringUnits = XMLHelper.GetString(reader);
|
|
break;
|
|
case SERIALNUMBER_TAG:
|
|
SerialNumber = XMLHelper.GetString(reader);
|
|
break;
|
|
case DESCRIPTION_TAG:
|
|
Description = XMLHelper.GetString(reader);
|
|
break;
|
|
case MANUFACTURER_TAG:
|
|
Manufacturer = XMLHelper.GetString(reader);
|
|
break;
|
|
case MODEL_TAG:
|
|
Model = XMLHelper.GetString(reader);
|
|
break;
|
|
case ZEROMETHOD_TAG:
|
|
value = XMLHelper.GetString(reader);
|
|
// support older version
|
|
if (value == "UsePreCalZero")
|
|
{
|
|
ZeroMethod = ZeroMethodType.UsePreEventDiagnosticsZero;
|
|
}
|
|
else
|
|
{
|
|
ZeroMethod = (ZeroMethodType)Enum.Parse(typeof(ZeroMethodType), value);
|
|
}
|
|
break;
|
|
case ZEROAVERAGESTARTSECONDS_TAG:
|
|
ZeroAverageStartSeconds = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ZEROAVERAGESTOPSECONDS_TAG:
|
|
ZeroAverageStopSeconds = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case INITIALOFFSET_TAG:
|
|
InitialOffset = XMLHelper.GetString(reader);
|
|
break;
|
|
case INITIALEU_TAG:
|
|
InitialEU = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ZEROMVINADC_TAG:
|
|
ZeromVInADC = Convert.ToInt16(XMLHelper.GetInt(reader));
|
|
break;
|
|
case UNIPOLAR_TAG:
|
|
Unipolar = XMLHelper.GetBool(reader);
|
|
break;
|
|
case SHUNTISENABLED_TAG:
|
|
ShuntIsEnabled = XMLHelper.GetBool(reader);
|
|
break;
|
|
case IEPECHANNEL_TAG:
|
|
IEPEChannel = XMLHelper.GetBool(reader);
|
|
break;
|
|
//http://manuscript.dts.local/f/cases/19006/StatusInvalidCommand-error-running-diagnostics-with-SLICE-PRO-DIM
|
|
// Need to confirm configuration if POST test Diag because the DAS could have been disconnected.
|
|
case DIGITIALINPUTCHANNEL_TAG:
|
|
DigitalInputChannel = XMLHelper.GetBool(reader);
|
|
break;
|
|
case COUPLINGMODE_TAG:
|
|
CouplingMode = (SensorConstants.CouplingModes)Enum.Parse(typeof(SensorConstants.CouplingModes), XMLHelper.GetString(reader));
|
|
break;
|
|
case VOLTAGEINSERTIONCHECKENABLED_TAG:
|
|
VoltageInsertionCheckEnabled = true;
|
|
XMLHelper.GetBool(reader);//we ignore the result for now.
|
|
break;
|
|
case CALSIGNALISENABLED_TAG:
|
|
CalSignalIsEnabled = XMLHelper.GetBool(reader);
|
|
break;
|
|
case REMOVEOFFSET_TAG:
|
|
RemoveOffset = XMLHelper.GetBool(reader);
|
|
break;
|
|
case VERIFYOFFSET_TAG:
|
|
VerifyOffset = XMLHelper.GetBool(reader);
|
|
break;
|
|
case OFFSETTOLERANCELOWMV_TAG:
|
|
OffsetToleranceLowMilliVolts = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case OFFSETTOLERANCEHIGHMV_TAG:
|
|
OffsetToleranceHighMilliVolts = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ISOCODE_TAG:
|
|
ISOCode = XMLHelper.GetString(reader);
|
|
break;
|
|
case BYPASSAAFILTER_TAG:
|
|
BypassAAFilter = XMLHelper.GetBool(reader);
|
|
break;
|
|
case ISOCHANNELNAME_TAG:
|
|
IsoChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case USERCODE_TAG:
|
|
UserCode = XMLHelper.GetString(reader);
|
|
break;
|
|
case USERCHANNELNAME_TAG:
|
|
UserChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case LEVELTRIGGERTYPE_TAG:
|
|
try
|
|
{
|
|
LevelTriggerType = (LevelTriggerTypes)Enum.Parse(typeof(LevelTriggerTypes), XMLHelper.GetString(reader));
|
|
}
|
|
catch (Exception ex) { APILogger.Log(ex); }
|
|
break;
|
|
case TRIGGERABOVEEU_TAG:
|
|
TriggerAboveThresholdEu = XMLHelper.GetOptionalDouble(reader);
|
|
break;
|
|
case TRIGGERBELOWEU_TAG:
|
|
TriggerBelowThresholdEu = XMLHelper.GetOptionalDouble(reader);
|
|
break;
|
|
case SOFTWAREFILTERHZ_TAG:
|
|
SoftwareFilterFrequency = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SCALEFACTORMVPERADC_TAG:
|
|
ScalefactorMilliVoltsPerADC = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case UNITCONVERSION_TAG:
|
|
UnitConverision = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case ATCAPACITY_TAG:
|
|
AtCapacity = XMLHelper.GetBool(reader);
|
|
break;
|
|
case CAPACITYOUTPUT_TAG:
|
|
CapacityOutputIsBasedOn = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SENSITIVITY_TAG:
|
|
var su = XMLHelper.GetString(reader);
|
|
SensitivityUnits = (SensorConstants.SensUnits)Enum.Parse(typeof(SensorConstants.SensUnits), su);
|
|
break;
|
|
case LASTCALIBRATIONDATE_TAG:
|
|
{
|
|
DateTime d;
|
|
if (DateTime.TryParse(XMLHelper.GetString(reader), System.Globalization.CultureInfo.InvariantCulture,
|
|
System.Globalization.DateTimeStyles.None, out d))
|
|
{
|
|
LastCalibrationDate = d;
|
|
}
|
|
}
|
|
break;
|
|
case CALDUEDATE_TAG:
|
|
{
|
|
DateTime d;
|
|
if (DateTime.TryParse(XMLHelper.GetString(reader), System.Globalization.CultureInfo.InvariantCulture,
|
|
System.Globalization.DateTimeStyles.None, out d))
|
|
{
|
|
CalDueDate = d;
|
|
}
|
|
}
|
|
break;
|
|
case NOISEASPERCENTOFFULLSCALE_TAG:
|
|
NoiseAsPercentOfFullScale = XMLHelper.GetDouble(reader);
|
|
break;
|
|
case SENSORID_TAG:
|
|
SensorID = XMLHelper.GetString(reader);
|
|
break;
|
|
case CHANNELID_TAG:
|
|
ChannelId = XMLHelper.GetString(reader);
|
|
break;
|
|
case CHANNELGROUPNAME_TAG:
|
|
ChannelGroupName = XMLHelper.GetString(reader);
|
|
break;
|
|
case ORIGINALCHANNELNAME_TAG:
|
|
OriginalChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case CHANNELNAME2_TAG:
|
|
ChannelName2 = XMLHelper.GetString(reader);
|
|
break;
|
|
case HARDWARECHANNELNAME_TAG:
|
|
HardwareChannelName = XMLHelper.GetString(reader);
|
|
break;
|
|
case UNSUPERSAMPLEDSAMPLERATE_TAG:
|
|
UnsupersampledSampleRate = XMLHelper.GetDouble(reader);
|
|
break;
|
|
//18294 Implement Bridge AC/DC coupling (fw update dependent)
|
|
//default here is false, we shouldn't get here unless the tag is found,
|
|
//but just for safety don't trust the getbool
|
|
case ACCOUPLINGMODEENABLED_TAG:
|
|
try
|
|
{
|
|
ACCouplingModeEnabled = XMLHelper.GetBool(reader);
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
APILogger.Log($"Failed to retrieve ACCouplingModeEnabled from xml, {ex.Message}");
|
|
ACCouplingModeEnabled = false;
|
|
}
|
|
break;
|
|
default:
|
|
// let child handle it
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Datascaler object for this AnalogInputDASChannel; should already have diagnostic information by time of use.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public DataScaler GetDataScaler()
|
|
{
|
|
var ds = new DataScaler();
|
|
if (null != DiagnosticInformation)
|
|
{
|
|
//hardware with diagnostics stuff
|
|
if (ZeroMethod == ZeroMethodType.None)
|
|
{
|
|
if (RemoveOffset && TypeOfBridge != SensorConstants.BridgeType.IEPE)
|
|
{
|
|
if (null != DiagnosticInformation.FinalOffsetADC)
|
|
{
|
|
ds.SetDataZeroLevelADC((short)DiagnosticInformation.FinalOffsetADC);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ds.SetDataZeroLevelADC(LinearizationFormula.IsValid() ? (short)0 : DiagnosticInformation.ZeroMVInADC);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (null != DiagnosticInformation.FinalOffsetADC)
|
|
{
|
|
ds.SetDataZeroLevelADC((short)DiagnosticInformation.FinalOffsetADC);
|
|
}
|
|
else
|
|
{
|
|
ds.SetDataZeroLevelADC(DiagnosticInformation.ZeroMVInADC);
|
|
}
|
|
}
|
|
|
|
if (null != DiagnosticInformation.RemovedOffsetADC)
|
|
{
|
|
ds.SetRemovedADC((int)DiagnosticInformation.RemovedOffsetADC);
|
|
}
|
|
if (null != DiagnosticInformation.RemovedInternalOffsetADC)
|
|
{
|
|
ds.SetRemovedInternalADC((int)DiagnosticInformation.RemovedInternalOffsetADC);
|
|
}
|
|
ds.SetScaleFactorMv(DiagnosticInformation.ScalefactorMilliVoltsPerADC);
|
|
ds.SetScaleFactorEU(DiagnosticInformation.ScalefactorEngineeringUnitsPerADC);
|
|
if (OwningModule?.OwningDAS?.IsTSRAIR() ?? false)
|
|
{
|
|
//is a tsrair
|
|
ds.SetUseEUScaleFactors(true);
|
|
}
|
|
ds.SetZeroMvInADC(DiagnosticInformation.ZeroMVInADC);
|
|
|
|
ds.MeasuredExcitationVoltage = null == DiagnosticInformation.MeasuredExcitationMilliVolts ? 0D : (double)DiagnosticInformation.MeasuredExcitationMilliVolts / 1000D;
|
|
ds.FactoryExcitationVoltage = DiagnosticInformation.ExpectedExcitationMilliVolts / 1000D;
|
|
}
|
|
else
|
|
{
|
|
//no hardware channel specific stuff
|
|
if (IsProportionalToExcitation)
|
|
{
|
|
ds.FactoryExcitationVoltage = DiagnosticInformation.ExpectedExcitationMilliVolts / 1000D;
|
|
ds.MeasuredExcitationVoltage = ds.FactoryExcitationVoltage;
|
|
}
|
|
}
|
|
//common initialization stuff
|
|
|
|
// first set the scaler initial offset using the new offset property present on a channel
|
|
// it's possible the channel has the old form though, so we might have to add that too
|
|
// so if it's a different value add it - this gets complicated because there's a third
|
|
// offset property (InitialEU, InitialOffset, UserOffset) on sensors and datascaler and
|
|
// channel both have two, so we may lose out on one or more here
|
|
ds.SetInitialOffset(InitialOffset);
|
|
if ( !InitialEU.Equals(ds.GetInitialEU()))
|
|
{
|
|
ds.UserOffsetEU = InitialEU;
|
|
}
|
|
|
|
ds.ZeroMethodType = ZeroMethod;
|
|
|
|
ds.UnitConversion = UnitConverision;
|
|
ds.SensitivityUnits = SensitivityUnits;
|
|
|
|
ds.SetMvPerEu(SensitivityMilliVoltsPerEU);
|
|
|
|
//data scaler needs to get inverted or not only from polarity as negative sensitivity
|
|
//shows up through scale factor
|
|
ds.IsInverted = IsInverted;
|
|
|
|
ds.ProportionalToExcitation = IsProportionalToExcitation;
|
|
|
|
ds.BasedOnOutputAtCapacity = AtCapacity;
|
|
ds.CapacityOutputIsBasedOn = CapacityOutputIsBasedOn;
|
|
|
|
ds.IEPE = TypeOfBridge == SensorConstants.BridgeType.IEPE;
|
|
|
|
|
|
#region Digital
|
|
//ds.Digital = sensor.IsDigitalInput();
|
|
//ds.DigitalOutput = sensor.IsDigitalOutput();
|
|
//if (sensor is SensorData sd)
|
|
//{
|
|
// ds.DigitalMode = sd.InputMode;
|
|
// ds.SetDigitalMultiplier(sd.ScaleMultiplier);
|
|
//}
|
|
#endregion Digital
|
|
//if (clearEUAdjustmentParams)
|
|
//{
|
|
// ds.SetInitialOffset(new DTS.Common.Classes.Sensors.InitialOffset(0));
|
|
// ds.UserOffsetEU = 0D;
|
|
// ds.SetDataZeroLevelADC(0);
|
|
//}
|
|
return ds;
|
|
}
|
|
}
|
|
}
|