some commands for matlab

matrix functions

 INV    Matrix inverse.
    INV(X) is the inverse of the square matrix X.
    A warning message is printed if X is badly scaled or
    nearly singular.

 .' Transpose.
    X.' is the non-conjugate transpose.
    B = TRANSPOSE(A) is called for the syntax A.' when A is an object.

 SQUEEZE Remove singleton dimensions.
    B = SQUEEZE(A) returns an array B with the same elements as
    A but with all the singleton dimensions removed.  A singleton
    is a dimension such that size(A,dim)==1.  2-D arrays are
    unaffected by squeeze so that row vectors remain rows.
    For example,   squeeze(rand(2,1,3))    is 2-by-3.

Especially, for a 3-dimension matrix, for the command "matri = original_matrix(1,:,:)", the resulting matrix matri is still a 3-D matrix whose 1st dimension is just 1.

==========

for plotting, this example will explain the most frequently used commands:

x = -pi:.1:pi;
y = sin(x);
plot(x,y);
set(gca,'XTick',-pi:pi/2:pi);
set(gca,'XTickLabel',{'-pi','-pi/2','0','pi/2','pi'});
xlabel('-\pi \leq \Theta \leq \pi');
ylabel('sin(\Theta)');
title('Plot of sin(\Theta)');
AXIS([XMIN XMAX YMIN YMAX])
XLIM([XMIN XMAX])
YLIM([YMIN YMAX])

Some usrp_spectrum_sense.py code Explanation

Hi Everybody,

and Merry Christmas

I received many emails requesting some explanation for usrp_spectrum_sense.py gnuradio example program. The following link contains the code with some explanation and one bug fix (in self.max_center_freq equation):

http://rapidshare.com/files/177960860/usrp_spectrum_sense.py





usrp_spectrum_sense.py Explanation :
=======================================================================================

Introduction:
-------------

1) This program can be used as a basic code for implementing wideband spectrum analyzer.
2) As we know, the USRP cannot examine more than 8 MHz of RF spectrum due to USB bus limitations.
3) So, to scan across a wide RF spectrum band (bigger than 8 MHz) we have to tune USRP RF front end in suitable steps so that we can examine a lot of spectrum, although not all at the same instant.
4) The usrp_spectrum_sense shows the way how it can be done.It steps across the spectrum and make the RF measurements. This application can
sense a large bandwidth, but not in real time, and it can do the frequency sweep over the required frequency range,



Theory:
-------

1) To use N points complex FFT X(W) analysis, we have to get N time samples x(t) which are sampled at Fs.
2) These N time samples must be time windowed using a known window function to reduce spectral leakage.
3) Performing N points complex FFT analysis.
4) The output of the complex FFT will represent the frequency spectrum contents as follows:

a) The first value of the FFT output (bin 0 == X[0]) is the passband center frequency.
b) The first half of the FFT (X[1] to X[N/2-1] contains the positive baseband frequencies,which corresponds to the passband spectrum from the center frequency out to the maximum passband frequency (from center frequency to +Fs/2).
c) The second half of the FFT (X[N/2] to X[N-1]) contains the negative baseband frequencies,which correspond to the lowest passband frequency up to the passband center frequency (from -Fs/2 to center frequency).


Example
-------

Let us assume that we have 1024 (I and Q) samples gathered using a tuner centered at 20MHz. And let us assume that the sampling frequency was 8MHz.
Doing 1024 points complex FFT means:

1) FFT Frequency resolution is : 8MHz / 1024 = 7812.5 KHz
2) The output of the FFT X[0] represents the spectrum at 20MHz.
3) The output of the FFT X[1] to X[511] represents the frequencies from 20.0078125 MHz to 23.9921875 MHz (about 4MHz above center frequency).
4) The output of the FFT X[512] to X[1023] represents the frequencies from 16.0078125 MHz to 19.9921875 MHz (about 4MHz bellow center frequency).




RF Frequency Sweeping
---------------------

1) Let us suppose that we want to scan RF spectrum band from 10MHz to 52 MHz.
2) Let us remember that USRP can analyze 8MHz of frequency at a time.
3) So theoretically we have to step our RF center frequency as follows:

First step is 14MHz (it will cover frequency band from 10MHz to 18MHz),
Second step is 22MHz (it will cover frequency band from 18MHz to 26MHz),
Third step is 30MHz (it will cover frequency band from 26MHz to 34MHz),
Fourth step is 38MHz (it will cover frequency band from 34MHz to 42MHz),
Fifth step is 46MHz (it will cover frequency band from 42MHz to 50MHz),
and finally the Sixth step is 54MHz (it will cover frequency band from 50MHz to 58MHz). Remember that we want the frequencies up to 52MHz only, so we have to discard some FFT points from the Sixth analysis.


4) Paralytically we have to use FFT overlapping to reduce the non linearity response of the Digital Down Converter (the DDC frequency response is not Flat from -Fs/2 to + Fs/2) and to fill the frequency holes that will be present at the FFT analysis edges (10MHz, 18MHz, 26MHz, 34MHz, 42MHz, 50 MHz).

So if we choose to use an overlap of 25%, this means that our step size will be 6MHz (8MHz*(1-.25)), thus practically we have to step our RF center frequency as follows:

First step is 13MHz (it will cover frequency band from 9MHz to 17MHz),
Second step is 19MHz (it will cover frequency band from 15MHz to 23MHz),
Third step is 25MHz (it will cover frequency band from 21MHz to 29MHz),
Fourth step is 31MHz (it will cover frequency band from 27MHz to 35MHz),
Fifth step is 37MHz (it will cover frequency band from 33MHz to 41MHz),
Sixth step is 43MHz (it will cover frequency band from 39MHz to 47MHz),
and Finally the Seventh step is 49MHz (it will cover frequency band from 45MHz to 53MHz),





Changing RF center Frequency
----------------------------

1) To change USRP RF center frequency we have to send a tunning command to the USRP every time we complete the analysis of the current frequency chunk.
2) Before gnuradio revision [10165], all USRP RF daughterboards tunning were done using Python functions and classes. After that revision, tunning the USRP daughterboards from withen C++ code is possible.
3) In usrp_spectrum_sense.py, the DSP C++ written code is allowed to transparently invoke Python code USRP tune function. This tunning control is done in gr_bin_statistics_f sink function.




Tunning Delay Problem:
---------------------

When we command the usrp RF daughterboard to change its center frequency, we have to wait until (right) ADC samples arrive to our FFT engine and we have to insure that it belongs to the wanted center frequency. This represents a problem since there are many delays along the digitization path (RF synthesizer settling time, and pipeline propagation delay [FPGA FIFO filling time, USB transferring time...etc]). To overcome this problem we have to use enough tune delay time in order to  be sure that the samples entering our FFT block are belong to the requested center frequency. This is done simply by dropping the incoming received samples over a specified tunning delay time.



usrp_spectrum_sense Implementation
----------------------------------

1) The engine of the usrp_spectrum_sense depends mainly on bin_statistics sink function.

2) bin_statistics function combines statistics gathering with a state machine for controlling the USRP RF tuning (frequency sweeping). It determines max values (keeps track of the maximum power in each FFT bin) of vectors (with length vlen) over a time period determined by dwell_delay (after converting it to a number of FFT vectors). This operation is performed after discarding tune_delay samples.

3) After processing N = dwell_delay samples, bin_statistics composes a message and inserts it in a message queue.

4) Each message from bin_statistics consists of a vector of max values, prefixed by the center frequency corresponding to the associated samples,
i.e., it is the center frequency value of the delivered input samples to bin_statistics.




Choosing Tune and Dwell delay times
----------------------------------

1) We have to play with the --tune-delay and --dwell-delay command line options to determine appropriate timming values. The most important one is the tune delay time.

2) The choose of tune-delay should include time for the front end PLL to settle, plus time for the new samples to propagate through the pipeline.  The default value is 1ms, which is probably in the ballpark on the RFX** boards.  The TV RX board is much slower.  The tuner data sheets says it could take 100ms to settle.

3) The tune delay timing parameter passed to bin_statistics is calculated in FFT frames which depends on USRP rate and FFT length as in :

tune_delay_passed_to_bin_statistics = int(round(required_tune_delay_in_sec*usrp_rate/fft_size))

if this calculated value is less than "1", then we should make it at least "1" FFT frame.

For example:

If the :

required_tune_delay_in_sec = 10e-3
and usrp_rate = 8000000 (decimation =8)
and FFT size is 1024


Then :

tune_delay_passed_to_bin_stats = 78   (FFT Frames)

This means we have to skip 78 incoming vectors (FFT frames) before we actually use the acquired samples in our spectrum statistics.

4) Beside tunning time depends on the hardware (RF synthesizer speed),one should remember that the time needed to collect 1024 samples
with decimation rate=8 (minimum USRP decimation) is 128 usec, while the time needed to collect 1024 samples with decimation rate=256 (maximum USRP decimation) is 4.096 msec. This means that the tune delay in the case of decimation rate =256 should be larger than that used for decimation = 8.

5) A working tune delay value (which gives accurate results) can be known by experiments (for given decimation rate and FFT length).




Interrupting Output Spectrum
-----------------------------

The actual mapping from the levels at the daughterboard antenna input port to the output analysis values depends on a lot of factors including the used daughterboard RF gain and decimation specific gain in the digital down converter. You'll need to calibrate the system if you need something that maps to dBm.Currently, the output of usrp_spectrum_sense is the magnitude squared of the FFT output.  That is, for each FFT bin[i], the output is Y[i] = re[X[i]]*re[X[i]] + im[X[i]]*im[X[i]]. If you want power, take the square root of the output.

========================================================================================


Best Regards,


Firas

advance info. about usrp trans.

new examples for the 802.11b trans. (here)

======================

btw, there is an excellent discussion about how to run the code.

(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.

(2)

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:-

m...@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
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$
 

benchmark_rx.py:-

m...@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:-

m...@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
...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................m...@mcrl-desktop:~/gnuradio/gnuradio-examples/python/digital$
 

benchmark_rx.py:-

m...@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.

(3)

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

(4)

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 u...@. 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

(5)

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

Why dont you read the "readme" file first?!

it's fucking awful to find everything in readme file, while I spent nearly 10 hours wander around in the internet......

==========

/gnuradio3.2.2/gnuradio-examples/python/digital/README

Quick overview of what's here:

* benchmark_tx.py: generates packets of the size you
specify and sends them across the air using the USRP.  Known to work
well using the USRP with the RFX transceiver daughterboards.
You can specify the bitrate to use with the -r command line
parameter.  The default is 500k.  Some machines will do 1M or more.
You can select the modulation to use with the -m command
line argument.  The legal values for are gmsk, dbpsk and dqpsk.

* benchmark_rx.py: the receiver half of benchmark_tx.py.
Command line arguments are pretty much the same as rx.  Works well
with a USRP and RFX transceiver daughterboards.  Will also work
with TVRX daugherboard, but you'll need to fiddle with the gain.  See
below.  Prints a summary of each packet received and keeps a running
total of packets received, and how many of them were error free.
There are two levels of error reporting going on.  If the access code
(PN code) and header of a packet were properly detected, then you'll
get an output line.  If the CRC32 of the payload was correct you get
"ok = True", else "ok = False".  The "pktno" is extracted from the
received packet.  If there are skipped numbers, you're missing some
packets.  Be sure you've got a suitable antenna connected to the TX/RX
port on each board.  For the RFX-400, "70 cm" / 420 MHz antennas for ham
handi-talkies work great.  These are available at ham radio supplies,
etc.  The boards need to be at least 3m apart.  You can also try
experimenting with the rx gain (-g command line option).

Generally speaking, I start the rx first on one machine, and then fire
up the tx on the other machine.  The tx also supports a discontinous
transmission mode where it sends bursts of 5 packets and then waits 1
second.  This is useful for ensuring that all the receiver control
loops lock up fast enough.

* tunnel.py: This program provides a framework for building your own
MACs.  It creates a "TAP" interface in the kernel, typically gr0,
and sends and receives ethernet frames through it.  See
/usr/src/linux/Documentation/networking/tuntap.txt and/or Google for
"universal tun tap".  The Linux 2.6 kernel includes the tun module, you
don't have to build it.  You may have to "modprobe tun" if it's not
loaded by default.  If /dev/net/tun doesn't exist, try "modprobe tun".

To run this program you'll need to be root or running with the
appropriate capability to open the tun interface.  You'll need to fire
up two copies on different machines.  Once each is running you'll need
to ifconfig the gr0 interface to set the IP address.

This will allow two machines to talk, but anything beyond the two
machines depends on your networking setup.  Left as an exercise...

On machine A:

  $ su
  # ./tunnel.py --freq 423.0M --bitrate 500k
  # # in another window on A, also as root...
  # ifconfig gr0 192.168.200.1


On machine B:

  $ su
  # ./tunnel.py --freq 423.0M --bitrate 500k
  # # in another window on B, also as root...
  # ifconfig gr0 192.168.200.2

Now, on machine A you shold be able to ping machine B:

  $ ping 192.168.200.2

and you should see some output for each packet in the
tunnel.py window if you used the -v option.

Likewise, on machine B:

  $ ping 192.168.200.1

This now uses a carrier sense MAC, so you should be able to ssh
between the machines, web browse, etc.

* run_length.py: This program takes a single argument '-f FILE' and
outputs the number of runs of similar bits within the file. It is
useful as a diagnostic tool when experimenting with line coding or
whitening algorithms.

How to test USRP when you get it

prerequisites:
1. install Linux: need to select a OS here
2. install GNU Radio:    --http://gnuradio.org/trac/wiki
3. (optional) read the hardware documents:    --http://gnuradio.org/trac/wiki/USRP
        user guide/install guide:    --http://www.comsec.com/wiki?UsrpInstall
        All the datasheets can be downloaded here
4. (optional) read driver source code
        the source codes related to USRP:
            /usrp
                firmware: for 8051 in USB controller, mostly writen as .c and .a51
                FPGA: for FPGA, mostly writen as .v (it seems fpga only has SRAM inside, so it need to download software for fpga every time)
                host: for PC, mostly writen as .cc
            /gr-usrp
                driver for dauther board: mostly writen as .py and .cc
            /gnuradio-example/python/usrp
                example for single usrp board: all writen in .py
            /gnuradio-example/python/multi-usrp
                example for multi usrp boards: all writen in .py

begin to test:
1. How to power on and start test:
        step1. before plug in USB cable, open two terminal.
        step2. to see a real time display of all log messages: tail -f /var/log/messages (to check the usb driver is correctly installed)
    How to stop and power off:
        step1. stop the program.
        step2. disconnect USB connection and power off
2. test a script for usrp first without daughter board, which file I need to test?
--http://www.comsec.com/wiki?UsrpInstall
gnuradio\gnuradio-examples\python\usrp\usrp_siggen.py & usrp_fft.py

3. how to test the transmitter and receiver for daughter board?
The antenna should be connect by Tx/Rx SMA but NOT Rx2! there is a switch for Rx2 and the switch is off in default!
The Tx and Rx can NOT be connected directly by cable! need a attenuator about 40-50 dB!!
    1) /gnuradio-examples/python/usrp/usrp_siggen.py and usrp_fft.py to observe signal
    2) /gnuradio-examples/python/digital/benchmark_tx.py and benchmark_rx.py to test data transmission.
        The boards need to be at least 3m apart. --/home/james/gnuradio/gnuradio-examples/python/digital/README
    3) use tx_voice.py and rx_voice.py to test voice transmission.
    4) some also said to test /gnuradio-examples/python/usrp/usrp_nbfm_ptt.py to test full duplex voice call, but I can't make it works.

test voice:
1. gnuradio-examples\python\audio\dial_tone.py as tutorial
2. gnuradio-examples\python\audio\audio_copy.py
    gnuradio-examples\python\audio\audio_to_file.py
    gnuradio-examples\python\audio\audio_play.py
3. gnuradio-examples\python\digital_voice\encdec.py to test by one USRP
4. gnuradio-examples\python\digital\tx_voice.py
    gnuradio-examples\python\digital\rx_voice.py to test by two USRP

test data:
1. gnuradio-examples\python\digital\benchmark_tx.py
    gnuradio-examples\python\digital\benchmark_rx.py to test by two USRP

suggested by others:
1. http://www.nabble.com/High-packet-error-and-reception-problems-with-RFX-2400-t3522095.html
./benchmark_tx.py -f 2412M --bitrate 500k -v --tx-amplitude=30000
usrp_siggen.py and usrp_oscope.py
./benchmark_rx.py -f 2412M --bitrate 100k -v --rx-gain=75
--in digital folder

2. http://staff.washington.edu/jon/gr-osx/gr-osx-usrp.html#using
benchmark_usb.py Estimate throughput of USB
usrp_siggen.py Signal generator
usrp_oscope.py Oscilloscope (screenshot)
usrp_fft.py Spectrum analyzer (screenshot)

ways to keep from duplicating path variable in csh

#!/usr/bin/perl
#
# ^^ ensure this is pointing to the correct location.
#
# Title:    SLimPath
# Author:   David "Shoe Lace" Pyke 
#   :   Tim Nelson 
# Purpose: To create a slim version of my envirnoment path so as to eliminate
#       duplicate entries and ensure that the "." path was last.
# Date Created: April 1st 1999
# Revision History:
#   01/04/99: initial tests.. didn't wok verywell at all
#       : retreived path throught '$ENV' call
#   07/04/99: After an email from Tim Nelson  got it to
#         work.
#       : used 'push' to add to array
#       : used 'join' to create a delimited string from a list/array.
#   16/02/00: fixed cmd-line options to look/work better
#   25/02/00: made verbosity level-oriented
#
#
use Getopt::Std;
sub printlevel;

$initial_str = "";
$debug_mode = "";
$delim_chr = ":";
$opt_v = 1;

getopts("v:hd:l:e:s:");

OPTS: {
    $opt_h && do {
print "\n$0 [-v level] [-d level] [-l delim] ( -e varname | -s strname | -h )";
print "\nWhere:";
print "\n   -h  This help";
print "\n   -d  Debug level";
print "\n   -l  Delimiter (between path vars)";
print "\n   -e  Specify environment variable (NB: don't include \$ sign)";
print "\n   -s  String (ie. $0 -s \$PATH:/looser/bin/)";
print "\n   -v  Verbosity (0 = quiet, 1 = normal, 2 = verbose)";
print "\n";
        exit;
    };
    $opt_d && do {
        printlevel 1, "You selected debug level $opt_d\n";
        $debug_mode = $opt_d;
    };
    $opt_l && do {
        printlevel 1, "You are going to delimit the string with \"$opt_l\"\n";
        $delim_chr = $opt_l;
    };
    $opt_e && do {
        if($opt_s) { die "Cannot specify BOTH env var and string\n"; }
        printlevel 1, "Using Environment variable \"$opt_e\"\n";
        $initial_str = $ENV{$opt_e};
    };
    $opt_s && do {
        printlevel 1, "Using String \"$opt_s\"\n";
        $initial_str = $opt_s;
    };
}
if( ($#ARGV != 1) and !$opt_e and !$opt_s){
    die "Nothing to work with -- try $0 -h\n";
}

$what = shift @ARGV;
# Split path using the delimiter
@dirs = split(/$delim_chr/, $initial_str);

$dest;
@newpath = ();
LOOP: foreach (@dirs){
    # Ensure the directory exists and is a directory
    if(! -e ) { printlevel 1, "$_ does not exist\n"; next; }
    # If the directory is ., set $dot and go around again
    if($_ eq '.') { $dot = 1; next; }
#   if ($_ ne `realpath $_`){
#               printlevel 2, "$_ becomes ".`realpath $_`."\n";
#   }
    undef $dest;
    #$_=Stdlib::realpath($_,$dest);
    # Check for duplicates and dot path
    foreach $adir (@newpath) { if($_ eq $adir) { 
        printlevel 2, "Duplicate: $_\n";
        next LOOP; 
    }}

    push @newpath, $_;
}
# Join creates a string from a list/array delimited by the first expression
print join($delim_chr, @newpath) . ($dot ? $delim_chr.".\n" : "\n");

printlevel 1, "Thank you for using $0\n";
exit;
sub printlevel {
    my($level, $string) = @_;

    if($opt_v >= $level) {
        print STDERR $string;
    }
}

"C/C++ Development Tooling" plug in Eclipse

It is weird that the official website of CDT does not contain anything about how to integrate the CDT with an existing Eclipse, and so does its google search within the website. However, except the awkward "import project" method (at least, for me... I have tried several times on the username/password to ssh the remote server), the method mentioned here is much more straightforward. For more information, the Eclipse CDT wiki is a nice place to go.

The method is:

1. Download the master zip file and put it somewhere on your machine.
2. Fire up Eclipse (The Platform Run-time 3.6 is minimum recommended)
3. Help->Install New Software...
4. Add... in the master zip as an Archive site
5. Under CDT Main Features select the one you want. C/C++ Development Tools is the main one. The SDK adds in the schemas and source for building extensions to the CDT. The C/C++ Development Platform is the Tools without the GNU toolchain support.
6. You can install other neat things, including the Mylyn bridge, from the CDT Optional Features category.

ps.
the Pydev install web address is: http://pydev.org/updates/
The EPIC for perl can be downloaded from: http://e-p-i-c.sf.net/updates. And it also need the ActivePerl (http://www.activestate.com/Products/activeperl/) for windows os.