5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

enb,nsa: refactor NR RRC/cell config parsing

Browse Source 
this allows to access all cell-related params from within RRC
master
Andre Puschmann 3 years ago
parent feec3c5905
commit 802b22ac91
12 changed files with 154 additions and 110 deletions
Show Stats Download Patch File Download Diff File

12
lib/include/srsran/interfaces/gnb_rrc_nr_interfaces.h
Unescape Escape View File

@ -12,8 +12,10 @@
#ifndef SRSRAN_GNB_RRC_NR_INTERFACES_H
#define SRSRAN_GNB_RRC_NR_INTERFACES_H
#include "srsenb/hdr/phy/phy_interfaces.h"
#include "srsran/asn1/ngap.h"
#include "srsran/common/byte_buffer.h"
namespace srsenb {
class rrc_interface_ngap_nr
@ -30,6 +32,16 @@ public:
virtual void write_dl_info(uint16_t rnti, srsran::unique_byte_buffer_t sdu) = 0;
};
// Cell/Sector configuration for NR cells
struct rrc_cell_cfg_nr_t {
phy_cell_cfg_nr_t phy_cell; // already contains all PHY-related parameters (i.e. RF port, PCI, etc.)
uint32_t tac; // Tracking area code
uint32_t dl_arfcn; // DL freq already included in phy_cell
uint32_t ul_arfcn; // UL freq also in phy_cell
};
typedef std::vector<rrc_cell_cfg_nr_t> rrc_cell_list_nr_t;
} // namespace srsenb
#endif // SRSRAN_GNB_RRC_NR_INTERFACES_H

2
srsenb/hdr/enb.h
Unescape Escape View File

@ -148,7 +148,7 @@ public:
private:
const static int ENB_POOL_SIZE = 1024 * 10;
int parse_args(const all_args_t& args_, rrc_cfg_t& rrc_cfg);
int parse_args(const all_args_t& args_, rrc_cfg_t& rrc_cfg_, rrc_nr_cfg_t& rrc_cfg_nr_);
srslog::sink& log_sink;
srslog::basic_logger& enb_log;

12
srsenb/hdr/stack/rrc/rrc_config.h
Unescape Escape View File

@ -64,12 +64,12 @@ struct rrc_cfg_t {
bool meas_cfg_present = false;
srsran_cell_t cell;
cell_list_t cell_list;
cell_list_t cell_list_nr;
uint32_t max_mac_dl_kos;
uint32_t max_mac_ul_kos;
uint32_t rlf_release_timer_ms;
srb_cfg_t srb1_cfg;
srb_cfg_t srb2_cfg;
uint32_t num_nr_cells = 0; /// number of configured NR cells (used to configure RF)
uint32_t max_mac_dl_kos;
uint32_t max_mac_ul_kos;
uint32_t rlf_release_timer_ms;
srb_cfg_t srb1_cfg;
srb_cfg_t srb2_cfg;
};
constexpr uint32_t UE_PCELL_CC_IDX = 0;

3
srsenb/hdr/stack/rrc/rrc_config_nr.h
Unescape Escape View File

@ -14,6 +14,7 @@
#define SRSRAN_RRC_CONFIG_NR_H
#include "srsran/asn1/rrc_nr.h"
#include "srsran/interfaces/gnb_rrc_nr_interfaces.h"
#include "srsue/hdr/phy/phy_common.h"
namespace srsenb {
@ -34,7 +35,7 @@ struct rrc_nr_cfg_t {
uint32_t nof_sibs;
rrc_nr_cfg_sr_t sr_cfg;
rrc_cfg_cqi_t cqi_cfg;
srsran_cell_t cell;
rrc_cell_list_nr_t cell_list;
std::string log_level;
uint32_t log_hex_limit;

8
srsenb/src/enb.cc
Unescape Escape View File

@ -43,7 +43,7 @@ int enb::init(const all_args_t& args_)
enb_log.info("%s", get_build_string().c_str());
// Validate arguments
if (parse_args(args_, rrc_cfg)) {
if (parse_args(args_, rrc_cfg, rrc_nr_cfg)) {
srsran::console("Error processing arguments.\n");
return SRSRAN_ERROR;
}
@ -63,7 +63,7 @@ int enb::init(const all_args_t& args_)
}
std::unique_ptr<gnb_stack_nr> tmp_nr_stack;
if (not rrc_cfg.cell_list_nr.empty()) {
if (not rrc_nr_cfg.cell_list.empty()) {
// add NR stack
tmp_nr_stack.reset(new gnb_stack_nr(log_sink));
if (tmp_nr_stack == nullptr) {
@ -175,11 +175,11 @@ void enb::stop()
}
}
int enb::parse_args(const all_args_t& args_, rrc_cfg_t& _rrc_cfg)
int enb::parse_args(const all_args_t& args_, rrc_cfg_t& rrc_cfg_, rrc_nr_cfg_t& rrc_cfg_nr_)
{
// set member variable
args = args_;
return enb_conf_sections::parse_cfg_files(&args, &_rrc_cfg, &phy_cfg);
return enb_conf_sections::parse_cfg_files(&args, &rrc_cfg_, &rrc_cfg_nr_, &phy_cfg);
}
void enb::start_plot()

184
srsenb/src/enb_cfg_parser.cc
Unescape Escape View File

@ -635,7 +635,7 @@ int field_qci::parse(libconfig::Setting& root)
namespace rr_sections {
int parse_rr(all_args_t* args_, rrc_cfg_t* rrc_cfg_)
int parse_rr(all_args_t* args_, rrc_cfg_t* rrc_cfg_, rrc_nr_cfg_t* rrc_nr_cfg_)
{
/* Transmission mode config section */
if (args_->enb.transmission_mode < 1 || args_->enb.transmission_mode > 4) {
@ -750,7 +750,7 @@ int parse_rr(all_args_t* args_, rrc_cfg_t* rrc_cfg_)
bool nr_cell_cnfg_present = false;
parser::section nr_cell_cnfg("nr_cell_list");
nr_cell_cnfg.set_optional(&nr_cell_cnfg_present);
nr_cell_cnfg.add_field(new rr_sections::nr_cell_list_section(args_, rrc_cfg_));
nr_cell_cnfg.add_field(new rr_sections::nr_cell_list_section(args_, rrc_nr_cfg_, rrc_cfg_));
// Run parser with two sections
parser p(args_->enb_files.rr_config);
@ -894,46 +894,54 @@ static int parse_cell_list(all_args_t* args, rrc_cfg_t* rrc_cfg, Setting& root)
return SRSRAN_SUCCESS;
}
static int parse_nr_cell_list(all_args_t* args, rrc_cfg_t* rrc_cfg, Setting& root)
static int parse_nr_cell_list(all_args_t* args, rrc_nr_cfg_t* rrc_cfg_nr, rrc_cfg_t* rrc_cfg_eutra, Setting& root)
{
for (uint32_t n = 0; n < (uint32_t)root.getLength(); ++n) {
cell_cfg_t cell_cfg = {};
rrc_cell_cfg_nr_t cell_cfg = {};
auto& cellroot = root[n];
parse_opt_field(cell_cfg.rf_port, cellroot, "rf_port");
HANDLEPARSERCODE(parse_required_field(cell_cfg.cell_id, cellroot, "cell_id"));
parse_opt_field(cell_cfg.phy_cell.rf_port, cellroot, "rf_port");
HANDLEPARSERCODE(parse_required_field(cell_cfg.phy_cell.carrier.pci, cellroot, "pci"));
HANDLEPARSERCODE(parse_required_field(cell_cfg.phy_cell.cell_id, cellroot, "cell_id"));
HANDLEPARSERCODE(parse_required_field(cell_cfg.phy_cell.root_seq_idx, cellroot, "root_seq_idx"));
HANDLEPARSERCODE(parse_required_field(cell_cfg.tac, cellroot, "tac"));
HANDLEPARSERCODE(parse_required_field(cell_cfg.pci, cellroot, "pci"));
cell_cfg.pci = cell_cfg.pci % SRSRAN_NOF_NID_NR;
HANDLEPARSERCODE(parse_required_field(cell_cfg.dl_earfcn, cellroot, "dl_arfcn"));
cell_cfg.phy_cell.carrier.pci = cell_cfg.phy_cell.carrier.pci % SRSRAN_NOF_NID_NR;
HANDLEPARSERCODE(parse_required_field(cell_cfg.dl_arfcn, cellroot, "dl_arfcn"));
// frequencies get derived from ARFCN
// Add further cell-specific parameters
// TODO: Add further cell-specific parameters
rrc_cfg->cell_list_nr.push_back(cell_cfg);
rrc_cfg_nr->cell_list.push_back(cell_cfg);
}
// Configuration check
for (auto it = rrc_cfg->cell_list_nr.begin(); it != rrc_cfg->cell_list_nr.end(); ++it) {
for (auto it = rrc_cfg_nr->cell_list.begin(); it != rrc_cfg_nr->cell_list.end(); ++it) {
// check against NR cells
for (auto it2 = it + 1; it2 != rrc_cfg->cell_list_nr.end(); it2++) {
for (auto it2 = it + 1; it2 != rrc_cfg_nr->cell_list.end(); it2++) {
// Check RF port is not repeated
if (it->rf_port == it2->rf_port) {
if (it->phy_cell.rf_port == it2->phy_cell.rf_port) {
ERROR("Repeated RF port for multiple cells");
return SRSRAN_ERROR;
}
// Check cell ID is not repeated
if (it->cell_id == it2->cell_id) {
// Check cell PCI not repeated
if (it->phy_cell.carrier.pci == it2->phy_cell.carrier.pci) {
ERROR("Repeated cell PCI");
return SRSRAN_ERROR;
}
// Check cell PCI and cell ID is not repeated
if (it->phy_cell.cell_id == it2->phy_cell.cell_id) {
ERROR("Repeated Cell identifier");
return SRSRAN_ERROR;
}
}
// also check RF port against EUTRA cells
for (auto it_eutra = rrc_cfg->cell_list.begin(); it_eutra != rrc_cfg->cell_list.end(); ++it_eutra) {
for (auto it_eutra = rrc_cfg_eutra->cell_list.begin(); it_eutra != rrc_cfg_eutra->cell_list.end(); ++it_eutra) {
// Check RF port is not repeated
if (it->rf_port == it_eutra->rf_port) {
if (it->phy_cell.rf_port == it_eutra->rf_port) {
ERROR("Repeated RF port for multiple cells");
return SRSRAN_ERROR;
}
@ -951,7 +959,7 @@ int cell_list_section::parse(libconfig::Setting& root)
int nr_cell_list_section::parse(libconfig::Setting& root)
{
HANDLEPARSERCODE(parse_nr_cell_list(args, rrc_cfg, root));
HANDLEPARSERCODE(parse_nr_cell_list(args, nr_rrc_cfg, eutra_rrc_cfg, root));
return 0;
}
@ -990,7 +998,7 @@ int parse_cell_cfg(all_args_t* args_, srsran_cell_t* cell)
return SRSRAN_SUCCESS;
}
int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_)
int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, rrc_nr_cfg_t* rrc_nr_cfg_, phy_cfg_t* phy_cfg_)
{
// Parse config files
srsran_cell_t cell_common_cfg = {};
@ -1022,7 +1030,7 @@ int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_)
}
try {
if (rr_sections::parse_rr(args_, rrc_cfg_) != SRSRAN_SUCCESS) {
if (rr_sections::parse_rr(args_, rrc_cfg_, rrc_nr_cfg_) != SRSRAN_SUCCESS) {
fprintf(stderr, "Error parsing Radio Resources configuration\n");
return SRSRAN_ERROR;
}
@ -1048,7 +1056,22 @@ int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_)
}
// Set fields derived from others, and check for correctness of the parsed configuration
return enb_conf_sections::set_derived_args(args_, rrc_cfg_, phy_cfg_, cell_common_cfg);
if (enb_conf_sections::set_derived_args(args_, rrc_cfg_, phy_cfg_, cell_common_cfg) != SRSRAN_SUCCESS) {
fprintf(stderr, "Error deriving EUTRA cell parameters\n");
return SRSRAN_ERROR;
}
// do the same for NR
if (enb_conf_sections::set_derived_args_nr(args_, rrc_nr_cfg_, phy_cfg_) != SRSRAN_SUCCESS) {
fprintf(stderr, "Error deriving NR cell parameters\n");
return SRSRAN_ERROR;
}
// update number of NR cells
rrc_cfg_->num_nr_cells = rrc_nr_cfg_->cell_list.size();
args_->rf.nof_carriers = rrc_cfg_->cell_list.size() + rrc_nr_cfg_->cell_list.size();
return SRSRAN_SUCCESS;
}
int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_, const srsran_cell_t& cell_cfg_)
@ -1155,59 +1178,6 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
phy_cfg_->phy_cell_cfg.push_back(phy_cell_cfg);
}
// Use helper class to derive NR carrier parameters
srsran::srsran_band_helper band_helper;
// Create NR dedicated cell configuration from RRC configuration
for (auto it = rrc_cfg_->cell_list_nr.begin(); it != rrc_cfg_->cell_list_nr.end(); ++it) {
auto& cfg = *it;
phy_cell_cfg_nr_t phy_cell_cfg = {};
phy_cell_cfg.carrier.max_mimo_layers = cell_cfg_.nof_ports;
switch (cell_cfg_.nof_prb) {
case 25:
phy_cell_cfg.carrier.nof_prb = 25;
break;
case 50:
phy_cell_cfg.carrier.nof_prb = 52;
break;
case 100:
phy_cell_cfg.carrier.nof_prb = 106;
break;
default:
ERROR("The only accepted number of PRB is: 25, 50, 100");
return SRSRAN_ERROR;
}
phy_cell_cfg.carrier.pci = cfg.pci;
phy_cell_cfg.cell_id = cfg.cell_id;
phy_cell_cfg.root_seq_idx = cfg.root_seq_idx;
phy_cell_cfg.rf_port = cfg.rf_port;
phy_cell_cfg.num_ra_preambles =
rrc_cfg_->sibs[1].sib2().rr_cfg_common.rach_cfg_common.preamb_info.nof_ra_preambs.to_number();
if (cfg.dl_freq_hz > 0) {
phy_cell_cfg.dl_freq_hz = cfg.dl_freq_hz;
} else {
phy_cell_cfg.dl_freq_hz = band_helper.nr_arfcn_to_freq(cfg.dl_earfcn);
}
if (cfg.ul_freq_hz > 0) {
phy_cell_cfg.ul_freq_hz = cfg.ul_freq_hz;
} else {
// auto-detect UL frequency
if (cfg.ul_earfcn == 0) {
// derive UL ARFCN from given DL ARFCN
cfg.ul_earfcn = band_helper.get_ul_arfcn_from_dl_arfcn(cfg.dl_earfcn);
if (cfg.ul_earfcn == 0) {
ERROR("Can't derive UL ARFCN from DL ARFCN %d", cfg.dl_earfcn);
return SRSRAN_ERROR;
}
}
phy_cell_cfg.ul_freq_hz = band_helper.nr_arfcn_to_freq(cfg.ul_earfcn);
}
phy_cfg_->phy_cell_cfg_nr.push_back(phy_cell_cfg);
}
if (args_->enb.transmission_mode == 1) {
phy_cfg_->pdsch_cnfg.p_b = 0; // Default TM1
rrc_cfg_->sibs[1].sib2().rr_cfg_common.pdsch_cfg_common.p_b = 0;
@ -1318,7 +1288,6 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
}
// Patch certain args that are not exposed yet
args_->rf.nof_carriers = rrc_cfg_->cell_list.size() + rrc_cfg_->cell_list_nr.size();
args_->rf.nof_antennas = args_->enb.nof_ports;
// MAC needs to know the cell bandwidth to dimension softbuffers
@ -1344,6 +1313,69 @@ int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_
return SRSRAN_SUCCESS;
}
/**
* @brief Set the derived args for the NR RRC and PHY config
*
* Mainly configures the RRC parameter based on the arguments and config files
* read. Since for NSA we are still using a commong PHY between EUTRA and NR
* the PHY configuration is also updated accordingly.
*
* @param args_
* @param nr_rrc_cfg
* @param phy_cfg_
* @return int
*/
int set_derived_args_nr(all_args_t* args_, rrc_nr_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_)
{
// Use helper class to derive NR carrier parameters
srsran::srsran_band_helper band_helper;
// Create NR dedicated cell configuration from RRC configuration
for (auto it = rrc_cfg_->cell_list.begin(); it != rrc_cfg_->cell_list.end(); ++it) {
auto& cfg = *it;
cfg.phy_cell.carrier.max_mimo_layers = args_->enb.nof_ports;
// NR cells have the same bandwidth as EUTRA cells, adjust PRB sizes
switch (args_->enb.n_prb) {
case 25:
cfg.phy_cell.carrier.nof_prb = 25;
break;
case 50:
cfg.phy_cell.carrier.nof_prb = 52;
break;
case 100:
cfg.phy_cell.carrier.nof_prb = 106;
break;
default:
ERROR("The only accepted number of PRB is: 25, 50, 100");
return SRSRAN_ERROR;
}
// phy_cell_cfg.root_seq_idx = cfg.root_seq_idx;
cfg.phy_cell.num_ra_preambles = 52; // FIXME: read from config
if (cfg.phy_cell.dl_freq_hz == 0) {
cfg.phy_cell.dl_freq_hz = band_helper.nr_arfcn_to_freq(cfg.dl_arfcn);
}
if (cfg.phy_cell.ul_freq_hz == 0) {
// auto-detect UL frequency
if (cfg.ul_arfcn == 0) {
// derive UL ARFCN from given DL ARFCN
cfg.ul_arfcn = band_helper.get_ul_arfcn_from_dl_arfcn(cfg.dl_arfcn);
if (cfg.ul_arfcn == 0) {
ERROR("Can't derive UL ARFCN from DL ARFCN %d", cfg.dl_arfcn);
return SRSRAN_ERROR;
}
}
cfg.phy_cell.ul_freq_hz = band_helper.nr_arfcn_to_freq(cfg.ul_arfcn);
}
phy_cfg_->phy_cell_cfg_nr.push_back(cfg.phy_cell);
}
return SRSRAN_SUCCESS;
}
} // namespace enb_conf_sections
namespace sib_sections {

19
srsenb/src/enb_cfg_parser.h
Unescape Escape View File

@ -10,8 +10,8 @@
*
*/
#ifndef ENB_CFG_PARSER_SIB1_H
#define ENB_CFG_PARSER_SIB1_H
#ifndef ENB_CFG_PARSER_H
#define ENB_CFG_PARSER_H
#include "srsenb/hdr/parser.h"
#include <iostream>
@ -22,6 +22,7 @@
#include <string>
#include "srsenb/hdr/stack/rrc/rrc.h"
#include "srsenb/hdr/stack/rrc/rrc_config_nr.h"
#include "srsran/asn1/asn1_utils.h"
namespace srsenb {
@ -37,8 +38,9 @@ bool sib_is_present(const asn1::rrc::sched_info_list_l& l, asn1::rrc::sib_type_e
namespace enb_conf_sections {
int parse_cell_cfg(all_args_t* args_, srsran_cell_t* cell);
int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_);
int parse_cfg_files(all_args_t* args_, rrc_cfg_t* rrc_cfg_, rrc_nr_cfg_t* rrc_cfg_nr_, phy_cfg_t* phy_cfg_);
int set_derived_args(all_args_t* args_, rrc_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_, const srsran_cell_t& cell_cfg_);
int set_derived_args_nr(all_args_t* args_, rrc_nr_cfg_t* rrc_cfg_, phy_cfg_t* phy_cfg_);
} // namespace enb_conf_sections
@ -85,15 +87,18 @@ private:
class nr_cell_list_section final : public parser::field_itf
{
public:
explicit nr_cell_list_section(all_args_t* all_args_, rrc_cfg_t* rrc_cfg_) : args(all_args_), rrc_cfg(rrc_cfg_) {}
explicit nr_cell_list_section(all_args_t* all_args_, rrc_nr_cfg_t* nr_rrc_cfg_, rrc_cfg_t* eutra_rrc_cfg_) :
args(all_args_), nr_rrc_cfg(nr_rrc_cfg_), eutra_rrc_cfg(eutra_rrc_cfg_)
{}
int parse(Setting& root) override;
const char* get_name() override { return "nr_cell_list"; }
private:
rrc_cfg_t* rrc_cfg;
all_args_t* args;
rrc_nr_cfg_t* nr_rrc_cfg;
rrc_cfg_t* eutra_rrc_cfg;
all_args_t* args;
};
} // namespace rr_sections
@ -573,4 +578,4 @@ private:
};
} // namespace srsenb
#endif
#endif // ENB_CFG_PARSER_H

2
srsenb/src/stack/rrc/rrc_endc.cc
Unescape Escape View File

@ -169,7 +169,7 @@ bool rrc::ue::rrc_endc::fill_conn_recfg(asn1::rrc::rrc_conn_recfg_r8_ies_s* conn
void rrc::ue::rrc_endc::handle_eutra_capabilities(const asn1::rrc::ue_eutra_cap_s& eutra_caps)
{
// skip any further checks if eNB runs without NR cells
if (rrc_enb->cfg.cell_list_nr.empty()) {
if (rrc_enb->cfg.num_nr_cells == 0) {
Debug("Skipping UE capabilities. No NR cell configured.");
return;
}

10
srsenb/src/stack/rrc/rrc_nr.cc
Unescape Escape View File

@ -110,14 +110,6 @@ rrc_nr_cfg_t rrc_nr::update_default_cfg(const rrc_nr_cfg_t& current)
cfg_default.mib.dmrs_type_a_position.value = mib_s::dmrs_type_a_position_opts::pos2;
cfg_default.mib.sys_frame_num.from_number(0);
cfg_default.cell.nof_prb = 25;
cfg_default.cell.nof_ports = 1;
cfg_default.cell.id = 0;
cfg_default.cell.cp = SRSRAN_CP_NORM;
cfg_default.cell.frame_type = SRSRAN_FDD;
cfg_default.cell.phich_length = SRSRAN_PHICH_NORM;
cfg_default.cell.phich_resources = SRSRAN_PHICH_R_1;
// Fill SIB1
cfg_default.sib1.cell_access_related_info.plmn_id_list.resize(1);
cfg_default.sib1.cell_access_related_info.plmn_id_list[0].plmn_id_list.resize(1);
@ -226,7 +218,7 @@ void rrc_nr::config_mac()
logger.info("Allocating %d PRBs for PUCCH", cell_cfg.nrb_pucch);
// Copy Cell configuration
cell_cfg.cell = cfg.cell;
// cell_cfg.cell = cfg.cell;
// Configure MAC/scheduler
mac->cell_cfg(sched_cells_cfg);

3
srsenb/src/stack/rrc/rrc_ue.cc
Unescape Escape View File

@ -377,8 +377,7 @@ void rrc::ue::parse_ul_dcch(uint32_t lcid, srsran::unique_byte_buffer_t pdu)
break;
case ul_dcch_msg_type_c::c1_c_::types::ue_cap_info:
if (handle_ue_cap_info(&ul_dcch_msg.msg.c1().ue_cap_info()) == SRSRAN_SUCCESS) {
if (not parent->cfg.cell_list_nr.empty() && endc_handler->is_endc_supported() &&
state == RRC_STATE_WAIT_FOR_UE_CAP_INFO) {
if (endc_handler != nullptr && endc_handler->is_endc_supported() && state == RRC_STATE_WAIT_FOR_UE_CAP_INFO) {
// request EUTRA-NR and NR capabilities as well
send_ue_cap_enquiry({asn1::rrc::rat_type_opts::options::eutra_nr, asn1::rrc::rat_type_opts::options::nr});
state = RRC_STATE_WAIT_FOR_UE_CAP_INFO_ENDC; // avoid endless loop

2
srsenb/test/rrc/CMakeLists.txt
Unescape Escape View File

@ -7,7 +7,7 @@
#
add_library(test_helpers test_helpers.cc)
target_link_libraries(test_helpers srsenb_rrc srsenb_common rrc_asn1 s1ap_asn1 srsran_common enb_cfg_parser ${LIBCONFIGPP_LIBRARIES})
target_link_libraries(test_helpers srsenb_rrc srsenb_common rrc_asn1 rrc_nr_asn1 s1ap_asn1 srsran_common enb_cfg_parser ${LIBCONFIGPP_LIBRARIES})
add_executable(rrc_nr_test rrc_nr_test.cc)
target_link_libraries(rrc_nr_test srsgnb_rrc srsran_common rrc_nr_asn1 ${ATOMIC_LIBS})

7
srsenb/test/rrc/test_helpers.cc
Unescape Escape View File

@ -39,7 +39,9 @@ int parse_default_cfg_phy(rrc_cfg_t* rrc_cfg, phy_cfg_t* phy_cfg, srsenb::all_ar
args.general.rrc_inactivity_timer = 60000;
return enb_conf_sections::parse_cfg_files(&args, rrc_cfg, phy_cfg);
rrc_nr_cfg_t rrc_cfg_nr;
return enb_conf_sections::parse_cfg_files(&args, rrc_cfg, &rrc_cfg_nr, phy_cfg);
}
int parse_default_cfg(rrc_cfg_t* rrc_cfg, srsenb::all_args_t& args)
@ -65,8 +67,9 @@ int parse_default_cfg(rrc_cfg_t* rrc_cfg, srsenb::all_args_t& args)
args.general.rrc_inactivity_timer = 60000;
phy_cfg_t phy_cfg;
rrc_nr_cfg_t rrc_cfg_nr;
return enb_conf_sections::parse_cfg_files(&args, rrc_cfg, &phy_cfg);
return enb_conf_sections::parse_cfg_files(&args, rrc_cfg, &rrc_cfg_nr, &phy_cfg);
}
int bring_rrc_to_reconf_state(srsenb::rrc& rrc, srsran::timer_handler& timers, uint16_t rnti)

Write Preview
Loading…
Cancel
Save