2455 lines
83 KiB
C#
2455 lines
83 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.ICommunication;
|
|
|
|
namespace DTS.DASLib.Command.TDAS
|
|
{
|
|
public class TestAllCommandString : CommandString
|
|
{
|
|
protected override string _CommandString => "TA";
|
|
|
|
protected override string _CommandDescription => "Test all - TA";
|
|
|
|
public Modes Mode { get; set; } = Modes.NONE;
|
|
|
|
public enum Modes
|
|
{
|
|
NONE,
|
|
CURR,
|
|
PREV
|
|
}
|
|
public override byte[] GetParameters()
|
|
{
|
|
switch (Mode)
|
|
{
|
|
case Modes.PREV:
|
|
return Encoding.ASCII.GetBytes(" PREV");
|
|
case Modes.CURR:
|
|
return Encoding.ASCII.GetBytes(" CURR");
|
|
default:
|
|
return new byte[0];
|
|
}
|
|
}
|
|
}
|
|
internal class QueryArmStatusCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "Query ARM status - ARM STAT READ";
|
|
|
|
protected override string _CommandString => "ARM STAT READ";
|
|
}
|
|
internal class LEDSCommandString : CommandString
|
|
{
|
|
protected override string _CommandString => "LEDS";
|
|
protected override string _CommandDescription => "LEDS";
|
|
}
|
|
public class QueryArmStatus : CommandBase
|
|
{
|
|
public enum ARMStatus
|
|
{
|
|
UNDEFINED,
|
|
DONE,
|
|
ARMED,
|
|
REC,
|
|
TRIG,
|
|
FLASH,
|
|
ARMING,
|
|
FLASHWRITE,
|
|
OFF,
|
|
CAL
|
|
}
|
|
private new ARMStatus _status = ARMStatus.UNDEFINED;
|
|
public new ARMStatus Status
|
|
{
|
|
get
|
|
{
|
|
if (_status == ARMStatus.UNDEFINED) { ProcessData(); }
|
|
return _status;
|
|
}
|
|
}
|
|
public void SetStatus(ARMStatus status)
|
|
{
|
|
_status = status;
|
|
}
|
|
|
|
public bool RackFault { get; private set; }
|
|
|
|
public bool LowPower { get; private set; }
|
|
|
|
public bool HardwareTrigger { get; private set; }
|
|
|
|
public bool StartRecord { get; private set; }
|
|
|
|
public bool LevelTrigger { get; }
|
|
|
|
public bool ModuleFault { get; private set; }
|
|
|
|
public QueryArmStatus(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new QueryArmStatusCommandString());
|
|
}
|
|
public QueryArmStatus(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeOut)
|
|
: base(sock, msTimeOut)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new QueryArmStatusCommandString());
|
|
}
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("ARM: ");
|
|
var end = s.IndexOf("\r\n");
|
|
if (start >= 0 && end > start)
|
|
{
|
|
_responseData = s.Substring(start + 5, end - start - 5);
|
|
}
|
|
else { return; }
|
|
|
|
var tokens = ResponseData.Split(' ');
|
|
foreach (var token in tokens)
|
|
{
|
|
var subTokens = token.Split('=');
|
|
if (2 == subTokens.Length)
|
|
{
|
|
switch (subTokens[0])
|
|
{
|
|
case "LP":
|
|
LowPower = subTokens[1] != "N";
|
|
break;
|
|
case "MF":
|
|
ModuleFault = subTokens[1] != "N";
|
|
break;
|
|
case "RF":
|
|
RackFault = subTokens[1] != "N";
|
|
break;
|
|
case "TF":
|
|
HardwareTrigger = subTokens[1] != "N";
|
|
break;
|
|
case "SR":
|
|
StartRecord = subTokens[1] != "N";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (token)
|
|
{
|
|
case "STATUS":
|
|
break;
|
|
case "DONE":
|
|
_status = ARMStatus.DONE;
|
|
break;
|
|
case "ARMED":
|
|
_status = ARMStatus.ARMED;
|
|
break;
|
|
case "REC":
|
|
_status = ARMStatus.REC;
|
|
break;
|
|
case "TRIG":
|
|
_status = ARMStatus.TRIG;
|
|
break;
|
|
case "FLASH":
|
|
_status = ARMStatus.FLASH;
|
|
break;
|
|
case "ARMING":
|
|
_status = ARMStatus.ARMING;
|
|
break;
|
|
case "FLASHWRITE":
|
|
_status = ARMStatus.FLASHWRITE;
|
|
break;
|
|
case "OFF":
|
|
_status = ARMStatus.OFF;
|
|
break;
|
|
case "CAL":
|
|
_status = ARMStatus.CAL;
|
|
break;
|
|
default:
|
|
throw new InvalidCastException("invalid status " + token);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TestAll : CommandBase
|
|
{
|
|
public TestAllCommandString.Modes Mode
|
|
{
|
|
get => ((TestAllCommandString)((TDASCommandPacketBase)baseCommand).GetCommandStringObject(0)).Mode;
|
|
set => ((TestAllCommandString)((TDASCommandPacketBase)baseCommand).GetCommandStringObject(0)).Mode = value;
|
|
}
|
|
|
|
public enum VoltageStatus
|
|
{
|
|
High,
|
|
Good,
|
|
Medium,
|
|
Low,
|
|
None
|
|
}
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor InputPower { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor PrimaryPower { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor BackupBattery { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor ModuleBattery { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor ModuleFault { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor RackFault { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor ArmFault { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor TriggerFlag { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
public DFConstantsAndEnums.VoltageStatusColor StartedRecordingFlag { get; private set; } = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
|
|
private static DFConstantsAndEnums.VoltageStatusColor ConvertToEnum(string s)
|
|
{
|
|
switch (s)
|
|
{
|
|
case "R":
|
|
return DFConstantsAndEnums.VoltageStatusColor.Red;
|
|
case "G":
|
|
return DFConstantsAndEnums.VoltageStatusColor.Green;
|
|
case "0":
|
|
return DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
case "O":
|
|
case "N":
|
|
return DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
case "Y":
|
|
return DFConstantsAndEnums.VoltageStatusColor.Yellow;
|
|
default:
|
|
throw new NotSupportedException("unknown flag mode: " + s);
|
|
}
|
|
}
|
|
|
|
public TestAll(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new TestAllCommandString());
|
|
((TDASCommandPacketBase)baseCommand).RebuildBytes = true;
|
|
}
|
|
public TestAll(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeOut)
|
|
: base(sock, msTimeOut)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new TestAllCommandString());
|
|
((TDASCommandPacketBase)baseCommand).RebuildBytes = true;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("TA: ");
|
|
var end = s.IndexOf("\r\n");
|
|
if (start >= 0 && end > start)
|
|
{
|
|
_responseData = s.Substring(start + 4, end - start - 4);
|
|
}
|
|
else { return; }
|
|
|
|
var tokens = ResponseData.Split(' ');
|
|
foreach (var token in tokens)
|
|
{
|
|
var subTokens = token.Split('=');
|
|
if (2 == subTokens.Length)
|
|
{
|
|
switch (subTokens[0])
|
|
{
|
|
case "IP":
|
|
InputPower = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "PP":
|
|
PrimaryPower = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "BB":
|
|
BackupBattery = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "MB":
|
|
ModuleBattery = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "MF":
|
|
ModuleFault = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "RF":
|
|
RackFault = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "AF":
|
|
ArmFault = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "TF":
|
|
TriggerFlag = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
case "SR":
|
|
StartedRecordingFlag = ConvertToEnum(subTokens[1]);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (token.Contains("CURR"))
|
|
{
|
|
continue;
|
|
}
|
|
if (token.Contains("PREV"))
|
|
{
|
|
continue;
|
|
}
|
|
throw new NotSupportedException("unexpected key pair " + token);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public class LEDS : CommandBase
|
|
{
|
|
public enum FlagStatus
|
|
{
|
|
Green,
|
|
Red,
|
|
YellowOrYes,
|
|
Off,
|
|
No
|
|
}
|
|
|
|
public FlagStatus BatteryPower { get; private set; } = FlagStatus.Off;
|
|
|
|
public FlagStatus Cal { get; private set; } = FlagStatus.Off;
|
|
|
|
public FlagStatus CalFault { get; private set; } = FlagStatus.Off;
|
|
|
|
public FlagStatus ArmEvent { get; private set; } = FlagStatus.Off;
|
|
|
|
public FlagStatus RackFault { get; private set; } = FlagStatus.Off;
|
|
|
|
private FlagStatus ConvertToEnum(string s)
|
|
{
|
|
switch (s)
|
|
{
|
|
case "R":
|
|
return FlagStatus.Red;
|
|
case "G":
|
|
return FlagStatus.Green;
|
|
case "0":
|
|
return FlagStatus.Off;
|
|
case "O":
|
|
return FlagStatus.Off;
|
|
case "Y":
|
|
return FlagStatus.YellowOrYes;
|
|
case "N":
|
|
return FlagStatus.No;
|
|
default:
|
|
throw new NotSupportedException("unknown flag mode: " + s);
|
|
}
|
|
}
|
|
|
|
public LEDS(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new LEDSCommandString());
|
|
}
|
|
public LEDS(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeOut)
|
|
: base(sock, msTimeOut)
|
|
{
|
|
baseCommand = new TDASCommandPacketBase(new LEDSCommandString());
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("LEDS: ");
|
|
var end = s.IndexOf("\r\n");
|
|
if (start >= 0 && end > start)
|
|
{
|
|
_responseData = s.Substring(start + 6, end - start - 6);
|
|
}
|
|
else { return; }
|
|
|
|
var tokens = ResponseData.Split(' ');
|
|
foreach (var token in tokens)
|
|
{
|
|
var subTokens = token.Split('=');
|
|
if (2 == subTokens.Length)
|
|
{
|
|
switch (subTokens[0])
|
|
{
|
|
case "BP": BatteryPower = ConvertToEnum(subTokens[1]); break;
|
|
case "CA": Cal = ConvertToEnum(subTokens[1]); break;
|
|
case "CF": CalFault = ConvertToEnum(subTokens[1]); break;
|
|
case "AE": ArmEvent = ConvertToEnum(subTokens[1]); break;
|
|
case "RF": RackFault = ConvertToEnum(subTokens[1]); break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException("unexpected key pair " + token);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
internal class SetupDASLoadDIMCommandString : CommandString
|
|
{
|
|
public string ArmMode { get; set; } = "TAPE";
|
|
|
|
public long SampleRate { get; set; } = 10000;
|
|
|
|
private double _preTriggerTimeInSeconds;
|
|
public double PreTriggerTimeInSeconds
|
|
{
|
|
get => _preTriggerTimeInSeconds;
|
|
set => _preTriggerTimeInSeconds = Math.Abs(value);
|
|
}
|
|
|
|
public double PostTriggerTimeInSeconds { get; set; }
|
|
|
|
public double PostADWaitTime { get; set; } = 1;
|
|
|
|
public string TriggerType { get; set; } = "HW";
|
|
|
|
public int TriggerChannel { get; set; } = 1;
|
|
|
|
private int _numberOfSamplesMeetingTrigger = 1;
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _numberOfSamplesMeetingTrigger;
|
|
set
|
|
{
|
|
if (value >= 1 && value <= 1000)
|
|
{
|
|
_numberOfSamplesMeetingTrigger = value;
|
|
}
|
|
else { throw new NotSupportedException("Invalid number of trigger samples for TDAS PRO " + value); }
|
|
}
|
|
}
|
|
|
|
private string _testId;
|
|
public string TestId
|
|
{
|
|
get => _testId;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testId = newValue;
|
|
}
|
|
}
|
|
|
|
private string _testConfig;
|
|
public string TestConfig
|
|
{
|
|
get => _testConfig;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Length > 240) { newValue = newValue.Substring(0, 240); }
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testConfig = newValue;
|
|
}
|
|
}
|
|
|
|
protected override string _CommandDescription => "SetupDASLoad - SDL (DIM)";
|
|
|
|
protected override string _CommandString => "SDL";
|
|
public bool IsDummyArm { get; set; }
|
|
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData { get; set; } = true;
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.Append(" ");
|
|
sb.Append(ArmMode);
|
|
sb.Append(" ");
|
|
sb.Append(CollectData ? SampleRate.ToString() : (-1 * SampleRate).ToString());
|
|
if (IsDummyArm)
|
|
{
|
|
PostADWaitTime = -1;
|
|
}
|
|
sb.Append(" ");
|
|
sb.Append(PreTriggerTimeInSeconds.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(PostTriggerTimeInSeconds.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(PostADWaitTime.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(TriggerType);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerChannel.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(NumberOfTriggerSamples.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TestId);
|
|
sb.Append(" ");
|
|
sb.Append(TestConfig);
|
|
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
public class SetupDASLoadDIM : CommandBase
|
|
{
|
|
public int ModuleIndex
|
|
{
|
|
get => ((TDASCommandPacketBase)baseCommand).ModuleIndex;
|
|
set => ((TDASCommandPacketBase)baseCommand).ModuleIndex = value;
|
|
}
|
|
|
|
public enum ArmModes
|
|
{
|
|
WAIT,
|
|
TAPE,
|
|
DIAGW
|
|
}
|
|
|
|
public ArmModes ArmMode
|
|
{
|
|
get => (ArmModes)Enum.Parse(typeof(ArmModes), _CommandString.ArmMode);
|
|
set => _CommandString.ArmMode = value.ToString();
|
|
}
|
|
|
|
public long SampleRate
|
|
{
|
|
get => _CommandString.SampleRate;
|
|
set => _CommandString.SampleRate = value;
|
|
}
|
|
|
|
public bool IsDummyArm
|
|
{
|
|
get => _CommandString.IsDummyArm;
|
|
set => _CommandString.IsDummyArm = value;
|
|
}
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData
|
|
{
|
|
get => _CommandString.CollectData;
|
|
set => _CommandString.CollectData = value;
|
|
}
|
|
|
|
public double PreTriggerSeconds
|
|
{
|
|
get => _CommandString.PreTriggerTimeInSeconds;
|
|
set => _CommandString.PreTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostTriggerSeconds
|
|
{
|
|
get => _CommandString.PostTriggerTimeInSeconds;
|
|
set => _CommandString.PostTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostADWaitTime
|
|
{
|
|
get => _CommandString.PostADWaitTime;
|
|
set => _CommandString.PostADWaitTime = value;
|
|
}
|
|
|
|
public enum TriggerTypes
|
|
{
|
|
HW,
|
|
LT
|
|
}
|
|
|
|
public TriggerTypes TriggerType
|
|
{
|
|
get => (TriggerTypes)Enum.Parse(typeof(TriggerTypes), _CommandString.TriggerType);
|
|
set => _CommandString.TriggerType = value.ToString();
|
|
}
|
|
|
|
public int TriggerChannel
|
|
{
|
|
get => _CommandString.TriggerChannel;
|
|
set
|
|
{
|
|
if (value >= 1 && value <= 8)
|
|
{
|
|
_CommandString.TriggerChannel = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _CommandString.NumberOfTriggerSamples;
|
|
set => _CommandString.NumberOfTriggerSamples = value;
|
|
}
|
|
|
|
public string TestId
|
|
{
|
|
get => _CommandString.TestId;
|
|
set => _CommandString.TestId = value;
|
|
}
|
|
|
|
public string TestConfig
|
|
{
|
|
get => _CommandString.TestConfig;
|
|
set => _CommandString.TestConfig = value;
|
|
}
|
|
|
|
|
|
private SetupDASLoadDIMCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as SetupDASLoadDIMCommandString;
|
|
}
|
|
}
|
|
public SetupDASLoadDIM(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupDASLoadDIMCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public SetupDASLoadDIM(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupDASLoadDIMCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
_responseData = "";
|
|
}
|
|
|
|
}
|
|
|
|
internal class SetExcitationCommandString : CommandString
|
|
{
|
|
public int[] Channels { get; set; } = { 0, 1, 2, 3, 4, 5, 6, 7 };
|
|
public int[] ExcitationMode { get; set; } = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
protected override string _CommandDescription => "Set Excitation - E";
|
|
|
|
protected override string _CommandString => "E";
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.Append(" ");
|
|
foreach (var ch in Channels)
|
|
{
|
|
sb.Append(ch);
|
|
}
|
|
|
|
sb.Append(" ");
|
|
|
|
foreach (var exc in ExcitationMode)
|
|
{
|
|
sb.Append(exc);
|
|
}
|
|
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 11326 Failed to arm in check trigger navi step
|
|
/// this command turns excitation back on
|
|
/// </summary>
|
|
public class SetExcitation : CommandBase
|
|
{
|
|
public const int SIM_TWO_VOLT = 1;
|
|
public const int SIM_TEN_VOLT = 2;
|
|
//For more information see 11653 Sample average using TDAS G5 shows larger offset if you run trigger check
|
|
//http://fogbugz/fogbugz/default.asp?11653
|
|
public const int G5_TWO_VOLT = 1;
|
|
public const int G5_FIVE_VOLT = 2;
|
|
public const int FIVE_VOLT = 1;
|
|
public const int SIM_OFF = 0;
|
|
public int ModuleIndex
|
|
{
|
|
get => ((TDASCommandPacketBase)baseCommand).ModuleIndex;
|
|
set => ((TDASCommandPacketBase)baseCommand).ModuleIndex = value;
|
|
}
|
|
|
|
public int[] Channels
|
|
{
|
|
get => _CommandString.Channels;
|
|
set => _CommandString.Channels = value;
|
|
}
|
|
|
|
public int[] ExcitationModes
|
|
{
|
|
get => _CommandString.ExcitationMode;
|
|
set => _CommandString.ExcitationMode = value;
|
|
}
|
|
|
|
private SetExcitationCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as SetExcitationCommandString;
|
|
}
|
|
}
|
|
public SetExcitation(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetExcitationCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public SetExcitation(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetExcitationCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
//we don't currently need the response, so I don't do any further processing
|
|
}
|
|
|
|
}
|
|
internal class SetupDASLoadCommandString : CommandString
|
|
{
|
|
public string ArmMode { get; set; } = "TAPE";
|
|
|
|
public long SampleRate { get; set; } = 10000;
|
|
|
|
public long OutputRate { get; set; }
|
|
|
|
private const int MIN_AAF = 50;
|
|
public int HardwareAAFilter { get; private set; }
|
|
|
|
public void SetHardwareAAFilter(int value, int maxAAFilterRateHz)
|
|
{
|
|
if (0 == value || MIN_AAF <= value && maxAAFilterRateHz >= value)
|
|
{
|
|
HardwareAAFilter = value;
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException("Invalid AAFilter rate for TDAS PRO - " + value);
|
|
}
|
|
}
|
|
|
|
private double _preTriggerTimeInSeconds;
|
|
public double PreTriggerTimeInSeconds
|
|
{
|
|
get => _preTriggerTimeInSeconds;
|
|
set => _preTriggerTimeInSeconds = Math.Abs(value);
|
|
}
|
|
|
|
public double PostTriggerTimeInSeconds { get; set; }
|
|
|
|
public double PostADWaitTime { get; set; } = 1;
|
|
|
|
public string TriggerType { get; set; } = "HW";
|
|
|
|
public int TriggerChannel { get; set; } = 1;
|
|
|
|
public string TriggerMode { get; set; } = "GT";
|
|
|
|
public int TriggerLevelADC { get; set; }
|
|
|
|
private int _numberOfSamplesMeetingTrigger = 1;
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _numberOfSamplesMeetingTrigger;
|
|
set
|
|
{
|
|
if (value >= 1 && value <= 1000)
|
|
{
|
|
_numberOfSamplesMeetingTrigger = value;
|
|
}
|
|
else { throw new NotSupportedException("Invalid number of trigger samples for TDAS PRO " + value); }
|
|
}
|
|
}
|
|
|
|
private string _testId;
|
|
public string TestId
|
|
{
|
|
get => _testId;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testId = newValue;
|
|
}
|
|
}
|
|
|
|
private string _testConfig;
|
|
public string TestConfig
|
|
{
|
|
get => _testConfig;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Length > 240) { newValue = newValue.Substring(0, 240); }
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testConfig = newValue;
|
|
}
|
|
}
|
|
|
|
protected override string _CommandDescription => "SetupDASLoad - SDL";
|
|
|
|
protected override string _CommandString => "SDL";
|
|
public bool IsDummyArm { get; set; }
|
|
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData { get; set; } = true;
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.Append(" ");
|
|
sb.Append(ArmMode);
|
|
sb.Append(" ");
|
|
sb.Append(CollectData ? SampleRate.ToString() : (-1 * SampleRate).ToString());
|
|
if (IsDummyArm)
|
|
{
|
|
PostADWaitTime = -1;
|
|
}
|
|
sb.Append(" ");
|
|
sb.Append(OutputRate.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(HardwareAAFilter);
|
|
sb.Append(" ");
|
|
sb.Append(PreTriggerTimeInSeconds.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(PostTriggerTimeInSeconds.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(PostADWaitTime.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(TriggerType);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerChannel.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TriggerMode);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerLevelADC.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(NumberOfTriggerSamples.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TestId);
|
|
sb.Append(" ");
|
|
sb.Append(TestConfig);
|
|
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
|
|
public class SetupDASLoad : CommandBase
|
|
{
|
|
public int ModuleIndex
|
|
{
|
|
get => ((TDASCommandPacketBase)baseCommand).ModuleIndex;
|
|
set => ((TDASCommandPacketBase)baseCommand).ModuleIndex = value;
|
|
}
|
|
|
|
public enum ARMMode
|
|
{
|
|
WAIT,
|
|
TAPE,
|
|
DIAGW
|
|
}
|
|
|
|
public ARMMode ArmMode
|
|
{
|
|
get => (ARMMode)Enum.Parse(typeof(ARMMode), _CommandString.ArmMode);
|
|
set => _CommandString.ArmMode = value.ToString();
|
|
}
|
|
|
|
public long SampleRate
|
|
{
|
|
get => _CommandString.SampleRate;
|
|
set => _CommandString.SampleRate = value;
|
|
}
|
|
|
|
public bool IsDummyArm
|
|
{
|
|
get => _CommandString.IsDummyArm;
|
|
set => _CommandString.IsDummyArm = value;
|
|
}
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData
|
|
{
|
|
get => _CommandString.CollectData;
|
|
set => _CommandString.CollectData = value;
|
|
}
|
|
public long OutputRate
|
|
{
|
|
get => _CommandString.OutputRate;
|
|
set => _CommandString.OutputRate = value;
|
|
}
|
|
|
|
public int HardwareAAFilter => _CommandString.HardwareAAFilter;
|
|
|
|
public void SetHardwareAAFilter(int value, uint maxAAF)
|
|
{
|
|
_CommandString.SetHardwareAAFilter(value, Convert.ToInt32(maxAAF));
|
|
}
|
|
public double PreTriggerSeconds
|
|
{
|
|
get => _CommandString.PreTriggerTimeInSeconds;
|
|
set => _CommandString.PreTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostTriggerSeconds
|
|
{
|
|
get => _CommandString.PostTriggerTimeInSeconds;
|
|
set => _CommandString.PostTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostADWaitTime
|
|
{
|
|
get => _CommandString.PostADWaitTime;
|
|
set => _CommandString.PostADWaitTime = value;
|
|
}
|
|
|
|
public enum TriggerTypes
|
|
{
|
|
HW,
|
|
LV,
|
|
BUS
|
|
}
|
|
|
|
public TriggerTypes TriggerType
|
|
{
|
|
get => (TriggerTypes)Enum.Parse(typeof(TriggerTypes), _CommandString.TriggerType);
|
|
set => _CommandString.TriggerType = value.ToString();
|
|
}
|
|
|
|
public int TriggerChannel
|
|
{
|
|
get => _CommandString.TriggerChannel;
|
|
set => _CommandString.TriggerChannel = value;
|
|
}
|
|
|
|
public enum TriggerModes
|
|
{
|
|
GT,
|
|
LT
|
|
}
|
|
|
|
public TriggerModes TriggerMode
|
|
{
|
|
get => (TriggerModes)Enum.Parse(typeof(TriggerModes), _CommandString.TriggerMode);
|
|
set => _CommandString.TriggerMode = value.ToString();
|
|
}
|
|
|
|
public int TriggerLevelADC
|
|
{
|
|
get => _CommandString.TriggerLevelADC;
|
|
set => _CommandString.TriggerLevelADC = value;
|
|
}
|
|
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _CommandString.NumberOfTriggerSamples;
|
|
set => _CommandString.NumberOfTriggerSamples = value;
|
|
}
|
|
|
|
public string TestId
|
|
{
|
|
get => _CommandString.TestId;
|
|
set => _CommandString.TestId = value;
|
|
}
|
|
|
|
public string TestConfig
|
|
{
|
|
get => _CommandString.TestConfig;
|
|
set => _CommandString.TestConfig = value;
|
|
}
|
|
|
|
|
|
private SetupDASLoadCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as SetupDASLoadCommandString;
|
|
}
|
|
}
|
|
public SetupDASLoad(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupDASLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public SetupDASLoad(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupDASLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
_responseData = "";
|
|
}
|
|
|
|
}
|
|
|
|
// CLH 6/20/2017
|
|
|
|
internal class SetupDASLoadBroadcastCommandString : CommandString
|
|
{
|
|
private string _armMode = "TAPE";
|
|
public string ArmMode
|
|
{
|
|
get { return _armMode; }
|
|
set { _armMode = value; }
|
|
}
|
|
|
|
private long _sampleRate = 10000;
|
|
public long SampleRate
|
|
{
|
|
get { return _sampleRate; }
|
|
set { _sampleRate = value; }
|
|
}
|
|
|
|
private long _outputRate = 0;
|
|
public long OutputRate
|
|
{
|
|
get { return _outputRate; }
|
|
set { _outputRate = value; }
|
|
}
|
|
|
|
//private int MaxAAFilterRateHz = 4300;
|
|
private int _hardwareAAFilter = 0;
|
|
private const int MIN_AAF = 50;
|
|
public int HardwareAAFilter
|
|
{
|
|
get { return _hardwareAAFilter; }
|
|
}
|
|
public void SetHardwareAAFilter(int value, int MaxAAFilterRateHz)
|
|
{
|
|
if (0 == value || (MIN_AAF <= value && MaxAAFilterRateHz >= value))
|
|
{
|
|
_hardwareAAFilter = value;
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException("Invalid AAFilter rate for TDAS PRO - " + value);
|
|
}
|
|
}
|
|
|
|
private double _preTriggerTimeInSeconds;
|
|
public double PreTriggerTimeInSeconds
|
|
{
|
|
get { return _preTriggerTimeInSeconds; }
|
|
set { _preTriggerTimeInSeconds = System.Math.Abs(value); }
|
|
}
|
|
|
|
private double _postTriggerTimeInSeconds;
|
|
public double PostTriggerTimeInSeconds
|
|
{
|
|
get { return _postTriggerTimeInSeconds; }
|
|
set { _postTriggerTimeInSeconds = value; }
|
|
}
|
|
|
|
private double _postADWaitTime = 1;
|
|
public double PostADWaitTime
|
|
{
|
|
get { return _postADWaitTime; }
|
|
set { _postADWaitTime = value; }
|
|
}
|
|
|
|
private string _triggerType = "HW";
|
|
public string TriggerType
|
|
{
|
|
get { return _triggerType; }
|
|
set { _triggerType = value; }
|
|
}
|
|
|
|
private int _triggerChannel = 1;
|
|
public int TriggerChannel
|
|
{
|
|
get { return _triggerChannel; }
|
|
set { _triggerChannel = value; }
|
|
}
|
|
|
|
private string _triggerMode = "GT";
|
|
public string TriggerMode
|
|
{
|
|
get { return _triggerMode; }
|
|
set { _triggerMode = value; }
|
|
}
|
|
|
|
private int _triggerLevelADC = 0;
|
|
public int TriggerLevelADC
|
|
{
|
|
get { return _triggerLevelADC; }
|
|
set { _triggerLevelADC = value; }
|
|
}
|
|
|
|
private int _numberOfSamplesMeetingTrigger = 1;
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get { return _numberOfSamplesMeetingTrigger; }
|
|
set
|
|
{
|
|
if (value >= 1 && value <= 1000)
|
|
{
|
|
_numberOfSamplesMeetingTrigger = value;
|
|
}
|
|
else { throw new NotSupportedException("Invalid number of trigger samples for TDAS PRO " + value); }
|
|
}
|
|
}
|
|
|
|
private string _testId;
|
|
public string TestId
|
|
{
|
|
get { return _testId; }
|
|
set
|
|
{
|
|
string newValue = value;
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = string.Format("\"{0}\"", newValue);
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testId = newValue;
|
|
}
|
|
}
|
|
|
|
private string _testConfig;
|
|
public string TestConfig
|
|
{
|
|
get { return _testConfig; }
|
|
set
|
|
{
|
|
string newValue = value;
|
|
if (newValue.Length > 240) { newValue = newValue.Substring(0, 240); }
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = string.Format("\"{0}\"", newValue);
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testConfig = newValue;
|
|
}
|
|
}
|
|
|
|
protected override string _CommandDescription
|
|
{
|
|
get { return "SetupDASLoad - SDL (*)"; }
|
|
}
|
|
protected override string _CommandString
|
|
{
|
|
get
|
|
{
|
|
if (ModuleIndex >= 0) { return string.Format("*{0}SDL", ModuleIndex); }
|
|
else { return "*SDL"; }
|
|
}
|
|
}
|
|
|
|
private bool _bIsDummyArm = false;
|
|
public bool IsDummyArm
|
|
{
|
|
get { return _bIsDummyArm; }
|
|
set { _bIsDummyArm = value; }
|
|
}
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append(" ");
|
|
/*if (IsDummyArm)
|
|
{
|
|
switch (ArmMode)
|
|
{ //note, only need DIAG, the T or W is ignored.
|
|
case "TAPE":
|
|
sb.Append("DIAGT");
|
|
break;
|
|
default:
|
|
sb.Append("DIAGW");
|
|
break;
|
|
}
|
|
}
|
|
else { sb.Append(ArmMode); }*/
|
|
sb.Append(ArmMode);
|
|
sb.Append(" ");
|
|
if (IsDummyArm) { sb.Append((-1 * SampleRate).ToString()); PostADWaitTime = 0; }
|
|
else { sb.Append(SampleRate.ToString()); }
|
|
//sb.Append(SampleRate.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(OutputRate.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(HardwareAAFilter);
|
|
sb.Append(" ");
|
|
sb.Append(PreTriggerTimeInSeconds.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(PostTriggerTimeInSeconds.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(PostADWaitTime.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TriggerType);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerChannel.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TriggerMode);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerLevelADC.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(NumberOfTriggerSamples.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TestId);
|
|
sb.Append(" ");
|
|
sb.Append(TestConfig);
|
|
|
|
return ASCIIEncoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
|
|
private int _moduleIndex = 0;
|
|
public int ModuleIndex { get { return _moduleIndex; } set { _moduleIndex = value; } }
|
|
|
|
public SetupDASLoadBroadcastCommandString(int moduleIndex)
|
|
{
|
|
_moduleIndex = moduleIndex;
|
|
RackCommand = false;
|
|
}
|
|
}
|
|
|
|
public class SetupDASLoadBroadcast : CommandBase
|
|
{
|
|
//public int ModuleIndex
|
|
//{
|
|
// get { return (baseCommand as TDASCommandPacketBase).ModuleIndex; }
|
|
// set { (baseCommand as TDASCommandPacketBase).ModuleIndex = value; }
|
|
//}
|
|
|
|
//public enum ARMMode
|
|
//{
|
|
// WAIT,
|
|
// TAPE,
|
|
// DIAGW
|
|
//}
|
|
|
|
public SetupDASLoad.ARMMode ArmMode
|
|
{
|
|
get
|
|
{
|
|
return (SetupDASLoad.ARMMode)Enum.Parse(typeof(SetupDASLoad.ARMMode), _CommandString.ArmMode);
|
|
}
|
|
set
|
|
{
|
|
_CommandString.ArmMode = value.ToString();
|
|
}
|
|
}
|
|
|
|
public long SampleRate
|
|
{
|
|
get { return _CommandString.SampleRate; }
|
|
set { _CommandString.SampleRate = value; }
|
|
}
|
|
|
|
public bool IsDummyArm
|
|
{
|
|
get { return _CommandString.IsDummyArm; }
|
|
set { _CommandString.IsDummyArm = value; }
|
|
}
|
|
|
|
public long OutputRate
|
|
{
|
|
get { return _CommandString.OutputRate; }
|
|
set { _CommandString.OutputRate = value; }
|
|
}
|
|
|
|
public int HardwareAAFilter
|
|
{
|
|
get { return _CommandString.HardwareAAFilter; }
|
|
//set { _CommandString.HardwareAAFilter = value; }
|
|
}
|
|
public void SetHardwareAAFilter(int value, uint MaxAAF)
|
|
{
|
|
_CommandString.SetHardwareAAFilter(value, Convert.ToInt32(MaxAAF));
|
|
}
|
|
public double PreTriggerSeconds
|
|
{
|
|
get { return _CommandString.PreTriggerTimeInSeconds; }
|
|
set { _CommandString.PreTriggerTimeInSeconds = value; }
|
|
}
|
|
|
|
public double PostTriggerSeconds
|
|
{
|
|
get { return _CommandString.PostTriggerTimeInSeconds; }
|
|
set { _CommandString.PostTriggerTimeInSeconds = value; }
|
|
}
|
|
|
|
public double PostADWaitTime
|
|
{
|
|
get { return _CommandString.PostADWaitTime; }
|
|
set { _CommandString.PostADWaitTime = value; }
|
|
}
|
|
|
|
//public enum TriggerTypes
|
|
//{
|
|
// HW,
|
|
// LV,
|
|
// BUS
|
|
//}
|
|
|
|
public SetupDASLoad.TriggerTypes TriggerType
|
|
{
|
|
get { return (SetupDASLoad.TriggerTypes)Enum.Parse(typeof(SetupDASLoad.TriggerTypes), _CommandString.TriggerType); }
|
|
set { _CommandString.TriggerType = value.ToString(); }
|
|
}
|
|
|
|
public int TriggerChannel
|
|
{
|
|
get { return _CommandString.TriggerChannel; }
|
|
set { _CommandString.TriggerChannel = value; }
|
|
}
|
|
|
|
//public enum TriggerModes
|
|
//{
|
|
// GT,
|
|
// LT
|
|
//}
|
|
|
|
public SetupDASLoad.TriggerModes TriggerMode
|
|
{
|
|
get { return (SetupDASLoad.TriggerModes)Enum.Parse(typeof(SetupDASLoad.TriggerModes), _CommandString.TriggerMode); }
|
|
set { _CommandString.TriggerMode = value.ToString(); }
|
|
}
|
|
|
|
public int TriggerLevelADC
|
|
{
|
|
get { return _CommandString.TriggerLevelADC; }
|
|
set { _CommandString.TriggerLevelADC = value; }
|
|
}
|
|
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get { return _CommandString.NumberOfTriggerSamples; }
|
|
set { _CommandString.NumberOfTriggerSamples = value; }
|
|
}
|
|
|
|
public string TestId
|
|
{
|
|
get { return _CommandString.TestId; }
|
|
set { _CommandString.TestId = value; }
|
|
}
|
|
|
|
public string TestConfig
|
|
{
|
|
get { return _CommandString.TestConfig; }
|
|
set { _CommandString.TestConfig = value; }
|
|
}
|
|
|
|
|
|
private SetupDASLoadBroadcastCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
TDASCommandPacketBase command = baseCommand as TDASCommandPacketBase;
|
|
return command.GetCommandStringObject(0) as SetupDASLoadBroadcastCommandString;
|
|
}
|
|
}
|
|
public SetupDASLoadBroadcast(DTS.Common.Interface.DASFactory.ICommunication sock, int moduleIndex)
|
|
: base(sock)
|
|
{
|
|
TDASCommandPacketBase command = new TDASCommandPacketBase(new SetupDASLoadBroadcastCommandString(moduleIndex));
|
|
baseCommand = command;
|
|
command.RebuildBytes = true;
|
|
command.RackCommand = false;
|
|
command.SingleModuleCommand = base.SingleModuleCommand;
|
|
}
|
|
public SetupDASLoadBroadcast(DTS.Common.Interface.DASFactory.ICommunication sock, int moduleIndex, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
TDASCommandPacketBase command = new TDASCommandPacketBase(new SetupDASLoadBroadcastCommandString(moduleIndex));
|
|
baseCommand = command;
|
|
command.RebuildBytes = true;
|
|
command.RackCommand = false;
|
|
command.SingleModuleCommand = base.SingleModuleCommand;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
_responseData = "";
|
|
}
|
|
|
|
}
|
|
|
|
internal class SetupG5LevelTriggerCommandString : CommandString
|
|
{
|
|
public int TriggerChannel { get; set; } = 1;
|
|
|
|
public int TriggerLevelLowADC { get; set; }
|
|
|
|
public int TriggerLevelHighADC { get; set; }
|
|
|
|
private int _numberOfSamplesMeetingTrigger = 1;
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _numberOfSamplesMeetingTrigger;
|
|
set
|
|
{
|
|
if (value >= 1 && value <= 1000)
|
|
{
|
|
_numberOfSamplesMeetingTrigger = value;
|
|
}
|
|
else { throw new NotSupportedException("Invalid number of trigger samples for TDAS G5 " + value); }
|
|
}
|
|
}
|
|
|
|
public string LevelTriggerType { get; set; } = "OW";
|
|
|
|
protected override string _CommandDescription => "SetupTrig";
|
|
|
|
protected override string _CommandString => "SETUP TRIG A"; //UNITS [A]DC cnts, [V]olts, [E]ngineering Units
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.Append(" ");
|
|
sb.Append(TriggerChannel.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(LevelTriggerType);
|
|
sb.Append(" ");
|
|
sb.Append(TriggerLevelLowADC.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(TriggerLevelHighADC.ToString());
|
|
sb.Append(" ");
|
|
|
|
sb.Append(NumberOfTriggerSamples.ToString());
|
|
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
|
|
public class SetupG5LevelTrigger : CommandBase
|
|
{
|
|
public enum LevelTriggerTypes
|
|
{
|
|
OW,//OUTSIDEWINDOW
|
|
IW,//INSIDEWINDOW
|
|
GT,//greater than
|
|
LT,//less than
|
|
}
|
|
public LevelTriggerTypes LevelTriggerType
|
|
{
|
|
get => Enum.TryParse(_CommandString.LevelTriggerType, out LevelTriggerTypes type) ? type : LevelTriggerTypes.OW;
|
|
set => _CommandString.LevelTriggerType = value.ToString();
|
|
}
|
|
public int TriggerChannel
|
|
{
|
|
get => _CommandString.TriggerChannel;
|
|
set => _CommandString.TriggerChannel = value;
|
|
}
|
|
|
|
public int TriggerLevelLowADC
|
|
{
|
|
get => _CommandString.TriggerLevelLowADC;
|
|
set => _CommandString.TriggerLevelLowADC = value;
|
|
}
|
|
|
|
public int TriggerLevelHighADC
|
|
{
|
|
get => _CommandString.TriggerLevelHighADC;
|
|
set => _CommandString.TriggerLevelHighADC = value;
|
|
}
|
|
|
|
public int NumberOfTriggerSamples
|
|
{
|
|
get => _CommandString.NumberOfTriggerSamples;
|
|
set => _CommandString.NumberOfTriggerSamples = value;
|
|
}
|
|
|
|
private SetupG5LevelTriggerCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as SetupG5LevelTriggerCommandString;
|
|
}
|
|
}
|
|
public SetupG5LevelTrigger(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupG5LevelTriggerCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public SetupG5LevelTrigger(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupG5LevelTriggerCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("SETUP: TRIG");
|
|
var end = s.LastIndexOf("\r\n");
|
|
System.Diagnostics.Debug.Assert(start >= 0 && end > start);
|
|
_responseData = s.Substring(start + 7, end - start - 7);
|
|
}
|
|
}
|
|
public class QueryTriggerLine : CommandBase
|
|
{
|
|
public QueryTriggerLine(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new QueryTriggerLineCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public QueryTriggerLine(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new QueryTriggerLineCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
public bool IsTriggered { get; private set; } = true;
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("TDT: 5 ");
|
|
var end = s.LastIndexOf("\r\n");
|
|
System.Diagnostics.Debug.Assert(start >= 0 && end > start);
|
|
_responseData = s.Substring(start + 7, end - start - 7);
|
|
if (_responseData == "0" || _responseData == "0 OK") { IsTriggered = false; } else { IsTriggered = true; }
|
|
}
|
|
|
|
public int ModuleIndex
|
|
{
|
|
set => (baseCommand as TDASCommandPacketBase).ModuleIndex = value;
|
|
}
|
|
}
|
|
internal class QueryTriggerLineCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "TDT 5";
|
|
|
|
protected override string _CommandString => "TDT 5";
|
|
|
|
public QueryTriggerLineCommandString()
|
|
{
|
|
RackCommand = false;
|
|
ExpectsData = true;
|
|
}
|
|
}
|
|
internal class ModuleArmBroadcastCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "Module Arm (broadcast)";
|
|
|
|
protected override string _CommandString => string.Format("*{0}ARM", _moduleIndex);
|
|
|
|
private int _moduleIndex;
|
|
|
|
public ModuleArmBroadcastCommandString(int index)
|
|
{
|
|
_moduleIndex = index;
|
|
RackCommand = false;
|
|
}
|
|
}
|
|
public class ModuleArmBroadcast : CommandBase
|
|
{
|
|
//17717 ModuleArmBroadcast must wait on G5
|
|
//this variable is to keep track of whether we are waiting or not
|
|
private bool _bExpectsResponse;
|
|
|
|
public ModuleArmBroadcast(DTS.Common.Interface.DASFactory.ICommunication sock, int moduleIndex, bool expectsResponse)
|
|
: base(sock)
|
|
{
|
|
_bExpectsResponse = expectsResponse;
|
|
var command = new TDASCommandPacketBase(new ModuleArmBroadcastCommandString(moduleIndex));
|
|
command.ExpectsData = expectsResponse;
|
|
command.ReplyWait = 0;
|
|
command.RebuildBytes = true;
|
|
command.RackCommand = false;
|
|
baseCommand = command;
|
|
}
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>(new[] { $"1000ARM {ResponseData}" }));
|
|
}
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
|
|
|
|
if (s.ToLower().Contains("err"))
|
|
{
|
|
throw new Exception($"Failed to arm {s}");
|
|
}
|
|
}
|
|
}
|
|
internal class QueryFlashClearCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "FLASH CLEAR?";
|
|
|
|
protected override string _CommandString => "FLASH CLEAR?";
|
|
|
|
public QueryFlashClearCommandString()
|
|
{
|
|
RackCommand = false;
|
|
ExpectsData = true;
|
|
}
|
|
}
|
|
public class QueryFlashClear : CommandBase
|
|
{
|
|
public QueryFlashClear(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new QueryFlashClearCommandString());
|
|
command.ModuleIndex = 0;
|
|
command.RebuildBytes = true;
|
|
command.RackCommand = false;
|
|
baseCommand = command;
|
|
}
|
|
public QueryFlashClear(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new QueryFlashClearCommandString());
|
|
command.ModuleIndex = 0;
|
|
command.RebuildBytes = true;
|
|
command.RackCommand = false;
|
|
baseCommand = command;
|
|
}
|
|
public bool Done
|
|
{
|
|
get
|
|
{
|
|
if (null == _responseData)
|
|
{
|
|
ProcessData();
|
|
}
|
|
return _responseData == "Y";
|
|
}
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (!(baseResponse is TDASCommandPacketBase response)) { return; }
|
|
var s = Encoding.ASCII.GetString(response.ToBytes());
|
|
const string commandString = "FLASH: CLEAR? ";
|
|
var start = s.IndexOf(commandString);
|
|
var end = s.LastIndexOf("\r\n");
|
|
System.Diagnostics.Debug.Assert(start >= 0 && end > start);
|
|
_responseData = s.Substring(start + commandString.Length, end - start - commandString.Length);
|
|
}
|
|
}
|
|
internal class ArmSetupLoadCommandString : CommandString
|
|
{
|
|
public string ArmMode { get; set; } = "TAPE";
|
|
|
|
public string RackArmMode { get; set; } = "SOLO";
|
|
|
|
public long SampleRate { get; set; } = 10000;
|
|
|
|
public double PostTriggerTimeInSeconds { get; set; } = 3D;
|
|
|
|
public int PostADWait { get; set; }
|
|
|
|
protected override string _CommandDescription => "ARM SETUP LOAD";
|
|
|
|
protected override string _CommandString => "ARM SETUP LOAD";
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.Append(" ");
|
|
sb.Append(ArmMode);
|
|
sb.Append(" ");
|
|
sb.Append(RackArmMode);
|
|
sb.Append(" ");
|
|
sb.Append(SampleRate.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(PostTriggerTimeInSeconds);
|
|
sb.Append(" ");
|
|
sb.Append(PostADWait);
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
public ArmSetupLoadCommandString()
|
|
{
|
|
RackCommand = true;
|
|
}
|
|
}
|
|
public class ArmSetupLoad : CommandBase
|
|
{
|
|
private ArmSetupLoadCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as ArmSetupLoadCommandString;
|
|
}
|
|
}
|
|
|
|
public enum ArmModes
|
|
{
|
|
TAPE,
|
|
WAIT
|
|
}
|
|
public ArmModes ArmMode
|
|
{
|
|
get => (ArmModes)Enum.Parse(typeof(ArmModes), _CommandString.ArmMode);
|
|
set => _CommandString.ArmMode = value.ToString();
|
|
}
|
|
//solo and sys are used when we are arming a rack to tell it whether it is part of a system or not
|
|
//being part of a system means it will check it's incoming status line
|
|
//solo means it will not monitor the incoming status
|
|
//there is also an ARM RF command which will turn on the incoming status line monitoring as well
|
|
//this needs to be done because in recorder mode the firmware will turn on monitoring when start is pressed
|
|
//but in circular buffer we need to turn it on ourselves using the ARM RF command.
|
|
public enum RackArmModes
|
|
{
|
|
SOLO,
|
|
SYS
|
|
}
|
|
public RackArmModes RackArmMode
|
|
{
|
|
get => (RackArmModes)Enum.Parse(typeof(RackArmModes), _CommandString.RackArmMode);
|
|
set => _CommandString.RackArmMode = value.ToString();
|
|
}
|
|
|
|
public long SampleRate
|
|
{
|
|
get => _CommandString.SampleRate;
|
|
set => _CommandString.SampleRate = value;
|
|
}
|
|
public double PostTriggerSeconds
|
|
{
|
|
get => _CommandString.PostTriggerTimeInSeconds;
|
|
set => _CommandString.PostTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public int PostADWait
|
|
{
|
|
get => _CommandString.PostADWait;
|
|
set => _CommandString.PostADWait = value;
|
|
}
|
|
|
|
public ArmSetupLoad(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new ArmSetupLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public ArmSetupLoad(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new ArmSetupLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var start = s.IndexOf("ARM: SETUP LOAD");
|
|
var end = s.LastIndexOf("\r\n");
|
|
System.Diagnostics.Debug.Assert(start >= 0 && end > start);
|
|
_responseData = s.Substring(start + 7, end - start - 7);
|
|
}
|
|
}
|
|
internal class RackArmCommandString : CommandString
|
|
{
|
|
public string ArmState { get; set; } = "NOW";
|
|
|
|
protected override string _CommandDescription => "ARM (Rack)";
|
|
|
|
protected override string _CommandString => "ARM";
|
|
|
|
public RackArmCommandString()
|
|
{
|
|
RackCommand = true;
|
|
}
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.Append(" ");
|
|
sb.Append(ArmState);
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
//.............X...X..*FLASH CLEAR 10000.0 10.0 32 0
|
|
//sample rate, min( pre + post, 32, 0
|
|
internal class RackFlashClearCommandString : CommandString
|
|
{
|
|
public double RecordingTime { get; set; } = 10D;
|
|
|
|
public double SampleRate { get; set; } = 10000D;
|
|
|
|
public int NumberOfChannels { get; set; } = 32;
|
|
|
|
public int LastParameter { get; set; } = 0;
|
|
|
|
protected override string _CommandDescription => "Flash Clear (Rack)";
|
|
|
|
protected override string _CommandString => "FLASH CLEAR";
|
|
|
|
public RackFlashClearCommandString()
|
|
{
|
|
RackCommand = true;
|
|
}
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.Append(" ");
|
|
sb.Append(SampleRate.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(RecordingTime.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(" ");
|
|
sb.Append(NumberOfChannels.ToString());
|
|
sb.Append(" ");
|
|
sb.Append(LastParameter.ToString());
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
public class RackFlashClear : CommandBase
|
|
{
|
|
private RackFlashClearCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as RackFlashClearCommandString;
|
|
}
|
|
}
|
|
public double SampleRate
|
|
{
|
|
get => _CommandString.SampleRate;
|
|
set => _CommandString.SampleRate = value;
|
|
}
|
|
public double RecordingTime
|
|
{
|
|
get => _CommandString.RecordingTime;
|
|
set => _CommandString.RecordingTime = value;
|
|
}
|
|
public int NumberOfChannels
|
|
{
|
|
get => _CommandString.NumberOfChannels;
|
|
set => _CommandString.NumberOfChannels = value;
|
|
}
|
|
public RackFlashClear(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackFlashClearCommandString());
|
|
command.RebuildBytes = true;
|
|
command.ReplyWait = 0;
|
|
baseCommand = command;
|
|
}
|
|
public RackFlashClear(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackFlashClearCommandString());
|
|
command.RebuildBytes = true;
|
|
command.ReplyWait = 0;
|
|
baseCommand = command;
|
|
}
|
|
protected override void ProcessData()
|
|
{
|
|
var response = baseResponse as TDASCommandPacketBase;
|
|
if (null == response) { return; }
|
|
var s = Encoding.ASCII.GetString(response.ToBytes());
|
|
const string commandstring = "FLASH: ";
|
|
var start = s.IndexOf(commandstring);
|
|
var end = s.LastIndexOf("\r\n");
|
|
System.Diagnostics.Debug.Assert(start >= 0 && end > start);
|
|
var csLength = commandstring.Length + 2;
|
|
_responseData = s.Substring(start + csLength, end - start - csLength);
|
|
}
|
|
}
|
|
public class RackArm : CommandBase
|
|
{
|
|
private RackArmCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as RackArmCommandString;
|
|
}
|
|
}
|
|
|
|
public new bool IsErrored { get; private set; }
|
|
|
|
//RF tells the firmware to start monitoring the status line
|
|
//this should be used in conjunction with the SYS rack arm mode
|
|
//this is used when in circular buffer. In recorder mode the firmware will turn on the checking
|
|
//when start record is received, however in circular buffer we need to send the ARM RF ourselves
|
|
public enum ArmStates
|
|
{
|
|
NOW,
|
|
OFF,
|
|
RF,
|
|
NOW_TEST //only really useful for G5, Rack will ignore the TEST portion of the command (per TJK)
|
|
}
|
|
public ArmStates ArmState
|
|
{
|
|
get
|
|
{
|
|
switch (_CommandString.ArmState)
|
|
{
|
|
case "OFF": return ArmStates.OFF;
|
|
case "RF": return ArmStates.RF;
|
|
case "NOW TEST": return ArmStates.NOW_TEST;
|
|
default:
|
|
return ArmStates.NOW;
|
|
|
|
}
|
|
}
|
|
set
|
|
{
|
|
switch (value)
|
|
{
|
|
case ArmStates.OFF: _CommandString.ArmState = "OFF"; break;
|
|
case ArmStates.NOW_TEST: _CommandString.ArmState = "NOW TEST"; break;
|
|
case ArmStates.RF:
|
|
_CommandString.ArmState = "RF"; break;
|
|
default:
|
|
_CommandString.ArmState = "NOW"; break;
|
|
}
|
|
}
|
|
}
|
|
public RackArm(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackArmCommandString());
|
|
command.RebuildBytes = true;
|
|
command.ReplyWait = 0;
|
|
baseCommand = command;
|
|
}
|
|
public RackArm(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackArmCommandString());
|
|
command.RebuildBytes = true;
|
|
command.ReplyWait = 0;
|
|
baseCommand = command;
|
|
}
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
var s = Encoding.ASCII.GetString(baseResponse.ToBytes());
|
|
var cs = "1000ARM";
|
|
if (s.Contains(cs))
|
|
{
|
|
_responseData = s.Substring(s.IndexOf(cs) + cs.Length - 1);
|
|
}
|
|
if (s.ToLower().Contains($"{_CommandString.ArmState.ToLower()} err")) { IsErrored = true; }
|
|
}
|
|
}
|
|
|
|
internal class DownloadCommandString : CommandString
|
|
{
|
|
public bool DoCurrentDownload { get; set; }
|
|
|
|
public bool DoVoltageOrInsertionDownload { get; set; }
|
|
|
|
private const int DMA_SIZE = 1024;
|
|
public int Channel { get; set; }
|
|
|
|
public long FirstPoint { get; set; }
|
|
|
|
public bool DigitalInput { get; set; }
|
|
|
|
public int Bank { get; set; } = 1;
|
|
|
|
public long LastPoint { get; set; }
|
|
|
|
protected override string _CommandDescription => "Download - RP";
|
|
|
|
protected override string _CommandString => "RP";
|
|
|
|
public DownloadCommandString()
|
|
{
|
|
RackCommand = false;
|
|
}
|
|
public override byte[] GetParameters()
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.Append(" ");
|
|
sb.Append(DMA_SIZE);
|
|
sb.Append(" ");
|
|
if (DigitalInput)
|
|
{
|
|
sb.AppendFormat("d{0}", Bank);
|
|
}
|
|
else
|
|
{
|
|
if (DoCurrentDownload) { sb.Append("I"); }
|
|
else if (DoVoltageOrInsertionDownload) { sb.Append("V"); }
|
|
sb.Append(Channel);
|
|
}
|
|
sb.Append(" ");
|
|
sb.Append(FirstPoint);
|
|
sb.Append(" ");
|
|
sb.Append(LastPoint);
|
|
return Encoding.ASCII.GetBytes(sb.ToString());
|
|
}
|
|
}
|
|
public class Download : CommandBase
|
|
{
|
|
public bool Digital
|
|
{
|
|
get => _CommandString.DigitalInput;
|
|
set => _CommandString.DigitalInput = value;
|
|
}
|
|
public int Bank
|
|
{
|
|
get => _CommandString.Bank;
|
|
set => _CommandString.Bank = value;
|
|
}
|
|
public bool DoVoltageOrInsertionDownload
|
|
{
|
|
get => _CommandString.DoVoltageOrInsertionDownload;
|
|
set => _CommandString.DoVoltageOrInsertionDownload = value;
|
|
}
|
|
public bool DoCurrentDownload
|
|
{
|
|
get => _CommandString.DoCurrentDownload;
|
|
set => _CommandString.DoCurrentDownload = value;
|
|
}
|
|
public int ModuleIndex
|
|
{
|
|
get => ((TDASCommandPacketBase)baseCommand).ModuleIndex;
|
|
set => ((TDASCommandPacketBase)baseCommand).ModuleIndex = value;
|
|
}
|
|
public int ChannelIndex
|
|
{
|
|
get => _CommandString.Channel;
|
|
set => _CommandString.Channel = value;
|
|
}
|
|
public short[] GetData()
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetData();
|
|
}
|
|
public int GetExpectedBytes()
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command.GetExpectedBytes();
|
|
}
|
|
private DownloadCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as DownloadCommandString;
|
|
}
|
|
}
|
|
|
|
public long FirstPoint
|
|
{
|
|
get => _CommandString.FirstPoint;
|
|
set => _CommandString.FirstPoint = value;
|
|
}
|
|
public long LastPoint
|
|
{
|
|
get => _CommandString.LastPoint;
|
|
set => _CommandString.LastPoint = value;
|
|
}
|
|
public Download(DTS.Common.Interface.DASFactory.ICommunication sock, Download copy)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new DownloadCommandString());
|
|
command.UseMDBMode = true;
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
FirstPoint = copy.FirstPoint;
|
|
LastPoint = copy.LastPoint;
|
|
ChannelIndex = copy.ChannelIndex;
|
|
ModuleIndex = copy.ModuleIndex;
|
|
DoCurrentDownload = copy.DoCurrentDownload;
|
|
DoVoltageOrInsertionDownload = copy.DoVoltageOrInsertionDownload;
|
|
Bank = copy.Bank;
|
|
Digital = copy.Digital;
|
|
}
|
|
public Download(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new DownloadCommandString());
|
|
command.UseMDBMode = true;
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public Download(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new DownloadCommandString());
|
|
command.UseMDBMode = true;
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
protected override void ProcessData()
|
|
{
|
|
_responseData = "";
|
|
}
|
|
}
|
|
|
|
internal class RackStartCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "START";
|
|
|
|
protected override string _CommandString => "START";
|
|
|
|
public RackStartCommandString()
|
|
{
|
|
RackCommand = true;
|
|
}
|
|
}
|
|
public class RackStartCommand : CommandBase
|
|
{
|
|
public RackStartCommand(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackStartCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public RackStartCommand(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackStartCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
}
|
|
|
|
internal class RackTriggerCommandString : CommandString
|
|
{
|
|
protected override string _CommandDescription => "TRIG";
|
|
|
|
protected override string _CommandString => "TRIG";
|
|
|
|
public RackTriggerCommandString()
|
|
{
|
|
RackCommand = true;
|
|
}
|
|
}
|
|
public class RackTriggerCommand : CommandBase
|
|
{
|
|
public RackTriggerCommand(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackTriggerCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public RackTriggerCommand(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new RackTriggerCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
}
|
|
internal class SetupTOMDasLoadCommandString : CommandString
|
|
{
|
|
public string ArmMode { get; set; } = "DIAGW";
|
|
|
|
public long SampleRate { get; set; } = 10000;
|
|
|
|
public bool IsDummyArm { get; set; }
|
|
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData { get; set; } = true;
|
|
|
|
public long OutputRate { get; set; }
|
|
|
|
private const int MINAAF = 50;
|
|
public int HardwareAAFilter { get; private set; } = 3000;
|
|
|
|
public void SetHardwareAAFilter(int value, int maxAAFilterRateHz)
|
|
{
|
|
if (0 == value || MINAAF <= value && maxAAFilterRateHz >= value)
|
|
{
|
|
HardwareAAFilter = value;
|
|
}
|
|
else
|
|
{
|
|
throw new NotSupportedException("Invalid AAFilter rate for TDAS PRO - " + value);
|
|
}
|
|
}
|
|
|
|
private double _preTriggerTimeInSeconds;
|
|
public double PreTriggerTimeInSeconds
|
|
{
|
|
get => _preTriggerTimeInSeconds;
|
|
set => _preTriggerTimeInSeconds = Math.Abs(value);
|
|
}
|
|
|
|
public double PostTriggerTimeInSeconds { get; set; }
|
|
|
|
public double WaitTime { get; set; } = 10;
|
|
|
|
public string TriggerMode { get; set; } = "BUS";
|
|
|
|
private string _testId;
|
|
public string TestId
|
|
{
|
|
get => _testId;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testId = newValue;
|
|
}
|
|
}
|
|
|
|
private string _testConfig;
|
|
public string TestConfig
|
|
{
|
|
get => _testConfig;
|
|
set
|
|
{
|
|
var newValue = value;
|
|
if (newValue.Length > 240) { newValue = newValue.Substring(0, 240); }
|
|
if (newValue.Contains(' '))
|
|
{
|
|
if (!newValue.StartsWith("\""))
|
|
{
|
|
newValue = $"\"{newValue}\"";
|
|
}
|
|
}
|
|
if (newValue.Length > 240) { throw new OverflowException("too many characters in test id, must be < 240"); }
|
|
_testConfig = newValue;
|
|
}
|
|
}
|
|
|
|
public double CapacitorDischarge { get; set; } = 80D;
|
|
|
|
protected override string _CommandDescription => "SetupDASLoad - SDL (TOM)";
|
|
|
|
protected override string _CommandString => "SDL";
|
|
|
|
public override byte[] GetParameters()
|
|
{
|
|
string s = $" {(IsDummyArm ? ArmMode == "TAPE" ? "DIAGT" : "DIAGW" : ArmMode)} {(CollectData ? SampleRate.ToString() : (-1 * Math.Abs(SampleRate)).ToString())} {OutputRate} {HardwareAAFilter} {PreTriggerTimeInSeconds} {PostTriggerTimeInSeconds} {(IsDummyArm ? -1 : WaitTime)} {TriggerMode} {CapacitorDischarge} {TestId} {TestConfig}";
|
|
|
|
return Encoding.ASCII.GetBytes(s);
|
|
}
|
|
}
|
|
|
|
public class SetupTOMDASLoad : CommandBase
|
|
{
|
|
/// <summary>
|
|
/// Whenever we dummy arm we always want to have PostADWait set to -1
|
|
/// however sometimes we still want to collect data even if we dummy armed
|
|
/// [GM checkout mode]
|
|
/// Collect data is used to indicate that we want to record data regardless
|
|
/// of whether we are "dummy armed" or not
|
|
/// </summary>
|
|
public bool CollectData
|
|
{
|
|
get => _CommandString.CollectData;
|
|
set => _CommandString.CollectData = value;
|
|
}
|
|
public bool IsDummyArm
|
|
{
|
|
get => _CommandString.IsDummyArm;
|
|
set => _CommandString.IsDummyArm = value;
|
|
}
|
|
public int ModuleIndex
|
|
{
|
|
get => ((TDASCommandPacketBase)baseCommand).ModuleIndex;
|
|
set => ((TDASCommandPacketBase)baseCommand).ModuleIndex = value;
|
|
}
|
|
|
|
public enum ARMMode
|
|
{
|
|
WAIT,
|
|
TAPE,
|
|
DIAGW
|
|
}
|
|
|
|
public ARMMode ArmMode
|
|
{
|
|
get => (ARMMode)Enum.Parse(typeof(ARMMode), _CommandString.ArmMode);
|
|
set => _CommandString.ArmMode = value.ToString();
|
|
}
|
|
|
|
public long SampleRate
|
|
{
|
|
get => _CommandString.SampleRate;
|
|
set => _CommandString.SampleRate = value;
|
|
}
|
|
|
|
public long OutputRate
|
|
{
|
|
get => _CommandString.OutputRate;
|
|
set => _CommandString.OutputRate = value;
|
|
}
|
|
|
|
public int HardwareAAFilter => _CommandString.HardwareAAFilter;
|
|
|
|
public void SetHardwareAAFilter(int value, uint MaxAAF)
|
|
{
|
|
_CommandString.SetHardwareAAFilter(value, Convert.ToInt32(MaxAAF));
|
|
}
|
|
|
|
public double PreTriggerSeconds
|
|
{
|
|
get => _CommandString.PreTriggerTimeInSeconds;
|
|
set => _CommandString.PreTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostTriggerSeconds
|
|
{
|
|
get => _CommandString.PostTriggerTimeInSeconds;
|
|
set => _CommandString.PostTriggerTimeInSeconds = value;
|
|
}
|
|
|
|
public double PostADWaitTime
|
|
{
|
|
get => _CommandString.WaitTime;
|
|
set => _CommandString.WaitTime = value;
|
|
}
|
|
|
|
public enum TriggerTypes
|
|
{
|
|
HW,
|
|
LV,
|
|
BUS
|
|
}
|
|
|
|
public TriggerTypes TriggerType
|
|
{
|
|
get => (TriggerTypes)Enum.Parse(typeof(TriggerTypes), _CommandString.TriggerMode);
|
|
set => _CommandString.TriggerMode = value.ToString();
|
|
}
|
|
|
|
public string TestId
|
|
{
|
|
get => _CommandString.TestId;
|
|
set => _CommandString.TestId = value;
|
|
}
|
|
|
|
public string TestConfig
|
|
{
|
|
get => _CommandString.TestConfig;
|
|
set => _CommandString.TestConfig = value;
|
|
}
|
|
|
|
private SetupTOMDasLoadCommandString _CommandString
|
|
{
|
|
get
|
|
{
|
|
var command = baseCommand as TDASCommandPacketBase;
|
|
return command?.GetCommandStringObject(0) as SetupTOMDasLoadCommandString;
|
|
}
|
|
}
|
|
public SetupTOMDASLoad(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupTOMDasLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
public SetupTOMDASLoad(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
|
|
: base(sock, msTimeout)
|
|
{
|
|
var command = new TDASCommandPacketBase(new SetupTOMDasLoadCommandString());
|
|
command.RebuildBytes = true;
|
|
baseCommand = command;
|
|
}
|
|
|
|
protected override void ProcessData()
|
|
{
|
|
if (null == baseResponse) { return; }
|
|
_responseData = "";
|
|
}
|
|
}
|
|
}
|
|
|