219 lines
9.6 KiB
Plaintext
219 lines
9.6 KiB
Plaintext
using DTS.Common.Interface.DataRecorders;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.ComponentModel.DataAnnotations.Schema;
|
|
using System.Data;
|
|
|
|
namespace DTS.Common.Classes.Hardware
|
|
{
|
|
/// <summary>
|
|
/// representation of a DASChannel in the db
|
|
/// <inheritdoc cref="IDASChannelDBRecord"/>
|
|
/// </summary>
|
|
public class DASChannelDBRecord : Common.Base.BasePropertyChanged, IDASChannelDBRecord
|
|
{
|
|
/// <summary>
|
|
/// a string id for the hardware the channel belongs to
|
|
/// (serialnumber_dastype)
|
|
/// </summary>
|
|
public string HardwareId { get; set; }
|
|
[Key]
|
|
[Column("DASChannelId")]
|
|
/// <summary>
|
|
/// the id/key of the DAS channel record in the db
|
|
/// </summary>
|
|
public int DaschannelId { get; set; }
|
|
[Column("DASId")]
|
|
/// <summary>
|
|
/// the das db id of the Hardware this channel belongs to
|
|
/// </summary>
|
|
public int? Dasid { get; set; }
|
|
|
|
private int _channelIdx;
|
|
/// <summary>
|
|
/// the physical channel index of the channel among channels on the DAS
|
|
/// </summary>
|
|
public int ChannelIdx
|
|
{
|
|
get => _channelIdx;
|
|
set => SetProperty(ref _channelIdx, value, "ChannelIdx");
|
|
}
|
|
/// <summary>
|
|
/// BitMask indicating the supported bridges on a das by default (half (4) + full (8))bridge
|
|
/// </summary>
|
|
public const int DEFAULT_SUPPORTED_BRIDGES = 12;
|
|
private int _supportedBridges = DEFAULT_SUPPORTED_BRIDGES;
|
|
/// <summary>
|
|
/// BitMask for bridges supported by the channel
|
|
/// Bit 0 indicates IEPE
|
|
/// Bit 1 indicates quarter bridge
|
|
/// Bit 2 indicates half bridge
|
|
/// Bit 3 indicates full bridge
|
|
/// Bit 4 indicates digital input
|
|
/// Bit 5 indicates squib fire
|
|
/// Bit 6 indicates digital output
|
|
/// Bit 7 indicates Half bridge signal plus (G5 signal plus)
|
|
/// Bit 8 indicates RealTime Clock
|
|
/// Bit 9 indicates UART
|
|
/// </summary>
|
|
public int SupportedBridges
|
|
{
|
|
get => _supportedBridges;
|
|
set => SetProperty(ref _supportedBridges, value, "SupportedBridges");
|
|
}
|
|
/// <summary>
|
|
/// BitMask indicating the supported excitations for a das channel by default
|
|
/// (5V by default)
|
|
/// </summary>
|
|
public const int DEFAULT_SUPPORTED_EXCITATIONS = 16;
|
|
private int _supporedExcitations = DEFAULT_SUPPORTED_EXCITATIONS;
|
|
/// <summary>
|
|
/// BitMask indicating what excitation options the channel supports
|
|
/// Bit 0 indicates an invalid excitation (undefined)
|
|
/// Bit 1 indicates 2V
|
|
/// Bit 2 indicates 2.5V
|
|
/// Bit 3 indicates 3V
|
|
/// Bit 4 indicates 5V
|
|
/// Bit 5 indicates 10V
|
|
/// Bit 6 indicates 1V
|
|
/// </summary>
|
|
public int SupportedExcitations
|
|
{
|
|
get => _supporedExcitations;
|
|
set => SetProperty(ref _supporedExcitations, value, "SupportedExcitations");
|
|
}
|
|
[Column("DASDisplayOrder")]
|
|
private int _dasDisplayOrder;
|
|
/// <summary>
|
|
/// The display order of the channel among channels on the DAS
|
|
/// note that the physical order of channels and the display order may not match for
|
|
/// some hardware
|
|
/// </summary>
|
|
public int DASDisplayOrder
|
|
{
|
|
get => _dasDisplayOrder;
|
|
set => SetProperty(ref _dasDisplayOrder, value, "DASDisplayOrder");
|
|
}
|
|
private bool _bLocalOnly;
|
|
/// <summary>
|
|
/// Indicates that record should be stored only in the local db and not propagated to a central db
|
|
/// deprecated
|
|
/// </summary>
|
|
public bool LocalOnly
|
|
{
|
|
get => _bLocalOnly;
|
|
set => SetProperty(ref _bLocalOnly, value, "LocalOnly");
|
|
}
|
|
/// <summary>
|
|
/// Bitmask indicating the default supported digital input modes for a channel (CCNC)
|
|
/// </summary>
|
|
public const int DEFAULT_SUPPORTED_DI_MODES = 16;
|
|
private int _supportedDigitalInputModes = DEFAULT_SUPPORTED_DI_MODES;
|
|
/// <summary>
|
|
/// BitMask indicating what Digital input modes are supported on the channel (if channel supports digital input bridge type)
|
|
/// Bit 0 indicates an invalid mode
|
|
/// Bit 1 indicates Transition low to high (TLH)
|
|
/// Bit 2 indicates Transition high to low (THL)
|
|
/// Bit 3 indicates Contact closure normally open (CCNO)
|
|
/// Bit 4 indicates Contact closure normally closed (CCNC)
|
|
/// </summary>
|
|
public int SupportedDigitalInputModes
|
|
{
|
|
get => _supportedDigitalInputModes;
|
|
set => SetProperty(ref _supportedDigitalInputModes, value, "SupportedDigitalInputModes");
|
|
}
|
|
/// <summary>
|
|
/// BitMask indicating the default squib fire modes supported by a channel (note that 16 is invalid, but
|
|
/// I'm preserving what is in the existing code)
|
|
/// </summary>
|
|
public const int DEFAULT_SQUIB_FIRE_MODES = 16;
|
|
private int _supportedSquibFireModes = DEFAULT_SQUIB_FIRE_MODES;
|
|
/// <summary>
|
|
/// BitMask indicating what Squib fire modes are supported on the channel (if the channel supports squib fire bridge type)
|
|
/// Bit 0 indicates an invalid mode (fire mode not set)
|
|
/// Bit 1 indicates capacitor discharge
|
|
/// Bit 2 indicates constant current
|
|
/// Bit 3 indicates AC discharge
|
|
/// </summary>
|
|
public int SupportedSquibFireModes
|
|
{
|
|
get => _supportedSquibFireModes;
|
|
set => SetProperty(ref _supportedSquibFireModes, value, "SupportedSquibFireModes");
|
|
}
|
|
/// <summary>
|
|
/// Default digital output mode for channels 16 doesn't exist, but I'm preserving the existing behavior values
|
|
/// </summary>
|
|
public const int DEFAULT_SUPPORTED_DO_MODES = 16;
|
|
private int _supportedDigitalOutputModes = DEFAULT_SUPPORTED_DO_MODES;
|
|
|
|
/// <summary>
|
|
/// BitMask indicating what digital output modes are supported on the channel (if the channel supports digital output bridge type)
|
|
/// Bit 0 indicates 5V low to high (FVLH)
|
|
/// Bit 1 indicates 5V high to low transition (FVHL)
|
|
/// Bit 2 indicates contact closure normally open (CCNO)
|
|
/// Bit 3 indicates contact closure normally closed (CCNC)
|
|
/// </summary>
|
|
public int SupportedDigitalOutputModes
|
|
{
|
|
get => _supportedDigitalOutputModes;
|
|
set => SetProperty(ref _supportedDigitalOutputModes, value, "SupportedDigitalOutputModes");
|
|
}
|
|
[StringLength(16)]
|
|
protected string _moduleSerialNumber = "";
|
|
/// <summary>
|
|
/// Serial number of module channel belongs to
|
|
/// </summary>
|
|
public string ModuleSerialNumber
|
|
{
|
|
get => _moduleSerialNumber;
|
|
set => SetProperty(ref _moduleSerialNumber, value, "ModuleSerialNumber");
|
|
}
|
|
public int SettingId { get; set; }
|
|
protected int _moduleArrayIndex;
|
|
/// <summary>
|
|
/// Array index of module among modules on a DAS or Rack
|
|
/// </summary>
|
|
public int ModuleArrayIndex
|
|
{
|
|
get => _moduleArrayIndex;
|
|
set => _moduleArrayIndex = value;
|
|
}
|
|
public DASChannelDBRecord() { }
|
|
/// <summary>
|
|
/// constructor using a datareader to retrieve values
|
|
/// </summary>
|
|
/// <param name="reader"></param>
|
|
public DASChannelDBRecord(IDataReader reader)
|
|
{
|
|
HardwareId = Utility.GetString(reader, "HardwareId", string.Empty);
|
|
ChannelIdx = Utility.GetInt(reader, "ChannelIdx", -1);
|
|
SupportedBridges = Utility.GetInt(reader, "SupportedBridges", DEFAULT_SUPPORTED_BRIDGES);
|
|
SupportedExcitations = Utility.GetInt(reader, "SupportedExcitations", DEFAULT_SUPPORTED_EXCITATIONS);
|
|
SupportedDigitalInputModes = Utility.GetInt(reader, "SupportedDigitalInputModes", DEFAULT_SUPPORTED_DI_MODES);
|
|
SupportedDigitalOutputModes = Utility.GetInt(reader, "SupportedDigitalOutputModes", DEFAULT_SUPPORTED_DO_MODES);
|
|
SupportedSquibFireModes = Utility.GetInt(reader, "SupportedSquibFireModes", DEFAULT_SQUIB_FIRE_MODES);
|
|
DASDisplayOrder = Utility.GetInt(reader, "DASDisplayOrder", 0);
|
|
ModuleSerialNumber = Utility.GetString(reader, "ModuleSerialNumber", string.Empty);
|
|
LocalOnly = Utility.GetBool(reader, "LocalOnly", false);
|
|
ModuleArrayIndex = Utility.GetInt(reader, "ModuleArrayIndex", -1);
|
|
}
|
|
/// <summary>
|
|
/// copy constructor
|
|
/// </summary>
|
|
/// <param name="copy"></param>
|
|
public DASChannelDBRecord(IDASChannelDBRecord copy)
|
|
{
|
|
HardwareId = copy.HardwareId;
|
|
ChannelIdx = copy.ChannelIdx;
|
|
SupportedBridges = copy.SupportedBridges;
|
|
SupportedExcitations = copy.SupportedExcitations;
|
|
SupportedDigitalInputModes = copy.SupportedDigitalInputModes;
|
|
SupportedDigitalOutputModes = copy.SupportedDigitalOutputModes;
|
|
SupportedSquibFireModes = copy.SupportedSquibFireModes;
|
|
DASDisplayOrder = copy.DASDisplayOrder;
|
|
ModuleSerialNumber = copy.ModuleSerialNumber;
|
|
LocalOnly = copy.LocalOnly;
|
|
ModuleArrayIndex = copy.ModuleArrayIndex;
|
|
}
|
|
}
|
|
}
|