[Commit-gnuradio] r4131 - gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python

[trondeau]

Author: trondeau
Date: 2006-12-17 22:25:36 -0700 (Sun, 17 Dec 2006)
New Revision: 4131

Modified:
   
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_receiver.py
   gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_test.py
Log:
working on OFDM receiver packaging

Modified: 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_receiver.py
===================================================================
--- 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_receiver.py
    2006-12-18 05:25:02 UTC (rev 4130)
+++ 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_receiver.py
    2006-12-18 05:25:36 UTC (rev 4131)
@@ -20,30 +20,29 @@
 # Boston, MA 02110-1301, USA.
 # 
 
+import math
 from gnuradio import gr
 from gnuradio import audio
 from gnuradio.eng_option import eng_option
 from optparse import OptionParser
 
-class ofdm_receiver(gr.hier_block2):
-    def __init__(self):
-        gr.hier_block2.__init__(self, 
-                               "ofdm_receiver", 
-                               gr.io_signature(1,1,gr.sizeof_gr_complex), 
-                               gr.io_signature(1,1,gr.sizeof_gr_complex))
+class ofdm_receiver(gr.hier_block):
+    def __init__(self, fg, fft_length, symbol_length, rho):
+        self.input = gr.add_const_cc(0) # Kluge that goes away with hier_block2
 
+        self.fg = fg
+        
+        cpsize = symbol_length - fft_length;
 
         # ML Sync
 
         # Energy Detection from ML Sync
 
         # Create a delay line
-        delayline = [0.0 for i in range(fftsize+1)]
-        delayline[fftsize] = 1.0
-        #self.delay = gr.fir_filter_ccf(1,delayline)
-        self.define_component("delay", gr.fir_filter_ccf (1, delayline))
-        
-        self.connect("self", "delay")
+        delayline = [0.0 for i in range(fft_length+1)]
+        delayline[fft_length] = 1.0
+        self.delay = gr.fir_filter_ccf(1,delayline)
+        self.fg.connect(self.input, self.delay)
 
         # magnitude squared blocks
         self.magsqrd1 = gr.complex_to_mag_squared()
@@ -53,11 +52,11 @@
         moving_sum_taps = [rho/2 for i in range(cpsize)]
         self.moving_sum_filter = gr.fir_filter_fff(1,moving_sum_taps)
         
-        self.connect(self.self,self.magsqrd1)
-        self.connect(self.delay,self.magsqrd2)
-        self.connect(self.magsqrd1,(self.adder,0))
-        self.connect(self.magsqrd2,(self.adder,1))
-        self.connect(self.adder,self.moving_sum_filter)
+        self.fg.connect(self.input,self.magsqrd1)
+        self.fg.connect(self.delay,self.magsqrd2)
+        self.fg.connect(self.magsqrd1,(self.adder,0))
+        self.fg.connect(self.magsqrd2,(self.adder,1))
+        self.fg.connect(self.adder,self.moving_sum_filter)
         
 
         # Correlation from ML Sync
@@ -72,22 +71,28 @@
         self.c2mag = gr.complex_to_mag()
         self.angle = gr.complex_to_arg()
         self.scale = gr.multiply_const_ff(-1000.0/(2*math.pi))
-        self.connect(self.self,(self.mixer,1))
-        self.connect(self.delay,self.conjg,(self.mixer,0))
-        self.connect(self.mixer,self.movingsum2,self.c2mag)
-
+        self.fg.connect(self.input,(self.mixer,1))
+        self.fg.connect(self.delay,self.conjg,(self.mixer,0))
+        self.fg.connect(self.mixer,self.movingsum2,self.c2mag)
+        self.fg.connect(self.movingsum2,self.angle)
+             
         # ML Sync output arg, need to find maximum point of this
         self.diff = gr.sub_ff()
-        self.connect(self.c2mag,(self.diff,0))
-        self.connect(self.moving_sum_filter,(self.diff,1))
+        self.fg.connect(self.c2mag,(self.diff,0))
+        self.fg.connect(self.moving_sum_filter,(self.diff,1))
 
         #ML measurements input to sampler block and detect
-        self.sampler = gr.ofdm_sampler(fftsize,symbol_length,1)
+        self.sampler = gr.ofdm_sampler(fft_length,symbol_length,1)
 
+        self.f2c1 = gr.float_to_complex()
+        self.f2c2 = gr.float_to_complex()
+
         # Connect inputs to OFDM sampler:
         #   1: stream to get downconverted to baseband
         #   2: output of difference block (theta)
         #   3: frequency error estimate (epsilon)
-        self.connect(self.self,(self.sampler,0))
-        self.connect(self.diff,self.f2c1,(self.sampler,1))
-        self.connect(self.angle,self.f2c2,(self.sampler,2))
+        self.fg.connect(self.input, (self.sampler,0))
+        self.fg.connect(self.diff, self.f2c1,(self.sampler,1))
+        self.fg.connect(self.angle, self.f2c2,(self.sampler,2))
+
+        gr.hier_block.__init__(self, fg, self.input, self.sampler)

Modified: 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_test.py
===================================================================
--- 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_test.py    
    2006-12-18 05:25:02 UTC (rev 4130)
+++ 
gnuradio/branches/developers/n4hy/ofdm/gnuradio-examples/python/ofdm_test.py    
    2006-12-18 05:25:36 UTC (rev 4131)
@@ -28,6 +28,7 @@
 import wx
 import os, sys, random, math
 
+from ofdm_receiver import ofdm_receiver
 
 class app_flow_graph(stdgui.gui_flow_graph):
     def __init__(self, frame, panel, vbox, argv):
@@ -56,16 +57,14 @@
         self.show_debug_info = True
         
         # parameters
-        fftsize = 128
         occupied_tones = 70
-        symbol_length = 128+32
+        fftsize = 128
+        cpsize = 32
+        symbol_length = fftsize + cpsize
 
-        cpsize = symbol_length - fftsize
-
         SNR_db = 100.0
         SNR = 10.0**(SNR_db/10.0)
         frequency_offset = -0.0
-        fdiff = frequency_offset * sample_rate / fftsize
 
         power_in_signal = occupied_tones
         noise_power_in_channel = power_in_signal/SNR
@@ -76,120 +75,58 @@
         print rho
         
         win = [1 for i in range(fftsize)]
-        data = [1,0,0,1]* 5000 #[random.randint(0,1) for i in range(100000)]
+        #data = [1,0,0,1]* 5000
+        data = [random.randint(0,1) for i in range(100000)]
        self.src = gr.vector_source_b(data, True)
 
         # Modulator
         self.ofdm = gr.ofdm_bpsk_mapper(occupied_tones, fftsize)
         self.ifft = gr.fft_vcc(fftsize, False, win)
         self.cp_adder = gr.ofdm_cyclic_prefixer(fftsize,symbol_length)
+
+        self.connect(self.src, self.ofdm, self.ifft, self.cp_adder)
+
+        # Channel
+        fdiff = frequency_offset * sample_rate / fftsize
         self.noise_adder = gr.add_cc()
         self.noise = gr.noise_source_c(gr.GR_GAUSSIAN,noise_voltage,1)
         self.offset = 
gr.sig_source_c((sample_rate*1.0),gr.GR_SIN_WAVE,fdiff,1.0,0.0)
         self.mixer_offset = gr.multiply_cc()
+        self.throttle = gr.throttle(gr.sizeof_gr_complex, 5e3)
 
-        #self.debugfile = gr.file_sink(gr.sizeof_gr_complex,"debug_out")
-        #self.connect(self.cp_adder,self.debugfile)
-        
-        #count_seq = range(10000)
-        #self.count_src = gr.vector_source_c(count_seq,True)
-        #self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex,256)
-        #self.connect(self.count_src, self.s2v, self.cp_adder,
-        #             self.throttle, self.debugfile) #, self.throttle) #, 
self.scope)
-
-        self.throttle = gr.throttle(gr.sizeof_gr_complex, 1e5)
-        self.scope = fftsink.fft_sink_c (self, panel, fft_size=1024, 
sample_rate=sample_rate, fft_rate=30)
-        self.connect(self.noise,(self.noise_adder,0))
-        self.connect(self.src, self.ofdm, self.ifft, 
self.cp_adder,(self.mixer_offset,1))
-        self.connect(self.mixer_offset,(self.noise_adder,1))
         self.connect(self.offset,(self.mixer_offset,0))
-        self.connect(self.noise_adder,self.throttle, self.scope)
+        self.connect(self.noise,(self.noise_adder,0))
+        self.connect(self.mixer_offset, self.throttle, (self.noise_adder,1))
 
-        # ML Sync
+        # Put modulated signal through channel
+        #self.scope = fftsink.fft_sink_c (self, panel, fft_size=1024, 
sample_rate=sample_rate, fft_rate=30)
+        self.connect(self.cp_adder, (self.mixer_offset,1))
 
-        # Energy Detection from ML Sync
 
-        #moving_sum_taps = [0.0 for i in range(symbol_length)]
-        #for i in range(cpsize):
-        #    moving_sum_taps[i] = 0.5
-        #for i in range(fftsize,symbol_length):
-        #    moving_sum_taps[i] = 0.5
-        #self.moving_sum_filter = gr.fir_filter_fff(1,moving_sum_taps)
-        #print moving_sum_taps
-        #self.complex_to_magsq = gr.complex_to_mag_squared();
-        
#self.connect(self.throttle,self.complex_to_magsq,self.moving_sum_filter)
-
-        delayline = [0.0 for i in range(fftsize+1)]
-        delayline[fftsize] = 1.0
-        self.delay = gr.fir_filter_ccf(1,delayline)
-        self.connect(self.throttle,self.delay)
-
-        self.magsqrd1 = gr.complex_to_mag_squared()
-        self.magsqrd2 = gr.complex_to_mag_squared()
-        self.adder = gr.add_ff()
-
-        moving_sum_taps = [rho/2 for i in range(cpsize)]
-        self.moving_sum_filter = gr.fir_filter_fff(1,moving_sum_taps)
+        # ML Sync
+        self.ofdm_rx = ofdm_receiver(self, fftsize, symbol_length, rho)
         
-        self.connect(self.throttle,self.magsqrd1)
-        self.connect(self.delay,self.magsqrd2)
-        self.connect(self.magsqrd1,(self.adder,0))
-        self.connect(self.magsqrd2,(self.adder,1))
-        self.connect(self.adder,self.moving_sum_filter)
-        
-
-        # Correlation from ML Sync
-        self.conjg = gr.conjugate_cc();
-        self.mixer = gr.multiply_cc();
-
-        movingsum2_taps = [1.0 for i in range(cpsize)]
-        self.movingsum2 = gr.fir_filter_ccf(1,movingsum2_taps)
-        
-
-        self.c2mag = gr.complex_to_mag()
-        self.angle = gr.complex_to_arg()
-        self.scale = gr.multiply_const_ff(-1000.0/(2*math.pi))
-        
-
-        self.connect(self.throttle,(self.mixer,1))
-        self.connect(self.delay,self.conjg,(self.mixer,0))
-        self.connect(self.mixer,self.movingsum2,self.c2mag)
-
-        # ML Sync output arg, need to find maximum point of this
-        self.diff = gr.sub_ff()
-        self.connect(self.c2mag,(self.diff,0))
-        self.connect(self.moving_sum_filter,(self.diff,1))
-
-        #ML measurements input to sampler block and detect
-
-        #self.sampler = 
gr.ofdm_sampler(fftsize,symbol_length,(-fftsize-cpsize))
-        self.sampler = gr.ofdm_sampler(fftsize,symbol_length,1)
+        # OFDM Demod
         self.fftdemod = gr.fft_vcc(fftsize,True,win)
         self.ofdm_demod = gr.ofdm_bpsk_demapper(occupied_tones, fftsize)
         self.unpack = gr.unpack_k_bits_bb(1)
 
-        self.outdem = gr.vector_to_stream(gr.sizeof_gr_complex,fftsize)
+        self.connect(self.noise_adder, self.ofdm_rx, self.fftdemod, 
self.ofdm_demod, self.unpack)
+             
+        # save output
         self.outdat = gr.file_sink(gr.sizeof_char,"output_data")
-#        self.outdat = gr.file_sink(gr.sizeof_gr_complex,"output_data")
+        self.connect(self.unpack, self.outdat)
         
-#        self.connect(self.sampler,self.fftdemod,self.outdem,self.outdat)
-        self.connect(self.sampler, self.fftdemod, self.ofdm_demod, 
self.unpack, self.outdat)
+        if 0:
+            self.connect(self.noise_adder,self.throttle, self.scope)
+            self.oscope = scopesink.scope_sink_f(self, panel, 
sample_rate=sample_rate)
+            self.connect(self.moving_sum_filter,(self.oscope,0))
+            self.connect(self.c2mag,(self.oscope,1))
+            self.connect(self.diff,(self.oscope,0))
+            self.connect(self.movingsum2,self.angle,self.scale,(self.oscope,1))
 
-        self.f2c1 = gr.float_to_complex()
-        self.f2c2 = gr.float_to_complex()
-        
-        self.connect(self.throttle,(self.sampler,0))
-        self.connect(self.diff,self.f2c1,(self.sampler,1))
-        self.connect(self.angle,self.f2c2,(self.sampler,2))
-        
-        self.oscope = scopesink.scope_sink_f(self, panel, 
sample_rate=sample_rate)
-#        self.connect(self.moving_sum_filter,(self.oscope,0))
-#        self.connect(self.c2mag,(self.oscope,1))
-        self.connect(self.diff,(self.oscope,0))
-        self.connect(self.movingsum2,self.angle,self.scale,(self.oscope,1))
+            self._build_gui(vbox)
 
-        self._build_gui(vbox)
-
     def _set_status_msg(self, msg):
         self.frame.GetStatusBar().SetStatusText(msg, 0)