digital: moved fll_band_edge out of gnruadio-core.

5 files changed, 0 insertions, 690 deletions

diff --git a/gnuradio-core/src/lib/general/Makefile.am b/gnuradio-core/src/lib/general/Makefile.am
index e63d8930b..29f9d8d44 100644
--- a/gnuradio-core/src/lib/general/Makefile.am
+++ b/gnuradio-core/src/lib/general/Makefile.am
@@ -72,7 +72,6 @@ libgeneral_la_SOURCES = 		\
 	gr_fft_vcc_fftw.cc		\
 	gr_fft_vfc.cc			\
 	gr_firdes.cc			\
-	gr_fll_band_edge_cc.cc		\
 	gr_float_to_char.cc		\
 	gr_float_to_complex.cc		\
 	gr_float_to_short.cc		\
@@ -220,7 +219,6 @@ grinclude_HEADERS = 			\
 	gr_fft_vcc_fftw.h		\
 	gr_fft_vfc.h			\
 	gr_firdes.h			\
-	gr_fll_band_edge_cc.h		\
 	gr_float_to_char.h		\
 	gr_float_to_complex.h		\
 	gr_float_to_short.h		\
@@ -382,7 +380,6 @@ swiginclude_HEADERS =			\
 	gr_fft_vcc.i			\
 	gr_fft_vfc.i			\
 	gr_firdes.i			\
-	gr_fll_band_edge_cc.i		\
 	gr_float_to_char.i		\
 	gr_float_to_complex.i		\
 	gr_float_to_short.i		\
diff --git a/gnuradio-core/src/lib/general/general.i b/gnuradio-core/src/lib/general/general.i
index c43622400..08b5ad98c 100644
--- a/gnuradio-core/src/lib/general/general.i
+++ b/gnuradio-core/src/lib/general/general.i
@@ -131,7 +131,6 @@
 #include <gr_wavelet_ff.h>
 #include <gr_wvps_ff.h>
 #include <gr_copy.h>
-#include <gr_fll_band_edge_cc.h>
 #include <gr_additive_scrambler_bb.h>
 #include <complex_vec_test.h>
 #include <gr_annotator_alltoall.h>
@@ -248,7 +247,6 @@
 %include "gr_wavelet_ff.i"
 %include "gr_wvps_ff.i"
 %include "gr_copy.i"
-%include "gr_fll_band_edge_cc.i"
 %include "gr_additive_scrambler_bb.i"
 %include "complex_vec_test.i"
 %include "gr_annotator_alltoall.i"
diff --git a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.cc b/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.cc
deleted file mode 100644
index 65e273e8a..000000000
--- a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.cc
+++ /dev/null
@@ -1,349 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2009-2011 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_fll_band_edge_cc.h>
-#include <gr_io_signature.h>
-#include <gr_expj.h>
-#include <gr_math.h>
-#include <cstdio>
-
-#define M_TWOPI (2*M_PI)
-
-float sinc(float x)
-{
-  if(x == 0)
-    return 1;
-  else
-    return sin(M_PI*x)/(M_PI*x);
-}
-  
-
-
-gr_fll_band_edge_cc_sptr
-gr_make_fll_band_edge_cc (float samps_per_sym, float rolloff,
-			  int filter_size, float bandwidth)
-{
-  return gnuradio::get_initial_sptr(new gr_fll_band_edge_cc (samps_per_sym, rolloff,
-							    filter_size, bandwidth));
-}
-
-
-static int ios[] = {sizeof(gr_complex), sizeof(float), sizeof(float), sizeof(float)};
-static std::vector<int> iosig(ios, ios+sizeof(ios)/sizeof(int));
-gr_fll_band_edge_cc::gr_fll_band_edge_cc (float samps_per_sym, float rolloff,
-					  int filter_size, float bandwidth)
-  : gr_sync_block ("fll_band_edge_cc",
-		   gr_make_io_signature (1, 1, sizeof(gr_complex)),
-		   gr_make_io_signaturev (1, 4, iosig)),
-    d_updated (false)
-{
-  // Initialize samples per symbol
-  if(samps_per_sym <= 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid number of sps. Must be > 0.");
-  }
-  d_sps = samps_per_sym;
-  
-  // Initialize rolloff factor
-  if(rolloff < 0 || rolloff > 1.0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid rolloff factor. Must be in [0,1].");
-  }
-  d_rolloff = rolloff;
-  
-  // Initialize filter length
-  if(filter_size <= 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid filter size. Must be > 0.");
-  }
-  d_filter_size = filter_size;
-  
-  // Initialize loop bandwidth
-  if(bandwidth < 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid bandwidth. Must be >= 0.");
-  }
-  d_loop_bw = bandwidth;
-
-  // base this on the number of samples per symbol
-  d_max_freq =  M_TWOPI * (2.0/samps_per_sym);
-  d_min_freq = -M_TWOPI * (2.0/samps_per_sym);
-
-  // Set the damping factor for a critically damped system
-  d_damping = sqrt(2.0)/2.0;
-
-  // Set the bandwidth, which will then call update_gains()
-  set_loop_bandwidth(bandwidth);
-
-  // Build the band edge filters
-  design_filter(d_sps, d_rolloff, d_filter_size);
-
-  // Initialize loop values
-  d_freq = 0;
-  d_phase = 0;
-}
-
-gr_fll_band_edge_cc::~gr_fll_band_edge_cc ()
-{
-}
-
-void
-gr_fll_band_edge_cc::set_loop_bandwidth(float bw) 
-{
-  if(bw < 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid bandwidth. Must be >= 0.");
-  }
-  
-  d_loop_bw = bw;
-  update_gains();
-}
-
-void
-gr_fll_band_edge_cc::set_damping_factor(float df) 
-{
-  if(df < 0 || df > 1.0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid damping factor. Must be in [0,1].");
-  }
-  
-  d_damping = df;
-  update_gains();
-}
-
-
-void
-gr_fll_band_edge_cc::set_alpha(float alpha)
-{
-  if(alpha < 0 || alpha > 1.0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid alpha. Must be in [0,1].");
-  }
-  d_alpha = alpha;
-}
-
-void
-gr_fll_band_edge_cc::set_beta(float beta)
-{
-  if(beta < 0 || beta > 1.0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid beta. Must be in [0,1].");
-  }
-  d_beta = beta;
-}
-
-void
-gr_fll_band_edge_cc::set_samples_per_symbol(float sps)
-{
-  if(sps <= 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid number of sps. Must be > 0.");
-  }
-  d_sps = sps;
-  design_filter(d_sps, d_rolloff, d_filter_size);
-}
-
-void
-gr_fll_band_edge_cc::set_rolloff(float rolloff)
-{
-  if(rolloff < 0 || rolloff > 1.0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid rolloff factor. Must be in [0,1].");
-  }
-  d_rolloff = rolloff;
-  design_filter(d_sps, d_rolloff, d_filter_size);
-}
-
-void
-gr_fll_band_edge_cc::set_filter_size(int filter_size)
-{
-  if(filter_size <= 0) {
-    throw std::out_of_range ("gr_fll_band_edge_cc: invalid filter size. Must be > 0.");
-  }
-  d_filter_size = filter_size;
-  design_filter(d_sps, d_rolloff, d_filter_size);
-}
-
-float
-gr_fll_band_edge_cc::get_loop_bandwidth()
-{
-  return d_loop_bw;
-}
-
-float
-gr_fll_band_edge_cc::get_damping_factor()
-{
-  return d_damping;
-}
-
-float
-gr_fll_band_edge_cc::get_alpha()
-{
-  return d_alpha;
-}
-
-float
-gr_fll_band_edge_cc::get_beta()
-{
-  return d_beta;
-}
-
-float
-gr_fll_band_edge_cc::get_samples_per_symbol()
-{
-  return d_sps;
-}
-
-float
-gr_fll_band_edge_cc::get_rolloff()
-{
-  return d_rolloff;
-}
-
-int
-gr_fll_band_edge_cc:: get_filter_size()
-{
-  return d_filter_size;
-}
-
-void
-gr_fll_band_edge_cc::update_gains() 
-{
-  float denom = (1.0 + 2.0*d_damping*d_loop_bw + d_loop_bw*d_loop_bw);
-  d_alpha = (4*d_damping*d_loop_bw) / denom;
-  d_beta = (4*d_loop_bw*d_loop_bw) / denom;
-}
-
-void
-gr_fll_band_edge_cc::design_filter(float samps_per_sym, float rolloff, int filter_size)
-{
-  int M = rint(filter_size / samps_per_sym);
-  float power = 0;
-
-  // Create the baseband filter by adding two sincs together
-  std::vector<float> bb_taps;
-  for(int i = 0; i < filter_size; i++) {
-    float k = -M + i*2.0/samps_per_sym;
-    float tap = sinc(rolloff*k - 0.5) + sinc(rolloff*k + 0.5);
-    power += tap;
-    
-    bb_taps.push_back(tap);
-  }
-
-  d_taps_lower.resize(filter_size);
-  d_taps_upper.resize(filter_size);
-
-  // Create the band edge filters by spinning the baseband
-  // filter up and down to the right places in frequency.
-  // Also, normalize the power in the filters
-  int N = (bb_taps.size() - 1.0)/2.0;
-  for(int i = 0; i < filter_size; i++) {
-    float tap = bb_taps[i] / power;
-    
-    float k = (-N + (int)i)/(2.0*samps_per_sym);
-    
-    gr_complex t1 = tap * gr_expj(-M_TWOPI*(1+rolloff)*k);
-    gr_complex t2 = tap * gr_expj(M_TWOPI*(1+rolloff)*k);
-    
-    d_taps_lower[filter_size-i-1] = t1;
-    d_taps_upper[filter_size-i-1] = t2;
-  }
-  
-  d_updated = true;
-
-  // Set the history to ensure enough input items for each filter
-  set_history(filter_size+1);
-}
-
-void
-gr_fll_band_edge_cc::print_taps()
-{
-  unsigned int i;
-
-  printf("Upper Band-edge: [");
-  for(i = 0; i < d_taps_upper.size(); i++) {
-    printf(" %.4e + %.4ej,", d_taps_upper[i].real(), d_taps_upper[i].imag());
-  }
-  printf("]\n\n");
-
-  printf("Lower Band-edge: [");
-  for(i = 0; i < d_taps_lower.size(); i++) {
-    printf(" %.4e + %.4ej,", d_taps_lower[i].real(), d_taps_lower[i].imag());
-  }
-  printf("]\n\n");
-}
-
-int
-gr_fll_band_edge_cc::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];
-  gr_complex *out = (gr_complex *) output_items[0];
-
-  float *frq = NULL;
-  float *phs = NULL;
-  float *err = NULL;
-  if(output_items.size() == 4) {
-    frq = (float *) output_items[1];
-    phs = (float *) output_items[2];
-    err = (float *) output_items[3];
-  }
-
-  if (d_updated) {
-    d_updated = false;
-    return 0;		     // history requirements may have changed.
-  }
-
-  int i;
-  float error;
-  gr_complex nco_out;
-  gr_complex out_upper, out_lower;
-  for(i = 0; i < noutput_items; i++) {
-    nco_out = gr_expj(d_phase);
-    out[i+d_filter_size-1] = in[i] * nco_out;
-
-    // Perform the dot product of the output with the filters
-    out_upper = 0;
-    out_lower = 0;
-    for(int k = 0; k < d_filter_size; k++) {
-      out_upper += d_taps_upper[k] * out[i+k];
-      out_lower += d_taps_lower[k] * out[i+k];
-    }
-    error = norm(out_lower) - norm(out_upper);
-
-    d_freq = d_freq + d_beta * error;
-    d_phase = d_phase + d_freq + d_alpha * error;
-
-    if(d_phase > M_PI)
-      d_phase -= M_TWOPI;
-    else if(d_phase < -M_PI)
-      d_phase += M_TWOPI;
-
-    if (d_freq > d_max_freq)
-      d_freq = d_max_freq;
-    else if (d_freq < d_min_freq)
-      d_freq = d_min_freq;
-
-    if(output_items.size() == 4) {
-      frq[i] = d_freq;
-      phs[i] = d_phase;
-      err[i] = error;
-    }
-  }
-
-  return noutput_items;
-}
diff --git a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.h b/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.h
deleted file mode 100644
index dba5e6e26..000000000
--- a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.h
+++ /dev/null
@@ -1,284 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2009,2011 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_GR_FLL_BAND_EDGE_CC_H
-#define	INCLUDED_GR_FLL_BAND_EDGE_CC_H
-
-#include <gr_sync_block.h>
-
-class gr_fll_band_edge_cc;
-typedef boost::shared_ptr<gr_fll_band_edge_cc> gr_fll_band_edge_cc_sptr;
-gr_fll_band_edge_cc_sptr gr_make_fll_band_edge_cc (float samps_per_sym, float rolloff,
-						   int filter_size, float bandwidth);
-
-/*!
- * \class gr_fll_band_edge_cc
- * \brief Frequency Lock Loop using band-edge filters
- *
- * \ingroup general
- *
- * The frequency lock loop derives a band-edge filter that covers the upper and lower bandwidths
- * of a digitally-modulated signal. The bandwidth range is determined by the excess bandwidth
- * (e.g., rolloff factor) of the modulated signal. The placement in frequency of the band-edges
- * is determined by the oversampling ratio (number of samples per symbol) and the excess bandwidth.
- * The size of the filters should be fairly large so as to average over a number of symbols.
- *
- * The FLL works by filtering the upper and lower band edges into x_u(t) and x_l(t), respectively.
- * These are combined to form cc(t) = x_u(t) + x_l(t) and ss(t) = x_u(t) - x_l(t). Combining
- * these to form the signal e(t) = Re{cc(t) \\times ss(t)^*} (where ^* is the complex conjugate)
- * provides an error signal at the DC term that is directly proportional to the carrier frequency.
- * We then make a second-order loop using the error signal that is the running average of e(t).
- *
- * In practice, the above equation can be simplified by just comparing the absolute value squared
- * of the output of both filters: abs(x_l(t))^2 - abs(x_u(t))^2 = norm(x_l(t)) - norm(x_u(t)).
- *
- * In theory, the band-edge filter is the derivative of the matched filter in frequency, 
- * (H_be(f) = \\frac{H(f)}{df}. In practice, this comes down to a quarter sine wave at the point
- * of the matched filter's rolloff (if it's a raised-cosine, the derivative of a cosine is a sine).
- * Extend this sine by another quarter wave to make a half wave around the band-edges is equivalent
- * in time to the sum of two sinc functions. The baseband filter fot the band edges is therefore
- * derived from this sum of sincs. The band edge filters are then just the baseband signal
- * modulated to the correct place in frequency. All of these calculations are done in the
- * 'design_filter' function.
- *
- * Note: We use FIR filters here because the filters have to have a flat phase response over the
- * entire frequency range to allow their comparisons to be valid.
- *
- * It is very important that the band edge filters be the derivatives of the pulse shaping filter,
- * and that they be linear phase. Otherwise, the variance of the error will be very large.
- *
- */
-
-class gr_fll_band_edge_cc : public gr_sync_block
-{
- private:
-  /*!
-   * Build the FLL
-   * \param samps_per_sym    (float) Number of samples per symbol of signal
-   * \param rolloff          (float) Rolloff factor of signal
-   * \param filter_size      (int)   Size (in taps) of the filter
-   * \param bandwdith        (float) Loop bandwidth
-   */
-  friend gr_fll_band_edge_cc_sptr gr_make_fll_band_edge_cc (float samps_per_sym, float rolloff,
-							    int filter_size, float bandwidth);
-
-  float                   d_sps;
-  float                   d_rolloff;
-  int                     d_filter_size;
-  float                   d_max_freq;
-  float                   d_min_freq;
-
-  float                   d_loop_bw;
-  float                   d_damping;
-  float                   d_alpha;
-  float                   d_beta;
-
-  std::vector<gr_complex> d_taps_lower;
-  std::vector<gr_complex> d_taps_upper;
-  bool			  d_updated;
-
-  float                   d_freq;
-  float                   d_phase; 
-
-  /*!
-   * Build the FLL
-   * \param samps_per_sym (float) number of samples per symbol
-   * \param rolloff (float) Rolloff (excess bandwidth) of signal filter
-   * \param filter_size (int) number of filter taps to generate
-   * \param bandwidth (float) Loop bandwidth
-   */
-  gr_fll_band_edge_cc(float samps_per_sym, float rolloff,
-		      int filter_size, float bandwidth);
-  
-  /*!
-   * \brief Update the gains, alpha and beta, of the loop filter.
-   */
-  void update_gains();
-
-  /*!
-   * Design the band-edge filter based on the number of samples per symbol,
-   * filter rolloff factor, and the filter size
-   *
-   * \param samps_per_sym    (float) Number of samples per symbol of signal
-   * \param rolloff          (float) Rolloff factor of signal
-   * \param filter_size      (int)   Size (in taps) of the filter
-   */
-  void design_filter(float samps_per_sym, float rolloff, int filter_size);
-
-public:
-  ~gr_fll_band_edge_cc ();
-
-  /*******************************************************************
-    SET FUNCTIONS
-  *******************************************************************/
-  
-  /*!
-   * \brief Set the loop bandwidth
-   *
-   * Set the loop filter's bandwidth to \p bw. This should be between 
-   * 2*pi/200 and 2*pi/100  (in rads/samp). It must also be a positive
-   * number.
-   *
-   * When a new damping factor is set, the gains, alpha and beta, of the loop
-   * are recalculated by a call to update_gains().
-   *
-   * \param bw    (float) new bandwidth
-   *
-   */
-  void set_loop_bandwidth(float bw);
-
-  /*!
-   * \brief Set the loop damping factor
-   *
-   * Set the loop filter's damping factor to \p df. The damping factor
-   * should be sqrt(2)/2.0 for critically damped systems.
-   * Set it to anything else only if you know what you are doing. It must
-   * be a number between 0 and 1.
-   *
-   * When a new damping factor is set, the gains, alpha and beta, of the loop
-   * are recalculated by a call to update_gains().
-   *
-   * \param df    (float) new damping factor
-   *
-   */
-  void set_damping_factor(float df);
-
-  /*!
-   * \brief Set the loop gain alpha
-   *
-   * Set's the loop filter's alpha gain parameter.
-   *
-   * This value should really only be set by adjusting the loop bandwidth
-   * and damping factor.
-   *
-   * \param alpha    (float) new alpha gain
-   *
-   */
-  void set_alpha(float alpha);
-
-  /*!
-   * \brief Set the loop gain beta
-   *
-   * Set's the loop filter's beta gain parameter.
-   *
-   * This value should really only be set by adjusting the loop bandwidth
-   * and damping factor.
-   *
-   * \param beta    (float) new beta gain
-   *
-   */
-  void set_beta(float beta);
-
-  /*!
-   * \brief Set the number of samples per symbol
-   *
-   * Set's the number of samples per symbol the system should use. This value
-   * is uesd to calculate the filter taps and will force a recalculation.
-   *
-   * \param sps    (float) new samples per symbol
-   *
-   */
-  void set_samples_per_symbol(float sps);
-
-  /*!
-   * \brief Set the rolloff factor of the shaping filter
-   *
-   * This sets the rolloff factor that is used in the pulse shaping filter
-   * and is used to calculate the filter taps. Changing this will force a
-   * recalculation of the filter taps.
-   *
-   * This should be the same value that is used in the transmitter's pulse
-   * shaping filter. It must be between 0 and 1 and is usually between
-   * 0.2 and 0.5 (where 0.22 and 0.35 are commonly used values).
-   *
-   * \param rolloff    (float) new shaping filter rolloff factor [0,1]
-   *
-   */
-  void set_rolloff(float rolloff);
-
-  /*!
-   * \brief Set the number of taps in the filter
-   *
-   * This sets the number of taps in the band-edge filters. Setting this will
-   * force a recalculation of the filter taps.
-   *
-   * This should be about the same number of taps used in the transmitter's
-   * shaping filter and also not very large. A large number of taps will
-   * result in a large delay between input and frequency estimation, and
-   * so will not be as accurate. Between 30 and 70 taps is usual.
-   *
-   * \param filter_size    (float) number of taps in the filters
-   *
-   */
-  void set_filter_size(int filter_size);
-
-  /*******************************************************************
-    GET FUNCTIONS
-  *******************************************************************/
-
-  /*!
-   * \brief Returns the loop bandwidth
-   */
-  float get_loop_bandwidth();
-
-  /*!
-   * \brief Returns the loop damping factor
-   */
-  float get_damping_factor();
-
-  /*!
-   * \brief Returns the loop gain alpha
-   */
-  float get_alpha();
-
-  /*!
-   * \brief Returns the loop gain beta
-   */
-  float get_beta();
-
-  /*!
-   * \brief Returns the number of sampler per symbol used for the filter
-   */
-  float get_samples_per_symbol();
-
-  /*!
-   * \brief Returns the rolloff factor used for the filter
-   */
-  float get_rolloff();
-
-  /*!
-   * \brief Returns the number of taps of the filter
-   */
-  int get_filter_size();
-
-  /*!
-   * Print the taps to screen.
-   */
-  void print_taps();
-   
-  int work (int noutput_items,
-	    gr_vector_const_void_star &input_items,
-	    gr_vector_void_star &output_items);
-};
-
-#endif
diff --git a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.i b/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.i
deleted file mode 100644
index 3617dc395..000000000
--- a/gnuradio-core/src/lib/general/gr_fll_band_edge_cc.i
+++ /dev/null
@@ -1,52 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2009,2011 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(gr,fll_band_edge_cc);
-
-gr_fll_band_edge_cc_sptr gr_make_fll_band_edge_cc (float samps_per_sym, float rolloff,
-						   int filter_size, float bandwidth);
-
-class gr_fll_band_edge_cc : public gr_sync_block
-{
- private:
-  gr_fll_band_edge_cc (float samps_per_sym, float rolloff,
-		       int filter_size, float bandwidth);
-
- public:
-  ~gr_fll_band_edge_cc ();
-
-  void set_loop_bandwidth(float bw);
-  void set_damping_factor(float df);
-  void set_alpha(float alpha);
-  void set_beta(float beta);
-  void set_samples_per_symbol(float sps);
-  void set_rolloff(float rolloff);
-  void set_filter_size(int filter_size);
-  float get_loop_bandwidth();
-  float get_damping_factor();
-  float get_alpha();
-  float get_beta();
-  float get_samples_per_symbol();
-  float get_rolloff();
-  int get_filter_size();
-  void print_taps();
-};