Commit 7bdbd161 authored by Ben Wojtowicz's avatar Ben Wojtowicz

Version 0.9.2: Added support for setting the sample rate and output data type...

Version 0.9.2: Added support for setting the sample rate and output data type in the LTE_fdd_dl_file_gen app and the sample rate and input data type in the LTE_fdd_dl_file_scan app to make the LTE_fdd_dl_file_gen, LTE_fdd_dl_file_scan, and LTE_file_recorder applications compatible, added uplink demodulation reference signal generation to the octave code
parent 4a10f2c7
......@@ -23,7 +23,7 @@
########################################################################
cmake_minimum_required(VERSION 2.6)
project(openLTE CXX C)
set(openLTE_version 0.9.1)
set(openLTE_version 0.9.2)
enable_testing()
#select the release build type by default to get optimization flags
......
......@@ -68,3 +68,9 @@ v00.09.01 Implemented liblte_phy routines for determining TBS, MCS, N_prb, a
checking on sizes passed to memcpy in liblte_rrc, added support for
changing the sample rate in the LTE_fdd_dl_file_gen app, and added
finding FFTW to cmake.
v00.09.02 Added support for setting the sample rate and output data type in the
LTE_fdd_dl_file_gen app and the sample rate and input data type in the
LTE_fdd_dl_file_scan app to make the LTE_fdd_dl_file_gen,
LTE_fdd_dl_file_scan, and LTE_file_recorder applications compatible,
added uplink demodulation reference signal generation to the octave
code.
......@@ -35,6 +35,8 @@
07/21/2013 Ben Wojtowicz Using the latest LTE library.
08/26/2013 Ben Wojtowicz Updates to support GnuRadio 3.7.
09/16/2013 Ben Wojtowicz Added support for changing the sample rate.
09/28/2013 Ben Wojtowicz Added support for setting the sample rate
and output data type.
*******************************************************************************/
......@@ -58,6 +60,7 @@
// Configurable Parameters
#define BANDWIDTH_PARAM "bandwidth"
#define FS_PARAM "fs"
#define FREQ_BAND_PARAM "freq_band"
#define N_FRAMES_PARAM "n_frames"
#define N_ANT_PARAM "n_ant"
......@@ -89,11 +92,16 @@ class LTE_fdd_dl_fg_samp_buf;
typedef boost::shared_ptr<LTE_fdd_dl_fg_samp_buf> LTE_fdd_dl_fg_samp_buf_sptr;
typedef enum{
LTE_FDD_DL_FG_OUT_SIZE_INT8 = 0,
LTE_FDD_DL_FG_OUT_SIZE_GR_COMPLEX,
}LTE_FDD_DL_FG_OUT_SIZE_ENUM;
/*******************************************************************************
CLASS DECLARATIONS
*******************************************************************************/
LTE_FDD_DL_FG_API LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf();
LTE_FDD_DL_FG_API LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf(size_t out_size_val);
class LTE_FDD_DL_FG_API LTE_fdd_dl_fg_samp_buf : public gr::sync_block
{
public:
......@@ -104,9 +112,12 @@ public:
gr_vector_void_star &output_items);
private:
friend LTE_FDD_DL_FG_API LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf();
friend LTE_FDD_DL_FG_API LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf(size_t out_size_val);
LTE_fdd_dl_fg_samp_buf(size_t out_size_val);
LTE_fdd_dl_fg_samp_buf();
// Input parameters
LTE_FDD_DL_FG_OUT_SIZE_ENUM out_size;
// Sample buffer
float *i_buf;
......@@ -152,6 +163,7 @@ private:
void print_config(void);
void change_config(char *line);
bool set_bandwidth(char *char_value);
bool set_fs(char *char_value);
bool set_n_ant(char *char_value);
bool set_n_id_cell(char *char_value);
bool set_mcc(char *char_value);
......
......@@ -15,16 +15,26 @@ class LTE_fdd_dl_file_gen(gr.top_block):
usage = "usage: %prog [options] file"
parser=OptionParser(option_class=eng_option, usage=usage)
# Add options here
parser.add_option("-d", "--data-type", type="string", default="int8",
help="Output file data type, default=%default, options=[int8, gr_complex]")
(options, args) = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
if options.data_type == "gr_complex":
size = gr.sizeof_gr_complex
elif options.data_type == "int8":
size = gr.sizeof_char
else:
print("Invalid data type using int8")
size = gr.sizeof_char
output_filename = args[0]
# Build flow graph
self.samp_buf = LTE_fdd_dl_fg.samp_buf()
self.fsink = blocks.file_sink(gr.sizeof_char, output_filename)
self.samp_buf = LTE_fdd_dl_fg.samp_buf(size)
self.fsink = blocks.file_sink(size, output_filename)
self.connect(self.samp_buf, self.fsink)
if __name__ == '__main__':
......
......@@ -40,6 +40,8 @@
08/26/2013 Ben Wojtowicz Updates to support GnuRadio 3.7 and the
latest LTE library.
09/16/2013 Ben Wojtowicz Added support for changing the sample rate.
09/28/2013 Ben Wojtowicz Added support for setting the sample rate
and output data type.
*******************************************************************************/
......@@ -76,16 +78,26 @@ static const int32 MAX_OUT = 1;
CLASS IMPLEMENTATIONS
*******************************************************************************/
LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf()
LTE_fdd_dl_fg_samp_buf_sptr LTE_fdd_dl_fg_make_samp_buf(size_t out_size_val)
{
return LTE_fdd_dl_fg_samp_buf_sptr(new LTE_fdd_dl_fg_samp_buf());
return LTE_fdd_dl_fg_samp_buf_sptr(new LTE_fdd_dl_fg_samp_buf(out_size_val));
}
LTE_fdd_dl_fg_samp_buf::LTE_fdd_dl_fg_samp_buf()
LTE_fdd_dl_fg_samp_buf::LTE_fdd_dl_fg_samp_buf(size_t out_size_val)
: gr::sync_block ("samp_buf",
gr::io_signature::make(MIN_IN, MAX_IN, sizeof(int8)),
gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof(int8)))
gr::io_signature::make(MIN_OUT, MAX_OUT, out_size_val))
{
// Parse the inputs
if(out_size_val == sizeof(gr_complex))
{
out_size = LTE_FDD_DL_FG_OUT_SIZE_GR_COMPLEX;
}else if(out_size_val == sizeof(int8)){
out_size = LTE_FDD_DL_FG_OUT_SIZE_INT8;
}else{
out_size = LTE_FDD_DL_FG_OUT_SIZE_INT8;
}
// Initialize the LTE parameters
// General
bandwidth = 20;
......@@ -240,23 +252,24 @@ int32 LTE_fdd_dl_fg_samp_buf::work(int32 noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
float i_samp;
float q_samp;
int32 act_noutput_items;
uint32 out_idx;
uint32 loop_cnt;
uint32 i;
uint32 j;
uint32 k;
uint32 p;
uint32 N_sfr;
uint32 last_prb;
uint32 max_N_prb;
size_t line_size = LINE_MAX;
ssize_t N_line_chars;
int8 *out = (int8 *)output_items[0];
char *line;
bool done = false;
gr_complex *gr_complex_out = (gr_complex *)output_items[0];
float i_samp;
float q_samp;
int32 act_noutput_items;
uint32 out_idx;
uint32 loop_cnt;
uint32 i;
uint32 j;
uint32 k;
uint32 p;
uint32 N_sfr;
uint32 last_prb;
uint32 max_N_prb;
size_t line_size = LINE_MAX;
ssize_t N_line_chars;
int8 *int8_out = (int8 *)output_items[0];
char *line;
bool done = false;
line = (char *)malloc(line_size);
if(need_config)
......@@ -265,7 +278,7 @@ int32 LTE_fdd_dl_fg_samp_buf::work(int32 noutput_items,
}
while(need_config)
{
N_line_chars = getline(&line, &line_size, stdin);
N_line_chars = getline(&line, &line_size, stdin);
line[strlen(line)-1] = '\0';
change_config(line);
if(!need_config)
......@@ -554,57 +567,83 @@ int32 LTE_fdd_dl_fg_samp_buf::work(int32 noutput_items,
out_idx = 0;
if(noutput_items > 0)
{
// Write out the first half sample if needed
if(true == last_samp_was_i)
if(LTE_FDD_DL_FG_OUT_SIZE_INT8 == out_size)
{
q_samp = 0;
for(p=0; p<N_ant; p++)
// Write out the first half sample if needed
if(true == last_samp_was_i)
{
q_samp += q_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
q_samp = 0;
for(p=0; p<N_ant; p++)
{
q_samp += q_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
}
int8_out[out_idx++] = (int8)(q_samp);
samp_buf_idx++;
act_noutput_items++;
}
out[out_idx++] = (int8)(q_samp);
samp_buf_idx++;
act_noutput_items++;
}
// Determine how many full samples to write
if((phy_struct->N_samps_per_frame - samp_buf_idx) < ((noutput_items - act_noutput_items) / 2))
{
loop_cnt = (phy_struct->N_samps_per_frame - samp_buf_idx)*2;
}else{
loop_cnt = noutput_items - act_noutput_items;
}
// Determine how many full samples to write
if((phy_struct->N_samps_per_frame - samp_buf_idx) < ((noutput_items - act_noutput_items) / 2))
{
loop_cnt = (phy_struct->N_samps_per_frame - samp_buf_idx)*2;
}else{
loop_cnt = noutput_items - act_noutput_items;
}
// Write out the full samples
for(i=0; i<loop_cnt/2; i++)
{
i_samp = 0;
q_samp = 0;
for(p=0; p<N_ant; p++)
// Write out the full samples
for(i=0; i<loop_cnt/2; i++)
{
i_samp += i_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
q_samp += q_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
i_samp = 0;
q_samp = 0;
for(p=0; p<N_ant; p++)
{
i_samp += i_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
q_samp += q_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
}
int8_out[out_idx++] = (int8)(i_samp);
int8_out[out_idx++] = (int8)(q_samp);
samp_buf_idx++;
act_noutput_items += 2;
}
out[out_idx++] = (int8)(i_samp);
out[out_idx++] = (int8)(q_samp);
samp_buf_idx++;
act_noutput_items += 2;
}
// Write out the last half sample if needed
if((noutput_items - act_noutput_items) == 1)
{
i_samp = 0;
for(p=0; p<N_ant; p++)
{
i_samp += i_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
}
int8_out[out_idx++] = (int8)(i_samp);
act_noutput_items++;
last_samp_was_i = true;
}else{
last_samp_was_i = false;
}
}else{ // LTE_FDD_DL_FG_OUT_SIZE_GR_COMPLEX == out_size
// Determine how many samples to write
if((phy_struct->N_samps_per_frame - samp_buf_idx) < noutput_items)
{
loop_cnt = phy_struct->N_samps_per_frame - samp_buf_idx;
}else{
loop_cnt = noutput_items;
}
// Write out the last half sample if needed
if((noutput_items - act_noutput_items) == 1)
{
i_samp = 0;
for(p=0; p<N_ant; p++)
// Write out samples
for(i=0; i<loop_cnt; i++)
{
i_samp += i_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
i_samp = 0;
q_samp = 0;
for(p=0; p<N_ant; p++)
{
i_samp += i_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
q_samp += q_buf[(p*phy_struct->N_samps_per_frame) + samp_buf_idx];
}
gr_complex_out[out_idx++] = gr_complex(i_samp, q_samp);
samp_buf_idx++;
act_noutput_items++;
}
out[out_idx++] = (int8)(i_samp);
act_noutput_items++;
last_samp_was_i = true;
}else{
last_samp_was_i = false;
}
}
......@@ -734,6 +773,20 @@ void LTE_fdd_dl_fg_samp_buf::print_config(void)
}
printf(", values = [1.4, 3, 5, 10, 15, 20]\n");
// FS
printf("\t%-30s = %10s, values = [",
FS_PARAM,
liblte_phy_fs_text[fs]);
for(i=0; i<LIBLTE_PHY_FS_N_ITEMS; i++)
{
if(0 != i)
{
printf(", ");
}
printf("%s", liblte_phy_fs_text[i]);
}
printf("]\n");
// FREQ_BAND
printf("\t%-30s = %10u, bounds = [1, 25]\n",
FREQ_BAND_PARAM,
......@@ -865,6 +918,8 @@ void LTE_fdd_dl_fg_samp_buf::change_config(char *line)
if(!strcasecmp(param, BANDWIDTH_PARAM))
{
err = set_bandwidth(value);
}else if(!strcasecmp(param, FS_PARAM)){
err = set_fs(value);
}else if(!strcasecmp(param, FREQ_BAND_PARAM)){
err = set_param(&sib1.freq_band_indicator, value, 1, 25);
}else if(!strcasecmp(param, N_FRAMES_PARAM)){
......@@ -928,32 +983,31 @@ bool LTE_fdd_dl_fg_samp_buf::set_bandwidth(char *char_value)
bandwidth = 1.4;
N_rb_dl = LIBLTE_PHY_N_RB_DL_1_4MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_6;
fs = LIBLTE_PHY_FS_1_92MHZ;
}else if(!strcasecmp(char_value, "3")){
}else if(!strcasecmp(char_value, "3") &&
fs >= LIBLTE_PHY_FS_3_84MHZ){
bandwidth = 3;
N_rb_dl = LIBLTE_PHY_N_RB_DL_3MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_15;
fs = LIBLTE_PHY_FS_3_84MHZ;
}else if(!strcasecmp(char_value, "5")){
}else if(!strcasecmp(char_value, "5") &&
fs >= LIBLTE_PHY_FS_7_68MHZ){
bandwidth = 5;
N_rb_dl = LIBLTE_PHY_N_RB_DL_5MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_25;
fs = LIBLTE_PHY_FS_7_68MHZ;
}else if(!strcasecmp(char_value, "10")){
}else if(!strcasecmp(char_value, "10") &&
fs >= LIBLTE_PHY_FS_15_36MHZ){
bandwidth = 10;
N_rb_dl = LIBLTE_PHY_N_RB_DL_10MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_50;
fs = LIBLTE_PHY_FS_15_36MHZ;
}else if(!strcasecmp(char_value, "15")){
}else if(!strcasecmp(char_value, "15") &&
fs == LIBLTE_PHY_FS_30_72MHZ){
bandwidth = 15;
N_rb_dl = LIBLTE_PHY_N_RB_DL_15MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_75;
fs = LIBLTE_PHY_FS_30_72MHZ;
}else if(!strcasecmp(char_value, "20")){
}else if(!strcasecmp(char_value, "20") &&
fs == LIBLTE_PHY_FS_30_72MHZ){
bandwidth = 20;
N_rb_dl = LIBLTE_PHY_N_RB_DL_20MHZ;
mib.dl_bw = LIBLTE_RRC_DL_BANDWIDTH_100;
fs = LIBLTE_PHY_FS_30_72MHZ;
}else{
err = true;
}
......@@ -963,6 +1017,32 @@ bool LTE_fdd_dl_fg_samp_buf::set_bandwidth(char *char_value)
return(err);
}
bool LTE_fdd_dl_fg_samp_buf::set_fs(char *char_value)
{
bool err = false;
if(!strcasecmp(char_value, "1.92") &&
N_rb_dl == LIBLTE_PHY_N_RB_DL_1_4MHZ)
{
fs = LIBLTE_PHY_FS_1_92MHZ;
}else if(!strcasecmp(char_value, "3.84") &&
bandwidth <= 3){
fs = LIBLTE_PHY_FS_3_84MHZ;
}else if(!strcasecmp(char_value, "7.68") &&
bandwidth <= 5){
fs = LIBLTE_PHY_FS_7_68MHZ;
}else if(!strcasecmp(char_value, "15.36") &&
bandwidth <= 10){
fs = LIBLTE_PHY_FS_15_36MHZ;
}else if(!strcasecmp(char_value, "30.72")){
fs = LIBLTE_PHY_FS_30_72MHZ;
}else{
err = true;
}
return(err);
}
bool LTE_fdd_dl_fg_samp_buf::set_n_ant(char *char_value)
{
uint32 value;
......
......@@ -37,6 +37,8 @@
03/17/2013 Ben Wojtowicz Added paging message printing.
07/21/2013 Ben Wojtowicz Using the latest LTE library.
08/26/2013 Ben Wojtowicz Updates to support GnuRadio 3.7.
09/28/2013 Ben Wojtowicz Added support for setting the sample rate
and input data type.
*******************************************************************************/
......@@ -56,10 +58,14 @@
DEFINES
*******************************************************************************/
#define LTE_FDD_DL_FS_SAMP_BUF_SIZE (307200*10)
#define LTE_FDD_DL_FS_SAMP_BUF_SIZE (LIBLTE_PHY_N_SAMPS_PER_FRAME_30_72MHZ*10)
#define LTE_FDD_DL_FS_SAMP_BUF_NUM_FRAMES (10)
#define LTE_FDD_DL_FS_SAMP_BUF_N_DECODED_CHANS_MAX 10
// Configurable Parameters
#define FS_PARAM "fs"
/*******************************************************************************
FORWARD DECLARATIONS
*******************************************************************************/
......@@ -72,6 +78,11 @@ class LTE_fdd_dl_fs_samp_buf;
typedef boost::shared_ptr<LTE_fdd_dl_fs_samp_buf> LTE_fdd_dl_fs_samp_buf_sptr;
typedef enum{
LTE_FDD_DL_FS_IN_SIZE_INT8 = 0,
LTE_FDD_DL_FS_IN_SIZE_GR_COMPLEX,
}LTE_FDD_DL_FS_IN_SIZE_ENUM;
typedef enum{
LTE_FDD_DL_FS_SAMP_BUF_STATE_COARSE_TIMING_SEARCH = 0,
LTE_FDD_DL_FS_SAMP_BUF_STATE_PSS_AND_FINE_TIMING_SEARCH,
......@@ -85,7 +96,7 @@ typedef enum{
CLASS DECLARATIONS
*******************************************************************************/
LTE_FDD_DL_FS_API LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf ();
LTE_FDD_DL_FS_API LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf(size_t in_size_val);
class LTE_FDD_DL_FS_API LTE_fdd_dl_fs_samp_buf : public gr::sync_block
{
public:
......@@ -96,9 +107,12 @@ public:
gr_vector_void_star &output_items);
private:
friend LTE_FDD_DL_FS_API LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf();
friend LTE_FDD_DL_FS_API LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf(size_t in_size_val);
LTE_fdd_dl_fs_samp_buf();
LTE_fdd_dl_fs_samp_buf(size_t in_size_val);
// Input parameters
LTE_FDD_DL_FS_IN_SIZE_ENUM in_size;
// LTE library
LIBLTE_PHY_STRUCT *phy_struct;
......@@ -107,6 +121,7 @@ private:
LIBLTE_RRC_MIB_STRUCT mib;
LIBLTE_RRC_BCCH_DLSCH_MSG_STRUCT bcch_dlsch_msg;
LIBLTE_RRC_PCCH_MSG_STRUCT pcch_msg;
LIBLTE_PHY_FS_ENUM fs;
// Sample buffer
float *i_buf;
......@@ -147,7 +162,7 @@ private:
// Helpers
void init(void);
void copy_input_to_samp_buf(const int8 *in, int32 ninput_items);
void copy_input_to_samp_buf(gr_vector_const_void_star &input_items, int32 ninput_items);
void freq_shift(uint32 start_idx, uint32 num_samps, float freq_offset);
void print_mib(LIBLTE_RRC_MIB_STRUCT *mib);
void print_sib1(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_1_STRUCT *sib1);
......@@ -159,6 +174,12 @@ private:
void print_sib7(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_7_STRUCT *sib7);
void print_sib8(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_8_STRUCT *sib8);
void print_page(LIBLTE_RRC_PAGING_STRUCT *page);
// Configuration
void print_config(void);
void change_config(char *line);
bool set_fs(char *char_value);
bool need_config;
};
#endif /* __LTE_FDD_DL_FS_SAMP_BUF_H__ */
......@@ -15,16 +15,26 @@ class LTE_fdd_dl_file_scan(gr.top_block):
usage = "usage: %prog [options] file"
parser=OptionParser(option_class=eng_option, usage=usage)
# Add options here
parser.add_option("-d", "--data-type", type="string", default="int8",
help="Input file data type, default=%default, options=[int8, gr_complex]")
(options, args) = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
if options.data_type == "gr_complex":
size = gr.sizeof_gr_complex
elif options.data_type == "int8":
size = gr.sizeof_char
else:
print("Invalid data type using int8")
size = gr.sizeof_char
input_filename = args[0]
# Build flow graph
self.fsrc = blocks.file_source(gr.sizeof_char, input_filename, False)
self.samp_buf = LTE_fdd_dl_fs.samp_buf()
self.fsrc = blocks.file_source(size, input_filename, False)
self.samp_buf = LTE_fdd_dl_fs.samp_buf(size)
self.connect(self.fsrc, self.samp_buf)
if __name__ == '__main__':
......
......@@ -45,6 +45,8 @@
07/21/2013 Ben Wojtowicz Fixed a bug and using the latest LTE library.
08/26/2013 Ben Wojtowicz Updates to support GnuRadio 3.7 and the
latest LTE library.
09/28/2013 Ben Wojtowicz Added support for setting the sample rate
and input data type.
*******************************************************************************/
......@@ -61,15 +63,13 @@
DEFINES
*******************************************************************************/
#define ONE_SUBFRAME_NUM_SAMPS (LIBLTE_PHY_N_SAMPS_PER_SUBFR_30_72MHZ)
#define ONE_FRAME_NUM_SAMPS (10 * ONE_SUBFRAME_NUM_SAMPS)
#define COARSE_TIMING_N_SLOTS (20)
#define COARSE_TIMING_SEARCH_NUM_SAMPS (((COARSE_TIMING_N_SLOTS/2)+2) * ONE_SUBFRAME_NUM_SAMPS)
#define PSS_AND_FINE_TIMING_SEARCH_NUM_SAMPS (COARSE_TIMING_SEARCH_NUM_SAMPS)
#define SSS_SEARCH_NUM_SAMPS (COARSE_TIMING_SEARCH_NUM_SAMPS)
#define BCH_DECODE_NUM_SAMPS (2 * ONE_FRAME_NUM_SAMPS)
#define PDSCH_DECODE_SIB1_NUM_SAMPS (2 * ONE_FRAME_NUM_SAMPS)
#define PDSCH_DECODE_SI_GENERIC_NUM_SAMPS (ONE_FRAME_NUM_SAMPS)
#define COARSE_TIMING_N_SLOTS (160)
#define COARSE_TIMING_SEARCH_NUM_SUBFRAMES ((COARSE_TIMING_N_SLOTS/2)+2)
#define PSS_AND_FINE_TIMING_SEARCH_NUM_SUBFRAMES (COARSE_TIMING_SEARCH_NUM_SUBFRAMES)
#define SSS_SEARCH_NUM_SUBFRAMES (COARSE_TIMING_SEARCH_NUM_SUBFRAMES)
#define BCH_DECODE_NUM_FRAMES (2)
#define PDSCH_DECODE_SIB1_NUM_FRAMES (2)
#define PDSCH_DECODE_SI_GENERIC_NUM_FRAMES (1)
/*******************************************************************************
TYPEDEFS
......@@ -90,31 +90,33 @@ static const int32 MAX_OUT = 0;
CLASS IMPLEMENTATIONS
*******************************************************************************/
LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf()
LTE_fdd_dl_fs_samp_buf_sptr LTE_fdd_dl_fs_make_samp_buf(size_t in_size_val)
{
return LTE_fdd_dl_fs_samp_buf_sptr(new LTE_fdd_dl_fs_samp_buf());
return LTE_fdd_dl_fs_samp_buf_sptr(new LTE_fdd_dl_fs_samp_buf(in_size_val));
}
LTE_fdd_dl_fs_samp_buf::LTE_fdd_dl_fs_samp_buf()
LTE_fdd_dl_fs_samp_buf::LTE_fdd_dl_fs_samp_buf(size_t in_size_val)
: gr::sync_block ("samp_buf",
gr::io_signature::make(MIN_IN, MAX_IN, sizeof(int8)),
gr::io_signature::make(MIN_IN, MAX_IN, in_size_val),
gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof(int8)))
{
uint32 i;
// Initialize the LTE library
liblte_phy_init(&phy_struct,
LIBLTE_PHY_FS_30_72MHZ,
LIBLTE_PHY_INIT_N_ID_CELL_UNKNOWN,
4,
LIBLTE_PHY_N_RB_DL_20MHZ,
LIBLTE_PHY_N_SC_RB_NORMAL_CP,
liblte_rrc_phich_resource_num[LIBLTE_RRC_PHICH_RESOURCE_1],
0,
0,
1,
false);
// Parse the inputs
if(in_size_val == sizeof(gr_complex))
{
in_size = LTE_FDD_DL_FS_IN_SIZE_GR_COMPLEX;
}else if(in_size_val == sizeof(int8)){
in_size = LTE_FDD_DL_FS_IN_SIZE_INT8;
}else{
in_size = LTE_FDD_DL_FS_IN_SIZE_INT8;
}
// Initialize the LTE parameters
fs = LIBLTE_PHY_FS_30_72MHZ;
// Initialize the configuration
need_config = true;
// Initialize the sample buffer
i_buf = (float *)malloc(LTE_FDD_DL_FS_SAMP_BUF_SIZE*sizeof(float));
......@@ -150,34 +152,84 @@ int32 LTE_fdd_dl_fs_samp_buf::work(int32 ninput_items,
LIBLTE_PHY_PCFICH_STRUCT pcfich;