uhd: moved WFM recever and no-gui receiver to gr-uhd/examples and made work with UHD.

5 files changed, 229 insertions, 262 deletions

diff --git a/gnuradio-examples/python/usrp/Makefile.am b/gnuradio-examples/python/usrp/Makefile.am
index e91e2a4ae..67760ffc9 100644
--- a/gnuradio-examples/python/usrp/Makefile.am
+++ b/gnuradio-examples/python/usrp/Makefile.am
@@ -32,7 +32,6 @@ dist_ourdata_SCRIPTS = 			\
 	usrp_test_loop_lfsr.py		\
 	usrp_tv_rcv_nogui.py		\
 	usrp_tv_rcv.py			\
-	usrp_wfm_rcv.py			\
 	usrp_wfm_rcv_nogui.py		\
 	usrp_wfm_rcv_fmdet.py		\
 	usrp_wfm_rcv_pll.py		\
diff --git a/gnuradio-examples/python/usrp/usrp_wfm_rcv_nogui.py b/gnuradio-examples/python/usrp/usrp_wfm_rcv_nogui.py
deleted file mode 100755
index 217f207c5..000000000
--- a/gnuradio-examples/python/usrp/usrp_wfm_rcv_nogui.py
+++ /dev/null
@@ -1,177 +0,0 @@
-#!/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, eng_notation, optfir
-from gnuradio import audio
-from gnuradio import usrp
-from gnuradio import blks2
-from gnuradio.eng_option import eng_option
-from optparse import OptionParser
-from usrpm import usrp_dbid
-import sys
-import math
-
-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 wfm_rx_block (gr.top_block):
-
-    def __init__(self):
-        gr.top_block.__init__(self)
-
-        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("-f", "--freq", type="eng_float", default=100.1e6,
-                          help="set frequency to FREQ", metavar="FREQ")
-        parser.add_option("-g", "--gain", type="eng_float", default=None,
-                          help="set gain in dB (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")
-
-        (options, args) = parser.parse_args()
-        if len(args) != 0:
-            parser.print_help()
-            sys.exit(1)
-        
-        self.vol = .1
-        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 = 1
-        demod_rate = usrp_rate / chanfilt_decim
-        audio_decimation = 10
-        audio_rate = demod_rate / audio_decimation  # 32 kHz
-
-
-        if options.rx_subdev_spec is None:
-            options.rx_subdev_spec = pick_subdevice(self.u)
-
-        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(),)
-
-
-        chan_filt_coeffs = optfir.low_pass (1,           # gain
-                                            usrp_rate,   # sampling rate
-                                            80e3,        # passband cutoff
-                                            115e3,       # 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)
-
-        self.guts = blks2.wfm_rcv (demod_rate, audio_decimation)
-
-        self.volume_control = gr.multiply_const_ff(self.vol)
-
-        # sound card as final sink
-        audio_sink = audio.sink(int(audio_rate),
-                                options.audio_output,
-                                False)  # ok_to_block
-        
-        # now wire it all together
-        self.connect (self.u, chan_filt, self.guts, self.volume_control, audio_sink)
-
-
-        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
-
-        if abs(options.freq) < 1e6:
-            options.freq *= 1e6
-
-        # set initial values
-
-        self.set_gain(options.gain)
-
-        if not(self.set_freq(options.freq)):
-            self._set_status_msg("Failed to set initial frequency")
-
-    def set_vol (self, vol):
-        self.vol = vol
-        self.volume_control.set_k(self.vol)
-        self.update_status_bar ()
-
-    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 down converter.
-        """
-        r = self.u.tune(0, self.subdev, target_freq)
-        
-        if r:
-            self.freq = target_freq
-            self.update_status_bar()
-            self._set_status_msg("OK", 0)
-            return True
-
-        self._set_status_msg("Failed", 0)
-        return False
-
-    def set_gain(self, gain):
-        self.subdev.set_gain(gain)
-
-    def update_status_bar (self):
-        msg = "Freq: %s  Volume:%f  Setting:%s" % (
-            eng_notation.num_to_str(self.freq), self.vol, self.state)
-        self._set_status_msg(msg, 1)
-        
-    def _set_status_msg(self, msg, which=0):
-        print msg
-
-    
-if __name__ == '__main__':
-    tb = wfm_rx_block()
-    try:
-        tb.run()
-    except KeyboardInterrupt:
-        pass
diff --git a/gr-uhd/examples/Makefile.am b/gr-uhd/examples/Makefile.am
index ca27819ae..d25c21d2d 100644
--- a/gr-uhd/examples/Makefile.am
+++ b/gr-uhd/examples/Makefile.am
@@ -30,4 +30,6 @@ dist_ourdata_SCRIPTS =		\
 	max_power.py		\
 	usrp_am_mw_rcv.py	\
 	usrp_nbfm_ptt.py	\
-	usrp_nbfm_rcv.py
+	usrp_nbfm_rcv.py	\
+	usrp_wfm_rcv.py		\
+	usrp_wfm_rcv_nogui.py
diff --git a/gnuradio-examples/python/usrp/usrp_wfm_rcv.py b/gr-uhd/examples/usrp_wfm_rcv.py
index fba2a1210..7b35fbbe4 100755
--- a/gnuradio-examples/python/usrp/usrp_wfm_rcv.py
+++ b/gr-uhd/examples/usrp_wfm_rcv.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright 2005,2006,2007,2009 Free Software Foundation, Inc.
+# Copyright 2005-2007,2009,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, optfir, 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 wfm_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=100.1e6,
                           help="set frequency to FREQ", metavar="FREQ")
         parser.add_option("-g", "--gain", type="eng_float", default=40,
@@ -64,6 +47,10 @@ class wfm_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=87.9e6,
+                          help="Set a minimum frequency [default=%default]")
+        parser.add_option("", "--freq-max", type="eng_float", default=108.1e6,
+                          help="Set a maximum frequency [default=%default]")
 
         (options, args) = parser.parse_args()
         if len(args) != 0:
@@ -77,72 +64,64 @@ class wfm_rx_block (stdgui2.std_top_block):
         self.state = "FREQ"
         self.freq = 0
 
+        self.fm_freq_min = options.freq_min
+        self.fm_freq_max = options.freq_max
+
         # 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 = 1
-        demod_rate = usrp_rate / chanfilt_decim
-        audio_decimation = 10
-        audio_rate = demod_rate / audio_decimation  # 32 kHz
-
-        if options.rx_subdev_spec is None:
-            options.rx_subdev_spec = pick_subdevice(self.u)
-
-        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(),)
-        dbid = self.subdev.dbid()
-        if not (dbid == usrp_dbid.BASIC_RX or
-                dbid == usrp_dbid.TV_RX or
-                dbid == usrp_dbid.TV_RX_REV_2 or
-                dbid == usrp_dbid.TV_RX_REV_3 or
-                dbid == usrp_dbid.TV_RX_MIMO or
-                dbid == usrp_dbid.TV_RX_REV_2_MIMO or
-                dbid == usrp_dbid.TV_RX_REV_3_MIMO
-):
-            print "This daughterboard does not cover the required frequency range"
-            print "for this application.  Please use a BasicRX or TVRX daughterboard."
-            raw_input("Press ENTER to continue anyway, or Ctrl-C to exit.")
-
-        chan_filt_coeffs = optfir.low_pass (1,           # gain
-                                            usrp_rate,   # sampling rate
-                                            80e3,        # passband cutoff
-                                            115e3,       # 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)
-
-        self.guts = blks2.wfm_rcv (demod_rate, audio_decimation)
+        self.u = uhd.usrp_source(device_addr=options.address,
+                                 io_type=uhd.io_type.COMPLEX_FLOAT32,
+                                 num_channels=1)
+
+        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()
+
+        nfilts = 32
+        chan_coeffs = optfir.low_pass (nfilts,           # gain
+                                       nfilts*usrp_rate, # sampling rate
+                                       80e3,             # passband cutoff
+                                       115e3,            # stopband cutoff
+                                       0.1,              # passband ripple
+                                       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_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,
-                                 False)  # ok_to_block
+        self.audio_sink = audio.sink (int (audio_rate),
+                                      options.audio_output,
+                                      False)  # ok_to_block
         
         # 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
 
         if options.volume is None:
             g = self.volume_range()
             options.volume = float(g[0]+g[1])/2
+        
+        frange = self.u.get_freq_range()
+        if(frange.start() > self.fm_freq_max or frange.stop() <  self.fm_freq_min):
+            sys.stderr.write("Radio does not support required frequency range.\n")
+            sys.exit(1)
+        if(options.freq < self.fm_freq_min or options.freq > self.fm_freq_max):
+            sys.stderr.write("Requested frequency is outside of required frequency range.\n")
+            sys.exit(1)
             
-        if abs(options.freq) < 1e6:
-            options.freq *= 1e6
 
         # set initial values
 
@@ -196,7 +175,7 @@ class wfm_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=(87.9e6, 108.1e6, 0.1e6),
+                                        range=(self.fm_freq_min, self.fm_freq_max, 0.1e6),
                                         callback=self.set_freq)
         hbox.Add((5,0), 0)
         vbox.Add(hbox, 0, wx.EXPAND)
@@ -210,9 +189,10 @@ class wfm_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.stop(), g.step()),
                                         callback=self.set_gain)
         hbox.Add((5,0), 0)
         vbox.Add(hbox, 0, wx.EXPAND)
@@ -268,14 +248,9 @@ class wfm_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
@@ -289,7 +264,7 @@ class wfm_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)
diff --git a/gr-uhd/examples/usrp_wfm_rcv_nogui.py b/gr-uhd/examples/usrp_wfm_rcv_nogui.py
new file mode 100755
index 000000000..d8fb055cb
--- /dev/null
+++ b/gr-uhd/examples/usrp_wfm_rcv_nogui.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+#
+# Copyright 2005-2007,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, optfir, audio, blks2, uhd
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+import sys
+
+class wfm_rx_block (gr.top_block):
+
+    def __init__(self):
+        gr.top_block.__init__(self)
+
+        parser=OptionParser(option_class=eng_option)
+        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=100.1e6,
+                          help="set frequency to FREQ", metavar="FREQ")
+        parser.add_option("-g", "--gain", type="eng_float", default=None,
+                          help="set gain in dB (default is midpoint)")
+        parser.add_option("-V", "--volume", type="eng_float", default=None,
+                          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=87.9e6,
+                          help="Set a minimum frequency [default=%default]")
+        parser.add_option("", "--freq-max", type="eng_float", default=108.1e6,
+                          help="Set a maximum frequency [default=%default]")
+
+        (options, args) = parser.parse_args()
+        if len(args) != 0:
+            parser.print_help()
+            sys.exit(1)
+        
+        self.state = "FREQ"
+        self.freq = 0
+
+        self.fm_freq_min = options.freq_min
+        self.fm_freq_max = options.freq_max
+
+        # build graph
+        self.u = uhd.usrp_source(device_addr=options.address,
+                                 io_type=uhd.io_type.COMPLEX_FLOAT32,
+                                 num_channels=1)
+
+        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()
+
+        nfilts = 32
+        chan_coeffs = optfir.low_pass (nfilts,           # gain
+                                       nfilts*usrp_rate, # sampling rate
+                                       80e3,             # passband cutoff
+                                       115e3,            # stopband cutoff
+                                       0.1,              # passband ripple
+                                       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_decim)
+
+        self.volume_control = gr.multiply_const_ff(1)
+
+        # sound card as final sink
+        self.audio_sink = audio.sink(int(audio_rate),
+                                     options.audio_output,
+                                     False)  # ok_to_block
+        
+        # now wire it all together
+        self.connect (self.u, self.chan_filt, self.guts,
+                      self.volume_control, self.audio_sink)
+
+        if options.gain is None:
+            # if no gain was specified, use the mid-point in dB
+            g = self.u.get_gain_range()
+            options.gain = float(g.start()+g.stop())/2
+
+        if options.volume is None:
+            g = self.volume_range()
+            options.volume = float(g[0]+g[1])/2
+
+        frange = self.u.get_freq_range()
+        if(frange.start() > self.fm_freq_max or frange.stop() <  self.fm_freq_min):
+            sys.stderr.write("Radio does not support required frequency range.\n")
+            sys.exit(1)
+        if(options.freq < self.fm_freq_min or options.freq > self.fm_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)):
+            self._set_status_msg("Failed to set initial frequency")
+
+    def set_vol (self, vol):
+        g = self.volume_range()
+        self.vol = max(g[0], min(g[1], vol))
+        self.volume_control.set_k(10**(self.vol/10))
+        self.update_status_bar ()
+
+    def set_freq(self, target_freq):
+        """
+        Set the center frequency we're interested in.
+
+        @param target_freq: frequency in Hz
+        @rypte: bool
+        """
+        
+        r = self.u.set_center_freq(target_freq)
+
+        if r:
+            self.freq = target_freq
+            self.update_status_bar()
+            self._set_status_msg("OK", 0)
+            return True
+
+        self._set_status_msg("Failed", 0)
+        return False
+
+    def set_gain(self, gain):
+        self.u.set_gain(gain)
+
+    def update_status_bar (self):
+        msg = "Freq: %s  Volume:%f  Setting:%s" % (
+            eng_notation.num_to_str(self.freq), self.vol, self.state)
+        self._set_status_msg(msg, 1)
+        
+    def _set_status_msg(self, msg, which=0):
+        print msg
+
+    def volume_range(self):
+        return (-20.0, 0.0, 0.5)
+
+    
+if __name__ == '__main__':
+    tb = wfm_rx_block()
+    try:
+        tb.run()
+    except KeyboardInterrupt:
+        pass