Forum: GNU Radio USRP2 benchmark_rx.py, benchmark_tx.py, transmit_path_usrp2.py, receive_path_usrp2.py, pick_bitrate.

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.
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-14 22:50
(Received via mailing list)
Hi,

I am trying to establish communication between USRP2 and USRP1. I am
using
RFX2400 daughterboard. I am using Ubuntu 8.10. I am using the svn
version of
GNU Radio. I dont know the revision number. I am not able to receive
anything on USRP2 when USRP1 is transmitting and vice versa. The python
codes for USRP2 work perfectly fine. I guess there is some problem with
the
ADC and DAC incompatibility (interpolation and decimation) between USRP2
and
USRP1. I am attaching all the necessary files that I am using currently.
I
would appreciate if someone can look at these files and help me to sort
out
the problem.

benchmark_tx.py

#!/usr/bin/env python
#
# Copyright 2005, 2006, 2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gru, modulation_utils
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 transmit_path_usrp2 import transmit_path
import fusb_options

#import os
#print os.getpid()
#raw_input('Attach and press enter')

class my_top_block(gr.top_block):
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)
        self.txpath = transmit_path(modulator, options)
        self.connect(self.txpath)

#
/////////////////////////////////////////////////////////////////////////////
#                                   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)

    mods = modulation_utils.type_1_mods()

    parser = OptionParser(option_class=eng_option,
conflict_handler="resolve")
    expert_grp = parser.add_option_group("Expert")

    parser.add_option("-m", "--modulation", type="choice",
choices=mods.keys(),
                      default='gmsk',
                      help="Select modulation from: %s
[default=%%default]"
                            % (', '.join(mods.keys()),))

    parser.add_option("-s", "--size", type="eng_float", default=1500,
                      help="set packet size [default=%default]")
    parser.add_option("-M", "--megabytes", type="eng_float",
default=1.0,
                      help="set megabytes to transmit
[default=%default]")
    parser.add_option("","--discontinuous", action="store_true",
default=False,
                      help="enable discontinous transmission (bursts of
5
packets)")
    parser.add_option("","--from-file", default=None,
                      help="use file for packet contents")

    transmit_path.add_options(parser, expert_grp)

    for mod in mods.values():
        mod.add_options(expert_grp)

    fusb_options.add_options(expert_grp)
    (options, args) = parser.parse_args ()

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

    if options.tx_freq is None:
        sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        parser.print_help(sys.stderr)
        sys.exit(1)

    if options.from_file is not None:
        source_file = open(options.from_file, 'r')

    # build the graph
    tb = my_top_block(mods[options.modulation], options)

    r = gr.enable_realtime_scheduling()
    if r != gr.RT_OK:
        print "Warning: failed to enable realtime scheduling"

    tb.start()                       # start flow graph

    # generate and send packets
    nbytes = int(1e6 * options.megabytes)
    n = 0
    pktno = 0
    pkt_size = int(options.size)

    while n < nbytes:
        if options.from_file is None:
            data = (pkt_size - 2) * chr(pktno & 0xff)
        else:
            data = source_file.read(pkt_size - 2)
            if data == '':
                break;

        payload = struct.pack('!H', pktno & 0xffff) + data
        send_pkt(payload)
        n += len(payload)
        sys.stderr.write('.')
        if options.discontinuous and pktno % 5 == 4:
            time.sleep(1)
        pktno += 1

    send_pkt(eof=True)

    tb.wait()                       # wait for it to finish

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


transmit_path_usrp2.py

#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from gnuradio import eng_notation

import copy
import sys

# from current dir
from pick_bitrate import pick_tx_bitrate

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

class transmit_path(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._interface          = options.interface           # the
USRP
board attached
  self._mac_addr           = options.mac_addr
        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._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()

        # 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 USRP
        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

        # 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 USRP for maximum transmit gain
        # (Note that on the RFX cards this is a nop.)
        self.set_gain(self.u.gain_range()[1])

        self.amp = gr.multiply_const_cc(1)
        self.set_tx_amplitude(self._tx_amplitude)

        # enable Auto Transmit/Receive switching
        #fiske_removed 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)

    def _setup_usrp_sink(self):
        """
        Creates a USRP sink, determines the settings for best bitrate,
        and attaches to the transmitter's subdevice.
        """
        #self.u = usrp2.source_32fc(options.interface, options.mac_addr)
  #self.u = usrp2.sink_32fc (options._interface, options._mac_addr)
  self.u = usrp2.sink_32fc("eth0","00:50:C2:85:31:5A")  #fiske hard
coded
  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)

        #fiske_removed self.u.set_interp_rate(self._interp)

        # determine the daughterboard subdevice we're using
        #if self._tx_subdev_spec is None:
        #    self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
        #self.u.set_mux(usrp.determine_tx_mux_value(self.u,
self._tx_subdev_spec))
        #self.subdev = usrp.selected_subdev(self.u,
self._tx_subdev_spec)


    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.
        """
        r = self.u.set_center_freq(target_freq)
        if r:
            return True

        return False

    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        self.gain = gain
        self.u.set_gain(gain)

    def set_tx_amplitude(self, ampl):
        """
        Sets the transmit amplitude sent to the USRP
        @param: ampl 0 <= ampl < 32768.  Try 8000
        """
        self._tx_amplitude = max(0.0, min(ampl, 32767.0))
        self.amp.set_k(self._tx_amplitude)

    def set_auto_tr(self, enable):
        """
        Turns on auto transmit/receive of USRP daughterboard (if exits;
else
ignored)
        """
        return self.u.set_auto_tr(enable)

    def send_pkt(self, payload='', eof=False):
        """
        Calls the transmitter method to send a packet
        """
        return self.packet_transmitter.send_pkt(payload, eof)

    def bitrate(self):
        return self._bitrate

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def interp(self):
        return self._interp

    def add_options(normal, expert):
        """
        Adds transmitter-specific options to the Options Parser
        """
        add_freq_option(normal)
        if not normal.has_option('--bitrate'):
            normal.add_option("-r", "--bitrate", type="eng_float",
default=None,
                              help="specify bitrate.  samples-per-symbol
and
interp/decim will be derived.")
        normal.add_option("-e", "--interface", type="string",
default="eth0",
                          help="select Ethernet interface, default is
eth0")
        normal.add_option("-m", "--mac-addr", type="string", default="",
                          help="select USRP by MAC address, default is
auto-select")
        #normal.add_option("-T", "--tx-subdev-spec", type="subdev",
default=None,
        #                  help="select USRP Tx side A or B")
        normal.add_option("", "--tx-amplitude", type="eng_float",
default=12000, metavar="AMPL",
                          help="set transmitter digital amplitude: 0 <=
AMPL
< 32768 [default=%default]")
        normal.add_option("-v", "--verbose", action="store_true",
default=False)

        expert.add_option("-S", "--samples-per-symbol", type="int",
default=None,
                          help="set samples/symbol [default=%default]")
        expert.add_option("", "--tx-freq", type="eng_float",
default=None,
                          help="set transmit frequency to FREQ
[default=%default]", metavar="FREQ")
        expert.add_option("-i", "--interp", type="intx", default=None,
                          help="set fpga interpolation rate to INTERP
[default=%default]")
        expert.add_option("", "--log", action="store_true",
default=False,
                          help="Log all parts of flow graph to file
(CAUTION: lots of data)")
        expert.add_option("","--use-whitener-offset",
action="store_true",
default=False,
                          help="make sequential packets use different
whitening")

    # Make a static method to call before instantiation
    add_options = staticmethod(add_options)

    def _print_verbage(self):
        """
        Prints information about the transmit path
        """
        print "Using TX d'board %s"    % (self.u.daughterboard_id(),)
        print "Tx amplitude     %s"    % (self._tx_amplitude)
        print "modulation:      %s"    %
(self._modulator_class.__name__)
        print "bitrate:         %sb/s" %
(eng_notation.num_to_str(self._bitrate))
        print "samples/symbol:  %3d"   % (self._samples_per_symbol)
        print "interp:          %3d"   % (self._interp)
        print "Tx Frequency:    %s"    %
(eng_notation.num_to_str(self._tx_freq))


def add_freq_option(parser):
    """
    Hackery that has the -f / --freq option set both tx_freq and rx_freq
    """
    def freq_callback(option, opt_str, value, parser):
        parser.values.rx_freq = value
        parser.values.tx_freq = value

    if not parser.has_option('--freq'):
        parser.add_option('-f', '--freq', type="eng_float",
                          action="callback", callback=freq_callback,
                          help="set Tx and/or Rx frequency to FREQ
[default=%default]",
                          metavar="FREQ")

benchmark_rx.py

#!/usr/bin/env python
#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gru, modulation_utils
from gnuradio import usrp2
from gnuradio import eng_notation
from gnuradio.eng_option import eng_option
from optparse import OptionParser

import random
import struct
import sys

# from current dir
from receive_path_usrp2 import receive_path
import fusb_options

#import os
#print os.getpid()
#raw_input('Attach and press enter: ')

class my_top_block(gr.top_block):
    def __init__(self, demodulator, rx_callback, options):
        gr.top_block.__init__(self)
        self.rxpath = receive_path(demodulator, rx_callback, options)
        self.connect(self.rxpath)

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

global n_rcvd, n_right

def main():
    global n_rcvd, n_right

    n_rcvd = 0
    n_right = 0

    def rx_callback(ok, payload):
        global n_rcvd, n_right
        (pktno,) = struct.unpack('!H', payload[0:2])
        n_rcvd += 1
        if ok:
            n_right += 1

        print "ok = %5s  pktno = %4d  n_rcvd = %4d  n_right = %4d" % (
            ok, pktno, n_rcvd, n_right)


    demods = modulation_utils.type_1_demods()

    # Create Options Parser:
    parser = OptionParser (option_class=eng_option,
conflict_handler="resolve")
    expert_grp = parser.add_option_group("Expert")

    parser.add_option("-m", "--modulation", type="choice",
choices=demods.keys(),
                      default='gmsk',
                      help="Select modulation from: %s
[default=%%default]"
                            % (', '.join(demods.keys()),))

    receive_path.add_options(parser, expert_grp)

    for mod in demods.values():
        mod.add_options(expert_grp)

    fusb_options.add_options(expert_grp)
    (options, args) = parser.parse_args ()

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

    if options.rx_freq is None:
        sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
        parser.print_help(sys.stderr)
        sys.exit(1)


    # build the graph
    tb = my_top_block(demods[options.modulation], rx_callback, options)

    r = gr.enable_realtime_scheduling()
    if r != gr.RT_OK:
        print "Warning: Failed to enable realtime scheduling."

    tb.start()        # start flow graph
    tb.wait()         # wait for it to finish

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

receive_path_usrp2.py

#!/usr/bin/env python
#
# Copyright 2005,2006,2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gru, blks2
from gnuradio import usrp2
from gnuradio import eng_notation
import copy
import sys

# from current dir
from pick_bitrate import pick_rx_bitrate

#
/////////////////////////////////////////////////////////////////////////////
#                              receive path
#
/////////////////////////////////////////////////////////////////////////////

class receive_path(gr.hier_block2):
    def __init__(self, demod_class, rx_callback, options):

  gr.hier_block2.__init__(self, "receive_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._interface          = options.interface           # the
USRP
board attached
  self._mac_addr           = options.mac_addr
        self._verbose            = options.verbose
        self._rx_freq            = options.rx_freq         # receiver's
center frequency
        self._rx_gain            = options.rx_gain         # receiver's
gain
        #self._rx_subdev_spec     = options.rx_subdev_spec  #
daughterboard
to use
        self._bitrate            = options.bitrate         # desired bit
rate
        self._decim              = options.decim           # Decimating
rate
for the USRP (prelim)
  self._samples_per_symbol = options.samples_per_symbol  # desired
samples/symbol
  self._fusb_block_size    = options.fusb_block_size # usb info for USRP
        self._fusb_nblocks       = options.fusb_nblocks    # usb info
for
USRP

        self._rx_callback   = rx_callback      # this callback is fired
when
there's a packet available
        self._demod_class   = demod_class      # the demodulator_class
we're
using

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

        # Set up USRP source; also adjusts decim, samples_per_symbol,
and
bitrate
        self._setup_usrp_source()

        g = self.u.gain_range()
        if options.show_rx_gain_range:
            print "Rx Gain Range: minimum = %g, maximum = %g, step size
=
%g" \
                  % (g[0], g[1], g[2])

        self.set_gain(options.rx_gain)

        self.set_auto_tr(True)                 # enable Auto
Transmit/Receive switching

        # Set RF frequency
        ok = self.set_freq(self._rx_freq)
        if not ok:
            print "Failed to set Rx frequency to %s" %
(eng_notation.num_to_str(self._rx_freq))
            raise ValueError, eng_notation.num_to_str(self._rx_freq)

        # copy the final answers back into options for use by
demodulator
        options.samples_per_symbol = self._samples_per_symbol
        options.bitrate = self._bitrate
        options.decim = self._decim

        # Get demod_kwargs
        demod_kwargs =
self._demod_class.extract_kwargs_from_options(options)
  # Fix USRP2 -> USRP1 scaling
  self.scale = gr.multiply_const_cc(32768)
        # Design filter to get actual channel we want
        sw_decim = 1
        chan_coeffs = gr.firdes.low_pass (1.0,                  # gain
                                          sw_decim *
self._samples_per_symbol, # sampling rate
                                          1.0,                  #
midpoint
of trans. band
                                          0.5,                  # width
of
trans. band
                                          gr.firdes.WIN_HANN)   # filter
type

        # Decimating channel filter
        # complex in and out, float taps
        self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
        #self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)

        # receiver
        self.packet_receiver = \
            blks2.demod_pkts(self._demod_class(**demod_kwargs),
                             access_code=None,
                             callback=self._rx_callback,
                             threshold=-1)

        # Carrier Sensing Blocks
        alpha = 0.001
        thresh = 30   # in dB, will have to adjust

        if options.log_rx_power == True:
            self.probe = gr.probe_avg_mag_sqrd_cf(thresh,alpha)
            self.power_sink = gr.file_sink(gr.sizeof_float,
"rxpower.dat")
            self.connect(self.chan_filt, self.probe, self.power_sink)
        else:
            self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
            self.connect(self.chan_filt, self.probe)

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

        self.connect(self.u, self.scale, self.chan_filt,
self.packet_receiver)

    def _setup_usrp_source(self):
        self.u = usrp2.source_32fc (self._interface, self._mac_addr)
  adc_rate = self.u.adc_rate()

        # derive values of bitrate, samples_per_symbol, and decim from
desired info
        (self._bitrate, self._samples_per_symbol, self._decim) = \
            pick_rx_bitrate(self._bitrate,
self._demod_class.bits_per_symbol(), \
                            self._samples_per_symbol, self._decim,
adc_rate)

        self.u.set_decim(self._decim)
        # determine the daughterboard subdevice we're using
        #if self._rx_subdev_spec is None:
        #    self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
        #self.subdev = usrp.selected_subdev(self.u,
self._rx_subdev_spec)

        #self.u.set_mux(usrp.determine_rx_mux_value(self.u,
self._rx_subdev_spec))

    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.
        """
        r = self.u.set_center_freq(target_freq)
        if r:
            return True

        return False

    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        if gain is None:
            r = self.u.gain_range()
            gain = (r[0] + r[1])/2               # set gain to midpoint
        self.gain = gain
        return self.u.set_gain(gain)

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

    def bitrate(self):
        return self._bitrate

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def decim(self):
        return self._decim

    def carrier_sensed(self):
        """
        Return True if we think carrier is present.
        """
        #return self.probe.level() > X
        return self.probe.unmuted()

    def carrier_threshold(self):
        """
        Return current setting in dB.
        """
        return self.probe.threshold()

    def set_carrier_threshold(self, threshold_in_db):
        """
        Set carrier threshold.

        @param threshold_in_db: set detection threshold
        @type threshold_in_db:  float (dB)
        """
        self.probe.set_threshold(threshold_in_db)


    def add_options(normal, expert):
        """
        Adds receiver-specific options to the Options Parser
        """
        add_freq_option(normal)
        if not normal.has_option("--bitrate"):
            normal.add_option("-r", "--bitrate", type="eng_float",
default=None,
                              help="specify bitrate.  samples-per-symbol
and
interp/decim will be derived.")
        normal.add_option("-e", "--interface", type="string",
default="eth0",
                          help="select Ethernet interface, default is
eth0")
        normal.add_option("-m", "--mac-addr", type="string", default="",
                          help="select USRP by MAC address, default is
auto-select")
        #normal.add_option("-R", "--rx-subdev-spec", type="subdev",
default=None,
        #                  help="select USRP Rx side A or B")
        normal.add_option("", "--rx-gain", type="eng_float",
default=None,
metavar="GAIN",
                          help="set receiver gain in dB
[default=midpoint].
See also --show-rx-gain-range")
        normal.add_option("", "--show-rx-gain-range",
action="store_true",
default=False,
                          help="print min and max Rx gain available on
selected daughterboard")
        normal.add_option("-v", "--verbose", action="store_true",
default=False)
        expert.add_option("-S", "--samples-per-symbol", type="int",
default=None,
                          help="set samples/symbol [default=%default]")
        expert.add_option("", "--rx-freq", type="eng_float",
default=None,
                          help="set Rx frequency to FREQ
[default=%default]", metavar="FREQ")
        expert.add_option("-d", "--decim", type="intx", default=None,
                          help="set fpga decimation rate to DECIM
[default=%default]")
        expert.add_option("", "--log", action="store_true",
default=False,
                          help="Log all parts of flow graph to files
(CAUTION: lots of data)")
        expert.add_option("", "--log-rx-power", action="store_true",
default=False,
                          help="Log receive signal power to file
(CAUTION:
lots of data)")

    # Make a static method to call before instantiation
    add_options = staticmethod(add_options)


    def _print_verbage(self):
        """
        Prints information about the receive path
        """
        print "\nReceive Path:"
        print "Using RX d'board %s"    % (self.u.daughterboard_id(),)
        print "Rx gain:         %g"    % (self.gain,)
        print "modulation:      %s"    % (self._demod_class.__name__)
        print "bitrate:         %sb/s" %
(eng_notation.num_to_str(self._bitrate))
        print "samples/symbol:  %3d"   % (self._samples_per_symbol)
        print "decim:           %3d"   % (self._decim)
        print "Rx Frequency:    %s"    %
(eng_notation.num_to_str(self._rx_freq))
        # print "Rx Frequency:    %f"    % (self._rx_freq)

    def __del__(self):
        # Avoid weak reference error
        #del self.subdev
  return

def add_freq_option(parser):
    """
    Hackery that has the -f / --freq option set both tx_freq and rx_freq
    """
    def freq_callback(option, opt_str, value, parser):
        parser.values.rx_freq = value
        parser.values.tx_freq = value

    if not parser.has_option('--freq'):
        parser.add_option('-f', '--freq', type="eng_float",
                          action="callback", callback=freq_callback,
                          help="set Tx and/or Rx frequency to FREQ
[default=%default]",
                          metavar="FREQ")

pick_bitrate.py

#
# Copyright 2005,2006 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

_default_bitrate = 500e3

_valid_samples_per_symbol = (2,3,4,5,6,7)

def _gen_tx_info(converter_rate):
    results = []
    for samples_per_symbol in _valid_samples_per_symbol:
        for interp in range(16, 512 + 1, 4):
            bitrate = converter_rate / interp / samples_per_symbol
            results.append((bitrate, samples_per_symbol, interp))
    results.sort()
    return results

def _gen_rx_info(converter_rate):
    results = []
    for samples_per_symbol in _valid_samples_per_symbol:
        for decim in range(8, 256 + 1, 2):
            bitrate = converter_rate / decim / samples_per_symbol
            results.append((bitrate, samples_per_symbol, decim))
    results.sort()
    return results

def _filter_info(info, samples_per_symbol, xrate):
    if samples_per_symbol is not None:
        info = [x for x in info if x[1] == samples_per_symbol]
    if xrate is not None:
        info = [x for x in info if x[2] == xrate]
    return info

def _pick_best(target_bitrate, bits_per_symbol, info):
    """
    @returns tuple (bitrate, samples_per_symbol,
interp_rate_or_decim_rate)
    """
    if len(info) == 0:
        raise RuntimeError, "info is zero length!"

    if target_bitrate is None:     # return the fastest one
        return info[-1]

    # convert bit rate to symbol rate
    target_symbolrate = target_bitrate / bits_per_symbol

    # Find the closest matching symbol rate.
    # In the event of a tie, the one with the lowest samples_per_symbol
wins.
    # (We already sorted them, so the first one is the one we take)

    best = info[0]
    best_delta = abs(target_symbolrate - best[0])
    for x in info[1:]:
        delta = abs(target_symbolrate - x[0])
        if delta < best_delta:
            best_delta = delta
            best = x

    # convert symbol rate back to bit rate
    return ((best[0] * bits_per_symbol),) + best[1:]

def _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                  xrate, converter_rate, gen_info):
    """
    @returns tuple (bitrate, samples_per_symbol,
interp_rate_or_decim_rate)
    """
    if not isinstance(bits_per_symbol, int) or bits_per_symbol < 1:
        raise ValueError, "bits_per_symbol must be an int >= 1"

    if samples_per_symbol is not None and xrate is not None:  #
completely
determined
        return (float(converter_rate) / xrate / samples_per_symbol,
                samples_per_symbol, xrate)

    if bitrate is None and samples_per_symbol is None and xrate is None:
        bitrate = _default_bitrate

    # now we have a target bitrate and possibly an xrate or
    # samples_per_symbol constraint, but not both of them.

    return _pick_best(bitrate, bits_per_symbol,
                      _filter_info(gen_info(converter_rate),
samples_per_symbol, xrate))

#
---------------------------------------------------------------------------------------

def pick_tx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                    interp_rate, converter_rate=128e6):
    """
    Given the 4 input parameters, return at configuration that matches

    @param bitrate: desired bitrate or None
    @type bitrate: number or None
    @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
    @type bits_per_symbol: integer >= 1
    @param samples_per_symbol: samples/baud (aka samples/symbol)
    @type samples_per_symbol: number or None
    @param interp_rate: USRP interpolation factor
    @type interp_rate: integer or None
    @param converter_rate: converter sample rate in Hz
    @type converter_rate: number

    @returns tuple (bitrate, samples_per_symbol, interp_rate)
    """
    return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                         interp_rate, converter_rate, _gen_tx_info)


def pick_rx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                    decim_rate, converter_rate=64e6):
    """
    Given the 4 input parameters, return at configuration that matches

    @param bitrate: desired bitrate or None
    @type bitrate: number or None
    @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
    @type bits_per_symbol: integer >= 1
    @param samples_per_symbol: samples/baud (aka samples/symbol)
    @type samples_per_symbol: number or None
    @param decim_rate: USRP decimation factor
    @type decim_rate: integer or None
    @param converter_rate: converter sample rate in Hz
    @type converter_rate: number

    @returns tuple (bitrate, samples_per_symbol, decim_rate)
    """
    return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
                         decim_rate, converter_rate, _gen_rx_info)

Thanks in advance for your cooperation.

Smith http://www.nabble.com/file/p23047724/benchmark_rx.py
benchmark_rx.py
http://www.nabble.com/file/p23047724/benchmark_tx.py benchmark_tx.py
http://www.nabble.com/file/p23047724/receive_path_usrp2.py
receive_path_usrp2.py
http://www.nabble.com/file/p23047724/transmit_path_usrp2.py
transmit_path_usrp2.py
http://www.nabble.com/file/p23047724/pick_bitrate.py
pick_bitrate.py
--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
745d8202ef5a58c1058d0e5395a78f9c?d=identicon&s=25 Eric Blossom (Guest)
on 2009-04-15 22:03
(Received via mailing list)
On Tue, Apr 14, 2009 at 01:48:21PM -0700, Smith L. wrote:
> would appreciate if someone can look at these files and help me to sort out
> the problem.

My guess is that the two are not running at the same bit rate.
You haven't provided us much to go on.

Please see http://gnuradio.org/trac/wiki/ReportingErrors, and try
asking again.

Eric
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-17 20:31
(Received via mailing list)
Hi,

This is what I get when I run benchmark _tx.py and benchmark_rx.py
respectively on USRP2 with transmit_path_usrp2.py and
receive_path_usrp2.py
respectively:

benchmark_tx.py:-

mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_tx.py -f 2400M -v
usrp2::ctor reset_db failed
usrp2::ctor set_rx_gain failed
usrp2::ctor set_tx_interp failed
usrp2::ctor set_rx_scale_iq failed
>>> gr_fir_fff: using SSE
bits per symbol = 1
Gaussian filter bt = 0.35
Using TX d'board 43
Tx amplitude     12000
modulation:      gmsk_mod
bitrate:         500kb/s
samples/symbol:    2
interp:          100
Tx Frequency:    2.4G
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$

benchmark_rx.py:-

mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_rx.py -f 2400M -v
usrp2::ctor reset_db failed
>>> gr_fir_fff: using SSE
bits per symbol = 1
M&M clock recovery omega = 2.000000
M&M clock recovery gain mu = 0.175000
M&M clock recovery mu = 0.500000
M&M clock recovery omega rel. limit = 0.005000
frequency error = 0.000000

Receive Path:
Using RX d'board 39
Rx gain:         35
modulation:      gmsk_demod
bitrate:         500kb/s
samples/symbol:    2
decim:           100
Rx Frequency:    2.4G


Now the same thing for usrp1 but using transmit_path.py and
receive_path.py
which is already provided in gnuradio:

benchmark_tx.py:-

mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_tx.py -f 2400M -v
>>> gr_fir_fff: using SSE
bits per symbol = 1
Gaussian filter bt = 0.35
Using TX d'board A: Flex 2400 Tx MIMO B
Tx amplitude     12000
modulation:      gmsk_mod
bitrate:         500kb/s
samples/symbol:    2
interp:          128
Tx Frequency:    2.4G
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$

benchmark_rx.py:-

mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
./benchmark_rx.py -f 2400M -v
>>> gr_fir_fff: using SSE
bits per symbol = 1
M&M clock recovery omega = 2.000000
M&M clock recovery gain mu = 0.175000
M&M clock recovery mu = 0.500000
M&M clock recovery omega rel. limit = 0.005000
frequency error = 0.000000

Receive Path:
Using RX d'board A: Flex 2400 Rx MIMO B
Rx gain:         45
modulation:      gmsk_demod
bitrate:         500kb/s
samples/symbol:    2
decim:            64
Rx Frequency:    2.4G

I am using the same pick_bitrate.py file that is already provided in
gnuradio. As it can be seen that both usrp systems have the default bit
rate
irrespective of whether it acts as receiver or transmitter. My concern
is
with the interpolation and decimation. Do I need to make changes to the
pick_bitrate.py file for USRP2? If yes, then what kind of changes. I
also
observed that even though USRP2 shows a bit rate of 500kbps, however I
believe that its transmitting too fast which does not allow USRP1 to
receive
correctly.I would greatly appreciate any help in this matter.

Thanks in advance.

Smith

Eric Blossom wrote:
>> anything on USRP2 when USRP1 is transmitting and vice versa. The python
> My guess is that the two are not running at the same bit rate.
> Discuss-gnuradio@gnu.org
> http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>
>

--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
745d8202ef5a58c1058d0e5395a78f9c?d=identicon&s=25 Eric Blossom (Guest)
on 2009-04-17 21:48
(Received via mailing list)
On Fri, Apr 17, 2009 at 11:24:00AM -0700, Smith L. wrote:
>
>
> I am using the same pick_bitrate.py file that is already provided in
> gnuradio. As it can be seen that both usrp systems have the default bit rate
> irrespective of whether it acts as receiver or transmitter. My concern is
> with the interpolation and decimation. Do I need to make changes to the
> pick_bitrate.py file for USRP2? If yes, then what kind of changes. I also
> observed that even though USRP2 shows a bit rate of 500kbps, however I
> believe that its transmitting too fast which does not allow USRP1 to receive
> correctly.I would greatly appreciate any help in this matter.

At a minimum, you will need to call pick_tx_bitrate and
pick_rx_bitrate providing proper rates for the ADC and DAC.  They
default to the values appropriate for the USRP1.  However, it looks
like you'll need a USRP2 version since they encode the acceptable
ranges for interpolation and decimation which are different between
the USRP1 and USRP2.

Eric
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-17 23:44
(Received via mailing list)
Hi,

I already tried to set the value of the converter_rate in
pick_tx_bitrate
and Pick_rx_bitrate according to the ADC and DAC specifications of
USRP@. I
set it to 200e6 in pick_tx_bitrate and in pick_rx_bitrate. But even that
did
not worked. I am confused with how to modify the pick_bitrate.py file
for
usrp2. I am not able to determine the different parameters that I need
to
provide for usrp2. If anyone has already worked on it then please help
me to
modify the pick_bitrate file for usrp2. Also if any other changes are
required in other python files.

Thanks in advance.

Smith


Eric Blossom wrote:
>> observed that even though USRP2 shows a bit rate of 500kbps, however I
>
> Eric
>
>
> _______________________________________________
> Discuss-gnuradio mailing list
> Discuss-gnuradio@gnu.org
> http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>
>

--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
745d8202ef5a58c1058d0e5395a78f9c?d=identicon&s=25 Eric Blossom (Guest)
on 2009-04-17 23:53
(Received via mailing list)
On Fri, Apr 17, 2009 at 02:24:44PM -0700, Smith L. wrote:
> required in other python files.
>
> Thanks in advance.
> Smith

The converter rates should both be 100e6.

Eric
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-20 22:32
(Received via mailing list)
Hi,

I tried 100e6 as converter rates for USRP2. But it is still not working.
USRP1 and USRP2 receive and transmit at 500kbps which is the default bit
rate defined in pick_bitrate. So how could they have bit rate
incompatibility. The samples per symbol is also 2 for both of them. I am
still wondering that as USRP1 has decim of 64 and interp of 128 and
USRP2
has both decim and interp of 100 would not they affect the
communication.
This time I tried to communicate between USRP1 and Usrp2 using cable. I
am
still not able to figure out what is the problem.

Thanks for any help in advance.
Smith

Eric Blossom wrote:
>> not worked. I am confused with how to modify the pick_bitrate.py file for
>
> Eric
>
>
> _______________________________________________
> Discuss-gnuradio mailing list
> Discuss-gnuradio@gnu.org
> http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>
>

--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
3596cfe1d579c65b9babd35e8787977c?d=identicon&s=25 Matt Ettus (Guest)
on 2009-04-21 01:03
(Received via mailing list)
The DAC rate is 100e6.  The "bitrate" is the desired data rate of the
over the air modulation.  It should be MUCH less, like 100k to 1M or so.

There is absolutely nothing in any of the systems for which 200e6 is a
correct choice.

Matt
165991260d0639bb7ac84c99339b4ee9?d=identicon&s=25 Ben Yahmed (Guest)
on 2009-04-22 17:58
(Received via mailing list)
Hi,
Did you try to send and receive packets between 2 USRP2? I tryed but
without any result. Are you sure that it's working correctly? I will
have a look to the code in more details and tell you if something will
work.

Ben Yahmed
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-24 20:09
(Received via mailing list)
Hi,

I don't have two usprp2. So I am trying to communicate  between usrp1
and
usrp2. Moreover, in the transmit_path.py file I have hard coded my
usrp2's
mac address so you would have to replace it with yours before using it.
If
there are any other problems with the code then please let me know

Smith


Ben Yahmed wrote:
> Smith L. wrote:
>> ./benchmark_tx.py -f 2400M -v
>> Tx amplitude     12000
>> ./benchmark_rx.py -f 2400M -v
>>
>> Now the same thing for usrp1 but using transmit_path.py and
>> bits per symbol = 1
>> benchmark_rx.py:-
>> M&M clock recovery omega rel. limit = 0.005000
>>
>>
>>>> I am trying to establish communication between USRP2 and USRP1. I am
>>>> and
>>> Please see http://gnuradio.org/trac/wiki/ReportingErrors, and try
>>>
>
>

--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
165991260d0639bb7ac84c99339b4ee9?d=identicon&s=25 unknown (Guest)
on 2009-04-26 02:09
(Received via mailing list)
Hi,
I replaced your USRP2'mac adress with mine and tryed the code but no
received packet even with USRP2. I suggest that you use the
usrp2_version
branch code to transmit packets with USRP2 and try to catch them with
USRP1 since this code works fine for many of us.

Ben Yahmed
0db2b83c8c9466edb194423b1798de4a?d=identicon&s=25 Smith L. (Guest)
on 2009-04-26 15:34
(Received via mailing list)
Hi,

I have already tried to use USRP2 as transmitter and USRP1 as receiver
using
transmit_path_usrp2 file for usrp2. However I am not able to figure out
the
bit rate, interpolation and decimation rate to be set for successful
communication. I am not able to catch the packets using USRP1. Were you
able
to transmit using USRP2 and receive using USRP1. If yes, please let me
know
what frequency you used, what were the command line parameters and also
if
you made any changes in the python code for either usrp1 or usrp2.

Thanks for your help in advance.

Kushal


Ben Yahmed wrote:
>> Hi,
>>
>>>
>>>> mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
>>>> Using TX d'board 43
>>>> mcrl@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$ sudo
>>>> frequency error = 0.000000
>>>>
>>>>>>>
>>>>
>>>> M&M clock recovery mu = 0.500000
>>>> Rx Frequency:    2.4G
>>>> believe that its transmitting too fast which does not allow USRP1 to
>>>>>
>>>>>> codes for USRP2 work perfectly fine. I guess there is some problem
>>>>>> out
>>>>>
>>>
>> 
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
>
>
>
> _______________________________________________
> Discuss-gnuradio mailing list
> Discuss-gnuradio@gnu.org
> http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>
>

--
View this message in context:
http://www.nabble.com/USRP2-benchmark_rx.py%2C-ben...
Sent from the GnuRadio mailing list archive at Nabble.com.
165991260d0639bb7ac84c99339b4ee9?d=identicon&s=25 unknown (Guest)
on 2009-04-26 21:44
(Received via mailing list)
Hi,
I don't have USRP but just USRP2.
I think you should try this part of code :
svn co
https://www.cgran.org/cgran/projects/bbn_80211/bra...
there are the bbn_80211b_rx.py & bbn_80211b_tx.py files wich work fine
for
many of us between 2 USRP2. I used these options: ./bbn_80211b_tx.py -f
2.4G -e eth1  -i 24 -r 20 and ./bbn_80211b_rx.py -f 2.4G -v

try them and tell us about the results.

Ben Yahmed
3e5d1707dd5f4807ed9938d5c37b2649?d=identicon&s=25 Patrick Strasser (Guest)
on 2009-04-29 10:31
(Received via mailing list)
Hello!

Smith L. wrote am 2009-04-14 22:48:

> I am using the svn version of
> GNU Radio. I dont know the revision number.

svn info

Patrick

--
Engineers motto: cheap, good, fast: choose any two
Patrick Strasser <patrick dot strasser at student dot tugraz dot at>
Student of Telematik, Techn. University Graz, Austria
This topic is locked and can not be replied to.