[Discuss-gnuradio] cannot transmit (USRP2+xcvr2450)

[Xiaolong Li]

Hello all,

I am using a USRP2+xcvr2450 with the latest trunk of GNU Radio (just 
compiled/update the firmware and updated FPGA code to the latest release), 
and FC 10 as the OS. I tried to use TCP/IP statck over USRP2 with modified 
tunnel.py, transmit_path.py and receive_path.py. I used one USRP2 and one 
USRP1 and ping USRP2 from USRP1. The USRP2 can receive the packets from 
USRP1, but the USRP1 cannot receive anything from USRP2. On USRP2 side, I 
can see packets going back and forth over the ethernet link via wireshark. I 
noticed that USRP1 code uses "set_auto_tr" to enable auto switching between 
tx and rx. however, no such function available for USRP2. I am wondering if 
this causes the problem and how to fix it. Below is my code for transmit 
path. Thanks.

class transmit_path_usrp2(gr.hier_block2):
   def __init__(self, modulator_class, options):
       '''
       See below for what options should hold
       '''
gr.hier_block2.__init__(self, "transmit_path",
                               gr.io_signature(0, 0, 0), # Input signature
                               gr.io_signature(0, 0, 0)) # Output signature

       options = copy.copy(options)    # make a copy so we can 
destructively modify

       self._which              = options.which           # the USRP board 
attached
       self._verbose            = options.verbose
       self._tx_freq            = options.tx_freq         # tranmitter's 
center frequency
       self._tx_amplitude       = options.tx_amplitude    # digital 
amplitude sent to USRP
       self._tx_subdev_spec     = options.tx_subdev_spec  # daughterboard 
to use
       self._bitrate            = options.bitrate         # desired bit 
rate
       self._interp             = options.interp          # interpolating 
rate for the USRP (prelim)
       self._samples_per_symbol = options.samples_per_symbol  # desired 
samples/baud
       self._fusb_block_size    = options.fusb_block_size # usb info for 
USRP
       self._fusb_nblocks       = options.fusb_nblocks    # usb info for 
USRP
       self._use_whitener_offset = options.use_whitener_offset # increment 
start of whitener XOR data


       self._interface = options.interface
       self._mac_addr = options.mac_addr

       self._modulator_class = modulator_class         # the 
modulator_class we are using

       if self._tx_freq is None:
           sys.stderr.write("-f FREQ or --freq FREQ or --tx-freq FREQ must 
be specified\n")
           raise SystemExit

       # Set up USRP sink; also adjusts interp, samples_per_symbol, and 
bitrate
       # self._setup_usrp_sink()

       self.u = usrp2.sink_32fc(self._interface, self._mac_addr)

       dac_rate = self.u.dac_rate();

       # derive values of bitrate, samples_per_symbol, and interp from 
desired info
       (self._bitrate, self._samples_per_symbol, self._interp) = \
           pick_tx_bitrate(self._bitrate, 
self._modulator_class.bits_per_symbol(),
                           self._samples_per_symbol, self._interp, 
dac_rate)

       self.u.set_interp(self._interp)

       # copy the final answers back into options for use by modulator
       options.samples_per_symbol = self._samples_per_symbol
       options.bitrate = self._bitrate
       options.interp = self._interp

       # Get mod_kwargs
       mod_kwargs = 
self._modulator_class.extract_kwargs_from_options(options)

       # Set center frequency of USRP2
       #ok = self.set_freq(self._tx_freq)
       #if not ok:
       #    print "Failed to set Tx frequency to %s" % 
(eng_notation.num_to_str(self._tx_freq),)
       #    raise ValueError

       # Tune the USRP2 FPGA and daughterboard to the requested center 
frequency
       # and LO offset
       if options.lo_offset is not None:
           self.u.set_lo_offset(options.lo_offset)
       print options.tx_freq
       tr = self.u.set_center_freq(options.tx_freq)
       if tr == None:
           sys.stderr.write('Failed to set center frequency\n')
           raise SystemExit, 1

       # transmitter
       self.packet_transmitter = \
           blks2.mod_pkts(self._modulator_class(**mod_kwargs),
                          access_code=None,
                          msgq_limit=4,
                          pad_for_usrp=True,
                          use_whitener_offset=options.use_whitener_offset)

       # Set the Tx daughterboard gain as requested
       if options.gain is None:
           g = self.u.gain_range()
           options.gain = float(g[0]+g[1])/2
        self.u.set_gain(options.gain)

       # Set the USRP for maximum transmit gain
       # (Note that on the RFX cards this is a nop.)
       #self.set_gain(self.subdev.gain_range()[1])

       self.amp = gr.multiply_const_cc(1)
       self.set_tx_amplitude(self._tx_amplitude)
       # enable Auto Transmit/Receive switching
       #self.set_auto_tr(True)

       # Display some information about the setup
       if self._verbose:
           self._print_verbage()

       # Create and setup transmit path flow graph
       self.connect(self.packet_transmitter, self.amp, self.u)


Best regards
Sean