[Commit-gnuradio] r10996 - gnuradio/branches/developers/jblum/digital

[jblum]

Author: jblum
Date: 2009-05-08 17:52:50 -0600 (Fri, 08 May 2009)
New Revision: 10996

Modified:
   gnuradio/branches/developers/jblum/digital/generic_usrp.py
   gnuradio/branches/developers/jblum/digital/receive_path.py
   gnuradio/branches/developers/jblum/digital/transmit_path.py
   gnuradio/branches/developers/jblum/digital/usrp_options.py
Log:
usrp options splits options into multiple groups.
dummy mode for generic usrp (testing purposes).



Modified: gnuradio/branches/developers/jblum/digital/generic_usrp.py
===================================================================
--- gnuradio/branches/developers/jblum/digital/generic_usrp.py  2009-05-08 
22:41:46 UTC (rev 10995)
+++ gnuradio/branches/developers/jblum/digital/generic_usrp.py  2009-05-08 
23:52:50 UTC (rev 10996)
@@ -21,7 +21,18 @@
 
 USRP1_TYPE = 'usrp1'
 USRP2_TYPE = 'usrp2'
-
+DUMMY_TYPE = 'dummy'
+#usrp2 rates common for decim and interp
+_USRP2_RATES = range(4, 128+1, 1) + range(130, 256+1, 2) + range(260, 512+1, 4)
+#dummy common rates
+_DUMMY_XRATES = range(4, 512, 2)
+_DUMMY_CONVERTER_RATE = 100e6
+#dummy freq result
+class _dummy_freq_result(object):
+    def __init__(self, target_freq):
+        self.baseband_freq = target_freq
+        self.dxc_freq = 0
+        self.residual_freq = 0
 from gnuradio import gr, usrp, usrp2
 
 ########################################################################
@@ -31,9 +42,7 @@
 
     def __init__(self, which=0, subdev_spec=None, interface="", mac_addr="",
         fusb_block_size=0, fusb_nblocks=0, usrpx=None, lo_offset=None, 
gain=None):
-        self._gain = gain
         self._lo_offset = lo_offset
-        self._usrpx = usrpx
         #usrp options
         self._which = which
         self._subdev_spec = subdev_spec
@@ -44,8 +53,9 @@
         self._fusb_block_size = fusb_block_size
         self._fusb_nblocks = fusb_nblocks
         #pick which usrp model
-        if self._usrpx == '1' or self._subdev_spec: 
self._setup_usrpx(USRP1_TYPE)
-        elif self._usrpx == '2' or self._mac_addr: 
self._setup_usrpx(USRP2_TYPE)
+        if usrpx == '0': self._setup_usrpx(DUMMY_TYPE)
+        elif usrpx == '1' or self._subdev_spec: self._setup_usrpx(USRP1_TYPE)
+        elif usrpx == '2' or self._mac_addr: self._setup_usrpx(USRP2_TYPE)
         else: #automatic
             try: self._setup_usrpx(USRP2_TYPE)
             except:
@@ -54,7 +64,7 @@
         #post usrp setup
         if self._lo_offset is not None:
             self.set_lo_offset(self._lo_offset)
-        self.set_gain(self._gain)
+        self.set_gain(gain)
         self.set_auto_tr(True)
 
     def _setup_usrpx(self, type):
@@ -65,12 +75,14 @@
         self._type = type
         if self._type == USRP1_TYPE: self._setup_usrp1()
         elif self._type == USRP2_TYPE: self._setup_usrp2()
+        elif self._type == DUMMY_TYPE: self._setup_dummy()
 
     def __str__(self):
         if self._type == USRP1_TYPE: return self._subdev.side_and_name()
         elif self._type == USRP2_TYPE:
             return 'Interface: %s    MAC Address: %s    D-Board ID: 0x%.2x'%(
                 self._u.interface_name(), self._u.mac_addr(), 
self._u.daughterboard_id())
+        elif self._type == DUMMY_TYPE: return 'Dummy USRP Device'
 
     def gain(self): return self._gain
 
@@ -82,24 +94,29 @@
         self._gain = gain
         if self._type == USRP1_TYPE: return self._subdev.set_gain(gain)
         elif self._type == USRP2_TYPE: return self._u.set_gain(gain)
+        elif self._type == DUMMY_TYPE: return True
 
     def gain_range(self):
         if self._type == USRP1_TYPE: return self._subdev.gain_range()
         elif self._type == USRP2_TYPE: return self._u.gain_range()
+        elif self._type == DUMMY_TYPE: return (0, 0)
 
     def set_center_freq(self, target_freq):
         if self._type == USRP1_TYPE:
             return self._u.tune(self._dxc, self._subdev, target_freq)
         elif self._type == USRP2_TYPE:
             return self._u.set_center_freq(target_freq)
+        elif self._type == DUMMY_TYPE: return _dummy_freq_result(target_freq)
 
     def freq_range(self):
         if self._type == USRP1_TYPE: return self._subdev.freq_range()
         elif self._type == USRP2_TYPE: return self._u.freq_range()
+        elif self._type == DUMMY_TYPE: return (-10e9, 10e9, 100e3)
 
     def set_lo_offset(self, lo_offset):
         if self._type == USRP1_TYPE: return 
self._subdev.set_lo_offset(lo_offset)
         elif self._type == USRP2_TYPE: return self._u.set_lo_offset(lo_offset)
+        elif self._type == DUMMY_TYPE: return True
 
     def set_auto_tr(self, enable):
         if self._type == USRP1_TYPE: return self._subdev.set_auto_tr(enable)
@@ -134,20 +151,22 @@
         if decim not in self.get_decim_rates(): return False
         if self._type == USRP1_TYPE: return self._u.set_decim_rate(decim)
         elif self._type == USRP2_TYPE: return self._u.set_decim(decim)
+        elif self._type == DUMMY_TYPE: return True
 
     def get_decim_rates(self):
         if self._type == USRP1_TYPE: return range(8, 256+1, 2) #default 
firmware w/ hb filters
-        if self._type == USRP2_TYPE: return range(4, 128+1, 1) + \
-            range(130, 256+1, 2) + \
-            range(260, 512+1, 4)
+        if self._type == USRP2_TYPE: return _USRP2_RATES
+        elif self._type == DUMMY_TYPE: return _DUMMY_XRATES
 
-    def adc_rate(self): return self._u.adc_rate()
+    def adc_rate(self):
+        if self._type == USRP1_TYPE: return self._u.adc_rate()
+        if self._type == USRP2_TYPE: return self._u.adc_rate()
+        elif self._type == DUMMY_TYPE: return _DUMMY_CONVERTER_RATE
 
     ####################################################################
     # setup usrp methods
     ####################################################################
     def _setup_usrp1(self):
-        self._type = USRP1_TYPE
         self._u = usrp.source_c (self._which,
                                 fusb_block_size=self._fusb_block_size,
                                 fusb_nblocks=self._fusb_nblocks)
@@ -159,9 +178,10 @@
         self._dxc = 0
 
     def _setup_usrp2(self):
-        self._type = USRP2_TYPE
         self._u = usrp2.source_32fc(self._interface, self._mac_addr)
 
+    def _setup_dummy(self): self._u = gr.null_source(gr.sizeof_gr_complex)
+
 ########################################################################
 # generic usrp sink
 ########################################################################
@@ -179,7 +199,7 @@
         _generic_usrp_base.__init__(self, **kwargs)
         if self._type == USRP1_TYPE: #scale 0.0 to 1.0 input for usrp1
             self.connect(self, gr.multiply_const_cc((2**15)-1), self._u)
-        elif self._type == USRP2_TYPE: self.connect(self, self._u)
+        else: self.connect(self, self._u)
 
     ####################################################################
     # generic access methods
@@ -188,20 +208,22 @@
         if interp not in self.get_interp_rates(): return False
         if self._type == USRP1_TYPE: return self._u.set_interp_rate(interp)
         elif self._type == USRP2_TYPE: return self._u.set_interp(interp)
+        elif self._type == DUMMY_TYPE: return True
 
     def get_interp_rates(self):
         if self._type == USRP1_TYPE: return range(16, 512+1, 4)
-        if self._type == USRP2_TYPE: return range(4, 128+1, 1) + \
-            range(130, 256+1, 2) + \
-            range(260, 512+1, 4)
+        if self._type == USRP2_TYPE: return _USRP2_RATES
+        elif self._type == DUMMY_TYPE: return _DUMMY_XRATES
 
-    def dac_rate(self): return self._u.dac_rate()
+    def dac_rate(self):
+        if self._type == USRP1_TYPE: return self._u.dac_rate()
+        if self._type == USRP2_TYPE: return self._u.dac_rate()
+        elif self._type == DUMMY_TYPE: return _DUMMY_CONVERTER_RATE
 
     ####################################################################
     # setup usrp methods
     ####################################################################
     def _setup_usrp1(self):
-        self._type = USRP1_TYPE
         self._u = usrp.sink_c (self._which,
                                 fusb_block_size=self._fusb_block_size,
                                 fusb_nblocks=self._fusb_nblocks)
@@ -212,6 +234,6 @@
         self._u.set_mux(usrp.determine_tx_mux_value(self._u, 
self._subdev_spec))
         self._dxc = self._subdev.which()
 
-    def _setup_usrp2(self):
-        self._type = USRP2_TYPE
-        self._u = usrp2.sink_32fc(self._interface, self._mac_addr)
+    def _setup_usrp2(self): self._u = usrp2.sink_32fc(self._interface, 
self._mac_addr)
+
+    def _setup_dummy(self): self._u = gr.null_sink(gr.sizeof_gr_complex)

Modified: gnuradio/branches/developers/jblum/digital/receive_path.py
===================================================================
--- gnuradio/branches/developers/jblum/digital/receive_path.py  2009-05-08 
22:41:46 UTC (rev 10995)
+++ gnuradio/branches/developers/jblum/digital/receive_path.py  2009-05-08 
23:52:50 UTC (rev 10996)
@@ -177,7 +177,7 @@
         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.")
-        usrp_options.add_rx_options(normal, expert)
+        usrp_options.add_rx_options(normal)
         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]")

Modified: gnuradio/branches/developers/jblum/digital/transmit_path.py
===================================================================
--- gnuradio/branches/developers/jblum/digital/transmit_path.py 2009-05-08 
22:41:46 UTC (rev 10995)
+++ gnuradio/branches/developers/jblum/digital/transmit_path.py 2009-05-08 
23:52:50 UTC (rev 10996)
@@ -160,7 +160,7 @@
         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.")
-        usrp_options.add_tx_options(normal, expert)
+        usrp_options.add_tx_options(normal)
         normal.add_option("--tx-amplitude", type="eng_float", default=0.15, 
metavar="AMPL",
                           help="set transmitter digital amplitude (0.0-1.0) 
[default=%default].")
         normal.add_option("-v", "--verbose", action="store_true", 
default=False)

Modified: gnuradio/branches/developers/jblum/digital/usrp_options.py
===================================================================
--- gnuradio/branches/developers/jblum/digital/usrp_options.py  2009-05-08 
22:41:46 UTC (rev 10995)
+++ gnuradio/branches/developers/jblum/digital/usrp_options.py  2009-05-08 
23:52:50 UTC (rev 10996)
@@ -19,59 +19,63 @@
 # Boston, MA 02110-1301, USA.
 #
 
+_parser_to_groups_dict = dict()
+class _parser_groups(object):
+    def __init__(self, parser):
+        self.usrpx_grp = parser.add_option_group("General USRP Options")
+        self.usrp1_grp = parser.add_option_group("USRP1 Specific Options")
+        self.usrp1exp_grp = parser.add_option_group("USRP1 Expert Options")
+        self.usrp2_grp = parser.add_option_group("USRP2 Specific Options")
+
 import generic_usrp
 
-def _add_options(parser, expert):
+def _add_options(parser):
     """
     Add options to manually choose between usrp or usrp2.
     Add options for usb. Add options common to source and sink.
     @param parser: instance of OptionParser
+    @return the parser group
     """
+    #cache groups so they dont get added twice on tranceiver apps
+    if not _parser_to_groups_dict.has_key(parser): 
_parser_to_groups_dict[parser] = _parser_groups(parser)
+    pg = _parser_to_groups_dict[parser]
     #pick usrp or usrp2
-    parser.add_option("-u", "--usrpx", type="string", default=None,
+    pg.usrpx_grp.add_option("-u", "--usrpx", type="string", default=None,
                       help="specify which usrp model: 1 for USRP, 2 for USRP2 
[default=auto]")
     #fast usb options
-    if expert: expert.add_option("-B", "--fusb-block-size", type="int", 
default=0,
+    pg.usrp1exp_grp.add_option("-B", "--fusb-block-size", type="int", 
default=0,
                       help="specify fast usb block size [default=%default]")
-    if expert: expert.add_option("-N", "--fusb-nblocks", type="int", default=0,
+    pg.usrp1exp_grp.add_option("-N", "--fusb-nblocks", type="int", default=0,
                       help="specify number of fast usb blocks 
[default=%default]")
     #lo offset
-    parser.add_option("--lo-offset", type="eng_float", default=None,
+    pg.usrpx_grp.add_option("--lo-offset", type="eng_float", default=None,
                       help="set LO Offset in Hz [default=automatic].")
     #usrp options
-    parser.add_option("-w", "--which", type="int", default=0,
+    pg.usrp1_grp.add_option("-w", "--which", type="int", default=0,
                       help="select USRP board [default=%default]")
     #usrp2 options
-    parser.add_option("-e", "--interface", type="string", default="eth0",
+    pg.usrp2_grp.add_option("-e", "--interface", type="string", default="eth0",
                       help="Use USRP2 at specified Ethernet interface 
[default=%default]")
-    parser.add_option("-m", "--mac-addr", type="string", default="",
+    pg.usrp2_grp.add_option("-m", "--mac-addr", type="string", default="",
                       help="Use USRP2 at specified MAC address [default=None]")
+    return pg
 
-def _ensure_values(options):
+def add_rx_options(parser):
     """
-    Ensure that expert options exist even if they did not get added to the 
parser.
-    @param options the parsed options
-    """
-    options.ensure_value('fusb_block_size', 0)
-    options.ensure_value('fusb_nblocks', 0)
-
-def add_rx_options(parser, expert=None):
-    """
     Add receive specific usrp options.
     @param parser: instance of OptionParser
     """
-    parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
+    pg = _add_options(parser)
+    pg.usrp1_grp.add_option("-R", "--rx-subdev-spec", type="subdev", 
default=None,
                       help="select USRP Rx side A or B")
-    parser.add_option("--rx-gain", type="eng_float", default=None, 
metavar="GAIN",
+    pg.usrpx_grp.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")
-    parser.add_option("--show-rx-gain-range", action="store_true", 
default=False, 
+    pg.usrpx_grp.add_option("--show-rx-gain-range", action="store_true", 
default=False, 
                       help="print min and max Rx gain available on selected 
daughterboard")
-    parser.add_option("-d", "--decim", type="intx", default=None,
+    pg.usrpx_grp.add_option("-d", "--decim", type="intx", default=None,
                       help="set fpga decimation rate to DECIM 
[default=%default]")
-    _add_options(parser, expert)
 
 def create_usrp_source(options):
-    _ensure_values(options)
     u = generic_usrp.generic_usrp_source_c(
         usrpx=options.usrpx,
         which=options.which,
@@ -87,23 +91,22 @@
         print "Rx Gain Range: minimum = %g, maximum = %g, step size = 
%g"%tuple(u.gain_range())
     return u
 
-def add_tx_options(parser, expert=None):
+def add_tx_options(parser):
     """
     Add transmit specific usrp options.
     @param parser: instance of OptionParser
     """
-    parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
+    pg = _add_options(parser)
+    pg.usrp1_grp.add_option("-T", "--tx-subdev-spec", type="subdev", 
default=None,
                       help="select USRP Rx side A or B")
-    parser.add_option("--tx-gain", type="eng_float", default=None, 
metavar="GAIN",
+    pg.usrpx_grp.add_option("--tx-gain", type="eng_float", default=None, 
metavar="GAIN",
                       help="set transmitter gain in dB [default=midpoint].  
See also --show-tx-gain-range")
-    parser.add_option("--show-tx-gain-range", action="store_true", 
default=False, 
+    pg.usrpx_grp.add_option("--show-tx-gain-range", action="store_true", 
default=False, 
                       help="print min and max Tx gain available on selected 
daughterboard")
-    parser.add_option("-i", "--interp", type="intx", default=None,
+    pg.usrpx_grp.add_option("-i", "--interp", type="intx", default=None,
                       help="set fpga interpolation rate to INTERP 
[default=%default]")
-    _add_options(parser, expert)
 
 def create_usrp_sink(options):
-    _ensure_values(options)
     u = generic_usrp.generic_usrp_sink_c(
         usrpx=options.usrpx,
         which=options.which,