init

DataPRO/EquipmentExchange/.svn/entries

@@ -0,0 +1 @@
+12

DataPRO/EquipmentExchange/.svn/format

@@ -0,0 +1 @@
+12

DataPRO/EquipmentExchange/.svn/pristine/2b/2b3cb3103680f9c1d3c82a005abb8563fe7f9593.svn-base

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{2513797D-EC82-48D5-969E-6B3B5E6002E3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>EquipmentExchange</RootNamespace>
+    <AssemblyName>EquipmentExchange</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkProfile />
+    <SccProjectName>
+    </SccProjectName>
+    <SccLocalPath>
+    </SccLocalPath>
+    <SccAuxPath>
+    </SccAuxPath>
+    <SccProvider>
+    </SccProvider>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="CrashDesignerTestSetup.cs" />
+    <Compile Include="EquipmentExchange.cs" />
+    <Compile Include="EQXSensorDatabase.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common.DAS.Concepts\DTS.Common.DAS.Concepts.csproj">
+      <Project>{AE3987F7-C4C6-40FB-A353-1A2DADEF7A9A}</Project>
+      <Name>DTS.Common.DAS.Concepts</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Common\DTS.Common.SharedResource\DTS.Common.SharedResource.csproj">
+      <Project>{c01e723f-86e2-403a-864c-9f56bdb60b8d}</Project>
+      <Name>DTS.Common.SharedResource</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{F7A0804F-61A4-40AE-83D0-F1137622B592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\SensorDB\SensorDB.csproj">
+      <Project>{444ef10c-046e-47ad-a9a5-17318d488723}</Project>
+      <Name>SensorDB</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

DataPRO/EquipmentExchange/.svn/pristine/3b/3b2f90077df459eefaeb5b217495f8d79c166def.svn-base

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("EquipmentExchange")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("EquipmentExchange")]
+[assembly: AssemblyCopyright("Copyright ©  2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3ec1813d-f027-400f-bb8b-93794efcd5af")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataPRO/EquipmentExchange/.svn/pristine/50/50e8a27642b55c2d8848094c6f28867f796d8ea4.svn-base

@@ -0,0 +1,991 @@
+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;
+        }
+    }
+}

DataPRO/EquipmentExchange/.svn/pristine/f8/f81733cfece981263810e6fba5f4e8094c45c54f.svn-base

@@ -0,0 +1,571 @@
+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;
+                }
+            }
+        }
+    }
+}

DataPRO/EquipmentExchange/CrashDesignerTestSetup.cs

@@ -0,0 +1,571 @@
+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;
+                }
+            }
+        }
+    }
+}

DataPRO/EquipmentExchange/EQXSensorDatabase.cs

@@ -0,0 +1,991 @@
+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;
+        }
+    }
+}

DataPRO/EquipmentExchange/EquipmentExchange.csproj

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{2513797D-EC82-48D5-969E-6B3B5E6002E3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>EquipmentExchange</RootNamespace>
+    <AssemblyName>EquipmentExchange</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkProfile />
+    <SccProjectName>
+    </SccProjectName>
+    <SccLocalPath>
+    </SccLocalPath>
+    <SccAuxPath>
+    </SccAuxPath>
+    <SccProvider>
+    </SccProvider>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="CrashDesignerTestSetup.cs" />
+    <Compile Include="EquipmentExchange.cs" />
+    <Compile Include="EQXSensorDatabase.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common.DAS.Concepts\DTS.Common.DAS.Concepts.csproj">
+      <Project>{AE3987F7-C4C6-40FB-A353-1A2DADEF7A9A}</Project>
+      <Name>DTS.Common.DAS.Concepts</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Common\DTS.Common.SharedResource\DTS.Common.SharedResource.csproj">
+      <Project>{c01e723f-86e2-403a-864c-9f56bdb60b8d}</Project>
+      <Name>DTS.Common.SharedResource</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{F7A0804F-61A4-40AE-83D0-F1137622B592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\SensorDB\SensorDB.csproj">
+      <Project>{444ef10c-046e-47ad-a9a5-17318d488723}</Project>
+      <Name>SensorDB</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

DataPRO/EquipmentExchange/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("EquipmentExchange")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("EquipmentExchange")]
+[assembly: AssemblyCopyright("Copyright ©  2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3ec1813d-f027-400f-bb8b-93794efcd5af")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataPRO/EquipmentExchange/obj/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]

DataPRO/EquipmentExchange/obj/x86/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]