/// <summary>Configures common settings for the ModAcc measurement and selects the measurement.</summary>
/// <param name="lte">Specifies the LTE signal to configure.</param>
/// <param name="modAccConfig">Specifies the ModAcc settings to apply.</param>
/// <param name="selectorString">Pass an empty string. The signal name that is passed when creating the signal configuration is used. See the RFmx help for more documention of this parameter.</param>
public static void ConfigureModAcc(RFmxLteMX lte, ModAccConfiguration modAccConfig, string selectorString = "")
{
lte.SelectMeasurements(selectorString, RFmxLteMXMeasurementTypes.ModAcc, false);
lte.ModAcc.Configuration.ConfigureAveraging(selectorString, modAccConfig.AveragingEnabled, modAccConfig.AveragingCount);
lte.ModAcc.Configuration.ConfigureSynchronizationModeAndInterval(selectorString, modAccConfig.SynchronizationMode, modAccConfig.MeasurementOffset, modAccConfig.MeasurementLength);
lte.ModAcc.Configuration.ConfigureEvmUnit(selectorString, modAccConfig.EvmUnit);
}
/// <summary>Fetches common results from the ModAcc measurement.</summary>
/// <param name="lte">Specifies the LTE signal to fetch results from.</param>
/// <param name="selectorString">(Optional) Specifies the result name. See the RFmx help for more documentation of this parameter.</param>
/// <returns>Common ModAcc measurement results.</returns>
public static ModAccResults FetchModAcc(RFmxLteMX lte, string selectorString = "")
{
double[] meanRmsCompositeEvm = null;
double[] maxPeakCompositeEvm = null;
double[] meanFrequencyError = null;
int[] peakCompositeEvmSymbolIndex = null;
int[] peakCompositeEvmSubcarrierIndex = null;
int[] peakCompositeEvmSlotIndex = null;
lte.ModAcc.Results.FetchCompositeEvmArray(selectorString, 10.0, ref meanRmsCompositeEvm,
ref maxPeakCompositeEvm, ref meanFrequencyError, ref peakCompositeEvmSymbolIndex,
ref peakCompositeEvmSubcarrierIndex, ref peakCompositeEvmSlotIndex);
ModAccResults results;
results.ComponentCarrierResults = new ModAccComponentCarrierResults[meanRmsCompositeEvm.Length];
for (int i = 0; i < meanRmsCompositeEvm.Length; i++)
{
results.ComponentCarrierResults[i] = new ModAccComponentCarrierResults()
{
MeanRmsCompositeEvm = meanRmsCompositeEvm[i],
MaxPeakCompositeEvm = maxPeakCompositeEvm[i],
MeanFrequencyError_Hz = meanFrequencyError[i],
PeakCompositeEvmSymbolIndex = peakCompositeEvmSymbolIndex[i],
PeakCompositeEvmSubcarrierIndex = peakCompositeEvmSubcarrierIndex[i],
PeakCompositeEvmSlotIndex = peakCompositeEvmSlotIndex[i]
};
}
return(results);
}
/// <summary>Configures common settings for the ACP measurement and selects the measurement.</summary>
/// <param name="lte">Specifies the LTE signal to configure.</param>
/// <param name="acpConfig">Specifies the ACP settings to apply.</param>
/// <param name="selectorString">Pass an empty string. The signal name that is passed when creating the signal configuration is used. See the RFmx help for more documention of this parameter.</param>
public static void ConfigureAcp(RFmxLteMX lte, AcpConfiguration acpConfig, string selectorString = "")
{
lte.SelectMeasurements(selectorString, RFmxLteMXMeasurementTypes.Acp, false);
lte.Acp.Configuration.ConfigureNumberOfEutraOffsets(selectorString, acpConfig.NumberOfEutraOffsets);
lte.Acp.Configuration.ConfigureNumberOfUtraOffsets(selectorString, acpConfig.NumberOfUtraOffsets);
lte.Acp.Configuration.ConfigureNumberOfGsmOffsets(selectorString, acpConfig.NumberOfGsmOffsets);
lte.Acp.Configuration.ConfigureRbwFilter(selectorString, acpConfig.RbwAuto, acpConfig.Rbw_Hz, acpConfig.RbwFilterType);
lte.Acp.Configuration.ConfigureAveraging(selectorString, acpConfig.AveragingEnabled, acpConfig.AveragingCount, acpConfig.AveragingType);
lte.Acp.Configuration.ConfigureSweepTime(selectorString, acpConfig.SweepTimeAuto, acpConfig.SweepTimeInterval_s);
}
public void TestOfflineAnalysisSingleCarrierTdd()
{
RFmxInstrMX instr = new RFmxInstrMX("", "AnalysisOnly=1");
RFmxLteMX lte = instr.GetLteSignalConfiguration();
ConfigureCommon(lte, CommonConfiguration.GetDefault());
StandardConfiguration signalConfig = StandardConfiguration.GetDefault();
signalConfig.DuplexScheme = RFmxLteMXDuplexScheme.Tdd;
ConfigureStandard(lte, signalConfig);
ModAccConfiguration modAccConfig = ModAccConfiguration.GetDefault();
modAccConfig.MeasurementOffset = 4;
ConfigureModAcc(lte, modAccConfig);
lte.Commit("");
instr.GetRecommendedIQPreTriggerTime("", out double pretriggerTime);
PrecisionTimeSpan timeOffset = new PrecisionTimeSpan(-pretriggerTime);
Waveform wfm = LoadWaveformFromTDMS(@"Support Files\LTE_TDD_2.0.tdms");
Buffer <ComplexSingle> readBuffer = wfm.Data.GetBuffer(true);
WritableBuffer <ComplexSingle> writeBuffer = wfm.Data.GetWritableBuffer();
int sampleOffset = (int)Math.Round(pretriggerTime * wfm.SampleRate);
for (int i = 0; i < readBuffer.Size; i++)
{
writeBuffer[i] = readBuffer[(i - sampleOffset + readBuffer.Size) % readBuffer.Size];
}
wfm.Data.PrecisionTiming = PrecisionWaveformTiming.CreateWithRegularInterval(
wfm.Data.PrecisionTiming.SampleInterval, timeOffset);
lte.AnalyzeIQ("", "", wfm.Data, true, out _);
ModAccResults modAccResults = FetchModAcc(lte);
instr.Close();
Assert.IsTrue(modAccResults.ComponentCarrierResults[0].MeanRmsCompositeEvm < 0.001);
}
/// <summary>Performs actions to initiate acquisition and measurement.<para></para> Enables the specified measurement(s) before optionally
/// automatically adjusting the reference level before beginning measurements. Finally, initiates the acquisition and measurement(s).</summary>
/// <param name="lte">Specifies the LTE signal to configure.</param>
/// <param name="measurements">Specifies one or more previously configured measurements to enable for this acquisition.</param>
/// <param name="autoLevelConfig">Specifies the configuration for the optional AutoLevel process which will automatically set the analyzer's reference level.</param>
/// <param name="enableTraces">(Optional) Specifies whether traces should be enabled for the measurement(s).</param>
/// <param name="selectorString">Pass an empty string. The signal name that is passed when creating the signal configuration is used. See the RFmx help for more documention of this parameter.</param>
/// <param name="resultName">(Optional) Specifies the name to be associated with measurement results. Provide a unique name, such as "r1" to enable
/// fetching of multiple measurement results and traces. See the RFmx help for more documentation of this parameter.</param>
public static void SelectAndInitiateMeasurements(RFmxLteMX lte, RFmxLteMXMeasurementTypes[] measurements, AutoLevelConfiguration autoLevelConfig = default,
bool enableTraces = false, string selectorString = "", string resultName = "")
{
// Aggregate the selected measurements into a single value
// OR of 0 and x equals x
RFmxLteMXMeasurementTypes selectedMeasurements = 0;
foreach (RFmxLteMXMeasurementTypes measurement in measurements)
{
selectedMeasurements |= measurement;
}
lte.SelectMeasurements(selectorString, selectedMeasurements, enableTraces);
if (autoLevelConfig.Enabled)
{
lte.AutoLevel(selectorString, autoLevelConfig.MeasurementInterval_s, out double _);
}
// Initiate acquisition and measurement for the selected measurements
lte.Initiate(selectorString, resultName);
}
/// <summary>Configures common settings related to the LTE standard of the measured signal.</summary>
/// <param name="lte">Specifies the LTE signal to configure.</param>
/// <param name="standardConfig">Specifies the LTE standard settings to apply.</param>
/// <param name="selectorString">Pass an empty string. The signal name that is passed when creating the signal configuration is used. See the RFmx help for more documention of this parameter.</param>
#region Measurement Configuration
public static void ConfigureStandard(RFmxLteMX lte, StandardConfiguration standardConfig, string selectorString = "")
{
lte.ComponentCarrier.SetSpacingType(selectorString, RFmxLteMXComponentCarrierSpacingType.Nominal); // nominal spacing is assumed
lte.ConfigureLinkDirection(selectorString, standardConfig.LinkDirection);
lte.ConfigureDuplexScheme(selectorString, standardConfig.DuplexScheme, standardConfig.UplinkDownlinkConfiguration);
lte.ConfigureBand(selectorString, standardConfig.Band);
lte.ConfigureNumberOfComponentCarriers(selectorString, standardConfig.ComponentCarrierConfigurations.Length);
for (int i = 0; i < standardConfig.ComponentCarrierConfigurations.Length; i++)
{
string carrierString = RFmxLteMX.BuildCarrierString(selectorString, i);
ComponentCarrierConfiguration componentCarrierConfig = standardConfig.ComponentCarrierConfigurations[i];
lte.ComponentCarrier.SetBandwidth(carrierString, componentCarrierConfig.Bandwidth_Hz);
lte.ComponentCarrier.SetCellId(carrierString, componentCarrierConfig.CellId);
lte.ComponentCarrier.ConfigurePuschModulationType(carrierString, componentCarrierConfig.PuschModulationType);
lte.ComponentCarrier.ConfigurePuschResourceBlocks(carrierString, componentCarrierConfig.PuschResourceBlockOffset, componentCarrierConfig.PuschNumberOfResourceBlocks);
lte.ComponentCarrier.ConfigureDownlinkTestModel(carrierString, componentCarrierConfig.DownlinkTestModel);
}
lte.ComponentCarrier.ConfigureAutoResourceBlockDetectionEnabled(selectorString, standardConfig.PuschAutoResourceBlockDetectionEnabled);
lte.ConfigureAutoDmrsDetectionEnabled(selectorString, standardConfig.AutoDmrsDetectionEnabled);
lte.ComponentCarrier.ConfigureDownlinkAutoCellIDDetectionEnabled(selectorString, standardConfig.DownlinkAutoCellIDDetectionEnabled);
}
/// <summary>Fetches common results from the ACP measurement.</summary>
/// <param name="lte">Specifies the LTE signal to fetch results from.</param>
/// <param name="selectorString">(Optional) Specifies the result name. See the RFmx help for more documentation of this parameter.</param>
/// <returns>Common ACP measurement results.</returns>
public static AcpResults FetchAcp(RFmxLteMX lte, string selectorString = "")
{
double[] lowerRelativePower = null;
double[] upperRelativePower = null;
double[] lowerAbsolutePower = null;
double[] upperAbsolutePower = null;
lte.Acp.Results.FetchOffsetMeasurementArray(selectorString, 10.0, ref lowerRelativePower, ref upperRelativePower, ref lowerAbsolutePower, ref upperAbsolutePower);
AcpResults results;
results.OffsetResults = new AcpOffsetResults[lowerAbsolutePower.Length];
for (int i = 0; i < lowerAbsolutePower.Length; i++)
{
string offsetString = RFmxLteMX.BuildOffsetString(selectorString, i); // get the signal string
lte.Acp.Configuration.GetOffsetFrequency(offsetString, out double offsetFrequency);
lte.Acp.Configuration.GetOffsetIntegrationBandwidth(offsetString, out double offsetIbw);
results.OffsetResults[i] = new AcpOffsetResults()
{
LowerRelativePower_dB = lowerRelativePower[i],
UpperRelativePower_dB = upperRelativePower[i],
LowerAbsolutePower_dBm = lowerAbsolutePower[i],
UpperAbsolutePower_dBm = upperAbsolutePower[i],
Frequency_Hz = offsetFrequency,
IntegrationBandwidth_Hz = offsetIbw
};
}
double[] absolutePower = null;
double[] relativePower = null;
lte.Acp.Results.ComponentCarrier.FetchMeasurementArray(selectorString, 10.0, ref absolutePower, ref relativePower);
results.ComponentCarrierResults = new AcpComponentCarrierResults[absolutePower.Length];
for (int i = 0; i < absolutePower.Length; i++)
{
results.ComponentCarrierResults[i] = new AcpComponentCarrierResults()
{
AbsolutePower_dBm = absolutePower[i],
RelativePower_dB = relativePower[i]
};
}
return(results);
}
public void Run()
{
#region Create Sessions
NIRfsg nIRfsg = new NIRfsg(resourceName, false, false);
RFmxInstrMX instr = new RFmxInstrMX(resourceName, "");
RFmxSpecAnMX specAn = instr.GetSpecAnSignalConfiguration(signalStringSpecan);
RFmxLteMX lte = instr.GetLteSignalConfiguration(signalStringLte);
#endregion
#region Configure Generation
ConfigureInstrument(nIRfsg, SgInstrConfig);
Waveform waveform = LoadWaveformFromTDMS(filePath);
// Apply CRF to the waveform if it is enabled
waveform = Methods.RFmxDPD.ConfigurePreDpdCrestFactorReduction(specAn, waveform, preDpdCrestFactorReductionConfig);
DownloadWaveform(nIRfsg, waveform);
ConfigureContinuousGeneration(nIRfsg, waveform);
nIRfsg.Initiate();
#endregion
#region Configure Analyzer
saAutolevelConfig.MeasurementInterval_s = waveform.BurstLength_s;
SA.RFmxInstr.ConfigureInstrument(instr, saInstrConfig);
SA.RFmxSpecAn.ConfigureCommon(specAn, saCommonConfig);
AmpmConfigurationSpecAn.ReferenceWaveform = waveform;
AmpmConfigurationSpecAn.DutAverageInputPower_dBm = SgInstrConfig.DutAverageInputPower_dBm;
SA.RFmxSpecAn.ConfigureAmpm(specAn, AmpmConfigurationSpecAn);
SA.RFmxLTE.ConfigureCommon(lte, saCommonConfig);
SA.RFmxLTE.ConfigureStandard(lte, StandardConfigLte);
#endregion
#region Configure and Measure DPD
if (EnableDpd)
{
Methods.RFmxDPD.ConfigureCommon(specAn, CommonConfigurationDpd, waveform);
Methods.RFmxDPD.ConfigureMemoryPolynomial(specAn, MemoryPolynomialConfiguration);
Methods.RFmxDPD.ConfigureApplyDpdCrestFactorReduction(specAn, applyDpdCrestFactorReductionConfig);
Console.WriteLine("\n--------------- Measurement Results with DPD --------------\n");
specAn.SelectMeasurements("", RFmxSpecAnMXMeasurementTypes.Dpd, true);
Methods.RFmxDPD.PerformMemoryPolynomial(specAn, nIRfsg, MemoryPolynomialConfiguration, waveform);
}
else
{
Console.WriteLine("\n------------- Measurement Results without DPD -------------\n");
}
#endregion
#region Measure
RFmxSpecAnMXMeasurementTypes[] specanMeasurements = new RFmxSpecAnMXMeasurementTypes[1] {
RFmxSpecAnMXMeasurementTypes.Ampm
};
SA.RFmxSpecAn.SelectAndInitiateMeasurements(specAn, specanMeasurements, saAutolevelConfig, waveform.SignalBandwidth_Hz, false, "", resultStringSpecan);
AmpmResultsSpecAn = SA.RFmxSpecAn.FetchAmpm(specAn, RFmxSpecAnMX.BuildResultString(resultStringSpecan));
PrintAMPMResults();
ConfigureAcp(lte, AcpConfigLte);
RFmxLteMXMeasurementTypes[] lteMeasurements = new RFmxLteMXMeasurementTypes[1] {
RFmxLteMXMeasurementTypes.Acp
};
SA.RFmxLTE.SelectAndInitiateMeasurements(lte, lteMeasurements, saAutolevelConfig, false, "", resultStringLte);
AcpResultsLte = FetchAcp(lte, RFmxLteMX.BuildResultString(resultStringLte));
PrintACPResults();
ConfigureModAcc(lte, ModaccConfigLte);
lteMeasurements[0] = RFmxLteMXMeasurementTypes.ModAcc;
SA.RFmxLTE.SelectAndInitiateMeasurements(lte, lteMeasurements, saAutolevelConfig, false, "", resultStringLte);
ModaccResultsLte = FetchModAcc(lte, RFmxLteMX.BuildResultString(resultStringLte));
PrintModAccResults();
#endregion
specAn.Dispose();
specAn = null;
lte.Dispose();
instr.Close();
AbortGeneration(nIRfsg);
CloseInstrument(nIRfsg);
}
/// <summary>Configures common measurement settings for the personality.</summary>
/// <param name="lte">Specifies the LTE signal to configure.</param>
/// <param name="commonConfig">Specifies the common settings to apply.</param>
/// <param name="selectorString">Pass an empty string. The signal name that is passed when creating the signal configuration is used.
/// See the RFmx help for more documention of this parameter.</param>
public static void ConfigureCommon(RFmxLteMX lte, CommonConfiguration commonConfig, string selectorString = "")
{
lte.SetSelectedPorts(selectorString, commonConfig.SelectedPorts);
lte.ConfigureRF(selectorString, commonConfig.CenterFrequency_Hz, commonConfig.ReferenceLevel_dBm, commonConfig.ExternalAttenuation_dB);
lte.ConfigureDigitalEdgeTrigger(selectorString, commonConfig.DigitalTriggerSource, RFmxLteMXDigitalEdgeTriggerEdge.Rising, commonConfig.TriggerDelay_s, commonConfig.TriggerEnabled);
}
/// <summary>
/// This example illustrates how to use the RFmxLTE APIs to configure the analyzer to perform a ModAcc measurement.
/// You can use the Generator Basic example to generate the LTE signal before running this example.
/// </summary>
static void Main(string[] args)
{
Console.WriteLine("\n----------------------- LTE Analyzer Example -----------------------\n");
double centerFrequency = 3.5e9; //Hz
string resourceName = "5840";
string signalString = "Signal0";
string resultString = "Result0";
SA.RFmxInstr.InstrumentConfiguration saInstrConfig;
SA.CommonConfiguration saCommonConfig;
SA.AutoLevelConfiguration saAutolevelConfig;
SA.RFmxLTE.StandardConfiguration StandardConfigLte;
SA.RFmxLTE.ModAccConfiguration ModaccConfigLte;
SA.RFmxLTE.ModAccResults ModaccResultsLte = new ModAccResults();
//Analyzer Configuration
Console.WriteLine("Configure...\n");
saInstrConfig = SA.RFmxInstr.InstrumentConfiguration.GetDefault();
saCommonConfig = SA.CommonConfiguration.GetDefault();
saCommonConfig.ExternalAttenuation_dB = 0;
saCommonConfig.CenterFrequency_Hz = centerFrequency;
saCommonConfig.ReferenceLevel_dBm = 0.0;
saAutolevelConfig = SA.AutoLevelConfiguration.GetDefault();
saAutolevelConfig.Enabled = true;
StandardConfigLte = SA.RFmxLTE.StandardConfiguration.GetDefault();
StandardConfigLte.AutoDmrsDetectionEnabled = RFmxLteMXAutoDmrsDetectionEnabled.True;
StandardConfigLte.ComponentCarrierConfigurations[0].Bandwidth_Hz = 20.0e6;
ModaccConfigLte = SA.RFmxLTE.ModAccConfiguration.GetDefault();
#region Configure Analyzer
saAutolevelConfig.MeasurementInterval_s = 0.001;
RFmxInstrMX instr = new RFmxInstrMX(resourceName, "");
SA.RFmxInstr.ConfigureInstrument(instr, saInstrConfig);
RFmxLteMX lte = instr.GetLteSignalConfiguration(signalString);
SA.RFmxLTE.ConfigureCommon(lte, saCommonConfig);
SA.RFmxLTE.ConfigureStandard(lte, StandardConfigLte);
#endregion
#region Measure
Console.WriteLine("Measure...\n");
ConfigureModAcc(lte, ModaccConfigLte);
RFmxLteMXMeasurementTypes[] lteMeasurements = new RFmxLteMXMeasurementTypes[1] {
RFmxLteMXMeasurementTypes.ModAcc
};
SA.RFmxLTE.SelectAndInitiateMeasurements(lte, lteMeasurements, saAutolevelConfig, false, "", resultString);
ModaccResultsLte = FetchModAcc(lte, RFmxLteMX.BuildResultString(resultString));
//print Results
for (int i = 0; i < ModaccResultsLte.ComponentCarrierResults.Length; i++)
{
Console.WriteLine("----------------------- EVM Results CC {0} -----------------------\n", i);
Console.WriteLine("Composite RMS EVM Mean (% or dB) : {0:0.000}", ModaccResultsLte.ComponentCarrierResults[i].MeanRmsCompositeEvm);
Console.WriteLine("Composite Peak EVM Maximum (% or dB) : {0:0.000}", ModaccResultsLte.ComponentCarrierResults[i].MaxPeakCompositeEvm);
Console.WriteLine("Composite Peak EVM Slot Index : {0}", ModaccResultsLte.ComponentCarrierResults[i].PeakCompositeEvmSlotIndex);
Console.WriteLine("Composite Peak EVM Symbol Index : {0}", ModaccResultsLte.ComponentCarrierResults[i].PeakCompositeEvmSymbolIndex);
Console.WriteLine("Composite Peak EVM Subcarrier Index : {0}", ModaccResultsLte.ComponentCarrierResults[i].PeakCompositeEvmSubcarrierIndex);
Console.WriteLine("Component Carrier Frequency Error Mean (Hz) : {0:0.000}", ModaccResultsLte.ComponentCarrierResults[i].MeanFrequencyError_Hz);
}
#endregion
lte.Dispose();
instr.Close();
Console.WriteLine("Please press any key to close the application.\n");
Console.ReadKey();
}
static void LoadAndRunMeasurements(string instrName, string inputPath, string outputPath)
{
inputPath = Path.GetFullPath(inputPath);
RFmxInstrMX instr = null;
NIRfsa rfsa = null;
IntPtr rfsaHandle;
try
{
Console.WriteLine($"Initializing RFmx session with instrument \"{instrName}\"...");
instr = new RFmxInstrMX(instrName, "");
Console.WriteLine($"Loading configuration from \"{Path.GetFileName(inputPath)}\"...");
instr.LoadAllConfigurations(inputPath, true);
instr.DangerousGetNIRfsaHandle(out rfsaHandle);
rfsa = new NIRfsa(rfsaHandle);
string[] signalNames = new string[0];
RFmxInstrMXPersonalities[] personalities = new RFmxInstrMXPersonalities[0];
Console.WriteLine("Configuration loaded successfully.");
instr.GetSignalConfigurationNames("", RFmxInstrMXPersonalities.All, ref signalNames, ref personalities);
for (int i = 0; i < signalNames.Length; i++)
{
Console.WriteLine("");
ConsoleKeyInfo info;
switch (personalities[i])
{
case RFmxInstrMXPersonalities.BT:
RFmxBTMX bt = instr.GetBTSignalConfiguration(signalNames[i]);
Console.WriteLine($"Enter 'y' to initiate acquisition for RFmx Bluetooth with signal \"{signalNames[i]}\"; any other key to skip.");
info = Console.ReadKey();
Console.WriteLine();
if (info.KeyChar == 'y')
{
bt.Initiate("", "");
bt.WaitForMeasurementComplete("", 10);
FetchAndLog(rfsa, personalities[i], signalNames[i], outputPath);
}
bt.Dispose();
break;
case RFmxInstrMXPersonalities.Wlan:
RFmxWlanMX wlan = instr.GetWlanSignalConfiguration(signalNames[i]);
Console.WriteLine($"Enter 'y' to initiate acquisition for RFmx WLAN with signal \"{signalNames[i]}\"; any other key to skip.");
info = Console.ReadKey();
Console.WriteLine();
if (info.KeyChar == 'y')
{
wlan.Initiate("", "");
wlan.WaitForMeasurementComplete("", 10);
FetchAndLog(rfsa, personalities[i], signalNames[i], outputPath);
}
wlan.Dispose();
break;
case RFmxInstrMXPersonalities.SpecAn:
RFmxSpecAnMX specAn = instr.GetSpecAnSignalConfiguration(signalNames[i]);
Console.WriteLine($"Enter 'y' to initiate acquisition for RFmx SpecAn with signal \"{signalNames[i]}\"; any other key to skip.");
info = Console.ReadKey();
Console.WriteLine();
if (info.KeyChar == 'y')
{
specAn.Initiate("", "");
specAn.WaitForMeasurementComplete("", 10);
FetchAndLog(rfsa, personalities[i], signalNames[i], outputPath);
}
specAn.Dispose();
break;
case RFmxInstrMXPersonalities.NR:
RFmxNRMX nr = instr.GetNRSignalConfiguration(signalNames[i]);
Console.WriteLine($"Enter 'y' to initiate acquisition for RFmx NR with signal \"{signalNames[i]}\"; any other key to skip.");
info = Console.ReadKey();
Console.WriteLine();
if (info.KeyChar == 'y')
{
nr.Initiate("", "");
nr.WaitForMeasurementComplete("", 10);
FetchAndLog(rfsa, personalities[i], signalNames[i], outputPath);
}
nr.Dispose();
break;
case RFmxInstrMXPersonalities.Lte:
RFmxLteMX lte = instr.GetLteSignalConfiguration(signalNames[i]);
Console.WriteLine($"Enter 'y' to initiate acquisition for RFmx LTE with signal \"{signalNames[i]}\"; any other key to skip.");
info = Console.ReadKey();
Console.WriteLine();
if (info.KeyChar == 'y')
{
lte.Initiate("", "");
lte.WaitForMeasurementComplete("", 10);
FetchAndLog(rfsa, personalities[i], signalNames[i], outputPath);
}
lte.Dispose();
break;
default:
throw new System.NotImplementedException($"The \"{personalities[i].ToString()}\" personality has not been implemented.");
}
}
Console.WriteLine("All measurements complete.");
}
catch (Exception ex)
{
Console.WriteLine("Exception occurred: " + ex.Message);
Console.WriteLine("Location: " + ex.StackTrace);
}
finally
{
if (instr != null)
{
instr.Dispose();
}
}
}
