572 lines
31 KiB
C#
572 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Xml;
|
|
|
|
namespace EquipmentExchange
|
|
{
|
|
public class CrashDesignerTestSetup
|
|
{
|
|
public string Name { get; set; }
|
|
public static void GetEqxElectricalMethod(string eqxBridge,
|
|
out bool isProportional,
|
|
out DTS.Common.Enums.Sensors.SensorConstants.BridgeType bridgeType)
|
|
{
|
|
isProportional = true;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.FullBridge;
|
|
switch (eqxBridge)
|
|
{
|
|
case "PiezoInput": bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.IEPE; break;
|
|
case "ActiveSensor":
|
|
case "Active":
|
|
isProportional = false;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
case "FullBridge":
|
|
isProportional = true;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
case "HalfBridge":
|
|
isProportional = true;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.HalfBridge;
|
|
break;
|
|
case "HalfBridgeActive":
|
|
isProportional = false;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.HalfBridge;
|
|
break;
|
|
case "QuarterBridge":
|
|
isProportional = true;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.QuarterBridge;
|
|
break;
|
|
case "QuarterBridgeActive":
|
|
isProportional = false;
|
|
bridgeType = DTS.Common.Enums.Sensors.SensorConstants.BridgeType.QuarterBridge;
|
|
break;
|
|
}
|
|
}
|
|
public static CrashDesignerTestSetup ReadXML(string importFile)
|
|
{
|
|
var test = new CrashDesignerTestSetup();
|
|
|
|
var doc = new XmlDocument();
|
|
|
|
doc.Load(importFile);
|
|
|
|
foreach (var node in doc.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
if (element.LocalName == "TestSetupDefinition")
|
|
{
|
|
test.Name = element.GetAttribute("Name");
|
|
foreach (var subNode in element.ChildNodes)
|
|
{
|
|
if (subNode is XmlElement subElement)
|
|
{
|
|
if (subElement.LocalName == "General")
|
|
{
|
|
test.General.ReadXml(subElement);
|
|
}
|
|
else if (subElement.LocalName == "ChannelGroups")
|
|
{
|
|
test.ChannGroups.ReadXml(subElement);
|
|
}
|
|
else if (subElement.LocalName == "DataAcquisitionUnit")
|
|
{
|
|
test.DataAcquisition.ReadXml(subElement);
|
|
}
|
|
else
|
|
{
|
|
System.Diagnostics.Trace.WriteLine($"unknown element: {subElement.LocalName}");
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return test;
|
|
}
|
|
public class GeneralSection
|
|
{
|
|
public DateTime DateGenerated { get; set; }
|
|
public string GeneratorName { get; set; }
|
|
public string Description { get; set; }
|
|
public string TestType { get; set; }
|
|
public double PreTriggerTime { get; set; }
|
|
public double PostTriggerTime { get; set; }
|
|
public string OutputDataDirectory { get; set; }
|
|
private readonly List<string> _groups = new List<string>();
|
|
public string[] TestSetupGroup { get => _groups.ToArray(); set { _groups.Clear(); _groups.AddRange(value); } }
|
|
public void ReadXml(XmlElement root)
|
|
{
|
|
foreach (var childNode in root.ChildNodes)
|
|
{
|
|
if (childNode is XmlElement element)
|
|
{
|
|
if (Enum.TryParse(element.LocalName, out Fields field))
|
|
{
|
|
switch (field)
|
|
{
|
|
case Fields.DateGenerated:
|
|
if (DateTime.TryParse(element.InnerText, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AssumeUniversal, out var dt))
|
|
{
|
|
DateGenerated = dt;
|
|
}
|
|
else { System.Diagnostics.Trace.WriteLine($"Failed to parse DateGenerated: {element.InnerText}"); }
|
|
break;
|
|
case Fields.Description:
|
|
Description = element.InnerText;
|
|
break;
|
|
case Fields.GeneratorName:
|
|
GeneratorName = element.InnerText;
|
|
break;
|
|
case Fields.OutputDataDirectory:
|
|
OutputDataDirectory = element.InnerText;
|
|
break;
|
|
case Fields.PostTriggerTimeReadout:
|
|
if (double.TryParse(element.InnerText, out var d))
|
|
{
|
|
PostTriggerTime = d;
|
|
}
|
|
break;
|
|
case Fields.PreTriggerTimeReadout:
|
|
if (double.TryParse(element.InnerText, out var d2))
|
|
{
|
|
PreTriggerTime = d2;
|
|
}
|
|
break;
|
|
case Fields.TestSetupGroup:
|
|
_groups.Add(element.InnerText);
|
|
break;
|
|
case Fields.TestType:
|
|
TestType = element.InnerText;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public enum Fields
|
|
{
|
|
DateGenerated,
|
|
GeneratorName,
|
|
Description,
|
|
TestType,
|
|
PreTriggerTimeReadout,
|
|
PostTriggerTimeReadout,
|
|
OutputDataDirectory,
|
|
TestSetupGroup
|
|
}
|
|
}
|
|
public GeneralSection General { get; set; } = new GeneralSection();
|
|
public ChannelGroupsSection ChannGroups { get; set; } = new ChannelGroupsSection();
|
|
public class ChannelGroupsSection
|
|
{
|
|
private readonly List<Group> _groups = new List<Group>();
|
|
public Group[] Groups { get => _groups.ToArray(); set { _groups.Clear(); _groups.AddRange(value); } }
|
|
|
|
public void ReadXml(XmlElement root)
|
|
{
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
if (element.LocalName == "Group")
|
|
{
|
|
var group = Group.ReadXml(element);
|
|
_groups.Add(group);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public class Group
|
|
{
|
|
public string Name { get; set; }
|
|
public string Id { get; set; }
|
|
public string Parent { get; set; }
|
|
public string Description { get; set; }
|
|
private readonly Dictionary<string, string> _properties = new Dictionary<string, string>();
|
|
public bool HasProperty(string key) { return _properties.ContainsKey(key); }
|
|
public string GetProperty(string key) { return _properties[key]; }
|
|
public void SetProperty(string key, string value) { _properties[key] = value; }
|
|
public enum KnownFormats
|
|
{
|
|
[Description("DataFormat")]
|
|
DataFormat,
|
|
[Description("ISO Title")]
|
|
ISOTitle,
|
|
[Description("Regulation")]
|
|
Regulation,
|
|
[Description("Media")]
|
|
Media,
|
|
[Description("TestDate")]
|
|
TestDate,
|
|
[Description("SignConvInstrStandard")]
|
|
SignConvInstrStandard,
|
|
[Description("LabName")]
|
|
LabName,
|
|
[Description("ContactName")]
|
|
ContactName,
|
|
[Description("ContactPhone")]
|
|
ContactPhone,
|
|
[Description("LabFax")]
|
|
LabFax,
|
|
[Description("LaboratoryContactEmail")]
|
|
LaboratoryContactEmail,
|
|
[Description("LaboratoryTestRefNumber")]
|
|
LaboratoryTestRefNumber,
|
|
[Description("CustomerName")]
|
|
CustomerName,
|
|
[Description("Testreference")]
|
|
Testreference,
|
|
[Description("CustomerReference")]
|
|
CustomerReference,
|
|
[Description("CustomerOrderNumber")]
|
|
CustomerOrderNumber,
|
|
[Description("CustomerCostUnit")]
|
|
CustomerCostUnit,
|
|
[Description("CustomerTestEngineerName")]
|
|
CustomerTestEngineerName,
|
|
[Description("CustomerTestEngineerPhone")]
|
|
CustomerTestEngineerPhone,
|
|
[Description("CustomerTestEngineerFax")]
|
|
CustomerTestEngineerFax,
|
|
[Description("CustomerTestEngineerEmail")]
|
|
CustomerTestEngineerEmail,
|
|
[Description("Name")]
|
|
Name,
|
|
[Description("Velocity")]
|
|
Velocity,
|
|
[Description("Mass")]
|
|
Mass,
|
|
[Description("DriverPosition")]
|
|
DriverPosition,
|
|
[Description("ImpactSide")]
|
|
ImpactSide,
|
|
[Description("TestObjectRefNumber")]
|
|
TestObjectRefNumber,
|
|
[Description("Class")]
|
|
Class,
|
|
[Description("Code")]
|
|
Code
|
|
}
|
|
public static Group ReadXml(XmlElement root)
|
|
{
|
|
var group = new Group();
|
|
if (root.HasAttribute("Id"))
|
|
{
|
|
group.Id = root.GetAttribute("Id");
|
|
}
|
|
if (root.HasAttribute("Parent"))
|
|
{
|
|
group.Parent = root.GetAttribute("Parent");
|
|
}
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
switch (element.LocalName)
|
|
{
|
|
case "Name": group.Name = element.InnerText; break;
|
|
case "Description": group.Description = element.InnerText; break;
|
|
case "Property":
|
|
group.SetProperty(element.GetAttribute("Name"), element.GetAttribute("Value"));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return group;
|
|
}
|
|
}
|
|
|
|
public DataAcquisitionSection DataAcquisition { get; set; } = new DataAcquisitionSection();
|
|
public class DataAcquisitionSection
|
|
{
|
|
private readonly List<DataAcquisitionUnit> _units = new List<DataAcquisitionUnit>();
|
|
public DataAcquisitionUnit[] DataAcquisitionUnits { get => _units.ToArray(); set { _units.Clear(); _units.AddRange(value); } }
|
|
|
|
public void ReadXml(XmlElement element)
|
|
{
|
|
var daq = DataAcquisitionUnit.ReadXml(element);
|
|
_units.Add(daq);
|
|
}
|
|
}
|
|
//public DataAcquisitionSection DataAcquisitionUnit { get; set; } = new DataAcquisitionSection();
|
|
public class DataAcquisitionUnit
|
|
{
|
|
private static double GetDouble(string text)
|
|
{
|
|
if (double.TryParse(text, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out var d))
|
|
{
|
|
return d;
|
|
}
|
|
return double.NaN;
|
|
}
|
|
public static DataAcquisitionUnit ReadXml(XmlElement root)
|
|
{
|
|
var daq = new DataAcquisitionUnit();
|
|
|
|
if (root.HasAttribute("Enabled"))
|
|
{
|
|
daq.Enabled = bool.Parse(root.GetAttribute("Enabled"));
|
|
}
|
|
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
switch (element.LocalName)
|
|
{
|
|
case "DatabaseUID": daq.DataBaseUID = element.InnerText; break;
|
|
case "Name": daq.Name = element.InnerText; break;
|
|
case "Type": daq.Type = element.InnerText; break;
|
|
case "SubType": daq.SubType = element.InnerText; break;
|
|
case "FirmwareVersion": daq.FirmwareVersion = element.InnerText; break;
|
|
case "ModelDescription": daq.ModelDescription = element.InnerText; break;
|
|
case "DefaultTriggerString": daq.DefaultTriggerString = element.InnerText; break;
|
|
case "Trigger": daq.Trigger.ReadXml(element); break;
|
|
case "Manufacturer": daq.Manufacturer = element.InnerText; break;
|
|
case "ADRangeNegV": daq.ADRangeNegV = GetDouble(element.InnerText); break;
|
|
case "ADRangePosV": daq.ADRangePosV = GetDouble(element.InnerText); break;
|
|
case "ADResolutionV": daq.ADResolutionV = GetDouble(element.InnerText); break;
|
|
case "GainRangeMax1": daq.GainRangeMax1 = GetDouble(element.InnerText); break;
|
|
case "GainRangeMin1": daq.GainRangeMin1 = GetDouble(element.InnerText); break;
|
|
case "GainRangeStep1": daq.GainRangeStep1 = GetDouble(element.InnerText); break;
|
|
case "GainRangeMax2": daq.GainRangeMax2 = GetDouble(element.InnerText); break;
|
|
case "GainRangeMin2": daq.GainRangeMin2 = GetDouble(element.InnerText); break;
|
|
case "GainRangeStep2": daq.GainRangeStep2 = GetDouble(element.InnerText); break;
|
|
case "FilterFrequencyHz": daq.FilterFrequencyHz = GetDouble(element.InnerText); break;
|
|
case "FilterSpecification": daq.FilterSpecification = element.InnerText; break;
|
|
case "SampleFrequencyHz": daq.SampleFrequencyHz = GetDouble(element.InnerText); break;
|
|
case "MaxSampleFrequencyHz": daq.MaxSampleFrequencyHz = GetDouble(element.InnerText); break;
|
|
case "MinSampleFrequencyHz": daq.MinSampleFrequencyHz = GetDouble(element.InnerText); break;
|
|
case "BitResolution": daq.BitResolution = GetDouble(element.InnerText); break;
|
|
case "Description": daq.Description = element.InnerText; break;
|
|
case "Status": daq.Status = element.InnerText; break;
|
|
case "Label": daq.Label = element.InnerText; break;
|
|
case "SerialNr": daq.SerialNr = element.InnerText; break;
|
|
case "TCPIPAddress": daq.TCPIPAddress = element.InnerText; break;
|
|
case "ControllerNr": daq.ControllerNr = element.InnerText; break;
|
|
case "RS422UnitNr": daq.RS422UnitNr = element.InnerText; break;
|
|
case "UseRS422Communication": daq.UseRS422Communication = bool.Parse(element.InnerText); break;
|
|
case "RS422COMPort": daq.RS422ComPort = int.Parse(element.InnerText); break;
|
|
case "AnalogInputChannelCount": daq.AnalogInputChannelCount = int.Parse(element.InnerText); break;
|
|
case "DigitalInputChannelCount": daq.DigitalInputChannelCount = int.Parse(element.InnerText); break;
|
|
case "DigitalOutputChannelCount": daq.DigitalOutputChannelCount = int.Parse(element.InnerText); break;
|
|
case "SystemChannelCount": daq.SystemChannelCount = int.Parse(element.InnerText); break;
|
|
case "StartAnalogChannelNr": daq.StartAnalogChannelNr = int.Parse(element.InnerText); break;
|
|
case "AnalogInChannel":
|
|
daq.AnalogChannels.ReadXml(element);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return daq;
|
|
}
|
|
public bool Enabled { get; set; }
|
|
public string DataBaseUID { get; set; }
|
|
public string Name { get; set; }
|
|
public string Type { get; set; }
|
|
public string SubType { get; set; }
|
|
public string FirmwareVersion { get; set; }
|
|
public string ModelDescription { get; set; }
|
|
public string DefaultTriggerString { get; set; }
|
|
public TriggerSection Trigger { get; set; } = new TriggerSection();
|
|
public class TriggerSection
|
|
{
|
|
public string TriggerMode { get; set; }
|
|
public string RecBus { get; set; }
|
|
public string T0Bus { get; set; }
|
|
public string Filter { get; set; }
|
|
|
|
public void ReadXml(XmlElement root)
|
|
{
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
switch (element.LocalName)
|
|
{
|
|
case "TriggerMode": TriggerMode = element.InnerText; break;
|
|
case "RecBus": RecBus = element.InnerText; break;
|
|
case "T0Bus": T0Bus = element.InnerText; break;
|
|
case "Filter": Filter = element.InnerText; break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public string Manufacturer { get; set; }
|
|
public double ADRangeNegV { get; set; }
|
|
public double ADRangePosV { get; set; }
|
|
public double ADResolutionV { get; set; }
|
|
public double GainRangeMax1 { get; set; }
|
|
public double GainRangeMin1 { get; set; }
|
|
public double GainRangeStep1 { get; set; }
|
|
public double GainRangeMax2 { get; set; }
|
|
public double GainRangeMin2 { get; set; }
|
|
public double GainRangeStep2 { get; set; }
|
|
public double FilterFrequencyHz { get; set; }
|
|
public string FilterSpecification { get; set; }
|
|
public double SampleFrequencyHz { get; set; }
|
|
public double MaxSampleFrequencyHz { get; set; }
|
|
public double MinSampleFrequencyHz { get; set; }
|
|
public double BitResolution { get; set; }
|
|
public string Description { get; set; }
|
|
public string Status { get; set; }
|
|
public string Label { get; set; }
|
|
public string SerialNr { get; set; }
|
|
public string TCPIPAddress { get; set; }
|
|
public string ControllerNr { get; set; }
|
|
public string RS422UnitNr { get; set; }
|
|
public bool UseRS422Communication { get; set; }
|
|
public int RS422ComPort { get; set; }
|
|
public int AnalogInputChannelCount { get; set; }
|
|
public int DigitalInputChannelCount { get; set; }
|
|
public int DigitalOutputChannelCount { get; set; }
|
|
public int SystemChannelCount { get; set; }
|
|
public int StartAnalogChannelNr { get; set; }
|
|
|
|
public AnalogInChannelSection AnalogChannels { get; set; } = new AnalogInChannelSection();
|
|
|
|
|
|
public class AnalogInChannelSection
|
|
{
|
|
private readonly List<AnalogInChannel> _channels = new List<AnalogInChannel>();
|
|
public AnalogInChannel[] Channels { get => _channels.ToArray(); set { _channels.Clear(); _channels.AddRange(value); } }
|
|
|
|
public void ReadXml(XmlElement element)
|
|
{
|
|
var analog = AnalogInChannel.ReadXml(element);
|
|
_channels.Add(analog);
|
|
}
|
|
}
|
|
public class AnalogInChannel
|
|
{
|
|
public bool Enabled { get; set; }
|
|
public string Id { get; set; }
|
|
public string GroupId { get; set; }
|
|
public bool DataConversionEnabled { get; set; }
|
|
public string ChannelName { get; set; }
|
|
public int GlobalNr { get; set; }
|
|
public string ISOCodeName { get; set; }
|
|
public string ISOCodeLongName { get; set; }
|
|
public string CompanyCodeName { get; set; }
|
|
public string CompanyCodeLongName { get; set; }
|
|
public string Comment { get; set; }
|
|
public string SubType { get; set; }
|
|
public int SampleFGroupId { get; set; }
|
|
public bool ReadoutEnabled { get; set; }
|
|
public int ChannelNr { get; set; }
|
|
public double SampleFrequency { get; set; }
|
|
public string SensorModelName { get; set; }
|
|
public string SerialNr { get; set; }
|
|
public string SensorName { get; set; }
|
|
public string SensorAxisName { get; set; }
|
|
public string SensorStatus { get; set; }
|
|
public bool SensorStatusUsable { get; set; }
|
|
public string SensorIDType { get; set; }
|
|
public DateTime NextCalibrationDate { get; set; }
|
|
public bool VoltageEngineeringUnit { get; set; }
|
|
public string ElectronicID { get; set; }
|
|
public string BridgeType { get; set; }
|
|
public bool SelfDescriptive { get; set; }
|
|
public double ExcitationVoltage { get; set; }
|
|
public double Sensitivity { get; set; }
|
|
public bool InvertFlag { get; set; }
|
|
public double CalculatedGain { get; set; }
|
|
public double PreferredMeasurementRange { get; set; }
|
|
public string PhysicalUnit { get; set; }
|
|
public string Direction { get; set; }
|
|
public bool HWAdjustOffsetFlag { get; set; }
|
|
public bool SWAdjustOffsetFlag { get; set; }
|
|
public bool OffsetFlag { get; set; }
|
|
public double OffsetMaxToleranceV { get; set; }
|
|
public double OffsetReferenceV { get; set; }
|
|
public bool ShuntPosFlag { get; set; }
|
|
public double ShuntGainPos { get; set; }
|
|
public double ShuntPosMaxToleranceV { get; set; }
|
|
public double ShuntPosReferenceV { get; set; }
|
|
public bool ShuntNegFlag { get; set; }
|
|
public double ShuntGainNeg { get; set; }
|
|
public double ShuntNegMaxToleranceV { get; set; }
|
|
public double ShuntNegReferenceV { get; set; }
|
|
public static DateTime GetDate(string text)
|
|
{
|
|
if (DateTime.TryParse(text, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var dt))
|
|
{
|
|
return dt;
|
|
}
|
|
return DateTime.MinValue;
|
|
}
|
|
public static AnalogInChannel ReadXml(XmlElement root)
|
|
{
|
|
var analog = new AnalogInChannel();
|
|
if (root.HasAttribute("Enabled")) { analog.Enabled = bool.Parse(root.GetAttribute("Enabled")); }
|
|
if (root.HasAttribute("Id")) { analog.Id = root.GetAttribute("Id"); }
|
|
if (root.HasAttribute("GroupId")) { analog.GroupId = root.GetAttribute("GroupId"); }
|
|
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is XmlElement element)
|
|
{
|
|
switch (element.LocalName)
|
|
{
|
|
case "DataConversionEnabled": analog.DataConversionEnabled = bool.Parse(element.InnerText); break;
|
|
case "ChannelName": analog.ChannelName = element.InnerText; break;
|
|
case "GlobalNr": analog.GlobalNr = int.Parse(element.InnerText); break;
|
|
case "ISOCodeName": analog.ISOCodeName = element.InnerText; break;
|
|
case "ISOCodeLongName": analog.ISOCodeLongName = element.InnerText; break;
|
|
case "CompanyCodeName": analog.CompanyCodeName = element.InnerText; break;
|
|
case "CompanyCodeLongName": analog.CompanyCodeLongName = element.InnerText; break;
|
|
case "Comment": analog.Comment = element.InnerText; break;
|
|
case "SubType": analog.SubType = element.InnerText; break;
|
|
case "SampleFGroupId": analog.SampleFGroupId = int.Parse(element.InnerText); break;
|
|
case "ReadoutEnabled": analog.ReadoutEnabled = bool.Parse(element.InnerText); break;
|
|
case "ChannelNr": analog.ChannelNr = int.Parse(element.InnerText); break;
|
|
case "SampleFrequency": analog.SampleFrequency = GetDouble(element.InnerText); break;
|
|
case "SensorModelName": analog.SensorModelName = element.InnerText; break;
|
|
case "SerialNr": analog.SerialNr = element.InnerText; break;
|
|
case "SensorName": analog.SensorName = element.InnerText; break;
|
|
case "SensorAxisName": analog.SensorAxisName = element.InnerText; break;
|
|
case "SensorStatus": analog.SensorStatus = element.InnerText; break;
|
|
case "SensorStatusUsable": analog.SensorStatusUsable = bool.Parse(element.InnerText); break;
|
|
case "SensorIDType": analog.SensorIDType = element.InnerText; break;
|
|
case "NextCalibrationDate": analog.NextCalibrationDate = GetDate(element.InnerText); break;
|
|
case "VoltageEngineeringUnit": analog.VoltageEngineeringUnit = bool.Parse(element.InnerText); break;
|
|
case "ElectronicID": analog.ElectronicID = element.InnerText; break;
|
|
case "BridgeType": analog.BridgeType = element.InnerText; break;
|
|
case "SelfDescriptive": analog.SelfDescriptive = bool.Parse(element.InnerText); break;
|
|
case "ExcitationVoltage": analog.ExcitationVoltage = GetDouble(element.InnerText); break;
|
|
case "Sensitivity": analog.Sensitivity = GetDouble(element.InnerText); break;
|
|
case "InvertFlag": analog.InvertFlag = bool.Parse(element.InnerText); break;
|
|
case "CalculatedGain": analog.CalculatedGain = GetDouble(element.InnerText); break;
|
|
case "PreferredMeasurementRange": analog.PreferredMeasurementRange = GetDouble(element.InnerText); break;
|
|
case "PhysicalUnit": analog.PhysicalUnit = element.InnerText; break;
|
|
case "Direction": analog.Direction = element.InnerText; break;
|
|
case "HWAdjustOffsetFlag": analog.HWAdjustOffsetFlag = bool.Parse(element.InnerText); break;
|
|
case "SWAdjustOffsetFlag": analog.SWAdjustOffsetFlag = bool.Parse(element.InnerText); break;
|
|
case "OffsetFlag": analog.OffsetFlag = bool.Parse(element.InnerText); break;
|
|
case "OffsetMaxToleranceV": analog.OffsetMaxToleranceV = GetDouble(element.InnerText); break;
|
|
case "OffsetReferenceV": analog.OffsetReferenceV = GetDouble(element.InnerText); break;
|
|
case "ShuntPosFlag": analog.ShuntPosFlag = bool.Parse(element.InnerText); break;
|
|
case "ShuntGainPos": analog.ShuntGainPos = GetDouble(element.InnerText); break;
|
|
case "ShuntPosMaxToleranceV": analog.ShuntGainPos = GetDouble(element.InnerText); break;
|
|
case "ShuntPosReferenceV": analog.ShuntPosReferenceV = GetDouble(element.InnerText); break;
|
|
case "ShuntNegFlag": analog.ShuntNegFlag = bool.Parse(element.InnerText); break;
|
|
case "ShuntGainNeg": analog.ShuntGainNeg = GetDouble(element.InnerText); break;
|
|
case "ShuntNegMaxToleranceV": analog.ShuntNegMaxToleranceV = GetDouble(element.InnerText); break;
|
|
case "ShuntNegReferenceV": analog.ShuntNegReferenceV = GetDouble(element.InnerText); break;
|
|
}
|
|
}
|
|
}
|
|
return analog;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|