Forum: GNU Radio cannot transmit (USRP2+xcvr2450)

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.
512d119a5dc9ca22a50bafd2a51d9e7f?d=identicon&s=25 Xiaolong Li (Guest)
on 2009-02-25 02:42
(Received via mailing list)
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
This topic is locked and can not be replied to.