noisedestroyers/DP44
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
noisedestroyers
2026-04-17 14:55:32 -04:00
commit bc3ac1d4c9
18017 changed files with 4371742 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
Common/DTS.Common/Constant/DASSpecific/PowerPRO.cs Normal file
View File

@@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class PowerPRO
{
public const uint MaxAAFilterRateHz = 20000;
public const byte MIN_PROTOCOL_VER = 1;
public const byte DIAGNOS_SHUNT_DAC = 2;
// 10582 Implement auto-discover and monitor DAS status.
// firmware B0H3 first supported this according to documentation
public const byte MIN_PROTOCOL_QUERYMACTABLE = 9;
public const byte MIN_PROTOCOL_MEASUREPOWERPROALLDIAGNOSTICCHANNEL = 12;
}
}

13
Common/DTS.Common/Constant/DASSpecific/SLICE.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE
{
public const uint MaxAAFilterRateHz = 30000;
}
}

35
Common/DTS.Common/Constant/DASSpecific/SLICE1_5.cs Normal file
View File

@@ -0,0 +1,35 @@
using DTS.Common.Enums;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE1_5
{
public const uint MaxAAFilterRateHz = 40000;
public const byte MIN_PROTOCOL_VER = 1;
public const int QUERY_ARM_AND_TRIGGER_STATUS_TIME_LEFT_IN_ARM = 2;
public const int IGNORE_SHORTED_START_EVENT = 4;
public const int START_REC_DELAY_IN_SECOND = 5;
public const int MEASURE_INTERNAL_OFFSET = 6;
public const int START_REALTIME_STREAM = 7;
public const int BASE_PLUS_MIN_MULTIEVENT_HYBRID_PROTOCOL = 8;
public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
{
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.MultipleEventRecorder:
case RecordingModes.HybridRecorder:
case RecordingModes.ContinuousRecorder:
return true;
case RecordingModes.MultipleEventHybridRecorder:
return protocolVersion >= BASE_PLUS_MIN_MULTIEVENT_HYBRID_PROTOCOL;
default:
return false;
}
}
}
}

31
Common/DTS.Common/Constant/DASSpecific/SLICE2.cs Normal file
View File

@@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE2
{
public const uint MaxAAFilterRateHz = 200000;
public const int SLICE1_5_BASETYPE = 2;
public const int SLICEPRO_DIM_BASETYPE = 3;
public const int SLICEPRO_TOM_BASETYPE = 5;
public const byte MIN_PROTOCOL_VER = 128;
public const int FILE_DATA = 133;
public const int MULTIPLE_EVENTS = 134;
public const int STACK_SENSORS = 136;
public const int STACK_FIRMWARE_UPDATE = 137;
public const int DIAGNOSTIC_TWO_VOLT_EXCITATION = 138;
public const int QUERY_ARM_AND_TRIGGER_STATUS_TIME_LEFT_IN_ARM = 139;
public const byte MIN_PROTOCOL_VER_GEN3 = 140;
public const int SLICE2_ONE_WIRE_ID = 142;
public const int EVENT_ARM_ATTEMPTS = 145;
public const int MEASURE_INTERNAL_OFFSET = 149;
public const int START_REC_DELAY_IN_SECONDS = 150;
public const int START_REALTIME_STREAM = 152;
public const int HALF_BRIDGE_SIG_PLUS_SUPPORT = 154;
}
}

35
Common/DTS.Common/Constant/DASSpecific/SLICE2_TOM.cs Normal file
View File

@@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DTS.Common.Enums;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE2_TOM
{
public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
{
var result = false;
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventRecorder:
case RecordingModes.HybridRecorder:
case RecordingModes.MultipleEventHybridRecorder:
case RecordingModes.ContinuousRecorder:
result = true;
break;
default:
result = false;
break;
}
return result;
}
}
}

72
Common/DTS.Common/Constant/DASSpecific/SLICE6.cs Normal file
View File

@@ -0,0 +1,72 @@
using DTS.Common.Enums;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE6
{
public const uint MaxAAFilterRateHz = 20000;
public const int MIN_PROTOCOL_VER = 1;
public const int DIAGNOS_SHUNT_DAC = 2;
public const int START_REC_DELAY_IN_SECONDS = 3;
public const int IN_SLICE_TILT_SENSOR_ADC_PRE = 4;
public const int STACK_SENSORS = 5;
public const int START_REALTIME_STREAM = 11;
public const int UDP_REALTIME_STREAM = 14;
// Profiles as detailed in 29378
public const int CLOCKSYNCPROFILE = 21;
// minimum protocol version for PTP Domain ID per 30472
public const int PTP_DOMAIN_ID_VER = 21;
public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
{
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.MultipleEventRecorder:
case RecordingModes.HybridRecorder:
case RecordingModes.MultipleEventHybridRecorder:
case RecordingModes.ContinuousRecorder:
case RecordingModes.MultipleEventRAMActive:
case RecordingModes.RAMActive:
return true;
//RecordingModes.S6A_DeviceStreamingOnly:
//note: per Loc, S6 only supports udp streams in realtime, *not* as a streaming test mode (i.e. boot-and-stream)
//result = protocolVersion >= UDP_REALTIME_STREAM;
//break;
default:
return false;
}
}
public static bool IsStreamingProfileSupported(UDPStreamProfile profile, int protocolVersion)
{
switch (profile)
{
//note: per Loc, S6 only supports these in realtime, *not* as a streaming test mode (i.e. boot-and-stream)
case UDPStreamProfile.RTCStreaming:
case UDPStreamProfile.DTS_UDP:
return true;
default: return false;
}
}
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion)
{
switch (profile)
{
case ClockSyncProfile.None:
return true;
case ClockSyncProfile.Manual:
//per LP there should be no max protocol version for manual, just any protocol version > 1
//http://manuscript.dts.local/f/cases/41798/Clock-slave-output-clock-type-setting-preventing-from-setting-clock-sync-in-manual-mode
return protocolVersion > 1;
case ClockSyncProfile.Slave_E2E:
return protocolVersion >= CLOCKSYNCPROFILE;
default: return false;
}
}
}
}

245
Common/DTS.Common/Constant/DASSpecific/SLICE6AIR.cs Normal file
View File

@@ -0,0 +1,245 @@
using DTS.Common.Enums;
using DTS.Common.Enums.DASFactory;
using System.Collections.Generic;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE6AIR
{
public const uint IENA_PTYPE_STREAM_MIN_PROTOCOL = 39;
public const uint UART_STREAM_MIN_PROTOCOL = 41;
public const uint MaxAAFilterRateHz = 50000;
public const uint MaxSampleRateHz = 400000;
public const uint MaxSampleRateHz_OBRDDR = uint.MaxValue;
public const uint UARTBitsPerSample = 96;
public const int MIN_PROTOCOL_VER = 1;
public const int UDP_REALTIME_STREAM = MIN_PROTOCOL_VER;
public const int SET_DSP_FILTER_SETTINGS = 28;
public const int RECORD_AND_STREAM_SUBSAMPLE = 29;
public const int UART_MULTIPLE_EVENT_MIN_PROTOCOL = 45;
public const int RECORD_ON_BOOT_PROTOCOL = 46;
public const int RECORD_ON_BOOT_PROTOCOL_S6A_ETHERNETRECORDER = 7;
//http://manuscript.dts.local/f/cases/34261/FW-Implement-ContinuousRecorderMode-for-SLICE6-AIR-ST-ethernet-recorder#BugEvent.219995
public const int CONTINUOUS_MODE_PROTOCOL_S6A_EDR = 5;
//43618 Allow EDRs to record from a list of UDP Addresses.
public const int MULTIPLE_UDP_ADDRESSES_S6A_ETHERNETRECORDER = 7;
public const int AUTOARM_RECORD_DELAY_PROTOCOL = 51;
public const int AUTOARM_RECORD_DELAY_PROTOCOL_S6A_ETHERNETRECORDER = 6;
public const int UDPALIGNONPPS_PROTOCOL = 49;
/// <summary>
/// protocol version that UART channel streaming was added
/// http://manuscript.dts.local/f/cases/43623/SW-Implement-Sample-Per-Packet-setting-per-DAS-in-DataPRO
/// </summary>
public const int UART_CHANNEL_STREAMING = 53;
/// <summary>
/// minimum protocol version that S6A supports removing leap seconds
/// http://manuscript.dts.local/f/cases/31747/Add-support-for-GPS-Time-leap-seconds
/// </summary>
public const int REMOVE_LEAP_SECONDS_VER = 42;
/// <summary>
/// minimum protocol version that S6A supports setting min packets per sample
/// http://manuscript.dts.local/f/cases/31754/expose-number-of-ADC-samples-in-UDP-packet
/// </summary>
public const int ADC_SAMPLES_PER_PACKET_VER = 43;
//minimum protocol version for attribute per Manuscript 18294
public const int AC_COUPLER_ENABLE = 36;
// minimum protocol version for PPS OUT clock types per Manuscript 29842
public const int PPS_OUT_CLOCKS = 39;
public static bool IsRecordingModeSupported_S6AIR(RecordingModes mode, int protocolVersion)
{
//43626 Since S6A_EthernetRecorder is really a SLICE6_AIR with different firmware
//we use this SLICE6AIR class to avoid creating a new class for only a few features.
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.MultipleEventRecorder:
case RecordingModes.HybridRecorder:
case RecordingModes.MultipleEventHybridRecorder:
case RecordingModes.ContinuousRecorder:
case RecordingModes.CircularBufferPlusUART:
case RecordingModes.RecorderPlusUART:
case RecordingModes.MultipleEventRAMActive:
case RecordingModes.RAMActive:
return true;
case RecordingModes.MultipleEventCircularBufferAndStream:
case RecordingModes.MultipleEventRecorderAndStream:
case RecordingModes.CircularBufferAndStreamSubSample:
case RecordingModes.HybridAndStream:
case RecordingModes.MultipleEventHybridAndStream:
case RecordingModes.RecorderAndStreamSubSample:
return protocolVersion >= RECORD_AND_STREAM_SUBSAMPLE;
case RecordingModes.S6A_DeviceStreamingOnly:
return protocolVersion >= UDP_REALTIME_STREAM;
case RecordingModes.ContinuousRecorderPlusUART:
case RecordingModes.MultipleEventCircularBufferPlusUART:
case RecordingModes.MultipleEventRecorderPlusUART:
return protocolVersion >= UART_MULTIPLE_EVENT_MIN_PROTOCOL;
case RecordingModes.RecordOnBoot:
case RecordingModes.RecordOnBootPlusUART:
return protocolVersion >= RECORD_ON_BOOT_PROTOCOL;
default:
return false;
}
}
/// <summary>
/// Returns True if UART channel streaming is supported on S6A device
/// </summary>
/// <param name="protocolVersion"></param>
/// <returns></returns>
public static bool IsUARTChannelStreamingSupported(int protocolVersion)
{
return protocolVersion >= UART_CHANNEL_STREAMING;
}
public static bool IsRecordingModeSupported_S6EDR(RecordingModes mode, int protocolVersion)
{
//43626 Since S6A_EthernetRecorder is really a SLICE6_AIR with different firmware
//we use this SLICE6AIR class to avoid creating a new class for only a few features.
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.MultipleEventRecorder:
return true;
case RecordingModes.RecordOnBoot:
return protocolVersion >= RECORD_ON_BOOT_PROTOCOL_S6A_ETHERNETRECORDER;
case RecordingModes.ContinuousRecorder:
return protocolVersion >= CONTINUOUS_MODE_PROTOCOL_S6A_EDR;
default:
return false;
}
}
public static bool IsStreamingProfileSupported(UDPStreamProfile profile, int protocolVersion)
{
switch (profile)
{
case UDPStreamProfile.RTCStreaming:
case UDPStreamProfile.DTS_UDP:
case UDPStreamProfile.CH10_MANUAL_CONFIG:
case UDPStreamProfile.CH10_PCM128_MM:
case UDPStreamProfile.CH10_ANALOG:
case UDPStreamProfile.CH10_PCM_STANDARD:
case UDPStreamProfile.CH10_PCM_SUPERCOM:
case UDPStreamProfile.CH10_PCM_128BIT_2HDR:
case UDPStreamProfile.CH10_ANALOG_2HDR:
case UDPStreamProfile.CH10_PCM_STANDARD_2HDR:
case UDPStreamProfile.CH10_PCM_SUPERCOM_2HDR:
case UDPStreamProfile.TMNS_PCM_STANDARD:
case UDPStreamProfile.TMNS_PCM_SUPERCOM:
return true;
case UDPStreamProfile.IENA_PTYPE_STREAM:
return protocolVersion >= IENA_PTYPE_STREAM_MIN_PROTOCOL;
case UDPStreamProfile.UART_STREAM:
return protocolVersion >= UART_STREAM_MIN_PROTOCOL;
default:
return false;
}
}
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion)
{
switch (profile)
{
case ClockSyncProfile.PPS_OUT:
case ClockSyncProfile.GPS_EXT_PPS_PPS_OUT:
case ClockSyncProfile.GPS_EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_EXT_PPS_PPS_OUT:
case ClockSyncProfile.IRIG_EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.EXT_PPS_PPS_OUT:
case ClockSyncProfile.EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.Slave_E2E_Master_E2E_OUT:
case ClockSyncProfile.Slave_E2E_Master_E2E_PPS_OUT:
case ClockSyncProfile.Manual:
//30487: GPS only clock sync option should be removed
case ClockSyncProfile.GPS:
case ClockSyncProfile.Master_E2E_GPS:
case ClockSyncProfile.GPS_PPS_OUT:
case ClockSyncProfile.GPS_Master_E2E_PPS_OUT:
return false;
case ClockSyncProfile.Slave_E2E_PPS_OUT:
case ClockSyncProfile.Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_PPS_OUT:
return protocolVersion >= PPS_OUT_CLOCKS;
default: return true;
}
}
// 39151 preliminary guesses via this and 15323, to be tested and filled in by 39201
private static Dictionary<UartBaudRate, uint> MaxSampleRateHz_UART = new Dictionary<UartBaudRate, uint>()
{
[UartBaudRate._110] = 30000,
[UartBaudRate._300] = 30000,
[UartBaudRate._600] = 30000,
[UartBaudRate._1200] = 30000,
[UartBaudRate._2400] = 30000,
[UartBaudRate._4800] = 30000,
[UartBaudRate._9600] = 30000,
[UartBaudRate._14400] = 10000,
[UartBaudRate._19200] = 10000,
[UartBaudRate._38400] = 10000,
[UartBaudRate._57600] = 10000,
[UartBaudRate._115200] = 10000,
[UartBaudRate._230400] = 10000,
[UartBaudRate._460800] = 10000,
[UartBaudRate._921600] = 10000
};
public static uint MaxSampleRateHzForRecordingMode(RecordingModes mode, bool isEthernetRecorder, int protocolVersion = 1, uint baudRate = 0)
{
//39151
if (isEthernetRecorder) { return MaxSampleRateHz_OBRDDR; }
// if we're not using a UART recording mode or we're not streaming to UART, return the model's Max Sample Rate
if (!RecordingModeExtensions.IsAUartMode(mode) && !(RecordingModeExtensions.IsAStreamMode(mode) && baudRate != 0)) { return MaxSampleRateHz; }
//33198
if (RecordingModeExtensions.IsAStreamMode(mode))
{
//39224 Per LP, UART baud rate should be twice ADC bit rate
// ex: 19200bps / (96bpsam * 2) = 100 sps max
return baudRate / (UARTBitsPerSample * 2);
}
//Per LP, sample rate limit is a function of baud rate:
//30kHz rate from FB15323 was tested at <=9600bps GPS testing, 10kHz rate limit from this issue was found during 921kbps testing other rates
switch (baudRate)
{
case var n when n >= (uint)UartBaudRate._921600:
return MaxSampleRateHz_UART[UartBaudRate._921600];
case var n when n >= (uint)UartBaudRate._460800:
return MaxSampleRateHz_UART[UartBaudRate._460800];
case var n when n >= (uint)UartBaudRate._230400:
return MaxSampleRateHz_UART[UartBaudRate._230400];
case var n when n >= (uint)UartBaudRate._115200:
return MaxSampleRateHz_UART[UartBaudRate._115200];
case var n when n >= (uint)UartBaudRate._57600:
return MaxSampleRateHz_UART[UartBaudRate._57600];
case var n when n >= (uint)UartBaudRate._38400:
return MaxSampleRateHz_UART[UartBaudRate._38400];
case var n when n >= (uint)UartBaudRate._19200:
return MaxSampleRateHz_UART[UartBaudRate._19200];
case var n when n >= (uint)UartBaudRate._14400:
return MaxSampleRateHz_UART[UartBaudRate._14400];
case var n when n >= (uint)UartBaudRate._9600:
return MaxSampleRateHz_UART[UartBaudRate._9600];
case var n when n >= (uint)UartBaudRate._4800:
return MaxSampleRateHz_UART[UartBaudRate._4800];
case var n when n >= (uint)UartBaudRate._2400:
return MaxSampleRateHz_UART[UartBaudRate._2400];
case var n when n >= (uint)UartBaudRate._1200:
return MaxSampleRateHz_UART[UartBaudRate._1200];
case var n when n >= (uint)UartBaudRate._600:
return MaxSampleRateHz_UART[UartBaudRate._600];
case var n when n >= (uint)UartBaudRate._300:
return MaxSampleRateHz_UART[UartBaudRate._300];
default:
return MaxSampleRateHz_UART[UartBaudRate._110];
}
}
}
}

73
Common/DTS.Common/Constant/DASSpecific/SLICE6AIRBR.cs Normal file
View File

@@ -0,0 +1,73 @@
using DTS.Common.Enums;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE6AIRBR
{
public const int MIN_PROTOCOL_VER = 1;
public const int ADC_SAMPLES_PER_PACKET_VER = 47;
public const int UDPALIGNONPPS_PROTOCOL = 51;
public const uint MaxAAFilterRateHz = 50000;
public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
{
switch (mode)
{
case RecordingModes.CircularBuffer:
case RecordingModes.Recorder:
case RecordingModes.MultipleEventCircularBuffer:
case RecordingModes.MultipleEventRecorder:
case RecordingModes.HybridRecorder:
case RecordingModes.MultipleEventHybridRecorder:
case RecordingModes.ContinuousRecorder:
case RecordingModes.S6A_DeviceStreamingOnly:
case RecordingModes.RAMActive:
case RecordingModes.MultipleEventRAMActive:
case RecordingModes.RecorderAndStreamSubSample:
case RecordingModes.MultipleEventRecorderAndStream:
case RecordingModes.CircularBufferAndStreamSubSample:
case RecordingModes.MultipleEventCircularBufferAndStream:
case RecordingModes.RecordOnBoot:
case RecordingModes.RecordOnBootPlusUART:
case RecordingModes.HybridAndStream:
return true;
default:
return false;
}
}
public static bool IsStreamingProfileSupported(UDPStreamProfile profile, int protocolVersion)
{
switch (profile)
{
case UDPStreamProfile.RTCStreaming:
case UDPStreamProfile.DTS_UDP:
case UDPStreamProfile.CH10_MANUAL_CONFIG:
case UDPStreamProfile.CH10_PCM128_MM:
case UDPStreamProfile.CH10_ANALOG:
case UDPStreamProfile.CH10_PCM_STANDARD:
case UDPStreamProfile.CH10_PCM_SUPERCOM:
case UDPStreamProfile.CH10_PCM_128BIT_2HDR:
case UDPStreamProfile.CH10_ANALOG_2HDR:
case UDPStreamProfile.CH10_PCM_STANDARD_2HDR:
case UDPStreamProfile.CH10_PCM_SUPERCOM_2HDR:
case UDPStreamProfile.TMNS_PCM_STANDARD:
case UDPStreamProfile.TMNS_PCM_SUPERCOM:
case UDPStreamProfile.IENA_PTYPE_STREAM:
return true;
default: return false;
}
}
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion)
{
switch (profile)
{
case ClockSyncProfile.None:
case ClockSyncProfile.Master_E2E:
case ClockSyncProfile.Slave_E2E:
return true;
default: return false;
}
}
}
}

75
Common/DTS.Common/Constant/DASSpecific/SLICE6AIRTC.cs Normal file
View File

@@ -0,0 +1,75 @@
using DTS.Common.Enums;
using static DTS.Common.Enums.DASFactory.DFConstantsAndEnums;
namespace DTS.Common.Constant.DASSpecific
{
#pragma warning disable S101 // Types should be named in PascalCase
public static class SLICE6AIRTC
#pragma warning restore S101 // Types should be named in PascalCase
{
public const int MIN_PROTOCOL_VER = 1;
public const int ADC_SAMPLES_PER_PACKET_VER = 1;
public const int MULTIPLE_CONFIGURATIONS_VER = 100;
public const int ThermocouplersPerModule = 8;
public static bool IsRecordingModeSupported(RecordingModes mode)
{
switch (mode)
{
case RecordingModes.S6A_DeviceStreamingOnly:
return true;
default:
return false;
}
}
public static bool IsStreamingProfileSupported(UDPStreamProfile profile, int protocolVersion)
{
switch (profile)
{
case UDPStreamProfile.RTCStreaming:
case UDPStreamProfile.DTS_UDP:
case UDPStreamProfile.CH10_MANUAL_CONFIG:
case UDPStreamProfile.CH10_PCM128_MM:
case UDPStreamProfile.CH10_ANALOG:
case UDPStreamProfile.CH10_PCM_STANDARD:
case UDPStreamProfile.CH10_PCM_SUPERCOM:
case UDPStreamProfile.CH10_PCM_128BIT_2HDR:
case UDPStreamProfile.CH10_ANALOG_2HDR:
case UDPStreamProfile.CH10_PCM_STANDARD_2HDR:
case UDPStreamProfile.CH10_PCM_SUPERCOM_2HDR:
case UDPStreamProfile.TMNS_PCM_STANDARD:
case UDPStreamProfile.TMNS_PCM_SUPERCOM:
case UDPStreamProfile.IENA_PTYPE_STREAM:
return true;
default:
return false;
}
}
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion)
{
switch (profile)
{
case ClockSyncProfile.PPS_OUT:
case ClockSyncProfile.GPS_EXT_PPS_PPS_OUT:
case ClockSyncProfile.GPS_EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_EXT_PPS_PPS_OUT:
case ClockSyncProfile.IRIG_EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.EXT_PPS_PPS_OUT:
case ClockSyncProfile.EXT_PPS_Master_E2E_PPS_OUT:
case ClockSyncProfile.Slave_E2E_Master_E2E_OUT:
case ClockSyncProfile.Slave_E2E_Master_E2E_PPS_OUT:
case ClockSyncProfile.Manual:
case ClockSyncProfile.Master_E2E_GPS:
case ClockSyncProfile.GPS_PPS_OUT:
case ClockSyncProfile.GPS_Master_E2E_PPS_OUT:
return false;
case ClockSyncProfile.GPS:
case ClockSyncProfile.Slave_E2E_PPS_OUT:
case ClockSyncProfile.Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_Master_E2E_PPS_OUT:
case ClockSyncProfile.IRIG_PPS_OUT:
default: return true;
}
}
}
}

48
Common/DTS.Common/Constant/DASSpecific/SLICE6DB.cs Normal file
View File

@@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICE6DB
{
public const uint MaxAAFilterRateHz = 200000;
public const byte MIN_PROTOCOL_VER = 1;
public const byte MIN_PROTOCOL_QUERYTEMPLOGFILE = 8;
// 10582 Implement auto-discover and monitor DAS status.
// firmware B0H3 first supported this according to documentation
public const byte MIN_PROTOCOL_QUERYMACTABLE = 9;
public const byte MIN_PROTOCOL_TILT = 14;
public const int CLOCKSYNCPROFILE = 18;
// minimum protocol version for PTP Domain ID per 30472
public const int PTP_DOMAIN_ID_VER = 18;
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion)
{
var result = false;
switch (profile)
{
case ClockSyncProfile.None:
result = true;
break;
case ClockSyncProfile.Manual:
if (protocolVersion < CLOCKSYNCPROFILE)
{
result = true;
}
break;
case ClockSyncProfile.Master_E2E:
case ClockSyncProfile.Slave_E2E:
if (protocolVersion >= CLOCKSYNCPROFILE)
{
result = true;
}
break;
}
return result;
}
}
}

30
Common/DTS.Common/Constant/DASSpecific/SLICEDB.cs Normal file
View File

@@ -0,0 +1,30 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class SLICEDB
{
public const uint MaxAAFilterRateHz = 200000;
public const byte MIN_PROTOCOL_VER = 1;
public const byte MIN_PROTOCOL_ARM = 2;
public const byte MIN_PROTOCOL_ENABLEFAULTCHECKING = MIN_PROTOCOL_ARM;
public const byte MIN_PROTOCOL_DIAGNOSTICS = 3;
public const byte MIN_PROTOCOL_ONOVERRIDE = 4;
public const byte MIN_PROTOCOL_OMAP_GPIO = MIN_PROTOCOL_ONOVERRIDE;
public const byte MIN_PROTOCOL_INITHARDWAREINPUTLINES = MIN_PROTOCOL_ONOVERRIDE;
//FB 16049 Support ECM Caldate
public const byte MIN_PROTOCOL_BASECALDATE = 5;
// 10582 Implement auto-discover and monitor DAS status.
// firmware B0H3 first supported this according to documentation
public const byte MIN_PROTOCOL_QUERYMACTABLE = 9;
public const byte MIN_PROTOCOL_TILT = 14;
}
}

66
Common/DTS.Common/Constant/DASSpecific/SliceProDB.cs Normal file
View File

@@ -0,0 +1,66 @@
namespace DTS.Common.Constant.DASSpecific
{
public static class SliceProDB
{
/// <summary>
/// The MINIMUM_VALID_INPUT_THRESHOLD is the minimum input reading we accept from a das, if it's below that we reject it
/// The low value for this threshold is the minimum setting value we consider valid before we reject it and use
/// MINIMUM_VALID_INPUT_THRESHOLD_VALUE as the default for the MINIMUM_VALID_INPUT_THRESHOLD
/// </summary>
public const double MINIMUM_VALID_INPUT_THRESHOLD_LOW = 30;
/// <summary>
/// The MINIMUM_VALID_INPUT_THRESHOLD is the minimum input reading we accept from a das, if it's below that we reject it
/// The high value for this threshold is the max setting value we consider valid before we reject it and use
/// MINIMUM_VALID_INPUT_THRESHOLD_VALUE as the default for the MINIMUM_VALID_INPUT_THRESHOLD
/// </summary>
public const double MINIMUM_VALID_INPUT_THRESHOLD_HIGH = 40;
/// <summary>
/// this is the default we'll use for the min valid input threshold if we reject the setting in the database
/// </summary>
public const double MINIMUM_VALID_INPUT_THRESHOLD_VALUE = 35;
/// <summary>
/// the MAXIMIMUM_VALID_INPUT_THRESHOLD is the max input voltage reading from the DAS that we will accept, any readings above this value we
/// reject
/// The High value here is the maximum setting value we allow before rejecting the setting and using
/// MAXIMUM_VALID_INPUT_THRESHOLD_VALUE as for the MAXIMUM_VALID_INPUT_THRESHOLD instead of the setting in the db
/// </summary>
public const double MAXIMUM_VALID_INPUT_THRESHOLD_HIGH = 60;
/// <summary>
/// the MAXIMIMUM_VALID_INPUT_THRESHOLD is the max input voltage reading from the DAS that we will accept, any readings above this value we
/// reject
/// The low value here is the min setting value we allow before rejecting the setting and using
/// MAXIMUM_VALID_INPUT_THRESHOLD_VALUE as for the MAXIMUM_VALID_INPUT_THRESHOLD instead of the setting in the db
/// </summary>
public const double MAXIMUM_VALID_INPUT_THRESHOLD_LOW = 50;
/// <summary>
/// this is the default value for the maximum valid input threshold when resetting from what is in the database
/// </summary>
public const double MAXIMUM_VALID_INPUT_THRESHOLD_VALUE = 57;
/// <summary>
/// this is the low value for the input low threshold before we decide the value is invalid and we use the default
/// </summary>
public const double INPUTLOWTHRESHOLD_LOW = 30;
/// <summary>
/// this is the high value for the input low threshold before we decide the value is invalid and we use the default
/// </summary>
public const double INPUTLOWTHRESHOLD_HIGH = 40;
/// <summary>
/// this is the default value that we use for the input low threshold if we need a default
/// </summary>
public const double INPUTLOWTHRESHOLD_DEFAULT = 36.5;
/// <summary>
/// this is the low value for the input high threshold before we decide the value is invalid and use the default
/// </summary>
public const double INPUTHIGHTHRESHOLD_LOW = 50;
/// <summary>
/// this is the high value for the input high threshold before we decide the value is invalid and use the default
/// </summary>
public const double INPUTHIGHTHRESHOLD_HIGH = 60;
/// <summary>
/// this is the default value for the input high threshold when we need a default
/// </summary>
public const double INPUTHIGHTHRESHOLD_DEFAULT = 56;
}
}

13
Common/DTS.Common/Constant/DASSpecific/TDAS.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DTS.Common.Constant.DASSpecific
{
public class TDAS
{
public const uint MaxAAFilterRateHz = 4300;
}
}

122
Common/DTS.Common/Constant/DASSpecific/TSRAIR.cs Normal file
View File

@@ -0,0 +1,122 @@
using DTS.Common.Enums;
namespace DTS.Common.Constant.DASSpecific
{
public class TSRAIR
{
public const uint MaxAAFilterRateHz = 200000;
public const byte MIN_PROTOCOL_VER = 1;
public const int VOLTAGE_INSERTION = 2;
public const int START_REC_DELAY_IN_SECONDS = 3;
public const int STACK_SENSORS = 5;
public const int WAKEUP_MOTION_TIMEOUT = 10;
public const int IRIG_GPS_PPSIN_SYNC = 25;
public const int DISABLE_STREAMING_FEATURE = 25;
public const int TSRAIR_MIN_PRE_TRIGGER_SAMPLES = 256;
public const int TSRAIR_MAX_PRE_TRIGGER_SAMPLES = 512;
public const int EXTENDED_FAULTS_VER = 27;
public const int ADC_SAMPLES_PER_PACKET_VER = 29;
public const int PROTOCOL_VERSION_CIRCULAR_UART = 29;
public const int PROTOCOL_VERSION_CIRCULAR = int.MaxValue;
public const int PROTOCOL_VERSION_RECORDER_UART = 30;
public const int PROTOCOL_VERSION_RECORDER = int.MaxValue;
public const int PROTOCOL_VERSION_SCHEDULED_EVENTCOUNT = 35;
public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
{
switch (mode)
{
case RecordingModes.CircularBufferPlusUART:
case RecordingModes.MultipleEventCircularBufferPlusUART:
return protocolVersion >= PROTOCOL_VERSION_CIRCULAR_UART;
case RecordingModes.CircularBuffer:
case RecordingModes.MultipleEventCircularBuffer:
return protocolVersion >= PROTOCOL_VERSION_CIRCULAR;
case RecordingModes.Recorder:
case RecordingModes.MultipleEventRecorder:
return protocolVersion >= PROTOCOL_VERSION_RECORDER;
case RecordingModes.MultipleEventRecorderPlusUART:
case RecordingModes.RecorderPlusUART:
return protocolVersion >= PROTOCOL_VERSION_RECORDER_UART;
case RecordingModes.Active:
case RecordingModes.MultipleEventActive:
case RecordingModes.Streaming:
case RecordingModes.S6A_DeviceStreamingOnly:
//26783: Since the "Set DAS to Streaming" checkbox is used for both
//TSR AIR and SLICE6Air, the recording mode may correspond to the
//"other" hardware if the DAS is switched from one to the other
case RecordingModes.Scheduled:
case RecordingModes.Interval:
return true;
default:
return false;
}
}
public static bool IsStreamingProfileSupported(UDPStreamProfile profile, int protocolVersion)
{
var result = false;
switch (profile)
{
case UDPStreamProfile.DTS_UDP:
case UDPStreamProfile.CH10_ANALOG_2HDR:
//FB 30035 Added other supported profiles for TSRAIR
case UDPStreamProfile.CH10_ANALOG:
case UDPStreamProfile.CH10_PCM_128BIT_2HDR:
case UDPStreamProfile.CH10_PCM128_MM:
result = true;
break;
}
return result;
}
public static bool IsClockSyncProfileSupported(ClockSyncProfile profile, int protocolVersion, bool master)
{
var result = false;
switch (profile)
{
case ClockSyncProfile.IRIG_EXT_PPS:
return false;
case ClockSyncProfile.EXT_PPS:
//master EXT_PPS not supported at this time for TSR AIR
//http://manuscript.dts.local/f/cases/34280/
if (protocolVersion >= IRIG_GPS_PPSIN_SYNC && !master)
{
result = true;
}
break;
case ClockSyncProfile.None:
result = true;
break;
case ClockSyncProfile.Master_E2E:
case ClockSyncProfile.Slave_E2E:
result = true;
break;
case ClockSyncProfile.GPS_EXT_PPS:
case ClockSyncProfile.Master_E2E_GPS_EXT_PPS:
case ClockSyncProfile.Master_E2E_EXT_PPS:
case ClockSyncProfile.IRIG:
case ClockSyncProfile.Master_E2E_IRIG:
case ClockSyncProfile.Master_E2E_IRIG_EXT_PPS:
// 30430 per EF and LP / 30704: everything but 1PPS out is legal with protocol 25
if (protocolVersion >= IRIG_GPS_PPSIN_SYNC)
{
result = true;
}
break;
case ClockSyncProfile.GPS:
case ClockSyncProfile.Master_E2E_GPS:
result = false;
// 30487: Leave this alone, GPS only clock sync option should be removed
break;
}
return result;
}
/* 39151 Leaving a note here in TSRAIR for when it inevitably gets UART recording
* copy/paste the implemented MaxSampleRateHz_UART dictionary and MaxSampleRateHzForRecordingMode function from SLICE6AIR
*/
}
}