USRP2 benchmark_rx.py, benchmark_tx.py, transmit_path_usrp2.py, receive_path_usrp2.py, pick_bitrate


#1

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-benchmark_tx.py%2C-transmit_path_usrp2.py%2C-receive_path_usrp2.py%2C-pick_bitrate.py-tp23047724p23047724.html
Sent from the GnuRadio mailing list archive at Nabble.com.