246 lines
13 KiB
Plaintext
246 lines
13 KiB
Plaintext
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];
|
|
}
|
|
}
|
|
}
|
|
}
|