10 files changed, 181 insertions, 48 deletions
diff --git a/gr-digital/include/digital/cma_equalizer_cc.h b/gr-digital/include/digital/cma_equalizer_cc.h
index f2ec636577..60c58db1e1 100644
--- a/gr-digital/include/digital/cma_equalizer_cc.h
+++ b/gr-digital/include/digital/cma_equalizer_cc.h
@@ -61,6 +61,8 @@ namespace gr {
        */
       static sptr make(int num_taps, float modulus, float mu, int sps);
 
+      virtual void set_taps(const std::vector<gr_complex> &taps) = 0;
+      virtual std::vector<gr_complex> taps() const = 0;
       virtual float gain() const = 0;
       virtual void set_gain(float mu) = 0;
       virtual float modulus() const = 0;
diff --git a/gr-digital/include/digital/lms_dd_equalizer_cc.h b/gr-digital/include/digital/lms_dd_equalizer_cc.h
index ecac9ac476..8084396759 100644
--- a/gr-digital/include/digital/lms_dd_equalizer_cc.h
+++ b/gr-digital/include/digital/lms_dd_equalizer_cc.h
@@ -89,6 +89,8 @@ namespace gr {
 		       float mu, int sps,
 		       constellation_sptr cnst);
 
+      virtual void set_taps(const std::vector<gr_complex> &taps) = 0;
+      virtual std::vector<gr_complex> taps() const = 0;
       virtual float gain() const = 0;
       virtual void set_gain(float mu) = 0;
     };
diff --git a/gr-digital/lib/cma_equalizer_cc_impl.cc b/gr-digital/lib/cma_equalizer_cc_impl.cc
index fca7c0c6e5..e4e6c56466 100644
--- a/gr-digital/lib/cma_equalizer_cc_impl.cc
+++ b/gr-digital/lib/cma_equalizer_cc_impl.cc
@@ -30,6 +30,8 @@
 namespace gr {
   namespace digital {
 
+    using namespace filter::kernel;
+
     cma_equalizer_cc::sptr
     cma_equalizer_cc::make(int num_taps, float modulus, float mu, int sps)
     {
@@ -43,38 +45,80 @@ namespace gr {
 			  gr_make_io_signature(1, 1, sizeof(gr_complex)),
 			  gr_make_io_signature(1, 1, sizeof(gr_complex)),
 			  sps),
-	filter::kernel::fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),
+	fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),
+	d_new_taps(num_taps, gr_complex(0,0)),
 	d_updated(false), d_error(gr_complex(0,0))
     {
       set_modulus(modulus);
       set_gain(mu);
       if(num_taps > 0)
-	d_taps[0] = 1.0;
-      set_taps(d_taps);
+	d_new_taps[0] = 1.0;
+      fir_filter_ccc::set_taps(d_new_taps);
 
-      set_history(num_taps+1);
+      set_history(num_taps);
     }
 
     cma_equalizer_cc_impl::~cma_equalizer_cc_impl()
     {
     }
 
+    void
+    cma_equalizer_cc_impl::set_taps(const std::vector<gr_complex> &taps)
+    {
+      d_new_taps = taps;
+      d_updated = true;
+    }
+
+    std::vector<gr_complex>
+    cma_equalizer_cc_impl::taps() const
+    {
+      return d_taps;
+    }
+
+    gr_complex
+    cma_equalizer_cc_impl::error(const gr_complex &out)
+    { 
+      gr_complex error = out*(norm(out) - d_modulus);
+      float re = gr_clip(error.real(), 1.0);
+      float im = gr_clip(error.imag(), 1.0);
+      return gr_complex(re, im);
+    }
+
+    void
+    cma_equalizer_cc_impl::update_tap(gr_complex &tap, const gr_complex &in)
+    {
+      // Hn+1 = Hn - mu*conj(Xn)*zn*(|zn|^2 - 1)
+      tap -= d_mu*conj(in)*d_error;
+    }
+
     int
     cma_equalizer_cc_impl::work(int noutput_items,
 				gr_vector_const_void_star &input_items,
 				gr_vector_void_star &output_items)
     {
-      gr_complex *in = (gr_complex *)input_items[0];
+      const gr_complex *in = (const gr_complex *)input_items[0];
       gr_complex *out = (gr_complex *)output_items[0];
 
-      int j = 0, k, l = d_taps.size();
+      if(d_updated) {
+	d_taps = d_new_taps;
+	set_history(d_taps.size());
+	d_updated = false;
+	return 0;		     // history requirements may have changed.
+      }
+
+      int j = 0;
+      size_t k, l = d_taps.size();
       for(int i = 0; i < noutput_items; i++) {
 	out[i] = filter(&in[j]);
 
 	// Adjust taps
 	d_error = error(out[i]);
-	for (k = 0; k < l; k++) {
-	  update_tap(d_taps[l-k-1], in[j+k]);
+	for(k = 0; k < l; k++) {
+	  // Update tap locally from error.
+	  update_tap(d_taps[k], in[j+k]);
+
+	  // Update aligned taps in filter object.
+	  fir_filter_ccc::update_tap(d_taps[k], k);
 	}
 
 	j += decimation();
diff --git a/gr-digital/lib/cma_equalizer_cc_impl.h b/gr-digital/lib/cma_equalizer_cc_impl.h
index 9e95d46f02..553501bf46 100644
--- a/gr-digital/lib/cma_equalizer_cc_impl.h
+++ b/gr-digital/lib/cma_equalizer_cc_impl.h
@@ -43,24 +43,16 @@ namespace gr {
       float d_mu;
 
     protected:
-      gr_complex error(const gr_complex &out) 
-      { 
-	gr_complex error = out*(norm(out) - d_modulus);
-	float re = gr_clip(error.real(), 1.0);
-	float im = gr_clip(error.imag(), 1.0);
-	return gr_complex(re, im);
-      }
-
-      void update_tap(gr_complex &tap, const gr_complex &in) 
-      {
-	// Hn+1 = Hn - mu*conj(Xn)*zn*(|zn|^2 - 1)
-	tap -= d_mu*conj(in)*d_error;
-      }
+      gr_complex error(const gr_complex &out);
+      void update_tap(gr_complex &tap, const gr_complex &in);
   
     public:
       cma_equalizer_cc_impl(int num_taps, float modulus, float mu, int sps);
       ~cma_equalizer_cc_impl();
 
+      void set_taps(const std::vector<gr_complex> &taps);
+      std::vector<gr_complex> taps() const;
+
       float gain() const
       {
 	return d_mu;
diff --git a/gr-digital/lib/lms_dd_equalizer_cc_impl.cc b/gr-digital/lib/lms_dd_equalizer_cc_impl.cc
index 6c217896c3..15008ca8e7 100644
--- a/gr-digital/lib/lms_dd_equalizer_cc_impl.cc
+++ b/gr-digital/lib/lms_dd_equalizer_cc_impl.cc
@@ -32,6 +32,8 @@
 namespace gr {
   namespace digital {
 
+    using namespace filter::kernel;
+
     lms_dd_equalizer_cc::sptr
     lms_dd_equalizer_cc::make(int num_taps, float mu, int sps,
 			      constellation_sptr cnst)
@@ -47,25 +49,54 @@ namespace gr {
 			  gr_make_io_signature(1, 1, sizeof(gr_complex)),
 			  gr_make_io_signature(1, 1, sizeof(gr_complex)),
 			  sps),
-	filter::kernel::fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),
-	d_cnst(cnst)
+	fir_filter_ccc(sps, std::vector<gr_complex>(num_taps, gr_complex(0,0))),
+	d_new_taps(num_taps, gr_complex(0,0)),
+	d_updated(false), d_cnst(cnst)
     {
       set_gain(mu);
       if(num_taps > 0)
-	d_taps[0] = 1.0;
-      set_taps(d_taps);
+	d_new_taps[0] = 1.0;
+      fir_filter_ccc::set_taps(d_new_taps);
 
       const int alignment_multiple =
 	volk_get_alignment() / sizeof(gr_complex);
       set_alignment(std::max(1,alignment_multiple));
 
-      set_history(num_taps+1);
+      set_history(num_taps);
     }
 
     lms_dd_equalizer_cc_impl::~lms_dd_equalizer_cc_impl()
     {
     }
 
+    void
+    lms_dd_equalizer_cc_impl::set_taps(const std::vector<gr_complex> &taps)
+    {
+      d_new_taps = taps;
+      d_updated = true;
+    }
+
+    std::vector<gr_complex>
+    lms_dd_equalizer_cc_impl::taps() const
+    {
+      return d_taps;
+    }
+
+    gr_complex
+    lms_dd_equalizer_cc_impl::error(const gr_complex &out)
+    { 
+      gr_complex decision, error;
+      d_cnst->map_to_points(d_cnst->decision_maker(&out), &decision);
+      error = decision - out;
+      return error;
+    }
+
+    void
+    lms_dd_equalizer_cc_impl::update_tap(gr_complex &tap, const gr_complex &in) 
+    {
+      tap += d_mu*conj(in)*d_error;
+    }
+
     int
     lms_dd_equalizer_cc_impl::work(int noutput_items,
 				   gr_vector_const_void_star &input_items,
@@ -74,14 +105,26 @@ namespace gr {
       const gr_complex *in = (const gr_complex *)input_items[0];
       gr_complex *out = (gr_complex *)output_items[0];
 
+      if(d_updated) {
+	d_taps = d_new_taps;
+	set_history(d_taps.size());
+	d_updated = false;
+	return 0;		     // history requirements may have changed.
+      }
+
       int j = 0;
-      size_t l = d_taps.size();
+      size_t k, l = d_taps.size();
       for(int i = 0; i < noutput_items; i++) {
 	out[i] = filter(&in[j]);
 
+	// Adjust taps
 	d_error = error(out[i]);
-	for(size_t k=0; k < l; k++) {
-	  update_tap(d_taps[k], in[i+k]);
+	for(k = 0; k < l; k++) {
+	  // Update tap locally from error.
+	  update_tap(d_taps[k], in[j+k]);
+
+	  // Update aligned taps in filter object.
+	  fir_filter_ccc::update_tap(d_taps[k], k);
 	}
 
 	j += decimation();
diff --git a/gr-digital/lib/lms_dd_equalizer_cc_impl.h b/gr-digital/lib/lms_dd_equalizer_cc_impl.h
index aa84a71b4a..ca6ba4d84c 100644
--- a/gr-digital/lib/lms_dd_equalizer_cc_impl.h
+++ b/gr-digital/lib/lms_dd_equalizer_cc_impl.h
@@ -42,18 +42,8 @@ namespace gr {
       constellation_sptr d_cnst;
 
     protected:
-      gr_complex error(const gr_complex &out) 
-      { 
-	gr_complex decision, error;
-	d_cnst->map_to_points(d_cnst->decision_maker(&out), &decision);
-	error = decision - out;
-	return error;
-      }
-
-      void update_tap(gr_complex &tap, const gr_complex &in) 
-      {
-	tap += d_mu*conj(in)*d_error;
-      }
+      gr_complex error(const gr_complex &out);
+      void update_tap(gr_complex &tap, const gr_complex &in);
 
     public:
       lms_dd_equalizer_cc_impl(int num_taps,
@@ -61,6 +51,9 @@ namespace gr {
 			       constellation_sptr cnst);
       ~lms_dd_equalizer_cc_impl();
 
+      void set_taps(const std::vector<gr_complex> &taps);
+      std::vector<gr_complex> taps() const;
+
       float gain() const
       {
 	return d_mu;
diff --git a/gr-digital/python/qa_cma_equalizer.py b/gr-digital/python/qa_cma_equalizer.py
index 2af1505c1c..f71e199189 100755
--- a/gr-digital/python/qa_cma_equalizer.py
+++ b/gr-digital/python/qa_cma_equalizer.py
@@ -45,10 +45,8 @@ class test_cma_equalizer_fir(gr_unittest.TestCase):
 	expected_data = src_data
 	result = self.transform(src_data)
 
-        # only test last N samples to allow for settling. Also adjust
-        # for a 1 sample delay in the filter.
         N = -500
-        self.assertComplexTuplesAlmostEqual(expected_data[N:-1], result[N+1:])
+        self.assertComplexTuplesAlmostEqual(expected_data[N:], result[N:])
 
 if __name__ == "__main__":
     gr_unittest.run(test_cma_equalizer_fir, "test_cma_equalizer_fir.xml")
diff --git a/gr-digital/python/qa_lms_equalizer.py b/gr-digital/python/qa_lms_equalizer.py
index 7bde258e7f..9ba90a89ab 100755
--- a/gr-digital/python/qa_lms_equalizer.py
+++ b/gr-digital/python/qa_lms_equalizer.py
@@ -48,10 +48,8 @@ class test_lms_dd_equalizer(gr_unittest.TestCase):
 	expected_data = src_data[N:]
 	result = self.transform(src_data, 0.1, const)[N:]
 
-        # only test last N samples to allow for settling. Also adjust
-        # for a 1 sample delay in the filter.
         N = -500
-        self.assertComplexTuplesAlmostEqual(expected_data[N:-1], result[N+1:])
+        self.assertComplexTuplesAlmostEqual(expected_data[N:], result[N:], 5)
 
 if __name__ == "__main__":
     gr_unittest.run(test_lms_dd_equalizer, "test_lms_dd_equalizer.xml")
diff --git a/gr-filter/include/filter/fir_filter.h b/gr-filter/include/filter/fir_filter.h
index e861112681..a54059463f 100644
--- a/gr-filter/include/filter/fir_filter.h
+++ b/gr-filter/include/filter/fir_filter.h
@@ -39,6 +39,7 @@ namespace gr {
 	~fir_filter_fff();
 
 	void set_taps(const std::vector<float> &taps);
+	void update_tap(float t, unsigned int index);
 	std::vector<float> taps() const;
 	unsigned int ntaps() const;
 	
@@ -70,6 +71,7 @@ namespace gr {
 	~fir_filter_ccf();
 
 	void set_taps(const std::vector<float> &taps);
+	void update_tap(float t, unsigned int index);
 	std::vector<float> taps() const;
 	unsigned int ntaps() const;
 
@@ -101,6 +103,7 @@ namespace gr {
 	~fir_filter_fcc();
 
 	void set_taps(const std::vector<gr_complex> &taps);
+	void update_tap(gr_complex t, unsigned int index);
 	std::vector<gr_complex> taps() const;
 	unsigned int ntaps() const;
 
@@ -132,6 +135,7 @@ namespace gr {
 	~fir_filter_ccc();
 
 	void set_taps(const std::vector<gr_complex> &taps);
+	void update_tap(gr_complex t, unsigned int index);
 	std::vector<gr_complex> taps() const;
 	unsigned int ntaps() const;
 
@@ -163,6 +167,7 @@ namespace gr {
 	~fir_filter_scc();
 
 	void set_taps(const std::vector<gr_complex> &taps);
+	void update_tap(gr_complex t, unsigned int index);
 	std::vector<gr_complex> taps() const;
 	unsigned int ntaps() const;
 
@@ -194,6 +199,7 @@ namespace gr {
 	~fir_filter_fsf();
 
 	void set_taps(const std::vector<float> &taps);
+	void update_tap(float t, unsigned int index);
 	std::vector<float> taps() const;
 	unsigned int ntaps() const;
 
diff --git a/gr-filter/lib/fir_filter.cc b/gr-filter/lib/fir_filter.cc
index c0a3615623..de064939f7 100644
--- a/gr-filter/lib/fir_filter.cc
+++ b/gr-filter/lib/fir_filter.cc
@@ -83,7 +83,16 @@ namespace gr {
 	    d_aligned_taps[i][i+j] = d_taps[j];
 	}
       }
-      
+
+      void
+      fir_filter_fff::update_tap(float t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
       std::vector<float>
       fir_filter_fff::taps() const
       {
@@ -189,6 +198,15 @@ namespace gr {
 	}
       }
       
+      void
+      fir_filter_ccf::update_tap(float t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
       std::vector<float>
       fir_filter_ccf::taps() const
       {
@@ -296,6 +314,16 @@ namespace gr {
 	}
       }
       
+      void
+      fir_filter_fcc::update_tap(gr_complex t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
+
       std::vector<gr_complex>
       fir_filter_fcc::taps() const
       {
@@ -402,6 +430,15 @@ namespace gr {
 	}
       }
       
+      void
+      fir_filter_ccc::update_tap(gr_complex t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
       std::vector<gr_complex>
       fir_filter_ccc::taps() const
       {
@@ -507,6 +544,15 @@ namespace gr {
 	}
       }
       
+      void
+      fir_filter_scc::update_tap(gr_complex t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
       std::vector<gr_complex>
       fir_filter_scc::taps() const
       {
@@ -613,6 +659,15 @@ namespace gr {
 	}
       }
       
+      void
+      fir_filter_fsf::update_tap(float t, unsigned int index)
+      {
+	d_taps[index] = t;
+	for(int i = 0; i < d_naligned; i++) {
+	  d_aligned_taps[i][i+index] = t;
+	}
+      }
+
       std::vector<float>
       fir_filter_fsf::taps() const
       {