diff --git a/srslte/tutorial_examples/CMakeLists.txt b/srslte/tutorial_examples/CMakeLists.txt new file mode 100644 index 000000000..927fbbeaa --- /dev/null +++ b/srslte/tutorial_examples/CMakeLists.txt @@ -0,0 +1,42 @@ +# +# Copyright 2012-2013 The libLTE Developers. See the +# COPYRIGHT file at the top-level directory of this distribution. +# +# This file is part of the libLTE library. +# +# libLTE is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of +# the License, or (at your option) any later version. +# +# libLTE 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 Lesser General Public License for more details. +# +# A copy of the GNU Lesser 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/. +# + + +################################################################# +# EXAMPLES shown in WinnForum 2015 Tutorial +################################################################# + + +FIND_PACKAGE(LIBSDRGUI) + +IF(LIBSDRGUI_FOUND) + include_directories(${LIBSDRGUI_INCLUDE_DIRS}) + + add_executable(pss pss.c) + target_link_libraries(pss srslte cuhd ${LIBSDRGUI_LIBRARIES}) + + include_directories("../examples") + add_executable(ue_rx ue_rx.c ../examples/cuhd_utils.c) + target_link_libraries(ue_rx srslte cuhd ${LIBSDRGUI_LIBRARIES} pthread) +ENDIF(LIBSDRGUI_FOUND) + +add_executable(simple_tx simple_tx.c) +target_link_libraries(simple_tx srslte cuhd) diff --git a/srslte/tutorial_examples/pss.c b/srslte/tutorial_examples/pss.c new file mode 100644 index 000000000..f0406e7d1 --- /dev/null +++ b/srslte/tutorial_examples/pss.c @@ -0,0 +1,400 @@ +/** + * + * \section COPYRIGHT + * + * Copyright 2013-2014 The libLTE Developers. See the + * COPYRIGHT file at the top-level directory of this distribution. + * + * \section LICENSE + * + * This file is part of the libLTE library. + * + * libLTE is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * libLTE 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 Lesser General Public License for more details. + * + * A copy of the GNU Lesser 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 +#include +#include +#include +#include +#include +#include + +#include + +#include "srslte/srslte.h" +#include "srslte/cuhd/cuhd.h" + + +#ifndef DISABLE_GRAPHICS +void init_plots(); +void do_plots(float *corr, float energy, uint32_t size, cf_t ce[SRSLTE_PSS_LEN]); +void do_plots_sss(float *corr_m0, float *corr_m1); +#endif + + +bool disable_plots = false; +int cell_id = -1; +char *uhd_args=""; +float uhd_gain=40.0, uhd_freq=-1.0; +int nof_frames = -1; +uint32_t fft_size=128; +float threshold = 0.4; +int N_id_2_sync = -1; +srslte_cp_t cp=SRSLTE_SRSLTE_CP_NORM; + +void usage(char *prog) { + printf("Usage: %s [aedgtvnp] -f rx_frequency_hz -i cell_id\n", prog); + printf("\t-a UHD args [Default %s]\n", uhd_args); + printf("\t-g UHD Gain [Default %.2f dB]\n", uhd_gain); + printf("\t-n nof_frames [Default %d]\n", nof_frames); + printf("\t-l N_id_2 to sync [Default use cell_id]\n"); + printf("\t-e Extended CP [Default Normal]\n", fft_size); + printf("\t-s symbol_sz [Default %d]\n", fft_size); + printf("\t-t threshold [Default %.2f]\n", threshold); +#ifndef DISABLE_GRAPHICS + printf("\t-d disable plots [Default enabled]\n"); +#else + printf("\t plots are disabled. Graphics library not available\n"); +#endif + printf("\t-v srslte_verbose\n"); +} + +void parse_args(int argc, char **argv) { + int opt; + while ((opt = getopt(argc, argv, "adgetvsfil")) != -1) { + switch (opt) { + case 'a': + uhd_args = argv[optind]; + break; + case 'g': + uhd_gain = atof(argv[optind]); + break; + case 'f': + uhd_freq = atof(argv[optind]); + break; + case 't': + threshold = atof(argv[optind]); + break; + case 'e': + cp = SRSLTE_SRSLTE_CP_EXT; + break; + case 'i': + cell_id = atoi(argv[optind]); + break; + case 'l': + N_id_2_sync = atoi(argv[optind]); + break; + case 's': + fft_size = atoi(argv[optind]); + break; + case 'n': + nof_frames = atoi(argv[optind]); + break; + case 'd': + disable_plots = true; + break; + case 'v': + srslte_verbose++; + break; + default: + usage(argv[0]); + exit(-1); + } + } + if (cell_id < 0 || uhd_freq < 0) { + usage(argv[0]); + exit(-1); + } +} + float m0_value, m1_value; + +int main(int argc, char **argv) { + cf_t *buffer; + int frame_cnt, n; + void *uhd; + srslte_pss_synch_t pss; + srslte_cfo_t cfocorr, cfocorr64; + srslte_sss_synch_t sss; + int32_t flen; + int peak_idx, last_peak; + float peak_value; + float mean_peak; + uint32_t nof_det, nof_nodet, nof_nopeak, nof_nopeakdet; + cf_t ce[SRSLTE_PSS_LEN]; + + parse_args(argc, argv); + + if (N_id_2_sync == -1) { + N_id_2_sync = cell_id%3; + } + uint32_t N_id_2 = cell_id%3; + uint32_t N_id_1 = cell_id/3; + +#ifndef DISABLE_GRAPHICS + if (!disable_plots) + init_plots(); +#endif + + flen = 4800*(fft_size/64); + + buffer = malloc(sizeof(cf_t) * flen * 2); + if (!buffer) { + perror("malloc"); + exit(-1); + } + + if (srslte_pss_synch_init_fft(&pss, flen, fft_size)) { + fprintf(stderr, "Error initiating PSS\n"); + exit(-1); + } + + if (srslte_pss_synch_set_N_id_2(&pss, N_id_2_sync)) { + fprintf(stderr, "Error setting N_id_2=%d\n",N_id_2_sync); + exit(-1); + } + + srslte_cfo_init(&cfocorr, flen); + srslte_cfo_init(&cfocorr64, flen); + + if (srslte_sss_synch_init(&sss, fft_size)) { + fprintf(stderr, "Error initializing SSS object\n"); + return SRSLTE_ERROR; + } + + srslte_sss_synch_set_N_id_2(&sss, N_id_2); + + printf("Opening UHD device...\n"); + if (cuhd_open(uhd_args, &uhd)) { + fprintf(stderr, "Error opening uhd\n"); + exit(-1); + } + printf("N_id_2: %d\n", N_id_2); + printf("Set RX rate: %.2f MHz\n", cuhd_set_rx_srate(uhd, flen*2*100) / 1000000); + printf("Set RX gain: %.1f dB\n", cuhd_set_rx_gain(uhd, uhd_gain)); + printf("Set RX freq: %.2f MHz\n", cuhd_set_rx_freq(uhd, uhd_freq) / 1000000); + cuhd_rx_wait_lo_locked(uhd); + cuhd_start_rx_stream(uhd); + + printf("Frame length %d samples\n", flen); + printf("PSS detection threshold: %.2f\n", threshold); + + nof_det = nof_nodet = nof_nopeak = nof_nopeakdet = 0; + frame_cnt = 0; + last_peak = 0; + mean_peak = 0; + int peak_offset = 0; + float cfo; + float mean_cfo = 0; + uint32_t m0, m1; + uint32_t sss_error1 = 0, sss_error2 = 0, sss_error3 = 0; + uint32_t cp_is_norm = 0; + + srslte_sync_t ssync; + bzero(&ssync, sizeof(srslte_sync_t)); + ssync.fft_size = fft_size; + + while(frame_cnt < nof_frames || nof_frames == -1) { + peak_offset = 0; + n = cuhd_recv(uhd, buffer, flen - peak_offset, 1); + if (n < 0) { + fprintf(stderr, "Error receiving samples\n"); + exit(-1); + } + + peak_idx = srslte_pss_synch_find_pss(&pss, buffer, &peak_value); + if (peak_idx < 0) { + fprintf(stderr, "Error finding PSS peak\n"); + exit(-1); + } + + mean_peak = SRSLTE_VEC_CMA(peak_value, mean_peak, frame_cnt); + + if (peak_value >= threshold) { + nof_det++; + + if (peak_idx >= fft_size) { + + // Estimate CFO + cfo = srslte_pss_synch_cfo_compute(&pss, &buffer[peak_idx-fft_size]); + mean_cfo = SRSLTE_VEC_CMA(cfo, mean_cfo, frame_cnt); + + // Correct CFO + srslte_cfo_correct(&cfocorr, buffer, buffer, -mean_cfo / fft_size); + + // Estimate channel + if (srslte_pss_synch_chest(&pss, &buffer[peak_idx-fft_size], ce)) { + fprintf(stderr, "Error computing channel estimation\n"); + exit(-1); + } + + // Find SSS + int sss_idx = peak_idx-2*fft_size-(SRSLTE_CP_ISNORM(cp)?SRSLTE_CP(fft_size, SRSLTE_SRSLTE_CP_NORM_LEN):SRSLTE_CP(fft_size, SRSLTE_SRSLTE_CP_EXT_LEN)); + if (sss_idx >= 0 && sss_idx < flen-fft_size) { + srslte_sss_synch_m0m1_partial(&sss, &buffer[sss_idx], 3, NULL, &m0, &m0_value, &m1, &m1_value); + if (srslte_sss_synch_N_id_1(&sss, m0, m1) != N_id_1) { + sss_error2++; + } + INFO("Partial N_id_1: %d\n", srslte_sss_synch_N_id_1(&sss, m0, m1)); + srslte_sss_synch_m0m1_diff(&sss, &buffer[sss_idx], &m0, &m0_value, &m1, &m1_value); + if (srslte_sss_synch_N_id_1(&sss, m0, m1) != N_id_1) { + sss_error3++; + } + INFO("Diff N_id_1: %d\n", srslte_sss_synch_N_id_1(&sss, m0, m1)); + srslte_sss_synch_m0m1_partial(&sss, &buffer[sss_idx], 1, NULL, &m0, &m0_value, &m1, &m1_value); + if (srslte_sss_synch_N_id_1(&sss, m0, m1) != N_id_1) { + sss_error1++; + } + INFO("Full N_id_1: %d\n", srslte_sss_synch_N_id_1(&sss, m0, m1)); + } + + // Estimate CP + if (peak_idx > 2*(fft_size + SRSLTE_CP_EXT(fft_size))) { + srslte_cp_t cp = srslte_sync_detect_cp(&ssync, buffer, peak_idx); + if (SRSLTE_CP_ISNORM(cp)) { + cp_is_norm++; + } + } + + } else { + INFO("No space for CFO computation. Frame starts at \n",peak_idx); + } + + if(srslte_sss_synch_subframe(m0,m1) == 0) + { +#ifndef DISABLE_GRAPHICS + if (!disable_plots) + do_plots_sss(sss.corr_output_m0, sss.corr_output_m1); +#endif + } + + } else { + nof_nodet++; + } + + if (frame_cnt > 100) { + if (abs(last_peak-peak_idx) > 4) { + if (peak_value >= threshold) { + nof_nopeakdet++; + } + nof_nopeak++; + } + } + + frame_cnt++; + + printf("[%5d]: Pos: %5d, PSR: %4.1f (~%4.1f) Pdet: %4.2f, " + "FA: %4.2f, CFO: %+4.1f KHz SSSmiss: %4.2f/%4.2f/%4.2f CPNorm: %.0f\%\r", + frame_cnt, + peak_idx, + peak_value, mean_peak, + (float) nof_det/frame_cnt, + (float) nof_nopeakdet/frame_cnt, mean_cfo*15, + (float) sss_error1/nof_det,(float) sss_error2/nof_det,(float) sss_error3/nof_det, + (float) cp_is_norm/nof_det * 100); + + if (SRSLTE_VERBOSE_ISINFO()) { + printf("\n"); + } + +#ifndef DISABLE_GRAPHICS + if (!disable_plots) + do_plots(pss.conv_output_avg, pss.conv_output_avg[peak_idx], pss.fft_size+pss.frame_size-1, ce); +#endif + + last_peak = peak_idx; + + } + + srslte_pss_synch_free(&pss); + free(buffer); + cuhd_close(uhd); + + printf("Ok\n"); + exit(0); +} + +extern cf_t *tmp2; + + +/********************************************************************** + * Plotting Functions + ***********************************************************************/ +#ifndef DISABLE_GRAPHICS + + +#include "libsdrgui/libsdrgui.h" +plot_real_t pssout; +//plot_complex_t pce; + +plot_real_t psss1;//, psss2; + +float tmp[100000]; +cf_t tmpce[SRSLTE_PSS_LEN]; + + +void init_plots() { + sdrgui_init(); + plot_real_init(&pssout); + plot_real_setTitle(&pssout, "PSS xCorr"); + plot_real_setLabels(&pssout, "Index", "Absolute value"); + plot_real_setYAxisScale(&pssout, 0, 1); + + /* + plot_complex_init(&pce); + plot_complex_setTitle(&pce, "Channel Estimates"); + plot_complex_setYAxisScale(&pce, Ip, -2, 2); + plot_complex_setYAxisScale(&pce, Q, -2, 2); + plot_complex_setYAxisScale(&pce, Magnitude, 0, 2); + plot_complex_setYAxisScale(&pce, Phase, -M_PI, M_PI); + */ + + plot_real_init(&psss1); + plot_real_setTitle(&psss1, "SSS xCorr m0"); + plot_real_setLabels(&psss1, "Index", "Absolute value"); + plot_real_setYAxisScale(&psss1, 0, 1); + + /* + plot_real_init(&psss2); + plot_real_setTitle(&psss2, "SSS xCorr m1"); + plot_real_setLabels(&psss2, "Index", "Absolute value"); + plot_real_setYAxisScale(&psss2, 0, 1); + */ + + +} + +void do_plots(float *corr, float energy, uint32_t size, cf_t ce[SRSLTE_PSS_LEN]) { + srslte_vec_sc_prod_fff(corr,1./energy,tmp, size); + plot_real_setNewData(&pssout, tmp, size); + +// float norm = srslte_vec_avg_power_cf(ce, SRSLTE_PSS_LEN); + // srslte_vec_sc_prod_cfc(ce, 1.0/sqrt(norm), tmpce, SRSLTE_PSS_LEN); + + //plot_complex_setNewData(&pce, tmpce, SRSLTE_PSS_LEN); +} + +void do_plots_sss(float *corr_m0, float *corr_m1) { + if (m0_value > 0) + srslte_vec_sc_prod_fff(corr_m0,1./m0_value,corr_m0, SRSLTE_SSS_N); + plot_real_setNewData(&psss1, corr_m0, SRSLTE_SSS_N); + +// if (m1_value > 0) +// srslte_vec_sc_prod_fff(corr_m1,1./m1_value,corr_m1, SRSLTE_SSS_N); +// plot_real_setNewData(&psss2, corr_m1, SRSLTE_SSS_N); +} + +#endif diff --git a/srslte/tutorial_examples/simple_tx.c b/srslte/tutorial_examples/simple_tx.c new file mode 100644 index 000000000..57bb94d5b --- /dev/null +++ b/srslte/tutorial_examples/simple_tx.c @@ -0,0 +1,263 @@ +/** + * + * \section COPYRIGHT + * + * Copyright 2013-2014 The srsLTE Developers. See the + * COPYRIGHT file at the top-level directory of this distribution. + * + * \section LICENSE + * + * This file is part of the srsLTE library. + * + * srsLTE is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser 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 Lesser General Public License for more details. + * + * A copy of the GNU Lesser 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 +#include +#include +#include +#include +#include +#include +#include + +#include "srslte/srslte.h" + +#include "srslte/cuhd/cuhd.h" +void *uhd; + +char *output_file_name = NULL; + +srslte_cell_t cell = { + 6, // nof_prb + 1, // nof_ports + 1, // cell_id + SRSLTE_SRSLTE_CP_NORM, // cyclic prefix + SRSLTE_PHICH_R_1, // PHICH resources + SRSLTE_PHICH_NORM // PHICH length +}; + + +char *uhd_args = ""; +float uhd_amp = 0.5, uhd_gain = 30.0, uhd_freq = 2400000000; + +bool null_file_sink=false; +srslte_filesink_t fsink; +srslte_ofdm_t ifft; +srslte_mod_t modulation; + +uint32_t sf_n_re, sf_n_samples; + +cf_t *sf_buffer = NULL, *output_buffer = NULL; + +void usage(char *prog) { + printf("Usage: %s [algfmv]\n", prog); + printf("\t-a UHD args [Default %s]\n", uhd_args); + printf("\t-l UHD amplitude [Default %.2f]\n", uhd_amp); + printf("\t-g UHD TX gain [Default %.2f dB]\n", uhd_gain); + printf("\t-f UHD TX frequency [Default %.1f MHz]\n", uhd_freq / 1000000); + printf("\t-m modulation (1: BPSK, 2: QPSK, 3: QAM16, 4: QAM64) [Default BPSK]\n"); + printf("\t-v [set srslte_verbose to debug, default none]\n"); +} + +void parse_args(int argc, char **argv) { + int opt; + while ((opt = getopt(argc, argv, "algfmv")) != -1) { + switch (opt) { + case 'a': + uhd_args = argv[optind]; + break; + case 'g': + uhd_gain = atof(argv[optind]); + break; + case 'l': + uhd_amp = atof(argv[optind]); + break; + case 'f': + uhd_freq = atof(argv[optind]); + break; + case 'm': + switch(atoi(argv[optind])) { + case 1: + modulation = SRSLTE_MOD_BPSK; + break; + case 2: + modulation = SRSLTE_MOD_QPSK; + break; + case 4: + modulation = SRSLTE_MOD_16QAM; + break; + case 6: + modulation = SRSLTE_MOD_64QAM; + break; + default: + fprintf(stderr, "Invalid modulation %d. Possible values: " + "(1: BPSK, 2: QPSK, 3: QAM16, 4: QAM64)\n", atoi(argv[optind])); + break; + } + break; + case 'v': + srslte_verbose++; + break; + default: + usage(argv[0]); + exit(-1); + } + } +#ifdef DISABLE_UHD + if (!output_file_name) { + usage(argv[0]); + exit(-1); + } +#endif +} + +void base_init() { + + /* init memory */ + sf_buffer = malloc(sizeof(cf_t) * sf_n_re); + if (!sf_buffer) { + perror("malloc"); + exit(-1); + } + output_buffer = malloc(sizeof(cf_t) * sf_n_samples); + if (!output_buffer) { + perror("malloc"); + exit(-1); + } + printf("Opening UHD device...\n"); + if (cuhd_open(uhd_args, &uhd)) { + fprintf(stderr, "Error opening uhd\n"); + exit(-1); + } + + /* create ifft object */ + if (srslte_ofdm_rx_init(&ifft, SRSLTE_SRSLTE_CP_NORM, cell.nof_prb)) { + fprintf(stderr, "Error creating iFFT object\n"); + exit(-1); + } + srslte_ofdm_set_normalize(&ifft, true); +} + +void base_free() { + + srslte_ofdm_rx_free(&ifft); + + if (sf_buffer) { + free(sf_buffer); + } + if (output_buffer) { + free(output_buffer); + } + cuhd_close(&uhd); +} + + +int main(int argc, char **argv) { + int sf_idx=0, N_id_2=0; + cf_t pss_signal[SRSLTE_PSS_LEN]; + float sss_signal0[SRSLTE_SSS_LEN]; // for subframe 0 + float sss_signal5[SRSLTE_SSS_LEN]; // for subframe 5 + int i; + +#ifdef DISABLE_UHD + if (argc < 3) { + usage(argv[0]); + exit(-1); + } +#endif + + parse_args(argc, argv); + + N_id_2 = cell.id % 3; + sf_n_re = 2 * SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB * cell.nof_prb * SRSLTE_NRE; + sf_n_samples = 2 * SRSLTE_SLOT_LEN(srslte_symbol_sz(cell.nof_prb)); + + cell.phich_length = SRSLTE_PHICH_NORM; + cell.phich_resources = SRSLTE_PHICH_R_1; + + /* this *must* be called after setting slot_len_* */ + base_init(); + + /* Generate PSS/SSS signals */ + srslte_pss_generate(pss_signal, N_id_2); + srslte_sss_generate(sss_signal0, sss_signal5, cell.id); + + printf("Set TX rate: %.2f MHz\n", + cuhd_set_tx_srate(uhd, srslte_sampling_freq_hz(cell.nof_prb)) / 1000000); + printf("Set TX gain: %.1f dB\n", cuhd_set_tx_gain(uhd, uhd_gain)); + printf("Set TX freq: %.2f MHz\n", + cuhd_set_tx_freq(uhd, uhd_freq) / 1000000); + + uint32_t nbits; + + srslte_modem_table_t modulator; + srslte_modem_table_init(&modulator); + srslte_modem_table_lte(&modulator, modulation, false); + + srslte_tcod_t turbocoder; + srslte_tcod_init(&turbocoder, MAX_LONG_CB); + + srslte_dft_precoding_t dft_precod; + srslte_dft_precoding_init(&dft_precod, 12); + + nbits = srslte_find_cb_index(sf_n_samples/8/srslte_mod_bits_x_symbol(modulation)/3 - 12); + uint32_t ncoded_bits = sf_n_samples/8/srslte_mod_bits_x_symbol(modulation); + + uint8_t *data = malloc(sizeof(uint8_t)*nbits); + uint8_t *data_enc = malloc(sizeof(uint8_t)*ncoded_bits); + cf_t *symbols = malloc(sizeof(cf_t)*sf_n_samples); + + bzero(data_enc, sizeof(uint8_t)*ncoded_bits); + while (1) { + for (sf_idx = 0; sf_idx < SRSLTE_NSUBFRAMES_X_FRAME; sf_idx++) { + bzero(sf_buffer, sizeof(cf_t) * sf_n_re); + +#ifdef kk + if (sf_idx == 0 || sf_idx == 5) { + srslte_pss_put_slot(pss_signal, sf_buffer, cell.nof_prb, SRSLTE_SRSLTE_CP_NORM); + srslte_sss_put_slot(sf_idx ? sss_signal5 : sss_signal0, sf_buffer, cell.nof_prb, + SRSLTE_SRSLTE_CP_NORM); + /* Transform to OFDM symbols */ + srslte_ofdm_rx_sf(&ifft, sf_buffer, output_buffer); + + float norm_factor = (float) sqrtf(cell.nof_prb)/15; + srslte_vec_sc_prod_cfc(output_buffer, uhd_amp*norm_factor, output_buffer, SRSLTE_SF_LEN_PRB(cell.nof_prb)); + + } else { +#endif + /* Generate random data */ + for (i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "srslte/srslte.h" + + +#ifndef DISABLE_UHD +#include "srslte/cuhd/cuhd.h" +#include "cuhd_utils.h" + +cell_search_cfg_t cell_detect_config = { + 5000, + 100, // nof_frames_total + 16.0 // threshold +}; + +#endif + +//#define STDOUT_COMPACT + +#ifndef DISABLE_GRAPHICS +#include "libsdrgui/libsdrgui.h" +void init_plots(); +pthread_t plot_thread; +sem_t plot_sem; +uint32_t plot_sf_idx=0; +#endif + + +#define B210_DEFAULT_GAIN 40.0 +#define B210_DEFAULT_GAIN_CORREC 110.0 // Gain of the Rx chain when the gain is set to 40 + +float gain_offset = B210_DEFAULT_GAIN_CORREC; + + +/********************************************************************** + * Program arguments processing + ***********************************************************************/ +typedef struct { + int nof_subframes; + bool disable_plots; + int force_N_id_2; + bool enable_cfo; + int time_offset; + uint16_t rnti; + char *input_file_name; + uint32_t file_nof_prb; + char *uhd_args; + float uhd_freq; + float uhd_freq_offset; + float uhd_gain; + int net_port; + char *net_address; + int net_port_signal; + char *net_address_signal; +}prog_args_t; + +void args_default(prog_args_t *args) { + args->nof_subframes = -1; + args->rnti = SRSLTE_SIRNTI; + args->force_N_id_2 = -1; // Pick the best + args->input_file_name = NULL; + args->enable_cfo = true; + args->time_offset = 0; + args->file_nof_prb = 6; + args->uhd_args = ""; + args->uhd_freq = -1.0; + args->uhd_freq = 8000000.0; + args->uhd_gain = 60.0; + args->net_port = -1; + args->net_address = "127.0.0.1"; + args->net_port_signal = -1; + args->net_address_signal = "127.0.0.1"; +} + +void usage(prog_args_t *args, char *prog) { + printf("Usage: %s [agilcdnruv] -f rx_frequency (in Hz) | -i input_file\n", prog); +#ifndef DISABLE_UHD + printf("\t-a UHD args [Default %s]\n", args->uhd_args); + printf("\t-g UHD RX gain [Default %.2f dB]\n", args->uhd_gain); + printf("\t-o UHD RX freq offset [Default %.1f MHz]\n", args->uhd_freq_offset/1000000); +#else + printf("\t UHD is disabled. CUHD library not available\n"); +#endif + printf("\t-i input_file [Default USRP]\n"); + printf("\t-p nof_prb for input file [Default %d]\n", args->file_nof_prb); + printf("\t-r RNTI [Default 0x%x]\n",args->rnti); + printf("\t-l Force N_id_2 [Default best]\n"); + printf("\t-c Disable CFO correction [Default %s]\n", args->enable_cfo?"Enabled":"Disabled"); + printf("\t-t Add time offset [Default %d]\n", args->time_offset); +#ifndef DISABLE_GRAPHICS + printf("\t-d disable plots [Default enabled]\n"); +#else + printf("\t plots are disabled. Graphics library not available\n"); +#endif + printf("\t-n nof_subframes [Default %d]\n", args->nof_subframes); + printf("\t-s remote UDP port to send input signal (-1 does nothing with it) [Default %d]\n", args->net_port_signal); + printf("\t-S remote UDP address to send input signal [Default %s]\n", args->net_address_signal); + printf("\t-u remote TCP port to send data (-1 does nothing with it) [Default %d]\n", args->net_port); + printf("\t-U remote TCP address to send data [Default %s]\n", args->net_address); + printf("\t-v [set srslte_verbose to debug, default none]\n"); +} + +void parse_args(prog_args_t *args, int argc, char **argv) { + int opt; + args_default(args); + while ((opt = getopt(argc, argv, "aoglipdnvrfctuUsS")) != -1) { + switch (opt) { + case 'i': + args->input_file_name = argv[optind]; + break; + case 'p': + args->file_nof_prb = atoi(argv[optind]); + break; + case 'a': + args->uhd_args = argv[optind]; + break; + case 'g': + args->uhd_gain = atof(argv[optind]); + break; + case 'o': + args->uhd_freq_offset = atof(argv[optind]); + break; + case 'f': + args->uhd_freq = atof(argv[optind]); + break; + case 'n': + args->nof_subframes = atoi(argv[optind]); + break; + case 'c': + args->enable_cfo = false; + break; + case 't': + args->time_offset = atoi(argv[optind]); + break; + case 'r': + args->rnti = atoi(argv[optind]); + break; + case 'l': + args->force_N_id_2 = atoi(argv[optind]); + break; + case 'u': + args->net_port = atoi(argv[optind]); + break; + case 'U': + args->net_address = argv[optind]; + break; + case 's': + args->net_port_signal = atoi(argv[optind]); + break; + case 'S': + args->net_address_signal = argv[optind]; + break; + case 'd': + args->disable_plots = true; + break; + case 'v': + srslte_verbose++; + break; + default: + usage(args, argv[0]); + exit(-1); + } + } + if (args->uhd_freq < 0 && args->input_file_name == NULL) { + usage(args, argv[0]); + exit(-1); + } +} +/**********************************************************************/ + +/* TODO: Do something with the output data */ +uint8_t data[20000], data_packed[20000]; + +bool go_exit = false; + +void sig_int_handler(int signo) +{ + if (signo == SIGINT) { + go_exit = true; + } +} + +#ifndef DISABLE_UHD +int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) { + DEBUG(" ---- Receive %d samples ---- \n", nsamples); + return cuhd_recv(h, data, nsamples, 1); +} +#endif + +extern float mean_exec_time; + +enum receiver_state { DECODE_MIB, DECODE_PDSCH} state; + +srslte_ue_dl_t ue_dl; +srslte_ue_sync_t ue_sync; +prog_args_t prog_args; + +uint32_t sfn = 0; // system frame number +cf_t *sf_buffer = NULL; +srslte_netsink_t net_sink, net_sink_signal; + +int main(int argc, char **argv) { + int ret; + srslte_cell_t cell; + int64_t sf_cnt; + srslte_ue_mib_t ue_mib; +#ifndef DISABLE_UHD + void *uhd; +#endif + uint32_t nof_trials = 0; + int n; + uint8_t bch_payload[BCH_PAYLOAD_LEN]; + uint32_t sfn_offset; + + parse_args(&prog_args, argc, argv); + + if (prog_args.net_port > 0) { + if (srslte_netsink_init(&net_sink, prog_args.net_address, prog_args.net_port, SRSLTE_NETSINK_TCP)) { + fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address, prog_args.net_port); + exit(-1); + } + srslte_netsink_set_nonblocking(&net_sink); + } + if (prog_args.net_port_signal > 0) { + if (srslte_netsink_init(&net_sink_signal, prog_args.net_address_signal, prog_args.net_port_signal, SRSLTE_NETSINK_UDP)) { + fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address_signal, prog_args.net_port_signal); + exit(-1); + } + srslte_netsink_set_nonblocking(&net_sink_signal); + } + +#ifndef DISABLE_UHD + if (!prog_args.input_file_name) { + printf("Opening UHD device...\n"); + if (cuhd_open(prog_args.uhd_args, &uhd)) { + fprintf(stderr, "Error opening uhd\n"); + exit(-1); + } + /* Set receiver gain */ + cuhd_set_rx_gain(uhd, prog_args.uhd_gain); + + /* set receiver frequency */ + cuhd_set_rx_freq_offset(uhd, (double) prog_args.uhd_freq, prog_args.uhd_freq_offset); + cuhd_rx_wait_lo_locked(uhd); + printf("Tunning receiver to %.3f MHz\n", (double ) prog_args.uhd_freq/1000000); + + ret = cuhd_search_and_decode_mib(uhd, &cell_detect_config, prog_args.force_N_id_2, &cell); + if (ret < 0) { + fprintf(stderr, "Error searching for cell\n"); + exit(-1); + } else if (ret == 0) { + printf("Cell not found\n"); + exit(0); + } + + /* set sampling frequency */ + int srate = srslte_sampling_freq_hz(cell.nof_prb); + if (srate != -1) { + cuhd_set_rx_srate(uhd, (double) srate); + } else { + fprintf(stderr, "Invalid number of PRB %d\n", cell.nof_prb); + return SRSLTE_ERROR; + } + + INFO("Stopping UHD and flushing buffer...\r",0); + cuhd_stop_rx_stream(uhd); + cuhd_flush_buffer(uhd); + + if (srslte_ue_mib_init(&ue_mib, cell)) { + fprintf(stderr, "Error initaiting UE MIB decoder\n"); + exit(-1); + } + } +#endif + + /* If reading from file, go straight to PDSCH decoding. Otherwise, decode MIB first */ + if (prog_args.input_file_name) { + state = DECODE_PDSCH; + /* preset cell configuration */ + cell.id = 1; + cell.cp = SRSLTE_SRSLTE_CP_NORM; + cell.phich_length = SRSLTE_PHICH_NORM; + cell.phich_resources = SRSLTE_PHICH_R_1; + cell.nof_ports = 1; + cell.nof_prb = prog_args.file_nof_prb; + + if (srslte_ue_sync_init_file(&ue_sync, prog_args.file_nof_prb, prog_args.input_file_name)) { + fprintf(stderr, "Error initiating ue_sync\n"); + exit(-1); + } + + } else { +#ifndef DISABLE_UHD + state = DECODE_MIB; + if (srslte_ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) { + fprintf(stderr, "Error initiating ue_sync\n"); + exit(-1); + } +#endif + } + + if (srslte_ue_dl_init(&ue_dl, cell)) { // This is the User RNTI + fprintf(stderr, "Error initiating UE downlink processing module\n"); + exit(-1); + } + + /* Configure downlink receiver for the SI-RNTI since will be the only one we'll use */ + srslte_ue_dl_set_rnti(&ue_dl, prog_args.rnti); + + /* Initialize subframe counter */ + sf_cnt = 0; + + // Register Ctrl+C handler + signal(SIGINT, sig_int_handler); + +#ifndef DISABLE_GRAPHICS + if (!prog_args.disable_plots) { + init_plots(cell); + } +#endif + +#ifndef DISABLE_UHD + if (!prog_args.input_file_name) { + cuhd_start_rx_stream(uhd); + } +#endif + + // Variables for measurements + uint32_t nframes=0; + float rsrp=0.0, rsrq=0.0, snr=0.0; + bool decode_pdsch; + int pdcch_tx=0; + srslte_ra_pdsch_t old_ra_dl; + bzero(&old_ra_dl, sizeof(srslte_ra_pdsch_t)); + + ue_sync.correct_cfo = prog_args.enable_cfo; + + /* Main loop */ + while (!go_exit && (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1)) { + + ret = srslte_ue_sync_get_buffer(&ue_sync, &sf_buffer); + if (ret < 0) { + fprintf(stderr, "Error calling srslte_ue_sync_work()\n"); + } + + /* srslte_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */ + if (ret == 1) { + switch (state) { + case DECODE_MIB: + if (srslte_ue_sync_get_sfidx(&ue_sync) == 0) { + srslte_pbch_decode_reset(&ue_mib.pbch); + n = srslte_ue_mib_decode(&ue_mib, sf_buffer, bch_payload, NULL, &sfn_offset); + if (n < 0) { + fprintf(stderr, "Error decoding UE MIB\n"); + exit(-1); + } else if (n == SRSLTE_UE_MIB_FOUND) { + srslte_pbch_mib_unpack(bch_payload, &cell, &sfn); + srslte_pbch_mib_fprint(stdout, &cell, sfn, cell.id); + printf("Decoded MIB. SFN: %d, offset: %d\n", sfn, sfn_offset); + sfn = (sfn + sfn_offset)%1024; + state = DECODE_PDSCH; + } + } + break; + case DECODE_PDSCH: + if (prog_args.rnti != SRSLTE_SIRNTI) { + decode_pdsch = true; + } else { + /* We are looking for SIB1 Blocks, search only in appropiate places */ + if ((srslte_ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) { + decode_pdsch = true; + } else { + decode_pdsch = false; + } + } + if (decode_pdsch) { + if (prog_args.rnti != SRSLTE_SIRNTI) { + n = srslte_ue_dl_decode(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync)); + } else { + n = srslte_ue_dl_decode_rnti_rv(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI, + ((int) ceilf((float)3*(((sfn)/2)%4)/2))%4); + } + if (memcmp(&ue_dl.ra_dl, &old_ra_dl, sizeof(srslte_ra_pdsch_t))) { + memcpy(&old_ra_dl, &ue_dl.ra_dl, sizeof(srslte_ra_pdsch_t)); + fflush(stdout);printf("\nCFI:\t%d\n", ue_dl.cfi); + printf("Format: %s\n", srslte_dci_format_string(ue_dl.dci_format)); + srslte_ra_pdsch_fprint(stdout, &old_ra_dl, cell.nof_prb); + } + if (n < 0) { + // fprintf(stderr, "Error decoding UE DL\n");fflush(stdout); + } else if (n > 0) { + /* Send data if socket active */ + if (prog_args.net_port > 0) { + srslte_bit_unpack_vector(data_packed, data, n); + srslte_netsink_write(&net_sink, data, 1+(n-1)/8); + } + } + nof_trials++; + + rsrq = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrq(&ue_dl.chest), rsrq, 0.05); + rsrp = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrp(&ue_dl.chest), rsrp, 0.05); + snr = SRSLTE_VEC_EMA(srslte_chest_dl_get_snr(&ue_dl.chest), snr, 0.01); + nframes++; + if (isnan(rsrq)) { + rsrq = 0; + } + if (isnan(snr)) { + snr = 0; + } + if (isnan(rsrp)) { + rsrp = 0; + } + +#ifdef adjust_estimator + /* Adjust channel estimator based on SNR */ + if (10*log10(snr) < 5.0) { + float f_low_snr[5]={0.05, 0.15, 0.6, 0.15, 0.05}; + srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_low_snr, 5); + } else if (10*log10(snr) < 10.0) { + float f_mid_snr[3]={0.1, 0.8, 0.1}; + srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_mid_snr, 3); + } else { + float f_high_snr[3]={0.05, 0.9, 0.05}; + srslte_chest_dl_set_filter_freq(&ue_dl.chest, f_high_snr, 3); + } +#endif + + } + if (srslte_ue_sync_get_sfidx(&ue_sync) != 5 && srslte_ue_sync_get_sfidx(&ue_sync) != 0) { + pdcch_tx++; + } + + + // Plot and Printf + if (srslte_ue_sync_get_sfidx(&ue_sync) == 5) { +#ifdef STDOUT_COMPACT + printf("SFN: %4d, PDCCH-Miss: %5.2f%% (%d missed), PDSCH-BLER: %5.2f%% (%d errors)\r", + sfn, 100*(1-(float) ue_dl.nof_detected/nof_trials),pdcch_tx-ue_dl.nof_detected, + (float) 100*ue_dl.pkt_errors/ue_dl.pkts_total,ue_dl.pkt_errors); +#else + printf("CFO: %+6.2f KHz, SFO: %+6.2f Khz, " + "RSRP: %+5.1f dBm, RSRQ: %5.1f dB, SNR: %4.1f dB, " + "PDCCH-Miss: %5.2f%% (%d), PDSCH-BLER: %5.2f%% (%d)\r", + srslte_ue_sync_get_cfo(&ue_sync)/1000, srslte_ue_sync_get_sfo(&ue_sync)/1000, + 10*log10(rsrp*1000)-gain_offset, + 10*log10(rsrq), 10*log10(snr), + 100*(1-(float) ue_dl.nof_detected/nof_trials), pdcch_tx-ue_dl.nof_detected, + (float) 100*ue_dl.pkt_errors/ue_dl.pkts_total, ue_dl.pkt_errors); + +#endif + } + break; + } + if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) { + sfn++; + if (sfn == 1024) { + sfn = 0; + } + } + + #ifndef DISABLE_GRAPHICS + if (!prog_args.disable_plots) { + plot_sf_idx = srslte_ue_sync_get_sfidx(&ue_sync); + sem_post(&plot_sem); + } + #endif + } else if (ret == 0) { + printf("Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r", + srslte_sync_get_peak_value(&ue_sync.sfind), + ue_sync.frame_total_cnt, ue_sync.state); + } + + sf_cnt++; + } // Main loop + + srslte_ue_dl_free(&ue_dl); + srslte_ue_sync_free(&ue_sync); + +#ifndef DISABLE_UHD + if (!prog_args.input_file_name) { + srslte_ue_mib_free(&ue_mib); + cuhd_close(uhd); + } +#endif + printf("\nBye\n"); + exit(0); +} + + + + + + + + +/********************************************************************** + * Plotting Functions + ***********************************************************************/ +#ifndef DISABLE_GRAPHICS + + +plot_real_t poutfft; +plot_real_t pce_angle, pce; +plot_scatter_t pscatequal, pscatequal_pdcch; + +float tmp_plot[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_SRSLTE_CP_NORM)]; +float tmp_plot2[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_SRSLTE_CP_NORM)]; +float tmp_plot3[SRSLTE_SLOT_LEN_RE(SRSLTE_MAX_PRB, SRSLTE_SRSLTE_CP_NORM)]; + +void *plot_thread_run(void *arg) { + int i; + uint32_t nof_re = SRSLTE_SF_LEN_RE(ue_dl.cell.nof_prb, ue_dl.cell.cp); + + while(1) { + sem_wait(&plot_sem); + + uint32_t nof_symbols = ue_dl.harq_process[0].dl_alloc.re_sf[plot_sf_idx]; + for (i = 0; i < nof_re; i++) { + tmp_plot[i] = 20 * log10f(cabsf(ue_dl.sf_symbols[i])); + if (isinf(tmp_plot[i])) { + tmp_plot[i] = -80; + } + } + for (i = 0; i < SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0); i++) { + tmp_plot2[i] = 20 * log10f(cabsf(ue_dl.chest.pilot_estimates_average[0][i])); + if (isinf(tmp_plot2[i])) { + tmp_plot2[i] = -80; + } + } + for (i = 0; i < SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0); i++) { + tmp_plot3[i] = cargf(ue_dl.chest.pilot_estimates_average[0][i]); + } + plot_real_setNewData(&poutfft, tmp_plot, nof_re); + plot_real_setNewData(&pce, tmp_plot2, SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0)); + plot_real_setNewData(&pce_angle, tmp_plot3, SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0)); + + plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.d, nof_symbols); + plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.d, 36*ue_dl.pdcch.nof_cce); + + if (plot_sf_idx == 1) { + if (prog_args.net_port_signal > 0) { + srslte_netsink_write(&net_sink_signal, &sf_buffer[srslte_ue_sync_sf_len(&ue_sync)/7], + srslte_ue_sync_sf_len(&ue_sync)); + } + } + + } + + return NULL; +} + +void init_plots() { + + sdrgui_init(); + + plot_real_init(&poutfft); + plot_real_setTitle(&poutfft, "Output FFT - Magnitude"); + plot_real_setLabels(&poutfft, "Index", "dB"); + plot_real_setYAxisScale(&poutfft, -40, 40); + + plot_real_init(&pce); + plot_real_setTitle(&pce, "Channel Response - Magnitude"); + plot_real_setLabels(&pce, "Index", "dB"); + + plot_real_init(&pce_angle); + plot_real_setTitle(&pce_angle, "Channel Response - Argument"); + plot_real_setLabels(&pce_angle, "Index", "Radiants"); + plot_real_setYAxisScale(&pce_angle, -M_PI, M_PI); + + plot_scatter_init(&pscatequal); + plot_scatter_setTitle(&pscatequal, "PDSCH - Equalized Symbols"); + plot_scatter_setXAxisScale(&pscatequal, -2, 2); + plot_scatter_setYAxisScale(&pscatequal, -2, 2); + + plot_scatter_init(&pscatequal_pdcch); + plot_scatter_setTitle(&pscatequal_pdcch, "PDCCH - Equalized Symbols"); + plot_scatter_setXAxisScale(&pscatequal_pdcch, -2, 2); + plot_scatter_setYAxisScale(&pscatequal_pdcch, -2, 2); + + if (sem_init(&plot_sem, 0, 0)) { + perror("sem_init"); + exit(-1); + } + + if (pthread_create(&plot_thread, NULL, plot_thread_run, NULL)) { + perror("pthread_create"); + exit(-1); + } +} + +#endif