2209 lines
103 KiB
C#
2209 lines
103 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using DTS.Common.Utilities;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.DASLib.Command;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.ICommunication;
|
|
using DTS.DASLib.Command.TDAS;
|
|
using DTS.Common.Interface.Connection;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.Interface.DASFactory.Config;
|
|
using DTS.Common.Interface.DASFactory;
|
|
|
|
namespace DTS.DASLib.Service
|
|
{
|
|
public partial class TDAS<T> : Communication<T>,
|
|
IDASCommunication,
|
|
IConfigurationActions,
|
|
IDiagnosticsActions,
|
|
ITriggerCheckActions,
|
|
IRealTimeActions,
|
|
IArmActions,
|
|
IDownloadActions where T : IConnection, new()
|
|
{
|
|
public int[] GetStackChannelConfigTypes() => new int[] { 0 };
|
|
/// <summary>
|
|
/// <inheritdoc cref="IConfiguration"/>
|
|
/// </summary>
|
|
public string TestDirectory { get; set; }
|
|
void IConfigurationActions.QueryTestSetup(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
info.Success();
|
|
}
|
|
void IConfigurationActions.StoreTestSetupXML(ServiceCallback callback, object userData, string testSetupXML)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
info.Success();
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns true if the unit is capable of reading arm status
|
|
/// 17800 Trigger status is "waiting" but PPRO has indeed triggered
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
bool IDASCommunication.GetCanCheckArmStatus() { return true; }
|
|
public bool SupportsMultipleConfigurations() { return false; }
|
|
void IDASCommunication.SetIsStreamingSupported(bool supported)
|
|
{
|
|
IsStreamingSupported = false;
|
|
}
|
|
void IDASCommunication.ReadFirstUseDate()
|
|
{
|
|
IsFirstUseDateSupported = false;
|
|
FirstUseDate = null;
|
|
}
|
|
public bool ConnectionCheck()
|
|
{
|
|
try
|
|
{
|
|
var querySerialNumber = new QuerySerialNumber(this);
|
|
querySerialNumber.SyncExecute();
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// discovers any connected devices
|
|
/// TDAS does support this currently
|
|
/// </summary>
|
|
public void QueryConnectedDevices()
|
|
{
|
|
}
|
|
|
|
public int MaxModules { get; set; } = 4;
|
|
|
|
bool IArmActions.SupportsBackgroundFlashErase => IsG5();
|
|
private DateTime _backgroundFlashClearStart = DateTime.MinValue;
|
|
DateTime? IArmActions.BackgroundFlashEraseStartTime
|
|
{
|
|
get
|
|
{
|
|
if (DateTime.MinValue == _backgroundFlashClearStart) { return null; }
|
|
return _backgroundFlashClearStart;
|
|
}
|
|
}
|
|
bool IArmActions.BackgroundFlashEraseStarted => null != (this as IArmActions).BackgroundFlashEraseStartTime;
|
|
|
|
void IArmActions.BeginBackgroundFlashErase(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
if (!(this as IArmActions).SupportsBackgroundFlashErase) { info.Success(); return; }
|
|
|
|
if (_backgroundFlashClearStart != DateTime.MinValue) { info.Success(); return; }//it's already been called ...
|
|
LaunchAsyncWorker("TDAS.BeginBackgroundFlashErase", AsyncBeginBackgroundFlashErase, info);
|
|
}
|
|
private void AsyncBeginBackgroundFlashErase(object o)
|
|
{
|
|
var info = o as TDASServiceAsyncInfo;
|
|
DoFlashErase(false);
|
|
_backgroundFlashClearStart = DateTime.Now;
|
|
info?.Success();
|
|
}
|
|
private void DoFlashErase(bool dummyArm)
|
|
{
|
|
if (!IsG5()) return;
|
|
if ((this as IArmActions).BackgroundFlashEraseStarted) return;
|
|
var rfc = new RackFlashClear(this);
|
|
|
|
rfc.SampleRate = Convert.ToDouble(ConfigData.Modules[0].SampleRateHz);
|
|
//didn't help at all :/
|
|
if (dummyArm)
|
|
{
|
|
rfc.RecordingTime = .1;
|
|
}
|
|
else { rfc.RecordingTime = ConfigData.Modules[0].PreTriggerSeconds + ConfigData.Modules[0].PostTriggerSeconds; }
|
|
|
|
rfc.SyncExecute();
|
|
}
|
|
void IArmActions.TurnOffT0Lights(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.TurnOffT0Lights", AsyncTurnOffT0Lights, info);
|
|
}
|
|
private void AsyncTurnOffT0Lights(object o)
|
|
{
|
|
var info = o as TDASServiceAsyncInfo;
|
|
|
|
if (!IsG5())
|
|
{
|
|
try
|
|
{
|
|
//turn off lights
|
|
foreach (var mod in ConfigData.Modules)
|
|
{
|
|
if (mod.SerialNumber() == "EMPTY") continue;
|
|
var qsnb = new QuerySerialNumberBroadcast(this, mod.ModuleArrayIndex);
|
|
qsnb.SyncExecute();
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info?.Error(ex.Message);
|
|
}
|
|
}
|
|
info?.Success();
|
|
}
|
|
|
|
public void SetDASDisplayOrder(int order) { throw new NotSupportedException("Not supported for TDAS"); }
|
|
public void SetChannelDisplayOrder(int[] order) { throw new NotSupportedException("Not supported for TDAS"); }
|
|
public int GetDASDisplayOrder() { return -1; }
|
|
public int[] GetChannelDisplayOrder() { return new[] { -1 }; }
|
|
public bool RequireDiagnosticRateMatchSampleRate() { return false; }
|
|
public DateTime SystemBaseTime => DateTime.MinValue;
|
|
public bool RangeBandwidthLimited => false;
|
|
public bool SupportsTimeSynchronization => false;
|
|
|
|
void IArmActions.ReadyForArming(ServiceCallback callback, object userData, Guid eventGuid, int armNowTimeout, bool testingMode,
|
|
int maxNumberEvents, bool dummyArm, bool sysMode)
|
|
{
|
|
var info = new ArmPacket(callback, userData, eventGuid, armNowTimeout);
|
|
info.DummyArm = dummyArm;
|
|
info.SysMode = sysMode;
|
|
LaunchAsyncWorker("TDAS.ReadyArming", AsyncReadyArming, info);
|
|
}
|
|
|
|
private void AsyncReadyArming(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as ArmPacket;
|
|
|
|
try
|
|
{
|
|
// not needed, we will query it again when turning it on.
|
|
|
|
var bHasDigitalChannels = false;
|
|
SetupG5LevelTrigger setupLT = null;
|
|
|
|
//if a g5 has _only_ digital channels, we don't want to dummy arm it as the digital channels won't work properly
|
|
//this little bit detects if there are digital channels in play on this g5
|
|
if (IsG5())
|
|
{
|
|
foreach (var m in ConfigData.Modules)
|
|
{
|
|
foreach (var c in m.Channels)
|
|
{
|
|
if (!(c is AnalogInputDASChannel)) continue;
|
|
if (!(c as AnalogInputDASChannel).DigitalInputChannel || c.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal) continue;
|
|
bHasDigitalChannels = true;
|
|
break;
|
|
}
|
|
if (bHasDigitalChannels) { break; }
|
|
}
|
|
}
|
|
var bAllModulesDummyArmed = true;
|
|
for (var moduleIdx = 0; moduleIdx < DASInfo.Modules.Length; moduleIdx++)
|
|
{
|
|
if (DASInfo.Modules[moduleIdx].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
|
|
{
|
|
continue;
|
|
}
|
|
var dummyChannels = from c in ConfigData.Modules[moduleIdx].Channels
|
|
where c.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm
|
|
select c;
|
|
|
|
if (DASInfo.Modules[moduleIdx].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
#region IsTom
|
|
|
|
if (IsTom((DASModule)ConfigData.Modules[moduleIdx]))
|
|
{
|
|
var bHasDoutsOnly = true;
|
|
foreach (var ch in ConfigData.Modules[moduleIdx].Channels)
|
|
{
|
|
if (ch is OutputTOMDigitalChannel)
|
|
{
|
|
//if we've gotten here then are sure there's no normal configured channels,
|
|
//so we just need to check that there's a digital channel
|
|
bHasDoutsOnly = false;
|
|
if (ch.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal) continue;
|
|
bHasDoutsOnly = true;
|
|
break;
|
|
}
|
|
if (ch.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal) continue;
|
|
bHasDoutsOnly = false;
|
|
break;
|
|
}
|
|
var sdl = new SetupTOMDASLoad(this);
|
|
if (null != dummyChannels && dummyChannels.Any() || info.DummyArm || bHasDoutsOnly)
|
|
{
|
|
sdl.IsDummyArm = true;
|
|
sdl.CollectData = null == dummyChannels || !dummyChannels.Any();
|
|
}
|
|
else
|
|
{
|
|
bAllModulesDummyArmed = false;
|
|
}
|
|
sdl.TestConfig =
|
|
$"{info.EventGuid.ToString()}{SETUPDASREAD_SENTINEL}{ConfigData.Description}{SETUPDASREAD_SENTINEL}{ConfigData.Modules[moduleIdx].GetCRC32()}";
|
|
switch (ConfigData.Modules[moduleIdx].RecordingMode)
|
|
{
|
|
case DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode:
|
|
case DFConstantsAndEnums.RecordingMode.AutoRecorderMode:
|
|
throw new NotSupportedException("TOM does not support Auto Mode");
|
|
case DFConstantsAndEnums.RecordingMode.CircularBuffer:
|
|
case DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode:
|
|
sdl.ArmMode = SetupTOMDASLoad.ARMMode.WAIT;
|
|
break;
|
|
case DFConstantsAndEnums.RecordingMode.RecorderMode:
|
|
case DFConstantsAndEnums.RecordingMode.RecorderModePlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode:
|
|
sdl.ArmMode = SetupTOMDASLoad.ARMMode.TAPE;
|
|
break;
|
|
default:
|
|
throw new NotSupportedException(
|
|
"Mode not supported for TOM: " +
|
|
ConfigData.Modules[moduleIdx].RecordingMode.ToString());
|
|
}
|
|
double aaFilter = ConfigData.Modules[moduleIdx].AAFilterRateHz;
|
|
if (aaFilter > MaxAAFilterRateHz)
|
|
{
|
|
aaFilter = MaxAAFilterRateHz;
|
|
}
|
|
if (0 == aaFilter && IsG5())
|
|
{
|
|
aaFilter = MaxAAFilterRateHz;
|
|
}
|
|
|
|
sdl.SetHardwareAAFilter(Convert.ToInt32(aaFilter), MaxAAFilterRateHz);
|
|
sdl.ModuleIndex = ConfigData.Modules[moduleIdx].ModuleArrayIndex;
|
|
sdl.PostTriggerSeconds = ConfigData.Modules[moduleIdx].PostTriggerSeconds;
|
|
sdl.PreTriggerSeconds = ConfigData.Modules[moduleIdx].PreTriggerSeconds;
|
|
sdl.SampleRate = ConfigData.Modules[moduleIdx].SampleRateHz;
|
|
sdl.TestId = ConfigData.TestID;
|
|
sdl.TriggerType = SetupTOMDASLoad.TriggerTypes.BUS;
|
|
if (info.DummyArm)
|
|
{
|
|
sdl.IsDummyArm = true;
|
|
sdl.CollectData = null == dummyChannels || !dummyChannels.Any();
|
|
}
|
|
sdl.SyncExecute();
|
|
}
|
|
|
|
#endregion IsTom
|
|
|
|
else
|
|
{
|
|
var module = ConfigData.Modules[moduleIdx];
|
|
var levelTriggerMode = SetupDASLoad.TriggerModes.GT;
|
|
var levelTriggerEnabled = false;
|
|
|
|
//g5
|
|
var levelTriggerUpperThresholds = new List<short>();
|
|
var levelTriggerLowerThresholds = new List<short>();
|
|
|
|
var g5LTTypes = new List<SetupG5LevelTrigger.LevelTriggerTypes>();
|
|
var levelTriggerChannels = new List<int>();
|
|
// For SIM
|
|
var levelTriggerChannel = 0;
|
|
short levelTriggerUpperThreshold = 0;
|
|
short levelTriggerLowerThreshold = 0;
|
|
|
|
// configure the range for this bridge
|
|
for (var channelIdx = 0; channelIdx < module.Channels.Length; channelIdx++)
|
|
{
|
|
var g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.OW;
|
|
var channel = module.Channels[channelIdx];
|
|
var dasChannelNumber =
|
|
DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(moduleIdx, channelIdx);
|
|
|
|
if (channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal) continue;
|
|
bAllModulesDummyArmed = false;
|
|
var analog = channel as AnalogInputDASChannel;
|
|
|
|
if (analog.SensitivityMilliVoltsPerEU == 0) continue;
|
|
var levelTriggerOnThisChannel = false;
|
|
var unused = GetMvPerEu(analog);
|
|
|
|
//
|
|
// push level trigger settings out to hardware
|
|
//
|
|
|
|
// If this is level trigger, diagnostic results may be null. Need to cope.
|
|
var scalefactorMilliVoltsPerADC = analog.ScalefactorMilliVoltsPerADC;
|
|
var offsetRemovalADC = 0;
|
|
try
|
|
{
|
|
var diagnostics = analog.Diagnostics;
|
|
scalefactorMilliVoltsPerADC = diagnostics.ScalefactorMilliVoltsPerADC;
|
|
offsetRemovalADC = diagnostics.GetExpectedDataZeroLevelADC(analog.ZeroMethod);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
|
|
if (null != analog.TriggerBelowThresholdEu)
|
|
{
|
|
var invertScaleFactor = 1D;
|
|
if (analog.IsInverted)
|
|
{
|
|
invertScaleFactor = -1D;
|
|
}
|
|
|
|
levelTriggerOnThisChannel = true;
|
|
var bInvert = analog.IsInverted;
|
|
if (analog.ScalefactorMilliVoltsPerADC < 0)
|
|
{
|
|
bInvert = !bInvert;
|
|
}
|
|
if (analog.SensitivityMilliVoltsPerEU < 0)
|
|
{
|
|
bInvert = !bInvert;
|
|
}
|
|
if (bInvert)
|
|
{
|
|
}
|
|
try
|
|
{
|
|
// Careful here... if remove offset is NOT active, and zero method is "none",
|
|
// then just send the level trigger as specified down to the hardware. Othewise,
|
|
// we'll need to apply the appropriate offset to it so it triggers as expected.
|
|
//
|
|
|
|
if (bInvert)
|
|
{
|
|
levelTriggerUpperThreshold =
|
|
(short)(invertScaleFactor * analog.TriggerBelowThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC
|
|
+ offsetRemovalADC);
|
|
}
|
|
else
|
|
{
|
|
levelTriggerLowerThreshold =
|
|
(short)(invertScaleFactor * analog.TriggerBelowThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC
|
|
+ offsetRemovalADC);
|
|
}
|
|
}
|
|
catch (ApplicationException ex)
|
|
{
|
|
if (null != Exceptional
|
|
.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
|
|
levelTriggerLowerThreshold =
|
|
(short)(analog.TriggerBelowThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC);
|
|
else throw;
|
|
}
|
|
levelTriggerMode = SetupDASLoad.TriggerModes.LT;
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.LT;
|
|
if (bInvert)
|
|
{
|
|
//FLIP IT!
|
|
levelTriggerMode = SetupDASLoad.TriggerModes.GT;
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.GT;
|
|
}
|
|
}
|
|
|
|
if (null != analog.TriggerAboveThresholdEu)
|
|
{
|
|
levelTriggerOnThisChannel = true;
|
|
var invertScaleFactor = 1D;
|
|
if (analog.IsInverted)
|
|
{
|
|
invertScaleFactor = -1D;
|
|
}
|
|
|
|
var bInvert = analog.IsInverted;
|
|
if (analog.ScalefactorMilliVoltsPerADC < 0)
|
|
{
|
|
bInvert = !bInvert;
|
|
}
|
|
if (analog.SensitivityMilliVoltsPerEU < 0)
|
|
{
|
|
bInvert = !bInvert;
|
|
}
|
|
|
|
try
|
|
{
|
|
//
|
|
// Careful here... if remove offset is NOT active, and zero method is "none",
|
|
// then just send the level trigger as specified down to the hardware. Othewise,
|
|
// we'll need to apply the appropriate offset to it so it triggers as expected.
|
|
//
|
|
|
|
if (bInvert)
|
|
{
|
|
levelTriggerLowerThreshold =
|
|
(short)(invertScaleFactor * analog.TriggerAboveThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC
|
|
+ offsetRemovalADC);
|
|
}
|
|
else
|
|
{
|
|
levelTriggerUpperThreshold =
|
|
(short)(analog.TriggerAboveThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC
|
|
+ offsetRemovalADC);
|
|
}
|
|
}
|
|
catch (ApplicationException ex)
|
|
{
|
|
if (null != Exceptional
|
|
.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
|
|
levelTriggerUpperThreshold =
|
|
(short)(analog.TriggerAboveThresholdEu *
|
|
analog.SensitivityMilliVoltsPerEUNormalized /
|
|
scalefactorMilliVoltsPerADC);
|
|
else throw;
|
|
}
|
|
levelTriggerMode = SetupDASLoad.TriggerModes.GT;
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.GT;
|
|
if (bInvert)
|
|
{
|
|
//FLIP IT!
|
|
levelTriggerMode = SetupDASLoad.TriggerModes.LT;
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.LT;
|
|
}
|
|
|
|
}
|
|
if (null != analog.TriggerAboveThresholdEu && null != analog.TriggerBelowThresholdEu)
|
|
{
|
|
switch (analog.LevelTriggerType)
|
|
{
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.GreaterThan:
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.InsideWindow:
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.IW;
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.LessThan:
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.OutsideWindow:
|
|
g5LTType = SetupG5LevelTrigger.LevelTriggerTypes.OW;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!levelTriggerOnThisChannel) continue;
|
|
levelTriggerEnabled = true;
|
|
|
|
if (g5LTType == SetupG5LevelTrigger.LevelTriggerTypes.GT ||
|
|
g5LTType == SetupG5LevelTrigger.LevelTriggerTypes.LT)
|
|
{
|
|
levelTriggerChannel = channelIdx + 1;
|
|
}
|
|
else
|
|
{
|
|
// One based trigger channel
|
|
levelTriggerChannel = dasChannelNumber + 1;
|
|
}
|
|
if (!IsG5() || !levelTriggerEnabled) continue;
|
|
levelTriggerChannels.Add(levelTriggerChannel);
|
|
g5LTTypes.Add(g5LTType);
|
|
levelTriggerUpperThresholds.Add(levelTriggerUpperThreshold);
|
|
levelTriggerLowerThresholds.Add(levelTriggerLowerThreshold);
|
|
}
|
|
|
|
//ideally we would have a common base class between these and just one object here, but there's some work to do
|
|
//basically there's some 3 separate parameters or so separating the two.
|
|
var sdl = new SetupDASLoad(this);
|
|
var sdlDIM = new SetupDASLoadDIM(this);
|
|
|
|
if (null == dummyChannels || !dummyChannels.Any())
|
|
{
|
|
bAllModulesDummyArmed = false;
|
|
}
|
|
sdl.TestConfig =
|
|
$"{info.EventGuid.ToString()}{SETUPDASREAD_SENTINEL}{ConfigData.Description}{SETUPDASREAD_SENTINEL}{ConfigData.Modules[moduleIdx].GetCRC32()}";
|
|
sdlDIM.TestConfig = sdl.TestConfig;
|
|
|
|
sdl.ModuleIndex = DASInfo.Modules[moduleIdx].ModuleArrayIndex;
|
|
sdlDIM.ModuleIndex = sdl.ModuleIndex;
|
|
|
|
switch (ConfigData.Modules[moduleIdx].RecordingMode)
|
|
{
|
|
case DFConstantsAndEnums.RecordingMode.CircularBuffer:
|
|
case DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode:
|
|
case DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode:
|
|
sdl.ArmMode = SetupDASLoad.ARMMode.WAIT;
|
|
sdlDIM.ArmMode = SetupDASLoadDIM.ArmModes.WAIT;
|
|
break;
|
|
case DFConstantsAndEnums.RecordingMode.RecorderMode:
|
|
case DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode:
|
|
case DFConstantsAndEnums.RecordingMode.RecorderModePlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoRecorderMode:
|
|
sdl.ArmMode = SetupDASLoad.ARMMode.TAPE;
|
|
sdlDIM.ArmMode = SetupDASLoadDIM.ArmModes.TAPE;
|
|
break;
|
|
default:
|
|
throw new NotSupportedException(
|
|
"mode not supported for TDAS: " +
|
|
ConfigData.Modules[moduleIdx].RecordingMode.ToString());
|
|
}
|
|
|
|
var aaf = Convert.ToInt32(ConfigData.Modules[moduleIdx].AAFilterRateHz);
|
|
if (0 == aaf && IsG5())
|
|
{
|
|
aaf = Convert.ToInt32(MaxAAFilterRateHz);
|
|
}
|
|
sdl.SetHardwareAAFilter(aaf, MaxAAFilterRateHz);
|
|
|
|
sdl.PreTriggerSeconds = ConfigData.Modules[moduleIdx].PreTriggerSeconds;
|
|
sdlDIM.PreTriggerSeconds = sdl.PreTriggerSeconds;
|
|
|
|
sdl.PostTriggerSeconds = ConfigData.Modules[moduleIdx].PostTriggerSeconds;
|
|
sdlDIM.PostTriggerSeconds = ConfigData.Modules[moduleIdx].PostTriggerSeconds;
|
|
|
|
sdl.SampleRate = ConfigData.Modules[moduleIdx].SampleRateHz;
|
|
sdlDIM.SampleRate = sdl.SampleRate;
|
|
|
|
if (info.DummyArm || (null != dummyChannels && dummyChannels.Any()))
|
|
{
|
|
sdl.IsDummyArm = true;
|
|
sdlDIM.IsDummyArm = true;
|
|
sdl.CollectData = null == dummyChannels || !dummyChannels.Any();
|
|
sdlDIM.CollectData = sdl.CollectData;
|
|
}
|
|
|
|
sdl.TestId = ConfigData.TestID;
|
|
sdlDIM.TestId = ConfigData.TestID;
|
|
|
|
if (levelTriggerEnabled && !IsG5()) //G5 always uses HW for SetupDasLoad (use setup trig for lvl trigger)
|
|
{
|
|
sdl.TriggerType = SetupDASLoad.TriggerTypes.LV;
|
|
sdlDIM.TriggerType = SetupDASLoadDIM.TriggerTypes.LT;
|
|
}
|
|
else
|
|
{
|
|
sdl.TriggerType = SetupDASLoad.TriggerTypes.HW;
|
|
sdlDIM.TriggerType = SetupDASLoadDIM.TriggerTypes.HW;
|
|
}
|
|
|
|
switch (levelTriggerMode)
|
|
{
|
|
case SetupDASLoad.TriggerModes.GT:
|
|
sdl.TriggerLevelADC = levelTriggerUpperThreshold;
|
|
sdl.TriggerChannel = levelTriggerChannel;
|
|
sdlDIM.TriggerChannel = levelTriggerChannel;
|
|
sdl.TriggerMode = levelTriggerMode;
|
|
break;
|
|
case SetupDASLoad.TriggerModes.LT:
|
|
sdl.TriggerLevelADC = levelTriggerLowerThreshold;
|
|
sdl.TriggerChannel = levelTriggerChannel;
|
|
sdlDIM.TriggerChannel = levelTriggerChannel;
|
|
sdl.TriggerMode = levelTriggerMode;
|
|
break;
|
|
}
|
|
|
|
sdl.NumberOfTriggerSamples = 5;
|
|
sdlDIM.NumberOfTriggerSamples = 5;
|
|
|
|
if (DASInfo.Modules[moduleIdx].TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM &&
|
|
!IsG5())
|
|
{
|
|
sdlDIM.SyncExecute();
|
|
if (sdlDIM.IsErrored())
|
|
{
|
|
info.Error(sdlDIM.GetErrorString(), new Exception(sdlDIM.GetErrorString()));
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (module.ModuleArrayIndex > 0 && IsG5())
|
|
{
|
|
//we only need to do the first module in a g5
|
|
}
|
|
else
|
|
{
|
|
sdl.SyncExecute();
|
|
if (sdl.IsErrored())
|
|
{
|
|
info.Error(sdl.GetErrorString(), new Exception(sdl.GetErrorString()));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DASInfo.Modules[moduleIdx].TypeOfModule != DFConstantsAndEnums.ModuleType.G5Analog ||
|
|
!levelTriggerEnabled) continue;
|
|
|
|
for (var i = 0; i < g5LTTypes.Count; i++)
|
|
{
|
|
var g5LTType = g5LTTypes[i];
|
|
levelTriggerUpperThreshold = levelTriggerUpperThresholds[i];
|
|
levelTriggerLowerThreshold = levelTriggerLowerThresholds[i];
|
|
levelTriggerChannel = levelTriggerChannels[i];
|
|
|
|
setupLT = new SetupG5LevelTrigger(this);
|
|
setupLT.LevelTriggerType = g5LTType;
|
|
if (0 != levelTriggerLowerThreshold)
|
|
{
|
|
setupLT.TriggerLevelLowADC = levelTriggerLowerThreshold;
|
|
}
|
|
if (0 != levelTriggerUpperThreshold)
|
|
{
|
|
setupLT.TriggerLevelHighADC = levelTriggerUpperThreshold;
|
|
}
|
|
setupLT.TriggerChannel = levelTriggerChannel;
|
|
setupLT.NumberOfTriggerSamples = 5;
|
|
setupLT.SyncExecute();
|
|
if (setupLT.IsErrored())
|
|
{
|
|
info.Error(setupLT.GetErrorString(),
|
|
new Exception(setupLT.GetErrorString()));
|
|
return;
|
|
}
|
|
setupLT = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
setupLT?.SyncExecute();
|
|
|
|
TurnOnExcitation();
|
|
|
|
var asl = new ArmSetupLoad(this);
|
|
if (bAllModulesDummyArmed) { asl.PostADWait = -1; }
|
|
else { asl.PostADWait = 5; }
|
|
|
|
switch (ConfigData.Modules[0].RecordingMode)
|
|
{
|
|
case DFConstantsAndEnums.RecordingMode.CircularBuffer:
|
|
case DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode:
|
|
case DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode:
|
|
asl.ArmMode = ArmSetupLoad.ArmModes.WAIT;
|
|
break;
|
|
case DFConstantsAndEnums.RecordingMode.RecorderMode:
|
|
case DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode:
|
|
case DFConstantsAndEnums.RecordingMode.RecorderModePlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoRecorderMode:
|
|
asl.ArmMode = ArmSetupLoad.ArmModes.TAPE;
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("unsupported recording mode " + ConfigData.Modules[0].RecordingMode.ToString());
|
|
}
|
|
|
|
asl.RackArmMode = info.SysMode ? ArmSetupLoad.RackArmModes.SYS : ArmSetupLoad.RackArmModes.SOLO;
|
|
|
|
asl.PostTriggerSeconds = ConfigData.Modules[0].PostTriggerSeconds + ConfigData.Modules[0].PreTriggerSeconds;
|
|
|
|
asl.SampleRate = ConfigData.Modules[0].SampleRateHz;
|
|
asl.SyncExecute();
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message.Contains("invalid sample rate") ?
|
|
DFConstantsAndEnums.CommandStatus.StatusArmInvalidSampleRate.ToString() : ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
public bool AutoArmed { get => false; set { } }
|
|
|
|
private class ArmPacket : TDASServiceAsyncInfo
|
|
{
|
|
public bool DummyArm { get; set; }
|
|
public Guid EventGuid { get; set; }
|
|
public int ArmNowTimeout { get; set; }
|
|
public bool SysMode { get; set; }
|
|
public ArmPacket(ServiceCallback cb, object ud, Guid eg, int armNowTimeout)
|
|
: base(cb, ud)
|
|
{
|
|
EventGuid = eg;
|
|
ArmNowTimeout = armNowTimeout;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// the UDP settings to broadcast auto arm status to on auto arm boot
|
|
/// 17583 Monitor Test UI
|
|
/// </summary>
|
|
public string AutoArmUDPSetting { get; set; } = "239.1.2.3:8504";
|
|
/// <summary>
|
|
/// Auto Arm a single DAS now (not supported for TDAS)
|
|
/// </summary>
|
|
/// <param name="callback">The function to call with information</param>
|
|
/// <param name="userData">Whatever you want to pass along</param>
|
|
/// <param name="eventGuid">A unique GUID that this event will be tagged
|
|
/// with</param>
|
|
void IArmActions.AutoArmNow(ServiceCallback callback, object userData, Guid eventGuid, int
|
|
armNowTimeout, bool testingMode, UInt32 diagnosticsDelayMs, int maxNumberEvents, bool repeatEnable, bool preserveDiagnostics)
|
|
{
|
|
throw new NotSupportedException("AutoArmNow not supported for TDAS");
|
|
}
|
|
|
|
#region FlashErase
|
|
|
|
private class FlashEraseInfo : TDASServiceAsyncInfo
|
|
{
|
|
public bool DummyArm { get; set; }
|
|
public FlashEraseInfo(ServiceCallback _callback, object _userData)
|
|
: base(_callback, _userData)
|
|
{
|
|
|
|
}
|
|
}
|
|
void IArmActions.BeginFlashErase(ServiceCallback callback, object userData, bool DummyArm)
|
|
{
|
|
var info = new FlashEraseInfo(callback, userData);
|
|
info.DummyArm = DummyArm;
|
|
LaunchAsyncWorker("TDAS.BeginFlashErase", AsyncBeginFlashErase, info);
|
|
|
|
}
|
|
/// <summary>
|
|
/// returns whether this das is a G5
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool IsG5()
|
|
{
|
|
return SerialNumber.StartsWith("5M") || SerialNumber.StartsWith("PI");
|
|
}
|
|
|
|
public enum G5Modes
|
|
{
|
|
VDS,
|
|
//IPORT,
|
|
INDUMMY
|
|
}
|
|
|
|
public G5Modes G5Mode { get; set; } = G5Modes.VDS;
|
|
|
|
/// <summary>
|
|
/// returns whether a given module in a rack is a Time Output Module (TOM)
|
|
/// </summary>
|
|
/// <param name="module"></param>
|
|
/// <returns></returns>
|
|
private static bool IsTom(IDASModule module)
|
|
{
|
|
try
|
|
{
|
|
if (module.SerialNumber().ToLower().Contains("tom"))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("problem getting serial number", ex); }
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// returns true if the module is a digital input module
|
|
/// </summary>
|
|
private static bool IsDIM(IDASModule module)
|
|
{
|
|
try
|
|
{
|
|
if (module.SerialNumber().ToLower().Contains("dim"))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log("problem getting serial number", ex); }
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// returns whether a given module type is a Timed Output Module (TOM)
|
|
/// </summary>
|
|
/// <param name="m"></param>
|
|
/// <returns></returns>
|
|
private static bool IsTom(DFConstantsAndEnums.ModuleType m)
|
|
{
|
|
switch (m)
|
|
{
|
|
case DFConstantsAndEnums.ModuleType.ProTOM: return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
private void AsyncBeginFlashErase(object asyncInfo)
|
|
{
|
|
if (!(asyncInfo is FlashEraseInfo info)) { return; }
|
|
try
|
|
{
|
|
DoFlashErase(info.DummyArm);
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
void IArmActions.QueryFlashEraseStatus(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.QueryFlashEraseStatus", AsyncQueryFlashEraseStatus, info);
|
|
}
|
|
|
|
private const double EXPECTED_FLASHCLEAR_TIME = 3 * 60 * 1000;
|
|
|
|
private void AsyncQueryFlashEraseStatus(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
|
|
if (IsG5())
|
|
{
|
|
try
|
|
{
|
|
bool done = false;
|
|
DateTime start = DateTime.Now;
|
|
if ((this as IArmActions).BackgroundFlashEraseStarted)
|
|
{
|
|
start = (DateTime)(this as IArmActions).BackgroundFlashEraseStartTime;
|
|
}
|
|
while (false == done)
|
|
{
|
|
QueryFlashClear queryStatus = new QueryFlashClear(this);
|
|
queryStatus.SyncExecute();
|
|
|
|
var eraseStatus = new FlashEraseStatus();
|
|
eraseStatus.LastError = DFConstantsAndEnums.CommandStatus.StatusNoError;
|
|
if (queryStatus.Done)
|
|
{
|
|
_backgroundFlashClearStart = DateTime.MinValue;
|
|
eraseStatus.PercentComplete = 100F;
|
|
done = true;
|
|
}
|
|
else
|
|
{
|
|
done = false;
|
|
var percentDoneExpected = 100D * DateTime.Now.Subtract(start).TotalMilliseconds /
|
|
EXPECTED_FLASHCLEAR_TIME;
|
|
if (percentDoneExpected < 1)
|
|
{
|
|
percentDoneExpected = 1;
|
|
}
|
|
else if (percentDoneExpected > 100)
|
|
{
|
|
percentDoneExpected = 100;
|
|
}
|
|
eraseStatus.PercentComplete = Convert.ToSingle(percentDoneExpected);
|
|
}
|
|
|
|
DASFlashEraseStatus = eraseStatus;
|
|
|
|
if (eraseStatus.LastError != DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
info?.Progress(0);
|
|
info?.Error("Error while clearing flash: " + eraseStatus.LastError.ToString());
|
|
done = true;
|
|
}
|
|
else if (eraseStatus.PercentComplete < 100.0f)
|
|
{
|
|
info?.Progress((int)eraseStatus.PercentComplete);
|
|
Thread.Sleep(500);
|
|
}
|
|
else
|
|
{
|
|
_backgroundFlashClearStart = DateTime.MinValue;
|
|
info?.Progress(100);
|
|
info?.Success();
|
|
done = true;
|
|
}
|
|
}
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info?.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info?.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
info?.Progress(100);
|
|
info?.Success();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ArmNow
|
|
internal bool _bExcitationOn = false;
|
|
|
|
/// <summary>
|
|
/// TDAS Excitation states On, Off, or Empty Slot.
|
|
/// If SIM Excitation is ON, it should not be turned ON again,
|
|
/// because FW does other tasks as well (offset removal).
|
|
/// </summary>
|
|
internal enum TdasExcitationState { On = 0, Off, EmptySlot };
|
|
|
|
public bool[] QueryTestPrepareStatus()
|
|
{
|
|
var ret = new bool[DASInfo.Modules.Length];
|
|
for (var i = 0; i < DASInfo.Modules.Length; i++)
|
|
{
|
|
if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { ret[i] = true; continue; }
|
|
var qtp = new QueryTestPrepare(this);
|
|
qtp.ModuleIndex = DASInfo.Modules[i].ModuleArrayIndex;
|
|
qtp.SyncExecute();
|
|
ret[i] = qtp.On;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
private List<TdasExcitationState> GetModulesExcitationState()
|
|
{
|
|
var excitationState = new List<TdasExcitationState>();
|
|
|
|
for (int i = 0; i < DASInfo.Modules.Length; i++)
|
|
{
|
|
if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
|
|
{
|
|
excitationState.Add(TdasExcitationState.EmptySlot);
|
|
continue;
|
|
}
|
|
QueryTestPrepare qtp = new QueryTestPrepare(this);
|
|
qtp.ModuleIndex = DASInfo.Modules[i].ModuleArrayIndex;
|
|
qtp.SyncExecute();
|
|
|
|
excitationState.Add(qtp.On ? TdasExcitationState.On : TdasExcitationState.Off);
|
|
}
|
|
|
|
return excitationState;
|
|
}
|
|
public void TurnOnExcitation()
|
|
{
|
|
//FB 16115 Undo part of the changes for FB 15873 causing the TestPrepare call in arm step
|
|
//Refactor the logic to get the excitation sate for modules in GetModulesExcitationSate method
|
|
var excitationStateForModules = GetModulesExcitationState();
|
|
|
|
//if there's any modules that are on then we don't need to turn on power
|
|
if (!excitationStateForModules.Exists(status => status == TdasExcitationState.On))
|
|
{
|
|
if (IsG5())
|
|
{
|
|
var tp = new TestPrepare(this);
|
|
tp.ModuleIndex = 0;
|
|
tp.On = true;
|
|
tp.SyncExecute();
|
|
}
|
|
for (var i = 0; i < DASInfo.Modules.Length; i++)
|
|
{
|
|
if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
|
|
var qsn = new QuerySerialNumberBroadcast(this, DASInfo.Modules[i].ModuleArrayIndex);
|
|
qsn.SyncExecute();
|
|
|
|
var tpb = new TestPrepareBroadcast(this, DASInfo.Modules[i].ModuleArrayIndex);
|
|
tpb.On = true;
|
|
tpb.SyncExecute();
|
|
Thread.Sleep(1000);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void TurnOffExcitation()
|
|
{
|
|
for (int i = 0; i < DASInfo.Modules.Length; i++)
|
|
{
|
|
if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { continue; }
|
|
if (IsG5())
|
|
{
|
|
TestPrepare tp = new TestPrepare(this);
|
|
tp.ModuleIndex = 0;
|
|
tp.On = false;
|
|
tp.SyncExecute();
|
|
break;
|
|
}
|
|
var qsn = new QuerySerialNumberBroadcast(this, DASInfo.Modules[i].ModuleArrayIndex);
|
|
qsn.SyncExecute();
|
|
|
|
var tpb = new TestPrepareBroadcast(this, DASInfo.Modules[i].ModuleArrayIndex);
|
|
tpb.On = false;
|
|
ExcitationStatus = DFConstantsAndEnums.ExcitationStatus.Off;
|
|
tpb.SyncExecute();
|
|
Thread.Sleep(1000);
|
|
break;
|
|
}
|
|
}
|
|
public void TurnOffExcitation(int moduleIdx)
|
|
{
|
|
if (DASInfo.Modules[moduleIdx].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK) { return; }
|
|
var tp = new TestPrepare(this);
|
|
tp.On = false;
|
|
tp.ModuleIndex = DASInfo.Modules[moduleIdx].ModuleArrayIndex;
|
|
tp.SyncExecute();
|
|
}
|
|
|
|
void IArmActions.ArmNow(ServiceCallback callback, object userData, Guid eventGuid,
|
|
int armNowTimeout, bool testingMode, int maxNumberEvents, bool SysMode)
|
|
{
|
|
var info = new ArmPacket(callback, userData, eventGuid, armNowTimeout);
|
|
info.SysMode = SysMode;
|
|
LaunchAsyncWorker("TDAS.ArmNow", new WaitCallback(AsyncArmNow), info);
|
|
}
|
|
|
|
void IArmActions.PrepareForArmNow(ServiceCallback callback, object userData, Guid eventGuid,
|
|
int armNowTimeout, bool testingMode, int maxNumberEvents, bool SysMode)
|
|
{
|
|
var info = new ArmPacket(callback, userData, eventGuid, armNowTimeout);
|
|
info.SysMode = SysMode;
|
|
LaunchAsyncWorker("TDAS.PrepareForArmNow", new WaitCallback(AsyncPrepareForArmNow), info);
|
|
}
|
|
void IArmActions.ReArm(ServiceCallback callback, object userData, bool autoArm, bool arm, bool repeatEnable)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
info.Error("NotSupported");
|
|
}
|
|
void IArmActions.PreparedArmNow(ServiceCallback callback, object userData, Guid eventGuid,
|
|
int armNowTimeout, bool checkoutMode, int maxNumberEvents, bool SysMode)
|
|
{
|
|
var info = new ArmPacket(callback, userData, eventGuid, armNowTimeout);
|
|
info.DummyArm = checkoutMode;
|
|
info.SysMode = SysMode;
|
|
LaunchAsyncWorker("TDAS.PreparedArmNow", new WaitCallback(AsyncPreparedArmNow), info);
|
|
}
|
|
|
|
private const char SETUPDASREAD_SENTINEL = (char)127;
|
|
private void AsyncArmNow(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as ArmPacket;
|
|
|
|
try
|
|
{
|
|
StartRecord = false;
|
|
if (IsG5() && (G5Mode == G5Modes.VDS))
|
|
{
|
|
try
|
|
{
|
|
var dockstat = new G5DockStat(this, true);
|
|
dockstat.SyncExecute();
|
|
if (dockstat.BatteryChargeLevel == G5DockStat.BatteryChargeStates.red /*|| dockstat.BatteryChargeLevel == Command.TDAS.G5DockStat.BatteryChargeStates.yellow*/)
|
|
{
|
|
info?.Error("BatteryLowVoltage");
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
var ra = new RackArm(this);
|
|
ra.ArmState = RackArm.ArmStates.NOW;
|
|
ra.SyncExecute();
|
|
if (ra.IsErrored) { throw new Exception(string.Format("{0}:{1}", SerialNumber, ra.ResponseData)); }
|
|
info?.Success();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
QueryModules qm = new QueryModules(this);
|
|
qm.SyncExecute();
|
|
info.Error(ex.Message);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void AsyncPrepareForArmNow(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as ArmPacket;
|
|
|
|
info?.Success();
|
|
}
|
|
|
|
private void AsyncPreparedArmNow(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as ArmPacket;
|
|
|
|
try
|
|
{
|
|
var moduleIndexToArm = -1;
|
|
for (var i = 0; i < ConfigData.Modules.Length; i++)
|
|
{
|
|
if (DASInfo.Modules[i].TypeOfModule == DFConstantsAndEnums.ModuleType.EMPTYBANK)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (moduleIndexToArm == -1)
|
|
{
|
|
moduleIndexToArm = DASInfo.Modules[i].ModuleArrayIndex;
|
|
}
|
|
|
|
//per rollin, this can add debug information if we call it before module arm
|
|
if (IsTom(DASInfo.Modules[i].TypeOfModule))
|
|
{
|
|
var gts = new GetTOMSwitch(this);
|
|
gts.ModuleIndex = DASInfo.Modules[i].ModuleArrayIndex;
|
|
gts.SyncExecute();
|
|
var dasModule = DASInfo.Modules[i];
|
|
var configModule = ConfigData.Modules[dasModule.ModuleArrayIndex];
|
|
if (!info.DummyArm)
|
|
{
|
|
var tsa = new TestSquibArray(this);
|
|
tsa.ModuleIndex = dasModule.ModuleArrayIndex;
|
|
tsa.SyncExecute();
|
|
for (var iCh = 0; iCh < 8; iCh += 2)
|
|
{
|
|
if (!(configModule.Channels[iCh] is OutputSquibChannel squib) ||
|
|
ConfigData.TestID == "TESTTRIG")
|
|
{
|
|
continue;
|
|
} // do not check the reistance being in range for the long Test Trigger check.
|
|
|
|
if (squib.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal)
|
|
{
|
|
var resistance = tsa.ResistanceOhms[Convert.ToInt32(Math.Floor(iCh / 2D))];
|
|
if (resistance > squib.SquibToleranceHigh)
|
|
{
|
|
info.Error
|
|
(
|
|
string.Format("{0} High",
|
|
DFConstantsAndEnums.CommandStatus.StatusArmSquibResistanceFault
|
|
.ToString())
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (resistance < squib.SquibToleranceLow)
|
|
{
|
|
info.Error
|
|
(
|
|
$"{DFConstantsAndEnums.CommandStatus.StatusArmSquibResistanceFault.ToString()} Low"
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
var qsn = new QuerySerialNumberBroadcast(this, moduleIndexToArm);
|
|
qsn.SyncExecute();
|
|
|
|
var mArm = new ModuleArmBroadcast(this, moduleIndexToArm, IsG5());
|
|
mArm.SyncExecute();
|
|
if (!IsG5())
|
|
{
|
|
//17717 ModuleArmBroadcast must wait on G5
|
|
//the G5 is waiting on syncexecute above, racks are not
|
|
//to make sure the rack doesn't try to execute another command too quickly
|
|
//I introduced a delay here based on EFizer seeing a 1.5s delay happening
|
|
//the delay should be as long as the slowest fully configured module..
|
|
//2.5 to me seems a generous amount of time to allow
|
|
Thread.Sleep(2500);
|
|
}
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//17717 ModuleArmBroadcast must wait on G5
|
|
//the modulearmbroadcast for a g5 now processes the response
|
|
//and in turn can throw an exception, so I handle the new exception here and
|
|
//send an error back to the service
|
|
info.Error(ex.Message, ex);
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
if (IsG5() && (G5Mode == G5Modes.VDS))
|
|
{
|
|
try
|
|
{
|
|
var dockstat = new G5DockStat(this, true);
|
|
dockstat.SyncExecute();
|
|
if (dockstat.BatteryChargeLevel == G5DockStat.BatteryChargeStates.red /*|| dockstat.BatteryChargeLevel == Command.TDAS.G5DockStat.BatteryChargeStates.yellow*/)
|
|
{
|
|
info.Error("BatteryLowVoltage");
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
|
|
var ra = new RackArm(this);
|
|
ra.ArmState = ConfigData.TestID == "TESTTRIG" ? RackArm.ArmStates.NOW_TEST : RackArm.ArmStates.NOW;
|
|
ra.SyncExecute();
|
|
if (ra.IsErrored) { throw new Exception(string.Format("{0}:{1}", SerialNumber, ra.ResponseData)); }
|
|
info.Success();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var qm = new QueryModules(this);
|
|
qm.SyncExecute();
|
|
info.Error(ex.Message);
|
|
}
|
|
}
|
|
public const string SQUIB_RESISTANCE_TOOHIGH = "SQUIB resistance too high";
|
|
public const string SQUIB_RESISTANCE_TOOLOW = "SQUIB resistance too low";
|
|
|
|
#endregion
|
|
|
|
#region EnableFaultChecking
|
|
|
|
void IArmActions.EnableFaultChecking(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.EnableFaultChecking", new WaitCallback(AsyncEnableFaultChecking), info);
|
|
}
|
|
|
|
void IArmActions.CheckAlreadyLevelTriggered(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.CheckAlreadyLevelTriggered", new WaitCallback(AsyncCheckAlreadyLevelTriggered), info);
|
|
}
|
|
private void AsyncCheckAlreadyLevelTriggered(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
try
|
|
{
|
|
foreach (var m in ConfigData.Modules)
|
|
{
|
|
foreach (var ch in m.Channels)
|
|
{
|
|
if (ch is AnalogInputDASChannel)
|
|
{
|
|
try
|
|
{
|
|
var aCh = ch as AnalogInputDASChannel;
|
|
if (aCh.LevelTriggerType == Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.NONE
|
|
|| aCh.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Normal)
|
|
{
|
|
aCh.AlreadyLevelTriggered = false;
|
|
aCh.MeasuredEULevelTriggerCheck = double.NaN;
|
|
}
|
|
else
|
|
{
|
|
aCh.AlreadyLevelTriggered = false;
|
|
aCh.MeasuredEULevelTriggerCheck = double.NaN;
|
|
//SA
|
|
var sa = new SampleAverageWithFallback(this, m.ModuleArrayIndex);
|
|
sa.SyncExecute();
|
|
|
|
var adc = sa.ChannelValues[aCh.ModuleChannelNumber];
|
|
double scalefactorMilliVoltsPerADC = aCh.ScalefactorMilliVoltsPerADC;
|
|
int offsetRemovalADC = 0;
|
|
try
|
|
{
|
|
var diagnostics = aCh.Diagnostics;
|
|
scalefactorMilliVoltsPerADC = diagnostics.ScalefactorMilliVoltsPerADC;
|
|
offsetRemovalADC = diagnostics.GetExpectedDataZeroLevelADC(aCh.ZeroMethod);
|
|
}
|
|
catch (Exception) { }
|
|
//short dataZeroLevelADC = 0;
|
|
//if (null != aCh.DiagnosticInformation) { dataZeroLevelADC = aCh.DiagnosticInformation.GetExpectedDataZeroLevelADC(aCh.ZeroMethod); }
|
|
|
|
//var eu = (adc - dataZeroLevelADC) * scalefactorMilliVoltsPerADC / aCh.SensitivityMilliVoltsPerEUNormalized;
|
|
//if (aCh.IsInverted) { eu *= -1D; }
|
|
//aCh.MeasuredEULevelTriggerCheck = eu;
|
|
var ds = aCh.GetDataScaler();
|
|
var eu = ds.GetEU(adc);
|
|
aCh.MeasuredEULevelTriggerCheck = eu;
|
|
switch (aCh.LevelTriggerType)
|
|
{
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.GreaterThan:
|
|
{
|
|
double euThreshold = (double)aCh.TriggerAboveThresholdEu;
|
|
if (euThreshold < eu)
|
|
{
|
|
aCh.AlreadyLevelTriggered = true;
|
|
}
|
|
}
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.InsideWindow:
|
|
{
|
|
double euThresholdLower = (double)aCh.TriggerBelowThresholdEu;
|
|
double euThresholdHigher = (double)aCh.TriggerAboveThresholdEu;
|
|
|
|
if (euThresholdLower <= eu && eu <= euThresholdHigher)
|
|
{
|
|
aCh.AlreadyLevelTriggered = true;
|
|
}
|
|
}
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.LessThan:
|
|
{
|
|
double euThreshold = (double)aCh.TriggerBelowThresholdEu;
|
|
if (euThreshold > eu)
|
|
{
|
|
aCh.AlreadyLevelTriggered = true;
|
|
}
|
|
}
|
|
break;
|
|
case Common.DAS.Concepts.DAS.Channel.LevelTriggerTypes.OutsideWindow:
|
|
{
|
|
double euThresholdLower = (double)aCh.TriggerBelowThresholdEu;
|
|
double euThresholdHigher = (double)aCh.TriggerAboveThresholdEu;
|
|
|
|
if (euThresholdLower > eu || eu > euThresholdHigher)
|
|
{
|
|
aCh.AlreadyLevelTriggered = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
APILogger.Log(ex2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
info.Success();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// calls TA Prev/TA Curr to keep a record of rack state in logs
|
|
/// </summary>
|
|
private void DoTAPrevCurRFCheck(bool loopOnFaulted)
|
|
{
|
|
var ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.PREV;
|
|
ta.SyncExecute();
|
|
|
|
ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.CURR;
|
|
ta.SyncExecute();
|
|
int maxIterations = 10;
|
|
int i = 1;
|
|
while (loopOnFaulted && ta.RackFault == DFConstantsAndEnums.VoltageStatusColor.Red && i <= maxIterations)
|
|
{
|
|
APILogger.Log($"### TACURRLOOP {SerialNumber} Iteration {i} RF={ta.RackFault.ToString()}");
|
|
// Pause for 100ms
|
|
Thread.Sleep(100);
|
|
|
|
//Lets Check again
|
|
ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.CURR;
|
|
ta.SyncExecute();
|
|
i++;
|
|
}
|
|
}
|
|
private void AsyncEnableFaultChecking(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
|
|
try
|
|
{
|
|
if (RecordingModeExtensions.IsARecorderMode(ConfigData.Modules[0].RecordingMode))
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
//15616Add additional debug information into TDAS arm sequence
|
|
DoTAPrevCurRFCheck(true);
|
|
var queryArmStat = new QueryArmStatus(this);
|
|
queryArmStat.SyncExecute();
|
|
var ra = new RackArm(this);
|
|
ra.ArmState = RackArm.ArmStates.RF;
|
|
ra.SyncExecute();
|
|
if (ra.IsErrored)
|
|
{
|
|
//execute TA PREV to get the state of latched switches,
|
|
//ARM RF Error will sometimes lead to disarming, so get it now before returning
|
|
//this is in reference to discoveries in TDC in ZenDesk id7153
|
|
//support.dtsweb.com/hc/requests/7153
|
|
//code in TDC was RJW 2004, presumably added for more debugging information.
|
|
DoTAPrevCurRFCheck(false);
|
|
throw new Exception(string.Format("{0}:{1}", SerialNumber, ra.ResponseData));
|
|
}
|
|
else
|
|
{
|
|
//15616 Add additional debug information into TDAS arm sequence
|
|
queryArmStat = new QueryArmStatus(this);
|
|
queryArmStat.SyncExecute();
|
|
}
|
|
}
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Disarm
|
|
void IArmActions.DisAutoArm(ServiceCallback callback, object userData)
|
|
{
|
|
throw new NotSupportedException("DisAutoArm not supported for TDAS");
|
|
}
|
|
void IArmActions.Disarm(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.Disarm", new WaitCallback(AsyncDisarm), info);
|
|
}
|
|
|
|
private void AsyncDisarm(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
|
|
if (null != DASArmStatus && DASArmStatus.IsTriggered && DASArmStatus.IsRecording)
|
|
{
|
|
try
|
|
{
|
|
var stopNow = new ARMSTOP(this);
|
|
stopNow.SyncExecute();
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!IsG5())
|
|
{
|
|
//try to disarm any modules ...
|
|
//this doesn't work, it just hangs things.
|
|
/*foreach (var m in DASInfo.Modules)
|
|
{
|
|
if (m.TypeOfModule == InfoResult.Module.ModuleType.EMPTYBANK) { continue; }
|
|
try
|
|
{
|
|
var armoff = new DTS.DASLib.Command.TDAS.ARMOFF(this);
|
|
armoff.ModuleIndex = m.ModuleArrayIndex;
|
|
armoff.SyncExecute();
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
}*/
|
|
}
|
|
try
|
|
{
|
|
try
|
|
{
|
|
var armOff = new ARMOFF(this);
|
|
armOff.SyncExecute();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
//11326 Failed to arm in check trigger navi step
|
|
//see above issue for more details
|
|
//IMMEDIATELY turn back on all excitation
|
|
|
|
foreach (var module in ConfigData.Modules)
|
|
{
|
|
bool bAnalog = true;
|
|
if (IsG5() && module.ModuleArrayIndex > 3) { continue; }//skip digital banks
|
|
switch (DASInfo.Modules[module.ModuleArrayIndex].TypeOfModule)
|
|
{
|
|
case DFConstantsAndEnums.ModuleType.EMPTYBANK: continue;
|
|
case DFConstantsAndEnums.ModuleType.ProDIM: continue;
|
|
case DFConstantsAndEnums.ModuleType.G5Digital: continue;
|
|
}
|
|
|
|
var setExcitation = new SetExcitation(this);
|
|
setExcitation.ModuleIndex = module.ModuleArrayIndex;
|
|
var channels = new List<int>();
|
|
var excitation = new List<int>();
|
|
|
|
foreach (var channel in module.Channels)
|
|
{
|
|
if (!channel.IsConfigured() || !bAnalog)
|
|
{
|
|
continue;
|
|
}
|
|
if (!(channel is AnalogInputDASChannel aic))
|
|
{
|
|
bAnalog = false;
|
|
continue;
|
|
}
|
|
switch (aic.Excitation)
|
|
{
|
|
case Common.Enums.ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
|
|
channels.Add(aic.ModuleChannelNumber);
|
|
excitation.Add(SetExcitation.SIM_TEN_VOLT);
|
|
break;
|
|
case Common.Enums.ExcitationVoltageOptions.ExcitationVoltageOption.Volt2:
|
|
channels.Add(aic.ModuleChannelNumber);
|
|
excitation.Add(IsG5() ? SetExcitation.G5_TWO_VOLT : SetExcitation.SIM_TWO_VOLT);
|
|
break;
|
|
case Common.Enums.ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
|
|
channels.Add(aic.ModuleChannelNumber);
|
|
if (IsG5())
|
|
{
|
|
excitation.Add(SetExcitation.G5_FIVE_VOLT);
|
|
}
|
|
else
|
|
{
|
|
excitation.Add(SetExcitation.FIVE_VOLT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
if (bAnalog && channels.Any())
|
|
{
|
|
setExcitation.Channels = channels.ToArray();
|
|
setExcitation.ExcitationModes = excitation.ToArray();
|
|
//setExcitation.SyncExecute();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log(ex);
|
|
}
|
|
}
|
|
|
|
info?.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info?.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info?.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetArmStatus
|
|
void IArmActions.GetAutoArmStatus(ServiceCallback callback, object userData)
|
|
{
|
|
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.GetAutoArmStatus", new WaitCallback(AsyncGetAutoArmStatus), info);
|
|
}
|
|
|
|
void IArmActions.GetArmStatus(ServiceCallback callback, object userData, uint inputVoltageCutoff, int maxTimeout)
|
|
{
|
|
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.GetArmStatus", new WaitCallback(AsyncGetArmStatus), info);
|
|
}
|
|
void IArmActions.GetExtendedFaultIds(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.GetExtendedFaultIds", new WaitCallback(TDASAsyncGetExtendedFaultIds), info);
|
|
}
|
|
|
|
private void TDASAsyncGetExtendedFaultIds(object asyncInfo)
|
|
{
|
|
var info = (TDASServiceAsyncInfo)asyncInfo;
|
|
info.Success();
|
|
}
|
|
private DateTime recordTime = DateTime.MinValue;
|
|
private DateTime triggerTime = DateTime.MinValue;
|
|
private DateTime armedTime = DateTime.MinValue;
|
|
|
|
|
|
private volatile bool _bInFlashWrite = false;
|
|
private DateTime _timeOfFirstFlashWrite = DateTime.MinValue;
|
|
private static object FlashWriteTimeLock = new object();
|
|
private volatile bool _previousRackFault = false;
|
|
private volatile bool _previousModuleFault = false;
|
|
|
|
private void AsyncGetArmStatus(object asyncInfo)
|
|
{
|
|
TDASServiceAsyncInfo info = asyncInfo as TDASServiceAsyncInfo;
|
|
|
|
try
|
|
{
|
|
if (null == BaseInput)
|
|
{
|
|
//var ta = new Command.TDAS.TestAll(this);
|
|
//ta.SyncExecute();
|
|
BaseInput = new BaseInputValues
|
|
{
|
|
InputVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off,
|
|
InputVoltageStatus = DFConstantsAndEnums.VoltageStatusColor.Off.ToString(),
|
|
StatusDisplayInput = String.Empty,
|
|
|
|
BatteryVoltageStatus = DFConstantsAndEnums.VoltageStatusColor.Off.ToString(),
|
|
BatteryVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off,
|
|
StatusDisplayBattery = String.Empty
|
|
};
|
|
}
|
|
}
|
|
catch (Exception ex) { APILogger.Log(ex); }
|
|
try
|
|
{
|
|
QueryArmStatus arm = new QueryArmStatus(this);
|
|
arm.SyncExecute();
|
|
|
|
LEDS leds = null;
|
|
if (!IsG5() && arm.Status == QueryArmStatus.ARMStatus.DONE)
|
|
{
|
|
Thread.Sleep(1000); // let's hangout for a bit. This is moving too quickly after status done from armstatus is seen
|
|
leds = new LEDS(this);
|
|
leds.SyncExecute();
|
|
if (leds.CalFault == LEDS.FlagStatus.YellowOrYes)
|
|
{
|
|
arm.SetStatus(QueryArmStatus.ARMStatus.CAL);
|
|
}
|
|
}
|
|
if (BaseInput != null)
|
|
{
|
|
bool bLowPower = arm.LowPower;
|
|
if (IsG5())
|
|
{
|
|
if (BaseInput.StatusDisplayBattery == TestAll.VoltageStatus.None.ToString())
|
|
{
|
|
if (BaseInput.StatusDisplayBattery == TestAll.VoltageStatus.None.ToString())/* no battery - display input */
|
|
{
|
|
BaseInput.InputVoltageStatus = bLowPower
|
|
? DFConstantsAndEnums.VoltageStatusColor.Red.ToString()
|
|
: DFConstantsAndEnums.VoltageStatusColor.Green.ToString();
|
|
BaseInput.InputVoltageStatusColor = bLowPower ? DFConstantsAndEnums.VoltageStatusColor.Red : DFConstantsAndEnums.VoltageStatusColor.Green;
|
|
BaseInput.StatusDisplayInput = bLowPower
|
|
? TestAll.VoltageStatus.Low.ToString()
|
|
: TestAll.VoltageStatus.Good.ToString();
|
|
|
|
BaseInput.BatteryVoltageStatus = String.Empty;
|
|
BaseInput.BatteryVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
BaseInput.StatusDisplayBattery = TestAll.VoltageStatus.None.ToString();
|
|
}
|
|
else
|
|
{
|
|
BaseInput.InputVoltageStatus = String.Empty;
|
|
BaseInput.InputVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
BaseInput.StatusDisplayInput = TestAll.VoltageStatus.None.ToString();
|
|
|
|
BaseInput.BatteryVoltageStatus = bLowPower
|
|
? DFConstantsAndEnums.VoltageStatusColor.Red.ToString()
|
|
: DFConstantsAndEnums.VoltageStatusColor.Green.ToString();
|
|
BaseInput.BatteryVoltageStatusColor = bLowPower
|
|
? DFConstantsAndEnums.VoltageStatusColor.Red
|
|
: DFConstantsAndEnums.VoltageStatusColor.Green;
|
|
BaseInput.StatusDisplayBattery = bLowPower
|
|
? TestAll.VoltageStatus.Low.ToString()
|
|
: TestAll.VoltageStatus.Good.ToString();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BaseInput.InputVoltageStatus = String.Empty;
|
|
BaseInput.InputVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off;
|
|
BaseInput.StatusDisplayInput = "---";
|
|
|
|
BaseInput.StatusDisplayBattery = bLowPower
|
|
? DFConstantsAndEnums.VoltageStatusColor.Red.ToString()
|
|
: DFConstantsAndEnums.VoltageStatusColor.Green.ToString();
|
|
BaseInput.BatteryVoltageStatusColor = bLowPower
|
|
? DFConstantsAndEnums.VoltageStatusColor.Red
|
|
: DFConstantsAndEnums.VoltageStatusColor.Green;
|
|
BaseInput.BatteryVoltageStatus = bLowPower
|
|
? TestAll.VoltageStatus.Low.ToString()
|
|
: TestAll.VoltageStatus.Good.ToString();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
ArmStatus status = new ArmStatus();
|
|
status.IsRearming = false;
|
|
|
|
//there's a bit of a problem here, the das could be faulted, but if it's triggered we don't know, we need
|
|
|
|
if (arm.HardwareTrigger || arm.LevelTrigger)
|
|
{
|
|
if (null != DASArmStatus) { status.IsFaulted = DASArmStatus.IsFaulted; }
|
|
}
|
|
else
|
|
{
|
|
bool taQueried = false;
|
|
if (arm.ModuleFault)
|
|
{
|
|
if (_previousModuleFault)
|
|
{
|
|
TestAll ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.PREV;
|
|
ta.SyncExecute();
|
|
|
|
ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.CURR;
|
|
ta.SyncExecute();
|
|
taQueried = true;
|
|
status.IsFaulted = true;
|
|
}
|
|
_previousModuleFault = true;
|
|
}
|
|
else
|
|
{
|
|
_previousModuleFault = false;
|
|
}
|
|
if (arm.RackFault)
|
|
{
|
|
if (!taQueried)
|
|
{
|
|
TestAll ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.PREV;
|
|
ta.SyncExecute();
|
|
|
|
ta = new TestAll(this);
|
|
ta.Mode = TestAllCommandString.Modes.CURR;
|
|
ta.SyncExecute();
|
|
}
|
|
if (_previousRackFault)
|
|
{
|
|
status.IsFaulted = true;
|
|
}
|
|
_previousRackFault = true;
|
|
}
|
|
else
|
|
{
|
|
_previousRackFault = false;
|
|
}
|
|
//status.IsFaulted = arm.ModuleFault || arm.RackFault;
|
|
}
|
|
status.IsInFlashWrite = false;
|
|
status.IsInPostTestDiagnostics = false;
|
|
switch (arm.Status)
|
|
{
|
|
case QueryArmStatus.ARMStatus.ARMED:
|
|
_bInFlashWrite = false;
|
|
if (null != ConfigData && null != ConfigData.Modules && ConfigData.Modules.Length > 0)
|
|
{
|
|
if (ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.CircularBuffer ||
|
|
ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART ||
|
|
ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode ||
|
|
ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode)
|
|
{
|
|
if (recordTime == DateTime.MinValue) { recordTime = DateTime.Now; }
|
|
}
|
|
else { recordTime = DateTime.MinValue; }
|
|
}
|
|
else { recordTime = DateTime.MinValue; }
|
|
triggerTime = DateTime.MinValue;
|
|
if (DateTime.MinValue == armedTime) { armedTime = DateTime.Now; }
|
|
status.IsArmed = true;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.ARMING:
|
|
_bInFlashWrite = false;
|
|
recordTime = DateTime.MinValue;
|
|
triggerTime = DateTime.MinValue;
|
|
status.IsArmed = true;
|
|
// status.IsRearming = true;
|
|
status.HasBeenRecording = false;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.DONE:
|
|
_bInFlashWrite = false;
|
|
status.IsArmed = false;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.FLASH:
|
|
status.IsArmed = false;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.FLASHWRITE:
|
|
status.IsArmed = false;
|
|
status.IsRecording = false;
|
|
status.IsInFlashWrite = true;
|
|
if (!_bInFlashWrite) { _bInFlashWrite = true; lock (FlashWriteTimeLock) { _timeOfFirstFlashWrite = DateTime.Now; } }
|
|
break;
|
|
case QueryArmStatus.ARMStatus.REC:
|
|
if (DateTime.MinValue == recordTime) { recordTime = DateTime.Now; }
|
|
status.IsArmed = true;
|
|
status.IsRecording = true;
|
|
|
|
status.HasBeenRecording = true;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.TRIG:
|
|
armedTime = DateTime.MinValue;
|
|
if (DateTime.MinValue == triggerTime) { triggerTime = DateTime.Now; }
|
|
status.IsArmed = true;
|
|
status.IsTriggered = true;
|
|
status.IsRecording = true;
|
|
status.HasBeenRecording = true;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.UNDEFINED:
|
|
status.IsArmed = false;
|
|
break;
|
|
case QueryArmStatus.ARMStatus.CAL:
|
|
status.IsArmed = true;
|
|
status.IsInPostTestDiagnostics = true;
|
|
break;
|
|
}
|
|
if (arm.StartRecord)
|
|
{
|
|
StartRecord = true;
|
|
}
|
|
else { StartRecord = false; }
|
|
|
|
if (arm.HardwareTrigger) { status.IsTriggered = true; }
|
|
else if (arm.LevelTrigger) { status.IsTriggered = true; }
|
|
if (arm.StartRecord && arm.Status != QueryArmStatus.ARMStatus.FLASHWRITE) { status.IsRecording = true; }
|
|
var faultMessage = new StringBuilder();
|
|
//took out TA below as TA should only be called after a fault
|
|
if (arm.ModuleFault && !arm.HardwareTrigger)
|
|
{
|
|
if (_previousModuleFault)
|
|
{
|
|
status.IsFaulted = true;
|
|
if (faultMessage.Length > 0) { faultMessage.Append(", "); }
|
|
faultMessage.Append("module fault");
|
|
}
|
|
_previousModuleFault = true;
|
|
}
|
|
else
|
|
{
|
|
_previousModuleFault = false;
|
|
}
|
|
//took out TA below as TA should only be called after a fault
|
|
if (arm.RackFault && !(/*ta.TriggerFlag == Command.TDAS.TestAll.VoltageStatusColor.Red ||*/ arm.HardwareTrigger))
|
|
{
|
|
if (_previousRackFault)
|
|
{
|
|
status.IsFaulted = true;
|
|
if (faultMessage.Length > 0) { faultMessage.Append(", "); }
|
|
faultMessage.Append("rack fault");
|
|
}
|
|
_previousRackFault = true;
|
|
}
|
|
else
|
|
{
|
|
_previousRackFault = false;
|
|
}
|
|
//took out TA below as TA should only be called after a fault
|
|
if (arm.LowPower /*|| ta.PrimaryPower == Command.TDAS.TestAll.VoltageStatusColor.Red*/)
|
|
{
|
|
status.IsFaulted = true;
|
|
if (faultMessage.Length > 0) { faultMessage.Append(", "); }
|
|
faultMessage.Append("low power");
|
|
}
|
|
|
|
if (status.IsFaulted) { status.FaultMessage = faultMessage.ToString(); }
|
|
|
|
if (arm.Status == QueryArmStatus.ARMStatus.DONE)
|
|
{
|
|
status.IsRecording = false;
|
|
status.IsTriggered = false;
|
|
status.IsArmed = false;
|
|
}
|
|
|
|
if (status.IsArmed)
|
|
{
|
|
ExcitationStatus = DFConstantsAndEnums.ExcitationStatus.On;
|
|
if (null == ConfigData)
|
|
{
|
|
ManualResetEvent finished = new ManualResetEvent(false);
|
|
|
|
(this as IConfigurationActions).QueryConfiguration(
|
|
delegate (ServiceCallbackData data)
|
|
{
|
|
switch (data.Status)
|
|
{
|
|
case ServiceCallbackData.CallbackStatus.Success:
|
|
case ServiceCallbackData.CallbackStatus.Failure:
|
|
case ServiceCallbackData.CallbackStatus.Canceled:
|
|
finished.Set();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}, null, 0, string.Empty, false);
|
|
|
|
while (false == finished.WaitOne(50)) { Thread.Sleep(10); }
|
|
}
|
|
|
|
if (null != ConfigData)
|
|
{
|
|
double timeRemaining = ConfigData.Modules[0].PreTriggerSeconds + ConfigData.Modules[0].PostTriggerSeconds;
|
|
status.CurrentSample = 0;
|
|
switch (ConfigData.Modules[0].RecordingMode)
|
|
{
|
|
case DFConstantsAndEnums.RecordingMode.CircularBuffer:
|
|
case DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoCircularBufferMode:
|
|
case DFConstantsAndEnums.RecordingMode.a16_CircularBufferAndStreamSubSampleMode:
|
|
status.IsRecording = true;
|
|
status.HasBeenRecording = true;
|
|
//for circular buffer we only need to calculate if we've seen trigger
|
|
status.RecordingMode = Convert.ToInt32(ConfigData.Modules[0].RecordingMode);
|
|
if (DateTime.MinValue != triggerTime)
|
|
{
|
|
double secondsSpent = DateTime.Now.Subtract(triggerTime).TotalSeconds;
|
|
timeRemaining = Math.Max(0, ConfigData.Modules[0].PostTriggerSeconds - (DateTime.Now.Subtract(triggerTime)).TotalSeconds);
|
|
//timeRemaining = Math.Max(0, ConfigData.Modules[0].PostTriggerSeconds - secondsSpent);
|
|
status.CurrentSample = Convert.ToUInt64(ConfigData.Modules[0].SampleRateHz * ConfigData.Modules[0].PreTriggerSeconds
|
|
+ ConfigData.Modules[0].SampleRateHz * secondsSpent);
|
|
|
|
}
|
|
else
|
|
{
|
|
if (DateTime.MinValue == recordTime)
|
|
{
|
|
if (status.IsRecording) { recordTime = DateTime.Now; }
|
|
}
|
|
double secondsSpent = DateTime.Now.Subtract(recordTime).TotalSeconds;
|
|
//timeRemaining = Math.Max(0, ConfigData.Modules[0].PreTriggerSeconds - secondsSpent);
|
|
if (secondsSpent > ConfigData.Modules[0].PreTriggerSeconds)
|
|
{
|
|
timeRemaining = ConfigData.Modules[0].PostTriggerSeconds;
|
|
}
|
|
else
|
|
{
|
|
//timeRemaining = ConfigData.Modules[0].PostTriggerSeconds - secondsSpent;
|
|
timeRemaining = ConfigData.Modules[0].PreTriggerSeconds - secondsSpent;
|
|
}
|
|
status.CurrentSample = Convert.ToUInt64(ConfigData.Modules[0].SampleRateHz * secondsSpent);
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.RecordingMode.RecorderMode:
|
|
case DFConstantsAndEnums.RecordingMode.a14_NormalRecorderAndStreamSubSampleMode:
|
|
case DFConstantsAndEnums.RecordingMode.RecorderModePlusUART:
|
|
case DFConstantsAndEnums.RecordingMode.AutoRecorderMode:
|
|
//for recorder mode we really only care about the total time spent
|
|
status.RecordingMode = Convert.ToInt32(ConfigData.Modules[0].RecordingMode);
|
|
if (DateTime.MinValue != recordTime)
|
|
{
|
|
double secondsSpent = DateTime.Now.Subtract(recordTime).TotalSeconds;
|
|
timeRemaining -= Math.Min(timeRemaining, secondsSpent);
|
|
status.CurrentSample = Convert.ToUInt64(secondsSpent * ConfigData.Modules[0].SampleRateHz);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("unknown recording mode for tdas");
|
|
}
|
|
|
|
status.TotalSamples = Convert.ToUInt64((ConfigData.Modules[0].SampleRateHz * (ConfigData.Modules[0].PreTriggerSeconds + ConfigData.Modules[0].PostTriggerSeconds)));
|
|
status.SampleRate = ConfigData.Modules[0].SampleRateHz;
|
|
status.TimeRemainingSeconds = timeRemaining;
|
|
}
|
|
else
|
|
{
|
|
// In theory we should never get to this case.
|
|
// We need to reconstruct needed info without ConfigData
|
|
//also note, you're probably going to need a module index, which the code below isn't using? I'm going to leave the code in for now
|
|
SetupDASRead SDR = new SetupDASRead(this);
|
|
SDR.SyncExecute();
|
|
status.SampleRate = (uint)SDR.ActualSampleRate;
|
|
status.TotalSamples = Convert.ToUInt64((status.SampleRate * (SDR.PreTriggerTimeInSeconds + SDR.PostTriggerTimeInSeconds)));
|
|
if (SDR.ArmMode == SetupDASLoad.ARMMode.TAPE)
|
|
{
|
|
status.RecordingMode = Convert.ToInt32(DFConstantsAndEnums.RecordingMode.RecorderMode);
|
|
}
|
|
else if (SDR.ArmMode == SetupDASLoad.ARMMode.WAIT)
|
|
{
|
|
status.RecordingMode = Convert.ToInt32(DFConstantsAndEnums.RecordingMode.CircularBuffer);
|
|
}
|
|
else
|
|
{
|
|
status.RecordingMode = Convert.ToInt32(DFConstantsAndEnums.RecordingMode.InvalidArmMode);
|
|
}
|
|
|
|
// Don't have a way to know record time or trigger time, so need to assume the test hasn't started.
|
|
status.TimeRemainingSeconds = status.SampleRate * status.TotalSamples;
|
|
status.CurrentSample = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status.SampleRate = 0;
|
|
status.TimeRemainingSeconds = 0;
|
|
status.TotalSamples = 0;
|
|
status.CurrentSample = 0;
|
|
status.RecordingMode = 0;
|
|
}
|
|
if (arm.Status == QueryArmStatus.ARMStatus.FLASHWRITE)
|
|
{
|
|
double timeRemaining = 0D;
|
|
lock (FlashWriteTimeLock)
|
|
{
|
|
timeRemaining = EXPECTED_FLASHWRITE_TIME - DateTime.Now.Subtract(_timeOfFirstFlashWrite).TotalSeconds;
|
|
if (timeRemaining > EXPECTED_FLASHWRITE_TIME) { timeRemaining = EXPECTED_FLASHWRITE_TIME; }
|
|
if (timeRemaining < 0) { timeRemaining = 0; }
|
|
}
|
|
|
|
status.TimeRemainingSeconds = timeRemaining;
|
|
|
|
double d = 100D * (EXPECTED_FLASHWRITE_TIME - timeRemaining) / EXPECTED_FLASHWRITE_TIME;
|
|
if (d < 0) { d = 1; }
|
|
if (d > 100) { d = 100; }
|
|
status.PercentComplete = d;
|
|
|
|
//System.Diagnostics.Trace.WriteLine("Time remaining: " + status.TimeRemainingSeconds.ToString() + " percentcomplete: " + status.PercentComplete.ToString());
|
|
}
|
|
|
|
if (arm.Status == QueryArmStatus.ARMStatus.UNDEFINED)
|
|
{
|
|
status.IsUndefined = true;
|
|
}
|
|
|
|
status.EventNumber = 0;
|
|
|
|
// Now check power
|
|
if (IsG5() && G5Mode == G5Modes.VDS && false == status.IsRecording && false == status.IsInFlashWrite && false == status.IsUndefined)
|
|
{
|
|
try
|
|
{
|
|
G5DockStat ds = new G5DockStat(this, true);
|
|
ds.SyncExecute();
|
|
status.BatteryMilliVolts = ds.BatteryMilliVolts;
|
|
}
|
|
catch (Exception) { /* tolerate failure in the case where it's not in a VDS */ }
|
|
|
|
//Command.TDAS.TestBattery tb = new Command.TDAS.TestBattery(this);
|
|
//tb.SyncExecute();
|
|
|
|
status.BatteryMilliVolts = null;
|
|
|
|
}
|
|
|
|
SetDASArmStatus(status, true);
|
|
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
|
|
}
|
|
private const double EXPECTED_FLASHWRITE_TIME = 120;
|
|
private void AsyncGetAutoArmStatus(object asyncInfo)
|
|
{
|
|
TDASServiceAsyncInfo info = asyncInfo as TDASServiceAsyncInfo;
|
|
AutoArmStatus = DFConstantsAndEnums.CommandStatus.StatusUnimplemented;
|
|
info.Success();
|
|
}
|
|
#endregion
|
|
|
|
#region EnterLowPowerMode
|
|
|
|
void IArmActions.EnterLowPowerMode(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.EnterLowPowerMode", new WaitCallback(AsyncEnterLowPowerMode), info);
|
|
|
|
}
|
|
|
|
private void AsyncEnterLowPowerMode(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
DiagnosticsHasBeenRun = false;
|
|
try
|
|
{
|
|
//clear any diagnostic results we have, they will be invalid after we go to low power
|
|
//16164 User can proceed past diag. without running on all channels
|
|
ClearChannelDiagnosticsResults();
|
|
TurnOffExcitation();
|
|
info.Success();
|
|
}
|
|
catch (CanceledException)
|
|
{
|
|
info.Cancel();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Start & Trigger
|
|
|
|
void IArmActions.StartRecord(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
|
|
LaunchAsyncWorker("TDAS.StartRecord", new WaitCallback(AsyncStartRecord), info);
|
|
}
|
|
|
|
private void AsyncStartRecord(object asyncInfo)
|
|
{
|
|
TDASServiceAsyncInfo info = asyncInfo as TDASServiceAsyncInfo;
|
|
try
|
|
{
|
|
RackStartCommand rs = new RackStartCommand(this);
|
|
rs.SyncExecute();
|
|
info.Success();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
void IArmActions.Trigger(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.Trigger", new WaitCallback(AsyncTrigger), info);
|
|
}
|
|
|
|
|
|
private void AsyncTrigger(object asyncInfo)
|
|
{
|
|
var info = asyncInfo as TDASServiceAsyncInfo;
|
|
|
|
try
|
|
{
|
|
RackTriggerCommand rtc = new RackTriggerCommand(
|
|
this);
|
|
rtc.SyncExecute();
|
|
info.Success();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
info.Error(ex.Message, ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void PerformVoltageCheckTAOnly(ServiceCallback callback, object userData)
|
|
{
|
|
var info = new TDASServiceAsyncInfo(callback, userData);
|
|
LaunchAsyncWorker("TDAS.PerformVoltageCheckTAOnly", new WaitCallback(AsyncPerformVoltageCheckTAOnly), info);
|
|
}
|
|
private void AsyncPerformVoltageCheckTAOnly(object o)
|
|
{
|
|
TDASServiceAsyncInfo info = o as TDASServiceAsyncInfo;
|
|
info.Success();
|
|
}
|
|
|
|
|
|
}
|
|
}
|