def __init__(self, N, fs):
gr.hier_block2.__init__(self,
"usrp_source",
gr.io_signature(0,0,0),
gr.io_signature(1,1, gr.sizeof_gr_complex))
# Parameters.
frequency = 1575.6e6
decim_rate = int(64e6/fs)
fpga_filename = "std_4rx_0tx.rbf"
# Sources.
usrp = usrp.source_c( decim_rate=decim_rate, fpga_filename=fpga_filename )
head = gr.head( gr.sizeof_gr_complex, N*fs*1e-3 )
self.connect( usrp, head, self )
# USRP settings.
rx_subdev_spec = usrp.pick_rx_subdevice(usrp)
usrp.set_mux(usrp.determine_rx_mux_value(usrp, rx_subdev_spec))
subdev = usrp.selected_subdev( usrp, rx_subdev_spec )
print "Subdev gain range: "
print subdev.gain_range()
subdev.set_gain(70)
r = usrp.tune( 0,_subdev, frequency )
if not r:
sys.exit('Failed to set frequency')
def __init__(self, usrp_offset):
gr.flow_graph.__init__(self)
print "decim = %d, gain = %d, offset = %.2f" % (decim, gain, usrp_offset)
print "filter center %.2f, filter width %.2f" % (xcf, xtw)
u = usrp.source_c(decim_rate=decim)
s = usrp.pick_subdev(u, (usrp_dbid.DBS_RX,))
u.set_mux(usrp.determine_rx_mux_value(u, s))
subdev = usrp.selected_subdev(u, s)
if subdev.dbid() != usrp_dbid.DBS_RX:
raise Exception("dbs daughterboard not detected!")
subdev.set_gain(gain)
sps = u.adc_freq() / u.decim_rate()
if sps < 2 * gsm_rate:
raise Exception("sample rate too low")
u.tune(0, subdev, c0 + usrp_offset)
xt = gr.firdes.low_pass(1.0, sps, xcf, xtw, gr.firdes.WIN_HAMMING)
xf = gr.fir_filter_ccf(1, xt)
self.gs = gs = gssm.sink(sps)
self.connect(u, xf, gs)
def __init__(self, usrp_offset):
gr.top_block.__init__(self)
u = usrp.source_c(decim_rate = decim)
s = usrp.pick_subdev(u, (usrp_dbid.DBS_RX,))
u.set_mux(usrp.determine_rx_mux_value(u, s))
subdev = usrp.selected_subdev(u, s)
if subdev.dbid() != usrp_dbid.DBS_RX:
raise Exception('dbs daughterboard not detected!')
subdev.set_gain(gain)
sps = u.adc_freq() / u.decim_rate()
if sps < 2 * gsm_rate:
raise Exception('sample rate too low')
u.tune(0, subdev, c0 + usrp_offset)
xcf = 150e3
xtw = 50e3
xt = gr.firdes.low_pass(1.0, sps, xcf, xtw,
gr.firdes.WIN_HAMMING)
xf = gr.fir_filter_ccf(1, xt)
g = gssm.sink(sps)
self.connect(u, xf, g)
def setup_usrp(freq, gain):
######## set up usrp
u = usrp.source_c(decim_rate=32) # 2M sampling freq
rx_subdev_spec = usrp.pick_rx_subdevice(u)
#print "u.db(0,0).dbid() = ", self.u.db(0,0).dbid()
#print "u.db(1,0).dbid() = ", self.u.db(1,0).dbid()
#print "rx_subdev_spec = ", options.rx_subdev_spec
mux=usrp.determine_rx_mux_value(u, rx_subdev_spec)
#print "mux = ", mux
u.set_mux(mux)
# determine the daughterboard subdevice we're using
subdev = usrp.selected_subdev(u, rx_subdev_spec)
#print "Using RX d'board %s" % (self.subdev.side_and_name(),)
input_rate = u.adc_freq() / u.decim_rate()
#print "ADC sampling @ ", eng_notation.num_to_str(self.u.adc_freq())
#print "USB sample rate %s" % (eng_notation.num_to_str(input_rate))
subdev.set_gain(gain)
r = u.tune(0, subdev, freq)
#print "freq range = [%s, %s]" % (eng_notation.num_to_str(self.subdev.freq_min()), eng_notation.num_to_str(self.subdev.freq_max()))
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
return u
def _setup_usrp_source(self):
self.rx_u = usrp.source_c (fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
adc_rate = self.rx_u.adc_rate()
self.rx_u.set_decim_rate(self._decim)
# determine the daughterboard subdevice we're using
if self._rx_subdev_spec is None:
print 'not set rx subdev'
self._rx_subdev_spec = usrp.pick_rx_subdevice(self.rx_u)
print self._rx_subdev_spec
self.rx_subdev = usrp.selected_subdev(self.rx_u, self._rx_subdev_spec)
gains = self.rx_subdev.gain_range()
self.rx_subdev.set_gain((gains[0]+gains[1])/2)
self.rx_u.set_mux(usrp.determine_rx_mux_value(self.rx_u, self._rx_subdev_spec))
print 'subdev size %d' % self.rx_subdev.which()
ok = self.rx_u.tune(0, self.rx_subdev, self._rx_freq)
if not ok:
print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq),)
raise ValueError
self.rx_subdev.set_auto_tr(True)
def __init__(self): gr.top_block.__init__ (self) self.u = usrp.source_c(0, usrp_decim) print "USRP Serial: ", self.u.serial_number() usrp_rate = self.u.adc_rate() / usrp_decim # 256 kS/s rx_subdev_spec = usrp.pick_subdev(self.u, dblist) self.u.set_mux(usrp.determine_rx_mux_value(self.u, rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec) print "Using d'board", self.subdev.side_and_name() self.gain = self.subdev.gain_range()[1] self.subdev.set_gain(self.gain) r = usrp.tune(self.u, 0, self.subdev, freq) if r: print "Freq: ", freq/1e6, "MHz" else: print "Failed to set frequency, quitting!" sys.exit(1) chan_filter_coeffs = gr.firdes.low_pass( 1.0, # gain usrp_rate, # sampling rate 80e3, # passband cutoff 35e3, # transition width gr.firdes.WIN_HAMMING) self.chan_filter = gr.fir_filter_ccf(1, chan_filter_coeffs) print "# channel filter:", len(chan_filter_coeffs), "taps" self.file_sink = gr.file_sink(gr.sizeof_gr_complex*1, "/home/sdr/rds_samples.dat") self.connect(self.u, self.chan_filter, self.file_sink)
def __init__( self, decim ):
self.freq = -2.5e6
self.src = usrp.source_c( )
self.subdev = usrp.pick_subdev( self.src,
(usrp_dbid.BASIC_RX,
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))
print self.subdev
self.subdevice = usrp.selected_subdev( self.src,
self.subdev )
self.mux = usrp.determine_rx_mux_value( self.src,
self.subdev )
self.decim = decim
self.adc_rate = self.src.adc_rate()
self.usrp_rate = self.adc_rate / self.decim
self.src.set_decim_rate( self.decim )
self.src.set_mux( self.mux )
usrp.tune( self.src, 0, self.subdevice, self.freq )
def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
self._subdev_spec = subdev_spec
self._gain = gain
self._length = length
self._alpha = alpha
self._msgq = msgq
self._loopback = loopback
self._verbose = verbose
self._debug = debug
self._fg = gr.flow_graph()
self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
if not self._loopback:
if self._subdev_spec == None:
self._subdev_spec = pick_subdevice(self._u)
self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
if self._verbose:
print "Using", self._subdev.name(), "for sounder receiver."
self.set_gain(self._gain)
self._vblen = gr.sizeof_gr_complex*self._length
if self._debug:
print "Generating impulse vectors of length", self._length, "byte length", self._vblen
self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
if self._verbose:
print "Using smoothing alpha of", self._alpha
self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
self._sink = gr.message_sink(self._vblen, self._msgq, True)
self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
def _setup_usrp_source(self, options):
#create USRP
self._usrp = usrp.source_c(which= options.which, decim_rate = options.decim_rate)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(self._usrp)
self._subdev = usrp.selected_subdev(self._usrp, options.rx_subdev_spec)
adc_rate = self._usrp.adc_rate()
mux = usrp.determine_rx_mux_value(self._usrp, options.rx_subdev_spec)
self._usrp.set_mux(mux)
tr = self._usrp.tune(0, self._subdev, options.freq)
if not (tr):
print "Failed to tune to center frequency!"
else:
print "Center frequency:", n2s(options.freq)
if options.gain is None:
g = self._subdev.gain_range();
options.gain = float(g[0]+g[1])/2.0
self._subdev.set_gain(options.gain)
#the bitrate option is initialised to value
self.rs_rate = options.rate
#Hard initialisation of bits per symbol
self.bits_per_symbol = 1
if options.verbose:
print "USRP source:", self._usrp
print "Decimation:", options.decim_rate
def _set_source(self):
options = self.options
fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
self.usrp = usrp.source_c(decim_rate=options.decim, fusb_block_size=fusb_block_size, fusb_nblocks=fusb_nblocks)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(self.usrp)
self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, options.rx_subdev_spec))
# determine the daughterboard subdevice
self.subdev = usrp.selected_subdev(self.usrp, options.rx_subdev_spec)
print "Using Rx d'board %s" % (self.subdev.side_and_name(),)
input_rate = self.usrp.adc_freq() / self.usrp.decim_rate()
print "USB sample rate %s" % (eng_notation.num_to_str(input_rate))
# set initial values
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
r = self.usrp.tune(0, self.subdev, options.freq)
self.subdev.set_gain(options.gain)
return self.usrp
def __set_rx_from_usrp(self, subdev_spec, decimation_rate, gain, frequency, preserve):
from gnuradio import usrp
# setup USRP
self.usrp.set_decim_rate(decimation_rate)
if subdev_spec is None:
subdev_spec = usrp.pick_rx_subdevice(self.usrp)
self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, subdev_spec))
subdev = usrp.selected_subdev(self.usrp, subdev_spec)
capture_rate = self.usrp.adc_freq() / self.usrp.decim_rate()
self.info["capture-rate"] = capture_rate
if gain is None:
g = subdev.gain_range()
gain = float(g[0]+g[1])/2
subdev.set_gain(gain)
r = self.usrp.tune(0, subdev, frequency)
if not r:
raise RuntimeError("failed to set USRP frequency")
# capture file
if preserve:
try:
self.capture_filename = os.tmpnam()
except RuntimeWarning:
ignore = True
capture_file = gr.file_sink(gr.sizeof_gr_complex, self.capture_filename)
self.__connect([[self.usrp, capture_file]])
else:
self.capture_filename = None
# everything else
self.__build_graph(self.usrp, capture_rate)
def __init__(self, options, args, queue):
gr.top_block.__init__(self)
self.options = options
self.args = args
self.u = usrp.source_c(which=0, decim_rate=self.options.decim)
if self.options.rx_subdev_spec is None:
self.options.rx_subdev_spec = pick_subdevice(self.u)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, self.options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, self.options.rx_subdev_spec)
if options.gain is None:
# Select a gain in the middle of the range
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
self.subdev.set_gain(options.gain)
r = self.u.tune(0, self.subdev, options.freq)
if_rate = self.u.adc_freq() / self.u.decim_rate()
self.mode_s = ppm_demod(if_rate, options.thresh)
pass_all = 0
if options.output_all:
pass_all = 1
self.format = air.ms_fmt_log(pass_all, queue)
self.connect(self.u, self.mode_s, self.format)
def main():
tb = gr.top_block()
ofdm_rx = howto.ofdm_rx();
#rs = gr.vector_source_c()
#rs = gr.file_source(gr.sizeof_gr_complex,'out.dat')
src = usrp.source_c(0)
#nchannel
src.set_nchannels(1)
sample_rate = 1e6
ulist = [src]
print "ulist"
print ulist
for u in ulist:
rdecim = int(u.adc_rate() / sample_rate)
u.set_decim_rate(rdecim)
sys.stderr.write("the decimate = %d\n"%(rdecim))
srx1 = usrp.pick_rx_subdevice(src)
print "srx1="
print srx1
subdev = ()
"""configure USRP mux and set rx/tx subdev """
ulist = [src]
assert len(ulist) == 1
src = ulist[0]
src.set_mux( usrp.determine_rx_mux_value(src, srx1))
subdev += (usrp.selected_subdev(src, srx1), )
for s in subdev: exec("if not hasattr(s, '_u'): s._u = src")
for s in subdev: s.set_auto_tr(True)
print "subdev"
print subdev
freq = 2400000000.0
for s in subdev:
r = usrp.tune(s._u, s.which(), s, freq)
if r:
sys.stderr.write("setting frequency of %s :\n"%(str(s)))
sys.stderr.write(" baseband frequency = %s \n" %(eng_notation.num_to_str(r.baseband_freq)))
sys.stderr.write(" DUC/DDC offset = %s\n" %(eng_notation.num_to_str(r.dxc_freq)))
elif not r:
sys.stderr.write("Unable to set frequency of %s to %g MHz \n"%(str(s), freq/ 1.0e6))
#g = 40.0
for s in subdev:
gain_range = s.gain_range()
#rx_gain = max(min(g, gain_range[1]), gain_range[0])
rx_gain = 0.3 * gain_range[1]
s.set_gain(rx_gain)
sys.stderr.write("the rx_gain = %d \n " %(rx_gain))
tb.connect(src, ofdm_rx)
print 'connect'
tb.run()
def __init__(self, options):
gr.top_block.__init__(self)
# Create a USRP source with GPIO FPGA build, then configure
u = usrp.source_s(decim_rate=options.decim,fpga_filename=gpio.fpga_filename)
if options.force_complex_RXA:
# This is a dirty hack to force complex mode (receive both I and Q) on basicRX or LFRX
# This forces the receive board in RXA (side A) to be used
# FIXME: This has as a side effect that the gain for Q is not set. So only use with gain 0 (--gain 0)
options.rx_subdev_spec=(0,0)
u.set_mux(0x10)
if not (0==options.gain):
print "WARNING, you should set the gain to 0 with --gain 0 when using --force-complex-RXA"
print "The gain for Q will now still be zero while the gain for I is not"
#options.gain=0
else:
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(u)
u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec))
subdev = usrp.selected_subdev(u, options.rx_subdev_spec)
print "Using RX d'board %s" % (subdev.side_and_name(),)
input_rate = u.adc_freq()/u.decim_rate()
print "USB sample rate %s" % (eng_notation.num_to_str(input_rate))
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = subdev.gain_range()
options.gain = float(g[0]+g[1])/2
#TODO setting gain on basicRX only sets the I channel, use a second subdev to set gain of Q channel
#see gnuradio-examples/multi-antenna for possible solutions
subdev.set_gain(options.gain)
#TODO check if freq has same problem as gain when trying to use complex mode on basicRX
r = u.tune(0, subdev, options.freq)
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
# Connect pipeline
src = u
if options.nsamples is not None:
head = gr.head(gr.sizeof_short, int(options.nsamples)*2)
self.connect(u, head)
src = head
ana_strip = gpio.and_const_ss(0xFFFE)
dig_strip = gpio.and_const_ss(0x0001)
ana_sink = gr.file_sink(gr.sizeof_short, options.ana_filename)
dig_sink = gr.file_sink(gr.sizeof_short, options.dig_filename)
self.connect(src, ana_strip, ana_sink)
self.connect(src, dig_strip, dig_sink)
def _setup_usrp1(self):
self._u = usrp.source_c (self._which,
fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
# determine the daughterboard subdevice we're using
if self._subdev_spec is None:
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._dxc = 0
def __init__(self, options, queue):
gr.top_block.__init__(self)
self.u = usrp.source_c()
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()
self.u.set_decim_rate(options.decim)
self.centerfreq = options.centerfreq
print "Tuning to: %fMHz" % (self.centerfreq - options.error)
if not(self.tune(options.centerfreq - options.error)):
print "Failed to set initial frequency"
if options.gain is None: #set to halfway
g = self.subdev.gain_range()
options.gain = (g[0]+g[1]) / 2.0
print "Setting gain to %i" % options.gain
self.subdev.set_gain(options.gain)
if self.subdev.name() == "DBS Rx":
self.subdev.set_bw(options.bandwidth) #only for DBSRX
print "Setting DBS RX bandwidth to %fMHz" % float(options.bandwidth / 1e6)
self.rate = self.u.adc_rate() / options.decim
print "Samples per second is %i" % self.rate
self._syms_per_sec = 3600;
options.audiorate = 11025
options.rate = self.rate
options.samples_per_second = self.rate #yeah i know it's on the list
options.syms_per_sec = self._syms_per_sec
options.gain_mu = 0.01
options.mu=0.5
options.omega_relative_limit = 0.3
options.syms_per_sec = self._syms_per_sec
options.offset = options.centerfreq - options.freq
print "Control channel offset: %f" % options.offset
self.demod = fsk_demod(options)
self.start_correlator = gr.correlate_access_code_bb("10101100",0) #should mark start of packet
self.smartnet_sync = smartnet.sync()
self.smartnet_deinterleave = smartnet.deinterleave()
self.smartnet_parity = smartnet.parity()
self.smartnet_crc = smartnet.crc()
self.smartnet_packetize = smartnet.packetize()
self.parse = smartnet.parse(queue) #packet-based. this simply posts lightly-formatted messages to the queue.
self.connect(self.u, self.demod)
self.connect(self.demod, self.start_correlator, self.smartnet_sync, self.smartnet_deinterleave, self.smartnet_parity, self.smartnet_crc, self.smartnet_packetize, self.parse)
def __init__(self, options):
gr.hier_block2.__init__(self, "transmit_path",
gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
#Set up usrp block
self.u = usrp.source_c()
adc_rate = self.u.adc_rate() # 64 MS/s
usrp_decim = 16
gain = 65
self.u.set_decim_rate(usrp_decim)
usrp_rate = adc_rate / usrp_decim # 320 kS/s
print usrp_rate
#subdev_spec = usrp.pick_subdev(self.u)
subdev_spec = (0,0)
mux_value = usrp.determine_rx_mux_value(self.u, subdev_spec)
self.u.set_mux(mux_value)
self.subdev = usrp.selected_subdev(self.u, subdev_spec)
self.subdev.set_gain(gain)
self.subdev.set_auto_tr(False)
self.subdev.set_enable(True)
if not(self.set_freq(915e6)):
print "Failed to set initial frequency"
#set up the rest of the path
deci = 1
self.agc = gr.agc_cc( rate = 1e-7, reference = 1.0, gain = 0.001, max_gain = 0.5)
matchtaps = [complex(-1,-1)] * 8 + [complex(1,1)] * 8 + [complex(-1,-1)]* 8 + [complex(1,1)]* 8
#matchtaps = [complex(-1,-1)] * 8 + [complex(1,1)] * 8
self.matchfilter = gr.fir_filter_ccc(1, matchtaps)
reverse = [complex(1,1)] * (8 / deci) + [complex(-1,-1)] * (8 / deci) + [complex(1,1)]* (8 / deci) + [complex(-1,-1)]* (8 / deci)
#pretaps = matchtaps * 3 + reverse * 4 + matchtaps * 4 + reverse * 8 + matchtaps * 6 + matchtaps * 62
pretaps = matchtaps * 2 + reverse * 2 + matchtaps * 2 + reverse * 4 + matchtaps * 3 + matchtaps * 31
#pretaps = matchtaps * 3 + reverse * 8 + matchtaps * 6 + matchtaps * 64
self.preamble_filter = gr.fir_filter_ccc(1, pretaps)
self.c_f = gr.complex_to_real()
self.c_f2 = gr.complex_to_real()
self.lock = howto.lock_time(32, 5, 32)
self.pd = howto.find_pre_ff(55, 200)
self.dec = symbols_decoder()
self.vect = gr.vector_sink_f()
#self.connect(self.u, self.agc, self.matchfilter, self.c_f, (self.lock, 0), self.dec, self.vect)
#self.connect(self.agc, self.preamble_filter, self.c_f2, self.pd, (self.lock, 1))
self.connect(self.u, self.agc, self.matchfilter, self.c_f, self.vect)
def _setup_usrp(self):
self._u = usrp.source_c(fpga_filename='usrp_radar_mono.rbf')
if self._subdev_spec == None:
self._subdev_spec = usrp.pick_rx_subdevice(self._u)
self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
if self._verbose:
print "Using", self._subdev.side_and_name(), "for radar receiver."
print "Setting receiver gain to", self._gain
self.set_gain(self._gain)
self.tune(self._frequency)
def __init__(self):
gr.flow_graph.__init__(self)
parser = OptionParser (option_class=eng_option)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default='B',
help="select USRP Rx side A or B (default=first one with a daughterboard)")
parser.add_option ("-c", "--cordic-freq", type="eng_float", default=434845200,
help="set rx cordic frequency to FREQ", metavar="FREQ")
parser.add_option ("-g", "--gain", type="eng_float", default=0,
help="set Rx PGA gain in dB [0,20]")
(options, args) = parser.parse_args ()
print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq))
# ----------------------------------------------------------------
self.freq = 1000
self.samples_per_symbol = 256
self.usrp_decim = int (64e6 / self.samples_per_symbol / self.freq)
self.fs = self.freq * self.samples_per_symbol
print "freq = ", eng_notation.num_to_str(self.freq)
print "samples_per_symbol = ", self.samples_per_symbol
print "usrp_decim = ", self.usrp_decim
print "fs = ", eng_notation.num_to_str(self.fs)
u = usrp.source_s (0, self.usrp_decim)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = pick_subdevice(u)
u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec))
subdev = usrp.selected_subdev(u, options.rx_subdev_spec)
print "Using RX d'board %s" % (subdev.side_and_name(),)
u.tune(0, subdev, options.cordic_freq)
u.set_pga(0, options.gain)
u.set_pga(1, options.gain)
self.u = u
self.filesink = gr.file_sink(gr.sizeof_float, 'rx_sin.dat')
self.stof = gr.short_to_float()
filter_coeffs = gr.firdes.low_pass (1.0, # gain
self.fs, # sampling rate
self.freq, # low pass cutoff freq
0.1*self.freq, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.lowpass = gr.fir_filter_fff(1, filter_coeffs)
self.connect(self.u, self.stof, self.lowpass, self.filesink)
def _setup_usrp_source(self):
self.u = usrp.source_c (fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
adc_rate = self.u.adc_rate()
self.u.set_decim_rate(self._decim)
# determine the daughterboard subdevice we're using
if self._rx_subdev_spec is None:
self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec))
def __init__(self, fg, decim=8, rx_subdev_spec=None, width_16=False,
verbose=False, gain=None, freq=None):
# build the graph"
self.u = usrp.source_c(decim_rate=decim, fpga_filename="usrp_std_d2.rbf")
if rx_subdev_spec is None:
rx_subdev_spec = pick_subdevice(self.u)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, rx_subdev_spec))
if not width_16:
width = 8
shift = 8
format = self.u.make_format(width, shift)
r = self.u.set_format(format)
if verbose:
print "Bits Per Encoded Sample = 8"
else:
if verbose:
print "Bits Per Encoded Sample = 16"
# determine the daughterboard subdevice we're using
self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec)
if verbose:
print "adc frequency = ", self.u.adc_freq()
print "decimation frequency = ", self.u.decim_rate()
print "input_rate = ", self.u.adc_freq() / self.u.decim_rate()
if gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
gain = float(g[0]+g[1])/2
if verbose:
print "gain = ", gain
if freq is None:
# if no freq was specified, use the mid-point
r = self.subdev.freq_range()
freq = float(r[0]+r[1])/2
self.subdev.set_gain(gain)
r = self.u.tune(0, self.subdev, freq)
if verbose:
print "desired freq = ", freq
#print "baseband frequency", r.baseband_freq
#print "dxc frequency", r.dxc_freq
gr.hier_block.__init__(self, fg, None, self.u)
def __init__(self, options, rx_callback):
"""
@param options Optparse option field for command line arguments.
@param rx_callback Callback function for the event when a packet is received.
"""
gr.flow_graph.__init__(self)
print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq_rx))
# ----------------------------------------------------------------
self.data_rate = options.data_rate
self.samples_per_symbol = 2
self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate)
self.fs = self.data_rate * self.samples_per_symbol
payload_size = 128 # bytes
print "data_rate = ", eng_notation.num_to_str(self.data_rate)
print "samples_per_symbol = ", self.samples_per_symbol
print "usrp_decim = ", self.usrp_decim
print "fs = ", eng_notation.num_to_str(self.fs)
u = usrp.source_c (0, self.usrp_decim)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = pick_subdevice(u)
u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
#self.subdev.select_rx_antenna('RX2')
u.tune(0, self.subdev, options.cordic_freq_rx)
u.set_pga(0, options.gain)
u.set_pga(1, options.gain)
self.u = u
self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self,
callback=rx_callback,
sps=self.samples_per_symbol,
symbol_rate=self.data_rate,
threshold=-1)
self.squelch = gr.pwr_squelch_cc(50, 1, 0, True)
#self.file_sink = gr.file_sink(gr.sizeof_gr_complex, "/dev/null")
self.connect(self.u, self.squelch, self.packet_receiver)
#self.connect(self.u, self.file_sink)
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self, options, queue):
gr.top_block.__init__(self, "usrp_flex_all")
if options.from_file is not None:
src = gr.file_source(gr.sizeof_gr_complex, options.from_file)
if options.verbose:
print "Reading samples from file", options.from_file
else:
src = usrp.source_c()
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_rx_subdevice(src)
subdev = usrp.selected_subdev(src, options.rx_subdev_spec)
src.set_mux(usrp.determine_rx_mux_value(src, options.rx_subdev_spec))
src.set_decim_rate(20)
result = usrp.tune(src, 0, subdev, 930.5125e6+options.calibration)
if options.verbose:
print "Using", subdev.name(), " for receiving."
print "Tuned USRP to", 930.5125e6+options.calibration
taps = gr.firdes.low_pass(1.0,
1.0,
1.0/128.0*0.4,
1.0/128.0*0.1,
gr.firdes.WIN_HANN)
if options.verbose:
print "Channel filter has", len(taps), "taps"
bank = blks2.analysis_filterbank(128, taps)
self.connect(src, bank)
if options.log and options.from_file == None:
src_sink = gr.file_sink(gr.sizeof_gr_complex, 'usrp.dat')
self.connect(src, src_sink)
for i in range(128):
if i < 64:
freq = 930.5e6+i*25e3
else:
freq = 928.9e6+(i-64)*25e3
if (freq < 929.0e6 or freq > 932.0e6):
self.connect((bank, i), gr.null_sink(gr.sizeof_gr_complex))
else:
self.connect((bank, i), pager.flex_demod(queue, freq, options.verbose, options.log))
if options.log:
self.connect((bank, i), gr.file_sink(gr.sizeof_gr_complex, 'chan_'+'%3.3f'%(freq/1e6)+'.dat'))
def setup_usrp(freq):
# Constants
interp = 128
decim = 64
# Make USRP instances to TX and RX
utx = usrp.sink_c(fpga_filename="local_rssi5.rbf")
urx = usrp.source_c(fpga_filename="local_rssi5.rbf")
# Set decim and interp rates
utx.set_interp_rate(interp)
urx.set_decim_rate(decim)
# Pick subdevice
subdev_spec_tx = usrp.pick_tx_subdevice(utx)
subdev_spec_rx = usrp.pick_rx_subdevice(urx)
# Set up mux
mux_tx = usrp.determine_tx_mux_value(utx, subdev_spec_tx)
mux_rx = usrp.determine_rx_mux_value(urx, subdev_spec_rx)
utx.set_mux(mux_tx)
urx.set_mux(mux_rx)
# pick d'board
subdev_tx = usrp.selected_subdev(utx, subdev_spec_tx)
subdev_rx = usrp.selected_subdev(urx, subdev_spec_rx)
print "Using TX d'board %s" %(subdev_tx.side_and_name())
print "Using RX d'board %s" %(subdev_rx.side_and_name())
# Gain
subdev_tx.set_gain((subdev_tx.gain_range()[0] + subdev_tx.gain_range()[1]) / 2)
subdev_rx.set_gain((subdev_rx.gain_range()[0] + subdev_rx.gain_range()[1]) / 2)
# Tune
if not utx.tune(subdev_tx._which, subdev_tx, freq):
DEBUG( "error tuning TX")
if not urx.tune(subdev_rx._which, subdev_rx, freq):
DEBUG( "error tuning RX")
# Power on
subdev_tx.set_enable(True)
subdev_rx.set_enable(True)
sys.stdout.flush()
return utx, urx
def _setup_usrp(self, which, decim, subdev_spec, freq, gain):
self._usrp = usrp.source_c(which=which, decim_rate=decim)
if subdev_spec is None:
subdev_spec = usrp.pick_rx_subdevice(self._usrp)
self._subdev = usrp.selected_subdev(self._usrp, subdev_spec)
mux = usrp.determine_rx_mux_value(self._usrp, subdev_spec)
self._usrp.set_mux(mux)
tr = self._usrp.tune(0, self._subdev, freq)
if not (tr):
print "Failed to tune to center frequency!"
else:
print "Center frequency:", n2s(freq)
if gain is None:
g = self._subdev.gain_range();
gain = float(g[0]+g[1])/2.0
self._subdev.set_gain(gain)
print "RX d'board:", self._subdev.side_and_name()
def __init__(self):
gr.top_block.__init__(self)
#build graph now
#usrp_source
self.usrp = usrp.source_c()
adc_rate = self.usrp.adc_rate() #64MHz
hw_decim = 16 #so Sample rate into host is 4MHz
self.usrp.set_decim_rate(hw_decim)
self.subdev = usrp.selected_subdev(self.usrp, usrp.pick_rx_subdevice(self.usrp))
self.usrp.set_mux(usrp.determine_rx_mux_value(self.usrp, usrp.pick_rx_subdevice(self.usrp)))
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
self.subdev.set_gain(30)
rf_freq = 106800000 # 106.8MHz
self.set_freq(rf_freq)
print "Freq: ", rf_freq
self.subdev.select_rx_antenna("TX/RX")
#low pass filter
self.sample_rate = adc_rate / hw_decim
self.lpf_decim = 20 # so after channel filter, the sample rate is 200KHz
self.lp_filter = gr.fir_filter_ccf( self.lpf_decim, gr.firdes.low_pass ( 1,
self.sample_rate,
100e3, # cut off freq
10e3, # transition band
gr.firdes.WIN_BLACKMAN, # Window function
6.76 # not used
))
# WBFM receiver
quad_rate = self.sample_rate #input rate of demodulator
max_dev = 75e3 #max deviation of FM Broadcast
fm_demod_gain = quad_rate/(2 * math.pi * max_dev)
self.fm_decoder = gr.quadrature_demod_cf (fm_demod_gain)
# Rational Resampler
self.audio_sample_rate = 96000
self.rational_resampler = blks2.rational_resampler_fff ( interpolation = int(self.audio_sample_rate/1000),
decimation = int(self.sample_rate/self.lpf_decim/1000),
taps = None,
fractional_bw = None,
)
self.audio_sink = audio.sink (int(self.audio_sample_rate), "", True)
#connections
self.connect ( self.usrp, self.lp_filter, self.fm_decoder, self.rational_resampler, self.audio_sink )
def _setup_usrp_source(self):
self.u = usrp.source_c (fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
adc_rate = self.u.adc_rate()
# 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.u.set_decim_rate(self._decim)
# determine the daughterboard subdevice we're using
if self._rx_subdev_spec is None:
self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec)
self.u.set_mux(usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec))
def setup_usrp(self):
options = self.options
#set resonable defaults if no user prefs set
if options.realtime:
if options.fusb_block_size == 0:
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
if options.fusb_nblocks == 0:
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
if options.fusb_block_size == 0:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
if options.fusb_nblocks == 0:
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
print >> sys.stderr, "fusb_block_size =", options.fusb_block_size
print >> sys.stderr, "fusb_nblocks =", options.fusb_nblocks
self.ursp = usrp.source_c(decim_rate=options.decim,fusb_block_size=options.fusb_block_size,fusb_nblocks=options.fusb_nblocks)
self.ursp.set_fpga_master_clock_freq(options.clock_frequency)
if options.rx_subdev_spec is None:
options.rx_subdev_spec = pick_subdevice(self.ursp)
self.ursp.set_mux(usrp.determine_rx_mux_value(self.ursp, options.rx_subdev_spec))
# determine the daughterboard subdevice
self.subdev = usrp.selected_subdev(self.ursp, options.rx_subdev_spec)
input_rate = self.ursp.adc_freq() / self.ursp.decim_rate()
if options.antenna is not None:
print >> sys.stderr, "USRP antenna %s" % (options.antenna,)
self.subdev.select_rx_antenna(options.antenna)
# set initial values
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
self.set_gain(options.gain)
self.source = self.ursp
def __init__(self):
gr.hier_block2.__init__(self, "rx_path",
gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
self.frequency = 13.56e6
self.gain = 10
# USRP settings
self.u_rx = usrp.source_c() #create the USRP source for RX
#try and set the LF_RX for this
rx_subdev_spec = usrp.pick_subdev(self.u_rx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX))
#Configure the MUX for the daughterboard
self.u_rx.set_mux(usrp.determine_rx_mux_value(self.u_rx, rx_subdev_spec))
#Tell it to use the LF_RX
self.subdev_rx = usrp.selected_subdev(self.u_rx, rx_subdev_spec)
#Make sure it worked
print "Using RX dboard %s" % (self.subdev_rx.side_and_name(),)
#Set gain.. duh
self.subdev_rx.set_gain(self.gain)
#Tune the center frequency
self.u_rx.tune(0, self.subdev_rx, self.frequency)
adc_rate = self.u_rx.adc_rate() #64 MS/s
usrp_decim = 256
self.u_rx.set_decim_rate(usrp_decim)
#BW = 64 MS/s / decim = 64,000,000 / 256 = 250 kHz
#Not sure if this decim rate exceeds USRP capabilities,
#if it does then some software decim may have to be done as well
usrp_rx_rate = adc_rate / usrp_decim
self.iir = gr.single_pole_iir_filter_ff(.001)
self.mag = gr.complex_to_mag()
self.snk = gr.probe_signal_f()
# dst = audio.sink (sample_rate, "")
# stv = gr.stream_to_vector (gr.sizeof_float, fft_size)
# c2m = gr.complex_to_mag_squared (fft_size)
self.connect(self.u_rx, self.mag, self.iir, self.snk)
def __init__(self, subdev_spec, decim, gain=None, calibration=0.0):
gr.hier_block2.__init__(self, "usrp_src",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._decim = decim
self._src = usrp.source_c()
if subdev_spec is None:
subdev_spec = usrp.pick_rx_subdevice(self._src)
self._subdev = usrp.selected_subdev(self._src, subdev_spec)
self._src.set_mux(usrp.determine_rx_mux_value(self._src, subdev_spec))
self._src.set_decim_rate(self._decim)
# If no gain specified, set to midrange
if gain is None:
g = self._subdev.gain_range()
gain = (g[0]+g[1])/2.0
self._subdev.set_gain(gain)
self._cal = calibration
self.connect(self._src, self)
def __init__(self, frame, panel, vbox, argv):
stdgui.gui_flow_graph.__init__(self)
self.frame = frame
self.panel = panel
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=first one with a daughterboard)"
)
parser.add_option(
"-d",
"--decim",
type="int",
default=16,
help="set fgpa decimation rate to DECIM [default=%default]")
parser.add_option("-f",
"--freq",
type="eng_float",
default=None,
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("-W",
"--waterfall",
action="store_true",
default=False,
help="Enable waterfall display")
parser.add_option("-8",
"--width-8",
action="store_true",
default=False,
help="Enable 8-bit samples across USB")
parser.add_option("-S",
"--oscilloscope",
action="store_true",
default=False,
help="Enable oscilloscope display")
parser.add_option("-F",
"--filename",
default=None,
help="Name of file with filter coefficients")
parser.add_option("-C",
"--cfilename",
default=None,
help="Name of file with compensator coefficients")
parser.add_option("-B",
"--bitstream",
default="mrfm.rbf",
help="Name of FPGA Bitstream file (.rbf)")
parser.add_option(
"-n",
"--frame-decim",
type="int",
default=20,
help="set oscope frame decimation factor to n [default=12]")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.show_debug_info = True
# default filter coefs
b00 = b01 = 16384
b10 = b20 = a10 = a20 = b11 = b21 = a11 = a21 = 0
ba = read_ints(options.filename)
if len(ba) >= 6:
b00 = ba[0]
b10 = ba[1]
b20 = ba[2]
a10 = ba[4]
a20 = ba[5]
if len(ba) >= 12:
b01 = ba[6]
b11 = ba[7]
b21 = ba[8]
a11 = ba[10]
a21 = ba[11]
print b00, b10, b20, a10, a20, b01, b11, b21, a11, a21
# default compensator coefficients
c11 = c22 = 1
c12 = c21 = cscale = 0
cs = read_ints(options.cfilename)
if len(cs) >= 5:
c11 = cs[0]
c12 = cs[1]
c21 = cs[2]
c22 = cs[3]
cscale = cs[4]
print c11, c12, c21, c22, cscale
# build the graph
self.u = mrfm.source_c(options.bitstream)
self.u.set_decim_rate(options.decim)
self.u.set_center_freq(options.freq)
frac_bits = 14
self.u.set_coeffs(frac_bits, b20, b10, b00, a20, a10, b21, b11, b01,
a21, a11)
self.u.set_compensator(c11, c12, c21, c22, cscale)
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))
if options.width_8:
width = 8
shift = 8
format = self.u.make_format(width, shift)
print "format =", hex(format)
r = self.u.set_format(format)
print "set_format =", r
# determine the daughterboard subdevice we're using
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
#input_rate = self.u.adc_freq() / self.u.decim_rate()
input_rate = self.u.adc_freq() / options.decim
# fft_rate = 15
fft_rate = 5
self.deint = gr.deinterleave(gr.sizeof_gr_complex)
self.connect(self.u, self.deint)
if options.waterfall:
self.scope1 = waterfallsink.waterfall_sink_c(
self,
panel,
fft_size=1024,
sample_rate=input_rate,
fft_rate=fft_rate)
self.scope2 = waterfallsink.waterfall_sink_c(
self,
panel,
fft_size=1024,
sample_rate=input_rate,
fft_rate=fft_rate)
elif options.oscilloscope:
self.scope1 = scopesink.scope_sink_c(
self,
panel,
sample_rate=input_rate,
frame_decim=options.frame_decim) # added option JPJ 4/21/2006
self.scope2 = scopesink.scope_sink_c(
self,
panel,
sample_rate=input_rate,
frame_decim=options.frame_decim)
else:
self.scope1 = fftsink.fft_sink_c(self,
panel,
fft_size=1024,
sample_rate=input_rate,
fft_rate=fft_rate)
self.scope2 = fftsink.fft_sink_c(self,
panel,
fft_size=1024,
sample_rate=input_rate,
fft_rate=fft_rate)
# Show I, I' on top scope panel, Q, Q' on bottom
#self.fin = gr.complex_to_float()
#self.fout = gr.complex_to_float()
#self.connect((self.deint,0), self.fin)
#self.connect((self.deint,1), self.fout)
#self.ii = gr.float_to_complex()
#self.qq = gr.float_to_complex()
#self.connect((self.fin,0), (self.ii,0))
#self.connect((self.fout,0), (self.ii,1))
#self.connect((self.fin,1), (self.qq,0))
#self.connect((self.fout,1), (self.qq,1))
#self.connect(self.ii, self.scope1)
#self.connect(self.qq, self.scope2)
self.connect((self.deint, 0), self.scope1)
self.connect((self.deint, 1), self.scope2)
self._build_gui(vbox)
# set initial values
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 options.freq is None:
# if no freq was specified, use the mid-point
r = self.subdev.freq_range()
options.freq = float(r[0] + r[1]) / 2
self.set_gain(options.gain)
if not (self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
if self.show_debug_info:
self.myform['decim'].set_value(self.u.decim_rate())
self.myform['fs@usb'].set_value(self.u.adc_freq() /
self.u.decim_rate())
self.myform['dbname'].set_value(self.subdev.name())
def __init__(self):
gr.top_block.__init__(self)
amplitude = 30000
filt_out = gr.file_sink(gr.sizeof_gr_complex, "./filt.out")
filt2_out = gr.file_sink(gr.sizeof_gr_complex, "./filt2.out")
ffilt_out = gr.file_sink(gr.sizeof_float, "./ffilt.out")
ffilt2_out = gr.file_sink(gr.sizeof_float, "./ffilt2.out")
interp_rate = 128
dec_rate = 8
sw_dec = 4
num_taps = int(64000 /
((dec_rate * 4) *
256)) #Filter matched to 1/4 of the 256 kHz tag cycle
taps = [complex(1, 1)] * num_taps
matched_filt = gr.fir_filter_ccc(sw_dec, taps)
agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100)
to_mag = gr.complex_to_mag()
center = rfid.center_ff(4)
omega = 2
mu = 0.25
gain_mu = 0.25
gain_omega = .25 * gain_mu * gain_mu
omega_relative_limit = .05
mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu,
omega_relative_limit)
self.reader = rfid.reader_f(int(128e6 / interp_rate))
tag_decoder = rfid.tag_decoder_f()
command_gate = rfid.command_gate_cc(12, 60,
64000000 / dec_rate / sw_dec)
to_complex = gr.float_to_complex()
amp = gr.multiply_const_ff(amplitude)
f_sink = gr.file_sink(gr.sizeof_gr_complex, 'f_sink.out')
f_sink2 = gr.file_sink(gr.sizeof_gr_complex, 'f_sink2.out')
#TX
freq = 915e6
rx_gain = 30
tx = usrp.sink_c(fusb_block_size=1024, fusb_nblocks=8)
tx.set_interp_rate(interp_rate)
tx_subdev = (0, 0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(0,
dec_rate,
fusb_block_size=512 * 4,
fusb_nblocks=16)
rx_subdev_spec = (1, 0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
r = usrp.tune(rx, 0, rx_subdev, freq)
self.rx = rx
if not r:
print "Couldn't set rx freq"
#End RX
command_gate.set_ctrl_out(self.reader.ctrl_q())
tag_decoder.set_ctrl_out(self.reader.ctrl_q())
agc2 = gr.agc2_ff(0.3, 1e-3, 1, 1, 100)
#########Build Graph
self.connect(rx, matched_filt)
self.connect(matched_filt, command_gate)
self.connect(command_gate, agc)
self.connect(agc, to_mag)
self.connect(to_mag, center, agc2, mm, tag_decoder)
self.connect(tag_decoder, self.reader, amp, to_complex, tx)
#################
self.connect(matched_filt, filt_out)
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("-f",
"--freq",
type="eng_float",
default=100.1e6,
help="set frequency to FREQ",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=65,
help="set gain in dB (default is midpoint)")
parser.add_option("-s",
"--squelch",
type="eng_float",
default=0,
help="set squelch level (default is 0)")
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")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.frame = frame
self.panel = panel
self.vol = 0
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 = 3 * demod_rate / audio_decimation / 2 # 48 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)
chan_filt_coeffs = gr.firdes.low_pass_2(
1, # gain
usrp_rate, # sampling rate
90e3, # passband cutoff
30e3, # transition bandwidth
70, # stopband attenuation
gr.firdes.WIN_BLACKMAN)
print len(chan_filt_coeffs)
chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs)
self.rchan_sample = blks2.rational_resampler_fff(3, 2)
self.lchan_sample = blks2.rational_resampler_fff(3, 2)
#self.guts = blks2.wfm_rcv (demod_rate, audio_decimation)
self.guts = blks2.wfm_rcv_pll(demod_rate, audio_decimation)
# FIXME rework {add,multiply}_const_* to handle multiple streams
self.volume_control_l = gr.multiply_const_ff(self.vol)
self.volume_control_r = 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.connect((self.guts, 0), self.lchan_sample, self.volume_control_l,
(audio_sink, 0))
self.connect((self.guts, 1), self.rchan_sample, self.volume_control_r,
(audio_sink, 1))
try:
self.guts.stereo_carrier_pll_recovery.squelch_enable(True)
except:
print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"
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
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0] + g[1]) / 2
if abs(options.freq) < 1e6:
options.freq *= 1e6
# set initial values
self.set_gain(options.gain)
self.set_vol(options.volume)
try:
self.guts.stereo_carrier_pll_recovery.set_lock_threshold(
options.squelch)
except:
print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"
if not (self.set_freq(options.freq)):
self._set_status_msg("Failed to set initial frequency")
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option("-m",
"--dab-mode",
type="int",
default=1,
help="DAB mode [default=%default]")
parser.add_option("-f",
"--freq",
type="eng_float",
default=206352000,
help="Carrier frequency [default=%default]")
parser.add_option("-g",
"--gain",
type="eng_float",
default=8,
help="USRP gain (dB) [default=%default]")
parser.add_option(
"-n",
"--config",
type="string",
default="channel.conf",
help="DAB+ channel configuration file [default=%default]")
(options, args) = parser.parse_args()
if len(args) > 0:
parser.print_help()
raise SystemExit, 1
self.conf = options.config
######## set up usrp
self.u = usrp.source_c(decim_rate=32) # 2M sampling freq
rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
#print "u.db(0,0).dbid() = ", self.u.db(0,0).dbid()
#print "u.db(1,0).dbid() = ", self.u.db(1,0).dbid()
#print "rx_subdev_spec = ", options.rx_subdev_spec
mux = usrp.determine_rx_mux_value(self.u, rx_subdev_spec)
#print "mux = ", mux
self.u.set_mux(mux)
# determine the daughterboard subdevice we're using
self.subdev = usrp.selected_subdev(self.u, rx_subdev_spec)
#print "Using RX d'board %s" % (self.subdev.side_and_name(),)
input_rate = self.u.adc_freq() / self.u.decim_rate()
#print "ADC sampling @ ", eng_notation.num_to_str(self.u.adc_freq())
#print "USB sample rate %s" % (eng_notation.num_to_str(input_rate))
self.subdev.set_gain(options.gain)
r = self.u.tune(0, self.subdev, options.freq)
#print "freq range = [%s, %s]" % (eng_notation.num_to_str(self.subdev.freq_min()), eng_notation.num_to_str(self.subdev.freq_max()))
if not r:
sys.stderr.write('Failed to set frequency\n')
raise SystemExit, 1
mode = options.dab_mode
param = dabp.parameters(mode)
# null symbol detector
samples_per_null_sym = param.get_Nnull()
#print "samples per null symbol : %d" % samples_per_null_sym
nulldet = dabp.detect_null(samples_per_null_sym)
# ofdm demod
demod = dabp.ofdm_demod(mode)
# FIC/MSC demultiplexer
demux = dabp.fic_msc_demux(0, mode)
# depuncturer
punc = dabp.depuncturer_fic(mode)
I = punc.getI()
# viterbi
vit = dabp.vitdec(I)
# descrambler
scram = dabp.scrambler(I)
# FIB sink
self.dst = dabp.fib_sink()
nullsink = gr.null_sink(gr.sizeof_char)
# connect everything
self.connect(self.u, nulldet)
self.connect(self.u, (demod, 0))
self.connect(nulldet, (demod, 1))
self.connect((demod, 0), demux, punc, vit, scram, self.dst)
self.connect((demod, 1), nullsink)
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 main():
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=144.800e6,
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("-d",
"--do-logging",
action="store_true",
default=False,
help="enable logging on datafiles")
parser.add_option("-s",
"--use-datafile",
action="store_true",
default=False,
help="use usrp.dat (256kbps) as input")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
markfreq = 2200
spacefreq = 1200
bitrate = 1200
usrp_decim = 250
if_rate = 64e6 / usrp_decim #256e3
sf = (if_rate * 3) / 5 #153600
bit_oversampling = 8
sw_decim = int(sf / bitrate / bit_oversampling) #8
bf = sf / sw_decim
symdev = abs(markfreq - spacefreq) / 2
symcf = min(markfreq, spacefreq) + symdev
nbfmdev = 3e3
nbfmk = if_rate / (2 * pi * nbfmdev)
symk = bf / (2 * pi * symdev)
fg = gr.flow_graph()
if options.do_logging:
logger1 = gr.file_sink(gr.sizeof_gr_complex, "usrpout.dat")
logger2 = gr.file_sink(gr.sizeof_float, "demod.dat")
logger3 = gr.file_sink(gr.sizeof_float, "clkrec.dat")
logger4 = gr.file_sink(gr.sizeof_char, "slicer.dat")
if options.use_datafile:
src = gr.file_source(gr.sizeof_gr_complex, "usrp.dat")
else:
u = usrp.source_c()
u.set_decim_rate(usrp_decim)
if options.rx_subdev_spec is None:
subdev_spec = usrp.pick_rx_subdevice(u)
else:
subdev_spec = options.rx_subdev_spec
subdev = usrp.selected_subdev(u, subdev_spec)
print "Using RX d'board %s" % (subdev.side_and_name(), )
u.set_mux(usrp.determine_rx_mux_value(u, subdev_spec))
print "MUX:%x" % (usrp.determine_rx_mux_value(u, subdev_spec))
if options.gain is None:
g = subdev.gain_range()
gain = float(g[0] + g[1]) / 2
else:
gain = options.gain
subdev.set_gain(gain)
print "Gain set to", str(gain)
r = usrp.tune(u, 0, subdev, options.freq)
if r:
print "Frequency set to", options.freq
else:
print "Frequency set to", options.freq, "failed"
src = u
chan_taps = gr.firdes.low_pass(1, if_rate, 13e3, 4e3, gr.firdes.WIN_HANN)
chan = gr.fir_filter_ccf(1, chan_taps) #256e3
dee = blks.fm_deemph(fg, if_rate, 75e-6)
fmdem = gr.quadrature_demod_cf(nbfmk)
res_taps = blks.design_filter(3, 5, 0.4)
res = blks.rational_resampler_fff(fg, 3, 5, res_taps) #153600
lo = gr.sig_source_c(sf, gr.GR_SIN_WAVE, -symcf, 1)
mix = gr.multiply_cc()
r2c = gr.float_to_complex()
lp_taps = gr.firdes.low_pass(sw_decim, sf, 600, 2e3, gr.firdes.WIN_HANN)
lp = gr.fir_filter_ccf(sw_decim, lp_taps)
dem = gr.quadrature_demod_cf(symk)
alpha = 0.0001
freqoff = gr.single_pole_iir_filter_ff(alpha)
sub = gr.sub_ff()
_def_gain_mu = 0.05
_def_mu = 0.5
_def_freq_error = 0.00
_def_omega_relative_limit = 0.005
_omega = bit_oversampling * (1 + _def_freq_error)
_gain_omega = .25 * _def_gain_mu * _def_gain_mu
clkrec = gr.clock_recovery_mm_ff(_omega, _gain_omega, _def_mu,
_def_gain_mu, _def_omega_relative_limit)
slicer = gr.binary_slicer_fb()
pktq = gr.msg_queue()
sink = packetradio.hdlc_framer(pktq, 0)
watcher = queue_watcher_thread(pktq, rx_callback)
fg.connect(src, chan, fmdem, dee, res, r2c, (mix, 0))
fg.connect(lo, (mix, 1))
fg.connect(mix, lp, dem)
fg.connect(dem, (sub, 0))
fg.connect(dem, freqoff, (sub, 1))
fg.connect(sub, clkrec, slicer)
fg.connect(slicer, sink)
if options.do_logging:
fg.connect(src, logger1)
fg.connect(sub, logger2)
fg.connect(clkrec, logger3)
fg.connect(slicer, logger4)
fg.start()
fg.wait()
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("-f",
"--freq",
type="eng_float",
default=1008.0e3,
help="set frequency to FREQ",
metavar="FREQ")
parser.add_option(
"-I",
"--use-if-freq",
action="store_true",
default=False,
help=
"use intermediate freq (compensates DC problems in quadrature boards)"
)
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB (default is maximum)")
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")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.frame = frame
self.panel = panel
self.use_IF = options.use_if_freq
if self.use_IF:
self.IF_freq = 64000.0
else:
self.IF_freq = 0.0
self.vol = 0
self.state = "FREQ"
self.freq = 0
# build graph
#TODO: add an AGC after the channel filter and before the AM_demod
self.u = usrp.source_c() # usrp is data source
adc_rate = self.u.adc_rate() # 64 MS/s
usrp_decim = 250
self.u.set_decim_rate(usrp_decim)
usrp_rate = adc_rate / usrp_decim # 256 kS/s
chanfilt_decim = 4
demod_rate = usrp_rate / chanfilt_decim # 64 kHz
audio_decimation = 2
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
8e3, # passband cutoff
12e3, # stopband cutoff
1.0, # passband ripple
60) # stopband attenuation
#print len(chan_filt_coeffs)
self.chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs)
if self.use_IF:
# Turn If to baseband and filter.
self.chan_filt = gr.freq_xlating_fir_filter_ccf(
chanfilt_decim, chan_filt_coeffs, self.IF_freq, usrp_rate)
else:
self.chan_filt = gr.fir_filter_ccf(chanfilt_decim,
chan_filt_coeffs)
self.am_demod = gr.complex_to_mag()
self.volume_control = gr.multiply_const_ff(self.vol)
audio_filt_coeffs = optfir.low_pass(
1, # gain
demod_rate, # sampling rate
8e3, # passband cutoff
10e3, # stopband cutoff
0.1, # passband ripple
60) # stopband attenuation
self.audio_filt = gr.fir_filter_fff(audio_decimation,
audio_filt_coeffs)
# 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, self.chan_filt, self.am_demod, self.audio_filt,
self.volume_control, audio_sink)
self._build_gui(vbox, usrp_rate, demod_rate, audio_rate)
if options.gain is None:
g = self.subdev.gain_range()
if True:
# if no gain was specified, use the maximum gain available
# (usefull for Basic_RX which is relatively deaf and the most probable board to be used for AM)
# TODO: check db type to decide on default gain.
options.gain = float(g[1])
else:
# if no gain was specified, use the mid-point in dB
options.gain = float(g[0] + g[1]) / 2
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0] * 3 + g[1]) / 4
if abs(options.freq) < 1e3:
options.freq *= 1e3
# 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 __init__(self):
gr.top_block.__init__(self)
amplitude = 5000
interp_rate = 256
dec_rate = 16
sw_dec = 5
num_taps = int(64000 / ( (dec_rate * 4) * 40 )) #Filter matched to 1/4 of the 40 kHz tag cycle
taps = [complex(1,1)] * num_taps
matched_filt = gr.fir_filter_ccc(sw_dec, taps);
agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100)
to_mag = gr.complex_to_mag()
center = rfid.center_ff(10)
omega = 5
mu = 0.25
gain_mu = 0.25
gain_omega = .25 * gain_mu * gain_mu
omega_relative_limit = .05
mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_relative_limit)
self.reader = rfid.reader_f(int(128e6/interp_rate));
tag_decoder = rfid.tag_decoder_f()
command_gate = rfid.command_gate_cc(12, 250, 64000000 / dec_rate / sw_dec)
to_complex = gr.float_to_complex()
amp = gr.multiply_const_ff(amplitude)
#output the TX and RX signals only
f_txout = gr.file_sink(gr.sizeof_gr_complex, 'f_txout.out');
f_rxout = gr.file_sink(gr.sizeof_gr_complex, 'f_rxout.out');
#TX
# working frequency at 915 MHz by default and RX Gain of 20
freq = options.center_freq #915e6
rx_gain = options.rx_gain #20
tx = usrp.sink_c(fusb_block_size = 512, fusb_nblocks=4)
tx.set_interp_rate(256)
tx_subdev = (0,0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(0, dec_rate, fusb_block_size = 512, fusb_nblocks = 4)
rx_subdev_spec = (1,0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
r = usrp.tune(rx, 0, rx_subdev, freq)
self.rx = rx
if not r:
print "Couldn't set rx freq"
#End RX
command_gate.set_ctrl_out(self.reader.ctrl_q())
tag_decoder.set_ctrl_out(self.reader.ctrl_q())
#########Build Graph
self.connect(rx, matched_filt)
self.connect(matched_filt, command_gate)
self.connect(command_gate, agc)
self.connect(agc, to_mag)
self.connect(to_mag, center, mm, tag_decoder)
self.connect(tag_decoder, self.reader, amp, to_complex, tx);
#################
#Output dumps for debug
self.connect(rx, f_rxout);
self.connect(to_complex, f_txout);
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("",
"--f1",
type="eng_float",
default=100.7e6,
help="set 1st station frequency to FREQ",
metavar="FREQ")
parser.add_option("",
"--f2",
type="eng_float",
default=102.5e6,
help="set 2nd station freq to FREQ",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=40,
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)
if abs(options.f1) < 1e6:
options.f1 *= 1e6
if abs(options.f2) < 1e6:
options.f2 *= 1e6
if abs(options.f1 - options.f2) > 5.5e6:
print "Sorry, two stations must be within 5.5MHz of each other"
raise SystemExit
f = (options.f1, options.f2)
self.vol = .1
self.state = "FREQ"
# build graph
self.u = usrp.source_c(0, nchan=2) # 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)
mv = usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)
mv |= (mv << 8) & 0xff00 # both DDC inputs setup same way
self.u.set_mux(mv)
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(), )
# deinterleave two channels from FPGA
di = gr.deinterleave(gr.sizeof_gr_complex)
# wire up the head of the chain
self.connect(self.u, di)
# sound card as final sink
audio_sink = audio.sink(int(audio_rate), options.audio_output)
# taps for channel filter
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)
mid_freq = (f[0] + f[1]) / 2
# set front end PLL to middle frequency
tune_result = self.subdev.set_freq(mid_freq)
for n in range(2):
chan_filt = gr.fir_filter_ccf(chanfilt_decim, chan_filt_coeffs)
guts = blks2.wfm_rcv(demod_rate, audio_decimation)
volume_control = gr.multiply_const_ff(self.vol)
self.connect((di, n), chan_filt)
self.connect(chan_filt, guts, volume_control)
self.connect(volume_control, (audio_sink, n))
dxc_freq, inverted = calc_dxc_freq(f[n], tune_result.baseband_freq,
self.u.converter_rate())
self.u.set_rx_freq(n, dxc_freq)
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
# set initial values
self.set_gain(options.gain)
def __init__(self, options):
gr.top_block.__init__(self)
fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
self._u = usrp.source_c(decim_rate=options.decim,
fusb_block_size=fusb_block_size,
fusb_nblocks=fusb_nblocks)
# master clock
if options.fpga_freq is not None:
self._u.set_fpga_master_clock_freq(long(options.fpga_freq))
# default subdev if use didn't pick one
if options.rx_subdev_spec is None:
if u.db(0, 0).dbid() >= 0:
options.rx_subdev_spec = (0, 0)
elif u.db(1, 0).dbid() >= 0:
options.rx_subdev_spec = (1, 0)
else:
options.rx_subdev_spec = (0, 0)
# configure usrp mux
self._u.set_mux(
usrp.determine_rx_mux_value(self._u, options.rx_subdev_spec))
# determine the daughterboard subdevice
self.subdev = usrp.selected_subdev(self._u, options.rx_subdev_spec)
# select antenna
if options.antenna is not None:
print "Selecting antenna %s" % (options.antenna, )
self.subdev.select_rx_antenna(options.antenna)
# set initial values
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
r = self._u.tune(0, self.subdev, options.freq)
self.subdev.set_gain(options.gain)
#sample_rate = options.fpga_clock/options.decim
sample_rate = self._u.adc_freq() / self._u.decim_rate()
symbol_rate = 18000
sps = 2
# output rate will be 36,000
ntaps = 11 * sps
new_sample_rate = symbol_rate * sps
channel_taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.1,
gr.firdes.WIN_HANN)
FILTER = gr.freq_xlating_fir_filter_ccf(1, channel_taps,
options.calibration,
sample_rate)
sys.stderr.write("sample rate: %d\n" % (sample_rate))
DEMOD = cqpsk.cqpsk_demod(samples_per_symbol=sps,
excess_bw=0.35,
costas_alpha=0.03,
gain_mu=0.05,
mu=0.05,
omega_relative_limit=0.05,
log=options.log,
verbose=options.verbose)
OUT = gr.file_sink(gr.sizeof_float, options.output_file)
r = float(sample_rate) / float(new_sample_rate)
INTERPOLATOR = gr.fractional_interpolator_cc(0, r)
self.connect(self._u, FILTER, INTERPOLATOR, DEMOD, OUT)
