mirror of https://github.com/pvnis/srsRAN_4G.git
Added UL SCH interleaver. Fixed issue with rate matching and filler bits
ismagom
10 years ago
parent
9a614ec9d1
commit
a47461a6f5
@ -0,0 +1,78 @@
|
||||
/**
|
||||
*
|
||||
* \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/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef HARQ_
|
||||
#define HARQ_
|
||||
|
||||
#include "liblte/config.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/phch/ra.h"
|
||||
|
||||
|
||||
struct cb_segm {
|
||||
uint32_t F;
|
||||
uint32_t C;
|
||||
uint32_t K1;
|
||||
uint32_t K2;
|
||||
uint32_t C1;
|
||||
uint32_t C2;
|
||||
};
|
||||
|
||||
typedef struct LIBLTE_API {
|
||||
ra_mcs_t mcs;
|
||||
ra_prb_t prb_alloc;
|
||||
lte_cell_t cell;
|
||||
|
||||
uint32_t N_symb_ul; // Number of symbols for PUSCH transmission
|
||||
uint32_t nof_prb_pusch_init; // Initial resource allocation for PUSCH.
|
||||
|
||||
uint32_t max_cb;
|
||||
uint32_t w_buff_size;
|
||||
float **pdsch_w_buff_f;
|
||||
uint8_t **pdsch_w_buff_c;
|
||||
|
||||
struct cb_segm cb_segm;
|
||||
|
||||
} harq_t;
|
||||
|
||||
LIBLTE_API int harq_init(harq_t * q,
|
||||
lte_cell_t cell);
|
||||
|
||||
LIBLTE_API int harq_setup(harq_t *p,
|
||||
ra_mcs_t mcs,
|
||||
ra_prb_t *prb_alloc);
|
||||
|
||||
LIBLTE_API void harq_reset(harq_t *p);
|
||||
|
||||
LIBLTE_API void harq_free(harq_t *p);
|
||||
|
||||
LIBLTE_API int codeblock_segmentation(struct cb_segm *s,
|
||||
uint32_t tbs);
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,120 @@
|
||||
/**
|
||||
*
|
||||
* \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/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef PUCH_
|
||||
#define PUSCH_
|
||||
|
||||
#include "liblte/config.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/mimo/precoding.h"
|
||||
#include "liblte/phy/mimo/layermap.h"
|
||||
#include "liblte/phy/modem/mod.h"
|
||||
#include "liblte/phy/modem/demod_soft.h"
|
||||
#include "liblte/phy/scrambling/scrambling.h"
|
||||
#include "liblte/phy/phch/regs.h"
|
||||
#include "liblte/phy/phch/sch.h"
|
||||
#include "liblte/phy/phch/harq.h"
|
||||
|
||||
#define TDEC_MAX_ITERATIONS 5
|
||||
|
||||
typedef _Complex float cf_t;
|
||||
|
||||
/* PDSCH object */
|
||||
typedef struct LIBLTE_API {
|
||||
lte_cell_t cell;
|
||||
|
||||
uint32_t max_symbols;
|
||||
bool rnti_is_set;
|
||||
uint16_t rnti;
|
||||
|
||||
/* buffers */
|
||||
// void buffers are shared for tx and rx
|
||||
cf_t *ce[MAX_PORTS];
|
||||
cf_t *pusch_symbols[MAX_PORTS];
|
||||
cf_t *pusch_x[MAX_PORTS];
|
||||
cf_t *pusch_d;
|
||||
void *pusch_e;
|
||||
|
||||
uint8_t *pusch_q_ri;
|
||||
uint8_t *pusch_q_ack;
|
||||
|
||||
/* tx & rx objects */
|
||||
modem_table_t mod[4];
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pusch[NSUBFRAMES_X_FRAME];
|
||||
|
||||
sch_t dl_sch;
|
||||
|
||||
}pusch_t;
|
||||
|
||||
|
||||
|
||||
|
||||
LIBLTE_API int pusch_init(pusch_t *q,
|
||||
lte_cell_t cell);
|
||||
|
||||
LIBLTE_API void pusch_free(pusch_t *q);
|
||||
|
||||
LIBLTE_API int pusch_set_rnti(pusch_t *q,
|
||||
uint16_t rnti);
|
||||
|
||||
LIBLTE_API int pusch_encode(pusch_t *q,
|
||||
uint8_t *data,
|
||||
cf_t *sf_symbols[MAX_PORTS],
|
||||
uint32_t nsubframe,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API int pusch_uci_encode(pusch_t *q,
|
||||
uint8_t *data,
|
||||
uci_data_t uci_data,
|
||||
cf_t *sf_symbols[MAX_PORTS],
|
||||
uint32_t subframe,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API int pusch_decode(pusch_t *q,
|
||||
cf_t *sf_symbols,
|
||||
cf_t *ce[MAX_PORTS],
|
||||
float noise_estimate,
|
||||
uint8_t *data,
|
||||
uint32_t nsubframe,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API float pusch_average_noi(pusch_t *q);
|
||||
|
||||
LIBLTE_API uint32_t pusch_last_noi(pusch_t *q);
|
||||
|
||||
LIBLTE_API int pusch_get(pusch_t *q,
|
||||
cf_t *sf_symbols,
|
||||
cf_t *pusch_symbols,
|
||||
ra_prb_t *prb_alloc,
|
||||
uint32_t subframe);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,112 @@
|
||||
/**
|
||||
*
|
||||
* \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/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef SCH_
|
||||
#define SCH_
|
||||
|
||||
#include "liblte/config.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/fec/rm_turbo.h"
|
||||
#include "liblte/phy/fec/turbocoder.h"
|
||||
#include "liblte/phy/fec/turbodecoder.h"
|
||||
#include "liblte/phy/fec/crc.h"
|
||||
#include "liblte/phy/phch/harq.h"
|
||||
#include "liblte/phy/phch/uci.h"
|
||||
|
||||
#define TDEC_MAX_ITERATIONS 5
|
||||
|
||||
|
||||
#ifndef RX_NULL
|
||||
#define RX_NULL 10000
|
||||
#endif
|
||||
|
||||
#ifndef TX_NULL
|
||||
#define TX_NULL 100
|
||||
#endif
|
||||
|
||||
/* DL-SCH AND UL-SCH common functions */
|
||||
typedef struct LIBLTE_API {
|
||||
|
||||
uint32_t nof_iterations;
|
||||
float average_nof_iterations;
|
||||
|
||||
/* buffers */
|
||||
uint8_t *cb_in;
|
||||
void *cb_out;
|
||||
void *pdsch_e;
|
||||
|
||||
tcod_t encoder;
|
||||
tdec_t decoder;
|
||||
crc_t crc_tb;
|
||||
crc_t crc_cb;
|
||||
} sch_t;
|
||||
|
||||
LIBLTE_API int sch_init(sch_t *q);
|
||||
|
||||
LIBLTE_API void sch_free(sch_t *q);
|
||||
|
||||
|
||||
LIBLTE_API float sch_average_noi(sch_t *q);
|
||||
|
||||
LIBLTE_API uint32_t sch_last_noi(sch_t *q);
|
||||
|
||||
LIBLTE_API int dlsch_encode(sch_t *q,
|
||||
uint8_t *data,
|
||||
uint8_t *e_bits,
|
||||
uint32_t tbs,
|
||||
uint32_t nb_e,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API int dlsch_decode(sch_t *q,
|
||||
float *e_bits,
|
||||
uint8_t *data,
|
||||
uint32_t tbs,
|
||||
uint32_t nb_e,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API int ulsch_encode(sch_t *q,
|
||||
uint8_t *data,
|
||||
uci_data_t uci_data,
|
||||
uint8_t *q_bits,
|
||||
uint32_t nb_q,
|
||||
uint8_t *q_bits_ack,
|
||||
uint8_t *q_bits_ri,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
LIBLTE_API int ulsch_decode(sch_t *q,
|
||||
float *e_bits,
|
||||
uint8_t *data,
|
||||
uint32_t tbs,
|
||||
uint32_t nb_e,
|
||||
harq_t *harq_process,
|
||||
uint32_t rv_idx);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,60 @@
|
||||
/**
|
||||
*
|
||||
* \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/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef UCI_
|
||||
#define UCI_
|
||||
|
||||
#include "liblte/config.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/phch/harq.h"
|
||||
|
||||
typedef struct LIBLTE_API {
|
||||
uint8_t *uci_cqi;
|
||||
uint32_t uci_cqi_len;
|
||||
float beta_cqi;
|
||||
uint8_t uci_ri; // Only 1-bit supported for RI
|
||||
uint32_t uci_ri_len;
|
||||
float beta_ri;
|
||||
uint8_t uci_ack; // Only 1-bit supported for HARQ
|
||||
uint32_t uci_ack_len;
|
||||
float beta_ack;
|
||||
} uci_data_t;
|
||||
|
||||
|
||||
LIBLTE_API int uci_encode_cqi(uint8_t *data,
|
||||
uint8_t *e_bits,
|
||||
uint32_t tbs,
|
||||
uint32_t nb_e);
|
||||
|
||||
/* Encode UCI RI and HARQ ACK/NACK bits */
|
||||
LIBLTE_API uint32_t uci_encode_ri_ack(uint8_t data,
|
||||
float beta,
|
||||
uint8_t q_bits[6],
|
||||
harq_t *harq_process);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,100 @@
|
||||
/**
|
||||
*
|
||||
* \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 "liblte/phy/phy.h"
|
||||
#include "liblte/mex/mexutils.h"
|
||||
|
||||
/** MEX function to be called from MATLAB to test the channel estimator
|
||||
*/
|
||||
|
||||
#define INPUT prhs[0]
|
||||
#define TRBLKLEN prhs[1]
|
||||
#define RV prhs[2]
|
||||
#define NOF_INPUTS 3
|
||||
|
||||
|
||||
void help()
|
||||
{
|
||||
mexErrMsgTxt
|
||||
("[out] = liblte_rm_turbo_rx(in, trblkin, rv)\n\n");
|
||||
}
|
||||
|
||||
/* the gateway function */
|
||||
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
|
||||
float *input;
|
||||
float *output;
|
||||
uint32_t in_len, trblklen, cblen, rvidx;
|
||||
float *w_buff_f;
|
||||
|
||||
if (nrhs != NOF_INPUTS) {
|
||||
help();
|
||||
return;
|
||||
}
|
||||
|
||||
// Read input symbols
|
||||
in_len = mexutils_read_f(INPUT, &input);
|
||||
if (in_len < 0) {
|
||||
mexErrMsgTxt("Error reading input bits\n");
|
||||
return;
|
||||
}
|
||||
|
||||
trblklen = (uint32_t) mxGetScalar(TRBLKLEN);
|
||||
rvidx = (uint32_t) mxGetScalar(RV);
|
||||
|
||||
struct cb_segm cbsegm;
|
||||
codeblock_segmentation(&cbsegm, trblklen);
|
||||
cblen = 3*cbsegm.K1+12;
|
||||
|
||||
w_buff_f = calloc(1,sizeof(float) * cblen * 10);
|
||||
if (!w_buff_f) {
|
||||
perror("malloc");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
// allocate memory for output bits
|
||||
output = vec_malloc(cblen * sizeof(float));
|
||||
|
||||
rm_turbo_rx(w_buff_f, cblen * 10, input, in_len, output, cblen,
|
||||
rvidx,cbsegm.F);
|
||||
|
||||
if (nlhs >= 1) {
|
||||
mexutils_write_f(output, &plhs[0], cblen, 1);
|
||||
}
|
||||
if (nlhs >= 2) {
|
||||
mexutils_write_f(input, &plhs[1], in_len, 1);
|
||||
}
|
||||
|
||||
free(input);
|
||||
free(output);
|
||||
free(w_buff_f);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@ -0,0 +1,200 @@
|
||||
/**
|
||||
*
|
||||
* \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 <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/phch/ra.h"
|
||||
#include "liblte/phy/phch/harq.h"
|
||||
#include "liblte/phy/fec/turbodecoder.h"
|
||||
#include "liblte/phy/utils/vector.h"
|
||||
#include "liblte/phy/utils/debug.h"
|
||||
|
||||
|
||||
#define MAX_PDSCH_RE(cp) (2 * CP_NSYMB(cp) * 12)
|
||||
|
||||
/* Calculate Codeblock Segmentation as in Section 5.1.2 of 36.212 */
|
||||
int codeblock_segmentation(struct cb_segm *s, uint32_t tbs) {
|
||||
uint32_t Bp, B, idx1;
|
||||
int ret;
|
||||
|
||||
B = tbs + 24;
|
||||
|
||||
/* Calculate CB sizes */
|
||||
if (B <= MAX_LONG_CB) {
|
||||
s->C = 1;
|
||||
Bp = B;
|
||||
} else {
|
||||
s->C = (uint32_t) ceilf((float) B / (MAX_LONG_CB - 24));
|
||||
Bp = B + 24 * s->C;
|
||||
}
|
||||
ret = lte_find_cb_index((Bp-1) / s->C + 1);
|
||||
if (ret != LIBLTE_ERROR) {
|
||||
idx1 = (uint32_t) ret;
|
||||
ret = lte_cb_size(idx1);
|
||||
if (ret != LIBLTE_ERROR) {
|
||||
s->K1 = (uint32_t) ret;
|
||||
if (idx1 > 0) {
|
||||
ret = lte_cb_size(idx1 - 1);
|
||||
}
|
||||
if (ret != LIBLTE_ERROR) {
|
||||
if (s->C == 1) {
|
||||
s->K2 = 0;
|
||||
s->C2 = 0;
|
||||
s->C1 = 1;
|
||||
} else {
|
||||
s->K2 = (uint32_t) ret;
|
||||
s->C2 = (s->C * s->K1 - Bp) / (s->K1 - s->K2);
|
||||
s->C1 = s->C - s->C2;
|
||||
}
|
||||
s->F = s->C1 * s->K1 + s->C2 * s->K2 - Bp;
|
||||
INFO("CB Segmentation: TBS: %d, C=%d, C+=%d K+=%d, C-=%d, K-=%d, F=%d, Bp=%d\n",
|
||||
tbs, s->C, s->C1, s->K1, s->C2, s->K2, s->F, Bp);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int harq_init(harq_t *q, lte_cell_t cell) {
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
|
||||
if (q != NULL) {
|
||||
uint32_t i;
|
||||
bzero(q, sizeof(harq_t));
|
||||
|
||||
memcpy(&q->cell, &cell, sizeof(lte_cell_t));
|
||||
|
||||
ret = ra_tbs_from_idx(26, cell.nof_prb);
|
||||
if (ret != LIBLTE_ERROR) {
|
||||
q->max_cb = (uint32_t) ret / (MAX_LONG_CB - 24) + 1;
|
||||
|
||||
q->pdsch_w_buff_f = malloc(sizeof(float*) * q->max_cb);
|
||||
if (!q->pdsch_w_buff_f) {
|
||||
perror("malloc");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
q->pdsch_w_buff_c = malloc(sizeof(uint8_t*) * q->max_cb);
|
||||
if (!q->pdsch_w_buff_c) {
|
||||
perror("malloc");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
// FIXME: Use HARQ buffer limitation based on UE category
|
||||
q->w_buff_size = cell.nof_prb * MAX_PDSCH_RE(cell.cp) * 6 * 10;
|
||||
for (i=0;i<q->max_cb;i++) {
|
||||
q->pdsch_w_buff_f[i] = vec_malloc(sizeof(float) * q->w_buff_size);
|
||||
if (!q->pdsch_w_buff_f[i]) {
|
||||
perror("malloc");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
q->pdsch_w_buff_c[i] = vec_malloc(sizeof(uint8_t) * q->w_buff_size);
|
||||
if (!q->pdsch_w_buff_c[i]) {
|
||||
perror("malloc");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
}
|
||||
ret = LIBLTE_SUCCESS;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void harq_free(harq_t *q) {
|
||||
if (q) {
|
||||
uint32_t i;
|
||||
if (q->pdsch_w_buff_f) {
|
||||
for (i=0;i<q->max_cb;i++) {
|
||||
if (q->pdsch_w_buff_f[i]) {
|
||||
free(q->pdsch_w_buff_f[i]);
|
||||
}
|
||||
}
|
||||
free(q->pdsch_w_buff_f);
|
||||
}
|
||||
if (q->pdsch_w_buff_c) {
|
||||
for (i=0;i<q->max_cb;i++) {
|
||||
if (q->pdsch_w_buff_c[i]) {
|
||||
free(q->pdsch_w_buff_c[i]);
|
||||
}
|
||||
}
|
||||
free(q->pdsch_w_buff_c);
|
||||
}
|
||||
bzero(q, sizeof(harq_t));
|
||||
}
|
||||
}
|
||||
|
||||
void harq_reset(harq_t *q) {
|
||||
int i;
|
||||
if (q->pdsch_w_buff_f) {
|
||||
for (i=0;i<q->max_cb;i++) {
|
||||
if (q->pdsch_w_buff_f[i]) {
|
||||
bzero(q->pdsch_w_buff_f[i], sizeof(float) * q->w_buff_size);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (q->pdsch_w_buff_c) {
|
||||
for (i=0;i<q->max_cb;i++) {
|
||||
if (q->pdsch_w_buff_c[i]) {
|
||||
bzero(q->pdsch_w_buff_c[i], sizeof(uint8_t) * q->w_buff_size);
|
||||
}
|
||||
}
|
||||
}
|
||||
bzero(&q->mcs, sizeof(ra_mcs_t));
|
||||
bzero(&q->cb_segm, sizeof(struct cb_segm));
|
||||
bzero(&q->prb_alloc, sizeof(ra_prb_t));
|
||||
}
|
||||
|
||||
int harq_setup(harq_t *q, ra_mcs_t mcs, ra_prb_t *prb_alloc) {
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
|
||||
if (q != NULL &&
|
||||
mcs.tbs > 0)
|
||||
{
|
||||
q->mcs = mcs;
|
||||
memcpy(&q->prb_alloc, prb_alloc, sizeof(ra_prb_t));
|
||||
|
||||
q->N_symb_ul = 2*(CP_NSYMB(q->cell.cp)-1);
|
||||
q->nof_prb_pusch_init = q->prb_alloc.slot[0].nof_prb;
|
||||
|
||||
codeblock_segmentation(&q->cb_segm, mcs.tbs);
|
||||
if (q->cb_segm.C > q->max_cb) {
|
||||
fprintf(stderr, "Codeblock segmentation returned more CBs (%d) than allocated (%d)\n",
|
||||
q->cb_segm.C, q->max_cb);
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
ret = LIBLTE_SUCCESS;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -0,0 +1,375 @@
|
||||
/**
|
||||
*
|
||||
* \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 <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "prb.h"
|
||||
#include "liblte/phy/phch/pusch.h"
|
||||
#include "liblte/phy/phch/uci.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/utils/bit.h"
|
||||
#include "liblte/phy/utils/debug.h"
|
||||
#include "liblte/phy/utils/vector.h"
|
||||
|
||||
|
||||
#define MAX_PUSCH_RE(cp) (2 * CP_NSYMB(cp) * 12)
|
||||
|
||||
|
||||
|
||||
const static lte_mod_t modulations[4] =
|
||||
{ LTE_BPSK, LTE_QPSK, LTE_QAM16, LTE_QAM64 };
|
||||
|
||||
//#define DEBUG_IDX
|
||||
|
||||
#ifdef DEBUG_IDX
|
||||
cf_t *offset_original=NULL;
|
||||
extern int indices[100000];
|
||||
extern int indices_ptr;
|
||||
#endif
|
||||
|
||||
|
||||
int pusch_cp(pusch_t *q, cf_t *input, cf_t *output, ra_prb_t *prb_alloc,
|
||||
uint32_t nsubframe, bool put)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Puts PUSCH in slot number 1
|
||||
*
|
||||
* Returns the number of symbols written to sf_symbols
|
||||
*
|
||||
* 36.211 10.3 section 6.3.5
|
||||
*/
|
||||
int pusch_put(pusch_t *q, cf_t *pusch_symbols, cf_t *sf_symbols,
|
||||
ra_prb_t *prb_alloc, uint32_t subframe) {
|
||||
return pusch_cp(q, pusch_symbols, sf_symbols, prb_alloc, subframe, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts PUSCH from slot number 1
|
||||
*
|
||||
* Returns the number of symbols written to PUSCH
|
||||
*
|
||||
* 36.211 10.3 section 6.3.5
|
||||
*/
|
||||
int pusch_get(pusch_t *q, cf_t *sf_symbols, cf_t *pusch_symbols,
|
||||
ra_prb_t *prb_alloc, uint32_t subframe) {
|
||||
return pusch_cp(q, sf_symbols, pusch_symbols, prb_alloc, subframe, false);
|
||||
}
|
||||
|
||||
/** Initializes the PDCCH transmitter and receiver */
|
||||
int pusch_init(pusch_t *q, lte_cell_t cell) {
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
int i;
|
||||
|
||||
if (q != NULL &&
|
||||
lte_cell_isvalid(&cell))
|
||||
{
|
||||
|
||||
bzero(q, sizeof(pusch_t));
|
||||
ret = LIBLTE_ERROR;
|
||||
|
||||
q->cell = cell;
|
||||
q->max_symbols = q->cell.nof_prb * MAX_PUSCH_RE(q->cell.cp);
|
||||
|
||||
INFO("Init PUSCH: %d ports %d PRBs, max_symbols: %d\n", q->cell.nof_ports,
|
||||
q->cell.nof_prb, q->max_symbols);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (modem_table_lte(&q->mod[i], modulations[i], true)) {
|
||||
goto clean;
|
||||
}
|
||||
}
|
||||
|
||||
demod_soft_init(&q->demod, q->max_symbols);
|
||||
demod_soft_alg_set(&q->demod, APPROX);
|
||||
|
||||
sch_init(&q->dl_sch);
|
||||
|
||||
q->rnti_is_set = false;
|
||||
|
||||
// Allocate floats for reception (LLRs)
|
||||
q->pusch_e = malloc(sizeof(float) * q->max_symbols * lte_mod_bits_x_symbol(LTE_QAM64));
|
||||
if (!q->pusch_e) {
|
||||
goto clean;
|
||||
}
|
||||
|
||||
// Allocate buffers for q bits for coded RI and ACK bits
|
||||
q->pusch_q_ack = malloc(sizeof(uint8_t) * 4 * q->cell.nof_prb * lte_mod_bits_x_symbol(LTE_QAM64));
|
||||
if (!q->pusch_q_ack) {
|
||||
goto clean;
|
||||
}
|
||||
q->pusch_q_ri = malloc(sizeof(uint8_t) * 4 * q->cell.nof_prb * lte_mod_bits_x_symbol(LTE_QAM64));
|
||||
if (!q->pusch_q_ri) {
|
||||
goto clean;
|
||||
}
|
||||
|
||||
q->pusch_d = malloc(sizeof(cf_t) * q->max_symbols);
|
||||
if (!q->pusch_d) {
|
||||
goto clean;
|
||||
}
|
||||
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
q->ce[i] = malloc(sizeof(cf_t) * q->max_symbols);
|
||||
if (!q->ce[i]) {
|
||||
goto clean;
|
||||
}
|
||||
q->pusch_x[i] = malloc(sizeof(cf_t) * q->max_symbols);
|
||||
if (!q->pusch_x[i]) {
|
||||
goto clean;
|
||||
}
|
||||
q->pusch_symbols[i] = malloc(sizeof(cf_t) * q->max_symbols);
|
||||
if (!q->pusch_symbols[i]) {
|
||||
goto clean;
|
||||
}
|
||||
}
|
||||
|
||||
ret = LIBLTE_SUCCESS;
|
||||
}
|
||||
clean:
|
||||
if (ret == LIBLTE_ERROR) {
|
||||
pusch_free(q);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void pusch_free(pusch_t *q) {
|
||||
int i;
|
||||
|
||||
if (q->pusch_e) {
|
||||
free(q->pusch_e);
|
||||
}
|
||||
if (q->pusch_d) {
|
||||
free(q->pusch_d);
|
||||
}
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
if (q->ce[i]) {
|
||||
free(q->ce[i]);
|
||||
}
|
||||
if (q->pusch_x[i]) {
|
||||
free(q->pusch_x[i]);
|
||||
}
|
||||
if (q->pusch_symbols[i]) {
|
||||
free(q->pusch_symbols[i]);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < NSUBFRAMES_X_FRAME; i++) {
|
||||
sequence_free(&q->seq_pusch[i]);
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
modem_table_free(&q->mod[i]);
|
||||
}
|
||||
demod_soft_free(&q->demod);
|
||||
sch_free(&q->dl_sch);
|
||||
|
||||
bzero(q, sizeof(pusch_t));
|
||||
|
||||
}
|
||||
|
||||
int pusch_set_rnti(pusch_t *q, uint16_t rnti) {
|
||||
uint32_t i;
|
||||
|
||||
for (i = 0; i < NSUBFRAMES_X_FRAME; i++) {
|
||||
if (sequence_pusch(&q->seq_pusch[i], rnti, 2 * i, q->cell.id,
|
||||
q->max_symbols * lte_mod_bits_x_symbol(LTE_QAM64))) {
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
}
|
||||
q->rnti_is_set = true;
|
||||
q->rnti = rnti;
|
||||
return LIBLTE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/** Decodes the PUSCH from the received symbols
|
||||
*/
|
||||
int pusch_decode(pusch_t *q, cf_t *sf_symbols, cf_t *ce[MAX_PORTS], float noise_estimate, uint8_t *data, uint32_t subframe,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
|
||||
/* Set pointers for layermapping & precoding */
|
||||
uint32_t i, n;
|
||||
cf_t *x[MAX_LAYERS];
|
||||
uint32_t nof_symbols, nof_bits, nof_bits_e;
|
||||
|
||||
if (q != NULL &&
|
||||
sf_symbols != NULL &&
|
||||
data != NULL &&
|
||||
subframe < 10 &&
|
||||
harq_process != NULL)
|
||||
{
|
||||
|
||||
if (q->rnti_is_set) {
|
||||
nof_bits = harq_process->mcs.tbs;
|
||||
nof_symbols = harq_process->prb_alloc.re_sf[subframe];
|
||||
nof_bits_e = nof_symbols * lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
|
||||
INFO("Decoding PUSCH SF: %d, Mod %s, NofBits: %d, NofSymbols: %d, NofBitsE: %d, rv_idx: %d\n",
|
||||
subframe, lte_mod_string(harq_process->mcs.mod), nof_bits, nof_symbols, nof_bits_e, rv_idx);
|
||||
|
||||
/* number of layers equals number of ports */
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
x[i] = q->pusch_x[i];
|
||||
}
|
||||
memset(&x[q->cell.nof_ports], 0, sizeof(cf_t*) * (MAX_LAYERS - q->cell.nof_ports));
|
||||
|
||||
/* extract symbols */
|
||||
n = pusch_get(q, sf_symbols, q->pusch_symbols[0], &harq_process->prb_alloc, subframe);
|
||||
if (n != nof_symbols) {
|
||||
fprintf(stderr, "Error expecting %d symbols but got %d\n", nof_symbols, n);
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
/* extract channel estimates */
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
n = pusch_get(q, ce[i], q->ce[i], &harq_process->prb_alloc, subframe);
|
||||
if (n != nof_symbols) {
|
||||
fprintf(stderr, "Error expecting %d symbols but got %d\n", nof_symbols, n);
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
/* demodulate symbols
|
||||
* The MAX-log-MAP algorithm used in turbo decoding is unsensitive to SNR estimation,
|
||||
* thus we don't need tot set it in the LLRs normalization
|
||||
*/
|
||||
demod_soft_sigma_set(&q->demod, sqrt(0.5));
|
||||
demod_soft_table_set(&q->demod, &q->mod[harq_process->mcs.mod]);
|
||||
demod_soft_demodulate(&q->demod, q->pusch_d, q->pusch_e, nof_symbols);
|
||||
|
||||
/* descramble */
|
||||
scrambling_f_offset(&q->seq_pusch[subframe], q->pusch_e, 0, nof_bits_e);
|
||||
|
||||
return ulsch_decode(&q->dl_sch, q->pusch_e, data, nof_bits, nof_bits_e, harq_process, rv_idx);
|
||||
} else {
|
||||
fprintf(stderr, "Must call pusch_set_rnti() before calling pusch_decode()\n");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
} else {
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
}
|
||||
|
||||
int pusch_encode(pusch_t *q, uint8_t *data, cf_t *sf_symbols[MAX_PORTS], uint32_t subframe,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
uci_data_t uci_data;
|
||||
bzero(&uci_data, sizeof(uci_data_t));
|
||||
return pusch_uci_encode(q, data, uci_data, sf_symbols, subframe, harq_process, rv_idx);
|
||||
}
|
||||
|
||||
/** Converts the PUSCH data bits to symbols mapped to the slot ready for transmission
|
||||
*/
|
||||
int pusch_uci_encode(pusch_t *q, uint8_t *data, uci_data_t uci_data,
|
||||
cf_t *sf_symbols[MAX_PORTS], uint32_t subframe,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
int i;
|
||||
uint32_t nof_symbols, nof_bits_ulsch, nof_bits_e;
|
||||
/* Set pointers for layermapping & precoding */
|
||||
cf_t *x[MAX_LAYERS];
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
|
||||
if (q != NULL &&
|
||||
data != NULL &&
|
||||
subframe < 10 &&
|
||||
harq_process != NULL)
|
||||
{
|
||||
|
||||
if (q->rnti_is_set) {
|
||||
for (i=0;i<q->cell.nof_ports;i++) {
|
||||
if (sf_symbols[i] == NULL) {
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
}
|
||||
|
||||
nof_bits_ulsch = harq_process->mcs.tbs;
|
||||
nof_symbols = 2*harq_process->prb_alloc.slot[0].nof_prb*RE_X_RB*(CP_NSYMB(q->cell.cp)-1);
|
||||
nof_bits_e = nof_symbols * lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
if (harq_process->mcs.tbs == 0) {
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
|
||||
if (nof_bits_ulsch > nof_bits_e) {
|
||||
fprintf(stderr, "Invalid code rate %.2f\n", (float) nof_bits_ulsch / nof_bits_e);
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
|
||||
if (nof_symbols > q->max_symbols) {
|
||||
fprintf(stderr,
|
||||
"Error too many RE per subframe (%d). PUSCH configured for %d RE (%d PRB)\n",
|
||||
nof_symbols, q->max_symbols, q->cell.nof_prb);
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
|
||||
INFO("Encoding PUSCH SF: %d, Mod %s, NofBits: %d, NofSymbols: %d, NofBitsE: %d, rv_idx: %d\n",
|
||||
subframe, lte_mod_string(harq_process->mcs.mod), nof_bits_ulsch, nof_symbols, nof_bits_e, rv_idx);
|
||||
|
||||
/* number of layers equals number of ports */
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
x[i] = q->pusch_x[i];
|
||||
}
|
||||
memset(&x[q->cell.nof_ports], 0, sizeof(cf_t*) * (MAX_LAYERS - q->cell.nof_ports));
|
||||
|
||||
if (ulsch_encode(&q->dl_sch, data, uci_data, q->pusch_e, nof_bits_e,
|
||||
q->pusch_q_ack, q->pusch_q_ri, harq_process, rv_idx))
|
||||
{
|
||||
fprintf(stderr, "Error encoding TB\n");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
scrambling_b_offset_pusch(&q->seq_pusch[subframe], (uint8_t*) q->pusch_e, 0, nof_bits_e);
|
||||
|
||||
mod_modulate(&q->mod[harq_process->mcs.mod], (uint8_t*) q->pusch_e, q->pusch_d, nof_bits_e);
|
||||
|
||||
/* mapping to resource elements */
|
||||
|
||||
for (i = 0; i < q->cell.nof_ports; i++) {
|
||||
pusch_put(q, q->pusch_symbols[i], sf_symbols[i], &harq_process->prb_alloc, subframe);
|
||||
}
|
||||
|
||||
ret = LIBLTE_SUCCESS;
|
||||
} else {
|
||||
fprintf(stderr, "Must call pusch_set_rnti() to set the encoder/decoder RNTI\n");
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -0,0 +1,547 @@
|
||||
/**
|
||||
*
|
||||
* \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 <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "liblte/phy/phch/pusch.h"
|
||||
#include "liblte/phy/phch/sch.h"
|
||||
#include "liblte/phy/phch/uci.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/utils/bit.h"
|
||||
#include "liblte/phy/utils/debug.h"
|
||||
#include "liblte/phy/utils/vector.h"
|
||||
|
||||
|
||||
int sch_init(sch_t *q) {
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
if (q) {
|
||||
bzero(q, sizeof(sch_t));
|
||||
|
||||
if (crc_init(&q->crc_tb, LTE_CRC24A, 24)) {
|
||||
fprintf(stderr, "Error initiating CRC\n");
|
||||
goto clean;
|
||||
}
|
||||
if (crc_init(&q->crc_cb, LTE_CRC24B, 24)) {
|
||||
fprintf(stderr, "Error initiating CRC\n");
|
||||
goto clean;
|
||||
}
|
||||
|
||||
if (tcod_init(&q->encoder, MAX_LONG_CB)) {
|
||||
fprintf(stderr, "Error initiating Turbo Coder\n");
|
||||
goto clean;
|
||||
}
|
||||
if (tdec_init(&q->decoder, MAX_LONG_CB)) {
|
||||
fprintf(stderr, "Error initiating Turbo Decoder\n");
|
||||
goto clean;
|
||||
}
|
||||
|
||||
// Allocate floats for reception (LLRs)
|
||||
q->cb_in = malloc(sizeof(uint8_t) * MAX_LONG_CB);
|
||||
if (!q->cb_in) {
|
||||
goto clean;
|
||||
}
|
||||
|
||||
q->cb_out = malloc(sizeof(float) * (3 * MAX_LONG_CB + 12));
|
||||
if (!q->cb_out) {
|
||||
goto clean;
|
||||
}
|
||||
ret = LIBLTE_SUCCESS;
|
||||
}
|
||||
clean:
|
||||
if (ret == LIBLTE_ERROR) {
|
||||
sch_free(q);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void sch_free(sch_t *q) {
|
||||
if (q->cb_in) {
|
||||
free(q->cb_in);
|
||||
}
|
||||
if (q->cb_out) {
|
||||
free(q->cb_out);
|
||||
}
|
||||
tdec_free(&q->decoder);
|
||||
tcod_free(&q->encoder);
|
||||
|
||||
bzero(q, sizeof(sch_t));
|
||||
}
|
||||
|
||||
|
||||
float sch_average_noi(sch_t *q) {
|
||||
return q->average_nof_iterations;
|
||||
}
|
||||
|
||||
uint32_t sch_last_noi(sch_t *q) {
|
||||
return q->nof_iterations;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Encode a transport block according to 36.212 5.3.2
|
||||
*
|
||||
*/
|
||||
static int encode_tb(sch_t *q, uint8_t *data, uint8_t *e_bits, uint32_t tbs, uint32_t nb_e,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
uint8_t parity[24];
|
||||
uint8_t *p_parity = parity;
|
||||
uint32_t par;
|
||||
uint32_t i;
|
||||
uint32_t cb_len, rp, wp, rlen, F, n_e;
|
||||
int ret = LIBLTE_ERROR_INVALID_INPUTS;
|
||||
uint32_t Qm = lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
if (q != NULL &&
|
||||
data != NULL &&
|
||||
harq_process != NULL)
|
||||
{
|
||||
|
||||
uint32_t Gp = nb_e / Qm;
|
||||
uint32_t gamma = Gp%harq_process->cb_segm.C;
|
||||
|
||||
if (rv_idx == 0) {
|
||||
/* Compute transport block CRC */
|
||||
par = crc_checksum(&q->crc_tb, data, tbs);
|
||||
|
||||
/* parity bits will be appended later */
|
||||
bit_pack(par, &p_parity, 24);
|
||||
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
DEBUG("DATA: ", 0);
|
||||
vec_fprint_b(stdout, data, tbs);
|
||||
DEBUG("PARITY: ", 0);
|
||||
vec_fprint_b(stdout, parity, 24);
|
||||
}
|
||||
}
|
||||
|
||||
wp = 0;
|
||||
rp = 0;
|
||||
for (i = 0; i < harq_process->cb_segm.C; i++) {
|
||||
|
||||
/* Get read lengths */
|
||||
if (i < harq_process->cb_segm.C2) {
|
||||
cb_len = harq_process->cb_segm.K2;
|
||||
} else {
|
||||
cb_len = harq_process->cb_segm.K1;
|
||||
}
|
||||
if (harq_process->cb_segm.C > 1) {
|
||||
rlen = cb_len - 24;
|
||||
} else {
|
||||
rlen = cb_len;
|
||||
}
|
||||
if (i == 0) {
|
||||
F = harq_process->cb_segm.F;
|
||||
} else {
|
||||
F = 0;
|
||||
}
|
||||
if (i <= harq_process->cb_segm.C - gamma - 1) {
|
||||
n_e = Qm * (Gp/harq_process->cb_segm.C);
|
||||
} else {
|
||||
n_e = Qm * ((uint32_t) ceilf((float) Gp/harq_process->cb_segm.C));
|
||||
}
|
||||
|
||||
INFO("CB#%d: cb_len: %d, rlen: %d, wp: %d, rp: %d, F: %d, E: %d\n", i,
|
||||
cb_len, rlen - F, wp, rp, F, n_e);
|
||||
|
||||
if (rv_idx == 0) {
|
||||
|
||||
/* Copy data to another buffer, making space for the Codeblock CRC */
|
||||
if (i < harq_process->cb_segm.C - 1) {
|
||||
// Copy data
|
||||
memcpy(&q->cb_in[F], &data[rp], (rlen - F) * sizeof(uint8_t));
|
||||
} else {
|
||||
INFO("Last CB, appending parity: %d from %d and 24 to %d\n",
|
||||
rlen - F - 24, rp, rlen - 24);
|
||||
/* Append Transport Block parity bits to the last CB */
|
||||
memcpy(&q->cb_in[F], &data[rp], (rlen - 24 - F) * sizeof(uint8_t));
|
||||
memcpy(&q->cb_in[rlen - 24], parity, 24 * sizeof(uint8_t));
|
||||
}
|
||||
/* Filler bits are treated like zeros for the CB CRC calculation */
|
||||
for (int j = 0; j < F; j++) {
|
||||
q->cb_in[j] = 0;
|
||||
}
|
||||
/* Attach Codeblock CRC */
|
||||
if (harq_process->cb_segm.C > 1) {
|
||||
crc_attach(&q->crc_cb, q->cb_in, rlen);
|
||||
}
|
||||
/* Set the filler bits to <NULL> */
|
||||
for (int j = 0; j < F; j++) {
|
||||
q->cb_in[j] = TX_NULL;
|
||||
}
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
DEBUG("CB#%d: ", i);
|
||||
vec_fprint_b(stdout, q->cb_in, cb_len);
|
||||
}
|
||||
|
||||
/* Turbo Encoding */
|
||||
tcod_encode(&q->encoder, q->cb_in, (uint8_t*) q->cb_out, cb_len);
|
||||
}
|
||||
|
||||
/* Rate matching */
|
||||
if (rm_turbo_tx(harq_process->pdsch_w_buff_c[i], harq_process->w_buff_size,
|
||||
(uint8_t*) q->cb_out, 3 * cb_len + 12,
|
||||
&e_bits[wp], n_e, rv_idx))
|
||||
{
|
||||
fprintf(stderr, "Error in rate matching\n");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
/* Set read/write pointers */
|
||||
rp += (rlen - F);
|
||||
wp += n_e;
|
||||
}
|
||||
INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp);
|
||||
|
||||
ret = LIBLTE_SUCCESS;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Decode a transport block according to 36.212 5.3.2
|
||||
*
|
||||
*/
|
||||
static int decode_tb(sch_t *q, float *e_bits, uint8_t *data, uint32_t tbs, uint32_t nb_e,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
uint8_t parity[24];
|
||||
uint8_t *p_parity = parity;
|
||||
uint32_t par_rx, par_tx;
|
||||
uint32_t i;
|
||||
uint32_t cb_len, rp, wp, rlen, F, n_e;
|
||||
uint32_t Qm = lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
if (q != NULL &&
|
||||
data != NULL &&
|
||||
harq_process != NULL)
|
||||
{
|
||||
|
||||
rp = 0;
|
||||
rp = 0;
|
||||
wp = 0;
|
||||
uint32_t Gp = nb_e / Qm;
|
||||
uint32_t gamma = Gp%harq_process->cb_segm.C;
|
||||
bool early_stop = true;
|
||||
for (i = 0; i < harq_process->cb_segm.C && early_stop; i++) {
|
||||
|
||||
/* Get read/write lengths */
|
||||
if (i < harq_process->cb_segm.C2) {
|
||||
cb_len = harq_process->cb_segm.K2;
|
||||
} else {
|
||||
cb_len = harq_process->cb_segm.K1;
|
||||
}
|
||||
if (harq_process->cb_segm.C == 1) {
|
||||
rlen = cb_len;
|
||||
} else {
|
||||
rlen = cb_len - 24;
|
||||
}
|
||||
if (i == 0) {
|
||||
F = harq_process->cb_segm.F;
|
||||
} else {
|
||||
F = 0;
|
||||
}
|
||||
|
||||
if (i <= harq_process->cb_segm.C - gamma - 1) {
|
||||
n_e = Qm * (Gp/harq_process->cb_segm.C);
|
||||
} else {
|
||||
n_e = Qm * ((uint32_t) ceilf((float) Gp/harq_process->cb_segm.C));
|
||||
}
|
||||
|
||||
INFO("CB#%d: cb_len: %d, rlen: %d, wp: %d, rp: %d, F: %d, E: %d\n", i,
|
||||
cb_len, rlen - F, wp, rp, F, n_e);
|
||||
|
||||
/* Rate Unmatching */
|
||||
if (rm_turbo_rx(harq_process->pdsch_w_buff_f[i], harq_process->w_buff_size,
|
||||
&e_bits[rp], n_e,
|
||||
(float*) q->cb_out, 3 * cb_len + 12, rv_idx, F)) {
|
||||
fprintf(stderr, "Error in rate matching\n");
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
DEBUG("CB#%d RMOUT: ", i);
|
||||
vec_fprint_f(stdout, q->cb_out, 3*cb_len+12);
|
||||
}
|
||||
|
||||
/* Turbo Decoding with CRC-based early stopping */
|
||||
q->nof_iterations = 0;
|
||||
uint32_t len_crc;
|
||||
uint8_t *cb_in_ptr;
|
||||
crc_t *crc_ptr;
|
||||
early_stop = false;
|
||||
|
||||
tdec_reset(&q->decoder, cb_len);
|
||||
|
||||
do {
|
||||
tdec_iteration(&q->decoder, (float*) q->cb_out, cb_len);
|
||||
q->nof_iterations++;
|
||||
|
||||
if (harq_process->cb_segm.C > 1) {
|
||||
len_crc = cb_len;
|
||||
cb_in_ptr = q->cb_in;
|
||||
crc_ptr = &q->crc_cb;
|
||||
} else {
|
||||
len_crc = tbs+24;
|
||||
cb_in_ptr = &q->cb_in[F];
|
||||
crc_ptr = &q->crc_tb;
|
||||
}
|
||||
|
||||
tdec_decision(&q->decoder, q->cb_in, cb_len);
|
||||
|
||||
/* Check Codeblock CRC and stop early if incorrect */
|
||||
if (!crc_checksum(crc_ptr, cb_in_ptr, len_crc)) {
|
||||
early_stop = true;
|
||||
}
|
||||
|
||||
} while (q->nof_iterations < TDEC_MAX_ITERATIONS && !early_stop);
|
||||
q->average_nof_iterations = VEC_EMA((float) q->nof_iterations, q->average_nof_iterations, 0.2);
|
||||
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
DEBUG("CB#%d IN: ", i);
|
||||
vec_fprint_b(stdout, q->cb_in, cb_len);
|
||||
}
|
||||
|
||||
// If CB CRC is not correct, early_stop will be false and wont continue with rest of CBs
|
||||
|
||||
/* Copy data to another buffer, removing the Codeblock CRC */
|
||||
if (i < harq_process->cb_segm.C - 1) {
|
||||
memcpy(&data[wp], &q->cb_in[F], (rlen - F) * sizeof(uint8_t));
|
||||
} else {
|
||||
DEBUG("Last CB, appending parity: %d to %d from %d and 24 from %d\n",
|
||||
rlen - F - 24, wp, F, rlen - 24);
|
||||
|
||||
/* Append Transport Block parity bits to the last CB */
|
||||
memcpy(&data[wp], &q->cb_in[F], (rlen - F - 24) * sizeof(uint8_t));
|
||||
memcpy(parity, &q->cb_in[rlen - 24], 24 * sizeof(uint8_t));
|
||||
}
|
||||
|
||||
/* Set read/write pointers */
|
||||
wp += (rlen - F);
|
||||
rp += n_e;
|
||||
}
|
||||
|
||||
if (!early_stop) {
|
||||
INFO("CB %d failed. TB is erroneous.\n",i-1);
|
||||
return LIBLTE_ERROR;
|
||||
} else {
|
||||
INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp);
|
||||
|
||||
// Compute transport block CRC
|
||||
par_rx = crc_checksum(&q->crc_tb, data, tbs);
|
||||
|
||||
// check parity bits
|
||||
par_tx = bit_unpack(&p_parity, 24);
|
||||
|
||||
if (!par_rx) {
|
||||
INFO("\n\tCAUTION!! Received all-zero transport block\n\n", 0);
|
||||
}
|
||||
|
||||
if (par_rx == par_tx) {
|
||||
INFO("TB decoded OK\n",i);
|
||||
return LIBLTE_SUCCESS;
|
||||
} else {
|
||||
INFO("Error in TB parity\n",i);
|
||||
return LIBLTE_ERROR;
|
||||
}
|
||||
|
||||
}
|
||||
} else {
|
||||
return LIBLTE_ERROR_INVALID_INPUTS;
|
||||
}
|
||||
}
|
||||
|
||||
int dlsch_decode(sch_t *q, float *e_bits, uint8_t *data, uint32_t tbs, uint32_t nb_e,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
return decode_tb(q, e_bits, data, tbs, nb_e, harq_process, rv_idx);
|
||||
}
|
||||
|
||||
int dlsch_encode(sch_t *q, uint8_t *data, uint8_t *e_bits, uint32_t tbs, uint32_t nb_e,
|
||||
harq_t *harq_process, uint32_t rv_idx) {
|
||||
return encode_tb(q, data, e_bits, tbs, nb_e, harq_process, rv_idx);
|
||||
}
|
||||
|
||||
int ulsch_decode(sch_t *q, float *e_bits, uint8_t *data, uint32_t tbs, uint32_t nb_e,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
return decode_tb(q, e_bits, data, tbs, nb_e, harq_process, rv_idx);
|
||||
}
|
||||
|
||||
|
||||
uint8_t ulsch_y_idx[10000];
|
||||
uint8_t ulsch_y_mat[10000];
|
||||
|
||||
/* UL-SCH channel interleaver according to 5.5.2.8 of 36.212 */
|
||||
void ulsch_interleave(uint8_t *q_bits, uint32_t nb_q,
|
||||
uint8_t q_bits_ack[6], uint32_t Q_ack,
|
||||
uint8_t q_bits_ri[6], uint32_t Q_ri,
|
||||
uint32_t Q_m)
|
||||
{
|
||||
uint32_t C_mux;
|
||||
uint32_t H_prime;
|
||||
uint32_t H_prime_total;
|
||||
uint32_t R_mux;
|
||||
uint32_t R_prime_mux;
|
||||
uint32_t i;
|
||||
uint32_t j;
|
||||
uint32_t k;
|
||||
uint32_t r;
|
||||
uint32_t idx;
|
||||
uint32_t ri_column_set[4] = {1, 4, 7, 10};
|
||||
uint32_t ack_column_set[4] = {2, 3, 8, 9};
|
||||
uint32_t C_ri;
|
||||
uint32_t C_ack;
|
||||
uint32_t N_pusch_symbs = 12;
|
||||
|
||||
// Step 1: Define C_mux
|
||||
C_mux = N_pusch_symbs;
|
||||
|
||||
// Step 2: Define R_mux and R_prime_mux
|
||||
H_prime = nb_q;
|
||||
H_prime_total = H_prime + Q_ri;
|
||||
R_mux = (H_prime_total*Q_m)/C_mux;
|
||||
R_prime_mux = R_mux/Q_m;
|
||||
|
||||
// Initialize the matricies
|
||||
//printf("Cmux*R_prime=%d*%d=%d\n",C_mux, R_prime_mux, C_mux*R_prime_mux);
|
||||
for(i=0; i<C_mux*R_prime_mux; i++) {
|
||||
ulsch_y_idx[i] = 100;
|
||||
}
|
||||
for(i=0; i<C_mux*R_mux; i++) {
|
||||
ulsch_y_mat[i] = 0;
|
||||
}
|
||||
|
||||
// Step 3: Interleave the RI control bits
|
||||
i = 0;
|
||||
j = 0;
|
||||
r = R_prime_mux-1;
|
||||
while(i < Q_ri) {
|
||||
C_ri = ri_column_set[j];
|
||||
ulsch_y_idx[r*C_mux + C_ri] = 1;
|
||||
for(k=0; k<Q_m; k++) {
|
||||
ulsch_y_mat[(C_mux*r*Q_m) + C_ri*Q_m + k] = q_bits_ri[Q_m*i+k];
|
||||
}
|
||||
i++;
|
||||
r = R_prime_mux - 1 - i/4;
|
||||
j = (j + 3) % 4;
|
||||
}
|
||||
|
||||
// Step 4: Interleave the data bits
|
||||
i = 0;
|
||||
k = 0;
|
||||
while(k < H_prime) {
|
||||
if(ulsch_y_idx[i] == 100) {
|
||||
ulsch_y_idx[i] = 1;
|
||||
for(j=0; j<Q_m; j++) {
|
||||
ulsch_y_mat[i*Q_m + j] = q_bits[Q_m*k+j];
|
||||
}
|
||||
k++;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
// Step 5: Interleave the ACK control bits
|
||||
i = 0;
|
||||
j = 0;
|
||||
r = R_prime_mux-1;
|
||||
while(i < Q_ack/Q_m) {
|
||||
C_ack = ack_column_set[j];
|
||||
ulsch_y_idx[r*C_mux + C_ack] = 2;
|
||||
for(k=0; k<Q_m; k++) {
|
||||
ulsch_y_mat[(C_mux*r*Q_m) + C_ack*Q_m + k] = q_bits_ack[Q_m*i+k];
|
||||
}
|
||||
i++;
|
||||
r = R_prime_mux - 1 - i/4;
|
||||
j = (j + 3) % 4;
|
||||
}
|
||||
|
||||
// Step 6: Read out the bits
|
||||
idx = 0;
|
||||
for(i=0; i<C_mux; i++) {
|
||||
for(j=0; j<R_prime_mux; j++) {
|
||||
for(k=0; k<Q_m; k++) {
|
||||
q_bits[idx++] = ulsch_y_mat[j*C_mux*Q_m + i*Q_m + k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
int ulsch_encode(sch_t *q, uint8_t *data, uci_data_t uci_data, uint8_t *q_bits, uint32_t nb_q,
|
||||
uint8_t *q_bits_ack, uint8_t *q_bits_ri,
|
||||
harq_t *harq_process, uint32_t rv_idx)
|
||||
{
|
||||
int ret;
|
||||
|
||||
uint32_t e_offset = 0;
|
||||
uint32_t Q_prime_ack = 0;
|
||||
uint32_t Q_prime_ri = 0;
|
||||
uint32_t Q_m = lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
// Encode CQI
|
||||
if (uci_data.uci_cqi_len > 0) {
|
||||
ret = uci_encode_cqi(uci_data.uci_cqi, q_bits, uci_data.uci_cqi_len, nb_q);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
e_offset += uci_data.uci_cqi_len;
|
||||
|
||||
// Encode UL-SCH
|
||||
ret = encode_tb(q, data, &q_bits[e_offset], harq_process->mcs.tbs,
|
||||
nb_q, harq_process, rv_idx);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Encode ACK
|
||||
if (uci_data.uci_ack_len > 0) {
|
||||
Q_prime_ack = uci_encode_ri_ack(uci_data.uci_ack, uci_data.beta_ack, q_bits_ack, harq_process);
|
||||
}
|
||||
|
||||
// Encode RI
|
||||
if (uci_data.uci_ri_len > 0) {
|
||||
Q_prime_ri = uci_encode_ri_ack(uci_data.uci_ri, uci_data.beta_ri, q_bits_ri, harq_process);
|
||||
}
|
||||
|
||||
// Multiplexing and Interleaving
|
||||
ulsch_interleave(q_bits, nb_q/Q_m,
|
||||
q_bits_ack, Q_prime_ack,
|
||||
q_bits_ri, Q_prime_ri,
|
||||
Q_m);
|
||||
return LIBLTE_SUCCESS;
|
||||
}
|
||||
|
||||
@ -0,0 +1,89 @@
|
||||
/**
|
||||
*
|
||||
* \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 <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "liblte/phy/phch/uci.h"
|
||||
#include "liblte/phy/phch/harq.h"
|
||||
#include "liblte/phy/common/phy_common.h"
|
||||
#include "liblte/phy/utils/vector.h"
|
||||
|
||||
|
||||
/* Encode UCI-CQI */
|
||||
int uci_encode_cqi(uint8_t *data, uint8_t *e_bits, uint32_t tbs, uint32_t nb_e)
|
||||
{
|
||||
fprintf(stderr, "Not implemented\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static uint32_t Q_prime(uint32_t O, float beta, harq_t *harq_process) {
|
||||
uint32_t M_sc = harq_process->prb_alloc.slot[0].nof_prb * RE_X_RB;
|
||||
|
||||
uint32_t K = harq_process->cb_segm.C1*harq_process->cb_segm.K1 +
|
||||
harq_process->cb_segm.C2*harq_process->cb_segm.K2;
|
||||
uint32_t M_sc_init = harq_process->nof_prb_pusch_init * RE_X_RB;
|
||||
|
||||
uint32_t x = (uint32_t) ceilf((float) O*M_sc_init*harq_process->N_symb_ul*beta/K);
|
||||
|
||||
printf("%d=%d*%d*%d*%f/%d\n",x,O,M_sc_init,harq_process->N_symb_ul,beta,K);
|
||||
|
||||
uint32_t Q_prime = MIN(x, 4*M_sc);
|
||||
|
||||
return Q_prime;
|
||||
}
|
||||
|
||||
/* Encode UCI RI and HARQ bits
|
||||
* Currently only supporting 1-bit RI or 1-bit HARQ
|
||||
*/
|
||||
uint32_t uci_encode_ri_ack(uint8_t data, float beta, uint8_t *q_bits, harq_t *harq_process)
|
||||
{
|
||||
uint8_t Q_m = lte_mod_bits_x_symbol(harq_process->mcs.mod);
|
||||
|
||||
q_bits[0] = data;
|
||||
q_bits[1] = 2;
|
||||
for (int i=2;i<Q_m;i++) {
|
||||
q_bits[i] = 3;
|
||||
}
|
||||
|
||||
uint32_t Qprime = Q_prime(1, beta, harq_process);
|
||||
|
||||
for (int i=1;i<Qprime;i++) {
|
||||
memcpy(&q_bits[i*Q_m], q_bits, Q_m*sizeof(uint8_t));
|
||||
}
|
||||
|
||||
printf("Q_m: %d, Qprime: %d, beta: %f\n", Q_m, Qprime, beta);
|
||||
|
||||
return Qprime * Q_m;
|
||||
}
|
||||
|
||||
@ -0,0 +1,124 @@
|
||||
/**
|
||||
*
|
||||
* \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 "liblte/phy/phy.h"
|
||||
#include "liblte/mex/mexutils.h"
|
||||
|
||||
#define UECFG prhs[0]
|
||||
#define PUSCHCFG prhs[1]
|
||||
#define OUTLEN prhs[2]
|
||||
#define TRBLKIN prhs[3]
|
||||
#define NOF_INPUTS 4
|
||||
|
||||
void help()
|
||||
{
|
||||
mexErrMsgTxt
|
||||
("[cwout] = liblte_dlsch_encode(ue, chs, outlen, trblkin)\n\n");
|
||||
}
|
||||
|
||||
/* the gateway function */
|
||||
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
sch_t dlsch;
|
||||
uint8_t *trblkin;
|
||||
ra_mcs_t mcs;
|
||||
ra_prb_t prb_alloc;
|
||||
harq_t harq_process;
|
||||
uint32_t rv;
|
||||
|
||||
if (nrhs < NOF_INPUTS) {
|
||||
help();
|
||||
return;
|
||||
}
|
||||
|
||||
if (sch_init(&dlsch)) {
|
||||
mexErrMsgTxt("Error initiating DL-SCH\n");
|
||||
return;
|
||||
}
|
||||
lte_cell_t cell;
|
||||
cell.nof_prb = 100;
|
||||
cell.id=1;
|
||||
if (harq_init(&harq_process, cell)) {
|
||||
mexErrMsgTxt("Error initiating HARQ\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mcs.tbs = mexutils_read_uint8(TRBLKIN, &trblkin);
|
||||
if (mcs.tbs == 0) {
|
||||
mexErrMsgTxt("Error trblklen is zero\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (mexutils_read_uint32_struct(PUSCHCFG, "RV", &rv)) {
|
||||
mexErrMsgTxt("Field RV not found in dlsch config\n");
|
||||
return;
|
||||
}
|
||||
|
||||
char *mod_str = mexutils_get_char_struct(PUSCHCFG, "Modulation");
|
||||
|
||||
if (!strcmp(mod_str, "QPSK")) {
|
||||
mcs.mod = LTE_QPSK;
|
||||
} else if (!strcmp(mod_str, "16QAM")) {
|
||||
mcs.mod = LTE_QAM16;
|
||||
} else if (!strcmp(mod_str, "64QAM")) {
|
||||
mcs.mod = LTE_QAM64;
|
||||
} else {
|
||||
mexErrMsgTxt("Unknown modulation\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mxFree(mod_str);
|
||||
|
||||
if (harq_setup(&harq_process, mcs, &prb_alloc)) {
|
||||
mexErrMsgTxt("Error configuring HARQ process\n");
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t nof_bits_e = (uint32_t) mxGetScalar(OUTLEN);
|
||||
uint8_t *e_bits = vec_malloc(nof_bits_e * sizeof(uint8_t));
|
||||
if (!e_bits) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (dlsch_encode(&dlsch, trblkin, e_bits, mcs.tbs, nof_bits_e, &harq_process, rv)) {
|
||||
mexErrMsgTxt("Error encoding TB\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (nlhs >= 1) {
|
||||
mexutils_write_uint8(e_bits, &plhs[0], nof_bits_e, 1);
|
||||
}
|
||||
|
||||
sch_free(&dlsch);
|
||||
|
||||
free(trblkin);
|
||||
free(e_bits);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@ -0,0 +1,259 @@
|
||||
/**
|
||||
*
|
||||
* \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 <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "liblte/phy/phy.h"
|
||||
|
||||
lte_cell_t cell = {
|
||||
6, // nof_prb
|
||||
1, // nof_ports
|
||||
0, // cell_id
|
||||
CPNORM, // cyclic prefix
|
||||
R_1_6, // PHICH resources
|
||||
PHICH_NORM // PHICH length
|
||||
};
|
||||
|
||||
uint32_t cfi = 2;
|
||||
uint32_t tbs = 0;
|
||||
uint32_t subframe = 1;
|
||||
lte_mod_t modulation = LTE_QPSK;
|
||||
uint32_t rv_idx = 0;
|
||||
|
||||
void usage(char *prog) {
|
||||
printf("Usage: %s [cpsrnfvmt] -l TBS \n", prog);
|
||||
printf("\t-m modulation (1: BPSK, 2: QPSK, 3: QAM16, 4: QAM64) [Default BPSK]\n");
|
||||
printf("\t-c cell id [Default %d]\n", cell.id);
|
||||
printf("\t-s subframe [Default %d]\n", subframe);
|
||||
printf("\t-r rv_idx [Default %d]\n", rv_idx);
|
||||
printf("\t-f cfi [Default %d]\n", cfi);
|
||||
printf("\t-p cell.nof_ports [Default %d]\n", cell.nof_ports);
|
||||
printf("\t-n cell.nof_prb [Default %d]\n", cell.nof_prb);
|
||||
printf("\t-v [set verbose to debug, default none]\n");
|
||||
}
|
||||
|
||||
void parse_args(int argc, char **argv) {
|
||||
int opt;
|
||||
while ((opt = getopt(argc, argv, "lcpnfvmtsr")) != -1) {
|
||||
switch(opt) {
|
||||
case 'm':
|
||||
switch(atoi(argv[optind])) {
|
||||
case 1:
|
||||
modulation = LTE_BPSK;
|
||||
break;
|
||||
case 2:
|
||||
modulation = LTE_QPSK;
|
||||
break;
|
||||
case 4:
|
||||
modulation = LTE_QAM16;
|
||||
break;
|
||||
case 6:
|
||||
modulation = LTE_QAM64;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "Invalid modulation %d. Possible values: "
|
||||
"(1: BPSK, 2: QPSK, 3: QAM16, 4: QAM64)\n", atoi(argv[optind]));
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
subframe = atoi(argv[optind]);
|
||||
break;
|
||||
case 'r':
|
||||
rv_idx = atoi(argv[optind]);
|
||||
break;
|
||||
case 'l':
|
||||
tbs = atoi(argv[optind]);
|
||||
break;
|
||||
case 'p':
|
||||
cell.nof_ports = atoi(argv[optind]);
|
||||
break;
|
||||
case 'n':
|
||||
cell.nof_prb = atoi(argv[optind]);
|
||||
break;
|
||||
case 'c':
|
||||
cell.id = atoi(argv[optind]);
|
||||
break;
|
||||
case 'v':
|
||||
verbose++;
|
||||
break;
|
||||
default:
|
||||
usage(argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
if (tbs == 0) {
|
||||
usage(argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
pusch_t pusch;
|
||||
uint32_t i, j;
|
||||
uint8_t *data = NULL;
|
||||
cf_t *ce[MAX_PORTS];
|
||||
uint32_t nof_re;
|
||||
cf_t *slot_symbols[MAX_PORTS];
|
||||
int ret = -1;
|
||||
struct timeval t[3];
|
||||
ra_mcs_t mcs;
|
||||
ra_prb_t prb_alloc;
|
||||
harq_t harq_process;
|
||||
uint32_t rv;
|
||||
|
||||
parse_args(argc,argv);
|
||||
|
||||
nof_re = 2 * CPNORM_NSYMB * cell.nof_prb * RE_X_RB;
|
||||
|
||||
mcs.tbs = tbs;
|
||||
mcs.mod = modulation;
|
||||
|
||||
prb_alloc.slot[0].nof_prb = 1;
|
||||
//for (i=0;i<prb_alloc.slot[0].nof_prb;i++) {
|
||||
// prb_alloc.slot[0].prb_idx[i] = true;
|
||||
//}
|
||||
memcpy(&prb_alloc.slot[1], &prb_alloc.slot[0], sizeof(ra_prb_slot_t));
|
||||
|
||||
/* init memory */
|
||||
for (i=0;i<cell.nof_ports;i++) {
|
||||
ce[i] = malloc(sizeof(cf_t) * nof_re);
|
||||
if (!ce[i]) {
|
||||
perror("malloc");
|
||||
goto quit;
|
||||
}
|
||||
for (j=0;j<nof_re;j++) {
|
||||
ce[i][j] = 1;
|
||||
}
|
||||
slot_symbols[i] = calloc(sizeof(cf_t) , nof_re);
|
||||
if (!slot_symbols[i]) {
|
||||
perror("malloc");
|
||||
goto quit;
|
||||
}
|
||||
}
|
||||
|
||||
data = malloc(sizeof(uint8_t) * mcs.tbs);
|
||||
if (!data) {
|
||||
perror("malloc");
|
||||
goto quit;
|
||||
}
|
||||
|
||||
if (pusch_init(&pusch, cell)) {
|
||||
fprintf(stderr, "Error creating PDSCH object\n");
|
||||
goto quit;
|
||||
}
|
||||
pusch_set_rnti(&pusch, 1234);
|
||||
|
||||
if (harq_init(&harq_process, cell)) {
|
||||
fprintf(stderr, "Error initiating HARQ process\n");
|
||||
goto quit;
|
||||
}
|
||||
|
||||
if (harq_setup(&harq_process, mcs, &prb_alloc)) {
|
||||
fprintf(stderr, "Error configuring HARQ process\n");
|
||||
goto quit;
|
||||
}
|
||||
|
||||
for (i=0;i<mcs.tbs;i++) {
|
||||
data[i] = rand()%2;
|
||||
}
|
||||
|
||||
vec_fprint_b(stdout, data, mcs.tbs);
|
||||
|
||||
for (rv=0;rv<=rv_idx;rv++) {
|
||||
printf("Encoding rv_idx=%d\n",rv);
|
||||
|
||||
uci_data_t uci_data;
|
||||
bzero(&uci_data, sizeof(uci_data_t));
|
||||
uci_data.beta_ack = 2.0;
|
||||
uci_data.uci_ack = 1;
|
||||
uci_data.uci_ack_len = 1;
|
||||
|
||||
uint32_t nof_symbols = 12*harq_process.prb_alloc.slot[0].nof_prb*RE_X_RB;
|
||||
uint32_t nof_bits_e = nof_symbols * lte_mod_bits_x_symbol(harq_process.mcs.mod);
|
||||
|
||||
if (ulsch_encode(&pusch.dl_sch, data, uci_data, pusch.pusch_e, nof_bits_e,
|
||||
pusch.pusch_q_ack, pusch.pusch_q_ri, &harq_process, rv))
|
||||
{
|
||||
fprintf(stderr, "Error encoding TB\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
vec_fprint_b(stdout, pusch.pusch_e, 288);
|
||||
|
||||
/* combine outputs */
|
||||
for (i=0;i<cell.nof_ports;i++) {
|
||||
for (j=0;j<nof_re;j++) {
|
||||
if (i > 0) {
|
||||
slot_symbols[0][j] += slot_symbols[i][j];
|
||||
}
|
||||
ce[i][j] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&t[1], NULL);
|
||||
//int r = pusch_decode(&pusch, slot_symbols[0], ce, 0, data, subframe, &harq_process, rv);
|
||||
int r = 0;
|
||||
gettimeofday(&t[2], NULL);
|
||||
get_time_interval(t);
|
||||
if (r) {
|
||||
printf("Error decoding\n");
|
||||
ret = -1;
|
||||
goto quit;
|
||||
} else {
|
||||
printf("DECODED OK in %d:%d (%.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec, (float) mcs.tbs/t[0].tv_usec);
|
||||
}
|
||||
|
||||
}
|
||||
ret = 0;
|
||||
quit:
|
||||
pusch_free(&pusch);
|
||||
harq_free(&harq_process);
|
||||
|
||||
for (i=0;i<cell.nof_ports;i++) {
|
||||
if (ce[i]) {
|
||||
free(ce[i]);
|
||||
}
|
||||
if (slot_symbols[i]) {
|
||||
free(slot_symbols[i]);
|
||||
}
|
||||
}
|
||||
if (data) {
|
||||
free(data);
|
||||
}
|
||||
if (ret) {
|
||||
printf("Error\n");
|
||||
} else {
|
||||
printf("Ok\n");
|
||||
}
|
||||
exit(ret);
|
||||
}
|
||||
@ -0,0 +1,190 @@
|
||||
/**
|
||||
*
|
||||
* \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 "liblte/phy/phy.h"
|
||||
#include "liblte/mex/mexutils.h"
|
||||
|
||||
#define UECFG prhs[0]
|
||||
#define PUSCHCFG prhs[1]
|
||||
#define TRBLKIN prhs[2]
|
||||
#define CQI prhs[3]
|
||||
#define RI prhs[4]
|
||||
#define ACK prhs[5]
|
||||
#define NOF_INPUTS 6
|
||||
|
||||
void help()
|
||||
{
|
||||
mexErrMsgTxt
|
||||
("[cwout] = liblte_pusch_encode(ue, chs, trblkin, cqi, ri, ack)\n\n");
|
||||
}
|
||||
|
||||
/* the gateway function */
|
||||
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
int i;
|
||||
sch_t ulsch;
|
||||
uint8_t *trblkin;
|
||||
ra_mcs_t mcs;
|
||||
ra_prb_t prb_alloc;
|
||||
harq_t harq_process;
|
||||
uint32_t rv;
|
||||
uci_data_t uci_data;
|
||||
bzero(&uci_data, sizeof(uci_data_t));
|
||||
|
||||
if (nrhs < NOF_INPUTS) {
|
||||
help();
|
||||
return;
|
||||
}
|
||||
if (sch_init(&ulsch)) {
|
||||
mexErrMsgTxt("Error initiating ULSCH\n");
|
||||
return;
|
||||
}
|
||||
lte_cell_t cell;
|
||||
cell.nof_prb = 100;
|
||||
cell.id=1;
|
||||
if (harq_init(&harq_process, cell)) {
|
||||
mexErrMsgTxt("Error initiating HARQ\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mcs.tbs = mexutils_read_uint8(TRBLKIN, &trblkin);
|
||||
if (mcs.tbs == 0) {
|
||||
mexErrMsgTxt("Error trblklen is zero\n");
|
||||
return;
|
||||
}
|
||||
uci_data.uci_cqi_len = mexutils_read_uint8(CQI, &uci_data.uci_cqi);
|
||||
uint8_t *tmp;
|
||||
uci_data.uci_ri_len = mexutils_read_uint8(RI, &tmp);
|
||||
if (uci_data.uci_ri_len > 0) {
|
||||
uci_data.uci_ri = *tmp;
|
||||
}
|
||||
free(tmp);
|
||||
uci_data.uci_ack_len = mexutils_read_uint8(ACK, &tmp);
|
||||
if (uci_data.uci_ack_len > 0) {
|
||||
uci_data.uci_ack = *tmp;
|
||||
}
|
||||
free(tmp);
|
||||
|
||||
mexPrintf("TRBL_len: %d, CQI_len: %d, ACK_len: %d, RI_len: %d\n", mcs.tbs,
|
||||
uci_data.uci_cqi_len, uci_data.uci_ack_len, uci_data.uci_ri_len);
|
||||
|
||||
if (mexutils_read_uint32_struct(PUSCHCFG, "RV", &rv)) {
|
||||
mexErrMsgTxt("Field RV not found in pdsch config\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (mexutils_read_float_struct(PUSCHCFG, "BetaCQI", &uci_data.beta_cqi)) {
|
||||
uci_data.beta_cqi = 2.0;
|
||||
}
|
||||
if (mexutils_read_float_struct(PUSCHCFG, "BetaRI", &uci_data.beta_ri)) {
|
||||
uci_data.beta_ri = 2.0;
|
||||
}
|
||||
if (mexutils_read_float_struct(PUSCHCFG, "BetaACK", &uci_data.beta_ack)) {
|
||||
uci_data.beta_ack = 2.0;
|
||||
}
|
||||
mexPrintf("Beta_CQI: %.1f, Beta_ACK: %.1f, Beta_RI: %.1f\n",
|
||||
uci_data.beta_cqi, uci_data.beta_ack, uci_data.beta_ri);
|
||||
|
||||
char *mod_str = mexutils_get_char_struct(PUSCHCFG, "Modulation");
|
||||
|
||||
if (!strcmp(mod_str, "QPSK")) {
|
||||
mcs.mod = LTE_QPSK;
|
||||
} else if (!strcmp(mod_str, "16QAM")) {
|
||||
mcs.mod = LTE_QAM16;
|
||||
} else if (!strcmp(mod_str, "64QAM")) {
|
||||
mcs.mod = LTE_QAM64;
|
||||
} else {
|
||||
mexErrMsgTxt("Unknown modulation\n");
|
||||
return;
|
||||
}
|
||||
|
||||
mxFree(mod_str);
|
||||
|
||||
float *prbset;
|
||||
mxArray *p;
|
||||
p = mxGetField(PUSCHCFG, 0, "PRBSet");
|
||||
if (!p) {
|
||||
mexErrMsgTxt("Error field PRBSet not found\n");
|
||||
return;
|
||||
}
|
||||
|
||||
prb_alloc.slot[0].nof_prb = mexutils_read_f(p, &prbset);
|
||||
for (i=0;i<MAX_PRB;i++) {
|
||||
prb_alloc.slot[0].prb_idx[i] = false;
|
||||
for (int j=0;j<prb_alloc.slot[0].nof_prb && !prb_alloc.slot[0].prb_idx[i];j++) {
|
||||
if ((int) prbset[j] == i) {
|
||||
prb_alloc.slot[0].prb_idx[i] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
memcpy(&prb_alloc.slot[1], &prb_alloc.slot[0], sizeof(ra_prb_slot_t));
|
||||
|
||||
free(prbset);
|
||||
|
||||
if (harq_setup(&harq_process, mcs, &prb_alloc)) {
|
||||
mexErrMsgTxt("Error configuring HARQ process\n");
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t nof_symbols = 12*harq_process.prb_alloc.slot[0].nof_prb*RE_X_RB;
|
||||
uint32_t nof_q_bits = nof_symbols * lte_mod_bits_x_symbol(harq_process.mcs.mod);
|
||||
|
||||
uint8_t *q_bits = vec_malloc(nof_q_bits * sizeof(uint8_t));
|
||||
if (!q_bits) {
|
||||
return;
|
||||
}
|
||||
uint8_t *q_bits_ack = vec_malloc(nof_q_bits * sizeof(uint8_t));
|
||||
if (!q_bits_ack) {
|
||||
return;
|
||||
}
|
||||
uint8_t *q_bits_ri = vec_malloc(nof_q_bits * sizeof(uint8_t));
|
||||
if (!q_bits_ri) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ulsch_encode(&ulsch, trblkin, uci_data, q_bits, nof_q_bits,
|
||||
q_bits_ack, q_bits_ri, &harq_process, rv))
|
||||
{
|
||||
fprintf(stderr, "Error encoding TB\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (nlhs >= 1) {
|
||||
mexutils_write_uint8(q_bits, &plhs[0], nof_q_bits, 1);
|
||||
}
|
||||
|
||||
sch_free(&ulsch);
|
||||
|
||||
free(trblkin);
|
||||
free(q_bits);
|
||||
free(q_bits_ack);
|
||||
free(q_bits_ri);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@ -0,0 +1,27 @@
|
||||
enbConfig=struct('NCellID',1,'CyclicPrefix','Normal','CellRefP',1);
|
||||
pdschConfig=struct('Modulation','QPSK','RV',0,'TxScheme','Port0');
|
||||
|
||||
addpath('../../debug/lte/phy/lib/phch/test')
|
||||
|
||||
TBs=1:111:15000;
|
||||
e_bits=10000;
|
||||
error=zeros(size(TBs));
|
||||
for i=1:length(TBs)
|
||||
trblkin=randi(2,TBs(i),1)-1;
|
||||
%trblkin=ones(104,1);
|
||||
%trblkin=[1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, ];
|
||||
%trblkin=[1, 0];
|
||||
|
||||
[mat, info]=lteDLSCH(enbConfig,pdschConfig,e_bits,trblkin);
|
||||
lib=liblte_dlsch_encode(enbConfig,pdschConfig,e_bits,trblkin);
|
||||
error(i)=mean(abs(double(mat)-double(lib)));
|
||||
end
|
||||
|
||||
if (length(TBs) == 1)
|
||||
%disp(info)
|
||||
disp(error)
|
||||
n=1:length(mat);
|
||||
plot(abs(double(mat)-double(lib)))
|
||||
else
|
||||
plot(error)
|
||||
end
|
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
@ -0,0 +1,33 @@
|
||||
ueConfig=struct('NCellID',1,'CyclicPrefixUL','Normal','NTxAnts',1);
|
||||
puschConfig=struct('NLayers',1,'OrthCover','Off','PRBSet',0,'Modulation','QPSK','RV',0,'Shortened',0);
|
||||
|
||||
addpath('../../debug/lte/phy/lib/phch/test')
|
||||
|
||||
TBs=104;
|
||||
error=zeros(size(TBs));
|
||||
for i=1:length(error)
|
||||
trblkin=randi(2,TBs(i),1)-1;
|
||||
%trblkin=ones(104,1);
|
||||
%trblkin=[1, 0];
|
||||
|
||||
puschConfig.BetaCQI = 2.0;
|
||||
puschConfig.BetaRI = 2.0;
|
||||
puschConfig.BetaACK = 2.0;
|
||||
|
||||
[mat, info]=lteULSCH(ueConfig,puschConfig,trblkin,[],[],[1],[]);
|
||||
mat(mat==-2)=2;
|
||||
[lib]=liblte_ulsch_encode(ueConfig,puschConfig,trblkin,[],[],[1]);
|
||||
error(i)=sum(abs(double(mat)-double(lib)));
|
||||
if (length(TBs) == 1)
|
||||
disp(error(i))
|
||||
end
|
||||
end
|
||||
|
||||
if (length(TBs) == 1)
|
||||
%disp(info)
|
||||
n=1:length(mat);
|
||||
plot(abs(double(mat)-double(lib)))
|
||||
else
|
||||
plot(error)
|
||||
disp(sum(error))
|
||||
end
|
||||
Loading…
Reference in New Issue