2 files changed, 53 insertions, 70 deletions
diff --git a/gnuradio-examples/python/usrp/Makefile.am b/gnuradio-examples/python/usrp/Makefile.am
index 3b6607c377..7ecff29d23 100644
--- a/gnuradio-examples/python/usrp/Makefile.am
+++ b/gnuradio-examples/python/usrp/Makefile.am
@@ -29,5 +29,4 @@ dist_ourdata_SCRIPTS = 			\
 	test_dft_synth.py		\
 	usrp_benchmark_usb.py		\
 	usrp_spectrum_sense.py		\
-	usrp_test_loop_lfsr.py		\
-	usrp_wxapt_rcv.py
+	usrp_test_loop_lfsr.py
diff --git a/gnuradio-examples/python/usrp/usrp_wxapt_rcv.py b/gr-uhd/examples/usrp_wxapt_rcv.py
index b356702a68..5b44398d1b 100755
--- a/gnuradio-examples/python/usrp/usrp_wxapt_rcv.py
+++ b/gr-uhd/examples/usrp_wxapt_rcv.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright 2005,2006,2007 Free Software Foundation, Inc.
+# Copyright 2005-2007,2011 Free Software Foundation, Inc.
 # 
 # This file is part of GNU Radio
 # 
@@ -20,42 +20,25 @@
 # Boston, MA 02110-1301, USA.
 # 
 
-from gnuradio import gr, gru, eng_notation, optfir
-from gnuradio import audio
-from gnuradio import usrp
-from gnuradio import blks2
+from gnuradio import gr, audio, blks2, uhd
 from gnuradio.eng_option import eng_option
 from gnuradio.wxgui import slider, powermate
 from gnuradio.wxgui import stdgui2, fftsink2, form
 from optparse import OptionParser
-from usrpm import usrp_dbid
 import sys
-import math
 import wx
 
-def pick_subdevice(u):
-    """
-    The user didn't specify a subdevice on the command line.
-    Try for one of these, in order: TV_RX, BASIC_RX, whatever is on side A.
-
-    @return a subdev_spec
-    """
-    return usrp.pick_subdev(u, (usrp_dbid.TV_RX,
-                                usrp_dbid.TV_RX_REV_2,
-				usrp_dbid.TV_RX_REV_3,
-				usrp_dbid.TV_RX_MIMO,
-                                usrp_dbid.TV_RX_REV_2_MIMO,
-				usrp_dbid.TV_RX_REV_3_MIMO,
-                                usrp_dbid.BASIC_RX))
-
 
 class wxapt_rx_block (stdgui2.std_top_block):
     def __init__(self,frame,panel,vbox,argv):
         stdgui2.std_top_block.__init__ (self,frame,panel,vbox,argv)
 
         parser=OptionParser(option_class=eng_option)
-        parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
-                          help="select USRP Rx side A or B (default=A)")
+        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("-f", "--freq", type="eng_float", default=137.5e6,
                           help="set frequency to FREQ", metavar="FREQ")
         parser.add_option("-g", "--gain", type="eng_float", default=None,
@@ -64,6 +47,10 @@ class wxapt_rx_block (stdgui2.std_top_block):
                           help="set volume (default is midpoint)")
         parser.add_option("-O", "--audio-output", type="string", default="",
                           help="pcm device name.  E.g., hw:0,0 or surround51 or /dev/dsp")
+        parser.add_option("", "--freq-min", type="eng_float", default=137e6,
+                          help="Set a minimum frequency [default=%default]")
+        parser.add_option("", "--freq-max", type="eng_float", default=138e6,
+                          help="Set a maximum frequency [default=%default]")
 
         (options, args) = parser.parse_args()
         if len(args) != 0:
@@ -77,62 +64,62 @@ class wxapt_rx_block (stdgui2.std_top_block):
         self.state = "FREQ"
         self.freq = 0
 
-        # build graph
-        
-        self.u = usrp.source_c()                    # usrp is data source
-
-        adc_rate = self.u.adc_rate()                # 64 MS/s
-        usrp_decim = 200
-        self.u.set_decim_rate(usrp_decim)
-        usrp_rate = adc_rate / usrp_decim           # 320 kS/s
-        chanfilt_decim = 4
-        demod_rate = usrp_rate / chanfilt_decim
-        audio_decimation = 10
-        audio_rate = demod_rate / audio_decimation  # 32 kHz
+        self.freq_min = options.freq_min
+        self.freq_max = options.freq_max
 
-        if options.rx_subdev_spec is None:
-            options.rx_subdev_spec = pick_subdevice(self.u)
+        # build graph
+        self.u = uhd.usrp_source(device_addr=options.address,
+                                 io_type=uhd.io_type.COMPLEX_FLOAT32,
+                                 num_channels=1)
 
-        self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
-        self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
-        print "Using RX d'board %s" % (self.subdev.side_and_name(),)
+        usrp_rate  = 320e3
+        demod_rate = 320e3
+        audio_rate = 32e3
+        audio_decim = int(demod_rate / audio_rate)
 
+        self.u.set_samp_rate(usrp_rate)
+        dev_rate = self.u.get_samp_rate()
 
-        chan_filt_coeffs = optfir.low_pass (1,           # gain
-                                            usrp_rate,   # sampling rate
-                                            40e3,        # passband cutoff
-                                            60e3,       # stopband cutoff
-                                            0.1,         # passband ripple
-                                            60)          # stopband attenuation
-        #print len(chan_filt_coeffs)
-        chan_filt = gr.fir_filter_ccf (chanfilt_decim, chan_filt_coeffs)
+        nfilts = 32
+        chan_coeffs = gr.firdes.low_pass_2 (nfilts,           # gain
+                                            nfilts*usrp_rate, # sampling rate
+                                            40e3,             # passband cutoff
+                                            20e3,             # transition bw
+                                            60)               # stopband attenuation
+        rrate = usrp_rate / dev_rate
+        self.chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts)
 
-        self.guts = blks2.wfm_rcv (demod_rate, audio_decimation)
+        self.guts = blks2.wfm_rcv (demod_rate, audio_decim)
 
         self.volume_control = gr.multiply_const_ff(self.vol)
 
         # sound card as final sink
-        audio_sink = audio.sink (int (audio_rate), options.audio_output)
+        self.audio_sink = audio.sink (int (audio_rate), options.audio_output)
         
         # now wire it all together
-        self.connect (self.u, chan_filt, self.guts, self.volume_control, audio_sink)
+        self.connect (self.u, self.chan_filt, self.guts,
+                      self.volume_control, self.audio_sink)
 
         self._build_gui(vbox, usrp_rate, demod_rate, audio_rate)
 
         if options.gain is None:
             # if no gain was specified, use the mid-point in dB
-            g = self.subdev.gain_range()
-            options.gain = float(g[0]+g[1])/2
+            g = self.u.get_gain_range()
+            options.gain = float(g.start()+g.stop())/2.0
 
         if options.volume is None:
             g = self.volume_range()
             options.volume = float(g[0]+g[1])/2
-            
-        if abs(options.freq) < 1e6:
-            options.freq *= 1e6
 
-        # set initial values
+        frange = self.u.get_freq_range()
+        if(frange.start() > self.freq_max or frange.stop() <  self.freq_min):
+            sys.stderr.write("Radio does not support required frequency range.\n")
+            sys.exit(1)
+        if(options.freq < self.freq_min or options.freq > self.freq_max):
+            sys.stderr.write("Requested frequency is outside of required frequency range.\n")
+            sys.exit(1)
 
+        # set initial values
         self.set_gain(options.gain)
         self.set_vol(options.volume)
         if not(self.set_freq(options.freq)):
@@ -183,7 +170,7 @@ class wxapt_rx_block (stdgui2.std_top_block):
         hbox.Add((5,0), 0)
         myform['freq_slider'] = \
             form.quantized_slider_field(parent=self.panel, sizer=hbox, weight=3,
-                                        range=(137.0e6, 138.0e6, 0.0005e6),
+                                        range=(self.freq_min, self.freq_max, 0.0005e6),
                                         callback=self.set_freq)
         hbox.Add((5,0), 0)
         vbox.Add(hbox, 0, wx.EXPAND)
@@ -197,9 +184,10 @@ class wxapt_rx_block (stdgui2.std_top_block):
                                         callback=self.set_vol)
         hbox.Add((5,0), 1)
 
+        g = self.u.get_gain_range()
         myform['gain'] = \
             form.quantized_slider_field(parent=self.panel, sizer=hbox, label="Gain",
-                                        weight=3, range=self.subdev.gain_range(),
+                                        weight=3, range=(g.start(), g.start(), g.step()),
                                         callback=self.set_gain)
         hbox.Add((5,0), 0)
         vbox.Add(hbox, 0, wx.EXPAND)
@@ -255,14 +243,10 @@ class wxapt_rx_block (stdgui2.std_top_block):
 
         @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 down converter.
         """
-        r = usrp.tune(self.u, 0, self.subdev, target_freq)
-        
+
+        r = self.u.set_center_freq(target_freq)
+
         if r:
             self.freq = target_freq
             self.myform['freq'].set_value(target_freq)         # update displayed value
@@ -276,7 +260,7 @@ class wxapt_rx_block (stdgui2.std_top_block):
 
     def set_gain(self, gain):
         self.myform['gain'].set_value(gain)     # update displayed value
-        self.subdev.set_gain(gain)
+        self.u.set_gain(gain)
 
     def update_status_bar (self):
         msg = "Volume:%r  Setting:%s" % (self.vol, self.state)