Forum: GNU Radio [Douglas BBN 802.11b] Porting code on USRP2 problems

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Costantini, Andrea (Guest)
on 2009-03-26 16:50
(Received via mailing list)
Dear all,

I'm trying to port the Douglas BBN 802.11b code on the USRP2 working
with the last version of GNU-Radio (3.2SVN)

The last version of Douglas bbn 802.11b already work with hier_blok2 but
not with USRP2, so,

in order to do this porting I followed the recommendations below :


-
http://www.opensubscriber.com/message/removed_emai...

- http://sdrblog.wordpress.com/2009/03/12/port-usrp1...


I just have modified the files "bbn_80211b_tx.py" and
"bbn_80211b_transmit_path.py" because

it should be by means of these ones that we can access to USRP2.

I obtain the following error:


Traceback (most recent call last):
  File "bbn_80211b_tx.py", line 108, in <module>
    main()
  File "bbn_80211b_tx.py", line 72, in main
    tb = my_block(options.interp, options.spb, options.barker)
  File "bbn_80211b_tx.py", line 22, in __init__
    self.txpath = bbn_80211b_transmit_path(interp_rate, spb, use_barker)
  File
"/home/usrptest1/bbn_80211_doug/src/examples/bbn_80211b_transmit_path.py",
line 44, in __init__
    self.packet_transmitter = bbn_80211b_mod_pkts(tb, spb=spb,
NameError: global name 'tb' is not defined

I am not able to solve this error and debug the new code :-(

Any suggestion about this porting will be welcome

Best regards   Andrea


Here below there are my two modified codes:

##################################################
#                              bbn_802.11b_tx.py
##################################################
from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option
from optparse import OptionParser

import random
import time
import struct
import sys

     # from current dir
from bbn_80211b_transmit_path import bbn_80211b_transmit_path

class my_block(gr.top_block):

            def __init__(self, interp_rate, spb, use_barker):
             gr.top_block.__init__(self)
             self.txpath = bbn_80211b_transmit_path(interp_rate, spb,
use_barker)


         #def __init__(self, tx_subdev_spec, interp_rate, spb,
use_barker):
            # gr.flow_graph.__init__(self)
            # self.txpath = bbn_80211b_transmit_path(tx_subdev_spec, \
                                                   #interp_rate, spb,
use_barker)


     #
/////////////////////////////////////////////////////////////////////////////
     #                                   main
     #
/////////////////////////////////////////////////////////////////////////////

def main():

         def send_pkt(payload='', eof=False):
             return tb.txpath.send_pkt(payload, eof)

         def rx_callback(ok, payload):
             print "ok = %r, payload = '%s'" % (ok, payload)

         parser = OptionParser (option_class=eng_option)
         #parser.add_option("-T", "--tx-subdev-spec", type="subdev",
default=None,
                          # help="select USRP Tx side A or B")
         parser.add_option("-f", "--freq", type="eng_float",
default=2.4e9,
                            help= \
                           "set Tx and Rx frequency to FREQ
[default=%default]",
                           metavar="FREQ")
         parser.add_option("-S", "--spb", type="int", default=8,
                           help="set samples/baud [default=%default]")
         parser.add_option("-i", "--interp", type="int", default=32,
                           help=
                           "set fpga interpolation rate to INTERP
[default=%default]")
         parser.add_option("-r", "--reps", type="int", default=20,
                           help=
                           "Number of packets to send
[default=%default]")
         parser.add_option("-b", "--barker", action="store_true",
                           default=False,
                           help="Use Barker Spreading
[default=%default]")

         (options, args) = parser.parse_args ()

         if len(args) != 0:
             parser.print_help()
             sys.exit(1)

         if options.freq < 1e6:
             options.freq *= 1e6

         # build the graph
         tb = my_block(options.interp, options.spb, options.barker)


         #print "bitrate: %sb/sec" %
(eng_notation.num_to_str(tb.txpath.bitrate()),)
         print "spb:     %3d" % (tb.txpath.spb(),)
         print "interp:  %3d" % (tb.txpath.interp(),)

         ok = tb.txpath.set_freq(options.freq)
         if not ok:
             print "Failed to set Tx frequency to %s" %
(eng_notation.num_to_str(options.freq),)
             raise SystemExit

         tb.start()                       # start flow graph

         # generate and send packets
         n = 0

         fp = open('getty.txt')
         lines = fp.readlines()
         payload = ""
         i = 0;
         while i < len(lines):
             payload = payload + lines[i]
             i = i + 1

         while n < options.reps:
             send_pkt(payload, False);
             n = n + 1

         time.sleep(1)
         send_pkt(eof=True)
         tb.wait()                       # wait for it to finish


if __name__ == '__main__':
         try:
             main()
         except KeyboardInterrupt:
             pass



##################################################
#                              bbn_802.11b_trasmit_path.py
##################################################
from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from bbn_80211b_pkt import *

     #
/////////////////////////////////////////////////////////////////////////////
     #                              transmit path
     #
/////////////////////////////////////////////////////////////////////////////

class bbn_80211b_transmit_path(gr.hier_block2):
         def __init__(self, interp, spb, use_barker):   #def
__init__(self, subdev_spec, interp, spb, use_barker):

             self.normal_gain = 28000

                self.u = usrp2.sink_32fc()       #self.u = usrp.sink_c()
             dac_rate = self.u.dac_rate();

             self._spb = spb
             self._interp=int(interp)
             self.u.set_interp(self._interp)   #
self.u.set_interp_rate(self._interp)

             # determine the daughterboard subdevice we're using
             #if subdev_spec is None:
                 #subdev_spec = usrp.pick_tx_subdevice(self.u)

             #self.u.set_mux(usrp.determine_tx_mux_value(self.u,
subdev_spec))
             #self.subdev = usrp.selected_subdev(self.u, subdev_spec)
             #print "Using TX d'board %s" %
(self.subdev.side_and_name(),)


********************************transmitter**************************************
             """self.packet_transmitter = bbn_80211b_mod_pkts(fg,
spb=spb,
                                                           alpha=0.5,

gain=self.normal_gain,

use_barker=use_barker)
             fg.connect(self.packet_transmitter, self.u)
        gr.hier_block.__init__(self, fg, None, None)

             self.set_gain(self.subdev.gain_range()[1])  # set max Tx
gain
             self.set_auto_tr(True)    # enable Auto Transmit/Receive
switching"""


                self.packet_transmitter = bbn_80211b_mod_pkts(tb,
spb=spb,
                                                           alpha=0.5,

gain=self.normal_gain,

use_barker=use_barker)
             tb.connect(self.packet_transmitter, self.u)
             gr.hier_block.__init__(self, tb, None, None)

             self.set_gain(self.usrp2.gain_range()[1])
             self.set_auto_tr(True)    # enable Auto Transmit/Receive
switching

***************************************************************************************


         def set_freq(self, target_freq):
             """
             Set the center frequency we're interested in.

             @param target_freq: frequency in Hz
             @rypte: bool

             Tuning is a two step process.  First we ask the front-end
to
             tune as close to the desired frequency as it can.  Then we
use
             the result of that operation and our target_frequency to
             determine the value for the digital up converter.  Finally,
we feed
             any residual_freq to the s/w freq translater.
             """
             r = self.u.set_center_freq(target_freq)  # r =
self.u.tune(self.subdev.which(), self.subdev, target_freq)
             if r:
                 # Could use residual_freq in s/w freq translator
                 return True

             return False

         def set_gain(self, gain):
             self.gain = gain
             self.usrp2.set_gain(gain)   #self.subdev.set_gain(gain)

         #def set_auto_tr(self, enable):
             #return self.subdev.set_auto_tr(enable)

         def send_pkt(self, payload='', eof=False):
             return self.packet_transmitter.send_pkt(payload, eof)

         def spb(self):
             return self._spb

         def interp(self):
             return self._interp
This topic is locked and can not be replied to.