[Commit-gnuradio] r5992 - grc/trunk/src/SignalBlockDefs

[jblum]

Author: jblum
Date: 2007-07-16 16:41:44 -0600 (Mon, 16 Jul 2007)
New Revision: 5992

Modified:
   grc/trunk/src/SignalBlockDefs/Sources.py
   grc/trunk/src/SignalBlockDefs/USRP.py
Log:
usrp blocks with flex rf support

Modified: grc/trunk/src/SignalBlockDefs/Sources.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/Sources.py    2007-07-16 20:24:01 UTC (rev 
5991)
+++ grc/trunk/src/SignalBlockDefs/Sources.py    2007-07-16 22:41:44 UTC (rev 
5992)
@@ -43,19 +43,20 @@
                ('Int', (gr.sig_source_i, Int())), 
                ('Short', (gr.sig_source_s, Short())),
        ], 1)
-       wfm_types = [('Constant', gr.GR_CONST_WAVE), 
-                                       ('Cosine', gr.GR_COS_WAVE), 
-                                       ('Sine', gr.GR_SIN_WAVE),]
-       try: wfm_types = wfm_types + [('Square', gr.GR_SQR_WAVE),
-                                                                               
        ('Triangle', gr.GR_TRI_WAVE),
-                                                                               
        ('Saw Tooth', gr.GR_SAW_WAVE),]
-       except: print ">>> sig source missing sqr, tri, saw waveform types"
+       wfm_types = [
+               ('Constant', gr.GR_CONST_WAVE), 
+               ('Cosine', gr.GR_COS_WAVE), 
+               ('Sine', gr.GR_SIN_WAVE),
+               ('Square', gr.GR_SQR_WAVE),
+               ('Triangle', gr.GR_TRI_WAVE),
+               ('Saw Tooth', gr.GR_SAW_WAVE),
+       ]
        sb.add_output_socket('out', Variable(type, index=1))
        sb.add_param('Type', type, False, type=True)
        sb.add_param('Sampling Rate', Float(default_samp_rate), variable=True)
        sb.add_param('Wave Form', Enum(wfm_types, 1))
        sb.add_param('Frequency', Float(1000), variable=True)
-       sb.add_param('Ampliude', Float(1), variable=True)
+       sb.add_param('Amplitude', Float(1), variable=True)
        sb.add_param('Offset', Variable(type, index=1), variable=True)
        def make(fg, type, samp_freq, waveform, freq, amplitude, offset):
                block = type.parse()[0](samp_freq.parse(), waveform.parse(), 
freq.parse(), amplitude.parse(), offset.parse())           

Modified: grc/trunk/src/SignalBlockDefs/USRP.py
===================================================================
--- grc/trunk/src/SignalBlockDefs/USRP.py       2007-07-16 20:24:01 UTC (rev 
5991)
+++ grc/trunk/src/SignalBlockDefs/USRP.py       2007-07-16 22:41:44 UTC (rev 
5992)
@@ -23,7 +23,70 @@
 from DataTypes import *
 from gnuradio import gr
 
-def set_freq(u, which, subdev, freq, verbose=False):
+####################################################################
+#      Constants
+####################################################################
+
+##default interpolation for a new sink
+DEFAULT_INTERP = 512
+
+##default decimation for a new source
+DEFAULT_DECIM = 256
+
+##auto tr options
+_auto_tr_options = [
+       ('Ignore', None),
+       ('Enable', True),
+       ('Disable', False),
+]
+
+##transmit enable options
+_tx_enb_options = [
+       ('Ignore', None),
+       ('Enable', True),
+       ('Disable', False),
+]
+
+##receive antenna options
+_rx_ant_options = [
+       ('Ignore', None),
+       ('TX/RX', 'TX/RX'),
+       ('RX2', 'RX2'),
+]
+
+##helpful usrp source message
+_usrp_source_msg = '''
+The USRP source outputs 64 Megasamples per second / decimation.
+
+--- Flex RF specific ---
+The "Auto TR" and "RX Antenna" settings are flex rf specific and should be 
left at "Ignore" unless this is a flex rf board.
+
+If enabled, "Auto Transmit/Receive Switching" handles the preference for 
transmit packets vs receive packets. \
+By default, "Auto TR" is disabled.
+
+The "Receive Antenna Setting" selects one of the SMA connectors as the data 
source. \
+By default, 'TX/RX' is selected.
+'''
+
+##helpful usrp sink message
+_usrp_sink_msg = '''
+The USRP sink inputs 128 Megasamples per second / interpolation.
+
+--- Flex RF specific ---
+The "Auto TR" and "TX Enable" settings are flex rf specific and should be left 
at "Ignore" unless this is a flex rf board.
+
+If enabled, "Auto Transmit/Receive Switching" handles the preference for 
transmit packets vs receive packets. \
+By default, "Auto TR" is disabled.
+
+The "Transmit Enable" configures the transmitter to be on or off. \
+Do not leave this unconfigured.
+'''
+
+####################################################################
+#      Helper Functions
+####################################################################
+
+def _set_freq(u, which, subdev, freq, verbose=False):
        """!
        Set the carrier frequency for the given subdevice.      
        @param u the usrp source/sink
@@ -40,7 +103,56 @@
                        print "  r.residual_freq =", r.residual_freq
                        print "  r.inverted      =", r.inverted
                else: print "  Failed!" 
+               
+def _setup_rx_subdev(fg, u, subdev_spec, ddc, gain, freq, auto_tr=None, 
rx_ant=None):
+       """
+       Setup a usrp receive subdevice by setting gain and freq.
+       Add the gain and freq callbacks to the flow graph.
+       FlexRF: Handle auto transmit/receive and set the receive antenna. 
+       @param fg the flow graph
+       @param u the usrp object
+       @param subdev the sub-device specification
+       @param ddc which ddc to use: 0 or 1
+       @param gain the gain DataType
+       @param freq the freq DataType
+       @param auto_tr auto transmit/receive True, False, or None
+       @param rx_ant the receive antenna: 'TX/RX', 'RX2', or None
+       """
+       from gnuradio import usrp
+       subdev = usrp.selected_subdev(u, subdev_spec)#get the subdev
+       subdev.set_gain(gain.parse())   
+       _set_freq(u, ddc, subdev, freq.parse(), verbose=True)
+       fg.add_callback(lambda f: _set_freq(u, ddc, subdev, f), freq)
+       fg.add_callback(subdev.set_gain, gain) #callback for gain setting 
+       if auto_tr != None: subdev.set_auto_tr(auto_tr)
+       if rx_ant != None: subdev.select_rx_antenna(rx_ant)
 
+def _setup_tx_subdev(fg, u, subdev_spec, gain, freq, auto_tr=None, 
tx_enb=None):
+       """
+       Setup a usrp receive subdevice by setting gain and freq.
+       Add the gain and freq callbacks to the flow graph.
+       FlexRF: Handle auto transmit/receive and enable the transmitter. 
+       @param fg the flow graph
+       @param u the usrp object
+       @param subdev the sub-device specification
+       @param gain the gain DataType
+       @param freq the freq DataType
+       @param auto_tr auto transmit/receive True, False, or None
+       @param tr_enb the transmit enable: True, False, or None
+       """
+       from gnuradio import usrp
+       subdev = usrp.selected_subdev(u, subdev_spec)#get the subdev
+       subdev.set_gain(gain.parse())   
+       _set_freq(u, subdev._which, subdev, freq.parse(), verbose=True)
+       fg.add_callback(lambda f: _set_freq(u, subdev._which, subdev, f), freq)
+       fg.add_callback(subdev.set_gain, gain) #callback for gain setting 
+       if auto_tr != None: subdev.set_auto_tr(auto_tr)
+       if tx_enb != None: subdev.set_enable(tx_enb)
+               
+####################################################################
+#      Reguar USRP Source
+####################################################################
+
 def USRPSource(sb):
        from gnuradio import usrp
        type = Enum([('Complex', (usrp.source_c, Complex())), ('IShort', 
(usrp.source_s, Short()))])
@@ -55,31 +167,73 @@
                ('Side B:1', (1, 1)),
        ]))
        sb.add_param('Frequency', Float(), variable=True)
-       sb.add_param('Decimation', Int(200, min=1))
-       sb.add_param('Gain', Float(100), variable=True)
+       sb.add_param('Decimation', Int(DEFAULT_DECIM, min=1))
+       sb.add_param('Gain', Float(0), variable=True)
        sb.add_param('Mux', Hex())
+       sb.add_param('Auto T/R', Enum(_auto_tr_options))
+       sb.add_param('RX Antenna', Enum(_rx_ant_options))
        sb.set_docs('''\
-The USRP source outputs 64 Megasamples per second / decimation.
 If left at 0, the Mux value will be automatically determined. \
-Otherwise, the Mux value must be in hexidecimal format.''')
-       def make(fg, type, number, subdev_spec, frequency, decimation, gain, 
mux):
+Otherwise, the Mux value must be in hexidecimal format.
+''' + _usrp_source_msg)
+       def make(fg, type, number, subdev_spec, freq, decim, gain, mux, 
auto_tr, rx_ant):
                number = number.parse()
                subdev_spec = subdev_spec.parse()       
                u = type.parse()[0](number, nchan=1)
                if subdev_spec == None: subdev_spec = usrp.pick_rx_subdevice(u)
-               u.set_decim_rate(decimation.parse())
+               u.set_decim_rate(decim.parse())
                if mux.parse() == 0: mux = usrp.determine_rx_mux_value(u, 
subdev_spec)
                else: mux = mux.parse()
-               u.set_mux(mux)
-               subdev = usrp.selected_subdev(u, subdev_spec)#get the subdev
-               subdev.set_auto_tr(True)
-               subdev.set_gain(gain.parse())   
-               set_freq(u, 0, subdev, frequency.parse(), verbose=True) #use 
DDC0
-               fg.add_callback(lambda f: set_freq(u, 0, subdev, f), frequency)
-               fg.add_callback(subdev.set_gain, gain) #callback for gain 
setting
+               u.set_mux(mux)                  
+               _setup_rx_subdev(fg, u, subdev_spec, 0, gain, freq, 
auto_tr.parse(), rx_ant.parse())                    
                return u
        return sb, make
+       
+####################################################################
+#      Dual USRP Source
+####################################################################   
+       
+def USRPDualSource(sb):
+       from gnuradio import usrp
+       default_mux = '0x3210'
+       type = Enum([('Complex', (usrp.source_c, Complex())), ('IShort', 
(usrp.source_s, Short()))])
+       sb.add_output_socket('outA', Variable(type, index=1))
+       sb.add_output_socket('outB', Variable(type, index=1))
+       sb.add_param('Output Type', type, False, type=True)
+       sb.add_param('Unit Number', Int(0, min=0))      
+       sb.add_param('FrequencyA', Float(), variable=True)
+       sb.add_param('FrequencyB', Float(), variable=True)
+       sb.add_param('Decimation', Int(DEFAULT_DECIM, min=1))
+       sb.add_param('GainA', Float(0), variable=True)  
+       sb.add_param('GainB', Float(0), variable=True)
+       sb.add_param('Mux', Hex(default_mux))           
+       sb.add_param('Auto T/R', Enum(_auto_tr_options))
+       sb.add_param('RX AntennaA', Enum(_rx_ant_options))
+       sb.add_param('RX AntennaB', Enum(_rx_ant_options))
+       sb.set_docs('''\
+Default mux is %s.
+Channel A (I & Q) will get ADC0 and ADC1
+Channel B (I & Q) will get ADC2 and ADC3
+'''%default_mux + _usrp_source_msg)
+       def make(fg, type, number, freq_a, freq_b, decim, gain_a, gain_b, mux, 
auto_tr, rx_ant_a, rx_ant_b):
+               number = number.parse()
+               u = type.parse()[0](number, nchan=2)            
+               u.set_decim_rate(decim.parse())
+               u.set_mux(mux.parse())
+               # setup A       #               
+               _setup_rx_subdev(fg, u, (0, 0), 0, gain_a, freq_a, 
auto_tr.parse(), rx_ant_a.parse())                           
+               #       setup B #
+               _setup_rx_subdev(fg, u, (1, 0), 1, gain_b, freq_b, 
auto_tr.parse(), rx_ant_b.parse())   
+               ###     Create an interleaver for the 2 data streams    ###
+               deinter = gr.deinterleave(type.parse()[1].get_num_bytes())
+               fg.connect(u, deinter)
+               return deinter
+       return sb, make 
 
+####################################################################
+#      Reguar USRP Sink
+####################################################################
+
 def USRPSink(sb):
        from gnuradio import usrp
        type = Enum([('Complex', (usrp.sink_c, Complex())), ('IShort', 
(usrp.sink_s, Short()))])
@@ -92,14 +246,16 @@
                ('Side B', (1, 0)),
        ]))
        sb.add_param('Frequency', Float(), variable=True)
-       sb.add_param('Interpolation', Int(400, min=1))
+       sb.add_param('Interpolation', Int(DEFAULT_INTERP, min=1))
        sb.add_param('Gain', Float(0), variable=True)   
        sb.add_param('Mux', Hex())
+       sb.add_param('Auto T/R', Enum(_auto_tr_options))
+       sb.add_param('TX Enable', Enum(_tx_enb_options))
        sb.set_docs('''\
-The USRP sink inputs 128 Megasamples per second / interpolation.
 If left at 0, the Mux value will be automatically determined. \
-Otherwise, the Mux value must be in hexidecimal format.''')
-       def make(fg, type, number, subdev_spec, frequency, interp, gain, mux):
+Otherwise, the Mux value must be in hexidecimal format.
+''' + _usrp_sink_msg)
+       def make(fg, type, number, subdev_spec, freq, interp, gain, mux, 
auto_tr, tx_enb):
                number = number.parse()
                subdev_spec = subdev_spec.parse()       
                u = type.parse()[0](number, nchan=1)
@@ -108,15 +264,14 @@
                if mux.parse() == 0: mux = usrp.determine_tx_mux_value(u, 
subdev_spec)
                else: mux = mux.parse()
                u.set_mux(mux)
-               subdev = usrp.selected_subdev(u, subdev_spec)#get the subdev
-               subdev.set_auto_tr(True)
-               subdev.set_gain(gain.parse())
-               set_freq(u, subdev._which, subdev, frequency.parse(), 
verbose=True)
-               fg.add_callback(lambda f: set_freq(u, subdev._which, subdev, 
f), frequency)
-               fg.add_callback(subdev.set_gain, gain) #callback for gain 
setting
+               _setup_tx_subdev(fg, u, subdev_spec, gain, freq, 
auto_tr.parse(), tx_enb.parse())
                return u
        return sb, make
        
+####################################################################
+#      Dual USRP Sink
+####################################################################   
+       
 def USRPDualSink(sb):
        from gnuradio import usrp
        default_mux = '0xba98'
@@ -127,95 +282,32 @@
        sb.add_param('Unit Number', Int(0, min=0))
        sb.add_param('FrequencyA', Float(), variable=True)
        sb.add_param('FrequencyB', Float(), variable=True)
-       sb.add_param('Interpolation', Int(400, min=1))
+       sb.add_param('Interpolation', Int(DEFAULT_INTERP, min=1))
        sb.add_param('GainA', Float(0), variable=True)  
        sb.add_param('GainB', Float(0), variable=True)
        sb.add_param('Mux', Hex(default_mux))   
+       sb.add_param('Auto T/R', Enum(_auto_tr_options))
+       sb.add_param('TX EnableA', Enum(_tx_enb_options))
+       sb.add_param('TX EnableB', Enum(_tx_enb_options))
        sb.set_docs('''\
-The USRP sink inputs 128 Megasamples per second / interpolation. \
 Default mux is %s. 
 This will use all 4 DACs: 
 DAC0 and DAC1 will get channel A (I & Q).
-DAC3 and DAC2 will get channel B (I & Q).'''%default_mux)
-       def make(fg, type, number, frequency_a, frequency_b, interp, gain_a, 
gain_b, mux):
+DAC3 and DAC2 will get channel B (I & Q).
+'''%default_mux + _usrp_sink_msg)
+       def make(fg, type, number, freq_a, freq_b, interp, gain_a, gain_b, mux, 
auto_tr, tx_enb_a, tx_enb_b):
                number = number.parse()
                u = type.parse()[0](number, nchan=2)            
                u.set_interp_rate(interp.parse())
                u.set_mux(mux.parse())
-               # setup side A  #               
-               subdev_a = usrp.selected_subdev(u, (0,0))#get the subdev
-               subdev_a.set_auto_tr(True)
-               subdev_a.set_gain(gain_a.parse())
-               set_freq(u, subdev_a._which, subdev_a, frequency_a.parse(), 
verbose=True)
-               fg.add_callback(lambda f: set_freq(u, subdev_a._which, 
subdev_a, f), frequency_a)
-               fg.add_callback(subdev_a.set_gain, gain_a) #callback for gain 
setting
+               # setup side A  #       
+               _setup_tx_subdev(fg, u, (0, 0), gain_a, freq_a, 
auto_tr.parse(), tx_enb_a.parse())              
                #       setup side B    #
-               subdev_b = usrp.selected_subdev(u, (1,0))#get the subdev
-               subdev_b.set_auto_tr(True)
-               subdev_b.set_gain(gain_b.parse())
-               set_freq(u, subdev_b._which, subdev_b, frequency_b.parse(), 
verbose=True)
-               fg.add_callback(lambda f: set_freq(u, subdev_b._which, 
subdev_b, f), frequency_b)
-               fg.add_callback(subdev_b.set_gain, gain_b) #callback for gain 
setting
+               _setup_tx_subdev(fg, u, (1, 0), gain_b, freq_b, 
auto_tr.parse(), tx_enb_b.parse())      
                ###     Create an interleaver for the 2 data streams    ###
                inter = gr.interleave(type.parse()[1].get_num_bytes())
                fg.connect(inter, u)
                return inter
        return sb, make
-
-def USRPDualSource(sb):
-       from gnuradio import usrp
-       default_mux = '0x3210'
-       type = Enum([('Complex', (usrp.source_c, Complex())), ('IShort', 
(usrp.source_s, Short()))])
-       sb.add_output_socket('out0', Variable(type, index=1))
-       sb.add_output_socket('out1', Variable(type, index=1))
-       sb.add_param('Output Type', type, False, type=True)
-       sb.add_param('Unit Number', Int(0, min=0))
-       sb.add_param('Ch0: Side:Subdevice', Enum([
-               ('Side A:0', (0, 0)), 
-               ('Side B:0', (1, 0)),
-               ('Side A:1', (0, 1)), 
-               ('Side B:1', (1, 1)),
-       ]))
-       sb.add_param('Ch1: Side:Subdevice', Enum([
-               ('Side A:0', (0, 0)), 
-               ('Side B:0', (1, 0)),
-               ('Side A:1', (0, 1)), 
-               ('Side B:1', (1, 1)),
-       ]))
-       sb.add_param('Frequency0', Float(), variable=True)
-       sb.add_param('Frequency1', Float(), variable=True)
-       sb.add_param('Decimation', Int(200, min=1))
-       sb.add_param('Gain0', Float(0), variable=True)  
-       sb.add_param('Gain1', Float(0), variable=True)
-       sb.add_param('Mux', Hex(default_mux))   
-       sb.set_docs('''\
-The USRP source outputs 64 Megasamples per second / decimation. \
-Default mux is %s.
-Channel 0 (I & Q) will get ADC0 and ADC1
-Channel 1 (I & Q) will get ADC2 and ADC3'''%default_mux)
-       def make(fg, type, number, subdev_spec_0, subdev_spec_1, frequency_0, 
frequency_1, decim, gain_0, gain_1, mux):
-               number = number.parse()
-               u = type.parse()[0](number, nchan=2)            
-               u.set_decim_rate(decim.parse())
-               u.set_mux(mux.parse())
-               # setup 0       #               
-               subdev_0 = usrp.selected_subdev(u, subdev_spec_0.parse())#get 
the subdev
-               subdev_0.set_auto_tr(True)
-               subdev_0.set_gain(gain_0.parse())
-               set_freq(u, 0, subdev_0, frequency_0.parse(), verbose=True)     
#use DDC0
-               fg.add_callback(lambda f: set_freq(u, 0, subdev_0, f), 
frequency_0)
-               fg.add_callback(subdev_0.set_gain, gain_0) #callback for gain 
setting
-               #       setup 1 #
-               subdev_1 = usrp.selected_subdev(u, subdev_spec_1.parse())#get 
the subdev
-               subdev_1.set_auto_tr(True)
-               subdev_1.set_gain(gain_1.parse())
-               set_freq(u, 1, subdev_1, frequency_1.parse(), verbose=True)     
#use DDC1
-               fg.add_callback(lambda f: set_freq(u, 1, subdev_1, f), 
frequency_1)
-               fg.add_callback(subdev_1.set_gain, gain_1) #callback for gain 
setting
-               ###     Create an interleaver for the 2 data streams    ###
-               deinter = gr.deinterleave(type.parse()[1].get_num_bytes())
-               fg.connect(u, deinter)
-               return deinter
-       return sb, make 
        
        
\ No newline at end of file