diff --git a/README.md b/README.md index 7b677db06..e128daff2 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,7 @@ Indicates the most recent driver version used to test builds of the current sour | NI-RFmx CDMA2k | 2023 Q1 | Not Supported | Not Supported | | NI-RFmx Demod | 2023 Q1 | Not Supported | Not Supported | | NI-RFmx GSM | 2023 Q1 | Not Supported | Not Supported | -| NI-RFmx LTE | 2024 Q3 | Not Supported | Not Supported | +| NI-RFmx LTE | 2024 Q4 | Not Supported | Not Supported | | NI-RFmx Pulse | 2025 Q1 | Not Supported | Not Supported | | NI-RFmx NR | 2024 Q4 | Not Supported | Not Supported | | NI-RFmx SpecAn | 2024 Q3 | Not Supported | Not Supported | diff --git a/generated/nirfmxinstr/nirfmxinstr.proto b/generated/nirfmxinstr/nirfmxinstr.proto index 3db63dc28..bc88c406c 100644 --- a/generated/nirfmxinstr/nirfmxinstr.proto +++ b/generated/nirfmxinstr/nirfmxinstr.proto @@ -1,6 +1,6 @@ //--------------------------------------------------------------------- -// This file is generated from NI-RFMXINSTR API metadata version 24.3.0 +// This file is generated from NI-RFMXINSTR API metadata version 25.0.0 //--------------------------------------------------------------------- // Proto file for the NI-RFMXINSTR Metadata //--------------------------------------------------------------------- @@ -216,6 +216,8 @@ enum NiRFmxInstrAttribute { NIRFMXINSTR_ATTRIBUTE_THERMAL_CORRECTION_TEMPERATURE_RESOLUTION = 120; NIRFMXINSTR_ATTRIBUTE_NUMBER_OF_RAW_IQ_RECORDS = 128; NIRFMXINSTR_ATTRIBUTE_LOAD_OPTIONS = 163; + NIRFMXINSTR_ATTRIBUTE_LO_SPLITTER_LOSS_FREQUENCY = 184; + NIRFMXINSTR_ATTRIBUTE_LO_SPLITTER_LOSS = 185; } enum ExportSignalSource { @@ -400,6 +402,7 @@ enum NiRFmxInstrInt32AttributeValues { NIRFMXINSTR_INT32_LO_SHARING_MODE_DISABLED = 0; NIRFMXINSTR_INT32_LO_SHARING_MODE_EXTERNAL_DAISY_CHAIN = 4; NIRFMXINSTR_INT32_LO_SHARING_MODE_EXTERNAL_STAR = 3; + NIRFMXINSTR_INT32_LO_SHARING_MODE_SPLITTER_AND_DAISY_CHAIN = 5; NIRFMXINSTR_INT32_LOAD_OPTIONS_SKIP_NONE = 0; NIRFMXINSTR_INT32_LOAD_OPTIONS_SKIP_RFINSTR = 1; NIRFMXINSTR_INT32_MECHANICAL_ATTENUATION_AUTO_FALSE = 0; diff --git a/generated/nirfmxlte/nirfmxlte.proto b/generated/nirfmxlte/nirfmxlte.proto index e4194d7ce..349add9b5 100644 --- a/generated/nirfmxlte/nirfmxlte.proto +++ b/generated/nirfmxlte/nirfmxlte.proto @@ -1,6 +1,6 @@ //--------------------------------------------------------------------- -// This file is generated from NI-RFMXLTE API metadata version 24.8.0 +// This file is generated from NI-RFMXLTE API metadata version 25.0.0 //--------------------------------------------------------------------- // Proto file for the NI-RFMXLTE Metadata //--------------------------------------------------------------------- @@ -196,11 +196,17 @@ service NiRFmxLTE { rpc ModAccFetchMaximumFrequencyErrorPerSlotTrace(ModAccFetchMaximumFrequencyErrorPerSlotTraceRequest) returns (ModAccFetchMaximumFrequencyErrorPerSlotTraceResponse); rpc ModAccFetchMaximumMagnitudeErrorPerSymbolTrace(ModAccFetchMaximumMagnitudeErrorPerSymbolTraceRequest) returns (ModAccFetchMaximumMagnitudeErrorPerSymbolTraceResponse); rpc ModAccFetchMaximumPhaseErrorPerSymbolTrace(ModAccFetchMaximumPhaseErrorPerSymbolTraceRequest) returns (ModAccFetchMaximumPhaseErrorPerSymbolTraceResponse); + rpc ModAccFetchNBSynchronizationSignalConstellation(ModAccFetchNBSynchronizationSignalConstellationRequest) returns (ModAccFetchNBSynchronizationSignalConstellationResponse); + rpc ModAccFetchNBSynchronizationSignalConstellationSplit(ModAccFetchNBSynchronizationSignalConstellationSplitRequest) returns (ModAccFetchNBSynchronizationSignalConstellationSplitResponse); + rpc ModAccFetchNPDSCHQPSKConstellation(ModAccFetchNPDSCHQPSKConstellationRequest) returns (ModAccFetchNPDSCHQPSKConstellationResponse); + rpc ModAccFetchNPDSCHQPSKConstellationSplit(ModAccFetchNPDSCHQPSKConstellationSplitRequest) returns (ModAccFetchNPDSCHQPSKConstellationSplitResponse); rpc ModAccFetchNPUSCHConstellationTrace(ModAccFetchNPUSCHConstellationTraceRequest) returns (ModAccFetchNPUSCHConstellationTraceResponse); rpc ModAccFetchNPUSCHConstellationTraceSplit(ModAccFetchNPUSCHConstellationTraceSplitRequest) returns (ModAccFetchNPUSCHConstellationTraceSplitResponse); rpc ModAccFetchNPUSCHDMRSEVM(ModAccFetchNPUSCHDMRSEVMRequest) returns (ModAccFetchNPUSCHDMRSEVMResponse); rpc ModAccFetchNPUSCHDataEVM(ModAccFetchNPUSCHDataEVMRequest) returns (ModAccFetchNPUSCHDataEVMResponse); rpc ModAccFetchNPUSCHSymbolPower(ModAccFetchNPUSCHSymbolPowerRequest) returns (ModAccFetchNPUSCHSymbolPowerResponse); + rpc ModAccFetchNRSConstellation(ModAccFetchNRSConstellationRequest) returns (ModAccFetchNRSConstellationResponse); + rpc ModAccFetchNRSConstellationSplit(ModAccFetchNRSConstellationSplitRequest) returns (ModAccFetchNRSConstellationSplitResponse); rpc ModAccFetchPDSCH1024QAMConstellation(ModAccFetchPDSCH1024QAMConstellationRequest) returns (ModAccFetchPDSCH1024QAMConstellationResponse); rpc ModAccFetchPDSCH1024QAMConstellationSplit(ModAccFetchPDSCH1024QAMConstellationSplitRequest) returns (ModAccFetchPDSCH1024QAMConstellationSplitResponse); rpc ModAccFetchPDSCH1024QAMEVM(ModAccFetchPDSCH1024QAMEVMRequest) returns (ModAccFetchPDSCH1024QAMEVMResponse); @@ -607,6 +613,17 @@ enum NiRFmxLTEAttribute { NIRFMXLTE_ATTRIBUTE_MODACC_TIMING_TRACKING_ENABLED = 3162241; NIRFMXLTE_ATTRIBUTE_MODACC_PHASE_TRACKING_ENABLED = 3162242; NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_MAXIMUM_PEAK_FREQUENCY_ERROR = 3162243; + NIRFMXLTE_ATTRIBUTE_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE = 3162244; + NIRFMXLTE_ATTRIBUTE_NPSS_POWER = 3162247; + NIRFMXLTE_ATTRIBUTE_NSSS_POWER = 3162249; + NIRFMXLTE_ATTRIBUTE_NPDSCH_POWER = 3162250; + NIRFMXLTE_ATTRIBUTE_NPDSCH_ENABLED = 3162251; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_MEAN_RMS_NPSS_EVM = 3162254; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_MEAN_RMS_NSSS_EVM = 3162255; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_NPDSCH_MEAN_RMS_EVM = 3162256; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_NPDSCH_MEAN_RMS_QPSK_EVM = 3162257; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_MEAN_RMS_NRS_EVM = 3162259; + NIRFMXLTE_ATTRIBUTE_MODACC_RESULTS_DOWNLINK_NRS_TRANSMIT_POWER = 3162260; NIRFMXLTE_ATTRIBUTE_OBW_MEASUREMENT_ENABLED = 3170304; NIRFMXLTE_ATTRIBUTE_OBW_NUMBER_OF_ANALYSIS_THREADS = 3170307; NIRFMXLTE_ATTRIBUTE_OBW_SPAN = 3170308; @@ -1419,6 +1436,8 @@ enum NiRFmxLTEInt32AttributeValues { NIRFMXLTE_INT32_MODACC_SYNCHRONIZATION_MODE_MARKER = 2; NIRFMXLTE_INT32_MODACC_TIMING_TRACKING_ENABLED_FALSE = 0; NIRFMXLTE_INT32_MODACC_TIMING_TRACKING_ENABLED_TRUE = 1; + NIRFMXLTE_INT32_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE_USER_DEFINED = 1; + NIRFMXLTE_INT32_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE_TEST_MODEL = 2; NIRFMXLTE_INT32_NB_IOT_UPLINK_SUBCARRIER_SPACING_15KHZ = 0; NIRFMXLTE_INT32_NB_IOT_UPLINK_SUBCARRIER_SPACING_3_75KHZ = 1; NIRFMXLTE_INT32_NPUSCH_DMRS_BASE_SEQUENCE_MODE_MANUAL = 0; @@ -1427,6 +1446,8 @@ enum NiRFmxLTEInt32AttributeValues { NIRFMXLTE_INT32_NPUSCH_DMRS_GROUP_HOPPING_ENABLED_TRUE = 1; NIRFMXLTE_INT32_NPUSCH_MODULATION_TYPE_BPSK = 0; NIRFMXLTE_INT32_NPUSCH_MODULATION_TYPE_QPSK = 1; + NIRFMXLTE_INT32_NPDSCH_ENABLED_FALSE = 0; + NIRFMXLTE_INT32_NPDSCH_ENABLED_TRUE = 1; NIRFMXLTE_INT32_OBW_AMPLITUDE_CORRECTION_TYPE_RF_CENTER_FREQUENCY = 0; NIRFMXLTE_INT32_OBW_AMPLITUDE_CORRECTION_TYPE_SPECTRUM_FREQUENCY_BIN = 1; NIRFMXLTE_INT32_OBW_AVERAGING_ENABLED_FALSE = 0; @@ -3796,6 +3817,61 @@ message ModAccFetchMaximumPhaseErrorPerSymbolTraceResponse { int32 actual_array_size = 5; } +message ModAccFetchNBSynchronizationSignalConstellationRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNBSynchronizationSignalConstellationResponse { + int32 status = 1; + repeated nidevice_grpc.NIComplexNumberF32 nsss_constellation = 2; + int32 nsss_constellation_actual_array_size = 3; + repeated nidevice_grpc.NIComplexNumberF32 npss_constellation = 4; + int32 npss_constellation_actual_array_size = 5; +} + +message ModAccFetchNBSynchronizationSignalConstellationSplitRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNBSynchronizationSignalConstellationSplitResponse { + int32 status = 1; + repeated float nsss_constellation_i = 2; + repeated float nsss_constellation_q = 3; + int32 nsss_constellation_actual_array_size = 4; + repeated float npss_constellation_i = 5; + repeated float npss_constellation_q = 6; + int32 npss_constellation_actual_array_size = 7; +} + +message ModAccFetchNPDSCHQPSKConstellationRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNPDSCHQPSKConstellationResponse { + int32 status = 1; + repeated nidevice_grpc.NIComplexNumberF32 qpsk_constellation = 2; + int32 actual_array_size = 3; +} + +message ModAccFetchNPDSCHQPSKConstellationSplitRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNPDSCHQPSKConstellationSplitResponse { + int32 status = 1; + repeated float qpsk_constellation_i = 2; + repeated float qpsk_constellation_q = 3; + int32 actual_array_size = 4; +} + message ModAccFetchNPUSCHConstellationTraceRequest { nidevice_grpc.Session instrument = 1; string selector_string = 2; @@ -3862,6 +3938,31 @@ message ModAccFetchNPUSCHSymbolPowerResponse { double npusch_mean_dmrs_power = 3; } +message ModAccFetchNRSConstellationRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNRSConstellationResponse { + int32 status = 1; + repeated nidevice_grpc.NIComplexNumberF32 nrs_constellation = 2; + int32 actual_array_size = 3; +} + +message ModAccFetchNRSConstellationSplitRequest { + nidevice_grpc.Session instrument = 1; + string selector_string = 2; + double timeout = 3; +} + +message ModAccFetchNRSConstellationSplitResponse { + int32 status = 1; + repeated float nrs_constellation_i = 2; + repeated float nrs_constellation_q = 3; + int32 actual_array_size = 4; +} + message ModAccFetchPDSCH1024QAMConstellationRequest { nidevice_grpc.Session instrument = 1; string selector_string = 2; diff --git a/generated/nirfmxlte/nirfmxlte_client.cpp b/generated/nirfmxlte/nirfmxlte_client.cpp index 200c076f4..53a2aa486 100644 --- a/generated/nirfmxlte/nirfmxlte_client.cpp +++ b/generated/nirfmxlte/nirfmxlte_client.cpp @@ -3847,6 +3847,82 @@ mod_acc_fetch_maximum_phase_error_per_symbol_trace(const StubPtr& stub, const ni return response; } +ModAccFetchNBSynchronizationSignalConstellationResponse +mod_acc_fetch_nb_synchronization_signal_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNBSynchronizationSignalConstellationRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNBSynchronizationSignalConstellationResponse{}; + + raise_if_error( + stub->ModAccFetchNBSynchronizationSignalConstellation(&context, request, &response), + context); + + return response; +} + +ModAccFetchNBSynchronizationSignalConstellationSplitResponse +mod_acc_fetch_nb_synchronization_signal_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNBSynchronizationSignalConstellationSplitRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNBSynchronizationSignalConstellationSplitResponse{}; + + raise_if_error( + stub->ModAccFetchNBSynchronizationSignalConstellationSplit(&context, request, &response), + context); + + return response; +} + +ModAccFetchNPDSCHQPSKConstellationResponse +mod_acc_fetch_npdschqpsk_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNPDSCHQPSKConstellationRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNPDSCHQPSKConstellationResponse{}; + + raise_if_error( + stub->ModAccFetchNPDSCHQPSKConstellation(&context, request, &response), + context); + + return response; +} + +ModAccFetchNPDSCHQPSKConstellationSplitResponse +mod_acc_fetch_npdschqpsk_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNPDSCHQPSKConstellationSplitRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNPDSCHQPSKConstellationSplitResponse{}; + + raise_if_error( + stub->ModAccFetchNPDSCHQPSKConstellationSplit(&context, request, &response), + context); + + return response; +} + ModAccFetchNPUSCHConstellationTraceResponse mod_acc_fetch_npusch_constellation_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) { @@ -3942,6 +4018,44 @@ mod_acc_fetch_npusch_symbol_power(const StubPtr& stub, const nidevice_grpc::Sess return response; } +ModAccFetchNRSConstellationResponse +mod_acc_fetch_nrs_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNRSConstellationRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNRSConstellationResponse{}; + + raise_if_error( + stub->ModAccFetchNRSConstellation(&context, request, &response), + context); + + return response; +} + +ModAccFetchNRSConstellationSplitResponse +mod_acc_fetch_nrs_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) +{ + ::grpc::ClientContext context; + + auto request = ModAccFetchNRSConstellationSplitRequest{}; + request.mutable_instrument()->CopyFrom(instrument); + request.set_selector_string(selector_string); + request.set_timeout(timeout); + + auto response = ModAccFetchNRSConstellationSplitResponse{}; + + raise_if_error( + stub->ModAccFetchNRSConstellationSplit(&context, request, &response), + context); + + return response; +} + ModAccFetchPDSCH1024QAMConstellationResponse mod_acc_fetch_pdsch1024q_am_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout) { diff --git a/generated/nirfmxlte/nirfmxlte_client.h b/generated/nirfmxlte/nirfmxlte_client.h index a3f03eb53..930e459f9 100644 --- a/generated/nirfmxlte/nirfmxlte_client.h +++ b/generated/nirfmxlte/nirfmxlte_client.h @@ -201,11 +201,17 @@ ModAccFetchMaximumEVMPerSymbolTraceResponse mod_acc_fetch_maximum_evm_per_symbol ModAccFetchMaximumFrequencyErrorPerSlotTraceResponse mod_acc_fetch_maximum_frequency_error_per_slot_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchMaximumMagnitudeErrorPerSymbolTraceResponse mod_acc_fetch_maximum_magnitude_error_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchMaximumPhaseErrorPerSymbolTraceResponse mod_acc_fetch_maximum_phase_error_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNBSynchronizationSignalConstellationResponse mod_acc_fetch_nb_synchronization_signal_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNBSynchronizationSignalConstellationSplitResponse mod_acc_fetch_nb_synchronization_signal_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNPDSCHQPSKConstellationResponse mod_acc_fetch_npdschqpsk_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNPDSCHQPSKConstellationSplitResponse mod_acc_fetch_npdschqpsk_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchNPUSCHConstellationTraceResponse mod_acc_fetch_npusch_constellation_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchNPUSCHConstellationTraceSplitResponse mod_acc_fetch_npusch_constellation_trace_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchNPUSCHDMRSEVMResponse mod_acc_fetch_npuschdmrsevm(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchNPUSCHDataEVMResponse mod_acc_fetch_npusch_data_evm(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchNPUSCHSymbolPowerResponse mod_acc_fetch_npusch_symbol_power(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNRSConstellationResponse mod_acc_fetch_nrs_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); +ModAccFetchNRSConstellationSplitResponse mod_acc_fetch_nrs_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchPDSCH1024QAMConstellationResponse mod_acc_fetch_pdsch1024q_am_constellation(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchPDSCH1024QAMConstellationSplitResponse mod_acc_fetch_pdsch1024q_am_constellation_split(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); ModAccFetchPDSCH1024QAMEVMResponse mod_acc_fetch_pdsch1024q_amevm(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout); diff --git a/generated/nirfmxlte/nirfmxlte_compilation_test.cpp b/generated/nirfmxlte/nirfmxlte_compilation_test.cpp index 0260dcd06..da3168392 100644 --- a/generated/nirfmxlte/nirfmxlte_compilation_test.cpp +++ b/generated/nirfmxlte/nirfmxlte_compilation_test.cpp @@ -902,6 +902,26 @@ int32 ModAccFetchMaximumPhaseErrorPerSymbolTrace(niRFmxInstrHandle instrumentHan return RFmxLTE_ModAccFetchMaximumPhaseErrorPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumPhaseErrorPerSymbol, arraySize, actualArraySize); } +int32 ModAccFetchNBSynchronizationSignalConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nsssConstellation[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, NIComplexSingle npssConstellation[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) +{ + return RFmxLTE_ModAccFetchNBSynchronizationSignalConstellation(instrumentHandle, selectorString, timeout, nsssConstellation, nsssConstellationArraySize, nsssConstellationActualArraySize, npssConstellation, npssConstellationArraySize, npssConstellationActualArraySize); +} + +int32 ModAccFetchNBSynchronizationSignalConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nsssConstellationI[], float32 nsssConstellationQ[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, float32 npssConstellationI[], float32 npssConstellationQ[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) +{ + return RFmxLTE_ModAccFetchNBSynchronizationSignalConstellationSplit(instrumentHandle, selectorString, timeout, nsssConstellationI, nsssConstellationQ, nsssConstellationArraySize, nsssConstellationActualArraySize, npssConstellationI, npssConstellationQ, npssConstellationArraySize, npssConstellationActualArraySize); +} + +int32 ModAccFetchNPDSCHQPSKConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qpskConstellation[], int32 arraySize, int32* actualArraySize) +{ + return RFmxLTE_ModAccFetchNPDSCHQPSKConstellation(instrumentHandle, selectorString, timeout, qpskConstellation, arraySize, actualArraySize); +} + +int32 ModAccFetchNPDSCHQPSKConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qpskConstellationI[], float32 qpskConstellationQ[], int32 arraySize, int32* actualArraySize) +{ + return RFmxLTE_ModAccFetchNPDSCHQPSKConstellationSplit(instrumentHandle, selectorString, timeout, qpskConstellationI, qpskConstellationQ, arraySize, actualArraySize); +} + int32 ModAccFetchNPUSCHConstellationTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle dataConstellation[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, NIComplexSingle dmrsConstellation[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) { return RFmxLTE_ModAccFetchNPUSCHConstellationTrace(instrumentHandle, selectorString, timeout, dataConstellation, dataConstellationArraySize, dataConstellationActualArraySize, dmrsConstellation, dmrsConstellationArraySize, dmrsConstellationActualArraySize); @@ -927,6 +947,16 @@ int32 ModAccFetchNPUSCHSymbolPower(niRFmxInstrHandle instrumentHandle, char sele return RFmxLTE_ModAccFetchNPUSCHSymbolPower(instrumentHandle, selectorString, timeout, npuschMeanDataPower, npuschMeanDMRSPower); } +int32 ModAccFetchNRSConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nrsConstellation[], int32 arraySize, int32* actualArraySize) +{ + return RFmxLTE_ModAccFetchNRSConstellation(instrumentHandle, selectorString, timeout, nrsConstellation, arraySize, actualArraySize); +} + +int32 ModAccFetchNRSConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nrsConstellationI[], float32 nrsConstellationQ[], int32 arraySize, int32* actualArraySize) +{ + return RFmxLTE_ModAccFetchNRSConstellationSplit(instrumentHandle, selectorString, timeout, nrsConstellationI, nrsConstellationQ, arraySize, actualArraySize); +} + int32 ModAccFetchPDSCH1024QAMConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qam1024Constellation[], int32 arraySize, int32* actualArraySize) { return RFmxLTE_ModAccFetchPDSCH1024QAMConstellation(instrumentHandle, selectorString, timeout, qam1024Constellation, arraySize, actualArraySize); diff --git a/generated/nirfmxlte/nirfmxlte_library.cpp b/generated/nirfmxlte/nirfmxlte_library.cpp index 97dc94db0..74fcbe967 100644 --- a/generated/nirfmxlte/nirfmxlte_library.cpp +++ b/generated/nirfmxlte/nirfmxlte_library.cpp @@ -206,11 +206,17 @@ NiRFmxLTELibrary::NiRFmxLTELibrary(std::shared_ptr(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumFrequencyErrorPerSlotTrace")); function_pointers_.ModAccFetchMaximumMagnitudeErrorPerSymbolTrace = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumMagnitudeErrorPerSymbolTrace")); function_pointers_.ModAccFetchMaximumPhaseErrorPerSymbolTrace = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumPhaseErrorPerSymbolTrace")); + function_pointers_.ModAccFetchNBSynchronizationSignalConstellation = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNBSynchronizationSignalConstellation")); + function_pointers_.ModAccFetchNBSynchronizationSignalConstellationSplit = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNBSynchronizationSignalConstellationSplit")); + function_pointers_.ModAccFetchNPDSCHQPSKConstellation = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPDSCHQPSKConstellation")); + function_pointers_.ModAccFetchNPDSCHQPSKConstellationSplit = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPDSCHQPSKConstellationSplit")); function_pointers_.ModAccFetchNPUSCHConstellationTrace = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPUSCHConstellationTrace")); function_pointers_.ModAccFetchNPUSCHConstellationTraceSplit = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPUSCHConstellationTraceSplit")); function_pointers_.ModAccFetchNPUSCHDMRSEVM = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPUSCHDMRSEVM")); function_pointers_.ModAccFetchNPUSCHDataEVM = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPUSCHDataEVM")); function_pointers_.ModAccFetchNPUSCHSymbolPower = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNPUSCHSymbolPower")); + function_pointers_.ModAccFetchNRSConstellation = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNRSConstellation")); + function_pointers_.ModAccFetchNRSConstellationSplit = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchNRSConstellationSplit")); function_pointers_.ModAccFetchPDSCH1024QAMConstellation = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchPDSCH1024QAMConstellation")); function_pointers_.ModAccFetchPDSCH1024QAMConstellationSplit = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchPDSCH1024QAMConstellationSplit")); function_pointers_.ModAccFetchPDSCH1024QAMEVM = reinterpret_cast(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchPDSCH1024QAMEVM")); @@ -1785,6 +1791,38 @@ int32 NiRFmxLTELibrary::ModAccFetchMaximumPhaseErrorPerSymbolTrace(niRFmxInstrHa return function_pointers_.ModAccFetchMaximumPhaseErrorPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumPhaseErrorPerSymbol, arraySize, actualArraySize); } +int32 NiRFmxLTELibrary::ModAccFetchNBSynchronizationSignalConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nsssConstellation[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, NIComplexSingle npssConstellation[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) +{ + if (!function_pointers_.ModAccFetchNBSynchronizationSignalConstellation) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNBSynchronizationSignalConstellation."); + } + return function_pointers_.ModAccFetchNBSynchronizationSignalConstellation(instrumentHandle, selectorString, timeout, nsssConstellation, nsssConstellationArraySize, nsssConstellationActualArraySize, npssConstellation, npssConstellationArraySize, npssConstellationActualArraySize); +} + +int32 NiRFmxLTELibrary::ModAccFetchNBSynchronizationSignalConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nsssConstellationI[], float32 nsssConstellationQ[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, float32 npssConstellationI[], float32 npssConstellationQ[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) +{ + if (!function_pointers_.ModAccFetchNBSynchronizationSignalConstellationSplit) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNBSynchronizationSignalConstellationSplit."); + } + return function_pointers_.ModAccFetchNBSynchronizationSignalConstellationSplit(instrumentHandle, selectorString, timeout, nsssConstellationI, nsssConstellationQ, nsssConstellationArraySize, nsssConstellationActualArraySize, npssConstellationI, npssConstellationQ, npssConstellationArraySize, npssConstellationActualArraySize); +} + +int32 NiRFmxLTELibrary::ModAccFetchNPDSCHQPSKConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qpskConstellation[], int32 arraySize, int32* actualArraySize) +{ + if (!function_pointers_.ModAccFetchNPDSCHQPSKConstellation) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNPDSCHQPSKConstellation."); + } + return function_pointers_.ModAccFetchNPDSCHQPSKConstellation(instrumentHandle, selectorString, timeout, qpskConstellation, arraySize, actualArraySize); +} + +int32 NiRFmxLTELibrary::ModAccFetchNPDSCHQPSKConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qpskConstellationI[], float32 qpskConstellationQ[], int32 arraySize, int32* actualArraySize) +{ + if (!function_pointers_.ModAccFetchNPDSCHQPSKConstellationSplit) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNPDSCHQPSKConstellationSplit."); + } + return function_pointers_.ModAccFetchNPDSCHQPSKConstellationSplit(instrumentHandle, selectorString, timeout, qpskConstellationI, qpskConstellationQ, arraySize, actualArraySize); +} + int32 NiRFmxLTELibrary::ModAccFetchNPUSCHConstellationTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle dataConstellation[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, NIComplexSingle dmrsConstellation[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) { if (!function_pointers_.ModAccFetchNPUSCHConstellationTrace) { @@ -1825,6 +1863,22 @@ int32 NiRFmxLTELibrary::ModAccFetchNPUSCHSymbolPower(niRFmxInstrHandle instrumen return function_pointers_.ModAccFetchNPUSCHSymbolPower(instrumentHandle, selectorString, timeout, npuschMeanDataPower, npuschMeanDMRSPower); } +int32 NiRFmxLTELibrary::ModAccFetchNRSConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nrsConstellation[], int32 arraySize, int32* actualArraySize) +{ + if (!function_pointers_.ModAccFetchNRSConstellation) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNRSConstellation."); + } + return function_pointers_.ModAccFetchNRSConstellation(instrumentHandle, selectorString, timeout, nrsConstellation, arraySize, actualArraySize); +} + +int32 NiRFmxLTELibrary::ModAccFetchNRSConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nrsConstellationI[], float32 nrsConstellationQ[], int32 arraySize, int32* actualArraySize) +{ + if (!function_pointers_.ModAccFetchNRSConstellationSplit) { + throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchNRSConstellationSplit."); + } + return function_pointers_.ModAccFetchNRSConstellationSplit(instrumentHandle, selectorString, timeout, nrsConstellationI, nrsConstellationQ, arraySize, actualArraySize); +} + int32 NiRFmxLTELibrary::ModAccFetchPDSCH1024QAMConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qam1024Constellation[], int32 arraySize, int32* actualArraySize) { if (!function_pointers_.ModAccFetchPDSCH1024QAMConstellation) { diff --git a/generated/nirfmxlte/nirfmxlte_library.h b/generated/nirfmxlte/nirfmxlte_library.h index 07f9df1d0..337ac0647 100644 --- a/generated/nirfmxlte/nirfmxlte_library.h +++ b/generated/nirfmxlte/nirfmxlte_library.h @@ -200,11 +200,17 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface { int32 ModAccFetchMaximumFrequencyErrorPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumFrequencyErrorPerSlot[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchMaximumMagnitudeErrorPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumMagnitudeErrorPerSymbol[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchMaximumPhaseErrorPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumPhaseErrorPerSymbol[], int32 arraySize, int32* actualArraySize) override; + int32 ModAccFetchNBSynchronizationSignalConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nsssConstellation[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, NIComplexSingle npssConstellation[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) override; + int32 ModAccFetchNBSynchronizationSignalConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nsssConstellationI[], float32 nsssConstellationQ[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, float32 npssConstellationI[], float32 npssConstellationQ[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) override; + int32 ModAccFetchNPDSCHQPSKConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qpskConstellation[], int32 arraySize, int32* actualArraySize) override; + int32 ModAccFetchNPDSCHQPSKConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qpskConstellationI[], float32 qpskConstellationQ[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchNPUSCHConstellationTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle dataConstellation[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, NIComplexSingle dmrsConstellation[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) override; int32 ModAccFetchNPUSCHConstellationTraceSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 dataConstellationI[], float32 dataConstellationQ[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, float32 dmrsConstellationI[], float32 dmrsConstellationQ[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) override; int32 ModAccFetchNPUSCHDMRSEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDMRSEVM, float64* npuschMaximumPeakDMRSEVM) override; int32 ModAccFetchNPUSCHDataEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDataEVM, float64* npuschMaximumPeakDataEVM) override; int32 ModAccFetchNPUSCHSymbolPower(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanDataPower, float64* npuschMeanDMRSPower) override; + int32 ModAccFetchNRSConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nrsConstellation[], int32 arraySize, int32* actualArraySize) override; + int32 ModAccFetchNRSConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nrsConstellationI[], float32 nrsConstellationQ[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchPDSCH1024QAMConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qam1024Constellation[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchPDSCH1024QAMConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qam1024ConstellationI[], float32 qam1024ConstellationQ[], int32 arraySize, int32* actualArraySize) override; int32 ModAccFetchPDSCH1024QAMEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* meanRMS1024QAMEVM) override; @@ -515,11 +521,17 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface { using ModAccFetchMaximumFrequencyErrorPerSlotTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumFrequencyErrorPerSlotTrace); using ModAccFetchMaximumMagnitudeErrorPerSymbolTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumMagnitudeErrorPerSymbolTrace); using ModAccFetchMaximumPhaseErrorPerSymbolTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumPhaseErrorPerSymbolTrace); + using ModAccFetchNBSynchronizationSignalConstellationPtr = decltype(&RFmxLTE_ModAccFetchNBSynchronizationSignalConstellation); + using ModAccFetchNBSynchronizationSignalConstellationSplitPtr = decltype(&RFmxLTE_ModAccFetchNBSynchronizationSignalConstellationSplit); + using ModAccFetchNPDSCHQPSKConstellationPtr = decltype(&RFmxLTE_ModAccFetchNPDSCHQPSKConstellation); + using ModAccFetchNPDSCHQPSKConstellationSplitPtr = decltype(&RFmxLTE_ModAccFetchNPDSCHQPSKConstellationSplit); using ModAccFetchNPUSCHConstellationTracePtr = decltype(&RFmxLTE_ModAccFetchNPUSCHConstellationTrace); using ModAccFetchNPUSCHConstellationTraceSplitPtr = decltype(&RFmxLTE_ModAccFetchNPUSCHConstellationTraceSplit); using ModAccFetchNPUSCHDMRSEVMPtr = decltype(&RFmxLTE_ModAccFetchNPUSCHDMRSEVM); using ModAccFetchNPUSCHDataEVMPtr = decltype(&RFmxLTE_ModAccFetchNPUSCHDataEVM); using ModAccFetchNPUSCHSymbolPowerPtr = decltype(&RFmxLTE_ModAccFetchNPUSCHSymbolPower); + using ModAccFetchNRSConstellationPtr = decltype(&RFmxLTE_ModAccFetchNRSConstellation); + using ModAccFetchNRSConstellationSplitPtr = decltype(&RFmxLTE_ModAccFetchNRSConstellationSplit); using ModAccFetchPDSCH1024QAMConstellationPtr = decltype(&RFmxLTE_ModAccFetchPDSCH1024QAMConstellation); using ModAccFetchPDSCH1024QAMConstellationSplitPtr = decltype(&RFmxLTE_ModAccFetchPDSCH1024QAMConstellationSplit); using ModAccFetchPDSCH1024QAMEVMPtr = decltype(&RFmxLTE_ModAccFetchPDSCH1024QAMEVM); @@ -830,11 +842,17 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface { ModAccFetchMaximumFrequencyErrorPerSlotTracePtr ModAccFetchMaximumFrequencyErrorPerSlotTrace; ModAccFetchMaximumMagnitudeErrorPerSymbolTracePtr ModAccFetchMaximumMagnitudeErrorPerSymbolTrace; ModAccFetchMaximumPhaseErrorPerSymbolTracePtr ModAccFetchMaximumPhaseErrorPerSymbolTrace; + ModAccFetchNBSynchronizationSignalConstellationPtr ModAccFetchNBSynchronizationSignalConstellation; + ModAccFetchNBSynchronizationSignalConstellationSplitPtr ModAccFetchNBSynchronizationSignalConstellationSplit; + ModAccFetchNPDSCHQPSKConstellationPtr ModAccFetchNPDSCHQPSKConstellation; + ModAccFetchNPDSCHQPSKConstellationSplitPtr ModAccFetchNPDSCHQPSKConstellationSplit; ModAccFetchNPUSCHConstellationTracePtr ModAccFetchNPUSCHConstellationTrace; ModAccFetchNPUSCHConstellationTraceSplitPtr ModAccFetchNPUSCHConstellationTraceSplit; ModAccFetchNPUSCHDMRSEVMPtr ModAccFetchNPUSCHDMRSEVM; ModAccFetchNPUSCHDataEVMPtr ModAccFetchNPUSCHDataEVM; ModAccFetchNPUSCHSymbolPowerPtr ModAccFetchNPUSCHSymbolPower; + ModAccFetchNRSConstellationPtr ModAccFetchNRSConstellation; + ModAccFetchNRSConstellationSplitPtr ModAccFetchNRSConstellationSplit; ModAccFetchPDSCH1024QAMConstellationPtr ModAccFetchPDSCH1024QAMConstellation; ModAccFetchPDSCH1024QAMConstellationSplitPtr ModAccFetchPDSCH1024QAMConstellationSplit; ModAccFetchPDSCH1024QAMEVMPtr ModAccFetchPDSCH1024QAMEVM; diff --git a/generated/nirfmxlte/nirfmxlte_library_interface.h b/generated/nirfmxlte/nirfmxlte_library_interface.h index c8ee0fb59..f9ff32f28 100644 --- a/generated/nirfmxlte/nirfmxlte_library_interface.h +++ b/generated/nirfmxlte/nirfmxlte_library_interface.h @@ -194,11 +194,17 @@ class NiRFmxLTELibraryInterface { virtual int32 ModAccFetchMaximumFrequencyErrorPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumFrequencyErrorPerSlot[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchMaximumMagnitudeErrorPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumMagnitudeErrorPerSymbol[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchMaximumPhaseErrorPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumPhaseErrorPerSymbol[], int32 arraySize, int32* actualArraySize) = 0; + virtual int32 ModAccFetchNBSynchronizationSignalConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nsssConstellation[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, NIComplexSingle npssConstellation[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) = 0; + virtual int32 ModAccFetchNBSynchronizationSignalConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nsssConstellationI[], float32 nsssConstellationQ[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, float32 npssConstellationI[], float32 npssConstellationQ[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize) = 0; + virtual int32 ModAccFetchNPDSCHQPSKConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qpskConstellation[], int32 arraySize, int32* actualArraySize) = 0; + virtual int32 ModAccFetchNPDSCHQPSKConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qpskConstellationI[], float32 qpskConstellationQ[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchNPUSCHConstellationTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle dataConstellation[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, NIComplexSingle dmrsConstellation[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) = 0; virtual int32 ModAccFetchNPUSCHConstellationTraceSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 dataConstellationI[], float32 dataConstellationQ[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, float32 dmrsConstellationI[], float32 dmrsConstellationQ[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize) = 0; virtual int32 ModAccFetchNPUSCHDMRSEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDMRSEVM, float64* npuschMaximumPeakDMRSEVM) = 0; virtual int32 ModAccFetchNPUSCHDataEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDataEVM, float64* npuschMaximumPeakDataEVM) = 0; virtual int32 ModAccFetchNPUSCHSymbolPower(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanDataPower, float64* npuschMeanDMRSPower) = 0; + virtual int32 ModAccFetchNRSConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nrsConstellation[], int32 arraySize, int32* actualArraySize) = 0; + virtual int32 ModAccFetchNRSConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nrsConstellationI[], float32 nrsConstellationQ[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchPDSCH1024QAMConstellation(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qam1024Constellation[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchPDSCH1024QAMConstellationSplit(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qam1024ConstellationI[], float32 qam1024ConstellationQ[], int32 arraySize, int32* actualArraySize) = 0; virtual int32 ModAccFetchPDSCH1024QAMEVM(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* meanRMS1024QAMEVM) = 0; diff --git a/generated/nirfmxlte/nirfmxlte_mock_library.h b/generated/nirfmxlte/nirfmxlte_mock_library.h index 25412e37a..90491e109 100644 --- a/generated/nirfmxlte/nirfmxlte_mock_library.h +++ b/generated/nirfmxlte/nirfmxlte_mock_library.h @@ -196,11 +196,17 @@ class NiRFmxLTEMockLibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface { MOCK_METHOD(int32, ModAccFetchMaximumFrequencyErrorPerSlotTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumFrequencyErrorPerSlot[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchMaximumMagnitudeErrorPerSymbolTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumMagnitudeErrorPerSymbol[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchMaximumPhaseErrorPerSymbolTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumPhaseErrorPerSymbol[], int32 arraySize, int32* actualArraySize), (override)); + MOCK_METHOD(int32, ModAccFetchNBSynchronizationSignalConstellation, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nsssConstellation[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, NIComplexSingle npssConstellation[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize), (override)); + MOCK_METHOD(int32, ModAccFetchNBSynchronizationSignalConstellationSplit, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nsssConstellationI[], float32 nsssConstellationQ[], int32 nsssConstellationArraySize, int32* nsssConstellationActualArraySize, float32 npssConstellationI[], float32 npssConstellationQ[], int32 npssConstellationArraySize, int32* npssConstellationActualArraySize), (override)); + MOCK_METHOD(int32, ModAccFetchNPDSCHQPSKConstellation, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qpskConstellation[], int32 arraySize, int32* actualArraySize), (override)); + MOCK_METHOD(int32, ModAccFetchNPDSCHQPSKConstellationSplit, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qpskConstellationI[], float32 qpskConstellationQ[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchNPUSCHConstellationTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle dataConstellation[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, NIComplexSingle dmrsConstellation[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchNPUSCHConstellationTraceSplit, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 dataConstellationI[], float32 dataConstellationQ[], int32 dataConstellationArraySize, int32* dataConstellationActualArraySize, float32 dmrsConstellationI[], float32 dmrsConstellationQ[], int32 dmrsConstellationArraySize, int32* dmrsConstellationActualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchNPUSCHDMRSEVM, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDMRSEVM, float64* npuschMaximumPeakDMRSEVM), (override)); MOCK_METHOD(int32, ModAccFetchNPUSCHDataEVM, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanRMSDataEVM, float64* npuschMaximumPeakDataEVM), (override)); MOCK_METHOD(int32, ModAccFetchNPUSCHSymbolPower, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* npuschMeanDataPower, float64* npuschMeanDMRSPower), (override)); + MOCK_METHOD(int32, ModAccFetchNRSConstellation, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle nrsConstellation[], int32 arraySize, int32* actualArraySize), (override)); + MOCK_METHOD(int32, ModAccFetchNRSConstellationSplit, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 nrsConstellationI[], float32 nrsConstellationQ[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchPDSCH1024QAMConstellation, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, NIComplexSingle qam1024Constellation[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchPDSCH1024QAMConstellationSplit, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float32 qam1024ConstellationI[], float32 qam1024ConstellationQ[], int32 arraySize, int32* actualArraySize), (override)); MOCK_METHOD(int32, ModAccFetchPDSCH1024QAMEVM, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* meanRMS1024QAMEVM), (override)); diff --git a/generated/nirfmxlte/nirfmxlte_service.cpp b/generated/nirfmxlte/nirfmxlte_service.cpp index 675584722..5deb6c8b6 100644 --- a/generated/nirfmxlte/nirfmxlte_service.cpp +++ b/generated/nirfmxlte/nirfmxlte_service.cpp @@ -6835,6 +6835,209 @@ namespace nirfmxlte_grpc { } } + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNBSynchronizationSignalConstellation(::grpc::ServerContext* context, const ModAccFetchNBSynchronizationSignalConstellationRequest* request, ModAccFetchNBSynchronizationSignalConstellationResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 nsss_constellation_actual_array_size {}; + int32 npss_constellation_actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNBSynchronizationSignalConstellation(instrument, selector_string, timeout, nullptr, 0, &nsss_constellation_actual_array_size, nullptr, 0, &npss_constellation_actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + std::vector nsss_constellation(nsss_constellation_actual_array_size, NIComplexSingle()); + std::vector npss_constellation(npss_constellation_actual_array_size, NIComplexSingle()); + auto npss_constellation_array_size = npss_constellation_actual_array_size; + auto nsss_constellation_array_size = nsss_constellation_actual_array_size; + status = library_->ModAccFetchNBSynchronizationSignalConstellation(instrument, selector_string, timeout, nsss_constellation.data(), nsss_constellation_array_size, &nsss_constellation_actual_array_size, npss_constellation.data(), npss_constellation_array_size, &npss_constellation_actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + convert_to_grpc(nsss_constellation, response->mutable_nsss_constellation()); + { + auto shrunk_size = nsss_constellation_actual_array_size; + auto current_size = response->mutable_nsss_constellation()->size(); + if (shrunk_size != current_size) { + response->mutable_nsss_constellation()->DeleteSubrange(shrunk_size, current_size - shrunk_size); + } + } + response->set_nsss_constellation_actual_array_size(nsss_constellation_actual_array_size); + convert_to_grpc(npss_constellation, response->mutable_npss_constellation()); + { + auto shrunk_size = npss_constellation_actual_array_size; + auto current_size = response->mutable_npss_constellation()->size(); + if (shrunk_size != current_size) { + response->mutable_npss_constellation()->DeleteSubrange(shrunk_size, current_size - shrunk_size); + } + } + response->set_npss_constellation_actual_array_size(npss_constellation_actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNBSynchronizationSignalConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNBSynchronizationSignalConstellationSplitRequest* request, ModAccFetchNBSynchronizationSignalConstellationSplitResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 nsss_constellation_actual_array_size {}; + int32 npss_constellation_actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNBSynchronizationSignalConstellationSplit(instrument, selector_string, timeout, nullptr, nullptr, 0, &nsss_constellation_actual_array_size, nullptr, nullptr, 0, &npss_constellation_actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->mutable_nsss_constellation_i()->Resize(nsss_constellation_actual_array_size, 0); + float32* nsss_constellation_i = response->mutable_nsss_constellation_i()->mutable_data(); + response->mutable_nsss_constellation_q()->Resize(nsss_constellation_actual_array_size, 0); + float32* nsss_constellation_q = response->mutable_nsss_constellation_q()->mutable_data(); + response->mutable_npss_constellation_i()->Resize(npss_constellation_actual_array_size, 0); + float32* npss_constellation_i = response->mutable_npss_constellation_i()->mutable_data(); + response->mutable_npss_constellation_q()->Resize(npss_constellation_actual_array_size, 0); + float32* npss_constellation_q = response->mutable_npss_constellation_q()->mutable_data(); + auto npss_constellation_array_size = npss_constellation_actual_array_size; + auto nsss_constellation_array_size = nsss_constellation_actual_array_size; + status = library_->ModAccFetchNBSynchronizationSignalConstellationSplit(instrument, selector_string, timeout, nsss_constellation_i, nsss_constellation_q, nsss_constellation_array_size, &nsss_constellation_actual_array_size, npss_constellation_i, npss_constellation_q, npss_constellation_array_size, &npss_constellation_actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + response->mutable_nsss_constellation_i()->Resize(nsss_constellation_actual_array_size, 0); + response->mutable_nsss_constellation_q()->Resize(nsss_constellation_actual_array_size, 0); + response->set_nsss_constellation_actual_array_size(nsss_constellation_actual_array_size); + response->mutable_npss_constellation_i()->Resize(npss_constellation_actual_array_size, 0); + response->mutable_npss_constellation_q()->Resize(npss_constellation_actual_array_size, 0); + response->set_npss_constellation_actual_array_size(npss_constellation_actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNPDSCHQPSKConstellation(::grpc::ServerContext* context, const ModAccFetchNPDSCHQPSKConstellationRequest* request, ModAccFetchNPDSCHQPSKConstellationResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNPDSCHQPSKConstellation(instrument, selector_string, timeout, nullptr, 0, &actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + std::vector qpsk_constellation(actual_array_size, NIComplexSingle()); + auto array_size = actual_array_size; + status = library_->ModAccFetchNPDSCHQPSKConstellation(instrument, selector_string, timeout, qpsk_constellation.data(), array_size, &actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + convert_to_grpc(qpsk_constellation, response->mutable_qpsk_constellation()); + { + auto shrunk_size = actual_array_size; + auto current_size = response->mutable_qpsk_constellation()->size(); + if (shrunk_size != current_size) { + response->mutable_qpsk_constellation()->DeleteSubrange(shrunk_size, current_size - shrunk_size); + } + } + response->set_actual_array_size(actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNPDSCHQPSKConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNPDSCHQPSKConstellationSplitRequest* request, ModAccFetchNPDSCHQPSKConstellationSplitResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNPDSCHQPSKConstellationSplit(instrument, selector_string, timeout, nullptr, nullptr, 0, &actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->mutable_qpsk_constellation_i()->Resize(actual_array_size, 0); + float32* qpsk_constellation_i = response->mutable_qpsk_constellation_i()->mutable_data(); + response->mutable_qpsk_constellation_q()->Resize(actual_array_size, 0); + float32* qpsk_constellation_q = response->mutable_qpsk_constellation_q()->mutable_data(); + auto array_size = actual_array_size; + status = library_->ModAccFetchNPDSCHQPSKConstellationSplit(instrument, selector_string, timeout, qpsk_constellation_i, qpsk_constellation_q, array_size, &actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + response->mutable_qpsk_constellation_i()->Resize(actual_array_size, 0); + response->mutable_qpsk_constellation_q()->Resize(actual_array_size, 0); + response->set_actual_array_size(actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + //--------------------------------------------------------------------- //--------------------------------------------------------------------- ::grpc::Status NiRFmxLTEService::ModAccFetchNPUSCHConstellationTrace(::grpc::ServerContext* context, const ModAccFetchNPUSCHConstellationTraceRequest* request, ModAccFetchNPUSCHConstellationTraceResponse* response) @@ -7034,6 +7237,97 @@ namespace nirfmxlte_grpc { } } + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNRSConstellation(::grpc::ServerContext* context, const ModAccFetchNRSConstellationRequest* request, ModAccFetchNRSConstellationResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNRSConstellation(instrument, selector_string, timeout, nullptr, 0, &actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + std::vector nrs_constellation(actual_array_size, NIComplexSingle()); + auto array_size = actual_array_size; + status = library_->ModAccFetchNRSConstellation(instrument, selector_string, timeout, nrs_constellation.data(), array_size, &actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + convert_to_grpc(nrs_constellation, response->mutable_nrs_constellation()); + { + auto shrunk_size = actual_array_size; + auto current_size = response->mutable_nrs_constellation()->size(); + if (shrunk_size != current_size) { + response->mutable_nrs_constellation()->DeleteSubrange(shrunk_size, current_size - shrunk_size); + } + } + response->set_actual_array_size(actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + + //--------------------------------------------------------------------- + //--------------------------------------------------------------------- + ::grpc::Status NiRFmxLTEService::ModAccFetchNRSConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNRSConstellationSplitRequest* request, ModAccFetchNRSConstellationSplitResponse* response) + { + if (context->IsCancelled()) { + return ::grpc::Status::CANCELLED; + } + try { + auto instrument_grpc_session = request->instrument(); + niRFmxInstrHandle instrument = session_repository_->access_session(instrument_grpc_session.name()); + auto selector_string_mbcs = convert_from_grpc(request->selector_string()); + char* selector_string = (char*)selector_string_mbcs.c_str(); + float64 timeout = request->timeout(); + int32 actual_array_size {}; + while (true) { + auto status = library_->ModAccFetchNRSConstellationSplit(instrument, selector_string, timeout, nullptr, nullptr, 0, &actual_array_size); + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->mutable_nrs_constellation_i()->Resize(actual_array_size, 0); + float32* nrs_constellation_i = response->mutable_nrs_constellation_i()->mutable_data(); + response->mutable_nrs_constellation_q()->Resize(actual_array_size, 0); + float32* nrs_constellation_q = response->mutable_nrs_constellation_q()->mutable_data(); + auto array_size = actual_array_size; + status = library_->ModAccFetchNRSConstellationSplit(instrument, selector_string, timeout, nrs_constellation_i, nrs_constellation_q, array_size, &actual_array_size); + if (status == kErrorReadBufferTooSmall || status == kWarningCAPIStringTruncatedToFitBuffer) { + // buffer is now too small, try again + continue; + } + if (!status_ok(status)) { + return ConvertApiErrorStatusForNiRFmxInstrHandle(context, status, instrument); + } + response->set_status(status); + response->mutable_nrs_constellation_i()->Resize(actual_array_size, 0); + response->mutable_nrs_constellation_q()->Resize(actual_array_size, 0); + response->set_actual_array_size(actual_array_size); + return ::grpc::Status::OK; + } + } + catch (nidevice_grpc::NonDriverException& ex) { + return ex.GetStatus(); + } + } + //--------------------------------------------------------------------- //--------------------------------------------------------------------- ::grpc::Status NiRFmxLTEService::ModAccFetchPDSCH1024QAMConstellation(::grpc::ServerContext* context, const ModAccFetchPDSCH1024QAMConstellationRequest* request, ModAccFetchPDSCH1024QAMConstellationResponse* response) diff --git a/generated/nirfmxlte/nirfmxlte_service.h b/generated/nirfmxlte/nirfmxlte_service.h index 7ca883792..e748e3354 100644 --- a/generated/nirfmxlte/nirfmxlte_service.h +++ b/generated/nirfmxlte/nirfmxlte_service.h @@ -223,11 +223,17 @@ class NiRFmxLTEService final : public NiRFmxLTE::Service { ::grpc::Status ModAccFetchMaximumFrequencyErrorPerSlotTrace(::grpc::ServerContext* context, const ModAccFetchMaximumFrequencyErrorPerSlotTraceRequest* request, ModAccFetchMaximumFrequencyErrorPerSlotTraceResponse* response) override; ::grpc::Status ModAccFetchMaximumMagnitudeErrorPerSymbolTrace(::grpc::ServerContext* context, const ModAccFetchMaximumMagnitudeErrorPerSymbolTraceRequest* request, ModAccFetchMaximumMagnitudeErrorPerSymbolTraceResponse* response) override; ::grpc::Status ModAccFetchMaximumPhaseErrorPerSymbolTrace(::grpc::ServerContext* context, const ModAccFetchMaximumPhaseErrorPerSymbolTraceRequest* request, ModAccFetchMaximumPhaseErrorPerSymbolTraceResponse* response) override; + ::grpc::Status ModAccFetchNBSynchronizationSignalConstellation(::grpc::ServerContext* context, const ModAccFetchNBSynchronizationSignalConstellationRequest* request, ModAccFetchNBSynchronizationSignalConstellationResponse* response) override; + ::grpc::Status ModAccFetchNBSynchronizationSignalConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNBSynchronizationSignalConstellationSplitRequest* request, ModAccFetchNBSynchronizationSignalConstellationSplitResponse* response) override; + ::grpc::Status ModAccFetchNPDSCHQPSKConstellation(::grpc::ServerContext* context, const ModAccFetchNPDSCHQPSKConstellationRequest* request, ModAccFetchNPDSCHQPSKConstellationResponse* response) override; + ::grpc::Status ModAccFetchNPDSCHQPSKConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNPDSCHQPSKConstellationSplitRequest* request, ModAccFetchNPDSCHQPSKConstellationSplitResponse* response) override; ::grpc::Status ModAccFetchNPUSCHConstellationTrace(::grpc::ServerContext* context, const ModAccFetchNPUSCHConstellationTraceRequest* request, ModAccFetchNPUSCHConstellationTraceResponse* response) override; ::grpc::Status ModAccFetchNPUSCHConstellationTraceSplit(::grpc::ServerContext* context, const ModAccFetchNPUSCHConstellationTraceSplitRequest* request, ModAccFetchNPUSCHConstellationTraceSplitResponse* response) override; ::grpc::Status ModAccFetchNPUSCHDMRSEVM(::grpc::ServerContext* context, const ModAccFetchNPUSCHDMRSEVMRequest* request, ModAccFetchNPUSCHDMRSEVMResponse* response) override; ::grpc::Status ModAccFetchNPUSCHDataEVM(::grpc::ServerContext* context, const ModAccFetchNPUSCHDataEVMRequest* request, ModAccFetchNPUSCHDataEVMResponse* response) override; ::grpc::Status ModAccFetchNPUSCHSymbolPower(::grpc::ServerContext* context, const ModAccFetchNPUSCHSymbolPowerRequest* request, ModAccFetchNPUSCHSymbolPowerResponse* response) override; + ::grpc::Status ModAccFetchNRSConstellation(::grpc::ServerContext* context, const ModAccFetchNRSConstellationRequest* request, ModAccFetchNRSConstellationResponse* response) override; + ::grpc::Status ModAccFetchNRSConstellationSplit(::grpc::ServerContext* context, const ModAccFetchNRSConstellationSplitRequest* request, ModAccFetchNRSConstellationSplitResponse* response) override; ::grpc::Status ModAccFetchPDSCH1024QAMConstellation(::grpc::ServerContext* context, const ModAccFetchPDSCH1024QAMConstellationRequest* request, ModAccFetchPDSCH1024QAMConstellationResponse* response) override; ::grpc::Status ModAccFetchPDSCH1024QAMConstellationSplit(::grpc::ServerContext* context, const ModAccFetchPDSCH1024QAMConstellationSplitRequest* request, ModAccFetchPDSCH1024QAMConstellationSplitResponse* response) override; ::grpc::Status ModAccFetchPDSCH1024QAMEVM(::grpc::ServerContext* context, const ModAccFetchPDSCH1024QAMEVMRequest* request, ModAccFetchPDSCH1024QAMEVMResponse* response) override; diff --git a/imports/include/niRFmxInstr.h b/imports/include/niRFmxInstr.h index 2556397a1..0ace56496 100644 --- a/imports/include/niRFmxInstr.h +++ b/imports/include/niRFmxInstr.h @@ -216,6 +216,8 @@ typedef union CVIAbsoluteTime { CVITime cviTime; unsigned int u32Data[4]; } CVIA #define RFMXINSTR_ATTR_NUMBER_OF_LO_SHARING_GROUPS 0x00000061 #define RFMXINSTR_ATTR_LOAD_OPTIONS 0x000000A3 #define RFMXINSTR_ATTR_DIGITAL_GAIN 0x00000054 +#define RFMXINSTR_ATTR_LO_SPLITTER_LOSS_FREQUENCY 0x000000b8 +#define RFMXINSTR_ATTR_LO_SPLITTER_LOSS 0x000000b9 /* -- Values for binary attributes -- */ @@ -447,6 +449,7 @@ typedef union CVIAbsoluteTime { CVITime cviTime; unsigned int u32Data[4]; } CVIA #define RFMXINSTR_VAL_LO_SHARING_MODE_DISABLED 0 #define RFMXINSTR_VAL_LO_SHARING_MODE_EXTERNAL_STAR 3 #define RFMXINSTR_VAL_LO_SHARING_MODE_EXTERNAL_DAISY_CHAIN 4 +#define RFMXINSTR_VAL_LO_SHARING_MODE_SPLITTER_AND_DAISY_CHAIN 5 // Values for RFMXINSTR_ATTR_LOAD_OPTIONS #define RFMXINSTR_VAL_LOAD_OPTIONS_SKIP_NONE 0 @@ -2070,6 +2073,36 @@ int32 __stdcall RFmxInstr_FetchRawIQData( float64 attrVal ); + int32 __stdcall RFmxInstr_GetLOSplitterLossFrequency( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal[], + int32 arraySize, + int32 *actualArraySize + ); + + int32 __stdcall RFmxInstr_SetLOSplitterLossFrequency( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal[], + int32 arraySize + ); + + int32 __stdcall RFmxInstr_GetLOSplitterLoss( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal[], + int32 arraySize, + int32 *actualArraySize + ); + + int32 __stdcall RFmxInstr_SetLOSplitterLoss( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal[], + int32 arraySize + ); + #ifdef __cplusplus } #endif @@ -2084,6 +2117,11 @@ int32 __stdcall RFmxInstr_FetchRawIQData( #define RFMXINSTR_VAL_AUTOMATIC_SG_SA_SHARED_LO_DISABLED 0 #define RFMXINSTR_VAL_AUTOMATIC_SG_SA_SHARED_LO_ENABLED 1 +/* -- Values for LO Sharing Mode -- */ + +#define RFMXINSTR_VAL_LO_SHARING_MODE_ONBOARD_STAR 1 +#define RFMXINSTR_VAL_LO_SHARING_MODE_ONBOARD_DAISY_CHAIN 2 + #ifdef __cplusplus extern "C" { diff --git a/imports/include/niRFmxLTE.h b/imports/include/niRFmxLTE.h index 9f4f28bf5..23381ecc7 100644 --- a/imports/include/niRFmxLTE.h +++ b/imports/include/niRFmxLTE.h @@ -123,6 +123,11 @@ #define RFMXLTE_ATTR_NPUSCH_DMRS_CYCLIC_SHIFT 0x00304067 #define RFMXLTE_ATTR_NPUSCH_DMRS_GROUP_HOPPING_ENABLED 0x00304069 #define RFMXLTE_ATTR_NPUSCH_DMRS_DELTA_SEQUENCE_SHIFT 0x00304068 +#define RFMXLTE_ATTR_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE 0x00304084 +#define RFMXLTE_ATTR_NPSS_POWER 0x00304087 +#define RFMXLTE_ATTR_NSSS_POWER 0x00304089 +#define RFMXLTE_ATTR_NPDSCH_POWER 0x0030408a +#define RFMXLTE_ATTR_NPDSCH_ENABLED 0x0030408b #define RFMXLTE_ATTR_EMTC_ANALYSIS_ENABLED 0x00304070 #define RFMXLTE_ATTR_NUMBER_OF_STEPS 0x00300ff8 #define RFMXLTE_ATTR_LIST_STEP_TIMER_UNIT 0x00300ff6 @@ -183,6 +188,12 @@ #define RFMXLTE_ATTR_MODACC_RESULTS_DOWNLINK_RS_TRANSMIT_POWER 0x00304051 #define RFMXLTE_ATTR_MODACC_RESULTS_DOWNLINK_OFDM_SYMBOL_TRANSMIT_POWER 0x00304052 #define RFMXLTE_ATTR_MODACC_RESULTS_DOWNLINK_DETECTED_CELL_ID 0x00304053 +#define RFMXLTE_ATTR_MODACC_RESULTS_MEAN_RMS_NPSS_EVM 0x0030408e +#define RFMXLTE_ATTR_MODACC_RESULTS_MEAN_RMS_NSSS_EVM 0x0030408f +#define RFMXLTE_ATTR_MODACC_RESULTS_NPDSCH_MEAN_RMS_EVM 0x00304090 +#define RFMXLTE_ATTR_MODACC_RESULTS_NPDSCH_MEAN_RMS_QPSK_EVM 0x00304091 +#define RFMXLTE_ATTR_MODACC_RESULTS_MEAN_RMS_NRS_EVM 0x00304093 +#define RFMXLTE_ATTR_MODACC_RESULTS_DOWNLINK_NRS_TRANSMIT_POWER 0x00304094 #define RFMXLTE_ATTR_MODACC_RESULTS_IN_BAND_EMISSION_MARGIN 0x0030402b #define RFMXLTE_ATTR_MODACC_RESULTS_SPECTRAL_FLATNESS_RANGE1_MAXIMUM_TO_RANGE1_MINIMUM 0x0030402c #define RFMXLTE_ATTR_MODACC_RESULTS_SPECTRAL_FLATNESS_RANGE2_MAXIMUM_TO_RANGE2_MINIMUM 0x0030402d @@ -628,6 +639,14 @@ #define RFMXLTE_VAL_NPUSCH_DMRS_GROUP_HOPPING_ENABLED_FALSE 0 #define RFMXLTE_VAL_NPUSCH_DMRS_GROUP_HOPPING_ENABLED_TRUE 1 +// Values for RFMXLTE_ATTR_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE +#define RFMXLTE_VAL_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE_USER_DEFINED 1 +#define RFMXLTE_VAL_NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE_TEST_MODEL 2 + +// Values for RFMXLTE_ATTR_NPDSCH_ENABLED +#define RFMXLTE_VAL_NB_IOT_DOWNLINK_USER_DEFINED_NPDSCH_ENABLED_FALSE 0 +#define RFMXLTE_VAL_NB_IOT_DOWNLINK_USER_DEFINED_NPDSCH_ENABLED_TRUE 1 + // Values for RFMXLTE_ATTR_EMTC_ANALYSIS_ENABLED #define RFMXLTE_VAL_EMTC_ANALYSIS_ENABLED_FALSE 0 #define RFMXLTE_VAL_EMTC_ANALYSIS_ENABLED_TRUE 1 @@ -2389,6 +2408,32 @@ int32 __stdcall RFmxLTE_ModAccFetchSynchronizationSignalConstellationSplit( int32* actualArraySize ); +int32 __stdcall RFmxLTE_ModAccFetchNBSynchronizationSignalConstellation( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + NIComplexSingle NSSSConstellation[], + int32 NSSSConstellationArraySize, + int32* NSSSConstellationActualArraySize, + NIComplexSingle NPSSConstellation[], + int32 NPSSConstellationArraySize, + int32* NPSSConstellationActualArraySize +); + +int32 __stdcall RFmxLTE_ModAccFetchNBSynchronizationSignalConstellationSplit( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + float32 NSSSConstellationI[], + float32 NSSSConstellationQ[], + int32 NSSSConstellationArraySize, + int32* NSSSConstellationActualArraySize, + float32 NPSSConstellationI[], + float32 NPSSConstellationQ[], + int32 NPSSConstellationArraySize, + int32* NPSSConstellationActualArraySize +); + int32 __stdcall RFmxLTE_AbortMeasurements( niRFmxInstrHandle instrumentHandle, char selectorString[] @@ -3185,6 +3230,44 @@ int32 __stdcall RFmxLTE_ModAccFetchMaximumFrequencyErrorPerSlotTrace( int32* actualArraySize ); +int32 __stdcall RFmxLTE_ModAccFetchNPDSCHQPSKConstellation( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + NIComplexSingle QPSKConstellation[], + int32 arraySize, + int32* actualArraySize +); + +int32 __stdcall RFmxLTE_ModAccFetchNPDSCHQPSKConstellationSplit( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + float32 QPSKConstellationI[], + float32 QPSKConstellationQ[], + int32 arraySize, + int32* actualArraySize +); + +int32 __stdcall RFmxLTE_ModAccFetchNRSConstellation( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + NIComplexSingle NRSConstellation[], + int32 arraySize, + int32* actualArraySize +); + +int32 __stdcall RFmxLTE_ModAccFetchNRSConstellationSplit( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 timeout, + float32 NRSConstellationI[], + float32 NRSConstellationQ[], + int32 arraySize, + int32* actualArraySize +); + int32 __stdcall RFmxLTE_ModAccFetchCompositeEVM( niRFmxInstrHandle instrumentHandle, char selectorString[], @@ -4913,6 +4996,66 @@ int32 __stdcall RFmxLTE_SetNPUSCHDMRSDeltaSequenceShift( int32 attrVal ); +int32 __stdcall RFmxLTE_GetNBIoTDownlinkChannelConfigurationMode( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + int32 *attrVal +); + +int32 __stdcall RFmxLTE_SetNBIoTDownlinkChannelConfigurationMode( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + int32 attrVal +); + +int32 __stdcall RFmxLTE_GetNPSSPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_SetNPSSPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal +); + +int32 __stdcall RFmxLTE_GetNSSSPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_SetNSSSPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal +); + +int32 __stdcall RFmxLTE_GetNPDSCHPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_SetNPDSCHPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 attrVal +); + +int32 __stdcall RFmxLTE_GetNPDSCHEnabled( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + int32 *attrVal +); + +int32 __stdcall RFmxLTE_SetNPDSCHEnabled( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + int32 attrVal +); + int32 __stdcall RFmxLTE_GetEMTCAnalysisEnabled( niRFmxInstrHandle instrumentHandle, char selectorString[], @@ -5555,6 +5698,42 @@ int32 __stdcall RFmxLTE_ModAccGetResultsDownlinkDetectedCellID( int32 *attrVal ); +int32 __stdcall RFmxLTE_ModAccGetResultsMeanRMSNPSSEVM( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_ModAccGetResultsMeanRMSNSSSEVM( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_ModAccGetResultsNPDSCHMeanRMSEVM( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_ModAccGetResultsNPDSCHMeanRMSQPSKEVM( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_ModAccGetResultsMeanRMSNRSEVM( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + +int32 __stdcall RFmxLTE_ModAccGetResultsDownlinkNRSTransmitPower( + niRFmxInstrHandle instrumentHandle, + char selectorString[], + float64 *attrVal +); + int32 __stdcall RFmxLTE_ModAccGetResultsInBandEmissionMargin( niRFmxInstrHandle instrumentHandle, char selectorString[], diff --git a/source/codegen/metadata/nirfmxinstr/attributes.py b/source/codegen/metadata/nirfmxinstr/attributes.py index f6ba527f8..41c2a81ce 100644 --- a/source/codegen/metadata/nirfmxinstr/attributes.py +++ b/source/codegen/metadata/nirfmxinstr/attributes.py @@ -527,5 +527,15 @@ 'enum': 'LoadOptions', 'name': 'LOAD_OPTIONS', 'type': 'int32[]' + }, + 184: { + 'access': 'read-write', + 'name': 'LO_SPLITTER_LOSS_FREQUENCY', + 'type': 'float64[]' + }, + 185: { + 'access': 'read-write', + 'name': 'LO_SPLITTER_LOSS', + 'type': 'float64[]' } } diff --git a/source/codegen/metadata/nirfmxinstr/config.py b/source/codegen/metadata/nirfmxinstr/config.py index 6a996f187..23d9cb0b3 100644 --- a/source/codegen/metadata/nirfmxinstr/config.py +++ b/source/codegen/metadata/nirfmxinstr/config.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- config = { - 'api_version': '24.3.0', + 'api_version': '25.0.0', 'c_header': 'niRFmxInstr.h', 'c_function_prefix': 'RFmxInstr_', 'service_class_prefix': 'NiRFmxInstr', diff --git a/source/codegen/metadata/nirfmxinstr/enums.py b/source/codegen/metadata/nirfmxinstr/enums.py index ff28604ed..23cf31bc6 100644 --- a/source/codegen/metadata/nirfmxinstr/enums.py +++ b/source/codegen/metadata/nirfmxinstr/enums.py @@ -327,6 +327,10 @@ { 'name': 'EXTERNAL_STAR', 'value': 3 + }, + { + 'name': 'SPLITTER_AND_DAISY_CHAIN', + 'value': 5 } ] }, diff --git a/source/codegen/metadata/nirfmxlte/attributes.py b/source/codegen/metadata/nirfmxlte/attributes.py index cb222ab0f..d5b669588 100644 --- a/source/codegen/metadata/nirfmxlte/attributes.py +++ b/source/codegen/metadata/nirfmxlte/attributes.py @@ -1457,6 +1457,63 @@ 'name': 'MODACC_RESULTS_MAXIMUM_PEAK_FREQUENCY_ERROR', 'type': 'float64' }, + 3162244: { + 'access': 'read-write', + 'enum': 'NBIoTDownlinkChannelConfigurationMode', + 'name': 'NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE', + 'type': 'int32' + }, + 3162247: { + 'access': 'read-write', + 'name': 'NPSS_POWER', + 'type': 'float64' + }, + 3162249: { + 'access': 'read-write', + 'name': 'NSSS_POWER', + 'type': 'float64' + }, + 3162250: { + 'access': 'read-write', + 'name': 'NPDSCH_POWER', + 'type': 'float64' + }, + 3162251: { + 'access': 'read-write', + 'enum': 'NpdschEnabled', + 'name': 'NPDSCH_ENABLED', + 'type': 'int32' + }, + 3162254: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_MEAN_RMS_NPSS_EVM', + 'type': 'float64' + }, + 3162255: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_MEAN_RMS_NSSS_EVM', + 'type': 'float64' + }, + 3162256: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_NPDSCH_MEAN_RMS_EVM', + 'type': 'float64' + }, + 3162257: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_NPDSCH_MEAN_RMS_QPSK_EVM', + 'type': 'float64' + }, + 3162259: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_MEAN_RMS_NRS_EVM', + 'type': 'float64' + }, + 3162260: { + 'access': 'read-write', + 'name': 'MODACC_RESULTS_DOWNLINK_NRS_TRANSMIT_POWER', + 'type': 'float64' + }, 3170304: { 'access': 'read-write', 'name': 'OBW_MEASUREMENT_ENABLED', diff --git a/source/codegen/metadata/nirfmxlte/config.py b/source/codegen/metadata/nirfmxlte/config.py index 73ccaa730..5a9bdd522 100644 --- a/source/codegen/metadata/nirfmxlte/config.py +++ b/source/codegen/metadata/nirfmxlte/config.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- config = { - 'api_version': '24.8.0', + 'api_version': '25.0.0', 'c_header': 'niRFmxLTE.h', 'c_function_prefix': 'RFmxLTE_', 'service_class_prefix': 'NiRFmxLTE', diff --git a/source/codegen/metadata/nirfmxlte/enums.py b/source/codegen/metadata/nirfmxlte/enums.py index 7e1a925ea..34f1dcedc 100644 --- a/source/codegen/metadata/nirfmxlte/enums.py +++ b/source/codegen/metadata/nirfmxlte/enums.py @@ -1317,6 +1317,19 @@ } ] }, + 'NBIoTDownlinkChannelConfigurationMode': { + 'enum-value-prefix': 'NB_IOT_DOWNLINK_CHANNEL_CONFIGURATION_MODE', + 'values': [ + { + 'name': 'USER_DEFINED', + 'value': 1 + }, + { + 'name': 'TEST_MODEL', + 'value': 2 + } + ] + }, 'NBIoTUplinkSubcarrierSpacing': { 'enum-value-prefix': 'NB_IOT_UPLINK_SUBCARRIER_SPACING', 'values': [ @@ -1369,6 +1382,18 @@ } ] }, + 'NpdschEnabled': { + 'values': [ + { + 'name': 'FALSE', + 'value': 0 + }, + { + 'name': 'TRUE', + 'value': 1 + } + ] + }, 'ObwAmplitudeCorrectionType': { 'values': [ { diff --git a/source/codegen/metadata/nirfmxlte/functions.py b/source/codegen/metadata/nirfmxlte/functions.py index 0ac6ad728..7fc696fac 100644 --- a/source/codegen/metadata/nirfmxlte/functions.py +++ b/source/codegen/metadata/nirfmxlte/functions.py @@ -6066,6 +6066,240 @@ ], 'returns': 'int32' }, + 'ModAccFetchNBSynchronizationSignalConstellation': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'nsssConstellation', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'nsssConstellationArraySize', + 'value_twist': 'nsssConstellationActualArraySize' + }, + 'type': 'NIComplexSingle[]' + }, + { + 'direction': 'in', + 'name': 'nsssConstellationArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'nsssConstellationActualArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'npssConstellation', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'npssConstellationArraySize', + 'value_twist': 'npssConstellationActualArraySize' + }, + 'type': 'NIComplexSingle[]' + }, + { + 'direction': 'in', + 'name': 'npssConstellationArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'npssConstellationActualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, + 'ModAccFetchNBSynchronizationSignalConstellationSplit': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'nsssConstellationI', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'nsssConstellationArraySize', + 'value_twist': 'nsssConstellationActualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'out', + 'name': 'nsssConstellationQ', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'nsssConstellationArraySize', + 'value_twist': 'nsssConstellationActualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'in', + 'name': 'nsssConstellationArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'nsssConstellationActualArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'npssConstellationI', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'npssConstellationArraySize', + 'value_twist': 'npssConstellationActualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'out', + 'name': 'npssConstellationQ', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'npssConstellationArraySize', + 'value_twist': 'npssConstellationActualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'in', + 'name': 'npssConstellationArraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'npssConstellationActualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, + 'ModAccFetchNPDSCHQPSKConstellation': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'qpskConstellation', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'NIComplexSingle[]' + }, + { + 'direction': 'in', + 'name': 'arraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'actualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, + 'ModAccFetchNPDSCHQPSKConstellationSplit': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'qpskConstellationI', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'out', + 'name': 'qpskConstellationQ', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'in', + 'name': 'arraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'actualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, 'ModAccFetchNPUSCHConstellationTrace': { 'parameters': [ { @@ -6303,6 +6537,98 @@ ], 'returns': 'int32' }, + 'ModAccFetchNRSConstellation': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'nrsConstellation', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'NIComplexSingle[]' + }, + { + 'direction': 'in', + 'name': 'arraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'actualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, + 'ModAccFetchNRSConstellationSplit': { + 'parameters': [ + { + 'direction': 'in', + 'grpc_name': 'instrument', + 'name': 'instrumentHandle', + 'type': 'niRFmxInstrHandle' + }, + { + 'direction': 'in', + 'name': 'selectorString', + 'type': 'char[]' + }, + { + 'direction': 'in', + 'name': 'timeout', + 'type': 'float64' + }, + { + 'direction': 'out', + 'name': 'nrsConstellationI', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'out', + 'name': 'nrsConstellationQ', + 'size': { + 'mechanism': 'ivi-dance-with-a-twist', + 'value': 'arraySize', + 'value_twist': 'actualArraySize' + }, + 'type': 'float32[]' + }, + { + 'direction': 'in', + 'name': 'arraySize', + 'type': 'int32' + }, + { + 'direction': 'out', + 'name': 'actualArraySize', + 'type': 'int32' + } + ], + 'returns': 'int32' + }, 'ModAccFetchPDSCH1024QAMConstellation': { 'parameters': [ {