992 lines
50 KiB
C#
992 lines
50 KiB
C#
using DTS.Common.Classes;
|
|
using DTS.Common.Classes.Groups;
|
|
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.Enums;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.SensorDB;
|
|
using EQX;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Xml.Serialization;
|
|
using static DTS.Common.Enums.Sensors.SensorConstants;
|
|
|
|
namespace EquipmentExchange
|
|
{
|
|
/// <summary>
|
|
/// class that handles reading an EQX file and translating into DTS SensorData and SensorCalibration objects
|
|
/// </summary>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S101:Types should be named in PascalCase", Justification = "EQX is an acronym")]
|
|
public class EQXSensorDatabase
|
|
{
|
|
public bool UsemVOverVForPolys { get; set; } = true;
|
|
private readonly Dictionary<string, List<SensorCalibration>> _calibrationLookup = new Dictionary<string, List<SensorCalibration>>();
|
|
private bool _importCreateDynamicGroups;
|
|
/// <summary>
|
|
/// sensor lookup by UUID (EQX id) or serial number
|
|
/// </summary>
|
|
private readonly Dictionary<string, SensorData> _sensorLookup = new Dictionary<string, SensorData>();
|
|
/// <summary>
|
|
/// whether the sensor has a null id section in EQX, this is used in DataPRO to determine whether to
|
|
/// use an existing id in the db or to overwrite; from original function:
|
|
/// check to see if the sensor had a NULL IDModuleString, if so
|
|
/// check for an existing EID and use that rather than wiping out the EID
|
|
/// 18467 Missing IDModuleString in e2x file import is clearing the EID on sensor import
|
|
/// </summary>
|
|
private readonly Dictionary<string, bool> _sensorHasNullIDModule = new Dictionary<string, bool>();
|
|
|
|
/// <summary>
|
|
/// returns true if the sensor has a NULL IDModuleString entry record in the EQX file
|
|
/// used to determine whether existing EID should be used or not
|
|
/// 18467 Missing IDModuleString in e2x file import is clearing the EID on sensor import
|
|
/// this method just returns whether we know if it has a value or not, not the value
|
|
/// </summary>
|
|
/// <param name="key">UUID or serial number of sensor</param>
|
|
/// <returns>true if the sensor has a null id module section, false otherwise</returns>
|
|
public bool SensorHasNullIDModule(string key)
|
|
{
|
|
return _sensorHasNullIDModule.ContainsKey(key);
|
|
}
|
|
/// <summary>
|
|
/// returns the value for whether a sensor has a null IDModuleString entry in the eqx
|
|
/// used to determine whether to update the EID in DataPRO or not
|
|
/// 18467 Missing IDModuleString in e2x file import is clearing the EID on sensor import
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public bool GetSensorNullIdModuleValue(string key)
|
|
{
|
|
return _sensorHasNullIDModule[key];
|
|
}
|
|
/// <summary>
|
|
/// returns all sensor records read in from Read method
|
|
/// <see cref="Read(string, ReportErrorsDelegate, bool, bool)"/>
|
|
/// </summary>
|
|
/// <returns>all sensors read in by Read</returns>
|
|
public SensorData[] GetSensors()
|
|
{
|
|
return _sensorLookup.Values.ToArray();
|
|
}
|
|
|
|
public SensorImportData GetImportData()
|
|
{
|
|
return new SensorImportData
|
|
{
|
|
GroupNameTestObjectLookup = _groupNameToTestObjectLookup,
|
|
GroupNameSensorListLookup = _groupNameSensorListLookup
|
|
};
|
|
}
|
|
/// <summary>
|
|
/// whether there is calibration information in eqx file for a given sensor
|
|
/// </summary>
|
|
/// <param name="key">UUID or serial number of sensor</param>
|
|
/// <returns>true if there are calibration entries, false otherwise</returns>
|
|
public bool ContainsCalibration(string key)
|
|
{
|
|
return _calibrationLookup.ContainsKey(key);
|
|
}
|
|
/// <summary>
|
|
/// returns all calibrations for a given sensor
|
|
/// </summary>
|
|
/// <param name="id">UUID or serial number for sensor</param>
|
|
/// <returns></returns>
|
|
public List<SensorCalibration> GetCalibrations(string id)
|
|
{
|
|
if (_calibrationLookup.ContainsKey(id))
|
|
{
|
|
return _calibrationLookup[id];
|
|
}
|
|
return new List<SensorCalibration>();
|
|
}
|
|
/// <summary>
|
|
/// action to perform to report an error with file
|
|
/// </summary>
|
|
/// <param name="errors"></param>
|
|
public delegate void ReportErrorsDelegate(List<string> errors);
|
|
/// <summary>
|
|
/// reads a EQX file and populates sensor and calibration entries
|
|
/// </summary>
|
|
/// <param name="path"></param>
|
|
/// <param name="reportErrors"></param>
|
|
/// <param name="eqxUseSerialNumberFieldForSN"></param>
|
|
/// <param name="useZeroForUnfiltered"></param>
|
|
public void Read(string path, ReportErrorsDelegate reportErrors,
|
|
bool eqxUseSerialNumberFieldForSN,
|
|
bool useZeroForUnfiltered, bool importCreateDynamicGroups)
|
|
{
|
|
_importCreateDynamicGroups = importCreateDynamicGroups;
|
|
var serializer = new XmlSerializer(typeof(EqxSensors));
|
|
EqxSensors sensors = null;
|
|
using (var tr = new StreamReader(path))
|
|
{
|
|
try
|
|
{
|
|
sensors = (EqxSensors)serializer.Deserialize(tr);
|
|
}
|
|
catch (Exception ex) { reportErrors?.Invoke(new List<string>(new[] { ex.Message })); return; }
|
|
var errors = new List<string>();
|
|
if (sensors?.Sensor != null) { foreach (var axis in sensors.Sensor) { AddEQXSensor(null, axis, eqxUseSerialNumberFieldForSN, useZeroForUnfiltered, ref errors); } }
|
|
if (sensors?.SensorGroup != null) { foreach (var group in sensors.SensorGroup) { AddEQXGroup(group, eqxUseSerialNumberFieldForSN, useZeroForUnfiltered, ref errors); } }
|
|
if ( null != errors && errors.Any())
|
|
{
|
|
reportErrors?.Invoke(errors);
|
|
}
|
|
tr.Close();
|
|
}
|
|
}
|
|
|
|
|
|
private bool PopulateSensorLookup(string groupName,
|
|
ref SensorData sd,
|
|
ref List<string> errors,
|
|
ref Dictionary<string, List<string>> groupNameSensorListLookup,
|
|
ref Dictionary<string, string> groupNameToTestObjectLookup)
|
|
{
|
|
var sensorTestObject = sd.TestObject;
|
|
|
|
// check group name for empty
|
|
if (string.IsNullOrEmpty(groupName) || string.IsNullOrWhiteSpace(groupName))
|
|
{
|
|
errors.Add(string.Format("No Group Name found for sensor {0}", sd.SerialNumber));
|
|
return false;
|
|
}
|
|
if (!groupNameSensorListLookup.ContainsKey(groupName))
|
|
{
|
|
groupNameSensorListLookup.Add(groupName, new List<string>());
|
|
}
|
|
|
|
groupNameSensorListLookup[groupName].Add(sd.SerialNumber);
|
|
|
|
if (!groupNameToTestObjectLookup.ContainsKey(groupName))
|
|
{
|
|
groupNameToTestObjectLookup.Add(groupName, sensorTestObject);
|
|
}
|
|
else
|
|
{
|
|
if (groupNameToTestObjectLookup[groupName] != sensorTestObject && !_importCreateDynamicGroups)
|
|
{
|
|
var errorMessage =
|
|
string.Format("Non distinct test object for group {0}",
|
|
groupName);
|
|
if (!errors.Contains(errorMessage))
|
|
{
|
|
errors.Add(errorMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
return errors.Count == 0;
|
|
}
|
|
/// <summary>
|
|
/// pads the EID if needed
|
|
/// 30609 EIDs can need correction when coming from crashdesigner EQX
|
|
/// pads and adds checksum if less than 16 characters, otherwise returns as is
|
|
/// does not pad null or empty eids.
|
|
/// on exception returns the id as is
|
|
/// </summary>
|
|
/// <param name="idModuleString"></param>
|
|
/// <returns></returns>
|
|
private static string PadEIDIfNeeded(string idModuleString)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(idModuleString)) { return idModuleString; }
|
|
if (idModuleString.Length < 16)
|
|
{
|
|
idModuleString = idModuleString.PadLeft(14, '0');
|
|
return $"{GenerateCRC(idModuleString)}{idModuleString}";
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//consume error, no logging
|
|
}
|
|
return idModuleString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// code borrowed from nate for
|
|
/// 30609 EIDs can need correction when coming from crashdesigner EQX
|
|
/// just copied it here as is
|
|
/// </summary>
|
|
/// <param name="ShortID"></param>
|
|
/// <returns></returns>
|
|
private static string GenerateCRC(string ShortID)
|
|
{
|
|
var int64 = long.Parse(ShortID, NumberStyles.HexNumber);
|
|
var bytes = BitConverter.GetBytes(int64);
|
|
var bitArray = new System.Collections.BitArray(bytes);
|
|
var CRCbit = new System.Collections.BitArray(8);
|
|
var CRCTemp = new System.Collections.BitArray(1);
|
|
var CRCbyte = new byte[1];
|
|
|
|
for (var i = 0; i < 56; i++)
|
|
{
|
|
CRCTemp[0] = CRCbit[0] ^ bitArray[i];
|
|
CRCbit[0] = CRCbit[1];
|
|
CRCbit[1] = CRCbit[2];
|
|
CRCbit[2] = CRCbit[3] ^ CRCTemp[0];
|
|
CRCbit[3] = CRCbit[4] ^ CRCTemp[0];
|
|
CRCbit[4] = CRCbit[5];
|
|
CRCbit[5] = CRCbit[6];
|
|
CRCbit[6] = CRCbit[7];
|
|
CRCbit[7] = CRCTemp[0];
|
|
}
|
|
|
|
CRCbit.CopyTo(CRCbyte, 0);
|
|
return BitConverter.ToString(CRCbyte); ;
|
|
}
|
|
private SensorCalibration GetCalibrationFromEQXSensorAxis(EqxSensorAxis sensor, SensorData sd)
|
|
{
|
|
var sc = new SensorCalibration();
|
|
if (null != sd) { sc.SerialNumber = sd.SerialNumber; }
|
|
|
|
sc.ModifyDate = DateTime.Now;
|
|
if (sensor.ElectricalMethodSpecified)
|
|
{
|
|
switch (sensor.ElectricalMethod)
|
|
{
|
|
case EqxElectricalMethod.HalfBridgeActive:
|
|
case EqxElectricalMethod.QuarterBridge:
|
|
case EqxElectricalMethod.QuarterBridgeActive:
|
|
case EqxElectricalMethod.ActiveSensor:
|
|
sc.IsProportional = false;
|
|
break;
|
|
default:
|
|
sc.IsProportional = true;
|
|
break;
|
|
}
|
|
}
|
|
if (sensor.CalDateSpecified)
|
|
{
|
|
sc.CalibrationDate = sensor.CalDate;
|
|
}
|
|
|
|
sc.Username = sensor.CalPerson;
|
|
if (sensor.ScalingMethodSpecified)
|
|
{
|
|
switch (sensor.ScalingMethod)
|
|
{
|
|
case EqxScalingMethod.CubicPolynomial:
|
|
{
|
|
sc.NonLinear = true;
|
|
sc.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.Polynomial;
|
|
|
|
var a = Convert.ToDouble(sensor.Sensitivity2.ToString("F10", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
|
|
var b = Convert.ToDouble(sensor.Sensitivity3.ToString("F10", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
|
|
var c = Convert.ToDouble(sensor.Sensitivity4.ToString("F10", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
|
|
var m = Convert.ToDouble(sensor.Sensitivity5.ToString("F10", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
|
|
|
|
sc.Records.Records[0].Poly.UsemVOverVForPolys = UsemVOverVForPolys;
|
|
sc.Records.Records[0].Poly.PolynomialCoefficients = new[] { a, b, c, m };
|
|
sc.Records.Records[0].Poly.PolynomialExponents = new[] { 3D, 2D, 1D, 0D };
|
|
sc.Records.Records[0].Poly.MarkValid(true);
|
|
}
|
|
break;
|
|
|
|
case EqxScalingMethod.IRTRACC:
|
|
{
|
|
ReadEQXCalibration(sc, sensor);
|
|
}
|
|
break;
|
|
default:
|
|
sc.Records.Records[0].Sensitivity = Convert.ToDouble(sensor.Sensitivity.ToString("F10", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (sensor.OffsetCompensationSpecified) { sc.RemoveOffset = sensor.OffsetCompensation; }
|
|
|
|
if (null != sd && sd.SupportedExcitation.Length > 0)
|
|
{
|
|
sc.Records.Records[0].Excitation = sd.SupportedExcitation[0];
|
|
}
|
|
sc.Records.Records[0].AtCapacity = false;
|
|
sc.Records.Records[0].SensitivityUnits = sc.IsProportional ? SensUnits.mVperVperEU : SensUnits.mVperEU;
|
|
sc.CalVersion = sensor.CalVersion;
|
|
if (sensor.SWOffsetFixValueSpecified)
|
|
{
|
|
sc.InitialOffsets.Offsets[0].Form = InitialOffsetTypes.EU;
|
|
sc.InitialOffsets.Offsets[0].EU = sensor.SWOffsetFixValue;
|
|
}
|
|
foreach (var r in sc.Records.Records) { r.EngineeringUnits = sensor.PhysicalUnit; }
|
|
return sc;
|
|
}
|
|
/// <summary>
|
|
/// process an EQX sensor, creating a sensor if necessary
|
|
/// </summary>
|
|
/// <param name="sensor"></param>
|
|
/// <param name="eqxUseSerialNumberFieldForSN"></param>
|
|
/// <param name="useZeroForUnfiltered"></param>
|
|
private void AddEQXSensor(string groupName, EqxSensorAxis sensor,
|
|
bool eqxUseSerialNumberFieldForSN,
|
|
bool useZeroForUnfiltered,
|
|
ref List<string> errors)
|
|
{
|
|
var sd = MakeDefaultSensor();
|
|
if (eqxUseSerialNumberFieldForSN)
|
|
{
|
|
if (null == sensor.SerialNumber) { sensor.SerialNumber = ""; }
|
|
sd.SerialNumber = sensor.SerialNumber.Replace("\n", "");
|
|
sd.Comment = sensor.Name;
|
|
}
|
|
else
|
|
{
|
|
sd.SerialNumber = sensor.Name.Replace("\n", "");
|
|
sd.UserSerialNumber = sensor.SerialNumber;
|
|
}
|
|
if (sensor.UUID == null)
|
|
{
|
|
sensor.UUID = Guid.NewGuid().ToString();
|
|
}
|
|
sensor.UUID = (eqxUseSerialNumberFieldForSN ? sensor.SerialNumber : sensor.UUID) ?? sensor.SerialNumber;
|
|
|
|
var zeroMethodStart = double.NaN;
|
|
var zeroMethodEnd = double.NaN;
|
|
var zeroMethodType = ZeroMethodType.AverageOverTime;
|
|
var typeSpecified = false;
|
|
foreach (var enumValue in Enum.GetValues(typeof(SensorData.ExchangeFields)))
|
|
{
|
|
var field = (SensorData.ExchangeFields)enumValue;
|
|
switch (field)
|
|
{
|
|
case SensorData.ExchangeFields.BridgeResistance:
|
|
sd.BridgeResistance = sensor.ShuntResistance;
|
|
break;
|
|
case SensorData.ExchangeFields.OffsetToleranceHigh:
|
|
if (sensor.OffsetTolSpecified) { sd.OffsetToleranceHigh = sensor.OffsetTol; }
|
|
break;
|
|
case SensorData.ExchangeFields.OffsetToleranceLow:
|
|
if (sensor.OffsetTolSpecified) { sd.OffsetToleranceLow = -1D * sensor.OffsetTol; }
|
|
break;
|
|
case SensorData.ExchangeFields.BridgeType:
|
|
if (sd.Bridge != BridgeType.SQUIB)
|
|
{
|
|
switch (sensor.ElectricalMethod)
|
|
{
|
|
case EqxElectricalMethod.PiezoInput:
|
|
sd.Bridge = SensorConstants.BridgeType.IEPE;
|
|
break;
|
|
case EqxElectricalMethod.HalfBridge:
|
|
sd.Bridge = SensorConstants.BridgeType.HalfBridge;
|
|
break;
|
|
case EqxElectricalMethod.HalfBridgeActive:
|
|
sd.Bridge = SensorConstants.BridgeType.HalfBridge;
|
|
break;
|
|
case EqxElectricalMethod.QuarterBridge:
|
|
sd.Bridge = SensorConstants.BridgeType.QuarterBridge;
|
|
break;
|
|
case EqxElectricalMethod.QuarterBridgeActive:
|
|
sd.Bridge = SensorConstants.BridgeType.QuarterBridge;
|
|
break;
|
|
default:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.CalibrationDueDate:
|
|
//FB 24428 Check if cal period is null, empty xml element
|
|
if (sensor.CalPeriodSpecified && sensor.CalPeriod.HasValue && sensor.CalPeriod.Value > 0) { sd.CalInterval = sensor.CalPeriod.Value; }
|
|
else { sensor.CalPeriod = 365; }
|
|
break;
|
|
case SensorData.ExchangeFields.Capacity:
|
|
sd.Capacity = Math.Max(sensor.MaxRange, sensor.PreferredRange);
|
|
sd.RangeHigh = sensor.MaxRange;
|
|
sd.RangeLow = sensor.MinRange;
|
|
sd.RangeMedium = sensor.PreferredRange;
|
|
break;
|
|
case SensorData.ExchangeFields.CheckOffset:
|
|
sd.CheckOffset = sensor.OffsetCheck;
|
|
break;
|
|
case SensorData.ExchangeFields.Comment:
|
|
if (!string.IsNullOrEmpty(sensor.Remark)) { sd.Comment = sensor.Remark.Substring(0, Math.Min(sensor.Remark.Length, 40)); }
|
|
else if (!string.IsNullOrEmpty(sensor.CompanyLongname)) { sd.Comment = sensor.CompanyLongname; }
|
|
sd.Comment = sd.Comment.Replace("\n", "");
|
|
break;
|
|
case SensorData.ExchangeFields.ExcitationVoltage:
|
|
double maxExc = Math.Max(sensor.ExcitationVoltage, sensor.SensitivityVoltage);
|
|
if (maxExc == 2D) { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt2 }; }
|
|
else if (maxExc == 2.5D) { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt2_5 }; }
|
|
else if (maxExc == 3D) { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt3 }; }
|
|
else if (maxExc == 5) { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 }; }
|
|
else if (maxExc == 10) { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt10 }; }
|
|
else { sd.SupportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Undefined }; }
|
|
break;
|
|
case SensorData.ExchangeFields.FilterClass:
|
|
var fc = new FilterClass(FilterClassType.None);
|
|
if (sensor.SWFilterClassTypeSpecified)
|
|
{
|
|
switch (sensor.SWFilterClassType)
|
|
{
|
|
case EqxFilterClassType.CFC10:
|
|
fc = new FilterClass(FilterClassType.CFC10);
|
|
break;
|
|
case EqxFilterClassType.CFC60:
|
|
fc = new FilterClass(FilterClassType.CFC60);
|
|
break;
|
|
case EqxFilterClassType.CFC180:
|
|
fc = new FilterClass(FilterClassType.CFC180);
|
|
break;
|
|
case EqxFilterClassType.CFC600:
|
|
fc = new FilterClass(FilterClassType.CFC600);
|
|
break;
|
|
case EqxFilterClassType.CFC1000:
|
|
fc = new FilterClass(FilterClassType.CFC1000);
|
|
break;
|
|
case EqxFilterClassType.AdHoc:
|
|
case EqxFilterClassType.None:
|
|
fc = new FilterClass(FilterClassType.None);
|
|
break;
|
|
}
|
|
}
|
|
sd.SetFilterAndFilterClassISO(fc, useZeroForUnfiltered, false);
|
|
break;
|
|
case SensorData.ExchangeFields.Id:
|
|
sd.EID = PadEIDIfNeeded(sensor.IDModuleString);
|
|
//there could be multiple entries in the eqx for a single sensor ... because of that
|
|
//right now just say if any of the entries has an IDModuleString, then the sensor has an IDModuleString
|
|
//so if we find a string in xml we set it to false straight out
|
|
//if we didn't find a string with this entry, but there's already a marking in the dictionary, then there's no point
|
|
//in updating the dictionary (if it's false it's overriding, if it's true it's the same value we would put in)
|
|
//finally if we didn't find a string and it's not in the dictionary, go ahead and set it to true
|
|
if (null == sensor.IDModuleString)
|
|
{
|
|
if (!_sensorHasNullIDModule.ContainsKey(sensor.UUID))
|
|
{
|
|
_sensorHasNullIDModule[sensor.UUID] = true;
|
|
}
|
|
}
|
|
else { _sensorHasNullIDModule[sensor.UUID] = false; }
|
|
break;
|
|
|
|
case SensorData.ExchangeFields.Invert:
|
|
sd.Invert = sensor.MountingPolarity == EqxPolarity.Negative;
|
|
break;
|
|
case SensorData.ExchangeFields.IsoCode:
|
|
sd.ISOCode = sensor.LocationCode;
|
|
if (sd.ISOCode?.Length == 16)
|
|
{
|
|
sd.FilterClassIso = sd.ISOCode?[15].ToString();
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.IsoLongName:
|
|
sd.ISOChannelName = sensor.LocationLongname;
|
|
break;
|
|
case SensorData.ExchangeFields.Manufacturer:
|
|
sd.Manufacturer = sensor.Supplier;
|
|
break;
|
|
case SensorData.ExchangeFields.MeasurementUnit:
|
|
if (string.IsNullOrWhiteSpace(sensor.PhysicalUnit))
|
|
{
|
|
sensor.PhysicalUnit = DTS.Common.SharedResource.Strings.StringResources.Units_EU;
|
|
errors.Add(string.Format(DTS.Common.SharedResource.Strings.StringResources.EQX_Warning_PhysicalUnitEmptyUsingEU, sd.SerialNumber));
|
|
}
|
|
sd.DisplayUnit = sensor.PhysicalUnit;
|
|
foreach (var r in sd.Calibration.Records.Records) { r.EngineeringUnits = sensor.PhysicalUnit; }
|
|
break;
|
|
case SensorData.ExchangeFields.Model:
|
|
sd.Model = sensor.Model;
|
|
break;
|
|
|
|
case SensorData.ExchangeFields.SerialNumber:
|
|
if (eqxUseSerialNumberFieldForSN)
|
|
{
|
|
if (!string.IsNullOrEmpty(sensor.SerialNumber))
|
|
{
|
|
sd.SerialNumber = sensor.SerialNumber.Replace("\n", "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sd.UserSerialNumber = sensor.SerialNumber;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.Shunt:
|
|
var shuntMode = ShuntMode.Emulation;
|
|
if ((sensor.ShuntCheckPosSpecified && sensor.ShuntCheckPos == false)
|
|
|| (sensor.ShuntResistanceSpecified && sensor.ShuntResistance <= 0))
|
|
{
|
|
shuntMode = ShuntMode.None;
|
|
}
|
|
sd.Shunt = shuntMode;
|
|
break;
|
|
case SensorData.ExchangeFields.Status:
|
|
break;
|
|
case SensorData.ExchangeFields.UserSerialNumber:
|
|
sd.UserSerialNumber = sensor.SerialNumber;
|
|
sd.UserSerialNumber = sd.UserSerialNumber?.Replace("\n", "");
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue1:
|
|
sd.UserValue1 = sensor.CompanyCode;
|
|
sd.UserCode = sensor.CompanyCode;
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue2:
|
|
sd.UserValue2 = sensor.CompanyLongname;
|
|
sd.UserChannelName = sensor.CompanyLongname;
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue3:
|
|
case SensorData.ExchangeFields.OffsetMethod:
|
|
case SensorData.ExchangeFields.CalZMO:
|
|
break;
|
|
case SensorData.ExchangeFields.FiringDelay:
|
|
if (sensor.FiringDelaySpecified)
|
|
{
|
|
sd.SquibFireDelayMS = sensor.FiringDelay;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.FiringDuration:
|
|
if (sensor.FiringDurationSpecified)
|
|
{
|
|
sd.SquibFireDurationMS = sensor.FiringDuration / 1000D;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.FireMode:
|
|
if (sensor.FiringModeSpecified)
|
|
{
|
|
sd.SquibFireMode = GetSquibFireMode(sensor.FiringMode);
|
|
sd.Bridge = BridgeType.SQUIB;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.CurrentLimit:
|
|
if (sensor.FiringCurrentLimitSpecified)
|
|
{
|
|
sd.SquibOutputCurrent = sensor.FiringCurrentLimit;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.InputMode:
|
|
if (sensor.InputModeSpecified)
|
|
{
|
|
sd.InputMode = GetInputMode(sensor.InputMode);
|
|
sd.Bridge = BridgeType.DigitalInput;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.SWOffsetCalculationEndSec:
|
|
if (sensor.SWOffsetCalculationEndSecSpecified)
|
|
{
|
|
zeroMethodEnd = sensor.SWOffsetCalculationEndSec;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.SWOffsetCalculationStartSec:
|
|
if (sensor.SWOffsetCalculationStartSecSpecified)
|
|
{
|
|
zeroMethodStart = sensor.SWOffsetCalculationStartSec;
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.SWOffsetCompensationType:
|
|
if (sensor.SWOffsetCompensationTypeSpecified)
|
|
{
|
|
zeroMethodType = GetZeroMethodType(sensor.SWOffsetCompensationType);
|
|
typeSpecified = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (string.IsNullOrEmpty(sd.SerialNumber))
|
|
{
|
|
sd.SerialNumber = sd.Comment;
|
|
}
|
|
if (string.IsNullOrEmpty(sd.ISOCode))
|
|
{
|
|
sd.ISOCode = new IsoCode(string.Empty).StringRepresentation;
|
|
}
|
|
if (string.IsNullOrEmpty(sd.Manufacturer) && !string.IsNullOrEmpty(sd.Model))
|
|
{
|
|
sd.Manufacturer = string.Empty;
|
|
}
|
|
sd.UUID = sensor.UUID;
|
|
|
|
//FB 42967 Assign fire delay
|
|
if (sensor.FiringDelaySpecified)
|
|
{
|
|
sd.SquibFireDelayMS = sensor.FiringDelay;
|
|
}
|
|
|
|
//FB 42967 Assign fire duration and convert to ms
|
|
if (sensor.FiringDurationSpecified)
|
|
{
|
|
sd.SquibFireDurationMS = sensor.FiringDuration / 1000.0;
|
|
}
|
|
|
|
var sc = GetCalibrationFromEQXSensorAxis(sensor, sd);
|
|
if (typeSpecified) { sc.ZeroMethods.Methods[0].Method = zeroMethodType; }
|
|
if (!double.IsNaN(zeroMethodStart)) { sc.ZeroMethods.Methods[0].Start = zeroMethodStart; }
|
|
if (!double.IsNaN(zeroMethodEnd)) { sc.ZeroMethods.Methods[0].End = zeroMethodEnd; }
|
|
|
|
if (!_sensorLookup.ContainsKey(sd.UUID))
|
|
{
|
|
_sensorLookup.Add(sd.UUID, sd);
|
|
_calibrationLookup.Add(sd.UUID, new List<SensorCalibration>());
|
|
if (sc.CalibrationDate.Year < 1970 || sc.CalibrationDate.Year > DateTime.Now.Year) { }
|
|
else { _calibrationLookup[sd.UUID].Add(sc); }
|
|
}
|
|
else
|
|
{
|
|
_sensorLookup[sd.UUID] = CombineSensors(sd, _sensorLookup[sd.UUID], useZeroForUnfiltered);
|
|
CombineCalibrations(sc, sensor.UUID);
|
|
}
|
|
if (null != sensor.CalHistory)
|
|
{
|
|
foreach (var cal in sensor.CalHistory) { CombineCalibrations(cal, sd.UUID, sensor); }
|
|
}
|
|
if (!string.IsNullOrEmpty(groupName))
|
|
{
|
|
_ = PopulateSensorLookup(groupName, ref sd,
|
|
ref errors,
|
|
ref _groupNameSensorListLookup,
|
|
ref _groupNameToTestObjectLookup);
|
|
}
|
|
}
|
|
private void ReadEQXCalibration(SensorCalibration sc, EqxSensorAxis sensor)
|
|
{
|
|
sc.NonLinear = true;
|
|
|
|
|
|
var sens1 = Convert.ToDouble(sensor.Sensitivity);
|
|
var exp = Convert.ToDouble(sensor.Sensitivity2);
|
|
sc.Records.Records[0].Poly.LinearizationExponent = exp;
|
|
if (!sensor.Sensitivity3Specified)
|
|
{
|
|
sc.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccAverageOverTime;
|
|
sc.Records.Records[0].Poly.MMPerV = sens1;
|
|
}
|
|
else
|
|
{
|
|
var sens3 = Convert.ToDouble(sensor.Sensitivity3);
|
|
sc.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccCalFactor;
|
|
|
|
//set the cal factor to 1000/sensitivity1, and set intercept to Sensitivity3/Sensitivity1
|
|
sc.Records.Records[0].Poly.CalibrationFactor = 1000 / sens1;
|
|
sc.Records.Records[0].Poly.ZeroPositionIntercept = sens3 / sens1;
|
|
}
|
|
sc.Records.Records[0].Poly.MarkValid(true);
|
|
}
|
|
|
|
private Dictionary<string, List<string>> _groupNameSensorListLookup = new Dictionary<string, List<string>>();
|
|
private Dictionary<string, string> _groupNameToTestObjectLookup = new Dictionary<string, string>();
|
|
/// <summary>
|
|
/// combine calibrations if necessary, or add a new entry if needed
|
|
///
|
|
/// </summary>
|
|
/// <param name="sc1"></param>
|
|
/// <param name="sensorUUID"></param>
|
|
private void CombineCalibrations(SensorCalibration sc1, string sensorUUID)
|
|
{
|
|
if (!_calibrationLookup.ContainsKey(sensorUUID)) { _calibrationLookup.Add(sensorUUID, new List<SensorCalibration>()); }
|
|
for (var i = 0; i < _calibrationLookup[sensorUUID].Count; i++)
|
|
{
|
|
var cal = _calibrationLookup[sensorUUID][i];
|
|
if (sc1.CalibrationDate.Date == cal.CalibrationDate.Date)
|
|
{
|
|
return;
|
|
// is in the history already ...
|
|
}
|
|
}
|
|
if (sc1.CalibrationDate.Year < 1970 || sc1.CalibrationDate.Year > DateTime.Now.Year) { return; }
|
|
_calibrationLookup[sensorUUID].Add(sc1);
|
|
}
|
|
/// <summary>
|
|
/// looks through existing calibration entries given a EQX entry and updates or combines calibrations as necessary
|
|
/// </summary>
|
|
/// <param name="entry"></param>
|
|
/// <param name="sensorUUID"></param>
|
|
/// <param name="sensor"></param>
|
|
private void CombineCalibrations(EqxCalHistoryEntry entry, string sensorUUID, EqxSensorAxis sensor)
|
|
{
|
|
if (!_calibrationLookup.ContainsKey(sensorUUID)) { _calibrationLookup[sensorUUID] = new List<SensorCalibration>(); }
|
|
var dt = DateTime.MinValue;
|
|
if (entry.CalDateSpecified) { dt = entry.CalDate; }
|
|
for (var i = 0; i < _calibrationLookup[sensorUUID].Count; i++)
|
|
{
|
|
var cal = _calibrationLookup[sensorUUID][i];
|
|
if (cal.CalibrationDate.Date != dt.Date) continue;
|
|
if (cal.CalVersion == entry.CalVersion)
|
|
{
|
|
return; //already present
|
|
}
|
|
}
|
|
|
|
//invalid date, reject
|
|
if (dt.Year < 1970 || dt.Year > DateTime.Now.Year) { return; }
|
|
|
|
_calibrationLookup[sensorUUID].Add(CreateSensorCalibration(entry, sensor));
|
|
}
|
|
/// <summary>
|
|
/// processes an EQX group
|
|
/// </summary>
|
|
/// <param name="group">group to process</param>
|
|
/// <param name="eqxUseSerialNumberFieldForSN"></param>
|
|
/// <param name="useZeroForUnfiltered"></param>
|
|
private void AddEQXGroup(EqxBaseSensorGroup group,
|
|
bool eqxUseSerialNumberFieldForSN,
|
|
bool useZeroForUnfiltered,
|
|
ref List<string>errors)
|
|
{
|
|
if (null != group.SensorGroup)
|
|
{
|
|
foreach (var subgroup in group.SensorGroup)
|
|
{
|
|
AddEQXGroup(subgroup, eqxUseSerialNumberFieldForSN, useZeroForUnfiltered, ref errors);
|
|
}
|
|
}
|
|
if (null == @group.Sensor) return;
|
|
foreach (var sensor in @group.Sensor)
|
|
{
|
|
var eqxSensorGroup = group as EqxSensorGroup;
|
|
AddEQXSensor(eqxSensorGroup.Name, sensor, eqxUseSerialNumberFieldForSN, useZeroForUnfiltered, ref errors);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// creates a sensor calibration given an EQX sensor record and EQX cal entry
|
|
/// </summary>
|
|
/// <param name="cal"></param>
|
|
/// <param name="sensor"></param>
|
|
/// <returns></returns>
|
|
private SensorCalibration CreateSensorCalibration(EqxCalHistoryEntry cal, EqxSensorAxis sensor)
|
|
{
|
|
var sc = GetCalibrationFromEQXSensorAxis(sensor, _sensorLookup.ContainsKey(sensor.UUID) ? _sensorLookup[sensor.UUID] : null);
|
|
|
|
sc.CalibrationDate = cal.CalDateSpecified ? cal.CalDate : DateTime.MinValue;
|
|
sc.Username = cal.CalPerson;
|
|
sc.CalVersion = cal.CalVersion;
|
|
|
|
sc.Records.Records[0].EngineeringUnits = sensor.PhysicalUnit;
|
|
|
|
//15609 Sensors not usable after EQX import
|
|
//use excitation voltage from eqx file
|
|
if (cal.SensitivityVoltageSpecified)
|
|
{
|
|
if (cal.SensitivityVoltage.Equals(1F))
|
|
{
|
|
sc.IsProportional = true;
|
|
sc.Records.Records[0].Excitation = ExcitationVoltageOptions.ExcitationVoltageOption.Volt5;
|
|
}
|
|
else
|
|
{
|
|
sc.Records.Records[0].Excitation = Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(cal.SensitivityVoltage);
|
|
}
|
|
}
|
|
|
|
sc.CalVersion = cal.CalVersion;
|
|
return sc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// keeps track of which EQX sensor entries has null id module strings
|
|
/// we do this so that we can prevent overwriting the EID on existing sensors when the id module string is null
|
|
/// since there could be multiple entries, any entries with an EID should take the cake
|
|
/// 18467 Missing IDModuleString in e2x file import is clearing the EID on sensor import
|
|
/// they key is the UUID for the sensor, the value is whether it had a NULL IDModuleString or not
|
|
/// </summary>
|
|
|
|
public SensorData MakeDefaultSensor()
|
|
{
|
|
return SensorDBTables.CreateDefaultSensor(DefaultZeroMethodStart, DefaultZeroMethodEnd); // FB12764: Default AoT data in SensorConstants
|
|
}
|
|
private const double DefaultOffsetToleranceLow = -100D;
|
|
private const double DefaultOffsetToleranceHigh = 100D;
|
|
/// <summary>
|
|
/// merges sensors into one sensor
|
|
/// This can happen when there are multiple entries for the same sensor in EQX
|
|
/// </summary>
|
|
/// <param name="sd1"></param>
|
|
/// <param name="sd2"></param>
|
|
/// <param name="useZeroForUnfiltered"></param>
|
|
/// <returns></returns>
|
|
private SensorData CombineSensors(SensorData sd1, SensorData sd2, bool useZeroForUnfiltered)
|
|
{
|
|
var sdNew = MakeDefaultSensor();
|
|
sdNew.UUID = sd1.UUID;
|
|
foreach (var enumValue in Enum.GetValues(typeof(SensorData.ExchangeFields)))
|
|
{
|
|
switch ((SensorData.ExchangeFields)enumValue)
|
|
{
|
|
case SensorData.ExchangeFields.BridgeResistance:
|
|
sdNew.BridgeResistance = Math.Max(sd1.BridgeResistance, sd2.BridgeResistance);
|
|
break;
|
|
case SensorData.ExchangeFields.BridgeType:
|
|
if (sd1.Bridge == sd2.Bridge) { sdNew.Bridge = sd1.Bridge; }
|
|
sdNew.Bridge = sd2.Bridge;
|
|
break;
|
|
case SensorData.ExchangeFields.CalibrationDate:
|
|
break;
|
|
case SensorData.ExchangeFields.CalibrationDueDate:
|
|
break;
|
|
case SensorData.ExchangeFields.CalUser:
|
|
break;
|
|
case SensorData.ExchangeFields.CalZMO:
|
|
break;
|
|
case SensorData.ExchangeFields.Capacity:
|
|
sdNew.Capacity = Math.Max(sd1.Capacity, sd2.Capacity);
|
|
break;
|
|
case SensorData.ExchangeFields.CheckOffset:
|
|
sdNew.CheckOffset = sd1.CheckOffset != sd2.CheckOffset || sd1.CheckOffset;
|
|
break;
|
|
case SensorData.ExchangeFields.Comment:
|
|
sdNew.Comment = String.IsNullOrEmpty(sd1.Comment) ? sd2.Comment : sd1.Comment;
|
|
break;
|
|
case SensorData.ExchangeFields.OffsetToleranceLow:
|
|
if (sd1.OffsetToleranceLow == sd2.OffsetToleranceLow) { sdNew.OffsetToleranceLow = sd1.OffsetToleranceLow; }
|
|
else if (sd1.OffsetToleranceLow == DefaultOffsetToleranceLow) { sdNew.OffsetToleranceLow = sd2.OffsetToleranceLow; }
|
|
else if (sd2.OffsetToleranceLow == DefaultOffsetToleranceLow) { sdNew.OffsetToleranceLow = sd1.OffsetToleranceLow; }
|
|
else { sdNew.OffsetToleranceLow = Math.Min(sd1.OffsetToleranceLow, sd2.OffsetToleranceLow); }
|
|
break;
|
|
case SensorData.ExchangeFields.OffsetToleranceHigh:
|
|
if (sd1.OffsetToleranceHigh == sd2.OffsetToleranceHigh) { sdNew.OffsetToleranceHigh = sd1.OffsetToleranceHigh; }
|
|
else if (sd1.OffsetToleranceHigh == DefaultOffsetToleranceHigh) { sdNew.OffsetToleranceHigh = sd2.OffsetToleranceHigh; }
|
|
else if (sd2.OffsetToleranceHigh == DefaultOffsetToleranceHigh) { sdNew.OffsetToleranceHigh = sd1.OffsetToleranceHigh; }
|
|
else { sdNew.OffsetToleranceHigh = Math.Min(sd1.OffsetToleranceHigh, sd2.OffsetToleranceHigh); }
|
|
break;
|
|
case SensorData.ExchangeFields.ExcitationVoltage:
|
|
if (sd1.SupportedExcitation[0] == sd2.SupportedExcitation[0]) { sdNew.SupportedExcitation = sd2.SupportedExcitation; }
|
|
else if (sd1.SupportedExcitation[0] == ExcitationVoltageOptions.ExcitationVoltageOption.Undefined) { sdNew.SupportedExcitation = sd2.SupportedExcitation; }
|
|
else { sdNew.SupportedExcitation = sd1.SupportedExcitation; }
|
|
break;
|
|
case SensorData.ExchangeFields.FilterClass:
|
|
sdNew.SetFilterAndFilterClassISO(sd1.Filter, useZeroForUnfiltered, false);
|
|
break;
|
|
case SensorData.ExchangeFields.Id:
|
|
sdNew.EID = string.IsNullOrEmpty(sd1.EID) ? sd2.EID : sd1.EID;
|
|
break;
|
|
case SensorData.ExchangeFields.InitialEU:
|
|
break;//handled in calibration data
|
|
|
|
case SensorData.ExchangeFields.Invert:
|
|
sdNew.Invert = sd1.Invert != sd2.Invert || sd1.Invert;
|
|
break;
|
|
case SensorData.ExchangeFields.IsoCode:
|
|
//if 1 is empty use 2, otherwise just use 1
|
|
sdNew.ISOCode = string.IsNullOrEmpty(sd1.ISOCode) ? sd2.ISOCode : sd1.ISOCode;
|
|
//so we either had 1 empty and chose #2, or #1 wasn't empty and we used it
|
|
//just incase #1 isn't empty, but is blank ... double check that if #1 is blank and #2 isn't
|
|
sdNew.ISOCode = (GroupChannel.BLANK_FULL_ISO.Equals(sd1.ISOCode) && !GroupChannel.BLANK_FULL_ISO.Equals(sd2.ISOCode)) ?
|
|
sd2.ISOCode : sdNew.ISOCode;
|
|
|
|
if (sdNew.ISOCode?.Length == 16)
|
|
{
|
|
sdNew.FilterClassIso = sdNew.ISOCode?[15].ToString();
|
|
}
|
|
break;
|
|
case SensorData.ExchangeFields.IsoLongName:
|
|
sdNew.ISOChannelName = string.IsNullOrEmpty(sd1.ISOChannelName) ? sd2.ISOChannelName : sd1.ISOChannelName;
|
|
break;
|
|
case SensorData.ExchangeFields.Manufacturer:
|
|
sdNew.Manufacturer = string.IsNullOrEmpty(sd1.Manufacturer) ? sd2.Manufacturer : sd1.Manufacturer;
|
|
break;
|
|
case SensorData.ExchangeFields.MeasurementUnit:
|
|
sdNew.DisplayUnit = string.IsNullOrEmpty(sd1.DisplayUnit) ? sd2.DisplayUnit : sd1.DisplayUnit;
|
|
break;
|
|
case SensorData.ExchangeFields.Model:
|
|
sdNew.Model = string.IsNullOrEmpty(sd1.Model) ? sd2.Model : sd1.Model;
|
|
break;
|
|
case SensorData.ExchangeFields.Sensitivity:
|
|
break;
|
|
case SensorData.ExchangeFields.SerialNumber:
|
|
if (string.IsNullOrEmpty(sd1.SerialNumber))
|
|
{
|
|
if (!string.IsNullOrEmpty(sd2.SerialNumber)) { sdNew.SerialNumber = sd2.SerialNumber; }
|
|
}
|
|
else { sdNew.SerialNumber = sd1.SerialNumber; }
|
|
break;
|
|
case SensorData.ExchangeFields.Shunt:
|
|
if (sd2.Shunt == sd1.Shunt) { sdNew.Shunt = sd1.Shunt; }
|
|
break;
|
|
case SensorData.ExchangeFields.Status:
|
|
break;
|
|
case SensorData.ExchangeFields.UserSerialNumber:
|
|
sdNew.UserSerialNumber = string.IsNullOrEmpty(sd1.UserSerialNumber) ? sd2.UserSerialNumber : sd1.UserSerialNumber;
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue1:
|
|
sdNew.UserValue1 = string.IsNullOrEmpty(sd1.UserValue1) ? sd2.UserValue1 : sd1.UserValue1;
|
|
sdNew.UserCode = string.IsNullOrEmpty(sd1.UserCode) ? sd2.UserCode : sd1.UserCode;
|
|
sdNew.UserChannelName = string.IsNullOrEmpty(sd1.UserChannelName) ? sd2.UserChannelName : sd1.UserChannelName;
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue2:
|
|
sdNew.UserValue2 = string.IsNullOrEmpty(sd1.UserValue2) ? sd2.UserValue2 : sd1.UserValue2;
|
|
break;
|
|
case SensorData.ExchangeFields.UserValue3:
|
|
sdNew.UserValue3 = string.IsNullOrEmpty(sd1.UserValue3) ? sd2.UserValue3 : sd1.UserValue3;
|
|
break;
|
|
case SensorData.ExchangeFields.IsProportional: break;//handled by calibration
|
|
case SensorData.ExchangeFields.RemoveOffset: break;//handled by calibration
|
|
case SensorData.ExchangeFields.OffsetMethod:
|
|
//don't think EQX populates this?
|
|
//16286 EQX import failed in Sensor DB when Set "EQXUseSerialNumberFieldForSN" to true in DataPRO.exe.config file
|
|
break;
|
|
case SensorData.ExchangeFields.FiringDelay:
|
|
sdNew.DelayMS = sd1.DelayMS == 0 ? sd2.DelayMS : sd1.DelayMS;
|
|
break;
|
|
case SensorData.ExchangeFields.FiringDuration:
|
|
sdNew.DurationMS = 0 == sd1.DurationMS ? sd2.DurationMS : sd1.DurationMS;
|
|
sdNew.LimitDuration = sd1.LimitDuration || sd2.LimitDuration;
|
|
break;
|
|
case SensorData.ExchangeFields.FireMode:
|
|
sdNew.SquibFireMode = sd1.SquibFireMode != SquibFireMode.NONE ? sd1.SquibFireMode : sd2.SquibFireMode;
|
|
break;
|
|
case SensorData.ExchangeFields.CurrentLimit:
|
|
sdNew.SquibOutputCurrent = sd1.SquibOutputCurrent == 0 ? sd2.SquibOutputCurrent : sd1.SquibOutputCurrent;
|
|
break;
|
|
case SensorData.ExchangeFields.InputMode:
|
|
sdNew.InputMode = sd1.InputMode == DigitalInputModes.NONE ? sd2.InputMode : sd1.InputMode;
|
|
break;
|
|
case SensorData.ExchangeFields.SWOffsetCalculationStartSec:
|
|
case SensorData.ExchangeFields.SWOffsetCalculationEndSec:
|
|
case SensorData.ExchangeFields.SWOffsetCompensationType:
|
|
//calibration fields
|
|
break;
|
|
|
|
default: throw new NotSupportedException("ImportSensorsPreviewControl::CombineSensors unsupported field: " + enumValue);
|
|
}
|
|
}
|
|
if (string.IsNullOrEmpty(sdNew.SerialNumber))
|
|
{
|
|
sdNew.SerialNumber = sdNew.Comment;
|
|
}
|
|
return sdNew;
|
|
}
|
|
private ZeroMethodType GetZeroMethodType(EqxSWOffsetCompensationType eqxZero)
|
|
{
|
|
switch(eqxZero)
|
|
{
|
|
case EqxSWOffsetCompensationType.Averagecalculation: return ZeroMethodType.AverageOverTime;
|
|
case EqxSWOffsetCompensationType.Fixvalue: return ZeroMethodType.None;
|
|
case EqxSWOffsetCompensationType.Pretestmeasurement: return ZeroMethodType.UsePreEventDiagnosticsZero;
|
|
default: throw new InvalidCastException($"no zero method type: {eqxZero}");
|
|
}
|
|
}
|
|
private DigitalInputModes GetInputMode(EqxInputModes mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case EqxInputModes.TLH: return DigitalInputModes.TLH;
|
|
case EqxInputModes.THL: return DigitalInputModes.THL;
|
|
case EqxInputModes.CCNO: return DigitalInputModes.CCNO;
|
|
case EqxInputModes.CCNC:
|
|
default:
|
|
return DigitalInputModes.CCNC;
|
|
}
|
|
}
|
|
private SquibFireMode GetSquibFireMode(EqxFiringMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case EqxFiringMode.AC: return SquibFireMode.AC;
|
|
case EqxFiringMode.DC:
|
|
return SquibFireMode.CAP;
|
|
case EqxFiringMode.ConstantCurrent:
|
|
return SquibFireMode.CONSTANT;
|
|
case EqxFiringMode.CapacitorDischarge:
|
|
default:
|
|
return SquibFireMode.CAP;
|
|
}
|
|
}
|
|
public EQXSensorDatabase(bool usemVOverVForPolys)
|
|
{
|
|
UsemVOverVForPolys = usemVOverVForPolys;
|
|
}
|
|
}
|
|
}
|