1274 lines
56 KiB
C#
1274 lines
56 KiB
C#
using DTS.Common.Behaviors;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
|
|
namespace DTS.Common.Enums.DASFactory
|
|
{
|
|
public static class DFConstantsAndEnums
|
|
{
|
|
/// <summary>
|
|
/// whether to show ADC as signed or unsigned
|
|
/// http://manuscript.dts.local/f/cases/32992/Add-a-flag-to-show-ADC-in-0-64k-rather-than-32k-to-32k
|
|
/// this property only holds the value of the attribute and does not
|
|
/// store or retrieve it
|
|
/// </summary>
|
|
public static bool AlwaysShowUnsignedADC = false;
|
|
/// <summary>
|
|
/// the time to wait for FPGA to unlatch in a one shot
|
|
///
|
|
/// </summary>
|
|
public static int OneShotWaitTimeMs = 3000;
|
|
[Flags]
|
|
public enum TempLogChannelBits
|
|
{
|
|
OnBoardTemp,
|
|
OnBoardHumidity,
|
|
EnvironmentalCh1,
|
|
EnvironmentalCh2,
|
|
EnvironmentalCh3,
|
|
EnvironmentalCh4,
|
|
}
|
|
public static string TemperatureLogTimeFormat { get; set; } = "MM-dd-yyyy HH:mm:ss";
|
|
public static string TemperatureLogValueFormat { get; set; } = "N2";
|
|
public const int TSR_AIR_HIGH_G_CUTOFF_RATE_SPS = 500;
|
|
/// <summary>
|
|
/// 29796 Add ability to configure multiple samples rates for TSR AIR
|
|
/// </summary>
|
|
public static readonly int[] TSRAIR_ValidSampleRates = new[]
|
|
{
|
|
100,
|
|
500,
|
|
1000,
|
|
5000,
|
|
10000,
|
|
15000,
|
|
20000
|
|
};
|
|
|
|
/// <summary>
|
|
/// Legacy SLICE 1 ARM status faults
|
|
/// </summary>
|
|
public enum FaultFlags
|
|
{
|
|
IncomingStatusLineDropped = 1 << 0,
|
|
ADCBufferOverrun = 1 << 1,
|
|
FlashCRCError = 1 << 2,
|
|
TriggerBeforeStart = 1 << 3,
|
|
InputVoltageLow = 1 << 4,
|
|
InputVoltageHigh = 1 << 5,
|
|
BackupVoltageLow = 1 << 6,
|
|
BackupVoltageHigh = 1 << 7,
|
|
OutOfMemory = 1 << 8,
|
|
SquibResistanceOutOfRange = 1 << 9,
|
|
SafeSwitchUnplugged = 1 << 10,
|
|
SquibPowerOutOfRange = 1 << 11,
|
|
AutoSquibDisableActivated = 1 << 12,
|
|
NO_DATA = 1 << 13
|
|
};
|
|
/// <summary>
|
|
/// possible excitation status for DAS
|
|
/// </summary>
|
|
public enum ExcitationStatus
|
|
{
|
|
Off,
|
|
On,
|
|
Unknown
|
|
}
|
|
public enum T0CorrectionStatus
|
|
{
|
|
ScanningForPowerLoss,
|
|
ScanningForPeaksAndTroughs,
|
|
SettingAttributes
|
|
}
|
|
/// <summary>
|
|
/// Whether to use drop down for test object and position
|
|
/// does not query database, so property must be set and maintained separately,
|
|
/// this merely allows passing the information between modules
|
|
/// 17567 Option to bring back Test Object and Position drop down in Test Set up -> Groups.
|
|
/// </summary>
|
|
public static bool UseDropDownForTestObjectAndPosition { get; set; } = false;
|
|
/// <summary>
|
|
/// whether to send EnableFaultChecking to S6DB or not
|
|
/// </summary>
|
|
public static bool AllowEnableFaultCheckingOnS6DB { get; set; } = true;
|
|
/// <summary>
|
|
/// returns true if the S6A firmware belongs to an ethernet recorder or not
|
|
/// </summary>
|
|
/// the amount of weight to add for a single channel when trying to predict the slowest module through diagnostics
|
|
/// when the channel uses remove offset
|
|
/// note that the time to remove offset can be highly dependent on the amount of offset present, etc
|
|
/// implemented for 21200 Correct SlowestModule calculation for TDAS
|
|
/// </summary>
|
|
public static double TDASRemoveOffsetWeighting { get; set; } = 1D;
|
|
/// <summary>
|
|
/// amount of weight to add for a single channel when trying to predict the slowest module through diagnostics when
|
|
/// the channel uses shunt emulation
|
|
/// </summary>
|
|
public static double TDASShuntEmulationWeighting { get; set; } = .5D;
|
|
/// <summary>
|
|
/// the expected amount of time in ms MAX for an individual channel in TDAS diagnostics
|
|
/// </summary>
|
|
public static int ExpectedMaxTDASDiagnosticRunTimePerChannelMS { get; set; } = 8000;
|
|
/// <summary>
|
|
/// returns true if the S6A firmware belongs to an ethernet recorder or not
|
|
/// </summary>
|
|
public static bool IsSLICE6ERFirmware(string firmwareVersion)
|
|
{
|
|
var tokens = firmwareVersion.Split('-');
|
|
var token = tokens.Last();
|
|
if (token.Length == 4)
|
|
{
|
|
//G1 and G3 are EDRs
|
|
//http://dtsinfo/dtswiki/index.php/SLICE_Base_Types
|
|
return token.StartsWith("G1") || token.StartsWith("G3");
|
|
}
|
|
return false;
|
|
}
|
|
public static bool UseUDPForAutoArmATDMonitor { get; set; } = false;
|
|
public const byte ArmStateIdle = 0;
|
|
public const string MADEUPEVENT_TESTID = "__MadeUp__";
|
|
/// <summary>
|
|
/// indicates that no configuration was found on the unit
|
|
/// originally added as this was an error condition when checking for TOMs on TDAS
|
|
/// </summary>
|
|
public const string NO_CONFIGURATION = "NO_CONFIGURATION";
|
|
/// <summary>
|
|
/// indiciates that a tom safety switch is in the armed position
|
|
/// </summary>
|
|
public const string TOMSWITCH_ARMED = "TOMSAFETY_ARMED";
|
|
/// <summary>
|
|
/// indicates there was an exception and the tom safety switch state could not be determined
|
|
/// </summary>
|
|
public const string SAFETYSWITCH_EXCEPTION = "SAFETYSWITCH_EXCEPTION";
|
|
public const string CHANNEL_SEPARATOR = "_";
|
|
public const string SERIAL_SEPARATOR = "-";
|
|
public const string LOWG_SERIAL_APPEND = "Low g";
|
|
public const string HIGHG_SERIAL_APPEND = "High g";
|
|
public const string ARS_SERIAL_APPEND = "ARS";
|
|
public const string ANGACCEL_SERIAL_APPEND = "Ang Acc";
|
|
public const string ATMOSPHERIC_SERIAL_APPEND = "Atm";
|
|
public const string OPTICAL_SERIAL_APPEND = "Opt";
|
|
public const string MAGNETIC_SERIAL_APPEND = "Mag";
|
|
public const string MAGNETICSWITCH_SERIAL_APPEND = "Mag Sw";
|
|
public const string MICROPHONE_SERIAL_APPEND = "Mic";
|
|
public const string RTCSECONDANDMARKER_SERIAL_APPEND = "RTC S";
|
|
public const string RTCCLOCKNANOPAD_SERIAL_APPEND = "RTC NS";
|
|
public const string STREAMOUT_SERIAL_APPEND = "StreamOut";
|
|
public const string UART_SERIAL_APPEND = "Uart";
|
|
public const int CHANNEL_X = 0;
|
|
public const int CHANNEL_Y = 1;
|
|
public const int CHANNEL_Z = 2;
|
|
public const int CHANNEL_TEMPERATURE = 0;
|
|
public const int CHANNEL_HUMIDITY = 1;
|
|
public const int CHANNEL_PRESSURE = 2;
|
|
public const string USER_CHANNEL_NAME_LOWG = "Low g";
|
|
public const string USER_CHANNEL_NAME_HIGHG = "High g";
|
|
public const string USER_CHANNEL_NAME_ANGULAR_RATE = "Angular Rate";
|
|
public const string USER_CHANNEL_NAME_TEMPERATURE = "Temperature";
|
|
public const string USER_CHANNEL_NAME_HUMIDITY = "Humidity";
|
|
public const string USER_CHANNEL_NAME_PRESSURE = "Pressure";
|
|
|
|
public static bool ExtraCommunicationLogging { get; set; } = false;
|
|
/// <summary>
|
|
/// ReceiveBufferSize in Bytes
|
|
/// amount of bytes for Ethernet sockets in dasfactory
|
|
/// 17589 Add new properties from 3.2 tweaks
|
|
/// </summary>
|
|
public static int ReceiveBufferSizeBytes { get; set; } = 65536;
|
|
/// <summary>
|
|
/// SendBufferSize in Bytes
|
|
/// amount of bytes for Ethernet sockets in dasfactory
|
|
/// 17589 Add new properties from 3.2 tweaks
|
|
/// </summary>
|
|
public static int SendBufferSizeBytes { get; set; } = 65536;
|
|
|
|
/// <summary>
|
|
/// keep alive time to send to remote clients for time between keep alives in seconds
|
|
/// 16053 Implement KeepAliveSeconds and KeepAliveRetrySeconds in the .config file
|
|
/// </summary>
|
|
public static uint RemoteKeepAliveSeconds { get; set; } = 60;
|
|
/// <summary>
|
|
/// keep alive time to send to remote clients for time for retry interval in seconds
|
|
/// 16053 Implement KeepAliveSeconds and KeepAliveRetrySeconds in the .config file
|
|
/// </summary>
|
|
public static uint RemoteKeepAliveRetryIntervalSeconds { get; set; } = 5;
|
|
/// <summary>
|
|
/// keep alive time to send to local sockets for time between keep alives in ms
|
|
/// 16053 Implement KeepAliveSeconds and KeepAliveRetrySeconds in the .config file
|
|
/// </summary>
|
|
public static uint LocalKeepAliveTimeOutMS { get; set; } = 5 * 1000;
|
|
/// <summary>
|
|
/// keep alive time to set for local sockets for time for retry interval in ms
|
|
/// 16053 Implement KeepAliveSeconds and KeepAliveRetrySeconds in the .config file
|
|
/// </summary>
|
|
public static uint LocalKeepAliveRetryIntervalMS = 1000;
|
|
|
|
public static int HeartbeatAsyncConnectTimeoutMS = 10000;
|
|
|
|
public static int WaitTimeBetweenUnitConnects = 100;
|
|
//15873 TDC vs DP speed improvements
|
|
//this is just to allow us to skip an SDL during the diagnostics process
|
|
public static bool DontDoSDL { get; set; } = false;
|
|
public const int SCHEDULE_AHEAD_IN_MINUTES = 2;
|
|
|
|
//FB 29510 Index for High g sensors
|
|
public const int High_g_Linear_1_Index = 3;
|
|
public const int High_g_Linear_2_Index = 4;
|
|
public const int High_g_Linear_3_Index = 5;
|
|
|
|
/// <summary>
|
|
/// This tells us what type of device it is
|
|
/// </summary>
|
|
public enum DASType
|
|
{
|
|
NONE,
|
|
HID_SLICE,
|
|
WINUSB_SLICE,
|
|
G5,
|
|
SIM,
|
|
TOM,
|
|
DIM,
|
|
TSR,
|
|
HEADS,
|
|
MINIDAU,
|
|
ETHERNET_SLICE,
|
|
ETHERNET_RIBEYE,
|
|
SLICE_DB,
|
|
TSR2,
|
|
ETHERNET_TDAS,
|
|
CDCUSB_SLICE,
|
|
ETHERNET_SLICE2,
|
|
WINUSB_SLICE1_5,
|
|
ETHERNET_SLICE1_5,
|
|
ETHERNET_SLICE6,
|
|
ETHERNET_SLICE6AIR,
|
|
WINUSB_SLICE6,
|
|
WINUSB_SLICE6AIR,
|
|
ETHERNET_SLICE6DB,
|
|
SERIAL_TDAS,
|
|
ETHERNET_POWERPRO,
|
|
ETHERNET_TSR_AIR,
|
|
ETHERNET_SLICE6DB3,
|
|
WINUSB_TSR_AIR,
|
|
ETHERNET_SLICEPRODB,
|
|
WINUSB_SLICE6AIR_BR,
|
|
ETHERNET_SLICE6AIR_BR,
|
|
}
|
|
|
|
public enum VoltageStatusColor
|
|
{
|
|
Green,
|
|
Red,
|
|
Yellow,
|
|
Off
|
|
}
|
|
|
|
public const int EVENT_NUMBER_PRETEST_DIAG = -1;
|
|
public const int EVENT_NUMBER_POSTTEST_DIAG = -2;
|
|
public const int EVENT_NUMBER_MEASURE_BRIDGE = -3;
|
|
public static string RealtimeUDPAddress { get; set; } = "UDP://239.1.2.10:8400";
|
|
|
|
|
|
/// <summary>
|
|
/// The different types of modules.
|
|
/// </summary>
|
|
public enum ModuleType
|
|
{
|
|
SliceBridge,
|
|
SliceARS,
|
|
G5Analog,
|
|
G5Digital,
|
|
ProSIM,
|
|
ProTOM,
|
|
ProDIM,
|
|
RibeyeLED,
|
|
SLICEIEPE,
|
|
SliceBridge2High,
|
|
SliceBridge2Low,
|
|
SliceIEPE2High,
|
|
SliceIEPE2Low,
|
|
EMPTYBANK,
|
|
SLICEPro_TOM,
|
|
EmbeddedLinearAccelLowG,
|
|
EmbeddedLinearAccelHighG,
|
|
EmbeddedAngularAccel,
|
|
EmbeddedAngularRate,
|
|
EmbeddedAtmospheric,
|
|
EmbeddedMicrophone,
|
|
EmbeddedMagnetometer,
|
|
EmbeddedMagnetInput,
|
|
EmbeddedOptical,
|
|
EmbeddedClockSecondsAndMarker,
|
|
EmbeddedClockNanosAndPad,
|
|
UART,
|
|
StreamOut,
|
|
StreamIn
|
|
}
|
|
|
|
/// <summary>
|
|
/// All available recording mode options.
|
|
/// </summary>
|
|
public enum RecordingMode
|
|
{
|
|
/// <summary>
|
|
/// invalid mode, this can't be used
|
|
/// </summary>
|
|
[Description("Invalid arm mode")] InvalidArmMode = 0,
|
|
|
|
/// <summary>
|
|
/// circular buffer mode (constant recording, trigger)
|
|
/// </summary>
|
|
[Description("Circular buffer")] CircularBuffer = 1,
|
|
|
|
/// <summary>
|
|
/// recorder mode (start, trigger)
|
|
/// </summary>
|
|
[Description("Recorder mode")] RecorderMode = 2,
|
|
|
|
/// <summary>
|
|
/// contant recording, trigger, rearm after data collected
|
|
/// </summary>
|
|
[Description("Circular buffer multiple-events")]
|
|
AutoCircularBufferMode = 4,
|
|
|
|
/// <summary>
|
|
/// recorder mode (start, trigger) rearm after data collected
|
|
/// </summary>
|
|
[Description("Recorder mode multiple-events")]
|
|
AutoRecorderMode = 5,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Immediate mode")] ImmediateMode = 0x06,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("High Power mode")] HighPowerRecorderMode = 0x07,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Low Power mode")] LowPowerRecorderMode = 0x08,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Continuous mode")] ContinuousRecorderMode = 0x09,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Hybrid mode")] HybridRecorderMode = 0x0A,
|
|
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Hybrid mode Multiple-Events")]
|
|
MultiHybridRecorderMode = 0x0B,
|
|
|
|
[Description("Active RAM")]
|
|
RAMActive = 0x0C, // slice6 only. Circular buffer in 32-KB Ram until trigger occur.
|
|
[Description("Active RAM Multiple-Events")]
|
|
MultipleEventRAMActive = 0x0D, // multiple event mode
|
|
|
|
/// <summary>
|
|
/// added S6A FM G0K9 (protocol 29)
|
|
/// 18090 Implement chapter 10 streaming while recording (in DTS format)
|
|
/// </summary>
|
|
[Description("Recorder and stream subsample")]
|
|
a14_NormalRecorderAndStreamSubSampleMode = 0x0E, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
[Description("Multiple event recorder and stream")]
|
|
a15_MultiRecorderAndStreamSubSampleMode = 0x0F, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
/// <summary>
|
|
/// added S6A FM G0K9 (protocol 29)
|
|
/// 18090 Implement chapter 10 streaming while recording (in DTS format)
|
|
/// </summary>
|
|
[Description("Circular buffer and stream subsample")]
|
|
a16_CircularBufferAndStreamSubSampleMode = 0x10, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
[Description("Multiple event circular buffer and stream")]
|
|
a17_MultiCircularBufferAndStreamSubSampleMode = 0x11, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
[Description("Hybrid recorder and stream")]
|
|
a18_HybridRecorderAndStreamSubSampleMode = 0x12, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
[Description("Multiple event hybrid and stream")]
|
|
a19_MultiHybridRecorderAndStreamSubSampleMode = 0x13, // S6A. Record and streaming realtime out to IRIG IP address.
|
|
/// <summary>
|
|
/// ???
|
|
/// </summary>
|
|
[Description("Streaming")] S6A_DeviceStreamingOnly = 0x14,
|
|
|
|
/// <summary>
|
|
/// circular buffer mode (constant recording, trigger) + UART recording
|
|
/// </summary>
|
|
[Description("Circular buffer + UART")] CircularBufferPlusUART = 0x15,
|
|
|
|
/// <summary>
|
|
/// recorder mode (start, trigger) + UART recording
|
|
/// </summary>
|
|
[Description("Recorder mode + UART")] RecorderModePlusUART = 0x16,
|
|
|
|
/* these display modes don't show up in the UI, they are just internal to the OBR-DDR*/
|
|
EthernetUDPRecordingCircularMode = 0x17,
|
|
EthernetUDPRecordingRecorderMode = 0x18,
|
|
MultiEthernetUDPRecordingCircularMode = 0x19,
|
|
MultiEthernetUDPRecordingRecorderMode = 0x1A,
|
|
EthernetHybridRecorderMode = 0x1B,
|
|
MultiEthernetHybridRecorderMode = 0x1C,
|
|
|
|
//The following are for TSR AIR only
|
|
[Description("Aerospace mode")]
|
|
Aerospace = 0x1D,
|
|
/// <summary>
|
|
/// active mode (start, trigger)
|
|
/// not sure why this is duplicated here [AutoActiveMode = AeroSpace] but both have the same value
|
|
/// I'll just preserve it for now since I want to avoid any side effects
|
|
/// </summary>
|
|
[Description("Active mode")] AutoActiveMode = Aerospace, // 0x1D,
|
|
[Description("AerospaceWithMotion mode")]
|
|
AerospaceWithMotion = 0x1E,
|
|
[Description("MultipleEventRecorderTriggerStart")]
|
|
MultipleEventRecorderTriggerStart = 0x1F,
|
|
[Description("Scheduled mode")]
|
|
Scheduled = 0x20,
|
|
[Description("Interval mode")]
|
|
Interval = 0x21,
|
|
[Description("Streaming mode")]
|
|
Streaming = 0x22,
|
|
//The preceding are for TSR AIR only
|
|
|
|
// Multiple Event + UART
|
|
[Description("Circular buffer + UART, multiple events")]
|
|
AutoCircularBufferPlusUART = 0x23,
|
|
[Description("Recorder mode + UART, multiple events")]
|
|
AutoRecorderModePlusUART = 0x24,
|
|
[Description("Continuous mode + UART, multiple events")]
|
|
ContinuousRecorderModePlusUART = 0x25,
|
|
[Description("Record on boot, multiple events")]
|
|
a26_MultiRecordOnBootDataMode = 0x26,
|
|
[Description("Record on boot + UART, multiple events")]
|
|
a28_MultiRecordOnBootAndUartDataMode = 0x28,
|
|
}
|
|
|
|
/// <summary>
|
|
/// All available 3 Axis assignments for the Slice 6 Bubble level tilt feature.
|
|
/// </summary>
|
|
public enum TiltAxes
|
|
{
|
|
[Description("+X+Y+Z")] XYZ = 0,
|
|
[Description("+X+Z+Y")] XZY = 1,
|
|
[Description("+Y+X+Z")] YXZ = 2,
|
|
[Description("+Y+Z+X")] YZX = 3,
|
|
[Description("+Z+X+Y")] ZXY = 4,
|
|
[Description("+Z+Y+X")] ZYX = 5,
|
|
[Description("+X+Y-Z")] XYIZ = 6,
|
|
[Description("+X+Z-Y")] XZIY = 7,
|
|
[Description("+Y+X-Z")] YXIZ = 8,
|
|
[Description("+Y+Z-X")] YZIX = 9,
|
|
[Description("+Z+X-Y")] ZXIY = 10,
|
|
[Description("+Z+Y-X")] ZYIX = 11,
|
|
[Description("+X-Y+Z")] XIYZ = 12,
|
|
[Description("+X-Z+Y")] XIZY = 13,
|
|
[Description("+Y-X+Z")] YIXZ = 14,
|
|
[Description("+Y-Z+X")] YIZX = 15,
|
|
[Description("+Z-X+Y")] ZIXY = 16,
|
|
[Description("+Z-Y+X")] ZIYX = 17,
|
|
[Description("+X-Y-Z")] XIYIZ = 18,
|
|
[Description("+X-Z-Y")] XIZIY = 19,
|
|
[Description("+Y-X-Z")] YIXIZ = 20,
|
|
[Description("+Y-Z-X")] YIZIX = 21,
|
|
[Description("+Z-X-Y")] ZIXIY = 22,
|
|
[Description("+Z-Y-X")] ZIYIX = 23,
|
|
[Description("-X+Y+Z")] IXYZ = 24,
|
|
[Description("-X+Z+Y")] IXZY = 25,
|
|
[Description("-Y+X+Z")] IYXZ = 26,
|
|
[Description("-Y+Z+X")] IYZX = 27,
|
|
[Description("-Z+X+Y")] IZXY = 28,
|
|
[Description("-Z+Y+X")] IZYX = 29,
|
|
[Description("-X+Y-Z")] IXYIZ = 30,
|
|
[Description("-X+Z-Y")] IXZIY = 31,
|
|
[Description("-Y+X-Z")] IYXIZ = 32,
|
|
[Description("-Y+Z-X")] IYZIX = 33,
|
|
[Description("-Z+X-Y")] IZXIY = 34,
|
|
[Description("-Z+Y-X")] IZYIX = 35,
|
|
[Description("-X-Y+Z")] IXIYZ = 36,
|
|
[Description("-X-Z+Y")] IXIZY = 37,
|
|
[Description("-Y-X+Z")] IYIXZ = 38,
|
|
[Description("-Y-Z+X")] IYIZX = 39,
|
|
[Description("-Z-X+Y")] IZIXY = 40,
|
|
[Description("-Z-Y+X")] IZIYX = 41,
|
|
[Description("-X-Y-Z")] IXIYIZ = 42,
|
|
[Description("-X-Z-Y")] IXIZIY = 43,
|
|
[Description("-Y-X-Z")] IYIXIZ = 44,
|
|
[Description("-Y-Z-X")] IYIZIX = 45,
|
|
[Description("-Z-X-Y")] IZIXIY = 46,
|
|
[Description("-Z-Y-X")] IZIYIX = 47
|
|
}
|
|
/// <summary>
|
|
/// When the DAS unit arms each channel will be handled based on this mode.
|
|
/// </summary>
|
|
public enum ConfigMode
|
|
{
|
|
/// <summary>
|
|
/// This channel is not part of Data Acquisition in this test.
|
|
/// </summary>
|
|
Disabled,
|
|
|
|
/// <summary>
|
|
/// Channel is part of current test/event and it's input WILL be sampled on recording.
|
|
/// </summary>
|
|
Normal,
|
|
|
|
/// <summary>
|
|
/// This channel is only used for 'Dummy' arming and recording and should not be downloaded.
|
|
/// </summary>
|
|
DummyArm,
|
|
|
|
/// <summary>
|
|
/// This channel is only used for clock recording and should not be downloaded to normal .chn files.
|
|
/// </summary>
|
|
Clock,
|
|
|
|
/// <summary>
|
|
/// This channel is only used for UART recording and should not be downloaded to normal .chn files.
|
|
/// </summary>
|
|
UART,
|
|
|
|
/// <summary>
|
|
/// This channel is only used for streaming out and should not be downloaded to normal .chn files.
|
|
/// </summary>
|
|
StreamOut,
|
|
|
|
/// <summary>
|
|
/// This channel is only used for streaming in and should not be downloaded to normal .chn files.
|
|
/// </summary>
|
|
StreamIn,
|
|
}
|
|
/// <summary>
|
|
/// Determines known device type from udp response
|
|
/// This is a bitwise device list that is hardcoded on the fw side and part of the UDP brodcast response back to the host
|
|
///
|
|
/// NextOne is reserved for the next device type
|
|
/// </summary>
|
|
public enum MultiCastDeviceClasses
|
|
{
|
|
Unknown = 0,
|
|
Slice6 = 1 << 0,
|
|
SDB = 1 << 1,
|
|
ECM = 1 << 2,
|
|
S6DB = 1 << 3,
|
|
Slice6Air = 1 << 4,
|
|
PowerPro = 1 << 5,
|
|
TsrAir = 1 << 6,
|
|
S6DB3 = 1 << 7,
|
|
S6FALCON = 1 << 8,
|
|
SPDB = 1 << 9,
|
|
|
|
NextOne = 1 << 10,
|
|
Any = 0xFFFF,
|
|
};
|
|
public enum ProtocolLimitedCommands
|
|
{
|
|
DiangosShuntDAC,
|
|
QueryMSP430Firmware,
|
|
MultipleAndHybridEvents,
|
|
AutoArm,
|
|
FlashCardInfo,
|
|
Arm,
|
|
OnOverride,
|
|
EnableFaultChecking,
|
|
OMAP_GPIO,
|
|
VoltageInsertion,
|
|
SetDefaultMIF,
|
|
StackFirmwareUpdate,
|
|
FileData,
|
|
StackSensors,
|
|
BaseSystemTime,
|
|
PhysicalStartAddress,
|
|
TestCommunication,
|
|
StackLowPowerMode,
|
|
StackChannelTypeConfiguration,
|
|
SetRealtimeSampleRate,
|
|
SLICE2_OneWireID,
|
|
QueryBatteryVoltage,
|
|
HardwareRevision,
|
|
HardwareConfiguration,
|
|
ProgramStackChannels,
|
|
EventFaultFlags,
|
|
EventArmAttempts,
|
|
QueryActualSampleRateImmediate,
|
|
InitHardwareInputLines,
|
|
VoltageSysAttributes,
|
|
DiagnosticTwoVoltExcitation,
|
|
ExcitationLevel,
|
|
MultipleEvents,
|
|
LevelTrigger,
|
|
Diagnostics,
|
|
AttributeStoreBlocks,
|
|
QueryArmAndTriggerStatus_VoltageReadings,
|
|
MaxEvents,
|
|
AutoArmDiagnosticDelay,
|
|
StackChannelAutoArmDiagLevel,
|
|
FlashClear,
|
|
DiagnosticsMode,
|
|
MultipleSamplesRealtime,
|
|
ResetAttributeStore,
|
|
IgnoreShortedStartEvent,
|
|
BaseCalibrationDate,
|
|
PTPTimestamp,
|
|
QueryArmAndTriggerStatus_TimeLeftInArm,
|
|
MeasureInternalOffset,
|
|
MeasureInternalOffsetSwitches,
|
|
QueryBatterySOC,
|
|
StartRecDelayInSecond,
|
|
QueryTiltSensorData,
|
|
InSliceTiltSensorADCPre,
|
|
MeasureBaseDiagnosticChannel,
|
|
InSliceTemperatureCPre,
|
|
StartRealtimeStream,
|
|
HalfBridgeSigPlusSupport,
|
|
DownloadStreaming,
|
|
IEPE,
|
|
QueryEthernetMacTable,
|
|
QueryClockSyncStatus,
|
|
SetClockSyncConfig,
|
|
UDPRealtimeStream,
|
|
QueryUARTDownload,
|
|
GetUARTSettings,
|
|
SetUARTSettings,
|
|
AutoArmRepeatEnable,
|
|
MeasurePowerProAllDiagnosticChannel,
|
|
SetDSPFilterSettings,
|
|
PTPSyncStatus,
|
|
QueryTempLogFile,
|
|
QueryExternalTiltInfo,
|
|
QueryStackActualSampleRateImmediate,
|
|
RecordAndStreamSubSample,
|
|
//17583 Monitor Test UI
|
|
AutoArmUDPSetting,
|
|
//18294 Implement Bridge AC/DC coupling (fw update dependent)
|
|
StackChannelBridgeACCouplerEnable,
|
|
GenerateEvent,
|
|
MaxEventsPossible,
|
|
AdcClockSource,
|
|
SliceBusEnabled,
|
|
QATSCurrentAndMaxSample,
|
|
DBTiltSensor,
|
|
RemoveLeapSeconds,
|
|
ADCSamplesPerPacket,
|
|
DisableStreamingFeature,
|
|
//30513 PTP Domain ID
|
|
PTPDomainID,
|
|
ActiveRAM,
|
|
RecordOnBoot
|
|
}
|
|
/// <summary>
|
|
/// possible command status
|
|
/// this appears to be common across all commands
|
|
/// </summary>
|
|
public enum CommandStatus
|
|
{
|
|
#pragma warning disable 1591 //disable xml warnings for all the enum values
|
|
StatusNoError = 0x00,
|
|
StatusInvalidParameter,
|
|
StatusInvalidParameterLength,
|
|
StatusInvalidCommandType,
|
|
StatusInvalidCommand,
|
|
StatusInvalidCRC,
|
|
StatusInvalidModeForCommand,
|
|
StatusUnimplemented,
|
|
StatusInvalidReceivedHeaderCRC,
|
|
StatusInvalidIDForCommand,
|
|
StatusInvalidPacket,
|
|
StatusPacketNotAvailableToReceive,
|
|
StatusPacketNotAvailableToSend,
|
|
|
|
StatusFlashEraseError = 0x10,
|
|
StatusFlashWriteError,
|
|
StatusFlashInvalidBlockCRC,
|
|
StatusFlashInvalidImageCRC,
|
|
|
|
StatusAttributeInvalidNumber = 0x20,
|
|
StatusAttributeSetError,
|
|
StatusAttributeBackupSetError,
|
|
StatusAttributeInvalidBuffer,
|
|
StatusAttributeNotRegistered,
|
|
StatusAttributeRegisteredCannotOverwrite,
|
|
StatusAttributeReadError,
|
|
StatusAttributeBackupReadError,
|
|
StatusAttributeInvalidLength,
|
|
StatusAttributeTypeMismatch,
|
|
StatusAttributeTypeNotInternallyImplemented = 0x2A,
|
|
|
|
StatusArmInvalidSampleRate = 0x30,
|
|
StatusArmInvalidEventLength = 0x31,
|
|
StatusArmInvalidArmMode = 0x32,
|
|
StatusArmUnimplementedArmMode = 0x33,
|
|
StatusArmEventNumberTooLarge = 0x34,
|
|
StatusArmMemoryFull = 0x35,
|
|
StatusArmInvalidSliceCount = 0x36,
|
|
StatusArmShortedStartRecordInput = 0x37,
|
|
StatusArmShortedTriggerInput = 0x38,
|
|
StatusArmInvalidPretriggerSamplesRequested = 0x39,
|
|
StatusArmShortedStartAndTrigger = 0x3A,
|
|
StatusArmEventUncompleted = 0x3B, /** Event completed without end block. Must be interrupted! **/
|
|
StatusArmSafeSwitchUnplugged = 0x3C, /** stop arming if safety switch is not connected. **/
|
|
StatusArmSquibResistanceFault = 0x3D, /** stop if resistance check fails . **/
|
|
StatusArmHardwareFault = 0x3F,
|
|
|
|
StatusSDUnableToStartMultipleBlockWrite = 0x40,
|
|
StatusSDUnableToFlushWriteBlock,
|
|
StatusSDUnableToStartMultipleBlockRead,
|
|
StatusSDUnexpectedAmountOfDataReadOrWritten,
|
|
StatusSDUnableToResetCard,
|
|
StatusSDBlockWriteCRCError = 0x45, /** The card reported a CRC error on a block write */
|
|
StatusSDWriteTimeout = 0x46,
|
|
StatusSDReadTimeout = 0x47,
|
|
|
|
StatusSwitchNumberInvalid = 0x50,
|
|
StatusSwitchSettingInvalid = 0x51,
|
|
StatusSwitchChannelInvalid = 0x52,
|
|
|
|
StatusDownloadFirstSampleGreaterThanLastSample = 0x60,
|
|
StatusFirstSampleGreaterThanTotalSamples,
|
|
StatusDownloadEventHasNoSamples,
|
|
StatusDownloadInvalidChannelRequested,
|
|
StatusDownloadInvalidEventRequested,
|
|
|
|
StatusMemoryNullPointerError = 0x70,
|
|
|
|
StatusTestRecorderFull = 0x80,
|
|
StatusTestRecorderEmpty,
|
|
|
|
StatusSPIInvalidMode = 0x90,
|
|
StatusSPIInvalidModeForWrite,
|
|
|
|
StatusSlicebusInvalidHeaderCRC = 0xA0,
|
|
StatusSlicebusInvalidDataCRC,
|
|
StatusSlicebusNullDescriptor,
|
|
StatusSlicebusNotImplemented,
|
|
StatusSlicebusNoResponse,
|
|
StatusSlicebusNullCommandBuffer,
|
|
StatusSlicebusCommandBufferTooShort,
|
|
|
|
StatusSetupRequestedSensorRangeTooSmall = 0xB0,
|
|
StatusSetupInvalidStackChannel,
|
|
StatusSetupInvalidChannelRequested,
|
|
StatusSetupInconsistentChannelCountFound,
|
|
StatusSetupNoShuntTargetsSet,
|
|
StatusSetupNoBridgeResistancesSet,
|
|
StatusSetupChannelDoesNotSupportShunt,
|
|
StatusSetupShuntDACOutputExceeded,
|
|
StatusSetupRequestedSensorRangeTooLarge,
|
|
StatusSetupInvalidExciteLevel = 0xB9,
|
|
StatusSetupI2CWriteFail = 0xBA,
|
|
StatusSetupI2CReadFail = 0xBB,
|
|
|
|
StatusSetupCALDACOutputExceeded = 0xC0,
|
|
StatusNoResponse
|
|
#pragma warning restore 1591
|
|
};
|
|
/// <summary>
|
|
/// max amount of time to wait for UDP thread to rejoin
|
|
/// </summary>
|
|
public static int UDP_RECEIVE_TIMEOUT = 10000;
|
|
/// <summary>
|
|
/// this error code indicates that a socket is not connected
|
|
/// 15575 No notification if unplug comm cable during downloading on G5
|
|
/// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
|
|
/// </summary>
|
|
public const int WSAEISCONN = 0X2748;
|
|
/// <summary>
|
|
/// this value signifies an uninitialized date time [date time not set] as opposed to an invalid date time
|
|
/// [feature not supported]
|
|
/// 15524 DAS "First Use Date"
|
|
/// </summary>
|
|
public static readonly DateTime FIRST_USE_DATE_NOT_SET = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
}
|
|
|
|
public static class RecordingModeExtensions
|
|
{
|
|
private static readonly HashSet<RecordingModes> _recordingModesUsingTestLength = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.Recorder,
|
|
RecordingModes.RecorderPlusUART,
|
|
RecordingModes.MultipleEventRecorder,
|
|
RecordingModes.MultipleEventRecorderPlusUART,
|
|
RecordingModes.RecorderAndStreamSubSample,
|
|
RecordingModes.Scheduled,
|
|
RecordingModes.Interval
|
|
};
|
|
public static bool UsesTestLength(RecordingModes mode)
|
|
{
|
|
return _recordingModesUsingTestLength.Contains(mode);
|
|
}
|
|
/// <summary>
|
|
/// returns true if the recording mode is only for TSR AIR
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsTSRAIROnlyRecordingMode(RecordingModes mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case RecordingModes.Active:
|
|
case RecordingModes.MultipleEventActive:
|
|
case RecordingModes.Scheduled:
|
|
case RecordingModes.Interval:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// returns true if the recording mode is allowed on a TSR AIR
|
|
/// </summary>
|
|
public static bool IsTSRAirRecordingMode(RecordingModes mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case RecordingModes.Active:
|
|
case RecordingModes.MultipleEventActive:
|
|
case RecordingModes.Scheduled:
|
|
case RecordingModes.Interval:
|
|
case RecordingModes.Streaming:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
public static bool SupportsT0Correction(DFConstantsAndEnums.RecordingMode recordingMode)
|
|
{
|
|
if (IsACircularBufferMode(recordingMode)) { return true; }
|
|
if (IsAHybridRecorderMode(recordingMode)) { return true; }
|
|
return false;
|
|
}
|
|
private static readonly IReadOnlyDictionary<DFConstantsAndEnums.RecordingMode, RecordingModes> _altToLookup =
|
|
new Dictionary<DFConstantsAndEnums.RecordingMode, RecordingModes>()
|
|
{
|
|
{DFConstantsAndEnums.RecordingMode.MultiHybridRecorderMode, RecordingModes.MultipleEventHybridRecorder },
|
|
{DFConstantsAndEnums.RecordingMode.AutoRecorderMode, RecordingModes.MultipleEventRecorder},
|
|
{DFConstantsAndEnums.RecordingMode.Interval, RecordingModes.Interval},
|
|
{DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode, RecordingModes.MultipleEventCircularBuffer},
|
|
{DFConstantsAndEnums.RecordingMode.AutoActiveMode, RecordingModes.MultipleEventActive}
|
|
};
|
|
private static readonly IReadOnlyDictionary<DFConstantsAndEnums.RecordingMode, RecordingModes> _toLookup =
|
|
new Dictionary<DFConstantsAndEnums.RecordingMode, RecordingModes>()
|
|
{
|
|
{ DFConstantsAndEnums.RecordingMode.CircularBuffer, RecordingModes.CircularBuffer },
|
|
{ DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode, RecordingModes.CircularBufferAndStreamSubSample},
|
|
{ DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART, RecordingModes.CircularBufferPlusUART},
|
|
{ DFConstantsAndEnums.RecordingMode.RecorderMode, RecordingModes.Recorder},
|
|
{ DFConstantsAndEnums.RecordingMode.RecorderModePlusUART, RecordingModes.RecorderPlusUART},
|
|
{ DFConstantsAndEnums.RecordingMode.ContinuousRecorderMode, RecordingModes.ContinuousRecorder},
|
|
{ DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode, RecordingModes.CircularBuffer},
|
|
{ DFConstantsAndEnums.RecordingMode.AutoRecorderMode, RecordingModes.Recorder},
|
|
{ DFConstantsAndEnums.RecordingMode.MultiHybridRecorderMode, RecordingModes.HybridRecorder},
|
|
{ DFConstantsAndEnums.RecordingMode.S6A_DeviceStreamingOnly, RecordingModes.S6A_DeviceStreamingOnly},
|
|
{ DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode, RecordingModes.RecorderAndStreamSubSample},
|
|
{ DFConstantsAndEnums.RecordingMode.AutoActiveMode, RecordingModes.Active},
|
|
{ DFConstantsAndEnums.RecordingMode.Streaming, RecordingModes.Streaming},
|
|
{ DFConstantsAndEnums.RecordingMode.Scheduled, RecordingModes.Scheduled},
|
|
{ DFConstantsAndEnums.RecordingMode.Interval, RecordingModes.Scheduled},
|
|
{ DFConstantsAndEnums.RecordingMode.MultipleEventRecorderTriggerStart, RecordingModes.Active},
|
|
{ DFConstantsAndEnums.RecordingMode.AerospaceWithMotion, RecordingModes.MultipleEventActive },
|
|
{ DFConstantsAndEnums.RecordingMode.HybridRecorderMode, RecordingModes.HybridRecorder },
|
|
{ DFConstantsAndEnums.RecordingMode.AutoCircularBufferPlusUART, RecordingModes.MultipleEventCircularBufferPlusUART },
|
|
{ DFConstantsAndEnums.RecordingMode.AutoRecorderModePlusUART, RecordingModes.MultipleEventRecorderPlusUART },
|
|
{ DFConstantsAndEnums.RecordingMode.ContinuousRecorderModePlusUART, RecordingModes.ContinuousRecorderPlusUART },
|
|
{ DFConstantsAndEnums.RecordingMode.RAMActive, RecordingModes.RAMActive },
|
|
{ DFConstantsAndEnums.RecordingMode.MultipleEventRAMActive, RecordingModes.MultipleEventRAMActive },
|
|
{ DFConstantsAndEnums.RecordingMode.a26_MultiRecordOnBootDataMode, RecordingModes.RecordOnBoot },
|
|
{ DFConstantsAndEnums.RecordingMode.a28_MultiRecordOnBootAndUartDataMode, RecordingModes.RecordOnBootPlusUART },
|
|
{ DFConstantsAndEnums.RecordingMode.a18_HybridRecorderAndStreamSubSampleMode, RecordingModes.HybridAndStream },
|
|
{ DFConstantsAndEnums.RecordingMode.a19_MultiHybridRecorderAndStreamSubSampleMode, RecordingModes.MultipleEventHybridAndStream },
|
|
{ DFConstantsAndEnums.RecordingMode.a15_MultiRecorderAndStreamSubSampleMode, RecordingModes.MultipleEventRecorderAndStream },
|
|
{ DFConstantsAndEnums.RecordingMode.a17_MultiCircularBufferAndStreamSubSampleMode, RecordingModes.MultipleEventCircularBufferAndStream }
|
|
};
|
|
/// <summary>
|
|
/// map from DFConstantAndEnums.RecordingMode to RecordingModes
|
|
/// This was an alternate form of mapping found in quick build ...
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static RecordingModes ToRecordingModesAlt(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return _altToLookup.ContainsKey(mode) ? _altToLookup[mode] : ToRecordingModes(mode);
|
|
}
|
|
public static RecordingModes ToRecordingModes(DFConstantsAndEnums.RecordingMode recordingMode)
|
|
{
|
|
return _toLookup.ContainsKey(recordingMode) ? _toLookup[recordingMode] : RecordingModes.CircularBuffer;
|
|
}
|
|
|
|
private static readonly IReadOnlyDictionary<RecordingModes, DFConstantsAndEnums.RecordingMode> _fromLookup =
|
|
new Dictionary<RecordingModes, DFConstantsAndEnums.RecordingMode>()
|
|
{
|
|
{ RecordingModes.CircularBuffer, DFConstantsAndEnums.RecordingMode.CircularBuffer},
|
|
{ RecordingModes.CircularBufferAndStreamSubSample, DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode},
|
|
{ RecordingModes.CircularBufferPlusUART, DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART},
|
|
{ RecordingModes.Recorder, DFConstantsAndEnums.RecordingMode.RecorderMode},
|
|
{ RecordingModes.RecorderPlusUART, DFConstantsAndEnums.RecordingMode.RecorderModePlusUART},
|
|
{ RecordingModes.HybridRecorder, DFConstantsAndEnums.RecordingMode.HybridRecorderMode},
|
|
{ RecordingModes.ContinuousRecorder, DFConstantsAndEnums.RecordingMode.ContinuousRecorderMode},
|
|
{ RecordingModes.ContinuousRecorderPlusUART, DFConstantsAndEnums.RecordingMode.ContinuousRecorderModePlusUART},
|
|
{ RecordingModes.MultipleEventCircularBuffer, DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode},
|
|
{ RecordingModes.MultipleEventCircularBufferPlusUART, DFConstantsAndEnums.RecordingMode.AutoCircularBufferPlusUART},
|
|
{ RecordingModes.MultipleEventRecorder, DFConstantsAndEnums.RecordingMode.AutoRecorderMode},
|
|
{ RecordingModes.MultipleEventRecorderPlusUART, DFConstantsAndEnums.RecordingMode.AutoRecorderModePlusUART},
|
|
{ RecordingModes.MultipleEventHybridRecorder, DFConstantsAndEnums.RecordingMode.MultiHybridRecorderMode},
|
|
{ RecordingModes.S6A_DeviceStreamingOnly, DFConstantsAndEnums.RecordingMode.S6A_DeviceStreamingOnly},
|
|
{ RecordingModes.RecorderAndStreamSubSample, DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode},
|
|
{ RecordingModes.MultipleEventActive, DFConstantsAndEnums.RecordingMode.AutoActiveMode},
|
|
{ RecordingModes.Streaming, DFConstantsAndEnums.RecordingMode.Streaming},
|
|
{ RecordingModes.Scheduled, DFConstantsAndEnums.RecordingMode.Scheduled},
|
|
{ RecordingModes.Interval, DFConstantsAndEnums.RecordingMode.Interval},
|
|
{ RecordingModes.RAMActive, DFConstantsAndEnums.RecordingMode.RAMActive },
|
|
{ RecordingModes.MultipleEventRAMActive, DFConstantsAndEnums.RecordingMode.MultipleEventRAMActive },
|
|
{ RecordingModes.RecordOnBoot, DFConstantsAndEnums.RecordingMode.a26_MultiRecordOnBootDataMode },
|
|
{ RecordingModes.RecordOnBootPlusUART, DFConstantsAndEnums.RecordingMode.a28_MultiRecordOnBootAndUartDataMode },
|
|
{ RecordingModes.HybridAndStream, DFConstantsAndEnums.RecordingMode.a18_HybridRecorderAndStreamSubSampleMode },
|
|
{ RecordingModes.MultipleEventHybridAndStream, DFConstantsAndEnums.RecordingMode.a19_MultiHybridRecorderAndStreamSubSampleMode },
|
|
{ RecordingModes.MultipleEventCircularBufferAndStream, DFConstantsAndEnums.RecordingMode.a17_MultiCircularBufferAndStreamSubSampleMode },
|
|
{ RecordingModes.MultipleEventRecorderAndStream, DFConstantsAndEnums.RecordingMode.a15_MultiRecorderAndStreamSubSampleMode },
|
|
|
|
};
|
|
|
|
public static DFConstantsAndEnums.RecordingMode FromRecordingModes(
|
|
this RecordingModes recordingMode)
|
|
{
|
|
return _fromLookup.ContainsKey(recordingMode)?_fromLookup[recordingMode] : DFConstantsAndEnums.RecordingMode.CircularBuffer;
|
|
}
|
|
|
|
|
|
private static readonly HashSet<DFConstantsAndEnums.RecordingMode> _circularBufferModes = new HashSet<DFConstantsAndEnums.RecordingMode>()
|
|
{
|
|
DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode,
|
|
DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode,
|
|
DFConstantsAndEnums.RecordingMode.CircularBuffer,
|
|
DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART,
|
|
DFConstantsAndEnums.RecordingMode.AutoCircularBufferPlusUART,
|
|
DFConstantsAndEnums.RecordingMode.AerospaceWithMotion,
|
|
DFConstantsAndEnums.RecordingMode.AutoActiveMode,
|
|
DFConstantsAndEnums.RecordingMode.RAMActive,
|
|
DFConstantsAndEnums.RecordingMode.MultipleEventRAMActive
|
|
};
|
|
|
|
/// <summary>
|
|
/// returns true if mode is a circular buffer mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsACircularBufferMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return _circularBufferModes.Contains(mode);
|
|
}
|
|
private static readonly HashSet<RecordingModes> _nonAutoArmModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.Active,
|
|
RecordingModes.MultipleEventActive,
|
|
RecordingModes.Scheduled,
|
|
RecordingModes.Interval,
|
|
RecordingModes.Streaming //Not really needed since Auto-Arm and Streaming checkboxes are mutually exclusive
|
|
};
|
|
/// <summary>
|
|
/// returns true if recording mode supports AutoArm, false otherwise
|
|
/// </summary>
|
|
/// <param name="mode">recording mode to check</param>
|
|
/// <returns>true if mode can be used with auto-arm</returns>
|
|
public static bool DoesModeSupportAutoArm(RecordingModes mode)
|
|
{
|
|
return !_nonAutoArmModes.Contains(mode);
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns true if mode is a circular buffer mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsACircularBufferMode(RecordingModes mode)
|
|
{
|
|
return IsACircularBufferMode(FromRecordingModes(mode));
|
|
}
|
|
private static readonly HashSet<DFConstantsAndEnums.RecordingMode> _recorderModes = new HashSet<DFConstantsAndEnums.RecordingMode>()
|
|
{
|
|
DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode,
|
|
DFConstantsAndEnums.RecordingMode.AutoRecorderMode,
|
|
DFConstantsAndEnums.RecordingMode.RecorderMode,
|
|
DFConstantsAndEnums.RecordingMode.RecorderModePlusUART,
|
|
DFConstantsAndEnums.RecordingMode.AutoRecorderModePlusUART
|
|
};
|
|
/// <summary>
|
|
/// returns true if the mode is a recorder mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsARecorderMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return _recorderModes.Contains(mode);
|
|
}
|
|
/// <summary>
|
|
/// returns true if mode is a recorder mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsARecorderMode(RecordingModes mode)
|
|
{
|
|
return IsARecorderMode(FromRecordingModes(mode));
|
|
}
|
|
/// <summary>
|
|
/// returns true if the mode is a hybrid recorder mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAHybridRecorderMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case DFConstantsAndEnums.RecordingMode.MultiHybridRecorderMode:
|
|
case DFConstantsAndEnums.RecordingMode.HybridRecorderMode:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// returns true if mode is a hybrid recorder mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAHybridRecorderMode(RecordingModes mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case RecordingModes.HybridRecorder:
|
|
case RecordingModes.MultipleEventHybridRecorder:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
private static readonly HashSet<RecordingModes> _multipleEventModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.MultipleEventActive,
|
|
RecordingModes.MultipleEventCircularBuffer,
|
|
RecordingModes.MultipleEventRecorder,
|
|
RecordingModes.ContinuousRecorder,
|
|
RecordingModes.MultipleEventCircularBufferPlusUART,
|
|
RecordingModes.MultipleEventRecorderPlusUART,
|
|
RecordingModes.ContinuousRecorderPlusUART,
|
|
RecordingModes.MultipleEventHybridRecorder,
|
|
RecordingModes.Interval,
|
|
RecordingModes.MultipleEventRAMActive,
|
|
RecordingModes.RecordOnBoot,
|
|
RecordingModes.RecordOnBootPlusUART,
|
|
RecordingModes.MultipleEventCircularBufferAndStream,
|
|
RecordingModes.MultipleEventHybridAndStream,
|
|
RecordingModes.MultipleEventRecorderAndStream
|
|
};
|
|
/// <summary>
|
|
/// returns true if recording mode is a form of multiple event recording
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAMultipleEvent(RecordingModes mode)
|
|
{
|
|
return _multipleEventModes.Contains(mode);
|
|
}
|
|
|
|
private static readonly HashSet<RecordingModes> _multipleEventSupportingModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.Active,
|
|
RecordingModes.MultipleEventActive,
|
|
RecordingModes.CircularBuffer,
|
|
RecordingModes.CircularBufferPlusUART,
|
|
RecordingModes.MultipleEventCircularBuffer,
|
|
RecordingModes.MultipleEventCircularBufferPlusUART,
|
|
RecordingModes.Recorder,
|
|
RecordingModes.RecorderPlusUART,
|
|
RecordingModes.MultipleEventRecorder,
|
|
RecordingModes.MultipleEventRecorderPlusUART,
|
|
RecordingModes.HybridRecorder,
|
|
RecordingModes.MultipleEventHybridRecorder,
|
|
RecordingModes.ContinuousRecorder,
|
|
RecordingModes.ContinuousRecorderPlusUART,
|
|
RecordingModes.Scheduled,
|
|
RecordingModes.Interval,
|
|
RecordingModes.RAMActive,
|
|
RecordingModes.MultipleEventRAMActive,
|
|
RecordingModes.RecordOnBoot,
|
|
RecordingModes.RecordOnBootPlusUART,
|
|
RecordingModes.RecorderAndStreamSubSample,
|
|
RecordingModes.CircularBufferAndStreamSubSample,
|
|
RecordingModes.HybridAndStream
|
|
};
|
|
/// <summary>
|
|
/// returns true if recording mode is a form of multiple event recording
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool CanBeAMultipleEvent(RecordingModes mode)
|
|
{
|
|
return _multipleEventSupportingModes.Contains(mode);
|
|
}
|
|
private static readonly HashSet<RecordingModes> _streamModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.CircularBufferAndStreamSubSample,
|
|
RecordingModes.RecorderAndStreamSubSample,
|
|
RecordingModes.S6A_DeviceStreamingOnly,
|
|
RecordingModes.Streaming,
|
|
RecordingModes.HybridAndStream,
|
|
RecordingModes.MultipleEventCircularBufferAndStream,
|
|
RecordingModes.MultipleEventRecorderAndStream,
|
|
RecordingModes.MultipleEventHybridAndStream
|
|
};
|
|
/// <summary>
|
|
/// returns true if the mode is a recording mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAStreamMode(RecordingModes mode)
|
|
{
|
|
return _streamModes.Contains(mode);
|
|
}
|
|
/// <summary>
|
|
/// returns true if either the mode is a recording mode or it will be set to a recording mode shortly
|
|
/// </summary>
|
|
/// <param name="recordingMode"></param>
|
|
/// <param name="streaming"></param>
|
|
/// <returns></returns>
|
|
//29609 At times, especially when Adding a new Test Setup, the recording mode may not yet have been set to the proper streaming value, so this checks DoStreaming also
|
|
public static bool TestWillBeStreaming(RecordingModes recordingMode, bool streaming)
|
|
{
|
|
return IsAStreamMode(recordingMode) || streaming;
|
|
}
|
|
/// <summary>
|
|
/// returns true if the mode is a recording mode
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAStreamMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return IsAStreamMode(ToRecordingModes(mode));
|
|
}
|
|
private static HashSet<RecordingModes> _uartModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.CircularBufferPlusUART,
|
|
RecordingModes.RecorderPlusUART,
|
|
RecordingModes.MultipleEventCircularBufferPlusUART,
|
|
RecordingModes.MultipleEventRecorderPlusUART,
|
|
RecordingModes.ContinuousRecorderPlusUART,
|
|
RecordingModes.RecordOnBootPlusUART
|
|
};
|
|
/// <summary>
|
|
/// returns true if the mode is a recording mode w/uart
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAUartMode(RecordingModes mode)
|
|
{
|
|
return _uartModes.Contains(mode);
|
|
}
|
|
/// <summary>
|
|
/// returns true if the mode is a recording mode w/uart
|
|
/// </summary>
|
|
/// <param name="mode"></param>
|
|
/// <returns></returns>
|
|
public static bool IsAUartMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return IsAUartMode(ToRecordingModes(mode));
|
|
}
|
|
|
|
|
|
private static HashSet<RecordingModes> _openEndedModes = new HashSet<RecordingModes>()
|
|
{
|
|
RecordingModes.ContinuousRecorder,
|
|
RecordingModes.ContinuousRecorderPlusUART,
|
|
RecordingModes.RecordOnBoot,
|
|
RecordingModes.RecordOnBootPlusUART
|
|
};
|
|
/// <summary>
|
|
/// returns true if the recording mode is open-ended (i.e. has no set recording time or post-trigger time)
|
|
/// </summary>
|
|
public static bool IsAnOpenEndedRecordingMode(RecordingModes mode)
|
|
{
|
|
return _openEndedModes.Contains(mode);
|
|
}
|
|
/// <summary>
|
|
/// returns true if the recording mode is open-ended (i.e. has no set recording time or post-trigger time)
|
|
/// </summary>
|
|
public static bool IsAnOpenEndedRecordingMode(DFConstantsAndEnums.RecordingMode mode)
|
|
{
|
|
return IsAnOpenEndedRecordingMode(ToRecordingModes(mode));
|
|
}
|
|
}
|
|
public enum QATSExtendedFault
|
|
{
|
|
EXT_FAULT_TYPE_NONE = 0,
|
|
|
|
//S6DB & S6DB-3
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_1_DROPPED = 1 << 0,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_2_DROPPED = 1 << 1,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_3_DROPPED = 1 << 2,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_4_DROPPED = 1 << 3,
|
|
|
|
EXT_FAULT_TYPE_STATUSLINE_PWRHUB__DROPPED = 1 << 4,
|
|
|
|
//Skip bit 5 for reserve.
|
|
//Hardware Detection Faults
|
|
//TSAIR
|
|
FAULT_FLAG__DEVICE = 1 << 6,
|
|
FAULT_FLAG__DEVICE__KX134 = 1 << 7,
|
|
FAULT_FLAG__DEVICE__ADXL373 = 1 << 8,
|
|
|
|
FAULT_FLAG__DEVICE__BMI270 = 1 << 9,
|
|
FAULT_FLAG__DEVICE__FRAM = 1 << 10,
|
|
FAULT_FLAG__DEVICE__BMI280 = 1 << 11,
|
|
FAULT_FLAG__DEVICE__MAGNET_SENSOR = 1 << 12,
|
|
|
|
FAULT_FLAG__DEVICE__RTC = 1 << 13,
|
|
FAULT_FLAG__DEVICE__KSZ = 1 << 14,
|
|
FAULT_FLAG__DEVICE__FPGA = 1 << 15,
|
|
FAULT_FLAG__DEVICE__NAND = 1 << 16,
|
|
|
|
FAULT_FLAG__DEVICE__FUEL_GAUGE = 1 << 17,
|
|
|
|
FAULT_FLAG__CONDITION__FRAM_WAKEUP = 1 << 18,
|
|
FAULT_FLAG__CONDITION__RTOS = 1 << 19,
|
|
FAULT_FLAG__CONDITION__NETWORK_CONFIG = 1 << 20,
|
|
FAULT_FLAG__CONDITION__DHCP_FAIL = 1 << 21,
|
|
|
|
//SPDB
|
|
EXT_FAULT_TYPE_STATUSLINE_SUPER_CAP = 1 << 22,
|
|
EXT_FAULT_TYPE_STATUSLINE_TEMPERATURE = 1 << 23,
|
|
|
|
//S6DB & S6DB-3
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_1_PG = 1 << 24,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_2_PG = 1 << 25,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_3_PG = 1 << 26,
|
|
EXT_FAULT_TYPE_STATUSLINE_PORT_4_PG = 1 << 27,
|
|
|
|
/* bit_31:22 = reserves */
|
|
EXT_FAULT_TYPE_MAX = 1 << 31, // limit to 32-bit
|
|
};
|
|
|
|
/// <summary>
|
|
/// describes different TMAT templates that are used for creating TMATs entry
|
|
/// </summary>
|
|
public enum TMAT_TEMPLATES
|
|
{
|
|
[StringMetaDataAttr("S6ATMTTemplate_PCM.tmt")]
|
|
S6Air_PCM,
|
|
[StringMetaDataAttr("S6ATMTTemplate_ANALOG.tmt")]
|
|
S6Air_ANALOG,
|
|
//FB 28292 Templates for "TmNS 144 bit PCM" and "TmNS Supercom 4x ADC PCM"
|
|
[StringMetaDataAttr("S6ATMTTemplate_TmNS_144PCM.tmt")]
|
|
S6Air_TmNS_144PPCM,
|
|
[StringMetaDataAttr("S6ATMTTemplate_TmNS_SuperCom4xPCM.tmt")]
|
|
S6Air_TmNS_SuperCom4xPCM,
|
|
//FB 30035 Added supported templates
|
|
[StringMetaDataAttr("TSRAIRTMTTemplate_PCM.tmt")]
|
|
TSRAIR_PCM,
|
|
[StringMetaDataAttr("TSRAIRTMTTemplate_ANALOG.tmt")]
|
|
TSRAIR_ANALOG
|
|
}
|
|
}
|