791 lines
31 KiB
Plaintext
791 lines
31 KiB
Plaintext
using DTS.Common.Enums;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface.Sensors;
|
|
using DTS.Common.Interface.Sensors.SoftwareFilters;
|
|
using DTS.Common.Interface.Tags;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.ComponentModel.DataAnnotations.Schema;
|
|
using System.Data;
|
|
using System.Data.SqlTypes;
|
|
using System.Reflection;
|
|
|
|
namespace DTS.Common.Classes.Sensors
|
|
{
|
|
/// <summary>
|
|
/// represents a record of an analog sensor in the db
|
|
/// <inheritdoc cref="IAnalogDbRecord"/>
|
|
/// </summary>
|
|
public class AnalogDbRecord : TagAwareBase, IAnalogDbRecord
|
|
{
|
|
public override TagTypes TagType => TagTypes.SensorModels;
|
|
protected int _id = -1;
|
|
/// <summary>
|
|
/// the database id of the sensor
|
|
/// </summary>
|
|
[Key]
|
|
public int Id
|
|
{
|
|
get => _id;
|
|
set => SetProperty(ref _id, value, "Id");
|
|
}
|
|
protected string _serialNumber = "";
|
|
/// <summary>
|
|
/// Serial number of sensor
|
|
/// [required to be unique]
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string SerialNumber
|
|
{
|
|
get => _serialNumber;
|
|
set => SetProperty(ref _serialNumber, value, "SerialNumber");
|
|
}
|
|
protected short _axisNumber = 0;
|
|
/// <summary>
|
|
/// deprecated
|
|
/// which axis the record is for when the sensor is multi-axis
|
|
/// </summary>
|
|
public short AxisNumber
|
|
{
|
|
get => _axisNumber;
|
|
set => SetProperty(ref _axisNumber, value, "AxisNumber");
|
|
}
|
|
|
|
protected short _bridgeLegMode;
|
|
/// <summary>
|
|
/// deprecated
|
|
/// </summary>
|
|
public short BridgeLegMode
|
|
{
|
|
get => _bridgeLegMode;
|
|
set => SetProperty(ref _bridgeLegMode, value, "BridgeLegMode");
|
|
}
|
|
protected double _bridgeResistance = 350D;
|
|
/// <summary>
|
|
/// the expected resistance in Ohms if applicable for the sensor
|
|
/// </summary>
|
|
public double BridgeResistance
|
|
{
|
|
get => _bridgeResistance;
|
|
set => SetProperty(ref _bridgeResistance, value, "BridgeResistance");
|
|
}
|
|
|
|
protected SensorConstants.BridgeType _bridge = SensorConstants.BridgeType.FullBridge;
|
|
/// <summary>
|
|
/// the type of bridge or sensor
|
|
/// [DO NOT USE BITMASKED VALUE WHEN READING/WRITING TO DB]
|
|
/// </summary>
|
|
public SensorConstants.BridgeType Bridge
|
|
{
|
|
get => _bridge;
|
|
set => SetProperty(ref _bridge, value, "Bridge");
|
|
}
|
|
protected void SetBridge(SensorConstants.BridgeType bridge)
|
|
{
|
|
_bridge = bridge;
|
|
}
|
|
protected bool _broken = false;
|
|
/// <summary>
|
|
/// Whether the sensor has been marked as broken by a user
|
|
/// </summary>
|
|
public bool Broken
|
|
{
|
|
get => _broken;
|
|
set => SetProperty(ref _broken, value, "Broken");
|
|
}
|
|
protected bool _bypassFilter = false;
|
|
/// <summary>
|
|
/// whether the sensor has it's own filtering or should otherwise bypass
|
|
/// hardware filters when collecting data
|
|
/// (not supported on all hardware)
|
|
/// </summary>
|
|
public bool BypassFilter
|
|
{
|
|
get => _bypassFilter;
|
|
set => SetProperty(ref _bypassFilter, value, "BypassFilter");
|
|
}
|
|
protected bool _calibrationSignal;
|
|
/// <summary>
|
|
/// deprecated?
|
|
/// </summary>
|
|
public bool CalibrationSignal
|
|
{
|
|
get => _calibrationSignal;
|
|
set => SetProperty(ref _calibrationSignal, value, "CalibrationSignal");
|
|
}
|
|
protected int _calInterval = 365;
|
|
/// <summary>
|
|
/// calibration interval in days, used in determining when sensor is out of cal
|
|
/// </summary>
|
|
public int CalInterval
|
|
{
|
|
get => _calInterval;
|
|
set => SetProperty(ref _calInterval, value, "CalInterval");
|
|
}
|
|
protected double _capacity = 2400D;
|
|
/// <summary>
|
|
/// capacity of the sensor in EU
|
|
/// </summary>
|
|
public double Capacity
|
|
{
|
|
get => _capacity;
|
|
set => SetProperty(ref _capacity, value, "Capacity");
|
|
}
|
|
protected bool _checkOffset = true;
|
|
/// <summary>
|
|
/// Whether to check the sensor output in mV against thresholds in diagnostics
|
|
/// </summary>
|
|
public bool CheckOffset
|
|
{
|
|
get => _checkOffset;
|
|
set => SetProperty(ref _checkOffset, value, "CheckOffset");
|
|
}
|
|
protected string _comment = "";
|
|
/// <summary>
|
|
/// user supplied descriptive comment on sensor
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string Comment
|
|
{
|
|
get => _comment;
|
|
set => SetProperty(ref _comment, value, "Comment");
|
|
}
|
|
protected SensorConstants.CouplingModes _couplingMode = SensorConstants.CouplingModes.AC;
|
|
/// <summary>
|
|
/// IEPE coupling mode to use for data collection if applicable
|
|
/// </summary>
|
|
public SensorConstants.CouplingModes CouplingMode
|
|
{
|
|
get => _couplingMode;
|
|
set => SetProperty(ref _couplingMode, value, "CouplingMode");
|
|
}
|
|
protected DateTime _created;
|
|
/// <summary>
|
|
/// date sensor record was created (if available)
|
|
/// </summary>
|
|
[Column(TypeName = "datetime")]
|
|
public DateTime Created
|
|
{
|
|
get => _created;
|
|
set => SetProperty(ref _created, value, "Created");
|
|
}
|
|
protected bool _diagnosticsMode = false;
|
|
/// <summary>
|
|
/// Whether this sensor should only record internal resistance and record no external signal
|
|
/// [generally only useful for testing purposes]
|
|
/// </summary>
|
|
public bool DiagnosticsMode
|
|
{
|
|
get => _diagnosticsMode;
|
|
set => SetProperty(ref _diagnosticsMode, value, "DiagnosticsMode");
|
|
}
|
|
|
|
protected string _displayUnit = "";
|
|
/// <summary>
|
|
/// engineering units collected data should be displayed in
|
|
/// note that calibration records are also tied against a specific engineering unit that should be used
|
|
/// the sensor db value is not used
|
|
/// </summary>
|
|
public string DisplayUnit
|
|
{
|
|
get => _displayUnit;
|
|
set => SetProperty(ref _displayUnit, value, "DisplayUnit");
|
|
}
|
|
protected bool _doNotUse = false;
|
|
/// <summary>
|
|
/// whether this sensor has been marked not to be used by user
|
|
/// </summary>
|
|
public bool DoNotUse
|
|
{
|
|
get => _doNotUse;
|
|
set => SetProperty(ref _doNotUse, value, "DoNotUse");
|
|
}
|
|
|
|
public bool InspectBeforeUseCleared { get; set; }
|
|
|
|
protected double _sensitivityTolerancePercent = Constants.SENSITIVITY_CHANGE_TOLERANCE_PERCENT_DEFAULT;
|
|
/// <summary>
|
|
///default SensitivityTolerancePercent
|
|
/// </summary>
|
|
public double SensitivityTolerancePercent
|
|
{
|
|
get => _sensitivityTolerancePercent;
|
|
set => SetProperty(ref _sensitivityTolerancePercent, value, "SensitivityTolerancePercent");
|
|
}
|
|
|
|
protected string _eId = "";
|
|
/// <summary>
|
|
/// Electronic Identification tag
|
|
/// [DALLAS or TEDS ID TAG]
|
|
/// if present required to be unique
|
|
/// </summary>
|
|
[Required]
|
|
[Column("eId")]
|
|
[StringLength(50)]
|
|
public string EId
|
|
{
|
|
get => _eId;
|
|
set => SetProperty(ref _eId, value, "EId");
|
|
}
|
|
protected double _externalShuntResistance;
|
|
/// <summary>
|
|
/// TDAS supports external resistance when measuring shunt resistance
|
|
/// this is the value of external resistance applied
|
|
/// </summary>
|
|
public double ExternalShuntResistance
|
|
{
|
|
get => _externalShuntResistance;
|
|
set => SetProperty(ref _externalShuntResistance, value, "ExternalShuntResistance");
|
|
}
|
|
|
|
private IFilterClass _filter = new FilterClass(FilterClassType.CFC1000);
|
|
/// <summary>
|
|
/// The default software filter class to apply to data channel when viewing
|
|
/// filtered EU data
|
|
/// </summary>
|
|
public IFilterClass Filter
|
|
{
|
|
get => _filter;
|
|
set => SetProperty(ref _filter, value, "Filter");
|
|
}
|
|
private double? _initialEU;
|
|
/// <summary>
|
|
/// Amount of EU to add in when EU is calculated
|
|
/// Used to offset EU readings by a specific amount
|
|
/// Note that analog sensor calibration records
|
|
/// can contain a more sophisticated EU offset
|
|
/// </summary>
|
|
[Column("InitialEU")]
|
|
[Required]
|
|
[StringLength(50)]
|
|
public double? InitialEu
|
|
{
|
|
get => _initialEU;
|
|
set => SetProperty(ref _initialEU, value, "InitialEu");
|
|
}
|
|
protected double _internalShuntResistance;
|
|
/// <summary>
|
|
/// TDAS supports performing external and internal resistance when measuring shunt resistance
|
|
/// This is the value to use when internal shunt resistance is used
|
|
/// </summary>
|
|
public double InternalShuntResistance
|
|
{
|
|
get => _internalShuntResistance;
|
|
set => SetProperty(ref _internalShuntResistance, value, "InternalShuntResistance");
|
|
}
|
|
protected bool _invert = false;
|
|
/// <summary>
|
|
/// whether output of the sensor in EU should be inverted or not
|
|
/// </summary>
|
|
public bool Invert
|
|
{
|
|
get => _invert;
|
|
set => SetProperty(ref _invert, value, "Invert");
|
|
}
|
|
private string _isoChannelName = string.Empty;
|
|
/// <summary>
|
|
/// ISO 13499 channel name to apply to a data channel when a data channel is
|
|
/// created using the sensor
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(255)]
|
|
public string ISOChannelName
|
|
{
|
|
get => _isoChannelName;
|
|
set => SetProperty(ref _isoChannelName, value, "ISOChannelName");
|
|
}
|
|
private string _isoCode = string.Empty;
|
|
/// <summary>
|
|
/// ISO 13499 code to apply to a data channel when a data channel is created
|
|
/// using the sensor
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string ISOCode
|
|
{
|
|
get => _isoCode;
|
|
set => SetProperty(ref _isoCode, value, "ISOCode");
|
|
}
|
|
private DateTime _lastModified = (DateTime)SqlDateTime.MinValue;
|
|
/// <summary>
|
|
/// when the sensor was last modified
|
|
/// </summary>
|
|
[Column(TypeName = "datetime")]
|
|
public DateTime LastModified
|
|
{
|
|
get => _lastModified;
|
|
set => SetProperty(ref _lastModified, value, "LastModified");
|
|
}
|
|
protected bool _localOnly = false;
|
|
/// <summary>
|
|
/// deprecated, used to determine which sensors should not propagate up to central database
|
|
/// </summary>
|
|
public bool LocalOnly
|
|
{
|
|
get => _localOnly;
|
|
set => SetProperty(ref _localOnly, value, "LocalOnly");
|
|
}
|
|
protected string _manufacturer = "";
|
|
/// <summary>
|
|
/// Maker of sensor
|
|
/// </summary>
|
|
[StringLength(50)]
|
|
public string Manufacturer
|
|
{
|
|
get => _manufacturer;
|
|
set => SetProperty(ref _manufacturer, value, "Manufacturer");
|
|
}
|
|
protected string _model = "";
|
|
/// <summary>
|
|
/// model of sensor
|
|
/// </summary>
|
|
[StringLength(50)]
|
|
public string Model
|
|
{
|
|
get => _model;
|
|
set => SetProperty(ref _model, value, "Model");
|
|
}
|
|
private string _modifiedBy = "";
|
|
/// <summary>
|
|
/// who last modified the sensor record
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string ModifiedBy
|
|
{
|
|
get => _modifiedBy;
|
|
set => SetProperty(ref _modifiedBy, value, "ModifiedBy");
|
|
}
|
|
private short _numberOfAxes = 1;
|
|
/// <summary>
|
|
/// deprecated/reserved
|
|
/// number of axes associated with this serial number
|
|
/// </summary>
|
|
public short NumberOfAxes
|
|
{
|
|
get => _numberOfAxes;
|
|
set => SetProperty(ref _numberOfAxes, value, "NumberOfAxes");
|
|
}
|
|
protected double _offsetToleranceHigh = SensorConstants.DefaultBridgeOffsetMVTolHigh;
|
|
/// <summary>
|
|
/// allowable tolerance in mV on the high side for an idle reading of sensor
|
|
/// used to determine if the sensor output is too high in diagnostics
|
|
/// </summary>
|
|
public double OffsetToleranceHigh
|
|
{
|
|
get => _offsetToleranceHigh;
|
|
set => SetProperty(ref _offsetToleranceHigh, value, "OffsetToleranceHigh");
|
|
}
|
|
protected double _offsetToleranceLow = SensorConstants.DefaultBridgeOffsetMVTolLow;
|
|
/// <summary>
|
|
/// allowable tolerance in mV on the low side for an idle reading of sensor
|
|
/// used to determine if the sensor output is too low in diagnostics
|
|
/// </summary>
|
|
public double OffsetToleranceLow
|
|
{
|
|
get => _offsetToleranceLow;
|
|
set => SetProperty(ref _offsetToleranceLow, value, "OffsetToleranceLow");
|
|
}
|
|
private double _rangeMedium;
|
|
/// <summary>
|
|
/// typical medium range for sensor in applications
|
|
/// </summary>
|
|
public double RangeMedium
|
|
{
|
|
get => 0 == _rangeMedium ? Capacity : _rangeMedium;
|
|
set => SetProperty(ref _rangeMedium, value, "RangeMedium");
|
|
}
|
|
private double _rangeHigh;
|
|
/// <summary>
|
|
/// typical high range for sensor in applications
|
|
/// </summary>
|
|
public double RangeHigh
|
|
{
|
|
get => 0 == _rangeHigh ? Capacity : _rangeHigh;
|
|
set => SetProperty(ref _rangeHigh, value, "RangeHigh");
|
|
}
|
|
private double _rangeLow;
|
|
/// <summary>
|
|
/// typical low range for sensor in applications
|
|
/// </summary>
|
|
public double RangeLow
|
|
{
|
|
get => 0 == _rangeLow ? Capacity : _rangeLow;
|
|
set => SetProperty(ref _rangeLow, value, "RangeLow");
|
|
}
|
|
protected int _sensorCategory;
|
|
/// <summary>
|
|
/// The type of sensor
|
|
/// Deprecated, remains for TDC purposes
|
|
/// Normal = 0,
|
|
/// POT = 1,
|
|
/// IRTracc = 2,
|
|
/// Polynomial = 3
|
|
/// </summary>
|
|
public int SensorCategory
|
|
{
|
|
get => _sensorCategory;
|
|
set => SetProperty(ref _sensorCategory, value, "SensorCategory");
|
|
}
|
|
private int _sensorModelId;
|
|
/// <summary>
|
|
/// the database id of the sensor model, if applicable
|
|
/// </summary>
|
|
public int SensorModelId
|
|
{
|
|
get => _sensorModelId;
|
|
set => SetProperty(ref _sensorModelId, value, "SensorModelId");
|
|
}
|
|
private const short SHUNT_MODE_EMULATION = 1;
|
|
protected short _shunt = SHUNT_MODE_EMULATION;
|
|
/// <summary>
|
|
/// The type of shunt used for measuring shunt results
|
|
/// note all SLICE hardware only supports emulation (or none)
|
|
/// None = 0,
|
|
/// Emulation = 1,
|
|
/// Internal = 2,
|
|
/// External = 3
|
|
/// </summary>
|
|
public short Shunt
|
|
{
|
|
get => _shunt;
|
|
set => SetProperty(ref _shunt, value, "Shunt");
|
|
}
|
|
protected SensorStatus _status = SensorStatus.Available;
|
|
[Required]
|
|
[StringLength(50)]
|
|
/// <summary>
|
|
/// reserved/not in use
|
|
/// </summary>
|
|
public SensorStatus Status
|
|
{
|
|
get => _status;
|
|
set => SetProperty(ref _status, value, "Status");
|
|
}
|
|
protected ExcitationVoltageOptions.ExcitationVoltageOption[] _supportedExcitation = new[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 };
|
|
/// <summary>
|
|
/// Excitation voltages supported by the sensor
|
|
/// used to prevent the sensor from being used in a situation that might damaged it
|
|
/// (say a 2V sensor being fed 10V excitation)
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public ExcitationVoltageOptions.ExcitationVoltageOption[] SupportedExcitation
|
|
{
|
|
get => _supportedExcitation;
|
|
set => SetProperty(ref _supportedExcitation, value, "SupportedExcitation");
|
|
}
|
|
protected long _timesUsed;
|
|
/// <summary>
|
|
/// Reserved/Not used
|
|
/// </summary>
|
|
public long TimesUsed
|
|
{
|
|
get => _timesUsed;
|
|
set => SetProperty(ref _timesUsed, value, "TimesUsed");
|
|
}
|
|
protected bool _uniPolar = false;
|
|
/// <summary>
|
|
/// flag indicating that the sensor should be interpreted as 0-n rather than -x<0<x
|
|
/// </summary>
|
|
public bool UniPolar
|
|
{
|
|
get => _uniPolar;
|
|
set => SetProperty(ref _uniPolar, value, "UniPolar");
|
|
}
|
|
private string _userChannelName = string.Empty;
|
|
/// <summary>
|
|
/// User channel name to apply when sensor is applied to a blank channel
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(255)]
|
|
public string UserChannelName
|
|
{
|
|
get => _userChannelName;
|
|
set => SetProperty(ref _userChannelName, value, "UserChannelName");
|
|
}
|
|
private string _userCode = string.Empty;
|
|
/// <summary>
|
|
/// User channel code to apply when sensor is applied to a blank channel
|
|
/// </summary>
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string UserCode
|
|
{
|
|
get => _userCode;
|
|
set => SetProperty(ref _userCode, value, "UserCode");
|
|
}
|
|
protected string _userSerialNumber = string.Empty;
|
|
[Required]
|
|
[StringLength(50)]
|
|
public string UserSerialNumber
|
|
{
|
|
get => _userSerialNumber;
|
|
set => SetProperty(ref _userSerialNumber, value, "UserSerialNumber");
|
|
}
|
|
|
|
protected string _userValue1 = string.Empty;
|
|
/// <summary>
|
|
/// user supplied string
|
|
/// travels with the sensor to data channels when
|
|
/// data is recorded with the sensor
|
|
/// </summary>
|
|
[StringLength(50)]
|
|
public string UserValue1
|
|
{
|
|
get => _userValue1;
|
|
set => SetProperty(ref _userValue1, value, "UserValue1");
|
|
}
|
|
protected string _userValue2 = string.Empty;
|
|
/// <summary>
|
|
/// user supplied string
|
|
/// travels with the sensor to data channels when
|
|
/// data is recorded with the sensor
|
|
/// </summary>
|
|
[StringLength(50)]
|
|
public string UserValue2
|
|
{
|
|
get => _userValue2;
|
|
set => SetProperty(ref _userValue2, value, "UserValue2");
|
|
}
|
|
protected string _userValue3 = string.Empty;
|
|
/// <summary>
|
|
/// user supplied string
|
|
/// travels with the sensor to data channels when
|
|
/// data is recorded with the sensor
|
|
/// </summary>
|
|
[StringLength(50)]
|
|
public string UserValue3
|
|
{
|
|
get => _userValue3;
|
|
set => SetProperty(ref _userValue3, value, "UserValue3");
|
|
}
|
|
private int _version = 1;
|
|
/// <summary>
|
|
/// deprecated
|
|
/// </summary>
|
|
public int Version
|
|
{
|
|
get => _version;
|
|
set => SetProperty(ref _version, value, "Version");
|
|
}
|
|
private DateTime? _firstUseDate;
|
|
[Column(TypeName = "datetime")]
|
|
/// <summary>
|
|
/// Date of first destructive use since sensor was calibrated,
|
|
/// only valid when using latest calibration
|
|
/// null indicates not set
|
|
/// </summary>
|
|
public DateTime? FirstUseDate
|
|
{
|
|
get => _firstUseDate;
|
|
set => SetProperty(ref _firstUseDate, value, "FirstUseDate");
|
|
}
|
|
private int? _latestCalibrationId;
|
|
/// <summary>
|
|
/// deprecated
|
|
/// Originally held the id of the latest calibration record
|
|
/// for sensor
|
|
/// </summary>
|
|
public int? LatestCalibrationId
|
|
{
|
|
get => _latestCalibrationId;
|
|
set => SetProperty(ref _latestCalibrationId, value, "LatestCalibrationId");
|
|
}
|
|
private string _assemblyName = string.Empty;
|
|
public string AssemblyName
|
|
{
|
|
get => _assemblyName;
|
|
set => SetProperty(ref _assemblyName, value, "AssemblyName");
|
|
}
|
|
private int _usageCount = 0;
|
|
public int UsageCount
|
|
{
|
|
get => _usageCount;
|
|
set => SetProperty(ref _usageCount, value, "UsageCount");
|
|
}
|
|
private int _maximumUsage = 2500;
|
|
public int MaximumUsage
|
|
{
|
|
get => _maximumUsage;
|
|
set => SetProperty(ref _maximumUsage, value, "MaximumUsage");
|
|
}
|
|
private bool _dontAllowDataCollectionIfOverused = false;
|
|
public bool DontAllowDataCollectionIfOverused
|
|
{
|
|
get => _dontAllowDataCollectionIfOverused;
|
|
set => SetProperty(ref _dontAllowDataCollectionIfOverused, value, "DontAllowDataCollectionIfOverused");
|
|
}
|
|
private int _sensorUsageWarningCount = 5;
|
|
public int SensorUsageWarningCount
|
|
{
|
|
get => _sensorUsageWarningCount;
|
|
set => SetProperty(ref _sensorUsageWarningCount, value, "SensorUsageWarningCount");
|
|
}
|
|
public AnalogDbRecord() { }
|
|
public AnalogDbRecord(IAnalogDbRecord copy)
|
|
{
|
|
AxisNumber = copy.AxisNumber;
|
|
Bridge = copy.Bridge;
|
|
BridgeLegMode = copy.BridgeLegMode;
|
|
BridgeResistance = copy.BridgeResistance;
|
|
BypassFilter = copy.BypassFilter;
|
|
CalibrationSignal = copy.CalibrationSignal;
|
|
CalInterval = copy.CalInterval;
|
|
Capacity = copy.Capacity;
|
|
CheckOffset = copy.CheckOffset;
|
|
Comment = copy.Comment;
|
|
CouplingMode = copy.CouplingMode;
|
|
Created = copy.Created;
|
|
ExternalShuntResistance = copy.ExternalShuntResistance;
|
|
Filter = new FilterClass(copy.Filter.FClass, copy.Filter.Frequency);
|
|
EId = copy.EId;
|
|
InternalShuntResistance = copy.InternalShuntResistance;
|
|
Invert = copy.Invert;
|
|
ISOCode = copy.ISOCode;
|
|
ISOChannelName = copy.ISOChannelName;
|
|
UserCode = copy.UserCode;
|
|
UserChannelName = copy.UserChannelName;
|
|
LastModified = copy.LastModified;
|
|
LocalOnly = copy.LocalOnly;
|
|
Manufacturer = copy.Manufacturer;
|
|
DisplayUnit = copy.DisplayUnit;
|
|
Model = copy.Model;
|
|
ModifiedBy = copy.ModifiedBy;
|
|
NumberOfAxes = copy.NumberOfAxes;
|
|
OffsetToleranceHigh = copy.OffsetToleranceHigh;
|
|
OffsetToleranceLow = copy.OffsetToleranceLow;
|
|
RangeMedium = copy.RangeMedium;
|
|
RangeHigh = copy.RangeHigh;
|
|
RangeLow = copy.RangeLow;
|
|
SensorCategory = copy.SensorCategory;
|
|
SerialNumber = copy.SerialNumber;
|
|
Shunt = copy.Shunt;
|
|
Status = copy.Status;
|
|
TimesUsed = copy.TimesUsed;
|
|
UniPolar = copy.UniPolar;
|
|
UserSerialNumber = copy.UserSerialNumber;
|
|
DiagnosticsMode = copy.DiagnosticsMode;
|
|
UserValue1 = copy.UserValue1;
|
|
UserValue2 = copy.UserValue2;
|
|
UserValue3 = copy.UserValue3;
|
|
Version = copy.Version;
|
|
SupportedExcitation = copy.SupportedExcitation;
|
|
TagsBlobBytes = copy.TagsBlobBytes;
|
|
DoNotUse = copy.DoNotUse;
|
|
Broken = copy.Broken;
|
|
//43046
|
|
SensitivityTolerancePercent = copy.SensitivityTolerancePercent;
|
|
|
|
Id = copy.Id;
|
|
FirstUseDate = copy.FirstUseDate;
|
|
LatestCalibrationId = copy.LatestCalibrationId;
|
|
ACCouplingModeEnabled = copy.ACCouplingModeEnabled;
|
|
AssemblyName = copy.AssemblyName;
|
|
UsageCount = copy.UsageCount;
|
|
MaximumUsage = copy.MaximumUsage;
|
|
}
|
|
public AnalogDbRecord(IDataReader reader, int actualDbVersion)
|
|
{
|
|
AxisNumber = Utility.GetShort(reader, "AxisNumber", 0);
|
|
SetBridge(SensorConstants.ConvertIntToBridgeType(Utility.GetInt(reader, "BridgeType")));
|
|
BridgeLegMode = Utility.GetShort(reader, "BridgeLegMode", 0);
|
|
BridgeResistance = Utility.GetDouble(reader, "BridgeResistance");
|
|
BypassFilter = Utility.GetBool(reader, "BypassFilter");
|
|
CalibrationSignal = Utility.GetBool(reader, "CalibrationSignal");
|
|
CalInterval = Utility.GetInt(reader, "CalInterval");
|
|
Capacity = Utility.GetDouble(reader, "Capacity");
|
|
CheckOffset = Utility.GetBool(reader, "CheckOffset");
|
|
Comment = Utility.GetString(reader, "Comment");
|
|
CouplingMode = (SensorConstants.CouplingModes)Utility.GetInt(reader, "CouplingMode");
|
|
Created = Utility.GetDateTime(reader, "Created", DateTime.MinValue);
|
|
ExternalShuntResistance = Utility.GetDouble(reader, "ExternalShuntResistance");
|
|
Filter = new FilterClass(Utility.GetString(reader, "FilterClass"));
|
|
EId = Utility.GetString(reader, "eId");
|
|
InternalShuntResistance = Utility.GetDouble(reader, "InternalShuntResistance");
|
|
Invert = Utility.GetBool(reader, "Invert");
|
|
ISOCode = Utility.GetString(reader, "IsoCode");
|
|
ISOChannelName = Utility.GetString(reader, "IsoChannelName");
|
|
UserCode = Utility.GetString(reader, "UserCode");
|
|
UserChannelName = Utility.GetString(reader, "UserChannelName");
|
|
LastModified = Utility.GetDateTime(reader, "LastModified", DateTime.MinValue);
|
|
LocalOnly = Utility.GetBool(reader, "LocalOnly", false);
|
|
Manufacturer = Utility.GetString(reader, "Manufacturer");
|
|
DisplayUnit = Utility.GetString(reader, "MeasurementUnit");
|
|
Model = Utility.GetString(reader, "Model");
|
|
ModifiedBy = Utility.GetString(reader, "ModifiedBy");
|
|
NumberOfAxes = Utility.GetShort(reader, "NumberOfAxes");
|
|
OffsetToleranceHigh = Utility.GetDouble(reader, "OffsetToleranceHigh");
|
|
OffsetToleranceLow = Utility.GetDouble(reader, "OffsetToleranceLow");
|
|
RangeMedium = Utility.GetDouble(reader, "RangeAve");
|
|
RangeHigh = Utility.GetDouble(reader, "RangeHigh");
|
|
RangeLow = Utility.GetDouble(reader, "RangeLow");
|
|
SensorCategory = Utility.GetInt(reader, "SensorCategory");
|
|
SerialNumber = Utility.GetString(reader, "SerialNumber");
|
|
Shunt = Utility.GetShort(reader, "Shunt");
|
|
var oStatus = reader["Status"];
|
|
if (oStatus is string s)
|
|
{
|
|
if (Enum.TryParse(s, out SensorStatus newStatus))
|
|
{
|
|
Status = newStatus;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Status = (SensorStatus)Convert.ToInt32(oStatus);
|
|
}
|
|
TimesUsed = Utility.GetInt(reader, "TimesUsed");
|
|
UniPolar = Utility.GetBool(reader, "UniPolar");
|
|
UserSerialNumber = Utility.GetString(reader, "UserSerialNumber");
|
|
DiagnosticsMode = Utility.GetBool(reader, "DiagnosticsMode");
|
|
UserValue1 = Utility.GetString(reader, "UserValue1");
|
|
UserValue2 = Utility.GetString(reader, "UserValue2");
|
|
UserValue3 = Utility.GetString(reader, "UserValue3");
|
|
Version = Utility.GetInt(reader, "Version");
|
|
SetSupportedExcitationFromString(Utility.GetString(reader, "SupportedExcitation"));
|
|
TagsBlobBytes = (byte[])reader["UserTags"];
|
|
DoNotUse = Utility.GetBool(reader, "DoNotUse");
|
|
|
|
Broken = Utility.GetBool(reader, "Broken");
|
|
Id = Utility.GetInt(reader, "Id", -1);
|
|
FirstUseDate = Utility.GetNullableDateTime(reader, "FirstUseDate");
|
|
LatestCalibrationId = Utility.GetNullableInt(reader, "LatestCalibrationId");
|
|
ACCouplingModeEnabled = Utility.GetBool(reader, "ACCouplingModeEnabled", false);
|
|
if (actualDbVersion >= Constants.SENSOR_ASSEMBLY_DB_VERSION)
|
|
{
|
|
//43046
|
|
SensitivityTolerancePercent = Utility.GetDouble(reader, "SensitivityTolerancePercent", Constants.SENSITIVITY_CHANGE_TOLERANCE_PERCENT_DEFAULT);
|
|
AssemblyName = Utility.GetString(reader, "AssemblyName").Trim();
|
|
UsageCount = Utility.GetInt(reader, "UsageCount", 0);
|
|
MaximumUsage = Utility.GetInt(reader, "MaximumUsage", 2500);
|
|
}
|
|
}
|
|
public void SetSupportedExcitationFromString(string s)
|
|
{
|
|
var excitations = new List<ExcitationVoltageOptions.ExcitationVoltageOption>();
|
|
|
|
var tokens = s.Split(new[] { System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator }, StringSplitOptions.None);
|
|
foreach (var token in tokens)
|
|
{
|
|
if (Enum.TryParse(token, out ExcitationVoltageOptions.ExcitationVoltageOption option)) { excitations.Add(option); }
|
|
}
|
|
SupportedExcitation = excitations.ToArray();
|
|
}
|
|
|
|
private bool _bACCouplingModeEnabled = false;
|
|
/// <summary>
|
|
/// whether to use AC Coupling when using a bridge mode (full/half/quarter/half+sig)
|
|
/// 18294 Implement Bridge AC/DC coupling(fw update dependent)
|
|
/// </summary>
|
|
public bool ACCouplingModeEnabled
|
|
{
|
|
get => _bACCouplingModeEnabled;
|
|
set => SetProperty(ref _bACCouplingModeEnabled, value, "ACCouplingModeEnabled");
|
|
}
|
|
}
|
|
}
|