switch source package format to 3.0 quilt

[debian/gnuradio] / gnuradio-core / src / lib / filter / gr_pfb_clock_sync_ccf.cc

diff --git a/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc b/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc
index 8271fe6b9e7d45212bc39a6da7019cc238d6bbfe..ff4fb70a36eed08aa623374a0ccf3e2128c622f3 100644 (file)
--- a/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc
+++ b/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2009 Free Software Foundation, Inc.
+ * Copyright 2009,2010 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -45,8 +45,8 @@ gr_pfb_clock_sync_ccf_sptr gr_make_pfb_clock_sync_ccf (double sps, float gain,
                                                                max_rate_deviation));
 }
 
-int ios[] = {sizeof(gr_complex), sizeof(float), sizeof(float), sizeof(float)};
-std::vector<int> iosig(ios, ios+sizeof(ios)/sizeof(int));
+static int ios[] = {sizeof(gr_complex), sizeof(float), sizeof(float), sizeof(float)};
+static std::vector<int> iosig(ios, ios+sizeof(ios)/sizeof(int));
 gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (double sps, float gain,
                                              const std::vector<float> &taps,
                                              unsigned int filter_size,
@@ -68,6 +68,8 @@ gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (double sps, float gain,
   set_beta(0.25*gain*gain);
   d_k = init_phase;
   d_rate = (sps-floor(sps))*(double)d_nfilters;
+  d_rate_i = (int)floor(d_rate);
+  d_rate_f = d_rate - (float)d_rate_i;
   d_filtnum = (int)floor(d_k);
 
   d_filters = std::vector<gr_fir_ccf*>(d_nfilters);
@@ -75,7 +77,7 @@ gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (double sps, float gain,
 
   // Create an FIR filter for each channel and zero out the taps
   std::vector<float> vtaps(0, d_nfilters);
-  for(unsigned int i = 0; i < d_nfilters; i++) {
+  for(int i = 0; i < d_nfilters; i++) {
     d_filters[i] = gr_fir_util::create_gr_fir_ccf(vtaps);
     d_diff_filters[i] = gr_fir_util::create_gr_fir_ccf(vtaps);
   }
@@ -89,11 +91,18 @@ gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (double sps, float gain,
 
 gr_pfb_clock_sync_ccf::~gr_pfb_clock_sync_ccf ()
 {
-  for(unsigned int i = 0; i < d_nfilters; i++) {
+  for(int i = 0; i < d_nfilters; i++) {
     delete d_filters[i];
+    delete d_diff_filters[i];
   }
 }
 
+bool
+gr_pfb_clock_sync_ccf::check_topology(int ninputs, int noutputs)
+{
+  return noutputs == 1 || noutputs == 4;
+}
+
 void
 gr_pfb_clock_sync_ccf::set_taps (const std::vector<float> &newtaps,
                                 std::vector< std::vector<float> > &ourtaps,
@@ -137,19 +146,29 @@ void
 gr_pfb_clock_sync_ccf::create_diff_taps(const std::vector<float> &newtaps,
                                        std::vector<float> &difftaps)
 {
+  float maxtap = 1e-20;
   difftaps.clear();
   difftaps.push_back(0); //newtaps[0]);
   for(unsigned int i = 1; i < newtaps.size()-1; i++) {
     float tap = newtaps[i+1] - newtaps[i-1];
     difftaps.push_back(tap);
+    if(tap > maxtap) {
+      maxtap = tap;
+    }
   }
   difftaps.push_back(0);//-newtaps[newtaps.size()-1]);
+
+  // Scale the differential taps; helps scale error term to better update state
+  // FIXME: should this be scaled this way or use the same gain as the taps?
+  for(unsigned int i = 0; i < difftaps.size(); i++) {
+    difftaps[i] /= maxtap;
+  }
 }
 
 void
 gr_pfb_clock_sync_ccf::print_taps()
 {
-  unsigned int i, j;
+  int i, j;
   printf("[ ");
   for(i = 0; i < d_nfilters; i++) {
     printf("[%.4e, ", d_taps[i][0]);
@@ -164,7 +183,7 @@ gr_pfb_clock_sync_ccf::print_taps()
 void
 gr_pfb_clock_sync_ccf::print_diff_taps()
 {
-  unsigned int i, j;
+  int i, j;
   printf("[ ");
   for(i = 0; i < d_nfilters; i++) {
     printf("[%.4e, ", d_dtaps[i][0]);
@@ -181,8 +200,7 @@ std::vector<float>
 gr_pfb_clock_sync_ccf::channel_taps(int channel)
 {
   std::vector<float> taps;
-  unsigned int i;
-  for(i = 0; i < d_taps_per_filter; i++) {
+  for(int i = 0; i < d_taps_per_filter; i++) {
     taps.push_back(d_taps[channel][i]);
   }
   return taps;
@@ -192,8 +210,7 @@ std::vector<float>
 gr_pfb_clock_sync_ccf::diff_channel_taps(int channel)
 {
   std::vector<float> taps;
-  unsigned int i;
-  for(i = 0; i < d_taps_per_filter; i++) {
+  for(int i = 0; i < d_taps_per_filter; i++) {
     taps.push_back(d_dtaps[channel][i]);
   }
   return taps;
@@ -209,8 +226,8 @@ gr_pfb_clock_sync_ccf::general_work (int noutput_items,
   gr_complex *in = (gr_complex *) input_items[0];
   gr_complex *out = (gr_complex *) output_items[0];
 
-  float *err, *outrate, *outk;
-  if(output_items.size() > 2) {
+  float *err = 0, *outrate = 0, *outk = 0;
+  if(output_items.size() == 4) {
     err = (float *) output_items[1];
     outrate = (float*)output_items[2];
     outk = (float*)output_items[3];
@@ -252,18 +269,18 @@ gr_pfb_clock_sync_ccf::general_work (int noutput_items,
     error = (error_i + error_r) / 2.0;       // average error from I&Q channel
 
     // Run the control loop to update the current phase (k) and tracking rate
-    d_k = d_k + d_alpha*error + d_rate;
-    d_rate = d_rate + d_beta*error;
+    d_k = d_k + d_alpha*error + d_rate_i + d_rate_f;
+    d_rate_f = d_rate_f + d_beta*error;
     
     // Keep our rate within a good range
-    d_rate = gr_branchless_clip(d_rate, d_max_dev);
+    d_rate_f = gr_branchless_clip(d_rate_f, d_max_dev);
 
     i++;
     count += (int)floor(d_sps);
 
-    if(output_items.size() > 2) {
+    if(output_items.size() == 4) {
       err[i] = error;
-      outrate[i] = d_rate;
+      outrate[i] = d_rate_f;
       outk[i] = d_k;
     }
   }