Moved generic psk and qam modulation into gr-digital.

13 files changed, 1233 insertions, 1 deletions

diff --git a/gr-digital/python/Makefile.am b/gr-digital/python/Makefile.am
index 13a3d1157..b1d0d11d8 100644
--- a/gr-digital/python/Makefile.am
+++ b/gr-digital/python/Makefile.am
@@ -38,5 +38,10 @@ digital_PYTHON = \
 	psk.py		\
 	dbpsk.py	\
 	dqpsk.py	\
-	d8psk.py
+	d8psk.py	\
+	psk2.py		\
+	generic_mod_demod.py	\
+	qam.py		\
+	bpsk.py		\
+	qpsk.py
 endif
diff --git a/gr-digital/python/bpsk.py b/gr-digital/python/bpsk.py
new file mode 100644
index 000000000..6d2eb5d6d
--- /dev/null
+++ b/gr-digital/python/bpsk.py
@@ -0,0 +1,98 @@
+#
+# Copyright 2005,2006,2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+"""
+BPSK modulation and demodulation.
+"""
+
+from math import pi, log
+from cmath import exp
+
+from gnuradio import gr, modulation_utils2
+from gnuradio.digital.generic_mod_demod import generic_mod, generic_demod
+
+# Default number of points in constellation.
+_def_constellation_points = 2
+# Whether differential coding is used.
+_def_differential = True
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           BPSK constellation
+# /////////////////////////////////////////////////////////////////////////////
+
+def bpsk_constellation(m=_def_constellation_points):
+    if m != _def_constellation_points:
+        raise ValueError("BPSK can only have 2 constellation points.")
+    return gr.constellation_bpsk()
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           BPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class bpsk_mod(generic_mod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered BPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_mod block for list of parameters.
+	"""
+
+        constellation = gr.constellation_bpsk()
+        if constellation_points != 2:
+            raise ValueError('Number of constellation points must be 2 for BPSK.')
+        super(bpsk_mod, self).__init__(constellation, *args, **kwargs)
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           BPSK demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class bpsk_demod(generic_demod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered BPSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_demod block for list of parameters.
+        """
+
+        constellation = gr.constellation_bpsk()
+        if constellation_points != 2:
+            raise ValueError('Number of constellation points must be 2 for BPSK.')
+        super(bpsk_demod, self).__init__(constellation, *args, **kwargs)
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils2.add_type_1_mod('bpsk', bpsk_mod)
+modulation_utils2.add_type_1_demod('bpsk', bpsk_demod)
+modulation_utils2.add_type_1_constellation('bpsk', bpsk_constellation)
diff --git a/gr-digital/python/generic_mod_demod.py b/gr-digital/python/generic_mod_demod.py
new file mode 100644
index 000000000..4b1819ed7
--- /dev/null
+++ b/gr-digital/python/generic_mod_demod.py
@@ -0,0 +1,395 @@
+#
+# Copyright 2005,2006,2007,2009,2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+# See gnuradio-examples/python/digital for examples
+
+"""
+Generic modulation and demodulation.
+"""
+
+from gnuradio import gr
+from gnuradio.modulation_utils2 import extract_kwargs_from_options_for_class
+from gnuradio.digital.utils import mod_codes
+
+# default values (used in __init__ and add_options)
+_def_samples_per_symbol = 2
+_def_excess_bw = 0.35
+_def_verbose = False
+_def_log = False
+
+# Frequency correction
+_def_freq_alpha = 0.010
+# Symbol timing recovery 
+_def_timing_alpha = 0.100
+_def_timing_beta = 0.010
+_def_timing_max_dev = 1.5
+# Fine frequency / Phase correction
+_def_phase_alpha = 0.1
+# Number of points in constellation
+_def_constellation_points = 16
+# Whether differential coding is used.
+_def_differential = True
+
+def add_common_options(parser):
+    """
+    Sets options common to both modulator and demodulator.
+    """
+    parser.add_option("-p", "--constellation-points", type="int", default=_def_constellation_points,
+                      help="set the number of constellation points (must be a power of 2 (power of 4 for QAM) [default=%default]")
+    parser.add_option("", "--differential", action="store_true", dest="differential", default=True,
+                      help="use differential encoding [default=%default]")
+    parser.add_option("", "--not-differential", action="store_false", dest="differential",
+                      help="do not use differential encoding [default=%default]")
+    parser.add_option("", "--mod-code", type="choice", choices=mod_codes.codes,
+                      default=mod_codes.NO_CODE,
+                      help="Select modulation code from: %s [default=%%default]"
+                            % (', '.join(mod_codes.codes),))
+    parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw,
+                      help="set RRC excess bandwith factor [default=%default]")
+    
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             Generic modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class generic_mod(gr.hier_block2):
+
+    def __init__(self, constellation,
+                 differential=_def_differential,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 excess_bw=_def_excess_bw,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered differential generic modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+        
+	@param constellation: determines the modulation type
+	@type constellation: gnuradio.gr.gr_constellation
+	@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 verbose: Print information about modulator?
+        @type verbose: bool
+        @param log: Log modulation data to files?
+        @type log: bool
+	"""
+
+	gr.hier_block2.__init__(self, "generic_mod",
+				gr.io_signature(1, 1, gr.sizeof_char),       # Input signature
+				gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
+
+        self._constellation = constellation.base()
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._differential = differential
+ 
+        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._constellation.apply_pre_diff_code():
+            self.symbol_mapper = gr.map_bb(self._constellation.pre_diff_code())
+
+        if differential:
+            self.diffenc = gr.diff_encoder_bb(arity)
+
+        self.chunks2symbols = gr.chunks_to_symbols_bc(self._constellation.points())
+
+        # 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
+        blocks = [self, self.bytes2chunks]
+        if self._constellation.apply_pre_diff_code():
+            blocks.append(self.symbol_mapper)
+        if differential:
+            blocks.append(self.diffenc)
+        blocks += [self.chunks2symbols, self.rrc_filter, self]
+        self.connect(*blocks)
+
+        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):   # static method that's also callable on an instance
+        return self._constellation.bits_per_symbol()
+
+    def add_options(parser):
+        """
+        Adds generic modulation options to the standard parser
+        """
+        add_common_options(parser)
+    add_options=staticmethod(add_options)
+
+    def extract_kwargs_from_options(cls, options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return extract_kwargs_from_options_for_class(cls, options)
+    extract_kwargs_from_options=classmethod(extract_kwargs_from_options)
+
+
+    def _print_verbage(self):
+        print "\nModulator:"
+        print "bits per symbol:     %d" % self.bits_per_symbol()
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.connect(self.bytes2chunks,
+                     gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat"))
+        if self._constellation.apply_pre_diff_code():
+            self.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat"))
+        if self._differential:
+            self.connect(self.diffenc,
+                         gr.file_sink(gr.sizeof_char, "tx_diffenc.dat"))
+        self.connect(self.chunks2symbols,
+                     gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat"))
+        self.connect(self.rrc_filter,
+                     gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat"))
+              
+
+# /////////////////////////////////////////////////////////////////////////////
+#                             Generic demodulator
+#
+#      Differentially coherent detection of differentially encoded generically
+#      modulated signal.
+# /////////////////////////////////////////////////////////////////////////////
+
+class generic_demod(gr.hier_block2):
+
+    def __init__(self, constellation,
+                 samples_per_symbol=_def_samples_per_symbol,
+                 differential=_def_differential,
+                 excess_bw=_def_excess_bw,
+                 freq_alpha=_def_freq_alpha,
+                 timing_alpha=_def_timing_alpha,
+                 timing_max_dev=_def_timing_max_dev,
+                 phase_alpha=_def_phase_alpha,
+                 verbose=_def_verbose,
+                 log=_def_log):
+        """
+	Hierarchical block for RRC-filtered differential generic demodulation.
+
+	The input is the complex modulated signal at baseband.
+	The output is a stream of bits packed 1 bit per byte (LSB)
+
+	@param constellation: determines the modulation type
+	@type constellation: gnuradio.gr.gr_constellation
+	@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 freq_alpha: loop filter gain for frequency recovery
+        @type freq_alpha: float
+        @param timing_alpha: loop alpha gain for timing recovery
+        @type timing_alpha: float
+        @param timing_max_dev: timing loop maximum rate deviations
+        @type timing_max_dev: float
+        @param phase_alpha: loop filter gain in phase loop
+        @type phase_alphas: 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, "generic_demod",
+				gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
+				gr.io_signature(1, 1, gr.sizeof_char))       # Output signature
+				
+        self._constellation = constellation.base()
+        self._samples_per_symbol = samples_per_symbol
+        self._excess_bw = excess_bw
+        self._phase_alpha = phase_alpha
+        self._freq_alpha = freq_alpha
+        self._freq_beta = 0.10*self._freq_alpha
+        self._timing_alpha = timing_alpha
+        self._timing_beta = _def_timing_beta
+        self._timing_max_dev=timing_max_dev
+        self._differential = differential
+
+        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)
+
+        arity = pow(2,self.bits_per_symbol())
+
+        # Automatic gain control
+        self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
+
+        # Frequency correction
+        self.freq_recov = gr.fll_band_edge_cc(self._samples_per_symbol, self._excess_bw,
+                                              11*int(self._samples_per_symbol),
+                                              self._freq_alpha, self._freq_beta)
+
+        # symbol timing recovery with RRC data filter
+        nfilts = 32
+        ntaps = 11 * int(self._samples_per_symbol*nfilts)
+        taps = gr.firdes.root_raised_cosine(nfilts, nfilts,
+                                            1.0/float(self._samples_per_symbol),
+                                            self._excess_bw, ntaps)
+        self.time_recov = gr.pfb_clock_sync_ccf(self._samples_per_symbol,
+                                                self._timing_alpha,
+                                                taps, nfilts, nfilts/2, self._timing_max_dev)
+        self.time_recov.set_beta(self._timing_beta)
+
+        #self._phase_beta  = 0.25 * self._phase_alpha * self._phase_alpha
+        self._phase_beta  = 0.25 * self._phase_alpha * self._phase_alpha
+        fmin = -0.25
+        fmax = 0.25
+        
+        self.receiver = gr.constellation_receiver_cb(
+            self._constellation,
+            self._phase_alpha, self._phase_beta,
+            fmin, fmax)
+        
+        # Do differential decoding based on phase change of symbols
+        if differential:
+            self.diffdec = gr.diff_decoder_bb(arity)
+
+        if self._constellation.apply_pre_diff_code():
+            self.symbol_mapper = gr.map_bb(
+                mod_codes.invert_code(self._constellation.pre_diff_code()))
+
+        # 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
+        blocks = [self, self.agc, self.freq_recov, self.time_recov, self.receiver]
+        if differential:
+            blocks.append(self.diffdec)
+        if self._constellation.apply_pre_diff_code():
+            blocks.append(self.symbol_mapper)
+        blocks += [self.unpack, self]
+        self.connect(*blocks)
+
+    def samples_per_symbol(self):
+        return self._samples_per_symbol
+
+    def bits_per_symbol(self):   # staticmethod that's also callable on an instance
+        return self._constellation.bits_per_symbol()
+
+    def _print_verbage(self):
+        print "\nDemodulator:"
+        print "bits per symbol:     %d"   % self.bits_per_symbol()
+        print "RRC roll-off factor: %.2f" % self._excess_bw
+        print "FLL gain:            %.2e" % self._freq_alpha
+        print "Timing alpha gain:   %.2e" % self._timing_alpha
+        print "Timing beta gain:    %.2e" % self._timing_beta
+        print "Timing max dev:      %.2f" % self._timing_max_dev
+        print "Phase track alpha:   %.2e" % self._phase_alpha
+        print "Phase track beta:    %.2e" % self._phase_beta
+
+    def _setup_logging(self):
+        print "Modulation logging turned on."
+        self.connect(self.agc,
+                     gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat"))
+        self.connect((self.freq_recov, 0),
+                     gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov.dat"))
+        self.connect((self.freq_recov, 1),
+                     gr.file_sink(gr.sizeof_float, "rx_freq_recov_freq.dat"))
+        self.connect((self.freq_recov, 2),
+                     gr.file_sink(gr.sizeof_float, "rx_freq_recov_phase.dat"))
+        self.connect((self.freq_recov, 3),
+                     gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov_error.dat"))
+        self.connect((self.time_recov, 0),
+                     gr.file_sink(gr.sizeof_gr_complex, "rx_time_recov.dat"))
+        self.connect((self.time_recov, 1),
+                     gr.file_sink(gr.sizeof_float, "rx_time_recov_error.dat"))
+        self.connect((self.time_recov, 2),
+                     gr.file_sink(gr.sizeof_float, "rx_time_recov_rate.dat"))
+        self.connect((self.time_recov, 3),
+                     gr.file_sink(gr.sizeof_float, "rx_time_recov_phase.dat"))
+        self.connect((self.receiver, 0),
+                     gr.file_sink(gr.sizeof_char, "rx_receiver.dat"))
+        self.connect((self.receiver, 1),
+                     gr.file_sink(gr.sizeof_float, "rx_receiver_error.dat"))
+        self.connect((self.receiver, 2),
+                     gr.file_sink(gr.sizeof_float, "rx_receiver_phase.dat"))
+        self.connect((self.receiver, 3),
+                     gr.file_sink(gr.sizeof_float, "rx_receiver_freq.dat"))
+        if self._differential:
+            self.connect(self.diffdec,
+                         gr.file_sink(gr.sizeof_char, "rx_diffdec.dat"))        
+        if self._constellation.apply_pre_diff_code():
+            self.connect(self.symbol_mapper,
+                         gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat"))        
+        self.connect(self.unpack,
+                     gr.file_sink(gr.sizeof_char, "rx_unpack.dat"))
+        
+    def add_options(parser):
+        """
+        Adds generic demodulation options to the standard parser
+        """
+        # Add options shared with modulator.
+        add_common_options(parser)
+        # Add options specific to demodulator.
+        parser.add_option("", "--freq-alpha", type="float", default=_def_freq_alpha,
+                          help="set frequency lock loop alpha gain value [default=%default]")
+        parser.add_option("", "--phase-alpha", type="float", default=_def_phase_alpha,
+                          help="set phase tracking loop alpha value [default=%default]")
+        parser.add_option("", "--timing-alpha", type="float", default=_def_timing_alpha,
+                          help="set timing symbol sync loop gain alpha value [default=%default]")
+        parser.add_option("", "--timing-beta", type="float", default=_def_timing_beta,
+                          help="set timing symbol sync loop gain beta value [default=%default]")
+        parser.add_option("", "--timing-max-dev", type="float", default=_def_timing_max_dev,
+                          help="set timing symbol sync loop maximum deviation [default=%default]")
+    add_options=staticmethod(add_options)
+    
+    def extract_kwargs_from_options(cls, options):
+        """
+        Given command line options, create dictionary suitable for passing to __init__
+        """
+        return extract_kwargs_from_options_for_class(cls, options)
+    extract_kwargs_from_options=classmethod(extract_kwargs_from_options)
+
diff --git a/gr-digital/python/psk2.py b/gr-digital/python/psk2.py
new file mode 100644
index 000000000..089af11dd
--- /dev/null
+++ b/gr-digital/python/psk2.py
@@ -0,0 +1,121 @@
+#
+# Copyright 2005,2006,2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+"""
+PSK modulation and demodulation.
+"""
+
+from math import pi, log
+from cmath import exp
+
+from gnuradio import gr, modulation_utils2
+from gnuradio.digital.generic_mod_demod import generic_mod, generic_demod
+from gnuradio.digital.utils import mod_codes, gray_code
+
+# Default number of points in constellation.
+_def_constellation_points = 4
+# The default encoding (e.g. gray-code, set-partition)
+_def_mod_code = mod_codes.GRAY_CODE
+
+def create_encodings(mod_code, arity):
+    post_diff_code = None
+    if mod_code not in mod_codes.codes:
+        raise ValueError('That modulation code does not exist.')
+    if mod_code == mod_codes.GRAY_CODE:
+        pre_diff_code = gray_code.gray_code(arity)
+    elif mod_code == mod_codes.SET_PARTITION_CODE:
+        pre_diff_code = set_partition_code.set_partition_code(arity) 
+    elif mod_code == mod_codes.NO_CODE:
+        pre_diff_code = []
+    else:
+        raise ValueError('That modulation code is not implemented for this constellation.')
+    return (pre_diff_code, post_diff_code)
+    
+# /////////////////////////////////////////////////////////////////////////////
+#                           PSK constellation
+# /////////////////////////////////////////////////////////////////////////////
+
+def psk_constellation(m=_def_constellation_points, mod_code=_def_mod_code):
+    """
+    Creates a PSK constellation object.
+    """
+    k = log(m) / log(2.0)
+    if (k != int(k)):
+        raise StandardError('Number of constellation points must be a power of two.')
+    points = [exp(2*pi*(0+1j)*i/m) for i in range(0,m)]
+    pre_diff_code, post_diff_code = create_encodings(mod_code, m)
+    if post_diff_code is not None:
+        inverse_post_diff_code = mod_codes.invert_code(post_diff_code)
+        points = [points[x] for x in inverse_post_diff_code]
+    constellation = gr.constellation_psk(points, pre_diff_code, m)
+    return constellation
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           PSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class psk_mod(generic_mod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 mod_code=_def_mod_code,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered PSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_mod block for list of parameters.
+	"""
+
+        constellation = psk_constellation(constellation_points, mod_code)
+        super(psk_mod, self).__init__(constellation, *args, **kwargs)
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           PSK demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class psk_demod(generic_demod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 mod_code=_def_mod_code,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered PSK modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_demod block for list of parameters.
+        """
+
+        constellation = psk_constellation(constellation_points, mod_code)
+        super(psk_demod, self).__init__(constellation, *args, **kwargs)
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils2.add_type_1_mod('psk', psk_mod)
+modulation_utils2.add_type_1_demod('psk', psk_demod)
+modulation_utils2.add_type_1_constellation('psk', psk_constellation)
diff --git a/gr-digital/python/qam.py b/gr-digital/python/qam.py
new file mode 100644
index 000000000..d22aac55e
--- /dev/null
+++ b/gr-digital/python/qam.py
@@ -0,0 +1,226 @@
+#
+# Copyright 2005,2006,2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+"""
+QAM modulation and demodulation.
+"""
+
+from math import pi, sqrt, log
+
+from gnuradio import gr, modulation_utils2
+from gnuradio.digital.generic_mod_demod import generic_mod, generic_demod
+from gnuradio.digital.utils.gray_code import gray_code
+from gnuradio.digital.utils import mod_codes
+
+# Default number of points in constellation.
+_def_constellation_points = 16
+# Whether the quadrant bits are coded differentially.
+_def_differential = True
+# Whether gray coding is used.  If differential is True then gray
+# coding is used within but not between each quadrant.
+_def_mod_code = mod_codes.NO_CODE
+
+def is_power_of_four(x):
+    v = log(x)/log(4)
+    return int(v) == v
+
+def get_bit(x, n):
+    """ Get the n'th bit of integer x (from little end)."""
+    return (x&(0x01 << n)) >> n
+
+def get_bits(x, n, k):
+    """ Get the k bits of integer x starting at bit n(from little end)."""
+    # Remove the n smallest bits
+    v = x >> n 
+    # Remove all bits bigger than n+k-1
+    return v % pow(2, k)
+
+def make_differential_constellation(m, gray_coded):
+    """
+    Create a constellation with m possible symbols where m must be
+    a power of 4.
+
+    Points are laid out in a square grid.
+
+    Bits referring to the quadrant are differentilly encoded,
+    remaining bits are gray coded.
+
+    """
+    sqrtm = pow(m, 0.5)
+    if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)):
+        raise ValueError("m must be a power of 4 integer.")
+    # Each symbol holds k bits.
+    k = int(log(m) / log(2.0))
+    # First create a constellation for one quadrant containing m/4 points.
+    # The quadrant has 'side' points along each side of a quadrant.
+    side = int(sqrtm/2)
+    if gray_coded:
+        # Number rows and columns using gray codes.
+        gcs = gray_code(side)
+        # Get inverse gray codes.
+        i_gcs = dict([(v, key) for key, v in enumerate(gcs)])
+    else:
+        i_gcs = dict([(i, i) for i in range(0, side)])
+    # The distance between points is found.
+    step = 1/(side-0.5)
+
+    gc_to_x = [(i_gcs[gc]+0.5)*step for gc in range(0, side)]
+
+    # Takes the (x, y) location of the point with the quadrant along
+    # with the quadrant number. (x, y) are integers referring to which
+    # point within the quadrant it is.
+    # A complex number representing this location of this point is returned.
+    def get_c(gc_x, gc_y, quad):
+        if quad == 0:
+            return complex(gc_to_x[gc_x], gc_to_x[gc_y])
+        if quad == 1:
+            return complex(-gc_to_x[gc_y], gc_to_x[gc_x])
+        if quad == 2:
+            return complex(-gc_to_x[gc_x], -gc_to_x[gc_y])
+        if quad == 3:
+            return complex(gc_to_x[gc_y], -gc_to_x[gc_x])
+        raise StandardError("Impossible!")
+
+    # First two bits determine quadrant.
+    # Next (k-2)/2 bits determine x position.
+    # Following (k-2)/2 bits determine y position.
+    # How x and y relate to real and imag depends on quadrant (see get_c function).
+    const_map = []
+    for i in range(m):
+        y = get_bits(i, 0, (k-2)/2)
+        x = get_bits(i, (k-2)/2, (k-2)/2)
+        quad = get_bits(i, k-2, 2)
+        const_map.append(get_c(x, y, quad))
+
+    return const_map
+
+def make_not_differential_constellation(m, gray_coded):
+    side = int(pow(m, 0.5))
+    if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)):
+        raise ValueError("m must be a power of 4 integer.")
+    # Each symbol holds k bits.
+    k = int(log(m) / log(2.0))
+    if gray_coded:
+        # Number rows and columns using gray codes.
+        gcs = gray_code(side)
+        # Get inverse gray codes.
+        i_gcs = mod_codes.invert_code(gcs)
+    else:
+        i_gcs = range(0, side)
+    # The distance between points is found.
+    step = 2.0/(side-1)
+
+    gc_to_x = [-1 + i_gcs[gc]*step for gc in range(0, side)]
+    # First k/2 bits determine x position.
+    # Following k/2 bits determine y position.
+    const_map = []
+    for i in range(m):
+        y = gc_to_x[get_bits(i, 0, k/2)]
+        x = gc_to_x[get_bits(i, k/2, k/2)]
+        const_map.append(complex(x,y))
+    return const_map
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM constellation
+# /////////////////////////////////////////////////////////////////////////////
+
+def qam_constellation(constellation_points=_def_constellation_points,
+                      differential=_def_differential,
+                      mod_code=_def_mod_code):
+    """
+    Creates a QAM constellation object.
+    """
+    if mod_code == mod_codes.GRAY_CODE:
+        gray_coded = True
+    elif mod_code == mod_codes.NO_CODE:
+        gray_coded = False
+    else:
+        raise ValueError("Mod code is not implemented for QAM")
+    if differential:
+        points = make_differential_constellation(constellation_points, gray_coded)
+    else:
+        points = make_not_differential_constellation(constellation_points, gray_coded)
+    side = int(sqrt(constellation_points))
+    width = 2.0/(side-1)
+    # No pre-diff code
+    # Should add one so that we can gray-code the quadrant bits too.
+    pre_diff_code = []
+    constellation = gr.constellation_rect(points, pre_diff_code, 4, side, side, width, width)
+    return constellation
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam_mod(generic_mod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 differential=_def_differential,
+                 mod_code=_def_mod_code,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered QAM modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_mod block for list of parameters.
+	"""
+
+        constellation = qam_constellation(constellation_points, differential, mod_code)
+        # We take care of the gray coding in the constellation generation so it doesn't 
+        # need to be done in the block.
+        super(qam_mod, self).__init__(constellation, differential=differential,
+                                      *args, **kwargs)
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QAM demodulator
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+class qam_demod(generic_demod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 differential=_def_differential,
+                 mod_code=_def_mod_code,
+                 *args, **kwargs):
+
+        """
+	Hierarchical block for RRC-filtered QAM modulation.
+
+	The input is a byte stream (unsigned char) and the
+	output is the complex modulated signal at baseband.
+
+        See generic_demod block for list of parameters.
+        """
+        constellation = qam_constellation(constellation_points, differential, mod_code)
+        # We take care of the gray coding in the constellation generation so it doesn't 
+        # need to be done in the block.
+        super(qam_demod, self).__init__(constellation, differential=differential,
+                                        *args, **kwargs)
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils2.add_type_1_mod('qam', qam_mod)
+modulation_utils2.add_type_1_demod('qam', qam_demod)
+modulation_utils2.add_type_1_constellation('qam', qam_constellation)
diff --git a/gr-digital/python/qpsk.py b/gr-digital/python/qpsk.py
new file mode 100644
index 000000000..ea1724424
--- /dev/null
+++ b/gr-digital/python/qpsk.py
@@ -0,0 +1,79 @@
+#
+# Copyright 2005,2006,2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+"""
+QPSK modulation.
+
+Demodulation is not included since the generic_mod_demod
+doesn't work for non-differential encodings.
+"""
+
+from gnuradio import gr, modulation_utils2
+from gnuradio.digital.generic_mod_demod import generic_mod
+
+
+# Default number of points in constellation.
+_def_constellation_points = 4
+# Whether differential coding is used.
+_def_differential = False
+_def_gray_coded = True
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QPSK constellation
+# /////////////////////////////////////////////////////////////////////////////
+
+def qpsk_constellation(m=_def_constellation_points): 
+    if m != _def_constellation_points:
+        raise ValueError("QPSK can only have 4 constellation points.")
+    return gr.constellation_qpsk()
+
+# /////////////////////////////////////////////////////////////////////////////
+#                           QPSK modulator
+# /////////////////////////////////////////////////////////////////////////////
+
+class qpsk_mod(generic_mod):
+
+    def __init__(self, constellation_points=_def_constellation_points,
+                 differential=_def_differential,
+                 gray_coded=_def_gray_coded,
+                 *args, **kwargs):
+
+        """
+	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.
+
+        See generic_mod block for list of parameters.
+	"""
+
+        constellation = gr.constellation_qpsk()
+        if constellation_points != 4:
+            raise ValueError("QPSK can only have 4 constellation points.")
+        if differential or not gray_coded:
+            raise ValueError("This QPSK mod/demod works only for gray-coded, non-differential.")
+        super(qpsk_mod, self).__init__(constellation, differential, gray_coded, *args, **kwargs)
+
+#
+# Add these to the mod/demod registry
+#
+modulation_utils2.add_type_1_mod('qpsk', qpsk_mod)
+modulation_utils2.add_type_1_constellation('qpsk', qpsk_constellation)
diff --git a/gr-digital/python/utils/.gitignore b/gr-digital/python/utils/.gitignore
new file mode 100644
index 000000000..60c81fdce
--- /dev/null
+++ b/gr-digital/python/utils/.gitignore
@@ -0,0 +1,3 @@
+run_tests
+Makefile
+Makefile.in
diff --git a/gr-digital/python/utils/Makefile.am b/gr-digital/python/utils/Makefile.am
new file mode 100644
index 000000000..c35951b44
--- /dev/null
+++ b/gr-digital/python/utils/Makefile.am
@@ -0,0 +1,35 @@
+#
+# Copyright 2007,2009 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+include $(top_srcdir)/Makefile.common
+
+if PYTHON
+utilspythondir = $(grpythondir)/utils
+
+TESTS = 				\
+	run_tests
+
+nobase_utilspython_PYTHON = \
+	__init__.py \
+	gray_code.py \
+	mod_codes.py \
+	alignment.py
+endif
\ No newline at end of file
diff --git a/gr-digital/python/utils/__init__.py b/gr-digital/python/utils/__init__.py
new file mode 100644
index 000000000..b3e997f9f
--- /dev/null
+++ b/gr-digital/python/utils/__init__.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+#
+# Copyright 2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
diff --git a/gr-digital/python/utils/alignment.py b/gr-digital/python/utils/alignment.py
new file mode 100644
index 000000000..d32365866
--- /dev/null
+++ b/gr-digital/python/utils/alignment.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+#
+# Copyright 2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+"""
+This module contains functions for aligning sequences.
+
+>>> import random
+>>> random.seed(1234)
+>>> ran_seq = [random.randint(0,1) for i in range(0, 100)]
+>>> offset_seq = [0] * 20 + ran_seq
+>>> correct, overlap, offset = align_sequences(ran_seq, offset_seq)
+>>> print(correct, overlap, offset)
+(1.0, 100, -20)
+>>> offset_err_seq = []
+>>> for bit in offset_seq:
+...     if random.randint(0,4) == 4:
+...         offset_err_seq.append(random.randint(0,1))
+...     else:
+...         offset_err_seq.append(bit)
+>>> correct, overlap, offset = align_sequences(ran_seq, offset_err_seq)
+>>> print(overlap, offset)
+(100, -20)
+
+"""
+
+import random
+
+# DEFAULT PARAMETERS
+# If the fraction of matching bits between two sequences is greater than
+# this the sequences are assumed to be aligned.
+def_correct_cutoff = 0.9
+# The maximum offset to test during sequence alignment.
+def_max_offset = 500
+# The maximum number of samples to take from two sequences to check alignment.
+def_num_samples = 1000
+
+def compare_sequences(d1, d2, offset, sample_indices=None):
+    """
+    Takes two binary sequences and an offset and returns the number of
+    matching entries and the number of compared entries.
+    d1 & d2 -- sequences
+    offset -- offset of d2 relative to d1
+    sample_indices -- a list of indices to use for the comparison
+    """
+    max_index = min(len(d1), len(d2)+offset)
+    if sample_indices is None:
+        sample_indices = range(0, max_index)
+    correct = 0
+    total = 0
+    for i in sample_indices:
+        if i >= max_index:
+            break
+        if d1[i] == d2[i-offset]:
+            correct += 1
+        total += 1
+    return (correct, total)
+
+def random_sample(size, num_samples=def_num_samples, seed=None):
+    """
+    Returns a set of random integers between 0 and (size-1).
+    The set contains no more than num_samples integers.
+    """
+    random.seed(seed)
+    if num_samples > size:
+        indices = set(range(0, size))
+    else:
+        if num_samples > size/2:
+            num_samples = num_samples/2
+        indices = set([])
+        while len(indices) < num_samples:
+            index = random.randint(0, size-1)
+            indices.add(index)
+    indices = list(indices)
+    indices.sort()
+    return indices
+
+def align_sequences(d1, d2,
+                    num_samples=def_num_samples,
+                    max_offset=def_max_offset,
+                    correct_cutoff=def_correct_cutoff,
+                    seed=None,
+                    indices=None):
+    """
+    Takes two sequences and finds the offset and which the two sequences best
+    match.  It returns the fraction correct, the number of entries compared,
+    the offset.
+    d1 & d2 -- sequences to compare
+    num_samples -- the maximum number of entries to compare
+    max_offset -- the maximum offset between the sequences that is checked
+    correct_cutoff -- If the fraction of bits correct is greater than this then
+                      the offset is assumed to optimum.
+    seed -- a random number seed
+    indices -- an explicit list of the indices used to compare the two sequences
+    """
+    max_overlap = max(len(d1), len(d2))
+    if indices is None:
+        indices = random_sample(max_overlap, num_samples, seed)
+    max_frac_correct = 0
+    best_offset = None
+    best_compared = None
+    best_correct = None
+    pos_range = range(0, min(len(d1), max_offset))
+    neg_range = range(-1, -min(len(d2), max_offset), -1)
+    # Interleave the positive and negative offsets.
+    int_range = [item for items in zip(pos_range, neg_range) for item in items]
+    for offset in int_range:
+        correct, compared = compare_sequences(d1, d2, offset, indices)
+        frac_correct = 1.0*correct/compared
+        if frac_correct > max_frac_correct:
+            max_frac_correct = frac_correct
+            best_offset = offset
+            best_compared = compared
+            best_correct = correct
+            if frac_correct > correct_cutoff:
+                break
+    return max_frac_correct, best_compared, best_offset, indices
+    
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
+    
diff --git a/gr-digital/python/utils/gray_code.py b/gr-digital/python/utils/gray_code.py
new file mode 100644
index 000000000..926a1ded1
--- /dev/null
+++ b/gr-digital/python/utils/gray_code.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+#
+# Copyright 2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+class GrayCodeGenerator(object):
+    """
+    Generates and caches gray codes.
+    """
+
+    def __init__(self):
+        self.gcs = [0, 1]
+        # The last power of two passed through.
+        self.lp2 = 2
+        # The next power of two that will be passed through.
+        self.np2 = 4
+        # Curent index
+        self.i = 2
+
+    def get_gray_code(self, length):
+        """
+        Returns a list of gray code of given length.
+        """
+        if len(self.gcs) < length:
+            self.generate_new_gray_code(length)
+        return self.gcs[:length]
+    
+    def generate_new_gray_code(self, length):
+        """
+        Generates new gray code and places into cache.
+        """
+        while len(self.gcs) < length:
+            if self.i == self.lp2:
+                # if i is a power of two then gray number is of form 1100000...
+                result = self.i + self.i/2
+            else:
+                # if not we take advantage of the symmetry of all but the last bit
+                # around a power of two.
+                result = self.gcs[2*self.lp2-1-self.i] + self.lp2
+            self.gcs.append(result)
+            self.i += 1
+            if self.i == self.np2:
+                self.lp2 = self.i
+                self.np2 = self.i*2
+
+_gray_code_generator = GrayCodeGenerator()
+
+gray_code = _gray_code_generator.get_gray_code
+
diff --git a/gr-digital/python/utils/mod_codes.py b/gr-digital/python/utils/mod_codes.py
new file mode 100644
index 000000000..caacda5cc
--- /dev/null
+++ b/gr-digital/python/utils/mod_codes.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+#
+# Copyright 2011 Free Software Foundation, Inc.
+# 
+# This file is part of GNU Radio
+# 
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+GRAY_CODE = 'gray'
+SET_PARTITION_CODE = 'set-partition'
+NO_CODE = 'none'
+
+codes = (GRAY_CODE, SET_PARTITION_CODE, NO_CODE)
+
+def invert_code(code):
+    c = enumerate(code)
+    ic = [(b, a) for (a, b) in c]
+    ic.sort()
+    return [a for (b, a) in ic]
diff --git a/gr-digital/python/utils/run_tests.in b/gr-digital/python/utils/run_tests.in
new file mode 100644
index 000000000..adcbdfd21
--- /dev/null
+++ b/gr-digital/python/utils/run_tests.in
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+# 1st parameter is absolute path to component source directory
+# 2nd parameter is absolute path to component build directory
+# 3rd parameter is path to Python QA directory
+
+# Note: calling master run_tests.sh in gnuradio core is not strictly
+# correct, as it will result in a partially bogus PYTHONPATH, but it
+# does make the correct paths in the second half so all is well.
+
+# Nothing in here at the moment.