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

fixed naming for ue_sync_nbiot

This commit is contained in:
Andre Puschmann 2019-12-10 16:23:18 +01:00
parent 447f71b8c9
commit 8bec22ff11
8 changed files with 91 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/examples/cell_search_nbiot.c
View File

@ -213,7 +213,7 @@ int main(int argc, char** argv)
srslte_ue_cellsearch_nbiot_set_nof_valid_frames(&cs, cell_detect_config.nof_valid_pss_frames);
}
if (cell_detect_config.init_agc) {
srslte_nbiot_ue_sync_start_agc(&cs.ue_sync, srslte_rf_set_rx_gain_wrapper, cell_detect_config.init_agc);
srslte_ue_sync_nbiot_start_agc(&cs.ue_sync, srslte_rf_set_rx_gain_wrapper, cell_detect_config.init_agc);
}
INFO("Setting sampling frequency %.2f MHz for NPSS search\n", SRSLTE_CS_SAMP_FREQ / 1000000);

14
lib/examples/usrp_capture_sync_nbiot.c
View File

@ -141,7 +141,7 @@ int main(int argc, char** argv)
buff_ptrs[0] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_PRB_NBIOT * 10);
srslte_nbiot_ue_sync_t ue_sync;
if (srslte_nbiot_ue_sync_init(&ue_sync, cell, srslte_rf_recv_wrapper, (void*)&rf)) {
if (srslte_ue_sync_nbiot_init(&ue_sync, cell, srslte_rf_recv_wrapper, (void*)&rf)) {
fprintf(stderr, "Error initiating ue_sync\n");
exit(-1);
}
@ -151,7 +151,7 @@ int main(int argc, char** argv)
bool start_capture = false;
bool stop_capture = false;
while ((subframe_count < nof_subframes || nof_subframes == -1) && !stop_capture) {
int n = srslte_nbiot_ue_sync_zerocopy_multi(&ue_sync, buff_ptrs);
int n = srslte_ue_sync_nbiot_zerocopy_multi(&ue_sync, buff_ptrs);
if (n < 0) {
fprintf(stderr, "Error receiving samples\n");
exit(-1);
@ -160,7 +160,7 @@ int main(int argc, char** argv)
if (n == 1) {
if (!start_capture) {
if (nof_warmup_subframes <= 0) {
if (srslte_nbiot_ue_sync_get_sfidx(&ue_sync) == 9) {
if (srslte_ue_sync_nbiot_get_sfidx(&ue_sync) == 9) {
printf("Starting capture ..\n");
start_capture = true;
}
@ -168,16 +168,16 @@ int main(int argc, char** argv)
nof_warmup_subframes--;
} else {
printf("Writing subframe %d (%d/%d) to file (cfo=%6.2f kHz)\n",
srslte_nbiot_ue_sync_get_sfidx(&ue_sync),
srslte_ue_sync_nbiot_get_sfidx(&ue_sync),
subframe_count,
nof_subframes,
srslte_nbiot_ue_sync_get_cfo(&ue_sync) / 1000);
srslte_ue_sync_nbiot_get_cfo(&ue_sync) / 1000);
srslte_filesink_write(&sink, buff_ptrs[0], SRSLTE_SF_LEN_PRB(nof_prb));
subframe_count++;
}
}
if (!keep_running) {
if (!start_capture || (start_capture && srslte_nbiot_ue_sync_get_sfidx(&ue_sync) == 9)) {
if (!start_capture || (start_capture && srslte_ue_sync_nbiot_get_sfidx(&ue_sync) == 9)) {
printf("Stopping capture ..\n");
stop_capture = true;
}
@ -186,7 +186,7 @@ int main(int argc, char** argv)
srslte_filesink_free(&sink);
srslte_rf_close(&rf);
srslte_nbiot_ue_sync_free(&ue_sync);
srslte_ue_sync_nbiot_free(&ue_sync);
printf("Ok - wrote %d subframes\n", subframe_count);
exit(0);

46
lib/include/srslte/phy/ue/ue_sync_nbiot.h
View File

@ -93,73 +93,73 @@ typedef struct SRSLTE_API {
#endif
} srslte_nbiot_ue_sync_t;
SRSLTE_API int srslte_nbiot_ue_sync_init(srslte_nbiot_ue_sync_t* q,
SRSLTE_API int srslte_ue_sync_nbiot_init(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
int(recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*),
void* stream_handler);
SRSLTE_API int
srslte_nbiot_ue_sync_init_multi(srslte_nbiot_ue_sync_t* q,
srslte_ue_sync_nbiot_init_multi(srslte_nbiot_ue_sync_t* q,
uint32_t max_prb,
int(recv_callback)(void*, cf_t* [SRSLTE_MAX_PORTS], uint32_t, srslte_timestamp_t*),
uint32_t nof_rx_antennas,
void* stream_handler);
SRSLTE_API int srslte_nbiot_ue_sync_init_file(srslte_nbiot_ue_sync_t* q,
SRSLTE_API int srslte_ue_sync_nbiot_init_file(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
char* file_name,
int offset_time,
float offset_freq);
SRSLTE_API int srslte_nbiot_ue_sync_init_file_multi(srslte_nbiot_ue_sync_t* q,
SRSLTE_API int srslte_ue_sync_nbiot_init_file_multi(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
char* file_name,
int offset_time,
float offset_freq,
uint32_t nof_rx_ant);
SRSLTE_API void srslte_nbiot_ue_sync_free(srslte_nbiot_ue_sync_t* q);
SRSLTE_API void srslte_ue_sync_nbiot_free(srslte_nbiot_ue_sync_t* q);
SRSLTE_API int srslte_nbiot_ue_sync_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t cell);
SRSLTE_API int srslte_ue_sync_nbiot_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t cell);
SRSLTE_API int srslte_nbiot_ue_sync_start_agc(srslte_nbiot_ue_sync_t* q,
SRSLTE_API int srslte_ue_sync_nbiot_start_agc(srslte_nbiot_ue_sync_t* q,
float(set_gain_callback)(void*, float),
float init_gain_value);
SRSLTE_API uint32_t srslte_nbiot_ue_sync_sf_len(srslte_nbiot_ue_sync_t* q);
SRSLTE_API uint32_t srslte_ue_sync_nbiot_sf_len(srslte_nbiot_ue_sync_t* q);
SRSLTE_API int srslte_nbiot_ue_sync_get_buffer(srslte_nbiot_ue_sync_t* q, cf_t** sf_symbols);
SRSLTE_API void srslte_nbiot_ue_sync_set_agc_period(srslte_nbiot_ue_sync_t* q, uint32_t period);
SRSLTE_API void srslte_ue_sync_nbiot_set_agc_period(srslte_nbiot_ue_sync_t* q, uint32_t period);
/* CAUTION: input_buffer MUST have space for 2 subframes */
SRSLTE_API int srslte_nbiot_ue_sync_zerocopy(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer);
SRSLTE_API int srslte_ue_sync_nbiot_zerocopy(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer);
SRSLTE_API int srslte_nbiot_ue_sync_zerocopy_multi(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer[SRSLTE_MAX_PORTS]);
SRSLTE_API int srslte_ue_sync_nbiot_zerocopy_multi(srslte_nbiot_ue_sync_t* q, cf_t** input_buffer);
SRSLTE_API void srslte_nbiot_ue_sync_set_cfo(srslte_nbiot_ue_sync_t* q, float cfo);
SRSLTE_API void srslte_ue_sync_nbiot_set_cfo(srslte_nbiot_ue_sync_t* q, float cfo);
SRSLTE_API void srslte_nbiot_ue_sync_reset(srslte_nbiot_ue_sync_t* q);
SRSLTE_API void srslte_ue_sync_nbiot_reset(srslte_nbiot_ue_sync_t* q);
SRSLTE_API srslte_nbiot_ue_sync_state_t srslte_nbiot_ue_sync_get_state(srslte_nbiot_ue_sync_t* q);
SRSLTE_API srslte_nbiot_ue_sync_state_t srslte_ue_sync_nbiot_get_state(srslte_nbiot_ue_sync_t* q);
SRSLTE_API uint32_t srslte_nbiot_ue_sync_get_sfidx(srslte_nbiot_ue_sync_t* q);
SRSLTE_API uint32_t srslte_ue_sync_nbiot_get_sfidx(srslte_nbiot_ue_sync_t* q);
SRSLTE_API void srslte_nbiot_ue_sync_set_cfo_enable(srslte_nbiot_ue_sync_t* q, bool enable);
SRSLTE_API void srslte_ue_sync_nbiot_set_cfo_enable(srslte_nbiot_ue_sync_t* q, bool enable);
SRSLTE_API float srslte_nbiot_ue_sync_get_cfo(srslte_nbiot_ue_sync_t* q);
SRSLTE_API float srslte_ue_sync_nbiot_get_cfo(srslte_nbiot_ue_sync_t* q);
SRSLTE_API float srslte_nbiot_ue_sync_get_sfo(srslte_nbiot_ue_sync_t* q);
SRSLTE_API float srslte_ue_sync_nbiot_get_sfo(srslte_nbiot_ue_sync_t* q);
SRSLTE_API void srslte_nbiot_ue_sync_set_cfo_ema(srslte_nbiot_ue_sync_t* q, float ema);
SRSLTE_API void srslte_ue_sync_nbiot_set_cfo_ema(srslte_nbiot_ue_sync_t* q, float ema);
SRSLTE_API void srslte_nbiot_ue_sync_set_cfo_tol(srslte_nbiot_ue_sync_t* q, float cfo_tol);
SRSLTE_API void srslte_ue_sync_nbiot_set_cfo_tol(srslte_nbiot_ue_sync_t* q, float cfo_tol);
SRSLTE_API int srslte_nbiot_ue_sync_get_last_sample_offset(srslte_nbiot_ue_sync_t* q);
SRSLTE_API int srslte_ue_sync_nbiot_get_last_sample_offset(srslte_nbiot_ue_sync_t* q);
SRSLTE_API void srslte_nbiot_ue_sync_set_sample_offset_correct_period(srslte_nbiot_ue_sync_t* q,
SRSLTE_API void srslte_ue_sync_nbiot_set_sample_offset_correct_period(srslte_nbiot_ue_sync_t* q,
uint32_t nof_subframes);
SRSLTE_API void srslte_nbiot_ue_sync_get_last_timestamp(srslte_nbiot_ue_sync_t* q, srslte_timestamp_t* timestamp);
SRSLTE_API void srslte_ue_sync_nbiot_get_last_timestamp(srslte_nbiot_ue_sync_t* q, srslte_timestamp_t* timestamp);
#endif // SRSLTE_UE_SYNC_NBIOT_H

2
lib/src/phy/ue/test/ue_mib_sync_test_nbiot_usrp.c
View File

@ -167,7 +167,7 @@ int main(int argc, char** argv)
srslte_mib_nb_t mib_nb;
srslte_npbch_mib_unpack(bch_payload_rx, &mib_nb);
srslte_mib_nb_printf(stdout, cell, &mib_nb);
printf("CFO: %+6.2f kHz\n", srslte_nbiot_ue_sync_get_cfo(&mib_sync.ue_sync) / 1000);
printf("CFO: %+6.2f kHz\n", srslte_ue_sync_nbiot_get_cfo(&mib_sync.ue_sync) / 1000);
} else {
printf("Failed!\n");
}

16
lib/src/phy/ue/test/ue_sync_test_nbiot_usrp.c
View File

@ -176,13 +176,13 @@ int main(int argc, char** argv)
}
srslte_nbiot_ue_sync_t ue_sync;
if (srslte_nbiot_ue_sync_init(&ue_sync, cell, srslte_rf_recv_wrapper_cs, (void*)&rf)) {
if (srslte_ue_sync_nbiot_init(&ue_sync, cell, srslte_rf_recv_wrapper_cs, (void*)&rf)) {
fprintf(stderr, "Error initiating ue_sync\n");
exit(-1);
}
srslte_nbiot_ue_sync_set_cfo_enable(&ue_sync, do_cfo_corr);
srslte_nbiot_ue_sync_set_cfo_ema(&ue_sync, cfo_ema);
srslte_ue_sync_nbiot_set_cfo_enable(&ue_sync, do_cfo_corr);
srslte_ue_sync_nbiot_set_cfo_ema(&ue_sync, cfo_ema);
srslte_rf_start_rx_stream(&rf, false);
@ -190,20 +190,20 @@ int main(int argc, char** argv)
printf("Trying to keep syncronized to cell for %d frames\n", nof_frames);
while ((frame_cnt < nof_frames || nof_frames == -1) && !go_exit) {
if (srslte_nbiot_ue_sync_zerocopy_multi(&ue_sync, rx_buffer) < 0) {
if (srslte_ue_sync_nbiot_zerocopy_multi(&ue_sync, rx_buffer) < 0) {
fprintf(stderr, "Error calling srslte_nbiot_ue_sync_work()\n");
break;
}
if (srslte_nbiot_ue_sync_get_sfidx(&ue_sync) == 0) {
printf("CFO: %+6.2f kHz\r", srslte_nbiot_ue_sync_get_cfo(&ue_sync) / 1000);
if (srslte_ue_sync_nbiot_get_sfidx(&ue_sync) == 0) {
printf("CFO: %+6.2f kHz\r", srslte_ue_sync_nbiot_get_cfo(&ue_sync) / 1000);
frame_cnt++;
}
#ifndef DISABLE_GRAPHICS
if (!disable_plots) {
// get current CFO estimate
cfo_table[cfo_table_index++] = srslte_nbiot_ue_sync_get_cfo(&ue_sync) / 1000;
cfo_table[cfo_table_index++] = srslte_ue_sync_nbiot_get_cfo(&ue_sync) / 1000;
if (cfo_table_index == cfo_num_plot) {
do_plots_cfo(cfo_table, cfo_num_plot);
cfo_table_index = 0;
@ -220,7 +220,7 @@ int main(int argc, char** argv)
}
clean_exit:
srslte_nbiot_ue_sync_free(&ue_sync);
srslte_ue_sync_nbiot_free(&ue_sync);
srslte_rf_close(&rf);
for (uint32_t i = 0; i < SRSLTE_MAX_PORTS; i++) {

14
lib/src/phy/ue/ue_cell_search_nbiot.c
View File

@ -41,7 +41,7 @@ int srslte_ue_cellsearch_nbiot_init(srslte_ue_cellsearch_nbiot_t* q,
ret = SRSLTE_ERROR;
bzero(q, sizeof(srslte_ue_cellsearch_nbiot_t));
if (srslte_nbiot_ue_sync_init_multi(
if (srslte_ue_sync_nbiot_init_multi(
&q->ue_sync, SRSLTE_NBIOT_MAX_PRB, recv_callback, SRSLTE_NBIOT_NUM_RX_ANTENNAS, stream_handler)) {
fprintf(stderr, "Error initiating ue_sync\n");
goto clean_exit;
@ -83,7 +83,7 @@ void srslte_ue_cellsearch_nbiot_free(srslte_ue_cellsearch_nbiot_t* q)
}
}
srslte_nbiot_ue_sync_free(&q->ue_sync);
srslte_ue_sync_nbiot_free(&q->ue_sync);
bzero(q, sizeof(srslte_ue_cellsearch_nbiot_t));
}
@ -108,18 +108,18 @@ int srslte_ue_cellsearch_nbiot_scan(srslte_ue_cellsearch_nbiot_t* q)
if (q != NULL) {
ret = SRSLTE_ERROR;
srslte_nbiot_ue_sync_reset(&q->ue_sync);
srslte_ue_sync_nbiot_reset(&q->ue_sync);
q->nsss_sf_counter = 0;
do {
ret = srslte_nbiot_ue_sync_zerocopy_multi(&q->ue_sync, q->rx_buffer);
ret = srslte_ue_sync_nbiot_zerocopy_multi(&q->ue_sync, q->rx_buffer);
if (ret < 0) {
fprintf(stderr, "Error calling srslte_nbiot_ue_sync_get_buffer()\n");
break;
} else if (ret == 1) {
// we are in sync, wait until we have received two full frames, store subframe 9 for both
DEBUG("In tracking state sf_idx=%d\n", srslte_nbiot_ue_sync_get_sfidx(&q->ue_sync));
if (srslte_nbiot_ue_sync_get_sfidx(&q->ue_sync) == 9) {
DEBUG("In tracking state sf_idx=%d\n", srslte_ue_sync_nbiot_get_sfidx(&q->ue_sync));
if (srslte_ue_sync_nbiot_get_sfidx(&q->ue_sync) == 9) {
// accumulate NSSS subframes for cell id detection
memcpy(&q->nsss_buffer[q->nsss_sf_counter * SRSLTE_SF_LEN_PRB_NBIOT],
q->rx_buffer[0],
@ -150,7 +150,7 @@ int srslte_ue_cellsearch_nbiot_detect(srslte_ue_cellsearch_nbiot_t* q, srslte_nb
found_cells[0].n_id_ncell = (uint32_t)cell_id;
found_cells[0].peak = q->ue_sync.strack.npss.peak_value;
found_cells[0].psr = srslte_sync_nbiot_get_peak_value(&q->ue_sync.strack);
found_cells[0].cfo = srslte_nbiot_ue_sync_get_cfo(&q->ue_sync);
found_cells[0].cfo = srslte_ue_sync_nbiot_get_cfo(&q->ue_sync);
INFO("CELL SEARCH: Found peak PSR=%.3f, Cell_id: %d\n", found_cells[0].psr, found_cells[0].n_id_ncell);
}
}

14
lib/src/phy/ue/ue_mib_nbiot.c
View File

@ -203,7 +203,7 @@ int srslte_ue_mib_sync_nbiot_init_multi(
fprintf(stderr, "Error initiating ue_mib\n");
return SRSLTE_ERROR;
}
if (srslte_nbiot_ue_sync_init_multi(
if (srslte_ue_sync_nbiot_init_multi(
&q->ue_sync, SRSLTE_NBIOT_MAX_PRB, recv_callback, q->nof_rx_antennas, stream_handler)) {
fprintf(stderr, "Error initiating ue_sync\n");
srslte_ue_mib_nbiot_free(&q->ue_mib);
@ -218,7 +218,7 @@ int srslte_ue_mib_sync_nbiot_set_cell(srslte_ue_mib_sync_nbiot_t* q, srslte_nbio
fprintf(stderr, "Error initiating ue_mib\n");
return SRSLTE_ERROR;
}
if (srslte_nbiot_ue_sync_set_cell(&q->ue_sync, cell)) {
if (srslte_ue_sync_nbiot_set_cell(&q->ue_sync, cell)) {
fprintf(stderr, "Error initiating ue_sync\n");
srslte_ue_mib_nbiot_free(&q->ue_mib);
return SRSLTE_ERROR;
@ -229,13 +229,13 @@ int srslte_ue_mib_sync_nbiot_set_cell(srslte_ue_mib_sync_nbiot_t* q, srslte_nbio
void srslte_ue_mib_sync_nbiot_free(srslte_ue_mib_sync_nbiot_t* q)
{
srslte_ue_mib_nbiot_free(&q->ue_mib);
srslte_nbiot_ue_sync_free(&q->ue_sync);
srslte_ue_sync_nbiot_free(&q->ue_sync);
}
void srslte_ue_mib_sync_nbiot_reset(srslte_ue_mib_sync_nbiot_t* q)
{
srslte_ue_mib_nbiot_reset(&q->ue_mib);
srslte_nbiot_ue_sync_reset(&q->ue_sync);
srslte_ue_sync_nbiot_reset(&q->ue_sync);
}
int srslte_ue_mib_sync_nbiot_decode(srslte_ue_mib_sync_nbiot_t* q,
@ -251,11 +251,11 @@ int srslte_ue_mib_sync_nbiot_decode(srslte_ue_mib_sync_nbiot_t* q,
uint32_t nof_frames = 0;
do {
mib_ret = SRSLTE_UE_MIB_NBIOT_NOTFOUND;
ret = srslte_nbiot_ue_sync_zerocopy_multi(&q->ue_sync, q->sf_buffer);
ret = srslte_ue_sync_nbiot_zerocopy_multi(&q->ue_sync, q->sf_buffer);
if (ret < 0) {
fprintf(stderr, "Error calling srslte_nbiot_ue_sync_zerocopy_multi()\n");
fprintf(stderr, "Error calling srslte_ue_sync_nbiot_zerocopy_multi()\n");
break;
} else if (srslte_nbiot_ue_sync_get_sfidx(&q->ue_sync) == 0) {
} else if (srslte_ue_sync_nbiot_get_sfidx(&q->ue_sync) == 0) {
mib_ret = srslte_ue_mib_nbiot_decode(&q->ue_mib, NULL, bch_payload, nof_tx_ports, sfn_offset);
if (mib_ret < 0) {
DEBUG("Resetting NPBCH decoder after %d frames\n", q->ue_mib.frame_cnt);

77
lib/src/phy/ue/ue_sync_nbiot.c
View File

@ -33,33 +33,30 @@
#define REPEAT_FROM_FILE 0
#define TIME_ALIGN_FROM_FILE 1
#define MAX_TIME_OFFSET 128
cf_t dummy[MAX_TIME_OFFSET];
#define TRACK_MAX_LOST 4
#define TRACK_FRAME_SIZE 32
#define FIND_NOF_AVG_FRAMES 4
#define DEFAULT_SFO_EMA_COEFF 0.1
cf_t dummy_buffer_nbiot0[15 * 2048 / 2];
cf_t dummy_buffer_nbiot1[15 * 2048 / 2];
// FIXME: this will break for 4 antennas!!
cf_t* dummy_offset_buffer_nbiot[SRSLTE_MAX_PORTS] = {dummy_buffer_nbiot0, dummy_buffer_nbiot1};
static cf_t dummy_buffer_nbiot0[15 * 2048 / 2];
static cf_t dummy_buffer_nbiot1[15 * 2048 / 2];
static cf_t* dummy_offset_buffer_nbiot[SRSLTE_MAX_PORTS] = {dummy_buffer_nbiot0, dummy_buffer_nbiot1, NULL, NULL};
///< This is a list of CFO candidates that the sync object uses to pre-compensate the received signal
static const float cfo_cands[] =
{0.0, 1000.0, -1000.0, 2000.0, -2000.0, 3000.0, -3000.0, 4000.0, -4000.0, 5000.0, -5000.0};
int srslte_nbiot_ue_sync_init_file(srslte_nbiot_ue_sync_t* q,
int srslte_ue_sync_nbiot_init_file(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
char* file_name,
int offset_time,
float offset_freq)
{
return srslte_nbiot_ue_sync_init_file_multi(q, cell, file_name, offset_time, offset_freq, 1);
return srslte_ue_sync_nbiot_init_file_multi(q, cell, file_name, offset_time, offset_freq, 1);
}
int srslte_nbiot_ue_sync_init_file_multi(srslte_nbiot_ue_sync_t* q,
int srslte_ue_sync_nbiot_init_file_multi(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
char* file_name,
int offset_time,
@ -118,18 +115,18 @@ int srslte_nbiot_ue_sync_init_file_multi(srslte_nbiot_ue_sync_t* q,
INFO("Offseting input file by %d samples and %.1f kHz\n", offset_time, offset_freq / 1000);
srslte_filesource_read(&q->file_source, dummy_buffer_nbiot0, offset_time);
srslte_nbiot_ue_sync_reset(q);
srslte_ue_sync_nbiot_reset(q);
ret = SRSLTE_SUCCESS;
}
clean_exit:
if (ret == SRSLTE_ERROR) {
srslte_nbiot_ue_sync_free(q);
srslte_ue_sync_nbiot_free(q);
}
return ret;
}
int srslte_nbiot_ue_sync_start_agc(srslte_nbiot_ue_sync_t* q,
int srslte_ue_sync_nbiot_start_agc(srslte_nbiot_ue_sync_t* q,
float(set_gain_callback)(void*, float),
float init_gain_value)
{
@ -153,19 +150,19 @@ int recv_callback_nbiot_multi_to_single(void* h, cf_t* x[SRSLTE_MAX_PORTS], uint
return q->recv_callback_single(q->stream_single, (void*)x[0], nsamples, t);
}
int srslte_nbiot_ue_sync_init(srslte_nbiot_ue_sync_t* q,
int srslte_ue_sync_nbiot_init(srslte_nbiot_ue_sync_t* q,
srslte_nbiot_cell_t cell,
int(recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*),
void* stream_handler)
{
int ret = srslte_nbiot_ue_sync_init_multi(
int ret = srslte_ue_sync_nbiot_init_multi(
q, SRSLTE_NBIOT_MAX_PRB, recv_callback_nbiot_multi_to_single, SRSLTE_NBIOT_NUM_RX_ANTENNAS, (void*)q);
q->recv_callback_single = recv_callback;
q->stream_single = stream_handler;
return ret;
}
int srslte_nbiot_ue_sync_init_multi(srslte_nbiot_ue_sync_t* q,
int srslte_ue_sync_nbiot_init_multi(srslte_nbiot_ue_sync_t* q,
uint32_t max_prb,
int(recv_callback)(void*, cf_t* [SRSLTE_MAX_PORTS], uint32_t, srslte_timestamp_t*),
uint32_t nof_rx_antennas,
@ -206,24 +203,24 @@ int srslte_nbiot_ue_sync_init_multi(srslte_nbiot_ue_sync_t* q,
goto clean_exit;
}
srslte_nbiot_ue_sync_reset(q);
srslte_ue_sync_nbiot_reset(q);
ret = SRSLTE_SUCCESS;
}
clean_exit:
if (ret == SRSLTE_ERROR) {
srslte_nbiot_ue_sync_free(q);
srslte_ue_sync_nbiot_free(q);
}
return ret;
}
uint32_t srslte_nbiot_ue_sync_sf_len(srslte_nbiot_ue_sync_t* q)
uint32_t srslte_ue_sync_nbiot_sf_len(srslte_nbiot_ue_sync_t* q)
{
return q->frame_len;
}
void srslte_nbiot_ue_sync_free(srslte_nbiot_ue_sync_t* q)
void srslte_ue_sync_nbiot_free(srslte_nbiot_ue_sync_t* q)
{
if (q->do_agc) {
srslte_agc_free(&q->agc);
@ -237,7 +234,7 @@ void srslte_nbiot_ue_sync_free(srslte_nbiot_ue_sync_t* q)
bzero(q, sizeof(srslte_nbiot_ue_sync_t));
}
int srslte_nbiot_ue_sync_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t cell)
int srslte_ue_sync_nbiot_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t cell)
{
int ret = SRSLTE_ERROR_INVALID_INPUTS;
@ -268,7 +265,7 @@ int srslte_nbiot_ue_sync_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t
return SRSLTE_ERROR;
}
srslte_nbiot_ue_sync_reset(q);
srslte_ue_sync_nbiot_reset(q);
ret = SRSLTE_SUCCESS;
}
@ -276,75 +273,75 @@ int srslte_nbiot_ue_sync_set_cell(srslte_nbiot_ue_sync_t* q, srslte_nbiot_cell_t
return ret;
}
void srslte_nbiot_ue_sync_get_last_timestamp(srslte_nbiot_ue_sync_t* q, srslte_timestamp_t* timestamp)
void srslte_ue_sync_nbiot_get_last_timestamp(srslte_nbiot_ue_sync_t* q, srslte_timestamp_t* timestamp)
{
memcpy(timestamp, &q->last_timestamp, sizeof(srslte_timestamp_t));
}
uint32_t srslte_nbiot_ue_sync_peak_idx(srslte_nbiot_ue_sync_t* q)
uint32_t srslte_ue_sync_nbiot_peak_idx(srslte_nbiot_ue_sync_t* q)
{
return q->peak_idx;
}
srslte_nbiot_ue_sync_state_t srslte_nbiot_ue_sync_get_state(srslte_nbiot_ue_sync_t* q)
srslte_nbiot_ue_sync_state_t srslte_ue_sync_nbiot_get_state(srslte_nbiot_ue_sync_t* q)
{
return q->state;
}
uint32_t srslte_nbiot_ue_sync_get_sfidx(srslte_nbiot_ue_sync_t* q)
uint32_t srslte_ue_sync_nbiot_get_sfidx(srslte_nbiot_ue_sync_t* q)
{
return q->sf_idx;
}
void srslte_nbiot_ue_sync_set_cfo_enable(srslte_nbiot_ue_sync_t* q, bool enable)
void srslte_ue_sync_nbiot_set_cfo_enable(srslte_nbiot_ue_sync_t* q, bool enable)
{
srslte_sync_nbiot_set_cfo_enable(&q->sfind, enable);
srslte_sync_nbiot_set_cfo_enable(&q->strack, enable);
}
float srslte_nbiot_ue_sync_get_cfo(srslte_nbiot_ue_sync_t* q)
float srslte_ue_sync_nbiot_get_cfo(srslte_nbiot_ue_sync_t* q)
{
return 15000 * (q->state == SF_TRACK ? srslte_sync_nbiot_get_cfo(&q->strack) : srslte_sync_nbiot_get_cfo(&q->sfind));
}
void srslte_nbiot_ue_sync_set_cfo(srslte_nbiot_ue_sync_t* q, float cfo)
void srslte_ue_sync_nbiot_set_cfo(srslte_nbiot_ue_sync_t* q, float cfo)
{
srslte_sync_nbiot_set_cfo(&q->sfind, cfo / 15000);
srslte_sync_nbiot_set_cfo(&q->strack, cfo / 15000);
}
float srslte_nbiot_ue_sync_get_sfo(srslte_nbiot_ue_sync_t* q)
float srslte_ue_sync_nbiot_get_sfo(srslte_nbiot_ue_sync_t* q)
{
return q->mean_sfo / 5e-3;
}
int srslte_nbiot_ue_sync_get_last_sample_offset(srslte_nbiot_ue_sync_t* q)
int srslte_ue_sync_nbiot_get_last_sample_offset(srslte_nbiot_ue_sync_t* q)
{
return q->last_sample_offset;
}
void srslte_nbiot_ue_sync_set_sample_offset_correct_period(srslte_nbiot_ue_sync_t* q, uint32_t nof_subframes)
void srslte_ue_sync_nbiot_set_sample_offset_correct_period(srslte_nbiot_ue_sync_t* q, uint32_t nof_subframes)
{
q->sample_offset_correct_period = nof_subframes;
}
void srslte_nbiot_ue_sync_set_cfo_ema(srslte_nbiot_ue_sync_t* q, float ema)
void srslte_ue_sync_nbiot_set_cfo_ema(srslte_nbiot_ue_sync_t* q, float ema)
{
srslte_sync_nbiot_set_cfo_ema_alpha(&q->sfind, ema);
srslte_sync_nbiot_set_cfo_ema_alpha(&q->strack, ema);
}
void srslte_nbiot_ue_sync_set_cfo_tol(srslte_nbiot_ue_sync_t* q, float cfo_tol)
void srslte_ue_sync_nbiot_set_cfo_tol(srslte_nbiot_ue_sync_t* q, float cfo_tol)
{
srslte_sync_nbiot_set_cfo_tol(&q->sfind, cfo_tol);
srslte_sync_nbiot_set_cfo_tol(&q->strack, cfo_tol);
}
void srslte_nbiot_ue_sync_set_sfo_ema(srslte_nbiot_ue_sync_t* q, float ema_coefficient)
void srslte_ue_sync_nbiot_set_sfo_ema(srslte_nbiot_ue_sync_t* q, float ema_coefficient)
{
q->sfo_ema = ema_coefficient;
}
void srslte_nbiot_ue_sync_set_agc_period(srslte_nbiot_ue_sync_t* q, uint32_t period)
void srslte_ue_sync_nbiot_set_agc_period(srslte_nbiot_ue_sync_t* q, uint32_t period)
{
q->agc_period = period;
}
@ -425,7 +422,7 @@ static int track_peak_ok(srslte_nbiot_ue_sync_t* q, uint32_t track_idx)
INFO("Time offset adjustment: %d samples (%.2f), mean SFO: %.2f Hz, %.5f samples/10-sf, ema=%f, length=%d\n",
q->next_rf_sample_offset,
q->mean_sample_offset,
srslte_nbiot_ue_sync_get_sfo(q),
srslte_ue_sync_nbiot_get_sfo(q),
q->mean_sfo,
q->sfo_ema,
q->sample_offset_correct_period);
@ -497,15 +494,15 @@ static int receive_samples(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer[SRSLTE_
return SRSLTE_SUCCESS;
}
int srslte_nbiot_ue_sync_zerocopy(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer)
int srslte_ue_sync_nbiot_zerocopy(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer)
{
cf_t* _input_buffer[SRSLTE_MAX_PORTS] = {NULL};
_input_buffer[0] = input_buffer;
return srslte_nbiot_ue_sync_zerocopy_multi(q, _input_buffer);
return srslte_ue_sync_nbiot_zerocopy_multi(q, _input_buffer);
}
/* Returns 1 if the subframe is synchronized in time, 0 otherwise */
int srslte_nbiot_ue_sync_zerocopy_multi(srslte_nbiot_ue_sync_t* q, cf_t* input_buffer[SRSLTE_MAX_PORTS])
int srslte_ue_sync_nbiot_zerocopy_multi(srslte_nbiot_ue_sync_t* q, cf_t** input_buffer)
{
int ret = SRSLTE_ERROR_INVALID_INPUTS;
@ -629,7 +626,7 @@ int srslte_nbiot_ue_sync_zerocopy_multi(srslte_nbiot_ue_sync_t* q, cf_t* input_b
return ret;
}
void srslte_nbiot_ue_sync_reset(srslte_nbiot_ue_sync_t* q)
void srslte_ue_sync_nbiot_reset(srslte_nbiot_ue_sync_t* q)
{
///< Set default params
srslte_sync_nbiot_set_cfo_enable(&q->sfind, true);