#!/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.
#
"""
Transmit 2 signals, one out each daughterboard.
Outputs SSB (USB) signals on side A and side B at frequencies
specified on command line.
Side A is 600 Hz tone.
Side B is 350 + 440 Hz tones.
"""
from gnuradio import gr, uhd, blks2
from gnuradio.eng_notation import num_to_str, str_to_num
from gnuradio.eng_option import eng_option
from optparse import OptionParser
import math
import sys
class example_signal_0(gr.hier_block2):
"""
Sinusoid at 600 Hz.
"""
def __init__(self, sample_rate):
gr.hier_block2.__init__(self, "example_signal_0",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
src = gr.sig_source_c (sample_rate, # sample rate
gr.GR_SIN_WAVE, # waveform type
600, # frequency
1.0, # amplitude
0) # DC Offset
self.connect(src, self)
class example_signal_1(gr.hier_block2):
"""
North American dial tone (350 + 440 Hz).
"""
def __init__(self, sample_rate):
gr.hier_block2.__init__(self, "example_signal_1",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
src0 = gr.sig_source_c (sample_rate, # sample rate
gr.GR_SIN_WAVE, # waveform type
350, # frequency
1.0, # amplitude
0) # DC Offset
src1 = gr.sig_source_c (sample_rate, # sample rate
gr.GR_SIN_WAVE, # waveform type
440, # frequency
1.0, # amplitude
0) # DC Offset
sum = gr.add_cc()
self.connect(src0, (sum, 0))
self.connect(src1, (sum, 1))
self.connect(sum, self)
class my_top_block(gr.top_block):
def __init__(self):
gr.top_block.__init__(self)
usage="%prog: [options] tx-freq0 tx-freq1"
parser = OptionParser (option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=320e3,
help="set sample rate [default=%default]")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
(options, args) = parser.parse_args ()
if len(args) != 2:
parser.print_help()
raise SystemExit
else:
freq0 = str_to_num(args[0])
freq1 = str_to_num(args[1])
# ----------------------------------------------------------------
# Set up USRP to transmit on both daughterboards
d = uhd.find_devices(uhd.device_addr(options.args))
uhd_type = d[0].get('type')
stream_args = uhd.stream_args('fc32', channels=range(2))
self.u = uhd.usrp_sink(device_addr=options.args, stream_args=stream_args)
# Set up USRP system based on type
if(uhd_type == "usrp"):
self.u.set_subdev_spec("A:0 B:0")
tr0 = uhd.tune_request(freq0)
tr1 = uhd.tune_request(freq1)
else:
if abs(freq0 - freq1) > 5.5e6:
sys.stderr.write("\nError: When not using two separate d'boards, frequencies must bewithin 5.5MHz of each other.\n")
raise SystemExit
self.u.set_subdev_spec("A:0 A:0")
mid_freq = (freq0 + freq1)/2.0
tr0 = uhd.tune_request(freq0, rf_freq=mid_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL)
tr1 = uhd.tune_request(freq1, rf_freq=mid_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL)
# Use the tune requests to tune each channel
self.set_freq(tr0, 0)
self.set_freq(tr1, 1)
self.usrp_rate = options.samp_rate
self.u.set_samp_rate(self.usrp_rate)
dev_rate = self.u.get_samp_rate()
# ----------------------------------------------------------------
# build two signal sources, interleave them, amplify and
# connect them to usrp
sig0 = example_signal_0(self.usrp_rate)
sig1 = example_signal_1(self.usrp_rate)
intl = gr.interleave(gr.sizeof_gr_complex)
self.connect(sig0, (intl, 0))
self.connect(sig1, (intl, 1))
# Correct for any difference in requested and actual rates
rrate = self.usrp_rate / dev_rate
resamp = blks2.pfb_arb_resampler_ccf(rrate)
# and wire them up
self.connect(intl, resamp, self.u)
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.0
self.set_gain(options.gain, 0)
self.set_gain(options.gain, 1)
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_antenna(options.antenna, 1)
def set_freq(self, target_freq, chan):
"""
Set the center frequency we're interested in.
@param side: 0 = side A, 1 = side B
@param target_freq: frequency in Hz
@rtype: bool
"""
print "Tuning channel %s to %sHz" % \
(chan, num_to_str(target_freq))
r = self.u.set_center_freq(target_freq, chan)
if r:
return True
else:
print " Set Frequency Failed!"
return False
def set_gain(self, gain, chan):
self.u.set_gain(gain, chan)
if __name__ == '__main__':
try:
my_top_block().run()
except KeyboardInterrupt:
pass