int srslte_ue_dl_decode_fft_estimate(srslte_ue_dl_t *q, cf_t *input, uint32_t sf_idx, uint32_t *cfi) { if (input && q && cfi && sf_idx < SRSLTE_NSUBFRAMES_X_FRAME) { /* Run FFT for all subframe data */ srslte_ofdm_rx_sf(&q->fft, input, q->sf_symbols); /* Correct SFO multiplying by complex exponential in the time domain */ if (q->sample_offset) { struct timeval t[3]; gettimeofday(&t[1], NULL); for (int i=0;i<2*SRSLTE_CP_NSYMB(q->cell.cp);i++) { srslte_cfo_correct(&q->sfo_correct, &q->sf_symbols[i*q->cell.nof_prb*SRSLTE_NRE], &q->sf_symbols[i*q->cell.nof_prb*SRSLTE_NRE], q->sample_offset / q->fft.symbol_sz); } gettimeofday(&t[2], NULL); get_time_interval(t); } return srslte_ue_dl_decode_estimate(q, sf_idx, cfi); } else { return SRSLTE_ERROR_INVALID_INPUTS; } }
long get_time_and_replace(struct timeval *then) { struct timeval* now = (struct timeval*)malloc(sizeof(struct timeval)); gettimeofday(now, NULL); long interval = get_time_interval(*now, *then); then = now; return interval; }
int main(int argc, char** argv) { parse_args(argc, argv); srslte_prach_t prach; bool high_speed_flag = false; cf_t preamble[MAX_LEN]; memset(preamble, 0, sizeof(cf_t)*MAX_LEN); srslte_prach_cfg_t prach_cfg; ZERO_OBJECT(prach_cfg); prach_cfg.config_idx = config_idx; prach_cfg.hs_flag = high_speed_flag; prach_cfg.freq_offset = 0; prach_cfg.root_seq_idx = root_seq_idx; prach_cfg.zero_corr_zone = zero_corr_zone; if (srslte_prach_init(&prach, srslte_symbol_sz(nof_prb))) { return -1; } if (srslte_prach_set_cfg(&prach, &prach_cfg, nof_prb)) { ERROR("Error initiating PRACH object\n"); return -1; } uint32_t seq_index = 0; uint32_t indices[64]; uint32_t n_indices = 0; for(int i=0;i<64;i++) indices[i] = 0; for(seq_index=0;seq_index<64;seq_index++) { srslte_prach_gen(&prach, seq_index, 0, preamble); uint32_t prach_len = prach.N_seq; struct timeval t[3]; gettimeofday(&t[1], NULL); srslte_prach_detect(&prach, 0, &preamble[prach.N_cp], prach_len, indices, &n_indices); gettimeofday(&t[2], NULL); get_time_interval(t); printf("texec=%ld us\n", t[0].tv_usec); if(n_indices != 1 || indices[0] != seq_index) return -1; } srslte_prach_free(&prach); srslte_dft_exit(); printf("Done\n"); exit(0); }
/* Function to handle report reads based on user input*/ int ReadReport(unsigned char input, char *buf) { int ret = 0; unsigned char data; /*Set the GetReport bit to run the AutoScan*/ data = 0x01; DO_SAFE(Write8BitRegisters(F54CommandBase, &data, 1), error); count = 0; do { DO_SAFE(Read8BitRegisters(F54CommandBase, &data, 1), error); msleep(1); count++; } while (data != 0x00 && (count < DefaultTimeout)); if (count >= DefaultTimeout) { TOUCH_LOG("Timeout - Not supported Report Type in FW\n"); Reset(); return -EAGAIN; } do_gettimeofday(&t_interval[ENDTIME]); TOUCH_LOG("Takes %lu ticks\n", get_time_interval(t_interval[ENDTIME].tv_sec, t_interval[STARTTIME].tv_sec)); switch (input) { case 'p': ret = ReadRT78(buf); break; case 'q': ret = GetImageRT78(buf); break; case 'r': ret = ReadElectodeShortRT78(buf); break; default: break; } return ret; error: TOUCH_ERR("[%s] ReadReport fail\n", __func__); return -EAGAIN; }
void GameEngine::run() { if (_running) { set_state_title(); CommonResources* p_resources = common_resources_get_instance(); p_resources -> player1.new_game(); while (_running) { _window.prepare(); _common_state.events(_window); _common_state.update(_window.get_gc()); _common_state.draw(_window.get_gc()); GameState* p_current_state = _states_stack.top(); p_current_state -> events(_window); p_current_state -> update(_window.get_gc()); // Drawing the front layer behind the current state or not if (p_current_state -> front_layer_behind()) { p_resources -> front_layer.draw(_window.get_gc()); p_current_state -> draw(_window.get_gc()); } else { p_current_state -> draw(_window.get_gc()); p_resources -> front_layer.draw(_window.get_gc()); } // Get the Frame rate p_resources -> fps = _framerate_counter.get_fps(); p_resources -> delta_time = get_time_interval(p_resources->fps); _window.display(); _framerate_counter.keep_alive(); } } }
int main(int argc, char **argv) { srslte_pucch_t pucch; srslte_pucch_cfg_t pucch_cfg; srslte_refsignal_ul_t dmrs; uint8_t bits[SRSLTE_PUCCH_MAX_BITS]; uint8_t pucch2_bits[2]; cf_t *sf_symbols = NULL; cf_t pucch_dmrs[2*SRSLTE_NRE*3]; int ret = -1; parse_args(argc,argv); if (srslte_pucch_init(&pucch, cell)) { fprintf(stderr, "Error creating PDSCH object\n"); goto quit; } if (srslte_refsignal_ul_init(&dmrs, cell)) { fprintf(stderr, "Error creating PDSCH object\n"); goto quit; } bzero(&pucch_cfg, sizeof(srslte_pucch_cfg_t)); for (int i=0;i<SRSLTE_PUCCH_MAX_BITS;i++) { bits[i] = i%2; } for (int i=0;i<2;i++) { pucch2_bits[i] = i%2; } if (srslte_pucch_set_crnti(&pucch, 11)) { fprintf(stderr, "Error setting C-RNTI\n"); goto quit; } sf_symbols = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)); if (!sf_symbols) { goto quit; } srslte_pucch_format_t format; for (format=0;format<=SRSLTE_PUCCH_FORMAT_2B;format++) { for (uint32_t d=1;d<=3;d++) { for (uint32_t ncs=0;ncs<8;ncs+=d) { for (uint32_t n_pucch=1;n_pucch<130;n_pucch+=50) { struct timeval t[3]; pucch_cfg.delta_pucch_shift = d; bool group_hopping_en = false; pucch_cfg.N_cs = ncs; pucch_cfg.n_rb_2 = 0; gettimeofday(&t[1], NULL); if (!srslte_pucch_set_cfg(&pucch, &pucch_cfg, group_hopping_en)) { fprintf(stderr, "Error setting PUCCH config\n"); goto quit; } if (srslte_pucch_encode(&pucch, format, n_pucch, subframe, bits, sf_symbols)) { fprintf(stderr, "Error encoding PUCCH\n"); goto quit; } srslte_refsignal_dmrs_pusch_cfg_t pusch_cfg; pusch_cfg.group_hopping_en = group_hopping_en; pusch_cfg.sequence_hopping_en = false; srslte_refsignal_ul_set_cfg(&dmrs, &pusch_cfg, &pucch_cfg, NULL); if (srslte_refsignal_dmrs_pucch_gen(&dmrs, format, n_pucch, subframe, pucch2_bits, pucch_dmrs)) { fprintf(stderr, "Error encoding PUCCH\n"); goto quit; } if (srslte_refsignal_dmrs_pucch_put(&dmrs, format, n_pucch, pucch_dmrs, sf_symbols)) { fprintf(stderr, "Error encoding PUCCH\n"); goto quit; } gettimeofday(&t[2], NULL); get_time_interval(t); INFO("format %d, n_pucch: %d, ncs: %d, d: %d, t_exec=%d us\n", format, n_pucch, ncs, d, t[0].tv_usec); } } } } ret = 0; quit: srslte_pucch_free(&pucch); srslte_refsignal_ul_free(&dmrs); if (sf_symbols) { free(sf_symbols); } if (ret) { printf("Error\n"); } else { printf("Ok\n"); } exit(ret); }
/** * Testsuite: * Generates random symbols and calls the module .... * @param ... * @param ... * @param ... */ int main(int argc, char **argv) { struct timespec tdata[3]; gnuplot_ctrl *plot; char tmp[64]; int ret, i, j; float *tmp_f; _Complex float *tmp_c; double *plot_buff_r; double *plot_buff_c; allocate_memory(); parameters = NULL; parse_paramters(argc, argv); if (generate_input_signal(input_data, input_lengths)) { printf("Error generating input signal\n"); exit(1); } for (i=0;i<nof_input_itf;i++) { if (!input_lengths[i]) { printf("Warning, input interface %d has zero length\n",i); } } if (initialize()) { printf("Error initializing\n"); exit(1); /* the reason for exiting should be printed out beforehand */ } #ifndef _ALOE_OLD_SKELETON for (i=0;i<nof_input_itf;i++) { input_ptr[i] = &input_data[i*input_max_samples*input_sample_sz]; } for (i=0;i<nof_output_itf;i++) { output_ptr[i] = &output_data[i*output_max_samples*output_sample_sz]; } clock_gettime(CLOCK_MONOTONIC,&tdata[1]); ret = work(input_ptr, output_ptr); clock_gettime(CLOCK_MONOTONIC,&tdata[2]); #else clock_gettime(CLOCK_MONOTONIC,&tdata[1]); ret = work(input_data, output_data); clock_gettime(CLOCK_MONOTONIC,&tdata[2]); #endif stop(); if (ret == -1) { printf("Error running\n"); exit(-1); } get_time_interval(tdata); for (i=0;i<nof_output_itf;i++) { if (!output_lengths[i]) { output_lengths[i] = ret; } if (!output_lengths[i]) { printf("Warning output interface %d has zero length\n",i); } } printf("\nExecution time: %d ns.\n", (int) tdata[0].tv_nsec); printf("FINISHED\n"); if (use_gnuplot) { for (i=0;i<nof_input_itf;i++) { plot_buff_r = malloc(sizeof(double)*input_lengths[i]); plot_buff_c = malloc(sizeof(double)*input_lengths[i]); if (input_sample_sz == sizeof(float)) { tmp_f = (float*) &input_data[i*input_max_samples]; for (j=0;j<input_lengths[i];j++) { plot_buff_r[j] = (double) tmp_f[j]; } plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"input_%d",i); gnuplot_plot_x(plot, plot_buff_r, get_input_samples(i), tmp); free(plot_buff_r); } else if (input_sample_sz == sizeof(_Complex float)) { tmp_c = (_Complex float*) &input_data[i*input_max_samples]; for (j=0;j<input_lengths[i];j++) { plot_buff_r[j] = (double) __real__ tmp_c[j]; plot_buff_c[j] = (double) __imag__ tmp_c[j]; } plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"input_real_%d",i); gnuplot_plot_x(plot, plot_buff_r, get_input_samples(i), tmp); plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"input_imag_%d",i); gnuplot_plot_x(plot, plot_buff_c, get_input_samples(i), tmp); free(plot_buff_r); free(plot_buff_c); } } for (i=0;i<nof_output_itf;i++) { plot_buff_r = malloc(sizeof(double)*output_lengths[i]); plot_buff_c = malloc(sizeof(double)*output_lengths[i]); if (output_sample_sz == sizeof(float)) { tmp_f = (float*) &output_data[i*output_max_samples]; for (j=0;j<output_lengths[i];j++) { plot_buff_r[j] = (double) __real__ tmp_f[j]; } plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"output_%d",i); gnuplot_plot_x(plot, plot_buff_r, output_lengths[i], tmp); free(plot_buff_r); } else if (output_sample_sz == sizeof(_Complex float)) { tmp_c = (_Complex float*) &output_data[i*output_max_samples]; for (j=0;j<output_lengths[i];j++) { plot_buff_r[j] = (double) __real__ tmp_c[j]; plot_buff_c[j] = (double) __imag__ tmp_c[j]; } plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"output_real_%d",i); gnuplot_plot_x(plot, plot_buff_r, output_lengths[i], tmp); plot = gnuplot_init() ; gnuplot_setstyle(plot,"lines"); snprintf(tmp,64,"output_imag_%d",i); gnuplot_plot_x(plot, plot_buff_c, output_lengths[i], tmp); free(plot_buff_r); free(plot_buff_c); } } printf("Type ctrl+c to exit\n");fflush(stdout); free_memory(); pause(); /* make sure we exit here */ exit(1); } free_memory(); return 0; }
int main(int argc, char **argv) { int i; srslte_modem_table_t mod; uint8_t *input, *input_bytes, *output; cf_t *symbols, *symbols_bytes; float *llr, *llr2; parse_args(argc, argv); /* initialize objects */ if (srslte_modem_table_lte(&mod, modulation)) { fprintf(stderr, "Error initializing modem table\n"); exit(-1); } srslte_modem_table_bytes(&mod); /* check that num_bits is multiple of num_bits x symbol */ if (num_bits % mod.nbits_x_symbol) { fprintf(stderr, "Error num_bits must be multiple of %d\n", mod.nbits_x_symbol); exit(-1); } /* allocate buffers */ input = srslte_vec_malloc(sizeof(uint8_t) * num_bits); if (!input) { perror("malloc"); exit(-1); } input_bytes = srslte_vec_malloc(sizeof(uint8_t) * num_bits/8); if (!input_bytes) { perror("malloc"); exit(-1); } output = srslte_vec_malloc(sizeof(uint8_t) * num_bits); if (!output) { perror("malloc"); exit(-1); } symbols = srslte_vec_malloc(sizeof(cf_t) * num_bits / mod.nbits_x_symbol); if (!symbols) { perror("malloc"); exit(-1); } symbols_bytes = srslte_vec_malloc(sizeof(cf_t) * num_bits / mod.nbits_x_symbol); if (!symbols_bytes) { perror("malloc"); exit(-1); } llr = srslte_vec_malloc(sizeof(float) * num_bits); if (!llr) { perror("malloc"); exit(-1); } llr2 = srslte_vec_malloc(sizeof(float) * num_bits); if (!llr2) { perror("malloc"); exit(-1); } /* generate random data */ for (i=0;i<num_bits;i++) { input[i] = rand()%2; } /* modulate */ struct timeval t[3]; gettimeofday(&t[1], NULL); int ntrials = 100; for (int i=0;i<ntrials;i++) { srslte_mod_modulate(&mod, input, symbols, num_bits); } gettimeofday(&t[2], NULL); get_time_interval(t); printf("Bit: %d us\n", t[0].tv_usec); /* Test packed implementation */ srslte_bit_pack_vector(input, input_bytes, num_bits); gettimeofday(&t[1], NULL); for (int i=0;i<ntrials;i++) { srslte_mod_modulate_bytes(&mod, input_bytes, symbols_bytes, num_bits); } gettimeofday(&t[2], NULL); get_time_interval(t); printf("Byte: %d us\n", t[0].tv_usec); for (int i=0;i<num_bits/mod.nbits_x_symbol;i++) { if (symbols[i] != symbols_bytes[i]) { printf("error in symbol %d\n", i); exit(-1); } } printf("Symbols OK\n"); /* demodulate */ gettimeofday(&x, NULL); srslte_demod_soft_demodulate(modulation, symbols, llr, num_bits / mod.nbits_x_symbol); gettimeofday(&y, NULL); printf("\nElapsed time [ns]: %d\n", (int) y.tv_usec - (int) x.tv_usec); for (i=0;i<num_bits;i++) { output[i] = llr[i]>=0 ? 1 : 0; } /* check errors */ for (i=0;i<num_bits;i++) { if (input[i] != output[i]) { fprintf(stderr, "Error in bit %d\n", i); exit(-1); } } free(llr); free(symbols); free(symbols_bytes); free(output); free(input); free(input_bytes); srslte_modem_table_free(&mod); printf("Ok\n"); exit(0); }
int main(int argc, char **argv) { int frame_cnt; float *llr; uint16_t *llr_s; uint8_t *llr_c; uint8_t *data_tx, *data_rx, *data_rx2, *symbols; int i, j; float var[SNR_POINTS], varunc[SNR_POINTS]; int snr_points; uint32_t errors; #ifdef TEST_SSE uint32_t errors2; srslte_viterbi_t dec_sse; #endif srslte_viterbi_t dec; srslte_convcoder_t cod; int coded_length; parse_args(argc, argv); if (!seed) { seed = time(NULL); } srand(seed); cod.poly[0] = 0x6D; cod.poly[1] = 0x4F; cod.poly[2] = 0x57; cod.K = 7; cod.tail_biting = tail_biting; cod.R = 3; coded_length = cod.R * (frame_length + ((cod.tail_biting) ? 0 : cod.K - 1)); srslte_viterbi_init(&dec, SRSLTE_VITERBI_37, cod.poly, frame_length, cod.tail_biting); printf("Convolutional Code 1/3 K=%d Tail bitting: %s\n", cod.K, cod.tail_biting ? "yes" : "no"); #ifdef TEST_SSE srslte_viterbi_init_sse(&dec_sse, SRSLTE_VITERBI_37, cod.poly, frame_length, cod.tail_biting); #endif printf(" Frame length: %d\n", frame_length); if (ebno_db < 100.0) { printf(" EbNo: %.2f\n", ebno_db); } data_tx = malloc(frame_length * sizeof(uint8_t)); if (!data_tx) { perror("malloc"); exit(-1); } data_rx = malloc(frame_length * sizeof(uint8_t)); if (!data_rx) { perror("malloc"); exit(-1); } data_rx2 = malloc(frame_length * sizeof(uint8_t)); if (!data_rx2) { perror("malloc"); exit(-1); } symbols = malloc(coded_length * sizeof(uint8_t)); if (!symbols) { perror("malloc"); exit(-1); } llr = malloc(coded_length * sizeof(float)); if (!llr) { perror("malloc"); exit(-1); } llr_s = malloc(2 * coded_length * sizeof(uint16_t)); if (!llr_s) { perror("malloc"); exit(-1); } llr_c = malloc(2 * coded_length * sizeof(uint8_t)); if (!llr_c) { perror("malloc"); exit(-1); } float ebno_inc, esno_db; ebno_inc = (SNR_MAX - SNR_MIN) / SNR_POINTS; if (ebno_db == 100.0) { snr_points = SNR_POINTS; for (i = 0; i < snr_points; i++) { ebno_db = SNR_MIN + i * ebno_inc; esno_db = ebno_db + 10 * log10((double) 1 / 3); var[i] = sqrt(1 / (pow(10, esno_db / 10))); varunc[i] = sqrt(1 / (pow(10, ebno_db / 10))); } } else { esno_db = ebno_db + 10 * log10((double) 1 / 3); var[0] = sqrt(1 / (pow(10, esno_db / 10))); varunc[0] = sqrt(1 / (pow(10, ebno_db / 10))); snr_points = 1; } for (i = 0; i < snr_points; i++) { frame_cnt = 0; errors = 0; #ifdef TEST_SSE errors2 = 0; #endif while (frame_cnt < nof_frames) { /* generate data_tx */ for (j = 0; j < frame_length; j++) { data_tx[j] = rand() % 2; } /* uncoded BER */ for (j = 0; j < frame_length; j++) { llr[j] = data_tx[j] ? sqrt(2) : -sqrt(2); } srslte_ch_awgn_f(llr, llr, varunc[i], frame_length); /* coded BER */ srslte_convcoder_encode(&cod, data_tx, symbols, frame_length); for (j = 0; j < coded_length; j++) { llr[j] = symbols[j] ? sqrt(2) : -sqrt(2); } srslte_ch_awgn_f(llr, llr, var[i], coded_length); //srslte_vec_fprint_f(stdout, llr, 100); srslte_vec_quant_fuc(llr, llr_c, 32, 127.5, 255, coded_length); srslte_vec_quant_fus(llr, llr_s, 8192, 32767.5, 65535, coded_length); struct timeval t[3]; gettimeofday(&t[1], NULL); int M = 1; for (int i=0;i<M;i++) { #ifdef VITERBI_16 srslte_viterbi_decode_us(&dec, llr_s, data_rx, frame_length); #else srslte_viterbi_decode_uc(&dec, llr_c, data_rx, frame_length); #endif } #ifdef TEST_SSE gettimeofday(&t[2], NULL); get_time_interval(t); //printf("Execution time:\t\t%.1f us\n", (float) t[0].tv_usec/M); gettimeofday(&t[1], NULL); for (int i=0;i<M;i++) { srslte_viterbi_decode_uc(&dec_sse, llr_c, data_rx2, frame_length); } gettimeofday(&t[2], NULL); get_time_interval(t); //printf("Execution time SIMD:\t%.1f us\n", (float) t[0].tv_usec/M); #endif /* check errors */ errors += srslte_bit_diff(data_tx, data_rx, frame_length); #ifdef TEST_SSE errors2 += srslte_bit_diff(data_tx, data_rx2, frame_length); #endif frame_cnt++; printf("Eb/No: %3.2f %10d/%d ", SNR_MIN + i * ebno_inc,frame_cnt,nof_frames); printf("BER: %.2e ", (float) errors / (frame_cnt * frame_length)); #ifdef TEST_SSE printf("BER2: %.2e ", (float) errors2 / (frame_cnt * frame_length)); #endif printf("\r"); } printf("\n"); if (snr_points == 1) { printf("BER : %g\t%u errors\n", (float) errors / (frame_cnt * frame_length), errors); #ifdef TEST_SSE printf("BER SSE: %g\t%u errors\n", (float) errors2 / (frame_cnt * frame_length), errors2); #endif } } srslte_viterbi_free(&dec); #ifdef TEST_SSE srslte_viterbi_free(&dec_sse); #endif free(data_tx); free(symbols); free(llr); free(llr_c); free(llr_s); free(data_rx); free(data_rx2); if (snr_points == 1) { int expected_errors = get_expected_errors(nof_frames, seed, frame_length, tail_biting, ebno_db); if (expected_errors == -1) { fprintf(stderr, "Test parameters not defined in test_results.h\n"); exit(-1); } else { printf("errors =%d, expected =%d\n", errors, expected_errors); exit(errors > expected_errors); } } else { printf("\n"); printf("Done\n"); exit(0); } }
int main(int argc, char **argv) { int i, j; float mse; cf_t *x[SRSLTE_MAX_LAYERS], *r[SRSLTE_MAX_PORTS], *y[SRSLTE_MAX_PORTS], *h[SRSLTE_MAX_PORTS], *xr[SRSLTE_MAX_LAYERS]; srslte_mimo_type_t type; srslte_precoding_t precoding; parse_args(argc, argv); if (nof_ports > SRSLTE_MAX_PORTS || nof_layers > SRSLTE_MAX_LAYERS) { fprintf(stderr, "Invalid number of layers or ports\n"); exit(-1); } if (srslte_str2mimotype(mimo_type_name, &type)) { fprintf(stderr, "Invalid MIMO type %s\n", mimo_type_name); exit(-1); } for (i = 0; i < nof_layers; i++) { x[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols); if (!x[i]) { perror("srslte_vec_malloc"); exit(-1); } xr[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols); if (!xr[i]) { perror("srslte_vec_malloc"); exit(-1); } } for (i = 0; i < nof_ports; i++) { y[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers); // TODO: The number of symbols per port is different in spatial multiplexing. if (!y[i]) { perror("srslte_vec_malloc"); exit(-1); } h[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers); if (!h[i]) { perror("srslte_vec_malloc"); exit(-1); } } /* only 1 receiver antenna supported now */ r[0] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers); if (!r[0]) { perror("srslte_vec_malloc"); exit(-1); } /* generate random data */ for (i = 0; i < nof_layers; i++) { for (j = 0; j < nof_symbols; j++) { x[i][j] = (2*(rand()%2)-1+(2*(rand()%2)-1)*_Complex_I)/sqrt(2); } } if (srslte_precoding_init(&precoding, nof_symbols * nof_layers)) { fprintf(stderr, "Error initializing precoding\n"); exit(-1); } /* precoding */ if (srslte_precoding_type(&precoding, x, y, nof_layers, nof_ports, nof_symbols, type) < 0) { fprintf(stderr, "Error layer mapper encoder\n"); exit(-1); } /* generate channel */ for (i = 0; i < nof_ports; i++) { for (j = 0; j < nof_symbols; j++) { h[i][nof_layers*j] = (float) rand()/RAND_MAX+((float) rand()/RAND_MAX)*_Complex_I; // assume the channel is time-invariant in nlayer consecutive symbols for (int k=0;k<nof_layers;k++) { h[i][nof_layers*j+k] = h[i][nof_layers*j]; } } } /* pass signal through channel (we are in the frequency domain so it's a multiplication) */ /* there's only one receiver antenna, signals from different transmitter * ports are simply combined at the receiver */ for (j = 0; j < nof_symbols * nof_layers; j++) { r[0][j] = 0; for (i = 0; i < nof_ports; i++) { r[0][j] += y[i][j] * h[i][j]; } } /* predecoding / equalization */ struct timeval t[3]; gettimeofday(&t[1], NULL); if (srslte_predecoding_type(&precoding, r[0], h, xr, nof_ports, nof_layers, nof_symbols * nof_layers, type, 0) < 0) { fprintf(stderr, "Error layer mapper encoder\n"); exit(-1); } gettimeofday(&t[2], NULL); get_time_interval(t); printf("Execution Time: %d us\n", t[0].tv_usec); /* check errors */ mse = 0; for (i = 0; i < nof_layers; i++) { for (j = 0; j < nof_symbols; j++) { mse += cabsf(xr[i][j] - x[i][j]); } } printf("MSE: %f\n", mse/ nof_layers / nof_symbols ); if (mse / nof_layers / nof_symbols > MSE_THRESHOLD) { exit(-1); } for (i = 0; i < nof_layers; i++) { free(x[i]); free(xr[i]); } for (i = 0; i < nof_ports; i++) { free(y[i]); free(h[i]); } free(r[0]); srslte_precoding_free(&precoding); printf("Ok\n"); exit(0); }
int main(int argc, char **argv) { int ch, longindex, ret; unsigned long flags; struct option *long_options; const struct command *commands; const char *short_options; char *p, *env; const struct sd_option *sd_opts; uint8_t sdhost[16]; int sdport; struct timespec start, end; start = get_time_tick(); log_dog_operation(argc, argv); install_crash_handler(crash_handler); init_commands(&commands); if (argc < 2) usage(commands, 0); flags = setup_commands(commands, argv[1], argv[2]); optind = 3; sd_opts = build_sd_options(command_opts); long_options = build_long_options(sd_opts); short_options = build_short_options(sd_opts); env = getenv("SHEEPDOG_DOG_ADDR"); if (env) { if (!str_to_addr(env, sdhost)) { sd_err("Invalid ip address %s", env); return EXIT_FAILURE; } memcpy(sd_nid.addr, sdhost, sizeof(sdhost)); } env = getenv("SHEEPDOG_DOG_PORT"); if (env) { sdport = strtol(env, &p, 10); if (env == p || sdport < 1 || sdport > UINT16_MAX || !is_numeric(env)) { sd_err("Invalid port number '%s'", env); exit(EXIT_USAGE); } sd_nid.port = sdport; } while ((ch = getopt_long(argc, argv, short_options, long_options, &longindex)) >= 0) { switch (ch) { case 'a': if (!str_to_addr(optarg, sdhost)) { sd_err("Invalid ip address %s", optarg); return EXIT_FAILURE; } memcpy(sd_nid.addr, sdhost, sizeof(sdhost)); break; case 'p': sdport = strtol(optarg, &p, 10); if (optarg == p || sdport < 1 || sdport > UINT16_MAX || !is_numeric(optarg)) { sd_err("Invalid port number '%s'", optarg); exit(EXIT_USAGE); } sd_nid.port = sdport; break; case 'r': raw_output = true; break; case 'v': verbose = true; break; case 'h': subcommand_usage(argv[1], argv[2], EXIT_SUCCESS); break; case 't': elapsed_time = true; break; case '?': usage(commands, EXIT_USAGE); break; default: if (command_parser) command_parser(ch, optarg); else usage(commands, EXIT_USAGE); break; } } if (sd_inode_actor_init(dog_bnode_writer, dog_bnode_reader) < 0) exit(EXIT_SYSFAIL); if (!is_stdout_console() || raw_output) highlight = false; if (flags & CMD_NEED_NODELIST) { ret = update_node_list(SD_MAX_NODES); if (ret < 0) { sd_err("Failed to get node list"); exit(EXIT_SYSFAIL); } } if (flags & CMD_NEED_ARG && argc == optind) subcommand_usage(argv[1], argv[2], EXIT_USAGE); if (init_event(EPOLL_SIZE) < 0) exit(EXIT_SYSFAIL); if (init_work_queue(get_nr_nodes) != 0) { sd_err("Failed to init work queue"); exit(EXIT_SYSFAIL); } if (sockfd_init()) { sd_err("sockfd_init() failed"); exit(EXIT_SYSFAIL); } ret = command_fn(argc, argv); if (ret == EXIT_USAGE) subcommand_usage(argv[1], argv[2], EXIT_USAGE); if (elapsed_time) { end = get_time_tick(); printf("\nElapsed time: %.3lf seconds\n", get_time_interval(&start, &end)); } return ret; }
/* Returns 1 if the subframe is synchronized in time, 0 otherwise */ int srslte_ue_sync_zerocopy(srslte_ue_sync_t *q, cf_t *input_buffer) { int ret = SRSLTE_ERROR_INVALID_INPUTS; uint32_t track_idx; if (q != NULL && input_buffer != NULL) { if (q->file_mode) { int n = srslte_filesource_read(&q->file_source, input_buffer, q->sf_len); if (n < 0) { fprintf(stderr, "Error reading input file\n"); return SRSLTE_ERROR; } if (n == 0) { return 7; // srslte_filesource_seek(&q->file_source, 0); // q->sf_idx = 9; // int n = srslte_filesource_read(&q->file_source, input_buffer, q->sf_len); // if (n < 0) { // fprintf(stderr, "Error reading input file\n"); // return SRSLTE_ERROR; // } } if (q->correct_cfo) { srslte_cfo_correct(&q->file_cfo_correct, input_buffer, input_buffer, q->file_cfo / 15000 / q->fft_size); } q->sf_idx++; if (q->sf_idx == 10) { q->sf_idx = 0; } INFO("Reading %d samples. sf_idx = %d\n", q->sf_len, q->sf_idx); ret = 1; } else { if (receive_samples(q, input_buffer)) { fprintf(stderr, "Error receiving samples\n"); return SRSLTE_ERROR; } switch (q->state) { case SF_FIND: switch(srslte_sync_find(&q->sfind, input_buffer, 0, &q->peak_idx)) { case SRSLTE_SYNC_ERROR: ret = SRSLTE_ERROR; fprintf(stderr, "Error finding correlation peak (%d)\n", ret); return SRSLTE_ERROR; case SRSLTE_SYNC_FOUND: ret = find_peak_ok(q, input_buffer); break; case SRSLTE_SYNC_FOUND_NOSPACE: /* If a peak was found but there is not enough space for SSS/CP detection, discard a few samples */ printf("No space for SSS/CP detection. Realigning frame...\n"); q->recv_callback(q->stream, dummy_offset_buffer, q->frame_len/2, NULL); srslte_sync_reset(&q->sfind); ret = SRSLTE_SUCCESS; break; default: ret = SRSLTE_SUCCESS; break; } if (q->do_agc) { srslte_agc_process(&q->agc, input_buffer, q->sf_len); } break; case SF_TRACK: ret = 1; srslte_sync_sss_en(&q->strack, q->decode_sss_on_track); q->sf_idx = (q->sf_idx + q->nof_recv_sf) % 10; /* Every SF idx 0 and 5, find peak around known position q->peak_idx */ if (q->sf_idx == 0 || q->sf_idx == 5) { if (q->do_agc && (q->agc_period == 0 || (q->agc_period && (q->frame_total_cnt%q->agc_period) == 0))) { srslte_agc_process(&q->agc, input_buffer, q->sf_len); } #ifdef MEASURE_EXEC_TIME struct timeval t[3]; gettimeofday(&t[1], NULL); #endif track_idx = 0; /* Track PSS/SSS around the expected PSS position * In tracking phase, the subframe carrying the PSS is always the last one of the frame */ switch(srslte_sync_find(&q->strack, input_buffer, q->frame_len - q->sf_len/2 - q->fft_size - q->strack.max_offset/2, &track_idx)) { case SRSLTE_SYNC_ERROR: ret = SRSLTE_ERROR; fprintf(stderr, "Error tracking correlation peak\n"); return SRSLTE_ERROR; case SRSLTE_SYNC_FOUND: ret = track_peak_ok(q, track_idx); break; case SRSLTE_SYNC_FOUND_NOSPACE: // It's very very unlikely that we fall here because this event should happen at FIND phase only ret = 0; q->state = SF_FIND; printf("Warning: No space for SSS/CP while in tracking phase\n"); break; case SRSLTE_SYNC_NOFOUND: ret = track_peak_no(q); break; } #ifdef MEASURE_EXEC_TIME gettimeofday(&t[2], NULL); get_time_interval(t); q->mean_exec_time = (float) SRSLTE_VEC_CMA((float) t[0].tv_usec, q->mean_exec_time, q->frame_total_cnt); #endif if (ret == SRSLTE_ERROR) { fprintf(stderr, "Error processing tracking peak\n"); q->state = SF_FIND; return SRSLTE_SUCCESS; } q->frame_total_cnt++; } else { if (q->correct_cfo) { srslte_cfo_correct(&q->sfind.cfocorr, input_buffer, input_buffer, -srslte_sync_get_cfo(&q->strack) / q->fft_size); } } break; } } } return ret; }
// Function to handle report reads based on user input int ReadReport(unsigned char input) { int ret = 0; unsigned char data; data = 0x01; Write8BitRegisters(F54CommandBase, &data, 1); count = 0; do { Read8BitRegisters(F54CommandBase, &data, 1); msleep(1); count++; } while (data != 0x00 && (count < DefaultTimeout)); if(count >= DefaultTimeout) { outbuf += sprintf(f54_wlog_buf+outbuf, "Timeout -- Not supported Report Type in FW\n"); Reset(); return ret; } do_gettimeofday(&t_interval[ENDTIME]); printk("Takes %lu ticks\n", get_time_interval(t_interval[ENDTIME].tv_sec,t_interval[STARTTIME].tv_sec)); switch (input){ case 'a': ret = ReadImageReport(); break; case 'b': ReadADCRangeReport(); break; case 'c': ReadSensorSpeedReport(); break; case 'd': // fprintk(stderr, "Press any key to continue after you have lowered the bar.\n"); // _getch(); ReadTRexOpenReport(); break; case 'e': ret = ReadTRexGroundReport(); break; case 'f': ret = ReadTRexShortReport(); break; case 'g': ret = ReadHighResistanceReport(); break; case 'h': ReadMaxMinReport(); break; case 'i': ReadAbsADCRangeReport(); break; case 'j': ReadAbsDeltaReport(); break; case 'k': ReadAbsRawReport(); break; default: break; } return ret; }
int main(int argc, char **argv) { int i; srslte_sequence_t seq; uint8_t *input_b, *scrambled_b; float *input_f, *scrambled_f; struct timeval t[3]; parse_args(argc, argv); if (init_sequence(&seq, srslte_sequence_name) == -1) { fprintf(stderr, "Error initiating sequence %s\n", srslte_sequence_name); exit(-1); } if (!do_floats) { input_b = malloc(sizeof(uint8_t) * seq.len); if (!input_b) { perror("malloc"); exit(-1); } scrambled_b = malloc(sizeof(uint8_t) * seq.len); if (!scrambled_b) { perror("malloc"); exit(-1); } for (i=0;i<seq.len;i++) { input_b[i] = rand()%2; scrambled_b[i] = input_b[i]; } gettimeofday(&t[1], NULL); srslte_scrambling_b(&seq, scrambled_b); gettimeofday(&t[2], NULL); srslte_scrambling_b(&seq, scrambled_b); get_time_interval(t); printf("Texec=%d us for %d bits\n", t[0].tv_usec, seq.len); for (i=0;i<seq.len;i++) { if (scrambled_b[i] != input_b[i]) { printf("Error in %d\n", i); exit(-1); } } free(input_b); free(scrambled_b); } else { input_f = malloc(sizeof(float) * seq.len); if (!input_f) { perror("malloc"); exit(-1); } scrambled_f = malloc(sizeof(float) * seq.len); if (!scrambled_f) { perror("malloc"); exit(-1); } for (i=0;i<seq.len;i++) { input_f[i] = 100*(rand()/RAND_MAX); scrambled_f[i] = input_f[i]; } gettimeofday(&t[1], NULL); srslte_scrambling_f(&seq, scrambled_f); gettimeofday(&t[2], NULL); srslte_scrambling_f(&seq, scrambled_f); get_time_interval(t); printf("Texec=%d us for %d bits\n", t[0].tv_usec, seq.len); for (i=0;i<seq.len;i++) { if (scrambled_f[i] != input_f[i]) { printf("Error in %d\n", i); exit(-1); } } free(input_f); free(scrambled_f); } printf("Ok\n"); srslte_sequence_free(&seq); exit(0); }
int main(int argc, char **argv) { int i, j, k, nof_errors = 0, ret = SRSLTE_SUCCESS; float mse; cf_t *x[SRSLTE_MAX_LAYERS], *r[SRSLTE_MAX_PORTS], *y[SRSLTE_MAX_PORTS], *h[SRSLTE_MAX_PORTS][SRSLTE_MAX_PORTS], *xr[SRSLTE_MAX_LAYERS]; srslte_mimo_type_t type; parse_args(argc, argv); /* Check input ranges */ if (nof_tx_ports > SRSLTE_MAX_PORTS || nof_rx_ports > SRSLTE_MAX_PORTS || nof_layers > SRSLTE_MAX_LAYERS) { fprintf(stderr, "Invalid number of layers or ports\n"); exit(-1); } /* Parse MIMO Type */ if (srslte_str2mimotype(mimo_type_name, &type)) { fprintf(stderr, "Invalid MIMO type %s\n", mimo_type_name); exit(-1); } /* Check scenario conditions are OK */ switch (type) { case SRSLTE_MIMO_TYPE_TX_DIVERSITY: nof_re = nof_layers*nof_symbols; break; case SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX: nof_re = nof_symbols; break; case SRSLTE_MIMO_TYPE_CDD: nof_re = nof_symbols*nof_tx_ports/nof_layers; if (nof_rx_ports != 2 || nof_tx_ports != 2) { fprintf(stderr, "CDD nof_tx_ports=%d nof_rx_ports=%d is not currently supported\n", nof_tx_ports, nof_rx_ports); exit(-1); } break; default: nof_re = nof_symbols*nof_layers; } /* Allocate x and xr (received symbols) in memory for each layer */ for (i = 0; i < nof_layers; i++) { /* Source data */ x[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols); if (!x[i]) { perror("srslte_vec_malloc"); exit(-1); } /* Sink data */ xr[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols); if (!xr[i]) { perror("srslte_vec_malloc"); exit(-1); } } /* Allocate y in memory for tx each port */ for (i = 0; i < nof_tx_ports; i++) { y[i] = srslte_vec_malloc(sizeof(cf_t) * nof_re); if (!y[i]) { perror("srslte_vec_malloc"); exit(-1); } } /* Allocate h in memory for each cross channel and layer */ for (i = 0; i < nof_tx_ports; i++) { for (j = 0; j < nof_rx_ports; j++) { h[i][j] = srslte_vec_malloc(sizeof(cf_t) * nof_re); if (!h[i][j]) { perror("srslte_vec_malloc"); exit(-1); } } } /* Allocate r */ for (i = 0; i < nof_rx_ports; i++) { r[i] = srslte_vec_malloc(sizeof(cf_t) * nof_re); if (!r[i]) { perror("srslte_vec_malloc"); exit(-1); } } /* Generate source random data */ for (i = 0; i < nof_layers; i++) { for (j = 0; j < nof_symbols; j++) { x[i][j] = (2 * (rand() % 2) - 1 + (2 * (rand() % 2) - 1) * _Complex_I) / sqrt(2); } } /* Execute Precoding (Tx) */ if (srslte_precoding_type(x, y, nof_layers, nof_tx_ports, codebook_idx, nof_symbols, scaling, type) < 0) { fprintf(stderr, "Error layer mapper encoder\n"); exit(-1); } /* generate channel */ populate_channel(type, h); /* pass signal through channel (we are in the frequency domain so it's a multiplication) */ for (i = 0; i < nof_rx_ports; i++) { for (k = 0; k < nof_re; k++) { r[i][k] = (cf_t) (0.0 + 0.0 * _Complex_I); for (j = 0; j < nof_tx_ports; j++) { r[i][k] += y[j][k] * h[j][i][k]; } } } awgn(r, (uint32_t) nof_re, snr_db); /* If CDD or Spatial muliplex choose decoder */ if (strncmp(decoder_type_name, "zf", 16) == 0) { srslte_predecoding_set_mimo_decoder(SRSLTE_MIMO_DECODER_ZF); } else if (strncmp(decoder_type_name, "mmse", 16) == 0) { srslte_predecoding_set_mimo_decoder(SRSLTE_MIMO_DECODER_MMSE); } else { ret = SRSLTE_ERROR; goto quit; } /* predecoding / equalization */ struct timeval t[3]; gettimeofday(&t[1], NULL); srslte_predecoding_type(r, h, xr, NULL, nof_rx_ports, nof_tx_ports, nof_layers, codebook_idx, nof_re, type, scaling, powf(10, -snr_db / 10)); gettimeofday(&t[2], NULL); get_time_interval(t); /* check errors */ mse = 0; for (i = 0; i < nof_layers; i++) { for (j = 0; j < nof_symbols; j++) { mse += cabsf(xr[i][j] - x[i][j]); if ((crealf(xr[i][j]) > 0) != (crealf(x[i][j]) > 0)) { nof_errors ++; } if ((cimagf(xr[i][j]) > 0) != (cimagf(x[i][j]) > 0)) { nof_errors ++; } } } printf("SNR: %5.1fdB;\tExecution time: %5ldus;\tMSE: %.6f;\tBER: %.6f\n", snr_db, t[0].tv_usec, mse / nof_layers / nof_symbols, (float) nof_errors / (4.0f * nof_re)); if (mse / nof_layers / nof_symbols > MSE_THRESHOLD) { ret = SRSLTE_ERROR; } quit: /* Free all data */ for (i = 0; i < nof_layers; i++) { free(x[i]); free(xr[i]); } for (i = 0; i < nof_rx_ports; i++) { free(r[i]); } for (i = 0; i < nof_rx_ports; i++) { for (j = 0; j < nof_tx_ports; j++) { free(h[j][i]); } } exit(ret); }
int main(int argc, char **argv) { int i; modem_table_t mod; demod_soft_t demod_soft; char *input, *output; cf_t *symbols; float *llr_exact, *llr_approx; parse_args(argc, argv); /* initialize objects */ if (modem_table_lte(&mod, modulation, true)) { fprintf(stderr, "Error initializing modem table\n"); exit(-1); } /* check that num_bits is multiple of num_bits x symbol */ num_bits = mod.nbits_x_symbol * (num_bits / mod.nbits_x_symbol); demod_soft_init(&demod_soft); demod_soft_table_set(&demod_soft, &mod); demod_soft_sigma_set(&demod_soft, 2.0 / mod.nbits_x_symbol); /* allocate buffers */ input = malloc(sizeof(char) * num_bits); if (!input) { perror("malloc"); exit(-1); } output = malloc(sizeof(char) * num_bits); if (!output) { perror("malloc"); exit(-1); } symbols = malloc(sizeof(cf_t) * num_bits / mod.nbits_x_symbol); if (!symbols) { perror("malloc"); exit(-1); } llr_exact = malloc(sizeof(float) * num_bits); if (!llr_exact) { perror("malloc"); exit(-1); } llr_approx = malloc(sizeof(float) * num_bits); if (!llr_approx) { perror("malloc"); exit(-1); } /* generate random data */ srand(0); int ret = -1; double mse; struct timeval t[3]; float mean_texec = 0.0; for (int n=0;n<nof_frames;n++) { for (i=0;i<num_bits;i++) { input[i] = rand()%2; } /* modulate */ mod_modulate(&mod, input, symbols, num_bits); /* add noise */ ch_awgn_c(symbols, symbols, ch_awgn_get_variance(5.0, mod.nbits_x_symbol), num_bits / mod.nbits_x_symbol); /* Compare exact with approximation algorithms */ demod_soft_alg_set(&demod_soft, EXACT); demod_soft_demodulate(&demod_soft, symbols, llr_exact, num_bits / mod.nbits_x_symbol); demod_soft_alg_set(&demod_soft, APPROX); gettimeofday(&t[1], NULL); demod_soft_demodulate(&demod_soft, symbols, llr_approx, num_bits / mod.nbits_x_symbol); gettimeofday(&t[2], NULL); get_time_interval(t); /* compute exponentially averaged execution time */ if (n > 0) { mean_texec = EXPAVERAGE((float) t[0].tv_usec, mean_texec, n-1); } /* check MSE */ mse = 0.0; for (i=0;i<num_bits;i++) { float e = llr_exact[i] - llr_approx[i]; mse += e*e; } mse/=num_bits; if (VERBOSE_ISDEBUG()) { printf("exact="); vec_fprint_f(stdout, llr_exact, num_bits); printf("approx="); vec_fprint_f(stdout, llr_approx, num_bits); } if (mse > mse_threshold()) { goto clean_exit; } } ret = 0; clean_exit: free(llr_exact); free(llr_approx); free(symbols); free(output); free(input); modem_table_free(&mod); if (ret == 0) { printf("Ok Mean Throughput: %.2f. Mbps ExTime: %.2f us\n", num_bits/mean_texec, mean_texec); } else { printf("Error: MSE too large (%f > %f)\n", mse, mse_threshold()); } exit(ret); }
int main(int argc, char **argv) { srslte_refsignal_ul_t refs; srslte_refsignal_dmrs_pusch_cfg_t pusch_cfg; cf_t *signal = NULL; int ret = -1; parse_args(argc,argv); if (srslte_refsignal_ul_init(&refs, cell)) { fprintf(stderr, "Error initializing UL reference signal\n"); goto do_exit; } signal = malloc(2 * SRSLTE_NRE * cell.nof_prb * sizeof(cf_t)); if (!signal) { perror("malloc"); goto do_exit; } printf("Running tests for %d PRB\n", cell.nof_prb); for (int n=6;n<cell.nof_prb;n++) { for (int delta_ss=29;delta_ss<SRSLTE_NOF_DELTA_SS;delta_ss++) { for (int cshift=0;cshift<SRSLTE_NOF_CSHIFT;cshift++) { for (int h=0;h<3;h++) { for (int sf_idx=0;sf_idx<10;sf_idx++) { for (int cshift_dmrs=0;cshift_dmrs<SRSLTE_NOF_CSHIFT;cshift_dmrs++) { uint32_t nof_prb = n; pusch_cfg.cyclic_shift = cshift; pusch_cfg.delta_ss = delta_ss; bool group_hopping_en = false; bool sequence_hopping_en = false; if (!h) { group_hopping_en = false; sequence_hopping_en = false; } else if (h == 1) { group_hopping_en = false; sequence_hopping_en = true; } else if (h == 2) { group_hopping_en = true; sequence_hopping_en = false; } printf("nof_prb: %d, ",nof_prb); printf("cyclic_shift: %d, ",pusch_cfg.cyclic_shift); printf("cyclic_shift_for_dmrs: %d, ", cshift_dmrs); printf("delta_ss: %d, ",pusch_cfg.delta_ss); printf("SF_idx: %d\n", sf_idx); struct timeval t[3]; gettimeofday(&t[1], NULL); pusch_cfg.group_hopping_en = group_hopping_en; pusch_cfg.sequence_hopping_en = sequence_hopping_en; srslte_refsignal_ul_set_cfg(&refs, &pusch_cfg, NULL, NULL); srslte_refsignal_dmrs_pusch_gen(&refs, nof_prb, sf_idx, cshift_dmrs, signal); gettimeofday(&t[2], NULL); get_time_interval(t); printf("DMRS ExecTime: %d us\n", t[0].tv_usec); gettimeofday(&t[1], NULL); srslte_refsignal_srs_gen(&refs, sf_idx, signal); gettimeofday(&t[2], NULL); get_time_interval(t); printf("SRS ExecTime: %d us\n", t[0].tv_usec); } } } } } } ret = 0; do_exit: if (signal) { free(signal); } srslte_refsignal_ul_free(&refs); if (!ret) { printf("OK\n"); } exit(ret); }
int main(int argc, char **argv) { srslte_pusch_t pusch; uint8_t *data = NULL; cf_t *sf_symbols = NULL; cf_t *ce = NULL; int ret = -1; struct timeval t[3]; srslte_pusch_cfg_t cfg; srslte_softbuffer_tx_t softbuffer_tx; srslte_softbuffer_rx_t softbuffer_rx; parse_args(argc,argv); bzero(&cfg, sizeof(srslte_pusch_cfg_t)); srslte_ra_ul_dci_t dci; dci.freq_hop_fl = freq_hop; if (riv < 0) { dci.type2_alloc.L_crb = L_prb; dci.type2_alloc.RB_start = n_prb; } else { dci.type2_alloc.riv = riv; } dci.mcs_idx = mcs_idx; srslte_ra_ul_grant_t grant; if (srslte_ra_ul_dci_to_grant(&dci, cell.nof_prb, 0, &grant, 0)) { fprintf(stderr, "Error computing resource allocation\n"); return ret; } srslte_pusch_hopping_cfg_t ul_hopping; ul_hopping.n_sb = 1; ul_hopping.hopping_offset = 0; ul_hopping.hop_mode = SRSLTE_PUSCH_HOP_MODE_INTER_SF; if (srslte_pusch_init(&pusch, cell)) { fprintf(stderr, "Error creating PDSCH object\n"); goto quit; } /* Configure PUSCH */ printf("Encoding rv_idx=%d\n",rv_idx); srslte_uci_cfg_t uci_cfg; uci_cfg.I_offset_cqi = 6; uci_cfg.I_offset_ri = 2; uci_cfg.I_offset_ack = 4; if (srslte_pusch_cfg(&pusch, &cfg, &grant, &uci_cfg, &ul_hopping, NULL, subframe, 0, 0)) { fprintf(stderr, "Error configuring PDSCH\n"); exit(-1); } srslte_pusch_set_rnti(&pusch, 1234); srslte_uci_data_t uci_data_tx; srslte_uci_data_t uci_data_rx; bzero(&uci_data_tx, sizeof(srslte_uci_data_t)); uci_data_tx.uci_cqi_len = 4; uci_data_tx.uci_ri_len = 0; uci_data_tx.uci_ack_len = 0; memcpy(&uci_data_rx, &uci_data_tx, sizeof(srslte_uci_data_t)); for (uint32_t i=0;i<20;i++) { uci_data_tx.uci_cqi [i] = 1; } uci_data_tx.uci_ri = 1; uci_data_tx.uci_ack = 1; uint32_t nof_re = SRSLTE_NRE*cell.nof_prb*2*SRSLTE_CP_NSYMB(cell.cp); sf_symbols = srslte_vec_malloc(sizeof(cf_t) * nof_re); if (!sf_symbols) { perror("malloc"); exit(-1); } data = srslte_vec_malloc(sizeof(uint8_t) * cfg.grant.mcs.tbs); if (!data) { perror("malloc"); exit(-1); } for (uint32_t i=0;i<cfg.grant.mcs.tbs/8;i++) { data[i] = 1; } if (srslte_softbuffer_tx_init(&softbuffer_tx, 100)) { fprintf(stderr, "Error initiating soft buffer\n"); goto quit; } if (srslte_softbuffer_rx_init(&softbuffer_rx, 100)) { fprintf(stderr, "Error initiating soft buffer\n"); goto quit; } uint32_t ntrials = 100; if (srslte_pusch_uci_encode(&pusch, &cfg, &softbuffer_tx, data, uci_data_tx, sf_symbols)) { fprintf(stderr, "Error encoding TB\n"); exit(-1); } if (rv_idx > 0) { cfg.rv = rv_idx; if (srslte_pusch_uci_encode(&pusch, &cfg, &softbuffer_tx, data, uci_data_tx, sf_symbols)) { fprintf(stderr, "Error encoding TB\n"); exit(-1); } } ce = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)); if (!ce) { perror("srslte_vec_malloc"); goto quit; } for (int j=0;j<SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp);j++) { ce[j] = 1; } gettimeofday(&t[1], NULL); int r = srslte_pusch_uci_decode(&pusch, &cfg, &softbuffer_rx, sf_symbols, ce, 0, data, &uci_data_rx); gettimeofday(&t[2], NULL); get_time_interval(t); if (r) { printf("Error decoding\n"); ret = -1; } else { ret = 0; printf("DECODED OK in %d:%d (TBS: %d bits, TX: %.2f Mbps, Processing: %.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec/ntrials, cfg.grant.mcs.tbs, (float) cfg.grant.mcs.tbs/1000, (float) cfg.grant.mcs.tbs/t[0].tv_usec*ntrials); } if (uci_data_tx.uci_ack_len) { if (uci_data_tx.uci_ack != uci_data_rx.uci_ack) { printf("UCI ACK bit error: %d != %d\n", uci_data_tx.uci_ack, uci_data_rx.uci_ack); } } if (uci_data_tx.uci_ri_len) { if (uci_data_tx.uci_ri != uci_data_rx.uci_ri) { printf("UCI RI bit error: %d != %d\n", uci_data_tx.uci_ri, uci_data_rx.uci_ri); } } if (uci_data_tx.uci_cqi_len) { printf("cqi_tx="); srslte_vec_fprint_b(stdout, uci_data_tx.uci_cqi, uci_data_tx.uci_cqi_len); printf("cqi_rx="); srslte_vec_fprint_b(stdout, uci_data_rx.uci_cqi, uci_data_rx.uci_cqi_len); } quit: srslte_pusch_free(&pusch); srslte_softbuffer_tx_free(&softbuffer_tx); if (sf_symbols) { free(sf_symbols); } if (data) { free(data); } if (ce) { free(ce); } if (ret) { printf("Error\n"); } else { printf("Ok\n"); } exit(ret); }
float transmit_packets(FILE *fp, int sockfd, struct sockaddr *server_address, int addrlen, long *len) { char *buf; long file_size, total_size_sent; char sends[DATALEN]; int socket_length = sizeof(struct sockaddr_in); struct ack_so acknowledgement; //Packet length + Header Length = total_packet_length int n, total_packet_length; float time_interval = 0.0; double random_error_probability = 0.0; struct timeval time_of_sending, time_of_receiving; total_size_sent = 0; fseek (fp , 0 , SEEK_END); file_size = ftell (fp); rewind (fp); printf("The file length is %d bytes\n", (int)file_size); printf("the packet length is %d bytes\n",DATALEN); // allocate memory to contain the whole file. buf = (char *) malloc (file_size); if (buf == NULL) exit (EXIT_FAILURE); // copy the file into the buffer. fread (buf,1,file_size,fp); /*** the whole file is loaded in the buffer. ***/ buf[file_size] ='\0'; gettimeofday(&time_of_sending, NULL); int retransmit_flag = 0; srand(time(NULL)); while(total_size_sent<= file_size) { if(retransmit_flag == 1){ retransmit_flag = 0; printf("Retransmitting frame\n"); } if ((file_size+1-total_size_sent) <= DATALEN) total_packet_length = file_size+1-total_size_sent; else total_packet_length = DATALEN; memcpy(sends, (buf+total_size_sent), total_packet_length); //Generating a random error probability value random_error_probability = (double)rand() / (double)RAND_MAX ; if(random_error_probability > FRAME_ERROR_PROBABILITY) { //Sending packet without any error printf("Error Probability less than FRAME_ERROR_PROBABILITY\n"); n = sendto(sockfd, &sends, total_packet_length, 0, server_address, socket_length); } else{ printf("random_error_probability = %f\nSending bad frame\n",random_error_probability); n = sendto(sockfd, &sends, 0, 0, server_address, socket_length); } if(n == -1) exit(EXIT_FAILURE); //Checking for Acknowledgement if (recv(sockfd, &acknowledgement, 2, 0) == -1) //receive the ack { printf("error receiving acknowledgement\n"); exit(EXIT_FAILURE); } else{ if (acknowledgement.num != ACK_CODE || acknowledgement.len != 0) { printf("Wrong Acknowledgement Received, continuing\n"); retransmit_flag = 1; continue; //printf("error in transmission\n"); } else printf("Acknowledgement received\n"); } total_size_sent += total_packet_length; } gettimeofday(&time_of_receiving, NULL); *len= total_size_sent; //Getting time interval between client sending and server receiving get_time_interval(&time_of_receiving, &time_of_sending); time_interval += (time_of_receiving.tv_sec)*1000.0 + (time_of_receiving.tv_usec)/1000.0; return(time_interval); }
int main(int argc, char **argv) { uint32_t i, j, k; int ret = -1; struct timeval t[3]; srslte_softbuffer_tx_t *softbuffers_tx[SRSLTE_MAX_CODEWORDS]; int M=1; parse_args(argc,argv); /* Initialise to zeros */ bzero(&pmch_tx, sizeof(srslte_pmch_t)); bzero(&pmch_rx, sizeof(srslte_pmch_t)); bzero(&pmch_cfg, sizeof(srslte_pdsch_cfg_t)); bzero(ce, sizeof(cf_t*)*SRSLTE_MAX_PORTS); bzero(tx_slot_symbols, sizeof(cf_t*)*SRSLTE_MAX_PORTS); bzero(rx_slot_symbols, sizeof(cf_t*)*SRSLTE_MAX_PORTS); cell.nof_ports = 1; srslte_ra_dl_dci_t dci; bzero(&dci, sizeof(srslte_ra_dl_dci_t)); dci.type0_alloc.rbg_bitmask = 0xffffffff; /* If transport block 0 is enabled */ grant.tb_en[0] = true; grant.tb_en[1] = false; grant.mcs[0].idx = mcs_idx; grant.nof_prb = cell.nof_prb; grant.sf_type = SRSLTE_SF_MBSFN; srslte_dl_fill_ra_mcs(&grant.mcs[0], cell.nof_prb); grant.Qm[0] = srslte_mod_bits_x_symbol(grant.mcs[0].mod); for(int i = 0; i < 2; i++){ for(int j = 0; j < grant.nof_prb; j++){ grant.prb_idx[i][j] = true; } } /* init memory */ for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (j = 0; j < SRSLTE_MAX_PORTS; j++) { ce[i][j] = srslte_vec_malloc(sizeof(cf_t) * NOF_CE_SYMBOLS); if (!ce[i][j]) { perror("srslte_vec_malloc"); goto quit; } for (k = 0; k < NOF_CE_SYMBOLS; k++) { ce[i][j][k] = (i == j) ? 1.0f : 0.0f; } } rx_slot_symbols[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)); if (!rx_slot_symbols[i]) { perror("srslte_vec_malloc"); goto quit; } } for (i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { softbuffers_tx[i] = calloc(sizeof(srslte_softbuffer_tx_t), 1); if (!softbuffers_tx[i]) { fprintf(stderr, "Error allocating TX soft buffer\n"); } if (srslte_softbuffer_tx_init(softbuffers_tx[i], cell.nof_prb)) { fprintf(stderr, "Error initiating TX soft buffer\n"); goto quit; } } for (i = 0; i < cell.nof_ports; i++) { tx_slot_symbols[i] = calloc(SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp), sizeof(cf_t)); if (!tx_slot_symbols[i]) { perror("srslte_vec_malloc"); goto quit; } } for (int i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { if (grant.tb_en[i]) { data_tx[i] = srslte_vec_malloc(sizeof(uint8_t) * grant.mcs[i].tbs); if (!data_tx[i]) { perror("srslte_vec_malloc"); goto quit; } bzero(data_tx[i], sizeof(uint8_t) * grant.mcs[i].tbs); data_rx[i] = srslte_vec_malloc(sizeof(uint8_t) * grant.mcs[i].tbs); if (!data_rx[i]) { perror("srslte_vec_malloc"); goto quit; } bzero(data_rx[i], sizeof(uint8_t) * grant.mcs[i].tbs); } } for (i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { softbuffers_rx[i] = calloc(sizeof(srslte_softbuffer_rx_t), 1); if (!softbuffers_rx[i]) { fprintf(stderr, "Error allocating RX soft buffer\n"); goto quit; } if (srslte_softbuffer_rx_init(softbuffers_rx[i], cell.nof_prb)) { fprintf(stderr, "Error initiating RX soft buffer\n"); goto quit; } } #ifdef DO_OFDM for (i = 0; i < cell.nof_ports; i++) { tx_sf_symbols[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_PRB(cell.nof_prb)); if (srslte_ofdm_tx_init_mbsfn(&ifft_mbsfn[i], SRSLTE_CP_EXT, tx_slot_symbols[i], tx_sf_symbols[i], cell.nof_prb)) { fprintf(stderr, "Error creating iFFT object\n"); exit(-1); } srslte_ofdm_set_non_mbsfn_region(&ifft_mbsfn[i], non_mbsfn_region); srslte_ofdm_set_normalize(&ifft_mbsfn[i], true); } for (i = 0; i < nof_rx_antennas; i++) { rx_sf_symbols[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_PRB(cell.nof_prb)); if (srslte_ofdm_rx_init_mbsfn(&fft_mbsfn[i], SRSLTE_CP_EXT, rx_sf_symbols[i], rx_slot_symbols[i], cell.nof_prb)) { fprintf(stderr, "Error creating iFFT object\n"); exit(-1); } srslte_ofdm_set_non_mbsfn_region(&fft_mbsfn[i], non_mbsfn_region); srslte_ofdm_set_normalize(&fft_mbsfn[i], true); } #endif /* DO_OFDM */ /* Configure PDSCH */ if (srslte_pmch_cfg(&pmch_cfg, cell, &grant, cfi, subframe)) { fprintf(stderr, "Error configuring PMCH\n"); exit(-1); } if (srslte_pmch_cfg(&pmch_cfg, cell, &grant, cfi, subframe)) { fprintf(stderr, "Error configuring PMCH\n"); exit(-1); } INFO(" Global:\n"); INFO(" nof_prb=%d\n", cell.nof_prb); INFO(" nof_ports=%d\n", cell.nof_ports); INFO(" id=%d\n", cell.id); INFO(" cp=%s\n", srslte_cp_string(cell.cp)); INFO(" phich_length=%d\n", (int) cell.phich_length); INFO(" phich_resources=%d\n", (int) cell.phich_resources); INFO(" nof_prb=%d\n", pmch_cfg.grant.nof_prb); INFO(" sf_idx=%d\n", pmch_cfg.sf_idx); INFO(" mimo_type=%s\n", srslte_mimotype2str(pmch_cfg.mimo_type)); INFO(" nof_layers=%d\n", pmch_cfg.nof_layers); INFO(" nof_tb=%d\n", SRSLTE_RA_DL_GRANT_NOF_TB(&pmch_cfg.grant)); INFO(" Qm=%d\n", pmch_cfg.grant.Qm[0]); INFO(" mcs.idx=0x%X\n", pmch_cfg.grant.mcs[0].idx); INFO(" mcs.tbs=%d\n", pmch_cfg.grant.mcs[0].tbs); INFO(" mcs.mod=%s\n", srslte_mod_string(pmch_cfg.grant.mcs[0].mod)); INFO(" rv=%d\n", pmch_cfg.rv[0]); INFO(" lstart=%d\n", pmch_cfg.nbits[0].lstart); INFO(" nof_bits=%d\n", pmch_cfg.nbits[0].nof_bits); INFO(" nof_re=%d\n", pmch_cfg.nbits[0].nof_re); INFO(" nof_symb=%d\n", pmch_cfg.nbits[0].nof_symb); if (srslte_pmch_init(&pmch_tx, cell.nof_prb)) { fprintf(stderr, "Error creating PMCH object\n"); } srslte_pmch_set_area_id(&pmch_tx, mbsfn_area_id); if (srslte_pmch_init(&pmch_rx, cell.nof_prb)) { fprintf(stderr, "Error creating PMCH object\n"); } srslte_pmch_set_area_id(&pmch_rx, mbsfn_area_id); for (int tb = 0; tb < SRSLTE_MAX_CODEWORDS; tb++) { if (grant.tb_en[tb]) { for (int byte = 0; byte < grant.mcs[tb].tbs / 8; byte++) { data_tx[tb][byte] = (uint8_t) (rand() % 256); } } } if (srslte_pmch_encode(&pmch_tx, &pmch_cfg, softbuffers_tx[0], data_tx[0], mbsfn_area_id, tx_slot_symbols)) { fprintf(stderr, "Error encoding PDSCH\n"); exit(-1); } gettimeofday(&t[2], NULL); get_time_interval(t); printf("ENCODED in %.2f (PHY bitrate=%.2f Mbps. Processing bitrate=%.2f Mbps)\n", (float) t[0].tv_usec/M, (float) (grant.mcs[0].tbs + grant.mcs[1].tbs)/1000.0f, (float) (grant.mcs[0].tbs + grant.mcs[1].tbs)*M/t[0].tv_usec); #ifdef DO_OFDM for (i = 0; i < cell.nof_ports; i++) { /* For each Tx antenna modulate OFDM */ srslte_ofdm_tx_sf(&ifft_mbsfn[i]); } /* combine outputs */ for (j = 0; j < nof_rx_antennas; j++) { for (k = 0; k < NOF_CE_SYMBOLS; k++) { rx_sf_symbols[j][k] = 0.0f; for (i = 0; i < cell.nof_ports; i++) { rx_sf_symbols[j][k] += tx_sf_symbols[i][k] * ce[i][j][k]; } } } #else /* combine outputs */ for (j = 0; j < nof_rx_antennas; j++) { for (k = 0; k < SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp); k++) { rx_slot_symbols[j][k] = 0.0f; for (i = 0; i < cell.nof_ports; i++) { rx_slot_symbols[j][k] += tx_slot_symbols[i][k] * ce[i][j][k]; } } } #endif int r=0; gettimeofday(&t[1], NULL); #ifdef DO_OFDM /* For each Rx antenna demodulate OFDM */ for (i = 0; i < nof_rx_antennas; i++) { srslte_ofdm_rx_sf(&fft_mbsfn[i]); } #endif for (i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { if (grant.tb_en[i]) { srslte_softbuffer_rx_reset_tbs(softbuffers_rx[i], (uint32_t) grant.mcs[i].tbs); } } r = srslte_pmch_decode(&pmch_rx, &pmch_cfg, softbuffers_rx[0],rx_slot_symbols[0], ce[0],0,mbsfn_area_id, data_rx[0]); gettimeofday(&t[2], NULL); get_time_interval(t); printf("DECODED %s in %.2f (PHY bitrate=%.2f Mbps. Processing bitrate=%.2f Mbps)\n", r?"Error":"OK", (float) t[0].tv_usec/M, (float) (grant.mcs[0].tbs + grant.mcs[1].tbs)/1000.0f, (float) (grant.mcs[0].tbs + grant.mcs[1].tbs)*M/t[0].tv_usec); /* If there is an error in PDSCH decode */ if (r) { ret = -1; goto quit; } /* Check Tx and Rx bytes */ for (int tb = 0; tb < SRSLTE_MAX_CODEWORDS; tb++) { if (grant.tb_en[tb]) { for (int byte = 0; byte < grant.mcs[tb].tbs / 8; byte++) { if (data_tx[tb][byte] != data_rx[tb][byte]) { ERROR("Found BYTE error in TB %d (%02X != %02X), quiting...", tb, data_tx[tb][byte], data_rx[tb][byte]); ret = SRSLTE_ERROR; goto quit; } } } } ret = SRSLTE_SUCCESS; quit: srslte_pmch_free(&pmch_tx); srslte_pmch_free(&pmch_rx); for (i = 0; i < SRSLTE_MAX_CODEWORDS; i++) { srslte_softbuffer_tx_free(softbuffers_tx[i]); if (softbuffers_tx[i]) { free(softbuffers_tx[i]); } srslte_softbuffer_rx_free(softbuffers_rx[i]); if (softbuffers_rx[i]) { free(softbuffers_rx[i]); } if (data_tx[i]) { free(data_tx[i]); } if (data_rx[i]) { free(data_rx[i]); } } for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (j = 0; j < SRSLTE_MAX_PORTS; j++) { if (ce[i][j]) { free(ce[i][j]); } } if (tx_slot_symbols[i]) { free(tx_slot_symbols[i]); } if (rx_slot_symbols[i]) { free(rx_slot_symbols[i]); } } if (ret) { printf("Error\n"); } else { printf("Ok\n"); } exit(ret); }
int main(int argc, char **argv) { int frame_cnt; float *llr; unsigned char *llr_c; char *data_tx, *data_rx, *symbols; int i, j; float var[SNR_POINTS]; int snr_points; float ber[MAX_ITERATIONS][SNR_POINTS]; unsigned int errors[100]; int coded_length; struct timeval tdata[3]; float mean_usec; tdec_t tdec; tcod_t tcod; parse_args(argc, argv); if (!seed) { seed = time(NULL); } srand(seed); if (test_known_data) { frame_length = KNOWN_DATA_LEN; } else { frame_length = lte_cb_size(lte_find_cb_index(frame_length)); } coded_length = 3 * (frame_length) + TOTALTAIL; printf(" Frame length: %d\n", frame_length); if (ebno_db < 100.0) { printf(" EbNo: %.2f\n", ebno_db); } data_tx = malloc(frame_length * sizeof(char)); if (!data_tx) { perror("malloc"); exit(-1); } data_rx = malloc(frame_length * sizeof(char)); if (!data_rx) { perror("malloc"); exit(-1); } symbols = malloc(coded_length * sizeof(char)); if (!symbols) { perror("malloc"); exit(-1); } llr = malloc(coded_length * sizeof(float)); if (!llr) { perror("malloc"); exit(-1); } llr_c = malloc(coded_length * sizeof(char)); if (!llr_c) { perror("malloc"); exit(-1); } if (tcod_init(&tcod, frame_length)) { fprintf(stderr, "Error initiating Turbo coder\n"); exit(-1); } if (tdec_init(&tdec, frame_length)) { fprintf(stderr, "Error initiating Turbo decoder\n"); exit(-1); } float ebno_inc, esno_db; ebno_inc = (SNR_MAX - SNR_MIN) / SNR_POINTS; if (ebno_db == 100.0) { snr_points = SNR_POINTS; for (i = 0; i < snr_points; i++) { ebno_db = SNR_MIN + i * ebno_inc; esno_db = ebno_db + 10 * log10((double) 1 / 3); var[i] = sqrt(1 / (pow(10, esno_db / 10))); } } else { esno_db = ebno_db + 10 * log10((double) 1 / 3); var[0] = sqrt(1 / (pow(10, esno_db / 10))); snr_points = 1; } for (i = 0; i < snr_points; i++) { mean_usec = 0; frame_cnt = 0; bzero(errors, sizeof(int) * MAX_ITERATIONS); while (frame_cnt < nof_frames) { /* generate data_tx */ for (j = 0; j < frame_length; j++) { if (test_known_data) { data_tx[j] = known_data[j]; } else { data_tx[j] = rand() % 2; } } /* coded BER */ if (test_known_data) { for (j = 0; j < coded_length; j++) { symbols[j] = known_data_encoded[j]; } } else { tcod_encode(&tcod, data_tx, symbols, frame_length); } for (j = 0; j < coded_length; j++) { llr[j] = symbols[j] ? sqrt(2) : -sqrt(2); } ch_awgn_f(llr, llr, var[i], coded_length); /* decoder */ tdec_reset(&tdec, frame_length); int t; if (nof_iterations == -1) { t = MAX_ITERATIONS; } else { t = nof_iterations; } for (j = 0; j < t; j++) { if (!j) gettimeofday(&tdata[1], NULL); // Only measure 1 iteration tdec_iteration(&tdec, llr, frame_length); tdec_decision(&tdec, data_rx, frame_length); if (!j) gettimeofday(&tdata[2], NULL); if (!j) get_time_interval(tdata); if (!j) mean_usec = (float) mean_usec * 0.9 + (float) tdata[0].tv_usec * 0.1; /* check errors */ errors[j] += bit_diff(data_tx, data_rx, frame_length); if (j < MAX_ITERATIONS) { ber[j][i] = (float) errors[j] / (frame_cnt * frame_length); } } frame_cnt++; printf("Eb/No: %3.2f %10d/%d ", SNR_MIN + i * ebno_inc, frame_cnt, nof_frames); printf("BER: %.2e ", (float) errors[j - 1] / (frame_cnt * frame_length)); printf("%3.1f Mbps (%6.2f usec)", (float) frame_length / mean_usec, mean_usec); printf("\r"); } printf("\n"); if (snr_points == 1) { if (test_known_data && seed == KNOWN_DATA_SEED && ebno_db == KNOWN_DATA_EBNO && frame_cnt == KNOWN_DATA_NFRAMES) { for (j = 0; j < MAX_ITERATIONS; j++) { if (errors[j] > known_data_errors[j]) { fprintf(stderr, "Expected %d errors but got %d\n", known_data_errors[j], errors[j]); exit(-1); } else { printf("Iter %d ok\n", j + 1); } } } else { for (j = 0; j < MAX_ITERATIONS; j++) { printf("BER: %g\t%u errors\n", (float) errors[j] / (frame_cnt * frame_length), errors[j]); if (test_errors) { if (errors[j] > get_expected_errors(frame_cnt, seed, j + 1, frame_length, ebno_db)) { fprintf(stderr, "Expected %d errors but got %d\n", get_expected_errors(frame_cnt, seed, j + 1, frame_length, ebno_db), errors[j]); exit(-1); } else { printf("Iter %d ok\n", j + 1); } } } } } } free(data_tx); free(symbols); free(llr); free(llr_c); free(data_rx); tdec_free(&tdec); tcod_free(&tcod); printf("\n"); output_matlab(ber, snr_points); printf("Done\n"); exit(0); }
int main(int argc, char **argv) { pdsch_t pdsch; uint32_t i, j; char *data = NULL; cf_t *ce[MAX_PORTS]; uint32_t nof_re; cf_t *slot_symbols[MAX_PORTS]; int ret = -1; struct timeval t[3]; ra_mcs_t mcs; ra_prb_t prb_alloc; pdsch_harq_t harq_process; uint32_t rv; parse_args(argc,argv); nof_re = 2 * CPNORM_NSYMB * cell.nof_prb * RE_X_RB; mcs.tbs = tbs; mcs.mod = modulation; prb_alloc.slot[0].nof_prb = cell.nof_prb; for (i=0;i<prb_alloc.slot[0].nof_prb;i++) { prb_alloc.slot[0].prb_idx[i] = i; } memcpy(&prb_alloc.slot[1], &prb_alloc.slot[0], sizeof(ra_prb_slot_t)); ra_prb_get_re_dl(&prb_alloc, cell.nof_prb, cell.nof_ports, 2, CPNORM); /* init memory */ for (i=0;i<cell.nof_ports;i++) { ce[i] = malloc(sizeof(cf_t) * nof_re); if (!ce[i]) { perror("malloc"); goto quit; } for (j=0;j<nof_re;j++) { ce[i][j] = 1; } slot_symbols[i] = calloc(sizeof(cf_t) , nof_re); if (!slot_symbols[i]) { perror("malloc"); goto quit; } } data = malloc(sizeof(char) * mcs.tbs); if (!data) { perror("malloc"); goto quit; } if (pdsch_init(&pdsch, cell)) { fprintf(stderr, "Error creating PDSCH object\n"); goto quit; } pdsch_set_rnti(&pdsch, 1234); if (pdsch_harq_init(&harq_process, &pdsch)) { fprintf(stderr, "Error initiating HARQ process\n"); goto quit; } if (pdsch_harq_setup(&harq_process, mcs, &prb_alloc)) { fprintf(stderr, "Error configuring HARQ process\n"); goto quit; } for (i=0;i<mcs.tbs;i++) { data[i] = rand()%2; } for (rv=0;rv<=rv_idx;rv++) { printf("Encoding rv_idx=%d\n",rv); if (pdsch_encode(&pdsch, data, slot_symbols, subframe, &harq_process, rv)) { fprintf(stderr, "Error encoding PDSCH\n"); goto quit; } /* combine outputs */ for (i=0;i<cell.nof_ports;i++) { for (j=0;j<nof_re;j++) { if (i > 0) { slot_symbols[0][j] += slot_symbols[i][j]; } ce[i][j] = 1; } } gettimeofday(&t[1], NULL); int r = pdsch_decode(&pdsch, slot_symbols[0], ce, data, subframe, &harq_process, rv); gettimeofday(&t[2], NULL); get_time_interval(t); if (r) { printf("Error decoding\n"); ret = -1; goto quit; } else { printf("DECODED OK in %d:%d (%.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec, (float) mcs.tbs/t[0].tv_usec); } } ret = 0; quit: pdsch_free(&pdsch); for (i=0;i<cell.nof_ports;i++) { if (ce[i]) { free(ce[i]); } if (slot_symbols[i]) { free(slot_symbols[i]); } } if (data) { free(data); } if (ret) { printf("Error\n"); } else { printf("Ok\n"); } exit(ret); }
int main(int argc, char **argv) { srslte_pdsch_t pdsch; uint32_t i, j; uint8_t *data = NULL; cf_t *ce[SRSLTE_MAX_PORTS]; cf_t *slot_symbols[SRSLTE_MAX_PORTS]; int ret = -1; struct timeval t[3]; srslte_pdsch_cfg_t pdsch_cfg; srslte_softbuffer_tx_t softbuffer_tx; srslte_softbuffer_rx_t softbuffer_rx; uint32_t rv; parse_args(argc,argv); bzero(&pdsch, sizeof(srslte_pdsch_t)); bzero(&pdsch_cfg, sizeof(srslte_pdsch_cfg_t)); bzero(ce, sizeof(cf_t*)*SRSLTE_MAX_PORTS); bzero(slot_symbols, sizeof(cf_t*)*SRSLTE_MAX_PORTS); bzero(&softbuffer_rx, sizeof(srslte_softbuffer_rx_t)); bzero(&softbuffer_tx, sizeof(srslte_softbuffer_tx_t)); srslte_ra_dl_grant_t grant; grant.mcs.tbs = tbs; grant.mcs.mod = modulation; grant.Qm = srslte_mod_bits_x_symbol(grant.mcs.mod); grant.nof_prb = cell.nof_prb; // Allocate all PRB for (i=0;i<grant.nof_prb;i++) { grant.prb_idx[0][i] = true; } memcpy(&grant.prb_idx[1], &grant.prb_idx[0], SRSLTE_MAX_PRB * sizeof(bool)); /* Configure PDSCH */ if (srslte_pdsch_cfg(&pdsch_cfg, cell, &grant, cfi, subframe, 1234, 0)) { fprintf(stderr, "Error configuring PDSCH\n"); exit(-1); } /* init memory */ for (i=0;i<cell.nof_ports;i++) { ce[i] = malloc(sizeof(cf_t) * SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)); if (!ce[i]) { perror("malloc"); goto quit; } for (j=0;j<SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp);j++) { ce[i][j] = 1; } slot_symbols[i] = calloc(sizeof(cf_t) , SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)); if (!slot_symbols[i]) { perror("malloc"); goto quit; } } data = malloc(sizeof(uint8_t) * tbs/8); if (!data) { perror("malloc"); goto quit; } if (srslte_pdsch_init(&pdsch, cell)) { fprintf(stderr, "Error creating PDSCH object\n"); goto quit; } srslte_pdsch_set_rnti(&pdsch, 1234); if (srslte_softbuffer_tx_init(&softbuffer_tx, cell.nof_prb)) { fprintf(stderr, "Error initiating TX soft buffer\n"); goto quit; } if (srslte_softbuffer_rx_init(&softbuffer_rx, cell.nof_prb)) { fprintf(stderr, "Error initiating RX soft buffer\n"); goto quit; } if (SRSLTE_VERBOSE_ISNONE()) { printf("Decoding TBS: %d\r",grant.mcs.tbs); } for (i=0;i<grant.mcs.tbs/8;i++) { data[i] = rand()%256; } for (rv=0;rv<=rv_idx;rv++) { pdsch_cfg.rv = rv; if (srslte_pdsch_encode(&pdsch, &pdsch_cfg, &softbuffer_tx, data, slot_symbols)) { fprintf(stderr, "Error encoding PDSCH\n"); goto quit; } /* combine outputs */ for (i=0;i<cell.nof_ports;i++) { for (j=0;j<SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp);j++) { if (i > 0) { slot_symbols[0][j] += slot_symbols[i][j]; } ce[i][j] = 1; } } gettimeofday(&t[1], NULL); int r = srslte_pdsch_decode(&pdsch, &pdsch_cfg, &softbuffer_rx, slot_symbols[0], ce, 0, data); gettimeofday(&t[2], NULL); get_time_interval(t); if (r) { printf("Error decoding TBS: %d\n", grant.mcs.tbs); ret = -1; goto quit; } else { printf("DECODED OK in %d:%d (%.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec, (float) grant.mcs.tbs/t[0].tv_usec); } } ret = 0; quit: srslte_pdsch_free(&pdsch); srslte_softbuffer_tx_free(&softbuffer_tx); srslte_softbuffer_rx_free(&softbuffer_rx); for (i=0;i<cell.nof_ports;i++) { if (ce[i]) { free(ce[i]); } if (slot_symbols[i]) { free(slot_symbols[i]); } } if (data) { free(data); } if (ret) { printf("Error\n"); } else { printf("Ok\n"); } exit(ret); }
int main(int argc, char **argv) { uint32_t frame_cnt; float *llr; short *llr_s; uint8_t *llr_c; uint8_t *data_tx, *data_rx, *data_rx_bytes, *symbols; uint32_t i, j; float var[SNR_POINTS]; uint32_t snr_points; uint32_t errors; uint32_t coded_length; struct timeval tdata[3]; float mean_usec; srslte_tdec_t tdec; srslte_tcod_t tcod; parse_args(argc, argv); if (!seed) { seed = time(NULL); } srand(seed); if (test_known_data) { frame_length = KNOWN_DATA_LEN; } else { frame_length = srslte_cbsegm_cbsize(srslte_cbsegm_cbindex(frame_length)); } coded_length = 3 * (frame_length) + SRSLTE_TCOD_TOTALTAIL; printf(" Frame length: %d\n", frame_length); if (ebno_db < 100.0) { printf(" EbNo: %.2f\n", ebno_db); } data_tx = srslte_vec_malloc(frame_length * sizeof(uint8_t)); if (!data_tx) { perror("malloc"); exit(-1); } data_rx = srslte_vec_malloc(frame_length * sizeof(uint8_t)); if (!data_rx) { perror("malloc"); exit(-1); } data_rx_bytes = srslte_vec_malloc(frame_length * sizeof(uint8_t)); if (!data_rx_bytes) { perror("malloc"); exit(-1); } symbols = srslte_vec_malloc(coded_length * sizeof(uint8_t)); if (!symbols) { perror("malloc"); exit(-1); } llr = srslte_vec_malloc(coded_length * sizeof(float)); if (!llr) { perror("malloc"); exit(-1); } llr_s = srslte_vec_malloc(coded_length * sizeof(short)); if (!llr_s) { perror("malloc"); exit(-1); } llr_c = srslte_vec_malloc(coded_length * sizeof(uint8_t)); if (!llr_c) { perror("malloc"); exit(-1); } if (srslte_tcod_init(&tcod, frame_length)) { fprintf(stderr, "Error initiating Turbo coder\n"); exit(-1); } if (srslte_tdec_init_manual(&tdec, frame_length, tdec_type)) { fprintf(stderr, "Error initiating Turbo decoder\n"); exit(-1); } srslte_tdec_force_not_sb(&tdec); float ebno_inc, esno_db; ebno_inc = (SNR_MAX - SNR_MIN) / SNR_POINTS; if (ebno_db == 100.0) { snr_points = SNR_POINTS; for (i = 0; i < snr_points; i++) { ebno_db = SNR_MIN + i * ebno_inc; esno_db = ebno_db + 10 * log10((double) 1 / 3); var[i] = sqrt(1 / (pow(10, esno_db / 10))); } } else { esno_db = ebno_db + 10 * log10((double) 1 / 3); var[0] = sqrt(1 / (pow(10, esno_db / 10))); snr_points = 1; } for (i = 0; i < snr_points; i++) { mean_usec = 0; errors = 0; frame_cnt = 0; while (frame_cnt < nof_frames) { /* generate data_tx */ for (j = 0; j < frame_length; j++) { if (test_known_data) { data_tx[j] = known_data[j]; } else { data_tx[j] = rand() % 2; } } /* coded BER */ if (test_known_data) { for (j = 0; j < coded_length; j++) { symbols[j] = known_data_encoded[j]; } } else { srslte_tcod_encode(&tcod, data_tx, symbols, frame_length); } for (j = 0; j < coded_length; j++) { llr[j] = symbols[j] ? 1 : -1; } srslte_ch_awgn_f(llr, llr, var[i], coded_length); for (j=0;j<coded_length;j++) { llr_s[j] = (int16_t) (100*llr[j]); } /* decoder */ srslte_tdec_new_cb(&tdec, frame_length); uint32_t t; if (nof_iterations == -1) { t = MAX_ITERATIONS; } else { t = nof_iterations; } gettimeofday(&tdata[1], NULL); for (int k=0;k<nof_repetitions;k++) { srslte_tdec_run_all(&tdec, llr_s, data_rx_bytes, t, frame_length); } gettimeofday(&tdata[2], NULL); get_time_interval(tdata); mean_usec = (tdata[0].tv_sec*1e6+tdata[0].tv_usec)/nof_repetitions; frame_cnt++; uint32_t errors_this = 0; srslte_bit_unpack_vector(data_rx_bytes, data_rx, frame_length); errors_this=srslte_bit_diff(data_tx, data_rx, frame_length); //printf("error[%d]=%d\n", cb, errors_this); errors += errors_this; printf("Eb/No: %2.2f %10d/%d ", SNR_MIN + i * ebno_inc, frame_cnt, nof_frames); printf("BER: %.2e ", (float) errors / (nof_cb*frame_cnt * frame_length)); printf("%3.1f Mbps (%6.2f usec)", (float) (nof_cb*frame_length) / mean_usec, mean_usec); printf("\r"); } printf("\n"); } printf("\n"); if (snr_points == 1) { if (errors) { printf("%d Errors\n", errors/nof_cb); } } if (data_rx_bytes) { free(data_rx_bytes); } free(data_tx); free(symbols); free(llr); free(llr_c); free(llr_s); free(data_rx); srslte_tdec_free(&tdec); srslte_tcod_free(&tcod); printf("\n"); printf("Done\n"); exit(0); }