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/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/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',