int main(int argc, char **argv) { parse_args(argc, argv); srslte_tcod_gentable(); srslte_tcod_t tcod; srslte_tcod_init(&tcod, 6144); uint32_t st=0, end=187; if (long_cb) { st=srslte_cbsegm_cbindex(long_cb); end=st; } for (uint32_t len=st;len<=end;len++) { long_cb = srslte_cbsegm_cbsize(len); printf("Checking long_cb=%d\n", long_cb); for (int i=0;i<long_cb/8;i++) { input_bytes[i] = rand()%256; } srslte_bit_unpack_vector(input_bytes, input_bits, long_cb); if (SRSLTE_VERBOSE_ISINFO()) { printf("Input bits:\n"); for (int i=0;i<long_cb/8;i++) { srslte_vec_fprint_b(stdout, &input_bits[i*8], 8); } } srslte_tcod_encode(&tcod, input_bits, output_bits, long_cb); srslte_tcod_encode_lut(&tcod, input_bytes, parity, len); srslte_bit_unpack_vector(parity, parity_bits, 2*(long_cb+4)); for (int i=0;i<long_cb;i++) { output_bits2[3*i] = input_bits[i]; output_bits2[3*i+1] = parity_bits[i]; output_bits2[3*i+2] = parity_bits[i+long_cb+4]; } if (SRSLTE_VERBOSE_ISINFO()) { srslte_vec_fprint_b(stdout, output_bits2, 3*long_cb); srslte_vec_fprint_b(stdout, output_bits, 3*long_cb); printf("\n"); } for (int i=0;i<2*long_cb;i++) { if (output_bits2[long_cb+i] != output_bits[long_cb+i]) { printf("error in bit %d, len=%d\n", i, len); exit(-1); } } } srslte_tcod_free(&tcod); printf("Done\n"); exit(0); }
int main(int argc, char **argv) { parse_args(argc, argv); srslte_tcod_gentable(); srslte_tcod_t tcod; srslte_tcod_init(&tcod, 6144); uint32_t st=0, end=187; if (long_cb) { st=srslte_cbsegm_cbindex(long_cb); end=st; } for (uint32_t len=st;len<=end;len++) { long_cb = srslte_cbsegm_cbsize(len); printf("Checking long_cb=%d\n", long_cb); for (int i=0;i<long_cb/8;i++) { input_bytes[i] = rand()%256; } srslte_bit_unpack_vector(input_bytes, input_bits, long_cb); if (SRSLTE_VERBOSE_ISINFO()) { printf("Input bits:\n"); for (int i=0;i<long_cb/8;i++) { srslte_vec_fprint_b(stdout, &input_bits[i*8], 8); } } srslte_tcod_encode(&tcod, input_bits, output_bits, long_cb); srslte_tcod_encode_lut(&tcod, input_bytes, output_bytes, long_cb); srslte_bit_unpack_vector(output_bytes, output_bits2, 2*long_cb+12); /* de-Interleace bits for comparison */ for (int i=0;i<long_cb;i++) { for (int j=0;j<2;j++) { output_bits3[j*long_cb+i] = output_bits[3*i+j+1]; } } // copy tail memcpy(&output_bits3[2*long_cb], &output_bits[3*long_cb], 12); if (SRSLTE_VERBOSE_ISINFO()) { printf("1st encoder\n"); srslte_vec_fprint_b(stdout, output_bits2, long_cb); srslte_vec_fprint_b(stdout, output_bits3, long_cb); printf("2nd encoder\n"); srslte_vec_fprint_b(stdout, &output_bits2[long_cb], long_cb); srslte_vec_fprint_b(stdout, &output_bits3[long_cb], long_cb); printf("tail\n"); srslte_vec_fprint_b(stdout, &output_bits2[2*long_cb], 12); srslte_vec_fprint_b(stdout, &output_bits3[2*long_cb], 12); printf("\n"); } for (int i=0;i<2*long_cb+12;i++) { if (output_bits2[i] != output_bits3[i]) { printf("error in bit %d, len=%d\n", i, len); exit(-1); } } } srslte_tcod_free(&tcod); printf("Done\n"); exit(0); }
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_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); srslte_tcod_t turbocoder; srslte_tcod_init(&turbocoder, SRSLTE_TCOD_MAX_LEN_CB); srslte_dft_precoding_t dft_precod; srslte_dft_precoding_init(&dft_precod, 12); nbits = srslte_cbsegm_cbindex(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_CP_NORM); srslte_sss_put_slot(sf_idx ? sss_signal5 : sss_signal0, sf_buffer, cell.nof_prb, SRSLTE_CP_NORM); /* Transform to OFDM symbols */ srslte_ofdm_tx_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<nbits;i++) { data[i] = rand()%2; } srslte_tcod_encode(&turbocoder, data, data_enc, nbits); srslte_mod_modulate(&modulator, data_enc, symbols, ncoded_bits); srslte_interp_linear_offset_cabs(symbols, output_buffer, 8, sf_n_samples/8, 0, 0); // } /* send to usrp */ srslte_vec_sc_prod_cfc(output_buffer, uhd_amp, output_buffer, sf_n_samples); cuhd_send(uhd, output_buffer, sf_n_samples, true); } } base_free(); printf("Done\n"); exit(0); }
/* Encode a transport block according to 36.212 5.3.2 * */ static int encode_tb(srslte_sch_t *q, srslte_softbuffer_tx_t *soft_buffer, srslte_cbsegm_t *cb_segm, uint32_t Qm, uint32_t rv, uint32_t nof_e_bits, uint8_t *data, uint8_t *e_bits) { uint8_t parity[3] = {0, 0, 0}; uint32_t par; uint32_t i; uint32_t cb_len, rp, wp, rlen, F, n_e; int ret = SRSLTE_ERROR_INVALID_INPUTS; if (q != NULL && e_bits != NULL && cb_segm != NULL && soft_buffer != NULL) { uint32_t Gp = nof_e_bits / Qm; uint32_t gamma = Gp; if (cb_segm->C > 0) { gamma = Gp%cb_segm->C; } if (data) { /* Compute transport block CRC */ par = srslte_crc_checksum_byte(&q->crc_tb, data, cb_segm->tbs); /* parity bits will be appended later */ parity[0] = (par&(0xff<<16))>>16; parity[1] = (par&(0xff<<8))>>8; parity[2] = par&0xff; if (SRSLTE_VERBOSE_ISDEBUG()) { DEBUG("DATA: ", 0); srslte_vec_fprint_byte(stdout, data, cb_segm->tbs/8); DEBUG("PARITY: ", 0); srslte_vec_fprint_byte(stdout, parity, 3); } } wp = 0; rp = 0; for (i = 0; i < cb_segm->C; i++) { /* Get read lengths */ if (i < cb_segm->C2) { cb_len = cb_segm->K2; } else { cb_len = cb_segm->K1; } if (cb_segm->C > 1) { rlen = cb_len - 24; } else { rlen = cb_len; } if (i == 0) { F = cb_segm->F; } else { F = 0; } if (i <= cb_segm->C - gamma - 1) { n_e = Qm * (Gp/cb_segm->C); } else { n_e = Qm * ((uint32_t) ceilf((float) Gp/cb_segm->C)); } INFO("CB#%d: cb_len: %d, rlen: %d, wp: %d, rp: %d, F: %d, E: %d\n", i, cb_len, rlen - F, wp, rp, F, n_e); if (data) { /* Copy data to another buffer, making space for the Codeblock CRC */ if (i < cb_segm->C - 1) { // Copy data memcpy(&q->cb_in[F/8], &data[rp/8], (rlen - F) * sizeof(uint8_t)/8); } else { INFO("Last CB, appending parity: %d from %d and 24 to %d\n", rlen - F - 24, rp, rlen - 24); /* Append Transport Block parity bits to the last CB */ memcpy(&q->cb_in[F/8], &data[rp/8], (rlen - 24 - F) * sizeof(uint8_t)/8); memcpy(&q->cb_in[(rlen - 24)/8], parity, 3 * sizeof(uint8_t)); } /* Filler bits are treated like zeros for the CB CRC calculation */ for (int j = 0; j < F/8; j++) { q->cb_in[j] = 0; } /* Attach Codeblock CRC */ if (cb_segm->C > 1) { srslte_crc_attach_byte(&q->crc_cb, q->cb_in, rlen); } /* pack bits to temporal buffer for encoding */ srslte_bit_unpack_vector(q->cb_in, q->cb_temp, cb_len); /* Set the filler bits to <NULL> */ for (int j = 0; j < F; j++) { q->cb_temp[j] = SRSLTE_TX_NULL; } if (SRSLTE_VERBOSE_ISDEBUG()) { DEBUG("CB#%d: ", i); srslte_vec_fprint_hex(stdout, q->cb_temp, cb_len); } /* Turbo Encoding */ srslte_tcod_encode(&q->encoder, q->cb_temp, (uint8_t*) q->cb_out, cb_len); if (SRSLTE_VERBOSE_ISDEBUG()) { DEBUG("CB#%d encoded: ", i); srslte_vec_fprint_b(stdout, q->cb_out, 3*cb_len+12); } } /* Rate matching */ if (srslte_rm_turbo_tx(soft_buffer->buffer_b[i], soft_buffer->buff_size, (uint8_t*) q->cb_out, 3 * cb_len + 12, &e_bits[wp], n_e, rv)) { fprintf(stderr, "Error in rate matching\n"); return SRSLTE_ERROR; } /* Set read/write pointers */ rp += (rlen - F); wp += n_e; } INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp); ret = SRSLTE_SUCCESS; }
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); }