init

Common/DTS.CommonCore/Constant/DASSpecific/PowerPRO.cs

@@ -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;
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE.cs

@@ -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;
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE1_5.cs

@@ -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;
+            }
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE2.cs

@@ -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;
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE2_TOM.cs

@@ -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;
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE6.cs

@@ -0,0 +1,70 @@
+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:
+                    return protocolVersion < CLOCKSYNCPROFILE;
+                case ClockSyncProfile.Slave_E2E:
+                    return protocolVersion >= CLOCKSYNCPROFILE;
+                default: return false;
+            }
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE6AIR.cs

@@ -0,0 +1,189 @@
+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 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;
+        /// <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(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.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;
+            }
+        }
+
+        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._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 = 9600)
+        {
+            //39151
+            if (isEthernetRecorder) { return MaxSampleRateHz_OBRDDR; }
+            if (!RecordingModeExtensions.IsAUartMode(mode)) { return MaxSampleRateHz; }
+            //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];
+            }
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE6AIRBR.cs

@@ -0,0 +1,62 @@
+using DTS.Common.Enums;
+
+namespace DTS.Common.Constant.DASSpecific
+{
+    public class SLICE6AIRBR
+    {
+        public const int MIN_PROTOCOL_VER = 1;
+        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:
+                    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;
+            }
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICE6DB.cs

@@ -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;
+        }
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/SLICEDB.cs

@@ -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;
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/TDAS.cs

@@ -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;
+    }
+}

Common/DTS.CommonCore/Constant/DASSpecific/TSRAIR.cs

@@ -0,0 +1,112 @@
+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 START_REALTIME_STREAM = 11;
+        //public const int UDP_REALTIME_STREAM = 14;
+        public const int IRIG_GPS_PPSIN_SYNC = 25;
+        public const int DISABLE_STREAMING_FEATURE = 25;
+
+        public static bool IsRecordingModeSupported(RecordingModes mode, int protocolVersion)
+        {
+            var result = false;
+
+            switch (mode)
+            {
+                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:
+                    result = true;
+                    break;
+                //case RecordingModes.S6A_DeviceStreamingOnly:
+                //    result = protocolVersion >= UDP_REALTIME_STREAM;
+                //    break;
+                default:
+                    result = false;
+                    break;
+            }
+
+            return result;
+        }
+
+        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
+         */
+    }
+}