- <timestamp>Tue May 7 15:42:23 2013</timestamp>

- <key>variable_slider</key>

- <value>freq_offset</value>

- <key>label</key>

- <value>Frequency Offset (Multiples of Sub-carrier spacing)</value>

- <key>value</key>

- <key>min</key>

- <value>-3</value>

- <key>max</key>

- <value>3</value>

- <key>num_steps</key>

- <value>100</value>

- <key>style</key>

- <value>wx.SL_HORIZONTAL</value>

- <key>converver</key>

- <value>float_converter</value>

- <key>grid_pos</key>

- <value></value>

- <key>notebook</key>

- <value></value>

- <value>(652, 285)</value>

- <key>variable_slider</key>

- <value>noise_voltage</value>

- <key>label</key>

- <value>Noise Amplitude</value>

- <key>value</key>

- <value>0.01</value>

- <key>min</key>

- <key>max</key>

- <value>1</value>

- <key>num_steps</key>

- <value>100</value>

- <key>style</key>

- <value>wx.SL_HORIZONTAL</value>

- <key>converver</key>

- <value>float_converter</value>

- <value>(651, 416)</value>

- <key>import</key>

- <value>import_0</value>

- <key>import</key>

- <value>import numpy</value>

- </param>

- <param>

- <key>_coordinate</key>

- <value>(536, -1)</value>

- <key>_rotation</key>

- <value>0</value>

- </block>

- <block>

- <key>import</key>

- <key>id</key>

- <value>import_0_0</value>

- <key>_enabled</key>

- <key>import</key>

- <value>from gnuradio.digital.utils import tagged_streams</value>

- <value>(633, -1)</value>

- <key>digital_ofdm_tx</key>

- <value>digital_ofdm_tx_0</value>

- <value>len_tag_key</value>

- <key>rolloff</key>

- <value>0</value>

- </param>

- <param>

- <value>(390, 78)</value>

- <key>blocks_float_to_uchar</key>

- <value>blocks_float_to_uchar_0</value>

- <value>(230, 119)</value>

- <key>variable</key>

- <value>tx_signal</value>

- <key>value</key>

- <value>[numpy.sin(2 * numpy.pi * 1.0/8 * x) for x in range(8*2)]</value>

- </param>

- <param>

- <key>_coordinate</key>

- <value>(176, -1)</value>

- <key>_rotation</key>

- </block>

- <block>

- <key>blocks_vector_source_x</key>

- <key>id</key>

- <value>blocks_vector_source_x_0</value>

- <key>_enabled</key>

- <value>True</value>

- <key>type</key>

- <value>float</value>

- <key>vector</key>

- <value>tx_signal</value>

- <key>tags</key>

- <value>tagged_streams.make_lengthtags((8*2*gr.sizeof_float,), (0,), tagname=len_tag_key)</value>

- <key>repeat</key>

- <value>True</value>

- <key>vlen</key>

- <value>1</value>

- <value>(-1, 101)</value>

- <key>blocks_throttle</key>

- <value>blocks_throttle_0</value>

- <key>type</key>

- <value>complex</value>

- <key>samples_per_second</key>

- <value>100e3</value>

- <key>vlen</key>

- <value>(354, 230)</value>

- <value>180</value>

- <key>blocks_tag_gate</key>

- <value>blocks_tag_gate_0</value>

- <value>complex</value>

- <key>vlen</key>

- <value>1</value>

- <key>propagate_tags</key>

- <value>False</value>

- <value>(539, 230)</value>

- <value>180</value>

- <key>wxgui_fftsink2</key>

- <value>wxgui_fftsink2_0</value>

- <value>complex</value>

- <value>Rx Spectrum</value>

- <value>100e3</value>

- <key>baseband_freq</key>

- <key>y_per_div</key>

- <value>10</value>

- </param>

- <param>

- <key>y_divs</key>

- <value>10</value>

- </param>

- <param>

- <key>ref_level</key>

- <key>ref_scale</key>

- <value>2.0</value>

- </param>

- <param>

- <key>fft_size</key>

- <value>1024</value>

- </param>

- <param>

- <key>fft_rate</key>

- <value>15</value>

- <key>peak_hold</key>

- <key>average</key>

- <key>avg_alpha</key>

- <value>0</value>

- </param>

- <param>

- <key>win</key>

- <value>None</value>

- <key>freqvar</key>

- <value>None</value>

- <value>(92, 463)</value>

- <key>channel_model</key>

- <value>chan_model</value>

- <key>noise_voltage</key>

- <value>noise_voltage</value>

- <key>freq_offset</key>

- <value>1.0/fft_len * freq_offset</value>

- <key>epsilon</key>

- <value>1.0</value>

- <key>taps</key>

- <value>1.0</value>

- <key>seed</key>

- <value>0</value>

- <value>(615, 86)</value>

- <key>digital_ofdm_rx</key>

- <value>digital_ofdm_rx_0</value>

- <value>False</value>

- <value>"rx_len"</value>

- <key>log</key>

- <value>False</value>

- </param>

- <param>

- <key>_coordinate</key>

- <value>(92, 307)</value>

- </param>

- <param>

- <key>_rotation</key>

- </block>

- <block>

- <key>blocks_uchar_to_float</key>

- <param>

- <key>id</key>

- <value>blocks_uchar_to_float_0</value>

- </param>

- <key>_enabled</key>

- <value>(332, 340)</value>

- <key>blocks_tag_debug</key>

- <value>blocks_tag_debug_0</value>

- <value>False</value>

- <value>byte</value>

- </param>

- <param>

- <key>name</key>

- <value>Rx Packets</value>

- </param>

- <param>

- <key>num_inputs</key>

- <value>1</value>

- <key>display</key>

- <value>True</value>

- <value>(336, 412)</value>

- <value>0</value>

- <key>wxgui_scopesink2</key>

- <value>wxgui_scopesink2_0</value>

- <value>False</value>

- <key>type</key>

- <value>float</value>

- <key>title</key>

- <value>Scope Plot</value>

- <key>samp_rate</key>

- <key>v_scale</key>

- <value>0</value>

- </param>

- <param>

- <key>v_offset</key>

- <value>0</value>

- <key>t_scale</key>

- <key>ac_couple</key>

- <value>False</value>

- </param>

- <param>

- <key>xy_mode</key>

- <value>False</value>

- </param>

- <param>

- <key>num_inputs</key>

- <value>1</value>

- </param>

- <param>

- <key>win_size</key>

- <value></value>

- </param>

- <param>

- <key>grid_pos</key>

- <value></value>

- </param>

- <param>

- <key>notebook</key>

- <value></value>

- </param>

- <param>

- <key>trig_mode</key>

- <value>gr.gr_TRIG_MODE_AUTO</value>

- </param>

- <param>

- <key>y_axis_label</key>

- <value>Counts</value>

- </param>

- <param>

- <value>(504, 314)</value>

- <source_block_id>blocks_vector_source_x_0</source_block_id>

- <sink_block_id>blocks_float_to_uchar_0</sink_block_id>

- <source_block_id>digital_ofdm_tx_0</source_block_id>

- <sink_block_id>chan_model</sink_block_id>

- <source_block_id>blocks_float_to_uchar_0</source_block_id>

- <sink_block_id>digital_ofdm_tx_0</sink_block_id>

- <source_block_id>blocks_throttle_0</source_block_id>

- <sink_block_id>digital_ofdm_rx_0</sink_block_id>

- <source_block_id>blocks_throttle_0</source_block_id>

- <sink_block_id>wxgui_fftsink2_0</sink_block_id>

- <source_block_id>digital_ofdm_rx_0</source_block_id>

- <sink_block_id>blocks_uchar_to_float_0</sink_block_id>

- <source_block_id>blocks_uchar_to_float_0</source_block_id>

- <sink_block_id>wxgui_scopesink2_0</sink_block_id>

- <source_block_id>digital_ofdm_rx_0</source_block_id>

- <sink_block_id>blocks_tag_debug_0</sink_block_id>

- <source_block_id>chan_model</source_block_id>

- <sink_block_id>blocks_tag_gate_0</sink_block_id>

- <source_block_id>blocks_tag_gate_0</source_block_id>

- <sink_block_id>blocks_throttle_0</sink_block_id>

- <name>Synchronisation preamble symbol 1</name>

- <name>Synchronisation preamble symbol 2</name>

- <make>digital.ofdm_frame_equalizer_vcvc($equalizer, $cp_len, $len_tag_key, $propagate_channel_state)</make>

- digital_ofdm_chanest_vcvc.h

- header_payload_demux.h

- DESTINATION ${GR_INCLUDE_DIR}/gnuradio/digital

-/* -*- c++ -*- */

-/* Copyright 2012 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 3, 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_DIGITAL_OFDM_CHANEST_VCVC_H

-#define INCLUDED_DIGITAL_OFDM_CHANEST_VCVC_H

-

-#include <digital_api.h>

-#include <gr_block.h>

-

-class digital_ofdm_chanest_vcvc;

-

-typedef boost::shared_ptr<digital_ofdm_chanest_vcvc> digital_ofdm_chanest_vcvc_sptr;

-

-/*

- * \param sync_symbol1 First synchronisation symbol in the frequency domain. Its length must be

- * the FFT length. For Schmidl & Cox synchronisation, every second sub-carrier

- * has to be zero.

- * \param sync_symbol2 Second synchronisation symbol in the frequency domain. Must be equal to

- * the FFT length, or zero length if only one synchronisation symbol is used.

- * Using this symbol is how synchronisation is described in [1]. Leaving this

- * empty forces us to interpolate the equalizer taps.

- * If you are using an unusual sub-carrier configuration (e.g. because of OFDMA),

- * this sync symbol is used to identify the active sub-carriers. If you only

- * have one synchronisation symbol, set the active sub-carriers to a non-zero

- * value in here, and also set \p force_one_sync_symbol parameter to true.

- * \param n_data_symbols The number of data symbols following each set of synchronisation symbols.

- * Must be at least 1.

- * \param eq_noise_red_len If non-zero, noise reduction for the equalizer taps is done according

- * to [2]. In this case, it is the channel influence time in number of

- * samples. A good value is usually the length of the cyclic prefix.

- * \param max_carr_offset Limit the number of sub-carriers the frequency offset can maximally be.

- * Leave this zero to try all possibilities.

- * \param force_one_sync_symbol See \p sync_symbol2.

- */

-DIGITAL_API digital_ofdm_chanest_vcvc_sptr

-digital_make_ofdm_chanest_vcvc (

- const std::vector<gr_complex> &sync_symbol1,

- const std::vector<gr_complex> &sync_symbol2,

- int n_data_symbols,

- int eq_noise_red_len=0,

- int max_carr_offset=-1,

- bool force_one_sync_symbol=false);

-

-/*!

- * \brief Estimate channel and coarse frequency offset for OFDM from preambles

- * \ingroup ofdm_blk

- * \ingroup syncronizers_blk

- *

- * Input: OFDM symbols (in frequency domain). The first one (or two) symbols are expected

- * to be synchronisation symbols, which are used to estimate the coarse freq offset

- * and the initial equalizer taps (these symbols are removed from the stream).

- * The following \p n_data_symbols are passed through unmodified (the actual equalisation

- * must be done elsewhere).

- * Output: The data symbols, without the synchronisation symbols.

- * The first data symbol passed through has two tags:

- * 'ofdm_sync_carr_offset' (integer), the coarse frequency offset as number of carriers,

- * and 'ofdm_sync_eq_taps' (complex vector).

- * Any tags attached to the synchronisation symbols are attached to the first data

- * symbol. All other tags are propagated as expected.

- *

- * Note: The vector on ofdm_sync_eq_taps is already frequency-corrected, whereas the rest is not.

- *

- * This block assumes the frequency offset is even (i.e. an integer multiple of 2).

- *

- * [1] Schmidl, T.M. and Cox, D.C., "Robust frequency and timing synchronization for OFDM",

- * Communications, IEEE Transactions on, 1997.

- * [2] K.D. Kammeyer, "Nachrichtenuebertragung," Chapter. 16.3.2.

- */

-class DIGITAL_API digital_ofdm_chanest_vcvc : public gr_block

-{

- private:

- friend DIGITAL_API digital_ofdm_chanest_vcvc_sptr digital_make_ofdm_chanest_vcvc (const std::vector<gr_complex> &sync_symbol1, const std::vector<gr_complex> &sync_symbol2, int n_data_symbols, int eq_noise_red_len, int max_carr_offset, bool force_one_sync_symbol);

-

- int d_fft_len; //! FFT length

- int d_n_data_syms; //! Number of data symbols following the sync symbol(s)

- int d_n_sync_syms; //! Number of sync symbols (1 or 2)

- //! 0 if no noise reduction is done for the initial channel state estimation. Otherwise, the maximum length of the channel delay in samples.

- int d_eq_noise_red_len;

- //! Is sync_symbol1 if d_n_sync_syms == 1, otherwise sync_symbol2. Used as a reference symbol to estimate the channel.

- std::vector<gr_complex> d_ref_sym;

- //! If d_n_sync_syms == 2 this is used as a differential correlation vector (called 'v' in [1]).

- std::vector<gr_complex> d_corr_v;

- //! If d_n_sync_syms == 1 we use this instead of d_corr_v to estimate the coarse freq. offset

- std::vector<float> d_known_symbol_diffs;

- //! If d_n_sync_syms == 1 we use this instead of d_corr_v to estimate the coarse freq. offset (temp. variable)

- std::vector<float> d_new_symbol_diffs;

- //! The index of the first carrier with data (index 0 is not DC here, but the lowest frequency)

- int d_first_active_carrier;

- //! The index of the last carrier with data

- int d_last_active_carrier;

- //! If true, the channel estimation must be interpolated

- bool d_interpolate;

- //! Maximum carrier offset (negative value!)

- int d_max_neg_carr_offset;

- //! Maximum carrier offset (positive value!)

- int d_max_pos_carr_offset;

-

-

- digital_ofdm_chanest_vcvc(const std::vector<gr_complex> &sync_symbol1, const std::vector<gr_complex> &sync_symbol2, int n_data_symbols, int eq_noise_red_len, int max_carr_offset, bool force_one_sync_symbol);

-

- //! Calculate the coarse frequency offset in number of carriers

- int get_carr_offset(const gr_complex *sync_sym1, const gr_complex *sync_sym2);

- //! Estimate the channel (phase and amplitude offset per carrier)

- void get_chan_taps(const gr_complex *sync_sym1, const gr_complex *sync_sym2, int carr_offset, std::vector<gr_complex> &taps);

-

- public:

- ~digital_ofdm_chanest_vcvc();

-

- void forecast (int noutput_items, gr_vector_int &ninput_items_required);

- int general_work (int noutput_items,

- gr_vector_int &ninput_items,

- gr_vector_const_void_star &input_items,

- gr_vector_void_star &output_items);

-};

-

-#endif /* INCLUDED_DIGITAL_OFDM_CHANEST_VCVC_H */

-

- digital_ofdm_chanest_vcvc.cc

-/* -*- c++ -*- */

-/* Copyright 2012 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 3, 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_io_signature.h>

-#include "digital_ofdm_chanest_vcvc.h"

-

-digital_ofdm_chanest_vcvc_sptr

-digital_make_ofdm_chanest_vcvc (

- const std::vector<gr_complex> &sync_symbol1,

- const std::vector<gr_complex> &sync_symbol2,

- int n_data_symbols,

- int eq_noise_red_len,

- int max_carr_offset,

- bool force_one_sync_symbol)

-{

- return gnuradio::get_initial_sptr (

- new digital_ofdm_chanest_vcvc(

- sync_symbol1,

- sync_symbol2,

- n_data_symbols,

- eq_noise_red_len,

- max_carr_offset,

- force_one_sync_symbol

- )

- );

-}

-

-

-digital_ofdm_chanest_vcvc::digital_ofdm_chanest_vcvc (

- const std::vector<gr_complex> &sync_symbol1,

- const std::vector<gr_complex> &sync_symbol2,

- int n_data_symbols,

- int eq_noise_red_len,

- int max_carr_offset,

- bool force_one_sync_symbol)

- : gr_block ("ofdm_chanest_vcvc",

- gr_make_io_signature(1, 1, sizeof (gr_complex) * sync_symbol1.size()),

- gr_make_io_signature(1, 2, sizeof (gr_complex) * sync_symbol1.size())),

- d_fft_len(sync_symbol1.size()),

- d_n_data_syms(n_data_symbols),

- d_n_sync_syms(1),

- d_eq_noise_red_len(eq_noise_red_len),

- d_ref_sym((sync_symbol2.size() && !force_one_sync_symbol) ? sync_symbol2 : sync_symbol1),

- d_corr_v(sync_symbol2),

- d_known_symbol_diffs(0, 0),

- d_new_symbol_diffs(0, 0),

- d_interpolate(false)

-{

- // Set index of first and last active carrier

- for (int i = 0; i < d_fft_len; i++) {

- if (d_ref_sym[i] != gr_complex(0, 0)) {

- d_first_active_carrier = i;

- break;

- }

- }

- for (int i = d_fft_len-1; i >= 0; i--) {

- if (d_ref_sym[i] != gr_complex(0, 0)) {

- d_last_active_carrier = i;

- break;

- }

- }

-

- // Sanity checks

- if (sync_symbol2.size()) {

- if (sync_symbol1.size() != sync_symbol2.size()) {

- throw std::invalid_argument("sync symbols must have equal length.");

- }

- if (!force_one_sync_symbol) {

- d_n_sync_syms = 2;

- }

- } else {

- if (sync_symbol1[d_first_active_carrier+1] == gr_complex(0, 0)) {

- d_last_active_carrier++;

- d_interpolate = true;

- }

- }

-

- // Set up coarse freq estimation info

- // Allow all possible values:

- d_max_neg_carr_offset = -d_first_active_carrier;

- d_max_pos_carr_offset = d_fft_len - d_last_active_carrier - 1;

- if (max_carr_offset != -1) {

- d_max_neg_carr_offset = std::max(-max_carr_offset, d_max_neg_carr_offset);

- d_max_pos_carr_offset = std::min(max_carr_offset, d_max_pos_carr_offset);

- }

- // Carrier offsets must be even

- if (d_max_neg_carr_offset % 2)

- d_max_neg_carr_offset++;

- if (d_max_pos_carr_offset % 2)

- d_max_pos_carr_offset--;

-

- if (d_n_sync_syms == 2) {

- for (int i = 0; i < d_fft_len; i++) {

- if (sync_symbol1[i] == gr_complex(0, 0)) {

- d_corr_v[i] = gr_complex(0, 0);

- } else {

- d_corr_v[i] /= sync_symbol1[i];

- }

- }

- } else {

- d_corr_v.resize(0, 0);

- d_known_symbol_diffs.resize(d_fft_len, 0);

- d_new_symbol_diffs.resize(d_fft_len, 0);

- for (int i = d_first_active_carrier; i < d_last_active_carrier-2 && i < d_fft_len-2; i += 2) {

- d_known_symbol_diffs[i] = std::norm(sync_symbol1[i] - sync_symbol1[i+2]);

- }

- }

-

- set_relative_rate((double) n_data_symbols / (n_data_symbols + d_n_sync_syms));

- set_tag_propagation_policy(TPP_DONT);

-}

-

-

-digital_ofdm_chanest_vcvc::~digital_ofdm_chanest_vcvc()

-{

-}

-

-void

-digital_ofdm_chanest_vcvc::forecast (int noutput_items, gr_vector_int &ninput_items_required)

-{

- ninput_items_required[0] = (noutput_items/d_n_data_syms) * (d_n_data_syms + d_n_sync_syms);

-}

-

-

-int

-digital_ofdm_chanest_vcvc::get_carr_offset(const gr_complex *sync_sym1, const gr_complex *sync_sym2)

-{

- int carr_offset = 0;

- if (d_corr_v.size()) {

- // Use Schmidl & Cox method

- float Bg_max = 0;

- // g here is 2g in the paper

- for (int g = d_max_neg_carr_offset; g <= d_max_pos_carr_offset; g += 2) {

- gr_complex tmp = gr_complex(0, 0);

- for (int k = 0; k < d_fft_len; k++) {

- if (d_corr_v[k] != gr_complex(0, 0)) {

- tmp += std::conj(sync_sym1[k+g]) * std::conj(d_corr_v[k]) * sync_sym2[k+g];

- }

- }

- if (std::abs(tmp) > Bg_max) {

- Bg_max = std::abs(tmp);

- carr_offset = g;

- }

- }

- } else {

- // Correlate

- std::fill(d_new_symbol_diffs.begin(), d_new_symbol_diffs.end(), 0);

- for(int i = 0; i < d_fft_len-2; i++) {

- d_new_symbol_diffs[i] = std::norm(sync_sym1[i] - sync_sym1[i+2]);

- }

-

- float sum;

- float max = 0;

- for (int g = d_max_neg_carr_offset; g <= d_max_pos_carr_offset; g += 2) {

- sum = 0;

- for (int j = 0; j < d_fft_len; j++) {

- if (d_known_symbol_diffs[j]) {

- sum += (d_known_symbol_diffs[j] * d_new_symbol_diffs[j + g]);

- }

- if(sum > max) {

- max = sum;

- carr_offset = g;

- }

- }

- }

- }

- return carr_offset;

-}

-

-

-void

-digital_ofdm_chanest_vcvc::get_chan_taps(

- const gr_complex *sync_sym1,

- const gr_complex *sync_sym2,

- int carr_offset,

- std::vector<gr_complex> &taps)

-{

- const gr_complex *sym = ((d_n_sync_syms == 2) ? sync_sym2 : sync_sym1);

- std::fill(taps.begin(), taps.end(), gr_complex(0, 0));

- int loop_start = 0;

- int loop_end = d_fft_len;

- if (carr_offset > 0) {

- loop_start = carr_offset;

- } else if (carr_offset < 0) {

- loop_end = d_fft_len + carr_offset;

- }

- for (int i = loop_start; i < loop_end; i++) {

- if ((d_ref_sym[i-carr_offset] != gr_complex(0, 0))) {

- taps[i-carr_offset] = sym[i] / d_ref_sym[i-carr_offset];

- }

- }

-

- if (d_interpolate) {

- // FIXME check this out re offset + update docs

- for (int i = d_first_active_carrier + 1; i < d_last_active_carrier; i += 2) {

- taps[i] = taps[i-1];

- }

- taps[d_last_active_carrier] = taps[d_last_active_carrier-1];

- }

-

- if (d_eq_noise_red_len) {

- // TODO

- // 1) IFFT

- // 2) Set all elements > d_eq_noise_red_len to zero

- // 3) FFT

- }

-}

-

-

-// 1) Go through all the frames available on the input buffer

-// 2) Estimate the coarse freq. offset and the eq. taps from the

-// input symbol(s)

-// 3) Copy the data symbols to the output

-// 4) Copy all other tags onto the output. A tag that was on

-// a sync symbol is copied onto the first data symbol.

-// 5) Add the new tags for carrier offset and eq. taps

-int

-digital_ofdm_chanest_vcvc::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 *in = (const gr_complex *) input_items[0];

- gr_complex *out = (gr_complex *) output_items[0];

- int n_frames = noutput_items/d_n_data_syms;

- const int framesize = d_n_sync_syms + d_n_data_syms;

-

- for (int i = 0; i < n_frames; i++) {

- int carr_offset = 0;

- if (d_max_neg_carr_offset || d_max_pos_carr_offset)

- carr_offset = get_carr_offset(in, in+d_fft_len);

- std::vector<gr_complex> chan_taps(d_fft_len, 0);

- get_chan_taps(in, in+d_fft_len, carr_offset, chan_taps);

-

- if (output_items.size() == 2) {

- gr_complex *out_chantaps = ((gr_complex *) output_items[1]) + i * d_fft_len;

- memcpy((void *) out_chantaps, (void *) &chan_taps[0], sizeof(gr_complex) * d_fft_len);

- produce(1, 1);

- }

-

- memcpy((void *) out,

- (void *) &in[d_n_sync_syms * d_fft_len],

- sizeof(gr_complex) * d_fft_len * d_n_data_syms);

- in += framesize * d_fft_len;

- out += d_n_data_syms * d_fft_len;

-

- std::vector<gr_tag_t> tags;

- get_tags_in_range(tags, 0,

- nitems_read(0)+i*framesize,

- nitems_read(0)+(i+1)*framesize);

- for (unsigned t = 0; t < tags.size(); t++) {

- int offset = tags[t].offset - (nitems_read(0) + i*framesize);

- if (offset < d_n_sync_syms) {

- offset = 0;

- } else {

- offset -= d_n_sync_syms;

- }

- tags[t].offset = offset + nitems_written(0) + i*d_n_data_syms;

- add_item_tag(0, tags[t]);

- }

-

- add_item_tag(0, nitems_written(0) + i*d_n_data_syms,

- pmt::pmt_string_to_symbol("ofdm_sync_carr_offset"),

- pmt::pmt_from_long(carr_offset));

- add_item_tag(0, nitems_written(0) + i*d_n_data_syms,

- pmt::pmt_string_to_symbol("ofdm_sync_chan_taps"),

- pmt::pmt_init_c32vector(d_fft_len, chan_taps));

- }

- produce(0, n_frames * d_n_data_syms);

- consume_each(n_frames * framesize);

-

- return WORK_CALLED_PRODUCE;

-}

-

- set_output_multiple(d_items_per_symbol);

- // noutput_items is an integer multiple of d_items_per_symbol!

- ninput_items_required[i] =

- noutput_items / d_items_per_symbol * (d_items_per_symbol + d_gi);

-

- // FIXME ninput_items[1] does not have to be defined O_o

- while (nread < noutput_items && nread < ninput_items[0] && nread < ninput_items[1] && !exit_loop) {

- case STATE_IDLE:

- // 1) Search for a trigger signal on input 1 (if present)

- // 2) Search for a trigger tag, make sure it's the first one

- // The first trigger to be found is used!

- // 3) Make sure the right number of items is skipped

- // 4) If trigger found, switch to STATE_HEADER

- if (find_trigger_signal(nread, noutput_items, input_items)) {

- d_remaining_symbols = d_header_len;

- d_state = STATE_HEADER;

- in += nread * d_itemsize;

- }

- break;

- case STATE_HEADER:

- copy_symbol(in, out_header, 0, nread, produced_hdr);

- if (d_remaining_symbols == 0) {

- d_state = STATE_WAIT_FOR_MSG;

- exit_loop = true;

- }

- break;

- case STATE_WAIT_FOR_MSG:

- if (empty_p(msg_port_id)) return 0; //no message available

- // If we're in this state, nread is zero (because previous state exits loop)

- // 1) Wait for msg (blocking call)

- // 2) set d_remaining_symbols

- // 3) Write tags

- // 4) fall through to next state

- d_remaining_symbols = -1;

- if (!parse_header_data_msg()) {

- d_state = STATE_IDLE;

- exit_loop = true;

- break;

- }

- d_state = STATE_PAYLOAD;

- case STATE_PAYLOAD:

- copy_symbol(in, out_payload, 1, nread, produced_payload);

- if (d_remaining_symbols == 0) {

- d_state = STATE_IDLE;

- exit_loop = true;

- }

- break;

- default:

- throw std::runtime_error("invalid state");

- pmt::pmt_t msg(delete_head_blocking(msg_port_id));

- self.connect((chanest, 1), blocks.file_sink(512, 'channel-estimate.dat'))

- self.connect((chanest, 0), blocks.file_sink(512, 'post-hdr-chanest.dat'))

- self.connect(header_eq, blocks.file_sink(512, 'post-hdr-eq.dat'))

- self.connect(header_serializer, blocks.file_sink(8, 'post-hdr-serializer.dat'))

- self.connect(header_demod, blocks.file_sink(1, 'post-hdr-demod.dat'))

- self.connect((hpd, 1), blocks.tag_debug(8*64, 'post-hpd'));

- self.connect(payload_fft, blocks.file_sink(8*64, 'post-payload-fft.dat'))

- self.connect(payload_eq, blocks.file_sink(8*64, 'post-payload-eq.dat'))

- self.connect(payload_serializer, blocks.file_sink(8, 'post-payload-serializer.dat'))

- self.connect(payload_demod, blocks.file_sink(1, 'post-payload-demod.dat'))

- self.connect(repack, blocks.file_sink(1, 'post-payload-repack.dat'))

- self.connect(crc, blocks.file_sink(1, 'post-payload-crc.dat'))

- self.connect(crc, blocks.tag_debug(1, 'post-payload-crc'))

- detected_tags = {

- 'ofdm_sync_carr_offset': False,

- 'test_tag_1': False,

- 'test_tag_2': False

- }

- if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset':

- carr_offset_hat = pmt.pmt_to_long(tag.value)

- self.assertEqual(pmt.pmt_to_long(tag.value), carr_offset)

- if pmt.pmt_symbol_to_string(tag.key) == 'test_tag_1':

- self.assertEqual(tag.offset, 0)

- if pmt.pmt_symbol_to_string(tag.key) == 'test_tag_2':

- self.assertEqual(tag.offset, 0)

- detected_tags[pmt.pmt_symbol_to_string(tag.key)] = True

- self.assertTrue(all(detected_tags.values()))

-/* -*- c++ -*- */

-/* Copyright 2012 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 3, 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(digital, ofdm_chanest_vcvc);

-

-digital_ofdm_chanest_vcvc_sptr

-digital_make_ofdm_chanest_vcvc (

- const std::vector<gr_complex> &sync_symbol1,

- const std::vector<gr_complex> &sync_symbol2,

- int n_data_symbols,

- int eq_noise_red_len=0,

- int max_carr_offset=-1,

- bool force_one_sync_symbol=false);

-

-class digital_ofdm_chanest_vcvc : public gr_block

-{

- private:

- digital_ofdm_chanest_vcvc(const std::vector<gr_complex> &sync_symbol1, const std::vector<gr_complex> &sync_symbol2, int n_data_symbols, int eq_noise_red_len, int max_carr_offset, bool force_one_sync_symbol);

-

- public:

-};

-

-#include "digital_ofdm_chanest_vcvc.h"

-%include "digital_ofdm_chanest_vcvc.i"

-GR_SWIG_BLOCK_MAGIC2(digital, ofdm_frame_equalizer_vcvc);

-

-%include "packet_header.i"

-

-GR_SWIG_BLOCK_MAGIC2(digital, packet_headergenerator_bb);

-

-%include "digital/ofdm_serializer_vcc.h"

-GR_SWIG_BLOCK_MAGIC2(digital, ofdm_serializer_vcc);

-

-GR_SWIG_BLOCK_MAGIC2(digital, packet_headerparser_b);

-GR_SWIG_BLOCK_MAGIC2(digital, header_payload_demux);