PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chaned srslte_crc prefix in variable names

This commit is contained in:
ismagom 2015-04-08 16:22:09 +01:00
parent fe2fe70d48
commit 5a3c2b1a04
20 changed files with 220 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -84,7 +84,7 @@ IF(CMAKE_COMPILER_IS_GNUCXX)
ENDIF(CMAKE_COMPILER_IS_GNUCXX) ENDIF(CMAKE_COMPILER_IS_GNUCXX)
IF(CMAKE_COMPILER_IS_GNUCC) IF(CMAKE_COMPILER_IS_GNUCC)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-format-extra-args -Winline -Wno-unused-result -Wno-format -std=c99 -D_GNU_SOURCE -g") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-write-strings -Wno-format-extra-args -Winline -Wno-unused-result -Wno-format -std=c99 -D_GNU_SOURCE -g")
# IF(${CMAKE_BUILD_TYPE} STREQUAL "Debug") # IF(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Wno-error=implicit-function-declaration -Wno-error=unused-but-set-variable") # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Wno-error=implicit-function-declaration -Wno-error=unused-but-set-variable")
# ENDIF(${CMAKE_BUILD_TYPE} STREQUAL "Debug") # ENDIF(${CMAKE_BUILD_TYPE} STREQUAL "Debug")

2
srslte/examples/pdsch_ue.c
View File

@ -102,7 +102,7 @@ void args_default(prog_args_t *args) {
args->file_cell_id = 0; args->file_cell_id = 0;
args->uhd_args = ""; args->uhd_args = "";
args->uhd_freq = -1.0; args->uhd_freq = -1.0;
args->uhd_freq = 8000000.0; args->uhd_freq_offset = 8000000.0;
args->uhd_gain = 60.0; args->uhd_gain = 60.0;
args->net_port = -1; args->net_port = -1;
args->net_address = "127.0.0.1"; args->net_address = "127.0.0.1";

4
srslte/include/srslte/phch/dci.h
View File

@ -131,12 +131,12 @@ SRSLTE_API int srslte_dci_msg_pack_pdsch(srslte_ra_pdsch_t *data,
srslte_dci_msg_t *msg, srslte_dci_msg_t *msg,
srslte_dci_format_t format, srslte_dci_format_t format,
uint32_t nof_prb, uint32_t nof_prb,
bool srslte_crc_is_crnti); bool crc_is_crnti);
SRSLTE_API int srslte_dci_msg_unpack_pdsch(srslte_dci_msg_t *msg, SRSLTE_API int srslte_dci_msg_unpack_pdsch(srslte_dci_msg_t *msg,
srslte_ra_pdsch_t *data, srslte_ra_pdsch_t *data,
uint32_t nof_prb, uint32_t nof_prb,
bool srslte_crc_is_crnti); bool crc_is_crnti);
SRSLTE_API uint32_t srslte_dci_format_sizeof(srslte_dci_format_t format, SRSLTE_API uint32_t srslte_dci_format_sizeof(srslte_dci_format_t format,
uint32_t nof_prb); uint32_t nof_prb);

2
srslte/include/srslte/phch/pdcch.h
View File

@ -115,7 +115,7 @@ SRSLTE_API int srslte_pdcch_decode_msg(srslte_pdcch_t *q,
srslte_dci_msg_t *msg, srslte_dci_msg_t *msg,
srslte_dci_location_t *location, srslte_dci_location_t *location,
srslte_dci_format_t format, srslte_dci_format_t format,
uint16_t *srslte_crc_rem); uint16_t *crc_rem);
/* Function for generation of UE-specific search space DCI locations */ /* Function for generation of UE-specific search space DCI locations */
SRSLTE_API uint32_t srslte_pdcch_ue_locations(srslte_pdcch_t *q, SRSLTE_API uint32_t srslte_pdcch_ue_locations(srslte_pdcch_t *q,

4
srslte/include/srslte/phch/sch.h
View File

@ -69,8 +69,8 @@ typedef struct SRSLTE_API {
srslte_tcod_t encoder; srslte_tcod_t encoder;
srslte_tdec_t decoder; srslte_tdec_t decoder;
srslte_crc_t srslte_crc_tb; srslte_crc_t crc_tb;
srslte_crc_t srslte_crc_cb; srslte_crc_t crc_cb;
srslte_uci_cqi_pusch_t uci_cqi; srslte_uci_cqi_pusch_t uci_cqi;

22
srslte/lib/fec/src/crc.c
View File

@ -32,7 +32,7 @@
#include "srslte/utils/bit.h" #include "srslte/utils/bit.h"
#include "srslte/fec/crc.h" #include "srslte/fec/crc.h"
void gen_srslte_crc_table(srslte_crc_t *h) { void gen_crc_table(srslte_crc_t *h) {
int i, j, ord = (h->order - 8); int i, j, ord = (h->order - 8);
unsigned long bit, crc; unsigned long bit, crc;
@ -74,21 +74,21 @@ unsigned long reversecrcbit(uint32_t crc, int nbits, srslte_crc_t *h) {
return (crc & h->crcmask); return (crc & h->crcmask);
} }
int srslte_crc_set_init(srslte_crc_t *srslte_crc_par, unsigned long srslte_crc_init_value) { int srslte_crc_set_init(srslte_crc_t *crc_par, unsigned long crc_init_value) {
srslte_crc_par->crcinit = srslte_crc_init_value; crc_par->crcinit = crc_init_value;
if (srslte_crc_par->crcinit != (srslte_crc_par->crcinit & srslte_crc_par->crcmask)) { if (crc_par->crcinit != (crc_par->crcinit & crc_par->crcmask)) {
printf("ERROR, invalid crcinit in srslte_crc_set_init().\n"); printf("ERROR, invalid crcinit in crc_set_init().\n");
return -1; return -1;
} }
return 0; return 0;
} }
int srslte_crc_init(srslte_crc_t *h, uint32_t srslte_crc_poly, int srslte_crc_order) { int srslte_crc_init(srslte_crc_t *h, uint32_t crc_poly, int crc_order) {
// Set crc working default parameters // Set crc working default parameters
h->polynom = srslte_crc_poly; h->polynom = crc_poly;
h->order = srslte_crc_order; h->order = crc_order;
h->crcinit = 0x00000000; h->crcinit = 0x00000000;
// Compute bit masks for whole CRC and CRC high bit // Compute bit masks for whole CRC and CRC high bit
@ -109,7 +109,7 @@ int srslte_crc_init(srslte_crc_t *h, uint32_t srslte_crc_poly, int srslte_crc_or
} }
// generate lookup table // generate lookup table
gen_srslte_crc_table(h); gen_crc_table(h);
return 0; return 0;
} }
@ -152,8 +152,8 @@ uint32_t srslte_crc_checksum(srslte_crc_t *h, uint8_t *data, int len) {
} }
/** Appends srslte_crc_order checksum bits to the buffer data. /** Appends crc_order checksum bits to the buffer data.
* The buffer data must be len + srslte_crc_order bytes * The buffer data must be len + crc_order bytes
*/ */
void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) { void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
uint32_t checksum = srslte_crc_checksum(h, data, len); uint32_t checksum = srslte_crc_checksum(h, data, len);

26
srslte/lib/fec/test/crc_test.c
View File

@ -36,15 +36,15 @@
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include "crc_test.h" #include "crc_test.h"
int num_bits = 5001, srslte_crc_length = 24; int num_bits = 5001, crc_length = 24;
uint32_t srslte_crc_poly = 0x1864CFB; uint32_t crc_poly = 0x1864CFB;
uint32_t seed = 1; uint32_t seed = 1;
void usage(char *prog) { void usage(char *prog) {
printf("Usage: %s [nlps]\n", prog); printf("Usage: %s [nlps]\n", prog);
printf("\t-n num_bits [Default %d]\n", num_bits); printf("\t-n num_bits [Default %d]\n", num_bits);
printf("\t-l srslte_crc_length [Default %d]\n", srslte_crc_length); printf("\t-l crc_length [Default %d]\n", crc_length);
printf("\t-p srslte_crc_poly (Hex) [Default 0x%x]\n", srslte_crc_poly); printf("\t-p crc_poly (Hex) [Default 0x%x]\n", crc_poly);
printf("\t-s seed [Default 0=time]\n"); printf("\t-s seed [Default 0=time]\n");
} }
@ -56,10 +56,10 @@ void parse_args(int argc, char **argv) {
num_bits = atoi(argv[optind]); num_bits = atoi(argv[optind]);
break; break;
case 'l': case 'l':
srslte_crc_length = atoi(argv[optind]); crc_length = atoi(argv[optind]);
break; break;
case 'p': case 'p':
srslte_crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16); crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16);
break; break;
case 's': case 's':
seed = (uint32_t) strtoul(argv[optind], NULL, 0); seed = (uint32_t) strtoul(argv[optind], NULL, 0);
@ -74,12 +74,12 @@ void parse_args(int argc, char **argv) {
int main(int argc, char **argv) { int main(int argc, char **argv) {
int i; int i;
uint8_t *data; uint8_t *data;
uint32_t srslte_crc_word, expected_word; uint32_t crc_word, expected_word;
srslte_crc_t srslte_crc_p; srslte_crc_t crc_p;
parse_args(argc, argv); parse_args(argc, argv);
data = malloc(sizeof(uint8_t) * (num_bits + srslte_crc_length * 2)); data = malloc(sizeof(uint8_t) * (num_bits + crc_length * 2));
if (!data) { if (!data) {
perror("malloc"); perror("malloc");
exit(-1); exit(-1);
@ -96,20 +96,20 @@ int main(int argc, char **argv) {
} }
//Initialize CRC params and tables //Initialize CRC params and tables
if (srslte_crc_init(&srslte_crc_p, srslte_crc_poly, srslte_crc_length)) { if (srslte_crc_init(&crc_p, crc_poly, crc_length)) {
exit(-1); exit(-1);
} }
// generate CRC word // generate CRC word
srslte_crc_word = srslte_crc_checksum(&srslte_crc_p, data, num_bits); crc_word = srslte_crc_checksum(&crc_p, data, num_bits);
free(data); free(data);
// check if generated word is as expected // check if generated word is as expected
if (get_expected_word(num_bits, srslte_crc_length, srslte_crc_poly, seed, if (get_expected_word(num_bits, crc_length, crc_poly, seed,
&expected_word)) { &expected_word)) {
fprintf(stderr, "Test parameters not defined in test_results.h\n"); fprintf(stderr, "Test parameters not defined in test_results.h\n");
exit(-1); exit(-1);
} }
exit(expected_word != srslte_crc_word); exit(expected_word != crc_word);
} }

34
srslte/lib/phch/src/dci.c
View File

@ -70,11 +70,11 @@ int srslte_dci_msg_to_ra_dl(srslte_dci_msg_t *msg, uint16_t msg_rnti,
if (type.type == SRSLTE_DCI_MSG_TYPE_PDSCH_SCHED) { if (type.type == SRSLTE_DCI_MSG_TYPE_PDSCH_SCHED) {
bzero(ra_dl, sizeof(srslte_ra_pdsch_t)); bzero(ra_dl, sizeof(srslte_ra_pdsch_t));
bool srslte_crc_is_crnti = false; bool crc_is_crnti = false;
if (msg_rnti >= SRSLTE_CRNTI_START && msg_rnti <= SRSLTE_CRNTI_END) { if (msg_rnti >= SRSLTE_CRNTI_START && msg_rnti <= SRSLTE_CRNTI_END) {
srslte_crc_is_crnti = true; crc_is_crnti = true;
} }
if (srslte_dci_msg_unpack_pdsch(msg, ra_dl, cell.nof_prb, srslte_crc_is_crnti)) { if (srslte_dci_msg_unpack_pdsch(msg, ra_dl, cell.nof_prb, crc_is_crnti)) {
fprintf(stderr, "Can't unpack PDSCH message\n"); fprintf(stderr, "Can't unpack PDSCH message\n");
return ret; return ret;
} }
@ -516,7 +516,7 @@ int dci_format1_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_t
* TODO: RA procedure initiated by PDCCH, TPC commands * TODO: RA procedure initiated by PDCCH, TPC commands
*/ */
int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t nof_prb, int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t nof_prb,
bool srslte_crc_is_crnti) { bool crc_is_crnti) {
/* pack bits */ /* pack bits */
uint8_t *y = msg->data; uint8_t *y = msg->data;
@ -538,7 +538,7 @@ int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t
} }
} else { } else {
uint32_t n_vrb_dl; uint32_t n_vrb_dl;
if (srslte_crc_is_crnti && nof_prb > 50) { if (crc_is_crnti && nof_prb > 50) {
n_vrb_dl = 16; n_vrb_dl = 16;
} else { } else {
n_vrb_dl = srslte_ra_type2_n_vrb_dl(nof_prb, data->type2_alloc.n_gap == SRSLTE_RA_TYPE2_NG1); n_vrb_dl = srslte_ra_type2_n_vrb_dl(nof_prb, data->type2_alloc.n_gap == SRSLTE_RA_TYPE2_NG1);
@ -559,7 +559,7 @@ int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t
riv = data->type2_alloc.riv; riv = data->type2_alloc.riv;
} }
uint32_t nb_gap = 0; uint32_t nb_gap = 0;
if (srslte_crc_is_crnti && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST && nof_prb >= 50) { if (crc_is_crnti && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST && nof_prb >= 50) {
nb_gap = 1; nb_gap = 1;
*y++ = data->type2_alloc.n_gap; *y++ = data->type2_alloc.n_gap;
} }
@ -570,7 +570,7 @@ int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t
srslte_bit_pack(data->harq_process, &y, 3); srslte_bit_pack(data->harq_process, &y, 3);
if (!srslte_crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST) { if (!crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST) {
*y++ = data->type2_alloc.n_gap; *y++ = data->type2_alloc.n_gap;
} else { } else {
y++; // bit reserved y++; // bit reserved
@ -579,7 +579,7 @@ int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t
// rv version // rv version
srslte_bit_pack(data->rv_idx, &y, 2); srslte_bit_pack(data->rv_idx, &y, 2);
if (srslte_crc_is_crnti) { if (crc_is_crnti) {
// TPC not implemented // TPC not implemented
*y++ = 0; *y++ = 0;
*y++ = 0; *y++ = 0;
@ -602,7 +602,7 @@ int dci_format1As_pack(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, uint32_t
* *
*/ */
int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_t nof_prb, int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_t nof_prb,
bool srslte_crc_is_crnti) { bool crc_is_crnti) {
/* pack bits */ /* pack bits */
uint8_t *y = msg->data; uint8_t *y = msg->data;
@ -626,7 +626,7 @@ int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_
/* unpack RIV according to 7.1.6.3 of 36.213 */ /* unpack RIV according to 7.1.6.3 of 36.213 */
uint32_t nb_gap = 0; uint32_t nb_gap = 0;
if (srslte_crc_is_crnti && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST && nof_prb >= 50) { if (crc_is_crnti && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST && nof_prb >= 50) {
nb_gap = 1; nb_gap = 1;
data->type2_alloc.n_gap = *y++; data->type2_alloc.n_gap = *y++;
} }
@ -646,7 +646,7 @@ int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_
data->harq_process = srslte_bit_unpack(&y, 3); data->harq_process = srslte_bit_unpack(&y, 3);
if (!srslte_crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST) { if (!crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == SRSLTE_RA_TYPE2_DIST) {
data->type2_alloc.n_gap = *y++; data->type2_alloc.n_gap = *y++;
} else { } else {
y++; // bit reserved y++; // bit reserved
@ -655,7 +655,7 @@ int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_
// rv version // rv version
srslte_bit_pack(data->rv_idx, &y, 2); srslte_bit_pack(data->rv_idx, &y, 2);
if (srslte_crc_is_crnti) { if (crc_is_crnti) {
// TPC not implemented // TPC not implemented
y++; y++;
y++; y++;
@ -665,7 +665,7 @@ int dci_format1As_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_
} }
uint32_t n_prb; uint32_t n_prb;
if (srslte_crc_is_crnti) { if (crc_is_crnti) {
n_prb = srslte_ra_nprb_dl(data, nof_prb); n_prb = srslte_ra_nprb_dl(data, nof_prb);
} else { } else {
n_prb = data->type2_alloc.n_prb1a == SRSLTE_RA_TYPE2_NPRB1A_2 ? 2 : 3; n_prb = data->type2_alloc.n_prb1a == SRSLTE_RA_TYPE2_NPRB1A_2 ? 2 : 3;
@ -765,12 +765,12 @@ int dci_format1Cs_unpack(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_
} }
int srslte_dci_msg_pack_pdsch(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, srslte_dci_format_t format, 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) { uint32_t nof_prb, bool crc_is_crnti) {
switch (format) { switch (format) {
case SRSLTE_DCI_FORMAT1: case SRSLTE_DCI_FORMAT1:
return dci_format1_pack(data, msg, nof_prb); return dci_format1_pack(data, msg, nof_prb);
case SRSLTE_DCI_FORMAT1A: case SRSLTE_DCI_FORMAT1A:
return dci_format1As_pack(data, msg, nof_prb, srslte_crc_is_crnti); return dci_format1As_pack(data, msg, nof_prb, crc_is_crnti);
case SRSLTE_DCI_FORMAT1C: case SRSLTE_DCI_FORMAT1C:
return dci_format1Cs_pack(data, msg, nof_prb); return dci_format1Cs_pack(data, msg, nof_prb);
default: default:
@ -781,11 +781,11 @@ int srslte_dci_msg_pack_pdsch(srslte_ra_pdsch_t *data, srslte_dci_msg_t *msg, sr
} }
int srslte_dci_msg_unpack_pdsch(srslte_dci_msg_t *msg, srslte_ra_pdsch_t *data, uint32_t nof_prb, 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) { bool crc_is_crnti) {
if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1, nof_prb)) { if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1, nof_prb)) {
return dci_format1_unpack(msg, data, nof_prb); return dci_format1_unpack(msg, data, nof_prb);
} else if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1A, nof_prb)) { } else if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1A, nof_prb)) {
return dci_format1As_unpack(msg, data, nof_prb, srslte_crc_is_crnti); return dci_format1As_unpack(msg, data, nof_prb, crc_is_crnti);
} else if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1C, nof_prb)) { } else if (msg->nof_bits == srslte_dci_format_sizeof(SRSLTE_DCI_FORMAT1C, nof_prb)) {
return dci_format1Cs_unpack(msg, data, nof_prb); return dci_format1Cs_unpack(msg, data, nof_prb);
} else { } else {

10
srslte/lib/phch/src/pbch.c
View File

@ -44,7 +44,7 @@
#define PBCH_RE_CP_NORM 240 #define PBCH_RE_CP_NORM 240
#define PBCH_RE_CP_EXT 216 #define PBCH_RE_CP_EXT 216
const uint8_t srslte_crc_mask[4][16] = { const uint8_t crc_mask[4][16] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
@ -359,10 +359,10 @@ void srslte_pbch_decode_reset(srslte_pbch_t *q) {
q->frame_idx = 0; q->frame_idx = 0;
} }
void srslte_crc_set_mask(uint8_t *data, int nof_ports) { void crc_set_mask(uint8_t *data, int nof_ports) {
int i; int i;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
data[SRSLTE_BCH_PAYLOAD_LEN + i] = (data[SRSLTE_BCH_PAYLOAD_LEN + i] + srslte_crc_mask[nof_ports - 1][i]) % 2; data[SRSLTE_BCH_PAYLOAD_LEN + i] = (data[SRSLTE_BCH_PAYLOAD_LEN + i] + crc_mask[nof_ports - 1][i]) % 2;
} }
} }
@ -376,7 +376,7 @@ void srslte_crc_set_mask(uint8_t *data, int nof_ports) {
uint32_t srslte_pbch_crc_check(srslte_pbch_t *q, uint8_t *bits, uint32_t nof_ports) { uint32_t srslte_pbch_crc_check(srslte_pbch_t *q, uint8_t *bits, uint32_t nof_ports) {
uint8_t data[SRSLTE_BCH_PAYLOADCRC_LEN]; uint8_t data[SRSLTE_BCH_PAYLOADCRC_LEN];
memcpy(data, bits, SRSLTE_BCH_PAYLOADCRC_LEN * sizeof(uint8_t)); memcpy(data, bits, SRSLTE_BCH_PAYLOADCRC_LEN * sizeof(uint8_t));
srslte_crc_set_mask(data, nof_ports); crc_set_mask(data, nof_ports);
int ret = srslte_crc_checksum(&q->crc, data, SRSLTE_BCH_PAYLOADCRC_LEN); int ret = srslte_crc_checksum(&q->crc, data, SRSLTE_BCH_PAYLOADCRC_LEN);
if (ret == 0) { if (ret == 0) {
uint32_t chkzeros=0; uint32_t chkzeros=0;
@ -567,7 +567,7 @@ int srslte_pbch_encode(srslte_pbch_t *q, uint8_t bch_payload[SRSLTE_BCH_PAYLOAD_
/* encode & modulate */ /* encode & modulate */
srslte_crc_attach(&q->crc, q->data, SRSLTE_BCH_PAYLOAD_LEN); srslte_crc_attach(&q->crc, q->data, SRSLTE_BCH_PAYLOAD_LEN);
srslte_crc_set_mask(q->data, q->cell.nof_ports); crc_set_mask(q->data, q->cell.nof_ports);
srslte_convcoder_encode(&q->encoder, q->data, q->data_enc, SRSLTE_BCH_PAYLOADCRC_LEN); srslte_convcoder_encode(&q->encoder, q->data, q->data_enc, SRSLTE_BCH_PAYLOADCRC_LEN);

22
srslte/lib/phch/src/pdcch.c
View File

@ -275,7 +275,7 @@ uint32_t srslte_pdcch_common_locations(srslte_pdcch_t *q, srslte_dci_location_t
*/ */
static int dci_decode(srslte_pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t nof_bits, uint16_t *crc) { static int dci_decode(srslte_pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t nof_bits, uint16_t *crc) {
uint16_t p_bits, srslte_crc_res; uint16_t p_bits, crc_res;
uint8_t *x; uint8_t *x;
if (q != NULL && if (q != NULL &&
@ -306,12 +306,12 @@ static int dci_decode(srslte_pdcch_t *q, float *e, uint8_t *data, uint32_t E, ui
x = &data[nof_bits]; x = &data[nof_bits];
p_bits = (uint16_t) srslte_bit_unpack(&x, 16); p_bits = (uint16_t) srslte_bit_unpack(&x, 16);
srslte_crc_res = ((uint16_t) srslte_crc_checksum(&q->crc, data, nof_bits) & 0xffff); crc_res = ((uint16_t) srslte_crc_checksum(&q->crc, data, nof_bits) & 0xffff);
INFO("p_bits: 0x%x, srslte_crc_checksum: 0x%x, srslte_crc_rem: 0x%x\n", p_bits, srslte_crc_res, INFO("p_bits: 0x%x, crc_checksum: 0x%x, crc_rem: 0x%x\n", p_bits, crc_res,
p_bits ^ srslte_crc_res); p_bits ^ crc_res);
if (crc) { if (crc) {
*crc = p_bits ^ srslte_crc_res; *crc = p_bits ^ crc_res;
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} else { } else {
@ -322,16 +322,16 @@ static int dci_decode(srslte_pdcch_t *q, float *e, uint8_t *data, uint32_t E, ui
/** Tries to decode a DCI message from the LLRs stored in the srslte_pdcch_t structure by the function /** Tries to decode a DCI message from the LLRs stored in the srslte_pdcch_t structure by the function
* srslte_pdcch_extract_llr(). This function can be called multiple times. * srslte_pdcch_extract_llr(). This function can be called multiple times.
* The decoded message is stored in msg and the CRC remainder in srslte_crc_rem pointer * The decoded message is stored in msg and the CRC remainder in crc_rem pointer
* *
*/ */
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) 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 *crc_rem)
{ {
int ret = SRSLTE_ERROR_INVALID_INPUTS; int ret = SRSLTE_ERROR_INVALID_INPUTS;
if (q != NULL && if (q != NULL &&
msg != NULL && msg != NULL &&
srslte_dci_location_isvalid(location) && srslte_dci_location_isvalid(location) &&
srslte_crc_rem != NULL) crc_rem != NULL)
{ {
if (location->ncce * 72 + PDCCH_FORMAT_NOF_BITS(location->L) > if (location->ncce * 72 + PDCCH_FORMAT_NOF_BITS(location->L) >
q->nof_cce*72) { q->nof_cce*72) {
@ -345,7 +345,7 @@ int srslte_pdcch_decode_msg(srslte_pdcch_t *q, srslte_dci_msg_t *msg, srslte_dci
location->ncce * 72, e_bits, nof_bits, location->ncce, location->L); location->ncce * 72, e_bits, nof_bits, location->ncce, location->L);
ret = dci_decode(q, &q->llr[location->ncce * 72], ret = dci_decode(q, &q->llr[location->ncce * 72],
msg->data, e_bits, nof_bits, srslte_crc_rem); msg->data, e_bits, nof_bits, crc_rem);
if (ret == SRSLTE_SUCCESS) { if (ret == SRSLTE_SUCCESS) {
msg->nof_bits = nof_bits; msg->nof_bits = nof_bits;
} }
@ -437,7 +437,7 @@ int srslte_pdcch_extract_llr(srslte_pdcch_t *q, cf_t *sf_symbols, cf_t *ce[SRSLT
static void srslte_crc_set_mask_rnti(uint8_t *crc, uint16_t rnti) { static void crc_set_mask_rnti(uint8_t *crc, uint16_t rnti) {
uint32_t i; uint32_t i;
uint8_t mask[16]; uint8_t mask[16];
uint8_t *r = mask; uint8_t *r = mask;
@ -472,7 +472,7 @@ static int dci_encode(srslte_pdcch_t *q, uint8_t *data, uint8_t *e, uint32_t nof
memcpy(encoder.poly, poly, 3 * sizeof(int)); memcpy(encoder.poly, poly, 3 * sizeof(int));
srslte_crc_attach(&q->crc, data, nof_bits); srslte_crc_attach(&q->crc, data, nof_bits);
srslte_crc_set_mask_rnti(&data[nof_bits], rnti); crc_set_mask_rnti(&data[nof_bits], rnti);
srslte_convcoder_encode(&encoder, data, tmp, nof_bits + 16); srslte_convcoder_encode(&encoder, data, tmp, nof_bits + 16);

3
srslte/lib/phch/src/pdsch.c
View File

@ -302,9 +302,8 @@ void srslte_pdsch_free(srslte_pdsch_t *q) {
} }
/* Precalculate the PUSCH scramble sequences for a given RNTI. This function takes a while /* Precalculate the PDSCH scramble sequences for a given RNTI. This function takes a while
* to execute, so shall be called once the final C-RNTI has been allocated for the session. * to execute, so shall be called once the final C-RNTI has been allocated for the session.
* For the connection procedure, use srslte_pusch_encode_rnti() or srslte_pusch_decode_rnti() functions
*/ */
int srslte_pdsch_set_rnti(srslte_pdsch_t *q, uint16_t rnti) { int srslte_pdsch_set_rnti(srslte_pdsch_t *q, uint16_t rnti) {
uint32_t i; uint32_t i;

18
srslte/lib/phch/src/sch.c
View File

@ -60,11 +60,11 @@ int srslte_sch_init(srslte_sch_t *q) {
if (q) { if (q) {
bzero(q, sizeof(srslte_sch_t)); bzero(q, sizeof(srslte_sch_t));
if (srslte_crc_init(&q->srslte_crc_tb, SRSLTE_LTE_CRC24A, 24)) { if (srslte_crc_init(&q->crc_tb, SRSLTE_LTE_CRC24A, 24)) {
fprintf(stderr, "Error initiating CRC\n"); fprintf(stderr, "Error initiating CRC\n");
goto clean; goto clean;
} }
if (srslte_crc_init(&q->srslte_crc_cb, SRSLTE_LTE_CRC24B, 24)) { if (srslte_crc_init(&q->crc_cb, SRSLTE_LTE_CRC24B, 24)) {
fprintf(stderr, "Error initiating CRC\n"); fprintf(stderr, "Error initiating CRC\n");
goto clean; goto clean;
} }
@ -152,7 +152,7 @@ static int encode_tb(srslte_sch_t *q, srslte_harq_t *harq, uint8_t *data, uint8_
if (harq->rv == 0) { if (harq->rv == 0) {
/* Compute transport block CRC */ /* Compute transport block CRC */
par = srslte_crc_checksum(&q->srslte_crc_tb, data, harq->mcs.tbs); par = srslte_crc_checksum(&q->crc_tb, data, harq->mcs.tbs);
/* parity bits will be appended later */ /* parity bits will be appended later */
srslte_bit_pack(par, &p_parity, 24); srslte_bit_pack(par, &p_parity, 24);
@ -213,7 +213,7 @@ static int encode_tb(srslte_sch_t *q, srslte_harq_t *harq, uint8_t *data, uint8_
} }
/* Attach Codeblock CRC */ /* Attach Codeblock CRC */
if (harq->cb_segm.C > 1) { if (harq->cb_segm.C > 1) {
srslte_crc_attach(&q->srslte_crc_cb, q->cb_in, rlen); srslte_crc_attach(&q->crc_cb, q->cb_in, rlen);
} }
/* Set the filler bits to <NULL> */ /* Set the filler bits to <NULL> */
for (int j = 0; j < F; j++) { for (int j = 0; j < F; j++) {
@ -325,7 +325,7 @@ static int decode_tb(srslte_sch_t *q, srslte_harq_t *harq, float *e_bits, uint8_
q->nof_iterations = 0; q->nof_iterations = 0;
uint32_t len_crc; uint32_t len_crc;
uint8_t *cb_in_ptr; uint8_t *cb_in_ptr;
srslte_crc_t *srslte_crc_ptr; srslte_crc_t *crc_ptr;
early_stop = false; early_stop = false;
srslte_tdec_reset(&q->decoder, cb_len); srslte_tdec_reset(&q->decoder, cb_len);
@ -337,17 +337,17 @@ static int decode_tb(srslte_sch_t *q, srslte_harq_t *harq, float *e_bits, uint8_
if (harq->cb_segm.C > 1) { if (harq->cb_segm.C > 1) {
len_crc = cb_len; len_crc = cb_len;
cb_in_ptr = q->cb_in; cb_in_ptr = q->cb_in;
srslte_crc_ptr = &q->srslte_crc_cb; crc_ptr = &q->crc_cb;
} else { } else {
len_crc = harq->mcs.tbs+24; len_crc = harq->mcs.tbs+24;
cb_in_ptr = &q->cb_in[F]; cb_in_ptr = &q->cb_in[F];
srslte_crc_ptr = &q->srslte_crc_tb; crc_ptr = &q->crc_tb;
} }
srslte_tdec_decision(&q->decoder, q->cb_in, cb_len); srslte_tdec_decision(&q->decoder, q->cb_in, cb_len);
/* Check Codeblock CRC and stop early if incorrect */ /* Check Codeblock CRC and stop early if incorrect */
if (!srslte_crc_checksum(srslte_crc_ptr, cb_in_ptr, len_crc)) { if (!srslte_crc_checksum(crc_ptr, cb_in_ptr, len_crc)) {
early_stop = true; early_stop = true;
} }
@ -385,7 +385,7 @@ static int decode_tb(srslte_sch_t *q, srslte_harq_t *harq, float *e_bits, uint8_
INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp); INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp);
// Compute transport block CRC // Compute transport block CRC
par_rx = srslte_crc_checksum(&q->srslte_crc_tb, data, harq->mcs.tbs); par_rx = srslte_crc_checksum(&q->crc_tb, data, harq->mcs.tbs);
// check parity bits // check parity bits
par_tx = srslte_bit_unpack(&p_parity, 24); par_tx = srslte_bit_unpack(&p_parity, 24);

8
srslte/lib/phch/test/pdcch_file_test.c
View File

@ -232,7 +232,7 @@ int main(int argc, char **argv) {
/* Get channel estimates for each port */ /* Get channel estimates for each port */
srslte_chest_dl_estimate(&chest, fft_buffer, ce, frame_cnt %10); srslte_chest_dl_estimate(&chest, fft_buffer, ce, frame_cnt %10);
uint16_t srslte_crc_rem = 0; uint16_t crc_rem = 0;
if (srslte_pdcch_extract_llr(&pdcch, fft_buffer, if (srslte_pdcch_extract_llr(&pdcch, fft_buffer,
ce, srslte_chest_dl_get_noise_estimate(&chest), ce, srslte_chest_dl_get_noise_estimate(&chest),
frame_cnt %10, cfi)) { frame_cnt %10, cfi)) {
@ -247,14 +247,14 @@ int main(int argc, char **argv) {
nof_locations = srslte_pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, frame_cnt %10, cfi, rnti); nof_locations = srslte_pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, frame_cnt %10, cfi, rnti);
} }
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) { for (i=0;i<nof_locations && crc_rem != rnti;i++) {
if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) { if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return -1; return -1;
} }
} }
if (srslte_crc_rem == rnti) { if (crc_rem == rnti) {
srslte_dci_msg_type_t type; srslte_dci_msg_type_t type;
if (srslte_dci_msg_get_type(&dci_msg, &type, cell.nof_prb, rnti)) { if (srslte_dci_msg_get_type(&dci_msg, &type, cell.nof_prb, rnti)) {
fprintf(stderr, "Can't get DCI message type\n"); fprintf(stderr, "Can't get DCI message type\n");

12
srslte/lib/phch/test/pdcch_test.c
View File

@ -195,16 +195,16 @@ int main(int argc, char **argv) {
fprintf(stderr, "Error extracting LLRs\n"); fprintf(stderr, "Error extracting LLRs\n");
goto quit; goto quit;
} }
uint16_t srslte_crc_rem; uint16_t crc_rem;
if (srslte_pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], SRSLTE_DCI_FORMAT1, &srslte_crc_rem)) { if (srslte_pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], SRSLTE_DCI_FORMAT1, &crc_rem)) {
fprintf(stderr, "Error decoding DCI message\n"); fprintf(stderr, "Error decoding DCI message\n");
goto quit; goto quit;
} }
if (srslte_crc_rem >= 1234 && srslte_crc_rem < 1234 + nof_dcis) { if (crc_rem >= 1234 && crc_rem < 1234 + nof_dcis) {
srslte_crc_rem -= 1234; crc_rem -= 1234;
memcpy(&dci_rx[srslte_crc_rem], &dci_tmp, sizeof(srslte_dci_msg_t)); memcpy(&dci_rx[crc_rem], &dci_tmp, sizeof(srslte_dci_msg_t));
} else { } else {
printf("Received invalid DCI CRC 0x%x\n", srslte_crc_rem); printf("Received invalid DCI CRC 0x%x\n", crc_rem);
goto quit; goto quit;
} }
} }

8
srslte/lib/phch/test/pdcch_test_mex.c
View File

@ -162,13 +162,13 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
formats = ue_formats; formats = ue_formats;
nof_formats = nof_ue_formats; nof_formats = nof_ue_formats;
} }
uint16_t srslte_crc_rem=0; uint16_t crc_rem=0;
srslte_dci_msg_t dci_msg; srslte_dci_msg_t dci_msg;
bzero(&dci_msg, sizeof(srslte_dci_msg_t)); bzero(&dci_msg, sizeof(srslte_dci_msg_t));
for (int f=0;f<nof_formats;f++) { for (int f=0;f<nof_formats;f++) {
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) { for (i=0;i<nof_locations && crc_rem != rnti;i++) {
if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &srslte_crc_rem)) { if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return; return;
} }
@ -176,7 +176,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
} }
if (nlhs >= 1) { if (nlhs >= 1) {
plhs[0] = mxCreateLogicalScalar(srslte_crc_rem == rnti); plhs[0] = mxCreateLogicalScalar(crc_rem == rnti);
} }
int nof_bits = (srslte_regs_pdcch_nregs(&regs, cfi) / 9) * 72; int nof_bits = (srslte_regs_pdcch_nregs(&regs, cfi) / 9) * 72;
if (nlhs >= 2) { if (nlhs >= 2) {

8
srslte/lib/phch/test/pdsch_file_test.c
View File

@ -267,19 +267,19 @@ int main(int argc, char **argv) {
nof_locations = srslte_pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti); nof_locations = srslte_pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti);
} }
uint16_t srslte_crc_rem = 0; uint16_t crc_rem = 0;
if (srslte_pdcch_extract_llr(&pdcch, fft_buffer, ce, srslte_chest_dl_get_noise_estimate(&chest), sf_idx, cfi)) { if (srslte_pdcch_extract_llr(&pdcch, fft_buffer, ce, srslte_chest_dl_get_noise_estimate(&chest), sf_idx, cfi)) {
fprintf(stderr, "Error extracting LLRs\n"); fprintf(stderr, "Error extracting LLRs\n");
return -1; return -1;
} }
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) { for (i=0;i<nof_locations && crc_rem != rnti;i++) {
if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) { if (srslte_pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return -1; return -1;
} }
} }
if (srslte_crc_rem == rnti) { if (crc_rem == rnti) {
if (srslte_dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, &ra_dl)) { if (srslte_dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, &ra_dl)) {
fprintf(stderr, "Error unpacking PDSCH scheduling DCI message\n"); fprintf(stderr, "Error unpacking PDSCH scheduling DCI message\n");
goto goout; goto goout;

1
srslte/lib/ue/src/ue_dl.c
View File

@ -223,6 +223,7 @@ int srslte_ue_dl_decode_rnti_rv_packet(srslte_ue_dl_t *q, srslte_dci_msg_t *dci_
ret = srslte_pdsch_decode_rnti(&q->pdsch, &q->harq_process[0], q->sf_symbols, ret = srslte_pdsch_decode_rnti(&q->pdsch, &q->harq_process[0], q->sf_symbols,
q->ce, 0, q->ce, 0,
rnti, data); rnti, data);
if (ret == SRSLTE_ERROR) { if (ret == SRSLTE_ERROR) {
q->pkt_errors++; q->pkt_errors++;
} else if (ret == SRSLTE_ERROR_INVALID_INPUTS) { } else if (ret == SRSLTE_ERROR_INVALID_INPUTS) {

29
srslte/lib/ue_itf/src/dl_buffer.cc
View File

@ -66,7 +66,7 @@ void dl_buffer::free_cell()
bool dl_buffer::recv_ue_sync(uint32_t current_tti, srslte_ue_sync_t *ue_sync, srslte_timestamp_t *rx_time) bool dl_buffer::recv_ue_sync(uint32_t current_tti, srslte_ue_sync_t *ue_sync, srslte_timestamp_t *rx_time)
{ {
if (signal_buffer) { if (signal_buffer) {
printf("DL_buffer %d receiving tti %d...\n", buffer_id, current_tti); INFO("DL Buffer TTI %d: Receiving packet\n", tti);
cf_t *sf_buffer = NULL; cf_t *sf_buffer = NULL;
tti = current_tti; tti = current_tti;
if (srslte_ue_sync_get_buffer(ue_sync, &sf_buffer) == 1) { if (srslte_ue_sync_get_buffer(ue_sync, &sf_buffer) == 1) {
@ -111,31 +111,47 @@ bool dl_buffer::get_ul_grant(pdcch_ul_search_t mode, uint32_t rnti, sched_grant
} }
uint8_t data[1024];
bool dl_buffer::get_dl_grant(pdcch_dl_search_t mode, uint32_t rnti, sched_grant *grant) bool dl_buffer::get_dl_grant(pdcch_dl_search_t mode, uint32_t rnti, sched_grant *grant)
{ {
if (signal_buffer) { if (signal_buffer) {
INFO("DL Buffer TTI %d: Getting DL grant\n", tti);
if (!sf_symbols_and_ce_done) { if (!sf_symbols_and_ce_done) {
INFO("DL Buffer TTI %d: Getting DL grant. Calling fft estimate\n", tti);
if (srslte_ue_dl_decode_fft_estimate(&ue_dl, signal_buffer, tti%10, &cfi) < 0) { if (srslte_ue_dl_decode_fft_estimate(&ue_dl, signal_buffer, tti%10, &cfi) < 0) {
return false; return false;
} }
sf_symbols_and_ce_done = true; sf_symbols_and_ce_done = true;
} }
if (!pdcch_llr_extracted) { if (!pdcch_llr_extracted) {
INFO("DL Buffer TTI %d: Getting DL grant. extracting LLR\n", tti);
if (srslte_pdcch_extract_llr(&ue_dl.pdcch, ue_dl.sf_symbols, ue_dl.ce, 0, tti%10, cfi)) { if (srslte_pdcch_extract_llr(&ue_dl.pdcch, ue_dl.sf_symbols, ue_dl.ce, 0, tti%10, cfi)) {
return false; return false;
} }
pdcch_llr_extracted = true; pdcch_llr_extracted = true;
} }
if (SRSLTE_VERBOSE_ISINFO()) {
srslte_vec_save_file((char*) "ce1", ue_dl.ce[0], SRSLTE_SF_LEN_RE(ue_dl.cell.nof_prb, ue_dl.cell.cp)*sizeof(cf_t));
srslte_vec_save_file((char*) "ce2", ue_dl.ce[1], SRSLTE_SF_LEN_RE(ue_dl.cell.nof_prb, ue_dl.cell.cp)*sizeof(cf_t));
srslte_vec_save_file((char*) "pdcch_d", ue_dl.pdcch.d, 36*ue_dl.pdcch.nof_cce*sizeof(cf_t));
}
srslte_dci_msg_t dci_msg; srslte_dci_msg_t dci_msg;
if (srslte_ue_dl_find_dl_dci(&ue_dl, &dci_msg, cfi, tti%10, rnti) != 1) { if (srslte_ue_dl_find_dl_dci(&ue_dl, &dci_msg, cfi, tti%10, rnti) != 1) {
return false; return false;
} }
if (srslte_dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, uint32_t sfn = tti/10;
uint32_t rvidx = ((uint32_t) ceilf((float)3*((sfn/2)%4)/2))%4;
srslte_ue_dl_decode_rnti_rv_packet(&ue_dl, &dci_msg, data, cfi, tti%10, rnti, rvidx);
/* if (srslte_dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi,
(srslte_ra_pdsch_t*) grant->get_grant_ptr())) { (srslte_ra_pdsch_t*) grant->get_grant_ptr())) {
return false; return false;
} }
*/
return true; return true;
} }
} }
@ -156,21 +172,28 @@ bool dl_buffer::decode_phich(srslte_phich_alloc_t assignment)
bool dl_buffer::decode_pdsch(sched_grant pdsch_grant, uint8_t *payload) bool dl_buffer::decode_pdsch(sched_grant pdsch_grant, uint8_t *payload)
{ {
if (signal_buffer) { if (signal_buffer) {
INFO("DL Buffer TTI %d: Decoding PDSCH\n", tti);
if (!sf_symbols_and_ce_done) { if (!sf_symbols_and_ce_done) {
INFO("DL Buffer TTI %d: Decoding PDSCH. Calling fft estimate\n", tti);
if (srslte_ue_dl_decode_fft_estimate(&ue_dl, signal_buffer, tti%10, &cfi) < 0) { if (srslte_ue_dl_decode_fft_estimate(&ue_dl, signal_buffer, tti%10, &cfi) < 0) {
return false; return false;
} }
sf_symbols_and_ce_done = true; sf_symbols_and_ce_done = true;
} }
srslte_ra_pdsch_t *ra_dl = (srslte_ra_pdsch_t*) pdsch_grant.get_grant_ptr(); srslte_ra_pdsch_t *ra_dl = (srslte_ra_pdsch_t*) pdsch_grant.get_grant_ptr();
if (srslte_harq_setup_dl(&ue_dl.harq_process[0], ra_dl->mcs, if (srslte_harq_setup_dl(&ue_dl.harq_process[0], ra_dl->mcs,
pdsch_grant.get_rv(), tti%10, &ra_dl->prb_alloc)) { ra_dl->rv_idx, tti%10, &ra_dl->prb_alloc)) {
fprintf(stderr, "Error configuring HARQ process\n"); fprintf(stderr, "Error configuring HARQ process\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if (ue_dl.harq_process[0].mcs.mod > 0 && ue_dl.harq_process[0].mcs.tbs >= 0) { if (ue_dl.harq_process[0].mcs.mod > 0 && ue_dl.harq_process[0].mcs.tbs >= 0) {
int ret = srslte_pdsch_decode_rnti(&ue_dl.pdsch, &ue_dl.harq_process[0], ue_dl.sf_symbols, int ret = srslte_pdsch_decode_rnti(&ue_dl.pdsch, &ue_dl.harq_process[0], ue_dl.sf_symbols,
ue_dl.ce, 0, pdsch_grant.get_rnti(), payload); ue_dl.ce, 0, pdsch_grant.get_rnti(), payload);
if (SRSLTE_VERBOSE_ISINFO()) {
srslte_vec_save_file((char*) "pdsch_d", ue_dl.pdsch.d, ue_dl.harq_process[0].nof_re*sizeof(cf_t));
}
if (ret == SRSLTE_SUCCESS) { if (ret == SRSLTE_SUCCESS) {
return true; return true;
} }

6
srslte/lib/ue_itf/src/phy.cc
View File

@ -65,7 +65,7 @@ bool phy::init(ue_phy_callback_tti_t tti_clock_callback_, ue_phy_callback_status
params_db.set_param(params::CELLSEARCH_TIMEOUT_MIB_NFRAMES, 100); params_db.set_param(params::CELLSEARCH_TIMEOUT_MIB_NFRAMES, 100);
if (init_radio_handler("")) { if (init_radio_handler((char*) "")) {
pthread_create(&radio_thread, NULL, radio_thread_fnc, this); pthread_create(&radio_thread, NULL, radio_thread_fnc, this);
started = true; started = true;
} }
@ -353,7 +353,6 @@ void phy::run_rx_tx_state()
{ {
int ret; int ret;
if (!is_sfn_synched) { if (!is_sfn_synched) {
printf("Synchronising SFN...\n");
ret = sync_sfn(); ret = sync_sfn();
switch(ret) { switch(ret) {
default: default:
@ -386,15 +385,12 @@ void phy::run_rx_tx_state()
void phy::main_radio_loop() { void phy::main_radio_loop() {
printf("PHY initiated\n");
while(started) { while(started) {
switch(phy_state) { switch(phy_state) {
case IDLE: case IDLE:
usleep(50000); usleep(50000);
break; break;
case RXTX: case RXTX:
printf("Run RX_TX\n");
run_rx_tx_state(); run_rx_tx_state();
break; break;
} }

109
srslte/lib/ue_itf/test/ue_itf_test.cc
View File

@ -33,29 +33,104 @@
void tti_callback(); void tti_callback();
void status_change(); void status_change();
/**********************************************************************
* Program arguments processing
***********************************************************************/
typedef struct {
float uhd_freq;
float uhd_gain;
}prog_args_t;
void args_default(prog_args_t *args) {
args->uhd_freq = -1.0;
args->uhd_gain = 60.0;
}
void usage(prog_args_t *args, char *prog) {
printf("Usage: %s [gv] -f rx_frequency (in Hz)\n", prog);
printf("\t-g UHD RX gain [Default %.2f dB]\n", args->uhd_gain);
printf("\t-v [increase verbosity, default none]\n");
}
void parse_args(prog_args_t *args, int argc, char **argv) {
int opt;
args_default(args);
while ((opt = getopt(argc, argv, "gfv")) != -1) {
switch (opt) {
case 'g':
args->uhd_gain = atof(argv[optind]);
break;
case 'f':
args->uhd_freq = atof(argv[optind]);
break;
case 'v':
srslte_verbose++;
break;
default:
usage(args, argv[0]);
exit(-1);
}
}
if (args->uhd_freq < 0) {
usage(args, argv[0]);
exit(-1);
}
}
srslte::ue::phy phy; srslte::ue::phy phy;
uint32_t total_pkts=0;
uint32_t total_dci=0;
uint32_t total_errors=0;
uint8_t payload[1024]; uint8_t payload[1024];
// This is the MAC implementation
void tti_callback(uint32_t tti) { void tti_callback(uint32_t tti) {
printf("called tti: %d\n", tti); srslte::ue::sched_grant grant;
INFO("called tti: %d\n", tti);
// This is the MAC implementation // SIB1 is scheduled in subframe #5 of even frames
if ((phy.tti_to_SFN(tti)%2) == 0 && phy.tti_to_subf(tti) == 5) { if ((phy.tti_to_SFN(tti)%2) == 0 && phy.tti_to_subf(tti) == 5) {
srslte::ue::sched_grant grant;
srslte_verbose = SRSLTE_VERBOSE_DEBUG; // Get buffer
if (phy.get_dl_buffer(tti)->get_dl_grant(srslte::ue::dl_buffer::PDCCH_DL_SEARCH_SIRNTI, SRSLTE_SIRNTI, &grant)) { srslte::ue::dl_buffer *buffer = phy.get_dl_buffer(tti);
if (phy.get_dl_buffer(tti)->decode_pdsch(grant, payload)) {
// Get DL grant
if (buffer->get_dl_grant(srslte::ue::dl_buffer::PDCCH_DL_SEARCH_SIRNTI, SRSLTE_SIRNTI, &grant))
{
// MAC sets RV
grant.set_rv(((uint32_t) ceilf((float)3*((phy.tti_to_SFN(tti)/2)%4)/2))%4);
// Decode packet
if (buffer->decode_pdsch(grant, payload)) {
printf("Decoded SIB1 ok TBS: %d\n", grant.get_tbs()); printf("Decoded SIB1 ok TBS: %d\n", grant.get_tbs());
srslte_vec_fprint_hex(stdout, payload, grant.get_tbs()); srslte_vec_fprint_hex(stdout, payload, grant.get_tbs());
exit(0);
} else { } else {
fprintf(stderr, "Could not decode SIB\n"); total_errors++;
} }
} else { exit(0);
fprintf(stderr, "Error getting DL grant\n"); total_dci++;
}
total_pkts++;
if (total_pkts==4) {
exit(-1);
} }
exit(0);
} }
printf("PDCCH BLER %.3f \%% PDSCH BLER %.3f \%% (total pkts: %d) \r",
1-(float) total_dci/total_pkts,
(float) total_errors/total_pkts,
total_pkts);
} }
void status_change() { void status_change() {
@ -66,18 +141,26 @@ int main(int argc, char *argv[])
{ {
srslte_cell_t cell; srslte_cell_t cell;
uint8_t bch_payload[SRSLTE_BCH_PAYLOAD_LEN]; uint8_t bch_payload[SRSLTE_BCH_PAYLOAD_LEN];
prog_args_t prog_args;
parse_args(&prog_args, argc, argv);
// Init PHY
phy.init(tti_callback, status_change); phy.init(tti_callback, status_change);
// Give it time to create thread
sleep(1); sleep(1);
phy.set_rx_freq(1825000000); // Set RX freq and gain
phy.set_rx_gain(60.0); phy.set_rx_freq(prog_args.uhd_freq);
phy.set_rx_gain(prog_args.uhd_gain);
/* Instruct the PHY to decode BCH */ /* Instruct the PHY to decode BCH */
if (!phy.decode_mib_best(&cell, bch_payload)) { if (!phy.decode_mib_best(&cell, bch_payload)) {
exit(-1); exit(-1);
} }
// Print MIB
srslte_pbch_mib_fprint(stdout, &cell, phy.get_current_tti()/10); srslte_pbch_mib_fprint(stdout, &cell, phy.get_current_tti()/10);
srslte_vec_fprint_hex(stdout, bch_payload, SRSLTE_BCH_PAYLOAD_LEN);
// Set the current PHY cell to the detected cell // Set the current PHY cell to the detected cell
if (!phy.set_cell(cell)) { if (!phy.set_cell(cell)) {