[Commit-gnuradio] r4851 - in gnuradio/branches/developers/jcorgan/channel: gnuradio-core/src/lib/general gnuradio-core/src/python/gnuradio/gr gnuradio-examples/python/hier/sounder

[jcorgan]

Author: jcorgan
Date: 2007-04-02 23:47:37 -0600 (Mon, 02 Apr 2007)
New Revision: 4851

Modified:
   
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/lib/general/gr_pn_correlator_cc.cc
   
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/python/gnuradio/gr/qa_pn_correlator_cc.py
   
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/sounder_rx.py
   
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/usrp_sounder_rx.py
Log:
Work in progress.  I see impulses...

Modified: 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/lib/general/gr_pn_correlator_cc.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/lib/general/gr_pn_correlator_cc.cc
   2007-04-03 00:43:10 UTC (rev 4850)
+++ 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/lib/general/gr_pn_correlator_cc.cc
   2007-04-03 05:47:37 UTC (rev 4851)
@@ -70,7 +70,7 @@
       sum += *in++ * d_pn;
     }
 
-    *out++ = sum;
+    *out++ = sum*gr_complex(1.0/d_len, 0.0);
   }
 
   return noutput_items;

Modified: 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/python/gnuradio/gr/qa_pn_correlator_cc.py
===================================================================
--- 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/python/gnuradio/gr/qa_pn_correlator_cc.py
    2007-04-03 00:43:10 UTC (rev 4850)
+++ 
gnuradio/branches/developers/jcorgan/channel/gnuradio-core/src/python/gnuradio/gr/qa_pn_correlator_cc.py
    2007-04-03 05:47:37 UTC (rev 4851)
@@ -44,7 +44,7 @@
         self.fg.connect(src, head, f2c, corr, dst)
         self.fg.run()
         data = dst.data()
-        self.assertEqual(data[-1], (length+0j))
+        self.assertEqual(data[-1], (1.0+0j))
         
 if __name__ == '__main__':
     gr_unittest.main ()

Modified: 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/sounder_rx.py
===================================================================
--- 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/sounder_rx.py
    2007-04-03 00:43:10 UTC (rev 4850)
+++ 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/sounder_rx.py
    2007-04-03 05:47:37 UTC (rev 4851)
@@ -31,86 +31,25 @@
     Creates a channel sounder receiver block with the given parameters.
     """
 
-    def __init__(self, chip_rate, max_delay, tc, output_rate, verbose):
+    def __init__(self, chip_rate, degree, verbose):
 
         # Call hierarchical block constructor
         # Top-level blocks have no inputs or outputs
         gr.hier_block2.__init__(self,
                                 "sounder_rx",                                # 
Block typename
                                 gr.io_signature(1, 1, gr.sizeof_gr_complex), # 
Input signature
-                                gr.io_signature(0, 1, gr.sizeof_gr_complex)) # 
Output signature
+                                gr.io_signature(1, 1, gr.sizeof_gr_complex)) # 
Output signature
 
-        self._max_delay = max_delay
+        self._degree = degree
         self._chip_rate = chip_rate
-        self._tc = tc
-        self._output_rate = output_rate
         self._verbose = verbose
-        min_chips = int(math.ceil(2.0*self._max_delay * self._chip_rate))
-        self._degree = int(math.ceil(math.log(min_chips)/math.log(2)))
         self._length = 2**self._degree-1
         self._rep_rate = self._chip_rate/float(self._length)
-        self._decim = int(self._rep_rate/self._output_rate)
-        self._output_rate = self._rep_rate
-        self._tap = 1.0-2.0/(self._tc*self._rep_rate+1.0)
 
         if self._verbose:
-            print "Mininum sequence length needed is", n2s(min_chips), "chips"
             print "Using PN sequence of degree", self._degree, "length", 
self._length
             print "Sequence repetition rate is", n2s(self._rep_rate), "per sec"
-            print "Smoothing time constant is", n2s(self._tc), "sec"
-            print "IIR tap is", n2s(self._tap)
-            print "Using sequence decimation of", self._decim
-            print "Sequence output rate is", n2s(self._rep_rate/self._decim)
         
-        self._generate_reference()
-
-        self.define_component("s2v-1", 
gr.stream_to_vector(gr.sizeof_gr_complex, self._length))
-        self.define_component("fft", gr.fft_vcc(self._length, True, ())) # No 
window needed
-        self.define_component("avg", gr.single_pole_iir_filter_cc(self._tap, 
self._length))
-        self.define_component("decim", 
gr.keep_one_in_n(gr.sizeof_gr_complex*self._length, self._decim))
-        self.define_component("ref", gr.vector_source_c(self._reference, True))
-        self.define_component("s2v-2", 
gr.stream_to_vector(gr.sizeof_gr_complex, self._length))
-        self.define_component("mult", gr.multiply_vcc(self._length))
-        self.define_component("ifft", gr.fft_vcc(self._length, False, ())) # 
No window needed
-        self.define_component("v2s", gr.vector_to_stream(gr.sizeof_gr_complex, 
self._length))
-        self.define_component("scale", gr.multiply_const_cc(1.0/self._length))
-        
-        # Averaged FFT of input
-        self.connect("self", 0, "s2v-1", 0)
-        self.connect("s2v-1", 0, "fft", 0)
-        self.connect("fft", 0, "avg", 0)
-        self.connect("avg", 0, "decim", 0)
-
-        # Reference signal
-        self.connect("ref", 0, "s2v-2", 0)
-        
-        # FFT correlation leg
-        self.connect("decim", 0, "mult", 0)
-        self.connect("s2v-2", 0, "mult", 1)
-        self.connect("mult", 0, "ifft", 0)
-        self.connect("ifft", 0, "v2s", 0)
-        self.connect("v2s", 0, "scale", 0)
-        self.connect("scale", 0, "self", 0)
-        
-    def _generate_reference(self):
-        # Create a temporary flowgraph to generate conjugate FFT of LFSR output
-        hb = gr.hier_block2("temp_block", gr.io_signature(0,0,0), 
gr.io_signature(0,0,0))
-        hb.define_component("glfsr", gr.glfsr_source_b(self._degree))
-        hb.define_component("head", gr.head(gr.sizeof_char, self._length))
-       hb.define_component("mapper", gr.chunks_to_symbols_bf((-1.0, 1.0), 1))
-        hb.define_component("s2v", gr.stream_to_vector(gr.sizeof_float, 
self._length))
-        hb.define_component("fft", gr.fft_vfc(self._length, True, ())) # No 
window needed
-        hb.define_component("v2s", gr.vector_to_stream(gr.sizeof_gr_complex, 
self._length))
-        hb.define_component("conj", gr.conjugate_cc())
-        sink = gr.vector_sink_c()
-        hb.define_component("sink", sink)
-        hb.connect("glfsr", 0, "head", 0)
-        hb.connect("head", 0, "mapper", 0)
-        hb.connect("mapper", 0, "s2v", 0)
-        hb.connect("s2v", 0, "fft", 0)
-        hb.connect("fft", 0, "v2s", 0)
-        hb.connect("v2s", 0, "conj", 0)
-        hb.connect("conj", 0, "sink", 0)
-        r = gr.runtime(hb)
-        r.run()
-        self._reference = sink.data()
+        self.define_component("corr", gr.pn_correlator_cc(self._degree))
+        self.connect("self", 0, "corr", 0)
+        self.connect("corr", 0, "self", 0)

Modified: 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/usrp_sounder_rx.py
===================================================================
--- 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/usrp_sounder_rx.py
       2007-04-03 00:43:10 UTC (rev 4850)
+++ 
gnuradio/branches/developers/jcorgan/channel/gnuradio-examples/python/hier/sounder/usrp_sounder_rx.py
       2007-04-03 05:47:37 UTC (rev 4851)
@@ -22,53 +22,19 @@
 
 from gnuradio import gr, eng_notation
 from gnuradio.eng_option import eng_option
-from gnuradio.wxgui import stdgui2, fftsink2, waterfallsink2, form, slider
 from optparse import OptionParser
 from usrp_source import usrp_source_c
 from sounder_rx import sounder_rx
-import wx
-import sys
 
 n2s = eng_notation.num_to_str
 
-class usrp_sounder_rx(stdgui2.std_top_block):
-    def __init__(self, frame, panel, vbox, argv):
-        stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
-       parser = OptionParser(option_class=eng_option)
-        parser.add_option("-R", "--rx-subdev-spec", type="subdev", 
default=None,
-                          help="select USRP Rx side A or B (default=first 
found)")
-        parser.add_option("-f", "--freq", type="eng_float", default=0.0,
-                          help="set center frequency (default=%default)")
-        parser.add_option("-c", "--cal", type="eng_float", default=0.0,
-                          help="set frequency calibration offset 
(default=%default)")
-       parser.add_option("-v", "--verbose", action="store_true", default=False,
-                         help="print extra debugging info")
-       parser.add_option("-d", "--max-delay", type="eng_float", default=10e-6,
-                         help="set maximum delay spread (default=%default)")
-       parser.add_option("-r", "--chip-rate", type="eng_float", default=8e6,
-                         help="set sounder chip rate (default=%default)")
-       parser.add_option("-g", "--gain", type="eng_float", default=None,
-                         help="set output amplitude (default=%default)")
-       parser.add_option("", "--tc", type="eng_float", default=1.0,
-                         help="set smoothing time constant in seconds 
(default=%default)")
-       parser.add_option("", "--update-rate", type="eng_float", default=1.0,
-                         help="set output update rate per second 
(default=%default)")
-        (options, args) = parser.parse_args()
-       if len(args) != 0:
-            parser.print_help()
-            sys.exit(1)
+class usrp_sounder_rx(gr.hier_block2):
+    def __init__(self, options):
+        gr.hier_block2.__init__(self, "usrp_sounder_rx",
+                                gr.io_signature(0,0,0),
+                                gr.io_signature(0,0,0))
 
         self._options = options
-        self._frame = frame
-        self._panel = panel
-        
-        self._setup_usrp()
-        self._setup_receiver()
-        self._setup_display()
-        self._setup_topology()
-        self._print_verbiage()
-        
-    def _setup_usrp(self):
         self._u = usrp_source_c(0,
                                 self._options.rx_subdev_spec,
                                 self._options.gain,
@@ -77,37 +43,65 @@
                                 self._options.cal,
                                 self._options.verbose)
         self._options.chip_rate = self._u._if_rate
-        
-    def _setup_receiver(self):
+        self._length = 2**self._options.degree-1
         self._receiver = sounder_rx(self._options.chip_rate,
-                                    self._options.max_delay,
-                                    self._options.tc,
-                                    self._options.update_rate,
+                                    self._options.degree,
                                     self._options.verbose)
 
-    def _setup_topology(self):
+        samples = 100 * self._length**2
+
         self.define_component("usrp", self._u)
+        self.define_component("head", gr.head(gr.sizeof_gr_complex, samples))
        self.define_component("rx",   self._receiver)
-        self.define_component("waterfall", self._waterfall)
-        self.define_component("file", gr.file_sink(gr.sizeof_gr_complex, 
"rx.dat"))
-       self.connect("usrp", 0, "rx", 0)
-        self.connect("rx", 0, "waterfall", 0)
-        self.connect("rx", 0, "file", 0)
-        
-    def _setup_display(self):
-        self._waterfall = waterfallsink2.waterfall_sink_c(self._panel, 
fft_rate=15,
-                                                          
fft_size=self._receiver._length,
-                                                          
sample_rate=self._options.chip_rate)
+        self.define_component("c2m",  gr.complex_to_mag())
+        self.define_component("s2v",  gr.stream_to_vector(gr.sizeof_float, 
self._length))
+        self.define_component("lpf",  
gr.single_pole_iir_filter_ff(self._options.alpha, self._length))
+        self.define_component("v2s",  gr.vector_to_stream(gr.sizeof_float, 
self._length))
+        self.define_component("sink", gr.file_sink(gr.sizeof_float, 
"impulse.dat"))
 
-    def _print_verbiage(self):
+        self.connect("usrp", 0, "head", 0)
+        self.connect("head", 0, "rx", 0)
+        self.connect("rx", 0, "c2m", 0)
+        self.connect("c2m", 0, "s2v", 0)
+        self.connect("s2v", 0, "lpf", 0)
+        self.connect("lpf", 0, "v2s", 0)
+        self.connect("v2s", 0, "sink", 0)
+
        if self._options.verbose:
             print "Chip rate is", n2s(self._options.chip_rate), "chips/sec"
             print "Resolution is", n2s(1.0/self._options.chip_rate), "sec"
-            print "Using specified maximum delay spread of", 
self._options.max_delay, "sec"
+            print "Using PN code of degree", self._options.degree
 
 def main():
-        app = stdgui2.stdapp(usrp_sounder_rx, "USRP Channel Sounder", 
nstatus=1)
-        app.MainLoop()
+    parser = OptionParser(option_class=eng_option)
+    parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
+                      help="select USRP Rx side A or B (default=first found)")
+    parser.add_option("-f", "--freq", type="eng_float", default=0.0,
+                      help="set center frequency (default=%default)")
+    parser.add_option("-c", "--cal", type="eng_float", default=0.0,
+                      help="set frequency calibration offset 
(default=%default)")
+    parser.add_option("-v", "--verbose", action="store_true", default=False,
+                      help="print extra debugging info")
+    parser.add_option("-d", "--degree", type="int", default=10,
+                      help="set PN code degree (length=2**degree-1, 
default=%default)")
+    parser.add_option("-r", "--chip-rate", type="eng_float", default=8e6,
+                      help="set sounder chip rate (default=%default)")
+    parser.add_option("-g", "--gain", type="eng_float", default=None,
+                      help="set receiver gain (default=%default)")
+    parser.add_option("", "--alpha", type="eng_float", default=1.0,
+                      help="set smoothing constant (default=%default)")
+    (options, args) = parser.parse_args()
+    if len(args) != 0:
+        parser.print_help()
+        sys.exit(1)
 
+    top_block = usrp_sounder_rx(options)
+    runtime = gr.runtime(top_block)
+
+    try:
+        runtime.run()
+    except KeyboardInterrupt:
+        pass
+
 if __name__ == '__main__':
     main ()