commit-gnuradio
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Commit-gnuradio] r3541 - in gnuradio/branches/developers/trondeau/wip2:


From: trondeau
Subject: [Commit-gnuradio] r3541 - in gnuradio/branches/developers/trondeau/wip2: gnuradio-core/src/lib/general gnuradio-core/src/python/gnuradio/blksimpl gnuradio-examples/python/gmsk2 gnuradio-examples/python/usrp
Date: Thu, 14 Sep 2006 10:43:40 -0600 (MDT)

Author: trondeau
Date: 2006-09-14 10:43:40 -0600 (Thu, 14 Sep 2006)
New Revision: 3541

Modified:
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
   
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
Log:
more formatting of digital mod; adding debug info; trying to keep consistency 
between files (need more checking on this); have Costas loop output its 
frequency (normalized) on output 2 into flowgraph

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
       2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
       2006-09-14 16:43:40 UTC (rev 3541)
@@ -49,7 +49,7 @@
                                      ) throw (std::invalid_argument)
   : gr_sync_block ("costas_loop_cc",
                   gr_make_io_signature (1, 1, sizeof (gr_complex)),
-                  gr_make_io_signature (1, 1, sizeof (gr_complex))),
+                  gr_make_io_signature (1, 2, sizeof (gr_complex))),
     d_alpha(alpha), d_beta(beta), 
     d_max_freq(max_freq), d_min_freq(min_freq),
     d_phase(0), d_freq((max_freq+min_freq)/2),
@@ -92,6 +92,7 @@
 {
   const gr_complex *iptr = (gr_complex *) input_items[0];
   gr_complex *optr = (gr_complex *) output_items[0];
+  gr_complex *foptr = (gr_complex*)output_items[1];
 
   float error;
   gr_complex nco_out;
@@ -104,15 +105,20 @@
     
     d_freq = d_freq + d_beta * error;
     d_phase = d_phase + d_freq + d_alpha * error;
+
     while(d_phase>M_TWOPI)
       d_phase -= M_TWOPI;
     while(d_phase<-M_TWOPI)
       d_phase += M_TWOPI;
     
-     if (d_freq > d_max_freq)
+    if (d_freq > d_max_freq)
       d_freq = d_max_freq;
     else if (d_freq < d_min_freq)
       d_freq = d_min_freq;
+    
+    //    fprintf(stderr, "Costas frequency = %f\terror = %f\n", d_freq, 
error);
+    // d_freq_out << d_freq << std::endl;
+    foptr[i] = gr_complex(d_freq,0);
   }
   return noutput_items;
 }

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
        2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
        2006-09-14 16:43:40 UTC (rev 3541)
@@ -26,6 +26,7 @@
 
 #include <gr_sync_block.h>
 #include <stdexcept>
+#include <fstream>
 
 class gr_costas_loop_cc;
 typedef boost::shared_ptr<gr_costas_loop_cc> gr_costas_loop_cc_sptr;

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
       2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
       2006-09-14 16:43:40 UTC (rev 3541)
@@ -58,44 +58,42 @@
         @param debug: Print modualtion data to files?
         @type debug: bool
        """
+        self.fg = fg
+        self.spb = spb
+        self.excess_bw = excess_bw
+        
         if not isinstance(spb, int) or spb < 2:
             raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
-        self.spb = spb
 
        ntaps = 11 * spb
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
+        arity = pow(2,self.bits_per_baud())
 
         # turn bytes into k-bit vectors
         self.bytes2chunks = \
-          gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+          gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
 
         self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
 
         # pulse shaping filter
        self.rrc_taps = gr.firdes.root_raised_cosine(
-               spb,            # gain  (spb since we're interpolating by spb)
+               spb,            # gain  (spb since we're interpolating by spb)
                spb,            # sampling rate
                1.0,            # symbol rate
-               excess_bw,      # excess bandwidth (roll-off factor)
+               self.excess_bw, # excess bandwidth (roll-off factor)
                 ntaps)
-
        self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
 
-       # Connect
-        fg.connect(self.bytes2chunks, self.chunks2symbols, self.rrc_filter)
-
         if verbose:
-            print "bits_per_symbol =", bits_per_symbol
+            self.verbose()
            
         if debug:
-            fg.connect(self.rrc_filter,
-                       gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
-            
-       # Initialize base class
-       gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+            self.debug()
 
+       # Connect and Initialize base class
+        self.fg.connect(self.bytes2chunks, self.chunks2symbols, 
self.rrc_filter)
+       gr.hier_block.__init__(self, self.fg, self.bytes2chunks, 
self.rrc_filter)
+
     def samples_per_baud(self):
         return self.spb
 
@@ -103,6 +101,19 @@
         return 1
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d" % self.bits_per_baud()
+        print "RRC roll-off factor = %.2f" % self.excess_bw
+
+    def debug(self):
+        print "Modulation debugging turned on."
+        self.fg.connect(self.bytes2chunks,
+                        gr.file_sink(gr.sizeof_char, "bytes2chunks.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.dat"))
+
     def arguments(self=None):
         args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True, 
'debug':False}
         return args
@@ -112,15 +123,20 @@
         """
         Adds modulation-specific options to the standard parser
         """
-        parser.add_option("", "--excess-bw", type="float", default=0.3,
-                          help="set RRC excess bandwith factor 
[default=%default]")
-        parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
-                          help="Don't use gray coding on modulated bits 
[default=%default]")
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+        except OptionConflictError:
+            pass
     add_options=staticmethod(add_options)
 
 
 class bpsk_demod__coherent_detection_of_psk(gr.hier_block):
-    def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+    def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005, 
gain_mu=0.05, mu=0.5,
+                 gray_code=True, verbose=True, debug=False):
         """
        Hierarchical block for RRC-filtered BPSK demodulation
 
@@ -137,14 +153,24 @@
         @type costas_alphas: float
         @param gain_mu:
         @type gain_mu: 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.spb = spb
+        self.excess_bw = excess_bw
+        self.costas_alpha = costas_alpha
+        self.gain_mu = gain_mu
+
         if spb < 2:
             raise TypeError, "sbp must be >= 2"
-        self.spb = spb
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
-        print "bits_per_symbol =", bits_per_symbol
+        arity = pow(2,self.bits_per_baud())
 
         # Automatic gain control
         self.preamp = gr.multiply_const_cc(10e-5)
@@ -153,9 +179,9 @@
         # Costas loop (carrier tracking)
         # FIXME: need to decide how to handle this more generally; do we pull 
it from higher layer?
         costas_order = 2
-        costas_alpha *= 15   # 2nd order loop needs more gain
+        self.costas_alpha *= 15   # 2nd order loop needs more gain
         beta = .25 * costas_alpha * costas_alpha
-        self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05, 
costas_order)
+        self.costas_loop = gr.costas_loop_cc(self.costas_alpha, beta, 0.05, 
-0.05, costas_order)
 
         # RRC data filter
         ntaps = 11 * spb
@@ -163,7 +189,7 @@
             1.0,                # gain 
             spb,                # sampling rate
             1.0,                # symbol rate
-            excess_bw,          # excess bandwidth (roll-off factor)
+            self.excess_bw,     # excess bandwidth (roll-off factor)
             ntaps)
 
         self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
@@ -173,42 +199,32 @@
         gain_omega = .25 * gain_mu * gain_mu
         omega_rel_limit = 0.5
         mu = 0.05
-        gain_mu = 0.1
+        self.gain_mu = 0.1
         self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
-                                                    mu, gain_mu, 
omega_rel_limit)
+                                                    mu, self.gain_mu, 
omega_rel_limit)
 
         # find closest constellation point
         #rot = .707 + .707j
         rot = 1
-        rotated_const = map(lambda pt: pt * rot, constellation[arity])
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
         print "rotated_const =", rotated_const
 
         self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
-        self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+        self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
         
         # unpack the k bit vector into a stream of bits
-        self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
 
-        fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter, 
self.clock_recovery,
-                   self.slicer, self.gray_decoder, self.unpack)
-        
-        # Debug sinks
-        if 1:
-            fg.connect(self.agc,
-                       gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
-            fg.connect(self.costas_loop,
-                       gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
-            fg.connect(self.rrc_filter,
-                       gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
-            fg.connect(self.clock_recovery,
-                       gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.dat"))
-            fg.connect(self.slicer,
-                       gr.file_sink(gr.sizeof_char, "slicer.dat"))
-            fg.connect(self.unpack,
-                       gr.file_sink(gr.sizeof_char, "unpack.dat"))
+        if verbose:
+            self.verbose()
+           
+        if debug:
+            self.debug()
 
-        # Initialize base class
-        gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
+        # Connect and Initialize base class
+        self.fg.connect(self.preamp, self.agc, self.costas_loop, 
self.rrc_filter, \
+                        self.clock_recovery, self.slicer, self.gray_decoder, 
self.unpack)
+        gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
 
     def samples_per_baud(self):
         return self.spb
@@ -217,6 +233,54 @@
         return 1
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d"         % self.bits_per_baud()
+        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
 
+    def debug(self):
+        print "Modulation debugging turned on."
+        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.rrc_filter,
+                        gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+        self.fg.connect(self.clock_recovery,
+                        gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.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 arguments(self=None):
+        args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005, 
'gain_mu':0.05, 'mu':0.5,
+                'gray_code':True, 'verbose':True, 'debug':False}
+        return args
+    arguments = staticmethod(arguments)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+            parser.add_option("", "--costas-alpha", type="float", 
default=0.005,
+                              help="set Costas loop alpha value 
[default=%default]")
+            parser.add_option("", "--gain-mu", type="float", default=0.05,
+                              help="set M&M symbol sync loop gain mu value 
[default=%default]")
+            parser.add_option("", "--mu", type="float", default=0.5,
+                              help="set M&M symbol sync loop mu value 
[default=%default]")
+        except OptionConflictError:
+            pass
+    add_options=staticmethod(add_options)
+    
 bpsk_demod = bpsk_demod__coherent_detection_of_psk
 

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
      2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
      2006-09-14 16:43:40 UTC (rev 3541)
@@ -59,19 +59,20 @@
         @type debug: bool
        """
 
-        if not isinstance(spb, int) or spb < 2:
-            raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
+        self.fg = fg
         self.spb = spb
+        self.excess_bw = excess_bw
+
+        if not isinstance(self.spb, int) or self.spb < 2:
+            raise TypeError, ("sbp must be an integer >= 2, is %d" % self.spb)
         
-       ntaps = 11 * spb
+       ntaps = 11 * self.spb
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
-        self.bits_per_symbol = bits_per_symbol
+        arity = pow(2,self.bits_per_baud())
        
         # turn bytes into k-bit vectors
         self.bytes2chunks = \
-          gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+          gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
 
         if gray_code:
             self.gray_coder = gr.map_bb(psk.binary_to_gray[arity])
@@ -84,29 +85,26 @@
 
         # pulse shaping filter
        self.rrc_taps = gr.firdes.root_raised_cosine(
-               spb,            # gain  (spb since we're interpolating by spb)
-               spb,            # sampling rate
-               1.0,            # symbol rate
-               excess_bw,      # excess bandwidth (roll-off factor)
+               self.spb,        # gain  (spb since we're interpolating by spb)
+               self.spb,        # sampling rate
+               1.0,             # symbol rate
+               self.excess_bw,  # excess bandwidth (roll-off factor)
                 ntaps)
 
-       self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
+       self.rrc_filter = gr.interp_fir_filter_ccf(self.spb, self.rrc_taps)
 
        # Connect
         fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
                    self.chunks2symbols, self.rrc_filter)
 
         if verbose:
-            print "bits_per_symbol =", bits_per_symbol
-         
+            self.verbose()
+            
         if debug:
-            fg.connect(self.gray_coder,
-                       gr.file_sink(gr.sizeof_char, "graycoder.dat"))
-            fg.connect(self.diffenc,
-                       gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+            self.debug()
             
        # Initialize base class
-       gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+       gr.hier_block.__init__(self, self.fg, self.bytes2chunks, 
self.rrc_filter)
 
     def samples_per_baud(self):
         return self.spb
@@ -115,6 +113,23 @@
         return 1
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d" % self.bits_per_baud()
+        print "RRC roll-off factor = %.2f" % self.excess_bw
+
+    def debug(self):
+        print "Modulation debugging turned on."
+        self.fg.connect(self.bytes2chunks,
+                        gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self.fg.connect(self.gray_coder,
+                        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 arguments(self=None):
         args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True, 
'debug':False}
         return args
@@ -124,15 +139,20 @@
         """
         Adds modulation-specific options to the standard parser
         """
-        parser.add_option("", "--excess-bw", type="float", default=0.3,
-                          help="set RRC excess bandwith factor 
[default=%default]")
-        parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
-                          help="Don't use gray coding on modulated bits 
[default=%default]")
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+        except OptionConflictError:
+            pass
     add_options=staticmethod(add_options)
 
 
 class 
dbpsk_demod__coherent_detection_of_differentially_encoded_psk(gr.hier_block):
-    def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+    def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005, 
gain_mu=0.05, mu=0.5,
+                 gray_code=True, verbose=True, debug=False):
         """
        Hierarchical block for RRC-filtered BPSK demodulation
 
@@ -149,14 +169,24 @@
         @type costas_alphas: float
         @param gain_mu:
         @type gain_mu: 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.spb = spb
+        self.excess_bw = excess_bw
+        self.costas_alpha = costas_alpha
+        self.gain_mu = gain_mu
+        
         if spb < 2:
-            raise TypeError, "sbp must be >= 2"
-        self.spb = spb
+            raise TypeError, "sbp must be >= 2, is %d" % sbp
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
-        print "bits_per_symbol =", bits_per_symbol
+        arity = pow(2,self.bits_per_baud())
 
         # Automatic gain control
         self.preamp = gr.multiply_const_cc(10e-5)
@@ -165,72 +195,58 @@
         # Costas loop (carrier tracking)
         # FIXME: need to decide how to handle this more generally; do we pull 
it from higher layer?
         costas_order = 2
-        costas_alpha *= 15   # 2nd order loop needs more gain
+        self.costas_alpha *= 15   # 2nd order loop needs more gain
         beta = .25 * costas_alpha * costas_alpha
-        self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05, 
costas_order)
+        self.costas_loop = gr.costas_loop_cc(self.costas_alpha, beta, 0.5, 
-0.5, costas_order)
 
         # RRC data filter
-        ntaps = 11 * spb
+        ntaps = 11 * self.spb
         self.rrc_taps = gr.firdes.root_raised_cosine(
             1.0,                # gain 
             spb,                # sampling rate
             1.0,                # symbol rate
-            excess_bw,          # excess bandwidth (roll-off factor)
+            self.excess_bw,     # excess bandwidth (roll-off factor)
             ntaps)
 
         self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
 
         # symbol clock recovery
         omega = spb
-        gain_omega = .25 * gain_mu * gain_mu
+        gain_omega = .25 * self.gain_mu * self.gain_mu
         omega_rel_limit = 0.5
         mu = 0.05
-        gain_mu = 0.1
         self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
-                                                    mu, gain_mu, 
omega_rel_limit)
+                                                    mu, self.gain_mu,
+                                                    omega_rel_limit)
 
         # find closest constellation point
         #rot = .707 + .707j
         rot = 1
-        rotated_const = map(lambda pt: pt * rot, constellation[arity])
+        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))
-        self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+        self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
         
         # unpack the k bit vector into a stream of bits
-        self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
 
-        fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter, 
self.clock_recovery,
-                   self.diffdec, self.slicer, self.gray_decoder, self.unpack)
-        #fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter, 
self.clock_recovery,
+        if verbose:
+            self.verbose()
+
+        if debug:
+            self.debug()
+
+        # Connect and Initialize base class
+        self.fg.connect(self.preamp, self.agc, self.costas_loop, 
self.rrc_filter, self.clock_recovery,
+                        self.diffdec, self.slicer, self.gray_decoder, 
self.unpack)
+        #self.fg.connect(self.preamp, self.agc, self.costas_loop, 
self.rrc_filter, self.clock_recovery,
         #           self.slicer, self.diffdec, self.gray_decoder, self.unpack)
-        
-        # Debug sinks
-        if 1:
-            fg.connect(self.agc,
-                       gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
-            fg.connect(self.costas_loop,
-                       gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
-            fg.connect(self.rrc_filter,
-                       gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
-            fg.connect(self.clock_recovery,
-                       gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.dat"))
-            fg.connect(self.slicer,
-                       gr.file_sink(gr.sizeof_char, "slicer.dat"))
-            fg.connect(self.diffdec,
-                       gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
-            #fg.connect(self.diffdec,
-            #          gr.file_sink(gr.sizeof_char, "diffdec.dat"))
-            fg.connect(self.unpack,
-                       gr.file_sink(gr.sizeof_char, "unpack.dat"))
+        gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
 
-        # Initialize base class
-        gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
-
     def samples_per_baud(self):
         return self.spb
 
@@ -238,6 +254,59 @@
         return 1
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d"         % self.bits_per_baud()
+        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
 
+    def debug(self):
+        print "Modulation debugging turned on."
+        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.rrc_filter,
+                        gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+        self.fg.connect(self.clock_recovery,
+                        gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.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"))
+        self.fg.connect((self.costas_loop,1),
+                        gr.file_sink(gr.sizeof_gr_complex, "costas.dat"))
+        
+
+    def arguments(self=None):
+        args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005, 
'gain_mu':0.05, 'mu':0.5,
+                'gray_code':True, 'verbose':True, 'debug':False}
+        return args
+    arguments = staticmethod(arguments)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+            parser.add_option("", "--costas-alpha", type="float", 
default=0.005,
+                              help="set Costas loop alpha value 
[default=%default]")
+            parser.add_option("", "--gain-mu", type="float", default=0.05,
+                              help="set M&M symbol sync loop gain mu value 
[default=%default]")
+            parser.add_option("", "--mu", type="float", default=0.5,
+                              help="set M&M symbol sync loop mu value 
[default=%default]")
+        except OptionConflictError:
+            pass
+    add_options=staticmethod(add_options)
+    
 dbpsk_demod = dbpsk_demod__coherent_detection_of_differentially_encoded_psk
 

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
      2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
      2006-09-14 16:43:40 UTC (rev 3541)
@@ -58,19 +58,21 @@
         @param debug: Print modualtion data to files?
         @type debug: bool
        """
-        
+
+        self.fg = fg
+        self.spb = spb
+        self.excess_bw = excess_bw        
+
         if not isinstance(spb, int) or spb < 2:
             raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
-        self.spb = spb
 
        ntaps = 11 * spb
+ 
+        arity = pow(2,self.bits_per_baud())
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
-
         # turn bytes into k-bit vectors
         self.bytes2chunks = \
-          gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+          gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
 
         if gray_code:
             self.gray_coder = gr.map_bb(psk.binary_to_gray[arity])
@@ -91,21 +93,16 @@
 
        self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
 
-       # Connect
-        fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
-                   self.chunks2symbols, self.rrc_filter)
-
         if verbose:
-            print "bits_per_symbol =", bits_per_symbol
+            self.verbose()
         
         if debug:
-            fg.connect(self.gray_coder,
-                       gr.file_sink(gr.sizeof_char, "graycoder.dat"))
-            fg.connect(self.diffenc,
-                       gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+            self.debug()
             
-       # Initialize base class
-       gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+       # Connect & Initialize base class
+        self.fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
+                        self.chunks2symbols, self.rrc_filter)
+       gr.hier_block.__init__(self, self.fg, self.bytes2chunks, 
self.rrc_filter)
 
     def samples_per_baud(self):
         return self.spb
@@ -114,6 +111,23 @@
         return 2
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d" % self.bits_per_baud()
+        print "RRS roll-off factor = %f" % self.excess_bw
+
+    def debug(self):
+        print "Modulation debugging turned on."
+        self.fg.connect(self.bytes2chunks,
+                        gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+        self.fg.connect(self.gray_coder,
+                        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 arguments(self=None):
         args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True, 
'debug':False}
         return args
@@ -123,15 +137,20 @@
         """
         Adds modulation-specific options to the standard parser
         """
-        parser.add_option("", "--excess-bw", type="float", default=0.3,
-                          help="set RRC excess bandwith factor 
[default=%default]")
-        parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
-                          help="Don't use gray coding on modulated bits 
[default=%default]")
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+        except OptionConflictError:
+            pass
     add_options=staticmethod(add_options)
 
 
 class 
dqpsk_demod__coherent_detection_of_differentially_encoded_psk(gr.hier_block):
-    def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+    def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005, 
gain_mu=0.05, mu=0.5,
+                 gray_code=True, verbose=True, debug=False):
         """
        Hierarchical block for RRC-filtered QPSK demodulation
 
@@ -148,15 +167,25 @@
         @type costas_alphas: float
         @param gain_mu:
         @type gain_mu: 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
        """
-        if spb < 2:
-            raise TypeError, "sbp must be >= 2"
+
+        self.fg = fg
         self.spb = spb
+        self.excess_bw = excess_bw
+        self.costas_alpha = costas_alpha
+        self.gain_mu = gain_mu
 
-        bits_per_symbol = self.bits_per_baud()
-        arity = pow(2,bits_per_symbol)
-        print "bits_per_symbol =", bits_per_symbol
+        if spb < 2:
+            raise TypeError, "sbp must be >= 2, is %d" % spb
 
+        arity = pow(2,self.bits_per_baud())
+ 
         # Automatic gain control
         self.preamp = gr.multiply_const_cc(10e-5)
         self.agc = gr.agc_cc(1e-3, 1, 1)
@@ -164,8 +193,8 @@
         # 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 * costas_alpha * costas_alpha
-        self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05, 
costas_order)
+        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)
 
         # RRC data filter
         ntaps = 11 * spb
@@ -185,50 +214,37 @@
         mu = 0.05
         gain_mu = 0.1
         self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
-                                                    mu, gain_mu, 
omega_rel_limit)
+                                                    mu, self.gain_mu,
+                                                    omega_rel_limit)
 
         # find closest constellation point
         #rot = .707 + .707j
         rot = 1
-        rotated_const = map(lambda pt: pt * rot, constellation[arity])
-        print "rotated_const =", rotated_const
+        rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+        print "rotated_const = %s" % 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))
-        self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+        self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
         
         # unpack the k bit vector into a stream of bits
-        self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+        self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
 
-        fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter, 
self.clock_recovery,
-                   self.diffdec, self.slicer, self.gray_decoder, self.unpack)
-        #fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter, 
self.clock_recovery,
+        if verbose:
+            self.verbose()
+        
+        if debug:
+            self.debug()
+ 
+        # Connect & Initialize base class
+        self.fg.connect(self.preamp, self.agc, self.costas_loop, 
self.rrc_filter, self.clock_recovery,
+                        self.diffdec, self.slicer, self.gray_decoder, 
self.unpack)
+        #self.fg.connect(self.preamp, self.agc, self.costas_loop, 
self.rrc_filter, self.clock_recovery,
         #           self.slicer, self.diffdec, self.gray_decoder, self.unpack)
-        
-        # Debug sinks
-        if 1:
-            fg.connect(self.agc,
-                       gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
-            fg.connect(self.costas_loop,
-                       gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
-            fg.connect(self.rrc_filter,
-                       gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
-            fg.connect(self.clock_recovery,
-                       gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.dat"))
-            fg.connect(self.slicer,
-                       gr.file_sink(gr.sizeof_char, "slicer.dat"))
-            fg.connect(self.diffdec,
-                       gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
-            #fg.connect(self.diffdec,
-            #          gr.file_sink(gr.sizeof_char, "diffdec.dat"))
-            fg.connect(self.unpack,
-                       gr.file_sink(gr.sizeof_char, "unpack.dat"))
+        gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
 
-        # Initialize base class
-        gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
-
     def samples_per_baud(self):
         return self.spb
 
@@ -236,6 +252,58 @@
         return 2
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d"         % self.bits_per_baud()
+        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
 
+    def debug(self):
+        print "Modulation debugging turned on."
+        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.rrc_filter,
+                        gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+        self.fg.connect(self.clock_recovery,
+                        gr.file_sink(gr.sizeof_gr_complex, 
"clock_recovery.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"))
+        self.fg.connect((self.costas_loop,1),
+                        gr.file_sink(gr.sizeof_gr_complex, "costas.dat"))
+
+    def arguments(self=None):
+        args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005, 
'gain_mu':0.05, 'mu':0.5 
+                'gray_code':True, verbose':True, 'debug':False}
+        return args
+    arguments = staticmethod(arguments)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--excess-bw", type="float", default=0.3,
+                              help="set RRC excess bandwith factor 
[default=%default]")
+            parser.add_option("", "--no-gray-code", action="store_false", 
default=True,
+                              help="Don't use gray coding on modulated bits 
[default=%default]")
+            parser.add_option("", "--costas-alpha", type="float", 
default=0.005,
+                              help="set Costas loop alpha value 
[default=%default]")
+            parser.add_option("", "--gain-mu", type="float", default=0.05,
+                              help="set M&M symbol sync loop gain mu value 
[default=%default]")
+            parser.add_option("", "--mu", type="float", default=0.5,
+                              help="set M&M symbol sync loop mu value 
[default=%default]")
+        except OptionConflictError:
+            pass
+    add_options=staticmethod(add_options)
+ 
 dqpsk_demod = dqpsk_demod__coherent_detection_of_differentially_encoded_psk
 

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
       2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
       2006-09-14 16:43:40 UTC (rev 3541)
@@ -54,10 +54,12 @@
         @type debug: bool       
        """
 
-        print spb
+        self.fg = fg
+        self.spb = spb
+        self.bt = bt
+
         if not isinstance(spb, int) or spb < 2:
             raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
-        self.spb = spb
 
        ntaps = 4 * spb                 # up to 3 bits in filter at once
        sensitivity = (pi / 2) / spb    # phase change per bit = pi / 2
@@ -66,7 +68,6 @@
        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
@@ -82,20 +83,15 @@
        # FM modulation
        self.fmmod = gr.frequency_modulator_fc(sensitivity)
                
-       # Connect
-       fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
-
         if verbose:
-            pass # I have nothing to say...
+            self.verbose()
          
         if debug:
-            fg.connect(self.gaussian_filter,
-                       gr.file_sink(gr.sizeof_gr_complex, 
"gaussianfilter.dat"))
-            fg.connect(self.diffenc,
-                       gr.file_sink(gr.sizeof_gr_complex, "gmsk_mod.dat"))
+            self.debug()
 
-       # Initialize base class
-       gr.hier_block.__init__(self, fg, self.nrz, self.fmmod)
+       # 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_baud(self):
         return self.spb
@@ -104,6 +100,19 @@
         return 1
     bits_per_baud = staticmethod(bits_per_baud)      # make it a static 
method.  RTFM
 
+    def verbose(self):
+        print "bits per symbol = %d" % self.bits_per_baud()
+        print "Gaussian filter bt = %.2f" % self.bt
+
+    def debug(self):
+        print "Modulation debugging 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 arguments(self=None):
         args = {'spb':2, 'bt':0.3, 'verbose':True, 'debug':False}
         return args
@@ -113,15 +122,20 @@
         """
         Adds modulation-specific options to the standard parser
         """
-        parser.add_option("", "--bt", type="float", default=0.3,
-                          help="set bandwidth-time product [default=%default]")
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--bt", type="float", default=0.3,
+                              help="set bandwidth-time product 
[default=%default]")
+        except OptionConflictError:
+            pass
     add_options=staticmethod(add_options)
 
 
 class gmsk_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):
+                 omega_relative_limit=0.000200, freq_error=0.0,
+                 verbose=True, debug=False):
         """
        Hierarchical block for Gaussian Minimum Shift Key (GMSK)
        demodulation.
@@ -133,6 +147,10 @@
        @type fg: flow graph
        @param spb: samples per baud
        @type spb: integer
+        @param verbose: Print information about modulator?
+        @type verbose: bool
+        @param debug: Print modualtion data to files?
+        @type debug: bool 
 
         Clock recovery parameters.  These all have reasonble defaults.
         
@@ -147,15 +165,23 @@
         @param freq_error: bit rate error as a fraction
         @param float
        """
-        if spb < 2:
-            raise TypeError, "sbp >= 2"
+
+        self.fg = fg
         self.spb = spb
+        self.omega = omega
+        self.gain_mu = gain_mu
+        self.mu = mu
+        self.omega_relative_limit = omega_relative_limit
+        self.freq_error = freq_error
         
-        if omega is None:
-            omega = spb*(1+freq_error)
+        if spb < 2:
+            raise TypeError, "sbp >= 2, is %f" % spb
 
-       gain_omega = .25*gain_mu*gain_mu        # critically damped
+        if self.omega is None:
+            self.omega = spb*(1+self.freq_error)
 
+       self.gain_omega = .25*self.gain_mu*self.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)
@@ -164,24 +190,74 @@
        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)
+       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()
 
-       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)
+        if verbose:
+            self.verbose()
+         
+        if debug:
+            self.debug()
 
+       # Connect & Initialize base class
+       self.fg.connect(self.preamp, self.agc, self.fmdemod, 
self.clock_recovery, self.slicer)
+       gr.hier_block.__init__(self, 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
+
+    def verbose(self):
+        print "bits per symbol = %d" % self.bits_per_baud()
+        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 debug(self):
+        print "Modulation debugging turned on."
+        self.fg.connect(self.agc,
+                        gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
+        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 arguments(self=None):
+        args = {'spb':2, 'omega':None, 'gain_mu':0.03, 'mu':0.5, \
+               'omega_relative_limit':0.0002, 'freq_error':0.0, \
+               'verbose':True, 'debug':False}
+        return args
+    arguments = staticmethod(arguments)
+
+    def add_options(parser):
+        """
+        Adds modulation-specific options to the standard parser
+        """
+        from optparse import OptionConflictError
+        try:
+            parser.add_option("", "--omega", type="float", default=None,
+                              help="M&M clock recovery omega 
[default=%default]")
+            parser.add_option("", "--gain_mu", type="float", default=0.03,
+                              help="M&M clock recovery gain mu 
[default=%default]")
+            parser.add_option("", "--mu", type="float", default=0.5,
+                              help="M&M clock recovery mu [default=%default]")
+            parser.add_option("", "--omega_relative_limit", type="float", 
default=0.0002,
+                              help="M&M clock recovery omega relative limit 
[default=%default]")
+            parser.add_option("", "--freq_error", type="float", default=0.0,
+                              help="M&M clock recovery frequency error 
[default=%default]")
+        except OptionConflictError:
+            pass
+    add_options=staticmethod(add_options)

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
 2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
 2006-09-14 16:43:40 UTC (rev 3541)
@@ -10,12 +10,12 @@
     'gmsk':  getattr(gmsk,  "gmsk_mod"),
 }
 
-demodulators = [
-    getattr(bpsk,  "bpsk_demod"),
-    getattr(dbpsk, "dbpsk_demod"),
-    getattr(dqpsk, "dqpsk_demod"),
-    getattr(gmsk,  "gmsk_demod"),
-]
+demodulators = {
+    'bpsk':  getattr(bpsk,  "bpsk_demod"),
+    'dbpsk': getattr(dbpsk, "dbpsk_demod"),
+    'dqpsk': getattr(dqpsk, "dqpsk_demod"),
+    'gmsk':  getattr(gmsk,  "gmsk_demod"),
+}
 
 def kwargs(modulator, attrs):
     args = modulator.arguments()

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
   2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
   2006-09-14 16:43:40 UTC (rev 3541)
@@ -69,13 +69,15 @@
     # Create Options Parser:
     parser = OptionParser (option_class=eng_option)
     parser.add_option("-m", "--modulation", type="choice", 
choices=blks.demodulators.keys(),
-                      default='bpsk',
+                      default='dbpsk',
                       help="Set modulation type %s" % blks.demodulators.keys())
     mod_grp = parser.add_option_group("Modulation")
     for mod in blks.demodulators.values():
         mod.add_options(mod_grp)
     receive_path.add_options(parser)
     fusb_options.add_options(parser)
+    parser.add_option("", "--debug", action="store_true", default="False",
+                      help="Turn debugging information on (CAUTION: takes up 
lots of diskspace)")
     (options, args) = parser.parse_args ()
 
     if len(args) != 0:

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
   2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
   2006-09-14 16:43:40 UTC (rev 3541)
@@ -64,7 +64,7 @@
 
         # Get demod_kwargs
         demod_kwargs = blks.kwargs(self._demodulator, [self._spb, self._decim, 
self._bitrate])
-        demod_kwargs['debug']=True
+        demod_kwargs['debug']=options.debug
 
         # receiver
         self.packet_receiver = \
@@ -92,7 +92,7 @@
 
         # Display some information about the setup
         if verbose:
-            self.verbosity()
+            self.verbose()
             
         fg.connect(self.u, self.chan_filt, self.packet_receiver)
         gr.hier_block.__init__(self, fg, None, None)
@@ -185,7 +185,7 @@
         """
         self.probe.set_threshold(threshold_in_db)
     
-    def verbosity(self):
+    def verbose(self):
         """
         Prints information about the receive path
         """
@@ -194,7 +194,9 @@
         print "bitrate:    %sb/sec" % (eng_notation.num_to_str(self._bitrate))
         print "spb:        %3d" % (self._spb)
         print "decim:      %3d" % (self._decim)
-        print "Center Frequency: %s" % 
(eng_notation.num_to_str(self._center_freq))
+        #print "Center Frequency: %s" % 
(eng_notation.num_to_str(self._center_freq))
+        print "Center Frequency: %f" % (self._center_freq)
+
         
     def add_options(parser):
         """

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
  2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
  2006-09-14 16:43:40 UTC (rev 3541)
@@ -62,21 +62,23 @@
         # transmitter
         self.packet_transmitter = \
             blks.mod_pkts(fg,
-                          self._modulator(fg, **mod_kwargs),
+                          self._modulator(fg, debug=options.debug, 
**mod_kwargs),
                           access_code=None,
                           msgq_limit=4,
                           pad_for_usrp=True)
 
         # Set gains: digital and USRP
         self.amp = gr.multiply_const_cc(self._gain)
-        self.set_gain(self.subdev.gain_range()[1])    # set max Tx gain
+        print  self.subdev.gain_range()
+        self.set_gain(self.subdev.gain_range()[0])    # set max Tx gain
+        self.set_gain(0)
 
         # enable Auto Transmit/Receive switching
         self.set_auto_tr(True)
 
         # Display some information about the setup
         if verbose:
-            self.verbosity()
+            self.verbose()
 
         # Create and setup transmit path flow graph
         fg.connect(self.packet_transmitter, self.amp, self.u)
@@ -128,7 +130,7 @@
             return True
 
         return False
-
+        
     def set_gain(self, gain):
         """
         Sets the analog gain in the USRP
@@ -157,7 +159,7 @@
     def interp(self):
         return self._interp
 
-    def verbosity(self):
+    def verbose(self):
         """
         Prints information about the transmit path
         """

Modified: 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
===================================================================
--- 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
     2006-09-14 15:09:03 UTC (rev 3540)
+++ 
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
     2006-09-14 16:43:40 UTC (rev 3541)
@@ -146,6 +146,12 @@
         parser.print_help()
         raise SystemExit
 
+    print "FPGA Interpolation: %d" % options.interp
+    print "Waveform Type: %s" % options.type
+    print "Waveform Freq: %d" % options.freq
+    print "Waveform Ampl: %d" % options.ampl
+    print "Waveform Offs: %d" % options.offset
+
     fg = my_graph()
     fg.set_interpolator (options.interp)
     fg.set_waveform_type (options.type)





reply via email to

[Prev in Thread] Current Thread [Next in Thread]