mirror of https://github.com/PentHertz/srsLTE.git
527 lines
19 KiB
C++
527 lines
19 KiB
C++
/*
|
|
* Copyright 2013-2020 Software Radio Systems Limited
|
|
*
|
|
* This file is part of srsLTE.
|
|
*
|
|
* srsLTE is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* srsLTE is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* A copy of the GNU Affero General Public License can be found in
|
|
* the LICENSE file in the top-level directory of this distribution
|
|
* and at http://www.gnu.org/licenses/.
|
|
*
|
|
*/
|
|
#include <srslte/common/test_common.h>
|
|
#include <srslte/common/threads.h>
|
|
#include <srslte/phy/utils/random.h>
|
|
#include <srslte/srslte.h>
|
|
#include <srsue/hdr/phy/phy.h>
|
|
|
|
#define CALLBACK(NAME, ...) \
|
|
private: \
|
|
bool received_##NAME = false; \
|
|
\
|
|
public: \
|
|
bool wait_##NAME(uint32_t timeout_ms, bool reset_flag = false) \
|
|
{ \
|
|
std::unique_lock<std::mutex> lock(mutex); \
|
|
std::chrono::system_clock::time_point expire_time = std::chrono::system_clock::now(); \
|
|
expire_time += std::chrono::milliseconds(timeout_ms); \
|
|
bool expired = false; \
|
|
if (reset_flag) { \
|
|
received_##NAME = false; \
|
|
} \
|
|
while (!received_##NAME && !expired) { \
|
|
expired = (cvar.wait_until(lock, expire_time) == std::cv_status::timeout); \
|
|
} \
|
|
if (expired) { \
|
|
log_h.info("Expired " #NAME " waiting\n"); \
|
|
} \
|
|
return received_##NAME; \
|
|
} \
|
|
\
|
|
bool get_received_##NAME() { return received_##NAME; } \
|
|
\
|
|
private: \
|
|
void notify_##NAME(__VA_ARGS__) \
|
|
{ \
|
|
std::unique_lock<std::mutex> lock(mutex); \
|
|
cvar.notify_all(); \
|
|
log_h.info(#NAME " received\n"); \
|
|
received_##NAME = true; \
|
|
}
|
|
|
|
class phy_test_bench : public srslte::thread
|
|
{
|
|
private:
|
|
// Dummy classes
|
|
class dummy_stack : public srsue::stack_interface_phy_lte
|
|
{
|
|
private:
|
|
srslte::log_filter log_h;
|
|
uint16_t rnti = 0x3c;
|
|
std::mutex mutex;
|
|
std::condition_variable cvar;
|
|
|
|
CALLBACK(in_sync)
|
|
CALLBACK(out_of_sync)
|
|
CALLBACK(new_phy_meas)
|
|
CALLBACK(new_grant_ul)
|
|
CALLBACK(new_grant_dl)
|
|
CALLBACK(run_tti)
|
|
|
|
public:
|
|
// Local test access methods
|
|
explicit dummy_stack(srslte::logger& logger) : log_h("stack", &logger) {}
|
|
void set_rnti(uint16_t rnti_) { rnti = rnti_; }
|
|
void set_loglevel(std::string& str) { log_h.set_level(str); }
|
|
|
|
void in_sync() override { notify_in_sync(); }
|
|
void out_of_sync() override { notify_out_of_sync(); }
|
|
void new_cell_meas(const std::vector<phy_meas_t>& meas) override
|
|
{
|
|
for (auto& m : meas) {
|
|
notify_new_phy_meas();
|
|
log_h.info(
|
|
"New measurement earfcn=%d; pci=%d; rsrp=%+.1fdBm; rsrq=%+.1fdB;\n", m.earfcn, m.pci, m.rsrp, m.rsrq);
|
|
}
|
|
}
|
|
uint16_t get_dl_sched_rnti(uint32_t tti) override { return rnti; }
|
|
uint16_t get_ul_sched_rnti(uint32_t tti) override { return rnti; }
|
|
void new_grant_ul(uint32_t cc_idx, mac_grant_ul_t grant, tb_action_ul_t* action) override { notify_new_grant_ul(); }
|
|
void new_grant_dl(uint32_t cc_idx, mac_grant_dl_t grant, tb_action_dl_t* action) override
|
|
{
|
|
notify_new_grant_dl();
|
|
for (auto& i : action->tb) {
|
|
i.enabled = true;
|
|
}
|
|
}
|
|
void tb_decoded(uint32_t cc_idx, mac_grant_dl_t grant, bool* ack) override {}
|
|
void bch_decoded_ok(uint32_t cc_idx, uint8_t* payload, uint32_t len) override {}
|
|
void mch_decoded(uint32_t len, bool crc) override {}
|
|
void new_mch_dl(srslte_pdsch_grant_t phy_grant, tb_action_dl_t* action) override {}
|
|
void set_mbsfn_config(uint32_t nof_mbsfn_services) override {}
|
|
void run_tti(const uint32_t tti, const uint32_t tti_jump) override
|
|
{
|
|
notify_run_tti();
|
|
log_h.info("Run TTI %d\n", tti);
|
|
}
|
|
};
|
|
|
|
class dummy_radio : public srslte::radio_interface_phy
|
|
{
|
|
private:
|
|
srslte::log_filter log_h;
|
|
std::vector<srslte_ringbuffer_t> ring_buffers;
|
|
float base_srate = 0.0f;
|
|
float tx_srate = 0.0f;
|
|
float rx_srate = 0.0f;
|
|
float rx_gain = 0.0f;
|
|
float tx_freq = 0.0f;
|
|
float rx_freq = 0.0f;
|
|
cf_t* temp_buffer = nullptr;
|
|
uint64_t rx_timestamp = 0;
|
|
std::mutex mutex;
|
|
std::condition_variable cvar;
|
|
srslte_rf_info_t rf_info = {};
|
|
srslte_timestamp_t tx_last_tx = {};
|
|
uint32_t count_late = 0;
|
|
|
|
CALLBACK(rx_now)
|
|
CALLBACK(tx)
|
|
CALLBACK(late)
|
|
|
|
public:
|
|
dummy_radio(srslte::logger& logger, uint32_t nof_channels, float base_srate_) :
|
|
log_h("radio", &logger),
|
|
ring_buffers(nof_channels),
|
|
base_srate(base_srate_)
|
|
{
|
|
// Create Ring buffers
|
|
for (auto& rb : ring_buffers) {
|
|
if (srslte_ringbuffer_init(&rb, (uint32_t)sizeof(cf_t) * SRSLTE_SF_LEN_MAX * SRSLTE_NOF_SF_X_FRAME)) {
|
|
perror("init softbuffer");
|
|
}
|
|
}
|
|
|
|
// Create temporal buffer
|
|
temp_buffer = srslte_vec_cf_malloc(SRSLTE_SF_LEN_MAX * SRSLTE_NOF_SF_X_FRAME);
|
|
if (!temp_buffer) {
|
|
perror("malloc");
|
|
}
|
|
|
|
// Set RF Info (in dB)
|
|
rf_info.min_rx_gain = 0.0f;
|
|
rf_info.max_rx_gain = 90.0f;
|
|
rf_info.min_tx_gain = 0.0f;
|
|
rf_info.max_tx_gain = 90.0f;
|
|
}
|
|
|
|
~dummy_radio()
|
|
{
|
|
for (auto& rb : ring_buffers) {
|
|
srslte_ringbuffer_free(&rb);
|
|
}
|
|
if (temp_buffer) {
|
|
free(temp_buffer);
|
|
}
|
|
}
|
|
|
|
void set_loglevel(std::string& str) { log_h.set_level(str); }
|
|
|
|
void write_ring_buffers(cf_t** buffer, uint32_t nsamples)
|
|
{
|
|
for (uint32_t i = 0; i < ring_buffers.size(); i++) {
|
|
int ret = SRSLTE_SUCCESS;
|
|
do {
|
|
if (ret != SRSLTE_SUCCESS) {
|
|
log_h.error("Ring buffer write failed (full). Trying again.\n");
|
|
}
|
|
ret = srslte_ringbuffer_write_timed(&ring_buffers[i], buffer[i], (uint32_t)sizeof(cf_t) * nsamples, 1000);
|
|
} while (ret == SRSLTE_ERROR_TIMEOUT);
|
|
}
|
|
}
|
|
|
|
uint32_t get_count_late() { return count_late; }
|
|
|
|
bool
|
|
tx(srslte::rf_buffer_interface& buffer, const uint32_t& nof_samples, const srslte_timestamp_t& tx_time) override
|
|
{
|
|
bool ret = true;
|
|
notify_tx();
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
|
|
if (!std::isnormal(tx_srate)) {
|
|
count_late++;
|
|
}
|
|
if (srslte_timestamp_compare(&tx_time, &tx_last_tx) < 0) {
|
|
ret = false;
|
|
}
|
|
|
|
tx_last_tx = tx_time;
|
|
srslte_timestamp_add(&tx_last_tx, 0, (double)nof_samples / (double)tx_srate);
|
|
|
|
return ret;
|
|
}
|
|
void release_freq(const uint32_t& carrier_idx) override{};
|
|
void tx_end() override {}
|
|
bool rx_now(srslte::rf_buffer_interface& buffer, const uint32_t& nof_samples, srslte_timestamp_t* rxd_time) override
|
|
{
|
|
notify_rx_now();
|
|
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
auto base_nsamples = (uint32_t)floorf(((float)nof_samples * base_srate) / rx_srate);
|
|
|
|
for (uint32_t i = 0; i < ring_buffers.size(); i++) {
|
|
cf_t* buf_ptr = ((buffer.get(i) != nullptr) && (base_srate == rx_srate)) ? buffer.get(i) : temp_buffer;
|
|
|
|
// Read base srate samples
|
|
int ret = srslte_ringbuffer_read(&ring_buffers[i], buf_ptr, (uint32_t)sizeof(cf_t) * base_nsamples);
|
|
if (ret < 0) {
|
|
log_h.error("Reading ring buffer\n");
|
|
} else {
|
|
log_h.debug("-- %d samples read from ring buffer\n", base_nsamples);
|
|
}
|
|
|
|
// Only if baseband buffer is provided
|
|
if (buffer.get(i)) {
|
|
if (base_srate > rx_srate) {
|
|
// Decimate
|
|
auto decimation = (uint32_t)roundf(base_srate / rx_srate);
|
|
|
|
// Perform decimation
|
|
for (uint32_t j = 0, k = 0; j < nof_samples; j++, k += decimation) {
|
|
buffer.get(i)[j] = buf_ptr[k];
|
|
}
|
|
} else if (base_srate < rx_srate) {
|
|
// Interpolate
|
|
auto interpolation = (uint32_t)roundf(rx_srate / base_srate);
|
|
|
|
// Perform zero order hold interpolation
|
|
for (uint32_t j = 0, k = 0; j < nof_samples; k++) {
|
|
for (uint32_t c = 0; c < interpolation; c++, j++) {
|
|
buffer.get(i)[j] = buf_ptr[k];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set Rx timestamp
|
|
if (rxd_time) {
|
|
srslte_timestamp_init_uint64(rxd_time, rx_timestamp, (double)base_srate);
|
|
}
|
|
|
|
// Update timestamp
|
|
rx_timestamp += base_nsamples;
|
|
|
|
return true;
|
|
}
|
|
void set_tx_freq(const uint32_t& channel_idx, const double& freq) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
tx_freq = (float)freq;
|
|
log_h.info("Set Tx freq to %+.0f MHz.\n", freq * 1.0e-6);
|
|
}
|
|
void set_rx_freq(const uint32_t& channel_idx, const double& freq) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
rx_freq = (float)freq;
|
|
log_h.info("Set Rx freq to %+.0f MHz.\n", freq * 1.0e-6);
|
|
}
|
|
void set_rx_gain_th(const float& gain) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
rx_gain = srslte_convert_dB_to_amplitude(gain);
|
|
log_h.info("Set Rx gain-th to %+.1f dB (%.6f).\n", gain, rx_gain);
|
|
}
|
|
void set_tx_gain(const float& gain) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
rx_gain = srslte_convert_dB_to_amplitude(gain);
|
|
log_h.info("Set Tx gain to %+.1f dB (%.6f).\n", gain, rx_gain);
|
|
}
|
|
void set_rx_gain(const float& gain) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
rx_gain = srslte_convert_dB_to_amplitude(gain);
|
|
log_h.info("Set Rx gain to %+.1f dB (%.6f).\n", gain, rx_gain);
|
|
}
|
|
void set_tx_srate(const double& srate) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
tx_srate = (float)srate;
|
|
log_h.info("Set Tx sampling rate to %+.3f MHz.\n", srate * 1.0e-6);
|
|
}
|
|
void set_rx_srate(const double& srate) override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
rx_srate = (float)srate;
|
|
log_h.info("Set Rx sampling rate to %+.3f MHz.\n", srate * 1.0e-6);
|
|
}
|
|
float get_rx_gain() override
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
return srslte_convert_amplitude_to_dB(rx_gain);
|
|
}
|
|
double get_freq_offset() override { return 0; }
|
|
bool is_continuous_tx() override { return false; }
|
|
bool get_is_start_of_burst() override { return false; }
|
|
bool is_init() override { return false; }
|
|
void reset() override {}
|
|
srslte_rf_info_t* get_info() override { return &rf_info; }
|
|
};
|
|
|
|
// Common instances
|
|
srslte::logger_stdout main_logger;
|
|
srslte::log_filter log_h;
|
|
|
|
// Dummy instances
|
|
dummy_stack stack;
|
|
dummy_radio radio;
|
|
|
|
// Phy Instances
|
|
std::unique_ptr<srsue::phy> phy;
|
|
|
|
// eNb
|
|
srslte_enb_dl_t enb_dl = {};
|
|
cf_t* enb_dl_buffer[SRSLTE_MAX_PORTS] = {};
|
|
srslte_dl_sf_cfg_t dl_sf_cfg = {};
|
|
uint64_t sfn = 0; // System Frame Number
|
|
uint32_t sf_len = 0;
|
|
|
|
// Control atributes
|
|
bool running = false;
|
|
std::mutex mutex;
|
|
std::condition_variable cvar;
|
|
|
|
public:
|
|
phy_test_bench(const srsue::phy_args_t& phy_args, const srslte_cell_t& cell) :
|
|
stack(main_logger),
|
|
radio(main_logger, cell.nof_ports, srslte_sampling_freq_hz(cell.nof_prb)),
|
|
thread("phy_test_bench"),
|
|
log_h("test bench")
|
|
{
|
|
// Deduce physical attributes
|
|
sf_len = SRSLTE_SF_LEN_PRB(cell.nof_prb);
|
|
|
|
// Initialise UE
|
|
phy = std::unique_ptr<srsue::phy>(new srsue::phy(&main_logger));
|
|
phy->init(phy_args, &stack, &radio);
|
|
|
|
// Initialise DL baseband buffers
|
|
for (uint32_t i = 0; i < cell.nof_ports; i++) {
|
|
enb_dl_buffer[i] = srslte_vec_cf_malloc(sf_len);
|
|
if (!enb_dl_buffer[i]) {
|
|
perror("malloc");
|
|
}
|
|
}
|
|
|
|
// Initialise eNb DL
|
|
srslte_enb_dl_init(&enb_dl, enb_dl_buffer, SRSLTE_MAX_PRB);
|
|
srslte_enb_dl_set_cell(&enb_dl, cell);
|
|
|
|
// Wait PHY init to end
|
|
phy->wait_initialize();
|
|
}
|
|
|
|
~phy_test_bench()
|
|
{
|
|
// Free eNb DL object
|
|
srslte_enb_dl_free(&enb_dl);
|
|
|
|
// Free buffers
|
|
for (auto& buf : enb_dl_buffer) {
|
|
if (buf) {
|
|
free(buf);
|
|
buf = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
dummy_stack* get_stack() { return &stack; }
|
|
dummy_radio* get_radio() { return &radio; }
|
|
srsue::phy_interface_rrc_lte* get_phy_interface_rrc() { return phy.get(); }
|
|
srsue::phy_interface_mac_lte* get_phy_interface_mac() { return phy.get(); }
|
|
|
|
void configure_dedicated(uint16_t rnti, srslte::phy_cfg_t& phy_cfg)
|
|
{
|
|
// set RNTI
|
|
phy->set_crnti(rnti);
|
|
|
|
// Set PHY configuration
|
|
phy->set_config(phy_cfg, 0, 0, nullptr);
|
|
}
|
|
|
|
void run_thread() override
|
|
{
|
|
bool _running;
|
|
|
|
// Free run DL
|
|
do {
|
|
log_h.debug("-- generating DL baseband SFN=%" PRId64 " TTI=%d;\n", sfn, dl_sf_cfg.tti);
|
|
|
|
// Create empty resource grid with basic signals
|
|
srslte_enb_dl_put_base(&enb_dl, &dl_sf_cfg);
|
|
|
|
// Generate signal and transmit
|
|
srslte_enb_dl_gen_signal(&enb_dl);
|
|
|
|
// Write baseband to radio
|
|
radio.write_ring_buffers(enb_dl_buffer, sf_len);
|
|
|
|
// Increase TTI
|
|
dl_sf_cfg.tti++;
|
|
|
|
// Increase System Frame number
|
|
if (dl_sf_cfg.tti >= 10240U) {
|
|
dl_sf_cfg.tti = 0;
|
|
sfn++;
|
|
}
|
|
|
|
// Update local running state
|
|
mutex.lock();
|
|
_running = running;
|
|
mutex.unlock();
|
|
} while (_running);
|
|
|
|
// Stop PHY now!
|
|
phy->stop();
|
|
|
|
// Finish thread
|
|
}
|
|
|
|
void start()
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
running = true;
|
|
thread::start();
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
cvar.notify_all();
|
|
mutex.lock();
|
|
running = false;
|
|
mutex.unlock();
|
|
wait_thread_finish();
|
|
}
|
|
|
|
void set_loglevel(std::string str)
|
|
{
|
|
log_h.set_level(str);
|
|
radio.set_loglevel(str);
|
|
stack.set_loglevel(str);
|
|
}
|
|
};
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
int ret = SRSLTE_SUCCESS;
|
|
const uint32_t default_timeout = 60000; // 1 minute
|
|
|
|
// Define Cell
|
|
srslte_cell_t cell = {.nof_prb = 6,
|
|
.nof_ports = 4,
|
|
.id = 1,
|
|
.cp = SRSLTE_CP_NORM,
|
|
.phich_length = SRSLTE_PHICH_NORM,
|
|
.phich_resources = SRSLTE_PHICH_R_1,
|
|
.frame_type = SRSLTE_FDD};
|
|
// Define PHY arguments
|
|
srsue::phy_args_t phy_args = {};
|
|
|
|
// Set custom test cell and arguments here
|
|
phy_args.log.phy_level = "info";
|
|
|
|
// Create test bench
|
|
std::unique_ptr<phy_test_bench> phy_test = std::unique_ptr<phy_test_bench>(new phy_test_bench(phy_args, cell));
|
|
phy_test->set_loglevel("info");
|
|
|
|
// Start test bench
|
|
phy_test->start();
|
|
|
|
// 1. Cell search
|
|
srsue::phy_interface_rrc_lte::phy_cell_t phy_cell;
|
|
auto cell_search_res = phy_test->get_phy_interface_rrc()->cell_search(&phy_cell);
|
|
TESTASSERT(cell_search_res.found == srsue::phy_interface_rrc_lte::cell_search_ret_t::CELL_FOUND);
|
|
TESTASSERT(phy_test->get_stack()->wait_in_sync(default_timeout));
|
|
TESTASSERT(phy_cell.pci == cell.id);
|
|
|
|
// 2. Cell select
|
|
phy_test->get_phy_interface_rrc()->cell_select(&phy_cell);
|
|
TESTASSERT(phy_test->get_stack()->wait_in_sync(default_timeout));
|
|
TESTASSERT(phy_test->get_stack()->wait_new_phy_meas(default_timeout));
|
|
|
|
// 3. Transmit PRACH
|
|
phy_test->get_phy_interface_mac()->configure_prach_params();
|
|
phy_test->get_phy_interface_mac()->prach_send(0, -1, 0.0f);
|
|
TESTASSERT(phy_test->get_radio()->wait_tx(default_timeout, false));
|
|
|
|
// 4. Configure RNTI with PUCCH and check transmission
|
|
uint16_t rnti = 0x3c;
|
|
srslte::phy_cfg_t phy_cfg = {};
|
|
phy_cfg.set_defaults();
|
|
phy_cfg.dl_cfg.cqi_report.periodic_mode = SRSLTE_CQI_MODE_12;
|
|
phy_cfg.dl_cfg.cqi_report.periodic_configured = true;
|
|
phy_cfg.dl_cfg.cqi_report.pmi_idx = 0;
|
|
phy_cfg.ul_cfg.pucch.n_pucch_2 = 0;
|
|
phy_test->configure_dedicated(rnti, phy_cfg);
|
|
TESTASSERT(phy_test->get_radio()->wait_tx(default_timeout));
|
|
|
|
// Wait to finish test
|
|
phy_test->stop();
|
|
|
|
// Final test checks...
|
|
TESTASSERT(!phy_test->get_radio()->get_count_late()); // No Late allowed
|
|
|
|
return ret;
|
|
}
|