From d0bf1499bb783c2d950198d4da16a2556b704d7f Mon Sep 17 00:00:00 2001 From: piotr Date: Wed, 5 Feb 2014 17:27:32 +0100 Subject: Coding style change, debug pritfs --- lib/receiver_impl.cc | 1121 +++++++++++++++++++++++++++----------------------- 1 file changed, 607 insertions(+), 514 deletions(-) (limited to 'lib') diff --git a/lib/receiver_impl.cc b/lib/receiver_impl.cc index 689079b..2c2a0c3 100644 --- a/lib/receiver_impl.cc +++ b/lib/receiver_impl.cc @@ -1,17 +1,17 @@ /* -*- c++ -*- */ -/* +/* * Copyright 2014 <+YOU OR YOUR COMPANY+>. - * + * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3, or (at your option) * any later version. - * + * * This software 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 General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this software; see the file COPYING. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, @@ -41,116 +41,136 @@ #define SYNC_SEARCH_RANGE 30 -namespace gr { - namespace gsm { +namespace gr +{ +namespace gsm +{ - typedef std::list list_float; - typedef std::vector vector_float; +typedef std::list list_float; +typedef std::vector vector_float; - typedef boost::circular_buffer circular_buffer_float; +typedef boost::circular_buffer circular_buffer_float; - receiver::sptr - receiver::make(feval_dd * tuner, int osr) - { - return gnuradio::get_initial_sptr - (new receiver_impl(tuner, osr)); - } +receiver::sptr +receiver::make(feval_dd * tuner, int osr) +{ + return gnuradio::get_initial_sptr + (new receiver_impl(tuner, osr)); +} - /* - * The private constructor - */ - receiver_impl::receiver_impl(feval_dd * tuner, int osr) - : gr::block("receiver", - gr::io_signature::make(1, 1, sizeof(gr_complex)), - gr::io_signature::make(0, 1, 142 * sizeof(float))), - d_OSR(osr), - d_chan_imp_length(CHAN_IMP_RESP_LENGTH), - d_tuner(tuner), - d_counter(0), - d_fcch_start_pos(0), - d_freq_offset(0), - d_state(first_fcch_search), - d_burst_nr(osr), - d_failed_sch(0) +/* + * The private constructor + */ +receiver_impl::receiver_impl(feval_dd * tuner, int osr) + : gr::block("receiver", + gr::io_signature::make(1, 1, sizeof(gr_complex)), + gr::io_signature::make(0, 1, 142 * sizeof(float))), + d_OSR(osr), + d_chan_imp_length(CHAN_IMP_RESP_LENGTH), + d_tuner(tuner), + d_counter(0), + d_fcch_start_pos(0), + d_freq_offset(0), + d_state(first_fcch_search), + d_burst_nr(osr), + d_failed_sch(0) +{ + int i; + gmsk_mapper(SYNC_BITS, N_SYNC_BITS, d_sch_training_seq, gr_complex(0.0, -1.0)); + for (i = 0; i < TRAIN_SEQ_NUM; i++) { - int i; - gmsk_mapper(SYNC_BITS, N_SYNC_BITS, d_sch_training_seq, gr_complex(0.0, -1.0)); - for (i = 0; i < TRAIN_SEQ_NUM; i++) { gr_complex startpoint; - if (i == 6 || i == 7) { //this is nasty hack - startpoint = gr_complex(-1.0, 0.0); //if I don't change it here all bits of normal bursts for BTSes with bcc=6 will have reversed values - } else { - startpoint = gr_complex(1.0, 0.0); //I've checked this hack for bcc==0,1,2,3,4,6 + if (i == 6 || i == 7) //this is nasty hack + { + startpoint = gr_complex(-1.0, 0.0); //if I don't change it here all bits of normal bursts for BTSes with bcc=6 will have reversed values + } + else + { + startpoint = gr_complex(1.0, 0.0); //I've checked this hack for bcc==0,1,2,3,4,6 } //I don't know what about bcc==5 and 7 yet //TODO:find source of this situation - this is purely mathematical problem I guess gmsk_mapper(train_seq[i], N_TRAIN_BITS, d_norm_training_seq[i], startpoint); - } } +} - /* - * Our virtual destructor. - */ - receiver_impl::~receiver_impl() - { - } - - void receiver_impl::forecast(int noutput_items, gr_vector_int &ninput_items_required) - { - ninput_items_required[0] = noutput_items * floor((TS_BITS + 2 * GUARD_PERIOD) * d_OSR); - } - - - int - receiver_impl::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) +/* + * Our virtual destructor. + */ +receiver_impl::~receiver_impl() +{ +} + +void receiver_impl::forecast(int noutput_items, gr_vector_int &ninput_items_required) +{ + ninput_items_required[0] = noutput_items * floor((TS_BITS + 2 * GUARD_PERIOD) * d_OSR); +} + + +int +receiver_impl::general_work(int noutput_items, + gr_vector_int &ninput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) +{ + const gr_complex *input = (const gr_complex *) input_items[0]; + //float *out = (float *) output_items[0]; + int produced_out = 0; //how many output elements were produced - this isn't used yet + //probably the gsm receiver will be changed into sink so this variable won't be necessary + switch (d_state) { - const gr_complex *input = (const gr_complex *) input_items[0]; - //float *out = (float *) output_items[0]; - int produced_out = 0; //how many output elements were produced - this isn't used yet - //probably the gsm receiver will be changed into sink so this variable won't be necessary - switch (d_state) { - //bootstrapping - case first_fcch_search: - if (find_fcch_burst(input, ninput_items[0])) { //find frequency correction burst in the input buffer + //bootstrapping + case first_fcch_search: + COUT("FCCH search"); + if (find_fcch_burst(input, ninput_items[0])) //find frequency correction burst in the input buffer + { set_frequency(d_freq_offset); //if fcch search is successful set frequency offset //produced_out = 0; d_state = next_fcch_search; - } else { + } + else + { //produced_out = 0; d_state = first_fcch_search; - } - break; - - case next_fcch_search: { //this state is used because it takes some time (a bunch of buffered samples) - COUT("fcch"); - float prev_freq_offset = d_freq_offset; //before previous set_frequqency cause change - if (find_fcch_burst(input, ninput_items[0])) { - if (abs(prev_freq_offset - d_freq_offset) > FCCH_MAX_FREQ_OFFSET) { + } + break; + + case next_fcch_search: //this state is used because it takes some time (a bunch of buffered samples) + { + COUT("NEXT FCCH search"); + float prev_freq_offset = d_freq_offset; //before previous set_frequqency cause change + if (find_fcch_burst(input, ninput_items[0])) + { + if (abs(prev_freq_offset - d_freq_offset) > FCCH_MAX_FREQ_OFFSET) + { set_frequency(d_freq_offset); //call set_frequncy only frequency offset change is greater than some value - } - //produced_out = 0; - d_state = sch_search; - } else { - //produced_out = 0; - d_state = next_fcch_search; } - break; - } - + //produced_out = 0; + d_state = sch_search; + } + else + { + //produced_out = 0; + d_state = next_fcch_search; + } + break; + } - case sch_search: { - vector_complex channel_imp_resp(CHAN_IMP_RESP_LENGTH*d_OSR); - int t1, t2, t3; - int burst_start = 0; - unsigned char output_binary[BURST_SIZE]; - if (reach_sch_burst(ninput_items[0])) { //wait for a SCH burst - burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]); //get channel impulse response from it - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //detect bits using MLSE detection - if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) { //decode SCH burst + case sch_search: + { + DCOUT("SCH search") ; + vector_complex channel_imp_resp(CHAN_IMP_RESP_LENGTH*d_OSR); + int t1, t2, t3; + int burst_start = 0; + unsigned char output_binary[BURST_SIZE]; + + if (reach_sch_burst(ninput_items[0])) //wait for a SCH burst + { + burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]); //get channel impulse response from it + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //detect bits using MLSE detection + if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) //decode SCH burst + { COUT("sch burst_start: " << burst_start); COUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3); d_burst_nr.set(t1, t2, t3, 0); //set counter of bursts value @@ -165,162 +185,186 @@ namespace gr { consume_each(burst_start + BURST_SIZE * d_OSR); //consume samples up to next guard period d_state = synchronized; - } else { + } + else + { d_state = next_fcch_search; //if there is error in the sch burst go back to fcch search phase - } - } else { - d_state = sch_search; } - break; - } - //in this state receiver is synchronized and it processes bursts according to burst type for given burst number - case synchronized: { - vector_complex channel_imp_resp(CHAN_IMP_RESP_LENGTH*d_OSR); - int burst_start; - int offset = 0; - int to_consume = 0; - unsigned char output_binary[BURST_SIZE]; - - burst_type b_type = d_channel_conf.get_burst_type(d_burst_nr); //get burst type for given burst number - - switch (b_type) { - case fcch_burst: { //if it's FCCH burst - const unsigned first_sample = ceil((GUARD_PERIOD + 2 * TAIL_BITS) * d_OSR) + 1; - const unsigned last_sample = first_sample + USEFUL_BITS * d_OSR - TAIL_BITS * d_OSR; - double freq_offset = compute_freq_offset(input, first_sample, last_sample); //extract frequency offset from it - - d_freq_offset_vals.push_front(freq_offset); - //process_normal_burst(d_burst_nr, fc_fb); - if (d_freq_offset_vals.size() >= 10) { - double sum = std::accumulate(d_freq_offset_vals.begin(), d_freq_offset_vals.end(), 0); - double mean_offset = sum / d_freq_offset_vals.size(); //compute mean - d_freq_offset_vals.clear(); - if (abs(mean_offset) > FCCH_MAX_FREQ_OFFSET) { - d_freq_offset -= mean_offset; //and adjust frequency if it have changed beyond - set_frequency(d_freq_offset); //some limit - DCOUT("mean_offset: " << mean_offset); - DCOUT("Adjusting frequency, new frequency offset: " << d_freq_offset << "\n"); - } - } + } + else + { + d_state = sch_search; + } + break; + } + //in this state receiver is synchronized and it processes bursts according to burst type for given burst number + case synchronized: + { + DCOUT("Synchronized") ; + vector_complex channel_imp_resp(CHAN_IMP_RESP_LENGTH*d_OSR); + int burst_start; + int offset = 0; + int to_consume = 0; + unsigned char output_binary[BURST_SIZE]; + + burst_type b_type = d_channel_conf.get_burst_type(d_burst_nr); //get burst type for given burst number + + switch (b_type) + { + case fcch_burst: //if it's FCCH burst + { + const unsigned first_sample = ceil((GUARD_PERIOD + 2 * TAIL_BITS) * d_OSR) + 1; + const unsigned last_sample = first_sample + USEFUL_BITS * d_OSR - TAIL_BITS * d_OSR; + double freq_offset = compute_freq_offset(input, first_sample, last_sample); //extract frequency offset from it + + d_freq_offset_vals.push_front(freq_offset); + process_normal_burst(d_burst_nr, fc_fb); + if (d_freq_offset_vals.size() >= 10) + { + double sum = std::accumulate(d_freq_offset_vals.begin(), d_freq_offset_vals.end(), 0); + double mean_offset = sum / d_freq_offset_vals.size(); //compute mean + d_freq_offset_vals.clear(); + if (abs(mean_offset) > FCCH_MAX_FREQ_OFFSET) + { + d_freq_offset -= mean_offset; //and adjust frequency if it have changed beyond + set_frequency(d_freq_offset); //some limit + DCOUT("mean_offset: " << mean_offset); + DCOUT("Adjusting frequency, new frequency offset: " << d_freq_offset << "\n"); } - break; - case sch_burst: { //if it's SCH burst - int t1, t2, t3, d_ncc, d_bcc; - burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]); //get channel impulse response - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //MLSE detection of bits - //process_normal_burst(d_burst_nr, output_binary); - if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) { //and decode SCH data - // d_burst_nr.set(t1, t2, t3, 0); //but only to check if burst_start value is correct - d_failed_sch = 0; - DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3); - offset = burst_start - floor((GUARD_PERIOD) * d_OSR); //compute offset from burst_start - burst should start after a guard period - DCOUT(offset); - to_consume += offset; //adjust with offset number of samples to be consumed - } else { - d_failed_sch++; - if (d_failed_sch >= MAX_SCH_ERRORS) { - // d_state = next_fcch_search; //TODO: this isn't good, the receiver is going wild when it goes back to next_fcch_search from here - // d_freq_offset_vals.clear(); - DCOUT("many sch decoding errors"); - } - } + } + } + break; + case sch_burst: //if it's SCH burst + { + int t1, t2, t3, d_ncc, d_bcc; + burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]); //get channel impulse response + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //MLSE detection of bits + process_normal_burst(d_burst_nr, output_binary); + if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) //and decode SCH data + { + // d_burst_nr.set(t1, t2, t3, 0); //but only to check if burst_start value is correct + d_failed_sch = 0; + DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3); + offset = burst_start - floor((GUARD_PERIOD) * d_OSR); //compute offset from burst_start - burst should start after a guard period + DCOUT(offset); + to_consume += offset; //adjust with offset number of samples to be consumed + } + else + { + d_failed_sch++; + if (d_failed_sch >= MAX_SCH_ERRORS) + { + d_state = first_fcch_search; //TODO: this isn't good, the receiver is going wild when it goes back to next_fcch_search from here + d_freq_offset_vals.clear(); + d_freq_offset=0; + set_frequency(0); + DCOUT("many sch decoding errors"); } - break; - - case normal_burst: //if it's normal burst - burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc); //get channel impulse response for given training sequence number - d_bcc - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //MLSE detection of bits - process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready - break; + } + } + break; - case dummy_or_normal: { - burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], TS_DUMMY); - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); - - std::vector v(20); - std::vector::iterator it; - it = std::set_difference(output_binary + TRAIN_POS, output_binary + TRAIN_POS + 16, &train_seq[TS_DUMMY][5], &train_seq[TS_DUMMY][21], v.begin()); - int different_bits = (it - v.begin()); - - if (different_bits > 2) { - burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc); - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); - //if (!output_binary[0] && !output_binary[1] && !output_binary[2]) { - COUT("Normal burst"); - process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready - //} - } else { - //process_normal_burst(d_burst_nr, dummy_burst); - } - } - case rach_burst: - //implementation of this channel isn't possible in current gsm_receiver - //it would take some realtime processing, counter of samples from USRP to - //stay synchronized with this device and possibility to switch frequency from uplink - //to C0 (where sch is) back and forth + case normal_burst: //if it's normal burst + burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc); //get channel impulse response for given training sequence number - d_bcc + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //MLSE detection of bits + process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready + break; - break; - case dummy: //if it's dummy - burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], TS_DUMMY); //read dummy - detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); // but as far as I know it's pointless - break; - case empty: //if it's empty burst - break; //do nothing + case dummy_or_normal: + { + burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], TS_DUMMY); + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); + + std::vector v(20); + std::vector::iterator it; + it = std::set_difference(output_binary + TRAIN_POS, output_binary + TRAIN_POS + 16, &train_seq[TS_DUMMY][5], &train_seq[TS_DUMMY][21], v.begin()); + int different_bits = (it - v.begin()); + + if (different_bits > 2) + { + burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc); + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); + //if (!output_binary[0] && !output_binary[1] && !output_binary[2]) { + // COUT("Normal burst"); + process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready + //} + } + else + { + process_normal_burst(d_burst_nr, dummy_burst); } + } + case rach_burst: + //implementation of this channel isn't possible in current gsm_receiver + //it would take some realtime processing, counter of samples from USRP to + //stay synchronized with this device and possibility to switch frequency from uplink + //to C0 (where sch is) back and forth - d_burst_nr++; //go to next burst + break; + case dummy: //if it's dummy + burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], TS_DUMMY); //read dummy + detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); // but as far as I know it's pointless + break; + case empty: //if it's empty burst + break; //do nothing + } - to_consume += TS_BITS * d_OSR + d_burst_nr.get_offset(); //consume samples of the burst up to next guard period - //and add offset which is introduced by - //0.25 fractional part of a guard period - //burst_number computes this offset - //but choice of this class to do this was random - consume_each(to_consume); - } - break; - } + d_burst_nr++; //go to next burst - return produced_out; + to_consume += TS_BITS * d_OSR + d_burst_nr.get_offset(); //consume samples of the burst up to next guard period + //and add offset which is introduced by + //0.25 fractional part of a guard period + //burst_number computes this offset + //but choice of this class to do this was random + consume_each(to_consume); + } + break; } - - bool receiver_impl::find_fcch_burst(const gr_complex *input, const int nitems) + return produced_out; +} + + +bool receiver_impl::find_fcch_burst(const gr_complex *input, const int nitems) +{ + circular_buffer_float phase_diff_buffer(FCCH_HITS_NEEDED * d_OSR); //circular buffer used to scan throug signal to find + //best match for FCCH burst + float phase_diff = 0; + gr_complex conjprod; + int start_pos = -1; + int hit_count = 0; + int miss_count = 0; + float min_phase_diff; + float max_phase_diff; + double best_sum = 0; + float lowest_max_min_diff = 99999; + + int to_consume = 0; + int sample_number = 0; + bool end = false; + bool result = false; + circular_buffer_float::iterator buffer_iter; + + /**@name Possible states of FCCH search algorithm*/ + //@{ + enum states { - circular_buffer_float phase_diff_buffer(FCCH_HITS_NEEDED * d_OSR); //circular buffer used to scan throug signal to find - //best match for FCCH burst - float phase_diff = 0; - gr_complex conjprod; - int start_pos = -1; - int hit_count = 0; - int miss_count = 0; - float min_phase_diff; - float max_phase_diff; - double best_sum = 0; - float lowest_max_min_diff = 99999; - - int to_consume = 0; - int sample_number = 0; - bool end = false; - bool result = false; - circular_buffer_float::iterator buffer_iter; - - /**@name Possible states of FCCH search algorithm*/ - //@{ - enum states { init, ///< initialize variables search, ///< search for positive samples found_something, ///< search for FCCH and the best position of it fcch_found, ///< when FCCH was found search_fail ///< when there is no FCCH in the input vector - } fcch_search_state; - //@} + } fcch_search_state; + //@} - fcch_search_state = init; + fcch_search_state = init; - while (!end) { - switch (fcch_search_state) { + while (!end) + { + switch (fcch_search_state) + { - case init: //initialize variables + case init: //initialize variables hit_count = 0; miss_count = 0; start_pos = -1; @@ -330,250 +374,286 @@ namespace gr { break; - case search: // search for positive samples + case search: // search for positive samples sample_number++; - if (sample_number > nitems - FCCH_HITS_NEEDED * d_OSR) { //if it isn't possible to find FCCH because - //there's too few samples left to look into, - to_consume = sample_number; //don't do anything with those samples which are left - //and consume only those which were checked - fcch_search_state = search_fail; - } else { - phase_diff = compute_phase_diff(input[sample_number], input[sample_number-1]); - - if (phase_diff > 0) { //if a positive phase difference was found - to_consume = sample_number; - fcch_search_state = found_something; //switch to state in which searches for FCCH - } else { - fcch_search_state = search; - } + if (sample_number > nitems - FCCH_HITS_NEEDED * d_OSR) //if it isn't possible to find FCCH because + { + //there's too few samples left to look into, + to_consume = sample_number; //don't do anything with those samples which are left + //and consume only those which were checked + fcch_search_state = search_fail; + } + else + { + phase_diff = compute_phase_diff(input[sample_number], input[sample_number-1]); + + if (phase_diff > 0) //if a positive phase difference was found + { + to_consume = sample_number; + fcch_search_state = found_something; //switch to state in which searches for FCCH + } + else + { + fcch_search_state = search; + } } break; - case found_something: {// search for FCCH and the best position of it - if (phase_diff > 0) { + case found_something: // search for FCCH and the best position of it + { + if (phase_diff > 0) + { hit_count++; //positive phase differencies increases hits_count - } else { + } + else + { miss_count++; //negative increases miss_count - } + } - if ((miss_count >= FCCH_MAX_MISSES * d_OSR) && (hit_count <= FCCH_HITS_NEEDED * d_OSR)) { + if ((miss_count >= FCCH_MAX_MISSES * d_OSR) && (hit_count <= FCCH_HITS_NEEDED * d_OSR)) + { //if miss_count exceeds limit before hit_count fcch_search_state = init; //go to init continue; - } else if (((miss_count >= FCCH_MAX_MISSES * d_OSR) && (hit_count > FCCH_HITS_NEEDED * d_OSR)) || (hit_count > 2 * FCCH_HITS_NEEDED * d_OSR)) { + } + else if (((miss_count >= FCCH_MAX_MISSES * d_OSR) && (hit_count > FCCH_HITS_NEEDED * d_OSR)) || (hit_count > 2 * FCCH_HITS_NEEDED * d_OSR)) + { //if hit_count and miss_count exceeds limit then FCCH was found fcch_search_state = fcch_found; continue; - } else if ((miss_count < FCCH_MAX_MISSES * d_OSR) && (hit_count > FCCH_HITS_NEEDED * d_OSR)) { + } + else if ((miss_count < FCCH_MAX_MISSES * d_OSR) && (hit_count > FCCH_HITS_NEEDED * d_OSR)) + { //find difference between minimal and maximal element in the buffer //for FCCH this value should be low //this part is searching for a region where this value is lowest min_phase_diff = * (min_element(phase_diff_buffer.begin(), phase_diff_buffer.end())); max_phase_diff = * (max_element(phase_diff_buffer.begin(), phase_diff_buffer.end())); - if (lowest_max_min_diff > max_phase_diff - min_phase_diff) { - lowest_max_min_diff = max_phase_diff - min_phase_diff; - start_pos = sample_number - FCCH_HITS_NEEDED * d_OSR - FCCH_MAX_MISSES * d_OSR; //store start pos - best_sum = 0; - - for (buffer_iter = phase_diff_buffer.begin(); - buffer_iter != (phase_diff_buffer.end()); - buffer_iter++) { - best_sum += *buffer_iter - (M_PI / 2) / d_OSR; //store best value of phase offset sum - } + if (lowest_max_min_diff > max_phase_diff - min_phase_diff) + { + lowest_max_min_diff = max_phase_diff - min_phase_diff; + start_pos = sample_number - FCCH_HITS_NEEDED * d_OSR - FCCH_MAX_MISSES * d_OSR; //store start pos + best_sum = 0; + + for (buffer_iter = phase_diff_buffer.begin(); + buffer_iter != (phase_diff_buffer.end()); + buffer_iter++) + { + best_sum += *buffer_iter - (M_PI / 2) / d_OSR; //store best value of phase offset sum + } } - } + } - sample_number++; + sample_number++; - if (sample_number >= nitems) { //if there's no single sample left to check + if (sample_number >= nitems) //if there's no single sample left to check + { fcch_search_state = search_fail;//FCCH search failed continue; - } - - phase_diff = compute_phase_diff(input[sample_number], input[sample_number-1]); - phase_diff_buffer.push_back(phase_diff); - fcch_search_state = found_something; } - break; - case fcch_found: { - DCOUT("fcch found on position: " << d_counter + start_pos); - to_consume = start_pos + FCCH_HITS_NEEDED * d_OSR + 1; //consume one FCCH burst + phase_diff = compute_phase_diff(input[sample_number], input[sample_number-1]); + phase_diff_buffer.push_back(phase_diff); + fcch_search_state = found_something; + } + break; - d_fcch_start_pos = d_counter + start_pos; + case fcch_found: + { + DCOUT("fcch found on position: " << d_counter + start_pos); + to_consume = start_pos + FCCH_HITS_NEEDED * d_OSR + 1; //consume one FCCH burst - //compute frequency offset - double phase_offset = best_sum / FCCH_HITS_NEEDED; - double freq_offset = phase_offset * 1625000.0 / (12.0 * M_PI); - d_freq_offset -= freq_offset; - DCOUT("freq_offset: " << d_freq_offset); + d_fcch_start_pos = d_counter + start_pos; - end = true; - result = true; - break; - } + //compute frequency offset + double phase_offset = best_sum / FCCH_HITS_NEEDED; + double freq_offset = phase_offset * 1625000.0 / (12.0 * M_PI); + d_freq_offset -= freq_offset; + DCOUT("freq_offset: " << d_freq_offset); - case search_fail: end = true; - result = false; + result = true; break; } - } - - d_counter += to_consume; - consume_each(to_consume); - return result; + case search_fail: + end = true; + result = false; + break; + } } + d_counter += to_consume; + consume_each(to_consume); - double receiver_impl::compute_freq_offset(const gr_complex * input, unsigned first_sample, unsigned last_sample) - { - double phase_sum = 0; - unsigned ii; - - for (ii = first_sample; ii < last_sample; ii++) { - double phase_diff = compute_phase_diff(input[ii], input[ii-1]) - (M_PI / 2) / d_OSR; - phase_sum += phase_diff; - } + return result; +} - double phase_offset = phase_sum / (last_sample - first_sample); - double freq_offset = phase_offset * 1625000.0 / (12.0 * M_PI); - return freq_offset; - } - void receiver_impl::set_frequency(double freq_offset) - { - d_tuner->calleval(freq_offset); - } +double receiver_impl::compute_freq_offset(const gr_complex * input, unsigned first_sample, unsigned last_sample) +{ + double phase_sum = 0; + unsigned ii; - inline float receiver_impl::compute_phase_diff(gr_complex val1, gr_complex val2) + for (ii = first_sample; ii < last_sample; ii++) { - gr_complex conjprod = val1 * conj(val2); - return fast_atan2f(imag(conjprod), real(conjprod)); + double phase_diff = compute_phase_diff(input[ii], input[ii-1]) - (M_PI / 2) / d_OSR; + phase_sum += phase_diff; } - bool receiver_impl::reach_sch_burst(const int nitems) + double phase_offset = phase_sum / (last_sample - first_sample); + double freq_offset = phase_offset * 1625000.0 / (12.0 * M_PI); + return freq_offset; +} + +void receiver_impl::set_frequency(double freq_offset) +{ + d_tuner->calleval(freq_offset); +} + +inline float receiver_impl::compute_phase_diff(gr_complex val1, gr_complex val2) +{ + gr_complex conjprod = val1 * conj(val2); + return fast_atan2f(imag(conjprod), real(conjprod)); +} + +bool receiver_impl::reach_sch_burst(const int nitems) +{ + //it just consumes samples to get near to a SCH burst + int to_consume = 0; + bool result = false; + unsigned sample_nr_near_sch_start = d_fcch_start_pos + (FRAME_BITS - SAFETY_MARGIN) * d_OSR; + + //consume samples until d_counter will be equal to sample_nr_near_sch_start + if (d_counter < sample_nr_near_sch_start) { - //it just consumes samples to get near to a SCH burst - int to_consume = 0; - bool result = false; - unsigned sample_nr_near_sch_start = d_fcch_start_pos + (FRAME_BITS - SAFETY_MARGIN) * d_OSR; - - //consume samples until d_counter will be equal to sample_nr_near_sch_start - if (d_counter < sample_nr_near_sch_start) { - if (d_counter + nitems >= sample_nr_near_sch_start) { - to_consume = sample_nr_near_sch_start - d_counter; - } else { - to_consume = nitems; + if (d_counter + nitems >= sample_nr_near_sch_start) + { + to_consume = sample_nr_near_sch_start - d_counter; + } + else + { + to_consume = nitems; } result = false; - } else { + } + else + { to_consume = 0; result = true; - } - - d_counter += to_consume; - consume_each(to_consume); - return result; } - int receiver_impl::get_sch_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp) - { - vector_complex correlation_buffer; - vector_float power_buffer; - vector_float window_energy_buffer; + d_counter += to_consume; + consume_each(to_consume); + return result; +} + +int receiver_impl::get_sch_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp) +{ + vector_complex correlation_buffer; + vector_float power_buffer; + vector_float window_energy_buffer; - int strongest_window_nr; - int burst_start = 0; - int chan_imp_resp_center = 0; - float max_correlation = 0; - float energy = 0; + int strongest_window_nr; + int burst_start = 0; + int chan_imp_resp_center = 0; + float max_correlation = 0; + float energy = 0; - for (int ii = SYNC_POS * d_OSR; ii < (SYNC_POS + SYNC_SEARCH_RANGE) *d_OSR; ii++) { + for (int ii = SYNC_POS * d_OSR; ii < (SYNC_POS + SYNC_SEARCH_RANGE) *d_OSR; ii++) + { gr_complex correlation = correlate_sequence(&d_sch_training_seq[5], N_SYNC_BITS - 10, &input[ii]); correlation_buffer.push_back(correlation); power_buffer.push_back(std::pow(abs(correlation), 2)); - } + } - //compute window energies - vector_float::iterator iter = power_buffer.begin(); - bool loop_end = false; - while (iter != power_buffer.end()) { + //compute window energies + vector_float::iterator iter = power_buffer.begin(); + bool loop_end = false; + while (iter != power_buffer.end()) + { vector_float::iterator iter_ii = iter; energy = 0; - for (int ii = 0; ii < (d_chan_imp_length) *d_OSR; ii++, iter_ii++) { - if (iter_ii == power_buffer.end()) { - loop_end = true; - break; - } - energy += (*iter_ii); + for (int ii = 0; ii < (d_chan_imp_length) *d_OSR; ii++, iter_ii++) + { + if (iter_ii == power_buffer.end()) + { + loop_end = true; + break; + } + energy += (*iter_ii); } - if (loop_end) { - break; + if (loop_end) + { + break; } iter++; window_energy_buffer.push_back(energy); - } + } - strongest_window_nr = max_element(window_energy_buffer.begin(), window_energy_buffer.end()) - window_energy_buffer.begin(); + strongest_window_nr = max_element(window_energy_buffer.begin(), window_energy_buffer.end()) - window_energy_buffer.begin(); // d_channel_imp_resp.clear(); - max_correlation = 0; - for (int ii = 0; ii < (d_chan_imp_length) *d_OSR; ii++) { + max_correlation = 0; + for (int ii = 0; ii < (d_chan_imp_length) *d_OSR; ii++) + { gr_complex correlation = correlation_buffer[strongest_window_nr + ii]; - if (abs(correlation) > max_correlation) { - chan_imp_resp_center = ii; - max_correlation = abs(correlation); + if (abs(correlation) > max_correlation) + { + chan_imp_resp_center = ii; + max_correlation = abs(correlation); } - // d_channel_imp_resp.push_back(correlation); + // d_channel_imp_resp.push_back(correlation); chan_imp_resp[ii] = correlation; - } - - burst_start = strongest_window_nr + chan_imp_resp_center - 48 * d_OSR - 2 * d_OSR + 2 + SYNC_POS * d_OSR; - return burst_start; } + burst_start = strongest_window_nr + chan_imp_resp_center - 48 * d_OSR - 2 * d_OSR + 2 + SYNC_POS * d_OSR; + return burst_start; +} + - void receiver_impl::detect_burst(const gr_complex * input, gr_complex * chan_imp_resp, int burst_start, unsigned char * output_binary) +void receiver_impl::detect_burst(const gr_complex * input, gr_complex * chan_imp_resp, int burst_start, unsigned char * output_binary) +{ + float output[BURST_SIZE]; + gr_complex rhh_temp[CHAN_IMP_RESP_LENGTH*d_OSR]; + gr_complex rhh[CHAN_IMP_RESP_LENGTH]; + gr_complex filtered_burst[BURST_SIZE]; + int start_state = 3; + unsigned int stop_states[2] = {4, 12}; + + autocorrelation(chan_imp_resp, rhh_temp, d_chan_imp_length*d_OSR); + for (int ii = 0; ii < (d_chan_imp_length); ii++) { - float output[BURST_SIZE]; - gr_complex rhh_temp[CHAN_IMP_RESP_LENGTH*d_OSR]; - gr_complex rhh[CHAN_IMP_RESP_LENGTH]; - gr_complex filtered_burst[BURST_SIZE]; - int start_state = 3; - unsigned int stop_states[2] = {4, 12}; - - autocorrelation(chan_imp_resp, rhh_temp, d_chan_imp_length*d_OSR); - for (int ii = 0; ii < (d_chan_imp_length); ii++) { rhh[ii] = conj(rhh_temp[ii*d_OSR]); - } + } - mafi(&input[burst_start], BURST_SIZE, chan_imp_resp, d_chan_imp_length*d_OSR, filtered_burst); + mafi(&input[burst_start], BURST_SIZE, chan_imp_resp, d_chan_imp_length*d_OSR, filtered_burst); - viterbi_detector(filtered_burst, BURST_SIZE, rhh, start_state, stop_states, 2, output); + viterbi_detector(filtered_burst, BURST_SIZE, rhh, start_state, stop_states, 2, output); - for (int i = 0; i < BURST_SIZE ; i++) { + for (int i = 0; i < BURST_SIZE ; i++) + { output_binary[i] = (output[i] > 0); - } } +} - //TODO consider placing this funtion in a separate class for signal processing - void receiver_impl::gmsk_mapper(const unsigned char * input, int nitems, gr_complex * gmsk_output, gr_complex start_point) - { - gr_complex j = gr_complex(0.0, 1.0); +//TODO consider placing this funtion in a separate class for signal processing +void receiver_impl::gmsk_mapper(const unsigned char * input, int nitems, gr_complex * gmsk_output, gr_complex start_point) +{ + gr_complex j = gr_complex(0.0, 1.0); - int current_symbol; - int encoded_symbol; - int previous_symbol = 2 * input[0] - 1; - gmsk_output[0] = start_point; + int current_symbol; + int encoded_symbol; + int previous_symbol = 2 * input[0] - 1; + gmsk_output[0] = start_point; - for (int i = 1; i < nitems; i++) { + for (int i = 1; i < nitems; i++) + { //change bits representation to NRZ current_symbol = 2 * input[i] - 1; //differentially encode @@ -581,157 +661,170 @@ namespace gr { //and do gmsk mapping gmsk_output[i] = j * gr_complex(encoded_symbol, 0.0) * gmsk_output[i-1]; previous_symbol = current_symbol; - } } +} - //TODO consider use of some generalized function for correlation and placing it in a separate class for signal processing - gr_complex receiver_impl::correlate_sequence(const gr_complex * sequence, int length, const gr_complex * input) - { - gr_complex result(0.0, 0.0); - int sample_number = 0; +//TODO consider use of some generalized function for correlation and placing it in a separate class for signal processing +gr_complex receiver_impl::correlate_sequence(const gr_complex * sequence, int length, const gr_complex * input) +{ + gr_complex result(0.0, 0.0); + int sample_number = 0; - for (int ii = 0; ii < length; ii++) { + for (int ii = 0; ii < length; ii++) + { sample_number = (ii * d_OSR) ; result += sequence[ii] * conj(input[sample_number]); - } - - result = result / gr_complex(length, 0); - return result; } - //computes autocorrelation for positive arguments - //TODO consider placing this funtion in a separate class for signal processing - inline void receiver_impl::autocorrelation(const gr_complex * input, gr_complex * out, int nitems) + result = result / gr_complex(length, 0); + return result; +} + +//computes autocorrelation for positive arguments +//TODO consider placing this funtion in a separate class for signal processing +inline void receiver_impl::autocorrelation(const gr_complex * input, gr_complex * out, int nitems) +{ + int i, k; + for (k = nitems - 1; k >= 0; k--) { - int i, k; - for (k = nitems - 1; k >= 0; k--) { out[k] = gr_complex(0, 0); - for (i = k; i < nitems; i++) { - out[k] += input[i] * conj(input[i-k]); + for (i = k; i < nitems; i++) + { + out[k] += input[i] * conj(input[i-k]); } - } } +} - //TODO consider use of some generalized function for filtering and placing it in a separate class for signal processing - inline void receiver_impl::mafi(const gr_complex * input, int nitems, gr_complex * filter, int filter_length, gr_complex * output) - { - int ii = 0, n, a; +//TODO consider use of some generalized function for filtering and placing it in a separate class for signal processing +inline void receiver_impl::mafi(const gr_complex * input, int nitems, gr_complex * filter, int filter_length, gr_complex * output) +{ + int ii = 0, n, a; - for (n = 0; n < nitems; n++) { + for (n = 0; n < nitems; n++) + { a = n * d_OSR; output[n] = 0; ii = 0; - while (ii < filter_length) { - if ((a + ii) >= nitems*d_OSR) - break; - output[n] += input[a+ii] * filter[ii]; - ii++; + while (ii < filter_length) + { + if ((a + ii) >= nitems*d_OSR) + break; + output[n] += input[a+ii] * filter[ii]; + ii++; } - } } - - //TODO: get_norm_chan_imp_resp is similar to get_sch_chan_imp_resp - consider joining this two functions - //TODO: this is place where most errors are introduced and can be corrected by improvements to this fuction - //especially computations of strongest_window_nr - int receiver_impl::get_norm_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp, int bcc) - { - vector_complex correlation_buffer; - vector_float power_buffer; - vector_float window_energy_buffer; - - int strongest_window_nr; - int burst_start = 0; - int chan_imp_resp_center = 0; - float max_correlation = 0; - float energy = 0; - - int search_center = (int)((TRAIN_POS + GUARD_PERIOD) * d_OSR); - int search_start_pos = search_center + 1; +} + +//TODO: get_norm_chan_imp_resp is similar to get_sch_chan_imp_resp - consider joining this two functions +//TODO: this is place where most errors are introduced and can be corrected by improvements to this fuction +//especially computations of strongest_window_nr +int receiver_impl::get_norm_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp, int bcc) +{ + vector_complex correlation_buffer; + vector_float power_buffer; + vector_float window_energy_buffer; + + int strongest_window_nr; + int burst_start = 0; + int chan_imp_resp_center = 0; + float max_correlation = 0; + float energy = 0; + + int search_center = (int)((TRAIN_POS + GUARD_PERIOD) * d_OSR); + int search_start_pos = search_center + 1; // int search_start_pos = search_center - d_chan_imp_length * d_OSR; - int search_stop_pos = search_center + d_chan_imp_length * d_OSR + 2 * d_OSR; + int search_stop_pos = search_center + d_chan_imp_length * d_OSR + 2 * d_OSR; - for (int ii = search_start_pos; ii < search_stop_pos; ii++) { + for (int ii = search_start_pos; ii < search_stop_pos; ii++) + { gr_complex correlation = correlate_sequence(&d_norm_training_seq[bcc][TRAIN_BEGINNING], N_TRAIN_BITS - 10, &input[ii]); correlation_buffer.push_back(correlation); power_buffer.push_back(std::pow(abs(correlation), 2)); - } + } - //compute window energies - vector_float::iterator iter = power_buffer.begin(); - bool loop_end = false; - while (iter != power_buffer.end()) { + //compute window energies + vector_float::iterator iter = power_buffer.begin(); + bool loop_end = false; + while (iter != power_buffer.end()) + { vector_float::iterator iter_ii = iter; energy = 0; - for (int ii = 0; ii < (d_chan_imp_length - 2)*d_OSR; ii++, iter_ii++) { - // for (int ii = 0; ii < (d_chan_imp_length)*d_OSR; ii++, iter_ii++) { - if (iter_ii == power_buffer.end()) { - loop_end = true; - break; - } - energy += (*iter_ii); + for (int ii = 0; ii < (d_chan_imp_length - 2)*d_OSR; ii++, iter_ii++) + { + // for (int ii = 0; ii < (d_chan_imp_length)*d_OSR; ii++, iter_ii++) { + if (iter_ii == power_buffer.end()) + { + loop_end = true; + break; + } + energy += (*iter_ii); } - if (loop_end) { - break; + if (loop_end) + { + break; } iter++; window_energy_buffer.push_back(energy); - } - //!why doesn't this work - int strongest_window_nr_new = max_element(window_energy_buffer.begin(), window_energy_buffer.end()) - window_energy_buffer.begin(); - strongest_window_nr = 3; //! so I have to override it here + } + //!why doesn't this work + int strongest_window_nr_new = max_element(window_energy_buffer.begin(), window_energy_buffer.end()) - window_energy_buffer.begin(); + strongest_window_nr = 3; //! so I have to override it here - max_correlation = 0; - for (int ii = 0; ii < (d_chan_imp_length)*d_OSR; ii++) { + max_correlation = 0; + for (int ii = 0; ii < (d_chan_imp_length)*d_OSR; ii++) + { gr_complex correlation = correlation_buffer[strongest_window_nr + ii]; - if (abs(correlation) > max_correlation) { - chan_imp_resp_center = ii; - max_correlation = abs(correlation); + if (abs(correlation) > max_correlation) + { + chan_imp_resp_center = ii; + max_correlation = abs(correlation); } - // d_channel_imp_resp.push_back(correlation); + // d_channel_imp_resp.push_back(correlation); chan_imp_resp[ii] = correlation; - } - // We want to use the first sample of the impulseresponse, and the - // corresponding samples of the received signal. - // the variable sync_w should contain the beginning of the used part of - // training sequence, which is 3+57+1+6=67 bits into the burst. That is - // we have that sync_t16 equals first sample in bit number 67. - - burst_start = search_start_pos + chan_imp_resp_center + strongest_window_nr - TRAIN_POS * d_OSR; - - // GMSK modulator introduces ISI - each bit is expanded for 3*Tb - // and it's maximum value is in the last bit period, so burst starts - // 2*Tb earlier - burst_start -= 2 * d_OSR; - burst_start += 2; - COUT("Poczatek ###############################"); - std::cout << " burst_start: " << burst_start << " center: " << ((float)(search_start_pos + strongest_window_nr + chan_imp_resp_center)) / d_OSR << " stronegest window nr: " << strongest_window_nr << "\n"; - COUT("burst_start_new: " << (search_start_pos + strongest_window_nr_new - TRAIN_POS * d_OSR)); - burst_start=(search_start_pos + strongest_window_nr_new - TRAIN_POS * d_OSR) - return burst_start; } - - - void receiver_impl::process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary) + // We want to use the first sample of the impulseresponse, and the + // corresponding samples of the received signal. + // the variable sync_w should contain the beginning of the used part of + // training sequence, which is 3+57+1+6=67 bits into the burst. That is + // we have that sync_t16 equals first sample in bit number 67. + + burst_start = search_start_pos + chan_imp_resp_center + strongest_window_nr - TRAIN_POS * d_OSR; + + // GMSK modulator introduces ISI - each bit is expanded for 3*Tb + // and it's maximum value is in the last bit period, so burst starts + // 2*Tb earlier + burst_start -= 2 * d_OSR; + burst_start += 2; + //COUT("Poczatek ###############################"); + //std::cout << " burst_start: " << burst_start << " center: " << ((float)(search_start_pos + strongest_window_nr + chan_imp_resp_center)) / d_OSR << " stronegest window nr: " << strongest_window_nr << "\n"; + //COUT("burst_start_new: " << (search_start_pos + strongest_window_nr_new - TRAIN_POS * d_OSR)); + burst_start=(search_start_pos + strongest_window_nr_new - TRAIN_POS * d_OSR); + return burst_start; +} + + +void receiver_impl::process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary) +{ + int ii; + //std::cout << "fn:" <(burst_binary[ii]); - } - std::cout << std::endl; + std::cout << std::setprecision(1) << static_cast(burst_binary[ii]) << " "; } - //TODO: this shouldn't be here also - the same reason - void receiver_impl::configure_receiver() - { - d_channel_conf.set_multiframe_type(TSC0, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT0, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + std::cout << std::endl; +} +//TODO: this shouldn't be here also - the same reason +void receiver_impl::configure_receiver() +{ + d_channel_conf.set_multiframe_type(TSC0, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT0, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_burst_types(TSC0, TEST_CCH_FRAMES, sizeof(TEST_CCH_FRAMES) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_burst_types(TSC0, FCCH_FRAMES, sizeof(FCCH_FRAMES) / sizeof(unsigned), fcch_burst); + d_channel_conf.set_burst_types(TSC0, TEST_CCH_FRAMES, sizeof(TEST_CCH_FRAMES) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_burst_types(TSC0, FCCH_FRAMES, sizeof(FCCH_FRAMES) / sizeof(unsigned), fcch_burst); // d_channel_conf.set_multiframe_type(TIMESLOT1, multiframe_26); // d_channel_conf.set_burst_types(TIMESLOT1, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal); @@ -747,24 +840,24 @@ namespace gr { // d_channel_conf.set_burst_types(TIMESLOT6, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal); // d_channel_conf.set_multiframe_type(TIMESLOT7, multiframe_26); // d_channel_conf.set_burst_types(TIMESLOT7, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT1, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT1, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT2, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT2, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT3, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT3, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT4, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT4, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT5, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT5, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT6, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT6, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - d_channel_conf.set_multiframe_type(TIMESLOT7, multiframe_51); - d_channel_conf.set_burst_types(TIMESLOT7, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); - - } - - - } /* namespace gsm */ + d_channel_conf.set_multiframe_type(TIMESLOT1, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT1, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT2, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT2, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT3, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT3, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT4, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT4, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT5, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT5, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT6, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT6, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + d_channel_conf.set_multiframe_type(TIMESLOT7, multiframe_51); + d_channel_conf.set_burst_types(TIMESLOT7, TEST51, sizeof(TEST51) / sizeof(unsigned), dummy_or_normal); + +} + + +} /* namespace gsm */ } /* namespace gr */ -- cgit v1.2.3