noisedestroyers/DP44
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
365ebdecbd94c65939f38bd270147e5dc6af3a75
DP44/DataPRO/IService/Classes/SLICE/SLICE2.cs

5715 lines
266 KiB
C#
Raw Normal View History

init
2026-04-17 14:55:32 -04:00
//#define _8868_MEASUREADCAT0MV_OLDSCHOOL
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DTS.DASLib.Command.SLICE;
using DTS.Common.Utilities;
using DTS.Common.DAS.Concepts;
using DTS.DASLib.Command;
using DTS.Common;
using DTS.Common.DASResource;
using DTS.Common.Enums;
using DTS.Common.ICommunication;
using DTS.Common.Utilities.Logging;
using DTS.Common.WINUSBConnection;
using DTS.DASLib.Command.SLICE.DownloadCommands;
using DTS.DASLib.Command.SLICE.RealtimeCommands;
using DTS.DASLib.Utility;
using DTS.Common.Classes.Sensors;
using System.IO;
using System.Xml;
using DTS.Common.Enums.Sensors;
using DTS.Common.Classes.Connection;
using DTS.Common.Interface.Connection;
using DTS.Common.Interface.DASFactory.Diagnostics;
using DTS.Common.Interface.DASFactory.Download;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Enums.Hardware;
using DTS.Common.Interface.DASFactory.Config;
using Prism.Ioc;
using DTS.Common.Events.DASFactory;
using DTS.Common.Constant.DASSpecific;
using DTS.Common.Utilities.LTLogging;
using DTS.DASLib.Service.FirmwareUtility;
using Prism.Events;
using DTS.Common.SharedResource.Strings;
namespace DTS.DASLib.Service
{
/// <inheritdoc />
/// <summary>
/// slice 2 does it's downloads a little differently
/// namely, it downloads pages at a time regardless of where the break in sample alignment is
/// it also requires that we make requests for samples based not on the sample number, but
/// the byte where the sample are.
/// this is partially because of ECC block size and partially for more efficient transfer
/// </summary>
public class WhatToDownloadSlice2 : DownloadRequest
{
/// <summary>
/// this will hold the number of channels in the download, this is needed
/// to calculate the sample alignment and request/response sample numbers.
/// the SLICE2 firmware uses samples counts irrespective of channels, so they must be realigned post
/// download
/// </summary>
private readonly ulong _numberOfChannels = 0;
public ulong RequestedStartSport { get; }
public WhatToDownloadSlice2(IDownloadRequest dr, int numberOfChannels, int pageSize)
{
if (dr is WhatToDownloadSlice2 dr2)
{
_numberOfChannels = (ulong)numberOfChannels;
DASChannelNumber = dr.DASChannelNumber;
base.EndSample = dr.EndSample;
EventNumber = dr.EventNumber;
SamplesToSkip = dr.SamplesToSkip;
base.StartSample = dr.StartSample;
RequestedStartSport = dr2.RequestedStartSport;
StartRecordTimestampSec = dr.StartRecordTimestampSec;
TriggerTimestampSec = dr.TriggerTimestampSec;
}
else
{
_numberOfChannels = (ulong)numberOfChannels;
if (null == dr)
{
return;
}
DASChannelNumber = dr.DASChannelNumber;
//we add one to the end sample for consistency with SLICE1 based code? - basically
//we need one more sample then the firmware is sending right now ...
base.EndSample = (dr.EndSample + 1) * _numberOfChannels;
EventNumber = dr.EventNumber;
SamplesToSkip = dr.SamplesToSkip;
//find the start of the page the start sample is on
var nearestdiv = Math.Truncate(dr.StartSample * (double)numberOfChannels / pageSize);
base.StartSample = Convert.ToUInt64(nearestdiv * pageSize);
RequestedStartSport = dr.StartSample * (ulong)numberOfChannels;
StartRecordTimestampSec = dr.StartRecordTimestampSec;
TriggerTimestampSec = dr.TriggerTimestampSec;
}
}
/// <inheritdoc />
/// <summary>
/// if EndSample gets set by a generic service, it is not expecting sample counts to be irrespective of channels
/// so we convert it to be irrespective here
/// however, we want to return what we consider the endsample so looping code doesn't give up until we really are done
/// with all the samples we want
/// </summary>
public override ulong EndSample
{
get => base.EndSample;
set => base.EndSample = (value + 1) * _numberOfChannels;
}
/// <inheritdoc />
/// <summary>
/// adjusting the start sample is a little more complicated than adjusting the endsample, we need to start
/// downloading from the start of the page that the start sample we want is on
/// </summary>
public override ulong StartSample
{
get => base.StartSample;
set => base.StartSample = value;
}
}
public class SLICE2_Base<T> : Slice<T>, IConfigurationActions, IVoltageInsertionEnabled, ITimeActions where T : IConnection, new()
{
/// <summary>
/// indicates that voltage insertion was detected as being on
/// http://manuscript.dts.local/f/cases/34284/Warn-when-VoltageInsertion-switches-are-set
/// </summary>
public bool VoltageInsertionEnabled { get; protected set; }
public override void SetIsStreamingSupported(bool supported = false)
{
IsStreamingSupported = false;
}
public override void ReadFirstUseDate()
{
try
{
if (RunTestVariables.InRunTest && !RunTestVariables.CheckHardwareFirstUseDateInRunTest)
{
//skip
IsFirstUseDateSupported = false;
FirstUseDate = null;
}
else
{
var attr = GetUserAttribute(AttributeTypes.SliceUserAttributes.FirstUseDate);
if (string.IsNullOrWhiteSpace(attr))
{
IsFirstUseDateSupported = false;
FirstUseDate = null;
return;
}
if (DateTime.TryParse(attr, System.Globalization.CultureInfo.InvariantCulture,
System.Globalization.DateTimeStyles.None, out var dt))
{
IsFirstUseDateSupported = true;
if (dt.Year == DFConstantsAndEnums.FIRST_USE_DATE_NOT_SET.Year)
{
FirstUseDate = null;
}
else
{
FirstUseDate = dt;
}
return;
}
IsFirstUseDateSupported = true;
FirstUseDate = null;
}
}
catch (Exception ex)
{
APILogger.Log(ex);
IsFirstUseDateSupported = false;
FirstUseDate = null;
}
}
protected override void SetFirstUseDateAsync(object o)
{
if (!(o is SliceServiceAsyncInfo info)) { return; }
try
{
var date = DFConstantsAndEnums.FIRST_USE_DATE_NOT_SET.ToString("d",
System.Globalization.CultureInfo.InvariantCulture);
if (null != FirstUseDate)
{
date = ((DateTime)FirstUseDate).ToString("d", System.Globalization.CultureInfo.InvariantCulture);
}
SetUserAttribute(AttributeTypes.SliceUserAttributes.FirstUseDate, date);
}
catch (Exception ex)
{
info.Error(ex.Message);
return;
}
info.Success();
}
public override HardwareTypes GetHardwareType()
{
if (!string.IsNullOrWhiteSpace(SerialNumber))
{
if (SerialNumber.StartsWith("SPS"))
{
return HardwareTypes.SLICE2_SIM;
}
if (SerialNumber.StartsWith("SLS"))
{
return HardwareTypes.SLICE2_SLS;
}
if (SerialNumber.StartsWith("SPD"))
{
return HardwareTypes.SLICE2_DIM;
}
if (SerialNumber.StartsWith("SLD"))
{
return HardwareTypes.SLICE2_SLD;
}
if (SerialNumber.StartsWith("SLD"))
{
return HardwareTypes.SLICE2_SLD;
}
if (SerialNumber.StartsWith("SPT"))
{
return HardwareTypes.SLICE2_TOM;
}
if (SerialNumber.StartsWith("SLT"))
{
return HardwareTypes.SLICE2_SLT;
}
}
return HardwareTypes.SLICE2_Base;
}
public override int[] GetStackChannelConfigTypes() => new int[] { 0 };
protected override void AsyncAutoDetect(object o)
{
if (!(o is AutoDetectServiceAsyncInfo info)) { return; }
if (null == DASInfo || null == DASInfo.Modules || 0 == DASInfo.Modules.Length
|| null == ConfigData || 0 == ConfigData.Modules.Length)
{
info.Error($"no configuration on unit {SerialNumber}");
return;
}
if (DASInfo.Modules[0].IsProgrammable)
{
var channels = new List<SetStackChannelTypeConfiguration.ChannelTypes>();
foreach (var module in ConfigData.Modules)
{
foreach (var _ in module.Channels)
{
channels.Add(SetStackChannelTypeConfiguration.ChannelTypes.AUTO_DETECT);
}
}
var cmd = new SetStackChannelTypeConfiguration(this);
cmd.SetValue(channels.ToArray());
if (info.QueryConfiguration)
{
var query = new QueryStackSensorIDs(this);
query.Exec();
var idx = 0;
foreach (var m in ConfigData.Modules)
{
foreach (var c in m.Channels)
{
if (c is AnalogInputDASChannel)
{
switch (Convert.ToInt32(query.Types[idx]))
{
case (int)SetStackChannelTypeConfiguration.ChannelTypes.FORCE_IEPE:
(c as AnalogInputDASChannel).IEPEChannel = true;
break;
case (int)SetStackChannelTypeConfiguration.ChannelTypes.FORCE_IEPE_LOW:
(c as AnalogInputDASChannel).IEPEChannel = true;
break;
default:
(c as AnalogInputDASChannel).IEPEChannel = false;
break;
}
var id = new EID(HexEncoding.ToString(query.IDs[idx]));
if (id.IsValid() && !RunTestVariables.BypassEIDRead)
{
c.IDs = new EID[] { id };
}
}
idx++;
}
}
}
}
info.Success();
}
protected override void AsyncClearLatches(object o)
{
if (!(o is SliceServiceAsyncInfo info)) { return; }
var QATS = new QueryArmAndTriggerStatus(this);
QATS.SyncExecute();
info.Success();
}
protected override void AsyncClearTriggerOut(object o)
{
if (!(o is SliceServiceAsyncInfo info)) { return; }
var ssi = new SetSwitchImmediate(this)
{
DeviceID = 0x00,
Switch = (byte)Switches.BaseSwitches.TriggerOut,
SwitchText = Switches.BaseSwitches.TriggerOut.ToString(),
Setting = InvertTrigger ? Convert.ToByte(1) : Convert.ToByte(0)
};
ssi.SyncExecute();
info.Success();
}
/// <summary>
/// clears trigger lines, used by AsyncClearDASTriggerLine and AsyncStartTriggerCheck
/// </summary>
private void ClearTriggerLine()
{
try
{
//reset the FPGA of SLICE6/SLICE2 which may have latched and will remain latched (until something resets it)
//IHL will apparently NOT reset it
//this should come atleast 1.5s after the SLICE6DB/ECM pulse, however there's a mandatory 1.7s wait by genericservices.starttriggercheck between
//ECM/S6DB and regular units
var qats = new QueryArmAndTriggerStatus(this);
qats.SyncExecute();
}
catch (Exception ex)
{
APILogger.Log(ex);
}
//performance improvement, don't set polarity in systems that don't need to
//[reduce # of commands]
if (RunTestVariables.InRunTest && RunTestVariables.DontSetPolarityInRunTest)
{
//don't set
}
else
{
var ssaStart = new SetSystemAttribute(this);
var ssaTrigger = new SetSystemAttribute(this);
try
{
ssaStart.SetValue(AttributeTypes.SystemAttributes.StartRecordPolarity, (byte)(InvertStart ? 1 : 0),
true);
ssaTrigger.SetValue(AttributeTypes.SystemAttributes.TriggerPolarity, (byte)(InvertTrigger ? 1 : 0),
true);
ssaStart.SyncExecute();
ssaTrigger.SyncExecute();
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
}
/// <summary>
/// complete any work we need to do before starting trigger check
/// </summary>
protected override void AsyncPreStartTriggerCheck(object asyncInfo)
{
if (!(asyncInfo is SliceServiceAsyncInfo info))
{
return;
}
// 14459 Trigger shorted error after running check trigger twice.
// if software trigger was used, it will still be set, this is to make sure it's unset
// prior to starting trigger check, this is occuring before the QATS that will reset
// FPGA status
ClearTriggerLine();
info.Success();
}
/// <summary>
/// clears any trigger lines for any das
/// </summary>
protected override void AsyncClearDASTriggerLine(object asyncInfo)
{
if (!(asyncInfo is SliceServiceAsyncInfo info))
{
return;
}
ClearTriggerLine();
info.Success();
}
protected override void AsyncStartTriggerCheck(object asyncInfo)
{
if (!(asyncInfo is SliceServiceAsyncInfo info)) { return; }
try
{
ClearTriggerLine();
var ihl = new InitializeHardwareLines(this) { LogCommands = true };
try
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines))
{
ihl.SyncExecute();
}
else
{
throw new Exception("command not supported: InitHardareInputLines");
}
}
catch (Exception ex)
{
InitializeHardwareLines.Log(ex, ihl);
}
if (ihl.TriggerInputShorted)
{
info.Error("TriggerInputShorted");
return;
}
if (ihl.StartRecordShorted)
{
info.Error("StartInputShorted");
return;
}
info.Success();
}
catch (CanceledException)
{
info.Cancel();
}
catch (Exception ex)
{
info.Error(ex.Message, ex);
}
}
/// <inheritdoc />
/// <summary>
/// gets the expected excitation for a given channel
/// note for SLICE2 we need to consider 2V,5V, and 10V, however 2V or 2.5V may both refer to 2V
/// returns 0 if excitation could not be retrieved, otherwise excitation in mV
/// </summary>
/// <param name="moduleIndex"></param>
/// <param name="channelOnModule"></param>
/// <returns></returns>
protected override double GetExpectedExcitationMV(int moduleIndex, int channelOnModule)
{
if (ConfigData?.Modules == null || ConfigData.Modules.Length <= moduleIndex)
{
APILogger.Log("could not get expected excitaiton, no configuration data to base it on");
return 0D;
}
if (!(ConfigData.Modules[moduleIndex].Channels[channelOnModule] is AnalogInputDASChannel aic))
{
//we never expect to get here, but if we ever do, there's no excitation to consider ...
APILogger.Log("could not get expected excitation, channel is not analog");
return 0D;
}
var excitation = Test.Module.Channel.Sensor.GetExcitationVoltageMagnitudeFromEnum(aic.Excitation) * 1000D;
try
{
var qsa = new QuerySystemAttribute_Slice2Bridge(this);
switch (channelOnModule)
{
case 0:
switch (aic.Excitation)
{
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationA_10000mV;
break;
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationA_5000mV;
break;
default:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationA_2000mV;
break;
}
break;
case 1:
switch (aic.Excitation)
{
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationB_10000mV;
break;
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationB_5000mV;
break;
default:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationB_2000mV;
break;
}
break;
default:
switch (aic.Excitation)
{
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationC_10000mV;
break;
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationC_5000mV;
break;
default:
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FactoryCalibratedExcitationC_2000mV;
break;
}
break;
}
//module 0 is the base, so we have to add one to offset this
qsa.DeviceID = Convert.ToByte(1 + moduleIndex);
qsa.SyncExecute();
var bridgeExcitation = Convert.ToDouble(qsa.Value);//already in mV, no conversion needed
var delta = Math.Abs(excitation - bridgeExcitation);
if (delta < 500)
{
excitation = bridgeExcitation;
}
}
catch (Exception ex)
{
APILogger.Log("failed to get expected excitation: ", ex);
}
return excitation;
}
private const ushort SLICE_SHUNT_DAC_MIDSCALE = 2116;
protected override void QueryInternalOffsets(ref DiagnosticsResult[] results)
{
}
protected override void MeasureInternalOffset(IDiagnosticActions[] ChannelActions,
SliceServiceAsyncInfo info, ref IDiagnosticResult[] results,
bool bFinalOffset)
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MeasureInternalOffset))
{
#region New internal offset measure
// first count how many we need to do it on
var numToMeasure = ChannelActions.Count(a => a.MeasureInternalOffset);
if (numToMeasure == 0)
return;
try
{
var measureInternalOffset = new MeasureStackInternalChannelOffset(this);
measureInternalOffset.NumberOfChannels = (byte)numToMeasure;
measureInternalOffset.DeviceID = 0; // send to base
var measureChannels = new byte[numToMeasure];
var channelCounter = 0;
for (var idx = 0; idx < ChannelActions.Length; idx++)
{
if (ChannelActions[idx].MeasureInternalOffset)
{
measureChannels[channelCounter++] = (byte)ChannelActions[idx].DASChannelNumber;
}
}
measureInternalOffset.ChannelList = measureChannels;
measureInternalOffset.SyncExecute();
// calculate result
channelCounter = 0;
var measuredChannelBiasMv = new double[ChannelDiagnostics.Length];
for (var idx = 0; idx < ChannelActions.Length; idx++)
{
if (ChannelActions[idx].MeasureInternalOffset)
{
var result = (double)measureInternalOffset.MeasuredInternalOffset[channelCounter];
measuredChannelBiasMv[idx] = result;
channelCounter++;
}
}
for (var idx = 0; idx < results.Length; idx++)
{
info.NewData(new ServiceCallbackData.DiagnosticNewData()
{
Result = measuredChannelBiasMv[idx],
DasChannelNumber = results[idx].DASChannelNumber,
Action = ServiceCallbackData.DiagnosticNewData.Actions.MeasureInternalOffset
});
//attempt to resolve the removed adc by using the before and after info
try
{
if (bFinalOffset)
{
if (null != results[idx] && ChannelActions[idx].RemoveOffset)
{
results[idx].RemovedInternalOffsetADC =
Convert.ToInt32((double)results[idx].MeasuredInternalOffsetMilliVolts / results[idx].ScalefactorMilliVoltsPerADC -
measuredChannelBiasMv[idx] / results[idx].ScalefactorMilliVoltsPerADC);
}
else
{
results[idx].RemovedInternalOffsetADC = 0;
}
}
else
{
results[idx].MeasuredInternalOffsetMilliVolts = measuredChannelBiasMv[idx];
if (results[idx].ScalefactorMilliVoltsPerADC == 0)
{
results[idx].ZeroMVInADC = 0;
}
else
{
results[idx].ZeroMVInADC = Convert.ToInt16(measuredChannelBiasMv[idx] / results[idx].ScalefactorMilliVoltsPerADC);
}
}
}
catch (Exception ex)
{
APILogger.Log(
$"Error Retrieving Internal Offset on {SerialNumber} channel {results[idx].DASChannelNumber}", ex);
results[idx].RemovedInternalOffsetADC = 0;
results[idx].MeasuredInternalOffsetMilliVolts = 0;
}
}
}
catch (Exception ex)
{
APILogger.Log("Error Retrieving Internal Offset", ex);
for (var idx = 0; idx < results.Length; idx++)
{
results[idx].RemovedInternalOffsetADC = 0;
results[idx].MeasuredInternalOffsetMilliVolts = 0;
}
}
#endregion
}
else if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MeasureInternalOffsetSwitches) && GEN3_REV_B == _hardwareRevision)
{
#region 8668 MEASUREADCAT0MV SWITCHES
try
{
// first count how many we need to do it on
var numToMeasure = ChannelActions.Count(a => a.MeasureInternalOffset);
if (numToMeasure == 0)
return;
var existingCourseShunts = new Dictionary<int, ushort>();
var existingFineShunts = new Dictionary<int, ushort>();
var existingSwitchValues = new Dictionary<int, Dictionary<byte, byte>>();
VoltageInsertionEnabled = false;
//query switches and DACs for resetting later
foreach (var module in DASInfo.Modules)
{
var qdac = new QueryDACImmediate(this);
qdac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qdac.DAC = (byte)DACs.BridgeDACS_SLICE2.CoarseShunt;
qdac.SyncExecute();
existingCourseShunts[module.ModuleArrayIndex] = qdac.Value;
qdac = new QueryDACImmediate(this);
qdac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qdac.DAC = (byte)DACs.BridgeDACS_SLICE2.FineShunt;
qdac.SyncExecute();
existingFineShunts[module.ModuleArrayIndex] = qdac.Value;
var qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID] = new Dictionary<byte, byte>();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
if (Convert.ToBoolean(qsi.Setting)) { VoltageInsertionEnabled = true; }
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionA;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionA.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
if (Convert.ToBoolean(qsi.Setting)) { VoltageInsertionEnabled = true; }
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionB;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionB.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
if (Convert.ToBoolean(qsi.Setting)) { VoltageInsertionEnabled = true; }
qsi = new QuerySwitchImmediate(this);
qsi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
qsi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionC;
qsi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionC.ToString();
qsi.SyncExecute();
existingSwitchValues[qsi.DeviceID][qsi.Switch] = qsi.Setting;
if (Convert.ToBoolean(qsi.Setting)) { VoltageInsertionEnabled = true; }
}
//set switches & DACs
uint fastestSPS = 0;
foreach (var module in DASInfo.Modules)
{
fastestSPS = Math.Max(ConfigData.Modules[module.ModuleArrayIndex].SampleRateHz, fastestSPS);
var ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted.ToString();
ssi.Setting = Convert.ToByte(false);
ssi.SyncExecute();
var sDac = new SetDACImmediate(this);
sDac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
sDac.DAC = (byte)DACs.BridgeDACS_SLICE2.CoarseShunt;
sDac.Value = SLICE_SHUNT_DAC_MIDSCALE;
sDac.SyncExecute();
sDac = new SetDACImmediate(this);
sDac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
sDac.DAC = (byte)DACs.BridgeDACS_SLICE2.FineShunt;
sDac.Value = SLICE_SHUNT_DAC_MIDSCALE;
sDac.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode.ToString();
ssi.Setting = Convert.ToByte(true);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp.ToString();
ssi.Setting = Convert.ToByte(false);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted.ToString();
ssi.Setting = Convert.ToByte(true);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionA;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionA.ToString();
ssi.Setting = Convert.ToByte(true);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionB;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionB.ToString();
ssi.Setting = Convert.ToByte(true);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionC;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionC.ToString();
ssi.Setting = Convert.ToByte(true);
ssi.SyncExecute();
}
//retrieve sample averages
var measureOffset = new RetrieveSampleAverage(this);
measureOffset.DeviceID = 0; // send to base
var avgTimeSeconds = 1.0 / 60.0 * 2.0; // 2 * 60Hz cycles
measureOffset.Samples = (ushort)(fastestSPS * avgTimeSeconds);
if (measureOffset.Samples < 1)
{
measureOffset.Samples = 1;
}
measureOffset.SyncExecute();
for (var i = 0; i < measureOffset._data.Length; i++)
{
if (bFinalOffset)
{
results[i].RemovedInternalOffsetADC = measureOffset._data[i];
}
else
{
try
{
results[i].MeasuredInternalOffsetMilliVolts = measureOffset._data[i] *
results[i].ScalefactorMilliVoltsPerADC;
results[i].ZeroMVInADC = measureOffset._data[i];
APILogger.Log("MeasuredInternalOffsetMv:", measureOffset._data[i],
"*", results[i].ScalefactorMilliVoltsPerADC, "=",
results[i].MeasuredInternalOffsetMilliVolts);
APILogger.Log(SerialNumber, string.Format("CH{0}", results[i].DASChannelNumber), "ZeroMVInADC=", results[i].ZeroMVInADC);
}
catch (Exception ex)
{
results[i].MeasuredInternalOffsetMilliVolts = 0D;
APILogger.Log(ex, "FinalOffset:", bFinalOffset);
}
}
}
//unset switches & DACs, do the opposite of everything/restore
foreach (var module in DASInfo.Modules)
{
var ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted;
ssi.Setting = existingSwitchValues[ssi.DeviceID][(byte)Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted];
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_ReferenceShorted.ToString();
ssi.SyncExecute();
var sDac = new SetDACImmediate(this);
sDac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
sDac.DAC = (byte)DACs.BridgeDACS_SLICE2.CoarseShunt;
sDac.Value = existingCourseShunts[module.ModuleArrayIndex];
sDac.SyncExecute();
sDac = new SetDACImmediate(this);
sDac.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
sDac.DAC = (byte)DACs.BridgeDACS_SLICE2.FineShunt;
sDac.Value = existingFineShunts[module.ModuleArrayIndex];
sDac.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionMode.ToString();
ssi.Setting = existingSwitchValues[ssi.DeviceID][ssi.Switch];
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionAmp.ToString();
ssi.Setting =
Convert.ToByte(
existingSwitchValues[ssi.DeviceID][
ssi.Switch]);
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted;
ssi.Setting = existingSwitchValues[ssi.DeviceID][(byte)Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted];
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swAll_SignalsShorted.ToString();
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionA;
ssi.Setting = existingSwitchValues[ssi.DeviceID][ssi.Switch];
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionA.ToString();
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionB;
ssi.Setting = existingSwitchValues[ssi.DeviceID][ssi.Switch];
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionB.ToString();
ssi.SyncExecute();
ssi = new SetSwitchImmediate(this);
ssi.DeviceID = Convert.ToByte(1 + module.ModuleArrayIndex);
ssi.Switch = (byte)Switches.BridgeSwitches_SLICE2.swVoltageInsertionC;
ssi.SwitchText = Switches.BridgeSwitches_SLICE2.swVoltageInsertionC.ToString();
ssi.Setting = existingSwitchValues[ssi.DeviceID][ssi.Switch];
ssi.SyncExecute();
}
}
catch (Exception ex)
{
APILogger.Log(ex, "finalOffset:", bFinalOffset);
foreach (var r in results)
{
if (bFinalOffset)
{
r.RemovedInternalOffsetADC = 0;
}
else
{
r.MeasuredInternalOffsetMilliVolts = 0D;
}
}
}
#endregion
}
else
{
//Command not supported
for (var idx = 0; idx < results.Length; idx++)
{
results[idx].RemovedInternalOffsetADC = 0;
results[idx].MeasuredInternalOffsetMilliVolts = 0;
}
}
}
/// <inheritdoc />
/// <summary>
/// Convert gain code to value based on Gen2 vs. Gen3 conversion table
/// </summary>
/// <param name="gainCode"></param>
/// <returns></returns>
protected override double GainCodeToGainValue(ushort gainCode)
{
var gainValueString = _hardwareRevision == GEN3_REV_B ? ((GainCodesGen3)gainCode).ToString() : ((GainCodesGen2)gainCode).ToString();
if (!double.TryParse(gainValueString.TrimStart('G'), out var gainValue))
{
gainValue = 1.0D;
}
return gainValue;
}
private SerializableDictionary<int, string> _userAttributes = null;
private static readonly object USER_ATTRIBUTE_LOCK = new object();
public string GetUserAttribute(AttributeTypes.SliceUserAttributes attribute)
{
CreateUserAttributesIfNeeded();
lock (USER_ATTRIBUTE_LOCK)
{
if (!_userAttributes.ContainsKey((int)attribute))
{
return string.Empty;
}
return _userAttributes[(int)attribute];
}
}
public void SetUserAttribute(AttributeTypes.SliceUserAttributes attribute, string value)
{
CreateUserAttributesIfNeeded();
lock (USER_ATTRIBUTE_LOCK)
{
_userAttributes[(int)attribute] = value;
var sb2 = new StringBuilder();
using (var w = XmlWriter.Create(sb2))
{
_userAttributes.WriteXml(w);
}
try
{
var ca = GetConfigAttributes(this);
ca.StoreXMLConfig(sb2.ToString(), ConfigAttributes.FileStore.UserAttributes);
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
}
private void CreateUserAttributesIfNeeded()
{
lock (USER_ATTRIBUTE_LOCK)
{
if (null == _userAttributes)
{
_userAttributes = new SerializableDictionary<int, string>();
try
{
var ca = GetConfigAttributes(this);
var xml = ca.RetrieveXMLConfig(ConfigAttributes.FileStore.UserAttributes, this);
if (!string.IsNullOrEmpty(xml))
{
//slice firmware tends to pad with \0, which is invalid in xml, strip them out first
xml = xml.Replace("\0", string.Empty);
var settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
using (var sr = new StringReader(xml))
{
var r = XmlReader.Create(sr, settings);
_userAttributes.ReadXml(r);
}
}
}
catch (Exception)
{
}
}
}
}
/// <summary>
/// slice pro/slice1.5 both don't support user attributes, so we store them in the filestore
/// specifically we store a dictionary in store 4, keyed by user attribute id, with a string value
/// </summary>
/// <returns></returns>
public override int GetDASDisplayOrder()
{
var sDisplayOrder = GetUserAttribute(AttributeTypes.SliceUserAttributes.DasDisplayOrder);
if (int.TryParse(sDisplayOrder, System.Globalization.NumberStyles.Any,
System.Globalization.CultureInfo.InvariantCulture, out var temp))
{
return temp;
}
return -1;
}
/// <inheritdoc />
/// <summary>
/// slice 1.5 and slice pro don't have a user attribute store, so we use the file store instead
/// we store a dictionary in there keyed by attribute number with string value
/// </summary>
/// <param name="order"></param>
public override void SetDASDisplayOrder(int order)
{
SetUserAttribute(AttributeTypes.SliceUserAttributes.DasDisplayOrder,
order.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
/// <summary>
/// sets the channel display order for slice 1.5/slice pro
/// </summary>
/// <param name="order"></param>
public override void SetChannelDisplayOrder(int[] order)
{
var _ = GetUserAttribute(AttributeTypes.SliceUserAttributes.DisplayOrder);
var sb = new StringBuilder();
foreach (var i in order)
{
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(i.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
SetUserAttribute(AttributeTypes.SliceUserAttributes.DisplayOrder, sb.ToString());
}
/// <summary>
/// gets the channel display order for slice 1.5/slice pro
/// </summary>
/// <returns></returns>
public override int[] GetChannelDisplayOrder()
{
var s = GetUserAttribute(AttributeTypes.SliceUserAttributes.DisplayOrder);
var atts = new List<int>();
if (!string.IsNullOrWhiteSpace(s))
{
var tokens = s.Split(',');
foreach (var token in tokens)
{
if (int.TryParse(token, out int iTemp))
{
atts.Add(iTemp);
}
}
}
return atts.ToArray();
}
internal class TimeSynchronizationAsyncInfo : SliceServiceAsyncInfo
{
public DateTime Time { get; set; }
public TimeSynchronizationAsyncInfo(ServiceCallback callback, object userData, DateTime time) :
base(callback, userData)
{
Time = time;
}
}
void ITimeActions.Synchronize(ServiceCallback callback, object userData, DateTime time)
{
var info = new TimeSynchronizationAsyncInfo(callback, userData, time);
LaunchAsyncWorker("Slice2.Synchronize", AsyncSynchronize, info);
}
private void AsyncSynchronize(object info)
{
var packet = (TimeSynchronizationAsyncInfo)info;
try
{
var set = new SetBaseSystemTime(this);
set.SystemTime = packet.Time;
set.SyncExecute();
var query = new QueryBaseSystemTime(this);
query.SyncExecute();
}
catch (Exception ex)
{
packet.Error(ex.Message);
return;
}
packet.Success();
}
private DateTime _systemDateTime = DateTime.MinValue;
public override DateTime SystemBaseTime => _systemDateTime;
void ITimeActions.QueryTime(ServiceCallback callback, object userData)
{
var info = new SliceServiceAsyncInfo(callback, userData);
LaunchAsyncWorker("Slice2.QueryTime", AsyncQueryTime, info);
}
private void AsyncQueryTime(object info)
{
var packet = (SliceServiceAsyncInfo)info;
try
{
var query = new QueryBaseSystemTime(this);
query.SyncExecute();
packet.NewData(query.SystemTime);
}
catch (Exception ex)
{
packet.Error(ex.Message);
return;
}
packet.Success();
}
public override bool RequireDiagnosticRateMatchSampleRate() { return true; }
private volatile bool _rangeBandwithLimited = false;
public override bool RangeBandwidthLimited => _rangeBandwithLimited;
private volatile bool _supportsTimeSynchronization = false;
public override bool SupportsTimeSynchronization => _supportsTimeSynchronization;
private static readonly double IEPE_GAIN_DIVIDER = 4.9D;
//0.2040816327F, 2.0408163265F
public static StaticInformation StaticDASIEPESLICE2Info = new StaticInformation(new double[]
{
2400D / (1.0D / IEPE_GAIN_DIVIDER),
2400D / (2.0D / IEPE_GAIN_DIVIDER),
2400D / (5.0D / IEPE_GAIN_DIVIDER),
2400D / (10.0D / IEPE_GAIN_DIVIDER),
2400D / (20.0D / IEPE_GAIN_DIVIDER),
2400D / (50.0D / IEPE_GAIN_DIVIDER),
2400D / (100.0D / IEPE_GAIN_DIVIDER)
});
/// <summary>
/// this is the SPS gen 3 input range table for modified SPS
/// http://fogbugz/fogbugz/default.asp?10080
/// note that we have artifically restricted this list to only provide
/// the gains we wish to make available
/// </summary>
public static StaticInformation StaticDASRevCBridgeInfoModified = new StaticInformation(new[]
{
2400D/1D,
2400D/2D,
2400D/4D,
2400D/8D,
2400D/16D,
2400D/20D,
2400D/32D,
2400D/40D,
2400D/64D,
2400D/80D,
2400D/160D,
2400D/320D,
2400D/640D,
2400D/800D,
2400D/1600D
});
/// <summary>
/// this is the SPS gen3 input range table for unmodified SPS
/// http://fogbugz/fogbugz/default.asp?10080
/// note that we have artifically restricted this list twice, once to
/// restricts gains above 1600 as not useful, and then we took out four
/// "noisy" gains
/// </summary>
public static StaticInformation StaticDASRevCBridgeInfoNotModified = new StaticInformation(new[]
{
2400D/1D,
2400D/2D,
2400D/4D,
2400D/8D,
// 2400D/16D,
2400D/20D,
// 2400D/32D,
2400D/40D,
// 2400D/64D,
2400D/80D,
2400D/160D,
2400D/320D,
// 2400D/640D,
2400D/800D,
2400D/1600D
});
public static StaticInformation StaticDASRevCIEPEInfo = new StaticInformation(new double[]{
2400D/(1D/IEPE_GAIN_DIVIDER),
2400D/(2D/IEPE_GAIN_DIVIDER),
2400D/(4D/IEPE_GAIN_DIVIDER),
2400D/(8D/IEPE_GAIN_DIVIDER),
2400D/(16D/IEPE_GAIN_DIVIDER),
2400D/(32D/IEPE_GAIN_DIVIDER),
2400D/(64D/IEPE_GAIN_DIVIDER)
});
public enum GainCodesGen2 //Used by Slice PRO Gen2
{
G1 = 8,
G2 = 16,
G4 = 17,
G5 = 24,
G8 = 18,
G10 = 25,
G16 = 19,
G20 = 26,
G32 = 20,
G40 = 27,
G50 = 48,
G64 = 21,
G80 = 35,
G100 = 49,
G128 = 22,
G160 = 43,
G200 = 50,
G256 = 23,
G320 = 37,
G400 = 51,
G640 = 45,
G800 = 52,
G1280 = 46,
G1600 = 53,
G2560 = 47,
G3200 = 54,
G6400 = 62,
G12800 = 63
};
/// <summary>
/// decorated with min/max/"middle" for
/// http://fogbugz/fogbugz/default.asp?10080
/// </summary>
public enum GainCodesGen3 //Used by Slice PRO Gen3
{
[MaxInputRange(2500D)]
[MinInputRange(1251.25)]
[FirmwareInputRange(1875.625)]
G1 = 8,
[MaxInputRange(1250D)]
[MinInputRange(625.625)]
[FirmwareInputRange(937.8125)]
G2 = 16,
[MaxInputRange(625D)]
[MinInputRange(156.40625)]
[FirmwareInputRange(468.90625)]
G4 = 24,
[MaxInputRange(312.5D)]
[MinInputRange(156.40625)]
[FirmwareInputRange(234.45313)]
G8 = 32,
[GainAvailableUnmodified(false)]
[MaxInputRange(156.25)]
[MinInputRange(125.03125)]
[FirmwareInputRange(140.64063)]
G16 = 40,
[MaxInputRange(125D)]
[MinInputRange(78.17188)]
[FirmwareInputRange(101.58594)]
G20 = 17,
[GainAvailableUnmodified(false)]
[MaxInputRange(78.125)]
[MinInputRange(62.51563)]
[FirmwareInputRange(70.32031)]
G32 = 48,
[MaxInputRange(62.5)]
[MinInputRange(39.08594)]
[FirmwareInputRange(50.79297)]
G40 = 25,
[GainAvailableUnmodified(false)]
[MaxInputRange(39.0625)]
[MinInputRange(31.25781)]
[FirmwareInputRange(35.16016)]
G64 = 56,
[MaxInputRange(31.25)]
[MinInputRange(15.64063)]
[FirmwareInputRange(23.44531)]
G80 = 33,
[MaxInputRange(15.625)]
[MinInputRange(7.82031)]
[FirmwareInputRange(11.72266)]
G160 = 41,
[MaxInputRange(7.8125)]
[MinInputRange(3.91016)]
[FirmwareInputRange(5.86133)]
G320 = 49,
[GainAvailableUnmodified(false)]
[MaxInputRange(3.90625)]
[MinInputRange(3.12578)]
[FirmwareInputRange(3.51602)]
G640 = 57,
[MaxInputRange(3.125)]
[MinInputRange(1.56406)]
[FirmwareInputRange(2.34453)]
G800 = 34,
[MaxInputRange(1.5625)]
[MinInputRange(.78203)]
[FirmwareInputRange(1.17227)]
G1600 = 42,
[GainDisabled(true)]
[MaxInputRange(.78125)]
[MinInputRange(0.39102)]
[FirmwareInputRange(0.58613)]
G3200 = 50,
[GainDisabled(true)]
[MaxInputRange(.39063)]
[MinInputRange(.15648)]
[FirmwareInputRange(.27355)]
G6400 = 58,
[GainDisabled(true)]
[MaxInputRange(.15625)]
[MinInputRange(.0782)]
[FirmwareInputRange(.11723)]
G16000 = 43,
[GainDisabled(true)]
[MaxInputRange(.07813)]
[MinInputRange(.03910)]
[FirmwareInputRange(.05861)]
G32000 = 51,
[GainDisabled(true)]
[MaxInputRange(.03906)]
[MinInputRange(0)]
[FirmwareInputRange(.01953)]
G64000 = 59
};
/// <summary>
/// 15462 Limit SLICE 6 AIR gains as they are not functional with IEPE accel
/// algorithm requires the gains to be in order of firmware input range explicitly
/// this can be used to sort enum values into order of firmware input range
/// </summary>
public class GainSorterSLICE6IEPE : IComparer<GainCodesSLICE6IEPE>
{
public int Compare(GainCodesSLICE6IEPE left, GainCodesSLICE6IEPE right)
{
var leftRange = FirmwareInputRangeAttribute.GetFirmwareInputRangemV(left);
var rightRange = FirmwareInputRangeAttribute.GetFirmwareInputRangemV(right);
return leftRange.CompareTo(rightRange);
}
}
/// <summary>
/// 10080 Implement SLICE PRO SIM Gain Limitation for Gen 3 SIMs
/// algorithm requires the gains to be in order of firmware input range explicitly
/// this can be used to sort enum values into order of firmware input range
/// </summary>
public class GainSorter : IComparer<GainCodesGen3>
{
public int Compare(GainCodesGen3 left, GainCodesGen3 right)
{
var leftRange = FirmwareInputRangeAttribute.GetFirmwareInputRangemV(left);
var rightRange = FirmwareInputRangeAttribute.GetFirmwareInputRangemV(right);
return leftRange.CompareTo(rightRange);
}
}
protected int _hardwareRevision = UNKNOWN_REVISION;
protected int _baseType = -1;
/// <summary>
/// returns the nominal input ranges for SLICE2
/// this was modified for
/// http://fogbugz/fogbugz/default.asp?10080
/// we now restrict the ranges by throwing out certain gains, etc
/// </summary>
/// <param name="bridgeType"></param>
/// <param name="bModified">whether the SPS is "modified" or not(http://fogbugz/fogbugz/default.asp?10080)</param>
/// <returns></returns>
public double[] GetNominalRanges(SensorConstants.BridgeType bridgeType, bool bModified)
{
//if we are not gen 3, do what we've always have done
if (_hardwareRevision != GEN3_REV_B)
return bridgeType == SensorConstants.BridgeType.IEPE
? StaticDASIEPESLICE2Info.NominalRanges
: WinUSBSlice.StaticDASBridgeInfo.NominalRanges;
//if we are IEPE, apparently we don't change anything
if (bridgeType == SensorConstants.BridgeType.IEPE)
{
return StaticDASRevCIEPEInfo.NominalRanges;
}
//finally, for not IEPE, we either use the modified or not modified ranges
return bModified
? StaticDASRevCBridgeInfoModified.NominalRanges
: StaticDASRevCBridgeInfoNotModified.NominalRanges;
}
private ushort _featureConfigValue = 1;
public override double[] GetNominalRanges(SensorConstants.BridgeType bridgeType)
{
if (_hardwareRevision != GEN3_REV_B)
{
//if we aren't gen3 we don't care whether we are modified or not
//http://fogbugz/fogbugz/default.asp?10080
return GetNominalRanges(bridgeType, false);
}
return GetNominalRanges(bridgeType, 1 == _featureConfigValue);
}
/// <summary>
/// checks whether the channel should perform voltage insertion or not
/// currently this just checks that the input range for the channel is >= 10mV per LP
/// http://manuscript.dts.local/f/cases/31824/Don-t-run-voltage-insertion-when-the-input-range-is-10mV
/// http://manuscript.dts.local/f/cases/3472/Fwd-RE-SLICE-PRO-SIM-Gen3-SPS00134-Voltage-insertion-Error
/// </summary>
/// <param name="dasChannelNumber"> </param>
/// <returns></returns>
protected bool ShouldPerformVoltageInsertionCheck(IDiagnosticActions action)
{
try
{
if (!action.PerformVoltageInsertCheck) { return false; }
var moduleNumber = DASInfo.MapDASChannelNumber2ModuleArrayIndex(action.DASChannelNumber);
var channelNumber = DASInfo.MapDASChannelNumber2ModuleChannelNumber(action.DASChannelNumber);
if (ConfigData.Modules[moduleNumber].Channels[channelNumber] is AnalogInputDASChannel aic)
{
if (double.IsNaN(aic.ScalefactorMilliVoltsPerADC) || 0 == aic.ScalefactorMilliVoltsPerADC)
{
//if any of these constraints fail treat the situation like existing behavior, run the check
return true;
}
var mvInputRange = Math.Abs(aic.ScalefactorMilliVoltsPerADC * short.MaxValue);
if (mvInputRange >= Constants.MINIMUM_VOLTAGE_INSERTION_RANGE_MV_SLICE) { return true; }
}
return false;
}
catch (Exception ex)
{
//if there's an exception, preserve the existing behavior, which would have been to run
//the check
APILogger.Log(ex);
return true;
}
}
protected override void PerformVoltageInsertionCheck(IDiagnosticActions[] ChannelActions, SliceServiceAsyncInfo info, ref IDiagnosticResult[] results)
{
// first count how many we need to do it on
var NumToMeasure = ChannelActions.Count(a => ShouldPerformVoltageInsertionCheck(a));
if (NumToMeasure == 0)
return;
var baseType = QueryBaseType();
var revision = QueryHardwareRevision();
//Min Protocol for QueryVoltageInsertion
if (baseType != PROBaseType || revision < 1)
{
// If the functionality doesn't exist, just make sure the results are set to null
// and the app will do the right thing.
//
ClearVoltageInsertionResults(ChannelActions, results);
}
var queryChannelInsertResults = new QueryVoltageInsertaionResult_SLICE2(this);
queryChannelInsertResults.DeviceID = 0; // send to base
var insertionChannelList = new byte[NumToMeasure];
var channelCounter = 0;
for (var idx = 0; idx < ChannelActions.Length; idx++)
{
var actions = ChannelActions[idx];
if (ShouldPerformVoltageInsertionCheck(actions))
{
insertionChannelList[channelCounter] = (byte)actions.DASChannelNumber;
channelCounter++;
}
}
queryChannelInsertResults.StackChannelList = insertionChannelList;
try
{
if (revision >= 1 && baseType == PROBaseType)
{
queryChannelInsertResults.SyncExecute();
channelCounter = 0;
for (var idx = 0; idx < ChannelActions.Length; idx++)
{
var actions = ChannelActions[idx];
if (ShouldPerformVoltageInsertionCheck(actions))
{
results[idx].MeasuredGain = queryChannelInsertResults.ActualGain[channelCounter];
results[idx].TargetGain = queryChannelInsertResults.ExpectedGain[channelCounter];
channelCounter++;
}
}
}
else
{
channelCounter = 0;
ClearVoltageInsertionResults(ChannelActions, results);
}
}
catch (Exception ex)
{
APILogger.Log("Failed to perform voltageinsertion check", ex);
// If the functionality doesn't exist, just make sure the results are set to null
// and the app will do the right thing.
//
ClearVoltageInsertionResults(ChannelActions, results);
}
}
/// <summary>
/// clears the measure and target gain information for any diagnostic results which should perform voltage insertion checks
/// http://manuscript.dts.local/f/cases/31824/Don-t-run-voltage-insertion-when-the-input-range-is-10mV
/// </summary>
/// <param name="ChannelActions"></param>
/// <param name="results"></param>
protected void ClearVoltageInsertionResults(IDiagnosticActions[] ChannelActions, IDiagnosticResult[] results)
{
for (var idx = 0; idx < ChannelActions.Length; idx++)
{
var actions = ChannelActions[idx];
if (ShouldPerformVoltageInsertionCheck(actions))
{
results[idx].MeasuredGain = null;
results[idx].TargetGain = null;
}
}
}
public override bool SupportsMultipleEvents()
{
return IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MultipleEvents);
}
public override bool SupportsAutoArm() { return IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.AutoArm); }
public override bool SupportsMultipleConfigurations() { return IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MultipleConfigurations); }
public override bool SupportsLevelTrigger() { return true; }
protected override bool SupportsIEPECalSignal
{
get
{
switch (DASInfo.Modules[0].TypeOfModule)
{
case DFConstantsAndEnums.ModuleType.ProDIM:
case DFConstantsAndEnums.ModuleType.SLICEPro_TOM:
return false;
default:
return true;
}
}
}
public override bool CheckAAF(float rate)
{
var configRate = 0F;
try { configRate = ConfigData.Modules[0].AAFilterRateHz; }
catch (Exception) { }
if (configRate < 100000 && rate < 100000) { return true; }
else if (configRate == 200000 && rate == 200000) { return true; }
else if (configRate >= 100000 && configRate <= 199000 && rate >= 100000 && rate <= 199000) { return true; }
return false;
}
//eventually this should be read from an attribute
public int PageSize => 16384;
/// <summary>
/// left over data are the samples broken between requests
/// since SLICE2 sends data by blocks, a complete sample for a list of channels could (and will) get broken
/// over multiple calls to QueryEventData. This temporarily holds the data between calls
/// the lock is not actually necessary, but is provided for sanity sake
/// </summary>
protected static object LeftOverDataLock = new object();
protected ushort[] _leftOverData = null;
/// <summary>
/// holds onto sample data between calls
/// original implementation was dynamic, but since we are
/// guaranteed by the block size that will never need to push twice in a row
/// it's quicker and easier just to hold an array between calls
/// </summary>
/// <param name="data"></param>
public void PushLeftOverData(ushort[] data)
{
lock (LeftOverDataLock)
{
_leftOverData = data;
}
}
/// <summary>
/// retrieves held over data between calls to QueryEventData
/// </summary>
/// <returns></returns>
public ushort[] PopLeftOverData()
{
lock (LeftOverDataLock)
{
if (null == _leftOverData) { return new ushort[0]; }
else { return _leftOverData; }
}
}
protected virtual bool SupportsDiagnosticsMode => IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticsMode) && !IsDIM() && !IsTOM();
/// <summary>
/// created for 11282, this just clears the diagnostics mode for das
/// this should be part of a generic services
/// </summary>
protected override void TurnOffDiagnosticsMode()
{
if (SupportsDiagnosticsMode)
{
try
{
var scd = new SetChannelDiagnosticVoltageInsertion_SLICE2(this);
// This command will clear the voltage insertion on any capable device.
scd.DeviceID = 0;
scd.StackChannelList = new byte[0]; // Empty Set
scd.SyncExecute(); // Send empty set to device
}
catch (Exception ex)
{
APILogger.Log("Failed to unset VoltageInsertion flag", ex);
}
}
}
/// <summary>
/// for SLICE2 we override WhatToDownload and transparently handle things our own way from the outside
/// </summary>
private WhatToDownloadSlice2 _whatToDownload;
public override IDownloadRequest WhatToDownload
{
get => _whatToDownload;
set
{
_leftOverData = new ushort[0];
var numChannels = NumberOfDownloadChannels();
if (IsTOM())
{
//number of channels is a lie! don't trust it!
numChannels = 9;
}
_whatToDownload = new WhatToDownloadSlice2(value, numChannels, PageSize);
}
}
/// <summary>
/// QueryEventData also is customized for SLICE2, it needs to perform SLICE2 specific data marshalling
/// </summary>
/// <returns></returns>
protected override QueryEventDataBase GetQueryEventData()
{
return new QueryEventData_SLICE2(this, AbstractCommandBase.Default_IO_Timeout);
}
/// <summary>
/// SLICE2 currently doesn't have a way of storing a GUID
/// we temporarily fake it by storing it in a file
/// SLICE2 really should hold onto the GUID ... GUID is more unique than test id ...
/// and this is already functionality in SLICE1 and soft baked into the TDAS implementation
/// </summary>
/// <param name="guid"></param>
protected override void SetEventGuid(Guid guid)
{
try
{
File.WriteAllText($"{SerialNumber}_GUID", guid.ToString());
APILogger.Log("SetEventGuid (", SerialNumber, "): ", guid.ToString());
}
catch (Exception ex)
{
APILogger.Log("Failed to set guid", ex);
}
}
/// <summary>
/// overrided as SLICE2 will not hold onto GUID right now
/// </summary>
/// <param name="eventNum"></param>
/// <returns></returns>
protected override Guid GetEventGuid(int eventNum)
{
try
{
if (File.Exists(string.Format("{0}_GUID", SerialNumber)))
{
var s = File.ReadAllText(string.Format("{0}_GUID", SerialNumber));
APILogger.Log("GetEventGuid: ", SerialNumber, ": ", s);
return new Guid(s);
}
}
catch (Exception ex)
{
APILogger.Log("Failed to get event guid", SerialNumber, ex);
}
return Guid.Empty;
}
/// <summary>
/// hardcoded constants right now ... maybe these belong in attributes in the firmware!
/// </summary>
protected override uint MaxAAFilterRateHz => SLICE2.MaxAAFilterRateHz;
protected override uint MaxSampleRateHz => 1000000;
public override long MaxMemory()
{
if (null == DASInfo || 0 == DASInfo.NumberOfBytesPerSampleClock ||
null == DASInfo.MaxEventStorageSpaceInBytes) { return 0; }
return (long)(DASInfo.MaxEventStorageSpaceInBytes / DASInfo.NumberOfBytesPerSampleClock);
}
/// <summary>
/// this is a mapping of module count to max sample rate for an SPD
/// http://manuscript.dts.local/f/cases/43548/Add-support-for-1-5MB-SPS-on-SPD
/// </summary>
private static readonly Dictionary<int, uint> _SPDModulesToMaxRate = new Dictionary<int, uint>()
{
{1, 1500000 },
{2, 1200000 },
{3, 1000000 },
{4, 800000 },
{5, 700000 },
{6, 600000 }
};
/// <summary>
/// the default max sample rate for an SPD if we don't have a matching module count
/// </summary>
private const uint DEFAULT_MAX_SPS_SPD = 600000;
/// <summary>
/// returns the max sample rate for a SLICE DIM
/// http://manuscript.dts.local/f/cases/43548/Add-support-for-1-5MB-SPS-on-SPD
/// </summary>
private uint MaxSampleRateDIM()
{
try
{
if (_SPDModulesToMaxRate.ContainsKey(DASInfo.Modules.Length))
{
return _SPDModulesToMaxRate[DASInfo.Modules.Length];
}
}
catch( Exception ex )
{
APILogger.Log(ex);
}
return DEFAULT_MAX_SPS_SPD;
}
/// <summary>
/// calculates the max sample rate
/// these are not exact max sample rates, but convenient close enough limits
/// drop 100k every module after 3 (starting at 800k)
/// </summary>
/// <returns></returns>
public override uint MaxSampleRate(int numberOfConfiguredChannels)
{
try
{
if (IsDIM()) { return MaxSampleRateDIM(); }
}
catch( Exception ex)
{
APILogger.Log(ex);
}
if (DASInfo.Modules.Length <= 3) { return MaxSampleRateHz; }
else
{
return Convert.ToUInt32((12 - DASInfo.Modules.Length) * 100000);
}
}
private uint _minSampleRate = uint.MinValue;
public override uint MinSampleRate()
{
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting the min sample rate while streaming, it will fail
if (GetIsStreaming())
{
_minSampleRate = 50;
return _minSampleRate;
}
if (uint.MinValue == _minSampleRate)
{
try
{
var qsa = new QuerySystemAttributeSLICE2(this);
qsa.Key = AttributeTypes.SystemAttributesSLICE2.MinimumSampleRate;
qsa.SyncExecute();
_minSampleRate = Convert.ToUInt16(qsa.Value);
}
catch (Exception)
{
_minSampleRate = 50;
}
}
return _minSampleRate;
}
public override uint MaxAAFilterRate()
{
return MaxAAFilterRateHz;
}
/// <summary>
/// returns a GetRealtimeSamples class object appropriate for the DAS
/// this is partially necessary as SLICE2 uses a different channel ordering than SLICE1
/// </summary>
/// <param name="iCommunication"></param>
/// <param name="bPolling">whether realtime is polling for samples or not</param>
/// <returns></returns>
protected override IGetRealtimeSamples GetRealtimeSamplesClass(DTS.Common.Interface.DASFactory.ICommunication iCommunication, bool bPolling = false)
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StartRealtimeStream) && !bPolling)
{
return new RealtimeStreamingNextSamples(iCommunication);
}
return new GetRealtimeSamplesSLICE2(iCommunication);
}
/// <summary>
/// indicates whether the DAS supports streaming
/// 10572 implement SW side for single command streaming realtime
/// (note protocol >=152 required for streaming)
/// </summary>
public override bool SupportsIndividualChannelRealtimeStreaming => IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StartRealtimeStream);
public class GetRealtimeSamplesSLICE2 : GetRealtimeSamples
{
public GetRealtimeSamplesSLICE2(DTS.Common.Interface.DASFactory.ICommunication sock)
: base(sock, 2000) { }
public GetRealtimeSamplesSLICE2(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
: base(sock, TimeoutMillisec) { }
protected override CommandReceiveAction WholePackage()
{
try
{
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
{
// Figure out the number of samples returned
var samples_returned = (response.ParameterLength - 8) / (_channels * 2);
_samplesReturned = samples_returned;
var data_bytes_returned = samples_returned * _channels * 2;
_data = new List<short[]>(_channels);
// Grab the sample number
if (response.ParameterLength > 0)
{
response.GetParameter(0, out _sampleNumber);
}
// Create the data arrays by channel
if (samples_returned > 0)
{
for (var i = 0; i < _channels; i++)
{
_data.Add(new short[samples_returned]);
}
}
// Grab the data
var parameter = 8;
for (var sample = 0; sample < samples_returned; sample++)
{
for (var channel = 0; channel < _channels; channel++)
{
response.GetParameter(parameter, out ushort val);
//changed from unsigned to signed
_data[channel][sample] = (short)(((((val & 0x00FF) << 8) | ((val >> 8) & 0x00FF))) + 0x8000);
try
{
if (recorder is IDASCommunication idas && null != idas.DASInfo && null != idas.DASInfo.Modules &&
idas.DASInfo.Modules.Any())
{
if (idas.DASInfo.Modules[0].TypeOfModule ==
DFConstantsAndEnums.ModuleType.ProDIM)
{
var ch = idas.ConfigData.Modules[
idas.DASInfo.MapDASChannelNumber2ModuleArrayIndex(channel)].Channels[
idas.DASInfo.MapDASChannelNumber2ModuleChannelNumber(channel)];
if (null == ch)
{
continue;
}
}
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
parameter += 2;
}
}
return CommandReceiveAction.StopReceiving;
}
}
catch
{
_samplesReturned = 0;
}
return CommandReceiveAction.StopReceiving;
}
}
private readonly Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte> SLICE2_MinimumProtocols = new Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte>();
public override void InitMinProto()
{
try
{
_baseType = QueryBaseType();
}
catch (Exception) { }
// SLICE 2.0 Protocol Limitations
if (_baseType != (int)SLICERecorder.SLICEPRO_BaseType.SLICEPRO_DIM)
{ SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.DiangosShuntDAC] = SLICE2.MIN_PROTOCOL_VER; }
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryMSP430Firmware] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleAndHybridEvents] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleEvents] = SLICE2.MULTIPLE_EVENTS;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AutoArm] = SLICE2.MULTIPLE_EVENTS;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.FlashCardInfo] = SLICE2.MIN_PROTOCOL_VER;
if (_baseType == SLICE2.SLICEPRO_DIM_BASETYPE || _baseType == SLICE2.SLICEPRO_TOM_BASETYPE || _baseType == SLICE2.SLICE1_5_BASETYPE)
{
//empty, just here for readability
}
else
{
//http://manuscript.dts.local/f/cases/18457/Add-Protocol-155-support-for-voltage-insertion-on-SLICE-PRO
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.VoltageInsertion] = 155;
}
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF] = SLICE2.MIN_PROTOCOL_VER_GEN3;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate] = SLICE2.STACK_FIRMWARE_UPDATE;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.FileData] = SLICE2.FILE_DATA;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackSensors] = SLICE2.STACK_SENSORS;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.BaseSystemTime] = SLICE2.MIN_PROTOCOL_VER_GEN3;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.PhysicalStartAddress] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.TestCommunication] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackLowPowerMode] = SLICE2.MIN_PROTOCOL_VER;
if (_baseType == SLICE2.SLICE1_5_BASETYPE || _baseType == SLICE2.SLICEPRO_DIM_BASETYPE || _baseType == SLICE2.SLICEPRO_TOM_BASETYPE)
{
//empty, just here for readability
}
else { SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackChannelTypeConfiguration] = SLICE2.MULTIPLE_EVENTS; }
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SetRealtimeSampleRate] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SLICE2_OneWireID] = SLICE2.SLICE2_ONE_WIRE_ID;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.HardwareRevision] = SLICE2.MIN_PROTOCOL_VER_GEN3;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.HardwareConfiguration] = SLICE2.MULTIPLE_EVENTS;
if (_baseType == SLICE2.SLICE1_5_BASETYPE || _baseType == SLICE2.SLICEPRO_DIM_BASETYPE || _baseType == SLICE2.SLICEPRO_TOM_BASETYPE)
{
//empty, just here for readability
}
else { SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels] = SLICE2.STACK_SENSORS; }
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.EventFaultFlags] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.EventArmAttempts] = SLICE2.EVENT_ARM_ATTEMPTS;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryActualSampleRateImmediate] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.VoltageSysAttributes] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticTwoVoltExcitation] = SLICE2.DIAGNOSTIC_TWO_VOLT_EXCITATION;
if (_baseType == SLICE2.SLICEPRO_DIM_BASETYPE || _baseType == SLICE2.SLICEPRO_TOM_BASETYPE || _baseType == SLICE2.SLICE1_5_BASETYPE)
{
//empty, just here for readability
}
else { SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.ExcitationLevel] = SLICE2.FILE_DATA; }
if (_baseType == SLICE2.SLICEPRO_DIM_BASETYPE || _baseType == SLICE2.SLICEPRO_TOM_BASETYPE)
{
//empty, just here for readability
}
else { SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.LevelTrigger] = SLICE2.MIN_PROTOCOL_VER; }
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AttributeStoreBlocks] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryArmAndTriggerStatus_VoltageReadings] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MaxEvents] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AutoArmDiagnosticDelay] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackChannelAutoArmDiagLevel] = SLICE2.FILE_DATA;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.FlashClear] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticsMode] = SLICE2.FILE_DATA;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleSamplesRealtime] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.ResetAttributeStore] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryArmAndTriggerStatus_TimeLeftInArm] = SLICE2.QUERY_ARM_AND_TRIGGER_STATUS_TIME_LEFT_IN_ARM;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MeasureInternalOffset] = SLICE2.MEASURE_INTERNAL_OFFSET;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MeasureInternalOffsetSwitches] = SLICE2.MIN_PROTOCOL_VER_GEN3;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryBatterySOC] = SLICE2.MIN_PROTOCOL_VER_GEN3;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StartRecDelayInSecond] = SLICE2.START_REC_DELAY_IN_SECONDS;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StartRealtimeStream] = SLICE2.START_REALTIME_STREAM;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.HalfBridgeSigPlusSupport] = SLICE2.HALF_BRIDGE_SIG_PLUS_SUPPORT;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AutoArmRepeatEnable] = SLICE2.MIN_PROTOCOL_VER;
SLICE2_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.GenerateEvent] = 156;
MinimumProtocols = SLICE2_MinimumProtocols;
}
private enum SquibFireModes
{
DISABLED = 0,
CapDischarge = 1,
ConstantCurrent = 2,
CapDischargeInternal = 3,
ConstantCurrentInternal = 4
}
private enum SquibMeasurementTypes
{
InitiationSignal = 0x00,
SquibVoltage = 0x01
}
private enum TOMDigitalOutputModes
{
Disabled = 0,
LHT = 1,
HLT = 2,
CCNC = 3,
CCNO = 4
}
private readonly float MaxSquibDurationMS = 40; //Kids need limits, so do unlimited-duration squibs
protected void SetArmDisableShortCheck()
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.IgnoreShortedStartEvent))
{
var ignoreShortedStart = Convert.ToByte(IgnoreShortedStart);
var ssa = new SetSystemAttributeSLICE2(this, AbstractCommandBase.Default_IO_Timeout);
ssa.SetValue(AttributeTypes.SystemAttributesSLICE2.ArmDisableStartShortCheck, ignoreShortedStart, true);
ssa.SyncExecute();
}
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.IgnoreShortedStartEvent))
{
var ignoreShortedTrigger = Convert.ToByte(IgnoreShortedTrigger);
var ssa = new SetSystemAttributeSLICE2(this, AbstractCommandBase.Default_IO_Timeout);
ssa.SetValue(AttributeTypes.SystemAttributesSLICE2.ArmDisableTriggerShortCheck, ignoreShortedTrigger, true);
ssa.SyncExecute();
}
}
private enum ModificationSettings
{
None = 0,
UseFullGainList = 1 << 0,
Excitation7_9V = 1 << 1
};
/// <summary>
/// the TOM is so different it didn't make sense to reuse the old AsyncConfigure, so I created one
/// specifically for TOM
/// </summary>
/// <param name="configAsyncInfo"></param>
private void AsyncConfigureTOM(object configAsyncInfo)
{
var info = configAsyncInfo as SliceConfigServiceAsyncInfo;
var progressValue = 0;
var bReleased = true;
PresetSampleRate();
SetVoltageRequirements();
SetPolarity();
try
{
Lock();
bReleased = false;
// report progress
progressValue = 5;
info.Progress(progressValue);
var config = GetConfigAttributes(this);// new ConfigAttributes(this);
// only set attributes to default if we haven't run diagnostics yet
if (!DiagnosticsHasBeenRun)
{
config.PurgeStaleData(this);
}
// store some attributes
if (ConfigData.Modules.Length > 0)
{
config.SampleRate = ConfigData.Modules[0].SampleRateHz;
//System.Diagnostics.Trace.WriteLine("Sample Rate: " + config.SampleRate);
var actualSampleRate = (float)ConfigData.Modules[0].SampleRateHz;
actualSampleRate = config.ActualSampleRate;
config.AAFilter = ConfigData.Modules[0].AAFilterRateHz;
config.TestID = ConfigData.TestID.TrimEnd(new char[] { '\0' });
config.TestSetupUniqueId = ConfigData.TestSetupUniqueId?.TrimEnd('\0');
config.TestDescription = ConfigData.Description;
config.PreTriggerSamples = (ulong)(ConfigData.Modules[0].PreTriggerSeconds * actualSampleRate);
config.PostTriggerSamples = (ulong)(ConfigData.Modules[0].PostTriggerSeconds * actualSampleRate);
SetArmMode(ConfigData.Modules[0].RecordingMode);
// get scale factors
var scaleFactors = config.GetScaleFactors();
for (var moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
{
for (var channelIdx = 0; channelIdx < ConfigData.Modules[moduleIdx].Channels.Length; channelIdx++)
{
if (ConfigData.Modules[moduleIdx].Channels[channelIdx] is OutputSquibChannel)
{
//var analog = ConfigData.Modules[moduleIdx].Channels[channelIdx] as AnalogInputDASChannel;
var dasChannelNumber = DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(moduleIdx, channelIdx);
//analog.ScalefactorMilliVoltsPerADC = scaleFactors[dasChannelNumber];
var squib = ConfigData.Modules[moduleIdx].Channels[channelIdx] as OutputSquibChannel;
squib.ScaleFactorMv = scaleFactors[dasChannelNumber];
}
}
progressValue++;
info.Progress(Math.Min(19, progressValue));
}
}
SetArmDisableShortCheck();
foreach (var module in ConfigData.Modules)
{
for (var i = 0; i < 8; i += 2)
{
var voltageSquib = module.Channels[i] as OutputSquibChannel;
var currentSquib = module.Channels[i + 1] as OutputSquibChannel;
System.Diagnostics.Trace.Assert((null != currentSquib && null != voltageSquib), "we are missing a voltage or a squib channel");
var sscc = new SetSquibChannelConfiguraion(this);
sscc.SetSquibChannelID(Convert.ToByte(i / 2));//we want 0-3 for channel id
if (currentSquib.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal)
{
switch (voltageSquib.MeasurementType)
{
default:
case SquibMeasurementType.VOLTAGE:
sscc.SetSquibRecordMode(Convert.ToByte(SquibMeasurementTypes.SquibVoltage));
break;
case SquibMeasurementType.INIT_SIGNAL:
sscc.SetSquibRecordMode(Convert.ToByte(SquibMeasurementTypes.InitiationSignal));
break;
}
switch (currentSquib.FireMode)
{
case SquibFireMode.CAP:
{
if (info.DummyConfig) { sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.CapDischargeInternal)); }
else { sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.CapDischarge)); }
}
break;
case SquibFireMode.CONSTANT:
{
if (info.DummyConfig) { sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.ConstantCurrentInternal)); }
else { sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.ConstantCurrent)); }
}
break;
//default: sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.DISABLED)); break;
}
if (currentSquib.LimitDuration) { sscc.SetSquibDurationMs(Convert.ToSingle(currentSquib.DurationMS)); }
else { sscc.SetSquibDurationMs(MaxSquibDurationMS); }
sscc.SetSquibDelayMs(Convert.ToSingle(currentSquib.DelayMS));
sscc.SetSquibResMax(Convert.ToSingle(currentSquib.SquibToleranceHigh));
sscc.SetSquibResMin(Convert.ToSingle(currentSquib.SquibToleranceLow));
sscc.SetSquibOutputCurrentAmp(Convert.ToSingle(currentSquib.SquibOutputCurrent));
}
else
{
sscc.SetSquibOutputMode(Convert.ToByte(SquibFireModes.DISABLED));
}
sscc.SyncExecute();
}
for (var i = 8; i < module.Channels.Length; i++)
{
var sscc = new SetDigitalChannelConfiguration(this);
sscc.SetDigitalChannelID(Convert.ToByte(i - 8));
var dout = module.Channels[i] as OutputTOMDigitalChannel;
System.Diagnostics.Trace.Assert(null != dout, "Missing a digital output channel");
if ((dout.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal) ||
(dout.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm))
{
if (!info.ConfigureDigitalOutput && info.DummyConfig)
{
sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.Disabled));
}
else
{
switch (dout.OutputMode)
{
case DigitalOutputModes.CCNC: sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.CCNC)); break;
case DigitalOutputModes.CCNO: sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.CCNO)); break;
case DigitalOutputModes.FVHL: sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.HLT)); break;
case DigitalOutputModes.FVLH: sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.LHT)); break;
case DigitalOutputModes.NONE: sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.Disabled)); break;
}
}
}
else
{
sscc.SetDigitalOutputMode(Convert.ToByte(TOMDigitalOutputModes.Disabled));
}
if ((dout.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal) ||
((dout.DelayMS + dout.DurationMS) <= (ConfigData.Modules[0].PostTriggerSeconds * 1000)))
{
//As long as the delay + duration is less than the post-trigger seconds (1 if CB, 10 if Recorder), use it even if it's just a trigger check
sscc.SetDigitalDelayMs(Convert.ToSingle(dout.DelayMS));
if (dout.LimitDuration) { sscc.SetDigitalDurationMs(Convert.ToSingle(dout.DurationMS)); }
else { sscc.SetDigitalDurationMs(0); }
}
else
{
// Since we're not going to let trigger check testing go longer than post-trigger seconds, just fire immediately
sscc.SetDigitalDelayMs(0);
sscc.SetDigitalDurationMs(Convert.ToSingle(10));
}
sscc.SyncExecute();
}
}
progressValue = 30;
info.Progress(progressValue);
// now store the data
var configStr = ConfigurationData.Serialize((ConfigurationData)ConfigData);
config.StoreXMLConfig(configStr, info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic);
ConfigurationData.SetConfiguration(this, configStr,
info.EventConfig
? (int)ConfigAttributes.FileStore.Event
: (int)ConfigAttributes.FileStore.Diagnostic);
//dummy read to flush buffer, per Loc
try
{
var qsa = new QuerySystemAttribute(this);
qsa.Key = AttributeTypes.SystemAttributes.SerialNumber;
qsa.SyncExecute();
}
catch (Exception) { }
progressValue = 60;
info.Progress(progressValue);
try
{
var retrieved = config.RetrieveXMLConfig(info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic, this);
var utf8Version = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(configStr));
if (!retrieved.Equals(utf8Version))
{
APILogger.Log($"read does not match write {SerialNumber}", retrieved, configStr);
}
}
catch (Exception ex)
{
APILogger.Log("failed to read config", ex);
}
//this only needs to be done in datapro, which doesn't set position 0
//we'll have to clean up the code a bit to use it if we want for sliceware.
//config.StoreXMLConfig(configStr, !info.EventConfig);
config.StoreXMLConfig(configStr, info.EventConfig ? ConfigAttributes.FileStore.Diagnostic : ConfigAttributes.FileStore.Event);
progressValue = 70;
info.Progress(progressValue);
//dummy read to flush buffer, per Loc
try
{
var qsa = new QuerySystemAttribute(this);
qsa.Key = AttributeTypes.SystemAttributes.SerialNumber;
qsa.SyncExecute();
}
catch (Exception) { }
progressValue = 80;
info.Progress(progressValue);
try
{
var retrieved = config.RetrieveXMLConfig(info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic, this);
var utf8Version = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(configStr));
if (!retrieved.Equals(utf8Version))
{
APILogger.Log($"read does not match write {SerialNumber}", retrieved, configStr);
}
}
catch (Exception ex)
{
APILogger.Log("failed to read config", ex);
}
ConfigureHasBeenRun = true;
if (info.DiscardDiagnostics) { DiagnosticsHasBeenRun = false; }
// report success'
if (!bReleased) { bReleased = true; Release(); }
progressValue = 90;
info.Progress(progressValue);
info.Success();
}
catch (CanceledException)
{
if (!bReleased) { bReleased = true; Release(); }
info.Cancel();
}
catch (Exception ex)
{
if (!bReleased) { bReleased = true; Release(); }
info.Error(ex.Message, ex);
}
finally { if (!bReleased) { bReleased = true; Release(); } }
info.Progress(100);
info.Success();
}
protected override float GetLevelTriggerThreshold(AnalogInputDASChannel analog, IDiagnosticResult diagnostics, double thresholdeu, double MvPerEu)
{
//I have modified this to be modeled after DataScaler and how it gets EU, it's a bit different than before ...
var dataZeroLevelADC = diagnostics.GetExpectedDataZeroLevelADC(analog.ZeroMethod);
var initialOffsetmVInADC = 0D;
var io = new InitialOffset();
io.FromDbSerializeString(analog.InitialOffset);
if (io.Form == InitialOffsetTypes.EUAtMV)
{
initialOffsetmVInADC = io.MV / diagnostics.ScalefactorMilliVoltsPerADC;
}
MvPerEu = analog.SensitivityMilliVoltsPerEU;
var adcToEUScalingFactor = (diagnostics.ScalefactorMilliVoltsPerADC / (analog.IsProportionalToExcitation
? analog.SensitivityMilliVoltsPerEU * analog.FactoryExcitationVolts : MvPerEu))
* (analog.AtCapacity ? analog.CapacityOutputIsBasedOn : 1.0)
* (analog.IsInverted ? -1.0 : 1.0);
var negativeSensitivity = analog.SensitivityMilliVoltsPerEU < 0;
var negativePolarity = analog.IsInverted;
var eu = 0D;
var adc = 0D;
var mV = 0D;
//16272 3.1 LevelTrigger issues
//there must be some double negative occurring in this case that doesn't occur in others?
if (negativeSensitivity && !negativePolarity)
{
eu = -1D * thresholdeu - analog.InitialEU - dataZeroLevelADC * (double)adcToEUScalingFactor +
initialOffsetmVInADC * (double)adcToEUScalingFactor;
adc = eu / (double)adcToEUScalingFactor;
mV = adc * diagnostics.ScalefactorMilliVoltsPerADC;
}
else
{
eu = thresholdeu - analog.InitialEU + dataZeroLevelADC * (double)adcToEUScalingFactor +
initialOffsetmVInADC * (double)adcToEUScalingFactor;
adc = eu / (double)adcToEUScalingFactor;
mV = adc * diagnostics.ScalefactorMilliVoltsPerADC;
}
var sb = new StringBuilder();
sb.AppendFormat("{0} {1} {2}:{3}\r\n", DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString(), SerialNumber, analog.Number);
sb.AppendFormat("DataZeroLevelADC={0}", dataZeroLevelADC);
sb.AppendFormat("ScaleFactormVPerADC={0}\r\n", diagnostics.ScalefactorMilliVoltsPerADC);
sb.AppendFormat("MvPerEU={0}\r\n", MvPerEu);
sb.AppendFormat("adcToEUScalingFactor = {0}\r\n", adcToEUScalingFactor);
sb.AppendFormat("eu={0}\r\n", eu);
sb.AppendFormat("ZeroMVINADC={0}", diagnostics.ZeroMVInADC);
sb.AppendFormat("adc={0}\r\n", adc);
sb.AppendFormat("mv={0}\r\n", mV);
LevelTriggerLogging.LevelTriggerLog(sb.ToString());
return Convert.ToSingle(mV);
}
protected bool ShouldQueryFeatureConfig()
{
return !(this is EthernetSlice6 || this is EthernetSlice6Air || this is EthernetSlice6AirBridge || this is EthernetSlice6DB || this is EthernetSlice6DB3 ||
this is WinUSBTsrAir || this is EthernetTsrAir || this is EthernetSlice6AirThermocoupler);
}
protected void ConfigureDiagChannels(byte[] diagnosticChannels)
{
if (SupportsDiagnosticsMode)
{
var scd = new SetChannelDiagnosticVoltageInsertion_SLICE2(this, AbstractCommandBase.Default_IO_Timeout);
if (!diagnosticChannels.Any())
{
// This command will clear the voltage insertion on any capable device.
scd.DeviceID = 0;
scd.StackChannelList = new byte[0]; // Empty Set
scd.SyncExecute(); // Send empty set to device
}
else
{
// The following command will set the voltage insertion if there are diagnosticChannels
scd = new SetChannelDiagnosticVoltageInsertion_SLICE2(this, AbstractCommandBase.Default_IO_Timeout);
scd.DeviceID = 0;
scd.StackChannelList = diagnosticChannels; // List of diagnostic channels
scd.SyncExecute();
}
}
}
protected void PresetSampleRate()
{
//this is a bit of a hack, but lets make sure sample rate gets set first
try
{
if (ConfigData.Modules.Length > 0)
{
var config = GetConfigAttributes(this);
config.SampleRate = ConfigData.Modules[0].SampleRateHz;
var actualSampleRate = (float)ConfigData.Modules[0].SampleRateHz;
actualSampleRate = config.ActualSampleRate;
config.AAFilter = ConfigData.Modules[0].AAFilterRateHz;
}
}
catch (Exception ex) { APILogger.Log("failed to pre-set sample rate", ex); }
}
private void ReconfigureIfNeeded(ref bool bModified)
{
if (_hardwareRevision == GEN3_REV_B)
{
if (!ShouldQueryFeatureConfig())
{
_featureConfigValue = 1;
}
else
{
var queryFeatureConfig = new QuerySystemAttribute_Slice2Bridge(this);
queryFeatureConfig.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2.FeatureConfig;
queryFeatureConfig.DeviceID = 1;
queryFeatureConfig.SyncExecute();
bModified = ((Convert.ToInt32(queryFeatureConfig.Value)) & (int)ModificationSettings.UseFullGainList) == (int)ModificationSettings.UseFullGainList;
}
}
}
protected virtual bool AdjustInputRange(AnalogInputDASChannel analog)
{
//if our range is not at an edge of the gains table, then
//the requested range may need to be manipulated for
//10080 Implement SLICE PRO SIM Gain Limitation for Gen 3 SIMs
switch (analog.TypeOfBridge)
{
case SensorConstants.BridgeType.FullBridge:
case SensorConstants.BridgeType.HalfBridge:
case SensorConstants.BridgeType.HalfBridge_SigPlus:
case SensorConstants.BridgeType.QuarterBridge:
return true;
}
return false;
}
protected virtual bool RequiresNon0QualificationSamples { get => false; }
protected virtual void CommonRangeWork(AnalogInputDASChannel analog,
bool bModified,
float[] rangeArray,
byte dasChannelNumber,
double MvPerEU,
IDASModule module
)
{
if (null == analog) { return; }
var requestedRange = GetRequestedRange(analog, MvPerEU);
APILogger.DebugLog($"CommonRangeWork HC={analog?.HardwareChannelName ?? "NULL"}, mVPerEu={MvPerEU}, DasChannelNumber={dasChannelNumber}, requestedRange={requestedRange}");
var nominalRanges = GetNominalRanges(analog.TypeOfBridge, bModified);
//if our range is at one of the edges, there's nothing we can do, just take the edge
if (requestedRange > nominalRanges[0])
{
requestedRange = nominalRanges[0];
}
else if (requestedRange < nominalRanges[nominalRanges.Length - 1])
{
requestedRange = nominalRanges[nominalRanges.Length - 1];
}
else
{
if (AdjustInputRange(analog))
{
APILogger.DebugLog($"CommonRangeWork HC={analog?.HardwareChannelName ?? "NULL"}, mVPerEu={MvPerEU}, DasChannelNumber={dasChannelNumber}, AdjustingInputRange");
requestedRange = AdjustInputRangeIfNeeded(requestedRange, bModified);
}
}
APILogger.DebugLog($"CommonRangeWork HC={analog?.HardwareChannelName ?? "NULL"}, mVPerEu={MvPerEU}, DasChannelNumber={dasChannelNumber}, AssignedRange={requestedRange}");
rangeArray[dasChannelNumber] = Convert.ToSingle(requestedRange);
}
protected void CommonConfigureWork(List<byte> diagnosticChannels,
int[] qualificationSamples,
ref bool bReleased,
SliceConfigServiceAsyncInfo info,
byte[] bridgeModeArray,
bool[] IsACCoupledArray,
ushort[] BridgeResistanceArray,
ref bool bModified,
float[] rangeArray,
bool[] enableUpperLevelTriggerThreshold,
float[] upperLevelTriggerThreshold,
bool[] enableLowerLevelTriggerThreshold,
float[] lowerLevelTriggerThreshold,
bool[] bridgeACCouplingArray)
{
APILogger.DebugLog($"CommonConfigureWork - {SerialNumber} Start");
for (var moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
{
APILogger.DebugLog($"CommonConfigureWork - module={moduleIdx}");
var module = ConfigData.Modules[moduleIdx];
// configure the range for this bridge
for (var channelIdx = 0; channelIdx < module.Channels.Length; channelIdx++)
{
APILogger.DebugLog($"CommonConfigureWork - module={moduleIdx}, channel={channelIdx}");
var channel = module.Channels[channelIdx];
var dasChannelNumber = DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(moduleIdx, channelIdx);
//diagnosticChannels[dasChannelNumber] = channel.DiagnosticsMode ? (byte)1 : (byte)0;
if (channel.DiagnosticsMode) { diagnosticChannels.Add(dasChannelNumber); }
if (RequiresNon0QualificationSamples)
{
if (0 == channel.QualificationSamples) { channel.QualificationSamples = 5; }
}
qualificationSamples[dasChannelNumber] = channel.QualificationSamples;
if (channel.ConfigurationMode != DFConstantsAndEnums.ConfigMode.Disabled &&
(channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.Normal
|| channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.DummyArm))
{
if (!(channel is AnalogInputDASChannel))
{
if (!bReleased) { bReleased = true; Release(); }
// "Configure: Slice bridge modules must only contain analog input channels"
info.Error("Slice bridge modules must only contain analog input channels");
return;
}
var analog = channel as AnalogInputDASChannel;
switch (analog.TypeOfBridge)
{
case SensorConstants.BridgeType.FullBridge:
bridgeModeArray[dasChannelNumber] = 0;
bridgeACCouplingArray[dasChannelNumber] = analog.ACCouplingModeEnabled;
break;
case SensorConstants.BridgeType.HalfBridge:
bridgeModeArray[dasChannelNumber] = 1;
bridgeACCouplingArray[dasChannelNumber] = analog.ACCouplingModeEnabled;
break;
case SensorConstants.BridgeType.IEPE:
bridgeModeArray[dasChannelNumber] = 0;
bridgeACCouplingArray[dasChannelNumber] = false;
break;
case SensorConstants.BridgeType.QuarterBridge:
bridgeModeArray[dasChannelNumber] = 2;
bridgeACCouplingArray[dasChannelNumber] = analog.ACCouplingModeEnabled;
break;
case SensorConstants.BridgeType.DigitalInput:
bridgeModeArray[dasChannelNumber] = 0;
analog.DigitalInputChannel = true;
bridgeACCouplingArray[dasChannelNumber] = false;
break;
case SensorConstants.BridgeType.HalfBridge_SigPlus:
bridgeModeArray[dasChannelNumber] = 3;
bridgeACCouplingArray[dasChannelNumber] = false;
break;
case SensorConstants.BridgeType.RTC:
bridgeModeArray[dasChannelNumber] = 8;
bridgeACCouplingArray[dasChannelNumber] = false;
break;
default:
bridgeModeArray[dasChannelNumber] = 0;
bridgeACCouplingArray[dasChannelNumber] = false;
break;
}
if (analog.IEPEChannel)
{
IsACCoupledArray[dasChannelNumber] = analog.CouplingMode == SensorConstants.CouplingModes.AC;
}
else { IsACCoupledArray[dasChannelNumber] = false; }
if (SensorConstants.IsTSRAirLowGChannel(module.SerialNumber()))
{
if (analog.ACCouplingModeEnabled && analog.CouplingMode == SensorConstants.CouplingModes.AC)
{
IsACCoupledArray[dasChannelNumber] = true;
}
}
switch (analog.TypeOfBridge)
{
case SensorConstants.BridgeType.HalfBridge:
case SensorConstants.BridgeType.HalfBridge_SigPlus:
BridgeResistanceArray[dasChannelNumber] = SLICE_HALFBRIDGE_RESISTANCE;
break;
case SensorConstants.BridgeType.RTC:
BridgeResistanceArray[dasChannelNumber] = 0;
break;
default:
BridgeResistanceArray[dasChannelNumber] = (ushort)analog.BridgeResistanceOhms;
break;
}
APILogger.DebugLog($"CommonConfigureWork {analog?.HardwareChannelName ?? "N/A"} sensitivity={analog?.SensitivityMilliVoltsPerEU}");
if (analog.SensitivityMilliVoltsPerEU != 0)
{
var MvPerEu = GetMvPerEUNormalized(analog);
CommonRangeWork(analog, bModified, rangeArray, dasChannelNumber, MvPerEu, module);
//
// push level trigger settings out to hardware
//
//if (enableLowerLevelTriggerThreshold[dasChannelNumber] = (null != analog.TriggerBelowThresholdEu))
if (null != analog.TriggerBelowThresholdEu)
{
//
// 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 ((analog.IsInverted || analog.SensitivityMilliVoltsPerEU < 0)
&& !(analog.IsInverted && analog.SensitivityMilliVoltsPerEU < 0))
{
enableUpperLevelTriggerThreshold[dasChannelNumber] = true;
try
{
var diagnostics = analog.Diagnostics;
upperLevelTriggerThreshold[dasChannelNumber] = GetLevelTriggerThreshold(analog, diagnostics, (double)analog.TriggerBelowThresholdEu, MvPerEu);
if (analog.SensitivityMilliVoltsPerEU < 0)
{
upperLevelTriggerThreshold[dasChannelNumber] = -upperLevelTriggerThreshold[dasChannelNumber];
}
}
catch (ApplicationException ex)
{
if (null != Exceptional.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
upperLevelTriggerThreshold[dasChannelNumber] = (float)analog.TriggerBelowThresholdEu;
else throw ex;
}
}
else
{
enableLowerLevelTriggerThreshold[dasChannelNumber] = true;
try
{
var diagnostics = analog.Diagnostics;
lowerLevelTriggerThreshold[dasChannelNumber] = GetLevelTriggerThreshold(analog, diagnostics, (double)analog.TriggerBelowThresholdEu, MvPerEu);
}
catch (ApplicationException ex)
{
if (null != Exceptional.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
lowerLevelTriggerThreshold[dasChannelNumber] = (float)analog.TriggerBelowThresholdEu;
else throw ex;
}
}
}
else
{
if ((analog.IsInverted || analog.SensitivityMilliVoltsPerEU < 0)
&& !(analog.IsInverted && analog.SensitivityMilliVoltsPerEU < 0)
)
{
upperLevelTriggerThreshold[dasChannelNumber] = 0;
enableUpperLevelTriggerThreshold[dasChannelNumber] = false;
}
else
{
lowerLevelTriggerThreshold[dasChannelNumber] = 0;
enableLowerLevelTriggerThreshold[dasChannelNumber] = false;
}
}
if (null != analog.TriggerAboveThresholdEu)
{
//
// 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 ((analog.IsInverted || analog.SensitivityMilliVoltsPerEU < 0)
&& !(analog.IsInverted && analog.SensitivityMilliVoltsPerEU < 0))
{
enableLowerLevelTriggerThreshold[dasChannelNumber] = true;
try
{
var diagnostics = analog.Diagnostics;
lowerLevelTriggerThreshold[dasChannelNumber] = GetLevelTriggerThreshold(analog, diagnostics, (double)analog.TriggerAboveThresholdEu, MvPerEu);
if (analog.SensitivityMilliVoltsPerEU < 0)
{
lowerLevelTriggerThreshold[dasChannelNumber] = -lowerLevelTriggerThreshold[dasChannelNumber];
}
}
catch (ApplicationException ex)
{
if (null != Exceptional.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
lowerLevelTriggerThreshold[dasChannelNumber] = (float)analog.TriggerAboveThresholdEu;
else throw ex;
}
}
else
{
enableUpperLevelTriggerThreshold[dasChannelNumber] = true;
try
{
var diagnostics = analog.Diagnostics;
upperLevelTriggerThreshold[dasChannelNumber] = GetLevelTriggerThreshold(analog, diagnostics, (double)analog.TriggerAboveThresholdEu, MvPerEu);
}
catch (ApplicationException ex)
{
if (null != Exceptional.ExtractFirstExceptionOfTypeFromExceptionTree<NoDiagnosticsAvailable>(ex))
upperLevelTriggerThreshold[dasChannelNumber] = (float)analog.TriggerAboveThresholdEu;
else throw ex;
}
}
}
else
{
if ((analog.IsInverted || analog.SensitivityMilliVoltsPerEU < 0)
&& !(analog.IsInverted && analog.SensitivityMilliVoltsPerEU < 0))
{
lowerLevelTriggerThreshold[dasChannelNumber] = 0;
enableLowerLevelTriggerThreshold[dasChannelNumber] = false;
}
else
{
upperLevelTriggerThreshold[dasChannelNumber] = 0;
enableUpperLevelTriggerThreshold[dasChannelNumber] = false;
}
}
}
else
{
APILogger.DebugLog($"CommonConfigureWork {analog?.HardwareChannelName ?? "N/A"} sensitivity 0, so range is 0");
rangeArray[dasChannelNumber] = 0;
}
}
else if (channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.StreamOut)
{
try
{
var streamOut = channel as StreamOutputDASChannel;
streamOut.UDPProfileName = info.StreamProfiles[this].ToString();
streamOut.UDPTimeChannelId = info.TimeChannelIds[this];
streamOut.UDPDataChannelId = info.DataChannelIds[this];
streamOut.IRIGTimeDataPacketIntervalMs = info.IrigTDPIntervals[this];
streamOut.UDPAddress = info.Addresses[this];
streamOut.UDPTmNSConfig = info.TmNSConfigs[this];
streamOut.TMATSIntervalMs = info.TMATSIntervalMs[this];
}
catch( Exception ex)
{
APILogger.Log("Failed to set stream output", ex);
}
}
else if (channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.UART)
{
try
{
var uart = channel as UARTInputDASChannel;
if (info.BaudRates.ContainsKey(this))
{
uart.BaudRate = info.BaudRates[this];
uart.DataBits = info.DataBits[this];
uart.StopBits = info.StopBits[this];
uart.Parity = info.Parities[this];
uart.FlowControl = info.FlowControls[this];
uart.DataFormat = info.DataFormats[this];
}
}
catch (Exception ex)
{
APILogger.Log("Failed to set UART", ex);
}
}
else if (channel.ConfigurationMode == DFConstantsAndEnums.ConfigMode.StreamIn)
{
var streamIn = channel as StreamInputDASChannel;
streamIn.UDPAddress = ConfigData.UDPReceiveAddress;
}
else
{
rangeArray[dasChannelNumber] = 0;
bridgeModeArray[dasChannelNumber] = 0;
BridgeResistanceArray[dasChannelNumber] = 0;
bridgeACCouplingArray[dasChannelNumber] = false;
enableLowerLevelTriggerThreshold[dasChannelNumber] = false;
enableUpperLevelTriggerThreshold[dasChannelNumber] = false;
lowerLevelTriggerThreshold[dasChannelNumber] = 0;
upperLevelTriggerThreshold[dasChannelNumber] = 0;
}
}
}
}
private bool IsStreamingOnlyMode()
{
if (null == ConfigData) { return false; }
if (null == ConfigData.Modules) { return false; }
if (0 >= ConfigData.Modules.Length) { return false; }
return ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.S6A_DeviceStreamingOnly
|| ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.Streaming;
}
protected virtual void SetStreamingRealtimeSampleRate(SliceConfigServiceAsyncInfo info)
{
//FB14613: When arming for stream-on-reboot, set RealtimeSampleRate to the DAS' test sample rate
try
{
//we don't need to set the realtime sample rate for record and stream recording modes, they won't use it
if (IsStreamingOnlyMode() &&
IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.SetRealtimeSampleRate))
{
var sampleRate = ConfigData.Modules[0].SampleRateHz;
var ssr = new SetRealtimeSampleRate(this);
ssr.SetValue(sampleRate);
ssr.SyncExecute();
//FB14966 - Can't get DataPRO to program RealtimeAAFilterFrequencyHz when running a streaming slice 6 air test
//Pass through Properties.SLICETurnOffAAFRealtime and use similar logic to TestTemplate.GetRealtimeAAFForHardware for the frequency
var aafRate = info.TurnOffAAFRealtime && DFConstantsAndEnums.SupportsTurnOffAAFRealtime(this)
? MaxAAFilterRateHz
: ConfigData.Modules[0].AAFilterRateHz;
var saaf = new SetArmAttribute(this);
saaf.SetValue(AttributeTypes.ArmAndEventAttributes.RealtimeAAFilterFrequencyHz, aafRate,
true);
saaf.SyncExecute();
}
}
catch (Exception ex)
{
APILogger.Log("Problem setting realtime sample rate", ex);
}
}
protected virtual void StoreConfigAttributes(SliceConfigServiceAsyncInfo info,
float[] rangeArray,
ref bool bReleased,
ref int progressValue,
byte[] bridgeModeArray,
bool[] IsACCoupledArray,
ushort[] BridgeResistanceArray,
bool[] enableLowerLevelTriggerThreshold,
float[] lowerLevelTriggerThreshold,
bool[] enableUpperLevelTriggerThreshold,
float[] upperLevelTriggerThreshold,
int[] qualificationSamples,
long numChannels,
out ConfigAttributes config,
bool[] bridgeACCouplingArray,
long numUartChannels,
long numStreamingChannels)
{
config = GetConfigAttributes(this);// new ConfigAttributes(this);
// only set attributes to default if we haven't run diagnostics yet
if (!DiagnosticsHasBeenRun)
{
config.PurgeStaleData(this);
}
// store some attributes
if (ConfigData.Modules.Length > 0)
{
config.SampleRate = ConfigData.Modules[0].SampleRateHz;
var actualSampleRate = (float)ConfigData.Modules[0].SampleRateHz;
actualSampleRate = config.ActualSampleRate;
config.AAFilter = ConfigData.Modules[0].AAFilterRateHz;
config.TestID = ConfigData.TestID.TrimEnd(new char[] { '\0' });
config.TestSetupUniqueId = ConfigData.TestSetupUniqueId?.TrimEnd('\0');
config.TestDescription = ConfigData.Description;
config.PreTriggerSamples = (ulong)(ConfigData.Modules[0].PreTriggerSeconds * actualSampleRate);
config.PostTriggerSamples = (ulong)(ConfigData.Modules[0].PostTriggerSeconds * actualSampleRate);
SetArmMode(ConfigData.Modules[0].RecordingMode);
SetStreamingRealtimeSampleRate(info);
try
{
config.ConfigureRange(rangeArray);
progressValue = 10;
info.Progress(progressValue);
}
catch (Exception ex)
{
var errorString = "Error attempting to set range to ";
foreach (var range in rangeArray)
{
errorString += range;
errorString += ", ";
}
errorString = errorString.Remove(errorString.Length - 2, 2);
if (ex.Message.Contains("StatusSetupRequestedSensorRangeTooSmall"))
{
APILogger.Log("Ignoring: " + errorString, ex);
}
else
{
APILogger.Log("Aborting: errorString", ex);
if (!bReleased) { bReleased = true; Release(); }
info.Error(string.Format(errorString));
return;
}
}
try
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StackChannelBridgeACCouplerEnable))
{
var set = new SetArmAttribute(this);
set.SetValue(AttributeTypes.ArmAndEventAttributes.StackChannelBridgeACCouplerEnable, bridgeACCouplingArray, true);
set.SyncExecute();
}
}
catch (Exception ex)
{
APILogger.Log($"Failed to set ACCouplingModeEnabled, {ex.Message}");
}
config.ConfigureBridge(bridgeModeArray);
config.ConfigureCoupling(IsACCoupledArray);
config.ConfigureBridgeResistance(BridgeResistanceArray);
// configure level trigger enable/threshold values
try
{
ConfigureLevelTriggers(enableLowerLevelTriggerThreshold,
enableUpperLevelTriggerThreshold,
lowerLevelTriggerThreshold,
upperLevelTriggerThreshold,
qualificationSamples);
}
catch (Exception ex) { APILogger.Log("Problem setting level triggers", ex); }
// get scale factors
var scaleFactors = config.GetScaleFactors();
if (numChannels > scaleFactors.Length + numUartChannels + numStreamingChannels)
{
if (!bReleased) { bReleased = true; Release(); }
// "ConfigurationService.Configure: Firmware returned {0} channels but stack contains {1}"
info.Error(string.Format("Firmware returned {0} channels but stack contains {1} analog channels",
scaleFactors.Length, numChannels - numUartChannels - numStreamingChannels));
return;
}
for (var moduleIdx = 0; moduleIdx < ConfigData.Modules.Length; moduleIdx++)
{
if (DFConstantsAndEnums.ModuleType.UART == ConfigData.Modules[moduleIdx].ModuleType()) continue; //only configuring the analogs
if (DFConstantsAndEnums.ModuleType.StreamOut == ConfigData.Modules[moduleIdx].ModuleType()) { continue; }
if (DFConstantsAndEnums.ModuleType.StreamIn == ConfigData.Modules[moduleIdx].ModuleType()) { continue; }
for (var channelIdx = 0;
channelIdx < ConfigData.Modules[moduleIdx].Channels.Length;
channelIdx++)
{
var analog = (AnalogInputDASChannel)ConfigData.Modules[moduleIdx].Channels[channelIdx];
var dasChannelNumber =
DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(moduleIdx, channelIdx);
analog.ScalefactorMilliVoltsPerADC = scaleFactors[dasChannelNumber];
}
progressValue++;
info.Progress(Math.Min(19, progressValue));
}
}
}
/// <summary>
/// abstracted this method out from a series of duplicated and very long functions
/// </summary>
/// <param name="progressValue"></param>
/// <param name="info"></param>
/// <param name="diagnosticChannels"></param>
/// <param name="config"></param>
/// <param name="bReleased"></param>
/// <param name="scaleFactors">scale factors for channels, only used in TSR AIR for some reason
/// <param name="ranges">ranges for channels, only used in TSR AIR for some reason</param>
/// <param name="measuredOffset">measured offset, only used in TSR AIR for some reason</param>
protected void RemainingConfigWork(ref int progressValue,
SliceConfigServiceAsyncInfo info,
List<byte> diagnosticChannels,
ConfigAttributes config,
ref bool bReleased,
float[] scaleFactors,
float[] ranges,
float[] measuredOffset)
{
ConfigureDiagChannels(diagnosticChannels.ToArray());
progressValue = 20;
info.Progress(progressValue);
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ExcitationLevel)) // add const value for proto version
{
// Allocate list for base excitation values.
var excitationValues = new List<byte>();
for (byte moduleIndex = 0; moduleIndex < ConfigData.Modules.Length; moduleIndex++)
{
for (var channelIdx = 0; channelIdx < ConfigData.Modules[moduleIndex].Channels.Length; channelIdx++)
{
var analog = ConfigData.Modules[moduleIndex].Channels[channelIdx] as AnalogInputDASChannel;
var dasChannelNumber = DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(moduleIndex, channelIdx);
switch (analog.Excitation)
{
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt2:
excitationValues.Add(2);
break;
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt10:
excitationValues.Add(10);
break;
case ExcitationVoltageOptions.ExcitationVoltageOption.Volt5:
excitationValues.Add(5);
break;
default:
excitationValues.Add(0);
break;
}
}
progressValue++;
info.Progress(Math.Min(29, progressValue));
}
var saa = new SetArmAttribute(this, AbstractCommandBase.Default_IO_Timeout);
saa.DeviceID = 0;
saa.SetValue(AttributeTypes.ArmAndEventAttributes.StackExcitationLevel, excitationValues.ToArray(), true);
saa.SyncExecute();
}
progressValue = 30;
info.Progress(progressValue);
// now store the data
var configStr = ConfigurationData.Serialize((ConfigurationData)ConfigData);
config.StoreXMLConfig(configStr, info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic);
ConfigurationData.SetConfiguration(this, configStr,
info.EventConfig
? (int)ConfigAttributes.FileStore.Event
: (int)ConfigAttributes.FileStore.Diagnostic);
//dummy read to flush buffer, per Loc
try
{
var qsa = new QuerySystemAttribute(this);
qsa.Key = AttributeTypes.SystemAttributes.SerialNumber;
qsa.SyncExecute();
}
catch (Exception) { }
progressValue = 60;
info.Progress(progressValue);
try
{
var retrieved = config.RetrieveXMLConfig(info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic, this);
var utf8Version = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(configStr));
if (!retrieved.Equals(utf8Version))
{
APILogger.Log($"read does not match write {SerialNumber}", retrieved, configStr);
}
}
catch (Exception ex)
{
APILogger.Log("failed to read config", ex);
}
//this only needs to be done in datapro, which doesn't set position 0
//we'll have to clean up the code a bit to use it if we want for sliceware.
config.StoreXMLConfig(configStr, info.EventConfig ? ConfigAttributes.FileStore.Diagnostic : ConfigAttributes.FileStore.Event);
progressValue = 70;
info.Progress(progressValue);
//dummy read to flush buffer, per Loc
try
{
var qsa = new QuerySystemAttribute(this);
qsa.Key = AttributeTypes.SystemAttributes.SerialNumber;
qsa.SyncExecute();
}
catch (Exception) { }
progressValue = 80;
info.Progress(progressValue);
try
{
var retrieved = config.RetrieveXMLConfig(info.EventConfig ? ConfigAttributes.FileStore.Event : ConfigAttributes.FileStore.Diagnostic, this);
var utf8Version = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(configStr));
if (!retrieved.Equals(utf8Version))
{
APILogger.Log($"read does not match write {SerialNumber}", retrieved, configStr);
}
}
catch (Exception ex)
{
APILogger.Log("failed to read config", ex);
}
ConfigureHasBeenRun = true;
ConfigureStreaming(info, scaleFactors, ranges, measuredOffset);
ConfigureHasBeenRun = true;
if (info.DiscardDiagnostics) { DiagnosticsHasBeenRun = false; }
// report success'
if (!bReleased) { bReleased = true; Release(); }
progressValue = 90;
info.Progress(progressValue);
info.Success();
}
protected virtual void ConfigureStreaming(SliceConfigServiceAsyncInfo info,
float[] scaleFactors, float[] ranges, float[] measuredOffset)
{
}
/// <summary>
/// we can probably simplify and take common items (slice2+slice1) out of this function, but for now
/// it's mostly a copy of SLICE1.AsyncConfigure
/// </summary>
/// <param name="configAsyncInfo"></param>
protected override void AsyncConfigure(object configAsyncInfo)
{
var info = configAsyncInfo as SliceConfigServiceAsyncInfo;
SetUDPAlignOnPPS();
IncrementNumberOfTimesWritten();
if (IsTOM()) { AsyncConfigureTOM(configAsyncInfo); }
else
{
//keeps track of whether the PC file was written or not
var bFileWritten = false;
try
{
var progressValue = 0;
var bReleased = true;
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels)) { ReconfigureAccordingToConfig(); }
PresetSampleRate();
SetVoltageRequirements();
SetPolarity();
SetArmDisableShortCheck();
try
{
Lock();
var bModified = false;
ReconfigureIfNeeded(ref bModified);
bReleased = false;
// loop thru the modules (slices) and configure the channels
var numChannels = DASInfo.Modules.Sum(mod => mod.NumberOfChannels);
var rangeArray = new float[numChannels];
//var IsHalfBridgeArray = new bool[numChannels];
var bridgeModeArray = new byte[numChannels];
var BridgeResistanceArray = new UInt16[numChannels];
var IsACCoupledArray = new bool[numChannels];
// level trigger values
var enableLowerLevelTriggerThreshold = new bool[numChannels];
var enableUpperLevelTriggerThreshold = new bool[numChannels];
var lowerLevelTriggerThreshold = new float[numChannels];
var upperLevelTriggerThreshold = new float[numChannels];
var qualificationSamples = new int[numChannels];
var diagnosticChannels = new List<byte>();
var bridgeACCouplingArray = new bool[numChannels];
CommonConfigureWork(diagnosticChannels,
qualificationSamples,
ref bReleased,
info,
bridgeModeArray,
IsACCoupledArray,
BridgeResistanceArray,
ref bModified,
rangeArray,
enableUpperLevelTriggerThreshold,
upperLevelTriggerThreshold,
enableLowerLevelTriggerThreshold,
lowerLevelTriggerThreshold,
bridgeACCouplingArray);
if (bReleased) { return; }
// report progress
progressValue = 5;
info.Progress(progressValue);
StoreConfigAttributes(info, rangeArray, ref bReleased, ref progressValue, bridgeModeArray,
IsACCoupledArray, BridgeResistanceArray, enableLowerLevelTriggerThreshold, lowerLevelTriggerThreshold,
enableUpperLevelTriggerThreshold, upperLevelTriggerThreshold, qualificationSamples,
numChannels, out var config, bridgeACCouplingArray, 0, 0);
if (bReleased) { return; }
RemainingConfigWork(ref progressValue, info, diagnosticChannels, config, ref bReleased,
null, null, null);
bFileWritten = true;
}
catch (CanceledException)
{
if (!bReleased) { bReleased = true; Release(); }
info.Cancel();
}
catch (Exception ex)
{
if (!bReleased) { bReleased = true; Release(); }
APILogger.Log("exception during configuration", ex);
info.Error(ex.Message, ex);
}
finally { if (!bReleased) { bReleased = true; Release(); } }
info.Progress(100);
info.Success();
}
finally
{
//if the pc file wasn't written warn the user
if (!bFileWritten)
{
APILogger.RaiseError(DTS.Common.Strings.Strings.FailedToWritePcConfigFile);
}
}
}
}
/// <summary>
/// adjusts the requested input range to avoid certain gains if needed
/// we are doing this for
/// 10080 Implement SLICE PRO SIM Gain Limitation for Gen 3 SIMs
/// whenever the hardware is not modified we manipulate the input range requested so we fall
/// within acceptable gains
/// </summary>
/// <param name="originalRange"></param>
/// <param name="bModified"></param>
/// <returns></returns>
protected virtual double AdjustInputRangeIfNeeded(double originalRange, bool bModified)
{
if (_hardwareRevision != GEN3_REV_B) return originalRange;
var gains = Enum.GetValues(typeof(GainCodesGen3)).Cast<GainCodesGen3>().ToList();
gains.Sort(new GainSorter());
gains.Reverse();
var lastAcceptableValue = double.NaN;
//assume gains are in order from 1 to 1600, so find the first gain which is too restrictive and bounce back from that
//so for instance, if someone selected a range of 700mV, we would start with G1, pass, go to G2, pass, go to G4, fail, so we would use
//G2. Also note, while we know the min/max theoretical value foreach gain, when we request a range from the firmware we don't use that value
//we use somewhere inbetween (the FirmwareInputRangemV) to increase the chances we get the gain we want...
//note there are gains greater than 1600, but they are currently explicitly disabled by issue 10080
foreach (var gain in gains)
{
if (GainDisabledAttribute.IsGainDisabled(gain))
{
continue;
}
if (!bModified && !GainAvailableUnmodifiedAttribute.IsGainAvailableToUnmodified(gain))
{
continue;
}
var maxValue = MaxInputRangeAttribute.GetMaxInputRangemV(gain);
if (originalRange < maxValue)
{
lastAcceptableValue = FirmwareInputRangeAttribute.GetFirmwareInputRangemV(gain);
}
else
{
break;
}
}
return !double.IsNaN(lastAcceptableValue) ? lastAcceptableValue : originalRange;
}
protected override ConfigAttributes GetConfigAttributes(DTS.Common.Interface.DASFactory.ICommunication com)
{
return new SLICE2ConfigAttributes(com);
}
/// <summary>
/// SLICE2 config attributes, mostly inherits from SLICE.ConfigAttributes with some functionality removed
/// </summary>
protected class SLICE2ConfigAttributes : ConfigAttributes
{
/// <summary>
/// I'm not aware of a purgeStaleData function in SLICE2 yet
/// this may be unnecessary if the firmware is intelligent enough, and maybe this is legacy
/// for now I just hollow it out
/// </summary>
/// <param name="das"></param>
public override void PurgeStaleData(IDASCommunication das)
{
}
public SLICE2ConfigAttributes(DTS.Common.Interface.DASFactory.ICommunication _com)
: base(_com)
{ }
#region CONFIG_XML
private static readonly uint XML_HEADER_LENGTH = 8;
private static readonly byte[] XML_STORE_MAGIC_BYTES = new byte[] { 0xAA, 0x55, 0xA5, 0x5A };
private readonly object _storeXMLConfigLock = new object();
/// <summary>
/// SLICE2 stores the xml in flash using SetFileData. We compress the XML string, write the header,
/// then write data 400 bytes at a time. For the header, we first write XML_STORE_MAGIC_BYTES followed
/// by the length of the compressed XML in bytes.
/// </summary>
/// <param name="data"></param>
/// <param name="info"></param>
/// <param name="ProgressSteps"></param>
public override void StoreXMLConfig(string data, FileStore fileStore)
{
try
{
lock (_storeXMLConfigLock)
{
if (string.IsNullOrEmpty(data))
{
return;
}
// since this might contain multi byte characters, we need to convert it to a byte array first
// Compress Data
var d = GetBytes(fileStore, data);
var crc = new Utilities.Crc32();
var crcBefore = crc.Get(d);
var ByteArrayData = GetCompressedBytes(d);
var crcAfter = crc.Get(ByteArrayData);
APILogger.Log($"StoreXMLConfig {com.SerialNumber} crc uncompressed: {crcBefore} crc compressed: {crcAfter}");
var fileid = (ushort)fileStore;//EventConfig ? Convert.ToUInt16(1) : Convert.ToUInt16(0);
//Store Header - magic bytes and data length
//Store Magic bytes
var sfd = new SetFileData(com, 600000);
sfd.StartByteCount = 0;
sfd.FileID = fileid;
sfd.Data = XML_STORE_MAGIC_BYTES;
sfd.SyncExecute();
//Store Header - data length
sfd.StartByteCount = (XML_HEADER_LENGTH / 2);
sfd.FileID = fileid;
sfd.Data = BitConverter.GetBytes((uint)ByteArrayData.Length);
sfd.SyncExecute();
//Store Data
for (uint i = 0; i < ByteArrayData.Length; i += (uint)sfd.MaximumFileStreamBytes)
{
long array_size = sfd.MaximumFileStreamBytes;
if ((i + sfd.MaximumFileStreamBytes) > ByteArrayData.Length)
{
array_size = ByteArrayData.Length - i;
}
var dataToSend = new byte[array_size];
Array.Copy(ByteArrayData, i, dataToSend, 0, array_size);
sfd.Data = dataToSend;
sfd.FileID = fileid;
sfd.StartByteCount = i + XML_HEADER_LENGTH;
sfd.SyncExecute();
}
var fileName = Path.Combine(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), Constants.DAS_CONFIGS), string.Format("{0}.xml", com.SerialNumber));
if ((FileStore.Diagnostic == fileStore) || (FileStore.Event == fileStore)) { StoreXmlConfigPC(data, Constants.DAS_CONFIGS, fileName); }
}
}
catch (Exception ex)
{
//log the error and rethrow it, this preserve the existing behavior at the time I added the handler
APILogger.Log($"SLICE2ConfigAttributes.StoreXMLConfig", ex);
throw ex;
}
}
private uint GetDeviceCRC(IDASCommunication das, bool eventConfig)
{
uint crc = 0;
string s = string.Empty;
if (das is EthernetSlice2 ethernet)
{
s = ethernet.GetUserAttribute(eventConfig
? AttributeTypes.SliceUserAttributes.EventConfigCRC
: AttributeTypes.SliceUserAttributes.ConfigCRC);
}
else if (das is CDCUSBSlice usbSLICE)
{
s = usbSLICE.GetUserAttribute(eventConfig
? AttributeTypes.SliceUserAttributes.EventConfigCRC
: AttributeTypes.SliceUserAttributes.ConfigCRC);
}
if (!string.IsNullOrWhiteSpace(s))
{
if (uint.TryParse(s, out var i))
{
return i;
}
}
return crc;
}
/// <summary>
/// We retrieve the xml from SLICE 2 flash using QueryFileData. We read the header, then read data 400
/// bytes at a time. For the header, we first read XML_STORE_MAGIC_BYTES followed by the length of the
/// compressed XML in bytes. We then unzip the data and return the XML string.
/// </summary>
/// <returns></returns>
public override string RetrieveXMLConfig(FileStore fileStore, IDASCommunication das)
{
lock (_storeXMLConfigLock)
{
var WholeStr = "";
try
{
var allBytes = new List<byte>();
allBytes.Clear();
//Get Header - magic bytes and data length
//Get Magic bytes
var qfd = new QueryFileData(com, 600000);
var fileid = (ushort)fileStore;
qfd.FileID = fileid;
qfd.StartByteCount = 0;
qfd.EndByteCount = (XML_HEADER_LENGTH / 2) - 1;
qfd.SyncExecute();
if (qfd.Data.Length < 4)
{
APILogger.Log($"{com.SerialNumber} RetrieveXMLConfig <4 bytes returning empty");
return "";
}
if (qfd.Data[0] == 0xFF && qfd.Data[1] == 0xFF && qfd.Data[2] == 0xFF && qfd.Data[3] == 0xFF)
{
APILogger.Log($"{com.SerialNumber} RetrieveXMLConfig first 4 bytes wrong, returning empty string");
return "";
}
if (BitConverter.ToUInt32(qfd.Data, 0) != BitConverter.ToUInt32(XML_STORE_MAGIC_BYTES, 0))
{
APILogger.Log($"{com.SerialNumber} RetrieveXMLConfig Magic bytes not found");
throw new InvalidDataException($"{com.SerialNumber} Magic bytes not found");
}
//Get data length
qfd.FileID = fileid;
qfd.StartByteCount = (XML_HEADER_LENGTH / 2); //account for magic bytes
qfd.EndByteCount = XML_HEADER_LENGTH - 1;
qfd.SyncExecute();
var ByteArrayDataLength = BitConverter.ToUInt32(qfd.Data, 0);
if (Math.Pow(2, 21) < ByteArrayDataLength)
{
APILogger.Log($"{com.SerialNumber} RetrieveXMLConfig data length is greater than store size");
throw new InvalidDataException($"data length is greater than store size {com.SerialNumber}");
}
//Get Data
for (uint i = 0; i < ByteArrayDataLength; i += (uint)qfd.MaximumFileStreamBytes)
{
uint array_size = (uint)qfd.MaximumFileStreamBytes;
if ((i + qfd.MaximumFileStreamBytes) > ByteArrayDataLength)
{
array_size = ByteArrayDataLength - i;
}
qfd.StartByteCount = (XML_HEADER_LENGTH) + i;
qfd.EndByteCount = (XML_HEADER_LENGTH - 1) + (i + array_size);
qfd.FileID = fileid;
qfd.SyncExecute();
APILogger.Log($"{com.SerialNumber} Read {i} of {ByteArrayDataLength} CRC: {CalculateCrc32(new List<byte>(qfd.Data)).ToString()}");
allBytes.InsertRange((int)i, qfd.Data);
}
if (allBytes.Count < 1)
{
APILogger.Log($"{com.SerialNumber} RetrieveXMLConfig all bytes count < 1");
// "Slice.RetrieveAttributes: Attributes are empty"
throw new Exception("Attributes are empty");
}
APILogger.Log($"{com.SerialNumber} read {allBytes.Count} bytes in total");
var crc = new Utilities.Crc32();
//DecideToFailOrNot(fileStore, ref allBytes);
WholeStr = GetDecompressedString(allBytes.ToArray(), fileStore);
}
catch (Exception ex)
{
APILogger.Log($"Failed to retrieve xml config - {fileStore} on {com.SerialNumber}. Error: {ex}");
if (FileStore.Event == fileStore)
{
//event file store FIRST falls back to diagnostics
//which will fall back onto pc if it fails
WholeStr = RetrieveXMLConfig(FileStore.Diagnostic, das);
}
else if (FileStore.Diagnostic == fileStore)
{
//diagnostics falls back to pc
WholeStr = RetrieveXmlConfigPC();
}
}
try { APILogger.ConfLog(com.SerialNumber, "XML Config\n", Common.Utils.Utils.PrettyPrint(WholeStr)); }
catch (Exception) { }
return WholeStr;
}
}
private static UInt32 CalculateCrc32(List<byte> data)
{
if (data.Count % 2 > 0) { data.Add(0x0); }
ushort crc = 0xFFFF;
byte[] b = data.ToArray();
for (int i = 0; i < b.Length; i += 2)
crc = Common.Utils.Utils.Math_DoCRC16Step(BitConverter.ToUInt16(b, i), crc);
return crc;
}
#endregion
/// <summary>
/// Retrieve the XML string that was split and stored in the Arm attributes
/// note that SLICE2 is apparently not going to store separate event configs,
/// so we just grab the same one off the pc again
/// [this is a bad idea as the event could be from earlier and the system config could have been
/// changed after the use ran the test, and then reconfigured but wants to download the old test]
/// </summary>
/// <param name="eventNum">The event number to get it from</param>
/// <param name="progress"></param>
/// <returns>The combined XML string</returns>
public override string RetrieveEventXMLConfig(int eventNum, QueryDownloadProgress progress, IDASCommunication das)
{
lock (_storeXMLConfigLock)
{
var s = string.Empty;
try
{
s = RetrieveXMLConfig(FileStore.Event, das);
}
catch (Exception ex)
{
APILogger.Log("failed to retrieve event xml config for event ", eventNum, ex);
}
//fall back to whatever is on the live config
if (string.IsNullOrEmpty(s))
{
APILogger.Log("failed to retrieve event xml config (it was empty) for event ", eventNum);
s = RetrieveXMLConfig(FileStore.Diagnostic, das);
}
return s;
}
}
}
protected override void AsyncReadyForArming(object asyncInfo)
{
//Until DataPRO supports StartRecDelayInSecond, set to 0
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StartRecDelayInSecond))
{
var ssaS6 = new SetSystemAttributeSLICE6(this);
ssaS6.SetValue(AttributeTypes.SystemAttributesSLICE6.StartRecDelayInSecond, Convert.ToUInt16(0), true);
ssaS6.SyncExecute();
}
base.AsyncReadyForArming(asyncInfo);
}
protected override void AsyncArmNow(object asyncInfo)
{
base.AsyncArmNow(asyncInfo);
}
private bool IsDIM()
{
if (SerialNumber.StartsWith("SPD") || SerialNumber.StartsWith("SLD")) { return true; }
else { return false; }
}
private DASModule MakeConfigModuleFromInfoModuleTOM(InfoResult.Module infoModule)
{
var configModule = new DASModule(infoModule.ModuleArrayIndex, this);
var channels = new List<DASChannel>();
for (var i = 0; i < 8; i++)
{
var c = new OutputSquibChannel(configModule, i);
c.SupportedSquibFireModes = new SquibFireMode[] { SquibFireMode.CAP, SquibFireMode.CONSTANT, SquibFireMode.NONE };
if (0 != i % 2) { c.MeasurementType = SquibMeasurementType.CURRENT; }
c.ModuleChannelNumber = i;
channels.Add(c);
}
for (var i = 8; i < 16; i++)
{
var c = new OutputTOMDigitalChannel(configModule, i);
channels.Add(c);
}
configModule.Channels = channels.ToArray();
return configModule;
}
protected override void PerformSensorIdCheck(ref Dictionary<int, string[]> sensorIds)
{
try
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StackSensors))
{
var qsi = new QueryStackSensorIDs(this);
qsi.SyncExecute();
foreach (var module in ConfigData.Modules)
{
foreach (var channel in module.Channels)
{
var id = "";
if (channel is OutputSquibChannel)
{
//we just expect 4 ids, the id of this channel is one of those 4
id = HexEncoding.ToString(qsi.IDs[channel.ModuleChannelNumber / 2]);
}
else if (channel is AnalogInputDASChannel)
{
var dasChannelNumber =
DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(module.ModuleArrayIndex,
channel.ModuleChannelNumber);
id = HexEncoding.ToString(qsi.IDs[dasChannelNumber]);
}
if (!string.IsNullOrWhiteSpace(id))
{
sensorIds[channel.Number] = new[] { id };
}
}
}
}
else
{
PerformSensorIdCheck_SingleChannelMethod(ref sensorIds);
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
finally
{
try
{
var prepForDC = new PrepareForDataCollection(this);
prepForDC.SyncExecute();
}
catch (Exception ex)
{
throw new Exception($"Unable to turn on excitation: {ex.Message}");
}
}
}
protected override DASModule MakeConfigModuleFromInfoModule(InfoResult.Module infoModule)
{
if (infoModule.TypeOfModule == DFConstantsAndEnums.ModuleType.SLICEPro_TOM)
{
return MakeConfigModuleFromInfoModuleTOM(infoModule);
}
var configModule = new DASModule(infoModule.ModuleArrayIndex, this);
configModule.Channels = new AnalogInputDASChannel[infoModule.NumberOfChannels];
for (var i = 0; i < infoModule.NumberOfChannels; i++)
{
var channel = new AnalogInputDASChannel(configModule, i);
switch (infoModule.TypeOfModule)
{
case DFConstantsAndEnums.ModuleType.SliceBridge2High:
case DFConstantsAndEnums.ModuleType.SliceBridge2Low:
channel.IEPEChannel = false;
channel.DigitalInputChannel = false;
break;
case DFConstantsAndEnums.ModuleType.SliceIEPE2High:
case DFConstantsAndEnums.ModuleType.SliceIEPE2Low:
channel.IEPEChannel = true;
channel.DigitalInputChannel = false;
break;
case DFConstantsAndEnums.ModuleType.ProDIM:
channel.TypeOfBridge = SensorConstants.BridgeType.DigitalInput;
channel.IEPEChannel = false;
channel.DigitalInputChannel = true;
break;
}
QueryHardwareRevision();
//int hardwareRevision = QueryHardwareRevision();
var baseType = QueryBaseType();
if (_hardwareRevision == GEN3_REV_B && baseType == PROBaseType)
{
channel.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5,
ExcitationVoltageOptions.ExcitationVoltageOption.Volt10, ExcitationVoltageOptions.ExcitationVoltageOption.Volt2};
}
else if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.DiagnosticTwoVoltExcitation))//loc thinks this is where cal started for 2 volt
{
channel.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] {ExcitationVoltageOptions.ExcitationVoltageOption.Volt2,
ExcitationVoltageOptions.ExcitationVoltageOption.Volt5};
}
else
{
channel.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { ExcitationVoltageOptions.ExcitationVoltageOption.Volt5 };
}
if (infoModule.TypeOfModule == DFConstantsAndEnums.ModuleType.ProDIM)
{
channel.SupportedBridges = new SensorConstants.BridgeType[] { SensorConstants.BridgeType.DigitalInput };
}
else if (_hardwareRevision == GEN3_REV_B && baseType == PROBaseType)
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.HalfBridgeSigPlusSupport))
{
channel.SupportedBridges = new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.HalfBridge_SigPlus,
SensorConstants.BridgeType.IEPE,
SensorConstants.BridgeType.QuarterBridge
};
}
else
{
channel.SupportedBridges = new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.IEPE,
SensorConstants.BridgeType.QuarterBridge
};
}
}
else if (infoModule.IsProgrammable)
{
channel.SupportedBridges = new SensorConstants.BridgeType[] { SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge, SensorConstants.BridgeType.IEPE};
}
else
{
if (channel.IEPEChannel)
{
channel.SupportedBridges = new SensorConstants.BridgeType[] { SensorConstants.BridgeType.IEPE };
}
else
{
channel.SupportedBridges = new SensorConstants.BridgeType[] {SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge};
}
}
configModule.Channels[i] = channel;
}
return configModule;
}
protected override bool CheckAutoDetectSupport()
{
if (null == DASInfo) { return false; }
if (null == DASInfo.Modules) { return false; }
if (0 == DASInfo.Modules.Length) { return false; }
return DASInfo.Modules[0].IsProgrammable;
}
protected bool _haveInited = false;
/// <summary>
/// returns whether the unit supports 2V or not
/// right now this is only used in one spot (SLICE2 AsyncQueryConfiguration)
/// so it may not be true for purposes outside of this function without
/// additional work
/// </summary>
/// <returns></returns>
protected virtual bool GetSupports2Volt()
{
return true;
}
protected override void AsyncQueryTestSetup(object configAsyncInfo)
{
var info = configAsyncInfo as SliceServiceQueryTestSetupAsyncInfo;
var config = GetConfigAttributes(this); //Temp: This is just to use RetrieveEventXMLConfig for now
var testSetupString = config.RetrieveXMLConfig(ConfigAttributes.FileStore.TestSetup, this);
config.StoreXmlConfigPC(testSetupString, Constants.DAS_TEST_SETUPS, config.TestSetupUniqueId);
info.Success();
}
/// <summary>
/// Updates the configuration on the unit using a given input file
/// 17872 Use DASConfig XMLs on disk when performing an emergency download with DAS that have blank filestore(s)
/// </summary>
protected override void AsyncUpdateConfigurationFromFile(object asyncInfo)
{
var info = asyncInfo as SliceServiceAsyncInfo;
if (!(info.functionData is string filePath))
{
info.Error($"AsyncUpdateConfigurationFromFile: {SerialNumber} - Empty file path");
return;
}
if (!File.Exists(filePath))
{
info.Error($"SyncUpdateConfigurationFromFile: {SerialNumber} - invalid file path: {filePath}");
return;
}
try
{
IncrementNumberOfTimesCorrected();
var fileData = File.ReadAllText(filePath);
ConfigData = ConfigurationData.DeserializeFromString(fileData);
var config = GetConfigAttributes(this);
config.StoreXMLConfig(fileData, Slice<T>.ConfigAttributes.FileStore.Event);
config.StoreXMLConfig(fileData, Slice<T>.ConfigAttributes.FileStore.Diagnostic);
QueryConfigGetScaleFactors(info);
}
catch (Exception ex)
{
APILogger.Log(ex);
info.Error(ex.Message, ex);
return;
}
info.Success();
}
//for testing this is the percentage diagnostics file store should fail
private const int DIAGNOSTICS_FAIL_PERCENT = 20;
//for testing this is the percentage event file store should fail
private const int EVENT_FAIL_PERCENT = 50;
//for testing this is how many bytes to mess with when a file store fails
private const int NUM_BYTES_TO_MESS_WITH = 5;
//mess with some bytes
private static void DecideToFailOrNot(ConfigAttributes.FileStore fileStore, ref List<byte> allBytes)
{
if (allBytes.Count < NUM_BYTES_TO_MESS_WITH) { return; }
var r = new Random(DateTime.Now.Millisecond);
var failPercent = 0;
if (fileStore == ConfigAttributes.FileStore.Diagnostic) { failPercent = DIAGNOSTICS_FAIL_PERCENT; }
else if (fileStore == ConfigAttributes.FileStore.Event) { failPercent = EVENT_FAIL_PERCENT; }
failPercent = 100 - failPercent;
if (r.Next(0, 100) > failPercent)
{
//we failed, mess up some bytes!
var badBytes = new byte[NUM_BYTES_TO_MESS_WITH];
r.NextBytes(badBytes);
//pick a spot
for (var i = 0; i < NUM_BYTES_TO_MESS_WITH; i++)
{
var index = r.Next(0, allBytes.Count - 1);
allBytes[index] = badBytes[i];
}
}
}
/// <summary>
/// This function was previously part of QueryConfiguration
/// I abstracted it out so that UpdateConfiguration could call it
/// it's needed to initialize some data structions that are part of the
/// configuration
/// 17872 Use DASConfig XMLs on disk when performing an emergency download with DAS that have blank filestore(s)
/// </summary>
private void QueryConfigGetScaleFactors(SliceServiceAsyncInfo info, bool bReadDeviceData = true)
{
var config = GetConfigAttributes(this);
try
{
var scaleFactors = new float[0];
try
{
//15949 S6A when streaming does a whole bunch of unnecessary queries
//only get this attribute while not streaming (to avoid failing)
if (!GetIsStreaming())
{
// scaleFactors = GetScaleFactors();
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
#if LEVEL_TRIGGER_DEFINED
// These are currently unutilized since we have no application for the offset-adjusted
// level trigger values outside of the Slice firmware.
//
// var levelTriggers = GetLevelTriggers( );
#endif
if (null == scaleFactors)
{
scaleFactors = new float[0];
}
info.Progress(80);
// set the OwningDAS and OwningModule since it was skipped during serialization
if (null != ConfigData.Modules)
{
foreach (var iDASModule in ConfigData.Modules)
{
var module = (DASModule)iDASModule;
// 17873 outside of download, ask device for "arm" sample rate, otherwise ask for first event's
var fSampleRate = bReadDeviceData ? config.ActualSampleRate : config.GetEventSamplerate(0);
if (float.IsNaN(fSampleRate))
{
fSampleRate = 10000F;
APILogger.Log("Warning invalid actual sample rate detected, defaulting back to 10k sps");
}
//per CPB, use the realtime sample rate in this case
//14549 Unhandled exception when using hardware discovery with SLICE6 AIR
if (float.IsInfinity(fSampleRate))
{
QueryArmAttribute qaa = new QueryArmAttribute(this);
qaa.Key = AttributeTypes.ArmAndEventAttributes.RealtimeSampleRate;
qaa.SyncExecute();
fSampleRate = Convert.ToSingle(qaa.Value);
APILogger.Log(
$"Warning invalid actual sample rate detected (infinity), default back to realtime rate, {fSampleRate}");
}
module.ActualSampleRateHz = Convert.ToUInt32(fSampleRate);
module.OwningDAS = this;
foreach (var iDASChannel in module.Channels)
{
var channel = (DASChannel)iDASChannel;
channel.OwningModule = module;
// pick up the scalefactor for this channel
if (channel is AnalogInputDASChannel analog)
{
var dasChannelNumber = analog.Number;
if (dasChannelNumber < scaleFactors.Length)
{
analog.ScalefactorMilliVoltsPerADC = scaleFactors[dasChannelNumber];
}
//double EuPerMv = GetEuPerMv(analog);
}
}
}
}
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException)
{
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (CanceledException)
{
// cancel must be propagated
throw;
}
catch (Exception ex)
{
APILogger.LogString("QueryConfiguration: GetScaleFactors threw exception");
APILogger.LogException(ex);
// we don't need no stinking scale factors
}
}
/// <summary>
/// queries the BaseFirmwareBuildID system attribute for the purpose of getting the string into the log
/// 26821 Add query of BaseFirmwareBuildID for SLICE PRO/ 1.5/ S6/S6A/PowerPRO/S6DB/S6DB3/ TSR AIR for Logs
/// All SLICE2 derivatives appear to support this (including S6DB)
/// </summary>
protected virtual void QueryBaseFirmwareBuildId()
{
try
{
var query = new QuerySystemAttributeSLICE2(this);
query.Key = AttributeTypes.SystemAttributesSLICE2.BaseFirmwareBuildID;
query.SyncExecute();
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
/// <summary>
/// retrieves the number of times configuration has been written, increments the count, then stores the value
/// </summary>
protected void IncrementNumberOfTimesWritten()
{
var num = 0L;
try
{
var sValue = GetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesWritten);
if (long.TryParse(sValue, out long temp))
{
num = temp;
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
num++;
try
{
SetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesWritten, num.ToString());
APILogger.Log($"Setting NumberTimesWritten to {num}");
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
/// <summary>
/// retrieves the number of times the configuration has been retrieved, increments, and stores
/// </summary>
protected void IncrementNumberOfTimesCorrected()
{
var num = 0L;
try
{
var sValue = GetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesCorrected);
if (long.TryParse(sValue, out long temp))
{
num = temp;
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
num++;
try
{
SetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesCorrected, num.ToString());
APILogger.Log($"Setting NumberTimesCorrected to {num}");
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
/// <summary>
/// retrieves the number of times configuration was detected invalid, increments, and stores the count
/// </summary>
protected void IncrementNumberOfFailedReads()
{
var numberOfFailures = 0L;
try
{
var sValue = GetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesDetected);
if (long.TryParse(sValue, out long temp))
{
numberOfFailures = temp;
}
}
catch (Exception ex)
{
APILogger.Log(ex);
}
numberOfFailures++;
try
{
SetUserAttribute(AttributeTypes.SliceUserAttributes.NumberTimesDetected, numberOfFailures.ToString());
APILogger.Log($"Setting NumberTimesDetected to {numberOfFailures}");
}
catch (Exception ex)
{
APILogger.Log(ex);
}
}
/// <summary>
/// basically a copy of SLICE1 ... may be able to eliminate and use the base version.
/// </summary>
/// <param name="configAsyncInfo"></param>
protected override void AsyncQueryConfiguration(object configAsyncInfo)
{
try
{
if (!_haveInited)
{
InitMinProto(); _haveInited = true;
}
if (GetIsStreaming())
{
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting this attribute if streaming, it will fail
}
else
{
QueryBaseFirmwareBuildId();
if (!ShouldQueryFeatureConfig())
{
_featureConfigValue = 1;
}
else
{
//hardware gen 3 we have to tell whether we are modified or not
//http://fogbugz/fogbugz/default.asp?10080
var qsa = new QuerySystemAttribute_Slice2Bridge_GEN3(this);
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2_GEN3.FeatureConfig;
//this is a bridge attribute, we are making a small assumption that
//all the modules have this bit set...
qsa.DeviceID = 1;
qsa.SyncExecute();
if (qsa.Value is float f)
{
//this would throw an invalid cast, so avoid it
}
else
{
_featureConfigValue = (ushort)qsa.Value;
}
}
}
}
catch (Exception) { }
var info = configAsyncInfo as SliceServiceQueryConfigAsyncInfo;
try
{
if (this is IDASReconfigure) { (this as IDASReconfigure).GetMaxModuleCount(); }
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception) { }
var hardwareRev = -1;
var baseType = -1;
//15949 S6A when streaming does a whole bunch of unnecessary queries
//only get this attribute if not streaming (otherwise it will fail)
if (!GetIsStreaming())
{
try
{
hardwareRev = QueryHardwareRevision();
baseType = QueryBaseType();
_rangeBandwithLimited = hardwareRev < 1;
}
catch (Exception ex)
{
APILogger.Log("failed to query hardware revision and type", ex);
}
}
info.Progress(10);
if (hardwareRev >= 1)
{
_supportsTimeSynchronization = true;
try
{
var qbst = new QueryBaseSystemTime(this);
qbst.SyncExecute();
_systemDateTime = qbst.SystemTime;
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception ex)
{
APILogger.Log("failed to query system time", ex);
}
}
info.Progress(15);
var dasDisplayOrder = -1;
var displayOrder = new int[] { -1 };
try
{
dasDisplayOrder = GetDASDisplayOrder();
displayOrder = GetChannelDisplayOrder();
}
catch (Exception) { }
try
{
// pickup the channel data
var config = GetConfigAttributes(this);
info.Progress(40);
try
{
var StoredInfoString = config.RetrieveXMLConfig(ConfigAttributes.FileStore.Diagnostic, this);
ConfigData = ConfigurationData.DeserializeFromString(StoredInfoString);
var blank = string.IsNullOrWhiteSpace(StoredInfoString);
var failedValidation = false;
if (!VerifyConfig())
{
failedValidation = true;
ConfigData = null;
}
if (ConfigData == null || ConfigData.Modules == null || ConfigData.Modules.Length == 0)
{
//note that not all users may be using microsoft prism and event structures...
//so put this in a try in case they aren't (f/w test utility)
// 17872 Use DASConfig XMLs on disk when performing an emergency download with DAS that have blank filestore(s)
IncrementNumberOfFailedReads();
try
{
var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
eventAggregator.GetEvent<DASConfigurationEvent>().Publish(new DASConfigurationArg(this, blank, failedValidation));
}
catch (Exception ex)
{
APILogger.Log(ex);
}
APILogger.LogString("QueryConfiguration: ConfigData or Modules empty, using default config");
ConfigData = MakeDefaultConfigFromInfo();
}
else if (DASInfo == null || DASInfo.Modules == null || !ModuleLengthsAreOK(info.DifferentModuleCountsAreOK))
{
APILogger.LogString("QueryConfiguration: DASInfo empty or Modules not expected length, using default config");
ConfigData = MakeDefaultConfigFromInfo();
}
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (Exception ex)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(ex);
if (ex.Message.Contains("ReceiveFailed"))
{
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
//for now we supress this order by requests from support
var error = string.Format(Strings.InvalidConfig, SerialNumber);
ConfigData = MakeDefaultConfigFromInfo();
}
info.Progress(50);
try
{
if (null != ConfigData.Modules)
{
foreach (var m in ConfigData.Modules)
{
foreach (var c in m.Channels)
{
if (c is AnalogInputDASChannel aic)
{
if (_hardwareRevision == GEN3_REV_B && _baseType == PROBaseType)
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.HalfBridgeSigPlusSupport))
{
aic.SupportedBridges =
new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.IEPE,
SensorConstants.BridgeType.QuarterBridge,
SensorConstants.BridgeType.HalfBridge_SigPlus
};
}
else
{
aic.SupportedBridges =
new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.IEPE,
SensorConstants.BridgeType.QuarterBridge
};
}
aic.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] {
ExcitationVoltageOptions.ExcitationVoltageOption.Volt10,
ExcitationVoltageOptions.ExcitationVoltageOption.Volt2,
ExcitationVoltageOptions.ExcitationVoltageOption.Volt5};
}
else if (DASInfo.Modules[0].IsProgrammable && IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels))
{
if (GetSupports2Volt())
{
aic.SupportedExcitation =
new ExcitationVoltageOptions.ExcitationVoltageOption[]
{
ExcitationVoltageOptions.ExcitationVoltageOption.Volt5,
ExcitationVoltageOptions.ExcitationVoltageOption.Volt2
};
}
else
{
aic.SupportedExcitation =
new ExcitationVoltageOptions.ExcitationVoltageOption[]
{
ExcitationVoltageOptions.ExcitationVoltageOption.Volt5
};
}
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.HalfBridgeSigPlusSupport))
{
aic.SupportedBridges =
new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.IEPE,
SensorConstants.BridgeType.HalfBridge_SigPlus
};
}
else
{
aic.SupportedBridges =
new SensorConstants.BridgeType[]
{
SensorConstants.BridgeType.FullBridge,
SensorConstants.BridgeType.HalfBridge,
SensorConstants.BridgeType.IEPE
};
}
}
if (aic.DigitalInputChannel) { aic.SupportedBridges = new SensorConstants.BridgeType[] { SensorConstants.BridgeType.DigitalInput }; }
}
}
}
}
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception) { }
info.Progress(60);
try
{
var idx = 0;
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels) &&
DASInfo.Modules.Any() &&
DASInfo.Modules[0].IsProgrammable)
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StackSensors) && info.ReadIds)
{
var query = new QueryStackSensorIDs(this);
query.SyncExecute();
if (null != ConfigData.Modules)
{
foreach (var m in ConfigData.Modules)
{
foreach (var c in m.Channels)
{
if (c is AnalogInputDASChannel aic)
{
var id = HexEncoding.ToString(query.IDs[idx]);
var eid = new EID(id);
if (eid.IsValid() && !RunTestVariables.BypassEIDRead)
{
c.IDs = new EID[] { eid };
}
else
{
c.IDs = new EID[0];
}
switch (Convert.ToInt32(query.Types[idx]))
{
case (int)SetStackChannelTypeConfiguration.ChannelTypes.FORCE_IEPE:
aic.IEPEChannel = true;
break;
case (int)SetStackChannelTypeConfiguration.ChannelTypes.FORCE_IEPE_LOW:
aic.IEPEChannel = true;
break;
default:
aic.IEPEChannel = false;
break;
}
}
idx++;
}
}
}
}
}
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception ex) { APILogger.Log("Failed to get channel types", ex); }
// get scale factors
info.Progress(70);
if (null != ConfigData) { ConfigData.DisplayOrder = displayOrder; ConfigData.DasDisplayOrder = dasDisplayOrder; }
try
{
QueryConfigGetScaleFactors(info, info.DeviceScaleFactors);
}
catch (Exception ex)
{
APILogger.Log(ex);
}
try
{
// get sensor ID's
if (ConfigData.Modules != null)
{
foreach (var iDASModule in ConfigData.Modules)
{
var module = (DASModule)iDASModule;
module.OwningDAS = this; // in case we bailed out above
if (!(IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels) && DASInfo.Modules[0].IsProgrammable))
{
foreach (var iDASChannel in module.Channels)
{
var channel = (DASChannel)iDASChannel;
channel.OwningModule = module; // in case bailed out above
var dasChannelNumber = DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(module.ModuleArrayIndex, channel.ModuleChannelNumber);
if (channel is OutputSquibChannel)
{
dasChannelNumber = DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(module.ModuleArrayIndex, channel.ModuleChannelNumber / 2);
}
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting ids while streaming, it will fail
if (!GetIsStreaming())
{
channel.IDs = EIDReader.RetriveEIDs(this, dasChannelNumber, 0);
}
}
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting ids while streaming, it will fail
if (!GetIsStreaming())
{
IEID[] ids = null;
//performance improvement, don't check (and re-check 3 times) for a battery id on channel 255
//update - SLICE2 and beyond don't have battery ids, don't check ...
if (null != ids && 0 != ids.Length)
{
module.OwningDAS.DASInfo.BatteryID = ids[0];
module.OwningDAS.SetDASInfo();
}
}
}
}
}
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception) { }
info.Progress(90);
try { RetrieveEventGuids(); }
catch (Exception ex) { APILogger.Log("problem getting event guids", ex); }
try { DASInfo.MaxEventStorageSpaceInBytes = ReadSampleStorageSizeInBytes(); }
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception ex) { APILogger.Log("problem getting sample storage size in bytes", ex); }
info.Progress(95);
try { GetAutoArmStatus(); }
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (Exception ex) { APILogger.Log("problem getting autoarm status", ex); }
info.Success();
}
catch (System.Net.Sockets.SocketException socketException)
{
APILogger.LogString("QueryConfiguration: RetrieveXMLConfig threw exception");
APILogger.LogException(socketException);
info.Error(string.Format("Connection with {0} failed", SerialNumber));
return;
}
catch (NotConnectedException) { info.Error(string.Format("Connection with {0} failed", SerialNumber)); return; }
catch (CanceledException)
{
info.Cancel();
}
catch (Exception ex)
{
info.Error(ex.Message, ex);
}
}
/// <summary>
/// This function returns True when the number of DAS modules is equal to the
/// number of Config modules or when it is acceptable if they differ.
/// </summary>
/// <returns></returns>
private bool ModuleLengthsAreOK(bool differentModuleCountsAreOK)
{
var result = DASInfo.Modules.Length == ConfigData.Modules.Length;
if (!result && differentModuleCountsAreOK)
{
try
{
// 28263 The config from a SLICE6Air that has a config that's not built from DataPRO 4.0 or later will not have a 3rd module for
// the UART channel and not have a 4th module for the Stream Output channel, so ignore the difference in the number of modules
// only if this call is for the purposes of reading an old config for a Quick Build.
if (_baseType == (int)SLICERecorder.SLICEPRO_BaseType.SLICE6AIR)
{
//Pre-DataPRO 4.0, the config only had two 3-channel modules, but as of 4.0
//additional modules exist for a UART channel, and a Stream Output channel.
//Since differentModuleCountsAreOK is True, we can add the new modules.
var newModules = new IDASModule[DASInfo.Modules.Length];
//Copy all of the existing module(s) from ConfigData
var index = 0;
foreach (var oldModule in ConfigData.Modules)
{
newModules[index] = oldModule;
index++;
}
//Add the new module(s) from DASInfo
for (var i = index; i < newModules.Length; i++)
{
newModules[i] = MakeConfigModuleFromInfoModule((InfoResult.Module)DASInfo.Modules[i]);
}
//Replace the modules in the config
ConfigData.Modules = newModules;
result = true;
}
}
catch (Exception ex)
{
APILogger.Log($"Exception in ModuleLengthsAreOK: {ex.Message}");
result = false;
}
}
return result;
}
protected override void AsyncEnterLowPowerMode(object asyncInfo)
{
var info = (SliceServiceAsyncInfo)asyncInfo;
try
{
//clear any results we have, they will be invalid after going to low power
//16164 User can proceed past diag. without running on all channels
ClearChannelDiagnosticsResults();
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StackLowPowerMode))
{
var low = new SetStackLowPowerMode(this);
low.SyncExecute();
}
else
{
if (DASInfo != null && DASInfo.Modules != null)
{
// DeviceID is the module index + 1
for (var i = 0; i < DASInfo.Modules.Length; i++)
{
try
{
DisablePowerSupply(DASInfo.Modules[i].TypeOfModule, (byte)(i + 1));
}
catch (Exception ex)
{
APILogger.Log("problem disabling power supply", ex);
}
}
}
}
info.Success();
}
catch (CanceledException)
{
info.Cancel();
}
catch (Exception ex)
{
info.Error(ex.Message, ex);
}
}
protected override void RetrieveEventGuids()
{
try
{
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting event guids while streaming, it will fail
if (GetIsStreaming())
{
SetEventGuids(null);
SetEventFaultFlags(null);
SetEventArmAttemps(null);
((IDownload)this)?.SetExtendedFaultFlags(null);
return;
}
var EventCount = new QueryTotalEventCount(this, AbstractCommandBase.Default_IO_Timeout);
EventCount.SyncExecute();
if (EventCount.Count < 1)
{
// no events
SetEventGuids(null);
SetEventFaultFlags(null);
((IDownload)this)?.SetExtendedFaultFlags(null);
SetEventArmAttemps(null);
return;
}
var guids = new Guid[EventCount.Count];
var downloadedStatus = new bool[EventCount.Count];
var query2 = new QueryEventAttribute(this, AbstractCommandBase.Default_IO_Timeout);
var faultFlags = new ushort[EventCount.Count];
var extendedFaultFlags = new List<uint[]>();
query2.Key = AttributeTypes.ArmAndEventAttributes.FaultFlags;
for (ushort eventIdx = 0; eventIdx < EventCount.Count; eventIdx++)
{
query2.EventNumber = eventIdx;
guids[eventIdx] = GetEventGuid(eventIdx);
extendedFaultFlags.Add(GetExtendedFaultFlags(eventIdx));
faultFlags[eventIdx] = 0;
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.EventFaultFlags))
{
try
{
query2.SyncExecute();
faultFlags[eventIdx] = (ushort)query2.Value;
}
catch (Exception ex)
{
APILogger.Log("could not get fault flags", ex);
}
}
try
{
var ca = GetConfigAttributes(this);//new Slice<T>.ConfigAttributes(this);
downloadedStatus[eventIdx] = ca.EventHasBeenDownloaded(eventIdx, out uint iflag);
}
catch (Exception) { }
}
SetEventGuids(guids);
SetEventFaultFlags(faultFlags);
((IDownload)this)?.SetExtendedFaultFlags(extendedFaultFlags.ToArray());
SetEventDownloadStatus(downloadedStatus);
}
catch (CommandException ce)
{
if (ce.Error != CommandErrorReason.InvalidMode)
{
APILogger.LogString("DASFactory.RetriveEventGuids: ");
APILogger.LogException(ce);
}
}
catch (Exception ex)
{
APILogger.LogString("DASFactory.RetriveEventGuids: ");
APILogger.LogException(ex);
}
}
protected override void AsyncUpdateIDs(object configAsyncInfo)
{
var info = configAsyncInfo as SliceServiceAsyncInfo;
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.ProgramStackChannels) || !DASInfo.Modules[0].IsProgrammable)
{
// Not Programmable
base.AsyncUpdateIDs(configAsyncInfo);
}
else
{
try
{
if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.StackSensors))
{
var query = new QueryStackSensorIDs(this);
query.SyncExecute();
var idx = 0;
foreach (var m in ConfigData.Modules)
{
foreach (var c in m.Channels)
{
if (c is AnalogInputDASChannel analog)
{
var eid = new EID(HexEncoding.ToString(query.IDs[idx]));
if (eid.IsValid() && !RunTestVariables.BypassEIDRead)
{
c.IDs = new EID[] { eid };
}
else
{
c.IDs = new EID[0];
}
switch (Convert.ToInt32(query.Types[idx]))
{
case (int)SetStackChannelTypeConfiguration.ChannelTypes.FORCE_IEPE:
analog.IEPEChannel = true;
break;
default:
analog.IEPEChannel = false;
break;
}
}
idx++;
}
}
}
info.Success();
}
catch (Exception ex)
{
APILogger.Log("Failed to update ids - ", ex);
info.Error("Failed to update IDS", ex);
}
}
}
/// <summary>
/// Retrieve the info to fill in the ConfigData property
/// </summary>
/// <param name="callback">The delegate to report to</param>
/// <param name="userData">User supplied data that we pass along</param>
void IConfigurationActions.QueryConfiguration(ServiceCallback callback, object userData, uint crc, string strConfig, bool bReadIds, bool bDeviceScaleFactors,
bool differentModuleCountsAreOK)
{
var info = new SliceServiceQueryConfigAsyncInfo(callback, userData, crc, strConfig, bReadIds, bDeviceScaleFactors, differentModuleCountsAreOK);
LaunchAsyncWorker("Slice2.QueryConfiguration", AsyncQueryConfiguration, info);
}
protected const int UNKNOWN_REVISION = -1;
protected const int GEN2_REV_A = 0;
protected const int GEN3_REV_B = 1;
protected int QueryHardwareRevision()
{
if (_hardwareRevision != UNKNOWN_REVISION)
{
return _hardwareRevision;
}
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.HardwareRevision)) { return UNKNOWN_REVISION; }
else
{
if (RunTestVariables.InRunTest && this is EthernetSlice6)
{
_hardwareRevision = RunTestVariables.AssumedBaseHardwareRevisionSLICE6;
return _hardwareRevision;
}
try
{
var qsa = new QuerySystemAttributeSLICE2(this);
qsa.Key = AttributeTypes.SystemAttributesSLICE2.BaseHardwareRevision;
qsa.SyncExecute();
_hardwareRevision = Convert.ToInt32(qsa.Value ?? -1);
QueryHardwareRevisionPost();
return Convert.ToInt32(qsa.Value ?? -1);
}
catch (Exception ex)
{
APILogger.Log("failed to get hardware revision", ex);
}
return UNKNOWN_REVISION;
}
}
protected virtual void QueryHardwareRevisionPost()
{
}
protected const int UNKNOWNBaseType = -1;
protected const int PROBaseType = 0;
protected const int NANOBaseType = 1;
protected int QueryBaseType()
{
//this shouldn't change if we've already gotten it once ...
if (_baseType != UNKNOWNBaseType) { return _baseType; }
if (RunTestVariables.InRunTest && this is EthernetSlice6 && RunTestVariables.AssumeBaseTypeSLICE6 > 0)
{
_baseType = RunTestVariables.AssumeBaseTypeSLICE6;
return _baseType;
}
try
{
//15949 S6A when streaming does a whole bunch of unnecessary queries
//avoid getting this attribute if streaming, it will fail
if (GetIsStreaming())
{
return UNKNOWNBaseType;
}
var qsa = new QuerySystemAttributeSLICE2(this);
qsa.Key = AttributeTypes.SystemAttributesSLICE2.BaseType;
qsa.SyncExecute();
_baseType = Convert.ToInt32(qsa.Value);
return _baseType;
}
catch (Exception ex) { APILogger.Log("failed to get base type", ex); }
return UNKNOWNBaseType;
}
#region IClockSyncActions
/// <summary>
/// AsyncInfo for IClockSyncActions that derive from here (S6, S6A, S6DB, etc)
/// </summary>
internal class SetClockSyncConfigPacket
{
public SliceServiceAsyncInfo Info { get; set; }
public SetClockSyncConfigPacket(SliceServiceAsyncInfo info)
{
Info = info;
}
}
internal class GetClockSyncStatusPacket
{
public SliceServiceAsyncInfo Info { get; set; }
public GetClockSyncStatusPacket(SliceServiceAsyncInfo info)
{
Info = info;
}
}
protected virtual void AsyncSetClockSyncConfig(object asyncInfo)
{
if (!(asyncInfo is SetClockSyncConfigPacket packet))
{
return;
}
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.SetClockSyncConfig))
{
packet.Info.Error("Set Clock Config not supported");
return;
}
var info = packet.Info;
var bLocked = false;
try
{
Lock();
bLocked = true;
try
{
var ssaClockSyncProfile =
new SetSystemAttributeSLICE2(this, SetSystemAttribute.Default_IO_Timeout);
ssaClockSyncProfile.SetValue(AttributeTypes.SystemAttributesSLICE2.ClockSyncProfile,
packet.Info.functionData, true);
ssaClockSyncProfile.SyncExecute();
//no exception, so update the current profile
DASClockSyncProfile = (ClockSyncProfile)packet.Info.functionData;
}
catch (Exception ex)
{
APILogger.Log("Problem setting clock sync profile", ex);
APILogger.RaiseError(string.Format(StringResources.UnableToSetClockSync, ex.Message, SerialNumber));
}
bLocked = false;
Release();
info.Success();
}
catch (CanceledException)
{
if (bLocked)
{
bLocked = false;
Release();
}
info.Cancel();
}
catch (CommandException ce)
{
if (bLocked)
{
Release();
bLocked = false;
}
straightFailures++;
if (straightFailures > PERMITTED_FAILURES)
{
APILogger.Log("SetClockSyncConfig error - has failed ", straightFailures, " times, giving up", ce);
info.Error(ce.Message, ce);
}
else
{
info.Success();
APILogger.Log("SetClockSyncConfig error", ce);
}
}
catch (Exception ex)
{
if (bLocked)
{
bLocked = false;
Release();
}
info.Error(ex.Message, ex);
}
finally
{
if (bLocked)
{
Release();
}
}
}
protected virtual void AsyncGetClockSyncStatus(object asyncInfo)
{
if (!(asyncInfo is GetClockSyncStatusPacket packet)) { return; }
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.PTPSyncStatus))
{
packet.Info.Error("Get PTP sync status not supported");
return;
}
var info = packet.Info;
var bLocked = false;
//SLICE6/S6DB only has PTP Sync
try
{
Lock();
bLocked = true;
try
{
var qsaClockSyncProfile = new QuerySystemAttributeSLICE2(this, QuerySystemAttribute.Default_IO_Timeout);
qsaClockSyncProfile.Key = AttributeTypes.SystemAttributesSLICE2.ClockSyncProfile;
qsaClockSyncProfile.SyncExecute();
DASClockSyncProfile = (ClockSyncProfile)qsaClockSyncProfile.Value;
}
catch (Exception ex)
{
APILogger.Log("Problem getting clock sync profile", ex);
}
try
{
var status = new Ptp1588GetSyncStatus(this);
status.SyncExecute();
if (null == DASClockSyncStatus)
{
DASClockSyncStatus = new Dictionary<InputClockSource, bool>();
List<InputClockSource> sources =
Enum.GetValues(typeof(InputClockSource)).Cast<InputClockSource>().ToList();
for (int i = 1; i < sources.Count; i++)
{
// init all sources not synced
DASClockSyncStatus.Add(sources[i], false);
}
}
DASClockSyncStatus[InputClockSource.PTP] = Ptp1588Commands.PtpSyncStatus.Synced == status.SyncStatus;
if (DASClockSyncStatus[InputClockSource.PTP])
{
DoRTCInUTCCheck();
}
}
catch (Exception ex)
{
APILogger.Log("Problem getting PTP sync status", ex);
}
bLocked = false;
Release();
info.Success();
}
catch (CanceledException)
{
if (bLocked) { bLocked = false; Release(); }
info.Cancel();
}
catch (CommandException ce)
{
if (bLocked) { Release(); bLocked = false; }
straightFailures++;
if (straightFailures > PERMITTED_FAILURES)
{
APILogger.Log("GetClockSyncStatus error - has failed ", straightFailures, " times, giving up", ce);
info.Error(ce.Message, ce);
}
else
{
if (info.userData is DTS.DASLib.Service.ServiceBase.CallbackData cbData)
{
cbData.Target.DASClockSyncStatus = null;
}
info.Success();
APILogger.Log("GetClockSyncStatus error", ce);
}
}
catch (Exception ex)
{
if (bLocked) { bLocked = false; Release(); }
info.Error(ex.Message, ex);
}
finally { if (bLocked) { Release(); } }
}
internal class SetPTPDomainIDPacket
{
public SliceServiceAsyncInfo Info { get; set; }
public SetPTPDomainIDPacket(SliceServiceAsyncInfo info)
{
Info = info;
}
}
internal class GetPTPDomainIDPacket
{
public SliceServiceAsyncInfo Info { get; set; }
public GetPTPDomainIDPacket(SliceServiceAsyncInfo info)
{
Info = info;
}
}
protected virtual void AsyncSetPTPDomainID(object asyncInfo)
{
if (!(asyncInfo is SetPTPDomainIDPacket packet))
{
return;
}
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.PTPDomainID))
{
packet.Info.Error("Set PTP Domain ID not supported");
return;
}
var info = packet.Info;
var bLocked = false;
try
{
Lock();
bLocked = true;
try
{
var ssaPTPDomainID =
new SetSystemAttributeSLICE2(this, SetSystemAttribute.Default_IO_Timeout);
ssaPTPDomainID.SetValue(AttributeTypes.SystemAttributesSLICE2.PTP_DomainNumber,
packet.Info.functionData, true);
ssaPTPDomainID.SyncExecute();
}
catch (Exception ex)
{
APILogger.Log("Problem setting ptp domain id", ex);
}
bLocked = false;
Release();
info.Success();
}
catch (CanceledException)
{
if (bLocked)
{
bLocked = false;
Release();
}
info.Cancel();
}
catch (CommandException ce)
{
if (bLocked)
{
Release();
bLocked = false;
}
straightFailures++;
if (straightFailures > PERMITTED_FAILURES)
{
APILogger.Log("SetPTPDomainID error - has failed ", straightFailures, " times, giving up", ce);
info.Error(ce.Message, ce);
}
else
{
info.Success();
APILogger.Log("SetPTPDomainID error", ce);
}
}
catch (Exception ex)
{
if (bLocked)
{
bLocked = false;
Release();
}
info.Error(ex.Message, ex);
}
finally
{
if (bLocked)
{
Release();
}
}
}
protected virtual void AsyncGetPTPDomainID(object asyncInfo)
{
if (!(asyncInfo is GetPTPDomainIDPacket packet)) { return; }
if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.PTPDomainID))
{
packet.Info.Error("Get PTP domain ID not supported");
return;
}
var info = packet.Info;
var bLocked = false;
try
{
Lock();
bLocked = true;
try
{
var qsaPTPDomainID = new QuerySystemAttributeSLICE2(this, QuerySystemAttribute.Default_IO_Timeout);
qsaPTPDomainID.Key = AttributeTypes.SystemAttributesSLICE2.PTP_DomainNumber;
qsaPTPDomainID.SyncExecute();
PTPDomainID = (byte)qsaPTPDomainID.Value;
}
catch (Exception ex)
{
APILogger.Log("Problem getting ptp domain id", ex);
}
bLocked = false;
Release();
info.Success();
}
catch (CanceledException)
{
if (bLocked) { bLocked = false; Release(); }
info.Cancel();
}
catch (CommandException ce)
{
if (bLocked) { Release(); bLocked = false; }
straightFailures++;
if (straightFailures > PERMITTED_FAILURES)
{
APILogger.Log("GetPTPDomainID error - has failed ", straightFailures, " times, giving up", ce);
info.Error(ce.Message, ce);
}
else
{
if (info.userData is DTS.DASLib.Service.ServiceBase.CallbackData cbData)
{
cbData.Target.PTPDomainID = 0;
}
info.Success();
APILogger.Log("GetPTPDomainID error", ce);
}
}
catch (Exception ex)
{
if (bLocked) { bLocked = false; Release(); }
info.Error(ex.Message, ex);
}
finally { if (bLocked) { Release(); } }
}
#endregion
}
/// <summary>
/// SLICE2 is basically a SLICE + some overrides for now
/// so, we extend slice and override specific functionality as required for SLICE2
/// </summary>
/// <typeparam name="T"></typeparam>
public class SLICE2<T> : SLICE2_Base<T>, IDASReconfigure where T : IConnection, new()
{
/// <summary>
/// return values to QueryHardwareRevision
/// </summary>
private enum SLICEPRO_Generation
{
SLICEPRO_GEN2 = 0,
SLICEPRO_GEN3 = 1
}
/// <summary>
/// the different revisions of slice pro Gen III
/// determined by querying Hardware_Revision
/// </summary>
private enum SLICEPro_GenIIIRevisions
{
MAX = 2, //200KHz fixed filter
HI = 3, //100KHz fixed filter
AUTO = 4 //4KHz fixed filter
}
/// <summary>
/// gets the number of samples the hardware filter shifted collected data by
/// </summary>
/// <param name="ModuleIndex"></param>
/// <param name="ActualSampleRate"></param>
/// <param name="HardwareAAF"></param>
/// <returns></returns>
public override ulong GetPhaseShiftSamples(uint ModuleIndex, double ActualSampleRate, uint HardwareAAF, ulong originalT0)
{
/*int baseHardwareRevision = QueryHardwareRevision();
int BaseType = QueryBaseType();
SLICEPRO_Generation gen = (SLICEPRO_Generation)baseHardwareRevision;
SLICEPro_BaseTypes type = (SLICEPro_BaseTypes)BaseType;
switch (type)
{
case SLICEPro_BaseTypes.DIM: return GetPhaseShiftSamplesDIM(ActualSampleRate, HardwareAAF, originalT0);
case SLICEPro_BaseTypes.TOM: return GetPhaseShiftSamplesTOM(ActualSampleRate, HardwareAAF, originalT0);
case SLICEPro_BaseTypes.SIM:
{
switch (gen)
{
case SLICEPRO_Generation.SLICEPRO_GEN2:
{
QueryHardwareConfiguration qhc = new QueryHardwareConfiguration(this, Convert.ToInt32(ModuleIndex));
qhc.SyncExecute();
switch (qhc.HardwareType)
{
case QueryHardwareConfiguration.Types.IEPE_Configurable:
case QueryHardwareConfiguration.Types.Bridge_Configurable:
case QueryHardwareConfiguration.Types.Bridge:
case QueryHardwareConfiguration.Types.IEPE:
return GetPhaseShiftSamplesGen2HBW(ActualSampleRate, HardwareAAF, originalT0);
case QueryHardwareConfiguration.Types.Bridge_Configurable_Low:
case QueryHardwareConfiguration.Types.IEPE_Configurable_Low:
return GetPhaseShiftSamplesGen2LBW(ActualSampleRate, HardwareAAF, originalT0);
}
}break;
case SLICEPRO_Generation.SLICEPRO_GEN3:
{
QuerySystemAttribute_Slice2Bridge_GEN3 qsa = new QuerySystemAttribute_Slice2Bridge_GEN3(this);
qsa.DeviceID = Convert.ToByte(ModuleIndex);
qsa.Key = AttributeTypes.SystemAttributes_Bridge_SLICE2_GEN3.Hardware_Revision;
qsa.SyncExecute();
int value = Convert.ToInt32(qsa.Value);
SLICEPro_GenIIIRevisions rev = (SLICEPro_GenIIIRevisions)value;
switch (rev)
{
case SLICEPro_GenIIIRevisions.AUTO: return GetPhaseShiftSamplesGen3Auto(ActualSampleRate, HardwareAAF, originalT0);
case SLICEPro_GenIIIRevisions.HI: return GetPhaseShiftSamplesGen3Hi(ActualSampleRate, HardwareAAF, originalT0);
case SLICEPro_GenIIIRevisions.MAX: return GetPhaseShiftSamplesGen3Max(ActualSampleRate, HardwareAAF, originalT0);
}
}break;
}
}break;
}
//note, we should never get here...*/
return 0;
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesGen3Max(double actualSampleRate, uint hardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (hardwareAAF < 50000) { microSeconds = 4.8D + 556D / hardwareAAF; }
else if (hardwareAAF < 200000) { microSeconds = 4.8D + 556D / 45000D; }
else { microSeconds = 4.8; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen3MAX");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesGen3Hi(double actualSampleRate, uint hardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (hardwareAAF < 50000) { microSeconds = 9D + 556D / hardwareAAF; }
else if (hardwareAAF < 100000) { microSeconds = 9D + 556D / 45000D; }
else { microSeconds = 9D; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen3HI");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesGen3Auto(double actualSampleRate, uint hardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (hardwareAAF < 4000) { microSeconds = 225D + 556D / hardwareAAF; }
else { microSeconds = 225D; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen3AUTO");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesGen2LBW(double actualSampleRate, uint hardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (hardwareAAF < 50000) { microSeconds = 8D + 556D / hardwareAAF; }
else if (hardwareAAF < 100000) { microSeconds = 8D; }
else if (hardwareAAF < 200000) { microSeconds = 4D; }
else { microSeconds = 4; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen2LBW");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesGen2HBW(double actualSampleRate, uint hardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (hardwareAAF < 50000) { microSeconds = 4D + 556D / hardwareAAF; }
else if (hardwareAAF < 100000) { microSeconds = 4D + 556D / 45000; }
else if (hardwareAAF < 200000) { microSeconds = 4D; }
else { microSeconds = 2; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen2HBW");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesDIM(double actualSampleRate, uint HardwareAAF, ulong originalT0)
{
return GetPhaseShiftSamples(.35D, actualSampleRate, originalT0, "Gen3DIM");
}
/// <summary>
/// computes the number of samples hardware AAF shifted collected data
/// see
/// http://foghat/dtswiki/index.php/SLICE_PRO_Hardware_Overview#SLICE_PRO_Hardware_Input_Signal_Delay_vs_Filter_Rate
/// </summary>
/// <param name="actualSampleRate"></param>
/// <param name="hardwareAAF"></param>
/// <returns></returns>
private ulong GetPhaseShiftSamplesTOM(double actualSampleRate, uint HardwareAAF, ulong originalT0)
{
var microSeconds = 0D;
if (HardwareAAF < 50000) { microSeconds = 9D + 556D / HardwareAAF; }
else if (HardwareAAF < 100000) { microSeconds = 9D + 556D / 45000D; }
else { microSeconds = 9; }
return GetPhaseShiftSamples(microSeconds, actualSampleRate, originalT0, "Gen3TOM");
}
void IDASReconfigure.SetMaxModuleCount(int count)
{
try
{
//turn off power supplies first
if (DASInfo != null && DASInfo.Modules != null && DASInfo.Modules.Length > 0)
{
DisablePowerSupply(DASInfo.Modules[0].TypeOfModule, 1);
}
var ssa = new SetSystemAttributeSLICE2(this);
ssa.SetValue(AttributeTypes.SystemAttributesSLICE2.MaxSLICEEnable, (byte)count, true);
ssa.SyncExecute();
}
catch (Exception ex)
{
APILogger.Log("Failed to set max module count", SerialNumber, ex);
}
}
private int _maxModuleCount = -1;
/// <summary>
/// gets the physical max number of modules.
/// </summary>
/// <returns></returns>
int IDASReconfigure.GetMaxModuleCount()
{
if (-1 == _maxModuleCount)
{
try
{
var q = new QuerySystemAttributeSLICE2(this);
q.Key = AttributeTypes.SystemAttributesSLICE2.SLICECountOnStack;
q.SyncExecute();
_maxModuleCount = Convert.ToInt32(q.Value);
return Convert.ToInt32(q.Value);
}
catch (Exception ex) { APILogger.Log("Failed to get max module count", SerialNumber, ex); }
return DASInfo.Modules.Length;
}
else { return _maxModuleCount; }
}
}
/// <summary>
/// this meaty class handles skipping parts of the download not needed (start of page to desired start sample)
/// [also note we'll need to do the same thing with the end sample too if we want to use the ECC properly,
/// but ECC isn't even implemented yet ...]
/// </summary>
public class QueryEventData_SLICE2 : QueryEventDataBase
{
public override UInt64 FirstSample
{
get => base.FirstSample;
set => base.FirstSample = value;
}
public override UInt64 LastSample
{
get => base.LastSample;
set => base.LastSample = value;
}
public QueryEventData_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock)
: base(sock) { LogCommands = false; }
public QueryEventData_SLICE2(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
: base(sock, TimeoutMillisec) { LogCommands = false; }
private ulong GetRequestedStartSport()
{
if (recorder is SLICE2<EthernetConnection>)
{
var slice2_Ethernet = recorder as SLICE2<EthernetConnection>;
return (slice2_Ethernet.WhatToDownload as WhatToDownloadSlice2).RequestedStartSport;
}
else if (recorder is SLICE2<WINUSBConnection>)
{
var slice2_USB = recorder as SLICE2<WINUSBConnection>;
return (slice2_USB.WhatToDownload as WhatToDownloadSlice2).RequestedStartSport;
}
else { throw new NotSupportedException("GetRequestedStartSport not supported for " + recorder.ConnectString); }
}
private void PushLeftOverData(ushort[] daters)
{
if (recorder is SLICE2<WINUSBConnection> slice2_USB) { slice2_USB.PushLeftOverData(daters); }
else if (recorder is SLICE2<EthernetConnection> slice2_Ethernet){ slice2_Ethernet.PushLeftOverData(daters); }
}
protected override CommandReceiveAction WholePackagePost()
{
// now send the data to the user
var stat = CommandStatus.Success;
if (response.Status != DFConstantsAndEnums.CommandStatus.StatusNoError)
{
var s = (int)response.Status;
APILogger.LogString("QueryEventData.WholePackagePost: reporting failure, status==" + CommandPacketBase.StatusLabels[s] + " (0x" + s.ToString("X") + ")");
stat = CommandStatus.Failure;
}
var cbReport = new QueryEventDataReport(stat, UserCallbackData);
cbReport.Data = new short[_channelsDownloaded][];
for (var i = 0; i < _channelsDownloaded; i++)
GetChannelData(i, out cbReport.Data[i]);
//we have processed some data, but there may be some left over (since data isn't channel sample aligned ...)
//figure out what we used and what's left over
//now we have two situations, one, we have already skimmed beyond all the data we need
//or two, we are somewhere in between, we need to skip a few samples
var requestedStartSpot = GetRequestedStartSport();
if ((FirstSample + (ulong)_data.Length) < requestedStartSpot)
{
//push no data, we don't want it!
}
else if (FirstSample > requestedStartSpot)
{//we want everything in here ...
var samplesProcessed = Convert.ToInt32(Math.Truncate((double)_data.Length / ChannelsDownloaded));
//performance improvement, do less calculations over iterations
var product = samplesProcessed * ChannelsDownloaded;
var leftover = new ushort[_data.Length - product];
for (var i = 0; i < leftover.Length; i++)
{
leftover[i] = _data[i + product];
}
PushLeftOverData(leftover);
}
else
{
//we need to calculate samples only from the start of the data we are interested in
var offset = Convert.ToInt32(requestedStartSpot - FirstSample);
var samplesProcessed = Convert.ToInt32(Math.Truncate(((double)_data.Length - offset) / ChannelsDownloaded));
var leftover = new ushort[_data.Length - offset - (samplesProcessed * ChannelsDownloaded)];
//performance improvement, do less calculations over iterations
offset += samplesProcessed * ChannelsDownloaded;
for (var i = 0; i < leftover.Length; i++)
{
leftover[i] = _data[i + offset];
}
PushLeftOverData(leftover);
}
return UserCallback(cbReport);
}
private ushort[] PopLeftOverData()
{
if (recorder is SLICE2<WINUSBConnection> slice2_USB)
{
return slice2_USB.PopLeftOverData();
}
else if (recorder is SLICE2<EthernetConnection> slice2_Ethernet)
{
return slice2_Ethernet.PopLeftOverData();
}
else if (recorder is SLICE6<EthernetConnection> slice6_Ethernet)
{
return slice6_Ethernet.PopLeftOverData();
}
else if (recorder is SLICE6AIR<EthernetConnection> slice6air_Ethernet)
{
return slice6air_Ethernet.PopLeftOverData();
}
else if (recorder is SLICE6DB<EthernetConnection> slice6db_Ethernet)
{
return slice6db_Ethernet.PopLeftOverData();
}
else { throw new NotImplementedException(); }
}
protected override CommandReceiveAction WholePackage()
{
if (response.Status != DFConstantsAndEnums.CommandStatus.StatusNoError)
{
return CommandReceiveAction.StopReceiving;
}
//we are going to process the data shortly, but before we do we'll need to
//pre-pend any left over data we have to the new incoming data
//since we already count the samples downloaded for samples in the left over stuff
//we don't need to recount it, just the new incoming samples
_samplesDownloaded = (ulong)response.Parameter.Length / 2;
var leftover = PopLeftOverData();
_data = new ushort[_samplesDownloaded + (ulong)leftover.Length];
leftover.CopyTo(_data, 0);
for (var i = 0; (ulong)i < _samplesDownloaded; i++)
{
response.GetParameter(2 * i, out _data[i + leftover.Length]);
}
return CommandReceiveAction.StopReceiving;
}
public override void GetChannelData(int channel, out short[] signedADC)
{
if (channel < 0 || channel > _channelsDownloaded)
{
throw new ApplicationException("QueryEventData.GetChannelData: Data requested on a channel that wasn't downloaded.");
}
//first short circuit if we know we are still completely skipping data
if (((ulong)_data.Length + FirstSample) < GetRequestedStartSport())//(slice2.WhatToDownload as WhatToDownloadSlice2).RequestedStartSport)
{
signedADC = new short[0];//nothing to see here (we are completely before the start of our requested data)
return;
}
//now we have two situations, one, we have already skimmed beyond all the data we need
//or two, we are somewhere in between, we need to skip a few samples
var offset = 0;
if (GetRequestedStartSport() > FirstSample)
//slice2.WhatToDownload as WhatToDownloadSlice2).RequestedStartSport > FirstSample)
{
offset = Convert.ToInt32(GetRequestedStartSport() - FirstSample);
}
// Data order for a 9 channel stack
// 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 etc.
ushort val;
var completeSamples = Convert.ToInt32(Math.Truncate((double)(_data.Length - offset) / ChannelsDownloaded));
var rv = new short[completeSamples];
short currentVal = 0;
offset += channel;
//performance improvement, skip unnecessary stuff ...
for (var i = 0; i < completeSamples; i++)
{
val = _data[i * ChannelsDownloaded + offset];
currentVal = (short)((((val & 0x00FF) << 8) | ((val >> 8) & 0x00FF)) + 0x8000);
rv[i] = currentVal;
}
signedADC = rv;
}
// this function isn't used by SLICEWare, but it is used by the FirmwareTestUtility
// SW uses the GetChannelData above
public override void GetRawIndexedData(int index, out ushort[] data)
{
data = new ushort[_samplesDownloaded];
for (var i = 0; i < data.Length; i++)
{
data[i] = _data[i + index];
}
}
public List<ushort[]> GetRawIndexedChannelData(ref List<ushort> leftOver, ref ulong carryoverStartPoint)
{
carryoverStartPoint += Convert.ToUInt64(_data.Length);
var data = new List<ushort>(leftOver);
data.AddRange(_data);
var samplesPresent = Convert.ToInt32(data.Count / ChannelsDownloaded);
var output = new List<ushort[]>();
for (var i = 0; i < 8; i++)
{
output.Add(new ushort[samplesPresent]);
for (var iSample = 0; iSample < samplesPresent; iSample++)
{
output[i][iSample] = data[iSample * ChannelsDownloaded + i];
}
}
data.RemoveRange(0, samplesPresent * ChannelsDownloaded);
leftOver.Clear();
leftOver.AddRange(data);
return output;
}
}
}
Reference in New Issue Copy Permalink