# 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
########################################################################
########################################################################
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
#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
"""
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)
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
"""
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)
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)
_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()
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)
"""
# 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
@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
@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)
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
# 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:
# 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)
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
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]")
# 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
# 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)
# 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)
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):
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]")
# 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(
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(
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())
projects / debian / gnuradio / commitdiff