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__':
......
......@@ -43,10 +43,20 @@ and specify a recorded LTE file as the input. For example:
$ LTE_fdd_dl_file_scan.py lte_file.bin
The recorded LTE file currently must be interleaved 8-bit I and
Q samples recorded at 30.72MHz. NOTE: Files generated by the
file generator app can be used with the file scanner app only if
generated with 20MHz or 15MHz of bandwidth.
To see a list of options, use the -h option:
$ LTE_fdd_dl_file_scan.py -h
To change the input file data type (int8 or gr_complex), use the
-d/--data-type option:
$ LTE_fdd_dl_file_scan.py -d int8 lte_file.bin
For int8 data type, the recorded LTE file must be interleaved signed
8-bit I and Q samples. For the gr_complex data type, the recorded
LTE file must be sequential gr_complex I/Q samples. Files recorded
with LTE_file_recorder or generated with LTE_fdd_dl_file_gen can be
scanned with this application.
####################
# FILE GENERATOR #
......@@ -62,12 +72,20 @@ For example:
$ LTE_fdd_dl_file_gen.py lte_file.bin
The generated LTE file contains interleaved 8-bit I and Q samples
at a sample rate specified by the bandwidth (i.e. 30.72Msps for
20MHz or 15MHz, 15.36Msps for 10MHz, 7.68MHz for 5MHz, 3.84Msps
for 3MHz, or 1.92Msps for 1.4MHz). The output file can be used as
the input for the LTE_fdd_dl_file_scan application when the
bandwidth is set to 20MHz or 15MHz.
To see a list of options, use the -h option:
$ LTE_fdd_dl_file_gen.py -h
To change the output file data type (int8 or gr_complex), use the
-d/--data-type option:
$ LTE_fdd_dl_file_gen.py -d gr_complex lte_file.bin
For int8 data type, the generated LTE file contains interleaved
signed 8-bit I and Q samples. For the gr_complex data type, the
generated LTE file contains sequential gr_complex I/Q samples.
Files generated with this application can be scanned with
LTE_fdd_dl_file_scan.
#############
# SCANNER #
......@@ -88,9 +106,11 @@ is set to /usr/local/lib (export LD_LIBRARY_PATH=/usr/local/lib),
plug in rtl-sdr or hackrf hardware, run LTE_file_recorder, and connect
(via telnet, nc, etc) to the control port at port number 25000.
Recording parameters can be changed on the control port. For a list
of parameters simply type help on the control port. NOTE: This does
not currently support recording files for use with the file scanner
application.
of parameters simply type help on the control port. File recorded
using hackRF hardware are recorded using a sample rate of 15.36MHz.
Files recorded with all other hardware are recorded using a sample
rate of 1.92MHz. All files recorded with this application can be
scanned with LTE_fdd_dl_file_scan.
############
# OCTAVE #
......
......@@ -52,6 +52,8 @@
be non-ambiguous.
09/16/2013 Ben Wojtowicz Implemented routines for determine TBS, MCS,
N_prb, and N_cce.
09/28/2013 Ben Wojtowicz Reordered sample rate enum and added a text
version.
*******************************************************************************/
......@@ -148,12 +150,14 @@
*******************************************************************************/
typedef enum{
LIBLTE_PHY_FS_30_72MHZ = 0, // 20MHz and 15MHz bandwidths
LIBLTE_PHY_FS_15_36MHZ, // 10MHz bandwidth
LIBLTE_PHY_FS_7_68MHZ, // 5MHz bandwidth
LIBLTE_PHY_FS_3_84MHZ, // 3MHz bandwidth
LIBLTE_PHY_FS_1_92MHZ, // 1.4MHz bandwidth
LIBLTE_PHY_FS_1_92MHZ = 0, // 1.4MHz bandwidth
LIBLTE_PHY_FS_3_84MHZ, // 3MHz bandwidth
LIBLTE_PHY_FS_7_68MHZ, // 5MHz bandwidth
LIBLTE_PHY_FS_15_36MHZ, // 10MHz bandwidth