merged trondeau/digital-wip2 r4193:4730 into trunk - improves digital receiver and fixes ticket:72

git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@4731 221aa14e-8319-0410-a670-987f0aec2ac5

31 files changed, 4186 insertions, 223 deletions

diff --git a/gnuradio-core/src/lib/general/Makefile.am b/gnuradio-core/src/lib/general/Makefile.am
index d29259b4a..3856a319a 100644
--- a/gnuradio-core/src/lib/general/Makefile.am
+++ b/gnuradio-core/src/lib/general/Makefile.am
@@ -88,6 +88,7 @@ libgeneral_la_SOURCES = 		\
 	gr_map_bb.cc			\
 	gr_math.cc			\
 	gr_misc.cc			\
+	gr_mpsk_receiver_cc.cc		\
 	gr_nlog10_ff.cc			\
 	gr_nop.cc			\
 	gr_null_sink.cc			\
@@ -211,6 +212,7 @@ grinclude_HEADERS = 			\
 	gr_map_bb.h			\
 	gr_math.h			\
 	gr_misc.h			\
+	gr_mpsk_receiver_cc.h		\
 	gr_nco.h			\
 	gr_nlog10_ff.h			\
 	gr_nop.h			\
@@ -337,6 +339,7 @@ swiginclude_HEADERS =			\
 	gr_lms_dfe_cc.i			\
 	gr_lms_dfe_ff.i			\
 	gr_map_bb.i			\
+	gr_mpsk_receiver_cc.i		\
 	gr_nlog10_ff.i			\
 	gr_nop.i			\
 	gr_null_sink.i			\
diff --git a/gnuradio-core/src/lib/general/general.i b/gnuradio-core/src/lib/general/general.i
index b659beb52..87368f81e 100644
--- a/gnuradio-core/src/lib/general/general.i
+++ b/gnuradio-core/src/lib/general/general.i
@@ -67,6 +67,7 @@
 #include <gr_nlog10_ff.h>
 #include <gr_fake_channel_coder_pp.h>
 #include <gr_throttle.h>
+#include <gr_mpsk_receiver_cc.h>
 #include <gr_stream_to_streams.h>
 #include <gr_streams_to_stream.h>
 #include <gr_streams_to_vector.h>
@@ -157,6 +158,7 @@
 %include "gr_nlog10_ff.i"
 %include "gr_fake_channel_coder_pp.i"
 %include "gr_throttle.i"
+%include "gr_mpsk_receiver_cc.i"
 %include "gr_stream_to_streams.i"
 %include "gr_streams_to_stream.i"
 %include "gr_streams_to_vector.i"
diff --git a/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.cc b/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.cc
index 88cd14077..6166e25e6 100644
--- a/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.cc
+++ b/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.cc
@@ -133,47 +133,90 @@ gr_clock_recovery_mm_cc::general_work (int noutput_items,
   float mm_val=0;
   gr_complex u, x, y;
 
-  while(oo < noutput_items && ii < ni) {
-    d_p_2T = d_p_1T;
-    d_p_1T = d_p_0T;
-    d_p_0T = d_interp->interpolate (&in[ii], d_mu);
-
-    d_c_2T = d_c_1T;
-    d_c_1T = d_c_0T;
-    d_c_0T = slicer_0deg(d_p_0T);
-
-    x = (d_c_0T - d_c_2T) * conj(d_p_1T);
-    y = (d_p_0T - d_p_2T) * conj(d_c_1T);
-    u = y - x;
-    mm_val = u.real();
-    out[oo++] = d_p_0T;
-
-    // limit mm_val
-    if (mm_val > 1.0)
-      mm_val = 1.0;
-    else if (mm_val < -1.0)
-      mm_val = -1.0;
-
-    d_omega = d_omega + d_gain_omega * mm_val;
-    if (d_omega > d_max_omega)
-      d_omega = d_max_omega;
-    else if (d_omega < d_min_omega)
-      d_omega = d_min_omega;
-
-    d_mu = d_mu + d_omega + d_gain_mu * mm_val;
-    ii += (int)floor(d_mu);
-    d_mu -= floor(d_mu);
-
-    if(d_verbose) {
+  // This loop writes the error to the second output, if it exists
+  if (write_foptr) {
+    while(oo < noutput_items && ii < ni) {
+      d_p_2T = d_p_1T;
+      d_p_1T = d_p_0T;
+      d_p_0T = d_interp->interpolate (&in[ii], d_mu);
+
+      d_c_2T = d_c_1T;
+      d_c_1T = d_c_0T;
+      d_c_0T = slicer_0deg(d_p_0T);
+      
+      x = (d_c_0T - d_c_2T) * conj(d_p_1T);
+      y = (d_p_0T - d_p_2T) * conj(d_c_1T);
+      u = y - x;
+      mm_val = u.real();
+      out[oo++] = d_p_0T;
+      
+      // limit mm_val
+      if (mm_val > 1.0)
+	mm_val = 1.0;
+      else if (mm_val < -1.0)
+	mm_val = -1.0;
+      
+      d_omega = d_omega + d_gain_omega * mm_val;
+      if (d_omega > d_max_omega)
+	d_omega = d_max_omega;
+      else if (d_omega < d_min_omega)
+	d_omega = d_min_omega;
+      
+      d_mu = d_mu + d_omega + d_gain_mu * mm_val;
+      ii += (int)floor(d_mu);
+      d_mu -= floor(d_mu);
+      
+      #if 0
       printf("%f\t%f\n", d_omega, d_mu);
-    }
-
-    // write the error signal to the second output
-    if (write_foptr)
+      #endif
+      
+      // write the error signal to the second output
       foptr[oo-1] = gr_complex(d_mu,0);
-
-    if (ii < 0)	// clamp it.  This should only happen with bogus input
-      ii = 0;
+      
+      if (ii < 0)	// clamp it.  This should only happen with bogus input
+	ii = 0;
+    }
+  }
+  // This loop does not write to the second output (ugly, but faster)
+  else {
+    while(oo < noutput_items && ii < ni) {
+      d_p_2T = d_p_1T;
+      d_p_1T = d_p_0T;
+      d_p_0T = d_interp->interpolate (&in[ii], d_mu);
+
+      d_c_2T = d_c_1T;
+      d_c_1T = d_c_0T;
+      d_c_0T = slicer_0deg(d_p_0T);
+      
+      x = (d_c_0T - d_c_2T) * conj(d_p_1T);
+      y = (d_p_0T - d_p_2T) * conj(d_c_1T);
+      u = y - x;
+      mm_val = u.real();
+      out[oo++] = d_p_0T;
+      
+      // limit mm_val
+      if (mm_val > 1.0)
+	mm_val = 1.0;
+      else if (mm_val < -1.0)
+	mm_val = -1.0;
+      
+      d_omega = d_omega + d_gain_omega * mm_val;
+      if (d_omega > d_max_omega)
+	d_omega = d_max_omega;
+      else if (d_omega < d_min_omega)
+	d_omega = d_min_omega;
+      
+      d_mu = d_mu + d_omega + d_gain_mu * mm_val;
+      ii += (int)floor(d_mu);
+      d_mu -= floor(d_mu);
+      
+      if(d_verbose) {
+	printf("%f\t%f\n", d_omega, d_mu);
+      }
+            
+      if (ii < 0)	// clamp it.  This should only happen with bogus input
+	ii = 0;
+    }
   }
 
   if (ii > 0){
diff --git a/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.h b/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.h
index 0a2d73a94..c9a50358c 100644
--- a/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.h
+++ b/gnuradio-core/src/lib/general/gr_clock_recovery_mm_cc.h
@@ -41,10 +41,11 @@ gr_make_clock_recovery_mm_cc (float omega, float gain_omega, float mu, float gai
  * \ingroup block
  *
  * This implements the Mueller and Müller (M&M) discrete-time error-tracking synchronizer.
- *
- * See "Digital Communication Receivers: Synchronization, Channel
- * Estimation and Signal Processing" by Heinrich Meyr, Marc Moeneclaey, & Stefan Fechtel.
- * ISBN 0-471-50275-8.
+ * The complex version here is based on:
+ * Modified Mueller and Muller clock recovery circuit
+ * Based:
+ *    G. R. Danesfahani, T.G. Jeans, "Optimisation of modified Mueller and Muller 
+ *    algorithm,"  Electronics Letters, Vol. 31, no. 13,  22 June 1995, pp. 1032 - 1033.
  */
 class gr_clock_recovery_mm_cc : public gr_block
 {
diff --git a/gnuradio-core/src/lib/general/gr_correlate_access_code_bb.cc b/gnuradio-core/src/lib/general/gr_correlate_access_code_bb.cc
index 18253e968..078ff5028 100644
--- a/gnuradio-core/src/lib/general/gr_correlate_access_code_bb.cc
+++ b/gnuradio-core/src/lib/general/gr_correlate_access_code_bb.cc
@@ -88,7 +88,7 @@ gr_correlate_access_code_bb::work (int noutput_items,
 {
   const unsigned char *in = (const unsigned char *) input_items[0];
   unsigned char *out = (unsigned char *) output_items[0];
-  
+
   for (int i = 0; i < noutput_items; i++){
 
     // compute output value
@@ -109,9 +109,12 @@ gr_correlate_access_code_bb::work (int noutput_items,
     // test for access code with up to threshold errors
     new_flag = (nwrong <= d_threshold);
 
-#if 0   
+#if VERBOSE
     if(new_flag) {
-      printf("%llx  ==>  %llx  :  d_flip=%u\n", d_access_code, d_data_reg, d_flip);
+      fprintf(stderr, "access code found: %llx\n", d_access_code);
+    }
+    else {
+      fprintf(stderr, "%llx  ==>  %llx\n", d_access_code, d_data_reg);
     }
 #endif
 
diff --git a/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.cc b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.cc
new file mode 100644
index 000000000..87b2f541a
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.cc
@@ -0,0 +1,345 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2005,2006,2007 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 2, 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_io_signature.h>
+#include <gr_prefs.h>
+#include <gr_mpsk_receiver_cc.h>
+#include <stdexcept>
+#include <gr_math.h>
+#include <gr_expj.h>
+#include <gri_mmse_fir_interpolator_cc.h>
+
+
+#define M_TWOPI (2*M_PI)
+#define VERBOSE_MM     0     // Used for debugging symbol timing loop
+#define VERBOSE_COSTAS 0     // Used for debugging phase and frequency tracking
+
+// Public constructor
+
+gr_mpsk_receiver_cc_sptr 
+gr_make_mpsk_receiver_cc(unsigned int M, float theta,
+			 float alpha, float beta,
+			 float fmin, float fmax,
+			 float mu, float gain_mu, 
+			 float omega, float gain_omega, float omega_rel)
+{
+  return gr_mpsk_receiver_cc_sptr (new gr_mpsk_receiver_cc (M, theta, 
+							    alpha, beta,
+							    fmin, fmax,
+							    mu, gain_mu, 
+							    omega, gain_omega, omega_rel));
+}
+
+gr_mpsk_receiver_cc::gr_mpsk_receiver_cc (unsigned int M, float theta, 
+					  float alpha, float beta,
+					  float fmin, float fmax,
+					  float mu, float gain_mu, 
+					  float omega, float gain_omega, float omega_rel)
+  : gr_block ("mpsk_receiver_cc",
+	      gr_make_io_signature (1, 1, sizeof (gr_complex)),
+	      gr_make_io_signature (1, 1, sizeof (gr_complex))),
+    d_M(M), d_theta(theta), 
+    d_alpha(alpha), d_beta(beta), d_freq(0), d_max_freq(fmax), d_min_freq(fmin), d_phase(0),
+    d_current_const_point(0),
+    d_mu(mu), d_gain_mu(gain_mu), d_gain_omega(gain_omega), 
+    d_omega_rel(omega_rel), d_max_omega(0), d_min_omega(0),
+    d_p_2T(0), d_p_1T(0), d_p_0T(0), d_c_2T(0), d_c_1T(0), d_c_0T(0)
+{
+  d_interp = new gri_mmse_fir_interpolator_cc();
+  d_dl_idx = 0;
+
+  set_omega(omega);
+
+  if (omega <= 0.0)
+    throw std::out_of_range ("clock rate must be > 0");
+  if (gain_mu <  0  || gain_omega < 0)
+    throw std::out_of_range ("Gains must be non-negative");
+  
+  assert(d_interp->ntaps() <= DLLEN);
+  
+  // zero double length delay line.
+  for (unsigned int i = 0; i < 2 * DLLEN; i++)
+    d_dl[i] = gr_complex(0.0,0.0);
+
+  // build the constellation vector from M
+  make_constellation();
+  
+  // Select a phase detector and a decision maker for the modulation order
+  switch(d_M) {
+  case 2:  // optimized algorithms for BPSK
+    d_phase_error_detector = &gr_mpsk_receiver_cc::phase_error_detector_generic; //bpsk;
+    d_decision = &gr_mpsk_receiver_cc::decision_generic; //bpsk;
+    break;
+
+  case 4: // optimized algorithms for QPSK
+    d_phase_error_detector = &gr_mpsk_receiver_cc::phase_error_detector_generic; //qpsk;
+    d_decision = &gr_mpsk_receiver_cc::decision_generic; //qpsk;
+    break;
+
+  default: // generic algorithms for any M (power of 2?) but not pretty
+    d_phase_error_detector = &gr_mpsk_receiver_cc::phase_error_detector_generic;
+    d_decision = &gr_mpsk_receiver_cc::decision_generic;
+    break;
+  }
+
+  set_history(3);			// ensure 2 extra input sample is available
+}
+
+gr_mpsk_receiver_cc::~gr_mpsk_receiver_cc ()
+{
+  delete d_interp;
+}
+
+void
+gr_mpsk_receiver_cc::forecast(int noutput_items, gr_vector_int &ninput_items_required)
+{
+  unsigned ninputs = ninput_items_required.size();
+  for (unsigned i=0; i < ninputs; i++)
+    ninput_items_required[i] = (int) ceil((noutput_items * d_omega) + d_interp->ntaps());
+  //ninput_items_required[i] = (int)(d_omega);
+
+}
+
+// FIXME add these back in an test difference in performance
+float
+gr_mpsk_receiver_cc::phase_error_detector_qpsk(gr_complex sample) const
+{
+  float phase_error = ((sample.real()>0 ? 1.0 : -1.0) * sample.imag() -
+		       (sample.imag()>0 ? 1.0 : -1.0) * sample.real());
+  return -phase_error;
+}
+
+// FIXME add these back in an test difference in performance
+float
+gr_mpsk_receiver_cc::phase_error_detector_bpsk(gr_complex sample) const
+{
+  return (sample.real()*sample.imag());
+}
+
+float gr_mpsk_receiver_cc::phase_error_detector_generic(gr_complex sample) const
+{
+  //return gr_fast_atan2f(sample*conj(d_constellation[d_current_const_point]));
+  return -arg(sample*conj(d_constellation[d_current_const_point]));
+}
+
+// FIXME add these back in an test difference in performance
+unsigned int
+gr_mpsk_receiver_cc::decision_bpsk(gr_complex sample) const
+{
+  unsigned int index = 0;
+
+  // Implements a 1-demensional slicer
+  if(sample.real() > 0)
+    index = 1;
+  return index;
+}
+
+// FIXME add these back in an test difference in performance
+unsigned int
+gr_mpsk_receiver_cc::decision_qpsk(gr_complex sample) const
+{
+  unsigned int index = 0;
+
+  // Implements a simple slicer function
+  if((sample.real() < 0) && (sample.imag() > 0))
+    index = 1;
+  else if((sample.real() < 0) && (sample.imag() < 0))
+    index = 2;
+  else
+    index = 3;
+  return index;
+}
+
+unsigned int
+gr_mpsk_receiver_cc::decision_generic(gr_complex sample) const
+{
+  unsigned int min_m = 0;
+  float min_s = 65535;
+  
+  // Develop all possible constellation points and find the one that minimizes
+  // the Euclidean distance (error) with the sample
+  for(unsigned int m=0; m < d_M; m++) {
+    gr_complex diff = norm(d_constellation[m] - sample);
+    
+    if(fabs(diff.real()) < min_s) {
+      min_s = fabs(diff.real());
+      min_m = m;
+    }
+  }
+  // Return the index of the constellation point that minimizes the error
+  return min_m;
+}
+
+
+void
+gr_mpsk_receiver_cc::make_constellation()
+{
+  for(unsigned int m=0; m < d_M; m++) {
+    d_constellation.push_back(gr_expj((M_TWOPI/d_M)*m));
+  }
+}
+
+void
+gr_mpsk_receiver_cc::mm_sampler(const gr_complex symbol)
+{
+  gr_complex sample, nco;
+
+  d_mu--;             // skip a number of symbols between sampling
+  d_phase += d_freq;  // increment the phase based on the frequency of the rotation
+
+  // Keep phase clamped and not walk to infinity
+  while(d_phase>M_TWOPI)
+    d_phase -= M_TWOPI;
+  while(d_phase<-M_TWOPI)
+    d_phase += M_TWOPI;
+
+  nco = gr_expj(d_phase+d_theta);   // get the NCO value for derotating the current sample
+  sample = nco*symbol;      // get the downconverted symbol
+  
+  // Fill up the delay line for the interpolator
+  d_dl[d_dl_idx] = sample;
+  d_dl[(d_dl_idx + DLLEN)] = sample;  // put this in the second half of the buffer for overflows
+  d_dl_idx = (d_dl_idx+1) % DLLEN;    // Keep the delay line index in bounds
+}
+
+void
+gr_mpsk_receiver_cc::mm_error_tracking(gr_complex sample)
+{
+  gr_complex u, x, y;
+  float mm_error = 0;
+
+  // Make sample timing corrections
+
+  // set the delayed samples
+  d_p_2T = d_p_1T;
+  d_p_1T = d_p_0T;
+  d_p_0T = sample;
+  d_c_2T = d_c_1T;
+  d_c_1T = d_c_0T;
+  
+  d_current_const_point = (*this.*d_decision)(d_p_0T);  // make a decision on the sample value
+  d_c_0T = d_constellation[d_current_const_point];
+  
+  x = (d_c_0T - d_c_2T) * conj(d_p_1T);
+  y = (d_p_0T - d_p_2T) * conj(d_c_1T);
+  u = y - x;
+  mm_error = u.real();   // the error signal is in the real part
+  
+  // limit mm_val
+  if (mm_error > 1.0)
+    mm_error = 1.0;
+  else if (mm_error < -1.0)
+    mm_error = -1.0;
+  
+  d_omega = d_omega + d_gain_omega * mm_error;  // update omega based on loop error
+
+  // make sure we don't walk away
+  if (d_omega > d_max_omega)
+    d_omega = d_max_omega;
+  else if (d_omega < d_min_omega)
+    d_omega = d_min_omega;
+  
+  d_mu += d_omega + d_gain_mu * mm_error;   // update mu based on loop error
+  
+#if VERBOSE_MM
+  printf("mm: mu: %f   omega: %f  mm_error: %f  sample: %f+j%f  constellation: %f+j%f\n", 
+	 d_mu, d_omega, mm_error, sample.real(), sample.imag(), 
+	 d_constellation[d_current_const_point].real(), d_constellation[d_current_const_point].imag());
+#endif
+}
+
+
+void
+gr_mpsk_receiver_cc::phase_error_tracking(gr_complex sample)
+{
+  float phase_error = 0;
+
+  // Make phase and frequency corrections based on sampled value
+  phase_error = (*this.*d_phase_error_detector)(sample);
+
+  if (phase_error > 1)
+    phase_error = 1;
+  else if (phase_error < -1)
+    phase_error = -1;  
+
+  d_freq += d_beta*phase_error;             // adjust frequency based on error
+  d_phase += d_freq + d_alpha*phase_error;  // adjust phase based on error
+  
+  // Make sure we stay within +-2pi
+  while(d_phase>M_TWOPI)
+    d_phase -= M_TWOPI;
+  while(d_phase<-M_TWOPI)
+    d_phase += M_TWOPI;
+  
+  // Limit the frequency range
+  if (d_freq > d_max_freq)
+    d_freq = d_max_freq;
+  else if (d_freq < d_min_freq)
+    d_freq = d_min_freq;
+
+#if VERBOSE_COSTAS
+  printf("cl: phase_error: %f  phase: %f  freq: %f  sample: %f+j%f  constellation: %f+j%f\n",
+	 phase_error, d_phase, d_freq, sample.real(), sample.imag(), 
+	 d_constellation[d_current_const_point].real(), d_constellation[d_current_const_point].imag());
+#endif
+}
+
+int
+gr_mpsk_receiver_cc::general_work (int noutput_items,
+				   gr_vector_int &ninput_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];
+
+  int i=0, o=0;
+
+  //while(i < ninput_items[0]) {    
+  while(o < noutput_items) {
+    while((d_mu > 1) && (i < ninput_items[0]))  {
+      mm_sampler(in[i]);   // puts symbols into a buffer and adjusts d_mu
+      i++;
+    }
+    
+    if(i < ninput_items[0]) {
+      gr_complex interp_sample = d_interp->interpolate(&d_dl[d_dl_idx], d_mu);
+       
+      mm_error_tracking(interp_sample);     // corrects M&M sample time
+      phase_error_tracking(interp_sample);  // corrects phase and frequency offsets
+
+      out[o++] = interp_sample;
+    }
+  }
+
+  #if 0
+  printf("ninput_items: %d   noutput_items: %d   consuming: %d   returning: %d\n",
+	 ninput_items[0], noutput_items, i, o);
+  #endif
+
+  consume_each(i);
+  return o;
+}
diff --git a/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.h b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.h
new file mode 100644
index 000000000..f096af484
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.h
@@ -0,0 +1,313 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2004 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 2, 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_MPSK_RECEIVER_CC_H
+#define	INCLUDED_GR_MPSK_RECEIVER_CC_H
+
+#include <gr_block.h>
+#include <gr_complex.h>
+#include <fstream>
+
+class gri_mmse_fir_interpolator_cc;
+
+class gr_mpsk_receiver_cc;
+typedef boost::shared_ptr<gr_mpsk_receiver_cc> gr_mpsk_receiver_cc_sptr;
+
+// public constructor
+gr_mpsk_receiver_cc_sptr 
+gr_make_mpsk_receiver_cc (unsigned int M, float theta, 
+			  float alpha, float beta,
+			  float fmin, float fmax,
+			  float mu, float gain_mu, 
+			  float omega, float gain_omega, float omega_rel);
+
+/*!
+ * \brief This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol
+ * synchronization. 
+ * \ingroup block
+ *
+ * This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol
+ * synchronization. It performs carrier frequency and phase locking as well as symbol timing recovery. 
+ * It works with (D)BPSK, (D)QPSK, and (D)8PSK as tested currently. It should also work for OQPSK and 
+ * PI/4 DQPSK.
+ *
+ * The phase and frequency synchronization are based on a Costas loop that finds the error of the incoming
+ * signal point compared to its nearest constellation point. The frequency and phase of the NCO are 
+ * updated according to this error. There are optimized phase error detectors for BPSK and QPSK, but 8PSK
+ * is done using a brute-force computation of the constellation points to find the minimum.
+ *
+ * The symbol synchronization is done using a modified Mueller and Muller circuit from the paper:
+ * 
+ *    G. R. Danesfahani, T.G. Jeans, "Optimisation of modified Mueller and Muller 
+ *    algorithm,"  Electronics Letters, Vol. 31, no. 13,  22 June 1995, pp. 1032 - 1033.
+ *
+ * This circuit interpolates the downconverted sample (using the NCO developed by the Costas loop)
+ * every mu samples, then it finds the sampling error based on this and the past symbols and the decision
+ * made on the samples. Like the phase error detector, there are optimized decision algorithms for BPSK
+ * and QPKS, but 8PSK uses another brute force computation against all possible symbols. The modifications
+ * to the M&M used here reduce self-noise.
+ *
+ */
+
+class gr_mpsk_receiver_cc : public gr_block
+{
+ public:
+  ~gr_mpsk_receiver_cc ();
+  void forecast(int noutput_items, gr_vector_int &ninput_items_required);
+  int general_work (int noutput_items,
+		    gr_vector_int &ninput_items,
+		    gr_vector_const_void_star &input_items,
+		    gr_vector_void_star &output_items);
+
+
+  // Member functions related to the symbol tracking portion of the receiver
+  //! (M&M) Returns current value of mu
+  float mu() const { return d_mu;}
+
+  //! (M&M) Returns current value of omega
+  float omega() const { return d_omega;}
+
+  //! (M&M) Returns mu gain factor
+  float gain_mu() const { return d_gain_mu;}
+
+  //! (M&M) Returns omega gain factor
+  float gain_omega() const { return d_gain_omega;}
+
+  //! (M&M) Sets value of mu
+  void set_mu (float mu) { d_mu = mu; }
+  
+  //! (M&M) Sets value of omega and its min and max values 
+  void set_omega (float omega) { 
+    d_omega = omega;
+    d_min_omega = omega*(1.0 - d_omega_rel);
+    d_max_omega = omega*(1.0 + d_omega_rel);
+  }
+
+  //! (M&M) Sets value for mu gain factor
+  void set_gain_mu (float gain_mu) { d_gain_mu = gain_mu; }
+
+  //! (M&M) Sets value for omega gain factor
+  void set_gain_omega (float gain_omega) { d_gain_omega = gain_omega; }
+
+
+
+  // Member function related to the phase/frequency tracking portion of the receiver
+  //! (CL) Returns the value for alpha (the phase gain term)
+  float alpha() const { return d_alpha; }
+  
+  //! (CL) Returns the value of beta (the frequency gain term)
+  float beta() const { return d_beta; }
+
+  //! (CL) Returns the current value of the frequency of the NCO in the Costas loop
+  float freq() const { return d_freq; }
+
+  //! (CL) Returns the current value of the phase of the NCO in the Costal loop
+  float phase() const { return d_phase; }
+
+  //! (CL) Sets the value for alpha (the phase gain term)
+  void set_alpha(float alpha) { d_alpha = alpha; }
+  
+  //! (CL) Setss the value of beta (the frequency gain term)
+  void set_beta(float beta) { d_beta = beta; }
+
+  //! (CL) Sets the current value of the frequency of the NCO in the Costas loop
+  void set_freq(float freq) { d_freq = freq; }
+
+  //! (CL) Setss the current value of the phase of the NCO in the Costal loop
+  void set_phase(float phase) { d_phase = phase; }
+
+
+protected:
+
+ /*!
+   * \brief Constructor to synchronize incoming M-PSK symbols
+   *
+   * \param M	        modulation order of the M-PSK modulation
+   * \param theta	any constant phase rotation from the real axis of the constellation
+   * \param alpha	gain parameter to adjust the phase in the Costas loop (~0.01)
+   * \param beta        gain parameter to adjust the frequency in the Costas loop (~alpha^2/4)	
+   * \param fmin        minimum normalized frequency value the loop can achieve
+   * \param fmax        maximum normalized frequency value the loop can achieve
+   * \param mu          initial parameter for the interpolator [0,1]
+   * \param gain_mu     gain parameter of the M&M error signal to adjust mu (~0.05)
+   * \param omega       initial value for the number of symbols between samples (~number of samples/symbol)
+   * \param gain_omega  gain parameter to adjust omega based on the error (~omega^2/4)
+   * \param omega_rel   sets the maximum (omega*(1+omega_rel)) and minimum (omega*(1+omega_rel)) omega (~0.005)
+   *
+   * The constructor also chooses which phase detector and decision maker to use in the work loop based on the
+   * value of M.
+   */
+  gr_mpsk_receiver_cc (unsigned int M, float theta, 
+		       float alpha, float beta,
+		       float fmin, float fmax,
+		       float mu, float gain_mu, 
+		       float omega, float gain_omega, float omega_rel);
+
+  void make_constellation();
+  void mm_sampler(const gr_complex symbol);
+  void mm_error_tracking(gr_complex sample);
+  void phase_error_tracking(gr_complex sample);
+
+
+/*!
+   * \brief Phase error detector for MPSK modulations.
+   *
+   * \param sample   the I&Q sample from which to determine the phase error
+   *
+   * This function determines the phase error for any MPSK signal by creating a set of PSK constellation points
+   * and doing a brute-force search to see which point minimizes the Euclidean distance. This point is then used
+   * to derotate the sample to the real-axis and a atan (using the fast approximation function) to determine the
+   * phase difference between the incoming sample and the real constellation point
+   *
+   * This should be cleaned up and made more efficient.
+   *
+   * \returns the approximated phase error.
+ */
+  float phase_error_detector_generic(gr_complex sample) const; // generic for M but more costly
+
+ /*!
+   * \brief Phase error detector for BPSK modulation.
+   *
+   * \param sample   the I&Q sample from which to determine the phase error
+   *
+   * This function determines the phase error using a simple BPSK phase error detector by multiplying the real
+   * and imaginary (the error signal) components together. As the imaginary part goes to 0, so does this error.
+   *
+   * \returns the approximated phase error.
+ */
+  float phase_error_detector_bpsk(gr_complex sample) const;    // optimized for BPSK
+
+ /*!
+   * \brief Phase error detector for QPSK modulation.
+   *
+   * \param sample   the I&Q sample from which to determine the phase error
+   *
+   * This function determines the phase error using the limiter approach in a standard 4th order Costas loop
+   *
+   * \returns the approximated phase error.
+ */
+  float phase_error_detector_qpsk(gr_complex sample) const;
+
+
+
+ /*!
+   * \brief Decision maker for a generic MPSK constellation.
+   *
+   * \param sample   the baseband I&Q sample from which to make the decision
+   *
+   * This decision maker is a generic implementation that does a brute-force search 
+   * for the constellation point that minimizes the error between it and the incoming signal.
+   *
+   * \returns the index to d_constellation that minimizes the error/
+ */
+  unsigned int decision_generic(gr_complex sample) const;
+
+
+ /*!
+   * \brief Decision maker for BPSK constellation.
+   *
+   * \param sample   the baseband I&Q sample from which to make the decision
+   *
+   * This decision maker is a simple slicer function that makes a decision on the symbol based on its
+   * placement on the real axis of greater than 0 or less than 0; the quadrature component is always 0.
+   *
+   * \returns the index to d_constellation that minimizes the error/
+ */
+  unsigned int decision_bpsk(gr_complex sample) const;
+  
+
+ /*!
+   * \brief Decision maker for QPSK constellation.
+   *
+   * \param sample   the baseband I&Q sample from which to make the decision
+   *
+   * This decision maker is a simple slicer function that makes a decision on the symbol based on its
+   * placement versus both axes and returns which quadrant the symbol is in.
+   *
+   * \returns the index to d_constellation that minimizes the error/
+ */
+  unsigned int decision_qpsk(gr_complex sample) const;
+
+  private:
+  unsigned int d_M;
+  float        d_theta;
+
+  // Members related to carrier and phase tracking
+  float d_alpha;
+  float d_beta;
+  float d_freq, d_max_freq, d_min_freq;
+  float d_phase;
+
+/*!
+   * \brief Decision maker function pointer 
+   *
+   * \param sample   the baseband I&Q sample from which to make the decision
+   *
+   * This is a function pointer that is set in the constructor to point to the proper decision function
+   * for the specified constellation order.
+   *
+   * \return index into d_constellation point that is the closest to the recieved sample
+ */
+  unsigned int (gr_mpsk_receiver_cc::*d_decision)(gr_complex sample) const; // pointer to decision function
+
+
+  std::vector<gr_complex> d_constellation;
+  unsigned int d_current_const_point;
+
+  // Members related to symbol timing
+  float d_mu, d_gain_mu;
+  float d_omega, d_gain_omega, d_omega_rel, d_max_omega, d_min_omega;
+  gr_complex d_p_2T, d_p_1T, d_p_0T;
+  gr_complex d_c_2T, d_c_1T, d_c_0T;
+
+ /*!
+   * \brief Phase error detector function pointer 
+   *
+   * \param sample   the I&Q sample from which to determine the phase error
+   *
+   * This is a function pointer that is set in the constructor to point to the proper phase error detector
+   * function for the specified constellation order.
+ */
+  float (gr_mpsk_receiver_cc::*d_phase_error_detector)(gr_complex sample) const;
+
+
+  //! get interpolated value
+  gri_mmse_fir_interpolator_cc 	*d_interp;
+  
+  //! delay line length.
+  static const unsigned int DLLEN = 8;
+  
+  //! delay line plus some length for overflow protection
+  gr_complex d_dl[2*DLLEN];
+  
+  //! index to delay line
+  unsigned int d_dl_idx;
+
+  friend gr_mpsk_receiver_cc_sptr
+  gr_make_mpsk_receiver_cc (unsigned int M, float theta,
+			    float alpha, float beta,
+			    float fmin, float fmax,
+			    float mu, float gain_mu, 
+			    float omega, float gain_omega, float omega_rel);
+};
+
+#endif
diff --git a/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.i b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.i
new file mode 100644
index 000000000..661b4d04d
--- /dev/null
+++ b/gnuradio-core/src/lib/general/gr_mpsk_receiver_cc.i
@@ -0,0 +1,59 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2004 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 2, 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,mpsk_receiver_cc);
+
+gr_mpsk_receiver_cc_sptr gr_make_mpsk_receiver_cc (unsigned int M, float theta,
+						   float alpha, float beta,
+						   float fmin, float fmax,
+						   float mu, float gain_mu, 
+						   float omega, float gain_omega, float omega_rel);
+class gr_mpsk_receiver_cc : public gr_block
+{
+ private:
+  gr_mpsk_receiver_cc (unsigned int M,float theta,
+				float alpha, float beta,
+				float fmin, float fmax,
+				float mu, float gain_mu, 
+				float omega, float gain_omega, float omega_rel);
+public:
+  float mu() const { return d_mu;}
+  float omega() const { return d_omega;}
+  float gain_mu() const { return d_gain_mu;}
+  float gain_omega() const { return d_gain_omega;}
+  void set_mu (float mu) { d_mu = mu; }
+  void set_omega (float omega) { 
+    d_omega = omega;
+    d_min_omega = omega*(1.0 - d_omega_rel);
+    d_max_omega = omega*(1.0 + d_omega_rel);
+  }
+  void set_gain_mu (float gain_mu) { d_gain_mu = gain_mu; }
+  void set_gain_omega (float gain_omega) { d_gain_omega = gain_omega; }
+  float alpha() const { return d_alpha; }
+  float beta() const { return d_beta; }
+  float freq() const { return d_freq; }
+  float phase() const { return d_phase; }
+  void set_alpha(float alpha) { d_alpha = alpha; }
+  void set_beta(float beta) { d_beta = beta; }
+  void set_freq(float freq) { d_freq = freq; }
+  void set_phase(float phase) { d_phase = phase; } 
+};
diff --git a/gnuradio-core/src/python/gnuradio/Makefile.am b/gnuradio-core/src/python/gnuradio/Makefile.am
index 4f8972f09..0d53a11cc 100644
--- a/gnuradio-core/src/python/gnuradio/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/Makefile.am
@@ -21,7 +21,7 @@
 
 include $(top_srcdir)/Makefile.common
 
-SUBDIRS = gr gru gruimpl blks blksimpl
+SUBDIRS = gr gru gruimpl blks blksimpl blks2 blksimpl2
 
 grpython_PYTHON = 			\
 	__init__.py			\
diff --git a/gnuradio-core/src/python/gnuradio/blks2/Makefile.am b/gnuradio-core/src/python/gnuradio/blks2/Makefile.am
new file mode 100644
index 000000000..ec0547b6f
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blks2/Makefile.am
@@ -0,0 +1,35 @@
+#
+# Copyright 2005 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 2, 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.
+# 
+
+include $(top_srcdir)/Makefile.common
+
+# EXTRA_DIST = run_tests.in
+# TESTS = run_tests
+
+grblks2pythondir = $(grpythondir)/blks2
+
+grblks2python_PYTHON =		\
+	__init__.py		
+
+
+noinst_PYTHON = 		
+
+CLEANFILES = *.pyc *.pyo
diff --git a/gnuradio-core/src/python/gnuradio/blks2/__init__.py b/gnuradio-core/src/python/gnuradio/blks2/__init__.py
new file mode 100644
index 000000000..da262dfc6
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blks2/__init__.py
@@ -0,0 +1,37 @@
+#
+# Copyright 2005 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 2, 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.
+# 
+
+import glob
+import os.path
+
+# Semi-hideous kludge to import everything in the blksimpl2 directory
+# into the gnuradio.blks2 namespace.  This keeps us from having to remember 
+# to manually update this file.
+
+for p in __path__:
+    filenames = glob.glob (os.path.join (p, "..", "blksimpl2", "*.py"))
+    for f in filenames:
+        f = os.path.basename(f).lower()
+        f = f[:-3]
+        if f == '__init__':
+            continue
+        # print f
+        exec "from gnuradio.blksimpl2.%s import *" % (f,)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am b/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
index 8122bfa6a..6bfbfa904 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
@@ -31,6 +31,7 @@ grblkspython_PYTHON =		\
 	am_demod.py		\
 	dbpsk.py		\
 	dqpsk.py		\
+	d8psk.py		\
 	filterbank.py		\
 	fm_demod.py		\
 	fm_emph.py		\
@@ -39,6 +40,11 @@ grblkspython_PYTHON =		\
 	nbfm_tx.py		\
 	pkt.py			\
 	psk.py			\
+	qam.py			\
+	qam8.py			\
+	qam16.py		\
+	qam64.py		\
+	qam256.py		\
 	rational_resampler.py	\
 	standard_squelch.py	\
 	wfm_rcv.py		\
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/d8psk.py b/gnuradio-core/src/python/gnuradio/blksimpl/d8psk.py
new file mode 100644
index 000000000..42839a0c3
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/d8psk.py
@@ -0,0 +1,364 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+differential 8PSK modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import psk
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 3
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = 0.175
+_def_gain_mu = 0.175
+_def_mu = 0.5
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           D8PSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class d8psk_mod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2,self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+	# Connect & Initialize base class
+        self._fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                         self.chunks2symbols, self.rrc_filter)
+	gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.bytes2chunks,
+                         gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "tx_graycoder.dat"))
+        self._fg.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))        
+        self._fg.connect(self.chunks2symbols,
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
+
+    def add_options(parser):
+        """
+        Adds 8PSK modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(d8psk_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           D8PSK demodulator
+#
+# Differentially coherent detection of differentially encoded 8psk
+# /////////////////////////////////////////////////////////////////////////////
+
+class d8psk_demod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered DQPSK demodulation
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (LSB)
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: float
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param costas_alpha: loop filter gain
+        @type costas_alphas: float
+        @param gain_mu: for M&M block
+        @type gain_mu: float
+        @param mu: for M&M block
+        @type mu: float
+        @param omega_relative_limit: for M&M block
+        @type omega_relative_limit: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._costas_alpha = costas_alpha
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
+        self._gray_code = gray_code
+
+        if samples_per_symbol < 2:
+            raise TypeError, "sbp must be >= 2, is %d" % samples_per_symbol
+
+        arity = pow(2,self.bits_per_symbol())
+ 
+        # Automatic gain control
+        scale = (1.0/16384.0)
+        self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
+        #self.agc = gr.agc_cc(1e-2, 1, 1, 100)
+        self.agc = gr.agc2_cc(1e-1, 1e-2, 1, 1, 100)
+        #self.agc = gr.feedforward_agc_cc(16, 1.0)
+
+        # RRC data filter
+        ntaps = 11 * samples_per_symbol
+        self.rrc_taps = gr.firdes.root_raised_cosine(
+            1.0,                      # gain
+            self._samples_per_symbol, # sampling rate
+            1.0,                      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
+
+        # symbol clock recovery
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.025
+        fmax = 0.025
+
+        self.receiver=gr.mpsk_receiver_cc(arity, 0,
+                                         self._costas_alpha, self._costas_beta,
+                                         fmin, fmax,
+                                         self._mm_mu, self._mm_gain_mu,
+                                         self._mm_omega, self._mm_gain_omega,
+                                         self._mm_omega_relative_limit)
+        
+        # Perform Differential decoding on the constellation
+        self.diffdec = gr.diff_phasor_cc()
+
+        # find closest constellation point
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.gray_to_binary[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[arity])
+
+        
+        # unpack the k bit vector into a stream of bits
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+ 
+        # Connect & Initialize base class
+        self._fg.connect(self.pre_scaler, self.agc, self.rrc_filter, self.receiver,
+                         self.diffdec, self.slicer, self.symbol_mapper, self.unpack)
+        gr.hier_block.__init__(self, self._fg, self.pre_scaler, self.unpack)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
+        
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.pre_scaler,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
+        self._fg.connect(self.agc,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self._fg.connect(self.receiver,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
+        self._fg.connect(self.diffdec,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_diffdec.dat"))        
+        self._fg.connect(self.slicer,
+                         gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "rx_gray_decoder.dat"))
+        self._fg.connect(self.unpack,
+                         gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+        parser.add_option("", "--costas-alpha", type="float", default=_def_costas_alpha,
+                          help="set Costas loop alpha value [default=%default] (PSK)")
+        parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
+                          help="set M&M symbol sync loop gain mu value [default=%default] (PSK)")
+        parser.add_option("", "--mu", type="float", default=_def_mu,
+                          help="set M&M symbol sync loop mu value [default=%default] (PSK)")
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(
+            d8psk_demod.__init__, ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('d8psk', d8psk_mod)
+#modulation_utils.add_type_1_demod('d8psk', d8psk_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
index 470ab8e2a..28fb42663 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
@@ -39,9 +39,9 @@ _def_gray_code = True
 _def_verbose = False
 _def_log = False
 
-_def_costas_alpha = None
-_def_gain_mu = 0.03
-_def_mu = 0.05
+_def_costas_alpha = 0.1
+_def_gain_mu = None
+_def_mu = 0.5
 _def_omega_relative_limit = 0.005
 
 
@@ -88,7 +88,7 @@ class dbpsk_mod(gr.hier_block):
 	ntaps = 11 * self._samples_per_symbol
 
         arity = pow(2,self.bits_per_symbol())
-       
+        
         # turn bytes into k-bit vectors
         self.bytes2chunks = \
           gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
@@ -99,18 +99,17 @@ class dbpsk_mod(gr.hier_block):
             self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
 
         self.diffenc = gr.diff_encoder_bb(arity)
-        
+
         self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
 
         # pulse shaping filter
 	self.rrc_taps = gr.firdes.root_raised_cosine(
-	    self._samples_per_symbol, # gain  (samples_per_symbol since we're
-                                      # interpolating by samples_per_symbol)
-	    self._samples_per_symbol, # sampling rate
-	    1.0,		      # symbol rate
-	    self._excess_bw,          # excess bandwidth (roll-off factor)
+	    self._samples_per_symbol,   # gain (samples_per_symbol since we're
+                                        # interpolating by samples_per_symbol)
+	    self._samples_per_symbol,   # sampling rate
+	    1.0,		        # symbol rate
+	    self._excess_bw,            # excess bandwidth (roll-off factor)
             ntaps)
-
 	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
                                                    self.rrc_taps)
 
@@ -155,22 +154,23 @@ class dbpsk_mod(gr.hier_block):
 
 
     def _print_verbage(self):
-        print "bits per symbol = %d" % self.bits_per_symbol()
-        print "Gray code = %s" % self._gray_code
-        print "RRC roll-off factor = %.2f" % self._excess_bw
+        print "\nModulator:"
+        print "bits per symbol:     %d" % self.bits_per_symbol()
+        print "Gray code:           %s" % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
 
     def _setup_logging(self):
         print "Modulation logging turned on."
         self._fg.connect(self.bytes2chunks,
-                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+                         gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
         self._fg.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+                         gr.file_sink(gr.sizeof_char, "tx_graycoder.dat"))
         self._fg.connect(self.diffenc,
-                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+                         gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
         self._fg.connect(self.chunks2symbols,
-                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
         self._fg.connect(self.rrc_filter,
-                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
               
 
 # /////////////////////////////////////////////////////////////////////////////
@@ -223,9 +223,9 @@ class dbpsk_demod(gr.hier_block):
         self._samples_per_symbol = samples_per_symbol
         self._excess_bw = excess_bw
         self._costas_alpha = costas_alpha
-        self._gain_mu = gain_mu
-        self._mu = mu
-        self._omega_relative_limit = omega_relative_limit
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
         self._gray_code = gray_code
         
         if samples_per_symbol < 2:
@@ -237,43 +237,41 @@ class dbpsk_demod(gr.hier_block):
         scale = (1.0/16384.0)
         self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
         #self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
-        self.agc = gr.feedforward_agc_cc(16, 1.0)
-
-        
-        # Costas loop (carrier tracking)
-        # The Costas loop is not needed for BPSK, though it can help. Turn the Costas loop on
-        # by setting an alpha value not None.
-        if self._costas_alpha is not None:
-            costas_order = 2
-            beta = .25 * self._costas_alpha * self._costas_alpha
-            self.costas_loop = gr.costas_loop_cc(self._costas_alpha, beta, 0.002, -0.002, costas_order)
+        self.agc = gr.feedforward_agc_cc(16, 2.0)
 
         # RRC data filter
-        ntaps = 11 * self._samples_per_symbol
+        ntaps = 11 * samples_per_symbol
         self.rrc_taps = gr.firdes.root_raised_cosine(
-            1.0,                      # gain 
+            1.0,                      # gain
             self._samples_per_symbol, # sampling rate
             1.0,                      # symbol rate
             self._excess_bw,          # excess bandwidth (roll-off factor)
             ntaps)
-
-        self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
 
         # symbol clock recovery
-        omega = self._samples_per_symbol
-        gain_omega = .25 * self._gain_mu * self._gain_mu
-        self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
-                                                    self._mu, self._gain_mu,
-                                                    self._omega_relative_limit)
+        if not self._mm_gain_mu:
+            self._mm_gain_mu = 0.1
+            
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.025
+        fmax = 0.025
+        
+        self.receiver=gr.mpsk_receiver_cc(arity, 0,
+                                         self._costas_alpha, self._costas_beta,
+                                         fmin, fmax,
+                                         self._mm_mu, self._mm_gain_mu,
+                                         self._mm_omega, self._mm_gain_omega,
+                                         self._mm_omega_relative_limit)
+
+        # Do differential decoding based on phase change of symbols
+        self.diffdec = gr.diff_phasor_cc()
 
         # find closest constellation point
         rot = 1
         rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
-        #print "rotated_const =", rotated_const
-
-        self.diffdec = gr.diff_phasor_cc()
-        #self.diffdec = gr.diff_decoder_bb(arity)
-
         self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
 
         if self._gray_code:
@@ -291,15 +289,8 @@ class dbpsk_demod(gr.hier_block):
             self._setup_logging()
 
         # Connect and Initialize base class
-        if self._costas_alpha is not None:   # With Costas Loop
-            self._fg.connect(self.pre_scaler, self.agc, self.costas_loop,
-                             self.rrc_filter, self.clock_recovery, self.diffdec,
-                             self.slicer, self.symbol_mapper, self.unpack)
-        else: # Without Costas Loop
-            self._fg.connect(self.pre_scaler, self.agc,
-                             self.rrc_filter, self.clock_recovery, self.diffdec,
-                             self.slicer, self.symbol_mapper, self.unpack)
-
+        self._fg.connect(self.pre_scaler, self.agc, self.rrc_filter, self.receiver,
+                         self.diffdec, self.slicer, self.symbol_mapper, self.unpack)
         gr.hier_block.__init__(self, self._fg, self.pre_scaler, self.unpack)
 
     def samples_per_symbol(self):
@@ -310,42 +301,36 @@ class dbpsk_demod(gr.hier_block):
     bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
 
     def _print_verbage(self):
-        print "bits per symbol = %d"         % self.bits_per_symbol()
-        print "Gray code = %s"               % self._gray_code
-        print "RRC roll-off factor = %.2f"   % self._excess_bw
-        if self._costas_alpha is not None:
-            print "Costas Loop alpha = %.5f"     % self._costas_alpha
-        else:
-            print "Costas Loop is turned off"
-        print "M&M symbol sync gain = %.5f"  % self._gain_mu
-        print "M&M symbol sync mu = %.5f"    % self._mu
-        print "M&M omega relative limit = %.5f" % self._omega_relative_limit
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
 
     def _setup_logging(self):
         print "Modulation logging turned on."
         self._fg.connect(self.pre_scaler,
-                         gr.file_sink(gr.sizeof_gr_complex, "prescaler.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
         self._fg.connect(self.agc,
-                         gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
-        if self._costas_alpha is not None:
-            self._fg.connect(self.costas_loop,
-                             gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
-            self._fg.connect((self.costas_loop,1),
-                             gr.file_sink(gr.sizeof_gr_complex, "costas_error.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
         self._fg.connect(self.rrc_filter,
-                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
-        self._fg.connect(self.clock_recovery,
-                         gr.file_sink(gr.sizeof_gr_complex, "clock_recovery.dat"))
-        self._fg.connect((self.clock_recovery,1),
-                         gr.file_sink(gr.sizeof_gr_complex, "clock_recovery_error.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self._fg.connect(self.receiver,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
         self._fg.connect(self.diffdec,
-                         gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))        
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_diffdec.dat"))        
         self._fg.connect(self.slicer,
-                        gr.file_sink(gr.sizeof_char, "slicer.dat"))
+                        gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
         self._fg.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "symbol_mapper.dat"))
+                         gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))
         self._fg.connect(self.unpack,
-                         gr.file_sink(gr.sizeof_char, "unpack.dat"))
+                         gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
         
     def add_options(parser):
         """
@@ -373,7 +358,6 @@ class dbpsk_demod(gr.hier_block):
         return modulation_utils.extract_kwargs_from_options(
                  dbpsk_demod.__init__, ('self', 'fg'), options)
     extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
-
 #
 # Add these to the mod/demod registry
 #
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
index 4332767bd..b6701ef9f 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
@@ -39,9 +39,9 @@ _def_gray_code = True
 _def_verbose = False
 _def_log = False
 
-_def_costas_alpha = None
-_def_gain_mu = 0.03
-_def_mu = 0.05
+_def_costas_alpha = 0.15
+_def_gain_mu = None
+_def_mu = 0.5
 _def_omega_relative_limit = 0.005
 
 
@@ -133,22 +133,23 @@ class dqpsk_mod(gr.hier_block):
     bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
 
     def _print_verbage(self):
-        print "bits per symbol = %d" % self.bits_per_symbol()
-        print "Gray code = %s" % self._gray_code
-        print "RRS roll-off factor = %f" % self._excess_bw
+        print "\nModulator:"
+        print "bits per symbol:     %d" % self.bits_per_symbol()
+        print "Gray code:           %s" % self._gray_code
+        print "RRS roll-off factor: %f" % self._excess_bw
 
     def _setup_logging(self):
         print "Modulation logging turned on."
         self._fg.connect(self.bytes2chunks,
-                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+                         gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
         self._fg.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+                         gr.file_sink(gr.sizeof_char, "tx_graycoder.dat"))
         self._fg.connect(self.diffenc,
-                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))        
+                         gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))        
         self._fg.connect(self.chunks2symbols,
-                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
         self._fg.connect(self.rrc_filter,
-                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
 
     def add_options(parser):
         """
@@ -221,9 +222,9 @@ class dqpsk_demod(gr.hier_block):
         self._samples_per_symbol = samples_per_symbol
         self._excess_bw = excess_bw
         self._costas_alpha = costas_alpha
-        self._gain_mu = gain_mu
-        self._mu = mu
-        self._omega_relative_limit = omega_relative_limit
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
         self._gray_code = gray_code
 
         if samples_per_symbol < 2:
@@ -235,53 +236,47 @@ class dqpsk_demod(gr.hier_block):
         scale = (1.0/16384.0)
         self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
         #self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
-        self.agc = gr.feedforward_agc_cc(16, 1.0)
+        self.agc = gr.feedforward_agc_cc(16, 2.0)
        
-        # Costas loop (carrier tracking)
-        if self._costas_alpha is None:   # If no alpha value was specified by the user
-            alpha_dir = {2:0.075, 3:0.09, 4:0.09, 5:0.095, 6:0.10, 7:0.105}
-            self._costas_alpha = alpha_dir[self._samples_per_symbol]
-        
-        costas_order = 4        
-        # The value of beta is now set to be underdamped; this value can have a huge impact on the
-        # performance of QPSK. Set to 0.25 for critically damped or higher for underdamped responses.
-        beta = .35 * self._costas_alpha * self._costas_alpha
-        self.costas_loop = gr.costas_loop_cc(self._costas_alpha, beta, 0.02, -0.02, costas_order)
-
         # RRC data filter
         ntaps = 11 * samples_per_symbol
         self.rrc_taps = gr.firdes.root_raised_cosine(
-            self._samples_per_symbol, # gain
+            1.0,                      # gain
             self._samples_per_symbol, # sampling rate
             1.0,                      # symbol rate
             self._excess_bw,          # excess bandwidth (roll-off factor)
             ntaps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
 
-        self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
-
-        # symbol clock recovery
-        omega = self._samples_per_symbol
-        gain_omega = .25 * self._gain_mu * self._gain_mu
-        self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
-                                                    self._mu, self._gain_mu,
-                                                    self._omega_relative_limit)
+        if not self._mm_gain_mu:
+            sbs_to_mm = {2: 0.050, 3: 0.075, 4: 0.11, 5: 0.125, 6: 0.15, 7: 0.15}
+            self._mm_gain_mu = sbs_to_mm[samples_per_symbol]
 
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.025
+        fmax = 0.025
+        
+        self.receiver=gr.mpsk_receiver_cc(arity, pi/4.0,
+                                          self._costas_alpha, self._costas_beta,
+                                          fmin, fmax,
+                                          self._mm_mu, self._mm_gain_mu,
+                                          self._mm_omega, self._mm_gain_omega,
+                                          self._mm_omega_relative_limit)
+
+        # Perform Differential decoding on the constellation
         self.diffdec = gr.diff_phasor_cc()
-        #self.diffdec = gr.diff_decoder_bb(arity)
-
+        
         # find closest constellation point
         rot = 1
-        #rot = .707 + .707j
         rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
-        #print "rotated_const = %s" % rotated_const
-
         self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
 
         if self._gray_code:
             self.symbol_mapper = gr.map_bb(psk.gray_to_binary[arity])
         else:
             self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[arity])
-
         
         # unpack the k bit vector into a stream of bits
         self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
@@ -293,10 +288,8 @@ class dqpsk_demod(gr.hier_block):
             self._setup_logging()
  
         # Connect & Initialize base class
-        self._fg.connect(self.pre_scaler, self.agc, self.costas_loop,
-                         self.rrc_filter, self.clock_recovery,
-                         self.diffdec, self.slicer, self.symbol_mapper,
-                         self.unpack)
+        self._fg.connect(self.pre_scaler, self.agc, self.rrc_filter, self.receiver,
+                         self.diffdec, self.slicer, self.symbol_mapper, self.unpack)
         gr.hier_block.__init__(self, self._fg, self.pre_scaler, self.unpack)
 
     def samples_per_symbol(self):
@@ -307,39 +300,36 @@ class dqpsk_demod(gr.hier_block):
     bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
 
     def _print_verbage(self):
-        print "bits per symbol = %d"         % self.bits_per_symbol()
-        print "Gray code = %s"               % self._gray_code
-        print "RRC roll-off factor = %.2f"   % self._excess_bw
-        print "Costas Loop alpha = %.5f"     % self._costas_alpha
-        print "M&M symbol sync gain = %.5f"  % self._gain_mu
-        print "M&M symbol sync mu = %.5f"    % self._mu
-        print "M&M omega relative limit = %.5f" % self._omega_relative_limit
-        
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
 
     def _setup_logging(self):
         print "Modulation logging turned on."
         self._fg.connect(self.pre_scaler,
-                         gr.file_sink(gr.sizeof_gr_complex, "prescaler.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
         self._fg.connect(self.agc,
-                         gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
-        self._fg.connect(self.costas_loop,
-                         gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
-        self._fg.connect((self.costas_loop,1),
-                         gr.file_sink(gr.sizeof_gr_complex, "costas_error.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
         self._fg.connect(self.rrc_filter,
-                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
-        self._fg.connect(self.clock_recovery,
-                         gr.file_sink(gr.sizeof_gr_complex, "clock_recovery.dat"))
-        self._fg.connect((self.clock_recovery,1),
-                        gr.file_sink(gr.sizeof_gr_complex, "clock_recovery_error.dat"))
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self._fg.connect(self.receiver,
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
         self._fg.connect(self.diffdec,
-                         gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))        
+                         gr.file_sink(gr.sizeof_gr_complex, "rx_diffdec.dat"))        
         self._fg.connect(self.slicer,
-                         gr.file_sink(gr.sizeof_char, "slicer.dat"))
+                         gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
         self._fg.connect(self.symbol_mapper,
-                         gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+                         gr.file_sink(gr.sizeof_char, "rx_gray_decoder.dat"))
         self._fg.connect(self.unpack,
-                         gr.file_sink(gr.sizeof_char, "unpack.dat"))
+                         gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
 
     def add_options(parser):
         """
@@ -350,7 +340,7 @@ class dqpsk_demod(gr.hier_block):
         parser.add_option("", "--no-gray-code", dest="gray_code",
                           action="store_false", default=_def_gray_code,
                           help="disable gray coding on modulated bits (PSK)")
-        parser.add_option("", "--costas-alpha", type="float", default=None,
+        parser.add_option("", "--costas-alpha", type="float", default=_def_costas_alpha,
                           help="set Costas loop alpha value [default=%default] (PSK)")
         parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
                           help="set M&M symbol sync loop gain mu value [default=%default] (PSK)")
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
index 7a77a84ec..29bf8e144 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
@@ -37,7 +37,7 @@ _def_bt = 0.35
 _def_verbose = False
 _def_log = False
 
-_def_gain_mu = 0.05
+_def_gain_mu = None
 _def_mu = 0.5
 _def_freq_error = 0.0
 _def_omega_relative_limit = 0.005
@@ -208,6 +208,9 @@ class gmsk_demod(gr.hier_block):
 
         self._omega = samples_per_symbol*(1+self._freq_error)
 
+        if not self._gain_mu:
+            self._gain_mu = 0.175
+            
 	self._gain_omega = .25 * self._gain_mu * self._gain_mu        # critically damped
 
 	# Demodulate FM
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/psk.py b/gnuradio-core/src/python/gnuradio/blksimpl/psk.py
index fdb6c9e69..58677b29d 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/psk.py
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/psk.py
@@ -19,12 +19,33 @@
 # Boston, MA 02110-1301, USA.
 # 
 
-from math import pi, sqrt
-import cmath
+from math import pi, sqrt, log10
+import math, cmath
 
+# The following algorithm generates Gray coded constellations for M-PSK for M=[2,4,8]
+def make_gray_constellation(m):
+    # number of bits/symbol (log2(M))
+    k = int(log10(m) / log10(2.0))
+
+    coeff = 1
+    const_map = []
+    bits = [0]*3
+    for i in range(m):
+        # get a vector of the k bits to use in this mapping
+        bits[3-k:3] = [((i&(0x01 << k-j-1)) >> k-j-1) for j in range(k)]
+
+        theta = -(2*bits[0]-1)*(2*pi/m)*(bits[0]+abs(bits[1]-bits[2])+2*bits[1])
+        re = math.cos(theta)
+        im = math.sin(theta)
+        const_map.append(complex(re, im))   # plug it into the constellation
+    
+    # return the constellation; by default, it is normalized
+    return const_map
+
+# This makes a constellation that increments around the unit circle
 def make_constellation(m):
     return [cmath.exp(i * 2 * pi / m * 1j) for i in range(m)]
-        
+
 # Common definition of constellations for Tx and Rx
 constellation = {
     2 : make_constellation(2),           # BPSK
@@ -35,18 +56,18 @@ constellation = {
 # -----------------------
 # Do Gray code
 # -----------------------
-# binary to gray coding
+# binary to gray coding -- constellation does Gray coding
 binary_to_gray = {
-    2 : (0, 1),
-    4 : (0, 1, 3, 2),
-    8 : (0, 1, 3, 2, 7, 6, 4, 5)
+    2 : range(2),
+    4 : [0,1,3,2],
+    8 : [0, 1, 3, 2, 7, 6, 4, 5]
     }
-   
+
 # gray to binary
 gray_to_binary = {
-    2 : (0, 1),
-    4 : (0, 1, 3, 2),
-    8 : (0, 1, 3, 2, 6, 7, 5, 4)
+    2 : range(2),
+    4 : [0,1,3,2],
+    8 : [0, 1, 3, 2, 6, 7, 5, 4]
     }
 
 # -----------------------
@@ -54,14 +75,14 @@ gray_to_binary = {
 # -----------------------
 # identity mapping
 binary_to_ungray = {
-    2 : (0, 1),
-    4 : (0, 1, 2, 3),
-    8 : (0, 1, 2, 3, 4, 5, 6, 7)
+    2 : range(2),
+    4 : range(4),
+    8 : range(8)
     }
-    
+
 # identity mapping
 ungray_to_binary = {
-    2 : (0, 1),
-    4 : (0, 1, 2, 3),
-    8 : (0, 1, 2, 3, 4, 5, 6, 7)
+    2 : range(2),
+    4 : range(4),
+    8 : range(8)
     }
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/qam.py b/gnuradio-core/src/python/gnuradio/blksimpl/qam.py
new file mode 100644
index 000000000..1bf9ad72e
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/qam.py
@@ -0,0 +1,113 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+from math import pi, sqrt
+import math
+
+# These constellations are generated for Gray coding when symbos [1, ..., m] are used
+# Mapping to Gray coding is therefore unnecessary
+
+def make_constellation(m):
+    # number of bits/symbol (log2(M))
+    k = int(math.log10(m) / math.log10(2.0))
+
+    coeff = 1
+    const_map = []
+    for i in range(m):
+        a = (i&(0x01 << k-1)) >> k-1
+        b = (i&(0x01 << k-2)) >> k-2
+        bits_i = [((i&(0x01 << k-j-1)) >> k-j-1) for j in range(2, k, 2)]
+        bits_q = [((i&(0x01 << k-j-1)) >> k-j-1) for j in range(3, k, 2)]
+
+        ss = 0
+        ll = len(bits_i)
+        for ii in range(ll):
+            rr = 0
+            for jj in range(ll-ii):
+                rr = abs(bits_i[jj] - rr)
+            ss += rr*pow(2.0, ii+1)
+        re = (2*a-1)*(ss+1)
+        
+        ss = 0
+        ll = len(bits_q)
+        for ii in range(ll):
+            rr = 0
+            for jj in range(ll-ii):
+                rr = abs(bits_q[jj] - rr)
+            ss += rr*pow(2.0, ii+1)
+        im = (2*b-1)*(ss+1)
+
+        a = max(re, im)
+        if a > coeff:
+            coeff = a
+        const_map.append(complex(re, im))
+
+    norm_map = [complex(i.real/coeff, i.imag/coeff) for i in const_map]
+    return norm_map
+        
+# Common definition of constellations for Tx and Rx
+constellation = {
+    4 :  make_constellation(4),           # QAM4 (QPSK)
+    8 :  make_constellation(8),           # QAM8
+    16:  make_constellation(16),          # QAM16
+    64:  make_constellation(64),          # QAM64
+    256: make_constellation(256)          # QAM256
+    }
+
+# -----------------------
+# Do Gray code
+# -----------------------
+# binary to gray coding
+binary_to_gray = {
+    4 : range(4),
+    8 : range(8),
+    16: range(16),
+    64: range(64),
+    256: range(256)
+    }
+   
+# gray to binary
+gray_to_binary = {
+    4 : range(4),
+    8 : range(8),
+    16: range(16),
+    64: range(64),
+    256: range(256)
+    }
+
+# -----------------------
+# Don't Gray code
+# -----------------------
+# identity mapping
+binary_to_ungray = {
+    4 : range(4),
+    8 : range(8),
+    16: range(16),
+    64: range(64)
+    }
+    
+# identity mapping
+ungray_to_binary = {
+    4 : range(4),
+    8 : range(8),
+    16: range(16),
+    64: range(64)
+    }
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/qam16.py b/gnuradio-core/src/python/gnuradio/blksimpl/qam16.py
new file mode 100644
index 000000000..c04a28743
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/qam16.py
@@ -0,0 +1,206 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+QAM16 modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import qam
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = None
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM16 modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam16_mod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2, self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1.0
+        print "constellation with %d arity" % arity
+        rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+	# Connect & Initialize base class
+        self._fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                         self.chunks2symbols, self.rrc_filter)
+	gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 4
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.bytes2chunks,
+                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+        self._fg.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))        
+        self._fg.connect(self.chunks2symbols,
+                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
+    def add_options(parser):
+        """
+        Adds QAM modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(qam16_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM16 demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam16_demod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        # do this
+        pass
+    
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 4
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('qam16', qam16_mod)
+#modulation_utils.add_type_1_demod('qam16', qam16_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/qam256.py b/gnuradio-core/src/python/gnuradio/blksimpl/qam256.py
new file mode 100644
index 000000000..66d1158a6
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/qam256.py
@@ -0,0 +1,206 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+QAM256 modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import qam
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = None
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM256 modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam256_mod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2, self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1.0
+        print "constellation with %d arity" % arity
+        rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+	# Connect & Initialize base class
+        self._fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                         self.chunks2symbols, self.rrc_filter)
+	gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 8
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.bytes2chunks,
+                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+        self._fg.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))        
+        self._fg.connect(self.chunks2symbols,
+                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
+    def add_options(parser):
+        """
+        Adds QAM modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(qam256_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM256 demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam256_demod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        # do this
+        pass
+    
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 8
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('qam256', qam256_mod)
+#modulation_utils.add_type_1_demod('qam256', qam256_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/qam64.py b/gnuradio-core/src/python/gnuradio/blksimpl/qam64.py
new file mode 100644
index 000000000..cadded6de
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/qam64.py
@@ -0,0 +1,206 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+differential QPSK modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import qam
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = None
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM64 modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam64_mod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2, self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1.0
+        print "constellation with %d arity" % arity
+        rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+	# Connect & Initialize base class
+        self._fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                         self.chunks2symbols, self.rrc_filter)
+	gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 6
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.bytes2chunks,
+                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+        self._fg.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))        
+        self._fg.connect(self.chunks2symbols,
+                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
+    def add_options(parser):
+        """
+        Adds QAM modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(qam64_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM16 demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam64_demod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        # do this
+        pass
+    
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 6
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('qam64', qam64_mod)
+#modulation_utils.add_type_1_demod('qam16', qam16_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/qam8.py b/gnuradio-core/src/python/gnuradio/blksimpl/qam8.py
new file mode 100644
index 000000000..e1895a4b3
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/qam8.py
@@ -0,0 +1,206 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+QAM8 modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import qam
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = None
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM8 modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam8_mod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param fg: flow graph
+	@type fg: flow graph
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        self._fg = fg
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2, self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1.0
+        print "constellation with %d arity" % arity
+        rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+	# Connect & Initialize base class
+        self._fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                         self.chunks2symbols, self.rrc_filter)
+	gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.bytes2chunks,
+                         gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+        self._fg.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "diffenc.dat"))        
+        self._fg.connect(self.chunks2symbols,
+                         gr.file_sink(gr.sizeof_gr_complex, "chunks2symbols.dat"))
+        self._fg.connect(self.rrc_filter,
+                         gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
+    def add_options(parser):
+        """
+        Adds QAM modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(qam8_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM8 demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam8_demod(gr.hier_block):
+
+    def __init__(self, fg,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+
+        # do this
+        pass
+    
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('qam8', qam8_mod)
+#modulation_utils.add_type_1_demod('qam8', qam8_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/Makefile.am b/gnuradio-core/src/python/gnuradio/blksimpl2/Makefile.am
new file mode 100644
index 000000000..4852ff3fb
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/Makefile.am
@@ -0,0 +1,40 @@
+#
+# Copyright 2005 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 2, 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.
+# 
+
+include $(top_srcdir)/Makefile.common
+
+# EXTRA_DIST = run_tests.in
+# TESTS = run_tests
+
+grblkspythondir = $(grpythondir)/blksimpl2
+
+grblkspython_PYTHON =		\
+	__init__.py		\
+	dbpsk.py		\
+	dqpsk.py		\
+	d8psk.py		\
+	gmsk.py			\
+	pkt.py			\
+	psk.py
+
+noinst_PYTHON = 		
+
+CLEANFILES = *.pyc *.pyo
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/__init__.py b/gnuradio-core/src/python/gnuradio/blksimpl2/__init__.py
new file mode 100644
index 000000000..a4917cf64
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/__init__.py
@@ -0,0 +1 @@
+# make this a package
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/d8psk.py b/gnuradio-core/src/python/gnuradio/blksimpl2/d8psk.py
new file mode 100644
index 000000000..b499b8fa3
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/d8psk.py
@@ -0,0 +1,407 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+differential 8PSK modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import psk
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 3
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = 0.01
+_def_gain_mu = 0.05
+_def_mu = 0.5
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           DQPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class d8psk_mod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        gr.hier_block2.__init__(self, "d8psk_mod",
+                                gr.io_signature(1,1,gr.sizeof_char),       # Input signature
+                                gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2,self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+
+        # Define components from objects
+        self.define_component("bytes2chunks", self.bytes2chunks)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+#        self.define_component("diffenc", self.diffenc)
+        self.define_component("chunks2symbols", self.chunks2symbols)
+        self.define_component("rrc_filter", self.rrc_filter)
+
+	# Connect components
+        self.connect("self", 0, "bytes2chunks", 0)
+        self.connect("bytes2chunks", 0, "symbol_mapper", 0)
+#        self.connect("symbol_mapper", 0, "diffenc", 0)
+#        self.connect("diffenc", 0, "chunks2symbols", 0)
+        self.connect("symbol_mapper", 0, "chunks2symbols", 0)
+        self.connect("chunks2symbols", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+            
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nModulator:"
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.define_component("bytes2chunks_dat", gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
+        self.define_component("symbol_mapper_dat", gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat"))
+#        self.define_component("diffenc_dat", gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
+        self.define_component("chunks2symbols_dat", gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
+        self.define_component("rrc_filter_dat", gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
+
+        self.connect("bytes2chunks", 0, "bytes2chunks_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+#        self.connect("diffenc", 0, "diffenc_dat", 0)
+        self.connect("chunks2symbols", 0, "chunks2symbols_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds 8PSK modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(d8psk_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           D8PSK demodulator
+#
+# Differentially coherent detection of differentially encoded 8psk
+# /////////////////////////////////////////////////////////////////////////////
+
+WITH_SYNC = False
+class d8psk_demod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered DQPSK demodulation
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (LSB)
+
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: float
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param costas_alpha: loop filter gain
+        @type costas_alphas: float
+        @param gain_mu: for M&M block
+        @type gain_mu: float
+        @param mu: for M&M block
+        @type mu: float
+        @param omega_relative_limit: for M&M block
+        @type omega_relative_limit: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        gr.hier_block2.__init__(self, "d8psk_demod",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_char))       # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._costas_alpha = costas_alpha
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
+        self._gray_code = gray_code
+
+        if samples_per_symbol < 2:
+            raise TypeError, "sbp must be >= 2, is %d" % samples_per_symbol
+
+        arity = pow(2,self.bits_per_symbol())
+ 
+        # Automatic gain control
+        scale = (1.0/16384.0)
+        self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
+        #self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
+        self.agc = gr.feedforward_agc_cc(16, 1.0)
+
+        # RRC data filter
+        ntaps = 11 * samples_per_symbol
+        self.rrc_taps = gr.firdes.root_raised_cosine(
+            1.0,                      # gain
+            self._samples_per_symbol, # sampling rate
+            1.0,                      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
+
+        # symbol clock recovery
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.05
+        fmax = 0.05
+
+        self.receiver=gr.mpsk_receiver_cc(arity, 0,
+                                          self._costas_alpha, self._costas_beta,
+                                          fmin, fmax,
+                                          self._mm_mu, self._mm_gain_mu,
+                                          self._mm_omega, self._mm_gain_omega,
+                                          self._mm_omega_relative_limit)
+        
+        #self.diffdec = gr.diff_decoder_bb(arity)
+
+        # find closest constellation point
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.gray_to_binary[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[arity])
+
+        
+        # unpack the k bit vector into a stream of bits
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
+
+ 
+        # Define components
+        self.define_component("pre_scaler", self.pre_scaler)
+        self.define_component("agc", self.agc)
+        self.define_component("rrc_filter", self.rrc_filter)
+        self.define_component("receiver", self.receiver)
+        self.define_component("slicer", self.slicer)
+        #self.define_component("diffdec", self.diffdec)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+        self.define_component("unpack", self.unpack)
+
+        # Connect and Initialize base class
+        self.connect("self", 0, "pre_scaler", 0)
+        self.connect("pre_scaler", 0, "agc", 0)
+        self.connect("agc", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "receiver", 0)
+        self.connect("receiver", 0, "slicer", 0)
+        #self.connect("slicer", 0, "diffdec", 0)
+        #self.connect("diffdec", 0, "symbol_mapper", 0)
+        self.connect("slicer", 0, "symbol_mapper", 0)
+        self.connect("symbol_mapper", 0, "unpack", 0)
+        self.connect("unpack", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 3
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
+        
+
+    def _setup_logging(self):
+        print "Demodulation logging turned on."
+        self.define_component("prescaler_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
+        self.define_component("agc_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
+        self.define_component("rrc_filter_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self.define_component("receiver_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
+        self.define_component("slicer_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
+#        self.define_component("diffdec_dat",
+#                              gr.file_sink(gr.sizeof_char, "rx_diffdec.dat"))
+        self.define_component("symbol_mapper_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))
+        self.define_component("unpack_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
+
+        self.connect("pre_scaler", 0, "prescaler_dat", 0)
+        self.connect("agc", 0, "agc_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+        self.connect("receiver", 0, "receiver_dat", 0)
+        self.connect("slicer", 0, "slicer_dat", 0)
+#        self.connect("diffdec", 0, "diffdec_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+        self.connect("unpack", 0, "unpack_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+        parser.add_option("", "--costas-alpha", type="float", default=None,
+                          help="set Costas loop alpha value [default=%default] (PSK)")
+        parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
+                          help="set M&M symbol sync loop gain mu value [default=%default] (PSK)")
+        parser.add_option("", "--mu", type="float", default=_def_mu,
+                          help="set M&M symbol sync loop mu value [default=%default] (PSK)")
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(
+            d8psk_demod.__init__, ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+#
+# Add these to the mod/demod registry
+#
+# NOT READY TO BE USED YET -- ENABLE AT YOUR OWN RISK
+#modulation_utils.add_type_1_mod('d8psk', d8psk_mod)
+#modulation_utils.add_type_1_demod('d8psk', d8psk_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/dbpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl2/dbpsk.py
new file mode 100644
index 000000000..36a2ea8af
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/dbpsk.py
@@ -0,0 +1,404 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+differential BPSK modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import psk
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = 0.15
+_def_gain_mu = 0.1
+_def_mu = 0.5
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             DBPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class dbpsk_mod(gr.hier_block2):
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered differential BPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+        
+	@param samples_per_symbol: samples per baud >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param log: Log modulation data to files?
+        @type log: bool
+	"""
+
+        gr.hier_block2.__init__(self, "dbpsk_mod",
+                                gr.io_signature(1,1,gr.sizeof_char), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol)
+        
+	ntaps = 11 * self._samples_per_symbol
+
+        arity = pow(2,self.bits_per_symbol())
+        
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
+
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol,   # gain (samples_per_symbol since we're
+                                        # interpolating by samples_per_symbol)
+	    self._samples_per_symbol,   # sampling rate
+	    1.0,		        # symbol rate
+	    self._excess_bw,            # excess bandwidth (roll-off factor)
+            ntaps)
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
+                                                   self.rrc_taps)
+
+        self.define_component("bytes2chunks", self.bytes2chunks)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+        self.define_component("diffenc", self.diffenc)
+        self.define_component("chunks2symbols", self.chunks2symbols)
+        self.define_component("rrc_filter", self.rrc_filter)
+
+	# Connect components
+        self.connect("self", 0, "bytes2chunks", 0)
+        self.connect("bytes2chunks", 0, "symbol_mapper", 0)
+        self.connect("symbol_mapper", 0, "diffenc", 0)
+        self.connect("diffenc", 0, "chunks2symbols", 0)
+        self.connect("chunks2symbols", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+            
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # static method that's also callable on an instance
+        return 1
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def add_options(parser):
+        """
+        Adds DBPSK modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default]")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=True,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(dbpsk_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+    def _print_verbage(self):
+        print "\nModulator:"
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRC roll-off factor = %.2f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.define_component("bytes2chunks_dat",
+                              gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
+        self.define_component("symbol_mapper_dat",
+                              gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat"))
+        self.define_component("diffenc_dat",
+                              gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
+        self.define_component("chunks2symbols_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
+        self.define_component("rrc_filter_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
+
+        self.connect("bytes2chunks", 0, "bytes2chunks_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+        self.connect("diffenc", 0, "diffenc_dat", 0)
+        self.connect("chunks2symbols", 0, "chunks2symbols_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+              
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             DBPSK demodulator
+#
+#      Differentially coherent detection of differentially encoded BPSK
+# /////////////////////////////////////////////////////////////////////////////
+
+class dbpsk_demod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered differential BPSK demodulation
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (LSB)
+
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: float
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param costas_alpha: loop filter gain
+        @type costas_alphas: float
+        @param gain_mu: for M&M block
+        @type gain_mu: float
+        @param mu: for M&M block
+        @type mu: float
+        @param omega_relative_limit: for M&M block
+        @type omega_relative_limit: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        gr.hier_block2.__init__(self, "dbpsk_demod",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_char))       # Output signature
+
+        
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._costas_alpha = costas_alpha
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
+        self._gray_code = gray_code
+        
+        if samples_per_symbol < 2:
+            raise TypeError, "samples_per_symbol must be >= 2, is %r" % (samples_per_symbol,)
+
+        arity = pow(2,self.bits_per_symbol())
+
+        # Automatic gain control
+        scale = (1.0/16384.0)
+        self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
+        #self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
+        self.agc = gr.feedforward_agc_cc(16, 1.0)
+
+        
+        # RRC data filter
+        ntaps = 11 * samples_per_symbol
+        self.rrc_taps = gr.firdes.root_raised_cosine(
+            1.0,                      # gain
+            self._samples_per_symbol, # sampling rate
+            1.0,                      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
+
+        # symbol clock recovery
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.02
+        fmax = 0.02
+        
+        self.receiver=gr.mpsk_receiver_cc(arity, 0,
+                                          self._costas_alpha, self._costas_beta,
+                                          fmin, fmax,
+                                          self._mm_mu, self._mm_gain_mu,
+                                          self._mm_omega, self._mm_gain_omega,
+                                          self._mm_omega_relative_limit)
+
+        # Using differential decoding
+        self.diffdec = gr.diff_phasor_cc()
+
+        # find closest constellation point
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.gray_to_binary[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[arity])
+        
+        # unpack the k bit vector into a stream of bits
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
+
+        # Define components
+        self.define_component("pre_scaler", self.pre_scaler)
+        self.define_component("agc", self.agc)
+        self.define_component("rrc_filter", self.rrc_filter)
+        self.define_component("receiver", self.receiver)
+        self.define_component("slicer", self.slicer)
+        self.define_component("diffdec", self.diffdec)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+        self.define_component("unpack", self.unpack)
+
+        # Connect and Initialize base class
+        self.connect("self", 0, "pre_scaler", 0)
+        self.connect("pre_scaler", 0, "agc", 0)
+        self.connect("agc", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "receiver", 0)
+        self.connect("receiver", 0, "diffdec", 0)
+        self.connect("diffdec", 0, "slicer", 0)
+        self.connect("slicer", 0, "symbol_mapper", 0)
+        self.connect("symbol_mapper", 0, "unpack", 0)
+        self.connect("unpack", 0, "self", 0)
+        
+        if verbose:
+            self._print_verbage()
+
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 1
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
+
+    def _setup_logging(self):
+        print "Demodulation logging turned on."
+        self.define_component("prescaler_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
+        self.define_component("agc_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
+        self.define_component("rrc_filter_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self.define_component("receiver_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
+        self.define_component("diffdec_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_diffdec.dat"))
+        self.define_component("slicer_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
+        self.define_component("symbol_mapper_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))
+        self.define_component("unpack_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
+
+        self.connect("pre_scaler", 0, "prescaler_dat", 0)
+        self.connect("agc", 0, "agc_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+        self.connect("receiver", 0, "receiver_dat", 0)
+        self.connect("diffdec", 0, "diffdec_dat", 0)
+        self.connect("slicer", 0, "slicer_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+        self.connect("unpack", 0, "unpack_dat", 0)
+
+        
+    def add_options(parser):
+        """
+        Adds DBPSK demodulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+        parser.add_option("", "--costas-alpha", type="float", default=None,
+                          help="set Costas loop alpha value [default=%default] (PSK)")
+        parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
+                          help="set M&M symbol sync loop gain mu value [default=%default] (GMSK/PSK)")
+        parser.add_option("", "--mu", type="float", default=_def_mu,
+                          help="set M&M symbol sync loop mu value [default=%default] (GMSK/PSK)")
+        parser.add_option("", "--omega-relative-limit", type="float", default=_def_omega_relative_limit,
+                          help="M&M clock recovery omega relative limit [default=%default] (GMSK/PSK)")
+    add_options=staticmethod(add_options)
+    
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(
+                 dbpsk_demod.__init__, ('self'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+#
+# Add these to the mod/demod registry
+#
+modulation_utils.add_type_1_mod('dbpsk', dbpsk_mod)
+modulation_utils.add_type_1_demod('dbpsk', dbpsk_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/dqpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl2/dqpsk.py
new file mode 100644
index 000000000..04623c93e
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/dqpsk.py
@@ -0,0 +1,397 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+differential QPSK modulation and demodulation.
+"""
+
+from gnuradio import gr, gru, modulation_utils
+from math import pi, sqrt
+import psk
+import cmath
+import Numeric
+from pprint import pprint
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_gray_code = True
+_def_verbose = False
+_def_log = False
+
+_def_costas_alpha = 0.15
+_def_gain_mu = 0.1
+_def_mu = 0.5
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           DQPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class dqpsk_mod(gr.hier_block2):
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered QPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: integer
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        gr.hier_block2.__init__(self, "dqpsk_mod",
+                                gr.io_signature(1,1,gr.sizeof_char),       # Input signature
+                                gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._gray_code = gray_code
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
+
+	ntaps = 11 * samples_per_symbol
+ 
+        arity = pow(2,self.bits_per_symbol())
+
+        # turn bytes into k-bit vectors
+        self.bytes2chunks = \
+          gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
+            
+        self.diffenc = gr.diff_encoder_bb(arity)
+
+        rot = .707 + .707j
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
+
+        # pulse shaping filter
+	self.rrc_taps = gr.firdes.root_raised_cosine(
+	    self._samples_per_symbol, # gain  (sps since we're interpolating by sps)
+            self._samples_per_symbol, # sampling rate
+            1.0,		      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+
+	self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
+            
+        # Define components from objects
+        self.define_component("bytes2chunks", self.bytes2chunks)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+        self.define_component("diffenc", self.diffenc)
+        self.define_component("chunks2symbols", self.chunks2symbols)
+        self.define_component("rrc_filter", self.rrc_filter)
+
+	# Connect components
+        self.connect("self", 0, "bytes2chunks", 0)
+        self.connect("bytes2chunks", 0, "symbol_mapper", 0)
+        self.connect("symbol_mapper", 0, "diffenc", 0)
+        self.connect("diffenc", 0, "chunks2symbols", 0)
+        self.connect("chunks2symbols", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 2
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nModulator:"
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gray code = %s" % self._gray_code
+        print "RRS roll-off factor = %f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.define_component("bytes2chunks_dat", gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
+        self.define_component("symbol_mapper_dat", gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat"))
+        self.define_component("diffenc_dat", gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
+        self.define_component("chunks2symbols_dat", gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
+        self.define_component("rrc_filter_dat", gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
+
+        self.connect("bytes2chunks", 0, "bytes2chunks_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+        self.connect("diffenc", 0, "diffenc_dat", 0)
+        self.connect("chunks2symbols", 0, "chunks2symbols_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds QPSK modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(dqpsk_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           DQPSK demodulator
+#
+# Differentially coherent detection of differentially encoded qpsk
+# /////////////////////////////////////////////////////////////////////////////
+
+class dqpsk_demod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 costas_alpha=_def_costas_alpha,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 gray_code=_def_gray_code,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered DQPSK demodulation
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (LSB)
+
+	@param samples_per_symbol: samples per symbol >= 2
+	@type samples_per_symbol: float
+	@param excess_bw: Root-raised cosine filter excess bandwidth
+	@type excess_bw: float
+        @param costas_alpha: loop filter gain
+        @type costas_alphas: float
+        @param gain_mu: for M&M block
+        @type gain_mu: float
+        @param mu: for M&M block
+        @type mu: float
+        @param omega_relative_limit: for M&M block
+        @type omega_relative_limit: float
+        @param gray_code: Tell modulator to Gray code the bits
+        @type gray_code: bool
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool
+	"""
+
+        gr.hier_block2.__init__(self, "dqpsk_demod",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_char))       # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._costas_alpha = costas_alpha
+        self._mm_gain_mu = gain_mu
+        self._mm_mu = mu
+        self._mm_omega_relative_limit = omega_relative_limit
+        self._gray_code = gray_code
+
+        if samples_per_symbol < 2:
+            raise TypeError, "sbp must be >= 2, is %d" % samples_per_symbol
+
+        arity = pow(2,self.bits_per_symbol())
+ 
+        # Automatic gain control
+        scale = (1.0/16384.0)
+        self.pre_scaler = gr.multiply_const_cc(scale)   # scale the signal from full-range to +-1
+        self.agc = gr.feedforward_agc_cc(16, 2.0)
+       
+        # RRC data filter
+        ntaps = 11 * samples_per_symbol
+        self.rrc_taps = gr.firdes.root_raised_cosine(
+            1.0,                      # gain
+            self._samples_per_symbol, # sampling rate
+            1.0,                      # symbol rate
+            self._excess_bw,          # excess bandwidth (roll-off factor)
+            ntaps)
+        self.rrc_filter=gr.interp_fir_filter_ccf(1, self.rrc_taps)        
+
+        # symbol clock recovery
+        self._mm_omega = self._samples_per_symbol
+        self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
+        self._costas_beta  = 0.25 * self._costas_alpha * self._costas_alpha
+        fmin = -0.01
+        fmax = 0.01
+        
+        self.receiver=gr.mpsk_receiver_cc(arity, pi/4.0,
+                                         self._costas_alpha, self._costas_beta,
+                                         fmin, fmax,
+                                         self._mm_mu, self._mm_gain_mu,
+                                         self._mm_omega, self._mm_gain_omega,
+                                         self._mm_omega_relative_limit)
+        
+        # Perform Differential decoding on the constellation
+        self.diffdec = gr.diff_phasor_cc()
+
+        # find closest constellation point
+        rot = 1
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
+
+        if self._gray_code:
+            self.symbol_mapper = gr.map_bb(psk.gray_to_binary[arity])
+        else:
+            self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[arity])
+        
+        # unpack the k bit vector into a stream of bits
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
+ 
+        # Define components
+        self.define_component("pre_scaler", self.pre_scaler)
+        self.define_component("agc", self.agc)
+        self.define_component("rrc_filter", self.rrc_filter)
+        self.define_component("receiver", self.receiver)
+        self.define_component("diffdec", self.diffdec)
+        self.define_component("slicer", self.slicer)
+        self.define_component("symbol_mapper", self.symbol_mapper)
+        self.define_component("unpack", self.unpack)
+
+        # Connect and Initialize base class
+        self.connect("self", 0, "pre_scaler", 0)
+        self.connect("pre_scaler", 0, "agc", 0)
+        self.connect("agc", 0, "rrc_filter", 0)
+        self.connect("rrc_filter", 0, "receiver", 0)
+        self.connect("receiver", 0, "diffdec", 0)
+        self.connect("diffdec", 0, "slicer", 0)
+        self.connect("slicer", 0, "symbol_mapper", 0)
+        self.connect("symbol_mapper", 0, "unpack", 0)
+        self.connect("unpack", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 2
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.  RTFM
+
+    def _print_verbage(self):
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "Gray code:           %s"   % self._gray_code
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "Costas Loop alpha:   %.2e" % self._costas_alpha
+        print "Costas Loop beta:    %.2e" % self._costas_beta
+        print "M&M mu:              %.2f" % self._mm_mu
+        print "M&M mu gain:         %.2e" % self._mm_gain_mu
+        print "M&M omega:           %.2f" % self._mm_omega
+        print "M&M omega gain:      %.2e" % self._mm_gain_omega
+        print "M&M omega limit:     %.2f" % self._mm_omega_relative_limit
+
+    def _setup_logging(self):
+        print "Demodulation logging turned on."
+        self.define_component("prescaler_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_prescaler.dat"))
+        self.define_component("agc_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
+        self.define_component("rrc_filter_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_rrc_filter.dat"))
+        self.define_component("receiver_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_receiver.dat"))
+        self.define_component("diffdec_dat",
+                              gr.file_sink(gr.sizeof_gr_complex, "rx_diffdec.dat"))
+        self.define_component("slicer_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
+        self.define_component("symbol_mapper_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))
+        self.define_component("unpack_dat",
+                              gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
+
+        self.connect("pre_scaler", 0, "prescaler_dat", 0)
+        self.connect("agc", 0, "agc_dat", 0)
+        self.connect("rrc_filter", 0, "rrc_filter_dat", 0)
+        self.connect("receiver", 0, "receiver_dat", 0)
+        self.connect("diffdec", 0, "diffdec_dat", 0)
+        self.connect("slicer", 0, "slicer_dat", 0)
+        self.connect("symbol_mapper", 0, "symbol_mapper_dat", 0)
+        self.connect("unpack", 0, "unpack_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                          help="set RRC excess bandwith factor [default=%default] (PSK)")
+        parser.add_option("", "--no-gray-code", dest="gray_code",
+                          action="store_false", default=_def_gray_code,
+                          help="disable gray coding on modulated bits (PSK)")
+        parser.add_option("", "--costas-alpha", type="float", default=None,
+                          help="set Costas loop alpha value [default=%default] (PSK)")
+        parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
+                          help="set M&M symbol sync loop gain mu value [default=%default] (PSK)")
+        parser.add_option("", "--mu", type="float", default=_def_mu,
+                          help="set M&M symbol sync loop mu value [default=%default] (PSK)")
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(
+            dqpsk_demod.__init__, ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils.add_type_1_mod('dqpsk', dqpsk_mod)
+modulation_utils.add_type_1_demod('dqpsk', dqpsk_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/gmsk.py b/gnuradio-core/src/python/gnuradio/blksimpl2/gmsk.py
new file mode 100644
index 000000000..e852b3c11
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/gmsk.py
@@ -0,0 +1,305 @@
+#
+# GMSK modulation and demodulation.  
+#
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+from gnuradio import gr
+from gnuradio import modulation_utils
+from math import pi
+import Numeric
+from pprint import pprint
+import inspect
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_bt = 0.35
+_def_verbose = False
+_def_log = False
+
+_def_gain_mu = 0.05
+_def_mu = 0.5
+_def_freq_error = 0.0
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                              GMSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class gmsk_mod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 bt=_def_bt,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for Gaussian Minimum Shift Key (GMSK)
+	modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+	@param samples_per_symbol: samples per baud >= 2
+	@type samples_per_symbol: integer
+	@param bt: Gaussian filter bandwidth * symbol time
+	@type bt: float
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool       
+	"""
+
+        gr.hier_block2.__init__(self, "gmsk_mod",
+                                gr.io_signature(1,1,gr.sizeof_char),       # Input signature
+                                gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._bt = bt
+
+        if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
+            raise TypeError, ("samples_per_symbol must be an integer >= 2, is %r" % (samples_per_symbol,))
+
+	ntaps = 4 * samples_per_symbol			# up to 3 bits in filter at once
+	sensitivity = (pi / 2) / samples_per_symbol	# phase change per bit = pi / 2
+
+	# Turn it into NRZ data.
+	self.nrz = gr.bytes_to_syms()
+
+	# Form Gaussian filter
+        # Generate Gaussian response (Needs to be convolved with window below).
+	self.gaussian_taps = gr.firdes.gaussian(
+		1,		       # gain
+		samples_per_symbol,    # symbol_rate
+		bt,		       # bandwidth * symbol time
+		ntaps	               # number of taps
+		)
+
+	self.sqwave = (1,) * samples_per_symbol       # rectangular window
+	self.taps = Numeric.convolve(Numeric.array(self.gaussian_taps),Numeric.array(self.sqwave))
+	self.gaussian_filter = gr.interp_fir_filter_fff(samples_per_symbol, self.taps)
+
+	# FM modulation
+	self.fmmod = gr.frequency_modulator_fc(sensitivity)
+		
+        # Define components from objects
+        self.define_component("nrz", self.nrz)
+        self.define_component("gaussian_filter", self.gaussian_filter)
+        self.define_component("fmmod", self.fmmod)
+
+	# Connect components
+        self.connect("self", 0, "nrz", 0)
+        self.connect("nrz", 0, "gaussian_filter", 0)
+        self.connect("gaussian_filter", 0, "fmmod", 0)
+        self.connect("fmmod", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+         
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):     # staticmethod that's also callable on an instance
+        return 1
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.
+
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "Gaussian filter bt = %.2f" % self._bt
+
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.define_component("nrz_dat", gr.file_sink(gr.sizeof_float, "tx_nrz.dat"))
+        self.define_component("gaussian_filter_dat", gr.file_sink(gr.sizeof_float, "tx_gaussian_filter.dat"))
+        self.define_component("fmmod_dat", gr.file_sink(gr.sizeof_gr_complex, "tx_fmmod.dat"))
+
+        self.connect("nrz", 0, "nrz_dat", 0)
+        self.connect("gaussian_filter", 0, "gaussian_filter_dat", 0)
+        self.connect("fmmod", 0, "fmmod_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds GMSK modulation-specific options to the standard parser
+        """
+        parser.add_option("", "--bt", type="float", default=_def_bt,
+                          help="set bandwidth-time product [default=%default] (GMSK)")
+    add_options=staticmethod(add_options)
+
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(gmsk_mod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                            GMSK demodulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class gmsk_demod(gr.hier_block2):
+
+    def __init__(self,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 gain_mu=_def_gain_mu,
+                 mu=_def_mu,
+                 omega_relative_limit=_def_omega_relative_limit,
+                 freq_error=_def_freq_error,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for Gaussian Minimum Shift Key (GMSK)
+	demodulation.
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (the LSB)
+
+	@param samples_per_symbol: samples per baud
+	@type samples_per_symbol: integer
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param log: Print modualtion data to files?
+        @type log: bool 
+
+        Clock recovery parameters.  These all have reasonble defaults.
+        
+        @param gain_mu: controls rate of mu adjustment
+        @type gain_mu: float
+        @param mu: fractional delay [0.0, 1.0]
+        @type mu: float
+        @param omega_relative_limit: sets max variation in omega
+        @type omega_relative_limit: float, typically 0.000200 (200 ppm)
+        @param freq_error: bit rate error as a fraction
+        @param float
+	"""
+
+        gr.hier_block2.__init__(self, "gmsk_demod",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_char))       # Output signature
+
+        self._samples_per_symbol = samples_per_symbol
+        self._gain_mu = gain_mu
+        self._mu = mu
+        self._omega_relative_limit = omega_relative_limit
+        self._freq_error = freq_error
+        
+        if samples_per_symbol < 2:
+            raise TypeError, "samples_per_symbol >= 2, is %f" % samples_per_symbol
+
+        self._omega = samples_per_symbol*(1+self._freq_error)
+
+	self._gain_omega = .25 * self._gain_mu * self._gain_mu        # critically damped
+
+	# Demodulate FM
+	sensitivity = (pi / 2) / samples_per_symbol
+	self.fmdemod = gr.quadrature_demod_cf(1.0 / sensitivity)
+
+	# the clock recovery block tracks the symbol clock and resamples as needed.
+	# the output of the block is a stream of soft symbols (float)
+	self.clock_recovery = gr.clock_recovery_mm_ff(self._omega, self._gain_omega,
+                                                      self._mu, self._gain_mu,
+                                                      self._omega_relative_limit)
+
+        # slice the floats at 0, outputting 1 bit (the LSB of the output byte) per sample
+        self.slicer = gr.binary_slicer_fb()
+
+        # Define components from objects
+        self.define_component("fmdemod", self.fmdemod)
+        self.define_component("clock_recovery", self.clock_recovery)
+        self.define_component("slicer", self.slicer)
+
+	# Connect components
+        self.connect("self", 0, "fmdemod", 0)
+        self.connect("fmdemod", 0, "clock_recovery", 0)
+        self.connect("clock_recovery", 0, "slicer", 0)
+        self.connect("slicer", 0, "self", 0)
+
+        if verbose:
+            self._print_verbage()
+         
+        if log:
+            self._setup_logging()
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self=None):   # staticmethod that's also callable on an instance
+        return 1
+    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a static method.
+
+    def _print_verbage(self):
+        print "bits per symbol = %d" % self.bits_per_symbol()
+        print "M&M clock recovery omega = %f" % self._omega
+        print "M&M clock recovery gain mu = %f" % self._gain_mu
+        print "M&M clock recovery mu = %f" % self._mu
+        print "M&M clock recovery omega rel. limit = %f" % self._omega_relative_limit
+        print "frequency error = %f" % self._freq_error
+
+
+    def _setup_logging(self):
+        print "Demodulation logging turned on."
+        self.define_component("fmdemod_dat", gr.file_sink(gr.sizeof_float, "rx_fmdemod.dat"))
+        self.define_component("clock_recovery_dat", gr.file_sink(gr.sizeof_float, "rx_clock_recovery.dat"))
+        self.define_component("slicer_dat", gr.file_sink(gr.sizeof_char, "rx_slicer.dat"))
+
+        self.connect("fmdemod", 0, "fmdemod_dat", 0)
+        self.connect("clock_recovery", 0, "clock_recovery_dat", 0)
+        self.connect("slicer", 0, "slicer_dat", 0)
+
+    def add_options(parser):
+        """
+        Adds GMSK demodulation-specific options to the standard parser
+        """
+        parser.add_option("", "--gain-mu", type="float", default=_def_gain_mu,
+                          help="M&M clock recovery gain mu [default=%default] (GMSK/PSK)")
+        parser.add_option("", "--mu", type="float", default=_def_mu,
+                          help="M&M clock recovery mu [default=%default] (GMSK/PSK)")
+        parser.add_option("", "--omega-relative-limit", type="float", default=_def_omega_relative_limit,
+                          help="M&M clock recovery omega relative limit [default=%default] (GMSK/PSK)")
+        parser.add_option("", "--freq-error", type="float", default=_def_freq_error,
+                          help="M&M clock recovery frequency error [default=%default] (GMSK)")
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return modulation_utils.extract_kwargs_from_options(gmsk_demod.__init__,
+                                                            ('self', 'fg'), options)
+    extract_kwargs_from_options=staticmethod(extract_kwargs_from_options)
+
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils.add_type_1_mod('gmsk', gmsk_mod)
+modulation_utils.add_type_1_demod('gmsk', gmsk_demod)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/pkt.py b/gnuradio-core/src/python/gnuradio/blksimpl2/pkt.py
new file mode 100644
index 000000000..1e1dae17a
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/pkt.py
@@ -0,0 +1,165 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+from math import pi
+import Numeric
+
+from gnuradio import gr, packet_utils
+import gnuradio.gr.gr_threading as _threading
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                   mod/demod with packets as i/o
+# /////////////////////////////////////////////////////////////////////////////
+
+class mod_pkts(gr.hier_block2):
+    """
+    Wrap an arbitrary digital modulator in our packet handling framework.
+
+    Send packets by calling send_pkt
+    """
+    def __init__(self, modulator, access_code=None, msgq_limit=2, pad_for_usrp=True):
+        """
+	Hierarchical block for sending packets
+
+        Packets to be sent are enqueued by calling send_pkt.
+        The output is the complex modulated signal at baseband.
+
+        @param modulator: instance of modulator class (gr_block or hier_block)
+        @type modulator: complex baseband out
+        @param access_code: AKA sync vector
+        @type access_code: string of 1's and 0's between 1 and 64 long
+        @param msgq_limit: maximum number of messages in message queue
+        @type msgq_limit: int
+        @param pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples
+        """
+
+        gr.hier_block2.__init__(self, "mod_pkts",
+                                gr.io_signature(0,0,0), # Input signature
+                                gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+        self._modulator = modulator
+        self._pad_for_usrp = pad_for_usrp
+
+        if access_code is None:
+            access_code = packet_utils.default_access_code
+        if not packet_utils.is_1_0_string(access_code):
+            raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
+        self._access_code = access_code
+
+        # accepts messages from the outside world
+        self._pkt_input = gr.message_source(gr.sizeof_char, msgq_limit)
+        self.define_component("packet_source", self._pkt_input)
+        self.define_component("modulator", self._modulator)
+
+        self.connect("packet_source", 0, "modulator", 0)
+        self.connect("modulator", 0, "self", 0)
+
+    def send_pkt(self, payload='', eof=False):
+        """
+        Send the payload.
+
+        @param payload: data to send
+        @type payload: string
+        """
+        if eof:
+            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
+        else:
+            # print "original_payload =", string_to_hex_list(payload)
+            pkt = packet_utils.make_packet(payload,
+                                           self._modulator.samples_per_symbol(),
+                                           self._modulator.bits_per_symbol(),
+                                           self._access_code,
+                                           self._pad_for_usrp)
+            #print "pkt =", string_to_hex_list(pkt)
+            msg = gr.message_from_string(pkt)
+        self._pkt_input.msgq().insert_tail(msg)
+
+
+
+class demod_pkts(gr.hier_block2):
+    """
+    Wrap an arbitrary digital demodulator in our packet handling framework.
+
+    The input is complex baseband.  When packets are demodulated, they are passed to the
+    app via the callback.
+    """
+
+    def __init__(self, demodulator, access_code=None, callback=None, threshold=-1):
+        """
+	Hierarchical block for demodulating and deframing packets.
+
+	The input is the complex modulated signal at baseband.
+        Demodulated packets are sent to the handler.
+
+        @param demodulator: instance of demodulator class (gr_block or hier_block)
+        @type demodulator: complex baseband in
+        @param access_code: AKA sync vector
+        @type access_code: string of 1's and 0's
+        @param callback:  function of two args: ok, payload
+        @type callback: ok: bool; payload: string
+        @param threshold: detect access_code with up to threshold bits wrong (-1 -> use default)
+        @type threshold: int
+	"""
+
+        gr.hier_block2.__init__(self, "demod_pkts",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+                                gr.io_signature(0,0,0)) # Output signature
+                                
+        self._demodulator = demodulator
+        if access_code is None:
+            access_code = packet_utils.default_access_code
+        if not packet_utils.is_1_0_string(access_code):
+            raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
+        self._access_code = access_code
+
+        if threshold == -1:
+            threshold = 12              # FIXME raise exception
+
+        self._rcvd_pktq = gr.msg_queue()          # holds packets from the PHY
+
+        self.define_component("demodulator", self._demodulator)
+        self.define_component("correlator", gr.correlate_access_code_bb(access_code, threshold))
+        self.define_component("framer_sink", gr.framer_sink_1(self._rcvd_pktq))
+
+        self.connect("self", 0, "demodulator",0)
+        self.connect("demodulator", 0, "correlator", 0)
+        self.connect("correlator", 0, "framer_sink", 0)
+
+        self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)
+
+
+class _queue_watcher_thread(_threading.Thread):
+    def __init__(self, rcvd_pktq, callback):
+        _threading.Thread.__init__(self)
+        self.setDaemon(1)
+        self.rcvd_pktq = rcvd_pktq
+        self.callback = callback
+        self.keep_running = True
+        self.start()
+
+
+    def run(self):
+        while self.keep_running:
+            msg = self.rcvd_pktq.delete_head()
+            ok, payload = packet_utils.unmake_packet(msg.to_string())
+            if self.callback:
+                self.callback(ok, payload)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl2/psk.py b/gnuradio-core/src/python/gnuradio/blksimpl2/psk.py
new file mode 100644
index 000000000..2a882f888
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl2/psk.py
@@ -0,0 +1,88 @@
+#
+# Copyright 2005,2006 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 2, 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.
+# 
+
+from math import pi, sqrt, log10
+import math, cmath
+
+# The following algorithm generates Gray coded constellations for M-PSK for M=[2,4,8]
+def make_gray_constellation(m):
+    # number of bits/symbol (log2(M))
+    k = int(log10(m) / log10(2.0))
+
+    coeff = 1
+    const_map = []
+    bits = [0]*3
+    for i in range(m):
+        # get a vector of the k bits to use in this mapping
+        bits[3-k:3] = [((i&(0x01 << k-j-1)) >> k-j-1) for j in range(k)]
+
+        theta = -(2*bits[0]-1)*(2*pi/m)*(bits[0]+abs(bits[1]-bits[2])+2*bits[1])
+        re = math.cos(theta)
+        im = math.sin(theta)
+        const_map.append(complex(re, im))   # plug it into the constellation
+        
+    # return the constellation; by default, it is normalized
+    return const_map
+
+# This makes a constellation that increments around the unit circle
+def make_constellation(m):
+    return [cmath.exp(i * 2 * pi / m * 1j) for i in range(m)]
+        
+# Common definition of constellations for Tx and Rx
+constellation = {
+    2 : make_constellation(2),           # BPSK
+    4 : make_constellation(4),           # QPSK
+    8 : make_constellation(8)            # 8PSK
+    }
+
+# -----------------------
+# Do Gray code
+# -----------------------
+# binary to gray coding -- constellation does Gray coding
+binary_to_gray = {
+    2 : range(2),
+    4 : [0,1,3,2],
+    8 : [0, 1, 3, 2, 7, 6, 4, 5]
+    }
+   
+# gray to binary
+gray_to_binary = {
+    2 : range(2),
+    4 : [0,1,3,2],
+    8 : [0, 1, 3, 2, 6, 7, 5, 4]
+    }
+
+# -----------------------
+# Don't Gray code
+# -----------------------
+# identity mapping
+binary_to_ungray = {
+    2 : range(2),
+    4 : range(4),
+    8 : range(8)
+    }
+    
+# identity mapping
+ungray_to_binary = {
+    2 : range(2),
+    4 : range(4),
+    8 : range(8)
+    }
diff --git a/gnuradio-core/src/python/gnuradio/packet_utils.py b/gnuradio-core/src/python/gnuradio/packet_utils.py
index 182c80cdc..f3552582e 100644
--- a/gnuradio-core/src/python/gnuradio/packet_utils.py
+++ b/gnuradio-core/src/python/gnuradio/packet_utils.py
@@ -72,7 +72,7 @@ def conv_1_0_string_to_packed_binary_string(s):
 default_access_code = \
   conv_packed_binary_string_to_1_0_string('\xAC\xDD\xA4\xE2\xF2\x8C\x20\xFC')
 preamble = \
-  conv_packed_binary_string_to_1_0_string('\x6C\xC6\x6C\xC6\x6C\xC6\x6C\xC6')
+  conv_packed_binary_string_to_1_0_string('\xA4\xF2')
 
 def is_1_0_string(s):
     if not isinstance(s, str):
@@ -103,7 +103,7 @@ def make_header(payload_len, whitener_offset=0):
 
 def make_packet(payload, samples_per_symbol, bits_per_symbol,
                 access_code=default_access_code, pad_for_usrp=True,
-                whitener_offset=0):
+                whitener_offset=0, whitening=True):
     """
     Build a packet, given access code, payload, and whitener offset
 
@@ -135,8 +135,13 @@ def make_packet(payload, samples_per_symbol, bits_per_symbol,
     if L > MAXLEN:
         raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
 
-    pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
-                   whiten(payload_with_crc, whitener_offset), '\x55'))
+    if whitening:
+        pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
+                       whiten(payload_with_crc, whitener_offset), '\x55'))
+    else:
+        pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
+                       (payload_with_crc), '\x55'))
+
     if pad_for_usrp:
         pkt = pkt + (_npadding_bytes(len(pkt), samples_per_symbol, bits_per_symbol) * '\x55')
 
@@ -165,13 +170,18 @@ def _npadding_bytes(pkt_byte_len, samples_per_symbol, bits_per_symbol):
     return byte_modulus - r
     
 
-def unmake_packet(whitened_payload_with_crc, whitener_offset=0):
+def unmake_packet(whitened_payload_with_crc, whitener_offset=0, dewhitening=True):
     """
     Return (ok, payload)
 
     @param whitened_payload_with_crc: string
     """
-    payload_with_crc = dewhiten(whitened_payload_with_crc, whitener_offset)
+
+    if dewhitening:
+        payload_with_crc = dewhiten(whitened_payload_with_crc, whitener_offset)
+    else:
+        payload_with_crc = (whitened_payload_with_crc)
+
     ok, payload = gru.check_crc32(payload_with_crc)
 
     if 0: