fixeria
/
srsRAN
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactored and commented SRSUE's Intra measure component

This commit is contained in:
Xavier Arteaga 2020-02-12 16:50:26 +01:00 committed by Xavier Arteaga
parent 8f6dd184be
commit 344016ef0a
4 changed files with 226 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/src/phy/sync/refsignal_dl_sync.c
View File

@ -30,19 +30,19 @@
* Constants
* --------------
* These constants have been optimized for passing scell_search_test for a number of scenarios.
* - 6 PRB. 6 cells distributed uniformly 10ms delay
* - 6 PRB. 6 cells distributed uniformly 10ms delay. Brut-forced search.
* srsue/test/phy/scell_search_test --duration=5 --cell.nof_prb=6 --active_cell_list=all
* --simulation_cell_list=1,2,3,4,5,6 --channel_period_s=30 --channel.hst.fd=750 --channel.delay_max=1000
* --simulation_cell_list=1,2,3,4,5,6 --channel_period_s=30 --channel.hst.fd=750 --channel.delay_max=10000
*
* - 6 PRB. 6 cells distributed uniformly 10ms delay
* - 6 PRB. 6 cells distributed uniformly 10ms delay. With PCI set list.
* srsue/test/phy/scell_search_test --duration=30 --cell.nof_prb=6 --active_cell_list=2,3,4,5,6
* --simulation_cell_list=1,2,3,4,5,6 --channel_period_s=30 --channel.hst.fd=750 --channel.delay_max=10000
*
* - 6 PRB. 6 cell PSS, SSS overlapped:
* - 6 PRB. 6 cell PSS, SSS overlapped. Brut-forced search.
* srsue/test/phy/scell_search_test --duration=30 --cell.nof_prb=6 --active_cell_list=all
* --simulation_cell_list=1,2,3,4,5,6 --channel_period_s=30 --channel.hst.fd=750 --channel.delay_max=0
*
* - 100 PRB, 6 cell, distributed around 1ms
* - 100 PRB, 6 cell, distributed around 1ms. With PCI set list.
* srsue/test/phy/scell_search_test --duration=30 --cell.nof_prb=100 --active_cell_list=2,3,4,5,6
* --simulation_cell_list=1,2,3,4,5,6 --channel_period_s=30 --channel.hst.fd=750 --channel.delay_max=1000
*/

166
srsue/hdr/phy/scell/intra_measure.h
View File

@ -34,45 +34,163 @@ namespace scell {
// Class to perform intra-frequency measurements
class intra_measure : public thread
{
/*
* The intra-cell measurment has 5 different states:
* - idle: it has been initiated and it is waiting to get configured to start capturing samples. From any state
* except quit can transition to idle.
* - wait: waits for at least intra_freq_meas_period_ms since last receive start and goes to receive.
* - receive: captures base-band samples for intra_freq_meas_len_ms and goes to measure.
* - measure: enables the inner thread to start the measuring function and goes to wait.
* - quit: stops the inner thread and quits. Transition from any state measure state.
*
* FSM abstraction:
*
* +------+ set_cells_to_meas +------+ intra_freq_meas_period_ms +---------+
* | Idle | --------------------->| Wait |------------------------------>| Receive |
* +------+ +------+ +---------+
* ^ ^ | stop +------+
* | | | ----->| Quit |
* init +---------+ intra_freq_meas_len_ms | +------+
* meas_stop | Measure |<----------------------------------+
* +---------+
*/
public:
/**
* Constructor
*/
intra_measure();
/**
* Destructor
*/
~intra_measure();
void init(phy_common* common, rrc_interface_phy_lte* rrc, srslte::log* log_h);
void stop();
void set_primary_cell(uint32_t earfcn, srslte_cell_t cell);
void set_cells_to_meas(const std::set<uint32_t>& pci);
void meas_stop();
void write(uint32_t tti, cf_t* data, uint32_t nsamples);
/**
* Initiation function, necessary to configure main parameters
* @param common SRSUE phy_common instance pointer for providing intra_freq_meas_len_ms and intra_freq_meas_period_ms
* @param rrc SRSUE PHY->RRC interface for supplying the RRC with the measurements
* @param log_h Physical layer Logging filter pointer
*/
void init(phy_common* common, rrc_interface_phy_lte* rrc, srslte::log* log_h);
/**
* Stops the operation of this component
*/
void stop();
/**
* Sets the primmary cell, configures the cell bandwidth and sampling rate
* @param earfcn Frequency the component is receiving base-band from. Used only for reporting the EARFCN to the RRC
* @param cell Actual cell configuration
*/
void set_primary_cell(uint32_t earfcn, srslte_cell_t cell);
/**
* Sets the PCI list of the cells this components needs to measure and starts the FSM for measuring
* @param pci is the list of PCIs to measure
*/
void set_cells_to_meas(const std::set<uint32_t>& pci);
/**
* Stops the measurment FSM, setting the inner state to idle.
*/
void meas_stop();
/**
* Inputs the baseband IQ samples into the component, internal state dictates whether it will be written or not.
* @param tti The current physical layer TTI, used for calculating the buffer write
* @param data buffer with baseband IQ samples
* @param nsamples number of samples to write
*/
void write(uint32_t tti, cf_t* data, uint32_t nsamples);
/**
* Get EARFCN of this component
* @return EARFCN
*/
uint32_t get_earfcn() { return current_earfcn; };
void wait_meas()
/**
* Synchronous wait mechanism, used for testing purposes, it waits for the inner thread to return a measurement.
*/
void wait_meas()
{ // Only used by scell_search_test
meas_sync.wait();
}
private:
class internal_state ///< Internal state class, provides thread safe state management
{
public:
typedef enum {
idle = 0, ///< Initial state, internal thread runs, it does not capture data
wait, ///< Wait for the period time to pass
receive, ///< Accumulate samples in ring buffer
measure, ///< Module is busy measuring
quit ///< Quit thread, no transitions are allowed
} state_t;
private:
state_t state = idle;
std::mutex mutex;
std::condition_variable cvar;
public:
/**
* Get the internal state
* @return protected state
*/
state_t get_state() { return state; }
/**
* Transitions to a different state, all transitions are allowed except from quit
* @param new_state
*/
void set_state(state_t new_state)
{
std::unique_lock<std::mutex> lock(mutex);
// Do not allow transition from quit
if (state != quit) {
state = new_state;
}
// Notifies to the inner thread about the change of state
cvar.notify_all();
}
/**
* Waits for a state transition change, used for blocking the inner thread
*/
void wait_change()
{
std::unique_lock<std::mutex> lock(mutex);
cvar.wait(lock);
}
};
internal_state state;
void run_thread() override;
const static int INTRA_FREQ_MEAS_PRIO = DEFAULT_PRIORITY + 5;
scell_recv scell = {};
rrc_interface_phy_lte* rrc = nullptr;
srslte::log* log_h = nullptr;
phy_common* common = nullptr;
uint32_t current_earfcn = 0;
uint32_t current_sflen = 0;
srslte_cell_t serving_cell = {};
std::set<uint32_t> active_pci = {};
std::mutex active_pci_mutex = {};
srslte::tti_sync_cv tti_sync;
srslte::tti_sync_cv meas_sync; // Only used by scell_search_test
scell_recv scell = {};
rrc_interface_phy_lte* rrc = nullptr;
srslte::log* log_h = nullptr;
uint32_t current_earfcn = 0;
uint32_t current_sflen = 0;
srslte_cell_t serving_cell = {};
std::set<uint32_t> active_pci = {};
std::mutex active_pci_mutex = {};
uint32_t last_measure_tti = 0;
uint32_t intra_freq_meas_len_ms = 20;
uint32_t intra_freq_meas_period_ms = 200;
uint32_t rx_gain_offset_db = 0;
srslte::tti_sync_cv meas_sync; // Only used by scell_search_test
cf_t* search_buffer = nullptr;
bool running = false;
bool receive_enabled = false;
bool receiving = false;
uint32_t receive_cnt = 0;
srslte_ringbuffer_t ring_buffer = {};
uint32_t receive_cnt = 0;
srslte_ringbuffer_t ring_buffer = {};
srslte_refsignal_dl_sync_t refsignal_dl_sync = {};
};

110
srsue/src/phy/scell/intra_measure.cc
View File

@ -45,52 +45,52 @@ intra_measure::~intra_measure()
free(search_buffer);
}
void intra_measure::init(phy_common* common_, rrc_interface_phy_lte* rrc_, srslte::log* log_h_)
void intra_measure::init(phy_common* common, rrc_interface_phy_lte* rrc_, srslte::log* log_h_)
{
this->rrc = rrc_;
this->log_h = log_h_;
this->common = common_;
receive_enabled = false;
rrc = rrc_;
log_h = log_h_;
if (common) {
intra_freq_meas_len_ms = common->args->intra_freq_meas_len_ms;
intra_freq_meas_period_ms = common->args->intra_freq_meas_period_ms;
rx_gain_offset_db = common->args->rx_gain_offset;
}
// Initialise Reference signal measurement
srslte_refsignal_dl_sync_init(&refsignal_dl_sync);
// Start scell
scell.init(log_h, common->args->intra_freq_meas_len_ms);
scell.init(log_h, intra_freq_meas_len_ms);
search_buffer =
(cf_t*)srslte_vec_malloc(common->args->intra_freq_meas_len_ms * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB) * sizeof(cf_t));
search_buffer = srslte_vec_cf_malloc(intra_freq_meas_len_ms * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB));
if (srslte_ringbuffer_init(
&ring_buffer, sizeof(cf_t) * common->args->intra_freq_meas_len_ms * 2 * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB))) {
if (srslte_ringbuffer_init(&ring_buffer, sizeof(cf_t) * intra_freq_meas_len_ms * SRSLTE_SF_LEN_PRB(SRSLTE_MAX_PRB))) {
return;
}
running = true;
state.set_state(internal_state::idle);
start(INTRA_FREQ_MEAS_PRIO);
}
void intra_measure::stop()
{
running = false;
state.set_state(internal_state::quit);
srslte_ringbuffer_stop(&ring_buffer);
tti_sync.increase();
wait_thread_finish();
srslte_refsignal_dl_sync_free(&refsignal_dl_sync);
}
void intra_measure::set_primary_cell(uint32_t earfcn, srslte_cell_t cell)
{
this->current_earfcn = earfcn;
current_sflen = (uint32_t)SRSLTE_SF_LEN_PRB(cell.nof_prb);
this->serving_cell = cell;
current_earfcn = earfcn;
current_sflen = (uint32_t)SRSLTE_SF_LEN_PRB(cell.nof_prb);
serving_cell = cell;
}
void intra_measure::meas_stop()
{
receive_enabled = false;
receiving = false;
receive_cnt = 0;
state.set_state(internal_state::idle);
receive_cnt = 0;
srslte_ringbuffer_reset(&ring_buffer);
if (log_h) {
log_h->info("INTRA: Disabled neighbour cell search for EARFCN %d\n", get_earfcn());
@ -102,30 +102,41 @@ void intra_measure::set_cells_to_meas(const std::set<uint32_t>& pci)
active_pci_mutex.lock();
active_pci = pci;
active_pci_mutex.unlock();
receive_enabled = true;
state.set_state(internal_state::receive);
log_h->info("INTRA: Received list of %lu neighbour cells to measure in EARFCN %d.\n", pci.size(), current_earfcn);
}
void intra_measure::write(uint32_t tti, cf_t* data, uint32_t nsamples)
{
if (receive_enabled) {
if ((tti % common->args->intra_freq_meas_period_ms) == 0) {
receiving = true;
receive_cnt = 0;
srslte_ringbuffer_reset(&ring_buffer);
}
if (receiving) {
uint32_t elapsed_tti = ((tti + 10240) - last_measure_tti) % 10240;
switch (state.get_state()) {
case internal_state::idle:
case internal_state::measure:
case internal_state::quit:
// Do nothing
break;
case internal_state::wait:
if (elapsed_tti >= intra_freq_meas_period_ms) {
state.set_state(internal_state::receive);
receive_cnt = 0;
last_measure_tti = tti;
srslte_ringbuffer_reset(&ring_buffer);
}
break;
case internal_state::receive:
if (srslte_ringbuffer_write(&ring_buffer, data, nsamples * sizeof(cf_t)) < (int)(nsamples * sizeof(cf_t))) {
Warning("Error writting to ringbuffer\n");
receiving = false;
Warning("Error writing to ringbuffer\n");
state.set_state(internal_state::idle);
} else {
receive_cnt++;
if (receive_cnt == common->args->intra_freq_meas_len_ms) {
tti_sync.increase();
receiving = false;
if (receive_cnt == intra_freq_meas_len_ms) {
// Buffer ready for measuring, start
state.set_state(internal_state::measure);
}
}
}
break;
}
}
@ -133,32 +144,31 @@ void intra_measure::run_thread()
{
std::set<uint32_t> cells_to_measure = {};
while (running) {
if (running) {
tti_sync.wait();
}
if (running) {
while (state.get_state() != internal_state::quit) {
if (state.get_state() == internal_state::measure) {
// Start measuring
active_pci_mutex.lock();
cells_to_measure = active_pci;
active_pci_mutex.unlock();
// Read data from buffer and find cells in it
srslte_ringbuffer_read(
&ring_buffer, search_buffer, common->args->intra_freq_meas_len_ms * current_sflen * sizeof(cf_t));
srslte_ringbuffer_read(&ring_buffer, search_buffer, intra_freq_meas_len_ms * current_sflen * sizeof(cf_t));
// Go to receive before finishing, so new samples can be enqueued before the thread finishes
if (state.get_state() == internal_state::measure) {
// Prevents transition to wait if state has changed while reading the ring-buffer
state.set_state(internal_state::wait);
}
// Detect new cells using PSS/SSS
std::set<uint32_t> detected_cells =
scell.find_cells(search_buffer, serving_cell, common->args->intra_freq_meas_len_ms);
std::set<uint32_t> detected_cells = scell.find_cells(search_buffer, serving_cell, intra_freq_meas_len_ms);
// Add detected cells to the list of cells to measure
for (auto& c : detected_cells) {
cells_to_measure.insert(c);
}
receiving = false;
// Initialise empty neighbour cell list
std::vector<rrc_interface_phy_lte::phy_meas_t> neighbour_cells = {};
// Use Cell Reference signal to measure cells in the time domain for all known active PCI
@ -171,14 +181,13 @@ void intra_measure::run_thread()
cell.id = id;
srslte_refsignal_dl_sync_set_cell(&refsignal_dl_sync, cell);
srslte_refsignal_dl_sync_run(
&refsignal_dl_sync, search_buffer, common->args->intra_freq_meas_len_ms * current_sflen);
srslte_refsignal_dl_sync_run(&refsignal_dl_sync, search_buffer, intra_freq_meas_len_ms * current_sflen);
if (refsignal_dl_sync.found) {
rrc_interface_phy_lte::phy_meas_t m = {};
m.pci = cell.id;
m.earfcn = current_earfcn;
m.rsrp = refsignal_dl_sync.rsrp_dBfs - common->rx_gain_offset;
m.rsrp = refsignal_dl_sync.rsrp_dBfs - rx_gain_offset_db;
m.rsrq = refsignal_dl_sync.rsrq_dB;
neighbour_cells.push_back(m);
@ -199,6 +208,9 @@ void intra_measure::run_thread()
}
meas_sync.increase();
} else if (state.get_state() != internal_state::quit) {
// Wait for changing state
state.wait_change();
}
}
}

28
srsue/test/phy/scell_search_test.cc
View File

@ -324,6 +324,7 @@ int parse_args(int argc, char** argv)
common.add_options()
("duration", bpo::value<uint32_t>(&duration_execution_s)->default_value(60), "Duration of the execution in seconds")
("cell.nof_prb", bpo::value<uint32_t>(&cell_base.nof_prb)->default_value(100), "Cell Number of PRB")
("cell.nof_ports", bpo::value<uint32_t>(&cell_base.nof_ports)->default_value(1), "Cell Number of Tx ports")
("intra_meas_log_level", bpo::value<std::string>(&intra_meas_log_level)->default_value("none"), "Intra measurement log level (none, warning, info, debug)")
("intra_freq_meas_len_ms", bpo::value<uint32_t>(&phy_args.intra_freq_meas_len_ms)->default_value(20), "Intra measurement measurement length")
("intra_freq_meas_period_ms", bpo::value<uint32_t>(&phy_args.intra_freq_meas_period_ms)->default_value(200), "Intra measurement measurement period")
@ -450,6 +451,7 @@ int main(int argc, char** argv)
phy_args.cfo_loop_pss_conv = DEFAULT_PSS_STABLE_TIMEOUT;
phy_args.snr_estim_alg = "refs";
phy_args.snr_ema_coeff = 0.1f;
phy_args.rx_gain_offset = rx_gain + 62.0f;
// Set phy-lib logging level
srslte_verbose = phy_lib_log_level;
@ -490,7 +492,7 @@ int main(int argc, char** argv)
logger.set_level(intra_meas_log_level);
intra_measure.init(&common, &rrc, &logger);
intra_measure.set_primary_cell(serving_cell_id, cell_base);
intra_measure.set_primary_cell(SRSLTE_MAX(earfcn_dl, 0), cell_base);
if (earfcn_dl >= 0) {
// Create radio log
@ -636,17 +638,19 @@ int main(int argc, char** argv)
enb->work(&sf_cfg_dl, nullptr, nullptr, nullptr, nullptr, baseband_buffer, ts);
}
}
}
srslte_timestamp_add(&ts, 0, 0.001f);
if (sf_idx > phy_args.intra_freq_meas_period_ms) {
if (sf_idx % phy_args.intra_freq_meas_period_ms == 0) {
intra_measure.wait_meas();
// If it is time for a measurement, wait previous to finish
if (sf_idx > phy_args.intra_freq_meas_period_ms) {
if (sf_idx % phy_args.intra_freq_meas_period_ms == 0) {
intra_measure.wait_meas();
}
}
}
intra_measure.write(sf_idx, baseband_buffer, SRSLTE_SF_LEN_PRB(cell_base.nof_prb));
// Increase Time counter
srslte_timestamp_add(&ts, 0, 0.001f);
// Give data to intra measure component
intra_measure.write(sf_idx % 10240, baseband_buffer, SRSLTE_SF_LEN_PRB(cell_base.nof_prb));
if (sf_idx % 1000 == 0) {
printf("Done %.1f%%\n", (double)sf_idx * 100.0 / ((double)duration_execution_s * 1000.0));
}
@ -657,6 +661,10 @@ int main(int argc, char** argv)
ret = rrc.print_stats() ? SRSLTE_SUCCESS : SRSLTE_ERROR;
if (radio) {
radio->stop();
}
if (baseband_buffer) {
free(baseband_buffer);
}
@ -673,7 +681,7 @@ int main(int argc, char** argv)
}
}
if (ret) {
if (ret && radio == nullptr) {
printf("Error\n");
} else {
printf("Ok\n");