13 files changed, 1635 insertions, 351 deletions
diff --git a/gnuradio-core/src/python/gnuradio/Makefile.am b/gnuradio-core/src/python/gnuradio/Makefile.am
index 05e42a7378..4f8972f09a 100644
--- a/gnuradio-core/src/python/gnuradio/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/Makefile.am
@@ -28,6 +28,7 @@ grpython_PYTHON = 			\
 	audio.py			\
 	eng_notation.py			\
 	eng_option.py			\
+	modulation_utils.py		\
 	packet_utils.py			\
 	gr_unittest.py			\
 	optfir.py			\
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am b/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
index 184aa7a29b..8122bfa6a7 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/Makefile.am
@@ -29,14 +29,16 @@ grblkspythondir = $(grpythondir)/blksimpl
 grblkspython_PYTHON =		\
 	__init__.py		\
 	am_demod.py		\
+	dbpsk.py		\
+	dqpsk.py		\
 	filterbank.py		\
 	fm_demod.py		\
 	fm_emph.py		\
-	gmsk2.py		\
-	gmsk2_pkt.py		\
+	gmsk.py			\
 	nbfm_rx.py		\
 	nbfm_tx.py		\
 	pkt.py			\
+	psk.py			\
 	rational_resampler.py	\
 	standard_squelch.py	\
 	wfm_rcv.py		\
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
new file mode 100644
index 0000000000..20b940bf05
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
@@ -0,0 +1,370 @@
+#
+# 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/gmsk2 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.05
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             DBPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class dbpsk_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 differential BPSK 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 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
+	"""
+
+        self._fg = fg
+        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)
+
+	# Connect
+        fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
+                   self.chunks2symbols, self.rrc_filter)
+
+        if verbose:
+            self._print_verbage()
+            
+        if log:
+            self._setup_logging()
+            
+	# Initialize base class
+	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):   # 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 "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"))
+        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"))
+              
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             DBPSK demodulator
+#
+#      Differentially coherent detection of differentially encoded BPSK
+# /////////////////////////////////////////////////////////////////////////////
+
+class dbpsk_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 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 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._gain_mu = gain_mu
+        self._mu = mu
+        self._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)
+
+        
+        # Costas loop (carrier tracking)
+        # FIXME: need to decide how to handle this more generally; do we pull it from higher layer?
+        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)
+
+        # RRC data filter
+        ntaps = 11 * self._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.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)
+
+        # 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:
+            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 and 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)
+
+        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 1
+    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
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.pre_scaler,
+                         gr.file_sink(gr.sizeof_gr_complex, "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"))
+        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"))
+        self._fg.connect(self.diffdec,
+                         gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))        
+        self._fg.connect(self.slicer,
+                        gr.file_sink(gr.sizeof_char, "slicer.dat"))
+        self._fg.connect(self.gray_decoder,
+                         gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+        self._fg.connect(self.unpack,
+                         gr.file_sink(gr.sizeof_char, "unpack.dat"))
+        
+    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', 'fg'), 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/blksimpl/dqpsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
new file mode 100644
index 0000000000..3b60f2242e
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
@@ -0,0 +1,370 @@
+#
+# 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/gmsk2 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.10
+_def_gain_mu = 0.03
+_def_mu = 0.05
+_def_omega_relative_limit = 0.005
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           DQPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class dqpsk_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 = .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)
+
+        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 2
+    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 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_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._gain_mu = gain_mu
+        self._mu = mu
+        self._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)
+       
+        # Costas loop (carrier tracking)
+        # FIXME: need to decide how to handle this more generally; do we pull it from higher layer?
+        costas_order = 4
+        beta = .25 * self._costas_alpha * self._costas_alpha
+        #self.costas_loop = gr.costas_loop_cc(self._costas_alpha, beta, 0.1, -0.1, costas_order)
+        self.costas_loop = gr.costas_loop_cc(self._costas_alpha, beta, 0.002, -0.002, costas_order)
+
+        # RRC data filter
+        ntaps = 11 * samples_per_symbol
+        self.rrc_taps = gr.firdes.root_raised_cosine(
+            self._samples_per_symbol, # 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)
+
+        # 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)
+
+        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())
+
+        if verbose:
+            self._print_verbage()
+        
+        if log:
+            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)
+        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 2
+    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
+        
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self._fg.connect(self.pre_scaler,
+                         gr.file_sink(gr.sizeof_gr_complex, "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"))
+        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"))
+        self._fg.connect(self.diffdec,
+                         gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))        
+        self._fg.connect(self.slicer,
+                         gr.file_sink(gr.sizeof_char, "slicer.dat"))
+        self._fg.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+        self._fg.connect(self.unpack,
+                         gr.file_sink(gr.sizeof_char, "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=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/blksimpl/gmsk.py b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
new file mode 100644
index 0000000000..098aa74bb5
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
@@ -0,0 +1,289 @@
+#
+# 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/gmsk2 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_block):
+
+    def __init__(self, fg,
+                 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 fg: flow graph
+	@type fg: flow graph
+	@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       
+	"""
+
+        self._fg = fg
+        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)
+		
+        if verbose:
+            self._print_verbage()
+         
+        if log:
+            self._setup_logging()
+
+	# Connect & Initialize base class
+	self._fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
+	gr.hier_block.__init__(self, self._fg, self.nrz, self.fmmod)
+
+    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._fg.connect(self.nrz,
+                         gr.file_sink(gr.sizeof_float, "nrz.dat"))
+        self._fg.connect(self.gaussian_filter,
+                         gr.file_sink(gr.sizeof_float, "gaussian_filter.dat"))
+        self._fg.connect(self.fmmod,
+                         gr.file_sink(gr.sizeof_gr_complex, "fmmod.dat"))
+
+
+    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_block):
+
+    def __init__(self, fg,
+                 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 fg: flow graph
+	@type fg: flow graph
+	@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
+	"""
+
+        self._fg = fg
+        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()
+
+        if verbose:
+            self._print_verbage()
+         
+        if log:
+            self._setup_logging()
+
+	# Connect & Initialize base class
+	self._fg.connect(self.fmdemod, self.clock_recovery, self.slicer)
+	gr.hier_block.__init__(self, self._fg, self.fmdemod, self.slicer)
+
+    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._fg.connect(self.fmdemod,
+                        gr.file_sink(gr.sizeof_float, "fmdemod.dat"))
+        self._fg.connect(self.clock_recovery,
+                        gr.file_sink(gr.sizeof_float, "clock_recovery.dat"))
+        self._fg.connect(self.slicer,
+                        gr.file_sink(gr.sizeof_char, "slicer.dat"))
+
+    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/blksimpl/gmsk2.py b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk2.py
deleted file mode 100644
index 4fc033977b..0000000000
--- a/gnuradio-core/src/python/gnuradio/blksimpl/gmsk2.py
+++ /dev/null
@@ -1,159 +0,0 @@
-#
-# 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/gmsk2 for examples
-
-from gnuradio import gr
-from math import pi
-import Numeric
-
-# /////////////////////////////////////////////////////////////////////////////
-#            GMSK mod/demod with steams of bytes as data i/o
-# /////////////////////////////////////////////////////////////////////////////
-
-class gmsk2_mod(gr.hier_block):
-
-    def __init__(self, fg, spb = 2, bt = 0.3):
-        """
-	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 fg: flow graph
-	@type fg: flow graph
-	@param spb: samples per baud >= 2
-	@type spb: integer
-	@param bt: Gaussian filter bandwidth * symbol time
-	@type bt: float
-	"""
-        if not isinstance(spb, int) or spb < 2:
-            raise TypeError, "sbp must be an integer >= 2"
-        self.spb = spb
-
-	ntaps = 4 * spb			# up to 3 bits in filter at once
-	sensitivity = (pi / 2) / spb	# 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
-		spb,            # symbol_rate
-		bt,		# bandwidth * symbol time
-		ntaps	        # number of taps
-		)
-
-	self.sqwave = (1,) * spb       # rectangular window
-	self.taps = Numeric.convolve(Numeric.array(self.gaussian_taps),Numeric.array(self.sqwave))
-	self.gaussian_filter = gr.interp_fir_filter_fff(spb, self.taps)
-
-	# FM modulation
-	self.fmmod = gr.frequency_modulator_fc(sensitivity)
-		
-	# Connect
-	fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
-
-	# Initialize base class
-	gr.hier_block.__init__(self, fg, self.nrz, self.fmmod)
-
-    def samples_per_baud(self):
-        return self.spb
-
-    def bits_per_baud(self=None):   # staticmethod that's also callable on an instance
-        return 1
-    bits_per_baud = staticmethod(bits_per_baud)      # make it a static method.  RTFM
-
-
-class gmsk2_demod(gr.hier_block):
-
-    def __init__(self, fg, spb=2, omega=None, gain_mu=0.03, mu=0.5,
-                 omega_relative_limit=0.000200, freq_error=0.0):
-        """
-	Hierarchical block for Gaussian Minimum Shift Key (GMSK)
-	demodulation.
-
-	The input is the complex modulated signal at baseband.
-	The output is a stream of symbols ready to be sliced at zero.
-
-	@param fg: flow graph
-	@type fg: flow graph
-	@param spb: samples per baud
-	@type spb: integer
-
-        Clock recovery parameters.  These all have reasonble defaults.
-        
-        @param omega: nominal relative freq (defaults to spb)
-        @type omega: float
-        @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
-	"""
-        if spb < 2:
-            raise TypeError, "sbp >= 2"
-        self.spb = spb
-        
-        if omega is None:
-            omega = spb*(1+freq_error)
-
-	gain_omega = .25*gain_mu*gain_mu        # critically damped
-
-        # Automatic gain control
-        self.preamp = gr.multiply_const_cc(10e-5)
-        self.agc = gr.agc_cc(1e-3, 1, 1, 1000)
-
-	# Demodulate FM
-	sensitivity = (pi / 2) / spb
-	self.fmdemod = gr.quadrature_demod_cf(1.0 / sensitivity)
-
-        alpha = 0.0008
-
-	# 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(omega, gain_omega, mu, gain_mu,
-                                                      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()
-
-	fg.connect(self.preamp, self.agc, self.fmdemod, self.clock_recovery, self.slicer)
-        
-	# Initialize base class
-	gr.hier_block.__init__(self, fg, self.preamp, self.slicer)
-
-    def samples_per_baud(self):
-        return self.spb
-
-    def bits_per_baud(self=None):   # staticmethod that's also callable on an instance
-        return 1
-    bits_per_baud = staticmethod(bits_per_baud)      # make it a static method.  RTFM
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/gmsk2_pkt.py b/gnuradio-core/src/python/gnuradio/blksimpl/gmsk2_pkt.py
deleted file mode 100644
index 672dbbd698..0000000000
--- a/gnuradio-core/src/python/gnuradio/blksimpl/gmsk2_pkt.py
+++ /dev/null
@@ -1,174 +0,0 @@
-#
-# 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
-import gmsk2
-
-
-def _deprecation_warning(old_name, new_name):
-    print '#'
-    print '#  Warning: %s is deprecated and will be removed soon.' % (old_name,)
-    print '#           Please use the modulation independent block, %s.' % (new_name,)
-    print "#"
-
-
-# /////////////////////////////////////////////////////////////////////////////
-#                   GMSK mod/demod with packets as i/o
-# /////////////////////////////////////////////////////////////////////////////
-
-class gmsk2_mod_pkts(gr.hier_block):
-    """
-    GSM modulator that is a GNU Radio source.
-
-    Send packets by calling send_pkt
-    """
-    def __init__(self, fg, access_code=None, msgq_limit=2, pad_for_usrp=True, *args, **kwargs):
-        """
-	Hierarchical block for Gaussian Minimum Shift Key (GMSK) modulation.
-
-        Packets to be sent are enqueued by calling send_pkt.
-        The output is the complex modulated signal at baseband.
-
-	@param fg: flow graph
-	@type fg: flow graph
-        @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
-
-        See gmsk_mod for remaining parameters
-        """
-        _deprecation_warning('gmsk2_mod_pkts', 'mod_pkts')
-        
-        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.gmsk_mod = gmsk2.gmsk2_mod(fg, *args, **kwargs)
-        fg.connect(self.pkt_input, self.gmsk_mod)
-        gr.hier_block.__init__(self, fg, None, self.gmsk_mod)
-
-    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.gmsk_mod.samples_per_baud(),
-                                           self.gmsk_mod.bits_per_baud(),
-                                           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 gmsk2_demod_pkts(gr.hier_block):
-    """
-    GSM demodulator that is a GNU Radio sink.
-
-    The input is complex baseband.  When packets are demodulated, they are passed to the
-    app via the callback.
-    """
-
-    def __init__(self, fg, access_code=None, callback=None, threshold=-1, *args, **kwargs):
-        """
-	Hierarchical block for Gaussian Minimum Shift Key (GMSK)
-	demodulation.
-
-	The input is the complex modulated signal at baseband.
-        Demodulated packets are sent to the handler.
-
-	@param fg: flow graph
-	@type fg: flow graph
-        @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
-
-        See gmsk_demod for remaining parameters.
-	"""
-
-        _deprecation_warning('gmsk2_demod_pkts', 'demod_pkts')
-
-        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.gmsk_demod = gmsk2.gmsk2_demod(fg, *args, **kwargs)
-        self.correlator = gr.correlate_access_code_bb(access_code, threshold)
-
-        self.framer_sink = gr.framer_sink_1(self._rcvd_pktq)
-        fg.connect(self.gmsk_demod, self.correlator, self.framer_sink)
-        
-        gr.hier_block.__init__(self, fg, self.gmsk_demod, None)
-        self._watcher = _queue_watcher_thread(self._rcvd_pktq, callback)
-
-    def carrier_sensed(self):
-        """
-        Return True if we detect carrier.
-        """
-        return False        # FIXME
-
-
-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 stop(self):
-    #    self.keep_running = False
-        
-    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/blksimpl/pkt.py b/gnuradio-core/src/python/gnuradio/blksimpl/pkt.py
index 05e22c90e5..a1ece893df 100644
--- a/gnuradio-core/src/python/gnuradio/blksimpl/pkt.py
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/pkt.py
@@ -81,8 +81,8 @@ class mod_pkts(gr.hier_block):
         else:
             # print "original_payload =", string_to_hex_list(payload)
             pkt = packet_utils.make_packet(payload,
-                                           self._modulator.samples_per_baud(),
-                                           self._modulator.bits_per_baud(),
+                                           self._modulator.samples_per_symbol(),
+                                           self._modulator.bits_per_symbol(),
                                            self._access_code,
                                            self._pad_for_usrp)
             #print "pkt =", string_to_hex_list(pkt)
diff --git a/gnuradio-core/src/python/gnuradio/blksimpl/psk.py b/gnuradio-core/src/python/gnuradio/blksimpl/psk.py
new file mode 100644
index 0000000000..fdb6c9e693
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/blksimpl/psk.py
@@ -0,0 +1,67 @@
+#
+# 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 cmath
+
+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
+binary_to_gray = {
+    2 : (0, 1),
+    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)
+    }
+
+# -----------------------
+# Don't Gray code
+# -----------------------
+# identity mapping
+binary_to_ungray = {
+    2 : (0, 1),
+    4 : (0, 1, 2, 3),
+    8 : (0, 1, 2, 3, 4, 5, 6, 7)
+    }
+    
+# identity mapping
+ungray_to_binary = {
+    2 : (0, 1),
+    4 : (0, 1, 2, 3),
+    8 : (0, 1, 2, 3, 4, 5, 6, 7)
+    }
diff --git a/gnuradio-core/src/python/gnuradio/gr/Makefile.am b/gnuradio-core/src/python/gnuradio/gr/Makefile.am
index 538f27172f..f562cd7177 100644
--- a/gnuradio-core/src/python/gnuradio/gr/Makefile.am
+++ b/gnuradio-core/src/python/gnuradio/gr/Makefile.am
@@ -44,6 +44,7 @@ grgrpython_PYTHON = 		\
 
 noinst_PYTHON = 			\
 	qa_add_and_friends.py		\
+	qa_agc.py			\
 	qa_basic_flow_graph.py		\
 	qa_complex_to_xxx.py		\
 	qa_correlate_access_code.py	\
diff --git a/gnuradio-core/src/python/gnuradio/gr/qa_agc.py b/gnuradio-core/src/python/gnuradio/gr/qa_agc.py
new file mode 100755
index 0000000000..01159173cc
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/gr/qa_agc.py
@@ -0,0 +1,433 @@
+#!/usr/bin/env python
+#
+# 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.
+# 
+
+from gnuradio import gr, gr_unittest
+import math
+
+test_output = False
+
+class test_sig_source (gr_unittest.TestCase):
+
+    def setUp (self):
+        self.fg = gr.flow_graph ()
+
+    def tearDown (self):
+        self.fg = None
+
+    
+    def test_001(self):
+        ''' Test the complex AGC loop (single rate input) '''
+        fg = self.fg
+
+        expected_result = (
+            (100.000244140625+7.2191943445432116e-07j),
+            (72.892257690429688+52.959323883056641j),
+            (25.089065551757812+77.216217041015625j),
+            (-22.611061096191406+69.589706420898438j),
+            (-53.357715606689453+38.766635894775391j),
+            (-59.458671569824219+3.4792964243024471e-07j),
+            (-43.373462677001953-31.512666702270508j),
+            (-14.94139289855957-45.984889984130859j),
+            (13.478158950805664-41.48150634765625j),
+            (31.838506698608398-23.132022857666016j),
+            (35.519271850585938-3.1176801940091536e-07j),
+            (25.942903518676758+18.848621368408203j),
+            (8.9492912292480469+27.5430908203125j),
+            (-8.0852642059326172+24.883890151977539j),
+            (-19.131628036499023+13.899936676025391j),
+            (-21.383295059204102+3.1281737733479531e-07j),
+            (-15.650330543518066-11.370632171630859j),
+            (-5.4110145568847656-16.65339469909668j),
+            (4.9008159637451172-15.083160400390625j),
+            (11.628337860107422-8.4484796524047852j),
+            (13.036135673522949-2.288476110834381e-07j),
+            (9.5726661682128906+6.954948902130127j),
+            (3.3216962814331055+10.223132133483887j),
+            (-3.0204284191131592+9.2959251403808594j),
+            (-7.1977195739746094+5.2294478416442871j),
+            (-8.1072216033935547+1.8976157889483147e-07j),
+            (-5.9838657379150391-4.3475332260131836j),
+            (-2.0879747867584229-6.4261269569396973j),
+            (1.9100792407989502-5.8786196708679199j),
+            (4.5814824104309082-3.3286411762237549j),
+            (5.1967458724975586-1.3684227440080576e-07j),
+            (3.8647139072418213+2.8078789710998535j),
+            (1.3594740629196167+4.1840314865112305j),
+            (-1.2544282674789429+3.8607344627380371j),
+            (-3.0366206169128418+2.2062335014343262j),
+            (-3.4781389236450195+1.1194014604143376e-07j),
+            (-2.6133756637573242-1.8987287282943726j),
+            (-0.9293016791343689-2.8600969314575195j),
+            (0.86727333068847656-2.6691930294036865j),
+            (2.1243946552276611-1.5434627532958984j),
+            (2.4633183479309082-8.6486437567145913e-08j),
+            (1.8744727373123169+1.3618841171264648j),
+            (0.67528903484344482+2.0783262252807617j),
+            (-0.63866174221038818+1.965599536895752j),
+            (-1.5857341289520264+1.152103066444397j),
+            (-1.8640764951705933+7.6355092915036948e-08j),
+            (-1.4381576776504517-1.0448826551437378j),
+            (-0.52529704570770264-1.6166983842849731j),
+            (0.50366902351379395-1.5501341819763184j),
+            (1.26766037940979-0.92100900411605835j))
+
+        sampling_freq = 100
+        src1 = gr.sig_source_c (sampling_freq, gr.GR_SIN_WAVE,
+                                sampling_freq * 0.10, 100.0)
+        dst1 = gr.vector_sink_c ()
+        head = gr.head (gr.sizeof_gr_complex, int (5*sampling_freq * 0.10))
+
+        agc = gr.agc_cc(1e-3, 1, 1, 1000)
+        
+        fg.connect (src1, head)
+        fg.connect (head, agc)
+        fg.connect (agc, dst1)
+
+        if test_output == True:
+            fg.connect (agc, gr.file_sink(gr.sizeof_gr_complex, "test_agc_cc.dat"))
+
+        fg.run ()
+        dst_data = dst1.data ()
+        self.assertComplexTuplesAlmostEqual (expected_result, dst_data, 4)
+
+    def test_002(self):
+        ''' Test the floating point AGC loop (single rate input) '''
+        fg = self.fg
+
+        expected_result = (
+            7.2191943445432116e-07,
+            58.837181091308594,
+            89.700050354003906,
+            81.264183044433594,
+            45.506141662597656,
+            4.269894304798072e-07,
+            -42.948936462402344,
+            -65.50335693359375,
+            -59.368724822998047,
+            -33.261005401611328,
+            -4.683740257860336e-07,
+            31.423542022705078,
+            47.950984954833984,
+            43.485683441162109,
+            24.378345489501953,
+            5.7254135299444897e-07,
+            -23.062990188598633,
+            -35.218441009521484,
+            -31.964075088500977,
+            -17.934831619262695,
+            -5.0591745548445033e-07,
+            16.998210906982422,
+            25.982204437255859,
+            23.606258392333984,
+            13.260685920715332,
+            4.9936483037527069e-07,
+            -12.59880542755127,
+            -19.28221321105957,
+            -17.54347038269043,
+            -9.8700437545776367,
+            -4.188150626305287e-07,
+            9.4074573516845703,
+            14.422011375427246,
+            13.145503044128418,
+            7.41046142578125,
+            3.8512698097292741e-07,
+            -7.0924453735351562,
+            -10.896408081054688,
+            -9.9552040100097656,
+            -5.6262712478637695,
+            -3.1982864356905338e-07,
+            5.4131259918212891,
+            8.3389215469360352,
+            7.6409502029418945,
+            4.3320145606994629,
+            2.882407841298118e-07,
+            -4.194943904876709,
+            -6.4837145805358887,
+            -5.9621825218200684,
+            -3.3931560516357422)
+
+        sampling_freq = 100
+        src1 = gr.sig_source_f (sampling_freq, gr.GR_SIN_WAVE,
+                                sampling_freq * 0.10, 100.0)
+        dst1 = gr.vector_sink_f ()
+        head = gr.head (gr.sizeof_float, int (5*sampling_freq * 0.10))
+
+        agc = gr.agc_ff(1e-3, 1, 1, 1000)
+        
+        fg.connect (src1, head)
+        fg.connect (head, agc)
+        fg.connect (agc, dst1)
+
+        if test_output == True:
+            fg.connect (agc, gr.file_sink(gr.sizeof_float, "test_agc_ff.dat"))
+
+        fg.run ()
+        dst_data = dst1.data ()
+        self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 4)
+
+    def test_003(self):
+        ''' Test the complex AGC loop (attack and decay rate inputs) '''
+        fg = self.fg
+
+        expected_result = \
+                        ((100.000244140625+7.2191943445432116e-07j),
+                         (0.80881959199905396+0.58764183521270752j),
+                         (0.30894950032234192+0.95084899663925171j),
+                         (-0.30895623564720154+0.95086973905563354j),
+                         (-0.80887287855148315+0.58768033981323242j),
+                         (-0.99984413385391235+5.850709250410091e-09j),
+                         (-0.80889981985092163-0.58770018815994263j),
+                         (-0.30897706747055054-0.95093393325805664j),
+                         (0.30898112058639526-0.95094609260559082j),
+                         (0.80893135070800781-0.58772283792495728j),
+                         (0.99990922212600708-8.7766354184282136e-09j),
+                         (0.80894720554351807+0.58773452043533325j),
+                         (0.30899339914321899+0.95098406076431274j),
+                         (-0.30899572372436523+0.95099133253097534j),
+                         (-0.80896598100662231+0.58774799108505249j),
+                         (-0.99994778633117676+1.4628290578855285e-08j),
+                         (-0.80897533893585205-0.58775502443313599j),
+                         (-0.30900305509567261-0.95101380348205566j),
+                         (0.30900448560714722-0.95101797580718994j),
+                         (0.80898630619049072-0.58776277303695679j),
+                         (0.99997037649154663-1.7554345532744264e-08j),
+                         (0.80899184942245483+0.58776694536209106j),
+                         (0.30900871753692627+0.95103120803833008j),
+                         (-0.30900952219963074+0.95103377103805542j),
+                         (-0.8089984655380249+0.58777159452438354j),
+                         (-0.99998390674591064+2.3406109050938539e-08j),
+                         (-0.809001624584198-0.58777409791946411j),
+                         (-0.30901208519935608-0.95104163885116577j),
+                         (0.30901262164115906-0.95104306936264038j),
+                         (0.80900543928146362-0.587776780128479j),
+                         (0.99999171495437622-2.6332081404234486e-08j),
+                         (0.80900734663009644+0.58777821063995361j),
+                         (0.30901408195495605+0.95104765892028809j),
+                         (-0.30901429057121277+0.95104855298995972j),
+                         (-0.80900967121124268+0.58777981996536255j),
+                         (-0.99999648332595825+3.2183805842578295e-08j),
+                         (-0.80901080369949341-0.58778077363967896j),
+                         (-0.30901527404785156-0.95105135440826416j),
+                         (0.30901545286178589-0.95105189085006714j),
+                         (0.80901217460632324-0.58778166770935059j),
+                         (0.99999916553497314-3.5109700036173308e-08j),
+                         (0.809012770652771+0.58778214454650879j),
+                         (0.30901595950126648+0.9510534405708313j),
+                         (-0.30901598930358887+0.95105385780334473j),
+                         (-0.80901366472244263+0.58778274059295654j),
+                         (-1.0000008344650269+4.0961388947380328e-08j),
+                         (-0.8090139627456665-0.58778303861618042j),
+                         (-0.30901634693145752-0.95105475187301636j),
+                         (0.30901640653610229-0.95105493068695068j),
+                         (0.80901449918746948-0.5877833366394043j))
+
+        sampling_freq = 100
+        src1 = gr.sig_source_c (sampling_freq, gr.GR_SIN_WAVE,
+                                sampling_freq * 0.10, 100)
+        dst1 = gr.vector_sink_c ()
+        head = gr.head (gr.sizeof_gr_complex, int (5*sampling_freq * 0.10))
+
+        agc = gr.agc2_cc(1e-2, 1e-3, 1, 1, 1000)
+        
+        fg.connect (src1, head)
+        fg.connect (head, agc)
+        fg.connect (agc, dst1)
+
+        if test_output == True:
+            fg.connect (agc, gr.file_sink(gr.sizeof_gr_complex, "test_agc2_cc.dat"))
+
+        fg.run ()
+        dst_data = dst1.data ()
+        self.assertComplexTuplesAlmostEqual (expected_result, dst_data, 4)
+
+    def test_004(self):
+        ''' Test the floating point AGC loop (attack and decay rate inputs) '''
+        fg = self.fg
+
+        expected_result = \
+            (7.2191943445432116e-07,
+             58.837181091308594,
+             40.194305419921875,
+             2.9183335304260254,
+             0.67606079578399658,
+             8.6260438791896377e-09,
+             -1.4542514085769653,
+             -1.9210131168365479,
+             -1.0450780391693115,
+             -0.61939650774002075,
+             -1.2590258613442984e-08,
+             1.4308931827545166,
+             1.9054338932037354,
+             1.0443156957626343,
+             0.61937344074249268,
+             2.0983527804219193e-08,
+             -1.4308838844299316,
+             -1.9054274559020996,
+             -1.0443152189254761,
+             -0.61937344074249268,
+             -2.5180233009791664e-08,
+             1.4308837652206421,
+             1.9054274559020996,
+             1.0443154573440552,
+             0.61937344074249268,
+             3.3573645197293445e-08,
+             -1.4308838844299316,
+             -1.9054274559020996,
+             -1.0443152189254761,
+             -0.61937350034713745,
+             -3.7770352179222755e-08,
+             1.4308837652206421,
+             1.9054274559020996,
+             1.0443154573440552,
+             0.61937350034713745,
+             4.6163762590367696e-08,
+             -1.4308838844299316,
+             -1.9054274559020996,
+             -1.0443153381347656,
+             -0.61937344074249268,
+             -5.0360466019583328e-08,
+             1.4308837652206421,
+             1.9054274559020996,
+             1.0443155765533447,
+             0.61937344074249268,
+             5.8753879983441948e-08,
+             -1.4308837652206421,
+             -1.9054274559020996,
+             -1.0443153381347656,
+             -0.61937344074249268)
+
+        sampling_freq = 100
+        src1 = gr.sig_source_f (sampling_freq, gr.GR_SIN_WAVE,
+                                sampling_freq * 0.10, 100)
+        dst1 = gr.vector_sink_f ()
+        head = gr.head (gr.sizeof_float, int (5*sampling_freq * 0.10))
+
+        agc = gr.agc2_ff(1e-2, 1e-3, 1, 1, 1000)
+        
+        fg.connect (src1, head)
+        fg.connect (head, agc)
+        fg.connect (agc, dst1)
+
+        if test_output == True:
+            fg.connect (agc, gr.file_sink(gr.sizeof_float, "test_agc2_ff.dat"))
+
+        fg.run ()
+        dst_data = dst1.data ()
+        self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 4)
+
+
+    def test_005(self):
+        ''' Test the complex AGC loop (attack and decay rate inputs) '''
+        fg = self.fg
+
+        expected_result = \
+                        ((100.000244140625+7.2191943445432116e-07j),
+                         (0.80881959199905396+0.58764183521270752j),
+                         (0.30894950032234192+0.95084899663925171j),
+                         (-0.30895623564720154+0.95086973905563354j),
+                         (-0.80887287855148315+0.58768033981323242j),
+                         (-0.99984413385391235+5.850709250410091e-09j),
+                         (-0.80889981985092163-0.58770018815994263j),
+                         (-0.30897706747055054-0.95093393325805664j),
+                         (0.30898112058639526-0.95094609260559082j),
+                         (0.80893135070800781-0.58772283792495728j),
+                         (0.99990922212600708-8.7766354184282136e-09j),
+                         (0.80894720554351807+0.58773452043533325j),
+                         (0.30899339914321899+0.95098406076431274j),
+                         (-0.30899572372436523+0.95099133253097534j),
+                         (-0.80896598100662231+0.58774799108505249j),
+                         (-0.99994778633117676+1.4628290578855285e-08j),
+                         (-0.80897533893585205-0.58775502443313599j),
+                         (-0.30900305509567261-0.95101380348205566j),
+                         (0.30900448560714722-0.95101797580718994j),
+                         (0.80898630619049072-0.58776277303695679j),
+                         (0.99997037649154663-1.7554345532744264e-08j),
+                         (0.80899184942245483+0.58776694536209106j),
+                         (0.30900871753692627+0.95103120803833008j),
+                         (-0.30900952219963074+0.95103377103805542j),
+                         (-0.8089984655380249+0.58777159452438354j),
+                         (-0.99998390674591064+2.3406109050938539e-08j),
+                         (-0.809001624584198-0.58777409791946411j),
+                         (-0.30901208519935608-0.95104163885116577j),
+                         (0.30901262164115906-0.95104306936264038j),
+                         (0.80900543928146362-0.587776780128479j),
+                         (0.99999171495437622-2.6332081404234486e-08j),
+                         (0.80900734663009644+0.58777821063995361j),
+                         (0.30901408195495605+0.95104765892028809j),
+                         (-0.30901429057121277+0.95104855298995972j),
+                         (-0.80900967121124268+0.58777981996536255j),
+                         (-0.99999648332595825+3.2183805842578295e-08j),
+                         (-0.80901080369949341-0.58778077363967896j),
+                         (-0.30901527404785156-0.95105135440826416j),
+                         (0.30901545286178589-0.95105189085006714j),
+                         (0.80901217460632324-0.58778166770935059j),
+                         (0.99999916553497314-3.5109700036173308e-08j),
+                         (0.809012770652771+0.58778214454650879j),
+                         (0.30901595950126648+0.9510534405708313j),
+                         (-0.30901598930358887+0.95105385780334473j),
+                         (-0.80901366472244263+0.58778274059295654j),
+                         (-1.0000008344650269+4.0961388947380328e-08j),
+                         (-0.8090139627456665-0.58778303861618042j),
+                         (-0.30901634693145752-0.95105475187301636j),
+                         (0.30901640653610229-0.95105493068695068j),
+                         (0.80901449918746948-0.5877833366394043j))
+
+        sampling_freq = 100
+        src1 = gr.sig_source_c (sampling_freq, gr.GR_SIN_WAVE,
+                                sampling_freq * 0.10, 100)
+        dst1 = gr.vector_sink_c ()
+        head = gr.head (gr.sizeof_gr_complex, int (5*sampling_freq * 0.10))
+
+        agc = gr.agc2_cc(1e-2, 1e-3, 1, 1, 1000)
+        
+        fg.connect (src1, head)
+        fg.connect (head, agc)
+        fg.connect (agc, dst1)
+
+        if test_output == True:
+            fg.connect (agc, gr.file_sink(gr.sizeof_gr_complex, "test_agc2_cc.dat"))
+
+        fg.run ()
+        dst_data = dst1.data ()
+        self.assertComplexTuplesAlmostEqual (expected_result, dst_data, 4)
+
+
+    def test_100(self):        # FIXME needs work
+        ''' Test complex feedforward agc with constant input '''
+        input_data = 16*(0.0,) + 64*(1.0,) + 64*(0.0,)
+        expected_result = ()
+
+        src = gr.vector_source_c(input_data)
+        agc = gr.feedforward_agc_cc(16, 2.0)
+        dst = gr.vector_sink_c ()
+        self.fg.connect (src, agc, dst)
+
+        if test_output == True:
+            self.fg.connect (agc, gr.file_sink(gr.sizeof_gr_complex, "test_feedforward_cc.dat"))
+
+        self.fg.run ()
+        dst_data = dst.data ()
+        #self.assertComplexTuplesAlmostEqual (expected_result, dst_data, 4)
+
+
+if __name__ == '__main__':
+    gr_unittest.main ()
diff --git a/gnuradio-core/src/python/gnuradio/modulation_utils.py b/gnuradio-core/src/python/gnuradio/modulation_utils.py
new file mode 100644
index 0000000000..a8bd7189f5
--- /dev/null
+++ b/gnuradio-core/src/python/gnuradio/modulation_utils.py
@@ -0,0 +1,81 @@
+#
+# Copyright 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 this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
+"""
+Miscellaneous utilities for managing mods and demods, as well as other items
+useful in dealing with generalized handling of different modulations and demods.
+"""
+
+import inspect
+
+
+# Type 1 modulators accept a stream of bytes on their input and produce complex baseband output
+_type_1_modulators = {}
+
+def type_1_mods():
+    return _type_1_modulators
+
+def add_type_1_mod(name, mod_class):
+    _type_1_modulators[name] = mod_class
+
+
+# Type 1 demodulators accept complex baseband input and produce a stream of bits, packed
+# 1 bit / byte as their output.  Their output is completely unambiguous.  There is no need
+# to resolve phase or polarity ambiguities.
+_type_1_demodulators = {}
+
+def type_1_demods():
+    return _type_1_demodulators
+
+def add_type_1_demod(name, demod_class):
+    _type_1_demodulators[name] = demod_class
+
+
+def extract_kwargs_from_options(function, excluded_args, options):
+    """
+    Given a function, a list of excluded arguments and the result of
+    parsing command line options, create a dictionary of key word
+    arguments suitable for passing to the function.  The dictionary
+    will be populated with key/value pairs where the keys are those
+    that are common to the function's argument list (minus the
+    excluded_args) and the attributes in options.  The values are the
+    corresponding values from options unless that value is None.
+    In that case, the corresponding dictionary entry is not populated.
+
+    (This allows different modulations that have the same parameter
+    names, but different default values to coexist.  The downside is
+    that --help in the option parser will list the default as None,
+    but in that case the default provided in the __init__ argument
+    list will be used since there is no kwargs entry.)
+
+    @param function: the function whose parameter list will be examined
+    @param excluded_args: function arguments that are NOT to be added to the dictionary
+    @type excluded_args: sequence of strings
+    @param options: result of command argument parsing
+    @type options: optparse.Values
+    """
+    # Try this in C++ ;)
+    args, varargs, varkw, defaults = inspect.getargspec(function)
+    d = {}
+    for kw in [a for a in args if a not in excluded_args]:
+        if hasattr(options, kw):
+            if getattr(options, kw) is not None:
+                d[kw] = getattr(options, kw)
+    return d
diff --git a/gnuradio-core/src/python/gnuradio/packet_utils.py b/gnuradio-core/src/python/gnuradio/packet_utils.py
index 7d4871473c..1dab48ab42 100644
--- a/gnuradio-core/src/python/gnuradio/packet_utils.py
+++ b/gnuradio-core/src/python/gnuradio/packet_utils.py
@@ -71,7 +71,8 @@ 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('\xAA\xAA\xAA\xAB')
 
 def is_1_0_string(s):
     if not isinstance(s, str):
@@ -97,16 +98,17 @@ def dewhiten(s):
 def make_header(payload_len):
     return struct.pack('!HH', payload_len, payload_len)
 
-def make_packet(payload, spb, bits_per_baud, access_code=default_access_code, pad_for_usrp=True):
+def make_packet(payload, samples_per_symbol, bits_per_symbol,
+                access_code=default_access_code, pad_for_usrp=True):
     """
     Build a packet, given access code and payload.
 
-    @param payload:       packet payload, len [0, 4096]
-    @param spb:           samples per baud (needed for padding calculation)
-    @type  spb:           int
-    @param bits_per_baud: (needed for padding calculation)
-    @type bits_per_baud:  int
-    @param access_code:   string of ascii 0's and 1's
+    @param payload:               packet payload, len [0, 4096]
+    @param samples_per_symbol:    samples per symbol (needed for padding calculation)
+    @type  samples_per_symbol:    int
+    @param bits_per_symbol:       (needed for padding calculation)
+    @type bits_per_symbol:        int
+    @param access_code:           string of ascii 0's and 1's
     
     Packet will have access code at the beginning, followed by length, payload
     and finally CRC-32.
@@ -115,6 +117,7 @@ def make_packet(payload, spb, bits_per_baud, access_code=default_access_code, pa
         raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
 
     (packed_access_code, padded) = conv_1_0_string_to_packed_binary_string(access_code)
+    (packed_preamble, ignore) = conv_1_0_string_to_packed_binary_string(preamble)
     
     payload_with_crc = gru.gen_and_append_crc32(payload)
     #print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
@@ -124,14 +127,14 @@ def make_packet(payload, spb, bits_per_baud, access_code=default_access_code, pa
     if L > MAXLEN:
         raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
 
-    pkt = ''.join((packed_access_code, make_header(L), whiten(payload_with_crc), '\x55'))
+    pkt = ''.join((packed_preamble, packed_access_code, make_header(L), whiten(payload_with_crc), '\x55'))
     if pad_for_usrp:
-        pkt = pkt + (_npadding_bytes(len(pkt), spb, bits_per_baud) * '\x55')
+        pkt = pkt + (_npadding_bytes(len(pkt), samples_per_symbol, bits_per_symbol) * '\x55')
 
     #print "make_packet: len(pkt) =", len(pkt)
     return pkt
 
-def _npadding_bytes(pkt_byte_len, spb, bits_per_baud):
+def _npadding_bytes(pkt_byte_len, samples_per_symbol, bits_per_symbol):
     """
     Generate sufficient padding such that each packet ultimately ends
     up being a multiple of 512 bytes when sent across the USB.  We
@@ -140,13 +143,13 @@ def _npadding_bytes(pkt_byte_len, spb, bits_per_baud):
     is a multiple of 128 samples.
 
     @param ptk_byte_len: len in bytes of packet, not including padding.
-    @param spb: samples per baud == samples per bit (1 bit / baud with GMSK)
-    @type spb: int
+    @param samples_per_symbol: samples per bit (1 bit / symbolwith GMSK)
+    @type samples_per_symbol: int
 
     @returns number of bytes of padding to append.
     """
     modulus = 128
-    byte_modulus = gru.lcm(modulus/8, spb) * bits_per_baud / spb
+    byte_modulus = gru.lcm(modulus/8, samples_per_symbol) * bits_per_symbol / samples_per_symbol
     r = pkt_byte_len % byte_modulus
     if r == 0:
         return 0