Robert Schmidt
6b37d183ce
set_latency_target() attempts to set keep "low latency" by - writing a specific latency to /dev/cpu_dma_latency - setting manually the minimum CPU processor frequency to be the maximum There is no functionality to undo this after stopping the softmodem(s), and most users are probably not even aware that OAI does this. It is generally preferable to set this beforehand using a governor or by disabling sleep states (as outlined in the tutorial, and in a follow-up commit in the performance tuning docs). The previous mlockall() call, to lock memory to RAM, is retained in a new function. There were additional mlockall() calls, which have been replaced with lock_memory_to_ram(), where necessary.
331 lines
12 KiB
C
331 lines
12 KiB
C
#include <stdint.h>
|
|
#include <openair1/PHY/impl_defs_top.h>
|
|
#include <radio/COMMON/common_lib.h>
|
|
#include <executables/softmodem-common.h>
|
|
#include <openair1/PHY/TOOLS/calibration_scope.h>
|
|
#include "nfapi/oai_integration/vendor_ext.h"
|
|
|
|
|
|
int oai_exit=false;
|
|
unsigned int mmapped_dma=0;
|
|
int single_thread_flag;
|
|
uint32_t timing_advance;
|
|
int8_t threequarter_fs;
|
|
uint64_t downlink_frequency[MAX_NUM_CCs][4];
|
|
int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
|
|
int opp_enabled;
|
|
THREAD_STRUCT thread_struct;
|
|
uint32_t target_ul_mcs = 9;
|
|
uint32_t target_dl_mcs = 9;
|
|
uint64_t dlsch_slot_bitmap = (1<<1);
|
|
uint64_t ulsch_slot_bitmap = (1<<8);
|
|
uint32_t target_ul_bw = 50;
|
|
uint32_t target_dl_bw = 50;
|
|
uint32_t target_dl_Nl;
|
|
uint32_t target_ul_Nl;
|
|
char *uecap_file;
|
|
#include <executables/nr-softmodem.h>
|
|
|
|
int read_recplayconfig(recplay_conf_t **recplay_conf, recplay_state_t **recplay_state) {return 0;}
|
|
void nfapi_setmode(nfapi_mode_t nfapi_mode) {}
|
|
void set_taus_seed(unsigned int seed_init){};
|
|
configmodule_interface_t *uniqCfg = NULL;
|
|
int main(int argc, char **argv) {
|
|
///static configuration for NR at the moment
|
|
if ((uniqCfg = load_configmodule(argc, argv, CONFIG_ENABLECMDLINEONLY)) == NULL) {
|
|
exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
|
|
}
|
|
set_softmodem_sighandler();
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
setvbuf(stderr, NULL, _IONBF, 0);
|
|
logInit();
|
|
paramdef_t cmdline_params[] = CMDLINE_PARAMS_DESC_GNB ;
|
|
|
|
CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
|
|
get_common_options(uniqCfg, SOFTMODEM_GNB_BIT);
|
|
config_process_cmdline(uniqCfg, cmdline_params, sizeofArray(cmdline_params), NULL);
|
|
CONFIG_CLEARRTFLAG(CONFIG_NOEXITONHELP);
|
|
lock_memory_to_ram();
|
|
|
|
int N_RB=50;
|
|
int sampling_rate=30.72e6;
|
|
int DFT=2048;
|
|
int TxAdvanceInDFTSize=12;
|
|
int antennas=1;
|
|
uint64_t freq=3619.200e6;
|
|
int rxGain=90;
|
|
int txGain=90;
|
|
int filterBand=40e6;
|
|
char * usrp_addrs="type=b200";
|
|
|
|
openair0_config_t openair0_cfg= {
|
|
//! Module ID for this configuration
|
|
.Mod_id=0,
|
|
//! device log level
|
|
.log_level=0,
|
|
//! duplexing mode
|
|
.duplex_mode=0,
|
|
//! number of downlink resource blocks
|
|
.num_rb_dl=N_RB,
|
|
//! number of samples per frame
|
|
.samples_per_frame=0,
|
|
//! the sample rate for both transmit and receive.
|
|
.sample_rate=sampling_rate,
|
|
//device is doing mmapped DMA transfers
|
|
.mmapped_dma=0,
|
|
//! offset in samples between TX and RX paths
|
|
.tx_sample_advance=0,
|
|
//! samples per packet on the fronthaul interface
|
|
.samples_per_packet=1024,
|
|
//! number of RX channels (=RX antennas)
|
|
.rx_num_channels=antennas,
|
|
//! number of TX channels (=TX antennas)
|
|
.tx_num_channels=antennas,
|
|
//! \brief Center frequency in Hz for RX.
|
|
//! index: [0..rx_num_channels[
|
|
.rx_freq={freq,freq,freq,freq},
|
|
//! \brief Center frequency in Hz for TX.
|
|
//! index: [0..rx_num_channels[ !!! see lte-ue.c:427 FIXME iterates over rx_num_channels
|
|
.tx_freq={freq,freq,freq,freq},
|
|
//! \brief memory
|
|
//! \brief Pointer to Calibration table for RX gains
|
|
.rx_gain_calib_table=NULL,
|
|
//! mode for rxgain (ExpressMIMO2)
|
|
.rxg_mode={0},
|
|
//! \brief Gain for RX in dB.
|
|
//! index: [0..rx_num_channels]
|
|
.rx_gain={rxGain,rxGain,rxGain,rxGain},
|
|
//! \brief Gain offset (for calibration) in dB
|
|
//! index: [0..rx_num_channels]
|
|
.rx_gain_offset={0},
|
|
//! gain for TX in dB
|
|
.tx_gain={txGain,txGain,txGain,txGain},
|
|
//! RX bandwidth in Hz
|
|
.rx_bw=filterBand,
|
|
//! TX bandwidth in Hz
|
|
.tx_bw=filterBand,
|
|
//! clock source
|
|
.clock_source=external,//internal gpsdo external
|
|
//! timing_source
|
|
.time_source=internal, //internal gpsdo external
|
|
//! Manual SDR IP address
|
|
.sdr_addrs=usrp_addrs,
|
|
//! Auto calibration flag
|
|
.autocal={0},
|
|
//! rf devices work with x bits iqs when oai have its own iq format
|
|
//! the two following parameters are used to convert iqs
|
|
.iq_txshift=0,
|
|
.iq_rxrescale=0,
|
|
//! Configuration file for LMS7002M
|
|
.configFilename="",
|
|
//! remote IP/MAC addr for Ethernet interface
|
|
.remote_addr="",
|
|
//! remote port number for Ethernet interface
|
|
.remote_port=0,
|
|
//! local IP/MAC addr for Ethernet interface (eNB/BBU, UE)
|
|
.my_addr=0,
|
|
//! local port number for Ethernet interface (eNB/BBU, UE)
|
|
.my_port=0,
|
|
//! record player configuration, definition in record_player.h
|
|
.recplay_mode=0,
|
|
.recplay_conf=NULL,
|
|
//! number of samples per tti
|
|
.samples_per_tti=0,
|
|
//! check for threequarter sampling rate
|
|
.threequarter_fs=0,
|
|
};
|
|
//-----------------------
|
|
openair0_device rfdevice= {
|
|
/*!tx write thread*/
|
|
//.write_thread={0},
|
|
/*!brief Module ID of this device */
|
|
.Mod_id=0,
|
|
/*!brief Component Carrier ID of this device */
|
|
.CC_id=0,
|
|
/*!brief Type of this device */
|
|
.type=NONE_DEV,
|
|
/*!brief Transport protocol type that the device supports (in case I/Q samples need to be transported) */
|
|
.transp_type=NONE_TP,
|
|
/*!brief Type of the device's host (RAU/RRU) */
|
|
.host_type=MIN_HOST_TYPE,
|
|
/* !brief RF frontend parameters set by application */
|
|
.openair0_cfg=NULL, //set by device_init
|
|
/* !brief ETH params set by application */
|
|
.eth_params=NULL,
|
|
//! record player data, definition in record_player.h
|
|
.recplay_state=NULL,
|
|
/* !brief Indicates if device already initialized */
|
|
.is_init=0,
|
|
/*!brief Can be used by driver to hold internal structure*/
|
|
.priv=NULL,
|
|
/* Functions API, which are called by the application*/
|
|
/*! \brief Called to start the transceiver. Return 0 if OK, < 0 if error
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
*/
|
|
.trx_start_func=NULL,
|
|
|
|
/*! \brief Called to configure the device
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
*/
|
|
.trx_config_func=NULL,
|
|
|
|
/*! \brief Called to send a request message between RAU-RRU on control port
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
@param msg pointer to the message structure passed between RAU-RRU
|
|
@param msg_len length of the message
|
|
*/
|
|
.trx_ctlsend_func=NULL,
|
|
|
|
/*! \brief Called to receive a reply message between RAU-RRU on control port
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
@param msg pointer to the message structure passed between RAU-RRU
|
|
@param msg_len length of the message
|
|
*/
|
|
.trx_ctlrecv_func=NULL,
|
|
|
|
/*! \brief Called to send samples to the RF target
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
@param timestamp The timestamp at whicch the first sample MUST be sent
|
|
@param buff Buffer which holds the samples (2 dimensional)
|
|
@param nsamps number of samples to be sent
|
|
@param number of antennas
|
|
@param flags flags must be set to TRUE if timestamp parameter needs to be applied
|
|
*/
|
|
.trx_write_func=NULL,
|
|
|
|
/*! \brief Called to send samples to the RF target
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
@param timestamp The timestamp at whicch the first sample MUST be sent
|
|
@param buff Buffer which holds the samples (1 dimensional)
|
|
@param nsamps number of samples to be sent
|
|
@param antenna_id index of the antenna if the device has multiple anteannas
|
|
@param flags flags must be set to TRUE if timestamp parameter needs to be applied
|
|
*/
|
|
.trx_write_func2=NULL,
|
|
|
|
/*! \brief Receive samples from hardware.
|
|
* Read \ref nsamps samples from each channel to buffers. buff[0] is the array for
|
|
* the first channel. *ptimestamp is the time at which the first sample
|
|
* was received.
|
|
* \param device the hardware to use
|
|
* \param[out] ptimestamp the time at which the first sample was received.
|
|
* \param[out] buff An array of pointers to buffers for received samples. The buffers must be large enough to hold the number of samples \ref nsamps.
|
|
* \param nsamps Number of samples. One sample is 2 byte I + 2 byte Q => 4 byte.
|
|
* \param num_antennas number of antennas from which to receive samples
|
|
* \returns the number of sample read
|
|
*/
|
|
|
|
.trx_read_func=NULL,
|
|
|
|
/*! \brief Receive samples from hardware, this version provides a single antenna at a time and returns.
|
|
* Read \ref nsamps samples from each channel to buffers. buff[0] is the array for
|
|
* the first channel. *ptimestamp is the time at which the first sample
|
|
* was received.
|
|
* \param device the hardware to use
|
|
* \param[out] ptimestamp the time at which the first sample was received.
|
|
* \param[out] buff A pointers to a buffer for received samples. The buffer must be large enough to hold the number of samples \ref nsamps.
|
|
* \param nsamps Number of samples. One sample is 2 byte I + 2 byte Q => 4 byte.
|
|
* \param antenna_id Index of antenna from which samples were received
|
|
* \returns the number of sample read
|
|
*/
|
|
.trx_read_func2=NULL,
|
|
|
|
/*! \brief print the device statistics
|
|
* \param device the hardware to use
|
|
* \returns 0 on success
|
|
*/
|
|
/*! \brief print the device statistics
|
|
* \param device the hardware to use
|
|
* \returns 0 on success
|
|
*/
|
|
.trx_get_stats_func=NULL,
|
|
|
|
/*! \brief Reset device statistics
|
|
* \param device the hardware to use
|
|
* \returns 0 in success
|
|
*/
|
|
.trx_reset_stats_func=NULL,
|
|
|
|
/*! \brief Terminate operation of the transceiver -- free all associated resources
|
|
* \param device the hardware to use
|
|
*/
|
|
.trx_end_func=NULL,
|
|
|
|
/*! \brief Stop operation of the transceiver
|
|
*/
|
|
.trx_stop_func=NULL,
|
|
|
|
/* Functions API related to UE*/
|
|
|
|
/*! \brief Set RX feaquencies
|
|
* \param device the hardware to use
|
|
* \param openair0_cfg RF frontend parameters set by application
|
|
* \returns 0 in success
|
|
*/
|
|
.trx_set_freq_func=NULL,
|
|
|
|
/*! \brief Set gains
|
|
* \param device the hardware to use
|
|
* \param openair0_cfg RF frontend parameters set by application
|
|
* \returns 0 in success
|
|
*/
|
|
.trx_set_gains_func=NULL,
|
|
|
|
/*! \brief RRU Configuration callback
|
|
* \param idx RU index
|
|
* \param arg pointer to capabilities or configuration
|
|
*/
|
|
.configure_rru=NULL,
|
|
/*! \brief Pointer to generic RRU private information
|
|
*/
|
|
.thirdparty_priv=NULL,
|
|
.thirdparty_init=NULL,
|
|
/*! \brief Callback for Third-party RRU Cleanup routine
|
|
\param device the hardware configuration to use
|
|
*/
|
|
.thirdparty_cleanup=NULL,
|
|
|
|
/*! \brief Callback for Third-party start streaming routine
|
|
\param device the hardware configuration to use
|
|
*/
|
|
.thirdparty_startstreaming=NULL,
|
|
|
|
/*! \brief RRU Configuration callback
|
|
* \param idx RU index
|
|
* \param arg pointer to capabilities or configuration
|
|
*/
|
|
.trx_write_init=NULL,
|
|
/* \brief Get internal parameter
|
|
* \param id parameter to get
|
|
* \return a pointer to the parameter
|
|
*/
|
|
.get_internal_parameter=NULL,
|
|
};
|
|
|
|
openair0_device_load(&rfdevice,&openair0_cfg);
|
|
|
|
void ** samplesRx = (void **)malloc16(antennas* sizeof(c16_t *) );
|
|
void ** samplesTx = (void **)malloc16(antennas* sizeof(c16_t *) );
|
|
|
|
int fd=open(getenv("rftestInputFile"),O_RDONLY);
|
|
AssertFatal(fd>=0,"%s",strerror(errno));
|
|
|
|
for (int i=0; i<antennas; i++) {
|
|
samplesRx[i] = (int32_t *)malloc16_clear( DFT*sizeof(c16_t) );
|
|
samplesTx[i] = (int32_t *)malloc16_clear( DFT*sizeof(c16_t) );
|
|
}
|
|
|
|
CalibrationInitScope(samplesRx, &rfdevice);
|
|
openair0_timestamp timestamp=0;
|
|
rfdevice.trx_start_func(&rfdevice);
|
|
|
|
while(!oai_exit) {
|
|
for (int i=0; i<antennas; i++)
|
|
read(fd, samplesTx[i], DFT*sizeof(c16_t));
|
|
rfdevice.trx_read_func(&rfdevice, ×tamp, samplesRx, DFT, antennas);
|
|
rfdevice.trx_write_func(&rfdevice, timestamp + TxAdvanceInDFTSize * DFT, samplesTx, DFT, antennas, 0);
|
|
}
|
|
|
|
return 0;
|
|
}
|