1497 lines
47 KiB
C#
1497 lines
47 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.ComponentModel;
|
||
using System.ComponentModel.DataAnnotations;
|
||
using System.Linq;
|
||
using System.Text;
|
||
|
||
namespace IRIGCh10
|
||
{
|
||
public enum SubFrameSyncTags
|
||
{
|
||
[Description("ISF1")]
|
||
[MaxLength(32)]
|
||
SubframeIDCounterName,
|
||
[Description("ISF2")]
|
||
[MaxLength(2)]
|
||
SubframeSyncType
|
||
}
|
||
|
||
public enum SubframeSyncTypes
|
||
{
|
||
[Description("ID")]
|
||
IDCounter,
|
||
[Description("OT")]
|
||
Other
|
||
}
|
||
public class SubframeSync
|
||
{
|
||
private TMATSectionNumberedArray<SubFrameSyncTags> _subframeSyncTags;
|
||
|
||
public SubframeSync(int number=1)
|
||
{
|
||
_subframeSyncTags = new TMATSectionNumberedArray<SubFrameSyncTags>(AttributeIdentifiers.PCMFormatAttributes, number,
|
||
"ISF\\N", 99);
|
||
}
|
||
|
||
public void SetSubframeIDCounterNamer(int number, string val)
|
||
{
|
||
_subframeSyncTags.SetValue(number, SubFrameSyncTags.SubframeIDCounterName, val);
|
||
}
|
||
|
||
public void SetSubframeSyncType(int number, SubframeSyncTypes syncType)
|
||
{
|
||
_subframeSyncTags.SetValue(number, SubFrameSyncTags.SubframeSyncType,
|
||
DescriptionDecoder.GetDescription(syncType));
|
||
}
|
||
|
||
public string Serialize()
|
||
{
|
||
return _subframeSyncTags.Serialize();
|
||
}
|
||
}
|
||
public enum StorageTags
|
||
{
|
||
[Description("ID")]
|
||
[MaxLength(32)]
|
||
DataSourceID,
|
||
[MaxLength(32)]
|
||
[Description("RID")]
|
||
StorageId,
|
||
[Description("R1")]
|
||
[MaxLength(32)]
|
||
StorageDescription
|
||
}
|
||
|
||
public enum TimeDataTags
|
||
{
|
||
[Description("TTF-")]
|
||
TimeDataTypeFormat,
|
||
[Description("TFMT-")]
|
||
TimeFormat,
|
||
[Description("TSRC-")]
|
||
TimeSource
|
||
}
|
||
|
||
public enum TimeFormats
|
||
{
|
||
[Description("A")]
|
||
IRIGA,
|
||
[Description("B")]
|
||
IRIGB,
|
||
[Description("G")]
|
||
IRIGG,
|
||
[Description("I")]
|
||
Internal,
|
||
[Description("N")]
|
||
NativeGPS,
|
||
[Description("U")]
|
||
UTCFromGPS,
|
||
[Description("X")]
|
||
None
|
||
}
|
||
|
||
public enum MessageDataTypeAttributes
|
||
{
|
||
[Description("R-@x\\MTF-@n")]
|
||
[MaxLength(1)]
|
||
MessageDataTypeFormat,
|
||
[Description("R-@x\\NMS\\N-@n")]
|
||
[MaxLength(5)]
|
||
NumberOfMessageSubChannels,
|
||
[Description("R-@x\\MSCN-n-m")]
|
||
[MaxLength(5)]
|
||
MessageSubChannelNumber,
|
||
[Description("R-@x\\MCNM-@n-@m")]
|
||
[MaxLength(32)]
|
||
MessageSubChannelName
|
||
}
|
||
|
||
public class MessageDataType
|
||
{
|
||
private readonly int X;
|
||
|
||
public MessageDataType(int x)
|
||
{
|
||
X = x;
|
||
}
|
||
|
||
private Dictionary<int, string> _MessageTypeFormat = new Dictionary<int, string>();
|
||
/// <summary>
|
||
/// MESSAGE DATA TYPE FORMAT: FORMAT 0 (MESSAGE DATA) – ‘0’
|
||
/// </summary>
|
||
/// <param name="n"></param>
|
||
/// <param name="value"></param>
|
||
public void SetMessageTypeFormat(int n, string value)
|
||
{
|
||
_MessageTypeFormat[n] = value;
|
||
}
|
||
|
||
private readonly Dictionary<int, int> _NumberOfMessageSubChannels = new Dictionary<int, int>();
|
||
|
||
/// <summary>
|
||
/// SPECIFY THE NUMBER OF MESSAGE SUB-CHANNELS INCLUDED WITHIN
|
||
/// THIS CHANNEL
|
||
/// </summary>
|
||
/// <param name="n"></param>
|
||
/// <param name="value"></param>
|
||
public void SetNumberOfMessageSubChannels(int n, int value)
|
||
{
|
||
_NumberOfMessageSubChannels[n] = value;
|
||
}
|
||
|
||
private Dictionary<int, Dictionary<int, int>> _MessageSubChannelNumber =
|
||
new Dictionary<int, Dictionary<int, int>>();
|
||
|
||
/// <summary>
|
||
/// SPECIFY THE MESSAGE SUB-CHANNEL NUMBER.
|
||
/// </summary>
|
||
/// <param name="n"></param>
|
||
/// <param name="m"></param>
|
||
/// <param name="value"></param>
|
||
public void SetMessageSubChannelNumber(int n, int m, int value)
|
||
{
|
||
if (!_MessageSubChannelNumber.ContainsKey(n))
|
||
{
|
||
_MessageSubChannelNumber[n] = new Dictionary<int, int>();
|
||
}
|
||
_MessageSubChannelNumber[n][m] = value;
|
||
}
|
||
|
||
private Dictionary<int, Dictionary<int, string>> _MessageSubChannelName =
|
||
new Dictionary<int, Dictionary<int, string>>();
|
||
|
||
public void SetMessageSubChannelName(int n, int m, string value)
|
||
{
|
||
if( !_MessageSubChannelName.ContainsKey(n)){ _MessageSubChannelName[n] = new Dictionary<int, string>(); }
|
||
if( !_MessageSubChannelName[n].ContainsKey(m) ){ _MessageSubChannelName[n][m] = value; }
|
||
}
|
||
|
||
public string Serialize()
|
||
{
|
||
var sb = new StringBuilder();
|
||
|
||
//R-1\MTF-4:0;
|
||
using (var enumTypes = _MessageTypeFormat.GetEnumerator())
|
||
{
|
||
while (enumTypes.MoveNext())
|
||
{
|
||
sb.AppendLine($"R-{X}\\MTF-{enumTypes.Current.Key}:{enumTypes.Current.Value};");
|
||
}
|
||
}
|
||
//R-1\NMS\N-4:1;
|
||
using (var enumSubChannelNums = _NumberOfMessageSubChannels.GetEnumerator())
|
||
{
|
||
while (enumSubChannelNums.MoveNext())
|
||
{
|
||
sb.AppendLine($"R-{X}\\NMS\\N-{enumSubChannelNums.Current.Key}:{enumSubChannelNums.Current.Value};");
|
||
}
|
||
}
|
||
|
||
//R-1\MSCN-4-1:1;
|
||
using (var enumSubChannelNumber = _MessageSubChannelNumber.GetEnumerator())
|
||
{
|
||
while (enumSubChannelNumber.MoveNext())
|
||
{
|
||
using (var enumSubSub = enumSubChannelNumber.Current.Value.GetEnumerator())
|
||
{
|
||
while (enumSubSub.MoveNext())
|
||
{
|
||
sb.AppendLine(
|
||
$"R-{X}\\MSCN-{enumSubChannelNumber.Current.Key}-{enumSubSub.Current.Key}:{enumSubSub.Current.Value};");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//R-1\MCNM-4-1:sio/0/in2-30;
|
||
using (var enumSubChannelName = _MessageSubChannelName.GetEnumerator())
|
||
{
|
||
while (enumSubChannelName.MoveNext())
|
||
{
|
||
using (var enumSubSub = enumSubChannelName.Current.Value.GetEnumerator())
|
||
{
|
||
while (enumSubSub.MoveNext())
|
||
{
|
||
sb.AppendLine($"R-{X}\\MCNM-{enumSubChannelName.Current.Key}-{enumSubSub.Current.Key}:{enumSubSub.Current.Value};");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return sb.ToString();
|
||
}
|
||
}
|
||
public enum TimeSources
|
||
{
|
||
[Description("I")]
|
||
Internal,
|
||
[Description("E")]
|
||
External,
|
||
[Description("R")]
|
||
ExternalFromRMM,
|
||
[Description("X")]
|
||
None
|
||
}
|
||
public class Storage : TMATSSection<StorageTags>
|
||
{
|
||
/// <summary>
|
||
/// DATA SOURCE ID CONSISTENT WITH GENERAL INFORMATION GROUP
|
||
/// </summary>
|
||
public string DataSourceID
|
||
{
|
||
get => GetValue(StorageTags.DataSourceID);
|
||
set => SetValueWithLength(StorageTags.DataSourceID, value);
|
||
}
|
||
|
||
/// <summary>
|
||
/// TAPE OR STORAGE IDENTIFICATION
|
||
/// </summary>
|
||
public string StorageID
|
||
{
|
||
get => GetValue(StorageTags.StorageId);
|
||
set => SetValueWithLength(StorageTags.StorageId, value);
|
||
}
|
||
|
||
public string StorageDescription
|
||
{
|
||
get => GetValue(StorageTags.StorageDescription);
|
||
set => SetValueWithLength(StorageTags.StorageDescription, value);
|
||
}
|
||
|
||
private StorageCharacteristics _storageCharacteristics = new StorageCharacteristics(1);
|
||
private RecorderInformation _recorderInformation = new RecorderInformation(1);
|
||
private RecorderData _recorderData = new RecorderData(1);
|
||
private TMATSectionNumberedArray<PCMDataTypeTags> _pcmDataChannels =
|
||
new TMATSectionNumberedArray<PCMDataTypeTags>(AttributeIdentifiers.StorageSourceAttributes, 1, null,
|
||
ushort.MaxValue);
|
||
private RecordingEventDefinitions _recordingEventDefinitions = new RecordingEventDefinitions(1);
|
||
|
||
private TMATSectionNumberedArray<TimeDataTags> _timeData =
|
||
new TMATSectionNumberedArray<TimeDataTags>(AttributeIdentifiers.StorageSourceAttributes, 1, null, 1);
|
||
|
||
public void SetDataSourceID(int number, string value)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.DataSourceID, value);
|
||
}
|
||
|
||
public void SetChannelDataType(int number, ChannelDataTypes dataType)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.ChannelDataType, DescriptionDecoder.GetDescription(dataType));
|
||
}
|
||
|
||
public void SetTrackNumber(int number, ushort trackNumber)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.TrackNumber, trackNumber.ToString());
|
||
}
|
||
|
||
/// <summary>
|
||
/// INDICATES IF SOURCE IS ENABLED. SOURCE MUST BE ENABLED TO
|
||
/// GENERATE DATA PACKETS.
|
||
/// </summary>
|
||
/// <param name="number"></param>
|
||
/// <param name="bEnabled"></param>
|
||
public void SetChannelEnabled(int number, bool bEnabled)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.ChannelEnable, bEnabled ? "T" : "F");
|
||
}
|
||
|
||
public void SetChannelDataLinkName(int number, string value)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.ChannelDataLinkName, value);
|
||
}
|
||
public void SetPhysicalChannelNumber(int number, ushort channelNumber)
|
||
{
|
||
_recorderData.SetValue(number, DataTags.RecorderPhysicalChannelNumber, channelNumber.ToString());
|
||
}
|
||
|
||
public void SetTimeChannelDataTypeFormat()
|
||
{
|
||
_timeData.SetValue(1, TimeDataTags.TimeDataTypeFormat, "1");
|
||
}
|
||
|
||
public void SetTimeFormat(TimeFormats format)
|
||
{
|
||
_timeData.SetValue(1, TimeDataTags.TimeFormat,
|
||
DescriptionDecoder.GetDescription(format));
|
||
}
|
||
|
||
public void SetTimeSource(TimeSources source)
|
||
{
|
||
_timeData.SetValue(1, TimeDataTags.TimeSource,
|
||
DescriptionDecoder.GetDescription(source));
|
||
}
|
||
|
||
|
||
|
||
public void SetPCMDataTimeFormat(int number)
|
||
{
|
||
_pcmDataChannels.SetValue(number, PCMDataTypeTags.PCMDataTypeFormat, "1");
|
||
}
|
||
|
||
public void SetPCMInputClockEdge(int number, InputClockEdges edge)
|
||
{
|
||
_pcmDataChannels.SetValue(number, PCMDataTypeTags.InputClockEdge,
|
||
DescriptionDecoder.GetDescription(edge));
|
||
}
|
||
public void SetPCMDataPackingOption(int number, DataPackingOptions option)
|
||
{
|
||
_pcmDataChannels.SetValue(number, PCMDataTypeTags.DataPackingOption,
|
||
DescriptionDecoder.GetDescription(option));
|
||
}
|
||
|
||
public void SetPCMInputSignalType(int number, InputSignalTypes signalType)
|
||
{
|
||
_pcmDataChannels.SetValue(number, PCMDataTypeTags.InputSignalType,
|
||
DescriptionDecoder.GetDescription(signalType));
|
||
}
|
||
|
||
public void SetPCMVideoTypeFormat(int number, VideoFormats format)
|
||
{
|
||
_pcmDataChannels.SetValue(number, PCMDataTypeTags.PCMVideoTypeFormat,
|
||
DescriptionDecoder.GetDescription(format));
|
||
}
|
||
public int NumberOfChannels
|
||
{
|
||
get => _recorderData.GetCount();
|
||
set => _recorderData.SetCount(value);
|
||
}
|
||
|
||
public bool OriginalStorage
|
||
{
|
||
get => _recorderInformation.OriginalStorage;
|
||
set => _recorderInformation.OriginalStorage = value;
|
||
}
|
||
|
||
public DateTime? DateTimeCreated
|
||
{
|
||
get => _recorderInformation.DateAndTimeCreated;
|
||
set => _recorderInformation.DateAndTimeCreated = value;
|
||
}
|
||
|
||
public int? NumberOfSourceBits
|
||
{
|
||
get => _storageCharacteristics.NumberOfSourceBits;
|
||
set => _storageCharacteristics.NumberOfSourceBits = value;
|
||
}
|
||
/// <summary>
|
||
/// INDICATES IF INDEX IS ENABLED. INDEX MUST BE ENABLED TO
|
||
/// GENERATE INDEX PACKETS.
|
||
/// </summary>
|
||
public bool RecordingEventsEnabled
|
||
{
|
||
get => _recordingEventDefinitions.RecordingEventsEnabled;
|
||
set => _recordingEventDefinitions.RecordingEventsEnabled = value;
|
||
}
|
||
|
||
private RecordingIndex _recordingIndex = new RecordingIndex(1);
|
||
/// <summary>
|
||
/// INDICATES IF INDEX IS ENABLED. INDEX MUST BE ENABLED TO
|
||
/// GENERATE INDEX PACKETS.
|
||
/// </summary>
|
||
public bool RecordingIndexEnabled
|
||
{
|
||
get => _recordingIndex.RecordingIndexEnabled;
|
||
set => _recordingIndex.RecordingIndexEnabled = value;
|
||
}
|
||
public RecordingIndexTypes RecordingIndexType
|
||
{
|
||
get => _recordingIndex.RecordingIndexType;
|
||
set => _recordingIndex.RecordingIndexType = value;
|
||
}
|
||
/// <summary>
|
||
/// IDENTIFY THE NUMBER OF MICROSECONDS FOR EACH INDEX
|
||
/// ENTRY GENERATION
|
||
/// </summary>
|
||
public int RecordingIndexTimeValue
|
||
{
|
||
get => _recordingIndex.IndexTimeValue;
|
||
set => _recordingIndex.IndexTimeValue = value;
|
||
}
|
||
/// <summary>
|
||
/// IDENTIFY THE NUMBER OF PACKETS FOR EACH INDEX ENTRY
|
||
/// GENERATION
|
||
/// </summary>
|
||
public int RecordingIndexCountValue
|
||
{
|
||
get => _recordingIndex.IndexCountValue;
|
||
set => _recordingIndex.IndexCountValue = value;
|
||
}
|
||
|
||
public Storage(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
public override string Serialize()
|
||
{
|
||
var sb = new StringBuilder();
|
||
var s = base.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
s = _storageCharacteristics.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _recorderInformation.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _recorderData.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _pcmDataChannels.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _recordingEventDefinitions.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _recordingIndex.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _timeData.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
return sb.ToString();
|
||
}
|
||
}
|
||
|
||
|
||
public class StorageCharacteristics : TMATSSection<StorageCharactersticTags>
|
||
{
|
||
/// <summary>
|
||
/// SPECIFY THE TAPE OR STORAGE TYPE: ANALOG - ‘ANAL’
|
||
/// CASSETTE - ‘CASS’ HDDR - ‘HDDR’ PARALLEL - ‘PARA’
|
||
/// SOLID STATE RECORDER - ‘SSR’ OTHER - ‘OTHR’, DEFINE IN COMMENTS
|
||
/// RECORD.
|
||
/// </summary>
|
||
public StorageTypes? StorageType
|
||
{
|
||
get
|
||
{
|
||
var s = GetValue(StorageCharactersticTags.StorageType);
|
||
if (string.IsNullOrWhiteSpace(s))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var types = Enum.GetValues(typeof(StorageTypes)).Cast<StorageTypes>().ToArray();
|
||
foreach (var storagetype in types)
|
||
{
|
||
if (DescriptionDecoder.GetDescription(storagetype) == s)
|
||
{
|
||
return storagetype;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.StorageType, string.Empty);
|
||
}
|
||
else
|
||
{
|
||
var attr = DescriptionDecoder.GetDescription((StorageTypes) value);
|
||
SetValueWithLength(StorageCharactersticTags.StorageType, attr);
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// NAME OF MANUFACTURER OF THE TAPE OR THE STORAGE MEDIA
|
||
/// </summary>
|
||
public string StorageManufacturer
|
||
{
|
||
get => GetValue(StorageCharactersticTags.StorageManufacturer);
|
||
set => SetValueWithLength(StorageCharactersticTags.StorageManufacturer, value);
|
||
}
|
||
/// <summary>
|
||
/// SPECIFY MANUFACTURER’S TAPE OR STORAGE MEDIA DESIGNATION CODE.
|
||
/// </summary>
|
||
public string StorageCode
|
||
{
|
||
get => GetValue(StorageCharactersticTags.StorageCode);
|
||
set => SetValueWithLength(StorageCharactersticTags.StorageCode, value);
|
||
}
|
||
/// <summary>
|
||
/// PHYSICAL DIMENSION OF TAPE WIDTH, IN INCHES
|
||
/// </summary>
|
||
public string TapeWidth
|
||
{
|
||
get => GetValue(StorageCharactersticTags.TapeWidth);
|
||
set => SetValueWithLength(StorageCharactersticTags.TapeWidth, value);
|
||
}
|
||
|
||
/// <summary>
|
||
/// STATE THE REEL SIZE, INCHES:
|
||
/// </summary>
|
||
public TapeHousings? TapeHousing
|
||
{
|
||
get
|
||
{
|
||
var s = GetValue(StorageCharactersticTags.TapeHousing);
|
||
if( string.IsNullOrWhiteSpace(s)){ return null; }
|
||
|
||
var housings = Enum.GetValues(typeof(TapeHousings))
|
||
.Cast<TapeHousings>().ToArray();
|
||
foreach (var housing in housings)
|
||
{
|
||
if( DescriptionDecoder.GetDescription(housing) == s )
|
||
{
|
||
return housing;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TapeHousing, string.Empty);
|
||
}
|
||
else
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TapeHousing,
|
||
DescriptionDecoder.GetDescription((TapeHousings) value));
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// STATE THE TYPE OF TRACKS ON THE TAPE:
|
||
/// </summary>
|
||
public TrackTypes? TypeOfTracks
|
||
{
|
||
get
|
||
{
|
||
var s = GetValue(StorageCharactersticTags.TypeOfTracks);
|
||
if( string.IsNullOrWhiteSpace(s)){ return null; }
|
||
|
||
var tracks = Enum.GetValues(typeof(TrackTypes))
|
||
.Cast<TrackTypes>().ToArray();
|
||
foreach (var track in tracks)
|
||
{
|
||
if (DescriptionDecoder.GetDescription(track) == s)
|
||
{
|
||
return track;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TypeOfTracks, string.Empty);
|
||
}
|
||
else
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TypeOfTracks,
|
||
DescriptionDecoder.GetDescription((TrackTypes)value));
|
||
}
|
||
}
|
||
}
|
||
///// <summary>
|
||
///// STATE THE NUMBER OF TRACKS ON THE TAPE OR THE NUMBER OF
|
||
///// CHANNELS ON THE STORAGE MEDIA.
|
||
///// </summary>
|
||
//public string NumberOfTracks
|
||
//{
|
||
// get => GetValue(StorageCharactersticTags.NumberOfTracks);
|
||
// set => SetValue(StorageCharactersticTags.NumberOfTracks, value);
|
||
//}
|
||
/// <summary>
|
||
/// STATE RECORD SPEED (inches/second).
|
||
/// </summary>
|
||
public string RecordSpeed
|
||
{
|
||
get => GetValue(StorageCharactersticTags.RecordSpeed);
|
||
set => SetValueWithLength(StorageCharactersticTags.RecordSpeed, value);
|
||
}
|
||
|
||
public RecordingBandwidth? DataPackingDensity
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(StorageCharactersticTags.DataPackingDensity);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var bandwidths = Enum.GetValues(typeof(RecordingBandwidth))
|
||
.Cast<RecordingBandwidth>().ToArray();
|
||
foreach (var bandwidth in bandwidths)
|
||
{
|
||
if (DescriptionDecoder.GetDescription(bandwidth) == val)
|
||
{
|
||
return bandwidth;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.DataPackingDensity
|
||
, string.Empty);
|
||
}
|
||
else
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.DataPackingDensity,
|
||
DescriptionDecoder.GetDescription((RecordingBandwidth) value));
|
||
}
|
||
}
|
||
}
|
||
|
||
public bool? TapeRewound
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(StorageCharactersticTags.TapeRewound);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
if (val == "Y")
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TapeRewound, string.Empty);
|
||
}
|
||
else
|
||
{
|
||
SetValueWithLength(StorageCharactersticTags.TapeRewound,
|
||
((bool) value) ? "Y" : "N");
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// NUMBER OF MOST SIGNIFICANT BITS OF THE CHANNEL ID USED FOR
|
||
/// MULTIPLEXER SOURCE ID. DEFAULT IS ZERO (ONE SOURCE).
|
||
/// </summary>
|
||
public int? NumberOfSourceBits
|
||
{
|
||
get => GetIntOrNull(StorageCharactersticTags.NumberOfSourceBits);
|
||
set => SetIntOrNull(StorageCharactersticTags.NumberOfSourceBits, value);
|
||
}
|
||
|
||
public StorageCharacteristics(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
|
||
public enum RecordingBandwidth
|
||
{
|
||
[Description("IM")]
|
||
IntermediateBand,
|
||
[Description("WB")]
|
||
WideBand,
|
||
[Description("DD")]
|
||
DoubleDensity,
|
||
[Description("OT")]
|
||
Other
|
||
}
|
||
public enum TrackTypes
|
||
{
|
||
[Description("LO")]
|
||
Logitudinal,
|
||
[Description("RO")]
|
||
Rotary
|
||
}
|
||
public enum TapeHousings
|
||
{
|
||
[Description("10.5")]
|
||
TenHalf,
|
||
[Description("14.0")]
|
||
Fourteen,
|
||
[Description("15.0")]
|
||
Fifteen,
|
||
[Description("16.0")]
|
||
Sixteen,
|
||
[Description("OTHER")]
|
||
Other
|
||
}
|
||
public enum StorageTypes
|
||
{
|
||
[Description("ANAL")]
|
||
Analog,
|
||
[Description("CASS")]
|
||
Cassette,
|
||
[Description("HDDR")]
|
||
HDDR,
|
||
[Description("PARA")]
|
||
Parallel,
|
||
[Description("SSR")]
|
||
SolidStateRecorder,
|
||
[Description("OTHR")]
|
||
Other
|
||
}
|
||
public enum StorageCharactersticTags
|
||
{
|
||
[MaxLength(4)]
|
||
[Description("TC1")]
|
||
StorageType,
|
||
[MaxLength(8)]
|
||
[Description("TC2")]
|
||
StorageManufacturer,
|
||
[MaxLength(8)]
|
||
[Description("TC3")]
|
||
StorageCode,
|
||
[MaxLength(4)]
|
||
[Description("TC4")]
|
||
TapeWidth,
|
||
[MaxLength(5)]
|
||
[Description("TC5")]
|
||
TapeHousing,
|
||
[MaxLength(2)]
|
||
[Description("TT")]
|
||
TypeOfTracks,
|
||
//[MaxLength(2)]
|
||
//[Description("N")]
|
||
//NumberOfTracks,
|
||
[Description("TC6")]
|
||
[MaxLength(4)]
|
||
RecordSpeed,
|
||
[Description("TC7")]
|
||
[MaxLength(2)]
|
||
DataPackingDensity,
|
||
[Description("TC8")]
|
||
[MaxLength(1)]
|
||
TapeRewound,
|
||
[Description("NSB")]
|
||
[MaxLength(2)]
|
||
NumberOfSourceBits
|
||
}
|
||
|
||
public enum RecorderInformationTags
|
||
{
|
||
[Description("RI1")]
|
||
[MaxLength(8)]
|
||
StorageManufacturer,
|
||
[Description("RI2")]
|
||
[MaxLength(8)]
|
||
StorgeModel,
|
||
[Description("RI3")]
|
||
[MaxLength(1)]
|
||
OriginalStorage,
|
||
[Description("RI4")]
|
||
[MaxLength(19)]
|
||
DateAndTimeCreated
|
||
}
|
||
|
||
public class RIPointOfContact : TMATSSection<GeneralInformationGroup.Information.PointOfContactTags>
|
||
{
|
||
public RIPointOfContact(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
|
||
public enum DubbingOrganizationPOC
|
||
{
|
||
[Description("DPOC1")]
|
||
[MaxLength(24)]
|
||
Name,
|
||
[Description("DPOC2")]
|
||
[MaxLength(48)]
|
||
Agency,
|
||
[Description("DPOC3")]
|
||
[MaxLength(48)]
|
||
Address,
|
||
[Description("DPOC4")]
|
||
[MaxLength(20)]
|
||
Telephone
|
||
}
|
||
|
||
public class DubbingOrganizationPersonOfContact : TMATSSection<DubbingOrganizationPOC>
|
||
{
|
||
public DubbingOrganizationPersonOfContact(int number) :
|
||
base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
public class RecorderInformation : TMATSSection<RecorderInformationTags>
|
||
{
|
||
/// <summary>
|
||
/// NAME OF TAPE DRIVE OR STORAGE DEVICE MANUFACTURER
|
||
/// </summary>
|
||
public string StorageManufacturer
|
||
{
|
||
get => GetValue(RecorderInformationTags.StorageManufacturer);
|
||
set => SetValueWithLength(RecorderInformationTags.StorageManufacturer, value);
|
||
}
|
||
/// <summary>
|
||
/// MANUFACTURER’S MODEL NUMBER OF TAPE DRIVE OR STORAGE DEVICE USED
|
||
/// TO CREATE THE TAPE OR STORAGE MEDIA
|
||
/// </summary>
|
||
public string StorageModel
|
||
{
|
||
get => GetValue(RecorderInformationTags.StorgeModel);
|
||
set => SetValueWithLength(RecorderInformationTags.StorgeModel, value);
|
||
}
|
||
|
||
public bool OriginalStorage
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecorderInformationTags.OriginalStorage);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return "Y" == val;
|
||
}
|
||
set
|
||
{
|
||
SetValueWithLength(RecorderInformationTags.OriginalStorage,
|
||
value ? "Y" : "N");
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// DATE AND TIME TAPE OR STORAGE MEDIA WAS CREATED:
|
||
/// </summary>
|
||
public DateTime? DateAndTimeCreated
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecorderInformationTags.DateAndTimeCreated);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
if (DateTime.TryParseExact(val, "MM-dd-yyyy-HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture,
|
||
System.Globalization.DateTimeStyles.None,
|
||
out var dt))
|
||
{
|
||
return dt;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
SetValueWithLength(RecorderInformationTags.DateAndTimeCreated,
|
||
string.Empty);
|
||
}
|
||
else
|
||
{
|
||
var dt = (DateTime) value;
|
||
//SetValueWithLength(RecorderInformationTags.DateAndTimeCreated,
|
||
// $"{dt.Month:00}-{dt.Day:00}-{dt.Year:0000}-{dt.Hour:00}-{dt.Minute:00}-{dt.Second:00}");
|
||
//Example is only setting date??
|
||
SetValueWithLength(RecorderInformationTags.DateAndTimeCreated,
|
||
$"{dt.Month:00}-{dt.Day:00}-{dt.Year:0000}");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE FACILITY CREATING THE TAPE OR STORAGE
|
||
/// MEDIA:Name
|
||
/// </summary>
|
||
public string CreatingOrganizationPOCName
|
||
{
|
||
get => _pointOfContact.GetValue(GeneralInformationGroup.Information.PointOfContactTags.Name);
|
||
set => _pointOfContact.SetValueWithLength( GeneralInformationGroup.Information.PointOfContactTags.Name,
|
||
value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE FACILITY CREATING THE TAPE OR STORAGE
|
||
/// MEDIA:Agency
|
||
/// </summary>
|
||
public string CreatingOrganizationPOCAgency
|
||
{
|
||
get => _pointOfContact.GetValue(GeneralInformationGroup.Information.PointOfContactTags.Agency);
|
||
set => _pointOfContact.SetValueWithLength(GeneralInformationGroup.Information.PointOfContactTags.Agency,
|
||
value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE FACILITY CREATING THE TAPE OR STORAGE
|
||
/// MEDIA:Address
|
||
/// </summary>
|
||
public string CreatingOrganizationPOCAddress
|
||
{
|
||
get => _pointOfContact.GetValue(GeneralInformationGroup.Information.PointOfContactTags.Address);
|
||
set => _pointOfContact.SetValueWithLength(GeneralInformationGroup.Information.PointOfContactTags.Address,
|
||
value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE FACILITY CREATING THE TAPE OR STORAGE
|
||
/// MEDIA:Telephone
|
||
/// </summary>
|
||
public string CreatingOrganizationPOCTelephone
|
||
{
|
||
get => _pointOfContact.GetValue(GeneralInformationGroup.Information.PointOfContactTags.Telephone);
|
||
set => _pointOfContact.SetValueWithLength(GeneralInformationGroup.Information.PointOfContactTags.Telephone,
|
||
value);
|
||
}
|
||
/// <summary>
|
||
/// DATE THE DUB WAS MADE:
|
||
/// </summary>
|
||
public DateTime? DateOfDub
|
||
{
|
||
get
|
||
{
|
||
var val = _dateOfDubs.GetValue(DateOfDubTags.DateOfDub);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
if (DateTime.TryParseExact(val, "MM-dd-yyyy", System.Globalization.CultureInfo.InvariantCulture,
|
||
System.Globalization.DateTimeStyles.None, out var dt))
|
||
{
|
||
return dt;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
set
|
||
{
|
||
if (null == value)
|
||
{
|
||
_dateOfDubs.SetValueWithLength(DateOfDubTags.DateOfDub,
|
||
string.Empty);
|
||
}
|
||
else
|
||
{
|
||
var dt = (DateTime) value;
|
||
_dateOfDubs.SetValueWithLength(DateOfDubTags.DateOfDub,
|
||
$"{dt.Month:00}-{dt.Day:00}-{dt.Year:0000}");
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE DUBBING AGENCY: NAME
|
||
/// </summary>
|
||
public string DubbingOrganizationPOCName
|
||
{
|
||
get => _dubbingPOC.GetValue(DubbingOrganizationPOC.Name);
|
||
set => _dubbingPOC.SetValueWithLength(DubbingOrganizationPOC.Name, value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE DUBBING AGENCY: ADDRESS
|
||
/// </summary>
|
||
public string DubbingOrganizationPOCAddress
|
||
{
|
||
get => _dubbingPOC.GetValue(DubbingOrganizationPOC.Address);
|
||
set => _dubbingPOC.SetValueWithLength(DubbingOrganizationPOC.Address, value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE DUBBING AGENCY: AGENCY
|
||
/// </summary>
|
||
public string DubbingOrganizationPOCAgency
|
||
{
|
||
get => _dubbingPOC.GetValue(DubbingOrganizationPOC.Agency);
|
||
set => _dubbingPOC.SetValueWithLength(DubbingOrganizationPOC.Agency, value);
|
||
}
|
||
/// <summary>
|
||
/// POINT OF CONTACT AT THE DUBBING AGENCY: TELEPHONE
|
||
/// </summary>
|
||
public string DubbingOrganizationTelephone
|
||
{
|
||
get => _dubbingPOC.GetValue(DubbingOrganizationPOC.Telephone);
|
||
set => _dubbingPOC.SetValueWithLength(DubbingOrganizationPOC.Telephone, value);
|
||
}
|
||
private RIPointOfContact _pointOfContact = new RIPointOfContact(1);
|
||
private DateOfDubs _dateOfDubs = new DateOfDubs(1);
|
||
private DubbingOrganizationPersonOfContact _dubbingPOC = new DubbingOrganizationPersonOfContact(1);
|
||
public RecorderInformation(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
public override string Serialize()
|
||
{
|
||
var sb = new StringBuilder();
|
||
|
||
var s = base.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _pointOfContact.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _dateOfDubs.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
|
||
s = _dubbingPOC.Serialize();
|
||
if (!string.IsNullOrWhiteSpace(s))
|
||
{
|
||
sb.Append(s);
|
||
}
|
||
return sb.ToString();
|
||
}
|
||
}
|
||
public enum DateOfDubTags
|
||
{
|
||
[Description("RI5")]
|
||
[MaxLength(10)]
|
||
DateOfDub
|
||
}
|
||
|
||
public class DateOfDubs : TMATSSection<DateOfDubTags>
|
||
{
|
||
public DateOfDubs(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
|
||
public enum NumberOfTracksTags
|
||
{
|
||
[Description("N")]
|
||
[MaxLength(2)]
|
||
NumberOfTracks
|
||
}
|
||
|
||
public class NumberOfTracks : TMATSSection<NumberOfTracksTags>
|
||
{
|
||
public NumberOfTracks(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
|
||
public enum RecordingEventDefinitionsTags
|
||
{
|
||
[Description("EV\\E")]
|
||
[MaxLength(1)]
|
||
RecordingEventsEnabled
|
||
}
|
||
|
||
public class RecordingEventDefinitions : TMATSSection<RecordingEventDefinitionsTags>
|
||
{
|
||
/// <summary>
|
||
/// INDICATES IF EVENTS ARE ENABLED. EVENTS MUST BE ENABLED TO
|
||
/// GENERATE EVENT PACKETS
|
||
/// </summary>
|
||
public bool RecordingEventsEnabled
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecordingEventDefinitionsTags.RecordingEventsEnabled);
|
||
if (string.IsNullOrWhiteSpace(val)) { return false; }
|
||
|
||
if ("T" == val){ return true; }
|
||
return false;
|
||
}
|
||
set
|
||
{
|
||
SetValueWithLength(RecordingEventDefinitionsTags.RecordingEventsEnabled,
|
||
value ? "T" : "F");
|
||
}
|
||
}
|
||
|
||
private TMATSectionNumberedArray<RecordingEventTags> _events =
|
||
new TMATSectionNumberedArray<RecordingEventTags>(AttributeIdentifiers.StorageSourceAttributes, 1,
|
||
$"R-1\\EV\\N", 999);
|
||
|
||
public RecordingEventDefinitions(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
public override string Serialize()
|
||
{
|
||
return _events.Serialize();
|
||
}
|
||
}
|
||
|
||
public enum NumberOfRecordingEventsTags
|
||
{
|
||
[Description("EV\\N")]
|
||
NumberOfRecordingEvents
|
||
}
|
||
|
||
public class NumberOfRecordingEvents : TMATSSection<NumberOfRecordingEventsTags>
|
||
{
|
||
public NumberOfRecordingEvents(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number)
|
||
{
|
||
}
|
||
}
|
||
|
||
public enum EventTypes
|
||
{
|
||
[Description("E")]
|
||
External,
|
||
[Description("D")]
|
||
MeasurementDiscrete,
|
||
[Description("L")]
|
||
MeasurementLimit,
|
||
[Description("R")]
|
||
Recorder,
|
||
[Description("O")]
|
||
Other
|
||
}
|
||
|
||
public enum EventPriorities
|
||
{
|
||
[Description("1")]
|
||
Priority1,
|
||
[Description("2")]
|
||
Priority2,
|
||
[Description("3")]
|
||
Priority3,
|
||
[Description("4")]
|
||
Priority4,
|
||
[Description("5")]
|
||
Priority5
|
||
}
|
||
|
||
public enum EventCaptureModes
|
||
{
|
||
[Description("1")]
|
||
Mode1,
|
||
[Description("2")]
|
||
Mode2,
|
||
[Description("3")]
|
||
Mode3,
|
||
[Description("4")]
|
||
Mode4,
|
||
[Description("5")]
|
||
Mode5,
|
||
[Description("6")]
|
||
Mode6
|
||
}
|
||
public enum RecordingEventTags
|
||
{
|
||
[Description("EV\\ID-")]
|
||
[MaxLength(32)]
|
||
EventID,
|
||
[Description("EV\\D-")]
|
||
[MaxLength(256)]
|
||
EventDescription,
|
||
[Description("EV\\T-")]
|
||
[MaxLength(1)]
|
||
EventType,
|
||
[Description("EV\\P-")]
|
||
[MaxLength(1)]
|
||
EventPriority,
|
||
[Description("EV\\CM-")]
|
||
[MaxLength(1)]
|
||
EventCaptureMode,
|
||
[Description("EV\\IC-")]
|
||
[MaxLength(1)]
|
||
EventInitialCapture,
|
||
[Description("EV\\LC-")]
|
||
[MaxLength(8)]
|
||
RecordingEventLimitCount,
|
||
[Description("EV\\MS-")]
|
||
[MaxLength(32)]
|
||
EventMeasurementSource,
|
||
[Description("EV\\MN-")]
|
||
[MaxLength(32)]
|
||
EventMeasurementName,
|
||
}
|
||
|
||
public enum RecordingIndexTags
|
||
{
|
||
[Description("IDX\\E")]
|
||
[MaxLength(1)]
|
||
RecordingIndexEnabled,
|
||
[Description("IDX\\IT")]
|
||
[MaxLength(1)]
|
||
RecordingIndexType,
|
||
[Description("IDX\\ITV")]
|
||
[MaxLength(8)]
|
||
IndexTimeValue,
|
||
[Description("IDX\\ICV")]
|
||
[MaxLength(4)]
|
||
IndexCountValue
|
||
}
|
||
|
||
public enum RecordingIndexTypes
|
||
{
|
||
[Description("T")]
|
||
Time,
|
||
[Description("C")]
|
||
Count
|
||
}
|
||
public class RecordingIndex : TMATSSection<RecordingIndexTags>
|
||
{
|
||
/// <summary>
|
||
/// INDICATES IF INDEX IS ENABLED. INDEX MUST BE ENABLED TO
|
||
/// GENERATE INDEX PACKETS.
|
||
/// </summary>
|
||
public bool RecordingIndexEnabled
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecordingIndexTags.RecordingIndexEnabled);
|
||
if (string.IsNullOrWhiteSpace(val)) { return false; }
|
||
return val == "T";
|
||
}
|
||
set => SetValueWithLength(RecordingIndexTags.RecordingIndexEnabled, value ? "T" : "F");
|
||
}
|
||
|
||
public RecordingIndexTypes RecordingIndexType
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecordingIndexTags.RecordingIndexType);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return RecordingIndexTypes.Time;
|
||
}
|
||
|
||
if (val == "C")
|
||
{
|
||
return RecordingIndexTypes.Count;
|
||
}
|
||
return RecordingIndexTypes.Time;
|
||
}
|
||
set => SetValueWithLength(RecordingIndexTags.RecordingIndexType,
|
||
DescriptionDecoder.GetDescription(value));
|
||
}
|
||
/// <summary>
|
||
/// IDENTIFY THE NUMBER OF MICROSECONDS FOR EACH INDEX
|
||
/// ENTRY GENERATION
|
||
/// </summary>
|
||
public int IndexTimeValue
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecordingIndexTags.IndexTimeValue);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (int.TryParse(val, System.Globalization.NumberStyles.Any,
|
||
System.Globalization.CultureInfo.InvariantCulture,
|
||
out var iTemp))
|
||
{
|
||
return iTemp;
|
||
}
|
||
return 0;
|
||
}
|
||
set
|
||
{
|
||
SetValueWithLength(RecordingIndexTags.IndexTimeValue,
|
||
value.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
||
SetValueWithLength(RecordingIndexTags.IndexCountValue,
|
||
string.Empty);
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// IDENTIFY THE NUMBER OF PACKETS FOR EACH INDEX ENTRY
|
||
/// GENERATION
|
||
/// </summary>
|
||
public int IndexCountValue
|
||
{
|
||
get
|
||
{
|
||
var val = GetValue(RecordingIndexTags.IndexCountValue);
|
||
if (string.IsNullOrWhiteSpace(val))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (int.TryParse(val, System.Globalization.NumberStyles.Any,
|
||
System.Globalization.CultureInfo.InvariantCulture,
|
||
out var iTmp))
|
||
{
|
||
return iTmp;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
set
|
||
{
|
||
SetValueWithLength(RecordingIndexTags.IndexCountValue,
|
||
value.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
||
SetValueWithLength(RecordingIndexTags.IndexTimeValue, string.Empty);
|
||
}
|
||
}
|
||
public RecordingIndex(int number) : base(AttributeIdentifiers.StorageSourceAttributes, 1)
|
||
{
|
||
}
|
||
}
|
||
public enum DataDirections
|
||
{
|
||
[Description("FWD")]
|
||
Forward,
|
||
[Description("REV")]
|
||
Reverse
|
||
}
|
||
|
||
public enum ChannelDataTypes
|
||
{
|
||
[Description("PCMIN")]
|
||
PCMInput,
|
||
[Description("ANAIN")]
|
||
AnalogInput,
|
||
[Description("DISIN")]
|
||
DiscreteInput,
|
||
[Description("TIMEIN")]
|
||
IRIGTimeInput,
|
||
[Description("VIDIN")]
|
||
VideoInput,
|
||
[Description("UARTIN")]
|
||
UARTInput,
|
||
[Description("1553IN")]
|
||
Input1553,
|
||
[Description("429IN")]
|
||
ARINC429Input,
|
||
[Description("MSGIN")]
|
||
MessageDataInput,
|
||
[Description("IMGIN")]
|
||
ImageDataInput,
|
||
[Description("1394IN")]
|
||
IEEE1394Input,
|
||
[Description("PARIN")]
|
||
ParallelInput,
|
||
[Description("ETHIN")]
|
||
EthernetInput
|
||
}
|
||
|
||
public class RecorderData : TMATSectionNumberedArray<DataTags>
|
||
{
|
||
public RecorderData(int number) : base(AttributeIdentifiers.StorageSourceAttributes, number, "N", 99)
|
||
{
|
||
}
|
||
}
|
||
public enum DataTags
|
||
{
|
||
[Description("TK1-")]
|
||
[MaxLength(5)]//max 2 bytes as an unsigned short, but it's
|
||
//represented as a string ....
|
||
TrackNumber,
|
||
[Description("TK2-")]
|
||
[MaxLength(6)]
|
||
RecordingTechnique,
|
||
[Description("DSI-")]
|
||
[MaxLength(32)]
|
||
DataSourceID,
|
||
[Description("TK3-")]
|
||
[MaxLength(3)]
|
||
DataDirection,
|
||
[Description("TK4-")]
|
||
[MaxLength(5)]
|
||
RecorderPhysicalChannelNumber,
|
||
[Description("CHE-")]
|
||
[MaxLength(1)]
|
||
ChannelEnable,
|
||
[Description("CDT-")]
|
||
[MaxLength(6)]
|
||
ChannelDataType,
|
||
[Description("CDLN-")]
|
||
[MaxLength(32)]
|
||
ChannelDataLinkName
|
||
}
|
||
|
||
public enum DataPackingOptions
|
||
{
|
||
[Description("UN")]
|
||
Unpacked,
|
||
[Description("PFS")]
|
||
PackedWithFrameSync,
|
||
[Description("TM")]
|
||
ThroughputMode
|
||
}
|
||
|
||
public enum InputClockEdges
|
||
{
|
||
[Description("0")]
|
||
ZeroDegrees,
|
||
[Description("180")]
|
||
OneHundredEightyDegrees
|
||
}
|
||
|
||
public enum InputSignalTypes
|
||
{
|
||
[Description("SE")]
|
||
SingleEnded,
|
||
[Description("DIFF")]
|
||
Differential,
|
||
[Description("RS422")]
|
||
RS422StandardDifferential,
|
||
[Description("TTL")]
|
||
SingleEndedWithTTL
|
||
}
|
||
|
||
public enum InputTerminations
|
||
{
|
||
[Description("LOW-Z")]
|
||
LowZ,
|
||
[Description("HIGH-Z")]
|
||
HighZ
|
||
}
|
||
|
||
public enum VideoFormats
|
||
{
|
||
[Description("NONE")]
|
||
None,
|
||
[Description("MPEG1")]
|
||
MPEG1,
|
||
[Description("MPEG2")]
|
||
MPEG2,
|
||
[Description("H261")]
|
||
H261,
|
||
[Description("WAVE")]
|
||
WAVE,
|
||
[Description("OTHER")]
|
||
OTHER
|
||
}
|
||
public enum PCMDataTypeTags
|
||
{
|
||
[Description("PDTF-")]
|
||
[MaxLength(1)]
|
||
PCMDataTypeFormat,
|
||
[Description("PDP-")]
|
||
[MaxLength(3)]
|
||
DataPackingOption,
|
||
[Description("ICE-")]
|
||
[MaxLength(3)]
|
||
InputClockEdge,
|
||
[Description("IST-")]
|
||
[MaxLength(5)]
|
||
InputSignalType,
|
||
[Description("ITH-")]
|
||
[MaxLength(5)]
|
||
InputThreshold,
|
||
[Description("ITM-")]
|
||
[MaxLength(6)]
|
||
InputTermination,
|
||
[Description("PTF-")]
|
||
[MaxLength(5)]
|
||
PCMVideoTypeFormat
|
||
}
|
||
}
|
||
|