git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/lib/general/gr_ofdm_correlator.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2006, 2007 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gr_ofdm_correlator.h>
  28 #include <gr_io_signature.h>
  29 #include <gr_expj.h>
  30
  31 #define VERBOSE 0
  32 #define M_TWOPI (2*M_PI)
  33
  34 gr_ofdm_correlator_sptr
  35 gr_make_ofdm_correlator (unsigned int occupied_carriers, unsigned int fft_length,
  36                          unsigned int cplen,
  37                          const std::vector<gr_complex> &known_symbol1,
  38                          const std::vector<gr_complex> &known_symbol2)
  39 {
  40   return gr_ofdm_correlator_sptr (new gr_ofdm_correlator (occupied_carriers, fft_length, cplen,
  41                                                           known_symbol1, known_symbol2));
  42 }
  43
  44 gr_ofdm_correlator::gr_ofdm_correlator (unsigned occupied_carriers, unsigned int fft_length,
  45                                         unsigned int cplen,
  46                                         const std::vector<gr_complex> &known_symbol1,
  47                                         const std::vector<gr_complex> &known_symbol2)
  48   : gr_block ("ofdm_correlator",
  49               gr_make_io_signature (1, 1, sizeof(gr_complex)*fft_length),
  50               gr_make_io_signature2 (2, 2, sizeof(gr_complex)*occupied_carriers, sizeof(char))),
  51     d_occupied_carriers(occupied_carriers),
  52     d_fft_length(fft_length),
  53     d_cplen(cplen),
  54     d_freq_shift_len(5),
  55     d_known_symbol1(known_symbol1),
  56     d_known_symbol2(known_symbol2),
  57     d_coarse_freq(0),
  58     d_phase_count(0)
  59 {
  60   d_diff_corr_factor.resize(d_occupied_carriers);
  61   d_hestimate.resize(d_occupied_carriers);
  62
  63   std::vector<gr_complex>::iterator i1, i2;
  64
  65   int i = 0;
  66   gr_complex one(1.0, 0.0);
  67   for(i1 = d_known_symbol1.begin(), i2 = d_known_symbol2.begin(); i1 != d_known_symbol1.end(); i1++, i2++) {
  68     d_diff_corr_factor[i] = one / ((*i1) * conj(*i2));
  69     i++;
  70   }
  71 }
  72
  73 gr_ofdm_correlator::~gr_ofdm_correlator(void)
  74 {
  75 }
  76
  77 void
  78 gr_ofdm_correlator::forecast (int noutput_items, gr_vector_int &ninput_items_required)
  79 {
  80   unsigned ninputs = ninput_items_required.size ();
  81   for (unsigned i = 0; i < ninputs; i++)
  82     ninput_items_required[i] = 2;
  83 }
  84
  85 gr_complex
  86 gr_ofdm_correlator::coarse_freq_comp(int freq_delta, int symbol_count)
  87 {
  88   //  return gr_complex(cos(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count),
  89   //        sin(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count));
  90   return gr_expj(-M_TWOPI*freq_delta*d_cplen/d_fft_length*symbol_count);
  91 }
  92
  93 bool
  94 gr_ofdm_correlator::correlate(const gr_complex *previous, const gr_complex *current,
  95                               int zeros_on_left)
  96 {
  97   unsigned int i = 0;
  98   int search_delta = 0;
  99   bool found = false;
 100
 101   gr_complex h_sqrd = gr_complex(0.0,0.0);
 102   float power = 0.0F;
 103
 104   while(!found && ((unsigned)abs(search_delta) < d_freq_shift_len)) {
 105     h_sqrd = gr_complex(0.0,0.0);
 106     power = 0.0F;
 107
 108     for(i = 0; i < d_occupied_carriers; i++) {
 109       h_sqrd = h_sqrd + previous[i+zeros_on_left+search_delta] *
 110         conj(coarse_freq_comp(search_delta,1)*current[i+zeros_on_left+search_delta]) *
 111         d_diff_corr_factor[i];
 112       power = power + norm(current[i+zeros_on_left+search_delta]); // No need to do coarse freq here
 113     }
 114
 115 #if VERBOSE
 116       printf("bin %d\th_sqrd = ( %f, %f )\t power = %f\t real(h)/p = %f\t angle = %f\n",
 117              search_delta, h_sqrd.real(), h_sqrd.imag(), power, h_sqrd.real()/power, arg(h_sqrd));
 118 #endif
 119
 120       // FIXME: Look at h_sqrd.read() > power
 121     if((h_sqrd.real() > 0.82*power)  && (h_sqrd.real() < 1.1 * power)) {
 122       found = true;
 123       d_coarse_freq = search_delta;
 124       d_phase_count = 1;
 125       //d_snr_est = 10*log10(power/(power-h_sqrd.real()));
 126
 127       // check for low noise power; sets maximum SNR at 100 dB
 128       if(fabs(h_sqrd.imag()) <= 1e-12) {
 129         d_snr_est = 100.0;
 130       }
 131       else {
 132         d_snr_est = 10*log10(fabs(h_sqrd.real()/h_sqrd.imag()));
 133       }
 134
 135       printf("CORR: Found, bin %d\tSNR Est %f dB\tcorr power fraction %f\n",
 136              search_delta, d_snr_est, h_sqrd.real()/power);
 137       // search_delta,10*log10(h_sqrd.real()/fabs(h_sqrd.imag())),h_sqrd.real()/power);
 138       break;
 139     }
 140     else {
 141       if(search_delta <= 0)
 142         search_delta = (-search_delta) + 1;
 143       else
 144         search_delta = -search_delta;
 145     }
 146   }
 147   return found;
 148 }
 149
 150 void
 151 gr_ofdm_correlator::calculate_equalizer(const gr_complex *previous, const gr_complex *current,
 152                                         int zeros_on_left)
 153 {
 154   unsigned int i=0;
 155
 156   for(i = 0; i < d_occupied_carriers; i++) {
 157     // FIXME possibly add small epsilon in divisor to protect from div 0
 158     //d_hestimate[i] = 0.5F * (d_known_symbol1[i] / previous[i+zeros_on_left] +
 159     //                      d_known_symbol2[i] / (coarse_freq_comp(d_coarse_freq,1)*
 160     //                                            current[i+zeros_on_left+d_coarse_freq]));
 161     d_hestimate[i] = 0.5F * (d_known_symbol1[i] / previous[i+zeros_on_left+d_coarse_freq] +
 162                              d_known_symbol2[i] / (coarse_freq_comp(d_coarse_freq,1)*
 163                                                    current[i+zeros_on_left+d_coarse_freq]));
 164
 165 #if VERBOSE
 166     fprintf(stderr, "%f %f ", d_hestimate[i].real(), d_hestimate[i].imag());
 167 #endif
 168   }
 169 #if VERBOSE
 170   fprintf(stderr, "\n");
 171 #endif
 172 }
 173
 174 int
 175 gr_ofdm_correlator::general_work(int noutput_items,
 176                                  gr_vector_int &ninput_items,
 177                                  gr_vector_const_void_star &input_items,
 178                                  gr_vector_void_star &output_items)
 179 {
 180   const gr_complex *in = (const gr_complex *)input_items[0];
 181   const gr_complex *previous = &in[0];
 182   const gr_complex *current = &in[d_fft_length];
 183
 184   gr_complex *out = (gr_complex *) output_items[0];
 185   char *sig = (char *) output_items[1];
 186
 187   unsigned int i=0;
 188
 189   int unoccupied_carriers = d_fft_length - d_occupied_carriers;
 190   int zeros_on_left = (int)ceil(unoccupied_carriers/2.0);
 191
 192   bool corr = correlate(previous, current, zeros_on_left);
 193   if(corr) {
 194     calculate_equalizer(previous, current, zeros_on_left);
 195     sig[0] = 1;
 196   }
 197   else {
 198     sig[0] = 0;
 199   }
 200
 201   for(i = 0; i < d_occupied_carriers; i++) {
 202     out[i] = d_hestimate[i]*coarse_freq_comp(d_coarse_freq,d_phase_count)*current[i+zeros_on_left+d_coarse_freq];
 203   }
 204
 205
 206   d_phase_count++;
 207   consume_each(1);
 208   return 1;
 209 }