1445 lines
72 KiB
C#
1445 lines
72 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using DTS.Common.DAS.Concepts;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using DTS.Common.Enums;
|
|
using DTS.Common.Storage;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.Sensors;
|
|
using DTS.Common.Interface.Sensors.SoftwareFilters;
|
|
using DTS.Common.Classes;
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
namespace DTS.SensorDB
|
|
{
|
|
public abstract class SensorBase : AnalogDbRecord, ISensorBase
|
|
{
|
|
public int CompareTo(SensorModel rhs)
|
|
{
|
|
if (null == Model) { Model = ""; }
|
|
if (null == rhs.Model) { rhs.Model = ""; }
|
|
return Model.CompareTo(rhs.Model);
|
|
}
|
|
|
|
public virtual bool IsDigitalInput() { return Bridge == SensorConstants.BridgeType.DigitalInput; }
|
|
|
|
public virtual bool IsDigitalOutput() { return Bridge == SensorConstants.BridgeType.TOMDigital; }
|
|
public virtual bool IsSquib() { return Bridge == SensorConstants.BridgeType.SQUIB; }
|
|
public virtual bool IsUart() { return Bridge == SensorConstants.BridgeType.UART; }
|
|
public virtual bool IsStreamOutput() { return Bridge == SensorConstants.BridgeType.StreamOut; }
|
|
public virtual bool IsStreamInput() { return Bridge == SensorConstants.BridgeType.StreamIn; }
|
|
public virtual bool IsThermocoupler() { return Bridge == SensorConstants.BridgeType.Thermocoupler; }
|
|
public virtual bool IsCan() { return Bridge == SensorConstants.BridgeType.CAN; }
|
|
|
|
public SensorBase() : base()
|
|
{
|
|
}
|
|
public SensorBase(IDataReader reader, int actualDbVersion) : base(reader, actualDbVersion)
|
|
{
|
|
}
|
|
public SensorBase(IAnalogDbRecord record) : base(record)
|
|
{
|
|
|
|
}
|
|
public virtual void CopyValues(ISensorBase iCopy, bool copyCalibration = true)
|
|
{
|
|
var copy = (SensorBase)iCopy;
|
|
AxisNumber = copy.AxisNumber;
|
|
Bridge = copy.Bridge;
|
|
BridgeResistance = copy.BridgeResistance;
|
|
if (copyCalibration)
|
|
{
|
|
Calibration.CopyValues(copy.Calibration);
|
|
}
|
|
CalInterval = copy.CalInterval;
|
|
Capacity = copy.Capacity;
|
|
CheckOffset = copy.CheckOffset;
|
|
CouplingMode = copy.CouplingMode;
|
|
Direction = copy.Direction;
|
|
Filter = new FilterClass(copy.Filter.FClass, copy.Filter.Frequency);
|
|
IgnoreRange = copy.IgnoreRange;
|
|
Invert = copy.Invert;
|
|
ISOCode = copy.ISOCode;
|
|
ISOChannelName = copy.ISOChannelName;
|
|
UserCode = copy.UserCode;
|
|
UserChannelName = copy.UserChannelName;
|
|
LastModified = copy.LastModified;
|
|
LastUpdatedBy = copy.LastUpdatedBy;
|
|
_localOnly = copy.LocalOnly;
|
|
Manufacturer = copy.Manufacturer;
|
|
DisplayUnit = copy.DisplayUnit;
|
|
Model = copy.Model;
|
|
NumberOfAxes = copy.NumberOfAxes;
|
|
OffsetToleranceHigh = copy.OffsetToleranceHigh;
|
|
OffsetToleranceLow = copy.OffsetToleranceLow;
|
|
PhysicalDimension = copy.PhysicalDimension;
|
|
Polarity = copy.Polarity;
|
|
RangeHigh = copy.RangeHigh;
|
|
RangeLow = copy.RangeLow;
|
|
RangeMedium = copy.RangeMedium;
|
|
Shunt = copy.Shunt;
|
|
_supportedExcitation = copy.SupportedExcitation;
|
|
UniPolar = copy.UniPolar;
|
|
UserPartNumber = copy.UserPartNumber;
|
|
Broken = copy.Broken;
|
|
DoNotUse = copy.DoNotUse;
|
|
//43046
|
|
SensitivityTolerancePercent = copy.SensitivityTolerancePercent;
|
|
MeasureExcitation = copy.MeasureExcitation;
|
|
MeasureNoise = copy.MeasureNoise;
|
|
}
|
|
|
|
|
|
protected bool _measureNoise = true;
|
|
public bool MeasureNoise
|
|
{
|
|
get => _measureNoise;
|
|
set => SetProperty(ref _measureNoise, value, "MeasureNoise");
|
|
}
|
|
|
|
protected bool _measureExcitation = true;
|
|
public bool MeasureExcitation
|
|
{
|
|
get => _measureExcitation;
|
|
set => SetProperty(ref _measureExcitation, value, "MeasureExcitation");
|
|
}
|
|
|
|
protected string _UserPartNumber = "";
|
|
public string UserPartNumber
|
|
{
|
|
get => _UserPartNumber;
|
|
set => SetProperty(ref _UserPartNumber, value, "UserPartNumber");
|
|
}
|
|
|
|
public double FullScaleCapacity => 2400D;
|
|
|
|
public virtual void SetDisplayUnitNoNotify(string unit)
|
|
{
|
|
_displayUnit = unit;
|
|
}
|
|
|
|
public virtual void SetExcitationsNoNotify(ExcitationVoltageOptions.ExcitationVoltageOption[] excitations)
|
|
{
|
|
_supportedExcitation = excitations;
|
|
}
|
|
|
|
protected SensorCalibration _calibration = new SensorCalibration();
|
|
/// <summary>
|
|
/// sensor models shouldn't have a cal date, but this is the min cal date we can use and not cause problems unintentionally somewhere else
|
|
/// </summary>
|
|
public virtual ISensorCalibration Calibration
|
|
{
|
|
get => _calibration;
|
|
set => SetProperty(ref _calibration, (SensorCalibration)value, "Calibration");
|
|
}
|
|
|
|
public new ShuntMode Shunt
|
|
{
|
|
get => (ShuntMode)base.Shunt;
|
|
set => base.Shunt = (short)value;
|
|
}
|
|
// http://manuscript.dts.local/f/cases/18743/Unable-to-enter-bridge-resistance-on-a-half-bridge-sensor
|
|
private const double HALF_BRIDGE_RESISTANCE = 3000.0D;
|
|
|
|
public new double BridgeResistance
|
|
{
|
|
get
|
|
{
|
|
double rv;
|
|
switch (Bridge)
|
|
{
|
|
// http://manuscript.dts.local/f/cases/18743/Unable-to-enter-bridge-resistance-on-a-half-bridge-sensor
|
|
case SensorConstants.BridgeType.HalfBridge:
|
|
case SensorConstants.BridgeType.HalfBridge_SigPlus:
|
|
rv = HALF_BRIDGE_RESISTANCE;
|
|
break;
|
|
default:
|
|
rv = base.BridgeResistance;
|
|
break;
|
|
}
|
|
return rv;
|
|
}
|
|
set => base.BridgeResistance = value;
|
|
}
|
|
|
|
|
|
protected IFilterClass _filterClass;
|
|
// FB 13120 Define filter class
|
|
public IFilterClass FilterClass
|
|
{
|
|
get
|
|
{
|
|
return _filterClass == null ? Filter : _filterClass;
|
|
}
|
|
set => SetProperty(ref _filterClass, value, "FilterClass");
|
|
}
|
|
|
|
public FilterClassType FilterType { get => Filter.FClass; }
|
|
|
|
public void SetFilterAndFilterClassISO(IFilterClass f, bool useZeroForUnfiltered, bool digitalIn)
|
|
{
|
|
Filter = f;
|
|
var ic = new IsoCode(ISOCode);
|
|
|
|
if (digitalIn)
|
|
{
|
|
ic.FilterClass = "0";
|
|
}
|
|
else
|
|
{
|
|
switch (f.FClass)
|
|
{
|
|
case FilterClassType.CFC1000: ic.FilterClass = "A"; break;
|
|
case FilterClassType.CFC180: ic.FilterClass = "C"; break;
|
|
case FilterClassType.CFC60: ic.FilterClass = "D"; break;
|
|
case FilterClassType.CFC600: ic.FilterClass = "B"; break;
|
|
case FilterClassType.AdHoc: ic.FilterClass = "S"; break;
|
|
case FilterClassType.Unfiltered: ic.FilterClass = useZeroForUnfiltered ? "0" : "P"; break;
|
|
default: ic.FilterClass = "P"; break;
|
|
}
|
|
}
|
|
ISOCode = ic.StringRepresentation;
|
|
}
|
|
public double Frequency
|
|
{
|
|
get => Filter.Frequency;
|
|
set
|
|
{
|
|
Filter.Frequency = value;
|
|
OnPropertyChanged("Frequency");
|
|
}
|
|
}
|
|
|
|
// FB 5843 - Surface the CFC Setting Option for a sensor in the SensorDB UI
|
|
public string FilterClassIso
|
|
{
|
|
get
|
|
{
|
|
switch (Filter.FClass)
|
|
{
|
|
case FilterClassType.Unfiltered:
|
|
return "0";
|
|
case FilterClassType.CFC1000:
|
|
return "A";
|
|
case FilterClassType.CFC600:
|
|
return "B";
|
|
case FilterClassType.CFC180:
|
|
return "C";
|
|
case FilterClassType.CFC60:
|
|
return "D";
|
|
case FilterClassType.None:
|
|
return "P";
|
|
case FilterClassType.AdHoc:
|
|
return "S";
|
|
default:
|
|
return "?";
|
|
}
|
|
}
|
|
set
|
|
{
|
|
//var ic = new IsoCode(ISOCode) { FilterClass = value };
|
|
//ISOCode = ic.StringRepresentation;
|
|
switch (value)
|
|
{
|
|
case "0":
|
|
Filter = new FilterClass(FilterClassType.Unfiltered);
|
|
break;
|
|
case "A":
|
|
Filter = new FilterClass(FilterClassType.CFC1000);
|
|
break;
|
|
case "B":
|
|
Filter = new FilterClass(FilterClassType.CFC600);
|
|
break;
|
|
case "C":
|
|
Filter = new FilterClass(FilterClassType.CFC180);
|
|
break;
|
|
case "D":
|
|
Filter = new FilterClass(FilterClassType.CFC60);
|
|
break;
|
|
case "P":
|
|
Filter = new FilterClass(FilterClassType.None);
|
|
break;
|
|
case "S":
|
|
//FB 13120 use frecuency for adhoc
|
|
Filter = new FilterClass(FilterClassType.AdHoc, Frequency);
|
|
break;
|
|
default:
|
|
Filter = new FilterClass(FilterClassType.CFC1000);
|
|
break;
|
|
}
|
|
OnPropertyChanged("FilterClassIso");
|
|
}
|
|
}
|
|
|
|
protected bool _IgnoreRange = false;
|
|
public bool IgnoreRange
|
|
{
|
|
get => _IgnoreRange;
|
|
set => SetProperty(ref _IgnoreRange, value, "IgnoreRange");
|
|
}
|
|
|
|
public string LastUpdatedBy
|
|
{
|
|
get => ModifiedBy;
|
|
set
|
|
{
|
|
ModifiedBy = value;
|
|
OnPropertyChanged("LastUpdatedBy");
|
|
}
|
|
}
|
|
|
|
public new bool LocalOnly
|
|
{
|
|
get => base.LocalOnly;
|
|
}
|
|
public void SetLocalOnly(bool bLocalOnly)
|
|
{
|
|
base.LocalOnly = bLocalOnly;
|
|
}
|
|
|
|
public string Polarity
|
|
{
|
|
get => Invert ? "-" : "+";
|
|
set { Invert = value == "-"; OnPropertyChanged("Polarity"); }
|
|
}
|
|
|
|
protected string _physicalDimension = string.Empty;
|
|
public string PhysicalDimension
|
|
{
|
|
get => _physicalDimension;
|
|
set => _physicalDimension = value;
|
|
}
|
|
|
|
protected string _direction = string.Empty;
|
|
public string Direction
|
|
{
|
|
get => _direction;
|
|
set => _direction = value;
|
|
}
|
|
|
|
private bool _outOfDate = false;
|
|
public bool OutOfDate
|
|
{
|
|
get => _outOfDate;
|
|
set => SetProperty(ref _outOfDate, value, "OutOfDate");
|
|
}
|
|
|
|
private bool _inWarningPeriod = false;
|
|
public bool InWarningPeriod
|
|
{
|
|
get => _inWarningPeriod;
|
|
set => SetProperty(ref _inWarningPeriod, value, "InWarningPeriod");
|
|
}
|
|
//FB 43246
|
|
private bool _inspectBeforeUse = false;
|
|
public bool InspectBeforeUse
|
|
{
|
|
get => _inspectBeforeUse;
|
|
set => SetProperty(ref _inspectBeforeUse, value, "InspectBeforeUse");
|
|
}
|
|
|
|
public enum SensorBaseFields
|
|
{
|
|
CheckOffset,
|
|
Invert,
|
|
Model,
|
|
Manufacturer,
|
|
UserPartNumber,
|
|
Capacity,
|
|
CouplingMode,
|
|
OffsetToleranceLow,
|
|
OffsetToleranceHigh,
|
|
MeasurementUnit,
|
|
RangeLow,
|
|
RangeMedium,
|
|
RangeHigh,
|
|
SupportedExcitation,
|
|
Calibration,
|
|
Bridge,
|
|
Shunt,
|
|
BridgeResistance,
|
|
Filter,
|
|
UniPolar,
|
|
IgnoreRange,
|
|
LastUpdatedBy,
|
|
Version,
|
|
LocalOnly,
|
|
AxisNumber,
|
|
NumberOfAxes,
|
|
CalInterval,
|
|
Polarity,
|
|
LastModified,
|
|
ISOCode,
|
|
PhysicalDimension,
|
|
Direction,
|
|
Broken,
|
|
DoNotUse
|
|
}
|
|
|
|
/// <summary>
|
|
/// modifies an isocode's Filter Class based on a sensor's Filter if the isocode's Filter Class is "?"
|
|
/// FB 8037 - sensor's default filter not displayed after SIF import
|
|
/// </summary>
|
|
/// <param name="importingIsoCode">the starting ISO code which may or may not already have a filter</param>
|
|
/// <param name="sensorFilterClass">the sensor's filter class to be used if the channel doesn't already have one</param>
|
|
/// <returns>a string representation of the ISO code with a non-'?' Filter Class if the sensor's Filter is one of the ISO values</returns>
|
|
public string BuildIsoCodeFromFilter(string importingIsoCode, FilterClassType sensorFilterClass)
|
|
{
|
|
var isoCodeWithFilter = new IsoCode(importingIsoCode);
|
|
if (isoCodeWithFilter.FilterClass == "?")
|
|
{
|
|
isoCodeWithFilter.FilterClass = FClassToIsoFilterCode(sensorFilterClass);
|
|
};
|
|
return isoCodeWithFilter.StringRepresentation;
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns the ISO Code for a Filter Class
|
|
/// </summary>
|
|
private static string FClassToIsoFilterCode(FilterClassType fClass)
|
|
{
|
|
switch (fClass)
|
|
{
|
|
case FilterClassType.Unfiltered:
|
|
return "0";
|
|
case FilterClassType.CFC1000:
|
|
return "A";
|
|
case FilterClassType.CFC600:
|
|
return "B";
|
|
case FilterClassType.CFC180:
|
|
return "C";
|
|
case FilterClassType.CFC60:
|
|
return "D";
|
|
case FilterClassType.None:
|
|
return "P";
|
|
case FilterClassType.AdHoc:
|
|
return "S";
|
|
default:
|
|
throw new ArgumentOutOfRangeException("fClass", fClass, null);
|
|
}
|
|
}
|
|
|
|
}
|
|
public class SensorModel : SensorBase, IComparable<SensorModel>
|
|
{
|
|
public override ISensorCalibration Calibration
|
|
{
|
|
get
|
|
{
|
|
if (null == base.Calibration) { return null; }
|
|
base.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
return base.Calibration;
|
|
}
|
|
set => base.Calibration = value;
|
|
}
|
|
public enum IRTraccFormats
|
|
{
|
|
Manual,
|
|
DiagnosticZeroMMmV,
|
|
ZeroMMmV,
|
|
AverageOverTime,
|
|
Polynomial
|
|
}
|
|
public enum PolynomialStyles
|
|
{
|
|
IRTRacc,
|
|
POT,
|
|
Thermocoupler,
|
|
Equation
|
|
}
|
|
|
|
public SensorModel() { }
|
|
public SensorModel(SensorModel copy)
|
|
{
|
|
if (null == copy) { copy = new SensorModel(); }
|
|
|
|
Polarity = copy.Polarity;
|
|
AxisNumber = copy.AxisNumber;
|
|
Bridge = copy.Bridge;
|
|
BridgeResistance = copy.BridgeResistance;
|
|
CalInterval = copy.CalInterval;
|
|
Capacity = copy.Capacity;
|
|
CouplingMode = copy.CouplingMode;
|
|
Filter = new FilterClass(copy.Filter.ToString());
|
|
IgnoreRange = copy.IgnoreRange;
|
|
/*case DbOperations.SensorDB.SensorModelFields.InitialEU:
|
|
InitialEU = copy.InitialEU;
|
|
break;*/
|
|
Invert = copy.Invert;
|
|
CheckOffset = copy.CheckOffset;
|
|
LastModified = copy.LastModified;
|
|
SetLocalOnly(copy.LocalOnly);
|
|
Manufacturer = copy.Manufacturer;
|
|
DisplayUnit = copy.DisplayUnit;
|
|
Model = copy.Model;
|
|
LastUpdatedBy = copy.LastUpdatedBy;
|
|
NumberOfAxes = copy.NumberOfAxes;
|
|
OffsetToleranceHigh = copy.OffsetToleranceHigh;
|
|
OffsetToleranceLow = copy.OffsetToleranceLow;
|
|
RangeMedium = copy.RangeMedium;
|
|
RangeHigh = copy.RangeHigh;
|
|
RangeLow = copy.RangeLow;
|
|
Shunt = copy.Shunt;
|
|
UniPolar = copy.UniPolar;
|
|
UserPartNumber = copy.UserPartNumber;
|
|
Version = copy.Version;
|
|
Calibration = new SensorCalibration(copy.Calibration);
|
|
ISOCode = copy.ISOCode;
|
|
ISOChannelName = copy.ISOChannelName;
|
|
UserCode = copy.UserCode;
|
|
UserChannelName = copy.UserChannelName;
|
|
_supportedExcitation = copy.SupportedExcitation;
|
|
}
|
|
public void ReadXML(System.Xml.XmlElement root)
|
|
{
|
|
foreach (var node in root.ChildNodes)
|
|
{
|
|
if (node is System.Xml.XmlElement)
|
|
{
|
|
ProcessXMLElement(node as System.Xml.XmlElement);
|
|
}
|
|
}
|
|
}
|
|
private void ProcessXMLElement(System.Xml.XmlElement node)
|
|
{
|
|
double initialEU = 0;
|
|
if (Enum.TryParse(node.Name, out DbOperations.SensorDB.SensorModelFields field))
|
|
{
|
|
switch (field)
|
|
{
|
|
case DbOperations.SensorDB.SensorModelFields.AxisNumber: AxisNumber = Convert.ToInt16(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Bridge: Bridge = (SensorConstants.BridgeType)Enum.Parse(typeof(SensorConstants.BridgeType), node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.BridgeResistance: BridgeResistance = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CalibrationRecord: Calibration = new SensorCalibration(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CalInterval: CalInterval = Convert.ToInt32(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Capacity: Capacity = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CheckOffset: CheckOffset = Convert.ToBoolean(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CouplingMode: CouplingMode = (SensorConstants.CouplingModes)Enum.Parse(typeof(SensorConstants.CouplingModes), node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.FilterClass: Filter = new FilterClass(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.IgnoreRange: IgnoreRange = Convert.ToBoolean(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Invert: Invert = Convert.ToBoolean(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.ISOCode: ISOCode = BuildIsoCodeFromFilter(node.InnerText, Filter.FClass); break;
|
|
case DbOperations.SensorDB.SensorModelFields.ISOChannelName: ISOChannelName = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserCode: UserCode = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserChannelName: UserChannelName = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.LastModified: LastModified = Convert.ToDateTime(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.LocalOnly: _localOnly = Convert.ToBoolean(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Manufacturer: Manufacturer = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.MeasurementUnit: DisplayUnit = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.Model: Model = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.ModifiedBy: LastUpdatedBy = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.NumberOfAxes: NumberOfAxes = Convert.ToInt16(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.OffsetToleranceHigh: OffsetToleranceHigh = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.OffsetToleranceLow: OffsetToleranceLow = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Polarity: Polarity = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeAve: RangeMedium = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeHigh: RangeHigh = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeLow: RangeLow = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Shunt: Shunt = (ShuntMode)Enum.Parse(typeof(ShuntMode), node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.SupportedExcitation:
|
|
{
|
|
var tokens = node.InnerText.Split(new string[] { System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator }, StringSplitOptions.None);
|
|
|
|
SupportedExcitation = tokens.Select(token => (ExcitationVoltageOptions.ExcitationVoltageOption)Enum.Parse(typeof(ExcitationVoltageOptions.ExcitationVoltageOption), token)).ToArray();
|
|
}
|
|
break;
|
|
case DbOperations.SensorDB.SensorModelFields.UniPolar: UniPolar = Convert.ToBoolean(node.InnerText); break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserPartNumber: UserPartNumber = node.InnerText; break;
|
|
case DbOperations.SensorDB.SensorModelFields.Version: Version = Convert.ToInt32(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
|
|
default: throw new NotSupportedException("SensorModel::ProcessXMLElement unsupported field: " + field.ToString());
|
|
}
|
|
}
|
|
Calibration.InitialOffsets = new InitialOffsets(new InitialOffset(initialEU));
|
|
}
|
|
public void WriteXML(ref System.Xml.XmlWriter writer)
|
|
{
|
|
writer.WriteStartElement("SensorModel");
|
|
|
|
var fields = Enum.GetValues(typeof(DbOperations.SensorDB.SensorModelFields)).Cast<DbOperations.SensorDB.SensorModelFields>().ToArray();
|
|
|
|
foreach (var f in fields)
|
|
{
|
|
writer.WriteStartElement(f.ToString());
|
|
|
|
switch (f)
|
|
{
|
|
case DbOperations.SensorDB.SensorModelFields.AxisNumber: writer.WriteString(AxisNumber.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Bridge: writer.WriteString(Bridge.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.BridgeResistance: writer.WriteString(BridgeResistance.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CalibrationRecord: writer.WriteString(Calibration.ToSerializedString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CalInterval: writer.WriteString(CalInterval.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Capacity: writer.WriteString(Capacity.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CheckOffset: writer.WriteString(CheckOffset.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.CouplingMode: writer.WriteString(CouplingMode.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.FilterClass: writer.WriteString(Filter.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.IgnoreRange: writer.WriteString(IgnoreRange.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Invert: writer.WriteString(Invert.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.ISOCode: writer.WriteString(ISOCode); break;
|
|
case DbOperations.SensorDB.SensorModelFields.ISOChannelName: writer.WriteString(ISOChannelName); break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserCode: writer.WriteString(UserCode); break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserChannelName: writer.WriteString(UserChannelName); break;
|
|
case DbOperations.SensorDB.SensorModelFields.LastModified: writer.WriteString(LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.LocalOnly: writer.WriteString(LocalOnly.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Manufacturer: writer.WriteString(Manufacturer); break;
|
|
case DbOperations.SensorDB.SensorModelFields.MeasurementUnit: writer.WriteString(DisplayUnit); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Model: writer.WriteString(Model); break;
|
|
case DbOperations.SensorDB.SensorModelFields.ModifiedBy: writer.WriteString(LastUpdatedBy); break;
|
|
case DbOperations.SensorDB.SensorModelFields.NumberOfAxes: writer.WriteString(NumberOfAxes.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.OffsetToleranceHigh: writer.WriteString(OffsetToleranceHigh.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.OffsetToleranceLow: writer.WriteString(OffsetToleranceLow.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Polarity: writer.WriteString(Polarity); break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeAve: writer.WriteString(RangeMedium.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeHigh: writer.WriteString(RangeHigh.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.RangeLow: writer.WriteString(RangeLow.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Shunt: writer.WriteString(Shunt.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.SupportedExcitation:
|
|
{
|
|
List<string> s = new List<string>();
|
|
foreach (var se in SupportedExcitation) { s.Add(se.ToString()); }
|
|
writer.WriteString(string.Join(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, s.ToArray()));
|
|
}
|
|
break;
|
|
case DbOperations.SensorDB.SensorModelFields.UniPolar: writer.WriteString(UniPolar.ToString()); break;
|
|
case DbOperations.SensorDB.SensorModelFields.UserPartNumber: writer.WriteString(UserPartNumber); break;
|
|
case DbOperations.SensorDB.SensorModelFields.Version: writer.WriteString(Version.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
|
|
default: throw new NotSupportedException("SensorModel::WriteXML unsupported field: " + f.ToString());
|
|
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
private enum XMLFields
|
|
{
|
|
Model,
|
|
Manufacturer,
|
|
UserPartNumber,
|
|
Capacity,
|
|
OffsetTolerance,
|
|
MeasurementUnit,
|
|
SensorRange,
|
|
Sensitivity,
|
|
Excitation,
|
|
IsProportional,
|
|
Bridge,
|
|
Shunt,
|
|
BridgeResistance,
|
|
RemoveOffset,
|
|
FilterClass,
|
|
ZeroMethod,
|
|
InitialEU,
|
|
NonLinear,
|
|
UniPolar,
|
|
PolynomialStyle,
|
|
IRTraccFormat,
|
|
LinearizationFormula,
|
|
PhysicalDimension,
|
|
IgnoreRange,
|
|
Invert,
|
|
CouplingMode,
|
|
CheckOffset
|
|
}
|
|
public SensorModel(System.Xml.XmlElement node)
|
|
{
|
|
var initialEU = 0D;
|
|
foreach (var childnode in node.ChildNodes)
|
|
{
|
|
if (!(childnode is System.Xml.XmlElement elem)) { continue; }
|
|
try
|
|
{
|
|
if (elem.Name == "Unipolar")
|
|
{
|
|
UniPolar = bool.Parse(elem.InnerText);
|
|
continue;
|
|
}
|
|
var field = (XMLFields)Enum.Parse(typeof(XMLFields), elem.Name);
|
|
var value = elem.InnerText;
|
|
switch (field)
|
|
{
|
|
case XMLFields.Bridge:
|
|
Bridge = (SensorConstants.BridgeType)Enum.Parse(typeof(SensorConstants.BridgeType), value);
|
|
break;
|
|
case XMLFields.BridgeResistance:
|
|
if (double.TryParse(value, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out var newD))
|
|
{
|
|
BridgeResistance = newD;
|
|
}
|
|
break;
|
|
case XMLFields.Capacity:
|
|
Capacity = double.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
|
|
break;
|
|
case XMLFields.Excitation:
|
|
SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { (ExcitationVoltageOptions.ExcitationVoltageOption)Enum.Parse(typeof(ExcitationVoltageOptions.ExcitationVoltageOption), value) };
|
|
break;
|
|
case XMLFields.FilterClass:
|
|
Filter = new FilterClass(value);
|
|
break;
|
|
case XMLFields.IgnoreRange:
|
|
IgnoreRange = bool.Parse(value);
|
|
break;
|
|
case XMLFields.Invert:
|
|
Invert = bool.Parse(value);
|
|
break;
|
|
case XMLFields.InitialEU:
|
|
initialEU = double.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
|
|
//InitialEU = double.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
|
|
break;
|
|
case XMLFields.IsProportional:
|
|
Calibration.IsProportional = bool.Parse(value);
|
|
break;
|
|
case XMLFields.LinearizationFormula:
|
|
Calibration.Records.Records[0].Poly = new DTS.Common.Classes.Sensors.LinearizationFormula();
|
|
Calibration.Records.Records[0].Poly.FromSerializeString(value);
|
|
break;
|
|
case XMLFields.Manufacturer:
|
|
Manufacturer = value;
|
|
//System.Diagnostics.Trace.WriteLine(Manufacturer);
|
|
break;
|
|
case XMLFields.MeasurementUnit:
|
|
DisplayUnit = value;
|
|
break;
|
|
case XMLFields.Model:
|
|
Model = value;
|
|
//System.Diagnostics.Trace.WriteLine(Model);
|
|
break;
|
|
case XMLFields.NonLinear:
|
|
Calibration.NonLinear = bool.Parse(value);
|
|
break;
|
|
case XMLFields.OffsetTolerance:
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(value))
|
|
{
|
|
try
|
|
{
|
|
var tol = new LowHigh(value);
|
|
OffsetToleranceHigh = tol.High;
|
|
OffsetToleranceLow = tol.Low;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case XMLFields.PhysicalDimension:
|
|
PhysicalDimension = value;
|
|
break;
|
|
case XMLFields.PolynomialStyle:
|
|
//var polystyle = (PolynomialStyles)Enum.Parse(typeof(PolynomialStyles), value);
|
|
//switch (polystyle)
|
|
//{
|
|
// case PolynomialStyles.
|
|
//}
|
|
//don't need this anymore?
|
|
break;
|
|
case XMLFields.IRTraccFormat:
|
|
var irFormat = (IRTraccFormats)Enum.Parse(typeof(IRTraccFormats), value);
|
|
switch (irFormat)
|
|
{
|
|
case IRTraccFormats.AverageOverTime: Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccAverageOverTime; break;
|
|
case IRTraccFormats.DiagnosticZeroMMmV: Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccDiagnosticsZero; break;
|
|
case IRTraccFormats.Manual: Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccManual; break;
|
|
case IRTraccFormats.ZeroMMmV: Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccZeroMMmV; break;
|
|
case IRTraccFormats.Polynomial: Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.Polynomial; break;
|
|
}
|
|
break;
|
|
case XMLFields.RemoveOffset:
|
|
Calibration.RemoveOffset = bool.Parse(value);
|
|
break;
|
|
case XMLFields.Sensitivity:
|
|
Calibration.Records.Records[0].Sensitivity = double.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
|
|
break;
|
|
case XMLFields.SensorRange:
|
|
{
|
|
var Range = new SensorRange(value);
|
|
RangeHigh = Range.High;
|
|
RangeLow = Range.Low;
|
|
RangeMedium = Range.Medium;
|
|
}
|
|
break;
|
|
case XMLFields.Shunt:
|
|
Shunt = (ShuntMode)Enum.Parse(typeof(ShuntMode), value);
|
|
break;
|
|
case XMLFields.UniPolar:
|
|
UniPolar = bool.Parse(value);
|
|
break;
|
|
case XMLFields.UserPartNumber:
|
|
UserPartNumber = value;
|
|
break;
|
|
case XMLFields.ZeroMethod:
|
|
{
|
|
Calibration.ZeroMethods = new ZeroMethods(new ZeroMethod(value));
|
|
}
|
|
break;
|
|
case XMLFields.CouplingMode:
|
|
CouplingMode = (SensorConstants.CouplingModes)Enum.Parse(typeof(SensorConstants.CouplingModes), value);
|
|
break;
|
|
case XMLFields.CheckOffset:
|
|
CheckOffset = Boolean.Parse(value);
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("field :" + field.ToString());
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Failed to parse xml", ex, elem.Name, elem.Value);
|
|
}
|
|
Calibration.InitialOffsets = new InitialOffsets(new InitialOffset(initialEU));
|
|
}
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return Model;
|
|
}
|
|
|
|
private SensorConstants.BridgeType ConvertToBridge(int bridge)
|
|
{
|
|
switch (bridge)
|
|
{
|
|
case 0: return SensorConstants.BridgeType.IEPE;
|
|
case 4: return SensorConstants.BridgeType.HalfBridge_SigPlus;
|
|
case 3: return SensorConstants.BridgeType.FullBridge;
|
|
case 2: return SensorConstants.BridgeType.HalfBridge;
|
|
case 1: return SensorConstants.BridgeType.QuarterBridge;
|
|
default: return SensorConstants.BridgeType.FullBridge;
|
|
}
|
|
}
|
|
|
|
internal SensorModel(DataRow dr)
|
|
{
|
|
|
|
try
|
|
{
|
|
Polarity = (string)dr[DbOperations.SensorDB.SensorModelFields.Polarity.ToString()];
|
|
AxisNumber = Convert.ToInt16(dr[DbOperations.SensorDB.SensorModelFields.AxisNumber.ToString()]);
|
|
Bridge = ConvertToBridge(Convert.ToInt32(dr[DbOperations.SensorDB.SensorModelFields.Bridge.ToString()]));
|
|
BridgeResistance = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.BridgeResistance.ToString()]);
|
|
CalInterval = Convert.ToInt32(dr[DbOperations.SensorDB.SensorModelFields.CalInterval.ToString()]);
|
|
Capacity = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.Capacity.ToString()]);
|
|
CouplingMode = (SensorConstants.CouplingModes)Convert.ToInt32(dr[DbOperations.SensorDB.SensorModelFields.CouplingMode.ToString()]);
|
|
Filter = new FilterClass((string)dr[DbOperations.SensorDB.SensorModelFields.FilterClass.ToString()]);
|
|
IgnoreRange = Convert.ToBoolean(dr[DbOperations.SensorDB.SensorModelFields.IgnoreRange.ToString()]);
|
|
CheckOffset = Convert.ToBoolean(dr[DbOperations.SensorDB.SensorModelFields.CheckOffset.ToString()]);
|
|
Invert = Convert.ToBoolean(dr[DbOperations.SensorDB.SensorModelFields.Invert.ToString()]);
|
|
LastModified = (DateTime)dr[DbOperations.SensorDB.SensorModelFields.LastModified.ToString()];
|
|
SetLocalOnly(Convert.ToBoolean(dr[DbOperations.SensorDB.SensorModelFields.LocalOnly.ToString()]));
|
|
Manufacturer = (string)dr[DbOperations.SensorDB.SensorModelFields.Manufacturer.ToString()];
|
|
DisplayUnit = (string)dr[DbOperations.SensorDB.SensorModelFields.MeasurementUnit.ToString()];
|
|
Model = (string)dr[DbOperations.SensorDB.SensorModelFields.Model.ToString()];
|
|
LastUpdatedBy = (string)dr[DbOperations.SensorDB.SensorModelFields.ModifiedBy.ToString()];
|
|
NumberOfAxes = Convert.ToInt16(dr[DbOperations.SensorDB.SensorModelFields.NumberOfAxes.ToString()]);
|
|
OffsetToleranceHigh = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.OffsetToleranceHigh.ToString()]);
|
|
OffsetToleranceLow = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.OffsetToleranceLow.ToString()]);
|
|
RangeMedium = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.RangeAve.ToString()]);
|
|
RangeHigh = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.RangeHigh.ToString()]);
|
|
RangeLow = Convert.ToDouble(dr[DbOperations.SensorDB.SensorModelFields.RangeLow.ToString()]);
|
|
Shunt = (ShuntMode)Convert.ToInt32(dr[DbOperations.SensorDB.SensorModelFields.Shunt.ToString()]);
|
|
UniPolar = Convert.ToBoolean(dr[DbOperations.SensorDB.SensorModelFields.UniPolar.ToString()]);
|
|
UserPartNumber = (string)dr[DbOperations.SensorDB.SensorModelFields.UserPartNumber.ToString()];
|
|
Version = Convert.ToInt32(dr[DbOperations.SensorDB.SensorModelFields.Version.ToString()]);
|
|
ISOCode = (string)dr[DbOperations.SensorDB.SensorModelFields.ISOCode.ToString()];
|
|
var o = dr[DbOperations.SensorDB.SensorModelFields.ISOChannelName.ToString()];
|
|
if (!DBNull.Value.Equals(o))
|
|
{
|
|
ISOChannelName = (string)o;
|
|
}
|
|
else
|
|
{
|
|
ISOChannelName = "";
|
|
}
|
|
o = dr[DbOperations.SensorDB.SensorModelFields.UserCode.ToString()];
|
|
if (!DBNull.Value.Equals(o))
|
|
{
|
|
UserCode = (string)o;
|
|
}
|
|
else
|
|
{
|
|
UserCode = "";
|
|
}
|
|
o = dr[DbOperations.SensorDB.SensorModelFields.UserChannelName.ToString()];
|
|
if (!DBNull.Value.Equals(o))
|
|
{
|
|
UserChannelName = (string)o;
|
|
}
|
|
else
|
|
{
|
|
UserChannelName = "";
|
|
}
|
|
|
|
Calibration = new SensorCalibration((string)dr[DbOperations.SensorDB.SensorModelFields.CalibrationRecord.ToString()]);
|
|
var options = new List<ExcitationVoltageOptions.ExcitationVoltageOption>();
|
|
var tokens = ((string)dr[DbOperations.SensorDB.SensorModelFields.SupportedExcitation.ToString()]).Split(new[] { System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator }, StringSplitOptions.None);
|
|
foreach (var token in tokens)
|
|
{
|
|
if (Enum.TryParse(token, out ExcitationVoltageOptions.ExcitationVoltageOption option)) { options.Add(option); }
|
|
}
|
|
|
|
SupportedExcitation = options.ToArray();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Failed to process fields: ", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SensorModelCollection : INotifyPropertyChanged
|
|
{
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
protected bool SetProperty<T>(ref T storage, T value, String propertyName = null)
|
|
{
|
|
if (Equals(storage, value)) return false;
|
|
|
|
storage = value;
|
|
OnPropertyChanged(propertyName);
|
|
return true;
|
|
}
|
|
protected void OnPropertyChanged(string propertyName = null)
|
|
{
|
|
if (!HookedUp) { return; }
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
private Dictionary<string, Dictionary<string, SensorModel>> _sensorModels = new Dictionary<string, Dictionary<string, SensorModel>>();
|
|
|
|
|
|
public void ReloadAll()
|
|
{
|
|
lock (_collection)
|
|
{
|
|
PopulateCollection();
|
|
}
|
|
}
|
|
|
|
private static void PopulateCollection()
|
|
{
|
|
if (null == _collection)
|
|
{
|
|
_collection = new SensorModelCollection();
|
|
}
|
|
else
|
|
{
|
|
_collection._sensorModels.Clear();
|
|
}
|
|
_collection.LoadAllSensorModels();
|
|
}
|
|
protected SensorModelCollection() { }
|
|
private static SensorModelCollection _collection = null;
|
|
public static SensorModelCollection SensorModelList
|
|
{
|
|
get
|
|
{
|
|
lock (_lock)
|
|
{
|
|
if (null == _collection)
|
|
{
|
|
PopulateCollection();
|
|
}
|
|
return _collection;
|
|
}
|
|
}
|
|
}
|
|
private static readonly object _lock = new object();
|
|
private volatile bool _Hookedup = true;
|
|
public bool HookedUp
|
|
{
|
|
get => _Hookedup;
|
|
set { _Hookedup = value; OnPropertyChanged("AllSensors"); }
|
|
}
|
|
|
|
public SensorModelCollection(string path)
|
|
{
|
|
LoadAllSensorModels(path);
|
|
}
|
|
public SensorModel[] SensorModels
|
|
{
|
|
get
|
|
{
|
|
lock (_lock)
|
|
{
|
|
var l = new List<SensorModel>();
|
|
using (var sensorModelsEnumerator = _sensorModels.GetEnumerator())
|
|
{
|
|
while (sensorModelsEnumerator.MoveNext())
|
|
{
|
|
var currentValueEnumerator = sensorModelsEnumerator.Current.Value.GetEnumerator();
|
|
while (currentValueEnumerator.MoveNext())
|
|
{
|
|
l.Add(currentValueEnumerator.Current.Value);
|
|
}
|
|
}
|
|
}
|
|
return l.ToArray();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// deletes all Sensor Models
|
|
/// originally created so TDM imports could clear all tables except DAS tables
|
|
/// </summary>
|
|
public void DeleteAll()
|
|
{
|
|
_sensorModels.Clear();
|
|
try
|
|
{
|
|
using (var cmd = DbOperations.GetSQLCommand(true))
|
|
{
|
|
try
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorModelsDelete.ToString();
|
|
cmd.Parameters.Add(new SqlParameter("@Model", SqlDbType.NVarChar, 50) { Value = null });
|
|
cmd.Parameters.Add(new SqlParameter("@Manufacturer", SqlDbType.NVarChar, 50) { Value = null });
|
|
var errorNumberParam =
|
|
new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
|
|
cmd.Parameters.Add(errorNumberParam);
|
|
var errorMessageParam =
|
|
new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
|
|
{
|
|
Direction = ParameterDirection.Output
|
|
};
|
|
cmd.Parameters.Add(errorMessageParam);
|
|
|
|
cmd.ExecuteNonQuery();
|
|
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
|
|
{
|
|
//errorMessageParam.Value
|
|
}
|
|
|
|
cmd.ExecuteNonQuery();
|
|
}
|
|
finally
|
|
{
|
|
cmd.Connection.Dispose();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("Failed to delete sensor models, ", ex); }
|
|
LoadAllSensorModels();
|
|
}
|
|
private const string FILE_NAME = "Model.SensorDB.xml";
|
|
protected void LoadAllSensorModels(string path)
|
|
{
|
|
string filename = System.IO.Path.Combine(path, FILE_NAME);
|
|
if (!System.IO.File.Exists(filename))
|
|
{
|
|
return;
|
|
}
|
|
var doc = new System.Xml.XmlDocument();
|
|
var xml = System.IO.File.ReadAllText(filename);
|
|
doc.LoadXml(xml);
|
|
var nodes = doc.GetElementsByTagName("SensorModels");
|
|
foreach (var node in nodes)
|
|
{
|
|
if (!(node is System.Xml.XmlElement element)) { continue; }
|
|
foreach (var childNode in element.GetElementsByTagName("SensorModel"))
|
|
{
|
|
if (!(childNode is System.Xml.XmlElement elem)) { continue; }
|
|
LoadSensor(elem);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void LoadAllSensorModels()
|
|
{
|
|
try
|
|
{
|
|
using (var cmd = DbOperations.GetSQLCommand(true))
|
|
{
|
|
try
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorModelsGet.ToString();
|
|
|
|
#region params
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@Model", SqlDbType.NVarChar, 50) { Value = null });
|
|
|
|
#endregion params
|
|
|
|
using (var ds = DbOperations.Connection.QueryDataSet(cmd))
|
|
{
|
|
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
|
|
{
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
try
|
|
{
|
|
var sm = new SensorModel(dr);
|
|
if (!_sensorModels.ContainsKey(sm.Manufacturer))
|
|
{
|
|
_sensorModels.Add(sm.Manufacturer, new Dictionary<string, SensorModel>());
|
|
}
|
|
if (!_sensorModels[sm.Manufacturer].ContainsKey(sm.Model))
|
|
{
|
|
_sensorModels[sm.Manufacturer].Add(sm.Model, sm);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Failed to process a row in the database: ", ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
cmd.Connection.Dispose();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("Failed to retrieve sensor models, ", ex); }
|
|
}
|
|
|
|
private void LoadSensor(System.Xml.XmlElement node)
|
|
{
|
|
try
|
|
{
|
|
var sm = new SensorModel(node);
|
|
if (!_sensorModels.ContainsKey(sm.Manufacturer))
|
|
{
|
|
_sensorModels.Add(sm.Manufacturer, new Dictionary<string, SensorModel>());
|
|
}
|
|
_sensorModels[sm.Manufacturer][sm.Model] = sm;
|
|
}
|
|
catch (Exception ex) { APILogger.Log("failed to get node from sensor model db, ", ex); }
|
|
}
|
|
|
|
public void Commit(SensorModel sm, string username) { Commit(sm, username, true); }
|
|
public void Commit(SensorModel sm, string username, bool bNotify)
|
|
{
|
|
if (_sensorModels.ContainsKey(sm.Manufacturer))
|
|
{
|
|
if (_sensorModels[sm.Manufacturer].ContainsKey(sm.Model))
|
|
{
|
|
UpdateAll(username, sm);
|
|
_sensorModels[sm.Manufacturer][sm.Model] = sm;
|
|
return;
|
|
}
|
|
Insert(username, sm);
|
|
_sensorModels[sm.Manufacturer].Add(sm.Model, sm);
|
|
}
|
|
else
|
|
{
|
|
Insert(username, sm);
|
|
_sensorModels.Add(sm.Manufacturer, new Dictionary<string, SensorModel>());
|
|
_sensorModels[sm.Manufacturer].Add(sm.Model, sm);
|
|
}
|
|
if (bNotify) { OnPropertyChanged("SensorModels"); }
|
|
}
|
|
public void UpdateList()
|
|
{
|
|
OnPropertyChanged("SensorModels");
|
|
}
|
|
private void Insert(string username, SensorModel sm)
|
|
{
|
|
try
|
|
{
|
|
|
|
sm.LastModified = DateTime.Now;
|
|
sm.LastUpdatedBy = username;
|
|
using (var cmd = DbOperations.GetSQLCommand(true))
|
|
{
|
|
try
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorModelsInsert.ToString();
|
|
|
|
#region params
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@Model", SqlDbType.NVarChar, 50) { Value = sm.Model });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@Manufacturer", SqlDbType.NVarChar, 50) { Value = sm.Manufacturer });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@UserPartNumber", SqlDbType.NVarChar, 50) { Value = sm.UserPartNumber });
|
|
cmd.Parameters.Add(new SqlParameter("@Capacity", SqlDbType.Float) { Value = sm.Capacity });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@OffsetToleranceLow", SqlDbType.Float) { Value = sm.OffsetToleranceLow });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@OffsetToleranceHigh", SqlDbType.Float) { Value = sm.OffsetToleranceHigh });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@MeasurementUnit", SqlDbType.NVarChar, 50) { Value = sm.DisplayUnit });
|
|
cmd.Parameters.Add(new SqlParameter("@Bridge", SqlDbType.SmallInt) { Value = SensorsCollection.ConvertBridgeToInt(sm.Bridge) });
|
|
cmd.Parameters.Add(new SqlParameter("@Shunt", SqlDbType.SmallInt) { Value = sm.Shunt });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@BridgeResistance", SqlDbType.Float) { Value = sm.BridgeResistance });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@FilterClass", SqlDbType.NVarChar, 50) { Value = sm.Filter.ToString() });
|
|
cmd.Parameters.Add(new SqlParameter("@UniPolar", SqlDbType.Bit) { Value = sm.UniPolar });
|
|
cmd.Parameters.Add(new SqlParameter("@IgnoreRange", SqlDbType.Bit) { Value = sm.IgnoreRange });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@CouplingMode", SqlDbType.SmallInt) { Value = sm.CouplingMode });
|
|
cmd.Parameters.Add(new SqlParameter("@Version", SqlDbType.Int) { Value = sm.Version });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeLow", SqlDbType.Float) { Value = sm.RangeLow });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeAve", SqlDbType.Float) { Value = sm.RangeMedium });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeHigh", SqlDbType.Float) { Value = sm.RangeHigh });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = sm.LastModified });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@ModifiedBy", SqlDbType.NVarChar, 50) { Value = sm.LastUpdatedBy });
|
|
cmd.Parameters.Add(new SqlParameter("@LocalOnly", SqlDbType.Bit) { Value = sm.LocalOnly });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@NumberOfAxes", SqlDbType.SmallInt) { Value = sm.NumberOfAxes });
|
|
cmd.Parameters.Add(new SqlParameter("@CalInterval", SqlDbType.Int) { Value = sm.CalInterval });
|
|
cmd.Parameters.Add(new SqlParameter("@AxisNumber", SqlDbType.SmallInt) { Value = sm.AxisNumber });
|
|
cmd.Parameters.Add(new SqlParameter("@Polarity", SqlDbType.NVarChar, 50) { Value = sm.Polarity });
|
|
cmd.Parameters.Add(new SqlParameter("@Invert", SqlDbType.Bit) { Value = sm.Invert });
|
|
cmd.Parameters.Add(new SqlParameter("@CheckOffset", SqlDbType.Bit) { Value = sm.CheckOffset });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@CalibrationRecord", SqlDbType.NVarChar, 255)
|
|
{
|
|
Value = sm.Calibration.ToSerializedString()
|
|
});
|
|
cmd.Parameters.Add(new SqlParameter("@ISOCode", SqlDbType.NVarChar, 20) { Value = sm.ISOCode });
|
|
cmd.Parameters.Add(new SqlParameter("@IsoChannelName", SqlDbType.NVarChar, 255) { Value = sm.ISOChannelName });
|
|
cmd.Parameters.Add(new SqlParameter("@UserCode", SqlDbType.NVarChar, 50) { Value = sm.UserCode });
|
|
cmd.Parameters.Add(new SqlParameter("@UserChannelName", SqlDbType.NVarChar, 255) { Value = sm.UserChannelName });
|
|
cmd.Parameters.Add(new SqlParameter("@SupportedExcitation", SqlDbType.NVarChar, 255)
|
|
{
|
|
Value = string.Join(
|
|
System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator,
|
|
sm.SupportedExcitation.Select(e => e.ToString()).ToArray())
|
|
});
|
|
cmd.Parameters.Add(//TODO: linear/nonlinear Offsets
|
|
new SqlParameter("@InitialEU", SqlDbType.Float) { Value = sm.Calibration.InitialOffsets.Offsets[0].EU });
|
|
var newIdParam =
|
|
new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
|
|
cmd.Parameters.Add(newIdParam);
|
|
var errorNumberParam =
|
|
new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
|
|
cmd.Parameters.Add(errorNumberParam);
|
|
var errorMessageParam =
|
|
new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
|
|
{
|
|
Direction = ParameterDirection.Output
|
|
};
|
|
cmd.Parameters.Add(errorMessageParam);
|
|
|
|
#endregion params
|
|
|
|
cmd.ExecuteNonQuery();
|
|
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
|
|
{
|
|
//errorMessageParam.Value
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
cmd.Connection.Dispose();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("failed to insert sensor model:", ex); }
|
|
|
|
|
|
}
|
|
|
|
private static void UpdateAll(string username, SensorModel sm)
|
|
{
|
|
sm.LastModified = DateTime.Now;
|
|
sm.LastUpdatedBy = username;
|
|
try
|
|
{
|
|
|
|
using (var cmd = DbOperations.GetSQLCommand(true))
|
|
{
|
|
try
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorModelsUpdate.ToString();
|
|
|
|
#region params
|
|
|
|
cmd.Parameters.Add(new SqlParameter("@Model", SqlDbType.NVarChar, 50) { Value = sm.Model });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@Manufacturer", SqlDbType.NVarChar, 50) { Value = sm.Manufacturer });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@UserPartNumber", SqlDbType.NVarChar, 50) { Value = sm.UserPartNumber });
|
|
cmd.Parameters.Add(new SqlParameter("@Capacity", SqlDbType.Float) { Value = sm.Capacity });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@OffsetToleranceLow", SqlDbType.Float) { Value = sm.OffsetToleranceLow });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@OffsetToleranceHigh", SqlDbType.Float) { Value = sm.OffsetToleranceHigh });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@MeasurementUnit", SqlDbType.NVarChar, 50) { Value = sm.DisplayUnit });
|
|
cmd.Parameters.Add(new SqlParameter("@Bridge", SqlDbType.SmallInt) { Value = SensorsCollection.ConvertBridgeToInt(sm.Bridge) });
|
|
cmd.Parameters.Add(new SqlParameter("@Shunt", SqlDbType.SmallInt) { Value = sm.Shunt });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@BridgeResistance", SqlDbType.Float) { Value = sm.BridgeResistance });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@FilterClass", SqlDbType.NVarChar, 50) { Value = sm.Filter.ToString() });
|
|
cmd.Parameters.Add(new SqlParameter("@UniPolar", SqlDbType.Bit) { Value = sm.UniPolar });
|
|
cmd.Parameters.Add(new SqlParameter("@IgnoreRange", SqlDbType.Bit) { Value = sm.IgnoreRange });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@CouplingMode", SqlDbType.SmallInt) { Value = sm.CouplingMode });
|
|
cmd.Parameters.Add(new SqlParameter("@Version", SqlDbType.Int) { Value = sm.Version });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeLow", SqlDbType.Float) { Value = sm.RangeLow });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeAve", SqlDbType.Float) { Value = sm.RangeMedium });
|
|
cmd.Parameters.Add(new SqlParameter("@RangeHigh", SqlDbType.Float) { Value = sm.RangeHigh });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = sm.LastModified });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@ModifiedBy", SqlDbType.NVarChar, 50) { Value = sm.LastUpdatedBy });
|
|
cmd.Parameters.Add(new SqlParameter("@LocalOnly", SqlDbType.Bit) { Value = sm.LocalOnly });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@NumberOfAxes", SqlDbType.SmallInt) { Value = sm.NumberOfAxes });
|
|
cmd.Parameters.Add(new SqlParameter("@CalInterval", SqlDbType.Int) { Value = sm.CalInterval });
|
|
cmd.Parameters.Add(new SqlParameter("@AxisNumber", SqlDbType.SmallInt) { Value = sm.AxisNumber });
|
|
cmd.Parameters.Add(new SqlParameter("@Polarity", SqlDbType.NVarChar, 50) { Value = sm.Polarity });
|
|
cmd.Parameters.Add(new SqlParameter("@Invert", SqlDbType.Bit) { Value = sm.Invert });
|
|
cmd.Parameters.Add(new SqlParameter("@CheckOffset", SqlDbType.Bit) { Value = sm.CheckOffset });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@CalibrationRecord", SqlDbType.NVarChar, 255)
|
|
{
|
|
Value = sm.Calibration.ToSerializedString()
|
|
});
|
|
cmd.Parameters.Add(new SqlParameter("@ISOCode", SqlDbType.NVarChar, 20) { Value = sm.ISOCode });
|
|
cmd.Parameters.Add(new SqlParameter("@IsoChannelName", SqlDbType.NVarChar, 255) { Value = sm.ISOChannelName });
|
|
cmd.Parameters.Add(new SqlParameter("@UserCode", SqlDbType.NVarChar, 50) { Value = sm.UserCode });
|
|
cmd.Parameters.Add(new SqlParameter("@UserChannelName", SqlDbType.NVarChar, 255) { Value = sm.UserChannelName });
|
|
cmd.Parameters.Add(new SqlParameter("@SupportedExcitation", SqlDbType.NVarChar, 255)
|
|
{
|
|
Value = string.Join(
|
|
System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator,
|
|
sm.SupportedExcitation.Select(e => e.ToString()).ToArray())
|
|
});
|
|
cmd.Parameters.Add(//TODO: linear/nonlinear offsets
|
|
new SqlParameter("@InitialEU", SqlDbType.Float) { Value = sm.Calibration.InitialOffsets.Offsets[0].EU });
|
|
var errorNumberParam =
|
|
new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
|
|
cmd.Parameters.Add(errorNumberParam);
|
|
var errorMessageParam =
|
|
new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
|
|
{
|
|
Direction = ParameterDirection.Output
|
|
};
|
|
cmd.Parameters.Add(errorMessageParam);
|
|
|
|
#endregion params
|
|
|
|
cmd.ExecuteNonQuery();
|
|
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
|
|
{
|
|
//errorMessageParam.Value
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
cmd.Connection.Dispose();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("failed to insert sensor model:", ex); }
|
|
|
|
}
|
|
|
|
public void DeleteSensorModel(SensorModel sm)
|
|
{
|
|
if (!_sensorModels.ContainsKey(sm.Manufacturer)) { return; }
|
|
if (!_sensorModels[sm.Manufacturer].ContainsKey(sm.Model)) { return; }
|
|
using (var cmd = DbOperations.GetSQLCommand(true))
|
|
{
|
|
try
|
|
{
|
|
cmd.CommandType = CommandType.StoredProcedure;
|
|
cmd.CommandText = DbOperationsEnum.StoredProcedure.sp_SensorModelsDelete.ToString();
|
|
cmd.Parameters.Add(new SqlParameter("@Model", SqlDbType.NVarChar, 50) { Value = sm.Model });
|
|
cmd.Parameters.Add(
|
|
new SqlParameter("@Manufacturer", SqlDbType.NVarChar, 50) { Value = sm.Manufacturer });
|
|
var errorNumberParam =
|
|
new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
|
|
cmd.Parameters.Add(errorNumberParam);
|
|
var errorMessageParam =
|
|
new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250)
|
|
{
|
|
Direction = ParameterDirection.Output
|
|
};
|
|
cmd.Parameters.Add(errorMessageParam);
|
|
|
|
cmd.ExecuteNonQuery();
|
|
if (int.Parse(errorNumberParam.Value.ToString()) != 0)
|
|
{
|
|
//errorMessageParam.Value
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
cmd.Connection.Dispose();
|
|
}
|
|
}
|
|
_sensorModels[sm.Manufacturer].Remove(sm.Model);
|
|
|
|
if (_sensorModels[sm.Manufacturer].Count < 1)
|
|
{
|
|
_sensorModels.Remove(sm.Manufacturer);
|
|
}
|
|
OnPropertyChanged("SensorModels");
|
|
}
|
|
|
|
public void DeleteSensorModels(SensorModel[] sms)
|
|
{
|
|
foreach (var sm in sms)
|
|
{
|
|
DeleteSensorModel(sm);
|
|
}
|
|
}
|
|
|
|
public SensorModel[] GetSensorModelsForManufacturer(string manufacturer)
|
|
{
|
|
if (!_sensorModels.ContainsKey(manufacturer)) { return new SensorModel[0]; }
|
|
|
|
var models = new SensorModel[_sensorModels[manufacturer].Count];
|
|
_sensorModels[manufacturer].Values.CopyTo(models, 0);
|
|
var list = new List<SensorModel>(models.Length);
|
|
list.AddRange(models);
|
|
list.Sort();
|
|
return list.ToArray();
|
|
}
|
|
public string[] GetUniqueManufacturers()
|
|
{
|
|
var names = new string[_sensorModels.Keys.Count];
|
|
_sensorModels.Keys.CopyTo(names, 0);
|
|
|
|
var list = new List<string>(names.Length);
|
|
list.AddRange(names);
|
|
list.Sort();
|
|
return list.ToArray();
|
|
}
|
|
public List<string> GetUniqueAssemblyNames()
|
|
{
|
|
var sensors = SensorsCollection.SensorsList.GetAllSensors(true);
|
|
var assemblyNameList = sensors.Select(x => x.AssemblyName.Trim()).Distinct().OrderBy(a => a).ToList();
|
|
return assemblyNameList;
|
|
}
|
|
public int GetNumberOfModels()
|
|
{
|
|
var count = 0;
|
|
using (var enumeratorSensorModels = _sensorModels.GetEnumerator())
|
|
{
|
|
while (enumeratorSensorModels.MoveNext())
|
|
{
|
|
count += enumeratorSensorModels.Current.Value.Count;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public SensorModel GetSensorModel(string maker, string model)
|
|
{
|
|
if (null == maker) { return null; }
|
|
if (!_sensorModels.ContainsKey(maker)) return null;
|
|
return _sensorModels[maker].ContainsKey(model) ? _sensorModels[maker][model] : null;
|
|
}
|
|
}
|
|
}
|