/** * * \section COPYRIGHT * * Copyright 2013-2015 Software Radio Systems Limited * * \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 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 #include #include #include #include #include #include #include #include #include #include #include #include "srslte/srslte.h" #define ENABLE_AGC_DEFAULT #ifndef DISABLE_RF #include "srslte/rf/rf.h" #include "srslte/rf/rf_utils.h" cell_search_cfg_t cell_detect_config = { SRSLTE_DEFAULT_MAX_FRAMES_PBCH, SRSLTE_DEFAULT_MAX_FRAMES_PSS, SRSLTE_DEFAULT_NOF_VALID_PSS_FRAMES, 0 }; #else #warning Compiling pdsch_ue with no RF support #endif //#define STDOUT_COMPACT #ifndef DISABLE_GRAPHICS #include "srsgui/srsgui.h" void init_plots(); pthread_t plot_thread; sem_t plot_sem; uint32_t plot_sf_idx=0; bool plot_track = true; #endif #define PRINT_CHANGE_SCHEDULIGN //#define CORRECT_SAMPLE_OFFSET /********************************************************************** * Program arguments processing ***********************************************************************/ typedef struct { int nof_subframes; bool disable_plots; bool disable_plots_except_constellation; bool disable_cfo; uint32_t time_offset; int force_N_id_2; uint16_t rnti; char *input_file_name; int file_offset_time; float file_offset_freq; uint32_t file_nof_prb; uint32_t file_nof_ports; uint32_t file_cell_id; char *rf_args; uint32_t rf_nof_rx_ant; double rf_freq; float rf_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->disable_plots = false; args->disable_plots_except_constellation = false; args->nof_subframes = -1; args->rnti = SRSLTE_SIRNTI; args->force_N_id_2 = -1; // Pick the best args->input_file_name = NULL; args->disable_cfo = false; args->time_offset = 0; args->file_nof_prb = 25; args->file_nof_ports = 1; args->file_cell_id = 0; args->file_offset_time = 0; args->file_offset_freq = 0; args->rf_args = ""; args->rf_freq = -1.0; args->rf_nof_rx_ant = 1; #ifdef ENABLE_AGC_DEFAULT args->rf_gain = -1.0; #else args->rf_gain = 50.0; #endif 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 [agpPoOcildDnruv] -f rx_frequency (in Hz) | -i input_file\n", prog); #ifndef DISABLE_RF printf("\t-a RF args [Default %s]\n", args->rf_args); #ifdef ENABLE_AGC_DEFAULT printf("\t-g RF fix RX gain [Default AGC]\n"); #else printf("\t-g Set RX gain [Default %.1f dB]\n", args->rf_gain); #endif #else printf("\t RF is disabled.\n"); #endif printf("\t-i input_file [Default use RF board]\n"); printf("\t-o offset frequency correction (in Hz) for input file [Default %.1f Hz]\n", args->file_offset_freq); printf("\t-O offset samples for input file [Default %d]\n", args->file_offset_time); printf("\t-p nof_prb for input file [Default %d]\n", args->file_nof_prb); printf("\t-P nof_ports for input file [Default %d]\n", args->file_nof_ports); printf("\t-c cell_id for input file [Default %d]\n", args->file_cell_id); printf("\t-r RNTI in Hex [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->disable_cfo?"Disabled":"Enabled"); printf("\t-t Add time offset [Default %d]\n", args->time_offset); #ifndef DISABLE_GRAPHICS printf("\t-d disable plots [Default enabled]\n"); printf("\t-D disable all but constellation 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, "aAoglipPcOCtdDnvrfuUsS")) != -1) { switch (opt) { case 'i': args->input_file_name = argv[optind]; break; case 'p': args->file_nof_prb = atoi(argv[optind]); break; case 'P': args->file_nof_ports = atoi(argv[optind]); break; case 'o': args->file_offset_freq = atof(argv[optind]); break; case 'O': args->file_offset_time = atoi(argv[optind]); break; case 'c': args->file_cell_id = atoi(argv[optind]); break; case 'a': args->rf_args = argv[optind]; break; case 'A': args->rf_nof_rx_ant = atoi(argv[optind]); break; case 'g': args->rf_gain = atof(argv[optind]); break; case 'C': args->disable_cfo = true; break; case 't': args->time_offset = atoi(argv[optind]); break; case 'f': args->rf_freq = strtod(argv[optind], NULL); break; case 'n': args->nof_subframes = atoi(argv[optind]); break; case 'r': args->rnti = strtol(argv[optind], NULL, 16); 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 'D': args->disable_plots_except_constellation = true; break; case 'v': srslte_verbose++; break; default: usage(args, argv[0]); exit(-1); } } if (args->rf_freq < 0 && args->input_file_name == NULL) { usage(args, argv[0]); exit(-1); } } /**********************************************************************/ /* TODO: Do something with the output data */ uint8_t data[20000]; bool go_exit = false; void sig_int_handler(int signo) { printf("SIGINT received. Exiting...\n"); if (signo == SIGINT) { go_exit = true; } } cf_t *sf_buffer[2] = {NULL, NULL}; #ifndef DISABLE_RF int srslte_rf_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) { DEBUG(" ---- Receive %d samples ---- \n", nsamples); void *d[2] = {data, sf_buffer[1]}; return srslte_rf_recv_with_time_multi(h, d, nsamples, true, NULL, NULL); } double srslte_rf_set_rx_gain_th_wrapper_(void *h, double f) { return srslte_rf_set_rx_gain_th((srslte_rf_t*) h, f); } #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 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_RF srslte_rf_t rf; #endif uint32_t nof_trials = 0; int n; uint8_t bch_payload[SRSLTE_BCH_PAYLOAD_LEN]; int sfn_offset; float cfo = 0; 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_RF if (!prog_args.input_file_name) { printf("Opening RF device with %d RX antennas...\n", prog_args.rf_nof_rx_ant); if (srslte_rf_open_multi(&rf, prog_args.rf_args, prog_args.rf_nof_rx_ant)) { fprintf(stderr, "Error opening rf\n"); exit(-1); } /* Set receiver gain */ if (prog_args.rf_gain > 0) { srslte_rf_set_rx_gain(&rf, prog_args.rf_gain); } else { printf("Starting AGC thread...\n"); if (srslte_rf_start_gain_thread(&rf, false)) { fprintf(stderr, "Error opening rf\n"); exit(-1); } srslte_rf_set_rx_gain(&rf, 50); cell_detect_config.init_agc = 50; } sigset_t sigset; sigemptyset(&sigset); sigaddset(&sigset, SIGINT); sigprocmask(SIG_UNBLOCK, &sigset, NULL); signal(SIGINT, sig_int_handler); srslte_rf_set_master_clock_rate(&rf, 30.72e6); /* set receiver frequency */ printf("Tunning receiver to %.3f MHz\n", prog_args.rf_freq/1000000); srslte_rf_set_rx_freq(&rf, prog_args.rf_freq); srslte_rf_rx_wait_lo_locked(&rf); uint32_t ntrial=0; do { ret = rf_search_and_decode_mib(&rf, &cell_detect_config, prog_args.force_N_id_2, &cell, &cfo); if (ret < 0) { fprintf(stderr, "Error searching for cell\n"); exit(-1); } else if (ret == 0 && !go_exit) { printf("Cell not found after %d trials. Trying again (Press Ctrl+C to exit)\n", ntrial++); } } while (ret == 0 && !go_exit); if (go_exit) { exit(0); } srslte_rf_stop_rx_stream(&rf); srslte_rf_flush_buffer(&rf); /* set sampling frequency */ int srate = srslte_sampling_freq_hz(cell.nof_prb); if (srate != -1) { if (srate < 10e6) { srslte_rf_set_master_clock_rate(&rf, 4*srate); } else { srslte_rf_set_master_clock_rate(&rf, srate); } printf("Setting sampling rate %.2f MHz\n", (float) srate/1000000); float srate_rf = srslte_rf_set_rx_srate(&rf, (double) srate); if (srate_rf != srate) { fprintf(stderr, "Could not set sampling rate\n"); exit(-1); } } else { fprintf(stderr, "Invalid number of PRB %d\n", cell.nof_prb); exit(-1); } printf("Stopping RF and flushing buffer...\r",0); } #endif /* If reading from file, go straight to PDSCH decoding. Otherwise, decode MIB first */ if (prog_args.input_file_name) { /* preset cell configuration */ cell.id = prog_args.file_cell_id; cell.cp = SRSLTE_CP_NORM; cell.phich_length = SRSLTE_PHICH_NORM; cell.phich_resources = SRSLTE_PHICH_R_1; cell.nof_ports = prog_args.file_nof_ports; 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, prog_args.file_offset_time, prog_args.file_offset_freq)) { fprintf(stderr, "Error initiating ue_sync\n"); exit(-1); } } else { #ifndef DISABLE_RF if (srslte_ue_sync_init(&ue_sync, cell, srslte_rf_recv_wrapper, (void*) &rf)) { fprintf(stderr, "Error initiating ue_sync\n"); exit(-1); } #endif } if (srslte_ue_mib_init(&ue_mib, cell)) { fprintf(stderr, "Error initaiting UE MIB decoder\n"); exit(-1); } if (srslte_ue_dl_init(&ue_dl, cell)) { // This is the User RNTI fprintf(stderr, "Error initiating UE downlink processing module\n"); exit(-1); } for (int i=0;i 0) { /* Send data if socket active */ if (prog_args.net_port > 0) { srslte_netsink_write(&net_sink, data, 1+(n-1)/8); } #ifdef PRINT_CHANGE_SCHEDULIGN if (ue_dl.dl_dci.mcs_idx != old_dl_dci.mcs_idx || memcmp(&ue_dl.dl_dci.type0_alloc, &old_dl_dci.type0_alloc, sizeof(srslte_ra_type0_t)) || memcmp(&ue_dl.dl_dci.type1_alloc, &old_dl_dci.type1_alloc, sizeof(srslte_ra_type1_t)) || memcmp(&ue_dl.dl_dci.type2_alloc, &old_dl_dci.type2_alloc, sizeof(srslte_ra_type2_t))) { memcpy(&old_dl_dci, &ue_dl.dl_dci, sizeof(srslte_ra_dl_dci_t)); fflush(stdout); printf("Format: %s\n", srslte_dci_format_string(ue_dl.dci_format)); srslte_ra_pdsch_fprint(stdout, &old_dl_dci, cell.nof_prb); srslte_ra_dl_grant_fprint(stdout, &ue_dl.pdsch_cfg.grant); } #endif } nof_trials++; rsrq = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrq(&ue_dl.chest), rsrq, 0.1); rsrp = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrp(&ue_dl.chest), rsrp, 0.05); noise = SRSLTE_VEC_EMA(srslte_chest_dl_get_noise_estimate(&ue_dl.chest), noise, 0.05); nframes++; if (isnan(rsrq)) { rsrq = 0; } if (isnan(noise)) { noise = 0; } if (isnan(rsrp)) { rsrp = 0; } } // Plot and Printf if (srslte_ue_sync_get_sfidx(&ue_sync) == 5) { float gain = prog_args.rf_gain; if (gain < 0) { gain = 10*log10(srslte_agc_get_gain(&ue_sync.agc)); } printf("CFO: %+6.2f kHz, " "SNR: %4.1f dB, " "PDCCH-Miss: %5.2f%%, PDSCH-BLER: %5.2f%%\r", srslte_ue_sync_get_cfo(&ue_sync)/1000, 10*log10(rsrp/noise), 100*(1-(float) ue_dl.nof_detected/nof_trials), (float) 100*ue_dl.pkt_errors/ue_dl.pkts_total); } break; } if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) { sfn++; if (sfn == 1024) { sfn = 0; printf("\n"); ue_dl.pkt_errors = 0; ue_dl.pkts_total = 0; ue_dl.nof_detected = 0; nof_trials = 0; } } #ifndef DISABLE_GRAPHICS if (!prog_args.disable_plots) { if ((sfn%4) == 0 && decode_pdsch) { plot_sf_idx = srslte_ue_sync_get_sfidx(&ue_sync); plot_track = true; 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); #ifndef DISABLE_GRAPHICS if (!prog_args.disable_plots) { plot_sf_idx = srslte_ue_sync_get_sfidx(&ue_sync); plot_track = false; sem_post(&plot_sem); } #endif } sf_cnt++; } // Main loop #ifndef DISABLE_GRAPHICS if (!prog_args.disable_plots) { if (!pthread_kill(plot_thread, 0)) { pthread_kill(plot_thread, SIGHUP); pthread_join(plot_thread, NULL); } } #endif srslte_ue_dl_free(&ue_dl); srslte_ue_sync_free(&ue_sync); #ifndef DISABLE_RF if (!prog_args.input_file_name) { srslte_ue_mib_free(&ue_mib); srslte_rf_close(&rf); } #endif printf("\nBye\n"); exit(0); } /********************************************************************** * Plotting Functions ***********************************************************************/ #ifndef DISABLE_GRAPHICS plot_real_t p_sync, pce; plot_scatter_t pscatequal, pscatequal_pdcch; float tmp_plot[110*15*2048]; float tmp_plot2[110*15*2048]; float tmp_plot3[110*15*2048]; 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); sdrgui_init(); plot_scatter_init(&pscatequal); plot_scatter_setTitle(&pscatequal, "PDSCH - Equalized Symbols"); plot_scatter_setXAxisScale(&pscatequal, -4, 4); plot_scatter_setYAxisScale(&pscatequal, -4, 4); plot_scatter_addToWindowGrid(&pscatequal, (char*)"pdsch_ue", 0, 0); if (!prog_args.disable_plots_except_constellation) { plot_real_init(&pce); plot_real_setTitle(&pce, "Channel Response - Magnitude"); plot_real_setLabels(&pce, "Index", "dB"); plot_real_setYAxisScale(&pce, -40, 40); plot_real_init(&p_sync); plot_real_setTitle(&p_sync, "PSS Cross-Corr abs value"); plot_real_setYAxisScale(&p_sync, 0, 1); plot_scatter_init(&pscatequal_pdcch); plot_scatter_setTitle(&pscatequal_pdcch, "PDCCH - Equalized Symbols"); plot_scatter_setXAxisScale(&pscatequal_pdcch, -4, 4); plot_scatter_setYAxisScale(&pscatequal_pdcch, -4, 4); plot_real_addToWindowGrid(&pce, (char*)"pdsch_ue", 0, 1); plot_real_addToWindowGrid(&pscatequal_pdcch, (char*)"pdsch_ue", 1, 0); plot_real_addToWindowGrid(&p_sync, (char*)"pdsch_ue", 1, 1); } while(1) { sem_wait(&plot_sem); uint32_t nof_symbols = ue_dl.pdsch_cfg.nbits.nof_re; if (!prog_args.disable_plots_except_constellation) { 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; } } int sz = srslte_symbol_sz(ue_dl.cell.nof_prb); bzero(tmp_plot2, sizeof(float)*sz); int g = (sz - 12*ue_dl.cell.nof_prb)/2; for (i = 0; i < 12*ue_dl.cell.nof_prb; i++) { tmp_plot2[g+i] = 20 * log10(cabs(ue_dl.ce[0][i])); if (isinf(tmp_plot2[g+i])) { tmp_plot2[g+i] = -80; } } plot_real_setNewData(&pce, tmp_plot2, sz); if (!prog_args.input_file_name) { if (plot_track) { srslte_pss_synch_t *pss_obj = srslte_sync_get_cur_pss_obj(&ue_sync.strack); int max = srslte_vec_max_fi(pss_obj->conv_output_avg, pss_obj->frame_size+pss_obj->fft_size-1); srslte_vec_sc_prod_fff(pss_obj->conv_output_avg, 1/pss_obj->conv_output_avg[max], tmp_plot2, pss_obj->frame_size+pss_obj->fft_size-1); plot_real_setNewData(&p_sync, tmp_plot2, pss_obj->frame_size); } else { int max = srslte_vec_max_fi(ue_sync.sfind.pss.conv_output_avg, ue_sync.sfind.pss.frame_size+ue_sync.sfind.pss.fft_size-1); srslte_vec_sc_prod_fff(ue_sync.sfind.pss.conv_output_avg, 1/ue_sync.sfind.pss.conv_output_avg[max], tmp_plot2, ue_sync.sfind.pss.frame_size+ue_sync.sfind.pss.fft_size-1); plot_real_setNewData(&p_sync, tmp_plot2, ue_sync.sfind.pss.frame_size); } } plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.d, 36*ue_dl.pdcch.nof_cce); } plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.d, nof_symbols); 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() { if (sem_init(&plot_sem, 0, 0)) { perror("sem_init"); exit(-1); } pthread_attr_t attr; struct sched_param param; param.sched_priority = 0; pthread_attr_init(&attr); pthread_attr_setschedpolicy(&attr, SCHED_OTHER); pthread_attr_setschedparam(&attr, ¶m); if (pthread_create(&plot_thread, NULL, plot_thread_run, NULL)) { perror("pthread_create"); exit(-1); } } #endif