digital: bug fixes for digital mods. Adding fist pass at a UHD benchmark transit chain. Automatically selects the right samples/symbol and sample rate to achieve requested bitrate.

1 files changed, 149 insertions, 0 deletions

diff --git a/gr-digital/examples/uhd_interface.py b/gr-digital/examples/uhd_interface.py
new file mode 100644
index 000000000..9ab9bb196
--- /dev/null
+++ b/gr-digital/examples/uhd_interface.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+#
+# Copyright 2010,2011 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, uhd
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import sys
+
+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")
+
+class uhd_transmitter(gr.hier_block2):
+    def __init__(self, address, bitrate, sps, freq=None, gain=None,
+                 antenna=None, verbose=False):
+        gr.hier_block2.__init__(self, "uhd_transmitter",
+                                gr.io_signature(1,1,gr.sizeof_gr_complex),
+                                gr.io_signature(0,0,0))
+      
+        self.u = uhd.usrp_sink(device_addr=address,
+                               io_type=uhd.io_type.COMPLEX_FLOAT32,
+                               num_channels=1)
+
+        self._addr = address
+        self._ant  = antenna
+        self._gain = self.set_gain(gain)
+        self._freq = self.set_freq(freq)
+
+        self._rate, self._sps = self.set_sample_rate(bitrate, sps)
+
+        if(antenna):
+            self.u.set_antenna(antenna, 0)
+        
+        self.connect(self, self.u)
+
+        if(verbose):
+            self._print_verbage()
+
+    def set_sample_rate(self, bitrate, req_sps):
+        start_sps = req_sps
+        while(True):
+            asked_samp_rate = bitrate * req_sps
+            self.u.set_samp_rate(asked_samp_rate)
+            actual_samp_rate = self.u.get_samp_rate()
+
+            sps = actual_samp_rate/bitrate
+            if(sps < 2):
+                req_sps +=1
+            else:
+                actual_sps = sps
+                break
+        
+        if(sps != req_sps):
+            print "\nBit Rate:            %f" % (bitrate)
+            print "Requested sps:       %f" % (start_sps)
+            print "Given sample rate:   %f" % (actual_samp_rate)
+            print "Actual sps for rate: %f" % (actual_sps)
+
+
+        if(actual_samp_rate != asked_samp_rate):
+            print "\nRequested sample rate: %f" % (asked_samp_rate)
+            print "Actual sample rate: %f" % (actual_samp_rate)
+
+        return (actual_samp_rate, actual_sps)
+
+    def set_gain(self, gain=None):
+        if gain is None:
+            # if no gain was specified, use the mid-point in dB
+            g = self.u.get_gain_range()
+            gain = float(g.start()+g.stop())/2
+            print "\nNo gain specified."
+            print "Setting gain to %f (from [%f, %f])" % \
+                (gain, g.start(), g.stop())
+        
+        self.u.set_gain(gain, 0)
+        return gain
+
+    def set_freq(self, freq=None):
+        if(freq is None):
+            sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+            sys.exit(1)
+        
+        r = self.u.set_center_freq(freq, 0)
+        if r:
+            return freq
+        else:
+            frange = self.u.get_freq_range()
+            sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \
+                                 (freq, frange.start(), frange.stop()))
+            sys.exit(1)
+            
+    def add_options(parser):
+        add_freq_option(parser)
+        parser.add_option("-a", "--address", type="string", default="addr=192.168.10.2",
+                          help="Address of UHD device, [default=%default]")
+        parser.add_option("-A", "--antenna", type="string", default=None,
+                          help="select Rx Antenna where appropriate")
+        parser.add_option("", "--tx-freq", type="eng_float", default=None,
+                          help="set transmit frequency to FREQ [default=%default]",
+                          metavar="FREQ")
+        parser.add_option("", "--tx-gain", type="eng_float", default=None,
+                          help="set transmit gain in dB (default is midpoint)")
+        parser.add_option("-v", "--verbose", action="store_true", default=False)
+
+    # Make a static method to call before instantiation
+    add_options = staticmethod(add_options)
+
+    def _print_verbage(self):
+        """
+        Prints information about the UHD transmitter
+        """
+        print "RATE: ", self._rate
+        print "\nUHD Transmitter:"
+        print "Address:     %s"    % (self._addr)
+        print "Freq:        %sHz"  % (eng_notation.num_to_str(self._freq))
+        print "Gain:        %f dB" % (self._gain)
+        print "Samp;e Rate: %ssps" % (eng_notation.num_to_str(self._rate))
+        print "Antenna:     %s"    % (self._ant)