5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added prefix to all exported symbols

Browse Source
master
ismagom 10 years ago
parent 0d71c911fe
commit 6d51de5ed6
177 changed files with 4194 additions and 4857 deletions
Show Stats Download Patch File Download Diff File

4
cuhd/lib/cuhd_utils.c
Unescape Escape View File

@ -64,9 +64,9 @@ int cuhd_rssi_scan(void *uhd, float *freqs, float *rssi, int nof_bands, double f
goto free_and_exit;
}
}
rssi[i] = vec_avg_power_cf(buffer, nsamp);
rssi[i] = srslte_vec_avg_power_cf(buffer, nsamp);
printf("[%3d]: Freq %4.1f Mhz - RSSI: %3.2f dBm\r", i, f/1000000, 10*log10f(rssi[i]) + 30); fflush(stdout);
if (VERBOSE_ISINFO()) {
if (SRSLTE_VERBOSE_ISINFO()) {
printf("\n");
}
}

2
matlab/sync/check_pss.m
Unescape Escape View File

@ -16,7 +16,7 @@ for i=1:nf
end
fs=fs+960;
[sfo sfo_v]=sfo_estimate(fs, 5/1000);
[sfo sfo_v]=srslte_sfo_estimate(fs, 5/1000);
subplot(1,3,1)
plot(1:nf,fs)

2
matlab/sync/sfo_estimate.m
Unescape Escape View File

@ -1,4 +1,4 @@
function [ sfo sfo_v ] = sfo_estimate( fs, T )
function [ sfo sfo_v ] = srslte_sfo_estimate( fs, T )
nanfs=fs(~isnan(fs));

2
matlab/tests/pdcch_bler.m
Unescape Escape View File

@ -43,7 +43,7 @@ cec.InterpWinSize = 1; % Interpolation window size
%% DCI Message Generation
% Generate a DCI message to be mapped to the PDCCH.
dciConfig.DCIFormat = 'Format1A'; % DCI message format
dciConfig.DCIFormat = 'SRSLTE_DCI_FORMAT1A'; % DCI message format
dciConfig.Allocation.RIV = 26; % Resource indication value
% Create DCI message for given configuration

2
matlab/tests/pdsch_resalloc.m
Unescape Escape View File

@ -12,7 +12,7 @@ enb.NTotalSubframes=1;
enb.DuplexMode = 'FDD';
dci.NDLRB = enb.NDLRB;
dci.DCIFormat = 'Format1C';
dci.DCIFormat = 'SRSLTE_DCI_FORMAT1C';
dci.AllocationType=1;
%dci.Allocation.Bitmap='01111000011110000';
%dci.Allocation.Subset=3;

2
matlab/tests/pusch_test.m
Unescape Escape View File

@ -51,7 +51,7 @@ for i=1:length(TBs)
subframe_mat(idx)=cw_mat;
waveform = lteSCFDMAModulate(ueConfig,subframe_mat,0);
[waveform_lib, subframe_lib, cwlib]=liblte_pusch_encode(ueConfig,puschConfig,trblkin,ones(1,cqilen(c)),ri_bit,ack_bit);
[waveform_lib, subframe_lib, cwlib]=liblte_srslte_pusch_encode(ueConfig,puschConfig,trblkin,ones(1,cqilen(c)),ri_bit,ack_bit);
err=mean(abs(waveform-waveform_lib));
if (err > 10^-6)
disp(err)

6
mex/lib/mexutils.c
Unescape Escape View File

@ -91,7 +91,7 @@ int mexutils_read_cell(const mxArray *ptr, srslte_cell_t *cell) {
int mexutils_read_cf(const mxArray *ptr, cf_t **buffer) {
int numelems = mxGetNumberOfElements(ptr);
cf_t *tmp = vec_malloc(numelems * sizeof(cf_t));
cf_t *tmp = srslte_vec_malloc(numelems * sizeof(cf_t));
if (tmp) {
double *inr=mxGetPr(ptr);
double *ini=mxGetPi(ptr);
@ -110,7 +110,7 @@ int mexutils_read_cf(const mxArray *ptr, cf_t **buffer) {
int mexutils_read_f(const mxArray *ptr, float **buffer) {
int numelems = mxGetNumberOfElements(ptr);
float *tmp = vec_malloc(numelems * sizeof(float));
float *tmp = srslte_vec_malloc(numelems * sizeof(float));
if (tmp) {
double *inr=mxGetPr(ptr);
for (int i=0;i<numelems;i++) {
@ -125,7 +125,7 @@ int mexutils_read_f(const mxArray *ptr, float **buffer) {
int mexutils_read_uint8(const mxArray *ptr, uint8_t **buffer) {
int numelems = mxGetNumberOfElements(ptr);
uint8_t *tmp = vec_malloc(numelems * sizeof(uint8_t));
uint8_t *tmp = srslte_vec_malloc(numelems * sizeof(uint8_t));
if (tmp) {
double *inr=mxGetPr(ptr);
for (int i=0;i<numelems;i++) {

1
srslte/CMakeLists.txt
Unescape Escape View File

@ -45,3 +45,4 @@ ADD_CUSTOM_TARGET (add_lte_phy_headers SOURCES ${HEADERS_ALL})
# Add subdirectories
########################################################################
ADD_SUBDIRECTORY(lib)

80
srslte/examples/cell_measurement.c
Unescape Escape View File

@ -78,7 +78,7 @@ void usage(prog_args_t *args, char *prog) {
printf("\t-g UHD RX gain [Default %.2f dB]\n", args->uhd_gain);
printf("\t-l Force N_id_2 [Default best]\n");
printf("\t-n nof_subframes [Default %d]\n", args->nof_subframes);
printf("\t-v [set verbose to debug, default none]\n");
printf("\t-v [set srslte_verbose to debug, default none]\n");
}
int parse_args(prog_args_t *args, int argc, char **argv) {
@ -102,7 +102,7 @@ int parse_args(prog_args_t *args, int argc, char **argv) {
args->force_N_id_2 = atoi(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(args, argv[0]);
@ -136,11 +136,11 @@ int main(int argc, char **argv) {
prog_args_t prog_args;
srslte_cell_t cell;
int64_t sf_cnt;
ue_sync_t ue_sync;
ue_mib_t ue_mib;
srslte_ue_sync_t ue_sync;
srslte_ue_mib_t ue_mib;
void *uhd;
ue_dl_t ue_dl;
srslte_fft_t fft;
srs_ue_dl_t ue_dl;
srslte_ofdm_t fft;
srslte_chest_dl_t chest;
uint32_t nframes=0;
uint32_t nof_trials = 0;
@ -190,26 +190,26 @@ int main(int argc, char **argv) {
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
if (ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) {
if (srslte_ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) {
fprintf(stderr, "Error initiating ue_sync\n");
return -1;
}
if (ue_dl_init(&ue_dl, cell)) {
if (srs_ue_dl_init(&ue_dl, cell)) {
fprintf(stderr, "Error initiating UE downlink processing module\n");
return -1;
}
if (ue_mib_init(&ue_mib, cell)) {
if (srslte_ue_mib_init(&ue_mib, cell)) {
fprintf(stderr, "Error initaiting UE MIB decoder\n");
return -1;
}
/* Configure downlink receiver for the SI-RNTI since will be the only one we'll use */
ue_dl_set_rnti(&ue_dl, SRSLTE_SIRNTI);
srs_ue_dl_set_rnti(&ue_dl, SRSLTE_SIRNTI);
/* Initialize subframe counter */
sf_cnt = 0;
if (srslte_fft_init(&fft, cell.cp, cell.nof_prb)) {
if (srslte_ofdm_tx_init(&fft, cell.cp, cell.nof_prb)) {
fprintf(stderr, "Error initiating FFT\n");
return -1;
}
@ -220,10 +220,10 @@ int main(int argc, char **argv) {
int sf_re = SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp);
cf_t *sf_symbols = vec_malloc(sf_re * sizeof(cf_t));
cf_t *sf_symbols = srslte_vec_malloc(sf_re * sizeof(cf_t));
for (int i=0;i<SRSLTE_MAX_PORTS;i++) {
ce[i] = vec_malloc(sizeof(cf_t) * sf_re);
ce[i] = srslte_vec_malloc(sizeof(cf_t) * sf_re);
}
cuhd_start_rx_stream(uhd);
@ -231,24 +231,24 @@ int main(int argc, char **argv) {
/* Main loop */
while (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1) {
ret = ue_sync_get_buffer(&ue_sync, &sf_buffer);
ret = srslte_ue_sync_get_buffer(&ue_sync, &sf_buffer);
if (ret < 0) {
fprintf(stderr, "Error calling ue_sync_work()\n");
fprintf(stderr, "Error calling srslte_ue_sync_work()\n");
}
/* ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
/* srslte_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
if (ret == 1) {
switch (state) {
case DECODE_MIB:
if (ue_sync_get_sfidx(&ue_sync) == 0) {
pbch_decode_reset(&ue_mib.pbch);
n = ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (srslte_ue_sync_get_sfidx(&ue_sync) == 0) {
decode_reset(&ue_mib.pbch);
n = srslte_ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (n < 0) {
fprintf(stderr, "Error decoding UE MIB\n");
return -1;
} else if (n == MIB_FOUND) {
bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
} else if (n == SRSLTE_UE_MIB_FOUND) {
srslte_bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
bcch_bch_unpack(bch_payload, BCH_PAYLOAD_LEN, &cell, &sfn);
printf("Decoded MIB. SFN: %d, offset: %d\n", sfn, sfn_offset);
sfn = (sfn + sfn_offset)%1024;
@ -258,20 +258,20 @@ int main(int argc, char **argv) {
break;
case DECODE_SIB:
/* We are looking for SI Blocks, search only in appropiate places */
if ((ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) {
n = ue_dl_decode_rnti_rv(&ue_dl, sf_buffer, data, ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI,
if ((srslte_ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) {
n = srs_ue_dl_decode_rnti_rv(&ue_dl, sf_buffer, data, srslte_ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI,
((int) ceilf((float)3*(((sfn)/2)%4)/2))%4);
if (n < 0) {
fprintf(stderr, "Error decoding UE DL\n");fflush(stdout);
return -1;
} else if (n == 0) {
printf("CFO: %+6.4f KHz, SFO: %+6.4f Khz, NOI: %.2f, PDCCH-Det: %.3f\r",
ue_sync_get_cfo(&ue_sync)/1000, ue_sync_get_sfo(&ue_sync)/1000,
sch_average_noi(&ue_dl.pdsch.dl_sch),
(float) ue_dl.nof_pdcch_detected/nof_trials);
srslte_ue_sync_get_cfo(&ue_sync)/1000, srslte_ue_sync_get_sfo(&ue_sync)/1000,
srslte_sch_average_noi(&ue_dl.pdsch.dl_sch),
(float) ue_dl.nof_detected/nof_trials);
nof_trials++;
} else {
bit_unpack_vector(data, data_unpacked, n);
srslte_bit_unpack_vector(data, data_unpacked, n);
void *dlsch_msg = bcch_dlsch_unpack(data_unpacked, n);
if (dlsch_msg) {
printf("\n");fflush(stdout);
@ -287,17 +287,17 @@ int main(int argc, char **argv) {
case MEASURE:
if (ue_sync_get_sfidx(&ue_sync) == 5) {
if (srslte_ue_sync_get_sfidx(&ue_sync) == 5) {
/* Run FFT for all subframe data */
srslte_fft_run_sf(&fft, sf_buffer, sf_symbols);
srslte_ofdm_tx_sf(&fft, sf_buffer, sf_symbols);
srslte_chest_dl_estimate(&chest, sf_symbols, ce, ue_sync_get_sfidx(&ue_sync));
srslte_chest_dl_estimate(&chest, sf_symbols, ce, srslte_ue_sync_get_sfidx(&ue_sync));
rssi = VEC_CMA(vec_avg_power_cf(sf_buffer,SRSLTE_SF_LEN(srslte_symbol_sz(cell.nof_prb))),rssi,nframes);
rssi_utra = VEC_CMA(srslte_chest_dl_get_rssi(&chest),rssi_utra,nframes);
rsrq = VEC_EMA(srslte_chest_dl_get_rsrq(&chest),rsrq,0.05);
rsrp = VEC_EMA(srslte_chest_dl_get_rsrp(&chest),rsrp,0.05);
snr = VEC_EMA(srslte_chest_dl_get_snr(&chest),snr,0.05);
rssi = SRSLTE_VEC_CMA(srslte_vec_avg_power_cf(sf_buffer,SRSLTE_SF_LEN(srslte_symbol_sz(cell.nof_prb))),rssi,nframes);
rssi_utra = SRSLTE_VEC_CMA(srslte_chest_dl_get_rssi(&chest),rssi_utra,nframes);
rsrq = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrq(&chest),rsrq,0.05);
rsrp = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrp(&chest),rsrp,0.05);
snr = SRSLTE_VEC_EMA(srslte_chest_dl_get_snr(&chest),snr,0.05);
nframes++;
}
@ -305,18 +305,18 @@ int main(int argc, char **argv) {
if ((nframes%10) == 0) {
printf("CFO: %+8.4f KHz, SFO: %+8.4f Khz, RSSI: %5.1f dBm, RSSI/ref-symbol: %+5.1f dBm, "
"RSRP: %+5.1f dBm, RSRQ: %5.1f dB, SNR: %5.1f dB\r",
ue_sync_get_cfo(&ue_sync)/1000, ue_sync_get_sfo(&ue_sync)/1000,
srslte_ue_sync_get_cfo(&ue_sync)/1000, srslte_ue_sync_get_sfo(&ue_sync)/1000,
10*log10(rssi*1000)-gain_offset,
10*log10(rssi_utra*1000)-gain_offset,
10*log10(rsrp*1000)-gain_offset,
10*log10(rsrq), 10*log10(snr));
if (verbose != VERBOSE_NONE) {
if (srslte_verbose != SRSLTE_VERBOSE_NONE) {
printf("\n");
}
}
break;
}
if (ue_sync_get_sfidx(&ue_sync) == 9) {
if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) {
sfn++;
if (sfn == 1024) {
sfn = 0;
@ -324,7 +324,7 @@ int main(int argc, char **argv) {
}
} else if (ret == 0) {
printf("Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r",
sync_get_peak_value(&ue_sync.sfind),
srslte_sync_get_peak_value(&ue_sync.sfind),
ue_sync.frame_total_cnt, ue_sync.state);
}
@ -332,7 +332,7 @@ int main(int argc, char **argv) {
sf_cnt++;
} // Main loop
ue_sync_free(&ue_sync);
srslte_ue_sync_free(&ue_sync);
cuhd_close(uhd);
printf("\nBye\n");
exit(0);

26
srslte/examples/cell_search.c
Unescape Escape View File

@ -69,7 +69,7 @@ void usage(char *prog) {
printf("\t-e earfcn_end [Default All]\n");
printf("\t-n nof_frames_total [Default 100]\n");
printf("\t-t threshold [Default %.2f]\n",config.threshold);
printf("\t-v [set verbose to debug, default none]\n");
printf("\t-v [set srslte_verbose to debug, default none]\n");
}
void parse_args(int argc, char **argv) {
@ -98,7 +98,7 @@ void parse_args(int argc, char **argv) {
uhd_gain = atof(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -119,8 +119,8 @@ int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t
int main(int argc, char **argv) {
int n;
void *uhd;
ue_cell_search_t cs;
ue_cell_search_result_t found_cells[3];
srslte_ue_cellsearch_t cs;
srslte_ue_cellsearch_result_t found_cells[3];
int nof_freqs;
srslte_earfcn_t channels[MAX_EARFCN];
uint32_t freq;
@ -150,30 +150,30 @@ int main(int argc, char **argv) {
printf("[%3d/%d]: EARFCN %d Freq. %.2f MHz looking for PSS. \n", freq, nof_freqs,
channels[freq].id, channels[freq].fd);
if (VERBOSE_ISINFO()) {
if (SRSLTE_VERBOSE_ISINFO()) {
printf("\n");
}
bzero(found_cells, 3*sizeof(ue_cell_search_result_t));
bzero(found_cells, 3*sizeof(srslte_ue_cellsearch_result_t));
if (ue_cell_search_init(&cs, cuhd_recv_wrapper, uhd)) {
if (srslte_ue_cellsearch_init(&cs, cuhd_recv_wrapper, uhd)) {
fprintf(stderr, "Error initiating UE cell detect\n");
exit(-1);
}
if (config.max_frames_pss) {
ue_cell_search_set_nof_frames_to_scan(&cs, config.max_frames_pss);
srslte_ue_cellsearch_set_nof_frames_to_scan(&cs, config.max_frames_pss);
}
if (config.threshold) {
ue_cell_search_set_threshold(&cs, config.threshold);
srslte_ue_cellsearch_set_threshold(&cs, config.threshold);
}
INFO("Setting sampling frequency %.2f MHz for PSS search\n", CS_SAMP_FREQ/1000);
cuhd_set_rx_srate(uhd, CS_SAMP_FREQ);
INFO("Setting sampling frequency %.2f MHz for PSS search\n", SRSLTE_CS_SAMP_FREQ/1000);
cuhd_set_rx_srate(uhd, SRSLTE_CS_SAMP_FREQ);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
n = ue_cell_search_scan(&cs, found_cells, NULL);
n = srslte_ue_cellsearch_scan(&cs, found_cells, NULL);
if (n < 0) {
fprintf(stderr, "Error searching cell\n");
exit(-1);
@ -188,7 +188,7 @@ int main(int argc, char **argv) {
fprintf(stderr, "Error decoding MIB\n");
exit(-1);
}
if (ret == MIB_FOUND) {
if (ret == SRSLTE_UE_MIB_FOUND) {
printf("Found CELL ID %d. %d PRB, %d ports\n",
cell.id, cell.nof_prb, cell.nof_ports);
}

36
srslte/examples/cuhd_utils.c
Unescape Escape View File

@ -53,15 +53,15 @@ int cuhd_recv_wrapper_cs(void *h, void *data, uint32_t nsamples, srslte_timestam
*/
int cuhd_mib_decoder(void *uhd, uint32_t max_nof_frames, srslte_cell_t *cell) {
int ret = SRSLTE_ERROR;
ue_mib_sync_t ue_mib;
srslte_ue_mib_sync_t ue_mib;
uint8_t bch_payload[BCH_PAYLOAD_LEN], bch_payload_unpacked[BCH_PAYLOAD_LEN];
if (ue_mib_sync_init(&ue_mib, cell->id, cell->cp, cuhd_recv_wrapper_cs, uhd)) {
fprintf(stderr, "Error initiating ue_mib_sync\n");
if (srslte_ue_mib_sync_init(&ue_mib, cell->id, cell->cp, cuhd_recv_wrapper_cs, uhd)) {
fprintf(stderr, "Error initiating srslte_ue_mib_sync\n");
goto clean_exit;
}
int srate = srslte_sampling_freq_hz(MIB_NOF_PRB);
int srate = srslte_sampling_freq_hz(SRSLTE_UE_MIB_NOF_PRB);
INFO("Setting sampling frequency %.2f MHz for PSS search\n", (float) srate/1000000);
cuhd_set_rx_srate(uhd, (float) srate);
@ -69,20 +69,20 @@ int cuhd_mib_decoder(void *uhd, uint32_t max_nof_frames, srslte_cell_t *cell) {
cuhd_start_rx_stream(uhd);
/* Find and decody MIB */
ret = ue_mib_sync_decode(&ue_mib, max_nof_frames, bch_payload, &cell->nof_ports, NULL);
ret = srslte_ue_mib_sync_decode(&ue_mib, max_nof_frames, bch_payload, &cell->nof_ports, NULL);
if (ret < 0) {
fprintf(stderr, "Error decoding MIB\n");
goto clean_exit;
}
if (ret == 1) {
bit_unpack_vector(bch_payload, bch_payload_unpacked, BCH_PAYLOAD_LEN);
srslte_bit_unpack_vector(bch_payload, bch_payload_unpacked, BCH_PAYLOAD_LEN);
bcch_bch_unpack(bch_payload_unpacked, BCH_PAYLOAD_LEN, cell, NULL);
}
clean_exit:
cuhd_stop_rx_stream(uhd);
ue_mib_sync_free(&ue_mib);
srslte_ue_mib_sync_free(&ue_mib);
return ret;
}
@ -93,25 +93,25 @@ int cuhd_cell_search(void *uhd, cell_search_cfg_t *config,
int force_N_id_2, srslte_cell_t *cell)
{
int ret = SRSLTE_ERROR;
ue_cell_search_t cs;
ue_cell_search_result_t found_cells[3];
srslte_ue_cellsearch_t cs;
srslte_ue_cellsearch_result_t found_cells[3];
bzero(found_cells, 3*sizeof(ue_cell_search_result_t));
bzero(found_cells, 3*sizeof(srslte_ue_cellsearch_result_t));
if (ue_cell_search_init(&cs, cuhd_recv_wrapper_cs, uhd)) {
if (srslte_ue_cellsearch_init(&cs, cuhd_recv_wrapper_cs, uhd)) {
fprintf(stderr, "Error initiating UE cell detect\n");
return SRSLTE_ERROR;
}
if (config->max_frames_pss) {
ue_cell_search_set_nof_frames_to_scan(&cs, config->max_frames_pss);
srslte_ue_cellsearch_set_nof_frames_to_scan(&cs, config->max_frames_pss);
}
if (config->threshold) {
ue_cell_search_set_threshold(&cs, config->threshold);
srslte_ue_cellsearch_set_threshold(&cs, config->threshold);
}
INFO("Setting sampling frequency %.2f MHz for PSS search\n", CS_SAMP_FREQ/1000000);
cuhd_set_rx_srate(uhd, CS_SAMP_FREQ);
INFO("Setting sampling frequency %.2f MHz for PSS search\n", SRSLTE_CS_SAMP_FREQ/1000000);
cuhd_set_rx_srate(uhd, SRSLTE_CS_SAMP_FREQ);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
@ -119,10 +119,10 @@ int cuhd_cell_search(void *uhd, cell_search_cfg_t *config,
/* Find a cell in the given N_id_2 or go through the 3 of them to find the strongest */
uint32_t max_peak_cell = 0;
if (force_N_id_2 >= 0) {
ret = ue_cell_search_scan_N_id_2(&cs, force_N_id_2, &found_cells[force_N_id_2]);
ret = srslte_ue_cellsearch_scan_N_id_2(&cs, force_N_id_2, &found_cells[force_N_id_2]);
max_peak_cell = force_N_id_2;
} else {
ret = ue_cell_search_scan(&cs, found_cells, &max_peak_cell);
ret = srslte_ue_cellsearch_scan(&cs, found_cells, &max_peak_cell);
}
if (ret < 0) {
fprintf(stderr, "Error searching cell\n");
@ -139,7 +139,7 @@ int cuhd_cell_search(void *uhd, cell_search_cfg_t *config,
}
cuhd_stop_rx_stream(uhd);
ue_cell_search_free(&cs);
srslte_ue_cellsearch_free(&cs);
return ret;
}

26
srslte/examples/hl_example.c
Unescape Escape View File

@ -39,10 +39,10 @@ void usage(char *arg) {
int main(int argc, char **argv) {
srslte_binsource_hl bs;
mod_hl mod;
srslte_mod_hl mod;
srslte_ch_awgn_hl ch;
demod_soft_hl demod_s;
demod_hard_hl demod_h;
srslte_demod_soft_hl demod_s;
srslte_demod_hard_hl demod_h;
bzero(&bs,sizeof(bs));
bzero(&mod,sizeof(mod));
@ -65,7 +65,7 @@ int main(int argc, char **argv) {
bs.output = malloc(nbits);
mod.in_len = nbits;
mod.init.std = LTE_BPSK;
mod.init.std = SRSLTE_MOD_BPSK;
mod.input = bs.output;
mod.output = malloc(nbits*sizeof(_Complex float));
@ -75,22 +75,22 @@ int main(int argc, char **argv) {
ch.output = malloc(nbits*sizeof(_Complex float));
demod_h.in_len = nbits;
demod_h.init.std = LTE_BPSK;
demod_h.init.std = SRSLTE_MOD_BPSK;
demod_h.input = ch.output;
demod_h.output = malloc(nbits);
demod_s.in_len = nbits;
demod_s.init.std = LTE_BPSK;
demod_s.init.std = SRSLTE_MOD_BPSK;
demod_s.input = ch.output;
demod_s.output = malloc(sizeof(float)*nbits);
demod_s.ctrl_in.alg_type = APPROX;
demod_s.ctrl_in.alg_type = SRSLTE_DEMOD_SOFT_ALG_APPROX;
demod_s.ctrl_in.sigma = var;
if ( srslte_binsource_initialize(&bs) ||
mod_initialize(&mod) ||
srslte_ch_awgn_initialize(&ch) ||
demod_hard_initialize(&demod_h) ||
demod_soft_initialize(&demod_s)
srslte_demod_hard_initialize(&demod_h) ||
srslte_demod_soft_initialize(&demod_s)
) {
printf("Error initializing modules\n");
exit(-1);
@ -99,8 +99,8 @@ int main(int argc, char **argv) {
srslte_binsource_work(&bs);
mod_work(&mod);
srslte_ch_awgn_work(&ch);
demod_hard_work(&demod_h);
demod_soft_work(&demod_s);
srslte_demod_hard_work(&demod_h);
srslte_demod_soft_work(&demod_s);
/* hard decision for soft demodulation */
uint8_t* tmp = malloc(nbits);
@ -108,8 +108,8 @@ int main(int argc, char **argv) {
tmp[i] = demod_s.output[i]>0?1:0;
}
printf("Hard errors: %u/%d\n",bit_diff(bs.output,demod_h.output,nbits),nbits);
printf("Soft errors: %u/%d\n",bit_diff(bs.output,tmp,nbits),nbits);
printf("Hard errors: %u/%d\n",srslte_bit_diff(bs.output,demod_h.output,nbits),nbits);
printf("Soft errors: %u/%d\n",srslte_bit_diff(bs.output,tmp,nbits),nbits);
free(bs.output);
free(mod.output);

2
srslte/examples/ll_example.c
Unescape Escape View File

@ -45,7 +45,7 @@ int main(int argc, char **argv) {
exit(-1);
}
printf("output: ");
bit_fprint(stdout,output,100);
srslte_bit_fprint(stdout,output,100);
printf("Done\n");
exit(0);
}

118
srslte/examples/pdsch_enodeb.c
Unescape Escape View File

@ -69,14 +69,14 @@ float uhd_amp = 0.03, uhd_gain = 70.0, uhd_freq = 2400000000;
bool null_file_sink=false;
srslte_filesink_t fsink;
srslte_fft_t ifft;
pbch_t pbch;
pcfich_t pcfich;
pdcch_t pdcch;
pdsch_t pdsch;
harq_t harq_process;
regs_t regs;
ra_pdsch_t ra_dl;
srslte_ofdm_t ifft;
srslte_pbch_t pbch;
srslte_pcfich_t pcfich;
srslte_pdcch_t pdcch;
srslte_pdsch_t pdsch;
srslte_harq_t harq_process;
srslte_regs_t regs;
srslte_ra_pdsch_t ra_dl;
cf_t *sf_buffer = NULL, *output_buffer = NULL;
@ -108,7 +108,7 @@ void usage(char *prog) {
printf("\t-c cell id [Default %d]\n", cell.id);
printf("\t-p nof_prb [Default %d]\n", cell.nof_prb);
printf("\t-u listen TCP port for input data (-1 is random) [Default %d]\n", net_port);
printf("\t-v [set verbose to debug, default none]\n");
printf("\t-v [set srslte_verbose to debug, default none]\n");
}
void parse_args(int argc, char **argv) {
@ -146,7 +146,7 @@ void parse_args(int argc, char **argv) {
cell.id = atoi(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -216,44 +216,44 @@ void base_init() {
}
/* create ifft object */
if (lte_ifft_init(&ifft, SRSLTE_SRSLTE_CP_NORM, cell.nof_prb)) {
if (srslte_ofdm_rx_init(&ifft, SRSLTE_SRSLTE_CP_NORM, cell.nof_prb)) {
fprintf(stderr, "Error creating iFFT object\n");
exit(-1);
}
srslte_fft_set_normalize(&ifft, true);
if (pbch_init(&pbch, cell)) {
srslte_ofdm_set_normalize(&ifft, true);
if (srslte_pbch_init(&pbch, cell)) {
fprintf(stderr, "Error creating PBCH object\n");
exit(-1);
}
if (regs_init(&regs, cell)) {
if (srslte_regs_init(&regs, cell)) {
fprintf(stderr, "Error initiating regs\n");
exit(-1);
}
if (pcfich_init(&pcfich, &regs, cell)) {
if (srslte_pcfich_init(&pcfich, &regs, cell)) {
fprintf(stderr, "Error creating PBCH object\n");
exit(-1);
}
if (regs_set_cfi(&regs, cfi)) {
if (srslte_regs_set_cfi(&regs, cfi)) {
fprintf(stderr, "Error setting CFI\n");
exit(-1);
}
if (pdcch_init(&pdcch, &regs, cell)) {
if (srslte_pdcch_init(&pdcch, &regs, cell)) {
fprintf(stderr, "Error creating PDCCH object\n");
exit(-1);
}
if (pdsch_init(&pdsch, cell)) {
if (srslte_pdsrslte_sch_init(&pdsch, cell)) {
fprintf(stderr, "Error creating PDSCH object\n");
exit(-1);
}
pdsch_set_rnti(&pdsch, 1234);
srslte_pdsch_set_rnti(&pdsch, 1234);
if (harq_init(&harq_process, cell)) {
if (srslte_harq_init(&harq_process, cell)) {
fprintf(stderr, "Error initiating HARQ process\n");
exit(-1);
}
@ -262,12 +262,12 @@ void base_init() {
void base_free() {
harq_free(&harq_process);
pdsch_free(&pdsch);
pdcch_free(&pdcch);
regs_free(&regs);
pbch_free(&pbch);
srslte_pdsch_free(&pdsch);
srslte_pdcch_free(&pdcch);
srslte_regs_free(&regs);
srslte_pbch_free(&pbch);
lte_ifft_free(&ifft);
srslte_ofdm_rx_free(&ifft);
if (sf_buffer) {
free(sf_buffer);
@ -304,7 +304,7 @@ reverse(register unsigned int x)
uint32_t prbset_to_bitmask() {
uint32_t mask=0;
int nb = (int) ceilf((float) cell.nof_prb / ra_type0_P(cell.nof_prb));
int nb = (int) ceilf((float) cell.nof_prb / srslte_ra_type0_P(cell.nof_prb));
for (int i=0;i<nb;i++) {
if (i >= prbset_orig && i < prbset_orig + prbset_num) {
mask = mask | (0x1<<i);
@ -314,25 +314,25 @@ uint32_t prbset_to_bitmask() {
}
int update_radl(uint32_t sf_idx) {
ra_dl_alloc_t prb_alloc;
srslte_srslte_ra_dl_alloc_t prb_alloc;
bzero(&ra_dl, sizeof(ra_pdsch_t));
bzero(&ra_dl, sizeof(srslte_ra_pdsch_t));
ra_dl.harq_process = 0;
ra_dl.mcs_idx = mcs_idx;
ra_dl.ndi = 0;
ra_dl.rv_idx = 0;
ra_dl.alloc_type = alloc_type0;
ra_dl.alloc_type = SRSLTE_RA_ALLOC_TYPE0;
ra_dl.type0_alloc.rbg_bitmask = prbset_to_bitmask();
ra_dl_alloc(&prb_alloc, &ra_dl, cell.nof_prb);
ra_dl_alloc_re(&prb_alloc, cell.nof_prb, 1, cell.nof_prb<10?(cfi+1):cfi, SRSLTE_SRSLTE_CP_NORM);
ra_mcs_from_idx_dl(mcs_idx, prb_alloc.slot[0].nof_prb, &ra_dl.mcs);
srslte_ra_dl_alloc(&prb_alloc, &ra_dl, cell.nof_prb);
srslte_ra_dl_alloc_re(&prb_alloc, cell.nof_prb, 1, cell.nof_prb<10?(cfi+1):cfi, SRSLTE_SRSLTE_CP_NORM);
srslte_ra_mcs_from_idx_dl(mcs_idx, prb_alloc.slot[0].nof_prb, &ra_dl.mcs);
ra_pdsch_fprint(stdout, &ra_dl, cell.nof_prb);
srslte_ra_pdsch_fprint(stdout, &ra_dl, cell.nof_prb);
printf("Type new MCS index and press Enter: "); fflush(stdout);
harq_reset(&harq_process);
if (harq_setup_dl(&harq_process, ra_dl.mcs, ra_dl.rv_idx, sf_idx, &prb_alloc)) {
srslte_harq_reset(&harq_process);
if (srslte_harq_setup_dl(&harq_process, ra_dl.mcs, ra_dl.rv_idx, sf_idx, &prb_alloc)) {
fprintf(stderr, "Error configuring HARQ process\n");
return -1;
}
@ -359,7 +359,7 @@ int update_control(uint32_t sf_idx) {
if(input[0] == 27) {
switch(input[2]) {
case RIGHT_KEY:
if (prbset_orig + prbset_num < (int) ceilf((float) cell.nof_prb / ra_type0_P(cell.nof_prb)))
if (prbset_orig + prbset_num < (int) ceilf((float) cell.nof_prb / srslte_ra_type0_P(cell.nof_prb)))
prbset_orig++;
break;
case LEFT_KEY:
@ -367,7 +367,7 @@ int update_control(uint32_t sf_idx) {
prbset_orig--;
break;
case UP_KEY:
if (prbset_num < (int) ceilf((float) cell.nof_prb / ra_type0_P(cell.nof_prb)))
if (prbset_num < (int) ceilf((float) cell.nof_prb / srslte_ra_type0_P(cell.nof_prb)))
prbset_num++;
break;
case DOWN_KEY:
@ -417,7 +417,7 @@ void *net_thread_fnc(void *arg) {
while (rpm >= nbytes) {
// wait for packet to be transmitted
sem_wait(&net_sem);
bit_pack_vector(&data_unpacked[wpm], data, nbytes*8);
srslte_bit_pack_vector(&data_unpacked[wpm], data, nbytes*8);
INFO("Sent %d/%d bytes ready\n", nbytes, rpm);
rpm -= nbytes;
wpm += nbytes;
@ -439,15 +439,15 @@ void *net_thread_fnc(void *arg) {
int main(int argc, char **argv) {
int nf=0, sf_idx=0, N_id_2=0;
cf_t pss_signal[PSS_LEN];
float sss_signal0[SSS_LEN]; // for subframe 0
float sss_signal5[SSS_LEN]; // for subframe 5
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
uint8_t bch_payload[BCH_PAYLOAD_LEN], bch_payload_packed[BCH_PAYLOAD_LEN/8];
int i;
cf_t *sf_symbols[SRSLTE_MAX_PORTS];
cf_t *slot1_symbols[SRSLTE_MAX_PORTS];
dci_msg_t dci_msg;
dci_location_t locations[SRSLTE_NSUBFRAMES_X_FRAME][30];
srslte_dci_msg_t dci_msg;
srslte_dci_location_t locations[SRSLTE_NSUBFRAMES_X_FRAME][30];
uint32_t sfn;
srslte_chest_dl_t est;
@ -468,15 +468,15 @@ int main(int argc, char **argv) {
cell.phich_resources = SRSLTE_PHICH_R_1;
sfn = 0;
prbset_num = (int) ceilf((float) cell.nof_prb / ra_type0_P(cell.nof_prb));
prbset_num = (int) ceilf((float) cell.nof_prb / srslte_ra_type0_P(cell.nof_prb));
last_prbset_num = prbset_num;
/* this *must* be called after setting slot_len_* */
base_init();
/* Generate PSS/SSS signals */
pss_generate(pss_signal, N_id_2);
sss_generate(sss_signal0, sss_signal5, cell.id);
srslte_pss_generate(pss_signal, N_id_2);
srslte_sss_generate(sss_signal0, sss_signal5, cell.id);
/* Generate CRS signals */
if (srslte_chest_dl_init(&est, cell)) {
@ -512,7 +512,7 @@ int main(int argc, char **argv) {
/* Initiate valid DCI locations */
for (i=0;i<SRSLTE_NSUBFRAMES_X_FRAME;i++) {
pdcch_ue_locations(&pdcch, locations[i], 30, i, cfi, 1234);
srslte_pdcch_ue_locations(&pdcch, locations[i], 30, i, cfi, 1234);
}
@ -525,20 +525,20 @@ int main(int argc, char **argv) {
bzero(sf_buffer, sizeof(cf_t) * sf_n_re);
if (sf_idx == 0 || sf_idx == 5) {
pss_put_slot(pss_signal, sf_buffer, cell.nof_prb, SRSLTE_SRSLTE_CP_NORM);
sss_put_slot(sf_idx ? sss_signal5 : sss_signal0, sf_buffer, cell.nof_prb,
srslte_pss_put_slot(pss_signal, sf_buffer, cell.nof_prb, SRSLTE_SRSLTE_CP_NORM);
srslte_sss_put_slot(sf_idx ? sss_signal5 : sss_signal0, sf_buffer, cell.nof_prb,
SRSLTE_SRSLTE_CP_NORM);
}
srslte_refsignal_cs_put_sf(cell, 0, est.csr_signal.pilots[0][sf_idx], sf_buffer);
bcch_bch_pack(&cell, sfn, bch_payload_packed, BCH_PAYLOAD_LEN/8);
bit_pack_vector(bch_payload_packed, bch_payload, BCH_PAYLOAD_LEN);
srslte_bit_pack_vector(bch_payload_packed, bch_payload, BCH_PAYLOAD_LEN);
if (sf_idx == 0) {
pbch_encode(&pbch, bch_payload, slot1_symbols);
srslte_pbch_encode(&pbch, bch_payload, slot1_symbols);
}
pcfich_encode(&pcfich, cfi, sf_symbols, sf_idx);
srslte_pcfich_encode(&pcfich, cfi, sf_symbols, sf_idx);
/* Update DL resource allocation from control port */
if (update_control(sf_idx)) {
@ -564,20 +564,20 @@ int main(int argc, char **argv) {
}
if (send_data) {
dci_msg_pack_pdsch(&ra_dl, &dci_msg, Format1, cell.nof_prb, false);
srslte_dci_msg_pack_pdsch(&ra_dl, &dci_msg, SRSLTE_DCI_FORMAT1, cell.nof_prb, false);
INFO("Putting DCI to location: n=%d, L=%d\n", locations[sf_idx][0].ncce, locations[sf_idx][0].L);
if (pdcch_encode(&pdcch, &dci_msg, locations[sf_idx][0], 1234, sf_symbols, sf_idx, cfi)) {
if (encode(&pdcch, &dci_msg, locations[sf_idx][0], 1234, sf_symbols, sf_idx, cfi)) {
fprintf(stderr, "Error encoding DCI message\n");
exit(-1);
}
if (pdsch_encode(&pdsch, &harq_process, data, sf_symbols)) {
if (srslte_pdsch_encode(&pdsch, &harq_process, data, sf_symbols)) {
fprintf(stderr, "Error encoding PDSCH\n");
exit(-1);
}
if (net_port > 0 && net_packet_ready) {
if (null_file_sink) {
bit_unpack_vector(data, data_tmp, ra_dl.mcs.tbs);
srslte_bit_unpack_vector(data, data_tmp, ra_dl.mcs.tbs);
if (srslte_netsink_write(&net_sink, data_tmp, 1+(ra_dl.mcs.tbs-1)/8) < 0) {
fprintf(stderr, "Error sending data through UDP socket\n");
}
@ -588,10 +588,10 @@ int main(int argc, char **argv) {
}
/* Transform to OFDM symbols */
lte_ifft_run_sf(&ifft, sf_buffer, output_buffer);
srslte_ofdm_rx_sf(&ifft, sf_buffer, output_buffer);
float norm_factor = (float) cell.nof_prb/15/sqrtf(ra_dl.prb_alloc.slot[0].nof_prb);
vec_sc_prod_cfc(output_buffer, uhd_amp*norm_factor, output_buffer, SRSLTE_SF_LEN_PRB(cell.nof_prb));
srslte_vec_sc_prod_cfc(output_buffer, uhd_amp*norm_factor, output_buffer, SRSLTE_SF_LEN_PRB(cell.nof_prb));
/* send to file or usrp */
if (output_file_name) {
@ -601,7 +601,7 @@ int main(int argc, char **argv) {
usleep(1000);
} else {
#ifndef DISABLE_UHD
vec_sc_prod_cfc(output_buffer, uhd_amp, output_buffer, sf_n_samples);
srslte_vec_sc_prod_cfc(output_buffer, uhd_amp, output_buffer, sf_n_samples);
cuhd_send(uhd, output_buffer, sf_n_samples, true);
#endif
}

84
srslte/examples/pdsch_ue.c
Unescape Escape View File

@ -130,7 +130,7 @@ void usage(prog_args_t *args, char *prog) {
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 verbose to debug, default none]\n");
printf("\t-v [set srslte_verbose to debug, default none]\n");
}
void parse_args(prog_args_t *args, int argc, char **argv) {
@ -181,7 +181,7 @@ void parse_args(prog_args_t *args, int argc, char **argv) {
args->disable_plots = true;
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(args, argv[0]);
@ -218,8 +218,8 @@ extern float mean_exec_time;
enum receiver_state { DECODE_MIB, DECODE_PDSCH} state;
ue_dl_t ue_dl;
ue_sync_t ue_sync;
srs_ue_dl_t ue_dl;
srslte_ue_sync_t ue_sync;
prog_args_t prog_args;
uint32_t sfn = 0; // system frame number
@ -230,7 +230,7 @@ int main(int argc, char **argv) {
int ret;
srslte_cell_t cell;
int64_t sf_cnt;
ue_mib_t ue_mib;
srslte_ue_mib_t ue_mib;
#ifndef DISABLE_UHD
void *uhd;
#endif
@ -293,7 +293,7 @@ int main(int argc, char **argv) {
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
if (ue_mib_init(&ue_mib, cell)) {
if (srslte_ue_mib_init(&ue_mib, cell)) {
fprintf(stderr, "Error initaiting UE MIB decoder\n");
exit(-1);
}
@ -311,7 +311,7 @@ int main(int argc, char **argv) {
cell.nof_ports = 1;
cell.nof_prb = prog_args.file_nof_prb;
if (ue_sync_init_file(&ue_sync, prog_args.file_nof_prb, prog_args.input_file_name)) {
if (srslte_ue_sync_init_file(&ue_sync, prog_args.file_nof_prb, prog_args.input_file_name)) {
fprintf(stderr, "Error initiating ue_sync\n");
exit(-1);
}
@ -319,20 +319,20 @@ int main(int argc, char **argv) {
} else {
#ifndef DISABLE_UHD
state = DECODE_MIB;
if (ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) {
if (srslte_ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper, uhd)) {
fprintf(stderr, "Error initiating ue_sync\n");
exit(-1);
}
#endif
}
if (ue_dl_init(&ue_dl, cell)) { // This is the User RNTI
if (srs_ue_dl_init(&ue_dl, cell)) { // This is the User RNTI
fprintf(stderr, "Error initiating UE downlink processing module\n");
exit(-1);
}
/* Configure downlink receiver for the SI-RNTI since will be the only one we'll use */
ue_dl_set_rnti(&ue_dl, prog_args.rnti);
srs_ue_dl_set_rnti(&ue_dl, prog_args.rnti);
/* Initialize subframe counter */
sf_cnt = 0;
@ -361,23 +361,23 @@ int main(int argc, char **argv) {
/* Main loop */
while (!go_exit && (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1)) {
ret = ue_sync_get_buffer(&ue_sync, &sf_buffer);
ret = srslte_ue_sync_get_buffer(&ue_sync, &sf_buffer);
if (ret < 0) {
fprintf(stderr, "Error calling ue_sync_work()\n");
fprintf(stderr, "Error calling srslte_ue_sync_work()\n");
}
/* ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
/* srslte_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
if (ret == 1) {
switch (state) {
case DECODE_MIB:
if (ue_sync_get_sfidx(&ue_sync) == 0) {
pbch_decode_reset(&ue_mib.pbch);
n = ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (srslte_ue_sync_get_sfidx(&ue_sync) == 0) {
decode_reset(&ue_mib.pbch);
n = srslte_ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (n < 0) {
fprintf(stderr, "Error decoding UE MIB\n");
exit(-1);
} else if (n == MIB_FOUND) {
bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
} else if (n == SRSLTE_UE_MIB_FOUND) {
srslte_bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
bcch_bch_unpack(bch_payload, BCH_PAYLOAD_LEN, &cell, &sfn);
printf("Decoded MIB. SFN: %d, offset: %d\n", sfn, sfn_offset);
sfn = (sfn + sfn_offset)%1024;
@ -390,7 +390,7 @@ int main(int argc, char **argv) {
decode_pdsch = true;
} else {
/* We are looking for SIB1 Blocks, search only in appropiate places */
if ((ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) {
if ((srslte_ue_sync_get_sfidx(&ue_sync) == 5 && (sfn%2)==0)) {
decode_pdsch = true;
} else {
decode_pdsch = false;
@ -398,9 +398,9 @@ int main(int argc, char **argv) {
}
if (decode_pdsch) {
if (prog_args.rnti != SRSLTE_SIRNTI) {
n = ue_dl_decode(&ue_dl, sf_buffer, data_packed, ue_sync_get_sfidx(&ue_sync));
n = srs_ue_dl_decode(&ue_dl, sf_buffer, data_packed, srslte_ue_sync_get_sfidx(&ue_sync));
} else {
n = ue_dl_decode_rnti_rv(&ue_dl, sf_buffer, data_packed, ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI,
n = srs_ue_dl_decode_rnti_rv(&ue_dl, sf_buffer, data_packed, srslte_ue_sync_get_sfidx(&ue_sync), SRSLTE_SIRNTI,
((int) ceilf((float)3*(((sfn)/2)%4)/2))%4);
}
if (n < 0) {
@ -408,15 +408,15 @@ int main(int argc, char **argv) {
} else if (n > 0) {
/* Send data if socket active */
if (prog_args.net_port > 0) {
bit_unpack_vector(data_packed, data, n);
srslte_bit_unpack_vector(data_packed, data, n);
srslte_netsink_write(&net_sink, data, 1+(n-1)/8);
}
}
nof_trials++;
rsrq = VEC_EMA(srslte_chest_dl_get_rsrq(&ue_dl.chest), rsrq, 0.05);
rsrp = VEC_EMA(srslte_chest_dl_get_rsrp(&ue_dl.chest), rsrp, 0.05);
snr = VEC_EMA(srslte_chest_dl_get_snr(&ue_dl.chest), snr, 0.01);
rsrq = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrq(&ue_dl.chest), rsrq, 0.05);
rsrp = SRSLTE_VEC_EMA(srslte_chest_dl_get_rsrp(&ue_dl.chest), rsrp, 0.05);
snr = SRSLTE_VEC_EMA(srslte_chest_dl_get_snr(&ue_dl.chest), snr, 0.01);
nframes++;
if (isnan(rsrq)) {
rsrq = 0;
@ -443,32 +443,32 @@ int main(int argc, char **argv) {
#endif
}
if (ue_sync_get_sfidx(&ue_sync) != 5 && ue_sync_get_sfidx(&ue_sync) != 0) {
if (srslte_ue_sync_get_sfidx(&ue_sync) != 5 && srslte_ue_sync_get_sfidx(&ue_sync) != 0) {
pdcch_tx++;
}
// Plot and Printf
if (ue_sync_get_sfidx(&ue_sync) == 5) {
if (srslte_ue_sync_get_sfidx(&ue_sync) == 5) {
#ifdef STDOUT_COMPACT
printf("SFN: %4d, PDCCH-Miss: %5.2f%% (%d missed), PDSCH-BLER: %5.2f%% (%d errors)\r",
sfn, 100*(1-(float) ue_dl.nof_pdcch_detected/nof_trials),pdcch_tx-ue_dl.nof_pdcch_detected,
sfn, 100*(1-(float) ue_dl.nof_detected/nof_trials),pdcch_tx-ue_dl.nof_detected,
(float) 100*ue_dl.pkt_errors/ue_dl.pkts_total,ue_dl.pkt_errors);
#else
printf("CFO: %+6.2f KHz, SFO: %+6.2f Khz, "
"RSRP: %+5.1f dBm, RSRQ: %5.1f dB, SNR: %4.1f dB, "
"PDCCH-Miss: %5.2f%% (%d), PDSCH-BLER: %5.2f%% (%d)\r",
ue_sync_get_cfo(&ue_sync)/1000, ue_sync_get_sfo(&ue_sync)/1000,
srslte_ue_sync_get_cfo(&ue_sync)/1000, srslte_ue_sync_get_sfo(&ue_sync)/1000,
10*log10(rsrp*1000)-gain_offset,
10*log10(rsrq), 10*log10(snr),
100*(1-(float) ue_dl.nof_pdcch_detected/nof_trials), pdcch_tx-ue_dl.nof_pdcch_detected,
100*(1-(float) ue_dl.nof_detected/nof_trials), pdcch_tx-ue_dl.nof_detected,
(float) 100*ue_dl.pkt_errors/ue_dl.pkts_total, ue_dl.pkt_errors);
#endif
}
break;
}
if (ue_sync_get_sfidx(&ue_sync) == 9) {
if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) {
sfn++;
if (sfn == 1024) {
sfn = 0;
@ -477,25 +477,25 @@ int main(int argc, char **argv) {
#ifndef DISABLE_GRAPHICS
if (!prog_args.disable_plots) {
plot_sf_idx = ue_sync_get_sfidx(&ue_sync);
plot_sf_idx = srslte_ue_sync_get_sfidx(&ue_sync);
sem_post(&plot_sem);
}
#endif
} else if (ret == 0) {
printf("Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r",
sync_get_peak_value(&ue_sync.sfind),
srslte_sync_get_peak_value(&ue_sync.sfind),
ue_sync.frame_total_cnt, ue_sync.state);
}
sf_cnt++;
} // Main loop
ue_dl_free(&ue_dl);
ue_sync_free(&ue_sync);
srs_ue_dl_free(&ue_dl);
srslte_ue_sync_free(&ue_sync);
#ifndef DISABLE_UHD
if (!prog_args.input_file_name) {
ue_mib_free(&ue_mib);
srslte_ue_mib_free(&ue_mib);
cuhd_close(uhd);
}
#endif
@ -549,8 +549,8 @@ void *plot_thread_run(void *arg) {
//}
plot_real_setNewData(&pce, tmp_plot2, SRSLTE_REFSIGNAL_NUM_SF(ue_dl.cell.nof_prb,0));
if (!prog_args.input_file_name) {
int max = vec_max_fi(ue_sync.strack.pss.conv_output_avg, ue_sync.strack.pss.frame_size+ue_sync.strack.pss.fft_size-1);
vec_sc_prod_fff(ue_sync.strack.pss.conv_output_avg,
int max = srslte_vec_max_fi(ue_sync.strack.pss.conv_output_avg, ue_sync.strack.pss.frame_size+ue_sync.strack.pss.fft_size-1);
srslte_vec_sc_prod_fff(ue_sync.strack.pss.conv_output_avg,
1/ue_sync.strack.pss.conv_output_avg[max],
tmp_plot2,
ue_sync.strack.pss.frame_size+ue_sync.strack.pss.fft_size-1);
@ -558,13 +558,13 @@ void *plot_thread_run(void *arg) {
}
plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.pdsch_d, nof_symbols);
plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.pdcch_d, 36*ue_dl.pdcch.nof_cce);
plot_scatter_setNewData(&pscatequal, ue_dl.pdsch.d, nof_symbols);
plot_scatter_setNewData(&pscatequal_pdcch, ue_dl.pdcch.d, 36*ue_dl.pdcch.nof_cce);
if (plot_sf_idx == 1) {
if (prog_args.net_port_signal > 0) {
srslte_netsink_write(&net_sink_signal, &sf_buffer[ue_sync_sf_len(&ue_sync)/7],
ue_sync_sf_len(&ue_sync));
srslte_netsink_write(&net_sink_signal, &sf_buffer[srslte_ue_sync_sf_len(&ue_sync)/7],
srslte_ue_sync_sf_len(&ue_sync));
}
}

134
srslte/examples/prach_ue.c
Unescape Escape View File

@ -105,7 +105,7 @@ void usage(prog_args_t *args, char *prog) {
printf("\t-p PRACH preamble idx [Default %d]\n",args->preamble_idx);
printf("\t-l Force N_id_2 [Default best]\n");
printf("\t-n nof_subframes [Default %d]\n", args->nof_subframes);
printf("\t-v [set verbose to debug, default none]\n");
printf("\t-v [set srslte_verbose to debug, default none]\n");
}
void parse_args(prog_args_t *args, int argc, char **argv) {
@ -147,7 +147,7 @@ void parse_args(prog_args_t *args, int argc, char **argv) {
args->force_N_id_2 = atoi(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(args, argv[0]);
@ -184,10 +184,10 @@ enum receiver_state { DECODE_MIB, SEND_PRACH, RECV_RAR, RECV_CONNSETUP} state;
#define NOF_PRACH_SEQUENCES 52
ue_dl_t ue_dl;
ue_ul_t ue_ul;
ue_sync_t ue_sync;
prach_t prach;
srs_ue_dl_t ue_dl;
srslte_ue_ul_t ue_ul;
srslte_ue_sync_t ue_sync;
srslte_prach_t prach;
int prach_buffer_len;
prog_args_t prog_args;
@ -265,20 +265,20 @@ int rar_unpack(uint8_t *buffer, rar_msg_t *msg)
msg->hdr_type = *ptr++;
if(msg->hdr_type == rar_header_type_bi) {
ptr += 2;
msg->BI = bit_unpack(&ptr, 4);
msg->BI = srslte_bit_unpack(&ptr, 4);
ret = SRSLTE_SUCCESS;
} else if (msg->hdr_type == rar_header_type_rapid) {
msg->RAPID = bit_unpack(&ptr, 6);
msg->RAPID = srslte_bit_unpack(&ptr, 6);
ptr++;
msg->timing_adv_cmd = bit_unpack(&ptr, 11);
msg->timing_adv_cmd = srslte_bit_unpack(&ptr, 11);
msg->hopping_flag = *ptr++;
msg->rba = bit_unpack(&ptr, 10);
msg->mcs = bit_unpack(&ptr, 4);
msg->tpc_command = (rar_tpc_command_t) bit_unpack(&ptr, 3);
msg->rba = srslte_bit_unpack(&ptr, 10);
msg->mcs = srslte_bit_unpack(&ptr, 4);
msg->tpc_command = (rar_tpc_command_t) srslte_bit_unpack(&ptr, 3);
msg->ul_delay = *ptr++;
msg->csi_req = *ptr++;
msg->temp_c_rnti = bit_unpack(&ptr, 16);
msg->temp_c_rnti = srslte_bit_unpack(&ptr, 16);
ret = SRSLTE_SUCCESS;
}
}
@ -293,13 +293,13 @@ int main(int argc, char **argv) {
int ret;
srslte_cell_t cell;
int64_t sf_cnt;
ue_mib_t ue_mib;
srslte_ue_mib_t ue_mib;
void *uhd;
int n;
uint8_t bch_payload[BCH_PAYLOAD_LEN], bch_payload_unpacked[BCH_PAYLOAD_LEN];
uint32_t sfn_offset;
rar_msg_t rar_msg;
ra_pusch_t ra_pusch;
srslte_ra_pusch_t ra_pusch;
uint32_t rar_window_start = 0, rar_trials = 0, rar_window_stop = 0;
srslte_timestamp_t uhd_time;
srslte_timestamp_t next_tx_time;
@ -368,33 +368,33 @@ int main(int argc, char **argv) {
#endif
if (ue_mib_init(&ue_mib, cell)) {
if (srslte_ue_mib_init(&ue_mib, cell)) {
fprintf(stderr, "Error initaiting UE MIB decoder\n");
exit(-1);
}
if (prach_init(&prach, srslte_symbol_sz(cell.nof_prb), 0, 0, false, 1)) {
if (srslte_prach_init(&prach, srslte_symbol_sz(cell.nof_prb), 0, 0, false, 1)) {
fprintf(stderr, "Error initializing PRACH\n");
exit(-1);
}
prach_buffer_len = prach.N_seq + prach.N_cp;
prach_buffer = vec_malloc(prach_buffer_len*sizeof(cf_t));
prach_buffer = srslte_vec_malloc(prach_buffer_len*sizeof(cf_t));
if(!prach_buffer) {
perror("maloc");
exit(-1);
}
if(prach_gen(&prach, prog_args.preamble_idx, 0, prog_args.beta_prach, prach_buffer)){
if(srslte_prach_gen(&prach, prog_args.preamble_idx, 0, prog_args.beta_prach, prach_buffer)){
fprintf(stderr, "Error generating prach sequence\n");
return -1;
}
if (ue_ul_init(&ue_ul, cell)) {
if (srslte_ue_ul_init(&ue_ul, cell)) {
fprintf(stderr, "Error initiating UE UL\n");
exit(-1);
}
pusch_hopping_cfg_t hop_cfg;
bzero(&hop_cfg, sizeof(pusch_hopping_cfg_t));
srslte_pusch_hopping_cfg_t hop_cfg;
bzero(&hop_cfg, sizeof(srslte_pusch_hopping_cfg_t));
srslte_refsignal_drms_pusch_cfg_t drms_cfg;
bzero(&drms_cfg, sizeof(srslte_refsignal_drms_pusch_cfg_t));
drms_cfg.beta_pusch = 1.0;
@ -404,16 +404,16 @@ int main(int argc, char **argv) {
drms_cfg.cyclic_shift = 0;
drms_cfg.cyclic_shift_for_drms = 0;
drms_cfg.en_drms_2 = false;
ue_ul_set_pusch_cfg(&ue_ul, &drms_cfg, &hop_cfg);
srslte_ue_ul_set_pusch_cfg(&ue_ul, &drms_cfg, &hop_cfg);
cf_t *ul_signal = vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_PRB(cell.nof_prb));
cf_t *ul_signal = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN_PRB(cell.nof_prb));
if (!ul_signal) {
perror("malloc");
exit(-1);
}
bzero(ul_signal, sizeof(cf_t) * SRSLTE_SF_LEN_PRB(cell.nof_prb));
if (ue_dl_init(&ue_dl, cell)) {
if (srs_ue_dl_init(&ue_dl, cell)) {
fprintf(stderr, "Error initiating UE downlink processing module\n");
exit(-1);
}
@ -423,7 +423,7 @@ int main(int argc, char **argv) {
#ifdef use_usrp
if (ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper_timed, uhd)) {
if (srslte_ue_sync_init(&ue_sync, cell, cuhd_recv_wrapper_timed, uhd)) {
fprintf(stderr, "Error initiating ue_sync\n");
exit(-1);
}
@ -445,9 +445,9 @@ int main(int argc, char **argv) {
while (!go_exit && (sf_cnt < prog_args.nof_subframes || prog_args.nof_subframes == -1)) {
#ifdef kk
ret = ue_sync_get_buffer(&ue_sync, &sf_buffer);
ret = srslte_ue_sync_get_buffer(&ue_sync, &sf_buffer);
if (ret < 0) {
fprintf(stderr, "Error calling ue_sync_work()\n");
fprintf(stderr, "Error calling srslte_ue_sync_work()\n");
}
#else
ret = 1;
@ -455,28 +455,28 @@ int main(int argc, char **argv) {
cf_t dummy[4];
#endif
/* ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
/* srslte_ue_sync_get_buffer returns 1 if successfully read 1 aligned subframe */
if (ret == 1) {
if (state != RECV_RAR) {
/* Run FFT for all subframe data */
srslte_fft_run_sf(&ue_dl.fft, sf_buffer, ue_dl.sf_symbols);
srslte_ofdm_tx_sf(&ue_dl.fft, sf_buffer, ue_dl.sf_symbols);
/* Get channel estimates for each port */
srslte_chest_dl_estimate(&ue_dl.chest, ue_dl.sf_symbols, ue_dl.ce, ue_sync_get_sfidx(&ue_sync));
srslte_chest_dl_estimate(&ue_dl.chest, ue_dl.sf_symbols, ue_dl.ce, srslte_ue_sync_get_sfidx(&ue_sync));
}
if (sf_cnt > 1000) {
switch (state) {
case DECODE_MIB:
if (ue_sync_get_sfidx(&ue_sync) == 0) {
pbch_decode_reset(&ue_mib.pbch);
n = ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (srslte_ue_sync_get_sfidx(&ue_sync) == 0) {
decode_reset(&ue_mib.pbch);
n = srslte_ue_mib_decode(&ue_mib, sf_buffer, bch_payload_unpacked, NULL, &sfn_offset);
if (n < 0) {
fprintf(stderr, "Error decoding UE MIB\n");
exit(-1);
} else if (n == MIB_FOUND) {
bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
} else if (n == SRSLTE_UE_MIB_FOUND) {
srslte_bit_unpack_vector(bch_payload_unpacked, bch_payload, BCH_PAYLOAD_LEN);
bcch_bch_unpack(bch_payload, BCH_PAYLOAD_LEN, &cell, &sfn);
printf("Decoded MIB. SFN: %d, offset: %d\n", sfn, sfn_offset);
sfn = (sfn + sfn_offset)%1024;
@ -487,8 +487,8 @@ int main(int argc, char **argv) {
case SEND_PRACH:
#ifdef kk
if (((sfn%2) == 1) && (ue_sync_get_sfidx(&ue_sync) == 1)) {
ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
if (((sfn%2) == 1) && (srslte_ue_sync_get_sfidx(&ue_sync) == 1)) {
srslte_ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
srslte_timestamp_copy(&next_tx_time, &uhd_time);
srslte_timestamp_add(&next_tx_time, 0, 0.01); // send next frame (10 ms)
@ -508,7 +508,7 @@ int main(int argc, char **argv) {
srslte_timestamp_copy(&tx_time, &rx_time);
printf("Transmitting PRACH...\n");
vec_save_file("prach_tx", prach_buffers[7], prach_buffer_len*sizeof(cf_t));
srslte_vec_save_file("srslte_prach_tx", prach_buffers[7], prach_buffer_len*sizeof(cf_t));
while(1) {
srslte_timestamp_add(&tx_time, 0, 0.001); // send every (10 ms)
cuhd_send_timed(uhd, prach_buffers[7], prach_buffer_len,
@ -520,9 +520,9 @@ int main(int argc, char **argv) {
case RECV_RAR:
#ifdef kk
if ((sfn == rar_window_start && ue_sync_get_sfidx(&ue_sync) > 3) || sfn > rar_window_start) {
printf("Looking for RAR in sfn: %d sf_idx: %d\n", sfn, ue_sync_get_sfidx(&ue_sync));
n = ue_dl_decode_rnti(&ue_dl, sf_buffer, data_rx, ue_sync_get_sfidx(&ue_sync), ra_rnti);
if ((sfn == rar_window_start && srslte_ue_sync_get_sfidx(&ue_sync) > 3) || sfn > rar_window_start) {
printf("Looking for RAR in sfn: %d sf_idx: %d\n", sfn, srslte_ue_sync_get_sfidx(&ue_sync));
n = srs_ue_dl_decode_rnti(&ue_dl, sf_buffer, data_rx, srslte_ue_sync_get_sfidx(&ue_sync), ra_rnti);
if (n < 0) {
fprintf(stderr, "Error decoding UE DL\n");fflush(stdout);
} else if (n > 0) {
@ -535,14 +535,14 @@ int main(int argc, char **argv) {
//cuhd_flush_buffer(uhd);
rar_msg_fprint(stdout, &rar_msg);
dci_rar_to_ra_ul(rar_msg.rba, rar_msg.mcs, rar_msg.hopping_flag, cell.nof_prb, &ra_pusch);
ra_pusch_fprint(stdout, &ra_pusch, cell.nof_prb);
srslte_dci_rar_to_ra_ul(rar_msg.rba, rar_msg.mcs, rar_msg.hopping_flag, cell.nof_prb, &ra_pusch);
srslte_ra_pusch_fprint(stdout, &ra_pusch, cell.nof_prb);
ra_ul_alloc(&ra_pusch.prb_alloc, &ra_pusch, 0, cell.nof_prb);
srslte_ra_ul_alloc(&ra_pusch.prb_alloc, &ra_pusch, 0, cell.nof_prb);
ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
srslte_ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
bit_pack_vector((uint8_t*) conn_request_msg, data, ra_pusch.mcs.tbs);
srslte_bit_pack_vector((uint8_t*) conn_request_msg, data, ra_pusch.mcs.tbs);
uint32_t n_ta = srssrslte_N_ta_new_rar(rar_msg.timing_adv_cmd);
printf("ta: %d, n_ta: %d\n", rar_msg.timing_adv_cmd, n_ta);
@ -554,15 +554,15 @@ int main(int argc, char **argv) {
const uint32_t rv[N_TX]={0,2,3,1,0};
for (int i=0; i<N_TX;i++) {
ra_pusch.rv_idx = rv[i];
ul_sf_idx = (ue_sync_get_sfidx(&ue_sync)+6+i*8)%10;
ul_sf_idx = (srslte_ue_sync_get_sfidx(&ue_sync)+6+i*8)%10;
n = ue_ul_pusch_encode_rnti(&ue_ul, &ra_pusch, data, ul_sf_idx, rar_msg.temp_c_rnti, ul_signal);
n = srslte_ue_ul_srslte_pusch_encode_rnti(&ue_ul, &ra_pusch, data, ul_sf_idx, rar_msg.temp_c_rnti, ul_signal);
if (n < 0) {
fprintf(stderr, "Error encoding PUSCH\n");
exit(-1);
}
vec_sc_prod_cfc(ul_signal, prog_args.beta_pusch, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb));
srslte_vec_sc_prod_cfc(ul_signal, prog_args.beta_pusch, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb));
srslte_timestamp_copy(&next_tx_time, &uhd_time);
srslte_timestamp_add(&next_tx_time, 0, 0.006 + i*0.008 - time_adv_sec); // send after 6 sub-frames (6 ms)
@ -593,7 +593,7 @@ int main(int argc, char **argv) {
}
#else
ra_pusch.mcs.mod = LTE_QPSK;
ra_pusch.mcs.mod = SRSLTE_MOD_QPSK;
ra_pusch.mcs.tbs = 94;
ra_pusch.rv_idx = 0;
ra_pusch.prb_alloc.freq_hopping = 0;
@ -603,15 +603,15 @@ int main(int argc, char **argv) {
uint32_t ul_sf_idx = 4;
printf("L: %d\n", ra_pusch.prb_alloc.L_prb);
// ue_ul_set_cfo(&ue_ul, sync_get_cfo(&ue_sync.strack));
bit_pack_vector((uint8_t*) conn_request_msg, data, ra_pusch.mcs.tbs);
n = ue_ul_pusch_encode_rnti(&ue_ul, &ra_pusch, data, ul_sf_idx, 111, ul_signal);
// srslte_ue_ul_set_cfo(&ue_ul, srslte_sync_get_cfo(&ue_sync.strack));
srslte_bit_pack_vector((uint8_t*) conn_request_msg, data, ra_pusch.mcs.tbs);
n = srslte_ue_ul_srslte_pusch_encode_rnti(&ue_ul, &ra_pusch, data, ul_sf_idx, 111, ul_signal);
if (n < 0) {
fprintf(stderr, "Error encoding PUSCH\n");
exit(-1);
}
vec_save_file("pusch_tx", ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb)*sizeof(cf_t));
srslte_vec_save_file("srslte_pusch_tx", ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb)*sizeof(cf_t));
#ifdef use_usrp
cuhd_recv_with_time(uhd, dummy, 4, 1, &uhd_time.full_secs, &uhd_time.frac_secs);
@ -629,19 +629,19 @@ int main(int argc, char **argv) {
break;
case RECV_CONNSETUP:
if (ue_sync_get_sfidx(&ue_sync) == (ul_sf_idx+4)%10) {
//verbose=VERBOSE_DEBUG;
vec_save_file("connsetup",sf_buffer,SRSLTE_SF_LEN_PRB(cell.nof_prb)*sizeof(cf_t));
if (srslte_ue_sync_get_sfidx(&ue_sync) == (ul_sf_idx+4)%10) {
//srslte_verbose=SRSLTE_VERBOSE_DEBUG;
srslte_vec_save_file("connsetup",sf_buffer,SRSLTE_SF_LEN_PRB(cell.nof_prb)*sizeof(cf_t));
} else {
//verbose=VERBOSE_NONE;
//srslte_verbose=SRSLTE_VERBOSE_NONE;
}
printf("Looking for ConnectionSetup in sfn: %d sf_idx: %d, RNTI: %d\n", sfn, ue_sync_get_sfidx(&ue_sync),rar_msg.temp_c_rnti);
n = ue_dl_decode_rnti(&ue_dl, sf_buffer, data_rx, ue_sync_get_sfidx(&ue_sync), rar_msg.temp_c_rnti);
printf("Looking for ConnectionSetup in sfn: %d sf_idx: %d, RNTI: %d\n", sfn, srslte_ue_sync_get_sfidx(&ue_sync),rar_msg.temp_c_rnti);
n = srs_ue_dl_decode_rnti(&ue_dl, sf_buffer, data_rx, srslte_ue_sync_get_sfidx(&ue_sync), rar_msg.temp_c_rnti);
if (n < 0) {
fprintf(stderr, "Error decoding UE DL\n");fflush(stdout);
} else if (n > 0) {
printf("Received ConnectionSetup len: %d.\n", n);
vec_fprint_hex(stdout, data_rx, n);
srslte_vec_fprint_hex(stdout, data_rx, n);
} else {
conn_setup_trial++;
if (conn_setup_trial == 20) {
@ -651,7 +651,7 @@ int main(int argc, char **argv) {
break;
}
if (ue_sync_get_sfidx(&ue_sync) == 9) {
if (srslte_ue_sync_get_sfidx(&ue_sync) == 9) {
sfn++;
if (sfn == 1024) {
sfn = 0;
@ -662,17 +662,17 @@ int main(int argc, char **argv) {
} else if (ret == 0) {
printf("Finding PSS... Peak: %8.1f, FrameCnt: %d, State: %d\r",
sync_get_peak_value(&ue_sync.sfind),
srslte_sync_get_peak_value(&ue_sync.sfind),
ue_sync.frame_total_cnt, ue_sync.state);
}
sf_cnt++;
} // Main loop
ue_dl_free(&ue_dl);
ue_sync_free(&ue_sync);
srs_ue_dl_free(&ue_dl);
srslte_ue_sync_free(&ue_sync);
ue_mib_free(&ue_mib);
srslte_ue_mib_free(&ue_mib);
cuhd_close(uhd);
printf("\nBye\n");
exit(0);

38
srslte/examples/synch_file.c
Unescape Escape View File

@ -52,7 +52,7 @@ void usage(char *prog) {
printf("\t-N out_N_id_2 [Default %d]\n", out_N_id_2);
printf("\t-f force_N_id_2 [Default %d]\n", force_N_id_2);
printf("\t-c force_cfo [Default disabled]\n");
printf("\t-v verbose\n");
printf("\t-v srslte_verbose\n");
}
void parse_args(int argc, char **argv) {
@ -87,7 +87,7 @@ void parse_args(int argc, char **argv) {
force_cfo = atof(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -103,9 +103,9 @@ void parse_args(int argc, char **argv) {
int main(int argc, char **argv) {
srslte_filesource_t fsrc;
srslte_filesink_t fsink;
pss_synch_t pss[3]; // One for each N_id_2
sss_synch_t sss[3]; // One for each N_id_2
cfo_t cfocorr;
srslte_pss_synch_t pss[3]; // One for each N_id_2
srslte_sss_synch_t sss[3]; // One for each N_id_2
srslte_cfo_t cfocorr;
int peak_pos[3];
float *cfo;
float peak_value[3];
@ -153,7 +153,7 @@ int main(int argc, char **argv) {
exit(-1);
}
if (cfo_init(&cfocorr, frame_length)) {
if (srslte_cfo_init(&cfocorr, frame_length)) {
fprintf(stderr, "Error initiating CFO\n");
return -1;
}
@ -164,19 +164,19 @@ int main(int argc, char **argv) {
* a) requries more memory but has less latency and is paralellizable.
*/
for (N_id_2=0;N_id_2<3;N_id_2++) {
if (pss_synch_init(&pss[N_id_2], frame_length)) {
if (srslte_pss_synch_init(&pss[N_id_2], frame_length)) {
fprintf(stderr, "Error initializing PSS object\n");
exit(-1);
}
if (pss_synch_set_N_id_2(&pss[N_id_2], N_id_2)) {
if (srslte_pss_synch_set_N_id_2(&pss[N_id_2], N_id_2)) {
fprintf(stderr, "Error initializing N_id_2\n");
exit(-1);
}
if (sss_synch_init(&sss[N_id_2], 128)) {
if (srslte_sss_synch_init(&sss[N_id_2], 128)) {
fprintf(stderr, "Error initializing SSS object\n");
exit(-1);
}
if (sss_synch_set_N_id_2(&sss[N_id_2], N_id_2)) {
if (srslte_sss_synch_set_N_id_2(&sss[N_id_2], N_id_2)) {
fprintf(stderr, "Error initializing N_id_2\n");
exit(-1);
}
@ -195,15 +195,15 @@ int main(int argc, char **argv) {
gettimeofday(&tdata[1], NULL);
if (force_cfo != CFO_AUTO) {
cfo_correct(&cfocorr, input, input, force_cfo/128);
srslte_cfo_correct(&cfocorr, input, input, force_cfo/128);
}
if (force_N_id_2 != -1) {
N_id_2 = force_N_id_2;
peak_pos[N_id_2] = pss_synch_find_pss(&pss[N_id_2], input, &peak_value[N_id_2]);
peak_pos[N_id_2] = srslte_pss_synch_find_pss(&pss[N_id_2], input, &peak_value[N_id_2]);
} else {
for (N_id_2=0;N_id_2<3;N_id_2++) {
peak_pos[N_id_2] = pss_synch_find_pss(&pss[N_id_2], input, &peak_value[N_id_2]);
peak_pos[N_id_2] = srslte_pss_synch_find_pss(&pss[N_id_2], input, &peak_value[N_id_2]);
}
float max_value=-99999;
N_id_2=-1;
@ -221,13 +221,13 @@ int main(int argc, char **argv) {
sss_idx = peak_pos[N_id_2]-2*(symbol_sz+SRSLTE_CP(symbol_sz,SRSLTE_SRSLTE_CP_NORM_LEN));
if (sss_idx >= 0) {
sss_synch_m0m1_diff(&sss[N_id_2], &input[sss_idx],
srslte_sss_synch_m0m1_diff(&sss[N_id_2], &input[sss_idx],
&m0, &m0_value, &m1, &m1_value);
cfo[frame_cnt] = pss_synch_cfo_compute(&pss[N_id_2], &input[peak_pos[N_id_2]-128]);
cfo[frame_cnt] = srslte_pss_synch_cfo_compute(&pss[N_id_2], &input[peak_pos[N_id_2]-128]);
printf("\t%d\t%d\t%d\t%d\t%.3f\t\t%3d\t%d\t%d\t%.3f\n",
frame_cnt,N_id_2, sss_synch_N_id_1(&sss[N_id_2], m0, m1),
sss_synch_subframe(m0, m1), peak_value[N_id_2],
frame_cnt,N_id_2, srslte_sss_synch_N_id_1(&sss[N_id_2], m0, m1),
srslte_sss_synch_subframe(m0, m1), peak_value[N_id_2],
peak_pos[N_id_2], m0, m1,
cfo[frame_cnt]);
}
@ -255,8 +255,8 @@ int main(int argc, char **argv) {
printf("Average CFO: %.3f\n", cfo_mean);
for (N_id_2=0;N_id_2<3;N_id_2++) {
pss_synch_free(&pss[N_id_2]);
sss_synch_free(&sss[N_id_2]);
srslte_pss_synch_free(&pss[N_id_2]);
srslte_sss_synch_free(&sss[N_id_2]);
}
srslte_filesource_free(&fsrc);

3
srslte/include/srslte/ch_estimation/chest_dl.h
Unescape Escape View File

@ -35,7 +35,6 @@
#include "srslte/config.h"
#include "srslte/resampling/interp.h"
#include "srslte/filter/filter2d.h"
#include "srslte/ch_estimation/refsignal_dl.h"
#include "srslte/common/phy_common.h"
@ -68,7 +67,7 @@ typedef struct {
cf_t *tmp_timeavg[SRSLTE_CHEST_MAX_FILTER_TIME_LEN];
cf_t *tmp_timeavg_mult;
srslte_interp_linvec_t srslte_interp_linvec;
srslte_interp_linsrslte_vec_t srslte_interp_linvec;
srslte_interp_lin_t srslte_interp_lin;
float rssi[SRSLTE_MAX_PORTS];

4
srslte/include/srslte/ch_estimation/refsignal_ul.h
Unescape Escape View File

@ -86,14 +86,14 @@ SRSLTE_API void srslte_refsignal_drms_pusch_put(srslte_refsignal_ul_t *q,
uint32_t n_prb[2],
cf_t *sf_symbols);
SRSLTE_API int srslte_refsignal_dmrs_pusch_gen(srslte_refsignal_ul_t *q,
SRSLTE_API int srslte_refsignal_dmrs_gen(srslte_refsignal_ul_t *q,
srslte_refsignal_drms_pusch_cfg_t *cfg,
uint32_t nof_prb,
uint32_t sf_idx,
cf_t *r_pusch);
SRSLTE_API int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q,
pucch_cfg_t *cfg,
srslte_pucch_cfg_t *cfg,
uint32_t sf_idx,
uint32_t n_rb,
cf_t *r_pucch) ;

17
srslte/include/srslte/common/phy_common.h
Unescape Escape View File

@ -147,11 +147,16 @@ typedef struct SRSLTE_API {
}srslte_cell_t;
typedef enum SRSLTE_API {
SINGLE_ANTENNA,TX_DIVERSITY, SPATIAL_MULTIPLEX
SRSLTE_MIMO_TYPE_SINGLE_ANTENNA,
SRSLTE_MIMO_TYPE_TX_DIVERSITY,
SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX
} srslte_mimo_type_t;
typedef enum SRSLTE_API {
LTE_BPSK = 0, LTE_QPSK = 1, LTE_QAM16 = 2, LTE_QAM64 = 3
SRSLTE_MOD_BPSK = 0,
SRSLTE_MOD_QPSK,
SRSLTE_MOD_16QAM,
SRSLTE_MOD_64QAM
} srslte_mod_t;
typedef struct SRSLTE_API {
@ -160,7 +165,13 @@ typedef struct SRSLTE_API {
} srslte_earfcn_t;
enum band_geographical_area {
ALL, NAR, APAC, EMEA, JAPAN, CALA, NA
SRSLTE_BAND_GEO_AREA_ALL,
SRSLTE_BAND_GEO_AREA_NAR,
SRSLTE_BAND_GEO_AREA_APAC,
SRSLTE_BAND_GEO_AREA_EMEA,
SRSLTE_BAND_GEO_AREA_JAPAN,
SRSLTE_BAND_GEO_AREA_CALA,
SRSLTE_BAND_GEO_AREA_NA
};
SRSLTE_API bool srslte_cell_isvalid(srslte_cell_t *cell);

63
srslte/include/srslte/utils/dft.h → srslte/include/srslte/dft/dft.h
Unescape Escape View File

@ -46,12 +46,12 @@
*/
typedef enum {
COMPLEX, REAL
}dft_mode_t;
SRSLTE_DFT_COMPLEX, SRSLTE_REAL
}srslte_dft_mode_t;
typedef enum {
FORWARD, BACKWARD
}dft_dir_t;
SRSLTE_DFT_FORWARD, SRSLTE_DFT_BACKWARD
}srslte_dft_dir_t;
typedef struct SRSLTE_API {
int size; // DFT length
@ -63,33 +63,56 @@ typedef struct SRSLTE_API {
bool db; // Provide output in dB?
bool norm; // Normalize output?
bool dc; // Handle insertion/removal of null DC carrier internally?
dft_dir_t dir; // Forward/Backward
dft_mode_t mode; // Complex/Real
srslte_dft_dir_t dir; // Forward/Backward
srslte_dft_mode_t mode; // Complex/Real
}srslte_dft_plan_t;
typedef _Complex float dft_c_t;
typedef float dft_r_t;
typedef _Complex float cf_t;
/* Create DFT plans */
SRSLTE_API int dft_plan(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir,
dft_mode_t type);
SRSLTE_API int dft_plan_c(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir);
SRSLTE_API int dft_plan_r(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir);
SRSLTE_API void dft_plan_free(srslte_dft_plan_t *plan);
SRSLTE_API int srslte_dft_plan(srslte_dft_plan_t *plan,
int dft_points,
srslte_dft_dir_t dir,
srslte_dft_mode_t type);
SRSLTE_API int srslte_dft_plan_c(srslte_dft_plan_t *plan,
int dft_points,
srslte_dft_dir_t dir);
SRSLTE_API int srslte_dft_plan_r(srslte_dft_plan_t *plan,
int dft_points,
srslte_dft_dir_t dir);
SRSLTE_API void srslte_dft_plan_free(srslte_dft_plan_t *plan);
/* Set options */
SRSLTE_API void dft_plan_set_mirror(srslte_dft_plan_t *plan, bool val);
SRSLTE_API void dft_plan_set_db(srslte_dft_plan_t *plan, bool val);
SRSLTE_API void dft_plan_set_norm(srslte_dft_plan_t *plan, bool val);
SRSLTE_API void dft_plan_set_dc(srslte_dft_plan_t *plan, bool val);
SRSLTE_API void srslte_dft_plan_set_mirror(srslte_dft_plan_t *plan,
bool val);
SRSLTE_API void srslte_dft_plan_set_db(srslte_dft_plan_t *plan,
bool val);
SRSLTE_API void srslte_dft_plan_set_norm(srslte_dft_plan_t *plan,
bool val);
SRSLTE_API void srslte_dft_plan_set_dc(srslte_dft_plan_t *plan,
bool val);
/* Compute DFT */
SRSLTE_API void dft_run(srslte_dft_plan_t *plan, void *in, void *out);
SRSLTE_API void dft_run_c(srslte_dft_plan_t *plan, dft_c_t *in, dft_c_t *out);
SRSLTE_API void dft_run_r(srslte_dft_plan_t *plan, dft_r_t *in, dft_r_t *out);
SRSLTE_API void srslte_dft_run(srslte_dft_plan_t *plan,
void *in,
void *out);
SRSLTE_API void srslte_dft_run_c(srslte_dft_plan_t *plan,
cf_t *in,
cf_t *out);
SRSLTE_API void srslte_dft_run_r(srslte_dft_plan_t *plan,
float *in,
float *out);
#endif // DFT_H_

14
srslte/include/srslte/filter/dft_precoding.h → srslte/include/srslte/dft/dft_precoding.h
Unescape Escape View File

@ -31,7 +31,7 @@
#include "srslte/config.h"
#include "srslte/common/phy_common.h"
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
typedef _Complex float cf_t;
@ -42,22 +42,22 @@ typedef struct SRSLTE_API {
srslte_dft_plan_t dft_plan[SRSLTE_MAX_PRB];
srslte_dft_plan_t idft_plan[SRSLTE_MAX_PRB];
}srslte_srslte_dft_precoding_t;
}srslte_dft_precoding_t;
SRSLTE_API int srslte_srslte_dft_precoding_init(srslte_srslte_dft_precoding_t *q,
SRSLTE_API int srslte_dft_precoding_init(srslte_dft_precoding_t *q,
uint32_t max_prb);
SRSLTE_API void srslte_srslte_dft_precoding_free(srslte_srslte_dft_precoding_t *q);
SRSLTE_API void srslte_dft_precoding_free(srslte_dft_precoding_t *q);
SRSLTE_API bool srslte_srslte_dft_precoding_valid_prb(uint32_t nof_prb);
SRSLTE_API bool srslte_dft_precoding_valid_prb(uint32_t nof_prb);
SRSLTE_API int srslte_dft_precoding(srslte_srslte_dft_precoding_t *q,
SRSLTE_API int srslte_dft_precoding(srslte_dft_precoding_t *q,
cf_t *input,
cf_t *output,
uint32_t nof_prb,
uint32_t nof_symbols);
SRSLTE_API int srslte_dft_predecoding(srslte_srslte_dft_precoding_t *q,
SRSLTE_API int srslte_dft_predecoding(srslte_dft_precoding_t *q,
cf_t *input,
cf_t *output,
uint32_t nof_prb,

30
srslte/include/srslte/common/fft.h → srslte/include/srslte/dft/ofdm.h
Unescape Escape View File

@ -35,7 +35,7 @@
#include "srslte/config.h"
#include "srslte/common/phy_common.h"
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
typedef _Complex float cf_t; /* this is only a shortcut */
@ -52,40 +52,42 @@ typedef struct SRSLTE_API{
bool freq_shift;
cf_t *shift_buffer;
}srslte_fft_t;
}srslte_ofdm_t;
SRSLTE_API int srslte_fft_init(srslte_fft_t *q,
SRSLTE_API int srslte_ofdm_tx_init(srslte_ofdm_t *q,
srslte_cp_t cp_type,
uint32_t nof_prb);
SRSLTE_API void srslte_fft_free(srslte_fft_t *q);
SRSLTE_API void srslte_ofdm_tx_free(srslte_ofdm_t *q);
SRSLTE_API void srslte_fft_run_slot(srslte_fft_t *q,
SRSLTE_API void srslte_ofdm_tx_slot(srslte_ofdm_t *q,
cf_t *input,
cf_t *output);
SRSLTE_API void srslte_fft_run_sf(srslte_fft_t *q,
SRSLTE_API void srslte_ofdm_tx_sf(srslte_ofdm_t *q,
cf_t *input,
cf_t *output);
SRSLTE_API int lte_ifft_init(srslte_fft_t *q,
srslte_cp_t cp_type,
uint32_t nof_prb);
SRSLTE_API void lte_ifft_free(srslte_fft_t *q);
SRSLTE_API void lte_ifft_run_slot(srslte_fft_t *q,
SRSLTE_API int srslte_ofdm_rx_init(srslte_ofdm_t *q,
srslte_cp_t cp_type,
uint32_t nof_prb);
SRSLTE_API void srslte_ofdm_rx_free(srslte_ofdm_t *q);
SRSLTE_API void srslte_ofdm_rx_slot(srslte_ofdm_t *q,
cf_t *input,
cf_t *output);
SRSLTE_API void lte_ifft_run_sf(srslte_fft_t *q,
SRSLTE_API void srslte_ofdm_rx_sf(srslte_ofdm_t *q,
cf_t *input,
cf_t *output);
SRSLTE_API int srslte_fft_set_freq_shift(srslte_fft_t *q,
SRSLTE_API int srslte_ofdm_set_freq_shift(srslte_ofdm_t *q,
float freq_shift);
SRSLTE_API void srslte_fft_set_normalize(srslte_fft_t *q,
SRSLTE_API void srslte_ofdm_set_normalize(srslte_ofdm_t *q,
bool normalize_enable);
#endif

80
srslte/include/srslte/filter/filter2d.h
Unescape Escape View File

@ -1,80 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2014 The srsLTE Developers. See the
* COPYRIGHT file at the top-level directory of this distribution.
*
* \section LICENSE
*
* This file is part of the srsLTE library.
*
* srsLTE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsLTE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* A copy of the GNU Lesser General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#ifndef FILTER2D_
#define FILTER2D_
#include "srslte/config.h"
#include <stdint.h>
/* 2-D real filter of complex input
*
*/
typedef _Complex float cf_t;
typedef struct SRSLTE_API{
uint32_t sztime; // Output signal size in the time domain
uint32_t szfreq; // Output signal size in the freq domain
uint32_t ntime; // 2-D Filter size in time domain
uint32_t nfreq; // 2-D Filter size in frequency domain
float **taps; // 2-D filter coefficients
float norm; //normalization factor
cf_t *output; // Output signal
} srslte_filter2d_t;
SRSLTE_API int srslte_filter2d_init (srslte_filter2d_t* q,
float **taps,
uint32_t ntime,
uint32_t nfreq,
uint32_t sztime,
uint32_t szfreq);
SRSLTE_API int srslte_filter2d_init_ones (srslte_filter2d_t* q,
uint32_t ntime,
uint32_t nfreq,
uint32_t sztime,
uint32_t szfreq);
SRSLTE_API void srslte_filter2d_free(srslte_filter2d_t *q);
SRSLTE_API void srslte_filter2d_step(srslte_filter2d_t *q);
SRSLTE_API void srslte_filter2d_reset(srslte_filter2d_t *q);
SRSLTE_API void srslte_filter2d_add(srslte_filter2d_t *q,
cf_t h,
uint32_t time_idx,
uint32_t freq_idx);
SRSLTE_API void srslte_filter2d_add_out(srslte_filter2d_t *q, cf_t x, int time_idx, int freq_idx);
SRSLTE_API void srslte_filter2d_get_symbol(srslte_filter2d_t *q,
uint32_t nsymbol,
cf_t *output);
#endif // FILTER2D_

91
srslte/include/srslte/mimo/precoding.h
Unescape Escape View File

@ -29,6 +29,7 @@
#define PRECODING_H_
#include "srslte/config.h"
#include "srslte/common/phy_common.h"
typedef _Complex float cf_t;
@ -47,59 +48,59 @@ typedef struct {
float *z_real;
float *z_imag;
uint32_t max_frame_len;
}precoding_t;
} srslte_precoding_t;
SRSLTE_API int precoding_init(precoding_t *q,
uint32_t max_frame_len);
SRSLTE_API int srslte_precoding_init(srslte_precoding_t *q,
uint32_t max_frame_len);
SRSLTE_API void precoding_free(precoding_t *q);
SRSLTE_API void srslte_precoding_free(srslte_precoding_t *q);
/* Generates the vector "y" from the input vector "x"
*/
SRSLTE_API int precoding_single(precoding_t *q,
cf_t *x,
cf_t *y,
int nof_symbols);
SRSLTE_API int precoding_diversity(precoding_t *q,
cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *y[SRSLTE_MAX_PORTS],
int nof_ports, int nof_symbols);
SRSLTE_API int precoding_type(precoding_t *q,
cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *y[SRSLTE_MAX_PORTS],
int nof_layers,
int nof_ports,
int nof_symbols,
srslte_mimo_type_t type);
SRSLTE_API int srslte_precoding_single(srslte_precoding_t *q,
cf_t *x,
cf_t *y,
int nof_symbols);
SRSLTE_API int srslte_precoding_diversity(srslte_precoding_t *q,
cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *y[SRSLTE_MAX_PORTS],
int nof_ports, int nof_symbols);
SRSLTE_API int srslte_precoding_type(srslte_precoding_t *q,
cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *y[SRSLTE_MAX_PORTS],
int nof_layers,
int nof_ports,
int nof_symbols,
srslte_mimo_type_t type);
/* Estimates the vector "x" based on the received signal "y" and the channel estimates "h"
*/
SRSLTE_API int predecoding_single(precoding_t *q,
cf_t *y,
cf_t *h,
cf_t *x,
int nof_symbols,
float noise_estimate);
SRSLTE_API int predecoding_diversity(precoding_t *q,
cf_t *y,
cf_t *h[SRSLTE_MAX_PORTS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports,
int nof_symbols,
float noise_estimate);
SRSLTE_API int predecoding_type(precoding_t *q,
cf_t *y,
cf_t *h[SRSLTE_MAX_PORTS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports,
int nof_layers,
int nof_symbols,
srslte_mimo_type_t type,
float noise_estimate);
SRSLTE_API int srslte_predecoding_single(srslte_precoding_t *q,
cf_t *y,
cf_t *h,
cf_t *x,
int nof_symbols,
float noise_estimate);
SRSLTE_API int srslte_predecoding_diversity(srslte_precoding_t *q,
cf_t *y,
cf_t *h[SRSLTE_MAX_PORTS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports,
int nof_symbols,
float noise_estimate);
SRSLTE_API int srslte_predecoding_type(srslte_precoding_t *q,
cf_t *y,
cf_t *h[SRSLTE_MAX_PORTS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports,
int nof_layers,
int nof_symbols,
srslte_mimo_type_t type,
float noise_estimate);
#endif /* PRECODING_H_ */

24
srslte/include/srslte/modem/demod_hard.h
Unescape Escape View File

@ -39,19 +39,23 @@ typedef _Complex float cf_t;
typedef struct SRSLTE_API {
srslte_mod_t mod; /* In this implementation, mapping table is hard-coded */
}demod_hard_t;
}srslte_demod_hard_t;
SRSLTE_API void demod_hard_init(demod_hard_t* q);
SRSLTE_API void demod_hard_table_set(demod_hard_t* q, srslte_mod_t mod);
SRSLTE_API int demod_hard_demodulate(demod_hard_t* q, cf_t* symbols, uint8_t *bits, uint32_t nsymbols);
SRSLTE_API void srslte_demod_hard_init(srslte_demod_hard_t* q);
SRSLTE_API void srslte_demod_hard_table_set(srslte_demod_hard_t* q,
srslte_mod_t mod);
SRSLTE_API int srslte_demod_hard_demodulate(srslte_demod_hard_t* q,
cf_t* symbols,
uint8_t *bits,
uint32_t nsymbols);
/* High-level API */
typedef struct SRSLTE_API {
demod_hard_t obj;
struct demod_hard_init {
srslte_demod_hard_t obj;
struct srslte_demod_hard_init {
srslte_mod_t std; // Symbol mapping standard (see modem_table.h)
} init;
@ -60,11 +64,11 @@ typedef struct SRSLTE_API {
uint8_t* output;
int out_len;
}demod_hard_hl;
}srslte_demod_hard_hl;
SRSLTE_API int demod_hard_initialize(demod_hard_hl* hl);
SRSLTE_API int demod_hard_work(demod_hard_hl* hl);
SRSLTE_API int demod_hard_stop(demod_hard_hl* hl);
SRSLTE_API int srslte_demod_hard_initialize(srslte_demod_hard_hl* hl);
SRSLTE_API int srslte_demod_hard_work(srslte_demod_hard_hl* hl);
SRSLTE_API int srslte_demod_hard_stop(srslte_demod_hard_hl* hl);
#endif // DEMOD_HARD_

53
srslte/include/srslte/modem/demod_soft.h
Unescape Escape View File

@ -35,50 +35,65 @@
#include "srslte/config.h"
#include "modem_table.h"
enum alg { EXACT, APPROX };
typedef enum SRSLTE_API {
SRSLTE_DEMOD_SOFT_ALG_EXACT,
SRSLTE_DEMOD_SOFT_ALG_APPROX
} srslte_demod_soft_alg_t;
typedef struct SRSLTE_API {
float sigma; // noise power
enum alg alg_type; // soft demapping algorithm (EXACT or APPROX)
modem_table_t *table; // symbol mapping table (see modem_table.h)
srslte_demod_soft_alg_t alg_type; // soft demapping algorithm (SRSLTE_DEMOD_SOFT_ALG_EXACT or SRSLTE_DEMOD_SOFT_ALG_APPROX)
srslte_srslte_modem_table_t *table; // symbol mapping table (see modem_table.h)
uint32_t *zones;
float *dd;
uint32_t max_symbols;
}demod_soft_t;
} srslte_demod_soft_t;
SRSLTE_API int demod_soft_init(demod_soft_t *q, uint32_t max_symbols);
SRSLTE_API void demod_soft_free(demod_soft_t *q);
SRSLTE_API void demod_soft_table_set(demod_soft_t *q, modem_table_t *table);
SRSLTE_API void demod_soft_alg_set(demod_soft_t *q, enum alg alg_type);
SRSLTE_API void demod_soft_sigma_set(demod_soft_t *q, float sigma);
SRSLTE_API int demod_soft_demodulate(demod_soft_t *q, const cf_t* symbols, float* llr, int nsymbols);
SRSLTE_API int srslte_demod_soft_init(srslte_demod_soft_t *q,
uint32_t max_symbols);
SRSLTE_API void srslte_demod_soft_free(srslte_demod_soft_t *q);
SRSLTE_API void srslte_demod_soft_table_set(srslte_demod_soft_t *q,
srslte_srslte_modem_table_t *table);
SRSLTE_API void srslte_demod_soft_alg_set(srslte_demod_soft_t *q,
srslte_demod_soft_alg_t alg_type);
SRSLTE_API void srslte_demod_soft_sigma_set(srslte_demod_soft_t *q,
float sigma);
SRSLTE_API int srslte_demod_soft_demodulate(srslte_demod_soft_t *q,
const cf_t* symbols,
float* llr,
int nsymbols);
/* High-level API */
typedef struct SRSLTE_API {
demod_soft_t obj;
modem_table_t table;
srslte_demod_soft_t obj;
srslte_srslte_modem_table_t table;
struct demod_soft_init{
struct srslte_demod_soft_init{
srslte_mod_t std; // symbol mapping standard (see modem_table.h)
} init;
const cf_t* input;
int in_len;
struct demod_soft_ctrl_in {
struct srslte_demod_soft_ctrl_in {
float sigma; // Estimated noise variance
enum alg alg_type; // soft demapping algorithm (EXACT or APPROX)
srslte_demod_soft_alg_t alg_type; // soft demapping algorithm (SRSLTE_DEMOD_SOFT_ALG_EXACT or SRSLTE_DEMOD_SOFT_ALG_APPROX)
}ctrl_in;
float* output;
int out_len;
}demod_soft_hl;
}srslte_demod_soft_hl;
SRSLTE_API int demod_soft_initialize(demod_soft_hl* hl);
SRSLTE_API int demod_soft_work(demod_soft_hl* hl);
SRSLTE_API int demod_soft_stop(demod_soft_hl* hl);
SRSLTE_API int srslte_demod_soft_initialize(srslte_demod_soft_hl* hl);
SRSLTE_API int srslte_demod_soft_work(srslte_demod_soft_hl* hl);
SRSLTE_API int srslte_demod_soft_stop(srslte_demod_soft_hl* hl);
#endif // DEMOD_SOFT_

17
srslte/include/srslte/modem/mod.h
Unescape Escape View File

@ -37,24 +37,27 @@
typedef _Complex float cf_t;
SRSLTE_API int mod_modulate(modem_table_t* table, const uint8_t *bits, cf_t* symbols, uint32_t nbits);
SRSLTE_API int srslte_mod_modulate(srslte_srslte_modem_table_t* table,
uint8_t *bits,
cf_t* symbols,
uint32_t nbits);
/* High-level API */
typedef struct SRSLTE_API {
modem_table_t obj;
srslte_srslte_modem_table_t obj;
struct mod_init {
srslte_mod_t std; // symbol mapping standard (see modem_table.h)
} init;
const uint8_t* input;
uint8_t* input;
int in_len;
cf_t* output;
int out_len;
}mod_hl;
}srslte_mod_hl;
SRSLTE_API int mod_initialize(mod_hl* hl);
SRSLTE_API int mod_work(mod_hl* hl);
SRSLTE_API int mod_stop(mod_hl* hl);
SRSLTE_API int mod_initialize(srslte_mod_hl* hl);
SRSLTE_API int mod_work(srslte_mod_hl* hl);
SRSLTE_API int mod_stop(srslte_mod_hl* hl);
#endif // MOD_

28
srslte/include/srslte/modem/modem_table.h
Unescape Escape View File

@ -43,30 +43,30 @@ typedef struct SRSLTE_API {
uint32_t min_idx[2][64][6]; /* NEW: for each constellation point zone (2, 4, 16, 64 for BPSK, QPSK, 16QAM, 64QAM) the 2x(1, 2, 4, and 6 closest constellation points) for each bit, respectively. */
uint32_t d_idx[64][7]; /* NEW: for each constellation point zone (2, 4, 16, 64 for BPSK, QPSK, 16QAM, 64QAM) the 2, 3, 5 and 7 indices to constellation points that need to be computed for any recevied symbol modulated as BPSK, QPSK, 16QAM, and 64QAM, respectively. */
}soft_table_t;
}srslte_soft_table_t;
typedef struct SRSLTE_API {
cf_t* symbol_table; // bit-to-symbol mapping
soft_table_t soft_table; // symbol-to-bit mapping (used in soft demodulating)
srslte_soft_table_t soft_table; // symbol-to-bit mapping (used in soft demodulating)
uint32_t nsymbols; // number of modulation symbols
uint32_t nbits_x_symbol; // number of bits per symbol
}modem_table_t;
}srslte_srslte_modem_table_t;
SRSLTE_API void modem_table_init(modem_table_t* q);
SRSLTE_API void srslte_modem_table_init(srslte_srslte_modem_table_t* q);
SRSLTE_API void modem_table_free(modem_table_t* q);
SRSLTE_API void srslte_modem_table_free(srslte_srslte_modem_table_t* q);
SRSLTE_API void modem_table_reset(modem_table_t* q);
SRSLTE_API void srslte_modem_table_reset(srslte_srslte_modem_table_t* q);
SRSLTE_API int modem_table_set(modem_table_t* q,
cf_t* table,
soft_table_t *soft_table,
uint32_t nsymbols,
uint32_t nbits_x_symbol);
SRSLTE_API int srslte_modem_table_set(srslte_srslte_modem_table_t* q,
cf_t* table,
srslte_soft_table_t *soft_table,
uint32_t nsymbols,
uint32_t nbits_x_symbol);
SRSLTE_API int modem_table_lte(modem_table_t* q,
srslte_mod_t modulation,
bool compute_soft_demod);
SRSLTE_API int srslte_modem_table_lte(srslte_srslte_modem_table_t* q,
srslte_mod_t modulation,
bool compute_soft_demod);
#endif // MODEM_TABLE_

16
srslte/include/srslte/phch/cqi.h
Unescape Escape View File

@ -46,7 +46,7 @@ transmission mode 8 configured without PMI/RI reporting). */
typedef struct SRSLTE_API {
uint8_t wideband_cqi; // 4-bit width
uint32_t subband_diff_cqi; // 2N-bit width
} cqi_hl_subband_t;
} srslte_cqi_hl_subband_t;
/* Table 5.2.2.6.3-1: Fields for channel quality information feedback for UE selected subband CQI
reports
@ -56,7 +56,7 @@ typedef struct SRSLTE_API {
uint8_t wideband_cqi; // 4-bit width
uint8_t subband_diff_cqi; // 2-bit width
uint32_t position_subband; // L-bit width
} cqi_ue_subband_t;
} srslte_cqi_ue_subband_t;
/* Table 5.2.3.3.1-1: Fields for channel quality information feedback for wideband CQI reports
(transmission mode 1, transmission mode 2, transmission mode 3, transmission mode 7 and
@ -65,29 +65,29 @@ This is for PUCCH Format 2 reports
*/
typedef struct SRSLTE_API {
uint8_t wideband_cqi; // 4-bit width
} cqi_format2_wideband_t;
} srslte_cqi_format2_wideband_t;
typedef struct SRSLTE_API {
uint8_t subband_cqi; // 4-bit width
uint8_t subband_label; // 1- or 2-bit width
} cqi_format2_subband_t;
} srslte_cqi_format2_subband_t;
SRSLTE_API int cqi_hl_subband_pack(cqi_hl_subband_t *msg,
SRSLTE_API int srslte_cqi_hl_subband_pack(srslte_cqi_hl_subband_t *msg,
uint32_t N,
uint8_t *buff,
uint32_t buff_len);
SRSLTE_API int cqi_ue_subband_pack(cqi_ue_subband_t *msg,
SRSLTE_API int srslte_cqi_ue_subband_pack(srslte_cqi_ue_subband_t *msg,
uint32_t L,
uint8_t *buff,
uint32_t buff_len);
SRSLTE_API int cqi_format2_wideband_pack(cqi_format2_wideband_t *msg,
SRSLTE_API int srslte_cqi_format2_wideband_pack(srslte_cqi_format2_wideband_t *msg,
uint8_t *buff,
uint32_t buff_len);
SRSLTE_API int cqi_format2_subband_pack(cqi_format2_subband_t *msg,
SRSLTE_API int srslte_cqi_format2_subband_pack(srslte_cqi_format2_subband_t *msg,
uint8_t *buff,
uint32_t buff_len);

141
srslte/include/srslte/phch/dci.h
Unescape Escape View File

@ -46,91 +46,100 @@ typedef _Complex float cf_t;
#define DCI_MAX_BITS 57
typedef enum {
Format0, Format1, Format1A, Format1C, FormatError
} dci_format_t;
SRSLTE_DCI_FORMAT0,
SRSLTE_DCI_FORMAT1,
SRSLTE_DCI_FORMAT1A,
SRSLTE_DCI_FORMAT1C,
SRSLTE_DCI_FORMAT_ERROR
} srslte_dci_format_t;
// Each type is for a different interface to packing/unpacking functions
typedef struct SRSLTE_API {
enum {
PUSCH_SCHED, PDSCH_SCHED, MCCH_CHANGE, TPC_COMMAND, RA_PROC_PDCCH
SRSLTE_DCI_MSG_TYPE_PUSCH_SCHED,
SRSLTE_DCI_MSG_TYPE_PDSCH_SCHED,
SRSLTE_DCI_MSG_TYPE_MCCH_CHANGE,
SRSLTE_DCI_MSG_TYPE_TPC_COMMAND,
SRSLTE_DCI_MSG_TYPE_RA_PROC_PDCCH
} type;
dci_format_t format;
}dci_msg_type_t;
srslte_dci_format_t format;
}srslte_dci_msg_type_t;
typedef enum {
DCI_COMMON = 0, DCI_UE = 1
SRSLTE_DCI_SPEC_COMMON_ = 0,
SRSLTE_DCI_SPEC_UE = 1
} dci_spec_t;
typedef struct SRSLTE_API {
uint32_t L; // Aggregation level
uint32_t ncce; // Position of first CCE of the dci
} dci_location_t;
} srslte_dci_location_t;
typedef struct SRSLTE_API {
uint8_t data[DCI_MAX_BITS];
uint32_t nof_bits;
} dci_msg_t;
} srslte_dci_msg_t;
/* Converts a received PDSCH DL scheduling DCI message
* to ra structures ready to be passed to the harq setup function
*/
SRSLTE_API int dci_msg_to_ra_dl(dci_msg_t *msg,
uint16_t msg_rnti,
srslte_cell_t cell,
uint32_t cfi,
ra_pdsch_t *ra_dl);
SRSLTE_API int dci_msg_to_ra_ul(dci_msg_t *msg,
uint32_t nof_prb,
uint32_t n_rb_ho,
ra_pusch_t *ra_ul);
SRSLTE_API int dci_rar_to_ra_ul(uint32_t rba,
uint32_t trunc_mcs,
bool hopping_flag,
uint32_t nof_prb,
ra_pusch_t *ra);
SRSLTE_API dci_format_t dci_format_from_string(char *str);
SRSLTE_API char* dci_format_string(dci_format_t format);
SRSLTE_API int dci_location_set(dci_location_t *c,
uint32_t L,
uint32_t nCCE);
SRSLTE_API bool dci_location_isvalid(dci_location_t *c);
SRSLTE_API int dci_msg_get_type(dci_msg_t *msg,
dci_msg_type_t *type,
uint32_t nof_prb,
uint16_t msg_rnti);
SRSLTE_API void dci_msg_type_fprint(FILE *f,
dci_msg_type_t type);
// For dci_msg_type_t = PUSCH_SCHED
SRSLTE_API int dci_msg_pack_pusch(ra_pusch_t *data,
dci_msg_t *msg,
uint32_t nof_prb);
SRSLTE_API int dci_msg_unpack_pusch(dci_msg_t *msg,
ra_pusch_t *data,
uint32_t nof_prb);
// For dci_msg_type_t = PDSCH_SCHED
SRSLTE_API int dci_msg_pack_pdsch(ra_pdsch_t *data,
dci_msg_t *msg,
dci_format_t format,
uint32_t nof_prb,
bool srslte_crc_is_crnti);
SRSLTE_API int dci_msg_unpack_pdsch(dci_msg_t *msg,
ra_pdsch_t *data,
uint32_t nof_prb,
bool srslte_crc_is_crnti);
SRSLTE_API uint32_t dci_format_sizeof(dci_format_t format,
uint32_t nof_prb);
SRSLTE_API int srslte_dci_msg_to_ra_dl(srslte_dci_msg_t *msg,
uint16_t msg_rnti,
srslte_cell_t cell,
uint32_t cfi,
srslte_ra_pdsch_t *ra_dl);
SRSLTE_API int srslte_dci_msg_to_ra_ul(srslte_dci_msg_t *msg,
uint32_t nof_prb,
uint32_t n_rb_ho,
srslte_ra_pusch_t *ra_ul);
SRSLTE_API int srslte_dci_rar_to_ra_ul(uint32_t rba,
uint32_t trunc_mcs,
bool hopping_flag,
uint32_t nof_prb,
srslte_ra_pusch_t *ra);
SRSLTE_API srslte_dci_format_t srslte_dci_format_from_string(char *str);
SRSLTE_API char* srslte_dci_format_string(srslte_dci_format_t format);
SRSLTE_API int srslte_dci_location_set(srslte_dci_location_t *c,
uint32_t L,
uint32_t nCCE);
SRSLTE_API bool srslte_dci_location_isvalid(srslte_dci_location_t *c);
SRSLTE_API int srslte_dci_msg_get_type(srslte_dci_msg_t *msg,
srslte_dci_msg_type_t *type,
uint32_t nof_prb,
uint16_t msg_rnti);
SRSLTE_API void srslte_dci_msg_type_fprint(FILE *f,
srslte_dci_msg_type_t type);
// For srslte_dci_msg_type_t = SRSLTE_DCI_MSG_TYPE_PUSCH_SCHED
SRSLTE_API int srslte_dci_msg_pack_pusch(srslte_ra_pusch_t *data,
srslte_dci_msg_t *msg,
uint32_t nof_prb);
SRSLTE_API int srslte_dci_msg_unpack_pusch(srslte_dci_msg_t *msg,
srslte_ra_pusch_t *data,
uint32_t nof_prb);
// For srslte_dci_msg_type_t = SRSLTE_DCI_MSG_TYPE_PDSCH_SCHED
SRSLTE_API int srslte_dci_msg_pack_pdsch(srslte_ra_pdsch_t *data,
srslte_dci_msg_t *msg,
srslte_dci_format_t format,
uint32_t nof_prb,
bool srslte_crc_is_crnti);
SRSLTE_API int srslte_dci_msg_unpack_pdsch(srslte_dci_msg_t *msg,
srslte_ra_pdsch_t *data,
uint32_t nof_prb,
bool srslte_crc_is_crnti);
SRSLTE_API uint32_t srslte_dci_format_sizeof(srslte_dci_format_t format,
uint32_t nof_prb);
#endif // DCI_

46
srslte/include/srslte/phch/harq.h
Unescape Escape View File

@ -34,21 +34,21 @@
#include "srslte/phch/ra.h"
struct cb_segm {
typedef struct SRSLTE_API {
uint32_t F;
uint32_t C;
uint32_t K1;
uint32_t K2;
uint32_t C1;
uint32_t C2;
};
} srslte_harq_cbsegm_t;
typedef struct SRSLTE_API {
ra_mcs_t mcs;
srslte_ra_mcs_t mcs;
uint32_t rv;
uint32_t sf_idx;
ra_dl_alloc_t dl_alloc;
ra_ul_alloc_t ul_alloc;
srslte_srslte_ra_dl_alloc_t dl_alloc;
srslte_srslte_ra_ul_alloc_t ul_alloc;
srslte_cell_t cell;
uint32_t nof_re; // Number of RE per subframe
@ -61,31 +61,31 @@ typedef struct SRSLTE_API {
float **pdsch_w_buff_f;
uint8_t **pdsch_w_buff_c;
struct cb_segm cb_segm;
srslte_harq_cbsegm_t cb_segm;
} harq_t;
} srslte_harq_t;
SRSLTE_API int harq_init(harq_t * q,
srslte_cell_t cell);
SRSLTE_API int srslte_harq_init(srslte_harq_t * q,
srslte_cell_t cell);
SRSLTE_API int harq_setup_dl(harq_t *p,
ra_mcs_t mcs,
uint32_t rv,
uint32_t sf_idx,
ra_dl_alloc_t *prb_alloc);
SRSLTE_API int srslte_harq_setup_dl(srslte_harq_t *p,
srslte_ra_mcs_t mcs,
uint32_t rv,
uint32_t sf_idx,
srslte_srslte_ra_dl_alloc_t *prb_alloc);
SRSLTE_API int harq_setup_ul(harq_t *p,
ra_mcs_t mcs,
uint32_t rv,
uint32_t sf_idx,
ra_ul_alloc_t *prb_alloc);
SRSLTE_API int srslte_harq_setup_ul(srslte_harq_t *p,
srslte_ra_mcs_t mcs,
uint32_t rv,
uint32_t sf_idx,
srslte_srslte_ra_ul_alloc_t *prb_alloc);
SRSLTE_API void harq_reset(harq_t *p);
SRSLTE_API void srslte_harq_reset(srslte_harq_t *p);
SRSLTE_API void harq_free(harq_t *p);
SRSLTE_API void srslte_harq_free(srslte_harq_t *p);
SRSLTE_API int codeblock_segmentation(struct cb_segm *s,
uint32_t tbs);
SRSLTE_API int srslte_harq_codeblock_segmentation(srslte_harq_cbsegm_t *s,
uint32_t tbs);
#endif

38
srslte/include/srslte/phch/pbch.h
Unescape Escape View File

@ -58,34 +58,34 @@ typedef struct SRSLTE_API {
/* buffers */
cf_t *ce[SRSLTE_MAX_PORTS];
cf_t *pbch_symbols[SRSLTE_MAX_PORTS];
cf_t *pbch_x[SRSLTE_MAX_PORTS];
cf_t *pbch_d;
float *pbch_llr;
cf_t *symbols[SRSLTE_MAX_PORTS];
cf_t *x[SRSLTE_MAX_PORTS];
cf_t *d;
float *llr;
float *temp;
float pbch_rm_f[BCH_ENCODED_LEN];
uint8_t *pbch_rm_b;
float rm_f[BCH_ENCODED_LEN];
uint8_t *rm_b;
uint8_t data[BCH_PAYLOADCRC_LEN];
uint8_t data_enc[BCH_ENCODED_LEN];
uint32_t frame_idx;
/* tx & rx objects */
modem_table_t mod;
demod_soft_t demod;
srslte_sequence_t seq_pbch;
srslte_srslte_modem_table_t mod;
srslte_demod_soft_t demod;
srslte_sequence_t seq;
srslte_viterbi_t decoder;
srslte_crc_t crc;
srslte_convcoder_t encoder;
precoding_t precoding;
srslte_precoding_t precoding;
} pbch_t;
} srslte_pbch_t;
SRSLTE_API int pbch_init(pbch_t *q,
SRSLTE_API int srslte_pbch_init(srslte_pbch_t *q,
srslte_cell_t cell);
SRSLTE_API void pbch_free(pbch_t *q);
SRSLTE_API int pbch_decode(pbch_t *q,
SRSLTE_API void srslte_pbch_free(srslte_pbch_t *q);
SRSLTE_API int srslte_pbch_decode(srslte_pbch_t *q,
cf_t *slot1_symbols,
cf_t *ce_slot1[SRSLTE_MAX_PORTS],
float noise_estimate,
@ -93,21 +93,21 @@ SRSLTE_API int pbch_decode(pbch_t *q,
uint32_t *nof_tx_ports,
uint32_t *sfn_offset);
SRSLTE_API int pbch_encode(pbch_t *q,
SRSLTE_API int srslte_pbch_encode(srslte_pbch_t *q,
uint8_t bch_payload[BCH_PAYLOAD_LEN],
cf_t *slot1_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API void pbch_decode_reset(pbch_t *q);
SRSLTE_API void srslte_pbch_decode_reset(srslte_pbch_t *q);
SRSLTE_API void pbch_mib_unpack(uint8_t *msg,
SRSLTE_API void srslte_pbch_mib_unpack(uint8_t *msg,
srslte_cell_t *cell,
uint32_t *sfn);
SRSLTE_API void pbch_mib_pack(srslte_cell_t *cell,
SRSLTE_API void srslte_pbch_mib_pack(srslte_cell_t *cell,
uint32_t sfn,
uint8_t *msg);
SRSLTE_API void pbch_mib_fprint(FILE *stream,
SRSLTE_API void srslte_pbch_mib_fprint(FILE *stream,
srslte_cell_t *cell,
uint32_t sfn,
uint32_t cell_id);

28
srslte/include/srslte/phch/pcfich.h
Unescape Escape View File

@ -48,13 +48,13 @@ typedef struct SRSLTE_API {
int nof_symbols;
/* handler to REGs resource mapper */
regs_t *regs;
srslte_regs_t *regs;
/* buffers */
cf_t ce[SRSLTE_MAX_PORTS][PCFICH_RE];
cf_t pcfich_symbols[SRSLTE_MAX_PORTS][PCFICH_RE];
cf_t pcfich_x[SRSLTE_MAX_PORTS][PCFICH_RE];
cf_t pcfich_d[PCFICH_RE];
cf_t symbols[SRSLTE_MAX_PORTS][PCFICH_RE];
cf_t x[SRSLTE_MAX_PORTS][PCFICH_RE];
cf_t d[PCFICH_RE];
// cfi table in floats
float cfi_table_float[3][PCFICH_CFI_LEN];
@ -66,20 +66,20 @@ typedef struct SRSLTE_API {
float data_f[PCFICH_CFI_LEN];
/* tx & rx objects */
modem_table_t mod;
demod_soft_t demod;
srslte_sequence_t seq_pcfich[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding;
srslte_srslte_modem_table_t mod;
srslte_demod_soft_t demod;
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_precoding_t precoding;
} pcfich_t;
} srslte_pcfich_t;
SRSLTE_API int pcfich_init(pcfich_t *q,
regs_t *regs,
SRSLTE_API int srslte_pcfich_init(srslte_pcfich_t *q,
srslte_regs_t *regs,
srslte_cell_t cell);
SRSLTE_API void pcfich_free(pcfich_t *q);
SRSLTE_API void srslte_pcfich_free(srslte_pcfich_t *q);
SRSLTE_API int pcfich_decode(pcfich_t *q,
SRSLTE_API int srslte_pcfich_decode(srslte_pcfich_t *q,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
@ -87,7 +87,7 @@ SRSLTE_API int pcfich_decode(pcfich_t *q,
uint32_t *cfi,
float *corr_result);
SRSLTE_API int pcfich_encode(pcfich_t *q,
SRSLTE_API int srslte_pcfich_encode(srslte_pcfich_t *q,
uint32_t cfi,
cf_t *sf_symbols[SRSLTE_MAX_PORTS],
uint32_t subframe);

98
srslte/include/srslte/phch/pdcch.h
Unescape Escape View File

@ -47,7 +47,7 @@ typedef _Complex float cf_t;
typedef enum SRSLTE_API {
SEARCH_UE, SEARCH_COMMON
} pdcch_search_mode_t;
} srslte_pdcch_search_mode_t;
/* PDCCH object */
@ -57,70 +57,70 @@ typedef struct SRSLTE_API {
uint32_t nof_cce;
uint32_t max_bits;
regs_t *regs;
srslte_regs_t *regs;
/* buffers */
cf_t *ce[SRSLTE_MAX_PORTS];
cf_t *pdcch_symbols[SRSLTE_MAX_PORTS];
cf_t *pdcch_x[SRSLTE_MAX_PORTS];
cf_t *pdcch_d;
uint8_t *pdcch_e;
float pdcch_rm_f[3 * (DCI_MAX_BITS + 16)];
float *pdcch_llr;
cf_t *symbols[SRSLTE_MAX_PORTS];
cf_t *x[SRSLTE_MAX_PORTS];
cf_t *d;
uint8_t *e;
float rm_f[3 * (DCI_MAX_BITS + 16)];
float *llr;
/* tx & rx objects */
modem_table_t mod;
demod_soft_t demod;
srslte_sequence_t seq_pdcch[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_srslte_modem_table_t mod;
srslte_demod_soft_t demod;
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_viterbi_t decoder;
srslte_crc_t crc;
precoding_t precoding;
srslte_precoding_t precoding;
} pdcch_t;
} srslte_pdcch_t;
SRSLTE_API int pdcch_init(pdcch_t *q,
regs_t *regs,
srslte_cell_t cell);
SRSLTE_API int srslte_pdcch_init(srslte_pdcch_t *q,
srslte_regs_t *regs,
srslte_cell_t cell);
SRSLTE_API void pdcch_free(pdcch_t *q);
SRSLTE_API void srslte_pdcch_free(srslte_pdcch_t *q);
/* Encoding function */
SRSLTE_API int pdcch_encode(pdcch_t *q,
dci_msg_t *msg,
dci_location_t location,
uint16_t rnti,
cf_t *sf_symbols[SRSLTE_MAX_PORTS],
uint32_t nsubframe,
uint32_t cfi);
/* Decoding functions: Extract the LLRs and save them in the pdcch_t object */
SRSLTE_API int pdcch_extract_llr(pdcch_t *q,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint32_t nsubframe,
uint32_t cfi);
/* Decoding functions: Try to decode a DCI message after calling pdcch_extract_llr */
SRSLTE_API int pdcch_decode_msg(pdcch_t *q,
dci_msg_t *msg,
dci_location_t *location,
dci_format_t format,
uint16_t *srslte_crc_rem);
SRSLTE_API int srslte_pdcch_encode(srslte_pdcch_t *q,
srslte_dci_msg_t *msg,
srslte_dci_location_t location,
uint16_t rnti,
cf_t *sf_symbols[SRSLTE_MAX_PORTS],
uint32_t nsubframe,
uint32_t cfi);
/* Decoding functions: Extract the LLRs and save them in the srslte_pdcch_t object */
SRSLTE_API int srslte_pdcch_extract_llr(srslte_pdcch_t *q,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint32_t nsubframe,
uint32_t cfi);
/* Decoding functions: Try to decode a DCI message after calling srslte_pdcch_extract_llr */
SRSLTE_API int srslte_pdcch_decode_msg(srslte_pdcch_t *q,
srslte_dci_msg_t *msg,
srslte_dci_location_t *location,
srslte_dci_format_t format,
uint16_t *srslte_crc_rem);
/* Function for generation of UE-specific search space DCI locations */
SRSLTE_API uint32_t pdcch_ue_locations(pdcch_t *q,
dci_location_t *locations,
uint32_t max_locations,
uint32_t nsubframe,
uint32_t cfi,
uint16_t rnti);
SRSLTE_API uint32_t srslte_pdcch_ue_locations(srslte_pdcch_t *q,
srslte_dci_location_t *locations,
uint32_t max_locations,
uint32_t nsubframe,
uint32_t cfi,
uint16_t rnti);
/* Function for generation of common search space DCI locations */
SRSLTE_API uint32_t pdcch_common_locations(pdcch_t *q,
dci_location_t *locations,
uint32_t max_locations,
uint32_t cfi);
SRSLTE_API uint32_t srslte_pdcch_common_locations(srslte_pdcch_t *q,
srslte_dci_location_t *locations,
uint32_t max_locations,
uint32_t cfi);
#endif

80
srslte/include/srslte/phch/pdsch.h
Unescape Escape View File

@ -41,7 +41,7 @@
#include "srslte/phch/sch.h"
#include "srslte/phch/harq.h"
#define TDEC_MAX_ITERATIONS 5
#define SRSLTE_PDSCH_MAX_TDEC_ITERS 5
typedef _Complex float cf_t;
@ -56,57 +56,57 @@ typedef struct SRSLTE_API {
/* buffers */
// void buffers are shared for tx and rx
cf_t *ce[SRSLTE_MAX_PORTS];
cf_t *pdsch_symbols[SRSLTE_MAX_PORTS];
cf_t *pdsch_x[SRSLTE_MAX_PORTS];
cf_t *pdsch_d;
void *pdsch_e;
cf_t *symbols[SRSLTE_MAX_PORTS];
cf_t *x[SRSLTE_MAX_PORTS];
cf_t *d;
void *e;
/* tx & rx objects */
modem_table_t mod[4];
demod_soft_t demod;
srslte_sequence_t seq_pdsch[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding;
srslte_srslte_modem_table_t mod[4];
srslte_demod_soft_t demod;
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_precoding_t precoding;
sch_t dl_sch;
srslte_sch_t dl_sch;
}pdsch_t;
} srslte_pdsch_t;
SRSLTE_API int pdsch_init(pdsch_t *q,
srslte_cell_t cell);
SRSLTE_API int srslte_pdsch_init(srslte_pdsch_t *q,
srslte_cell_t cell);
SRSLTE_API void pdsch_free(pdsch_t *q);
SRSLTE_API void srslte_pdsch_free(srslte_pdsch_t *q);
SRSLTE_API int pdsch_set_rnti(pdsch_t *q,
uint16_t rnti);
SRSLTE_API int srslte_pdsch_set_rnti(srslte_pdsch_t *q,
uint16_t rnti);
SRSLTE_API int pdsch_encode(pdsch_t *q,
harq_t *harq_process,
uint8_t *data,
cf_t *sf_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API int srslte_pdsch_encode(srslte_pdsch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
cf_t *sf_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API int pdsch_encode_rnti(pdsch_t *q,
harq_t *harq_process,
uint8_t *data,
uint16_t rnti,
cf_t *sf_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API int srslte_pdsch_encode_rnti(srslte_pdsch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
uint16_t rnti,
cf_t *sf_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API int pdsch_decode(pdsch_t *q,
harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint8_t *data);
SRSLTE_API int srslte_pdsch_decode(srslte_pdsch_t *q,
srslte_harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint8_t *data);
SRSLTE_API int pdsch_decode_rnti(pdsch_t *q,
harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint16_t rnti,
uint8_t *data);
SRSLTE_API int srslte_pdsch_decode_rnti(srslte_pdsch_t *q,
srslte_harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint16_t rnti,
uint8_t *data);
SRSLTE_API float pdsch_average_noi(pdsch_t *q);
SRSLTE_API float srslte_pdsch_average_noi(srslte_pdsch_t *q);
SRSLTE_API uint32_t pdsch_last_noi(pdsch_t *q);
SRSLTE_API uint32_t srslte_pdsch_last_noi(srslte_pdsch_t *q);
#endif

105
srslte/include/srslte/phch/phich.h
Unescape Escape View File

@ -41,70 +41,69 @@
typedef _Complex float cf_t;
#define SRSLTE_PHICH_NORM_NSEQUENCES 8
#define SRSLTE_PHICH_EXT_NSEQUENCES 4
#define PHICH_MAX_SEQUENCES SRSLTE_PHICH_NORM_NSEQUENCES
#define PHICH_NBITS 3
#define SRSLTE_PHICH_NORM_MSYMB PHICH_NBITS * 4
#define SRSLTE_PHICH_EXT_MSYMB PHICH_NBITS * 2
#define PHICH_SRSLTE_MAX_NSYMB SRSLTE_PHICH_NORM_MSYMB
#define SRSLTE_PHICH_NORM_C 1
#define SRSLTE_PHICH_EXT_C 2
#define SRSLTE_PHICH_NORM_NSF 4
#define SRSLTE_PHICH_EXT_NSF 2
#define SRSLTE_PHICH_EXT_NSEQUENCES 4
#define SRSLTE_PHICH_NBITS 3
#define SRSLTE_PHICH_NORM_MSYMB SRSLTE_PHICH_NBITS * 4
#define SRSLTE_PHICH_EXT_MSYMB SRSLTE_PHICH_NBITS * 2
#define SRSLTE_PHICH_MAX_NSYMB SRSLTE_PHICH_NORM_MSYMB
#define SRSLTE_PHICH_NORM_C 1
#define SRSLTE_PHICH_EXT_C 2
#define SRSLTE_PHICH_NORM_NSF 4
#define SRSLTE_PHICH_EXT_NSF 2
/* phich object */
typedef struct SRSLTE_API {
srslte_cell_t cell;
/* handler to REGs resource mapper */
regs_t *regs;
srslte_regs_t *regs;
/* buffers */
cf_t ce[SRSLTE_MAX_PORTS][PHICH_SRSLTE_MAX_NSYMB];
cf_t phich_symbols[SRSLTE_MAX_PORTS][PHICH_SRSLTE_MAX_NSYMB];
cf_t phich_x[SRSLTE_MAX_PORTS][PHICH_SRSLTE_MAX_NSYMB];
cf_t phich_d[PHICH_SRSLTE_MAX_NSYMB];
cf_t phich_d0[PHICH_SRSLTE_MAX_NSYMB];
cf_t phich_z[PHICH_NBITS];
cf_t ce[SRSLTE_MAX_PORTS][SRSLTE_PHICH_MAX_NSYMB];
cf_t symbols[SRSLTE_MAX_PORTS][SRSLTE_PHICH_MAX_NSYMB];
cf_t x[SRSLTE_MAX_PORTS][SRSLTE_PHICH_MAX_NSYMB];
cf_t d[SRSLTE_PHICH_MAX_NSYMB];
cf_t d0[SRSLTE_PHICH_MAX_NSYMB];
cf_t z[SRSLTE_PHICH_NBITS];
/* bit message */
uint8_t data[PHICH_NBITS];
uint8_t data[SRSLTE_PHICH_NBITS];
/* tx & rx objects */
modem_table_t mod;
demod_hard_t demod;
srslte_sequence_t seq_phich[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding;
}phich_t;
SRSLTE_API int phich_init(phich_t *q,
regs_t *regs,
srslte_cell_t cell);
SRSLTE_API void phich_free(phich_t *q);
SRSLTE_API int phich_decode(phich_t *q,
cf_t *slot_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint32_t ngroup,
uint32_t nseq,
uint32_t nsubframe,
uint8_t *ack,
uint32_t *distance);
SRSLTE_API int phich_encode(phich_t *q,
uint8_t ack,
uint32_t ngroup,
uint32_t nseq,
uint32_t nsubframe,
cf_t *slot_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API void phich_reset(phich_t *q,
cf_t *slot_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API uint32_t phich_ngroups(phich_t *q);
srslte_srslte_modem_table_t mod;
srslte_demod_hard_t demod;
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_precoding_t precoding;
} srslte_phich_t;
SRSLTE_API int srslte_phich_init(srslte_phich_t *q,
srslte_regs_t *regs,
srslte_cell_t cell);
SRSLTE_API void srslte_phich_free(srslte_phich_t *q);
SRSLTE_API int srslte_phich_decode(srslte_phich_t *q,
cf_t *slot_symbols,
cf_t *ce[SRSLTE_MAX_PORTS],
float noise_estimate,
uint32_t ngroup,
uint32_t nseq,
uint32_t nsubframe,
uint8_t *ack,
uint32_t *distance);
SRSLTE_API int srslte_phich_encode(srslte_phich_t *q,
uint8_t ack,
uint32_t ngroup,
uint32_t nseq,
uint32_t nsubframe,
cf_t *slot_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API void srslte_phich_reset(srslte_phich_t *q,
cf_t *slot_symbols[SRSLTE_MAX_PORTS]);
SRSLTE_API uint32_t srslte_phich_ngroups(srslte_phich_t *q);
#endif // PHICH_

45
srslte/include/srslte/phch/prach.h
Unescape Escape View File

@ -33,13 +33,10 @@
#include <complex.h>
#include <stdbool.h>
#include "srslte/config.h"
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
typedef _Complex float cf_t;
//PRACH detection threshold is PRACH_DETECT_FACTOR*average
#define PRACH_DETECT_FACTOR 10
/** Generation and detection of RACH signals for uplink.
* Currently only supports preamble formats 0-3.
* Does not currently support high speed flag.
@ -83,30 +80,30 @@ typedef struct SRSLTE_API {
srslte_dft_plan_t *zc_ifft;
}prach_t;
} srslte_prach_t;
SRSLTE_API int prach_init(prach_t *p,
uint32_t N_ifft_ul,
uint32_t preamble_format,
uint32_t root_seq_index,
bool high_speed_flag,
uint32_t zero_corr_zone_config);
SRSLTE_API int srslte_prach_init(srslte_prach_t *p,
uint32_t N_ifft_ul,
uint32_t preamble_format,
uint32_t root_seq_index,
bool high_speed_flag,
uint32_t zero_corr_zone_config);
SRSLTE_API int prach_gen(prach_t *p,
uint32_t seq_index,
uint32_t freq_offset,
float beta_prach,
cf_t *signal);
SRSLTE_API int srslte_prach_gen(srslte_prach_t *p,
uint32_t seq_index,
uint32_t freq_offset,
float beta_prach,
cf_t *signal);
SRSLTE_API int prach_detect(prach_t *p,
uint32_t freq_offset,
cf_t *signal,
uint32_t sig_len,
uint32_t *indices,
uint32_t *ind_len);
SRSLTE_API int srslte_prach_detect(srslte_prach_t *p,
uint32_t freq_offset,
cf_t *signal,
uint32_t sig_len,
uint32_t *indices,
uint32_t *ind_len);
SRSLTE_API int prach_free(prach_t *p);
SRSLTE_API int srslte_prach_free(srslte_prach_t *p);
SRSLTE_API int prach_print_seqs(prach_t *p);
SRSLTE_API int srslte_prach_print_seqs(srslte_prach_t *p);
#endif // PRACH_

78
srslte/include/srslte/phch/pucch.h
Unescape Escape View File

@ -39,71 +39,69 @@
#include "srslte/phch/regs.h"
#include "srslte/phch/sch.h"
#include "srslte/phch/harq.h"
#include "srslte/filter/dft_precoding.h"
#define TDEC_MAX_ITERATIONS 5
#include "srslte/dft/dft_precoding.h"
typedef _Complex float cf_t;
#define PUCCH_N_SEQ 12 // Only Format 1, 1a and 1b supported
#define PUCCH_MAX_BITS 2
#define PUCCH_N_SF_MAX 4
#define SRSLTE_PUCCH_N_SEQ 12 // Only Format 1, 1a and 1b supported
#define SRSLTE_PUCCH_MAX_BITS 2
#define SRSLTE_PUCCH_N_SF_MAX 4
typedef enum SRSLTE_API {
PUCCH_FORMAT_1 = 0,
PUCCH_FORMAT_1A,
PUCCH_FORMAT_1B,
PUCCH_FORMAT_2,
PUCCH_FORMAT_2A,
PUCCH_FORMAT_2B,
} pucch_format_t;
SRSLTE_PUCCH_FORMAT_1 = 0,
SRSLTE_PUCCH_FORMAT_1A,
SRSLTE_PUCCH_FORMAT_1B,
SRSLTE_PUCCH_FORMAT_2,
SRSLTE_PUCCH_FORMAT_2A,
SRSLTE_PUCCH_FORMAT_2B,
} srslte_pucch_format_t;
typedef struct SRSLTE_API {
pucch_format_t format;
srslte_pucch_format_t format;
float beta_pucch;
uint32_t delta_pucch_shift;
uint32_t n_pucch;
uint32_t N_cs;
} pucch_cfg_t;
} srslte_pucch_cfg_t;
/* PUSCH object */
typedef struct SRSLTE_API {
srslte_cell_t cell;
pucch_cfg_t pucch_cfg;
srslte_pucch_cfg_t pucch_cfg;
uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB];
float tmp_arg[PUCCH_N_SF_MAX*PUCCH_N_SEQ];
float y[PUCCH_N_SEQ];
}pucch_t;
float tmp_arg[SRSLTE_PUCCH_N_SF_MAX*SRSLTE_PUCCH_N_SEQ];
float y[SRSLTE_PUCCH_N_SEQ];
}srslte_pucch_t;
SRSLTE_API int pucch_init(pucch_t *q,
srslte_cell_t cell);
SRSLTE_API int srslte_pucch_init(srslte_pucch_t *q,
srslte_cell_t cell);
SRSLTE_API void pucch_free(pucch_t *q);
SRSLTE_API void srslte_pucch_free(srslte_pucch_t *q);
SRSLTE_API void pucch_set_cfg(pucch_t *q,
pucch_cfg_t *cfg);
SRSLTE_API void srslte_pucch_set_cfg(srslte_pucch_t *q,
srslte_pucch_cfg_t *cfg);
SRSLTE_API int pucch_set_rnti(pucch_t *q,
uint16_t rnti);
SRSLTE_API int srslte_pucch_set_rnti(srslte_pucch_t *q,
uint16_t rnti);
SRSLTE_API int pucch_encode(pucch_t *q,
pucch_cfg_t *cfg,
uint8_t bits[PUCCH_MAX_BITS],
cf_t *sf_symbols);
SRSLTE_API int srslte_pucch_encode(srslte_pucch_t *q,
srslte_pucch_cfg_t *cfg,
uint8_t bits[SRSLTE_PUCCH_MAX_BITS],
cf_t *sf_symbols);
SRSLTE_API float pucch_get_alpha(uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB],
pucch_cfg_t *cfg,
srslte_cp_t cp,
bool is_drms,
uint32_t ns,
uint32_t l,
uint32_t *n_oc);
SRSLTE_API float srslte_pucch_get_alpha(uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB],
srslte_pucch_cfg_t *cfg,
srslte_cp_t cp,
bool is_drms,
uint32_t ns,
uint32_t l,
uint32_t *n_oc);
SRSLTE_API int generate_n_cs_cell(srslte_cell_t cell,
uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB]);
SRSLTE_API int srslte_generate_n_cs_cell(srslte_cell_t cell,
uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB]);
SRSLTE_API bool pucch_cfg_isvalid(pucch_cfg_t *cfg);
SRSLTE_API bool srslte_pucch_cfg_isvalid(srslte_pucch_cfg_t *cfg);
#endif

104
srslte/include/srslte/phch/pusch.h
Unescape Escape View File

@ -39,102 +39,102 @@
#include "srslte/phch/regs.h"
#include "srslte/phch/sch.h"
#include "srslte/phch/harq.h"
#include "srslte/filter/dft_precoding.h"
#include "srslte/dft/dft_precoding.h"
#define TDEC_MAX_ITERATIONS 5
#define SRSLTE_PUSCH_MAX_TDEC_ITERS 5
typedef _Complex float cf_t;
typedef struct {
enum {
hop_mode_inter_sf = 1,
hop_mode_intra_sf = 0
SRSLTE_PUSCH_HOP_MODE_INTER_SF = 1,
SRSLTE_PUSCH_HOP_MODE_INTRA_SF = 0
} hop_mode;
uint32_t current_tx_nb;
uint32_t hopping_offset;
uint32_t n_sb;
} pusch_hopping_cfg_t;
} srslte_pusch_hopping_cfg_t;
/* PUSCH object */
typedef struct SRSLTE_API {
srslte_cell_t cell;
pusch_hopping_cfg_t hopping_cfg;
srslte_pusch_hopping_cfg_t hopping_cfg;
uint32_t max_re;
bool rnti_is_set;
uint16_t rnti;
srslte_srslte_dft_precoding_t srslte_dft_precoding;
srslte_dft_precoding_t dft_precoding;
precoding_t equalizer;
srslte_precoding_t equalizer;
/* buffers */
// void buffers are shared for tx and rx
cf_t *ce;
cf_t *pusch_z;
cf_t *pusch_d;
cf_t *z;
cf_t *d;
void *pusch_q;
void *pusch_g;
void *q;
void *g;
/* tx & rx objects */
modem_table_t mod[4];
demod_soft_t demod;
srslte_sequence_t seq_pusch[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_srslte_modem_table_t mod[4];
srslte_demod_soft_t demod;
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
srslte_sequence_t seq_type2_fo;
sch_t dl_sch;
srslte_sch_t dl_sch;
}pusch_t;
}srslte_pusch_t;
SRSLTE_API int pusch_init(pusch_t *q,
srslte_cell_t cell);
SRSLTE_API int srslte_pusch_init(srslte_pusch_t *q,
srslte_cell_t cell);
SRSLTE_API void pusch_free(pusch_t *q);
SRSLTE_API void srslte_pusch_free(srslte_pusch_t *q);
SRSLTE_API void pusch_set_hopping_cfg(pusch_t *q,
pusch_hopping_cfg_t *cfg);
SRSLTE_API void srslte_pusch_set_hopping_cfg(srslte_pusch_t *q,
srslte_pusch_hopping_cfg_t *cfg);
SRSLTE_API int pusch_set_rnti(pusch_t *q,
uint16_t rnti);
SRSLTE_API int srslte_pusch_set_rnti(srslte_pusch_t *q,
uint16_t rnti);
SRSLTE_API int pusch_encode(pusch_t *q,
harq_t *harq_process,
uint8_t *data,
cf_t *sf_symbols);
SRSLTE_API int srslte_pusch_encode(srslte_pusch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
cf_t *sf_symbols);
SRSLTE_API int pusch_encode_rnti(pusch_t *q,
harq_t *harq_process,
uint8_t *data,
uint16_t rnti,
cf_t *sf_symbols);
SRSLTE_API int srslte_pusch_encode_rnti(srslte_pusch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
uint16_t rnti,
cf_t *sf_symbols);
SRSLTE_API int pusch_uci_encode(pusch_t *q,
harq_t *harq_process,
uint8_t *data,
uci_data_t uci_data,
cf_t *sf_symbols);
SRSLTE_API int srslte_pusch_uci_encode(srslte_pusch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
srslte_uci_data_t uci_data,
cf_t *sf_symbols);
SRSLTE_API int pusch_uci_encode_rnti(pusch_t *q,
harq_t *harq,
uint8_t *data,
uci_data_t uci_data,
uint16_t rnti,
cf_t *sf_symbols);
SRSLTE_API int srslte_pusch_uci_encode_rnti(srslte_pusch_t *q,
srslte_harq_t *harq,
uint8_t *data,
srslte_uci_data_t uci_data,
uint16_t rnti,
cf_t *sf_symbols);
SRSLTE_API int pusch_decode(pusch_t *q,
harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce,
float noise_estimate,
uint8_t *data);
SRSLTE_API int srslte_pusch_decode(srslte_pusch_t *q,
srslte_harq_t *harq_process,
cf_t *sf_symbols,
cf_t *ce,
float noise_estimate,
uint8_t *data);
SRSLTE_API float pusch_average_noi(pusch_t *q);
SRSLTE_API float srslte_pusch_average_noi(srslte_pusch_t *q);
SRSLTE_API uint32_t pusch_last_noi(pusch_t *q);
SRSLTE_API uint32_t srslte_pusch_last_noi(srslte_pusch_t *q);
#endif

169
srslte/include/srslte/phch/ra.h
Unescape Escape View File

@ -32,6 +32,7 @@
#include <stdbool.h>
#include "srslte/config.h"
#include "srslte/common/phy_common.h"
/** Structures and utility functions for DL/UL resource
* allocation.
@ -40,164 +41,166 @@
typedef struct SRSLTE_API {
srslte_mod_t mod;
int tbs;
} ra_mcs_t;
} srslte_ra_mcs_t;
typedef enum SRSLTE_API {
alloc_type0 = 0, alloc_type1 = 1, alloc_type2 = 2
} ra_type_t;
SRSLTE_RA_ALLOC_TYPE0 = 0,
SRSLTE_RA_ALLOC_TYPE1 = 1,
SRSLTE_RA_ALLOC_TYPE2 = 2
} srslte_ra_type_t;
typedef struct SRSLTE_API {
uint32_t rbg_bitmask;
} ra_type0_t;
} srslte_ra_type0_t;
typedef struct SRSLTE_API {
uint32_t vrb_bitmask;
uint32_t rbg_subset;
bool shift;
} ra_type1_t;
} srslte_ra_type1_t;
typedef struct SRSLTE_API {
uint32_t riv; // if L_crb==0, DCI message packer will take this value directly
uint32_t L_crb;
uint32_t RB_start;
enum {
nprb1a_2 = 0, nprb1a_3 = 1
SRSLTE_RA_TYPE2_NPRB1A_2 = 0, SRSLTE_RA_TYPE2_NPRB1A_3 = 1
} n_prb1a;
enum {
t2_ng1 = 0, t2_ng2 = 1
SRSLTE_RA_TYPE2_NG1 = 0, SRSLTE_RA_TYPE2_NG2 = 1
} n_gap;
enum {
t2_loc = 0, t2_dist = 1
SRSLTE_RA_TYPE2_LOC = 0, SRSLTE_RA_TYPE2_DIST = 1
} mode;
} ra_type2_t;
} srslte_ra_type2_t;
typedef struct SRSLTE_API {
bool prb_idx[SRSLTE_MAX_PRB];
uint32_t nof_prb;
} ra_prb_slot_t;
} srslte_ra_prb_slot_t;
typedef struct SRSLTE_API {
ra_prb_slot_t slot[2];
srslte_ra_prb_slot_t slot[2];
uint32_t lstart;
uint32_t re_sf[SRSLTE_NSUBFRAMES_X_FRAME];
} ra_dl_alloc_t;
} srslte_srslte_ra_dl_alloc_t;
typedef struct SRSLTE_API {
uint32_t n_prb[2];
uint32_t n_prb_tilde[2];
uint32_t L_prb;
uint32_t freq_hopping;
} ra_ul_alloc_t;
} srslte_srslte_ra_ul_alloc_t;
typedef struct SRSLTE_API {
uint16_t rnti;
ra_type_t alloc_type;
srslte_ra_type_t alloc_type;
union {
ra_type0_t type0_alloc;
ra_type1_t type1_alloc;
ra_type2_t type2_alloc;
srslte_ra_type0_t type0_alloc;
srslte_ra_type1_t type1_alloc;
srslte_ra_type2_t type2_alloc;
};
ra_dl_alloc_t prb_alloc;
srslte_srslte_ra_dl_alloc_t prb_alloc;
uint32_t mcs_idx;
ra_mcs_t mcs;
srslte_ra_mcs_t mcs;
uint32_t harq_process;
uint32_t rv_idx;
bool ndi;
} ra_pdsch_t;
} srslte_ra_pdsch_t;
typedef struct SRSLTE_API {
/* 36.213 Table 8.4-2: hop_half is 0 for < 10 Mhz and 10 for > 10 Mhz.
* hop_quart is 00 for > 10 Mhz and hop_quart_neg is 01 for > 10 Mhz.
/* 36.213 Table 8.4-2: SRSLTE_RA_PUSCH_HOP_HALF is 0 for < 10 Mhz and 10 for > 10 Mhz.
* SRSLTE_RA_PUSCH_HOP_QUART is 00 for > 10 Mhz and SRSLTE_RA_PUSCH_HOP_QUART_NEG is 01 for > 10 Mhz.
*/
enum {
hop_disabled = -1,
hop_quart = 0,
hop_quart_neg = 1,
hop_half = 2,
hop_type_2 = 3
SRSLTE_RA_PUSCH_HOP_DISABLED = -1,
SRSLTE_RA_PUSCH_HOP_QUART = 0,
SRSLTE_RA_PUSCH_HOP_QUART_NEG = 1,
SRSLTE_RA_PUSCH_HOP_HALF = 2,
SRSLTE_RA_PUSCH_HOP_TYPE2 = 3
} freq_hop_fl;
ra_ul_alloc_t prb_alloc;
srslte_srslte_ra_ul_alloc_t prb_alloc;
ra_type2_t type2_alloc;
srslte_ra_type2_t type2_alloc;
uint32_t mcs_idx;
ra_mcs_t mcs;
srslte_ra_mcs_t mcs;
uint32_t rv_idx; // If set to non-zero, a retransmission is requested with the same modulation
// than before (Format0 message, see also 8.6.1 in 36.2313).
// than before (SRSLTE_DCI_FORMAT0 message, see also 8.6.1 in 36.2313).
bool ndi;
bool cqi_request;
} ra_pusch_t;
} srslte_ra_pusch_t;
SRSLTE_API void ra_prb_fprint(FILE *f,
ra_prb_slot_t *prb,
uint32_t nof_prb);
SRSLTE_API void srslte_ra_prb_fprint(FILE *f,
srslte_ra_prb_slot_t *prb,
uint32_t nof_prb);
SRSLTE_API int ra_dl_alloc(ra_dl_alloc_t *prb,
ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API int srslte_ra_dl_alloc(srslte_srslte_ra_dl_alloc_t *prb,
srslte_ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API int ra_ul_alloc(ra_ul_alloc_t *prb,
ra_pusch_t *ra,
uint32_t n_rb_ho,
uint32_t nof_prb);
SRSLTE_API int srslte_ra_ul_alloc(srslte_srslte_ra_ul_alloc_t *prb,
srslte_ra_pusch_t *ra,
uint32_t n_rb_ho,
uint32_t nof_prb);
SRSLTE_API void ra_dl_alloc_re(ra_dl_alloc_t *prb_dist,
uint32_t nof_prb,
uint32_t nof_ports,
uint32_t nof_ctrl_symbols,
srslte_cp_t cp);
SRSLTE_API void srslte_ra_dl_alloc_re(srslte_srslte_ra_dl_alloc_t *prb_dist,
uint32_t nof_prb,
uint32_t nof_ports,
uint32_t nof_ctrl_symbols,
srslte_cp_t cp);
SRSLTE_API uint32_t ra_nprb_dl(ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_nprb_dl(srslte_ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API uint32_t ra_nprb_ul(ra_pusch_t *ra,
uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_nprb_ul(srslte_ra_pusch_t *ra,
uint32_t nof_prb);
SRSLTE_API int ra_mcs_from_idx_dl(uint32_t mcs_idx,
uint32_t nof_prb,
ra_mcs_t *mcs);
SRSLTE_API int srslte_ra_mcs_from_idx_dl(uint32_t mcs_idx,
uint32_t nof_prb,
srslte_ra_mcs_t *mcs);
SRSLTE_API int ra_mcs_from_idx_ul(uint32_t mcs_idx,
uint32_t nof_prb,
ra_mcs_t *mcs);
SRSLTE_API int srslte_ra_mcs_from_idx_ul(uint32_t mcs_idx,
uint32_t nof_prb,
srslte_ra_mcs_t *mcs);
SRSLTE_API int ra_tbs_from_idx_format1c(uint32_t tbs_idx);
SRSLTE_API int srslte_srslte_ra_tbs_from_idx_format1c(uint32_t tbs_idx);
SRSLTE_API int ra_tbs_from_idx(uint32_t tbs_idx,
uint32_t n_prb);
SRSLTE_API int srslte_ra_tbs_from_idx(uint32_t tbs_idx,
uint32_t n_prb);
SRSLTE_API int ra_tbs_to_table_idx(uint32_t tbs,
uint32_t n_prb);
SRSLTE_API int srslte_ra_tbs_to_table_idx(uint32_t tbs,
uint32_t n_prb);
SRSLTE_API uint32_t ra_type0_P(uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_type0_P(uint32_t nof_prb);
SRSLTE_API uint32_t ra_type2_to_riv(uint32_t L_crb,
uint32_t RB_start,
uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_type2_to_riv(uint32_t L_crb,
uint32_t RB_start,
uint32_t nof_prb);
SRSLTE_API void ra_type2_from_riv(uint32_t riv,
uint32_t *L_crb,
uint32_t *RB_start,
uint32_t nof_prb,
uint32_t nof_vrb);
SRSLTE_API void srslte_ra_type2_from_riv(uint32_t riv,
uint32_t *L_crb,
uint32_t *RB_start,
uint32_t nof_prb,
uint32_t nof_vrb);
SRSLTE_API uint32_t ra_type2_n_vrb_dl(uint32_t nof_prb,
bool ngap_is_1);
SRSLTE_API uint32_t srslte_ra_type2_n_vrb_dl(uint32_t nof_prb,
bool ngap_is_1);
SRSLTE_API uint32_t ra_type2_n_rb_step(uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_type2_n_rb_step(uint32_t nof_prb);
SRSLTE_API uint32_t ra_type2_ngap(uint32_t nof_prb,
bool ngap_is_1);
SRSLTE_API uint32_t srslte_ra_type2_ngap(uint32_t nof_prb,
bool ngap_is_1);
SRSLTE_API uint32_t ra_type1_N_rb(uint32_t nof_prb);
SRSLTE_API uint32_t srslte_ra_type1_N_rb(uint32_t nof_prb);
SRSLTE_API void ra_pdsch_fprint(FILE *f,
ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API void srslte_ra_pdsch_fprint(FILE *f,
srslte_ra_pdsch_t *ra,
uint32_t nof_prb);
SRSLTE_API void ra_pusch_fprint(FILE *f,
ra_pusch_t *ra,
uint32_t nof_prb);
SRSLTE_API void srslte_ra_pusch_fprint(FILE *f,
srslte_ra_pusch_t *ra,
uint32_t nof_prb);
#endif /* RB_ALLOC_H_ */

90
srslte/include/srslte/phch/regs.h
Unescape Escape View File

@ -49,12 +49,12 @@ typedef struct SRSLTE_API {
uint32_t k0;
uint32_t l;
bool assigned;
}regs_reg_t;
}srslte_regs_reg_t;
typedef struct SRSLTE_API {
uint32_t nof_regs;
regs_reg_t **regs;
}regs_ch_t;
srslte_regs_reg_t **regs;
}srslte_regs_ch_t;
typedef struct SRSLTE_API {
srslte_cell_t cell;
@ -66,67 +66,67 @@ typedef struct SRSLTE_API {
srslte_phich_resources_t phich_res;
srslte_phich_length_t phich_len;
regs_ch_t pcfich;
regs_ch_t *phich; // there are several phich
regs_ch_t pdcch[3]; /* PDCCH indexing, permutation and interleaving is computed for
srslte_regs_ch_t pcfich;
srslte_regs_ch_t *phich; // there are several phich
srslte_regs_ch_t pdcch[3]; /* PDCCH indexing, permutation and interleaving is computed for
the three possible CFI value */
uint32_t nof_regs;
regs_reg_t *regs;
}regs_t;
srslte_regs_reg_t *regs;
}srslte_regs_t;
SRSLTE_API int regs_init(regs_t *h,
srslte_cell_t cell);
SRSLTE_API int srslte_regs_init(srslte_regs_t *h,
srslte_cell_t cell);
SRSLTE_API void regs_free(regs_t *h);
SRSLTE_API int regs_set_cfi(regs_t *h,
uint32_t nof_ctrl_symbols);
SRSLTE_API void srslte_regs_free(srslte_regs_t *h);
SRSLTE_API int srslte_regs_set_cfi(srslte_regs_t *h,
uint32_t nof_ctrl_symbols);
SRSLTE_API uint32_t regs_pcfich_nregs(regs_t *h);
SRSLTE_API int regs_pcfich_put(regs_t *h,
cf_t pcfich_symbols[REGS_PCFICH_NSYM],
SRSLTE_API uint32_t srslte_regs_pcfich_nregs(srslte_regs_t *h);
SRSLTE_API int srslte_regs_pcfich_put(srslte_regs_t *h,
cf_t symbols[REGS_PCFICH_NSYM],
cf_t *slot_symbols);
SRSLTE_API int regs_pcfich_get(regs_t *h,
cf_t *slot_symbols,
cf_t pcfich_symbols[REGS_PCFICH_NSYM]);
SRSLTE_API int srslte_regs_pcfich_get(srslte_regs_t *h,
cf_t *slot_symbols,
cf_t symbols[REGS_PCFICH_NSYM]);
SRSLTE_API uint32_t regs_phich_nregs(regs_t *h);
SRSLTE_API int regs_phich_add(regs_t *h,
cf_t phich_symbols[REGS_PHICH_NSYM],
uint32_t ngroup,
cf_t *slot_symbols);
SRSLTE_API uint32_t srslte_regs_phich_nregs(srslte_regs_t *h);
SRSLTE_API int srslte_regs_phich_add(srslte_regs_t *h,
cf_t symbols[REGS_PHICH_NSYM],
uint32_t ngroup,
cf_t *slot_symbols);
SRSLTE_API int regs_phich_get(regs_t *h,
cf_t *slot_symbols,
cf_t phich_symbols[REGS_PHICH_NSYM],
uint32_t ngroup);
SRSLTE_API int srslte_regs_phich_get(srslte_regs_t *h,
cf_t *slot_symbols,
cf_t symbols[REGS_PHICH_NSYM],
uint32_t ngroup);
SRSLTE_API uint32_t regs_phich_ngroups(regs_t *h);
SRSLTE_API int regs_phich_reset(regs_t *h,
cf_t *slot_symbols);
SRSLTE_API uint32_t srslte_regs_phich_ngroups(srslte_regs_t *h);
SRSLTE_API int srslte_regs_phich_reset(srslte_regs_t *h,
cf_t *slot_symbols);
SRSLTE_API int regs_pdcch_nregs(regs_t *h, uint32_t cfi);
SRSLTE_API int regs_pdcch_put(regs_t *h,
cf_t *pdcch_symbols,
cf_t *slot_symbols);
SRSLTE_API int srslte_regs_pdcch_nregs(srslte_regs_t *h, uint32_t cfi);
SRSLTE_API int srslte_regs_pdcch_put(srslte_regs_t *h,
cf_t *d,
cf_t *slot_symbols);
SRSLTE_API int regs_pdcch_put_offset(regs_t *h,
cf_t *pdcch_symbols,
SRSLTE_API int srslte_regs_pdcch_put_offset(srslte_regs_t *h,
cf_t *d,
cf_t *slot_symbols,
uint32_t start_reg,
uint32_t nof_regs);
SRSLTE_API int regs_pdcch_get(regs_t *h,
cf_t *slot_symbols,
cf_t *pdcch_symbols);
SRSLTE_API int regs_pdcch_get_offset(regs_t *h,
SRSLTE_API int srslte_regs_pdcch_get(srslte_regs_t *h,
cf_t *slot_symbols,
cf_t *pdcch_symbols,
uint32_t start_reg,
uint32_t nof_regs);
cf_t *d);
SRSLTE_API int srslte_regs_pdcch_get_offset(srslte_regs_t *h,
cf_t *slot_symbols,
cf_t *d,
uint32_t start_reg,
uint32_t nof_regs);
#endif // REGS_H_

38
srslte/include/srslte/phch/sch.h
Unescape Escape View File

@ -38,7 +38,7 @@
#include "srslte/phch/harq.h"
#include "srslte/phch/uci.h"
#define TDEC_MAX_ITERATIONS 5
#define SRSLTE_PDSCH_MAX_TDEC_ITERS 5
#ifndef SRSLTE_RX_NULL
@ -58,51 +58,51 @@ typedef struct SRSLTE_API {
/* buffers */
uint8_t *cb_in;
void *cb_out;
void *pdsch_e;
void *e;
srslte_tcod_t encoder;
srslte_tdec_t decoder;
srslte_crc_t srslte_crc_tb;
srslte_crc_t srslte_crc_cb;
uci_cqi_pusch_t uci_cqi;
srslte_uci_cqi_pusch_t uci_cqi;
} sch_t;
} srslte_sch_t;
SRSLTE_API int sch_init(sch_t *q);
SRSLTE_API int srslte_sch_init(srslte_sch_t *q);
SRSLTE_API void sch_free(sch_t *q);
SRSLTE_API void srslte_sch_free(srslte_sch_t *q);
SRSLTE_API float sch_average_noi(sch_t *q);
SRSLTE_API float srslte_sch_average_noi(srslte_sch_t *q);
SRSLTE_API uint32_t sch_last_noi(sch_t *q);
SRSLTE_API uint32_t srslte_sch_last_noi(srslte_sch_t *q);
SRSLTE_API int dlsch_encode(sch_t *q,
harq_t *harq_process,
SRSLTE_API int srslte_dlsch_encode(srslte_sch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
uint8_t *e_bits);
SRSLTE_API int dlsch_decode(sch_t *q,
harq_t *harq_process,
SRSLTE_API int srslte_dlsch_decode(srslte_sch_t *q,
srslte_harq_t *harq_process,
float *e_bits,
uint8_t *data);
SRSLTE_API int ulsch_encode(sch_t *q,
harq_t *harq_process,
SRSLTE_API int srslte_ulsch_encode(srslte_sch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
uint8_t *g_bits,
uint8_t *q_bits);
SRSLTE_API int ulsch_uci_encode(sch_t *q,
harq_t *harq_process,
SRSLTE_API int srslte_ulsch_uci_encode(srslte_sch_t *q,
srslte_harq_t *harq_process,
uint8_t *data,
uci_data_t uci_data,
srslte_uci_data_t uci_data,
uint8_t *g_bits,
uint8_t *q_bits);
SRSLTE_API int ulsch_decode(sch_t *q,
harq_t *harq_process,
SRSLTE_API int srslte_ulsch_decode(srslte_sch_t *q,
srslte_harq_t *harq_process,
float *e_bits,
uint8_t *data);

62
srslte/include/srslte/phch/uci.h
Unescape Escape View File

@ -34,16 +34,16 @@
#include "srslte/phch/harq.h"
#include "srslte/fec/crc.h"
#define MAX_CQI_LEN_PUSCH 512
#define MAX_CQI_LEN_PUCCH 13
#define CQI_CODED_PUCCH_B 20
#define SRSLTE_UCI_MAX_CQI_LEN_PUSCH 512
#define SRSLTE_UCI_MAX_CQI_LEN_PUCCH 13
#define SRSLTE_UCI_CQI_CODED_PUCCH_B 20
typedef struct SRSLTE_API {
srslte_crc_t crc;
uint8_t tmp_cqi[MAX_CQI_LEN_PUSCH];
uint8_t encoded_cqi[3*MAX_CQI_LEN_PUSCH];
} uci_cqi_pusch_t;
uint8_t tmp_cqi[SRSLTE_UCI_MAX_CQI_LEN_PUSCH];
uint8_t encoded_cqi[3*SRSLTE_UCI_MAX_CQI_LEN_PUSCH];
} srslte_uci_cqi_pusch_t;
typedef struct SRSLTE_API {
uint8_t *uci_cqi;
@ -55,37 +55,37 @@ typedef struct SRSLTE_API {
uint8_t uci_ack; // Only 1-bit supported for HARQ
uint32_t uci_ack_len;
float beta_ack;
} uci_data_t;
} srslte_uci_data_t;
SRSLTE_API int uci_cqi_init(uci_cqi_pusch_t *q);
SRSLTE_API int srslte_uci_cqi_init(srslte_uci_cqi_pusch_t *q);
SRSLTE_API void uci_cqi_free(uci_cqi_pusch_t *q);
SRSLTE_API void srslte_uci_cqi_free(srslte_uci_cqi_pusch_t *q);
SRSLTE_API int uci_encode_cqi_pusch(uci_cqi_pusch_t *q,
uint8_t *cqi_data,
uint32_t cqi_len,
float beta,
uint32_t Q_prime_ri,
harq_t *harq_process,
uint8_t *q_bits);
SRSLTE_API int srslte_uci_encode_cqi_pusch(srslte_uci_cqi_pusch_t *q,
uint8_t *cqi_data,
uint32_t cqi_len,
float beta,
uint32_t Q_prime_ri,
srslte_harq_t *harq_process,
uint8_t *q_bits);
SRSLTE_API int uci_encode_cqi_pucch(uint8_t *cqi_data,
uint32_t cqi_len,
uint8_t b_bits[CQI_CODED_PUCCH_B]);
SRSLTE_API int srslte_uci_encode_cqi_pucch(uint8_t *cqi_data,
uint32_t cqi_len,
uint8_t b_bits[SRSLTE_UCI_CQI_CODED_PUCCH_B]);
SRSLTE_API int uci_encode_ack(uint8_t data,
uint32_t O_cqi,
float beta,
harq_t *harq_process,
uint32_t H_prime_total,
uint8_t *q_bits);
SRSLTE_API int srslte_uci_encode_ack(uint8_t data,
uint32_t O_cqi,
float beta,
srslte_harq_t *harq_process,
uint32_t H_prime_total,
uint8_t *q_bits);
SRSLTE_API int uci_encode_ri(uint8_t data,
uint32_t O_cqi,
float beta,
harq_t *harq_process,
uint32_t H_prime_total,
uint8_t *q_bits);
SRSLTE_API int srslte_uci_encode_ri(uint8_t data,
uint32_t O_cqi,
float beta,
srslte_harq_t *harq_process,
uint32_t H_prime_total,
uint8_t *q_bits);
#endif

11
srslte/include/srslte/resampling/decim.h
Unescape Escape View File

@ -33,7 +33,14 @@
typedef _Complex float cf_t;
SRSLTE_API void decim_c(cf_t *input, cf_t *output, int M, int len);
SRSLTE_API void decim_f(float *input, float *output, int M, int len);
SRSLTE_API void srslte_decim_c(cf_t *input,
cf_t *output,
int M,
int len);
SRSLTE_API void srslte_decim_f(float *input,
float *output,
int M,
int len);
#endif // DECIM_H

46
srslte/include/srslte/resampling/interp.h
Unescape Escape View File

@ -44,16 +44,16 @@ SRSLTE_API cf_t srslte_interp_linear_onesample_cabs(cf_t input0,
cf_t input1);
SRSLTE_API void srslte_interp_linear_offset_cabs(cf_t *input,
cf_t *output,
uint32_t M,
uint32_t len,
uint32_t off_st,
uint32_t off_end);
cf_t *output,
uint32_t M,
uint32_t len,
uint32_t off_st,
uint32_t off_end);
SRSLTE_API void srslte_interp_linear_f(float *input,
float *output,
uint32_t M,
uint32_t len);
float *output,
uint32_t M,
uint32_t len);
@ -62,18 +62,18 @@ SRSLTE_API void srslte_interp_linear_f(float *input,
typedef struct {
cf_t *diff_vec;
uint32_t vector_len;
} srslte_interp_linvec_t;
} srslte_interp_linsrslte_vec_t;
SRSLTE_API int srslte_interp_linear_vector_init(srslte_interp_linvec_t *q,
uint32_t vector_len);
SRSLTE_API int srslte_interp_linear_vector_init(srslte_interp_linsrslte_vec_t *q,
uint32_t vector_len);
SRSLTE_API void srslte_interp_linear_vector_free(srslte_interp_linvec_t *q);
SRSLTE_API void srslte_interp_linear_vector_free(srslte_interp_linsrslte_vec_t *q);
SRSLTE_API void srslte_interp_linear_vector(srslte_interp_linvec_t *q,
cf_t *in0,
cf_t *in1,
cf_t *between,
uint32_t M);
SRSLTE_API void srslte_interp_linear_vector(srslte_interp_linsrslte_vec_t *q,
cf_t *in0,
cf_t *in1,
cf_t *between,
uint32_t M);
@ -88,16 +88,16 @@ typedef struct {
} srslte_interp_lin_t;
SRSLTE_API int srslte_interp_linear_init(srslte_interp_lin_t *q,
uint32_t vector_len,
uint32_t M);
uint32_t vector_len,
uint32_t M);
SRSLTE_API void srslte_interp_linear_free(srslte_interp_lin_t *q);
SRSLTE_API void srslte_interp_linear_offset(srslte_interp_lin_t *q,
cf_t *input,
cf_t *output,
uint32_t off_st,
uint32_t off_end);
cf_t *input,
cf_t *output,
uint32_t off_st,
uint32_t off_end);
#endif // INTERP_H

17
srslte/include/srslte/resampling/resample_arb.h
Unescape Escape View File

@ -35,17 +35,22 @@
typedef _Complex float cf_t;
#define RESAMPLE_ARB_N 32 // Polyphase filter rows
#define RESAMPLE_ARB_M 8 // Polyphase filter columns
#define SRSLTE_RESAMPLE_ARB_N 32 // Polyphase filter rows
#define SRSLTE_RESAMPLE_ARB_M 8 // Polyphase filter columns
typedef struct SRSLTE_API {
float rate; // Resample rate
float step; // Step increment through filter
float acc; // Index into filter
cf_t reg[RESAMPLE_ARB_M]; // Our window of samples
}resample_arb_t;
cf_t reg[SRSLTE_RESAMPLE_ARB_M]; // Our window of samples
} srslte_resample_arb_t;
SRSLTE_API void resample_arb_init(resample_arb_t *q, float rate);
SRSLTE_API int resample_arb_compute(resample_arb_t *q, cf_t *input, cf_t *output, int n_in);
SRSLTE_API void srslte_resample_arb_init(srslte_resample_arb_t *q,
float rate);
SRSLTE_API int srslte_resample_arb_compute(srslte_resample_arb_t *q,
cf_t *input,
cf_t *output,
int n_in);
#endif //RESAMPLE_ARB_

78
srslte/include/srslte/scrambling/scrambling.h
Unescape Escape View File

@ -36,68 +36,34 @@
typedef _Complex float cf_t;
/* Scrambling has no state */
SRSLTE_API void scrambling_b(srslte_sequence_t *s,
uint8_t *data);
SRSLTE_API void srslte_scrambling_b(srslte_sequence_t *s,
uint8_t *data);
SRSLTE_API void scrambling_b_offset(srslte_sequence_t *s,
uint8_t *data,
int offset,
int len);
SRSLTE_API void srslte_scrambling_b_offset(srslte_sequence_t *s,
uint8_t *data,
int offset,
int len);
SRSLTE_API void scrambling_b_offset_pusch(srslte_sequence_t *s,
uint8_t *data,
int offset,
int len);
SRSLTE_API void srslte_scrambling_b_offset_pusch(srslte_sequence_t *s,
uint8_t *data,
int offset,
int len);
SRSLTE_API void scrambling_f(srslte_sequence_t *s,
float *data);
SRSLTE_API void srslte_scrambling_f(srslte_sequence_t *s,
float *data);
SRSLTE_API void scrambling_f_offset(srslte_sequence_t *s,
float *data,
int offset,
int len);
SRSLTE_API void srslte_scrambling_f_offset(srslte_sequence_t *s,
float *data,
int offset,
int len);
SRSLTE_API void scrambling_c(srslte_sequence_t *s,
cf_t *data);
SRSLTE_API void srslte_scrambling_c(srslte_sequence_t *s,
cf_t *data);
SRSLTE_API void scrambling_c_offset(srslte_sequence_t *s,
cf_t *data,
int offset,
int len);
SRSLTE_API void srslte_scrambling_c_offset(srslte_sequence_t *s,
cf_t *data,
int offset,
int len);
/* High-level API */
/* channel integer values */
#define SCRAMBLING_PDSCH 0 /* also PUSCH */
#define SCRAMBLING_PCFICH 1
#define SCRAMBLING_PDCCH 2
#define SCRAMBLING_PBCH 3
#define SCRAMBLING_PMCH 4
#define SCRAMBLING_PUCCH 5
typedef struct SRSLTE_API {
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
}scrambling_t;
typedef struct SRSLTE_API {
scrambling_t obj;
struct scrambling_init {
int hard;
int q;
int cell_id;
int nrnti;
int nMBSFN;
int channel;
int nof_symbols; // 7 normal 6 extended
} init;
void *input; // input type may be uint8_t or float depending on hard
int in_len;
struct scrambling_ctrl_in {
int subframe;
} ctrl_in;
void *output;
int out_len;
}scrambling_hl;
#endif // SCRAMBLING_

10
srslte/include/srslte/srslte.h
Unescape Escape View File

@ -41,17 +41,12 @@
#include "srslte/utils/bit.h"
#include "srslte/utils/convolution.h"
#include "srslte/utils/debug.h"
#include "srslte/utils/dft.h"
#include "srslte/utils/matrix.h"
#include "srslte/utils/mux.h"
#include "srslte/utils/cexptab.h"
#include "srslte/utils/pack.h"
#include "srslte/utils/vector.h"
#include "srslte/common/timestamp.h"
#include "srslte/common/sequence.h"
#include "srslte/common/phy_common.h"
#include "srslte/common/fft.h"
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/ch_estimation/refsignal_dl.h"
@ -72,8 +67,9 @@
#include "srslte/fec/rm_conv.h"
#include "srslte/fec/rm_turbo.h"
#include "srslte/filter/filter2d.h"
#include "srslte/filter/dft_precoding.h"
#include "srslte/dft/dft_precoding.h"
#include "srslte/dft/ofdm.h"
#include "srslte/dft/dft.h"
#include "srslte/io/binsource.h"
#include "srslte/io/filesink.h"

30
srslte/include/srslte/sync/cfo.h
Unescape Escape View File

@ -37,32 +37,32 @@
typedef _Complex float cf_t;
/** If the frequency is changed more than the tolerance, a new table is generated */
#define CFO_TOLERANCE 0.00001
#define SRSLTE_CFO_TOLERANCE 0.00001
#define CFO_CEXPTAB_SIZE 4096
#define SRSLTE_CFO_CEXPTAB_SIZE 4096
typedef struct SRSLTE_API {
float last_freq;
float tol;
int nsamples;
cexptab_t tab;
srslte_cexptab_t tab;
cf_t *cur_cexp;
}cfo_t;
}srslte_cfo_t;
SRSLTE_API int cfo_init(cfo_t *h,
uint32_t nsamples);
SRSLTE_API int srslte_cfo_init(srslte_cfo_t *h,
uint32_t nsamples);
SRSLTE_API void cfo_free(cfo_t *h);
SRSLTE_API void srslte_cfo_free(srslte_cfo_t *h);
SRSLTE_API int cfo_realloc(cfo_t *h,
uint32_t samples);
SRSLTE_API int srslte_cfo_realloc(srslte_cfo_t *h,
uint32_t samples);
SRSLTE_API void cfo_set_tol(cfo_t *h,
float tol);
SRSLTE_API void srslte_cfo_set_tol(srslte_cfo_t *h,
float tol);
SRSLTE_API void cfo_correct(cfo_t *h,
cf_t *input,
cf_t *output,
float freq);
SRSLTE_API void srslte_cfo_correct(srslte_cfo_t *h,
cf_t *input,
cf_t *output,
float freq);
#endif // CFO_

84
srslte/include/srslte/sync/pss.h
Unescape Escape View File

@ -40,21 +40,21 @@ typedef _Complex float cf_t; /* this is only a shortcut */
#define CONVOLUTION_FFT
#define PSS_LEN 62
#define PSS_RE 6*12
#define SRSLTE_PSS_LEN 62
#define SRSLTE_PSS_RE (6*12)
/* PSS processing options */
#define PSS_ACCUMULATE_ABS // If enabled, accumulates the correlation absolute value on consecutive calls to pss_synch_find_pss
#define SRSLTE_PSS_ACCUMULATE_ABS // If enabled, accumulates the correlation absolute value on consecutive calls to srslte_pss_synch_find_pss
#define PSS_ABS_SQUARE // If enabled, compute abs square, otherwise computes absolute value only
#define SRSLTE_PSS_ABS_SQUARE // If enabled, compute abs square, otherwise computes absolute value only
#define PSS_RETURN_PSR // If enabled returns peak to side-lobe ratio, otherwise returns absolute peak value
#define SRSLTE_PSS_RETURN_PSR // If enabled returns peak to side-lobe ratio, otherwise returns absolute peak value
/**
* The pss_synch_t object provides functions for fast computation of the crosscorrelation
* between the PSS and received signal and CFO estimation. Also, the function pss_synch_periodic() is designed
* The srslte_pss_synch_t object provides functions for fast computation of the crosscorrelation
* between the PSS and received signal and CFO estimation. Also, the function srslte_pss_synch_tperiodic() is designed
* to be called periodically every subframe, taking care of the correct data alignment with respect
* to the PSS sequence.
*
@ -70,14 +70,14 @@ typedef struct SRSLTE_API {
srslte_dft_plan_t dftp_input;
#ifdef CONVOLUTION_FFT
conv_fft_cc_t conv_fft;
srslte_conv_fft_cc_t conv_fft;
#endif
uint32_t frame_size;
uint32_t N_id_2;
uint32_t fft_size;
cf_t pss_signal_time[3][PSS_LEN];
cf_t pss_signal_time[3][SRSLTE_PSS_LEN];
cf_t *pss_signal_freq[3]; // One sequence for each N_id_2
cf_t *tmp_input;
cf_t *conv_output;
@ -85,53 +85,53 @@ typedef struct SRSLTE_API {
float ema_alpha;
float *conv_output_avg;
float peak_value;
}pss_synch_t;
}srslte_pss_synch_t;
typedef enum { PSS_TX, PSS_RX } pss_direction_t;
/* Basic functionality */
SRSLTE_API int pss_synch_init_fft(pss_synch_t *q,
uint32_t frame_size,
uint32_t fft_size);
SRSLTE_API int srslte_pss_synch_init_fft(srslte_pss_synch_t *q,
uint32_t frame_size,
uint32_t fft_size);
SRSLTE_API int pss_synch_init(pss_synch_t *q,
uint32_t frame_size);
SRSLTE_API int srslte_pss_synch_init(srslte_pss_synch_t *q,
uint32_t frame_size);
SRSLTE_API void pss_synch_free(pss_synch_t *q);
SRSLTE_API void srslte_pss_synch_free(srslte_pss_synch_t *q);
SRSLTE_API void pss_synch_reset(pss_synch_t *q);
SRSLTE_API void srslte_pss_synch_reset(srslte_pss_synch_t *q);
SRSLTE_API int pss_generate(cf_t *signal,
uint32_t N_id_2);
SRSLTE_API int srslte_pss_generate(cf_t *signal,
uint32_t N_id_2);
SRSLTE_API void pss_put_slot(cf_t *pss_signal,
cf_t *slot,
uint32_t nof_prb,
srslte_cp_t cp);
SRSLTE_API void srslte_pss_put_slot(cf_t *pss_signal,
cf_t *slot,
uint32_t nof_prb,
srslte_cp_t cp);
SRSLTE_API void pss_synch_set_ema_alpha(pss_synch_t *q,
float alpha);
SRSLTE_API void srslte_pss_synch_set_ema_alpha(srslte_pss_synch_t *q,
float alpha);
SRSLTE_API int pss_synch_set_N_id_2(pss_synch_t *q,
uint32_t N_id_2);
SRSLTE_API int srslte_pss_synch_set_N_id_2(srslte_pss_synch_t *q,
uint32_t N_id_2);
SRSLTE_API int pss_synch_find_pss(pss_synch_t *q,
cf_t *input,
float *corr_peak_value);
SRSLTE_API int srslte_pss_synch_find_pss(srslte_pss_synch_t *q,
cf_t *input,
float *corr_peak_value);
SRSLTE_API int pss_synch_chest(pss_synch_t *q,
cf_t *input,
cf_t ce[PSS_LEN]);
SRSLTE_API int srslte_pss_synch_chest(srslte_pss_synch_t *q,
cf_t *input,
cf_t ce[SRSLTE_PSS_LEN]);
SRSLTE_API float pss_synch_cfo_compute(pss_synch_t* q,
cf_t *pss_recv);
SRSLTE_API float srslte_pss_synch_cfo_compute(srslte_pss_synch_t* q,
cf_t *pss_recv);
/* High-level API */
typedef struct SRSLTE_API {
pss_synch_t obj;
struct pss_synch_init {
srslte_pss_synch_t obj;
struct srslte_pss_synch_init {
int frame_size; // if 0, 2048
int unsync_nof_pkts;
int N_id_2;
@ -139,19 +139,19 @@ typedef struct SRSLTE_API {
} init;
cf_t *input;
int in_len;
struct pss_synch_ctrl_in {
struct srslte_pss_synch_tctrl_in {
int correlation_threshold;
float manual_cfo;
} ctrl_in;
cf_t *output;
int out_len;
}pss_synch_hl;
}srslte_pss_synch_hl;
#define DEFAULT_FRAME_SIZE 2048
SRSLTE_API int pss_synch_initialize(pss_synch_hl* h);
SRSLTE_API int pss_synch_work(pss_synch_hl* hl);
SRSLTE_API int pss_synch_stop(pss_synch_hl* hl);
SRSLTE_API int srslte_pss_synch_initialize(srslte_pss_synch_hl* h);
SRSLTE_API int srslte_pss_synch_twork(srslte_pss_synch_hl* hl);
SRSLTE_API int srslte_pss_synch_tstop(srslte_pss_synch_hl* hl);
#endif // PSS_

10
srslte/include/srslte/sync/sfo.h
Unescape Escape View File

@ -31,7 +31,13 @@
#include "srslte/config.h"
SRSLTE_API float sfo_estimate(int *t0, int len, float period);
SRSLTE_API float sfo_estimate_period(int *t0, int *t, int len, float period);
SRSLTE_API float srslte_sfo_estimate(int *t0,
int len,
float period);
SRSLTE_API float srslte_sfo_estimate_period(int *t0,
int *t,
int len,
float period);
#endif // SFO_

174
srslte/include/srslte/sync/sss.h
Unescape Escape View File

@ -34,29 +34,29 @@
#include "srslte/config.h"
#include "srslte/common/phy_common.h"
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
typedef _Complex float cf_t; /* this is only a shortcut */
#define N_SSS 31
#define SSS_LEN 2*N_SSS
#define SRSLTE_SSS_N 31
#define SRSLTE_SSS_LEN 2*SRSLTE_SSS_N
struct sss_tables{
int z1[N_SSS][N_SSS];
int c[2][N_SSS];
int s[N_SSS][N_SSS];
};
typedef struct SRSLTE_API {
int z1[SRSLTE_SSS_N][SRSLTE_SSS_N];
int c[2][SRSLTE_SSS_N];
int s[SRSLTE_SSS_N][SRSLTE_SSS_N];
}srslte_sss_tables_t;
/* Allocate 32 complex to make it multiple of 32-byte AVX instructions alignment requirement.
* Should use vec_malloc() to make it platform agnostic.
* Should use srslte_vec_malloc() to make it platform agnostic.
*/
struct fc_tables{
float z1[N_SSS][N_SSS];
float c[2][N_SSS];
float s[N_SSS][N_SSS];
float sd[N_SSS][N_SSS-1];
};
typedef struct SRSLTE_API {
float z1[SRSLTE_SSS_N][SRSLTE_SSS_N];
float c[2][SRSLTE_SSS_N];
float s[SRSLTE_SSS_N][SRSLTE_SSS_N];
float sd[SRSLTE_SSS_N][SRSLTE_SSS_N-1];
}srslte_sss_fc_tables_t;
/* Low-level API */
@ -72,107 +72,107 @@ typedef struct SRSLTE_API {
uint32_t N_id_2;
uint32_t N_id_1_table[30][30];
struct fc_tables fc_tables[3]; // one for each N_id_2
srslte_sss_fc_tables_t fc_tables[3]; // one for each N_id_2
float corr_output_m0[N_SSS];
float corr_output_m1[N_SSS];
float corr_output_m0[SRSLTE_SSS_N];
float corr_output_m1[SRSLTE_SSS_N];
}sss_synch_t;
}srslte_sss_synch_t;
/* Basic functionality */
SRSLTE_API int sss_synch_init(sss_synch_t *q,
uint32_t fft_size);
SRSLTE_API int sss_synch_realloc(sss_synch_t *q,
uint32_t fft_size);
SRSLTE_API void sss_synch_free(sss_synch_t *q);
SRSLTE_API void sss_generate(float *signal0,
float *signal5,
uint32_t cell_id);
SRSLTE_API void sss_put_slot(float *sss,
cf_t *symbol,
uint32_t nof_prb,
srslte_cp_t cp);
SRSLTE_API int sss_synch_set_N_id_2(sss_synch_t *q,
uint32_t N_id_2);
SRSLTE_API int sss_synch_m0m1_partial(sss_synch_t *q,
cf_t *input,
uint32_t M,
cf_t ce[2*N_SSS],
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API int sss_synch_m0m1_diff_coh(sss_synch_t *q,
cf_t *input,
cf_t ce[2*N_SSS],
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API int sss_synch_m0m1_diff(sss_synch_t *q,
cf_t *input,
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API uint32_t sss_synch_subframe(uint32_t m0,
SRSLTE_API int srslte_sss_synch_init(srslte_sss_synch_t *q,
uint32_t fft_size);
SRSLTE_API int srslte_sss_synch_realloc(srslte_sss_synch_t *q,
uint32_t fft_size);
SRSLTE_API void srslte_sss_synch_free(srslte_sss_synch_t *q);
SRSLTE_API void srslte_sss_generate(float *signal0,
float *signal5,
uint32_t cell_id);
SRSLTE_API void srslte_sss_put_slot(float *sss,
cf_t *symbol,
uint32_t nof_prb,
srslte_cp_t cp);
SRSLTE_API int srslte_sss_synch_set_N_id_2(srslte_sss_synch_t *q,
uint32_t N_id_2);
SRSLTE_API int srslte_sss_synch_m0m1_partial(srslte_sss_synch_t *q,
cf_t *input,
uint32_t M,
cf_t ce[2*SRSLTE_SSS_N],
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API int srslte_sss_synch_m0m1_diff_coh(srslte_sss_synch_t *q,
cf_t *input,
cf_t ce[2*SRSLTE_SSS_N],
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API int srslte_sss_synch_m0m1_diff(srslte_sss_synch_t *q,
cf_t *input,
uint32_t *m0,
float *m0_value,
uint32_t *m1,
float *m1_value);
SRSLTE_API uint32_t srslte_sss_synch_subframe(uint32_t m0,
uint32_t m1);
SRSLTE_API int srslte_sss_synch_N_id_1(srslte_sss_synch_t *q,
uint32_t m0,
uint32_t m1);
SRSLTE_API int sss_synch_N_id_1(sss_synch_t *q,
uint32_t m0,
uint32_t m1);
SRSLTE_API int sss_synch_frame(sss_synch_t *q,
cf_t *input,
uint32_t *subframe_idx,
uint32_t *N_id_1);
SRSLTE_API int srslte_sss_synch_frame(srslte_sss_synch_t *q,
cf_t *input,
uint32_t *subframe_idx,
uint32_t *N_id_1);
SRSLTE_API void sss_synch_set_threshold(sss_synch_t *q,
float threshold);
SRSLTE_API void srslte_sss_synch_set_threshold(srslte_sss_synch_t *q,
float threshold);
SRSLTE_API void sss_synch_set_symbol_sz(sss_synch_t *q,
uint32_t symbol_sz);
SRSLTE_API void srslte_sss_synch_set_symbol_sz(srslte_sss_synch_t *q,
uint32_t symbol_sz);
SRSLTE_API void sss_synch_set_subframe_sz(sss_synch_t *q,
uint32_t subframe_sz);
SRSLTE_API void srslte_sss_synch_set_subframe_sz(srslte_sss_synch_t *q,
uint32_t subframe_sz);
/* High-level API */
typedef struct SRSLTE_API {
sss_synch_t obj;
struct sss_synch_init {
srslte_sss_synch_t obj;
struct srslte_sss_synch_init {
uint32_t N_id_2;
} init;
cf_t *input;
uint32_t in_len;
struct sss_synch_ctrl_in {
struct srslte_sss_synch_ctrl_in {
uint32_t symbol_sz;
uint32_t subframe_sz;
uint32_t correlation_threshold;
} ctrl_in;
struct sss_synch_ctrl_out {
struct srslte_sss_synch_ctrl_out {
uint32_t subframe_idx;
uint32_t N_id_1;
} ctrl_out;
}sss_synch_hl;
}srslte_sss_synch_hl;
#define DEFAULT_FRAME_SIZE 2048
SRSLTE_API int sss_synch_initialize(sss_synch_hl* h);
SRSLTE_API int sss_synch_work(sss_synch_hl* hl);
SRSLTE_API int sss_synch_stop(sss_synch_hl* hl);
SRSLTE_API int srslte_sss_synch_initialize(srslte_sss_synch_hl* h);
SRSLTE_API int srslte_sss_synch_work(srslte_sss_synch_hl* hl);
SRSLTE_API int srslte_sss_synch_stop(srslte_sss_synch_hl* hl);
#endif // SSS_

83
srslte/include/srslte/sync/sync.h
Unescape Escape View File

@ -37,8 +37,8 @@
#include "srslte/sync/sss.h"
#include "srslte/sync/cfo.h"
#define FFT_SIZE_MIN 64
#define FFT_SIZE_MAX 2048
#define SRSLTE_SYNC_FFT_SZ_MIN 64
#define SRSLTE_SYNC_FFT_SZ_MAX 2048
/**
*
@ -55,8 +55,8 @@
typedef enum {SSS_DIFF=0, SSS_PARTIAL_3=2, SSS_FULL=1} sss_alg_t;
typedef struct SRSLTE_API {
pss_synch_t pss;
sss_synch_t sss;
srslte_pss_synch_t pss;
srslte_sss_synch_t sss;
float threshold;
float peak_value;
float mean_peak_value;
@ -66,7 +66,7 @@ typedef struct SRSLTE_API {
uint32_t fft_size;
uint32_t frame_size;
float mean_cfo;
cfo_t cfocorr;
srslte_cfo_t cfocorr;
sss_alg_t sss_alg;
bool detect_cp;
bool sss_en;
@ -79,79 +79,80 @@ typedef struct SRSLTE_API {
float M_norm_avg;
float M_ext_avg;
}sync_t;
}srslte_sync_t;
SRSLTE_API int sync_init(sync_t *q,
uint32_t frame_size,
uint32_t fft_size);
SRSLTE_API int srslte_sync_init(srslte_sync_t *q,
uint32_t frame_size,
uint32_t fft_size);
SRSLTE_API void sync_free(sync_t *q);
SRSLTE_API void srslte_sync_free(srslte_sync_t *q);
SRSLTE_API void sync_reset(sync_t *q);
SRSLTE_API void srslte_sync_reset(srslte_sync_t *q);
/* Finds a correlation peak in the input signal around position find_offset */
SRSLTE_API int sync_find(sync_t *q,
cf_t *input,
uint32_t find_offset,
uint32_t *peak_position);
SRSLTE_API int srslte_sync_find(srslte_sync_t *q,
cf_t *input,
uint32_t find_offset,
uint32_t *peak_position);
/* Estimates the CP length */
SRSLTE_API srslte_cp_t sync_detect_cp(sync_t *q,
cf_t *input,
uint32_t peak_pos);
SRSLTE_API srslte_cp_t srslte_sync_detect_cp(srslte_sync_t *q,
cf_t *input,
uint32_t peak_pos);
/* Sets the threshold for peak comparison */
SRSLTE_API void sync_set_threshold(sync_t *q,
float threshold);
SRSLTE_API void srslte_sync_set_threshold(srslte_sync_t *q,
float threshold);
/* Gets the subframe idx (0 or 5) */
SRSLTE_API uint32_t sync_get_sf_idx(sync_t *q);
SRSLTE_API uint32_t srslte_sync_get_sf_idx(srslte_sync_t *q);
/* Gets the last peak value */
SRSLTE_API float sync_get_last_peak_value(sync_t *q);
SRSLTE_API float srslte_sync_get_last_peak_value(srslte_sync_t *q);
/* Gets the mean peak value */
SRSLTE_API float sync_get_peak_value(sync_t *q);
SRSLTE_API float srslte_sync_get_peak_value(srslte_sync_t *q);
/* Choose SSS detection algorithm */
SRSLTE_API void sync_set_sss_algorithm(sync_t *q,
sss_alg_t alg);
SRSLTE_API void srslte_sync_set_sss_algorithm(srslte_sync_t *q,
sss_alg_t alg);
/* Sets PSS exponential averaging alpha weight */
SRSLTE_API void sync_set_em_alpha(sync_t *q,
float alpha);
SRSLTE_API void srslte_sync_set_em_alpha(srslte_sync_t *q,
float alpha);
/* Sets the N_id_2 to search for */
SRSLTE_API int sync_set_N_id_2(sync_t *q,
uint32_t N_id_2);
SRSLTE_API int srslte_sync_set_N_id_2(srslte_sync_t *q,
uint32_t N_id_2);
/* Gets the Physical CellId from the last call to synch_run() */
SRSLTE_API int sync_get_cell_id(sync_t *q);
SRSLTE_API int srslte_sync_get_cell_id(srslte_sync_t *q);
/* Gets the CFO estimation from the last call to synch_run() */
SRSLTE_API float sync_get_cfo(sync_t *q);
SRSLTE_API float srslte_sync_get_cfo(srslte_sync_t *q);
/* Gets the CP length estimation from the last call to synch_run() */
SRSLTE_API srslte_cp_t sync_get_cp(sync_t *q);
SRSLTE_API srslte_cp_t srslte_sync_get_cp(srslte_sync_t *q);
/* Sets the CP length estimation (must do it if disabled) */
SRSLTE_API void sync_set_cp(sync_t *q, srslte_cp_t cp);
SRSLTE_API void srslte_sync_set_cp(srslte_sync_t *q,
srslte_cp_t cp);
/* Enables/Disables SSS detection */
SRSLTE_API void sync_sss_en(sync_t *q,
bool enabled);
SRSLTE_API void srslte_sync_sss_en(srslte_sync_t *q,
bool enabled);
SRSLTE_API bool sync_sss_detected(sync_t *q);
SRSLTE_API bool srslte_sync_sss_detected(srslte_sync_t *q);
SRSLTE_API bool sync_sss_is_en(sync_t *q);
SRSLTE_API bool srslte_sync_sss_is_en(srslte_sync_t *q);
/* Enables/Disables CP detection */
SRSLTE_API void sync_cp_en(sync_t *q,
bool enabled);
SRSLTE_API void srslte_sync_cp_en(srslte_sync_t *q,
bool enabled);
SRSLTE_API void sync_correct_cfo(sync_t *q,
bool enabled);
SRSLTE_API void srslte_sync_correct_cfo(srslte_sync_t *q,
bool enabled);
#endif // SYNC_

62
srslte/include/srslte/ue/ue_cell_search.h
Unescape Escape View File

@ -36,7 +36,7 @@
#include "srslte/sync/cfo.h"
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/phch/pbch.h"
#include "srslte/common/fft.h"
#include "srslte/dft/ofdm.h"
/************************************************************
*
@ -44,8 +44,8 @@
* several synchronized frames and obtains the most common cell_id
* and cp length.
*
* The I/O stream device sampling frequency must be set to 1.92 MHz (CS_SAMP_FREQ constant)
* before calling to ue_cell_search_scan() functions.
* The I/O stream device sampling frequency must be set to 1.92 MHz (SRSLTE_CS_SAMP_FREQ constant)
* before calling to srslte_ue_cellsearch_scan() functions.
*
************************************************************/
@ -53,14 +53,14 @@
* TODO: Check also peak offset
*/
#define CS_DEFAULT_MAXFRAMES_TOTAL 500
#define CS_DEFAULT_MAXFRAMES_DETECTED 50
#define SRSLTE_CS_DEFAULT_MAXFRAMES_TOTAL 500
#define SRSLTE_CS_DEFAULT_MAXFRAMES_DETECTED 50
#define CS_DEFAULT_NOFFRAMES_TOTAL 50
#define CS_DEFAULT_NOFFRAMES_DETECTED 10
#define SRSLTE_CS_DEFAULT_NOFFRAMES_TOTAL 50
#define SRSLTE_CS_DEFAULT_NOFFRAMES_DETECTED 10
#define CS_NOF_PRB 6
#define CS_SAMP_FREQ 1920000.0
#define SRSLTE_CS_NOF_PRB 6
#define SRSLTE_CS_SAMP_FREQ 1920000.0
typedef struct SRSLTE_API {
uint32_t cell_id;
@ -68,11 +68,11 @@ typedef struct SRSLTE_API {
float peak;
float mode;
float psr;
} ue_cell_search_result_t;
} srslte_ue_cellsearch_result_t;
typedef struct SRSLTE_API {
ue_sync_t ue_sync;
srslte_ue_sync_t ue_sync;
uint32_t max_frames;
uint32_t nof_frames_to_scan; // number of 5 ms frames to scan
@ -81,34 +81,34 @@ typedef struct SRSLTE_API {
uint32_t *mode_ntimes;
uint8_t *mode_counted;
ue_cell_search_result_t *candidates;
} ue_cell_search_t;
srslte_ue_cellsearch_result_t *candidates;
} srslte_ue_cellsearch_t;
SRSLTE_API int ue_cell_search_init(ue_cell_search_t *q,
int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API int srslte_ue_cellsearch_init(srslte_ue_cellsearch_t *q,
int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API int ue_cell_search_init_max(ue_cell_search_t *q,
uint32_t max_frames_total,
int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API int srslte_ue_cellsearch_init_max(srslte_ue_cellsearch_t *q,
uint32_t max_frames_total,
int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API void ue_cell_search_free(ue_cell_search_t *q);
SRSLTE_API void srslte_ue_cellsearch_free(srslte_ue_cellsearch_t *q);
SRSLTE_API int ue_cell_search_scan_N_id_2(ue_cell_search_t *q,
uint32_t N_id_2,
ue_cell_search_result_t *found_cell);
SRSLTE_API int srslte_ue_cellsearch_scan_N_id_2(srslte_ue_cellsearch_t *q,
uint32_t N_id_2,
srslte_ue_cellsearch_result_t *found_cell);
SRSLTE_API int ue_cell_search_scan(ue_cell_search_t * q,
ue_cell_search_result_t found_cells[3],
uint32_t *max_N_id_2);
SRSLTE_API int srslte_ue_cellsearch_scan(srslte_ue_cellsearch_t * q,
srslte_ue_cellsearch_result_t found_cells[3],
uint32_t *max_N_id_2);
SRSLTE_API int ue_cell_search_set_nof_frames_to_scan(ue_cell_search_t *q,
uint32_t nof_frames);
SRSLTE_API int srslte_ue_cellsearch_set_nof_frames_to_scan(srslte_ue_cellsearch_t *q,
uint32_t nof_frames);
SRSLTE_API void ue_cell_search_set_threshold(ue_cell_search_t *q,
float threshold);
SRSLTE_API void srslte_ue_cellsearch_set_threshold(srslte_ue_cellsearch_t *q,
float threshold);

114
srslte/include/srslte/ue/ue_dl.h
Unescape Escape View File

@ -37,7 +37,7 @@
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/common/fft.h"
#include "srslte/dft/ofdm.h"
#include "srslte/common/phy_common.h"
#include "srslte/phch/dci.h"
@ -53,18 +53,18 @@
#include "srslte/config.h"
#define NOF_HARQ_PROCESSES 8
#define SRSLTE_UE_UL_NOF_HARQ_PROCESSES 8
typedef struct SRSLTE_API {
pcfich_t pcfich;
pdcch_t pdcch;
pdsch_t pdsch;
harq_t harq_process[NOF_HARQ_PROCESSES];
regs_t regs;
srslte_fft_t fft;
srslte_pcfich_t pcfich;
srslte_pdcch_t pdcch;
srslte_pdsch_t pdsch;
srslte_harq_t harq_process[SRSLTE_UE_UL_NOF_HARQ_PROCESSES];
srslte_regs_t regs;
srslte_ofdm_t fft;
srslte_chest_dl_t chest;
ra_pdsch_t ra_dl;
srslte_ra_pdsch_t ra_dl;
srslte_cell_t cell;
@ -73,57 +73,57 @@ typedef struct SRSLTE_API {
uint64_t pkt_errors;
uint64_t pkts_total;
uint64_t nof_pdcch_detected;
uint64_t nof_detected;
uint16_t current_rnti;
}ue_dl_t;
}srs_ue_dl_t;
/* This function shall be called just after the initial synchronization */
SRSLTE_API int ue_dl_init(ue_dl_t *q,
srslte_cell_t cell);
SRSLTE_API void ue_dl_free(ue_dl_t *q);
SRSLTE_API int ue_dl_decode_fft_estimate(ue_dl_t *q,
cf_t *input,
uint32_t sf_idx,
uint32_t *cfi);
SRSLTE_API int ue_dl_decode_rnti_rv_packet(ue_dl_t *q,
dci_msg_t *dci_msg,
uint8_t *data,
uint32_t cfi,
uint32_t sf_idx,
uint16_t rnti,
uint32_t rvidx);
SRSLTE_API int ue_dl_find_ul_dci(ue_dl_t *q,
dci_msg_t *dci_msg,
uint32_t cfi,
uint32_t sf_idx,
uint16_t rnti);
SRSLTE_API int ue_dl_decode(ue_dl_t * q,
cf_t *input,
uint8_t *data,
uint32_t sf_idx);
SRSLTE_API int ue_dl_decode_rnti(ue_dl_t * q,
cf_t *input,
uint8_t *data,
uint32_t sf_idx,
uint16_t rnti);
SRSLTE_API int ue_dl_decode_rnti_rv(ue_dl_t * q,
cf_t *input,
uint8_t * data,
uint32_t sf_idx,
uint16_t rnti,
uint32_t rvidx);
SRSLTE_API void ue_dl_reset(ue_dl_t *q);
SRSLTE_API void ue_dl_set_rnti(ue_dl_t *q,
uint16_t rnti);
SRSLTE_API int srs_ue_dl_init(srs_ue_dl_t *q,
srslte_cell_t cell);
SRSLTE_API void srs_ue_dl_free(srs_ue_dl_t *q);
SRSLTE_API int srs_ue_dl_decode_fft_estimate(srs_ue_dl_t *q,
cf_t *input,
uint32_t sf_idx,
uint32_t *cfi);
SRSLTE_API int srs_ue_dl_decode_rnti_rv_packet(srs_ue_dl_t *q,
srslte_dci_msg_t *dci_msg,
uint8_t *data,
uint32_t cfi,
uint32_t sf_idx,
uint16_t rnti,
uint32_t rvidx);
SRSLTE_API int srs_ue_dl_find_ul_dci(srs_ue_dl_t *q,
srslte_dci_msg_t *dci_msg,
uint32_t cfi,
uint32_t sf_idx,
uint16_t rnti);
SRSLTE_API int srs_ue_dl_decode(srs_ue_dl_t * q,
cf_t *input,
uint8_t *data,
uint32_t sf_idx);
SRSLTE_API int srs_ue_dl_decode_rnti(srs_ue_dl_t * q,
cf_t *input,
uint8_t *data,
uint32_t sf_idx,
uint16_t rnti);
SRSLTE_API int srs_ue_dl_decode_rnti_rv(srs_ue_dl_t * q,
cf_t *input,
uint8_t * data,
uint32_t sf_idx,
uint16_t rnti,
uint32_t rvidx);
SRSLTE_API void srs_ue_dl_reset(srs_ue_dl_t *q);
SRSLTE_API void srs_ue_dl_set_rnti(srs_ue_dl_t *q,
uint16_t rnti);
#endif

2
srslte/include/srslte/ue/ue_mac_itf.h
Unescape Escape View File

@ -1,5 +1,5 @@
class ue_mac_itf
class srslte_ue_mac_itf
{
public:
virtual void ready_to_send() = 0;

70
srslte/include/srslte/ue/ue_mib.h
Unescape Escape View File

@ -33,7 +33,7 @@
*
* This object decodes the MIB from the PBCH of an LTE signal.
*
* The function ue_mib_decode() shall be called multiple times,
* The function srslte_ue_mib_decode() shall be called multiple times,
* each passing a number of samples multiple of 19200, sampled at 1.92 MHz
* (that is, 10 ms of samples).
*
@ -53,69 +53,69 @@
#include "srslte/sync/cfo.h"
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/phch/pbch.h"
#include "srslte/common/fft.h"
#include "srslte/dft/ofdm.h"
#define MIB_SRSLTE_MAX_PORTS 4
#define MIB_NOF_PRB 6
#define SRSLTE_UE_MIB_MAX_PORTS 4
#define SRSLTE_UE_MIB_NOF_PRB 6
#define MIB_FOUND 1
#define MIB_NOTFOUND 0
#define SRSLTE_UE_MIB_FOUND 1
#define SRSLTE_UE_MIB_NOTFOUND 0
typedef struct SRSLTE_API {
sync_t sfind;
srslte_sync_t sfind;
cf_t *sf_symbols;
cf_t *ce[MIB_SRSLTE_MAX_PORTS];
cf_t *ce[SRSLTE_UE_MIB_MAX_PORTS];
srslte_fft_t fft;
srslte_ofdm_t fft;
srslte_chest_dl_t chest;
pbch_t pbch;
srslte_pbch_t pbch;
uint8_t bch_payload[BCH_PAYLOAD_LEN];
uint32_t nof_tx_ports;
uint32_t sfn_offset;
uint32_t frame_cnt;
} ue_mib_t;
} srslte_ue_mib_t;
SRSLTE_API int ue_mib_init(ue_mib_t *q,
srslte_cell_t cell);
SRSLTE_API int srslte_ue_mib_init(srslte_ue_mib_t *q,
srslte_cell_t cell);
SRSLTE_API void ue_mib_free(ue_mib_t *q);
SRSLTE_API void srslte_ue_mib_free(srslte_ue_mib_t *q);
SRSLTE_API void ue_mib_reset(ue_mib_t * q);
SRSLTE_API void srslte_ue_mib_reset(srslte_ue_mib_t * q);
SRSLTE_API int ue_mib_decode(ue_mib_t * q,
cf_t *input,
uint8_t bch_payload[BCH_PAYLOAD_LEN],
uint32_t *nof_tx_ports,
uint32_t *sfn_offset);
SRSLTE_API int srslte_ue_mib_decode(srslte_ue_mib_t * q,
cf_t *input,
uint8_t bch_payload[BCH_PAYLOAD_LEN],
uint32_t *nof_tx_ports,
uint32_t *sfn_offset);
/* This interface uses ue_mib and ue_sync to first get synchronized subframes
* and then decode MIB
*/
typedef struct {
ue_mib_t ue_mib;
ue_sync_t ue_sync;
} ue_mib_sync_t;
srslte_ue_mib_t ue_mib;
srslte_ue_sync_t ue_sync;
} srslte_ue_mib_sync_t;
SRSLTE_API int ue_mib_sync_init(ue_mib_sync_t *q,
uint32_t cell_id,
srslte_cp_t cp,
int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t *),
void *stream_handler);
SRSLTE_API int srslte_ue_mib_sync_init(srslte_ue_mib_sync_t *q,
uint32_t cell_id,
srslte_cp_t cp,
int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t *),
void *stream_handler);
SRSLTE_API void ue_mib_sync_free(ue_mib_sync_t *q);
SRSLTE_API void srslte_ue_mib_sync_free(srslte_ue_mib_sync_t *q);
SRSLTE_API void ue_mib_sync_reset(ue_mib_sync_t * q);
SRSLTE_API void srslte_ue_mib_sync_reset(srslte_ue_mib_sync_t * q);
SRSLTE_API int ue_mib_sync_decode(ue_mib_sync_t * q,
uint32_t max_frames_timeout,
uint8_t bch_payload[BCH_PAYLOAD_LEN],
uint32_t *nof_tx_ports,
uint32_t *sfn_offset);
SRSLTE_API int srslte_ue_mib_sync_decode(srslte_ue_mib_sync_t * q,
uint32_t max_frames_timeout,
uint8_t bch_payload[BCH_PAYLOAD_LEN],
uint32_t *nof_tx_ports,
uint32_t *sfn_offset);

10
srslte/include/srslte/ue/ue_phy.h
Unescape Escape View File

@ -33,7 +33,7 @@
typedef _Complex float cf_t;
class ue_phy
class srslte_ue_phy
{
public:
@ -55,7 +55,7 @@ public:
bool is_tpc_pucch = false;
};
class pdcch_dl_search : public queue::element {
class dl_search : public queue::element {
public:
set_crnti(uint16_t rnti);
set_crnti_ra_procedure(uint16_t rnti);
@ -169,7 +169,7 @@ public:
void set_param();
pdcch_ul_search* get_pdcch_ul_search(uint32_t tti);
pdcch_dl_search* get_pdcch_dl_search(uint32_t tti);
dl_search* get_dl_search(uint32_t tti);
ul_assignment* get_ul_assignment(uint32_t tti);
dl_assignment* get_dl_assignment(uint32_t tti);
phich_assignment* get_phich_assignment(uint32_t tti);
@ -183,11 +183,11 @@ private:
IDLE, MEASURE, RX_BCH, RXTX
} phy_state;
bool prach_initiated = false;
bool srslte_prach_initiated = false;
bool prach_ready_to_send = false;
queue pdcch_ul_search;
queue pdcch_dl_search;
queue dl_search;
queue ul_assignment;
queue dl_assignment;
queue phich_assignment;

62
srslte/include/srslte/ue/ue_sync.h
Unescape Escape View File

@ -35,7 +35,7 @@
#include "srslte/sync/cfo.h"
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/phch/pbch.h"
#include "srslte/common/fft.h"
#include "srslte/dft/ofdm.h"
#include "srslte/common/timestamp.h"
#include "srslte/io/filesource.h"
@ -43,26 +43,26 @@
*
* This object automatically manages the cell synchronization procedure.
*
* The main function is ue_sync_get_buffer(), which returns a pointer
* The main function is srslte_ue_sync_get_buffer(), which returns a pointer
* to the aligned subframe of samples (before FFT). This function
* should be called regularly, returning every 1 ms. It reads from the
* USRP, aligns the samples to the subframe and performs time/freq synch.
*
* It is also possible to read the signal from a file using the init function
* ue_sync_init_file(). The sampling frequency is derived from the number of PRB.
* srslte_ue_sync_init_file(). The sampling frequency is derived from the number of PRB.
*
* The function returns 1 when the signal is correctly acquired and the
* returned buffer is aligned with the subframe.
*
*************************************************************/
typedef enum SRSLTE_API { SF_FIND, SF_TRACK} ue_sync_state_t;
typedef enum SRSLTE_API { SF_FIND, SF_TRACK} srslte_ue_sync_state_t;
//#define MEASURE_EXEC_TIME
typedef struct SRSLTE_API {
sync_t sfind;
sync_t strack;
srslte_sync_t sfind;
srslte_sync_t strack;
void *stream;
int (*recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*);
@ -71,13 +71,13 @@ typedef struct SRSLTE_API {
srslte_filesource_t file_source;
bool file_mode;
ue_sync_state_t state;
srslte_ue_sync_state_t state;
cf_t *input_buffer;
uint32_t frame_len;
uint32_t fft_size;
uint32_t nof_recv_sf; // Number of subframes received each call to ue_sync_get_buffer
uint32_t nof_recv_sf; // Number of subframes received each call to srslte_ue_sync_get_buffer
uint32_t nof_avg_find_frames;
uint32_t frame_find_cnt;
uint32_t sf_len;
@ -102,43 +102,43 @@ typedef struct SRSLTE_API {
#ifdef MEASURE_EXEC_TIME
float mean_exec_time;
#endif
} ue_sync_t;
} srslte_ue_sync_t;
SRSLTE_API int ue_sync_init(ue_sync_t *q,
srslte_cell_t cell,
int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API int srslte_ue_sync_init(srslte_ue_sync_t *q,
srslte_cell_t cell,
int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*),
void *stream_handler);
SRSLTE_API int ue_sync_init_file(ue_sync_t *q,
uint32_t nof_prb,
char *file_name);
SRSLTE_API int srslte_ue_sync_init_file(srslte_ue_sync_t *q,
uint32_t nof_prb,
char *file_name);
SRSLTE_API void ue_sync_free(ue_sync_t *q);
SRSLTE_API void srslte_ue_sync_free(srslte_ue_sync_t *q);
SRSLTE_API uint32_t ue_sync_sf_len(ue_sync_t *q);
SRSLTE_API uint32_t srslte_ue_sync_sf_len(srslte_ue_sync_t *q);
SRSLTE_API int ue_sync_get_buffer(ue_sync_t *q,
cf_t **sf_symbols);
SRSLTE_API int srslte_ue_sync_get_buffer(srslte_ue_sync_t *q,
cf_t **sf_symbols);
SRSLTE_API void ue_sync_reset(ue_sync_t *q);
SRSLTE_API void srslte_ue_sync_reset(srslte_ue_sync_t *q);
SRSLTE_API void ue_sync_set_N_id_2(ue_sync_t *q,
uint32_t N_id_2);
SRSLTE_API void ue_srslte_sync_set_N_id_2(srslte_ue_sync_t *q,
uint32_t N_id_2);
SRSLTE_API void ue_sync_decode_sss_on_track(ue_sync_t *q,
bool enabled);
SRSLTE_API void srslte_ue_sync_decode_sss_on_track(srslte_ue_sync_t *q,
bool enabled);
SRSLTE_API ue_sync_state_t ue_sync_get_state(ue_sync_t *q);
SRSLTE_API srslte_ue_sync_state_t srslte_ue_sync_get_state(srslte_ue_sync_t *q);
SRSLTE_API uint32_t ue_sync_get_sfidx(ue_sync_t *q);
SRSLTE_API uint32_t srslte_ue_sync_get_sfidx(srslte_ue_sync_t *q);
SRSLTE_API float ue_sync_get_cfo(ue_sync_t *q);
SRSLTE_API float srslte_ue_sync_get_cfo(srslte_ue_sync_t *q);
SRSLTE_API float ue_sync_get_sfo(ue_sync_t *q);
SRSLTE_API float srslte_ue_sync_get_sfo(srslte_ue_sync_t *q);
SRSLTE_API void ue_sync_get_last_timestamp(ue_sync_t *q,
srslte_timestamp_t *timestamp);
SRSLTE_API void srslte_ue_sync_get_last_timestamp(srslte_ue_sync_t *q,
srslte_timestamp_t *timestamp);

110
srslte/include/srslte/ue/ue_ul.h
Unescape Escape View File

@ -37,7 +37,7 @@
#include "srslte/common/phy_common.h"
#include "srslte/ch_estimation/chest_dl.h"
#include "srslte/common/fft.h"
#include "srslte/dft/ofdm.h"
#include "srslte/ch_estimation/refsignal_ul.h"
#include "srslte/phch/pusch.h"
#include "srslte/phch/ra.h"
@ -47,76 +47,76 @@
#include "srslte/config.h"
#define NOF_HARQ_PROCESSES 8
#define SRSLTE_UE_UL_NOF_HARQ_PROCESSES 8
typedef struct SRSLTE_API {
srslte_fft_t fft;
cfo_t cfo;
srslte_ofdm_t fft;
srslte_cfo_t cfo;
srslte_cell_t cell;
bool normalize_en;
float current_cfo;
srslte_refsignal_drms_pusch_cfg_t pusch_drms_cfg;
srslte_refsignal_drms_pusch_cfg_t drms_cfg;
srslte_refsignal_ul_t drms;
harq_t harq_process[NOF_HARQ_PROCESSES];
pusch_t pusch;
srslte_harq_t harq_process[SRSLTE_UE_UL_NOF_HARQ_PROCESSES];
srslte_pusch_t pusch;
cf_t *refsignal;
cf_t *sf_symbols;
uint16_t current_rnti;
}ue_ul_t;
}srslte_ue_ul_t;
/* This function shall be called just after the initial synchronization */
SRSLTE_API int ue_ul_init(ue_ul_t *q,
srslte_cell_t cell);
SRSLTE_API void ue_ul_free(ue_ul_t *q);
SRSLTE_API void ue_ul_set_cfo(ue_ul_t *q,
float cur_cfo);
SRSLTE_API void ue_ul_set_normalization(ue_ul_t *q,
bool enabled);
SRSLTE_API void ue_ul_set_pusch_cfg(ue_ul_t *q,
srslte_refsignal_drms_pusch_cfg_t *pusch_drms_cfg,
pusch_hopping_cfg_t *pusch_hopping_cfg);
SRSLTE_API int ue_ul_pusch_encode(ue_ul_t *q,
ra_pusch_t *ra_ul,
uint8_t *data,
uint32_t sf_idx,
cf_t *output_signal);
SRSLTE_API int ue_ul_pusch_encode_rnti(ue_ul_t *q,
ra_pusch_t *ra_ul,
uint8_t *data,
uint32_t sf_idx,
uint16_t rnti,
cf_t *output_signal);
SRSLTE_API int ue_ul_pusch_uci_encode(ue_ul_t *q,
ra_pusch_t *ra_ul,
uint8_t *data,
uci_data_t uci_data,
uint32_t sf_idx,
cf_t *output_signal);
SRSLTE_API int ue_ul_pusch_uci_encode_rnti(ue_ul_t *q,
ra_pusch_t *ra_ul,
uint8_t *data,
uci_data_t uci_data,
uint32_t sf_idx,
uint16_t rnti,
cf_t *output_signal);
SRSLTE_API void ue_ul_reset(ue_ul_t *q);
SRSLTE_API void ue_ul_set_rnti(ue_ul_t *q,
uint16_t rnti);
SRSLTE_API int srslte_ue_ul_init(srslte_ue_ul_t *q,
srslte_cell_t cell);
SRSLTE_API void srslte_ue_ul_free(srslte_ue_ul_t *q);
SRSLTE_API void srslte_ue_ul_set_cfo(srslte_ue_ul_t *q,
float cur_cfo);
SRSLTE_API void srslte_ue_ul_set_normalization(srslte_ue_ul_t *q,
bool enabled);
SRSLTE_API void srslte_ue_ul_set_pusch_cfg(srslte_ue_ul_t *q,
srslte_refsignal_drms_pusch_cfg_t *drms_cfg,
srslte_pusch_hopping_cfg_t *pusch_hopping_cfg);
SRSLTE_API int srslte_ue_ul_srslte_pusch_encode(srslte_ue_ul_t *q,
srslte_ra_pusch_t *ra_ul,
uint8_t *data,
uint32_t sf_idx,
cf_t *output_signal);
SRSLTE_API int srslte_ue_ul_srslte_pusch_encode_rnti(srslte_ue_ul_t *q,
srslte_ra_pusch_t *ra_ul,
uint8_t *data,
uint32_t sf_idx,
uint16_t rnti,
cf_t *output_signal);
SRSLTE_API int srslte_ue_ul_srslte_pusch_uci_encode(srslte_ue_ul_t *q,
srslte_ra_pusch_t *ra_ul,
uint8_t *data,
srslte_uci_data_t uci_data,
uint32_t sf_idx,
cf_t *output_signal);
SRSLTE_API int srslte_ue_ul_srslte_pusch_uci_encode_rnti(srslte_ue_ul_t *q,
srslte_ra_pusch_t *ra_ul,
uint8_t *data,
srslte_uci_data_t uci_data,
uint32_t sf_idx,
uint16_t rnti,
cf_t *output_signal);
SRSLTE_API void srslte_ue_ul_reset(srslte_ue_ul_t *q);
SRSLTE_API void srslte_ue_ul_set_rnti(srslte_ue_ul_t *q,
uint16_t rnti);
#endif

36
srslte/include/srslte/utils/bit.h
Unescape Escape View File

@ -34,30 +34,30 @@
#include "srslte/config.h"
SRSLTE_API void bit_pack_vector(uint8_t *bit_unpacked,
uint8_t *bits_packed,
int nof_bits);
SRSLTE_API void srslte_bit_pack_vector(uint8_t *srslte_bit_unpacked,
uint8_t *bits_packed,
int nof_bits);
SRSLTE_API void bit_unpack_vector(uint8_t *bits_packed,
uint8_t *bit_unpacked,
int nof_bits);
SRSLTE_API void srslte_bit_unpack_vector(uint8_t *bits_packed,
uint8_t *srslte_bit_unpacked,
int nof_bits);
SRSLTE_API uint32_t bit_unpack(uint8_t **bits,
int nof_bits);
SRSLTE_API uint32_t srslte_bit_unpack(uint8_t **bits,
int nof_bits);
SRSLTE_API void bit_pack(uint32_t value,
uint8_t **bits,
int nof_bits);
SRSLTE_API void srslte_bit_pack(uint32_t value,
uint8_t **bits,
int nof_bits);
SRSLTE_API void bit_fprint(FILE *stream,
uint8_t *bits,
int nof_bits);
SRSLTE_API void srslte_bit_fprint(FILE *stream,
uint8_t *bits,
int nof_bits);
SRSLTE_API uint32_t bit_diff(uint8_t *x,
uint8_t *y,
int nbits);
SRSLTE_API uint32_t srslte_bit_diff(uint8_t *x,
uint8_t *y,
int nbits);
SRSLTE_API uint32_t bit_count(uint32_t n);
SRSLTE_API uint32_t srslte_bit_count(uint32_t n);
#endif // BIT_

20
srslte/include/srslte/utils/cexptab.h
Unescape Escape View File

@ -38,20 +38,20 @@ typedef _Complex float cf_t;
typedef struct SRSLTE_API {
uint32_t size;
cf_t *tab;
}cexptab_t;
}srslte_cexptab_t;
SRSLTE_API int cexptab_init(cexptab_t *nco,
uint32_t size);
SRSLTE_API int srslte_cexptab_init(srslte_cexptab_t *nco,
uint32_t size);
SRSLTE_API void cexptab_free(cexptab_t *nco);
SRSLTE_API void srslte_cexptab_free(srslte_cexptab_t *nco);
SRSLTE_API void cexptab_gen(cexptab_t *nco,
cf_t *x,
float freq,
uint32_t len);
SRSLTE_API void cexptab_gen_direct(cf_t *x,
SRSLTE_API void srslte_cexptab_gen(srslte_cexptab_t *nco,
cf_t *x,
float freq,
uint32_t len);
SRSLTE_API void srslte_cexptab_gen_direct(cf_t *x,
float freq,
uint32_t len);
#endif // CEXPTAB_

50
srslte/include/srslte/utils/convolution.h
Unescape Escape View File

@ -30,7 +30,7 @@
#define CONVOLUTION_H_
#include "srslte/config.h"
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
typedef _Complex float cf_t;
@ -45,35 +45,35 @@ typedef struct SRSLTE_API {
srslte_dft_plan_t input_plan;
srslte_dft_plan_t filter_plan;
srslte_dft_plan_t output_plan;
}conv_fft_cc_t;
}srslte_conv_fft_cc_t;
SRSLTE_API int conv_fft_cc_init(conv_fft_cc_t *q,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API int srslte_conv_fft_cc_init(srslte_conv_fft_cc_t *q,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API void conv_fft_cc_free(conv_fft_cc_t *q);
SRSLTE_API void srslte_conv_fft_cc_free(srslte_conv_fft_cc_t *q);
SRSLTE_API uint32_t conv_fft_cc_run(conv_fft_cc_t *q,
cf_t *input,
cf_t *filter,
cf_t *output);
SRSLTE_API uint32_t srslte_conv_fft_cc_run(srslte_conv_fft_cc_t *q,
cf_t *input,
cf_t *filter,
cf_t *output);
SRSLTE_API uint32_t conv_cc(cf_t *input,
cf_t *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API uint32_t srslte_conv_cc(cf_t *input,
cf_t *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API uint32_t conv_same_cf(cf_t *input,
float *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API uint32_t srslte_conv_same_cf(cf_t *input,
float *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API uint32_t conv_same_cc(cf_t *input,
cf_t *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
SRSLTE_API uint32_t srslte_conv_same_cc(cf_t *input,
cf_t *filter,
cf_t *output,
uint32_t input_len,
uint32_t filter_len);
#endif // CONVOLUTION_H_

30
srslte/include/srslte/utils/debug.h
Unescape Escape View File

@ -31,36 +31,36 @@
#include <stdio.h>
#include "srslte/config.h"
#define VERBOSE_DEBUG 2
#define VERBOSE_INFO 1
#define VERBOSE_NONE 0
#define SRSLTE_VERBOSE_DEBUG 2
#define SRSLTE_VERBOSE_INFO 1
#define SRSLTE_VERBOSE_NONE 0
#include <sys/time.h>
SRSLTE_API void get_time_interval(struct timeval * tdata);
#ifndef DEBUG_DISABLED
#ifndef SRSLTE_DEBUG_DISABLED
SRSLTE_API extern int verbose;
SRSLTE_API extern int srslte_verbose;
#define VERBOSE_ISINFO() (verbose>=VERBOSE_INFO)
#define VERBOSE_ISDEBUG() (verbose>=VERBOSE_DEBUG)
#define VERBOSE_ISNONE() (verbose==VERBOSE_NONE)
#define SRSLTE_VERBOSE_ISINFO() (srslte_verbose>=SRSLTE_VERBOSE_INFO)
#define SRSLTE_VERBOSE_ISDEBUG() (srslte_verbose>=SRSLTE_VERBOSE_DEBUG)
#define SRSLTE_VERBOSE_ISNONE() (srslte_verbose==SRSLTE_VERBOSE_NONE)
#define PRINT_DEBUG verbose=VERBOSE_DEBUG
#define PRINT_INFO verbose=VERBOSE_INFO
#define PRINT_NONE verbose=VERBOSE_NONE
#define PRINT_DEBUG srslte_verbose=SRSLTE_VERBOSE_DEBUG
#define PRINT_INFO srslte_verbose=SRSLTE_VERBOSE_INFO
#define PRINT_NONE srslte_verbose=SRSLTE_VERBOSE_NONE
#define DEBUG(_fmt, ...) if (verbose >= VERBOSE_DEBUG) \
#define DEBUG(_fmt, ...) if (srslte_verbose >= SRSLTE_VERBOSE_DEBUG) \
fprintf(stdout, "[DEBUG]: " _fmt, __VA_ARGS__)
#define INFO(_fmt, ...) if (verbose >= VERBOSE_INFO) \
#define INFO(_fmt, ...) if (srslte_verbose >= SRSLTE_VERBOSE_INFO) \
fprintf(stdout, "[INFO]: " _fmt, __VA_ARGS__)
#else // DEBUG_DISABLED
#else // SRSLTE_DEBUG_DISABLED
#define DEBUG
#define INFO
#endif // DEBUG_DISABLED
#endif // SRSLTE_DEBUG_DISABLED
#endif // DEBUG_H

47
srslte/include/srslte/utils/matrix.h
Unescape Escape View File

@ -1,47 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2014 The srsLTE Developers. See the
* COPYRIGHT file at the top-level directory of this distribution.
*
* \section LICENSE
*
* This file is part of the srsLTE library.
*
* srsLTE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsLTE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* A copy of the GNU Lesser General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#ifndef MATRIX_
#define MATRIX_
#include <stdio.h>
#include "srslte/config.h"
typedef _Complex float cf_t;
SRSLTE_API int matrix_init(void ***m, int sz_x, int sz_y, int elem_sz);
SRSLTE_API void matrix_free(void **q, int sz_x);
SRSLTE_API void matrix_bzero(void **q, int sz_x, int sz_y, int elem_sz);
SRSLTE_API void matrix_fprintf_cf(FILE *f, cf_t **q, int sz_x, int sz_y);
SRSLTE_API void matrix_fprintf_f(FILE *f, float **q, int sz_x, int sz_y);
SRSLTE_API void matrix_copy(void **dst, void **src, int sz_x, int sz_y, int elem_sz);
SRSLTE_API void matrix_dotprod_cf(cf_t **x, cf_t **y, cf_t **out, int sz_x, int sz_y);
SRSLTE_API void matrix_dotprod_float(float **x, float **y, float **out, int sz_x, int sz_y);
SRSLTE_API void matrix_dotprod_int(int **x, int **y, int **out, int sz_x, int sz_y);
#endif // MATRIX_

40
srslte/include/srslte/utils/mux.h
Unescape Escape View File

@ -1,40 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2014 The srsLTE Developers. See the
* COPYRIGHT file at the top-level directory of this distribution.
*
* \section LICENSE
*
* This file is part of the srsLTE library.
*
* srsLTE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsLTE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* A copy of the GNU Lesser General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#ifndef MUX_
#define MUX_
#include "srslte/config.h"
SRSLTE_API void mux(void **input, void *output, int *input_lengths, int *input_padding_pre, int nof_inputs,
int sample_sz);
SRSLTE_API void demux(void *input, void **output, int *output_lengths,
int *output_padding_pre, int *output_padding_post, int nof_outputs,
int sample_sz);
#endif // MUX_

42
srslte/include/srslte/utils/pack.h
Unescape Escape View File

@ -1,42 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2014 The srsLTE Developers. See the
* COPYRIGHT file at the top-level directory of this distribution.
*
* \section LICENSE
*
* This file is part of the srsLTE library.
*
* srsLTE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsLTE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* A copy of the GNU Lesser General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#ifndef PACK_
#define PACK_
#include "srslte/config.h"
#include <stdint.h>
SRSLTE_API uint32_t unpack_bits(uint8_t **bits,
int nof_bits);
SRSLTE_API void pack_bits(uint32_t value,
uint8_t **bits,
int nof_bits);
#endif // PACK_

2
srslte/include/srslte/utils/queue.h
Unescape Escape View File

@ -30,7 +30,7 @@
#ifndef QUEUE_H
#define QUEUE_H
class queue
class srslte_queue
{
public:

102
srslte/include/srslte/utils/vector.h
Unescape Escape View File

@ -40,106 +40,106 @@ extern "C" {
typedef _Complex float cf_t;
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define SRSLTE_MAX(a,b) ((a)>(b)?(a):(b))
#define SRSLTE_MIN(a,b) ((a)<(b)?(a):(b))
// Cumulative moving average
#define VEC_CMA(data, average, n) ((average) + ((data) - (average)) / ((n)+1))
#define SRSLTE_VEC_CMA(data, average, n) ((average) + ((data) - (average)) / ((n)+1))
// Exponential moving average
#define VEC_EMA(data, average, alpha) ((alpha)*(data)+(1-alpha)*(average))
#define SRSLTE_VEC_EMA(data, average, alpha) ((alpha)*(data)+(1-alpha)*(average))
/** Return the sum of all the elements */
SRSLTE_API int vec_acc_ii(int *x, uint32_t len);
SRSLTE_API float vec_acc_ff(float *x, uint32_t len);
SRSLTE_API cf_t vec_acc_cc(cf_t *x, uint32_t len);
SRSLTE_API int srslte_vec_acc_ii(int *x, uint32_t len);
SRSLTE_API float srslte_vec_acc_ff(float *x, uint32_t len);
SRSLTE_API cf_t srslte_vec_acc_cc(cf_t *x, uint32_t len);
SRSLTE_API void *vec_malloc(uint32_t size);
SRSLTE_API void *srslte_vec_malloc(uint32_t size);
SRSLTE_API void *vec_realloc(void *ptr, uint32_t old_size, uint32_t new_size);
SRSLTE_API void *srslte_vec_realloc(void *ptr, uint32_t old_size, uint32_t new_size);
/* print vectors */
SRSLTE_API void vec_fprint_c(FILE *stream, cf_t *x, uint32_t len);
SRSLTE_API void vec_fprint_f(FILE *stream, float *x, uint32_t len);
SRSLTE_API void vec_fprint_b(FILE *stream, uint8_t *x, uint32_t len);
SRSLTE_API void vec_fprint_byte(FILE *stream, uint8_t *x, uint32_t len);
SRSLTE_API void vec_fprint_i(FILE *stream, int *x, uint32_t len);
SRSLTE_API void vec_fprint_hex(FILE *stream, uint8_t *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_c(FILE *stream, cf_t *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_f(FILE *stream, float *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_b(FILE *stream, uint8_t *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_byte(FILE *stream, uint8_t *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_i(FILE *stream, int *x, uint32_t len);
SRSLTE_API void srslte_vec_fprint_hex(FILE *stream, uint8_t *x, uint32_t len);
/* Saves a vector to a file */
SRSLTE_API void vec_save_file(char *filename, void *buffer, uint32_t len);
SRSLTE_API void srslte_vec_save_file(char *filename, void *buffer, uint32_t len);
/* sum two vectors */
SRSLTE_API void vec_sum_ch(uint8_t *x, uint8_t *y, char *z, uint32_t len);
SRSLTE_API void vec_sum_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void vec_sum_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sum_ch(uint8_t *x, uint8_t *y, char *z, uint32_t len);
SRSLTE_API void srslte_vec_sum_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void srslte_vec_sum_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
/* substract two vectors z=x-y */
SRSLTE_API void vec_sub_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void vec_sub_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sub_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void srslte_vec_sub_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
/* Square distance */
SRSLTE_API void vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints);
SRSLTE_API void srslte_vec_square_dist(cf_t symbol, cf_t *points, float *distance, uint32_t npoints);
/* scalar addition */
SRSLTE_API void vec_sc_add_fff(float *x, float h, float *z, uint32_t len);
SRSLTE_API void vec_sc_add_cfc(cf_t *x, float h, cf_t *z, uint32_t len);
SRSLTE_API void vec_sc_add_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_add_fff(float *x, float h, float *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_add_cfc(cf_t *x, float h, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_add_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len);
/* scalar product */
SRSLTE_API void vec_sc_prod_cfc(cf_t *x, float h, cf_t *z, uint32_t len);
SRSLTE_API void vec_sc_prod_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len);
SRSLTE_API void vec_sc_prod_fff(float *x, float h, float *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_prod_cfc(cf_t *x, float h, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_prod_ccc(cf_t *x, cf_t h, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_sc_prod_fff(float *x, float h, float *z, uint32_t len);
SRSLTE_API void vec_convert_fi(float *x, int16_t *z, float scale, uint32_t len);
SRSLTE_API void srslte_vec_convert_fi(float *x, int16_t *z, float scale, uint32_t len);
SRSLTE_API void vec_deinterleave_cf(cf_t *x, float *real, float *imag, uint32_t len);
SRSLTE_API void vec_deinterleave_real_cf(cf_t *x, float *real, uint32_t len);
SRSLTE_API void srslte_vec_deinterleave_cf(cf_t *x, float *real, float *imag, uint32_t len);
SRSLTE_API void srslte_vec_deinterleave_real_cf(cf_t *x, float *real, uint32_t len);
SRSLTE_API void vec_interleave_cf(float *real, float *imag, cf_t *x, uint32_t len);
SRSLTE_API void srslte_vec_interleave_cf(float *real, float *imag, cf_t *x, uint32_t len);
/* vector product (element-wise) */
SRSLTE_API void vec_prod_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_prod_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
/* vector product (element-wise) */
SRSLTE_API void vec_prod_cfc(cf_t *x, float *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_prod_cfc(cf_t *x, float *y, cf_t *z, uint32_t len);
/* conjugate vector product (element-wise) */
SRSLTE_API void vec_prod_conj_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_prod_conj_ccc(cf_t *x, cf_t *y, cf_t *z, uint32_t len);
/* Dot-product */
SRSLTE_API cf_t vec_dot_prod_cfc(cf_t *x, float *y, uint32_t len);
SRSLTE_API cf_t vec_dot_prod_ccc(cf_t *x, cf_t *y, uint32_t len);
SRSLTE_API cf_t vec_dot_prod_conj_ccc(cf_t *x, cf_t *y, uint32_t len);
SRSLTE_API float vec_dot_prod_fff(float *x, float *y, uint32_t len);
SRSLTE_API cf_t srslte_vec_dot_prod_cfc(cf_t *x, float *y, uint32_t len);
SRSLTE_API cf_t srslte_vec_dot_prod_ccc(cf_t *x, cf_t *y, uint32_t len);
SRSLTE_API cf_t srslte_vec_dot_prod_conj_ccc(cf_t *x, cf_t *y, uint32_t len);
SRSLTE_API float srslte_vec_dot_prod_fff(float *x, float *y, uint32_t len);
/* z=x/y vector division (element-wise) */
SRSLTE_API void vec_div_ccc(cf_t *x, cf_t *y, float *y_mod, cf_t *z, float *z_real, float *z_imag, uint32_t len);
void vec_div_cfc(cf_t *x, float *y, cf_t *z, float *z_real, float *z_imag, uint32_t len);
SRSLTE_API void vec_div_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void srslte_vec_div_ccc(cf_t *x, cf_t *y, float *y_mod, cf_t *z, float *z_real, float *z_imag, uint32_t len);
void srslte_vec_div_cfc(cf_t *x, float *y, cf_t *z, float *z_real, float *z_imag, uint32_t len);
SRSLTE_API void srslte_vec_div_fff(float *x, float *y, float *z, uint32_t len);
/* conjugate */
SRSLTE_API void vec_conj_cc(cf_t *x, cf_t *y, uint32_t len);
SRSLTE_API void srslte_vec_conj_cc(cf_t *x, cf_t *y, uint32_t len);
/* average vector power */
SRSLTE_API float vec_avg_power_cf(cf_t *x, uint32_t len);
SRSLTE_API float srslte_vec_avg_power_cf(cf_t *x, uint32_t len);
/* return the index of the maximum value in the vector */
SRSLTE_API uint32_t vec_max_fi(float *x, uint32_t len);
SRSLTE_API uint32_t vec_max_abs_ci(cf_t *x, uint32_t len);
SRSLTE_API uint32_t srslte_vec_max_fi(float *x, uint32_t len);
SRSLTE_API uint32_t srslte_vec_max_abs_ci(cf_t *x, uint32_t len);
/* maximum between two vectors */
SRSLTE_API void vec_max_fff(float *x, float *y, float *z, uint32_t len);
SRSLTE_API void srslte_vec_max_fff(float *x, float *y, float *z, uint32_t len);
/* quantify vector of floats and convert to uint8_t */
SRSLTE_API void vec_quant_fuc(float *in, uint8_t *out, float gain, float offset, float clip, uint32_t len);
SRSLTE_API void srslte_vec_quant_fuc(float *in, uint8_t *out, float gain, float offset, float clip, uint32_t len);
/* magnitude of each vector element */
SRSLTE_API void vec_abs_cf(cf_t *x, float *abs, uint32_t len);
SRSLTE_API void vec_abs_square_cf(cf_t *x, float *abs_square, uint32_t len);
SRSLTE_API void srslte_vec_abs_cf(cf_t *x, float *abs, uint32_t len);
SRSLTE_API void srslte_vec_abs_square_cf(cf_t *x, float *abs_square, uint32_t len);
/* argument of each vector element */
SRSLTE_API void vec_arg_cf(cf_t *x, float *arg, uint32_t len);
SRSLTE_API void srslte_vec_arg_cf(cf_t *x, float *arg, uint32_t len);
#ifdef __cplusplus
}

4
srslte/lib/agc/src/agc.c
Unescape Escape View File

@ -81,10 +81,10 @@ void srslte_agc_lock(srslte_agc_t *q, bool enable) {
void srslte_agc_process(srslte_agc_t *q, cf_t *input, cf_t *output, uint32_t len) {
// Apply current gain to input signal
vec_sc_prod_cfc(input, q->gain, output, len);
srslte_vec_sc_prod_cfc(input, q->gain, output, len);
// compute output energy estimate
float y = sqrtf(crealf(vec_dot_prod_conj_ccc(output, output, len))/len);
float y = sqrtf(crealf(srslte_vec_dot_prod_conj_ccc(output, output, len))/len);
if (q->isfirst) {
q->y_out = y;

44
srslte/lib/ch_estimation/src/chest_dl.c
Unescape Escape View File

@ -69,25 +69,25 @@ int srslte_chest_dl_init(srslte_chest_dl_t *q, srslte_cell_t cell)
goto clean_exit;
}
q->tmp_freqavg = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_MAX_NUM_SF(cell.nof_prb));
q->tmp_freqavg = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_MAX_NUM_SF(cell.nof_prb));
if (!q->tmp_freqavg) {
perror("malloc");
goto clean_exit;
}
q->tmp_noise = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_MAX_NUM_SF(cell.nof_prb));
q->tmp_noise = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_MAX_NUM_SF(cell.nof_prb));
if (!q->tmp_noise) {
perror("malloc");
goto clean_exit;
}
for (int i=0;i<SRSLTE_CHEST_MAX_FILTER_TIME_LEN;i++) {
q->tmp_timeavg[i] = vec_malloc(sizeof(cf_t) * 2*cell.nof_prb);
q->tmp_timeavg[i] = srslte_vec_malloc(sizeof(cf_t) * 2*cell.nof_prb);
if (!q->tmp_timeavg[i]) {
perror("malloc");
goto clean_exit;
}
bzero(q->tmp_timeavg[i], sizeof(cf_t) * 2*cell.nof_prb);
}
q->tmp_timeavg_mult = vec_malloc(sizeof(cf_t) * 2*cell.nof_prb);
q->tmp_timeavg_mult = srslte_vec_malloc(sizeof(cf_t) * 2*cell.nof_prb);
if (!q->tmp_timeavg_mult) {
perror("malloc");
goto clean_exit;
@ -95,17 +95,17 @@ int srslte_chest_dl_init(srslte_chest_dl_t *q, srslte_cell_t cell)
bzero(q->tmp_timeavg_mult, sizeof(cf_t) * 2*cell.nof_prb);
for (int i=0;i<cell.nof_ports;i++) {
q->pilot_estimates[i] = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
q->pilot_estimates[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
if (!q->pilot_estimates[i]) {
perror("malloc");
goto clean_exit;
}
q->pilot_estimates_average[i] = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
q->pilot_estimates_average[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
if (!q->pilot_estimates_average[i]) {
perror("malloc");
goto clean_exit;
}
q->pilot_recv_signal[i] = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
q->pilot_recv_signal[i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(cell.nof_prb, i));
if (!q->pilot_recv_signal[i]) {
perror("malloc");
goto clean_exit;
@ -210,10 +210,10 @@ int srslte_chest_dl_set_filter_time(srslte_chest_dl_t *q, float *filter, uint32_
/* Uses the difference between the averaged and non-averaged pilot estimates */
static float estimate_noise_port(srslte_chest_dl_t *q, uint32_t port_id, cf_t *avg_pilots) {
/* Use difference between averaged and noisy LS pilot estimates */
vec_sub_ccc(avg_pilots, q->pilot_estimates[port_id],
srslte_vec_sub_ccc(avg_pilots, q->pilot_estimates[port_id],
q->tmp_noise, SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
return vec_avg_power_cf(q->tmp_noise, SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
return srslte_vec_avg_power_cf(q->tmp_noise, SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
}
#else
@ -222,11 +222,11 @@ static float estimate_noise_port(srslte_chest_dl_t *q, uint32_t port_id, cf_t *a
static float estimate_noise_empty_sc(srslte_chest_dl_t *q, cf_t *input) {
int k_sss = (SRSLTE_CP_NSYMB(q->cell.cp) - 2) * q->cell.nof_prb * SRSLTE_NRE + q->cell.nof_prb * SRSLTE_NRE / 2 - 31;
float noise_power = 0;
noise_power += vec_avg_power_cf(&input[k_sss-5], 5); // 5 empty SC before SSS
noise_power += vec_avg_power_cf(&input[k_sss+62], 5); // 5 empty SC after SSS
noise_power += srslte_vec_avg_power_cf(&input[k_sss-5], 5); // 5 empty SC before SSS
noise_power += srslte_vec_avg_power_cf(&input[k_sss+62], 5); // 5 empty SC after SSS
int k_pss = (SRSLTE_CP_NSYMB(q->cell.cp) - 1) * q->cell.nof_prb * SRSLTE_NRE + q->cell.nof_prb * SRSLTE_NRE / 2 - 31;
noise_power += vec_avg_power_cf(&input[k_pss-5], 5); // 5 empty SC before PSS
noise_power += vec_avg_power_cf(&input[k_pss+62], 5); // 5 empty SC after PSS
noise_power += srslte_vec_avg_power_cf(&input[k_pss-5], 5); // 5 empty SC before PSS
noise_power += srslte_vec_avg_power_cf(&input[k_pss+62], 5); // 5 empty SC after PSS
return noise_power;
}
@ -245,7 +245,7 @@ static void average_pilots(srslte_chest_dl_t *q, uint32_t port_id)
for (l=0;l<srslte_refsignal_cs_nof_symbols(port_id);l++) {
if (q->filter_freq_len > 0) {
/* Filter pilot estimates in frequency */
conv_same_cf(&pilot_est(0), q->filter_freq, &pilot_tmp(0), nref, q->filter_freq_len);
srslte_conv_same_cf(&pilot_est(0), q->filter_freq, &pilot_tmp(0), nref, q->filter_freq_len);
/* Adjust extremes using linear interpolation */
@ -275,8 +275,8 @@ static void average_pilots(srslte_chest_dl_t *q, uint32_t port_id)
/* Multiply all symbols by filter and add them */
bzero(&pilot_avg(0), nref * sizeof(cf_t));
for (i=0;i<q->filter_time_len;i++) {
vec_sc_prod_cfc(q->tmp_timeavg[i], q->filter_time[i], q->tmp_timeavg[i], nref);
vec_sum_ccc(q->tmp_timeavg[i], &pilot_avg(0), &pilot_avg(0), nref);
srslte_vec_sc_prod_cfc(q->tmp_timeavg[i], q->filter_time[i], q->tmp_timeavg[i], nref);
srslte_vec_sum_ccc(q->tmp_timeavg[i], &pilot_avg(0), &pilot_avg(0), nref);
}
} else {
memcpy(&pilot_avg(0), &pilot_tmp(0), nref * sizeof(cf_t));
@ -334,7 +334,7 @@ float srslte_chest_dl_rssi(srslte_chest_dl_t *q, cf_t *input, uint32_t port_id)
uint32_t nsymbols = srslte_refsignal_cs_nof_symbols(port_id);
for (l=0;l<nsymbols;l++) {
cf_t *tmp = &input[srslte_refsignal_cs_nsymbol(l, q->cell.cp, port_id) * q->cell.nof_prb * SRSLTE_NRE];
rssi += vec_dot_prod_conj_ccc(tmp, tmp, q->cell.nof_prb * SRSLTE_NRE);
rssi += srslte_vec_dot_prod_conj_ccc(tmp, tmp, q->cell.nof_prb * SRSLTE_NRE);
}
return rssi/nsymbols;
}
@ -343,10 +343,10 @@ float srslte_chest_dl_rssi(srslte_chest_dl_t *q, cf_t *input, uint32_t port_id)
float srslte_chest_dl_rsrp(srslte_chest_dl_t *q, uint32_t port_id) {
#ifdef RSRP_FROM_ESTIMATES
return vec_avg_power_cf(q->pilot_estimates[port_id],
return srslte_vec_avg_power_cf(q->pilot_estimates[port_id],
SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
#else
return vec_avg_power_cf(q->pilot_estimates_average[port_id],
return srslte_vec_avg_power_cf(q->pilot_estimates_average[port_id],
SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
#endif
}
@ -357,7 +357,7 @@ int srslte_chest_dl_estimate_port(srslte_chest_dl_t *q, cf_t *input, cf_t *ce, u
srslte_refsignal_cs_get_sf(q->cell, port_id, input, q->pilot_recv_signal[port_id]);
/* Use the known CSR signal to compute Least-squares estimates */
vec_prod_conj_ccc(q->pilot_recv_signal[port_id], q->csr_signal.pilots[port_id/2][sf_idx],
srslte_vec_prod_conj_ccc(q->pilot_recv_signal[port_id], q->csr_signal.pilots[port_id/2][sf_idx],
q->pilot_estimates[port_id], SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, port_id));
/* Average pilot estimates */
@ -392,7 +392,7 @@ int srslte_chest_dl_estimate(srslte_chest_dl_t *q, cf_t *input, cf_t *ce[SRSLTE_
}
float srslte_chest_dl_get_noise_estimate(srslte_chest_dl_t *q) {
float noise = vec_acc_ff(q->noise_estimate, q->cell.nof_ports)/q->cell.nof_ports;
float noise = srslte_vec_acc_ff(q->noise_estimate, q->cell.nof_ports)/q->cell.nof_ports;
#ifdef NOISE_POWER_USE_ESTIMATES
return noise*sqrtf(srslte_symbol_sz(q->cell.nof_prb));
#else
@ -421,6 +421,6 @@ float srslte_chest_dl_get_rsrq(srslte_chest_dl_t *q) {
float srslte_chest_dl_get_rsrp(srslte_chest_dl_t *q) {
// return sum of power received from all tx ports
return vec_acc_ff(q->rsrp, q->cell.nof_ports);
return srslte_vec_acc_ff(q->rsrp, q->cell.nof_ports);
}

2
srslte/lib/ch_estimation/src/refsignal_dl.c
Unescape Escape View File

@ -133,7 +133,7 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
for (p=0;p<2;p++) {
for (i=0;i<SRSLTE_NSUBFRAMES_X_FRAME;i++) {
q->pilots[p][i] = vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, 2*p));
q->pilots[p][i] = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_REFSIGNAL_NUM_SF(q->cell.nof_prb, 2*p));
if (!q->pilots[p][i]) {
perror("malloc");
goto free_and_exit;

42
srslte/lib/ch_estimation/src/refsignal_ul.c
Unescape Escape View File

@ -141,7 +141,7 @@ int srslte_refsignal_ul_init(srslte_refsignal_ul_t * q, srslte_cell_t cell)
q->cell = cell;
// Allocate temporal buffer for computing signal argument
q->tmp_arg = vec_malloc(SRSLTE_NRE * q->cell.nof_prb * sizeof(cf_t));
q->tmp_arg = srslte_vec_malloc(SRSLTE_NRE * q->cell.nof_prb * sizeof(cf_t));
if (!q->tmp_arg) {
perror("malloc");
goto free_and_exit;
@ -162,7 +162,7 @@ int srslte_refsignal_ul_init(srslte_refsignal_ul_t * q, srslte_cell_t cell)
goto free_and_exit;
}
if (generate_n_cs_cell(q->cell, q->n_cs_cell)) {
if (srslte_generate_n_cs_cell(q->cell, q->n_cs_cell)) {
goto free_and_exit;
}
@ -243,7 +243,7 @@ static void compute_pusch_r_uv_arg(srslte_refsignal_ul_t *q, srslte_refsignal_dr
}
/* Calculates alpha according to 5.5.2.1.1 of 36.211 */
static float pusch_get_alpha(srslte_refsignal_ul_t *q, srslte_refsignal_drms_pusch_cfg_t *cfg, uint32_t ns) {
static float get_alpha(srslte_refsignal_ul_t *q, srslte_refsignal_drms_pusch_cfg_t *cfg, uint32_t ns) {
uint32_t n_drms_2_val = 0;
if (cfg->en_drms_2) {
n_drms_2_val = n_drms_2[cfg->cyclic_shift_for_drms];
@ -280,7 +280,7 @@ void srslte_refsignal_drms_pusch_put(srslte_refsignal_ul_t *q, srslte_refsignal_
}
/* Generate DRMS for PUSCH signal according to 5.5.2.1 of 36.211 */
int srslte_refsignal_dmrs_pusch_gen(srslte_refsignal_ul_t *q, srslte_refsignal_drms_pusch_cfg_t *cfg, uint32_t nof_prb, uint32_t sf_idx, cf_t *r_pusch)
int srslte_refsignal_dmrs_gen(srslte_refsignal_ul_t *q, srslte_refsignal_drms_pusch_cfg_t *cfg, uint32_t nof_prb, uint32_t sf_idx, cf_t *r_pusch)
{
int ret = SRSLTE_ERROR_INVALID_INPUTS;
@ -305,9 +305,9 @@ int srslte_refsignal_dmrs_pusch_gen(srslte_refsignal_ul_t *q, srslte_refsignal_d
compute_pusch_r_uv_arg(q, cfg, nof_prb, u, v);
// Add cyclic prefix alpha
float alpha = pusch_get_alpha(q, cfg, ns);
float alpha = get_alpha(q, cfg, ns);
if (verbose == VERBOSE_DEBUG) {
if (srslte_verbose == SRSLTE_VERBOSE_DEBUG) {
uint32_t N_sz = largest_prime_lower_than(nof_prb*SRSLTE_NRE);
DEBUG("Generating PUSCH DRMS sequence with parameters:\n",0);
DEBUG("\tbeta: %.1f, nof_prb: %d, u: %d, v: %d, alpha: %f, N_sc: %d, root q: %d, nprs: %d\n",
@ -324,19 +324,19 @@ int srslte_refsignal_dmrs_pusch_gen(srslte_refsignal_ul_t *q, srslte_refsignal_d
return ret;
}
int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q, pucch_cfg_t *cfg, uint32_t sf_idx, uint32_t n_rb, cf_t *r_pucch)
int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q, srslte_pucch_cfg_t *cfg, uint32_t sf_idx, uint32_t n_rb, cf_t *r_pucch)
{
int ret = SRSLTE_ERROR_INVALID_INPUTS;
if (pucch_cfg_isvalid(cfg)) {
if (srslte_pucch_cfg_isvalid(cfg)) {
ret = SRSLTE_ERROR;
for (uint32_t ns=2*sf_idx;ns<2*(sf_idx+1);ns++) {
uint32_t N_rs=0;
uint32_t *pucch_symbol = NULL;
switch (cfg->format) {
case PUCCH_FORMAT_1:
case PUCCH_FORMAT_1A:
case PUCCH_FORMAT_1B:
case SRSLTE_PUCCH_FORMAT_1:
case SRSLTE_PUCCH_FORMAT_1A:
case SRSLTE_PUCCH_FORMAT_1B:
if (SRSLTE_CP_ISNORM(q->cell.cp)) {
N_rs = 3;
pucch_symbol=pucch_symbol_format1_cpnorm;
@ -345,7 +345,7 @@ int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q, pucch_cfg_t *cfg,
pucch_symbol=pucch_symbol_format1_cpext;
}
break;
case PUCCH_FORMAT_2:
case SRSLTE_PUCCH_FORMAT_2:
if (SRSLTE_CP_ISNORM(q->cell.cp)) {
N_rs = 2;
pucch_symbol=pucch_symbol_format2_cpnorm;
@ -354,8 +354,8 @@ int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q, pucch_cfg_t *cfg,
pucch_symbol=pucch_symbol_format2_cpext;
}
break;
case PUCCH_FORMAT_2A:
case PUCCH_FORMAT_2B:
case SRSLTE_PUCCH_FORMAT_2A:
case SRSLTE_PUCCH_FORMAT_2B:
N_rs = 2;
pucch_symbol=pucch_symbol_format2_cpnorm;
break;
@ -367,29 +367,29 @@ int srslte_refsignal_dmrs_pucch_gen(srslte_refsignal_ul_t *q, pucch_cfg_t *cfg,
uint32_t l = pucch_symbol[m];
// Add cyclic prefix alpha
float alpha = pucch_get_alpha(q->n_cs_cell, cfg, q->cell.cp, true, ns, l, &n_oc);
float alpha = srslte_pucch_get_alpha(q->n_cs_cell, cfg, q->cell.cp, true, ns, l, &n_oc);
// Choose number of symbols and orthogonal sequence from Tables 5.5.2.2.1-1 to -3
float *w=NULL;
switch (cfg->format) {
case PUCCH_FORMAT_1:
case PUCCH_FORMAT_1A:
case PUCCH_FORMAT_1B:
case SRSLTE_PUCCH_FORMAT_1:
case SRSLTE_PUCCH_FORMAT_1A:
case SRSLTE_PUCCH_FORMAT_1B:
if (SRSLTE_CP_ISNORM(q->cell.cp)) {
w=w_arg_pucch_format1_cpnorm[n_oc];
} else {
w=w_arg_pucch_format1_cpext[n_oc];
}
break;
case PUCCH_FORMAT_2:
case SRSLTE_PUCCH_FORMAT_2:
if (SRSLTE_CP_ISNORM(q->cell.cp)) {
w=w_arg_pucch_format2_cpnorm;
} else {
w=w_arg_pucch_format2_cpext;
}
break;
case PUCCH_FORMAT_2A:
case PUCCH_FORMAT_2B:
case SRSLTE_PUCCH_FORMAT_2A:
case SRSLTE_PUCCH_FORMAT_2B:
w=w_arg_pucch_format2_cpnorm;
break;
}

18
srslte/lib/ch_estimation/test/chest_test_dl.c
Unescape Escape View File

@ -71,7 +71,7 @@ void parse_args(int argc, char **argv) {
output_matlab = argv[optind];
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -83,7 +83,7 @@ void parse_args(int argc, char **argv) {
int main(int argc, char **argv) {
srslte_chest_dl_t est;
precoding_t cheq;
srslte_precoding_t cheq;
cf_t *input = NULL, *ce = NULL, *h = NULL, *output = NULL;
int i, j, n_port, sf_idx, cid, num_re;
int ret = -1;
@ -131,7 +131,7 @@ int main(int argc, char **argv) {
max_cid = cell.id;
}
precoding_init(&cheq, num_re);
srslte_precoding_init(&cheq, num_re);
while(cid <= max_cid) {
cell.id = cid;
@ -173,7 +173,7 @@ int main(int argc, char **argv) {
gettimeofday(&t[1], NULL);
for (int j=0;j<100;j++) {
predecoding_single(&cheq, input, ce, output, num_re, 0);
srslte_predecoding_single(&cheq, input, ce, output, num_re, 0);
}
gettimeofday(&t[2], NULL);
get_time_interval(t);
@ -188,7 +188,7 @@ int main(int argc, char **argv) {
gettimeofday(&t[1], NULL);
for (int j=0;j<100;j++) {
predecoding_single(&cheq, input, ce, output, num_re, srslte_chest_dl_get_noise_estimate(&est));
srslte_predecoding_single(&cheq, input, ce, output, num_re, srslte_chest_dl_get_noise_estimate(&est));
}
gettimeofday(&t[2], NULL);
get_time_interval(t);
@ -207,13 +207,13 @@ int main(int argc, char **argv) {
if (fmatlab) {
fprintf(fmatlab, "input=");
vec_fprint_c(fmatlab, input, num_re);
srslte_vec_fprint_c(fmatlab, input, num_re);
fprintf(fmatlab, ";\n");
fprintf(fmatlab, "h=");
vec_fprint_c(fmatlab, h, num_re);
srslte_vec_fprint_c(fmatlab, h, num_re);
fprintf(fmatlab, ";\n");
fprintf(fmatlab, "ce=");
vec_fprint_c(fmatlab, ce, num_re);
srslte_vec_fprint_c(fmatlab, ce, num_re);
fprintf(fmatlab, ";\n");
}
}
@ -228,7 +228,7 @@ int main(int argc, char **argv) {
do_exit:
precoding_free(&cheq);
srslte_precoding_free(&cheq);
if (output) {
free(output);

18
srslte/lib/ch_estimation/test/chest_test_dl_mex.c
Unescape Escape View File

@ -64,7 +64,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
int i;
srslte_cell_t cell;
srslte_chest_dl_t chest;
precoding_t cheq;
srslte_precoding_t cheq;
cf_t *input_signal = NULL, *output_signal[SRSLTE_MAX_LAYERS];
cf_t *output_signal2 = NULL;
cf_t *ce[SRSLTE_MAX_PORTS];
@ -153,15 +153,15 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
/** Allocate input buffers */
int nof_re = 2*SRSLTE_CP_NSYMB(cell.cp)*cell.nof_prb*SRSLTE_NRE;
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
ce[i] = vec_malloc(nof_re * sizeof(cf_t));
ce[i] = srslte_vec_malloc(nof_re * sizeof(cf_t));
}
input_signal = vec_malloc(nof_re * sizeof(cf_t));
input_signal = srslte_vec_malloc(nof_re * sizeof(cf_t));
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
output_signal[i] = vec_malloc(nof_re * sizeof(cf_t));
output_signal[i] = srslte_vec_malloc(nof_re * sizeof(cf_t));
}
output_signal2 = vec_malloc(nof_re * sizeof(cf_t));
output_signal2 = srslte_vec_malloc(nof_re * sizeof(cf_t));
precoding_init(&cheq, nof_re);
srslte_precoding_init(&cheq, nof_re);
/* Create output values */
if (nlhs >= 1) {
@ -201,9 +201,9 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
}
if (cell.nof_ports == 1) {
predecoding_single(&cheq, input_signal, ce[0], output_signal2, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
srslte_predecoding_single(&cheq, input_signal, ce[0], output_signal2, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
} else {
predecoding_diversity(&cheq, input_signal, ce, output_signal, cell.nof_ports, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
srslte_predecoding_diversity(&cheq, input_signal, ce, output_signal, cell.nof_ports, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
srslte_layerdemap_diversity(output_signal, output_signal2, cell.nof_ports, nof_re/cell.nof_ports);
}
@ -254,7 +254,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
}
srslte_chest_dl_free(&chest);
precoding_free(&cheq);
srslte_precoding_free(&cheq);
return;
}

6
srslte/lib/ch_estimation/test/refsignal_pusch_mex.c
Unescape Escape View File

@ -123,19 +123,19 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
mexPrintf("cyclic_shift_for_drms: %d, ",pusch_cfg.cyclic_shift_for_drms);
mexPrintf("delta_ss: %d, ",pusch_cfg.delta_ss);
cf_t *signal = vec_malloc(2*SRSLTE_NRE*nof_prb*sizeof(cf_t));
cf_t *signal = srslte_vec_malloc(2*SRSLTE_NRE*nof_prb*sizeof(cf_t));
if (!signal) {
perror("malloc");
return;
}
cf_t *sf_symbols = vec_malloc(SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)*sizeof(cf_t));
cf_t *sf_symbols = srslte_vec_malloc(SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)*sizeof(cf_t));
if (!sf_symbols) {
perror("malloc");
return;
}
bzero(sf_symbols, SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp)*sizeof(cf_t));
//mexPrintf("Generating DRMS for ns=%d, nof_prb=%d\n", 2*sf_idx+i,pusch_cfg.nof_prb);
srslte_refsignal_dmrs_pusch_gen(&refs, &pusch_cfg, nof_prb, sf_idx, signal);
srslte_refsignal_dmrs_gen(&refs, &pusch_cfg, nof_prb, sf_idx, signal);
uint32_t n_prb[2];
n_prb[0] = prbset[0];
n_prb[1] = prbset[0];

4
srslte/lib/ch_estimation/test/refsignal_ul_test.c
Unescape Escape View File

@ -65,7 +65,7 @@ void parse_args(int argc, char **argv) {
cell.id = atoi(argv[optind]);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -123,7 +123,7 @@ int main(int argc, char **argv) {
printf("cyclic_shift_for_drms: %d, ",pusch_cfg.cyclic_shift_for_drms);
printf("delta_ss: %d, ",pusch_cfg.delta_ss);
printf("SF_idx: %d\n", sf_idx);
srslte_refsignal_dmrs_pusch_gen(&refs, &pusch_cfg, nof_prb, sf_idx, signal);
srslte_refsignal_dmrs_gen(&refs, &pusch_cfg, nof_prb, sf_idx, signal);
exit(0);
}
}

80
srslte/lib/common/src/phy_common.c
Unescape Escape View File

@ -134,13 +134,13 @@ bool srslte_cb_size_isvalid(uint32_t size) {
char *srslte_mod_string(srslte_mod_t mod) {
switch (mod) {
case LTE_BPSK:
case SRSLTE_MOD_BPSK:
return "BPSK";
case LTE_QPSK:
case SRSLTE_MOD_QPSK:
return "QPSK";
case LTE_QAM16:
case SRSLTE_MOD_16QAM:
return "QAM16";
case LTE_QAM64:
case SRSLTE_MOD_64QAM:
return "QAM64";
default:
return "N/A";
@ -149,13 +149,13 @@ char *srslte_mod_string(srslte_mod_t mod) {
uint32_t srslte_mod_bits_x_symbol(srslte_mod_t mod) {
switch (mod) {
case LTE_BPSK:
case SRSLTE_MOD_BPSK:
return 1;
case LTE_QPSK:
case SRSLTE_MOD_QPSK:
return 2;
case LTE_QAM16:
case SRSLTE_MOD_16QAM:
return 4;
case LTE_QAM64:
case SRSLTE_MOD_64QAM:
return 6;
default:
return 0;
@ -301,45 +301,45 @@ struct lte_band {
};
struct lte_band lte_bands[SRSLTE_NOF_LTE_BANDS] = {
{1, 2110, 0, 599, ALL},
{2, 1930, 600, 1199, NAR},
{3, 1805, 1200, 1949, ALL},
{4, 2110, 1950, 2399, NAR},
{5, 869, 2400, 2649, NAR},
{6, 875, 2650, 2749, APAC},
{7, 2620, 2750, 3449, EMEA},
{8, 925, 3450, 3799, ALL},
{9, 1844.9, 3800, 4149, APAC},
{10, 2110, 4150, 4749, NAR},
{11, 1475.9, 4750, 4949, JAPAN},
{12, 729, 5010, 5179, NAR},
{13, 746, 5180, 5279, NAR},
{14, 758, 5280, 5379, NAR},
{17, 734, 5730, 5849, NAR},
{18, 860, 5850, 5999, JAPAN},
{19, 875, 6000, 6149, JAPAN},
{20, 791, 6150, 6449, EMEA},
{21, 1495.9, 6450, 6599, JAPAN},
{22, 3500, 6600, 7399, NA},
{23, 2180, 7500, 7699, NAR},
{24, 1525, 7700, 8039, NAR},
{25, 1930, 8040, 8689, NAR},
{26, 859, 8690, 9039, NAR},
{27, 852, 9040, 9209, NAR},
{28, 758, 9210, 9659, APAC},
{29, 717, 9660, 9769, NAR},
{30, 2350, 9770, 9869, NAR},
{31, 462.5, 9870, 9919, CALA}
{1, 2110, 0, 599, SRSLTE_BAND_GEO_AREA_ALL},
{2, 1930, 600, 1199, SRSLTE_BAND_GEO_AREA_NAR},
{3, 1805, 1200, 1949, SRSLTE_BAND_GEO_AREA_ALL},
{4, 2110, 1950, 2399, SRSLTE_BAND_GEO_AREA_NAR},
{5, 869, 2400, 2649, SRSLTE_BAND_GEO_AREA_NAR},
{6, 875, 2650, 2749, SRSLTE_BAND_GEO_AREA_APAC},
{7, 2620, 2750, 3449, SRSLTE_BAND_GEO_AREA_EMEA},
{8, 925, 3450, 3799, SRSLTE_BAND_GEO_AREA_ALL},
{9, 1844.9, 3800, 4149, SRSLTE_BAND_GEO_AREA_APAC},
{10, 2110, 4150, 4749, SRSLTE_BAND_GEO_AREA_NAR},
{11, 1475.9, 4750, 4949, SRSLTE_BAND_GEO_AREA_JAPAN},
{12, 729, 5010, 5179, SRSLTE_BAND_GEO_AREA_NAR},
{13, 746, 5180, 5279, SRSLTE_BAND_GEO_AREA_NAR},
{14, 758, 5280, 5379, SRSLTE_BAND_GEO_AREA_NAR},
{17, 734, 5730, 5849, SRSLTE_BAND_GEO_AREA_NAR},
{18, 860, 5850, 5999, SRSLTE_BAND_GEO_AREA_JAPAN},
{19, 875, 6000, 6149, SRSLTE_BAND_GEO_AREA_JAPAN},
{20, 791, 6150, 6449, SRSLTE_BAND_GEO_AREA_EMEA},
{21, 1495.9, 6450, 6599, SRSLTE_BAND_GEO_AREA_JAPAN},
{22, 3500, 6600, 7399, SRSLTE_BAND_GEO_AREA_NA},
{23, 2180, 7500, 7699, SRSLTE_BAND_GEO_AREA_NAR},
{24, 1525, 7700, 8039, SRSLTE_BAND_GEO_AREA_NAR},
{25, 1930, 8040, 8689, SRSLTE_BAND_GEO_AREA_NAR},
{26, 859, 8690, 9039, SRSLTE_BAND_GEO_AREA_NAR},
{27, 852, 9040, 9209, SRSLTE_BAND_GEO_AREA_NAR},
{28, 758, 9210, 9659, SRSLTE_BAND_GEO_AREA_APAC},
{29, 717, 9660, 9769, SRSLTE_BAND_GEO_AREA_NAR},
{30, 2350, 9770, 9869, SRSLTE_BAND_GEO_AREA_NAR},
{31, 462.5, 9870, 9919, SRSLTE_BAND_GEO_AREA_CALA}
};
#define EOF_BAND 9919
int srslte_str2mimotype(char *mimo_type_str, srslte_mimo_type_t *type) {
if (!strcmp(mimo_type_str, "single")) {
*type = SINGLE_ANTENNA;
*type = SRSLTE_MIMO_TYPE_SINGLE_ANTENNA;
} else if (!strcmp(mimo_type_str, "diversity")) {
*type = TX_DIVERSITY;
*type = SRSLTE_MIMO_TYPE_TX_DIVERSITY;
} else if (!strcmp(mimo_type_str, "multiplex")) {
*type = SPATIAL_MULTIPLEX;
*type = SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX;
} else {
return SRSLTE_ERROR;
}

62
srslte/lib/utils/src/dft.c → srslte/lib/dft/src/dft.c
Unescape Escape View File

@ -31,18 +31,18 @@
#include <fftw3.h>
#include <string.h>
#include "srslte/utils/dft.h"
#include "srslte/dft/dft.h"
#include "srslte/utils/vector.h"
#define dft_ceil(a,b) ((a-1)/b+1)
#define dft_floor(a,b) (a/b)
int dft_plan(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir,
dft_mode_t mode) {
if(mode == COMPLEX){
return dft_plan_c(plan,dft_points,dir);
int srslte_dft_plan(srslte_dft_plan_t *plan, const int dft_points, srslte_dft_dir_t dir,
srslte_dft_mode_t mode) {
if(mode == SRSLTE_DFT_COMPLEX){
return srslte_dft_plan_c(plan,dft_points,dir);
} else {
return dft_plan_r(plan,dft_points,dir);
return srslte_dft_plan_r(plan,dft_points,dir);
}
return 0;
}
@ -52,17 +52,17 @@ static void allocate(srslte_dft_plan_t *plan, int size_in, int size_out, int len
plan->out = fftwf_malloc(size_out*len);
}
int dft_plan_c(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir) {
int srslte_dft_plan_c(srslte_dft_plan_t *plan, const int dft_points, srslte_dft_dir_t dir) {
allocate(plan,sizeof(fftwf_complex),sizeof(fftwf_complex), dft_points);
int sign = (dir == FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD;
int sign = (dir == SRSLTE_DFT_FORWARD) ? FFTW_FORWARD : FFTW_BACKWARD;
plan->p = fftwf_plan_dft_1d(dft_points, plan->in, plan->out, sign, 0U);
if (!plan->p) {
return -1;
}
plan->size = dft_points;
plan->mode = COMPLEX;
plan->mode = SRSLTE_DFT_COMPLEX;
plan->dir = dir;
plan->forward = (dir==FORWARD)?true:false;
plan->forward = (dir==SRSLTE_DFT_FORWARD)?true:false;
plan->mirror = false;
plan->db = false;
plan->norm = false;
@ -71,17 +71,17 @@ int dft_plan_c(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir) {
return 0;
}
int dft_plan_r(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir) {
int srslte_dft_plan_r(srslte_dft_plan_t *plan, const int dft_points, srslte_dft_dir_t dir) {
allocate(plan,sizeof(float),sizeof(float), dft_points);
int sign = (dir == FORWARD) ? FFTW_R2HC : FFTW_HC2R;
int sign = (dir == SRSLTE_DFT_FORWARD) ? FFTW_R2HC : FFTW_HC2R;
plan->p = fftwf_plan_r2r_1d(dft_points, plan->in, plan->out, sign, 0U);
if (!plan->p) {
return -1;
}
plan->size = dft_points;
plan->mode = REAL;
plan->mode = SRSLTE_REAL;
plan->dir = dir;
plan->forward = (dir==FORWARD)?true:false;
plan->forward = (dir==SRSLTE_DFT_FORWARD)?true:false;
plan->mirror = false;
plan->db = false;
plan->norm = false;
@ -90,16 +90,16 @@ int dft_plan_r(srslte_dft_plan_t *plan, const int dft_points, dft_dir_t dir) {
return 0;
}
void dft_plan_set_mirror(srslte_dft_plan_t *plan, bool val){
void srslte_dft_plan_set_mirror(srslte_dft_plan_t *plan, bool val){
plan->mirror = val;
}
void dft_plan_set_db(srslte_dft_plan_t *plan, bool val){
void srslte_dft_plan_set_db(srslte_dft_plan_t *plan, bool val){
plan->db = val;
}
void dft_plan_set_norm(srslte_dft_plan_t *plan, bool val){
void srslte_dft_plan_set_norm(srslte_dft_plan_t *plan, bool val){
plan->norm = val;
}
void dft_plan_set_dc(srslte_dft_plan_t *plan, bool val){
void srslte_dft_plan_set_dc(srslte_dft_plan_t *plan, bool val){
plan->dc = val;
}
@ -128,56 +128,56 @@ static void copy_post(uint8_t *dst, uint8_t *src, int size_d, int len,
}
}
void dft_run(srslte_dft_plan_t *plan, void *in, void *out) {
if(plan->mode == COMPLEX) {
dft_run_c(plan,in,out);
void srslte_dft_run(srslte_dft_plan_t *plan, void *in, void *out) {
if(plan->mode == SRSLTE_DFT_COMPLEX) {
srslte_dft_run_c(plan,in,out);
} else {
dft_run_r(plan,in,out);
srslte_dft_run_r(plan,in,out);
}
}
void dft_run_c(srslte_dft_plan_t *plan, dft_c_t *in, dft_c_t *out) {
void srslte_dft_run_c(srslte_dft_plan_t *plan, cf_t *in, cf_t *out) {
float norm;
int i;
fftwf_complex *f_out = plan->out;
copy_pre((uint8_t*)plan->in, (uint8_t*)in, sizeof(dft_c_t), plan->size,
copy_pre((uint8_t*)plan->in, (uint8_t*)in, sizeof(cf_t), plan->size,
plan->forward, plan->mirror, plan->dc);
fftwf_execute(plan->p);
if (plan->norm) {
norm = 1.0/sqrtf(plan->size);
vec_sc_prod_cfc(f_out, norm, f_out, plan->size);
srslte_vec_sc_prod_cfc(f_out, norm, f_out, plan->size);
}
if (plan->db) {
for (i=0;i<plan->size;i++) {
f_out[i] = 10*log10(f_out[i]);
}
}
copy_post((uint8_t*)out, (uint8_t*)plan->out, sizeof(dft_c_t), plan->size,
copy_post((uint8_t*)out, (uint8_t*)plan->out, sizeof(cf_t), plan->size,
plan->forward, plan->mirror, plan->dc);
}
void dft_run_r(srslte_dft_plan_t *plan, dft_r_t *in, dft_r_t *out) {
void srslte_dft_run_r(srslte_dft_plan_t *plan, float *in, float *out) {
float norm;
int i;
int len = plan->size;
float *f_out = plan->out;
memcpy(plan->in,in,sizeof(dft_r_t)*plan->size);
memcpy(plan->in,in,sizeof(float)*plan->size);
fftwf_execute(plan->p);
if (plan->norm) {
norm = 1.0/plan->size;
vec_sc_prod_fff(f_out, norm, f_out, plan->size);
srslte_vec_sc_prod_fff(f_out, norm, f_out, plan->size);
}
if (plan->db) {
for (i=0;i<len;i++) {
f_out[i] = 10*log10(f_out[i]);
}
}
memcpy(out,plan->out,sizeof(dft_r_t)*plan->size);
memcpy(out,plan->out,sizeof(float)*plan->size);
}
void dft_plan_free(srslte_dft_plan_t *plan) {
void srslte_dft_plan_free(srslte_dft_plan_t *plan) {
if (!plan) return;
if (!plan->size) return;
if (plan->in) fftwf_free(plan->in);

44
srslte/lib/filter/src/dft_precoding.c → srslte/lib/dft/src/dft_precoding.c
Unescape Escape View File

@ -37,30 +37,30 @@
#include "srslte/common/phy_common.h"
#include "srslte/utils/debug.h"
#include "srslte/utils/vector.h"
#include "srslte/utils/dft.h"
#include "srslte/filter/dft_precoding.h"
#include "srslte/dft/dft.h"
#include "srslte/dft/dft_precoding.h"
/* Create DFT plans for transform precoding */
int srslte_srslte_dft_precoding_init(srslte_srslte_dft_precoding_t *q, uint32_t max_prb)
int srslte_dft_precoding_init(srslte_dft_precoding_t *q, uint32_t max_prb)
{
int ret = SRSLTE_ERROR_INVALID_INPUTS;
bzero(q, sizeof(srslte_srslte_dft_precoding_t));
bzero(q, sizeof(srslte_dft_precoding_t));
if (max_prb <= SRSLTE_MAX_PRB) {
ret = SRSLTE_ERROR;
for (uint32_t i=1;i<max_prb;i++) {
if(srslte_srslte_dft_precoding_valid_prb(i)) {
if(srslte_dft_precoding_valid_prb(i)) {
DEBUG("Initiating DFT precoding plan for %d PRBs\n", i);
if (dft_plan_c(&q->dft_plan[i], i*SRSLTE_NRE, FORWARD)) {
if (srslte_dft_plan_c(&q->dft_plan[i], i*SRSLTE_NRE, SRSLTE_DFT_FORWARD)) {
fprintf(stderr, "Error: Creating DFT plan %d\n",i);
goto clean_exit;
}
dft_plan_set_norm(&q->dft_plan[i], true);
if (dft_plan_c(&q->idft_plan[i], i*SRSLTE_NRE, BACKWARD)) {
srslte_dft_plan_set_norm(&q->dft_plan[i], true);
if (srslte_dft_plan_c(&q->idft_plan[i], i*SRSLTE_NRE, SRSLTE_DFT_BACKWARD)) {
fprintf(stderr, "Error: Creating DFT plan %d\n",i);
goto clean_exit;
}
dft_plan_set_norm(&q->idft_plan[i], true);
srslte_dft_plan_set_norm(&q->idft_plan[i], true);
}
}
q->max_prb = max_prb;
@ -69,25 +69,25 @@ int srslte_srslte_dft_precoding_init(srslte_srslte_dft_precoding_t *q, uint32_t
clean_exit:
if (ret == SRSLTE_ERROR) {
srslte_srslte_dft_precoding_free(q);
srslte_dft_precoding_free(q);
}
return ret;
}
/* Free DFT plans for transform precoding */
void srslte_srslte_dft_precoding_free(srslte_srslte_dft_precoding_t *q)
void srslte_dft_precoding_free(srslte_dft_precoding_t *q)
{
for (uint32_t i=1;i<q->max_prb;i++) {
if(srslte_srslte_dft_precoding_valid_prb(i)) {
if(srslte_dft_precoding_valid_prb(i)) {
DEBUG("Freeing DFT precoding plan for %d PRBs\n", i);
dft_plan_free(&q->dft_plan[i]);
dft_plan_free(&q->idft_plan[i]);
srslte_dft_plan_free(&q->dft_plan[i]);
srslte_dft_plan_free(&q->idft_plan[i]);
}
}
bzero(q, sizeof(srslte_srslte_dft_precoding_t));
bzero(q, sizeof(srslte_dft_precoding_t));
}
bool srslte_srslte_dft_precoding_valid_prb(uint32_t nof_prb) {
bool srslte_dft_precoding_valid_prb(uint32_t nof_prb) {
if (nof_prb == 1 || (nof_prb%2) == 0 || (nof_prb%3) == 0 || (nof_prb%5) == 0) {
return true;
} else {
@ -95,32 +95,32 @@ bool srslte_srslte_dft_precoding_valid_prb(uint32_t nof_prb) {
}
}
int srslte_dft_precoding(srslte_srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
int srslte_dft_precoding(srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
uint32_t nof_prb, uint32_t nof_symbols)
{
if (!srslte_srslte_dft_precoding_valid_prb(nof_prb)) {
if (!srslte_dft_precoding_valid_prb(nof_prb)) {
fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb);
return SRSLTE_ERROR;
}
for (uint32_t i=0;i<nof_symbols;i++) {
dft_run_c(&q->dft_plan[nof_prb], &input[i*SRSLTE_NRE*nof_prb], &output[i*SRSLTE_NRE*nof_prb]);
srslte_dft_run_c(&q->dft_plan[nof_prb], &input[i*SRSLTE_NRE*nof_prb], &output[i*SRSLTE_NRE*nof_prb]);
}
return SRSLTE_SUCCESS;
}
int srslte_dft_predecoding(srslte_srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
int srslte_dft_predecoding(srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
uint32_t nof_prb, uint32_t nof_symbols)
{
if (!srslte_srslte_dft_precoding_valid_prb(nof_prb)) {
if (!srslte_dft_precoding_valid_prb(nof_prb)) {
fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb);
return SRSLTE_ERROR;
}
for (uint32_t i=0;i<nof_symbols;i++) {
dft_run_c(&q->dft_plan[nof_prb], &input[i*SRSLTE_NRE*nof_prb], &output[i*SRSLTE_NRE*nof_prb]);
srslte_dft_run_c(&q->dft_plan[nof_prb], &input[i*SRSLTE_NRE*nof_prb], &output[i*SRSLTE_NRE*nof_prb]);
}
return SRSLTE_SUCCESS;

71
srslte/lib/common/src/fft.c → srslte/lib/dft/src/ofdm.c
Unescape Escape View File

@ -32,73 +32,74 @@
#include <math.h>
#include "srslte/common/phy_common.h"
#include "srslte/utils/dft.h"
#include "srslte/common/fft.h"
#include "srslte/dft/dft.h"
#include "srslte/dft/ofdm.h"
#include "srslte/utils/debug.h"
#include "srslte/utils/vector.h"
int srslte_fft_init_(srslte_fft_t *q, srslte_cp_t cp, uint32_t nof_prb, dft_dir_t dir) {
int srslte_ofdm_tx_init_(srslte_ofdm_t *q, srslte_cp_t cp, uint32_t nof_prb, srslte_dft_dir_t dir) {
int symbol_sz = srslte_symbol_sz(nof_prb);
if (symbol_sz < 0) {
fprintf(stderr, "Error: Invalid nof_prb=%d\n", nof_prb);
return -1;
}
if (dft_plan_c(&q->fft_plan, symbol_sz, dir)) {
if (srslte_dft_plan_c(&q->fft_plan, symbol_sz, dir)) {
fprintf(stderr, "Error: Creating DFT plan\n");
return -1;
}
q->tmp = malloc((uint32_t) symbol_sz * sizeof(cf_t));
q->tmp = srslte_vec_malloc((uint32_t) symbol_sz * sizeof(cf_t));
if (!q->tmp) {
perror("malloc");
return -1;
}
dft_plan_set_mirror(&q->fft_plan, true);
dft_plan_set_dc(&q->fft_plan, true);
srslte_dft_plan_set_mirror(&q->fft_plan, true);
srslte_dft_plan_set_dc(&q->fft_plan, true);
q->symbol_sz = (uint32_t) symbol_sz;
q->nof_symbols = SRSLTE_CP_NSYMB(cp);
q->cp = cp;
q->freq_shift = false;
q->shift_buffer = NULL;
q->nof_re = nof_prb * SRSLTE_NRE;
q->nof_guards = ((symbol_sz - q->nof_re) / 2);
q->slot_sz = SRSLTE_SLOT_LEN(symbol_sz);
DEBUG("Init %s symbol_sz=%d, nof_symbols=%d, cp=%s, nof_re=%d, nof_guards=%d\n",
dir==FORWARD?"FFT":"iFFT", q->symbol_sz, q->nof_symbols,
dir==SRSLTE_DFT_FORWARD?"FFT":"iFFT", q->symbol_sz, q->nof_symbols,
q->cp==SRSLTE_SRSLTE_CP_NORM?"Normal":"Extended", q->nof_re, q->nof_guards);
return SRSLTE_SUCCESS;
}
void srslte_fft_free_(srslte_fft_t *q) {
dft_plan_free(&q->fft_plan);
void srslte_ofdm_free_(srslte_ofdm_t *q) {
srslte_dft_plan_free(&q->fft_plan);
if (q->tmp) {
free(q->tmp);
}
if (q->shift_buffer) {
free(q->shift_buffer);
}
bzero(q, sizeof(srslte_fft_t));
bzero(q, sizeof(srslte_ofdm_t));
}
int srslte_fft_init(srslte_fft_t *q, srslte_cp_t cp, uint32_t nof_prb) {
return srslte_fft_init_(q, cp, nof_prb, FORWARD);
int srslte_ofdm_tx_init(srslte_ofdm_t *q, srslte_cp_t cp, uint32_t nof_prb) {
return srslte_ofdm_tx_init_(q, cp, nof_prb, SRSLTE_DFT_FORWARD);
}
void srslte_fft_free(srslte_fft_t *q) {
srslte_fft_free_(q);
void srslte_ofdm_tx_free(srslte_ofdm_t *q) {
srslte_ofdm_free_(q);
}
int lte_ifft_init(srslte_fft_t *q, srslte_cp_t cp, uint32_t nof_prb) {
int srslte_ofdm_rx_init(srslte_ofdm_t *q, srslte_cp_t cp, uint32_t nof_prb) {
uint32_t i;
int ret;
ret = srslte_fft_init_(q, cp, nof_prb, BACKWARD);
ret = srslte_ofdm_tx_init_(q, cp, nof_prb, SRSLTE_DFT_BACKWARD);
if (ret == SRSLTE_SUCCESS) {
dft_plan_set_norm(&q->fft_plan, true);
srslte_dft_plan_set_norm(&q->fft_plan, true);
/* set now zeros at CP */
for (i=0;i<q->nof_symbols;i++) {
@ -113,8 +114,8 @@ int lte_ifft_init(srslte_fft_t *q, srslte_cp_t cp, uint32_t nof_prb) {
* Freq_shift is relative to inter-carrier spacing.
* Caution: This function shall not be called during run-time
*/
int srslte_fft_set_freq_shift(srslte_fft_t *q, float freq_shift) {
q->shift_buffer = vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN(q->symbol_sz));
int srslte_ofdm_set_freq_shift(srslte_ofdm_t *q, float freq_shift) {
q->shift_buffer = srslte_vec_malloc(sizeof(cf_t) * SRSLTE_SF_LEN(q->symbol_sz));
if (!q->shift_buffer) {
perror("malloc");
return -1;
@ -131,50 +132,50 @@ int srslte_fft_set_freq_shift(srslte_fft_t *q, float freq_shift) {
}
/* Disable DC carrier addition */
dft_plan_set_dc(&q->fft_plan, false);
srslte_dft_plan_set_dc(&q->fft_plan, false);
q->freq_shift = true;
return SRSLTE_SUCCESS;
}
void lte_ifft_free(srslte_fft_t *q) {
srslte_fft_free_(q);
void srslte_ofdm_rx_free(srslte_ofdm_t *q) {
srslte_ofdm_free_(q);
}
/* Transforms input samples into output OFDM symbols.
* Performs FFT on a each symbol and removes CP.
*/
void srslte_fft_run_slot(srslte_fft_t *q, cf_t *input, cf_t *output) {
void srslte_ofdm_tx_slot(srslte_ofdm_t *q, cf_t *input, cf_t *output) {
uint32_t i;
for (i=0;i<q->nof_symbols;i++) {
input += SRSLTE_CP_ISNORM(q->cp)?SRSLTE_CP_NORM(i, q->symbol_sz):SRSLTE_CP_EXT(q->symbol_sz);
dft_run_c(&q->fft_plan, input, q->tmp);
srslte_dft_run_c(&q->fft_plan, input, q->tmp);
memcpy(output, &q->tmp[q->nof_guards], q->nof_re * sizeof(cf_t));
input += q->symbol_sz;
output += q->nof_re;
}
}
void srslte_fft_run_sf(srslte_fft_t *q, cf_t *input, cf_t *output) {
void srslte_ofdm_tx_sf(srslte_ofdm_t *q, cf_t *input, cf_t *output) {
uint32_t n;
if (q->freq_shift) {
vec_prod_ccc(input, q->shift_buffer, input, 2*q->slot_sz);
srslte_vec_prod_ccc(input, q->shift_buffer, input, 2*q->slot_sz);
}
for (n=0;n<2;n++) {
srslte_fft_run_slot(q, &input[n*q->slot_sz], &output[n*q->nof_re*q->nof_symbols]);
srslte_ofdm_tx_slot(q, &input[n*q->slot_sz], &output[n*q->nof_re*q->nof_symbols]);
}
}
/* Transforms input OFDM symbols into output samples.
* Performs FFT on a each symbol and adds CP.
*/
void lte_ifft_run_slot(srslte_fft_t *q, cf_t *input, cf_t *output) {
void srslte_ofdm_rx_slot(srslte_ofdm_t *q, cf_t *input, cf_t *output) {
uint32_t i, cp_len;
for (i=0;i<q->nof_symbols;i++) {
cp_len = SRSLTE_CP_ISNORM(q->cp)?SRSLTE_CP_NORM(i, q->symbol_sz):SRSLTE_CP_EXT(q->symbol_sz);
memcpy(&q->tmp[q->nof_guards], input, q->nof_re * sizeof(cf_t));
dft_run_c(&q->fft_plan, q->tmp, &output[cp_len]);
srslte_dft_run_c(&q->fft_plan, q->tmp, &output[cp_len]);
input += q->nof_re;
/* add CP */
memcpy(output, &output[q->symbol_sz], cp_len * sizeof(cf_t));
@ -182,16 +183,16 @@ void lte_ifft_run_slot(srslte_fft_t *q, cf_t *input, cf_t *output) {
}
}
void srslte_fft_set_normalize(srslte_fft_t *q, bool normalize_enable) {
dft_plan_set_norm(&q->fft_plan, normalize_enable);
void srslte_ofdm_set_normalize(srslte_ofdm_t *q, bool normalize_enable) {
srslte_dft_plan_set_norm(&q->fft_plan, normalize_enable);
}
void lte_ifft_run_sf(srslte_fft_t *q, cf_t *input, cf_t *output) {
void srslte_ofdm_rx_sf(srslte_ofdm_t *q, cf_t *input, cf_t *output) {
uint32_t n;
for (n=0;n<2;n++) {
lte_ifft_run_slot(q, &input[n*q->nof_re*q->nof_symbols], &output[n*q->slot_sz]);
srslte_ofdm_rx_slot(q, &input[n*q->nof_re*q->nof_symbols], &output[n*q->slot_sz]);
}
if (q->freq_shift) {
vec_prod_ccc(output, q->shift_buffer, output, 2*q->slot_sz);
srslte_vec_prod_ccc(output, q->shift_buffer, output, 2*q->slot_sz);
}
}

12
srslte/lib/common/test/CMakeLists.txt → srslte/lib/dft/test/CMakeLists.txt
Unescape Escape View File

@ -23,12 +23,12 @@
# FFT TEST
########################################################################
ADD_EXECUTABLE(fft_test fft_test.c)
TARGET_LINK_LIBRARIES(fft_test lte_phy)
ADD_EXECUTABLE(ofdm_test ofdm_test.c)
TARGET_LINK_LIBRARIES(ofdm_test lte_phy)
ADD_TEST(fft_normal fft_test)
ADD_TEST(fft_extended fft_test -e)
ADD_TEST(ofdm_normal ofdm_test)
ADD_TEST(ofdm_extended ofdm_test -e)
ADD_TEST(fft_normal_single fft_test -n 6)
ADD_TEST(fft_extended_single fft_test -e -n 6)
ADD_TEST(ofdm_normal_single ofdm_test -n 6)
ADD_TEST(ofdm_extended_single ofdm_test -e -n 6)

18
srslte/lib/common/test/fft_test.c → srslte/lib/dft/test/ofdm_test.c
Unescape Escape View File

@ -62,7 +62,7 @@ void parse_args(int argc, char **argv) {
int main(int argc, char **argv) {
srslte_fft_t fft, ifft;
srslte_ofdm_t fft, ifft;
cf_t *input, *outfft, *outifft;
float mse;
int n_prb, max_prb, n_re;
@ -98,24 +98,24 @@ int main(int argc, char **argv) {
exit(-1);
}
if (srslte_fft_init(&fft, cp, n_prb)) {
if (srslte_ofdm_tx_init(&fft, cp, n_prb)) {
fprintf(stderr, "Error initializing FFT\n");
exit(-1);
}
dft_plan_set_norm(&fft.fft_plan, true);
srslte_dft_plan_set_norm(&fft.fft_plan, true);
if (lte_ifft_init(&ifft, cp, n_prb)) {
if (srslte_ofdm_rx_init(&ifft, cp, n_prb)) {
fprintf(stderr, "Error initializing iFFT\n");
exit(-1);
}
dft_plan_set_norm(&ifft.fft_plan, true);
srslte_dft_plan_set_norm(&ifft.fft_plan, true);
for (i=0;i<n_re;i++) {
input[i] = 100 * ((float) rand()/RAND_MAX + (float) I*rand()/RAND_MAX);
}
lte_ifft_run_slot(&ifft, input, outfft);
srslte_fft_run_slot(&fft, outfft, outifft);
srslte_ofdm_rx_slot(&ifft, input, outfft);
srslte_ofdm_tx_slot(&fft, outfft, outifft);
/* compute MSE */
@ -130,8 +130,8 @@ int main(int argc, char **argv) {
exit(-1);
}
srslte_fft_free(&fft);
lte_ifft_free(&ifft);
srslte_ofdm_tx_free(&fft);
srslte_ofdm_rx_free(&ifft);
free(input);
free(outfft);

6
srslte/lib/fec/src/crc.c
Unescape Escape View File

@ -29,7 +29,7 @@
#include <stdlib.h>
#include <string.h>
#include "srslte/utils/pack.h"
#include "srslte/utils/bit.h"
#include "srslte/fec/crc.h"
void gen_srslte_crc_table(srslte_crc_t *h) {
@ -137,7 +137,7 @@ uint32_t srslte_crc_checksum(srslte_crc_t *h, uint8_t *data, int len) {
h->byte |= ((uint8_t) *(pter + k)) << (7 - k);
}
} else {
h->byte = (uint8_t) (unpack_bits(&pter, 8) & 0xFF);
h->byte = (uint8_t) (srslte_bit_unpack(&pter, 8) & 0xFF);
}
crc = crctable(h);
}
@ -160,6 +160,6 @@ void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
// Add CRC
uint8_t *ptr = &data[len];
pack_bits(checksum, &ptr, h->order);
srslte_bit_pack(checksum, &ptr, h->order);
}

24
srslte/lib/fec/src/turbodecoder.c
Unescape Escape View File

@ -166,9 +166,9 @@ void srslte_map_gen_alpha(srslte_map_gen_t * s, srslte_llr_t * input, srslte_llr
int srslte_map_gen_init(srslte_map_gen_t * h, int max_long_cb)
{
bzero(h, sizeof(srslte_map_gen_t));
h->beta = vec_malloc(sizeof(srslte_llr_t) * (max_long_cb + SRSLTE_TCOD_TOTALTAIL + 1) * NUMSTATES);
h->beta = srslte_vec_malloc(sizeof(srslte_llr_t) * (max_long_cb + SRSLTE_TCOD_TOTALTAIL + 1) * NUMSTATES);
if (!h->beta) {
perror("vec_malloc");
perror("srslte_vec_malloc");
return -1;
}
h->max_long_cb = max_long_cb;
@ -209,29 +209,29 @@ int srslte_tdec_init(srslte_tdec_t * h, uint32_t max_long_cb)
h->max_long_cb = max_long_cb;
h->llr1 = vec_malloc(sizeof(srslte_llr_t) * len);
h->llr1 = srslte_vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->llr1) {
perror("vec_malloc");
perror("srslte_vec_malloc");
goto clean_and_exit;
}
h->llr2 = vec_malloc(sizeof(srslte_llr_t) * len);
h->llr2 = srslte_vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->llr2) {
perror("vec_malloc");
perror("srslte_vec_malloc");
goto clean_and_exit;
}
h->w = vec_malloc(sizeof(srslte_llr_t) * len);
h->w = srslte_vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->w) {
perror("vec_malloc");
perror("srslte_vec_malloc");
goto clean_and_exit;
}
h->syst = vec_malloc(sizeof(srslte_llr_t) * len);
h->syst = srslte_vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->syst) {
perror("vec_malloc");
perror("srslte_vec_malloc");
goto clean_and_exit;
}
h->parity = vec_malloc(sizeof(srslte_llr_t) * len);
h->parity = srslte_vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->parity) {
perror("vec_malloc");
perror("srslte_vec_malloc");
goto clean_and_exit;
}

2
srslte/lib/fec/src/viterbi.c
Unescape Escape View File

@ -218,7 +218,7 @@ int srslte_viterbi_decode_f(srslte_viterbi_t *q, float *symbols, uint8_t *data,
len = 3 * (frame_length + q->K - 1);
}
if (!q->decode_f) {
vec_quant_fuc(symbols, q->symbols_uc, q->gain_quant, 127.5, 255, len);
srslte_vec_quant_fuc(symbols, q->symbols_uc, q->gain_quant, 127.5, 255, len);
return q->decode(q, q->symbols_uc, data, frame_length);
} else {
return q->decode_f(q, symbols, data, frame_length);

6
srslte/lib/fec/test/rm_turbo_rx_mex.c
Unescape Escape View File

@ -68,8 +68,8 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
trblklen = (uint32_t) mxGetScalar(TRBLKLEN);
rvidx = (uint32_t) mxGetScalar(RV);
struct cb_segm cbsegm;
codeblock_segmentation(&cbsegm, trblklen);
srslte_harq_cbsegm_t cbsegm;
srslte_harq_codeblock_segmentation(&cbsegm, trblklen);
cblen = 3*cbsegm.K1+12;
w_buff_f = calloc(1,sizeof(float) * cblen * 10);
@ -79,7 +79,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
}
// allocate memory for output bits
output = vec_malloc(cblen * sizeof(float));
output = srslte_vec_malloc(cblen * sizeof(float));
srslte_rm_turbo_rx(w_buff_f, cblen * 10, input, in_len, output, cblen,
rvidx,cbsegm.F);

10
srslte/lib/fec/test/rm_turbo_test.c
Unescape Escape View File

@ -129,12 +129,12 @@ int main(int argc, char **argv) {
}
printf("BITS: ");
vec_fprint_b(stdout, bits, nof_tx_bits);
srslte_vec_fprint_b(stdout, bits, nof_tx_bits);
srslte_rm_turbo_tx(w_buff_c, nof_tx_bits * 10, bits, nof_tx_bits, rm_bits, nof_rx_bits, rv_idx);
printf("RM: ");
vec_fprint_b(stdout, rm_bits, nof_rx_bits);
srslte_vec_fprint_b(stdout, rm_bits, nof_rx_bits);
for (i = 0; i < nof_rx_bits; i++) {
rm_symbols[i] = (float) rm_bits[i] ? 1 : -1;
@ -144,15 +144,15 @@ int main(int argc, char **argv) {
rv_idx, nof_filler_bits);
printf("UMRM: ");
vec_fprint_f(stdout, unrm_symbols, nof_tx_bits);
srslte_vec_fprint_f(stdout, unrm_symbols, nof_tx_bits);
for (i=0;i<nof_tx_bits;i++) {
bits_out[i] = unrm_symbols[i]>0?1:0;
}
printf("BITS: ");
vec_fprint_b(stdout, bits_out, nof_tx_bits);
srslte_vec_fprint_b(stdout, bits_out, nof_tx_bits);
printf("BITS: ");
vec_fprint_b(stdout, bits, nof_tx_bits);
srslte_vec_fprint_b(stdout, bits, nof_tx_bits);
nof_errors = 0;
for (i = 0; i < nof_tx_bits; i++) {

14
srslte/lib/fec/test/turbodecoder_test.c
Unescape Escape View File

@ -93,7 +93,7 @@ void parse_args(int argc, char **argv) {
seed = (uint32_t) strtoul(argv[optind], NULL, 0);
break;
case 'v':
verbose++;
srslte_verbose++;
break;
default:
usage(argv[0]);
@ -162,29 +162,29 @@ int main(int argc, char **argv) {
printf(" EbNo: %.2f\n", ebno_db);
}
data_tx = vec_malloc(frame_length * sizeof(uint8_t));
data_tx = srslte_vec_malloc(frame_length * sizeof(uint8_t));
if (!data_tx) {
perror("malloc");
exit(-1);
}
data_rx = vec_malloc(frame_length * sizeof(uint8_t));
data_rx = srslte_vec_malloc(frame_length * sizeof(uint8_t));
if (!data_rx) {
perror("malloc");
exit(-1);
}
symbols = vec_malloc(coded_length * sizeof(uint8_t));
symbols = srslte_vec_malloc(coded_length * sizeof(uint8_t));
if (!symbols) {
perror("malloc");
exit(-1);
}
llr = vec_malloc(coded_length * sizeof(float));
llr = srslte_vec_malloc(coded_length * sizeof(float));
if (!llr) {
perror("malloc");
exit(-1);
}
llr_c = vec_malloc(coded_length * sizeof(uint8_t));
llr_c = srslte_vec_malloc(coded_length * sizeof(uint8_t));
if (!llr_c) {
perror("malloc");
exit(-1);
@ -267,7 +267,7 @@ int main(int argc, char **argv) {
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);
errors[j] += srslte_bit_diff(data_tx, data_rx, frame_length);
if (j < MAX_ITERATIONS) {
ber[j][i] = (float) errors[j] / (frame_cnt * frame_length);
}

2
srslte/lib/fec/test/turbodecoder_test_mex.c
Unescape Escape View File

@ -84,7 +84,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
}
// allocate memory for output bits
output_data = vec_malloc(nof_bits * sizeof(uint8_t));
output_data = srslte_vec_malloc(nof_bits * sizeof(uint8_t));
if (srslte_tdec_init(&tdec, nof_bits)) {
mexErrMsgTxt("Error initiating Turbo decoder\n");

4
srslte/lib/fec/test/viterbi_test.c
Unescape Escape View File

@ -279,7 +279,7 @@ int main(int argc, char **argv) {
}
srslte_ch_awgn_f(llr, llr, var[i], coded_length[n]);
vec_quant_fuc(llr, llr_c, Gain, 127.5, 255, coded_length[n]);
srslte_vec_quant_fuc(llr, llr_c, Gain, 127.5, 255, coded_length[n]);
/* decoder 1 */
srslte_viterbi_decode_uc(&dec[n], llr_c, data_rx[1+n], frame_length);
@ -287,7 +287,7 @@ int main(int argc, char **argv) {
/* check errors */
for (j = 0; j < 1+ncods; j++) {
errors[j] += bit_diff(data_tx, data_rx[j], frame_length);
errors[j] += srslte_bit_diff(data_tx, data_rx[j], frame_length);
}
frame_cnt++;
printf("Eb/No: %3.2f %10d/%d ",

2
srslte/lib/fec/test/viterbi_test_mex.c
Unescape Escape View File

@ -59,7 +59,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// Read input symbols
nof_bits = mexutils_read_f(INPUT, &input_llr);
output_data = vec_malloc(nof_bits * sizeof(uint8_t));
output_data = srslte_vec_malloc(nof_bits * sizeof(uint8_t));
uint32_t poly[3] = { 0x6D, 0x4F, 0x57 };
if (srslte_viterbi_init(&viterbi, SRSLTE_VITERBI_37, poly, nof_bits/3, true)) {

194
srslte/lib/filter/src/filter2d.c
Unescape Escape View File

@ -1,194 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2014 The libLTE Developers. See the
* COPYRIGHT file at the top-level directory of this distribution.
*
* \section LICENSE
*
* This file is part of the libLTE library.
*
* libLTE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* libLTE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* A copy of the GNU Lesser General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include "srslte/utils/debug.h"
#include "srslte/resampling/interp.h"
#include "srslte/filter/filter2d.h"
#include "srslte/utils/matrix.h"
#include "srslte/utils/vector.h"
#include "srslte/utils/debug.h"
/* Useful macros */
#define intceil(X, Y) ((X-1)/Y+1)
#define idx(a, b) ((a)*(q->szfreq+q->nfreq)+b)
int srslte_filter2d_init(srslte_filter2d_t* q, float **taps, uint32_t ntime, uint32_t nfreq, uint32_t sztime,
uint32_t szfreq) {
int ret = -1;
bzero(q, sizeof(srslte_filter2d_t));
if (matrix_init((void***)&q->taps, ntime, nfreq, sizeof(float))) {
goto free_and_exit;
}
matrix_copy((void**) q->taps, (void**) taps, ntime, nfreq, sizeof(float));
q->output = vec_malloc((ntime+sztime)*(szfreq+nfreq)*sizeof(cf_t));
if (!q->output) {
goto free_and_exit;
}
bzero(q->output, (ntime+sztime)*(szfreq+nfreq)*sizeof(cf_t));
q->nfreq = nfreq;
q->ntime = ntime;
q->szfreq = szfreq;
q->sztime = sztime;
q->norm = 0.0;
for (int i = 0; i < ntime; i++) {
for (int j = 0; j < nfreq; j++) {
q->norm += q->taps[i][j];
}
}
ret = 0;
free_and_exit: if (ret == -1) {
srslte_filter2d_free(q);
}
return ret;
}
void srslte_filter2d_free(srslte_filter2d_t *q) {
matrix_free((void**) q->taps, q->ntime);
if (q->output) {
free(q->output);
}
bzero(q, sizeof(srslte_filter2d_t));
}
int srslte_filter2d_init_ones(srslte_filter2d_t* q, uint32_t ntime, uint32_t nfreq, uint32_t sztime,
uint32_t szfreq)
{
int i, j;
float **taps;
int ret = -1;
if (matrix_init((void***) &taps, ntime, nfreq, sizeof(float))) {
goto free_and_exit;
}
/* Compute the default 2-D interpolation mesh */
for (i = 0; i < ntime; i++) {
for (j = 0; j < nfreq; j++) {
taps[i][j] = 1.0/(i+1);
}
}
INFO("Using all-ones interpolation matrix of size %dx%d\n", ntime, nfreq);
if (verbose >= VERBOSE_INFO) {
matrix_fprintf_f(stdout, taps, ntime, nfreq);
}
if (srslte_filter2d_init(q, taps, ntime, nfreq, sztime, szfreq)) {
goto free_and_exit;
}
ret = 0;
free_and_exit:
matrix_free((void**) taps, ntime);
return ret;
}
/* Moves the last ntime symbols to the start and clears the remaining of the output.
* Should be called, for instance, before filtering each OFDM frame.
*/
void srslte_filter2d_step(srslte_filter2d_t *q) {
int i;
for (i = 0; i < q->ntime; i++) {
memcpy(&q->output[idx(i,0)], &q->output[idx(q->sztime + i,0)],
sizeof(cf_t) * (q->szfreq+q->nfreq));
}
for (; i < q->ntime + q->sztime; i++) {
memset(&q->output[idx(i,0)], 0, sizeof(cf_t) * (q->szfreq+q->nfreq));
}
}
void srslte_filter2d_reset(srslte_filter2d_t *q) {
bzero(q->output, (q->ntime+q->sztime)*(q->szfreq+q->nfreq)*sizeof(cf_t));
}
/** Adds samples x to the from the given time/freq indexes to the filter
* and computes the output.
*/
void srslte_filter2d_add(srslte_filter2d_t *q, cf_t x, uint32_t time_idx, uint32_t freq_idx) {
int i, j;
uint32_t ntime = q->ntime;
uint32_t nfreq = q->nfreq;
if (freq_idx < q->szfreq && time_idx < q->sztime) {
DEBUG("Adding %f+%fi to %d:%d\n",__real__ x,__imag__ x,time_idx,freq_idx);
for (i = 0; i < ntime; i++) {
for (j = 0; j < nfreq; j++) {
q->output[idx(i+time_idx, j+freq_idx)] += x * (cf_t)(q->taps[i][j])/q->norm;
}
}
}
}
void srslte_filter2d_add_out(srslte_filter2d_t *q, cf_t x, int time_idx, int freq_idx) {
int i, j;
uint32_t ntime = q->ntime;
uint32_t nfreq = q->nfreq;
float norm=0;
for (i = 0; i < ntime; i++) {
for (j = 0; j < nfreq; j++) {
if (i+time_idx >= 0 && j+freq_idx >= 0 &&
i+time_idx < q->ntime+q->sztime && j+freq_idx < q->nfreq + q->szfreq)
{
norm += q->taps[i][j];
}
}
}
for (i = 0; i < ntime; i++) {
for (j = 0; j < nfreq; j++) {
if (i+time_idx >= 0 && j+freq_idx >= 0 &&
i+time_idx < q->ntime+q->sztime && j+freq_idx < q->nfreq + q->szfreq)
{
q->output[idx(i+time_idx, j+freq_idx)] += x * (cf_t)(q->taps[i][j])/q->norm;
}
}
}
}
void srslte_filter2d_get_symbol(srslte_filter2d_t *q, uint32_t nsymbol, cf_t *output) {
memcpy(output, &q->output[idx(nsymbol,q->nfreq/2)], sizeof(cf_t) * (q->szfreq));
}

4
srslte/lib/io/src/binsource.c
Unescape Escape View File

@ -106,9 +106,9 @@ static int int_2_bits(uint32_t* src, uint8_t* dst, int nbits) {
int n;
n=nbits/32;
for (int i=0;i<n;i++) {
bit_pack(src[i],&dst,32);
srslte_bit_pack(src[i],&dst,32);
}
bit_pack(src[n],&dst,nbits-n*32);
srslte_bit_pack(src[n],&dst,nbits-n*32);
return n;
}

12
srslte/lib/mimo/src/layermap.c
Unescape Escape View File

@ -94,7 +94,7 @@ int srslte_layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYER
}
switch(type) {
case SINGLE_ANTENNA:
case SRSLTE_MIMO_TYPE_SINGLE_ANTENNA:
if (nof_cw == 1 && nof_layers == 1) {
return srslte_layermap_single(x[0], d[0], nof_symbols[0]);
} else {
@ -102,7 +102,7 @@ int srslte_layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYER
return -1;
}
break;
case TX_DIVERSITY:
case SRSLTE_MIMO_TYPE_TX_DIVERSITY:
if (nof_cw == 1) {
if (nof_layers == 2 || nof_layers == 4) {
return srslte_layermap_diversity(d[0], x, nof_layers, nof_symbols[0]);
@ -115,7 +115,7 @@ int srslte_layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYER
return -1;
}
break;
case SPATIAL_MULTIPLEX:
case SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX:
return srslte_layermap_multiplex(d, x, nof_cw, nof_layers, nof_symbols);
break;
}
@ -183,7 +183,7 @@ int srslte_layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWO
}
switch(type) {
case SINGLE_ANTENNA:
case SRSLTE_MIMO_TYPE_SINGLE_ANTENNA:
if (nof_cw == 1 && nof_layers == 1) {
nof_symbols[0] = srslte_layerdemap_single(x[0], d[0], nof_layer_symbols);
nof_symbols[1] = 0;
@ -192,7 +192,7 @@ int srslte_layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWO
return -1;
}
break;
case TX_DIVERSITY:
case SRSLTE_MIMO_TYPE_TX_DIVERSITY:
if (nof_cw == 1) {
if (nof_layers == 2 || nof_layers == 4) {
nof_symbols[0] = srslte_layerdemap_diversity(x, d[0], nof_layers, nof_layer_symbols);
@ -206,7 +206,7 @@ int srslte_layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWO
return -1;
}
break;
case SPATIAL_MULTIPLEX:
case SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX:
return srslte_layerdemap_multiplex(x, d, nof_layers, nof_cw, nof_layer_symbols, nof_symbols);
break;
}

94
srslte/lib/mimo/src/precoding.c
Unescape Escape View File

@ -42,41 +42,41 @@
*
**************************************************/
int precoding_init(precoding_t *q, uint32_t max_frame_len) {
int srslte_precoding_init(srslte_precoding_t *q, uint32_t max_frame_len) {
if (q) {
bzero(q, sizeof(precoding_t));
bzero(q, sizeof(srslte_precoding_t));
q->h_mod = vec_malloc(sizeof(cf_t) * max_frame_len);
q->h_mod = srslte_vec_malloc(sizeof(cf_t) * max_frame_len);
if (!q->h_mod) {
perror("malloc");
goto clean_exit;
}
q->tmp1 = vec_malloc(sizeof(cf_t) * max_frame_len);
q->tmp1 = srslte_vec_malloc(sizeof(cf_t) * max_frame_len);
if (!q->tmp1) {
perror("malloc");
goto clean_exit;
}
q->tmp2 = vec_malloc(sizeof(cf_t) * max_frame_len);
q->tmp2 = srslte_vec_malloc(sizeof(cf_t) * max_frame_len);
if (!q->tmp2) {
perror("malloc");
goto clean_exit;
}
q->tmp3 = vec_malloc(sizeof(cf_t) * max_frame_len);
q->tmp3 = srslte_vec_malloc(sizeof(cf_t) * max_frame_len);
if (!q->tmp3) {
perror("malloc");
goto clean_exit;
}
q->y_mod = vec_malloc(sizeof(float) * max_frame_len);
q->y_mod = srslte_vec_malloc(sizeof(float) * max_frame_len);
if (!q->y_mod) {
perror("malloc");
goto clean_exit;
}
q->z_real = vec_malloc(sizeof(float) * max_frame_len);
q->z_real = srslte_vec_malloc(sizeof(float) * max_frame_len);
if (!q->z_real) {
perror("malloc");
goto clean_exit;
}
q->z_imag = vec_malloc(sizeof(float) * max_frame_len);
q->z_imag = srslte_vec_malloc(sizeof(float) * max_frame_len);
if (!q->z_imag) {
perror("malloc");
goto clean_exit;
@ -87,11 +87,11 @@ int precoding_init(precoding_t *q, uint32_t max_frame_len) {
return SRSLTE_ERROR_INVALID_INPUTS;
}
clean_exit:
precoding_free(q);
srslte_precoding_free(q);
return SRSLTE_ERROR;
}
void precoding_free(precoding_t *q) {
void srslte_precoding_free(srslte_precoding_t *q) {
if (q->tmp1) {
free(q->tmp1);
@ -114,22 +114,22 @@ void precoding_free(precoding_t *q) {
if (q->z_imag) {
free(q->z_imag);
}
bzero(q, sizeof(precoding_t));
bzero(q, sizeof(srslte_precoding_t));
}
/* ZF/MMSE SISO equalizer x=y(h'h+no)^(-1)h' (ZF if n0=0.0)*/
int predecoding_single(precoding_t *q, cf_t *y, cf_t *h, cf_t *x, int nof_symbols, float noise_estimate) {
int srslte_predecoding_single(srslte_precoding_t *q, cf_t *y, cf_t *h, cf_t *x, int nof_symbols, float noise_estimate) {
if (nof_symbols <= q->max_frame_len) {
// h'h
vec_abs_square_cf(h, q->y_mod, nof_symbols);
srslte_vec_abs_square_cf(h, q->y_mod, nof_symbols);
if (noise_estimate > 0.0) {
// (h'h + n0)
vec_sc_add_fff(q->y_mod, noise_estimate, q->y_mod, nof_symbols);
srslte_vec_sc_add_fff(q->y_mod, noise_estimate, q->y_mod, nof_symbols);
}
// y*h'
vec_prod_conj_ccc(y, h, x, nof_symbols);
srslte_vec_prod_conj_ccc(y, h, x, nof_symbols);
// divide by (h'h+no)
vec_div_cfc(x,q->y_mod,x,q->z_real,q->z_imag, nof_symbols);
srslte_vec_div_cfc(x,q->y_mod,x,q->z_real,q->z_imag, nof_symbols);
return nof_symbols;
} else {
return SRSLTE_ERROR;
@ -138,7 +138,7 @@ int predecoding_single(precoding_t *q, cf_t *y, cf_t *h, cf_t *x, int nof_symbol
/* ZF/MMSE STBC equalizer x=y(H'H+n0·I)^(-1)H' (ZF is n0=0.0)
*/
int predecoding_diversity(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x[SRSLTE_MAX_LAYERS],
int srslte_predecoding_diversity(srslte_precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports, int nof_symbols, float noise_estimate)
{
int i;
@ -166,27 +166,27 @@ int predecoding_diversity(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf
}
// Compute common dividend and store in y_mod
vec_abs_square_cf(h0, modh0, nof_symbols/2);
vec_abs_square_cf(h1, modh1, nof_symbols/2);
vec_sum_fff(modh0, modh1, modhh, nof_symbols/2);
srslte_vec_abs_square_cf(h0, modh0, nof_symbols/2);
srslte_vec_abs_square_cf(h1, modh1, nof_symbols/2);
srslte_vec_sum_fff(modh0, modh1, modhh, nof_symbols/2);
//if (noise_estimate > 0.0) {
// (H'H + n0)
//vec_sc_add_fff(modhh, noise_estimate, modhh, nof_symbols/2);
//srslte_vec_sc_add_fff(modhh, noise_estimate, modhh, nof_symbols/2);
//}
vec_sc_prod_fff(modhh, 1/sqrt(2), modhh, nof_symbols/2);
srslte_vec_sc_prod_fff(modhh, 1/sqrt(2), modhh, nof_symbols/2);
// x[0] = r0·h0*/(|h0|+|h1|)+r1*·h1/(|h0|+|h1|)
vec_prod_conj_ccc(r0,h0,q->tmp1, nof_symbols/2);
vec_prod_conj_ccc(h1,r1,q->tmp2, nof_symbols/2);
vec_sum_ccc(q->tmp1, q->tmp2, x[0], nof_symbols/2);
vec_div_cfc(x[0], modhh, x[0], q->z_real, q->z_imag, nof_symbols/2);
srslte_vec_prod_conj_ccc(r0,h0,q->tmp1, nof_symbols/2);
srslte_vec_prod_conj_ccc(h1,r1,q->tmp2, nof_symbols/2);
srslte_vec_sum_ccc(q->tmp1, q->tmp2, x[0], nof_symbols/2);
srslte_vec_div_cfc(x[0], modhh, x[0], q->z_real, q->z_imag, nof_symbols/2);
// x[1] = r1·h0*/(|h0|+|h1|)-r0*·h1/(|h0|+|h1|)
vec_prod_conj_ccc(r1,h0,q->tmp1, nof_symbols/2);
vec_prod_conj_ccc(h1,r0,q->tmp2, nof_symbols/2);
vec_sub_ccc(q->tmp1, q->tmp2, x[1], nof_symbols/2);
vec_div_cfc(x[1], modhh, x[1], q->z_real, q->z_imag, nof_symbols/2);
srslte_vec_prod_conj_ccc(r1,h0,q->tmp1, nof_symbols/2);
srslte_vec_prod_conj_ccc(h1,r0,q->tmp2, nof_symbols/2);
srslte_vec_sub_ccc(q->tmp1, q->tmp2, x[1], nof_symbols/2);
srslte_vec_div_cfc(x[1], modhh, x[1], q->z_real, q->z_imag, nof_symbols/2);
#else
cf_t h0, h1, h2, h3, r0, r1, r2, r3;
@ -240,7 +240,7 @@ int predecoding_diversity(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf
}
/* 36.211 v10.3.0 Section 6.3.4 */
int predecoding_type(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x[SRSLTE_MAX_LAYERS],
int srslte_predecoding_type(srslte_precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x[SRSLTE_MAX_LAYERS],
int nof_ports, int nof_layers, int nof_symbols, srslte_mimo_type_t type, float noise_estimate) {
if (nof_ports > SRSLTE_MAX_PORTS) {
@ -255,25 +255,25 @@ int predecoding_type(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x
}
switch (type) {
case SINGLE_ANTENNA:
case SRSLTE_MIMO_TYPE_SINGLE_ANTENNA:
if (nof_ports == 1 && nof_layers == 1) {
return predecoding_single(q, y, h[0], x[0], nof_symbols, noise_estimate);
return srslte_predecoding_single(q, y, h[0], x[0], nof_symbols, noise_estimate);
} else {
fprintf(stderr,
"Number of ports and layers must be 1 for transmission on single antenna ports\n");
return -1;
}
break;
case TX_DIVERSITY:
case SRSLTE_MIMO_TYPE_TX_DIVERSITY:
if (nof_ports == nof_layers) {
return predecoding_diversity(q, y, h, x, nof_ports, nof_symbols, noise_estimate);
return srslte_predecoding_diversity(q, y, h, x, nof_ports, nof_symbols, noise_estimate);
} else {
fprintf(stderr,
"Error number of layers must equal number of ports in transmit diversity\n");
return -1;
}
break;
case SPATIAL_MULTIPLEX:
case SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX:
fprintf(stderr, "Spatial multiplexing not supported\n");
return -1;
}
@ -291,11 +291,11 @@ int predecoding_type(precoding_t *q, cf_t *y, cf_t *h[SRSLTE_MAX_PORTS], cf_t *x
*
**************************************************/
int precoding_single(precoding_t *q, cf_t *x, cf_t *y, int nof_symbols) {
int srslte_precoding_single(srslte_precoding_t *q, cf_t *x, cf_t *y, int nof_symbols) {
memcpy(y, x, nof_symbols * sizeof(cf_t));
return nof_symbols;
}
int precoding_diversity(precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSLTE_MAX_PORTS], int nof_ports,
int srslte_precoding_diversity(srslte_precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSLTE_MAX_PORTS], int nof_ports,
int nof_symbols) {
int i;
if (nof_ports == 2) {
@ -306,8 +306,8 @@ int precoding_diversity(precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSL
y[1][2 * i + 1] = conjf(x[0][i]);
}
// normalize
vec_sc_prod_cfc(y[0], 1.0/sqrtf(2), y[0], 2*nof_symbols);
vec_sc_prod_cfc(y[1], 1.0/sqrtf(2), y[1], 2*nof_symbols);
srslte_vec_sc_prod_cfc(y[0], 1.0/sqrtf(2), y[0], 2*nof_symbols);
srslte_vec_sc_prod_cfc(y[1], 1.0/sqrtf(2), y[1], 2*nof_symbols);
return 2 * i;
} else if (nof_ports == 4) {
//int m_ap = (nof_symbols%4)?(nof_symbols*4-2):nof_symbols*4;
@ -341,7 +341,7 @@ int precoding_diversity(precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSL
}
/* 36.211 v10.3.0 Section 6.3.4 */
int precoding_type(precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSLTE_MAX_PORTS], int nof_layers,
int srslte_precoding_type(srslte_precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSLTE_MAX_PORTS], int nof_layers,
int nof_ports, int nof_symbols, srslte_mimo_type_t type) {
if (nof_ports > SRSLTE_MAX_PORTS) {
@ -356,24 +356,24 @@ int precoding_type(precoding_t *q, cf_t *x[SRSLTE_MAX_LAYERS], cf_t *y[SRSLTE_MA
}
switch (type) {
case SINGLE_ANTENNA:
case SRSLTE_MIMO_TYPE_SINGLE_ANTENNA:
if (nof_ports == 1 && nof_layers == 1) {
return precoding_single(q, x[0], y[0], nof_symbols);
return srslte_precoding_single(q, x[0], y[0], nof_symbols);
} else {
fprintf(stderr,
"Number of ports and layers must be 1 for transmission on single antenna ports\n");
return -1;
}
break;
case TX_DIVERSITY:
case SRSLTE_MIMO_TYPE_TX_DIVERSITY:
if (nof_ports == nof_layers) {
return precoding_diversity(q, x, y, nof_ports, nof_symbols);
return srslte_precoding_diversity(q, x, y, nof_ports, nof_symbols);
} else {
fprintf(stderr,
"Error number of layers must equal number of ports in transmit diversity\n");
return -1;
}
case SPATIAL_MULTIPLEX:
case SRSLTE_MIMO_TYPE_SPATIAL_MULTIPLEX:
fprintf(stderr, "Spatial multiplexing not supported\n");
return -1;
}

28
srslte/lib/mimo/test/precoding_test.c
Unescape Escape View File

@ -82,7 +82,7 @@ int main(int argc, char **argv) {
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;
precoding_t precoding;
srslte_precoding_t precoding;
parse_args(argc, argv);
@ -97,35 +97,35 @@ int main(int argc, char **argv) {
}
for (i = 0; i < nof_layers; i++) {
x[i] = vec_malloc(sizeof(cf_t) * nof_symbols);
x[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols);
if (!x[i]) {
perror("vec_malloc");
perror("srslte_vec_malloc");
exit(-1);
}
xr[i] = calloc(1,sizeof(cf_t) * nof_symbols);
if (!xr[i]) {
perror("vec_malloc");
perror("srslte_vec_malloc");
exit(-1);
}
}
for (i = 0; i < nof_ports; i++) {
y[i] = vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers);
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("vec_malloc");
perror("srslte_vec_malloc");
exit(-1);
}
h[i] = vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers);
h[i] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers);
if (!h[i]) {
perror("vec_malloc");
perror("srslte_vec_malloc");
exit(-1);
}
}
/* only 1 receiver antenna supported now */
r[0] = vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers);
r[0] = srslte_vec_malloc(sizeof(cf_t) * nof_symbols * nof_layers);
if (!r[0]) {
perror("vec_malloc");
perror("srslte_vec_malloc");
exit(-1);
}
@ -136,13 +136,13 @@ int main(int argc, char **argv) {
}
}
if (precoding_init(&precoding, nof_symbols * nof_layers)) {
if (srslte_precoding_init(&precoding, nof_symbols * nof_layers)) {
fprintf(stderr, "Error initializing precoding\n");
exit(-1);
}
/* precoding */
if (precoding_type(&precoding, x, y, nof_layers, nof_ports, nof_symbols, type) < 0) {
if (srslte_precoding_type(&precoding, x, y, nof_layers, nof_ports, nof_symbols, type) < 0) {
fprintf(stderr, "Error layer mapper encoder\n");
exit(-1);
}
@ -173,7 +173,7 @@ int main(int argc, char **argv) {
/* predecoding / equalization */
struct timeval t[3];
gettimeofday(&t[1], NULL);
if (predecoding_type(&precoding, r[0], h, xr, nof_ports, nof_layers,
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);
@ -206,7 +206,7 @@ int main(int argc, char **argv) {
free(r[0]);
precoding_free(&precoding);
srslte_precoding_free(&precoding);
printf("Ok\n");
exit(0);

28
srslte/lib/modem/src/demod_hard.c
Unescape Escape View File

@ -33,31 +33,31 @@
#include "hard_demod_lte.h"
void demod_hard_init(demod_hard_t* q) {
bzero((void*) q, sizeof(demod_hard_t));
void srslte_demod_hard_init(srslte_demod_hard_t* q) {
bzero((void*) q, sizeof(srslte_demod_hard_t));
}
void demod_hard_table_set(demod_hard_t* q, srslte_mod_t mod) {
void srslte_demod_hard_table_set(srslte_demod_hard_t* q, srslte_mod_t mod) {
q->mod = mod;
}
int demod_hard_demodulate(demod_hard_t* q, cf_t* symbols, uint8_t *bits, uint32_t nsymbols) {
int srslte_demod_hard_demodulate(srslte_demod_hard_t* q, cf_t* symbols, uint8_t *bits, uint32_t nsymbols) {
int nbits=-1;
switch(q->mod) {
case LTE_BPSK:
case SRSLTE_MOD_BPSK:
hard_bpsk_demod(symbols,bits,nsymbols);
nbits=nsymbols;
break;
case LTE_QPSK:
case SRSLTE_MOD_QPSK:
hard_qpsk_demod(symbols,bits,nsymbols);
nbits=nsymbols*2;
break;
case LTE_QAM16:
case SRSLTE_MOD_16QAM:
hard_qam16_demod(symbols,bits,nsymbols);
nbits=nsymbols*4;
break;
case LTE_QAM64:
case SRSLTE_MOD_64QAM:
hard_qam64_demod(symbols,bits,nsymbols);
nbits=nsymbols*6;
break;
@ -66,20 +66,20 @@ int demod_hard_demodulate(demod_hard_t* q, cf_t* symbols, uint8_t *bits, uint32_
}
int demod_hard_initialize(demod_hard_hl* hl) {
demod_hard_init(&hl->obj);
demod_hard_table_set(&hl->obj,hl->init.std);
int srslte_demod_hard_initialize(srslte_demod_hard_hl* hl) {
srslte_demod_hard_init(&hl->obj);
srslte_demod_hard_table_set(&hl->obj,hl->init.std);
return 0;
}
int demod_hard_work(demod_hard_hl* hl) {
int ret = demod_hard_demodulate(&hl->obj,hl->input,hl->output,hl->in_len);
int srslte_demod_hard_work(srslte_demod_hard_hl* hl) {
int ret = srslte_demod_hard_demodulate(&hl->obj,hl->input,hl->output,hl->in_len);
hl->out_len = ret;
return 0;
}
int demod_hard_stop(demod_hard_hl* hl) {
int srslte_demod_hard_stop(srslte_demod_hard_hl* hl) {
return 0;
}

42
srslte/lib/modem/src/demod_soft.c
Unescape Escape View File

@ -35,17 +35,17 @@
#include "soft_algs.h"
int demod_soft_init(demod_soft_t *q, uint32_t max_symbols) {
int srslte_demod_soft_init(srslte_demod_soft_t *q, uint32_t max_symbols) {
int ret = SRSLTE_ERROR;
bzero((void*)q,sizeof(demod_soft_t));
bzero((void*)q,sizeof(srslte_demod_soft_t));
q->sigma = 1.0;
q->zones = vec_malloc(sizeof(uint32_t) * max_symbols);
q->zones = srslte_vec_malloc(sizeof(uint32_t) * max_symbols);
if (!q->zones) {
perror("malloc");
goto clean_exit;
}
q->dd = vec_malloc(sizeof(float*) * max_symbols * 7);
q->dd = srslte_vec_malloc(sizeof(float*) * max_symbols * 7);
if (!q->dd) {
perror("malloc");
goto clean_exit;
@ -56,40 +56,40 @@ int demod_soft_init(demod_soft_t *q, uint32_t max_symbols) {
clean_exit:
if (ret != SRSLTE_SUCCESS) {
demod_soft_free(q);
srslte_demod_soft_free(q);
}
return ret;
}
void demod_soft_free(demod_soft_t *q) {
void srslte_demod_soft_free(srslte_demod_soft_t *q) {
if (q->zones) {
free(q->zones);
}
if (q->dd) {
free(q->dd);
}
bzero((void*)q,sizeof(demod_soft_t));
bzero((void*)q,sizeof(srslte_demod_soft_t));
}
void demod_soft_table_set(demod_soft_t *q, modem_table_t *table) {
void srslte_demod_soft_table_set(srslte_demod_soft_t *q, srslte_srslte_modem_table_t *table) {
q->table = table;
}
void demod_soft_alg_set(demod_soft_t *q, enum alg alg_type) {
void srslte_demod_soft_alg_set(srslte_demod_soft_t *q, srslte_demod_soft_alg_t alg_type) {
q->alg_type = alg_type;
}
void demod_soft_sigma_set(demod_soft_t *q, float sigma) {
void srslte_demod_soft_sigma_set(srslte_demod_soft_t *q, float sigma) {
q->sigma = 2*sigma;
}
int demod_soft_demodulate(demod_soft_t *q, const cf_t* symbols, float* llr, int nsymbols) {
int srslte_demod_soft_demodulate(srslte_demod_soft_t *q, const cf_t* symbols, float* llr, int nsymbols) {
switch(q->alg_type) {
case EXACT:
case SRSLTE_DEMOD_SOFT_ALG_EXACT:
llr_exact(symbols, llr, nsymbols, q->table->nsymbols, q->table->nbits_x_symbol,
q->table->symbol_table, q->table->soft_table.idx, q->sigma);
break;
case APPROX:
case SRSLTE_DEMOD_SOFT_ALG_APPROX:
if (nsymbols <= q->max_symbols) {
llr_approx(symbols, llr, nsymbols, q->table->nsymbols,
q->table->nbits_x_symbol,
@ -109,26 +109,26 @@ int demod_soft_demodulate(demod_soft_t *q, const cf_t* symbols, float* llr, int
/* High-Level API */
int demod_soft_initialize(demod_soft_hl* hl) {
modem_table_init(&hl->table);
if (modem_table_lte(&hl->table,hl->init.std,true)) {
int srslte_demod_soft_initialize(srslte_demod_soft_hl* hl) {
srslte_modem_table_init(&hl->table);
if (srslte_modem_table_lte(&hl->table,hl->init.std,true)) {
return -1;
}
demod_soft_init(&hl->obj, 10000);
srslte_demod_soft_init(&hl->obj, 10000);
hl->obj.table = &hl->table;
return 0;
}
int demod_soft_work(demod_soft_hl* hl) {
int srslte_demod_soft_work(srslte_demod_soft_hl* hl) {
hl->obj.sigma = hl->ctrl_in.sigma;
hl->obj.alg_type = hl->ctrl_in.alg_type;
int ret = demod_soft_demodulate(&hl->obj,hl->input,hl->output,hl->in_len);
int ret = srslte_demod_soft_demodulate(&hl->obj,hl->input,hl->output,hl->in_len);
hl->out_len = ret;
return 0;
}
int demod_soft_stop(demod_soft_hl* hl) {
modem_table_free(&hl->table);
int srslte_demod_soft_stop(srslte_demod_soft_hl* hl) {
srslte_modem_table_free(&hl->table);
return 0;
}

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save