diff options
| -rw-r--r-- | gnuradio-examples/python/digital/generic_usrp.py | 162 | ||||
| -rw-r--r-- | gnuradio-examples/python/digital/pick_bitrate.py | 26 | ||||
| -rw-r--r-- | gnuradio-examples/python/digital/receive_path.py | 16 | ||||
| -rw-r--r-- | gnuradio-examples/python/digital/transmit_path.py | 27 | ||||
| -rw-r--r-- | gnuradio-examples/python/digital/usrp_options.py | 58 |
5 files changed, 170 insertions, 119 deletions
diff --git a/gnuradio-examples/python/digital/generic_usrp.py b/gnuradio-examples/python/digital/generic_usrp.py index ac5b13c81..7f062f3c7 100644 --- a/gnuradio-examples/python/digital/generic_usrp.py +++ b/gnuradio-examples/python/digital/generic_usrp.py @@ -19,9 +19,20 @@ # Boston, MA 02110-1301, USA. # -USRP_TYPE = 'usrp' +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 ######################################################################## @@ -29,9 +40,9 @@ from gnuradio import gr, usrp, usrp2 ######################################################################## class _generic_usrp_base(object): - def __init__(self, which=0, subdev_spec=None, interface="", mac_addr="", fusb_block_size=0, fusb_nblocks=0, usrpx=None): - self._gain = 0 - self._usrpx = usrpx + 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._lo_offset = lo_offset #usrp options self._which = which self._subdev_spec = subdev_spec @@ -41,37 +52,80 @@ class _generic_usrp_base(object): #fusb options self._fusb_block_size = fusb_block_size self._fusb_nblocks = fusb_nblocks + #pick which usrp model + 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: + try: self._setup_usrpx(USRP1_TYPE) + except: raise Exception, 'Failed to automatically setup a usrp device.' + #post usrp setup + if self._lo_offset is not None: + self.set_lo_offset(self._lo_offset) + self.set_gain(gain) + self.set_auto_tr(True) + + def _setup_usrpx(self, type): + """ + Call the appropriate setup method. + @param type the usrp type constant + """ + 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 == USRP_TYPE: return self._subdev.side_and_name() - elif self._type == USRP2_TYPE: return "D-Board ID 0x%x\n"%self._u.daughterboard_id() + 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 def set_gain(self, gain=None): - if gain is None: - r = self.gain_range() - gain = (r[0] + r[1])/2 # set gain to midpoint + #automatic gain calculation + r = self.gain_range() + if gain is None: gain = (r[0] + r[1])/2 # set gain to midpoint + #set gain for usrp self._gain = gain - if self._type == USRP_TYPE: return self._subdev.set_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 == USRP_TYPE: return self._subdev.gain_range() + 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 == USRP_TYPE: - return bool(self._u.tune(self._dxc, self._subdev, 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 == USRP_TYPE: return self._subdev.set_auto_tr(enable) + if self._type == USRP1_TYPE: return self._subdev.set_auto_tr(enable) def __del__(self): - # Avoid weak reference error - if self._type == USRP_TYPE: del self._subdev + try: # Avoid weak reference error + del self._u + del self._subdev + except: pass ######################################################################## # generic usrp source @@ -84,34 +138,35 @@ class generic_usrp_source_c(_generic_usrp_base, gr.hier_block2): """ def __init__(self, **kwargs): - _generic_usrp_base.__init__(self, **kwargs) gr.hier_block2.__init__(self, "generic_usrp_source", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature - #pick usrp or usrp2 - if self._usrpx == '1' or self._subdev_spec: - self._setup_usrp_source() - elif self._usrpx == '2' or self._mac_addr: - self._setup_usrp2_source() - else: #automatic - try: self._setup_usrp2_source() - except: self._setup_usrp_source() + _generic_usrp_base.__init__(self, **kwargs) self.connect(self._u, self) - self.set_auto_tr(True) #################################################################### # generic access methods #################################################################### def set_decim(self, decim): - if self._type == USRP_TYPE: return self._u.set_decim_rate(decim) + 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 _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_usrp_source(self): + def _setup_usrp1(self): self._u = usrp.source_c (self._which, fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) @@ -120,12 +175,12 @@ class generic_usrp_source_c(_generic_usrp_base, gr.hier_block2): self._subdev_spec = usrp.pick_rx_subdevice(self._u) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec)) - self._type = USRP_TYPE self._dxc = 0 - def _setup_usrp2_source(self): + def _setup_usrp2(self): self._u = usrp2.source_32fc(self._interface, self._mac_addr) - self._type = USRP2_TYPE + + def _setup_dummy(self): self._u = gr.null_source(gr.sizeof_gr_complex) ######################################################################## # generic usrp sink @@ -138,39 +193,37 @@ class generic_usrp_sink_c(_generic_usrp_base, gr.hier_block2): """ def __init__(self, **kwargs): - _generic_usrp_base.__init__(self, **kwargs) gr.hier_block2.__init__(self, "generic_usrp_sink", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(0, 0, 0)) # Output signature - - #pick usrp or usrp2 - if self._usrpx == '1' or self._subdev_spec: - self._setup_usrp_source() - elif self._usrpx == '2' or self._mac_addr: - self._setup_usrp2_source() - else: #automatic - try: self._setup_usrp2_source() - except: self._setup_usrp_source() - self.connect(self, self._u) - self.set_auto_tr(True) + _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) + else: self.connect(self, self._u) #################################################################### # generic access methods #################################################################### def set_interp(self, interp): - if self._type == USRP_TYPE: return self._u.set_interp_rate(interp) + 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 dac_rate(self): return self._u.dac_rate() + def get_interp_rates(self): + if self._type == USRP1_TYPE: return range(16, 512+1, 4) + if self._type == USRP2_TYPE: return _USRP2_RATES + elif self._type == DUMMY_TYPE: return _DUMMY_XRATES - def ampl_range(self): - if self._type == USRP_TYPE: return (0.0, 2.**15-1) - elif self._type == USRP2_TYPE: return (0.0, 1.0) + 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_usrp_source(self): + def _setup_usrp1(self): self._u = usrp.sink_c (self._which, fusb_block_size=self._fusb_block_size, fusb_nblocks=self._fusb_nblocks) @@ -179,9 +232,8 @@ class generic_usrp_sink_c(_generic_usrp_base, gr.hier_block2): self._subdev_spec = usrp.pick_tx_subdevice(self._u) self._subdev = usrp.selected_subdev(self._u, self._subdev_spec) self._u.set_mux(usrp.determine_tx_mux_value(self._u, self._subdev_spec)) - self._type = USRP_TYPE self._dxc = self._subdev.which() - def _setup_usrp2_source(self): - self._u = usrp2.sink_32fc(self._interface, self._mac_addr) - self._type = USRP2_TYPE + 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) diff --git a/gnuradio-examples/python/digital/pick_bitrate.py b/gnuradio-examples/python/digital/pick_bitrate.py index 73957421b..ce1e021c5 100644 --- a/gnuradio-examples/python/digital/pick_bitrate.py +++ b/gnuradio-examples/python/digital/pick_bitrate.py @@ -25,19 +25,19 @@ _default_bitrate = 500e3 _valid_samples_per_symbol = (2,3,4,5,6,7) -def _gen_tx_info(converter_rate): +def _gen_tx_info(converter_rate, xrates): results = [] for samples_per_symbol in _valid_samples_per_symbol: - for interp in range(16, 512 + 1, 4): + for interp in xrates: bitrate = converter_rate / interp / samples_per_symbol results.append((bitrate, samples_per_symbol, interp)) results.sort() return results -def _gen_rx_info(converter_rate): +def _gen_rx_info(converter_rate, xrates): results = [] for samples_per_symbol in _valid_samples_per_symbol: - for decim in range(8, 256 + 1, 2): + for decim in xrates: bitrate = converter_rate / decim / samples_per_symbol results.append((bitrate, samples_per_symbol, decim)) results.sort() @@ -79,7 +79,7 @@ def _pick_best(target_bitrate, bits_per_symbol, info): return ((best[0] * bits_per_symbol),) + best[1:] def _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol, - xrate, converter_rate, gen_info): + xrate, converter_rate, xrates, gen_info): """ @returns tuple (bitrate, samples_per_symbol, interp_rate_or_decim_rate) """ @@ -97,14 +97,14 @@ def _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol, # samples_per_symbol constraint, but not both of them. ret = _pick_best(bitrate, bits_per_symbol, - _filter_info(gen_info(converter_rate), samples_per_symbol, xrate)) + _filter_info(gen_info(converter_rate, xrates), samples_per_symbol, xrate)) print "Actual Bitrate:", eng_notation.num_to_str(ret[0]) return ret # --------------------------------------------------------------------------------------- def pick_tx_bitrate(bitrate, bits_per_symbol, samples_per_symbol, - interp_rate, converter_rate): + interp_rate, converter_rate, possible_interps): """ Given the 4 input parameters, return at configuration that matches @@ -118,16 +118,18 @@ def pick_tx_bitrate(bitrate, bits_per_symbol, samples_per_symbol, @type interp_rate: integer or None @param converter_rate: converter sample rate in Hz @type converter_rate: number + @param possible_interps: a list of possible rates + @type possible_interps: a list of integers @returns tuple (bitrate, samples_per_symbol, interp_rate) """ - print "Requested TX Bitrate:", bitrate and eng_notation.num_to_str(bitrate) or 'Auto' + print "Requested TX Bitrate:", bitrate and eng_notation.num_to_str(bitrate) or 'Auto', return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol, - interp_rate, converter_rate, _gen_tx_info) + interp_rate, converter_rate, possible_interps, _gen_tx_info) def pick_rx_bitrate(bitrate, bits_per_symbol, samples_per_symbol, - decim_rate, converter_rate): + decim_rate, converter_rate, possible_decims): """ Given the 4 input parameters, return at configuration that matches @@ -141,9 +143,11 @@ def pick_rx_bitrate(bitrate, bits_per_symbol, samples_per_symbol, @type decim_rate: integer or None @param converter_rate: converter sample rate in Hz @type converter_rate: number + @param possible_decims: a list of possible rates + @type possible_decims: a list of integers @returns tuple (bitrate, samples_per_symbol, decim_rate) """ print "Requested RX Bitrate:", bitrate and eng_notation.num_to_str(bitrate) or 'Auto' return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol, - decim_rate, converter_rate, _gen_rx_info) + decim_rate, converter_rate, possible_decims, _gen_rx_info) diff --git a/gnuradio-examples/python/digital/receive_path.py b/gnuradio-examples/python/digital/receive_path.py index 7d9a08ca9..507d05e7b 100644 --- a/gnuradio-examples/python/digital/receive_path.py +++ b/gnuradio-examples/python/digital/receive_path.py @@ -45,7 +45,6 @@ class receive_path(gr.hier_block2): self._verbose = options.verbose self._rx_freq = options.rx_freq # receiver's center frequency - self._rx_gain = options.rx_gain # receiver's gain 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 @@ -60,11 +59,6 @@ class receive_path(gr.hier_block2): # Set up USRP source; also adjusts decim, samples_per_symbol, and bitrate self._setup_usrp_source(options) - if options.show_rx_gain_range: - print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g"%tuple(self.u.gain_range()) - - self.set_gain(options.rx_gain) - # Set RF frequency ok = self.set_freq(self._rx_freq) if not ok: @@ -125,7 +119,7 @@ class receive_path(gr.hier_block2): # 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._samples_per_symbol, self._decim, adc_rate, self.u.get_decim_rates()) self.u.set_decim(self._decim) @@ -142,12 +136,6 @@ class receive_path(gr.hier_block2): determine the value for the digital up converter. """ return self.u.set_center_freq(target_freq) - - def set_gain(self, gain): - """ - Sets the analog gain in the USRP - """ - return self.u.set_gain(gain) def bitrate(self): return self._bitrate @@ -189,7 +177,7 @@ class receive_path(gr.hier_block2): 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]") diff --git a/gnuradio-examples/python/digital/transmit_path.py b/gnuradio-examples/python/digital/transmit_path.py index 9486d795f..2819e87f4 100644 --- a/gnuradio-examples/python/digital/transmit_path.py +++ b/gnuradio-examples/python/digital/transmit_path.py @@ -62,9 +62,6 @@ class transmit_path(gr.hier_block2): # Set up USRP sink; also adjusts interp, samples_per_symbol, and bitrate self._setup_usrp_sink(options) - if options.show_tx_ampl_range: - print "Tx Amplitude Range: minimum = %g, maximum = %g"%tuple(self.u.ampl_range()) - # copy the final answers back into options for use by modulator options.samples_per_symbol = self._samples_per_symbol options.bitrate = self._bitrate @@ -90,7 +87,7 @@ class transmit_path(gr.hier_block2): # 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.set_gain(self.u.gain_range()[1]) self.amp = gr.multiply_const_cc(1) self.set_tx_amplitude(self._tx_amplitude) @@ -113,7 +110,7 @@ class transmit_path(gr.hier_block2): # 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) + self._samples_per_symbol, self._interp, dac_rate, self.u.get_interp_rates()) self.u.set_interp(self._interp) @@ -131,21 +128,13 @@ class transmit_path(gr.hier_block2): determine the value for the digital up converter. """ return self.u.set_center_freq(target_freq) - - def set_gain(self, gain): - """ - Sets the analog gain in the USRP - """ - return self.u.set_gain(gain) def set_tx_amplitude(self, ampl): """ Sets the transmit amplitude sent to the USRP - @param ampl the amplitude or None for automatic + @param ampl the amplitude between 0.0 and 1.0 """ - ampl_range = self.u.ampl_range() - if ampl is None: ampl = (ampl_range[1] - ampl_range[0])*0.15 + ampl_range[0] - self._tx_amplitude = max(ampl_range[0], min(ampl, ampl_range[1])) + self._tx_amplitude = max(0.0, min(ampl, 1.0)) self.amp.set_k(self._tx_amplitude) def send_pkt(self, payload='', eof=False): @@ -171,11 +160,9 @@ class transmit_path(gr.hier_block2): 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) - normal.add_option("--tx-amplitude", type="eng_float", default=None, metavar="AMPL", - help="set transmitter digital amplitude [default=midpoint]. See also --show-tx-ampl-range") - normal.add_option("--show-tx-ampl-range", action="store_true", default=False, - help="print min and max Tx amplitude available") + 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) expert.add_option("-S", "--samples-per-symbol", type="int", default=None, help="set samples/symbol [default=%default]") diff --git a/gnuradio-examples/python/digital/usrp_options.py b/gnuradio-examples/python/digital/usrp_options.py index 5408d2f3d..380ef60f4 100644 --- a/gnuradio-examples/python/digital/usrp_options.py +++ b/gnuradio-examples/python/digital/usrp_options.py @@ -19,45 +19,61 @@ # 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 - 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]") - 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 + 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("-a", "--mac-addr", type="string", default="", help="Use USRP2 at specified MAC address [default=None]") + return pg -def add_rx_options(parser, expert=None): +def add_rx_options(parser): """ 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): u = generic_usrp.generic_usrp_source_c( @@ -68,25 +84,27 @@ def create_usrp_source(options): mac_addr=options.mac_addr, fusb_block_size=options.fusb_block_size, fusb_nblocks=options.fusb_nblocks, + lo_offset=options.lo_offset, + gain=options.rx_gain, ) if options.show_rx_gain_range: 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): u = generic_usrp.generic_usrp_sink_c( @@ -97,6 +115,8 @@ def create_usrp_sink(options): mac_addr=options.mac_addr, fusb_block_size=options.fusb_block_size, fusb_nblocks=options.fusb_nblocks, + lo_offset=options.lo_offset, + gain=options.tx_gain, ) if options.show_tx_gain_range: print "Tx Gain Range: minimum = %g, maximum = %g, step size = %g"%tuple(u.gain_range()) |