git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/lib/filter/gr_pfb_clock_sync_fff.h

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2009,2010 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 3, 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
  24 #ifndef INCLUDED_GR_PFB_CLOCK_SYNC_FFF_H
  25 #define INCLUDED_GR_PFB_CLOCK_SYNC_FFF_H
  26
  27 #include <gr_block.h>
  28
  29 class gr_pfb_clock_sync_fff;
  30 typedef boost::shared_ptr<gr_pfb_clock_sync_fff> gr_pfb_clock_sync_fff_sptr;
  31 gr_pfb_clock_sync_fff_sptr gr_make_pfb_clock_sync_fff (double sps, float gain,
  32                                                        const std::vector<float> &taps,
  33                                                        unsigned int filter_size=32,
  34                                                        float init_phase=0,
  35                                                        float max_rate_deviation=1.5);
  36
  37 class gr_fir_fff;
  38
  39 /*!
  40  * \class gr_pfb_clock_sync_fff
  41  *
  42  * \brief Timing synchronizer using polyphase filterbanks
  43  *
  44  * \ingroup filter_blk
  45  *
  46  */
  47
  48 class gr_pfb_clock_sync_fff : public gr_block
  49 {
  50  private:
  51   /*!
  52    * Build the polyphase filterbank timing synchronizer.
  53    */
  54   friend gr_pfb_clock_sync_fff_sptr gr_make_pfb_clock_sync_fff (double sps, float gain,
  55                                                                 const std::vector<float> &taps,
  56                                                                 unsigned int filter_size,
  57                                                                 float init_phase,
  58                                                                 float max_rate_deviation);
  59
  60   bool                     d_updated;
  61   double                   d_sps;
  62   double                   d_sample_num;
  63   float                    d_alpha;
  64   float                    d_beta;
  65   int                      d_nfilters;
  66   std::vector<gr_fir_fff*> d_filters;
  67   std::vector<gr_fir_fff*> d_diff_filters;
  68   std::vector< std::vector<float> > d_taps;
  69   std::vector< std::vector<float> > d_dtaps;
  70   float                    d_k;
  71   float                    d_rate;
  72   float                    d_rate_i;
  73   float                    d_rate_f;
  74   float                    d_max_dev;
  75   int                      d_filtnum;
  76   int                      d_taps_per_filter;
  77
  78   /*!
  79    * Build the polyphase filterbank timing synchronizer.
  80    */
  81   gr_pfb_clock_sync_fff (double sps, float gain,
  82                          const std::vector<float> &taps,
  83                          unsigned int filter_size,
  84                          float init_phase,
  85                          float max_rate_deviation);
  86
  87   void create_diff_taps(const std::vector<float> &newtaps,
  88                         std::vector<float> &difftaps);
  89
  90 public:
  91   ~gr_pfb_clock_sync_fff ();
  92
  93   /*!
  94    * Resets the filterbank's filter taps with the new prototype filter
  95    */
  96   void set_taps (const std::vector<float> &taps,
  97                  std::vector< std::vector<float> > &ourtaps,
  98                  std::vector<gr_fir_fff*> &ourfilter);
  99   std::vector<float> channel_taps(int channel);
 100   std::vector<float> diff_channel_taps(int channel);
 101
 102   /*!
 103    * Print all of the filterbank taps to screen.
 104    */
 105   void print_taps();
 106   void print_diff_taps();
 107
 108   void set_alpha(float alpha)
 109   {
 110     d_alpha = alpha;
 111   }
 112   void set_beta(float beta)
 113   {
 114     d_beta = beta;
 115   }
 116
 117   void set_max_rate_deviation(float m)
 118   {
 119     d_max_dev = m;
 120   }
 121
 122   bool check_topology(int ninputs, int noutputs);
 123
 124   int general_work (int noutput_items,
 125                     gr_vector_int &ninput_items,
 126                     gr_vector_const_void_star &input_items,
 127                     gr_vector_void_star &output_items);
 128 };
 129
 130 #endif