[Commit-gnuradio] r6101 - in grc/trunk/src: . SignalBlockDefs

[jblum]

Author: jblum
Date: 2007-08-02 13:06:43 -0600 (Thu, 02 Aug 2007)
New Revision: 6101

Modified:
   grc/trunk/src/ExecFlowGraph.py
   grc/trunk/src/SignalBlockDefs/Filters.py
   grc/trunk/src/SignalBlockDefs/GraphicalSinks.py
   grc/trunk/src/SignalBlockDefs/Modulators.py
   grc/trunk/src/SignalBlockDefs/SignalBlockConstants.py
Log:
implemented connect method to support hier_blocks, removed hier and throttle 
helpers

Modified: grc/trunk/src/ExecFlowGraph.py
===================================================================
--- grc/trunk/src/ExecFlowGraph.py      2007-08-02 11:17:20 UTC (rev 6100)
+++ grc/trunk/src/ExecFlowGraph.py      2007-08-02 19:06:43 UTC (rev 6101)
@@ -25,7 +25,7 @@
 import Variables
 from Elements import SignalBlock
 from gnuradio import gr
-import os,time
+import os
 from Constants import FLOW_GRAPH_FILE_EXTENSION,MUTEX
 from optparse import OptionParser
 
@@ -57,6 +57,21 @@
                """Stop the flow graph."""
                self.runtime.stop()
                self.started = False
+               
+       def connect(self, *points):
+               """
+               Override connect so that we can connect internal hier blocks.
+               @param points the blocks to connect.
+               """
+               points2 = [(points[i], points[i+1]) for i in 
range(len(points)-1)]
+               for source,sink in points2:
+                       if hasattr(source, "__getitem__") and len(source) == 2: 
source,i = source
+                       else: i = 0
+                       if hasattr(sink, "__getitem__") and len(sink) == 2: 
sink,j = sink
+                       else: j = 0
+                       while hasattr(source, 'tail'): source = source.tail
+                       while hasattr(sink, 'head'): sink = sink.head
+                       gr.hier_block2.connect(self, (source, i), (sink, j))    
                        
        def add_window(self, *args):
                """Empty method for adding a window in the GUI flow graph."""
@@ -122,7 +137,6 @@
                                for function, data_type_params in 
self.callbacks_locked + self.callbacks_cond:
                                        self._parse_callback(function, 
*data_type_params)
                                self._hb.unlock()
-                               time.sleep(.005)        #sleep to lower chances 
of possible thread-lockup
                print "***\n\nCallback Time END\n\n***"
                MUTEX.unlock()
                

Modified: grc/trunk/src/SignalBlockDefs/Filters.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/Filters.py    2007-08-02 11:17:20 UTC (rev 
6100)
+++ grc/trunk/src/SignalBlockDefs/Filters.py    2007-08-02 19:06:43 UTC (rev 
6101)
@@ -22,7 +22,7 @@
 
 from DataTypes import *
 from gnuradio import gr,gru,blks
-from SignalBlockConstants import default_samp_rate,all_choices,HierHelper
+from SignalBlockConstants import default_samp_rate,all_choices
 
 ###########################################################################
 #      Generic filters with taps parameters
@@ -148,10 +148,7 @@
        sb.add_param('Taps', ComplexVector('1.0,0.0'))
        sb.set_docs('''Simulate channel distortion.''')
        def make(fg, noise_voltage, frequency_offset, epsilon, taps):
-               return HierHelper(
-                       fcn(fg, noise_voltage.parse(), 
frequency_offset.parse(), epsilon.parse(), taps.parse()), 
-                       Complex().get_num_bytes(), Complex().get_num_bytes(), 
-               )
+               return fcn(fg, noise_voltage.parse(), frequency_offset.parse(), 
epsilon.parse(), taps.parse())
        return sb, make
 
 ###########################################################################
@@ -463,10 +460,7 @@
                out_rate = outrate.parse()
                interp = int(lcm(in_rate, out_rate)/in_rate)
                decim = int(lcm(in_rate, out_rate)/out_rate)
-               return HierHelper(
-                       filter_type.parse()[0](fg, interp, decim, taps=None, 
fractional_bw=fractional_bw.parse()),
-                       filter_type.parse()[1].get_num_bytes(), 
filter_type.parse()[1].get_num_bytes(), 
-               )
+               return filter_type.parse()[0](fg, interp, decim, taps=None, 
fractional_bw=fractional_bw.parse())
        return sb, make
        
 def FractionalInterpolator(sb):

Modified: grc/trunk/src/SignalBlockDefs/GraphicalSinks.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/GraphicalSinks.py     2007-08-02 11:17:20 UTC 
(rev 6100)
+++ grc/trunk/src/SignalBlockDefs/GraphicalSinks.py     2007-08-02 19:06:43 UTC 
(rev 6101)
@@ -22,7 +22,7 @@
 
 from DataTypes import *
 from gnuradio import gr
-from SignalBlockConstants import default_samp_rate,ThrottleHelper,HierHelper
+from SignalBlockConstants import default_samp_rate
 
 number_display_pritority = 0
 fft_display_priority = 1
@@ -58,7 +58,9 @@
                fg.add_window(block.win, fft_display_priority, title.parse())
                fg.add_callback(block.set_ref_level, ref_lvl)
                fg.add_callback(block.set_y_per_div, y_per_div)
-               return ThrottleHelper(type.parse()[1].get_num_bytes(), 
samp_rate.parse(), HierHelper(block, type.parse()[1].get_num_bytes()), True)
+               throttle = gr.throttle(type.parse()[1].get_num_bytes(), 
samp_rate.parse())
+               fg.connect(throttle, block)
+               return throttle
        return sb, make
        
 def WaterfallSink(sb):
@@ -87,7 +89,9 @@
                block.set_average(average)                      #set the 
average option outside the contructor
                fg.add_window(block.win, waterfall_display_priority, 
title.parse())
                fg.add_callback(block.set_baseband_freq, baseband_freq)
-               return ThrottleHelper(type.parse()[1].get_num_bytes(), 
samp_rate.parse(), HierHelper(block, type.parse()[1].get_num_bytes()), True)
+               throttle = gr.throttle(type.parse()[1].get_num_bytes(), 
samp_rate.parse())
+               fg.connect(throttle, block)
+               return throttle
        return sb, make
        
 def ScopeSink(sb):
@@ -114,7 +118,9 @@
                        sample_rate=samp_rate.parse(), 
frame_decim=frame_decim.parse(), 
                        v_scale=v_scale, t_scale=t_scale.parse())
                fg.add_window(block.win, scope_display_priority, title.parse()) 
-               return ThrottleHelper(type.parse()[1].get_num_bytes(), 
samp_rate.parse(), HierHelper(block, type.parse()[1].get_num_bytes()), True)
+               throttle = gr.throttle(type.parse()[1].get_num_bytes(), 
samp_rate.parse())
+               fg.connect(throttle, block)
+               return throttle
        return sb, make
        
 def ConstellationSink(sb):
@@ -136,7 +142,9 @@
                elif marker == 1: block.win.set_format_dot()
                elif marker == 2: block.win.set_format_line()
                fg.add_window(block.win, constellation_display_pritority, 
title.parse())        
-               return ThrottleHelper(Complex().get_num_bytes(), 
samp_rate.parse(), HierHelper(block, Complex().get_num_bytes()), True)
+               throttle = gr.throttle(Complex().get_num_bytes(), 
samp_rate.parse())
+               fg.connect(throttle, block)
+               return throttle
        return sb, make
 
 def NumericalSink(sb):
@@ -176,7 +184,9 @@
                fg.add_callback(block.set_base_value, base)
                fg.add_callback(block.set_ref_level, ref_lvl)
                fg.add_callback(block.set_decimal_places, decimals)
-               return ThrottleHelper(type.parse()[1].get_num_bytes(), 
samp_rate.parse(), HierHelper(block, type.parse()[1].get_num_bytes()), True)
+               throttle = gr.throttle(Complex().get_num_bytes(), 
samp_rate.parse())
+               fg.connect(throttle, block)
+               return throttle
        return sb, make
                
        
\ No newline at end of file

Modified: grc/trunk/src/SignalBlockDefs/Modulators.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/Modulators.py 2007-08-02 11:17:20 UTC (rev 
6100)
+++ grc/trunk/src/SignalBlockDefs/Modulators.py 2007-08-02 19:06:43 UTC (rev 
6101)
@@ -22,7 +22,6 @@
 
 from DataTypes import *
 from gnuradio import gr
-from SignalBlockConstants import HierHelper
 
 def FrequencyMod(sb):
        fcn = gr.frequency_modulator_fc
@@ -59,8 +58,7 @@
        sb.set_docs('''\
 Wide Band FM Receiver.
 The audio rate is the quad rate/audio decimation.''')
-       return sb, lambda fg, quad_rate, audio_dec: \
-               HierHelper(fcn(fg, quad_rate.parse(), audio_dec.parse()), 
Complex().get_num_bytes(), Float().get_num_bytes())
+       return sb, lambda fg, quad_rate, audio_dec: fcn(fg, quad_rate.parse(), 
audio_dec.parse())
        
 def WFMTransmit(sb):
        from gnuradio import blks
@@ -80,7 +78,7 @@
                #       make sure that the quad rate is an integer multiple of 
the audio rate   #
                audio_rate = quad_rate/audio_decimation
                quad_rate = audio_decimation * (quad_rate/audio_decimation)
-               return HierHelper(fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse()), Float().get_num_bytes(), Complex().get_num_bytes())
+               return fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse())
        return sb, make
        
 def NBFMReceive(sb):
@@ -101,7 +99,7 @@
                #       make sure that the quad rate is an integer multiple of 
the audio rate   #
                audio_rate = quad_rate/audio_decimation
                quad_rate = audio_decimation * (quad_rate/audio_decimation)
-               return HierHelper(fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse()), Complex().get_num_bytes(), Float().get_num_bytes())
+               return fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse())
        return sb, make 
        
 def NBFMTransmit(sb):
@@ -122,7 +120,7 @@
                #       make sure that the quad rate is an integer multiple of 
the audio rate   #
                audio_rate = quad_rate/audio_decimation
                quad_rate = audio_decimation * (quad_rate/audio_decimation)
-               return HierHelper(fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse()), Float().get_num_bytes(), Complex().get_num_bytes())
+               return fcn(fg, audio_rate, quad_rate, tau.parse(), 
max_dev.parse())
        return sb, make 
                
 ###########################################################################
@@ -138,8 +136,7 @@
        sb.add_param('Audio Decimation', Int(1, min=1)) 
        sb.add_param('Audio Passband (Hz)', Float(5e3))
        sb.add_param('Audio Stopband (Hz)', Float(5.5e3))
-       return sb, lambda fg, *args: \
-               HierHelper(fcn(fg, *map(lambda a: a.parse(), args)), 
Complex().get_num_bytes(), Float().get_num_bytes())
+       return sb, lambda fg, *args: fcn(fg, *map(lambda a: a.parse(), args))
                
 def FMDemod(sb):
        from gnuradio import blks
@@ -153,8 +150,7 @@
        sb.add_param('Audio Stopband (Hz)', Float(4e3))
        sb.add_param('Gain', Float(1))
        sb.add_param('Tau', Float(75e-6))
-       return sb, lambda fg, *args: \
-               HierHelper(fcn(fg, *map(lambda a: a.parse(), args)), 
Complex().get_num_bytes(), Float().get_num_bytes())
+       return sb, lambda fg, *args: fcn(fg, *map(lambda a: a.parse(), args))
        
 ###########################################################################
 #      Phase shift keying
@@ -172,8 +168,7 @@
        sb.add_param('Samples/Symbol', Int(2, min=2))
        sb.add_param('Excess BW', Float(0.35))
        sb.add_param('Use Gray Code', Bool(true='Yes', false='No', 
default=True))
-       return sb, lambda fg, type, *args: \
-               HierHelper(type.parse()(fg, *map(lambda a: a.parse(), args)), 
Byte().get_num_bytes(), Complex().get_num_bytes())
+       return sb, lambda fg, type, *args: type.parse()(fg, *map(lambda a: 
a.parse(), args))
        
 def PSKDemod(sb):
        from gnuradio import blks
@@ -191,8 +186,7 @@
        sb.add_param('Mu', Float(0.005))
        sb.add_param('Omega Relative Limit', Float(0.05))
        sb.add_param('Use Gray Code', Bool(true='Yes', false='No', 
default=True))
-       return sb, lambda fg, type, *args: \
-               HierHelper(type.parse()(fg, *map(lambda a: a.parse(), args)), 
Complex().get_num_bytes(), Byte().get_num_bytes())
+       return sb, lambda fg, type, *args: type.parse()(fg, *map(lambda a: 
a.parse(), args))
 
 ###########################################################################
 #      Gaussian minimum shift keying
@@ -205,8 +199,7 @@
        sb.add_output_socket('out', Complex())  
        sb.add_param('Samples/Symbol', Int(2, min=2))
        sb.add_param('Filter BW', Float(0.35))
-       return sb, lambda fg, *args: \
-               HierHelper(fcn(fg, *map(lambda a: a.parse(), args)), 
Byte().get_num_bytes(), Complex().get_num_bytes())
+       return sb, lambda fg, *args: fcn(fg, *map(lambda a: a.parse(), args))
        
 def GMSKDemod(sb):
        from gnuradio import blks
@@ -219,8 +212,7 @@
        sb.add_param('Omega Relative Limit', Float(0.005))
        sb.add_param('Frequency Error', Float(0))
        sb.set_docs('''Mu is the fractional delay between 0 and 1''')
-       return sb, lambda fg, *args: \
-               HierHelper(fcn(fg, *map(lambda a: a.parse(), args)), 
Complex().get_num_bytes(), Byte().get_num_bytes())
+       return sb, lambda fg, *args: fcn(fg, *map(lambda a: a.parse(), args))
        
 ###########################################################################
 #      Quadrature amplitude modulation
@@ -238,8 +230,7 @@
        sb.add_param('Samples/Symbol', Int(2, min=2))
        sb.add_param('Excess BW', Float(0.35))
        sb.add_param('Use Gray Code', Bool(true='Yes', false='No', 
default=True))
-       return sb, lambda fg, type, *args: \
-               HierHelper(type.parse()(fg, *map(lambda a: a.parse(), args)), 
Byte().get_num_bytes(), Complex().get_num_bytes())
+       return sb, lambda fg, type, *args: type.parse()(fg, *map(lambda a: 
a.parse(), args))
        
 def QAMDemod(sb):
        from gnuradio import blks
@@ -257,8 +248,7 @@
        sb.add_param('Mu', Float(0.005))
        sb.add_param('Omega Relative Limit', Float(0.05))
        sb.add_param('Use Gray Code', Bool(true='Yes', false='No', 
default=True))
-       return sb, lambda fg, type, *args: \
-               HierHelper(type.parse()(fg, *map(lambda a: a.parse(), args)), 
Complex().get_num_bytes(), Byte().get_num_bytes())
+       return sb, lambda fg, type, *args: type.parse()(fg, *map(lambda a: 
a.parse(), args))
                
 ###########################################################################
 #      Phase Locked Loops

Modified: grc/trunk/src/SignalBlockDefs/SignalBlockConstants.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/SignalBlockConstants.py       2007-08-02 
11:17:20 UTC (rev 6100)
+++ grc/trunk/src/SignalBlockDefs/SignalBlockConstants.py       2007-08-02 
19:06:43 UTC (rev 6101)
@@ -22,47 +22,7 @@
 
 from DataTypes import *
 from gnuradio import gr
-
-class ThrottleHelper(gr.hier_block2):
-       """A block with a throttle on the input or output."""
-       def __init__(self, item_size, samp_rate, block, position):
-               """!
-               ThrottleHelper contructor.
-               Create a throttle and append it to the block.
-               @param item_size the size of the gr data stream in bytes
-               @param block the gr block
-               @param position if true connect a throttle to the input of 
block, otherwise the output
-               """             
-               gr.hier_block2.__init__(
-                       self, "throttle_helper",
-                       gr.io_signature(1, 1, item_size),
-                       gr.io_signature(1, 1, item_size),
-               )
-               throttle = gr.throttle(item_size, samp_rate)
-               if position: self.connect(self, throttle, block, self)
-               else: self.connect(self, block, throttle, self)
                        
-class HierHelper(gr.hier_block2):
-       """Wrap a hier2 block around a hier block."""
-       def __init__(self, hier_block, item_size_in=0, item_size_out=0):
-               """!
-               HierHelper constructor.
-               An item size of zero means that there is no connection.
-               @param hier_block a regular hier block
-               @param item_size_in the size of the input data stream in bytes
-               @param item_size_out the size of the output data stream in 
bytes                
-               """
-               #io signatures
-               if item_size_in > 0: io_sig_in = gr.io_signature(1, 1, 
item_size_in)
-               else: io_sig_in = gr.io_signature(0, 0, 0)
-               if item_size_out > 0: io_sig_out = gr.io_signature(1, 1, 
item_size_out)
-               else: io_sig_out = gr.io_signature(0, 0, 0)
-               #initialize
-               gr.hier_block2.__init__(self, "hier_helper", io_sig_in, 
io_sig_out)
-               #connect
-               if item_size_in > 0: self.connect(self, hier_block.head)        
-               if item_size_out > 0: self.connect(hier_block.tail, self)
-
 ##max number of sockets to draw on one side of a signal block.
 MAX_NUM_SOCKETS = 20