diff options
Diffstat (limited to 'gnuradio-core/src/lib/general')
22 files changed, 742 insertions, 385 deletions
diff --git a/gnuradio-core/src/lib/general/Makefile.am b/gnuradio-core/src/lib/general/Makefile.am index c76130039..d774baa1c 100644 --- a/gnuradio-core/src/lib/general/Makefile.am +++ b/gnuradio-core/src/lib/general/Makefile.am @@ -63,7 +63,7 @@ libgeneral_la_SOURCES = \ gr_diff_decoder_bb.cc \ gr_diff_encoder_bb.cc \ gr_diff_phasor_cc.cc \ - gr_dpll_ff.cc \ + gr_dpll_bb.cc \ gr_fake_channel_coder_pp.cc \ gr_fast_atan2f.cc \ gr_feedforward_agc_cc.cc \ @@ -102,6 +102,7 @@ libgeneral_la_SOURCES = \ gr_ofdm_mapper_bcv.cc \ gr_ofdm_bpsk_demapper.cc \ gr_ofdm_bpsk_mapper.cc \ + gr_ofdm_frame_sink.cc \ gr_ofdm_sampler.cc \ gr_pa_2x2_phase_combiner.cc \ gr_packet_sink.cc \ @@ -197,7 +198,7 @@ grinclude_HEADERS = \ gr_deinterleave.h \ gr_delay.h \ gr_diff_phasor_cc.h \ - gr_dpll_ff.h \ + gr_dpll_bb.h \ gr_expj.h \ gr_fake_channel_coder_pp.h \ gr_feedforward_agc_cc.h \ @@ -240,7 +241,8 @@ grinclude_HEADERS = \ gr_ofdm_mapper_bcv.h \ gr_ofdm_bpsk_mapper.h \ gr_ofdm_bpsk_demapper.h \ - gr_ofdm_sampler.h \ + gr_ofdm_frame_sink.h \ + gr_ofdm_sampler.h \ gr_pa_2x2_phase_combiner.h \ gr_packet_sink.h \ gr_phase_modulator_fc.h \ @@ -342,7 +344,7 @@ swiginclude_HEADERS = \ gr_diff_decoder_bb.i \ gr_diff_encoder_bb.i \ gr_diff_phasor_cc.i \ - gr_dpll_ff.i \ + gr_dpll_bb.i \ gr_deinterleave.i \ gr_delay.i \ gr_fake_channel_coder_pp.i \ @@ -379,7 +381,8 @@ swiginclude_HEADERS = \ gr_ofdm_mapper_bcv.i \ gr_ofdm_bpsk_demapper.i \ gr_ofdm_bpsk_mapper.i \ - gr_ofdm_sampler.i \ + gr_ofdm_frame_sink.i \ + gr_ofdm_sampler.i \ gr_pa_2x2_phase_combiner.i \ gr_packet_sink.i \ gr_phase_modulator_fc.i \ diff --git a/gnuradio-core/src/lib/general/general.i b/gnuradio-core/src/lib/general/general.i index 64144a05a..1fdb4239a 100644 --- a/gnuradio-core/src/lib/general/general.i +++ b/gnuradio-core/src/lib/general/general.i @@ -84,7 +84,7 @@ #include <gr_packet_sink.h> #include <gr_lms_dfe_cc.h> #include <gr_lms_dfe_ff.h> -#include <gr_dpll_ff.h> +#include <gr_dpll_bb.h> #include <gr_pll_freqdet_cf.h> #include <gr_pll_refout_cc.h> #include <gr_pll_carriertracking_cc.h> @@ -97,6 +97,7 @@ #include <gr_ofdm_cyclic_prefixer.h> #include <gr_ofdm_bpsk_demapper.h> #include <gr_ofdm_bpsk_mapper.h> +#include <gr_ofdm_frame_sink.h> #include <gr_ofdm_sampler.h> #include <gr_costas_loop_cc.h> #include <gr_pa_2x2_phase_combiner.h> @@ -186,7 +187,7 @@ %include "gr_packet_sink.i" %include "gr_lms_dfe_cc.i" %include "gr_lms_dfe_ff.i" -%include "gr_dpll_ff.i" +%include "gr_dpll_bb.i" %include "gr_pll_freqdet_cf.i" %include "gr_pll_refout_cc.i" %include "gr_pll_carriertracking_cc.i" @@ -199,6 +200,7 @@ %include "gr_ofdm_cyclic_prefixer.i" %include "gr_ofdm_bpsk_demapper.i" %include "gr_ofdm_bpsk_mapper.i" +%include "gr_ofdm_frame_sink.i" %include "gr_ofdm_sampler.i" %include "gr_costas_loop_cc.i" %include "gr_pa_2x2_phase_combiner.i" diff --git a/gnuradio-core/src/lib/general/gr_conjugate_cc.cc b/gnuradio-core/src/lib/general/gr_conjugate_cc.cc index 0a5b3790e..453c6d338 100644 --- a/gnuradio-core/src/lib/general/gr_conjugate_cc.cc +++ b/gnuradio-core/src/lib/general/gr_conjugate_cc.cc @@ -53,19 +53,24 @@ gr_conjugate_cc::work (int noutput_items, int size = noutput_items; while (size >= 8){ - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; + optr[0] = conj(iptr[0]); + optr[1] = conj(iptr[1]); + optr[2] = conj(iptr[2]); + optr[3] = conj(iptr[3]); + optr[4] = conj(iptr[4]); + optr[5] = conj(iptr[5]); + optr[6] = conj(iptr[6]); + optr[7] = conj(iptr[7]); size -= 8; + optr += 8; + iptr += 8; + } + + while (size-- > 0) { + *optr = conj(*iptr); + iptr++; + optr++; } - while (size-- > 0) - *optr++ = gr_complex(real(*iptr),-imag(*iptr));iptr++; - return noutput_items; } diff --git a/gnuradio-core/src/lib/general/gr_delay.cc b/gnuradio-core/src/lib/general/gr_delay.cc index 12c50e4b6..89ab3ce0e 100644 --- a/gnuradio-core/src/lib/general/gr_delay.cc +++ b/gnuradio-core/src/lib/general/gr_delay.cc @@ -56,7 +56,7 @@ gr_delay::work (int noutput_items, iptr = (const char *) input_items[i]; optr = (char *) output_items[i]; - memcpy(optr, iptr + delay()*d_itemsize, noutput_items*d_itemsize); + memcpy(optr, iptr, noutput_items*d_itemsize); } return noutput_items; diff --git a/gnuradio-core/src/lib/general/gr_dpll_ff.cc b/gnuradio-core/src/lib/general/gr_dpll_bb.cc index ae868fce5..d5b726528 100644 --- a/gnuradio-core/src/lib/general/gr_dpll_ff.cc +++ b/gnuradio-core/src/lib/general/gr_dpll_bb.cc @@ -20,25 +20,23 @@ * Boston, MA 02110-1301, USA. */ -// WARNING: this file is machine generated. Edits will be over written - #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include <gr_dpll_ff.h> +#include <gr_dpll_bb.h> #include <gr_io_signature.h> -gr_dpll_ff_sptr -gr_make_dpll_ff (float period, float gain) +gr_dpll_bb_sptr +gr_make_dpll_bb (float period, float gain) { - return gr_dpll_ff_sptr (new gr_dpll_ff (period, gain)); + return gr_dpll_bb_sptr (new gr_dpll_bb (period, gain)); } -gr_dpll_ff::gr_dpll_ff (float period, float gain) - : gr_sync_block ("dpll_ff", - gr_make_io_signature (1, 1, sizeof (float)), - gr_make_io_signature (1, 1, sizeof (float))), +gr_dpll_bb::gr_dpll_bb (float period, float gain) + : gr_sync_block ("dpll_bb", + gr_make_io_signature (1, 1, sizeof (char)), + gr_make_io_signature (1, 1, sizeof (char))), d_restart(0),d_pulse_phase(0) { d_pulse_frequency = 1.0/period; @@ -55,16 +53,16 @@ gr_dpll_ff::gr_dpll_ff (float period, float gain) } int -gr_dpll_ff::work (int noutput_items, +gr_dpll_bb::work (int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) { - float *iptr = (float *) input_items[0]; - float *optr = (float *) output_items[0]; + const char *iptr = (const char *) input_items[0]; + char *optr = (char *) output_items[0]; for (int i = 0; i < noutput_items; i++){ - optr[i]= (float)0; - if(iptr[i] ==(float)1) { + optr[i]= 0; + if(iptr[i] == 1) { if (d_restart == 0) { d_pulse_phase = 1; } else { @@ -77,7 +75,7 @@ gr_dpll_ff::work (int noutput_items, d_pulse_phase -= 1.0; if (d_restart > 0) { d_restart -= 1; - optr[i] = (float)1; + optr[i] = 1; } } d_pulse_phase += d_pulse_frequency; diff --git a/gnuradio-core/src/lib/general/gr_dpll_ff.h b/gnuradio-core/src/lib/general/gr_dpll_bb.h index 1de1efa85..c80612bc5 100644 --- a/gnuradio-core/src/lib/general/gr_dpll_ff.h +++ b/gnuradio-core/src/lib/general/gr_dpll_bb.h @@ -20,17 +20,15 @@ * Boston, MA 02110-1301, USA. */ -// WARNING: this file is machine generated. Edits will be over written - -#ifndef INCLUDED_GR_DPLL_FF_H -#define INCLUDED_GR_DPLL_FF_H +#ifndef INCLUDED_GR_DPLL_BB_H +#define INCLUDED_GR_DPLL_BB_H #include <gr_sync_block.h> -class gr_dpll_ff; -typedef boost::shared_ptr<gr_dpll_ff> gr_dpll_ff_sptr; +class gr_dpll_bb; +typedef boost::shared_ptr<gr_dpll_bb> gr_dpll_bb_sptr; -gr_dpll_ff_sptr gr_make_dpll_ff (float period, float gain); +gr_dpll_bb_sptr gr_make_dpll_bb (float period, float gain); /*! * \brief Detect the peak of a signal @@ -39,11 +37,11 @@ gr_dpll_ff_sptr gr_make_dpll_ff (float period, float gain); * If a peak is detected, this block outputs a 1, * or it outputs 0's. */ -class gr_dpll_ff : public gr_sync_block +class gr_dpll_bb : public gr_sync_block { - friend gr_dpll_ff_sptr gr_make_dpll_ff (float period, float gain); + friend gr_dpll_bb_sptr gr_make_dpll_bb (float period, float gain); - gr_dpll_ff (float period, float gain); + gr_dpll_bb (float period, float gain); private: unsigned char d_restart; diff --git a/gnuradio-core/src/lib/general/gr_dpll_ff.i b/gnuradio-core/src/lib/general/gr_dpll_bb.i index 9606fba52..ae95e2dfb 100644 --- a/gnuradio-core/src/lib/general/gr_dpll_ff.i +++ b/gnuradio-core/src/lib/general/gr_dpll_bb.i @@ -20,14 +20,12 @@ * Boston, MA 02110-1301, USA. */ -// WARNING: this file is machine generated. Edits will be over written +GR_SWIG_BLOCK_MAGIC(gr,dpll_bb) -GR_SWIG_BLOCK_MAGIC(gr,dpll_ff) + gr_dpll_bb_sptr gr_make_dpll_bb (float period, float gain); - gr_dpll_ff_sptr gr_make_dpll_ff (float period, float gain); - -class gr_dpll_ff : public gr_sync_block +class gr_dpll_bb : public gr_sync_block { private: - gr_dpll_ff (float period, float gain); + gr_dpll_bb (float period, float gain); }; diff --git a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.cc b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.cc index df4632398..f0b52c325 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.cc +++ b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2006 Free Software Foundation, Inc. + * Copyright 2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -29,30 +29,32 @@ #include <vector> gr_ofdm_bpsk_mapper_sptr -gr_make_ofdm_bpsk_mapper (unsigned int mtu, unsigned int occupied_carriers, unsigned int vlen, - std::vector<gr_complex> known_symbol1, std::vector<gr_complex> known_symbol2) +gr_make_ofdm_bpsk_mapper (unsigned int msgq_limit, + unsigned int occupied_carriers, unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2) { - return gr_ofdm_bpsk_mapper_sptr (new gr_ofdm_bpsk_mapper (mtu, occupied_carriers, vlen, + return gr_ofdm_bpsk_mapper_sptr (new gr_ofdm_bpsk_mapper (msgq_limit, occupied_carriers, fft_length, known_symbol1, known_symbol2)); } -gr_ofdm_bpsk_mapper::gr_ofdm_bpsk_mapper (unsigned int mtu, unsigned int occupied_carriers, unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2) - : gr_block ("ofdm_bpsk_mapper", - gr_make_io_signature (1, 1, 2*sizeof(int) + sizeof(unsigned char)*mtu), - gr_make_io_signature (1, 1, sizeof(gr_complex)*vlen)), - d_mtu(mtu), +// Consumes 1 packet and produces as many OFDM symbols of fft_length to hold the full packet +gr_ofdm_bpsk_mapper::gr_ofdm_bpsk_mapper (unsigned int msgq_limit, + unsigned int occupied_carriers, unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2) + : gr_sync_block ("ofdm_bpsk_mapper", + gr_make_io_signature (0, 0, 0), + gr_make_io_signature2 (1, 2, sizeof(gr_complex)*fft_length, sizeof(char))), + d_msgq(gr_make_msg_queue(msgq_limit)), d_msg_offset(0), d_eof(false), d_occupied_carriers(occupied_carriers), - d_vlen(vlen), - d_packet_offset(0), + d_fft_length(fft_length), d_bit_offset(0), d_header_sent(0), d_known_symbol1(known_symbol1), d_known_symbol2(known_symbol2) - { - assert(d_occupied_carriers < d_vlen); + assert(d_occupied_carriers <= d_fft_length); assert(d_occupied_carriers == d_known_symbol1.size()); assert(d_occupied_carriers == d_known_symbol2.size()); } @@ -61,99 +63,101 @@ gr_ofdm_bpsk_mapper::~gr_ofdm_bpsk_mapper(void) { } -void -gr_ofdm_bpsk_mapper::forecast (int noutput_items, gr_vector_int &ninput_items_required) +float randombit() { - unsigned ninputs = ninput_items_required.size (); - for (unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = 1; + int r = rand()&1; + return (float)(-1 + 2*r); } int -gr_ofdm_bpsk_mapper::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) +gr_ofdm_bpsk_mapper::work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) { - const gr_frame *in = (const gr_frame *) input_items[0]; gr_complex *out = (gr_complex *)output_items[0]; unsigned int i=0; - unsigned int num_symbols = 0, pkt_length; + unsigned int unoccupied_carriers = d_fft_length - d_occupied_carriers; + unsigned int zeros_on_left = (unsigned)ceil(unoccupied_carriers/2.0); //printf("OFDM BPSK Mapper: ninput_items: %d noutput_items: %d\n", ninput_items[0], noutput_items); - pkt_length = in[0].length; - - std::vector<gr_complex>::iterator ks_itr; - if(d_header_sent == 0) { - ks_itr = d_known_symbol1.begin(); - } - else if(d_header_sent == 1) { - ks_itr = d_known_symbol2.begin(); + if(d_eof) { + return -1; } - if(d_header_sent < 2) { - // Add training symbols here - for(i=0; i < (ceil((d_vlen - d_occupied_carriers)/2.0)); i++) { - out[i] = gr_complex(0,0); + if(!d_msg) { + d_msg = d_msgq->delete_head(); // block, waiting for a message + d_msg_offset = 0; + d_bit_offset = 0; + d_header_sent = 0; + + if((d_msg->length() == 0) && (d_msg->type() == 1)) { + d_msg.reset(); + return -1; } - for(;i<d_vlen - ceil((d_vlen-d_occupied_carriers)/2.0);i++) { - //out[i] = gr_complex(1,0); - out[i] = *(ks_itr++); + } + + if(output_items.size() == 2) { + char *sig = (char *)output_items[1]; + if(d_header_sent == 1) { + sig[0] = 1; } - for(; i < d_vlen; i++) { - out[i] = gr_complex(0,0); + else { + sig[0] = 0; } - - num_symbols = 1; - out += d_vlen; - d_header_sent++; } - unsigned int unoccupied_carriers = d_vlen - d_occupied_carriers; - unsigned int zeros_on_left = (unsigned)ceil(unoccupied_carriers/2.0); - unsigned int zeros_on_right = unoccupied_carriers - zeros_on_left; + // Build a single symbol: - while(num_symbols < (unsigned)noutput_items) { + // Initialize all bins to 0 to set unused carriers + memset(out, 0, d_fft_length*sizeof(gr_complex)); + + if(d_header_sent == 0) { + for(i=0; i < d_occupied_carriers; i++) { + out[i+zeros_on_left] = d_known_symbol1[i]; + } + d_header_sent++; - // stick in unused carriers - for(i = d_vlen-zeros_on_right; i < d_vlen; i++) { - out[i] = gr_complex(0,0); + return 1; + } + + if(d_header_sent == 1) { + for(i=0; i < d_occupied_carriers; i++) { + out[i+zeros_on_left] = d_known_symbol2[i]; } + d_header_sent++; - for(i=0; i < zeros_on_left; i++) { - out[i] = gr_complex(0,0); - } + return 1; + } - while((d_packet_offset < pkt_length) && (i < d_vlen-zeros_on_right)) { - unsigned char bit = (in[0].data[d_packet_offset] >> (d_bit_offset++)) & 0x01; - out[i++] = gr_complex(-1+2*(bit)); - if(d_bit_offset == 8) { - d_bit_offset = 0; - d_packet_offset++; - } + i = 0; + while((d_msg_offset < d_msg->length()) && (i < d_occupied_carriers)) { + unsigned char bit = (d_msg->msg()[d_msg_offset] >> (d_bit_offset)) & 0x01; + out[i + zeros_on_left] = gr_complex(-1+2*(bit)); + i++; + d_bit_offset++; + if(d_bit_offset == 8) { + d_bit_offset = 0; + d_msg_offset++; } + } - // Ran out of data to put in symbols - if(d_packet_offset == pkt_length) { - while(i < d_vlen-zeros_on_right) { - out[i++] = gr_complex(0,0); - } - - d_packet_offset = 0; - assert(d_bit_offset == 0); - num_symbols++; - d_header_sent = 0; - consume_each(1); - return num_symbols; + // Ran out of data to put in symbol + if (d_msg_offset == d_msg->length()) { + while(i < d_occupied_carriers) { // finish filling out the symbol + out[i + zeros_on_left] = gr_complex(randombit(),0); + i++; } - - // Ran out of space in symbol - out += d_vlen; - num_symbols++; + + if (d_msg->type() == 1) // type == 1 sets EOF + d_eof = true; + d_msg.reset(); // finished packet, free message + + assert(d_bit_offset == 0); + return 1; // produced one symbol } - consume_each(0); - return num_symbols; + + return 1; // produced symbol } diff --git a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.h b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.h index 1ae6c75d8..41b2f5bed 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.h +++ b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.h @@ -24,17 +24,19 @@ #define INCLUDED_GR_OFDM_BPSK_MAPPER_H -#include <gr_block.h> -#include <gr_frame.h> +#include <gr_sync_block.h> +#include <gr_message.h> +#include <gr_msg_queue.h> #include <vector> class gr_ofdm_bpsk_mapper; typedef boost::shared_ptr<gr_ofdm_bpsk_mapper> gr_ofdm_bpsk_mapper_sptr; gr_ofdm_bpsk_mapper_sptr -gr_make_ofdm_bpsk_mapper (unsigned mtu, unsigned occupied_carriers, unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); +gr_make_ofdm_bpsk_mapper (unsigned msgq_limit, + unsigned occupied_carriers, unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); /*! * \brief take a stream of bytes in and map to a vector of complex @@ -42,35 +44,40 @@ gr_make_ofdm_bpsk_mapper (unsigned mtu, unsigned occupied_carriers, unsigned int * modulator. Simple BPSK version. */ -class gr_ofdm_bpsk_mapper : public gr_block +class gr_ofdm_bpsk_mapper : public gr_sync_block { friend gr_ofdm_bpsk_mapper_sptr - gr_make_ofdm_bpsk_mapper (unsigned mtu, unsigned occupied_carriers, unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + gr_make_ofdm_bpsk_mapper (unsigned msgq_limit, + unsigned occupied_carriers, unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); protected: - gr_ofdm_bpsk_mapper (unsigned mtu, unsigned occupied_carriers, unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + gr_ofdm_bpsk_mapper (unsigned msgq_limit, + unsigned occupied_carriers, unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); private: - unsigned int d_mtu; + gr_msg_queue_sptr d_msgq; + gr_message_sptr d_msg; + unsigned d_msg_offset; + bool d_eof; + unsigned int d_occupied_carriers; - unsigned int d_vlen; - unsigned int d_packet_offset; + unsigned int d_fft_length; unsigned int d_bit_offset; unsigned int d_header_sent; std::vector<gr_complex> d_known_symbol1, d_known_symbol2; - void forecast (int noutput_items, gr_vector_int &ninput_items_required); - public: ~gr_ofdm_bpsk_mapper(void); - int general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + + gr_msg_queue_sptr msgq() const { return d_msgq; } + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); }; diff --git a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.i b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.i index 12b86dc33..d0094062a 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.i +++ b/gnuradio-core/src/lib/general/gr_ofdm_bpsk_mapper.i @@ -22,27 +22,28 @@ #include <vector> -GR_SWIG_BLOCK_MAGIC(gr,ofdm_bpsk_mapper) +GR_SWIG_BLOCK_MAGIC(gr,ofdm_bpsk_mapper); gr_ofdm_bpsk_mapper_sptr -gr_make_ofdm_bpsk_mapper (unsigned int mtu, +gr_make_ofdm_bpsk_mapper (unsigned int msgq_limit, unsigned int bits_per_symbol, - unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); -class gr_ofdm_bpsk_mapper : public gr_block +class gr_ofdm_bpsk_mapper : public gr_sync_block { protected: - gr_ofdm_bpsk_mapper (unsigned int mtu, + gr_ofdm_bpsk_mapper (unsigned int msgq_limit, unsigned int bits_per_symbol, - unsigned int vlen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + unsigned int fft_length, + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); public: - int general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + gr_msg_queue_sptr msgq(); + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); }; diff --git a/gnuradio-core/src/lib/general/gr_ofdm_correlator.cc b/gnuradio-core/src/lib/general/gr_ofdm_correlator.cc index 21fbc6b3e..3973b8374 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_correlator.cc +++ b/gnuradio-core/src/lib/general/gr_ofdm_correlator.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2006 Free Software Foundation, Inc. + * Copyright 2006, 2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -26,29 +26,30 @@ #include <gr_ofdm_correlator.h> #include <gr_io_signature.h> +#include <gr_expj.h> #define VERBOSE 0 #define M_TWOPI (2*M_PI) gr_ofdm_correlator_sptr -gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int vlen, +gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2) + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2) { - return gr_ofdm_correlator_sptr (new gr_ofdm_correlator (occupied_carriers, vlen, cplen, + return gr_ofdm_correlator_sptr (new gr_ofdm_correlator (occupied_carriers, fft_length, cplen, known_symbol1, known_symbol2)); } -gr_ofdm_correlator::gr_ofdm_correlator (unsigned occupied_carriers, unsigned int vlen, +gr_ofdm_correlator::gr_ofdm_correlator (unsigned occupied_carriers, unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2) + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2) : gr_block ("ofdm_correlator", - gr_make_io_signature (1, 1, sizeof(gr_complex)*vlen), - gr_make_io_signature (1, 1, sizeof(gr_complex)*occupied_carriers)), + gr_make_io_signature (1, 1, sizeof(gr_complex)*fft_length), + gr_make_io_signature2 (2, 2, sizeof(gr_complex)*occupied_carriers, sizeof(char))), d_occupied_carriers(occupied_carriers), - d_vlen(vlen), + d_fft_length(fft_length), d_cplen(cplen), d_freq_shift_len(5), d_known_symbol1(known_symbol1), @@ -84,8 +85,9 @@ gr_ofdm_correlator::forecast (int noutput_items, gr_vector_int &ninput_items_req gr_complex gr_ofdm_correlator::coarse_freq_comp(int freq_delta, int symbol_count) { - return gr_complex(cos(-M_TWOPI*freq_delta*d_cplen/d_vlen*symbol_count), - sin(-M_TWOPI*freq_delta*d_cplen/d_vlen*symbol_count)); + // return gr_complex(cos(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count), + // sin(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count)); + return gr_expj(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count); } bool @@ -99,7 +101,7 @@ gr_ofdm_correlator::correlate(const gr_complex *previous, const gr_complex *curr gr_complex h_sqrd = gr_complex(0.0,0.0); float power = 0.0F; - while(!found && (abs(search_delta) < d_freq_shift_len)) { + while(!found && ((unsigned)abs(search_delta) < d_freq_shift_len)) { h_sqrd = gr_complex(0.0,0.0); power = 0.0F; @@ -115,11 +117,20 @@ gr_ofdm_correlator::correlate(const gr_complex *previous, const gr_complex *curr search_delta, h_sqrd.real(), h_sqrd.imag(), power, h_sqrd.real()/power, arg(h_sqrd)); #endif - if(h_sqrd.real() > 0.75*power) { + // FIXME: Look at h_sqrd.read() > power + if((h_sqrd.real() > 0.82*power) && (h_sqrd.real() < 1.1 * power)) { found = true; d_coarse_freq = search_delta; d_phase_count = 1; - d_snr_est = 10*log10(power/(power-h_sqrd.real())); + //d_snr_est = 10*log10(power/(power-h_sqrd.real())); + + // check for low noise power; sets maximum SNR at 100 dB + if(fabs(h_sqrd.imag()) <= 1e-12) { + d_snr_est = 100.0; + } + else { + d_snr_est = 10*log10(fabs(h_sqrd.real()/h_sqrd.imag())); + } printf("CORR: Found, bin %d\tSNR Est %f dB\tcorr power fraction %f\n", search_delta, d_snr_est, h_sqrd.real()/power); @@ -168,23 +179,30 @@ gr_ofdm_correlator::general_work(int noutput_items, { const gr_complex *in = (const gr_complex *)input_items[0]; const gr_complex *previous = &in[0]; - const gr_complex *current = &in[d_vlen]; + const gr_complex *current = &in[d_fft_length]; gr_complex *out = (gr_complex *) output_items[0]; + char *sig = (char *) output_items[1]; unsigned int i=0; - int unoccupied_carriers = d_vlen - d_occupied_carriers; + int unoccupied_carriers = d_fft_length - d_occupied_carriers; int zeros_on_left = (int)ceil(unoccupied_carriers/2.0); bool corr = correlate(previous, current, zeros_on_left); if(corr) { calculate_equalizer(previous, current, zeros_on_left); + sig[0] = 1; + } + else { + sig[0] = 0; } for(i = 0; i < d_occupied_carriers; i++) { out[i] = d_hestimate[i]*coarse_freq_comp(d_coarse_freq,d_phase_count)*current[i+zeros_on_left+d_coarse_freq]; } + + d_phase_count++; consume_each(1); return 1; diff --git a/gnuradio-core/src/lib/general/gr_ofdm_correlator.h b/gnuradio-core/src/lib/general/gr_ofdm_correlator.h index 4c44cca32..44a6847af 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_correlator.h +++ b/gnuradio-core/src/lib/general/gr_ofdm_correlator.h @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2006 Free Software Foundation, Inc. + * Copyright 2006, 2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -31,10 +31,10 @@ class gr_ofdm_correlator; typedef boost::shared_ptr<gr_ofdm_correlator> gr_ofdm_correlator_sptr; gr_ofdm_correlator_sptr -gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int vlen, +gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); /*! * \brief take a vector of complex constellation points in from an FFT @@ -48,7 +48,7 @@ gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int vlen, * been corrected and that the samples fall in the middle of one FFT bin. * * It then uses one of those known - * symbosl to estimate the channel response overa all subcarriers and does a simple + * symbols to estimate the channel response over all subcarriers and does a simple * 1-tap equalization on all subcarriers. This corrects for the phase and amplitude * distortion caused by the channel. */ @@ -58,7 +58,7 @@ class gr_ofdm_correlator : public gr_block /*! * \brief Build an OFDM correlator and equalizer. * \param occupied_carriers The number of subcarriers with data in the received symbol - * \param vlen The size of the FFT vector (occupied_carriers + unused carriers) + * \param fft_length The size of the FFT vector (occupied_carriers + unused carriers) * \param known_symbol1 A vector of complex numbers representing a known symbol at the * start of a frame (usually a BPSK PN sequence) * \param known_symbol2 A vector of complex numbers representing a known symbol at the @@ -67,16 +67,16 @@ class gr_ofdm_correlator : public gr_block * for phase changes between symbols. */ friend gr_ofdm_correlator_sptr - gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int vlen, + gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); protected: - gr_ofdm_correlator (unsigned int occupied_carriers, unsigned int vlen, + gr_ofdm_correlator (unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); private: unsigned char slicer(gr_complex x); @@ -86,15 +86,15 @@ class gr_ofdm_correlator : public gr_block gr_complex coarse_freq_comp(int freq_delta, int count); unsigned int d_occupied_carriers; // !< \brief number of subcarriers with data - unsigned int d_vlen; // !< \brief length of FFT vector + unsigned int d_fft_length; // !< \brief length of FFT vector unsigned int d_cplen; // !< \brief length of cyclic prefix in samples unsigned int d_freq_shift_len; // !< \brief number of surrounding bins to look at for correlation std::vector<gr_complex> d_known_symbol1, d_known_symbol2; // !< \brief known symbols at start of frame std::vector<gr_complex> d_diff_corr_factor; // !< \brief factor used in correlation - std::vector<gr_complex> d_hestimate; // !< channel estimate - signed int d_coarse_freq; // !< \brief search distance in number of bins - unsigned int d_phase_count; // !< \brief accumulator for coarse freq correction - float d_snr_est; // !< an estimation of the signal to noise ratio + std::vector<gr_complex> d_hestimate; // !< channel estimate + signed int d_coarse_freq; // !< \brief search distance in number of bins + unsigned int d_phase_count; // !< \brief accumulator for coarse freq correction + float d_snr_est; // !< an estimation of the signal to noise ratio void forecast(int noutput_items, gr_vector_int &ninput_items_required); diff --git a/gnuradio-core/src/lib/general/gr_ofdm_correlator.i b/gnuradio-core/src/lib/general/gr_ofdm_correlator.i index fbbf6a8af..40f9f83ff 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_correlator.i +++ b/gnuradio-core/src/lib/general/gr_ofdm_correlator.i @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2004,2006 Free Software Foundation, Inc. + * Copyright 2006, 2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -22,23 +22,23 @@ #include <vector> -GR_SWIG_BLOCK_MAGIC(gr,ofdm_correlator) +GR_SWIG_BLOCK_MAGIC(gr,ofdm_correlator); gr_ofdm_correlator_sptr gr_make_ofdm_correlator (unsigned int occupied_carriers, - unsigned int vlen, + unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); class gr_ofdm_correlator : public gr_sync_decimator { protected: gr_ofdm_correlator (unsigned int occupied_carriers, - unsigned int vlen, + unsigned int fft_length, unsigned int cplen, - std::vector<gr_complex> known_symbol1, - std::vector<gr_complex> known_symbol2); + const std::vector<gr_complex> &known_symbol1, + const std::vector<gr_complex> &known_symbol2); public: float snr() { return d_snr_est; } diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.cc b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.cc new file mode 100644 index 000000000..acaf1258b --- /dev/null +++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.cc @@ -0,0 +1,235 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio 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 2, or (at your option) + * any later version. + * + * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <gr_ofdm_frame_sink.h> +#include <gr_io_signature.h> +#include <cstdio> +#include <stdexcept> + +#define VERBOSE 0 + +inline void +gr_ofdm_frame_sink::enter_search() +{ + if (VERBOSE) + fprintf(stderr, "@ enter_search\n"); + + d_state = STATE_SYNC_SEARCH; + +} + +inline void +gr_ofdm_frame_sink::enter_have_sync() +{ + if (VERBOSE) + fprintf(stderr, "@ enter_have_sync\n"); + + d_state = STATE_HAVE_SYNC; + + // clear state of demapper + d_byte_offset = 0; + d_partial_byte = 0; + + d_header = 0; + d_headerbytelen_cnt = 0; +} + +inline void +gr_ofdm_frame_sink::enter_have_header() +{ + d_state = STATE_HAVE_HEADER; + + // header consists of two 16-bit shorts in network byte order + // payload length is lower 12 bits + // whitener offset is upper 4 bits + d_packetlen = (d_header >> 16) & 0x0fff; + d_packet_whitener_offset = (d_header >> 28) & 0x000f; + d_packetlen_cnt = 0; + + if (VERBOSE) + fprintf(stderr, "@ enter_have_header (payload_len = %d) (offset = %d)\n", + d_packetlen, d_packet_whitener_offset); +} + +unsigned char gr_ofdm_frame_sink::bpsk_slicer(gr_complex x) +{ + return (unsigned char)(x.real() > 0 ? 1 : 0); +} + +unsigned int gr_ofdm_frame_sink::bpsk_demapper(const gr_complex *in, + unsigned char *out) +{ + unsigned int i=0, bytes_produced=0; + + while(i < d_occupied_carriers) { + + while((d_byte_offset < 8) && (i < d_occupied_carriers)) { + //fprintf(stderr, "%f+j%f\n", in[i].real(), in[i].imag()); + d_partial_byte |= bpsk_slicer(in[i++]) << (d_byte_offset++); + } + + if(d_byte_offset == 8) { + out[bytes_produced++] = d_partial_byte; + d_byte_offset = 0; + d_partial_byte = 0; + } + } + + return bytes_produced; +} + + + +gr_ofdm_frame_sink_sptr +gr_make_ofdm_frame_sink(gr_msg_queue_sptr target_queue, unsigned int occupied_carriers) +{ + return gr_ofdm_frame_sink_sptr(new gr_ofdm_frame_sink(target_queue, occupied_carriers)); +} + + +gr_ofdm_frame_sink::gr_ofdm_frame_sink(gr_msg_queue_sptr target_queue, unsigned int occupied_carriers) + : gr_sync_block ("ofdm_frame_sink", + gr_make_io_signature2 (2, 2, sizeof(gr_complex)*occupied_carriers, sizeof(char)), + gr_make_io_signature (0, 0, 0)), + d_target_queue(target_queue), d_occupied_carriers(occupied_carriers), + d_byte_offset(0), d_partial_byte(0) +{ + d_bytes_out = new unsigned char[(int)ceil(d_occupied_carriers/8.0)]; + + enter_search(); +} + +gr_ofdm_frame_sink::~gr_ofdm_frame_sink () +{ + delete [] d_bytes_out; +} + +int +gr_ofdm_frame_sink::work (int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) +{ + const gr_complex *in = (const gr_complex *) input_items[0]; + const char *sig = (const char *) input_items[1]; + int count_tones=0, count_items=0; + unsigned int j = 0; + unsigned int bytes=0; + + if (VERBOSE) + fprintf(stderr,">>> Entering state machine\n"); + + bytes = bpsk_demapper(&in[0], d_bytes_out); + + switch(d_state) { + + case STATE_SYNC_SEARCH: // Look for flag indicating beginning of pkt + if (VERBOSE) + fprintf(stderr,"SYNC Search, noutput=%d\n", noutput_items); + + if (sig[0]) { // Found it, set up for header decode + enter_have_sync(); + } + break; + + case STATE_HAVE_SYNC: + if(sig[0]) + printf("ERROR -- Found SYNC in HAVE_SYNC\n"); + if (VERBOSE) + fprintf(stderr,"Header Search bitcnt=%d, header=0x%08x\n", + d_headerbytelen_cnt, d_header); + + j = 0; + while(j < bytes) { + d_header = (d_header << 8) | (d_bytes_out[j] & 0xFF); + j++; + + if (++d_headerbytelen_cnt == HEADERBYTELEN) { + + if (VERBOSE) + fprintf(stderr, "got header: 0x%08x\n", d_header); + + // we have a full header, check to see if it has been received properly + if (header_ok()){ + enter_have_header(); + printf("\nPacket Length: %d\n", d_packetlen); + //for(int k=0; k < d_packetlen; k++) + // printf("%02x", d_packet[k]); + //printf("\n"); + + while((j < bytes) && (d_packetlen_cnt < d_packetlen)) { + d_packet[d_packetlen_cnt++] = d_bytes_out[j++]; + } + + if(d_packetlen_cnt == d_packetlen) { + gr_message_sptr msg = + gr_make_message(0, d_packet_whitener_offset, 0, d_packetlen); + memcpy(msg->msg(), d_packet, d_packetlen_cnt); + d_target_queue->insert_tail(msg); // send it + msg.reset(); // free it up + + enter_search(); + } + } + else { + enter_search(); // bad header + } + } + } + break; + + case STATE_HAVE_HEADER: + if(sig[0]) + printf("ERROR -- Found SYNC in HAVE_HEADER at %d, length of %d\n", d_packetlen_cnt, d_packetlen); + if (VERBOSE) + fprintf(stderr,"Packet Build\n"); + + j = 0; + while(j < bytes) { + d_packet[d_packetlen_cnt++] = d_bytes_out[j++]; + + if (d_packetlen_cnt == d_packetlen){ // packet is filled + // build a message + // NOTE: passing header field as arg1 is not scalable + gr_message_sptr msg = + gr_make_message(0, d_packet_whitener_offset, 0, d_packetlen_cnt); + memcpy(msg->msg(), d_packet, d_packetlen_cnt); + + d_target_queue->insert_tail(msg); // send it + msg.reset(); // free it up + + enter_search(); + break; + } + } + break; + + default: + assert(0); + + } // switch + + return 1; +} diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.h b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.h new file mode 100644 index 000000000..d77c76741 --- /dev/null +++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.h @@ -0,0 +1,105 @@ +/* -*- c++ -*- */ +/* + * Copyright 2005,2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio 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 2, or (at your option) + * any later version. + * + * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_GR_OFDM_FRAME_SINK_H +#define INCLUDED_GR_OFDM_FRAME_SINK_H + +#include <gr_sync_block.h> +#include <gr_msg_queue.h> + +class gr_ofdm_frame_sink; +typedef boost::shared_ptr<gr_ofdm_frame_sink> gr_ofdm_frame_sink_sptr; + +gr_ofdm_frame_sink_sptr +gr_make_ofdm_frame_sink (gr_msg_queue_sptr target_queue, unsigned int occupied_tones); + +/*! + * \brief Given a stream of bits and access_code flags, assemble packets. + * \ingroup sink + * + * input: stream of bytes from gr_correlate_access_code_bb + * output: none. Pushes assembled packet into target queue + * + * The framer expects a fixed length header of 2 16-bit shorts + * containing the payload length, followed by the payload. If the + * 2 16-bit shorts are not identical, this packet is ignored. Better + * algs are welcome. + * + * The input data consists of bytes that have two bits used. + * Bit 0, the LSB, contains the data bit. + * Bit 1 if set, indicates that the corresponding bit is the + * the first bit of the packet. That is, this bit is the first + * one after the access code. + */ +class gr_ofdm_frame_sink : public gr_sync_block +{ + friend gr_ofdm_frame_sink_sptr + gr_make_ofdm_frame_sink (gr_msg_queue_sptr target_queue, unsigned int occupied_tones); + + private: + enum state_t {STATE_SYNC_SEARCH, STATE_HAVE_SYNC, STATE_HAVE_HEADER}; + + static const int MAX_PKT_LEN = 4096; + static const int HEADERBYTELEN = 4; + + gr_msg_queue_sptr d_target_queue; // where to send the packet when received + state_t d_state; + unsigned int d_header; // header bits + int d_headerbytelen_cnt; // how many so far + + unsigned char *d_bytes_out; // hold the current bytes produced by the demapper + + unsigned int d_occupied_carriers; + unsigned int d_byte_offset; + unsigned int d_partial_byte; + + unsigned char d_packet[MAX_PKT_LEN]; // assembled payload + int d_packetlen; // length of packet + int d_packet_whitener_offset; // offset into whitener string to use + int d_packetlen_cnt; // how many so far + + protected: + gr_ofdm_frame_sink(gr_msg_queue_sptr target_queue, unsigned int occupied_tones); + + void enter_search(); + void enter_have_sync(); + void enter_have_header(); + + bool header_ok() + { + // confirm that two copies of header info are identical + return ((d_header >> 16) ^ (d_header & 0xffff)) == 0; + } + + unsigned char bpsk_slicer(gr_complex x); + unsigned int bpsk_demapper(const gr_complex *in, + unsigned char *out); + + public: + ~gr_ofdm_frame_sink(); + + int work(int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); +}; + +#endif /* INCLUDED_GR_OFDM_FRAME_SINK_H */ diff --git a/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.i b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.i new file mode 100644 index 000000000..b05c8b795 --- /dev/null +++ b/gnuradio-core/src/lib/general/gr_ofdm_frame_sink.i @@ -0,0 +1,35 @@ +/* -*- c++ -*- */ +/* + * Copyright 2004,2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio 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 2, or (at your option) + * any later version. + * + * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +GR_SWIG_BLOCK_MAGIC(gr,ofdm_frame_sink); + +gr_ofdm_frame_sink_sptr +gr_make_ofdm_frame_sink(gr_msg_queue_sptr target_queue, unsigned int occupied_tones); + +class gr_ofdm_frame_sink : public gr_sync_block +{ + protected: + gr_ofdm_frame_sink(gr_msg_queue_sptr target_queue, unsigned int occupied_tones); + + public: + ~gr_ofdm_frame_sink(); +}; diff --git a/gnuradio-core/src/lib/general/gr_ofdm_sampler.cc b/gnuradio-core/src/lib/general/gr_ofdm_sampler.cc index 9ac5abdcd..5f5a91fd2 100644 --- a/gnuradio-core/src/lib/general/gr_ofdm_sampler.cc +++ b/gnuradio-core/src/lib/general/gr_ofdm_sampler.cc @@ -38,7 +38,7 @@ gr_make_ofdm_sampler (unsigned int fft_length, gr_ofdm_sampler::gr_ofdm_sampler (unsigned int fft_length, unsigned int symbol_length) : gr_block ("ofdm_sampler", - gr_make_io_signature (2, 2, sizeof (gr_complex)), + gr_make_io_signature2 (2, 2, sizeof (gr_complex), sizeof(char)), gr_make_io_signature (1, 1, sizeof (gr_complex)*fft_length)), d_fft_length(fft_length), d_symbol_length(symbol_length) { @@ -61,7 +61,7 @@ gr_ofdm_sampler::general_work (int noutput_items, gr_vector_void_star &output_items) { gr_complex *iptr = (gr_complex *) input_items[0]; - gr_complex *trigger = (gr_complex *) input_items[1]; + char *trigger = (char *) input_items[1]; gr_complex *optr = (gr_complex *) output_items[0]; @@ -70,7 +70,7 @@ gr_ofdm_sampler::general_work (int noutput_items, unsigned int i=d_fft_length-1; while(!found && i<std::min(ninput_items[0],ninput_items[1]) ) - if(trigger[i].real() > 0.5) + if(trigger[i]) found = 1; else i++; diff --git a/gnuradio-core/src/lib/general/gr_skiphead.cc b/gnuradio-core/src/lib/general/gr_skiphead.cc index 4a1f87511..e395cbf66 100644 --- a/gnuradio-core/src/lib/general/gr_skiphead.cc +++ b/gnuradio-core/src/lib/general/gr_skiphead.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2005 Free Software Foundation, Inc. + * Copyright 2005,2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -26,45 +26,57 @@ #include <gr_skiphead.h> #include <gr_io_signature.h> -gr_skiphead::gr_skiphead (size_t sizeof_stream_item, int nitems) - : gr_sync_block ("skiphead", - gr_make_io_signature (1, 1, sizeof_stream_item), - gr_make_io_signature (1, 1, sizeof_stream_item)), - d_nitems (nitems), d_nskipped_items (0) +gr_skiphead::gr_skiphead (size_t itemsize, size_t nitems_to_skip) + : gr_block ("skiphead", + gr_make_io_signature(1, 1, itemsize), + gr_make_io_signature(1, 1, itemsize)), + d_nitems_to_skip(nitems_to_skip), d_nitems(0) { } -gr_block_sptr -gr_make_skiphead (size_t sizeof_stream_item, int nitems) +gr_skiphead_sptr +gr_make_skiphead (size_t itemsize, size_t nitems_to_skip) { - return gr_block_sptr (new gr_skiphead (sizeof_stream_item, nitems)); + return gr_skiphead_sptr (new gr_skiphead (itemsize, nitems_to_skip)); } int -gr_skiphead::work (int noutput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) +gr_skiphead::general_work(int noutput_items, + gr_vector_int &ninput_items_ignored, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items) { - int items_to_skip = d_nitems - d_nskipped_items; - if (items_to_skip <=0) - { - //Done with skipping, copy all input to the output; - memcpy (output_items[0], input_items[0], noutput_items * input_signature()->sizeof_stream_item (0)); - return noutput_items; - } else if (items_to_skip < noutput_items) - { - memcpy (output_items[0], &(((char *)input_items[0])[items_to_skip*input_signature()->sizeof_stream_item (0)]), (noutput_items -items_to_skip) * input_signature()->sizeof_stream_item (0)); - //memcpy (output_items[0], &((input_items[0])[items_to_skip]), (noutput_items -items_to_skip) * input_signature()->sizeof_stream_item (0)); - //memcpy (output_items[0], input_items[0]+items_to_skip*input_signature()->sizeof_stream_item (0), (noutput_items -items_to_skip) * input_signature()->sizeof_stream_item (0)); - d_nskipped_items += items_to_skip; - consume_each (items_to_skip); - return (noutput_items -items_to_skip); - } else - { - d_nskipped_items += noutput_items; - consume_each (items_to_skip); - return 0; + const char *in = (const char *) input_items[0]; + char *out = (char *) output_items[0]; + + int ninput_items = noutput_items; // we've got at least this many input items + int ii = 0; // input index + + while (ii < ninput_items){ + + long long ni_total = ii + d_nitems; // total items processed so far + if (ni_total < d_nitems_to_skip){ // need to skip some more + + int n_to_skip = (int) std::min(d_nitems_to_skip - ni_total, + (long long)(ninput_items - ii)); + ii += n_to_skip; + } + + else { // nothing left to skip. copy away + + int n_to_copy = ninput_items - ii; + if (n_to_copy > 0){ + size_t itemsize = output_signature()->sizeof_stream_item(0); + memcpy(out, in + (ii*itemsize), n_to_copy*itemsize); + } + + d_nitems += ninput_items; + consume_each(ninput_items); + return n_to_copy; + } } - return -1;//Should never get here + d_nitems += ninput_items; + consume_each(ninput_items); + return 0; } diff --git a/gnuradio-core/src/lib/general/gr_skiphead.h b/gnuradio-core/src/lib/general/gr_skiphead.h index 81898ef40..6e2c78272 100644 --- a/gnuradio-core/src/lib/general/gr_skiphead.h +++ b/gnuradio-core/src/lib/general/gr_skiphead.h @@ -26,6 +26,10 @@ #include <gr_sync_block.h> #include <stddef.h> // size_t +class gr_skiphead; +typedef boost::shared_ptr<gr_skiphead> gr_skiphead_sptr; + + /*! * \brief skips the first N items, from then on copies items to the output * \ingroup block @@ -33,22 +37,24 @@ * Useful for building test cases and sources which have metadata or junk at the start */ -class gr_skiphead : public gr_sync_block +class gr_skiphead : public gr_block { - friend gr_block_sptr gr_make_skiphead (size_t sizeof_stream_item, int nitems); - gr_skiphead (size_t sizeof_stream_item, int nitems); + friend gr_skiphead_sptr gr_make_skiphead (size_t itemsize, size_t nitems_to_skip); + gr_skiphead (size_t itemsize, size_t nitems_to_skip); - int d_nitems; - int d_nskipped_items; + long long d_nitems_to_skip; + long long d_nitems; // total items seen public: - int work (int noutput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + + int general_work(int noutput_items, + gr_vector_int &ninput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); }; -gr_block_sptr -gr_make_skiphead (size_t sizeof_stream_item, int nitems); +gr_skiphead_sptr +gr_make_skiphead (size_t itemsize, size_t nitems_to_skip); #endif /* INCLUDED_GR_SKIPHEAD_H */ diff --git a/gnuradio-core/src/lib/general/gr_skiphead.i b/gnuradio-core/src/lib/general/gr_skiphead.i index 8942f184e..c725e26bb 100644 --- a/gnuradio-core/src/lib/general/gr_skiphead.i +++ b/gnuradio-core/src/lib/general/gr_skiphead.i @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2005 Free Software Foundation, Inc. + * Copyright 2005,2007 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -20,11 +20,11 @@ * Boston, MA 02110-1301, USA. */ -%ignore gr_skiphead; +GR_SWIG_BLOCK_MAGIC(gr,skiphead); + +gr_skiphead_sptr gr_make_skiphead (size_t itemsize, size_t nitems_to_skip); + class gr_skiphead : public gr_block { - friend gr_block_sptr gr_make_skiphead (size_t sizeof_stream_item, int nitems); - gr_skiphead (size_t sizeof_stream_item, int nitems); + friend gr_skiphead_sptr gr_make_skiphead (size_t itemsize, size_t nitems_to_skip); + gr_skiphead (size_t itemsize, size_t nitems_to_skip); }; - -%rename(skiphead) gr_make_skiphead; -gr_block_sptr gr_make_skiphead (size_t sizeof_stream_item, int nitems); diff --git a/gnuradio-core/src/lib/general/gr_stream_mux.cc b/gnuradio-core/src/lib/general/gr_stream_mux.cc index 1eaad29a2..e7e45de74 100644 --- a/gnuradio-core/src/lib/general/gr_stream_mux.cc +++ b/gnuradio-core/src/lib/general/gr_stream_mux.cc @@ -44,6 +44,10 @@ gr_stream_mux::gr_stream_mux (size_t itemsize, const std::vector<int> &lengths) d_residual(0), d_lengths(lengths) { + if(d_lengths[d_stream] == 0) { + increment_stream(); + } + d_residual = d_lengths[d_stream]; } gr_stream_mux::~gr_stream_mux(void) @@ -55,9 +59,17 @@ gr_stream_mux::forecast (int noutput_items, gr_vector_int &ninput_items_required { unsigned ninputs = ninput_items_required.size (); for (unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = 0; + ninput_items_required[i] = (d_lengths[i] == 0 ? 0 : 1); } +void gr_stream_mux::increment_stream() +{ + do { + d_stream = (d_stream+1) % d_lengths.size(); + } while(d_lengths[d_stream] == 0); + + d_residual = d_lengths[d_stream]; +} int gr_stream_mux::general_work(int noutput_items, @@ -65,128 +77,46 @@ gr_stream_mux::general_work(int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) { - char *out = (char *) output_items[0]; const char *in; + int out_index = 0; + std::vector<int> input_index(d_lengths.size(), 0); - int acc = 0; - int N=0; - int M=0; - std::vector<int> consume_vector(d_lengths.size(), 0); + if(VERBOSE) { + printf("mux: nouput_items: %d d_stream: %d\n", noutput_items, d_stream); + for(size_t i = 0; i < d_lengths.size(); i++) + printf("\tninput_items[%d]: %d\n", i, ninput_items[i]); + } - #if VERBOSE - printf("mux: nouput_items: %d d_stream: %d\n", noutput_items, d_stream); - for(int i = 0; i < d_lengths.size(); i++) - printf("\tninput_items[%d]: %d\n", i, ninput_items[i]); - #endif + while (1) { + int r = std::min(noutput_items - out_index, + std::min(d_residual, + ninput_items[d_stream] - input_index[d_stream])); + if(VERBOSE) { + printf("mux: r=%d\n", r); + printf("\tnoutput_items - out_index: %d\n", + noutput_items - out_index); + printf("\td_residual: %d\n", + d_residual); + printf("\tninput_items[d_stream] - input_index[d_stream]: %d\n", + ninput_items[d_stream] - input_index[d_stream]); + } - in = (const char *) input_items[d_stream]; + if(r <= 0) { + return out_index; + } - if(d_residual) { - #if VERBOSE - printf("Cleaning up residual bytes (%d) from stream %d\n", d_residual, d_stream); - #endif + in = (const char *) input_items[d_stream] + input_index[d_stream]*d_itemsize; - // get the number of items available in input stream up to the - // num items required - N=std::min(d_residual, ninput_items[d_stream]); - - // get the number of items we can put into the output buffer - M=std::min(N, noutput_items); - - // copy the items to the output buff - memcpy(out, in, M*d_itemsize); + memcpy(&out[out_index*d_itemsize], in, r*d_itemsize); + out_index += r; + input_index[d_stream] += r; + d_residual -= r; - // increment the output accumulator - acc += M; - - // keep track of items consumed - consume_vector[d_stream]=M; + consume(d_stream, r); - // keep track if there are residual items left from the input stream - d_residual -= M; - - #if VERBOSE - printf("Stream: %d (%x) Wrote: %d bytes Output has: %d bytes residual: %d bytes\n", - d_stream, in, M, acc, d_residual); - #endif - - // if no residual items, we're done with this input stream for - // this round - if (!d_residual) { - if(d_stream == d_lengths.size() - 1) { - d_stream=0; // wrap stream pointer - } - else { - d_stream++; // or increment the stream pointer - } - #if VERBOSE - printf("Going to next stream: %d\n", d_stream); - #endif - in = ((const char *) (input_items[d_stream])) + d_itemsize*consume_vector[d_stream]; - } - } - - if(!d_residual) { - while (acc<noutput_items){ - // get the number of items available in input stream up to the - // num items required - N=std::min(d_lengths[d_stream], ninput_items[d_stream]); - - // get the number of items we can put into the output buffer - M=std::min(N, noutput_items-acc); - - // copy the items to the output buff - memcpy(out+acc*d_itemsize,in,M*d_itemsize); - - // increment the output accumulator - acc += M; - - // keep track of items consumed - consume_vector[d_stream]+=M; - - // keep track if there are residual items left from the input stream - d_residual=d_lengths[d_stream] - M; - - #if VERBOSE - printf("Stream: %d (%x) Wrote: %d bytes Output has: %d bytes residual: %d bytes\n", - d_stream, in, M, acc, d_residual); - #endif - - // if no residual items, we're done with this input stream for - // this round - if (!d_residual) { - if(d_stream == d_lengths.size() - 1) { - d_stream=0; // wrap stream pointer - } - else { - d_stream++; // or increment the stream pointer - } - #if VERBOSE - printf("Going to next stream: %d\n", d_stream); - #endif - - // get next stream pointer - in = ((const char *) (input_items[d_stream])) + d_itemsize*consume_vector[d_stream]; - } - else{ - break; - } + if(d_residual == 0) { + increment_stream(); } } - - for (unsigned int j=0;j<d_lengths.size();j++){ - consume(j,consume_vector[j]); - - #if VERBOSE - printf("consuming: %d on stream: %d\n", consume_vector[j], j); - #endif - } - - #if VERBOSE - printf("mux: returning: %d\n\n", acc); - #endif - - return acc; - } diff --git a/gnuradio-core/src/lib/general/gr_stream_mux.h b/gnuradio-core/src/lib/general/gr_stream_mux.h index 492940001..5ea783cb6 100644 --- a/gnuradio-core/src/lib/general/gr_stream_mux.h +++ b/gnuradio-core/src/lib/general/gr_stream_mux.h @@ -25,7 +25,6 @@ #include <gr_block.h> -#include <gr_frame.h> #include <vector> class gr_stream_mux; @@ -66,14 +65,15 @@ class gr_stream_mux : public gr_block protected: gr_stream_mux (size_t itemsize, const std::vector<int> &lengths); + private: - size_t d_itemsize; - unsigned int d_stream; - int d_residual; - int d_times; - int d_unconsume; - //gr_vector_int d_unconsume; - gr_vector_int d_lengths; + size_t d_itemsize; + unsigned int d_stream; // index of currently selected stream + int d_residual; // number if items left to put into current stream + gr_vector_int d_lengths; // number if items to pack per stream + + void increment_stream(); + public: ~gr_stream_mux(void); |