644 lines
25 KiB
C#
644 lines
25 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.Utilities.Logging;
|
|
|
|
|
|
namespace DTS.DASLib.Command.SLICE
|
|
{
|
|
public abstract class ArmCommands : CommandBase
|
|
{
|
|
protected enum Commands
|
|
{
|
|
Reserved = 0x00,
|
|
Arm = 0x01,
|
|
Disarm = 0x02,
|
|
EnableFaultChecking = 0x03,
|
|
DisableFaultChecking = 0x04,
|
|
QueryArmAndTriggerStatus = 0x05,
|
|
PrepareForDiagnostics = 0x06,
|
|
PrepareForDataCollection = 0x07,
|
|
BeginFlashErase = 0x08,
|
|
QueryFlashEraseStatus = 0x09,
|
|
InitializeHardwareLines = 0x0a,
|
|
};
|
|
|
|
protected abstract Commands _Command { get; }
|
|
|
|
protected ArmCommands(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Type = CommandPacket.CommandType.Arm;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
protected ArmCommands(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Type = CommandPacket.CommandType.Arm;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
}
|
|
|
|
public class Arm : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.Arm;
|
|
|
|
public Arm(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public Arm(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
public DFConstantsAndEnums.CommandStatus ArmStatus { get; private set; } = DFConstantsAndEnums.CommandStatus.StatusNoError;
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
switch (response.Status)
|
|
{
|
|
case DFConstantsAndEnums.CommandStatus.StatusNoError:
|
|
break;
|
|
default:
|
|
ArmStatus = response.Status;
|
|
break;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
}
|
|
|
|
public class EnableFaultChecking : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.EnableFaultChecking;
|
|
|
|
public EnableFaultChecking(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public EnableFaultChecking(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class DisableFaultChecking : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.DisableFaultChecking;
|
|
|
|
public DisableFaultChecking(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public DisableFaultChecking(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class QueryArmAndTriggerStatus : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.QueryArmAndTriggerStatus;
|
|
|
|
public enum FaultFlags
|
|
{
|
|
IncomingStatusLineDropped = (1 << 0),
|
|
ADCBufferOverrun = (1 << 1),
|
|
FlashCRCError = (1 << 2),
|
|
TriggerBeforeStart = (1 << 3),
|
|
InputVoltageLow = (1 << 4),
|
|
InputVoltageHigh = (1 << 5),
|
|
BackupVoltageLow = (1 << 6),
|
|
BackupVoltageHigh = (1 << 7),
|
|
OutOfMemory = (1 << 8),
|
|
SquibResistanceOutOfRange = (1 << 9),
|
|
SafeSwitchUnplugged = (1 << 10),
|
|
SquibPowerOutOfRange = (1 << 11),
|
|
AutoSquibDisableActivated = (1 << 12)
|
|
}
|
|
private float _inputVoltage = 0;
|
|
public float InputVoltage => _inputVoltage;
|
|
|
|
private float _backupVoltage = 0;
|
|
public float BackupVoltage => _backupVoltage;
|
|
|
|
private byte _armstate;
|
|
private byte _armmode;
|
|
private byte _startrecordstatus;
|
|
private byte _triggerstatus;
|
|
private byte _faultstatus;
|
|
private uint _eventsamplerate;
|
|
private ulong _totalsamples;
|
|
private ulong _currentsample;
|
|
private ushort _currenteventnumber;
|
|
private ulong _faultsamplenumber;
|
|
private ushort _faultbits;
|
|
|
|
private float _batterySoc;
|
|
private float _systemTempC;
|
|
private ulong _actualCurrentSample;
|
|
private ulong _maxSampleAvailable;
|
|
|
|
private short _tsChannel1;
|
|
private short _tsChannel2;
|
|
private short _tsChannel3;
|
|
|
|
private short _sensorChannelA;
|
|
private short _sensorChannelB;
|
|
private short _sensorChannelC;
|
|
private short _sensorChannelD;
|
|
private short _sensorChannelE;
|
|
private short _sensorChannelF;
|
|
|
|
// for TOM
|
|
private float _squib1;
|
|
private float _squib2;
|
|
private float _squib3;
|
|
private float _squib4;
|
|
private float _squibP17V;
|
|
private float _squibP5V;
|
|
private float _squibP3p3V;
|
|
private float _squibN5V;
|
|
private bool _ptpEnable;
|
|
private bool _adcPtpClkEnable;
|
|
private bool _ptpSyncStatus;
|
|
private bool _adcClkSyncStatus;
|
|
|
|
private uint _extFaultId;
|
|
|
|
public ArmStates ArmState => (ArmStates)_armstate;
|
|
|
|
public enum ArmStates { Disarmed, Armed, Realtime, Diagnostics, FlashClear, Arming };
|
|
|
|
public byte ArmMode => _armmode;
|
|
|
|
public bool IsDiagnostics => (ArmStates)_armstate == ArmStates.Diagnostics;
|
|
public bool IsFlashClear => (ArmStates)_armstate == ArmStates.FlashClear;
|
|
public bool IsArming => (ArmStates)_armstate == ArmStates.Arming;
|
|
public bool IsArmed => (ArmStates)_armstate == ArmStates.Armed;
|
|
|
|
public bool IsInRealtime => (ArmStates)_armstate == ArmStates.Realtime;
|
|
|
|
public bool IsRecording => _startrecordstatus == 0x01;
|
|
|
|
public bool IsTriggered => _triggerstatus == 0x01;
|
|
|
|
public bool IsFaulted => _faultstatus == 0x01;
|
|
|
|
public uint EventSampleRate => _eventsamplerate;
|
|
|
|
public ulong TotalSamples => _totalsamples;
|
|
|
|
public ulong CurrentSample => _currentsample;
|
|
|
|
public ushort EventNumber => _currenteventnumber;
|
|
|
|
public ulong FaultSampleNumber => _faultsamplenumber;
|
|
|
|
public List<FaultFlags> CurrentFaultFlags { get; } = new List<FaultFlags>();
|
|
|
|
public int BatterySoc => (int)_batterySoc;
|
|
public float SystemTempC => _systemTempC;
|
|
public ulong ActualCurrentSample => _actualCurrentSample;
|
|
public ulong MaxSampleAvailable => _maxSampleAvailable;
|
|
|
|
public short TiltSensorChannel1 => _tsChannel1;
|
|
public short TiltSensorChannel2 => _tsChannel2;
|
|
public short TiltSensorChannel3 => _tsChannel3;
|
|
|
|
public short SensorChannelA => _sensorChannelA;
|
|
public short SensorChannelB => _sensorChannelB;
|
|
public short SensorChannelC => _sensorChannelC;
|
|
public short SensorChannelD => _sensorChannelD;
|
|
public short SensorChannelE => _sensorChannelE;
|
|
public short SensorChannelF => _sensorChannelF;
|
|
|
|
|
|
public float SquibResistance1 { get { return _squib1; } }
|
|
public float SquibResistance2 { get { return _squib2; } }
|
|
public float SquibResistance3 { get { return _squib3; } }
|
|
public float SquibResistance4 { get { return _squib4; } }
|
|
|
|
public float SquibPowerP17V { get { return _squibP17V; } }
|
|
public float SquibPowerP5V { get { return _squibP5V; } }
|
|
public float SquibPowerP3p3V { get { return _squibP3p3V; } }
|
|
public float SquibPowerN5V { get { return _squibN5V; } }
|
|
|
|
|
|
public bool PtpFunctionEnable { get { return _ptpEnable; } }
|
|
public bool AdcPtpClkEnable { get { return _adcPtpClkEnable; } }
|
|
public bool PtpClkSyncStatus { get { return _ptpSyncStatus; } }
|
|
public bool AdcClkSyncStatus { get { return _adcClkSyncStatus; } }
|
|
private List<QATSExtendedFault> _extendedFaultFlags = new List<QATSExtendedFault>();
|
|
public List<QATSExtendedFault> ExtendedFaultFlags { get { return _extendedFaultFlags; } }
|
|
public uint ExtendedFaultId { get { return _extFaultId; } }
|
|
public QueryArmAndTriggerStatus(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public QueryArmAndTriggerStatus(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
|
|
private const int QUATS_MIN_LENGTH_INPUTVOLTAGE = 38;
|
|
private const int QUATS_MIN_LENGTH_BACKUPVOLTAGE = 42;
|
|
private const int QUATS_MIN_LENGTH_BATTERYSOC = 49;
|
|
private const int QUATS_MIN_LENGTH_ACTUALCURRENTSAMPLE = 57;
|
|
private const int QUATS_MIN_LENGTH_MAXSAMPLEAVAILABLE = 65;
|
|
private const int QUATS_MIN_LENGTH_TILTCHANNELDATA = 71;
|
|
private const int QUATS_MIN_LENGTH_SYSTEMTEMP = 75;
|
|
private const int QUATS_MIN_LENGTH_CHANNELADC = 87;
|
|
private const int QUATS_MIN_LENGTH_TOMSTATUS = 119;
|
|
private const int QUATS_MIN_LENGTH_CLKSTATUS = 123;
|
|
private const int QUATS_MIN_LENGTH_EXTFAULTID = 127;
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
if (response.ParameterLength > 1)
|
|
{
|
|
|
|
|
|
response.GetParameter(0, out _armstate);
|
|
response.GetParameter(1, out _armmode);
|
|
response.GetParameter(2, out _startrecordstatus);
|
|
response.GetParameter(3, out _triggerstatus);
|
|
response.GetParameter(4, out _faultstatus);
|
|
response.GetParameter(5, out _eventsamplerate);
|
|
response.GetParameter(9, out _totalsamples);
|
|
response.GetParameter(17, out _currentsample);
|
|
response.GetParameter(25, out _currenteventnumber);
|
|
response.GetParameter(27, out _faultsamplenumber);
|
|
//this is only valid for > 00E7, but that's long retired, so I'm enforcing it now
|
|
response.GetParameter(35, out _faultbits);
|
|
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
if (0 != (_faultbits & (1 << i)))
|
|
{
|
|
CurrentFaultFlags.Add((FaultFlags)(1 << i));
|
|
}
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_INPUTVOLTAGE)
|
|
{
|
|
response.GetParameter(37, out _inputVoltage);
|
|
}
|
|
else
|
|
{
|
|
_inputVoltage = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_BACKUPVOLTAGE)
|
|
{
|
|
response.GetParameter(41, out _backupVoltage);
|
|
}
|
|
else
|
|
{
|
|
_backupVoltage = 0;
|
|
}
|
|
|
|
|
|
if (recorder.IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.QueryBatterySOC)
|
|
&& response.ParameterLength >= QUATS_MIN_LENGTH_BATTERYSOC)
|
|
{
|
|
response.GetParameter(45, out _batterySoc);
|
|
}
|
|
else
|
|
{
|
|
_batterySoc = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_ACTUALCURRENTSAMPLE)
|
|
{
|
|
response.GetParameter(49, out _actualCurrentSample);
|
|
}
|
|
else
|
|
{
|
|
_actualCurrentSample = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_MAXSAMPLEAVAILABLE)
|
|
{
|
|
response.GetParameter(57, out _maxSampleAvailable);
|
|
}
|
|
else
|
|
{
|
|
_maxSampleAvailable = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_TILTCHANNELDATA)
|
|
{
|
|
response.GetParameter(65, out _tsChannel1);
|
|
response.GetParameter(67, out _tsChannel2);
|
|
response.GetParameter(69, out _tsChannel3);
|
|
}
|
|
else
|
|
{
|
|
_tsChannel1 = 0;
|
|
_tsChannel2 = 0;
|
|
_tsChannel3 = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_SYSTEMTEMP)
|
|
{
|
|
response.GetParameter(71, out _systemTempC);
|
|
}
|
|
else
|
|
{
|
|
_systemTempC = 0;
|
|
}
|
|
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_CHANNELADC)
|
|
{
|
|
response.GetParameter(75, out _sensorChannelA);
|
|
response.GetParameter(77, out _sensorChannelB);
|
|
response.GetParameter(79, out _sensorChannelC);
|
|
response.GetParameter(81, out _sensorChannelD);
|
|
response.GetParameter(83, out _sensorChannelE);
|
|
response.GetParameter(85, out _sensorChannelF);
|
|
}
|
|
else
|
|
{
|
|
_sensorChannelA = 0;
|
|
_sensorChannelB = 0;
|
|
_sensorChannelC = 0;
|
|
_sensorChannelD = 0;
|
|
_sensorChannelE = 0;
|
|
_sensorChannelF = 0;
|
|
}
|
|
|
|
// hack for TOM
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_TOMSTATUS)
|
|
{
|
|
response.GetParameter(87, out _squib1);
|
|
response.GetParameter(91, out _squib2);
|
|
response.GetParameter(95, out _squib3);
|
|
response.GetParameter(99, out _squib4);
|
|
|
|
response.GetParameter(103, out _squibP17V);
|
|
response.GetParameter(107, out _squibP5V);
|
|
response.GetParameter(111, out _squibP3p3V);
|
|
response.GetParameter(115, out _squibN5V);
|
|
}
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_CLKSTATUS)
|
|
{
|
|
response.GetParameter(119, out _ptpEnable);
|
|
response.GetParameter(120, out _adcPtpClkEnable);
|
|
response.GetParameter(121, out _ptpSyncStatus);
|
|
response.GetParameter(122, out _adcClkSyncStatus);
|
|
}
|
|
if (response.ParameterLength >= QUATS_MIN_LENGTH_EXTFAULTID)
|
|
{
|
|
response.GetParameter(123, out _extFaultId);
|
|
}
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (0 != (_extFaultId & (1 << i)))
|
|
{
|
|
_extendedFaultFlags.Add((QATSExtendedFault)(1 << i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
|
|
lines.Add(new List<string>() { $"Event number: {EventNumber}, Arm Mode: {ArmMode}" });
|
|
lines.Add(new List<string>() { $"Armed: {IsArmed}, Started: {IsRecording}, Triggered: {IsTriggered}, Faulted: {IsFaulted}, Diagnostics: {IsDiagnostics}, FlashClear: {IsFlashClear}, Arming: {IsArming}, ArmState: {_armstate}" });
|
|
lines.Add(new List<string>() { $"Samplerate: {EventSampleRate}, Current Sample: {CurrentSample}, Total Samples: {TotalSamples}, Fault Sample Number: {FaultSampleNumber}" });
|
|
lines.Add(new List<string>() { $"Input Voltage: {InputVoltage.ToString("N3")}V, Backup Voltage: {BackupVoltage.ToString("N3")}V, Backup Percentage Remaining: {BatterySoc}%" });
|
|
lines.Add(new List<string>() { $"System Temp: {SystemTempC}C, Actual Current Sample: {ActualCurrentSample}, Max Sample Available: {MaxSampleAvailable}" });
|
|
lines.Add(new List<string>() { $"Tilt Ch1: {TiltSensorChannel1}, Tilt Ch2: {TiltSensorChannel2}, Tilt Ch3: {TiltSensorChannel3}" });
|
|
lines.Add(new List<string>() { $"Squib Ch1: {SquibResistance1}, Squib Ch2: { SquibResistance2}, Squib Ch3: { SquibResistance3}, Squib Ch4: { SquibResistance4}" });
|
|
lines.Add(new List<string>() { $"Squib P17V: {SquibPowerP17V}, Squib PV5: { SquibPowerP5V}, Squib P3p3V: { SquibPowerP3p3V}, Squib N5V: { SquibPowerN5V}" });
|
|
lines.Add(new List<string>() { $"PTP Enabled: {PtpFunctionEnable}, PTP Clk Enable: {AdcPtpClkEnable}, PTP Clk Sync Status: {PtpClkSyncStatus}, ADC Clk Sync Status: {AdcClkSyncStatus}" });
|
|
|
|
|
|
var sb = new StringBuilder(50);
|
|
sb.AppendFormat("Fault Flags: ");
|
|
if (null != CurrentFaultFlags && CurrentFaultFlags.Count > 0)
|
|
{
|
|
var addcomma = false;
|
|
for (int i = 0; i < CurrentFaultFlags.Count; i++)
|
|
{
|
|
if (addcomma) sb.AppendFormat(", ");
|
|
addcomma = true;
|
|
sb.AppendFormat("{0}", CurrentFaultFlags[i].ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb.AppendFormat("none");
|
|
}
|
|
lines.Add(new List<string>() { sb.ToString() });
|
|
sb = new StringBuilder();
|
|
sb.AppendFormat("Extended Fault Flags: ");
|
|
if (null != ExtendedFaultFlags && ExtendedFaultFlags.Count > 0)
|
|
{
|
|
var addcomma = false;
|
|
for (int i = 0; i < ExtendedFaultFlags.Count; i++)
|
|
{
|
|
if (addcomma) sb.AppendFormat(", ");
|
|
addcomma = true;
|
|
sb.AppendFormat("{0}", ExtendedFaultFlags[i].ToString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sb.AppendFormat("none");
|
|
}
|
|
lines.Add(new List<string>() { sb.ToString() });
|
|
}
|
|
}
|
|
|
|
public class Disarm : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.Disarm;
|
|
|
|
public Disarm(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public Disarm(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class PrepareForDiagnostics : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.PrepareForDiagnostics;
|
|
|
|
public PrepareForDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public PrepareForDiagnostics(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class PrepareForDataCollection : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.PrepareForDataCollection;
|
|
|
|
public PrepareForDataCollection(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public PrepareForDataCollection(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class BeginFlashErase : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.BeginFlashErase;
|
|
|
|
public BeginFlashErase(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public BeginFlashErase(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class QueryFlashEraseStatus : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.QueryFlashEraseStatus;
|
|
|
|
public QueryFlashEraseStatus(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public QueryFlashEraseStatus(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private float _percentcomplete;
|
|
public float PercentComplete => _percentcomplete;
|
|
|
|
private byte _lasterror;
|
|
public DFConstantsAndEnums.CommandStatus LastError => (DFConstantsAndEnums.CommandStatus)_lasterror;
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
const int LastErrorPosition = 0;
|
|
const int PercentCompletePosition = 1;
|
|
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
response.GetParameter(LastErrorPosition, out _lasterror);
|
|
response.GetParameter(PercentCompletePosition, out _percentcomplete);
|
|
}
|
|
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>() { $"Erase status: {LastError.ToString()}, Percent complete: {PercentComplete.ToString()}" });
|
|
}
|
|
|
|
}
|
|
public class InitializeHardwareLines : ArmCommands
|
|
{
|
|
protected override Commands _Command => Commands.InitializeHardwareLines;
|
|
|
|
public bool CheckTriggerForShort
|
|
{
|
|
get => Convert.ToBoolean(command.Parameter[0]);
|
|
set => command.Parameter[0] = Convert.ToByte(value);
|
|
}
|
|
|
|
public bool CheckStartForShort
|
|
{
|
|
get => Convert.ToBoolean(command.Parameter[1]);
|
|
set => command.Parameter[1] = Convert.ToByte(value);
|
|
}
|
|
|
|
public InitializeHardwareLines(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Parameter = new byte[] { 0x01, 0x01 };
|
|
LogCommands = false;
|
|
}
|
|
|
|
public InitializeHardwareLines(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Parameter = new byte[] { 0x01, 0x01 };
|
|
LogCommands = false;
|
|
}
|
|
|
|
public bool StartRecordShorted { get; private set; } = false;
|
|
|
|
public bool TriggerInputShorted { get; private set; } = false;
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
switch (response.Status)
|
|
{
|
|
case DFConstantsAndEnums.CommandStatus.StatusNoError:
|
|
break;
|
|
case DFConstantsAndEnums.CommandStatus.StatusArmShortedStartRecordInput:
|
|
StartRecordShorted = true;
|
|
break;
|
|
case DFConstantsAndEnums.CommandStatus.StatusArmShortedTriggerInput:
|
|
TriggerInputShorted = true;
|
|
break;
|
|
case DFConstantsAndEnums.CommandStatus.StatusArmShortedStartAndTrigger:
|
|
StartRecordShorted = true;
|
|
TriggerInputShorted = true;
|
|
break;
|
|
default:
|
|
APILogger.Log("Unexpected return from InitializeHardwareLines ", response.Status.ToString());
|
|
break;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>(new[] { $"StartRecord: {StartRecordShorted}, Trigger: {TriggerInputShorted}" }));
|
|
}
|
|
|
|
public static void Log(Exception exception, InitializeHardwareLines ihl)
|
|
{
|
|
var bShortStart = exception.Message.Contains(DFConstantsAndEnums.CommandStatus.StatusArmShortedStartRecordInput.ToString());
|
|
var bShortTrig = exception.Message.Contains(DFConstantsAndEnums.CommandStatus.StatusArmShortedTriggerInput.ToString());
|
|
|
|
if (exception.Message.Contains(DFConstantsAndEnums.CommandStatus.StatusArmShortedStartAndTrigger.ToString()))
|
|
{
|
|
bShortStart = true;
|
|
bShortTrig = true;
|
|
}
|
|
APILogger.Log($"InitializeHardwareLines: Start shorted: {bShortStart} Trigger shorted: {bShortTrig}");
|
|
}
|
|
}
|
|
}
|