#!/usr/bin/env python
from gnuradio import gr, gru, usrp, optfir, audio, eng_notation, blks
from gnuradio.eng_option import eng_option
from optparse import OptionParser
"""
This example application demonstrates receiving and demodulating
different types of signals using the USRP.
A receive chain is built up of the following signal processing
blocks:
USRP - Daughter board source generating complex baseband signal.
CHAN - Low pass filter to select channel bandwidth
RFSQL - RF squelch zeroing output when input power below threshold
AGC - Automatic gain control leveling signal at [-1.0, +1.0]
DEMOD - Demodulation block appropriate to selected signal type.
This converts the complex baseband to real audio frequencies,
and applies an appropriate low pass decimating filter.
CTCSS - Optional tone squelch zeroing output when tone is not present.
RSAMP - Resampler block to convert audio sample rate to user specified
sound card output rate.
AUDIO - Audio sink for playing final output to speakers.
The following are required command line parameters:
-f FREQ USRP receive frequency
-m MOD Modulation type, select from AM, FM, or WFM
The following are optional command line parameters:
-R SUBDEV Daughter board specification, defaults to first found
-c FREQ Calibration offset. Gets added to receive frequency.
Defaults to 0.0 Hz.
-g GAIN Daughterboard gain setting. Defaults to mid-range.
-o RATE Sound card output rate. Defaults to 32000. Useful if
your sound card only accepts particular sample rates.
-r RFSQL RF squelch in db. Defaults to -50.0.
-p FREQ CTCSS frequency. Opens squelch when tone is present.
Once the program is running, ctrl-break (Ctrl-C) stops operation.
Please see fm_demod.py and am_demod.py for details of the demodulation
blocks.
"""
# (usrp_decim, channel_decim, audio_decim, channel_pass, channel_stop, demod)
demod_params = {
'AM' : (250, 16, 1, 5000, 8000, blks.demod_10k0a3e_cf),
'FM' : (250, 8, 4, 8000, 9000, blks.demod_20k0f3e_cf),
'WFM' : (250, 1, 8, 90000, 100000, blks.demod_200kf3e_cf)
}
class usrp_source_c(gr.hier_block):
"""
Create a USRP source object supplying complex floats.
Selects user supplied subdevice or chooses first available one.
Calibration value is the offset from the tuned frequency to
the actual frequency.
"""
def __init__(self, fg, subdev_spec, decim, gain=None, calibration=0.0):
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
gr.hier_block.__init__(self, fg, self._src, self._src)
def tune(self, freq):
result = usrp.tune(self._src, 0, self._subdev, freq+self._cal)
# TODO: deal with residual
def rate(self):
return self._src.adc_rate()/self._decim
class app_flow_graph(gr.flow_graph):
def __init__(self, options, args):
gr.flow_graph.__init__(self)
self.options = options
self.args = args
(usrp_decim, channel_decim, audio_decim,
channel_pass, channel_stop, demod) = demod_params[options.modulation]
USRP = usrp_source_c(self, # Flow graph
options.rx_subdev_spec, # Daugherboard spec
usrp_decim, # IF decimation ratio
options.gain, # Receiver gain
options.calibration) # Frequency offset
USRP.tune(options.frequency)
if_rate = USRP.rate()
channel_rate = if_rate // channel_decim
audio_rate = channel_rate // audio_decim
CHAN_taps = optfir.low_pass(1.0, # Filter gain
if_rate, # Sample rate
channel_pass, # One sided modulation bandwidth
channel_stop, # One sided channel bandwidth
0.1, # Passband ripple
60) # Stopband attenuation
CHAN = gr.freq_xlating_fir_filter_ccf(channel_decim, # Decimation rate
CHAN_taps, # Filter taps
0.0, # Offset frequency
if_rate) # Sample rate
RFSQL = gr.pwr_squelch_cc(options.rf_squelch, # Power threshold
125.0/channel_rate, # Time constant
channel_rate/20, # 50ms rise/fall
False) # Zero, not gate output
AGC = gr.agc_cc(1.0/channel_rate, # Time constant
1.0, # Reference power
1.0, # Initial gain
1.0) # Maximum gain
DEMOD = demod(self, channel_rate, audio_decim)
# From RF to audio
self.connect(USRP, CHAN, RFSQL, AGC, DEMOD)
# Optionally add CTCSS and RSAMP if needed
tail = DEMOD
if options.ctcss != None and options.ctcss > 60.0:
CTCSS = gr.ctcss_squelch_ff(audio_rate, # Sample rate
options.ctcss) # Squelch tone
self.connect(DEMOD, CTCSS)
tail = CTCSS
if options.output_rate != audio_rate:
out_lcm = gru.lcm(audio_rate, options.output_rate)
out_interp = int(out_lcm // audio_rate)
out_decim = int(out_lcm // options.output_rate)
RSAMP = blks.rational_resampler_fff(self, out_interp, out_decim)
self.connect(tail, RSAMP)
tail = RSAMP
# Send to default audio output
AUDIO = audio.sink(options.output_rate, "")
self.connect(tail, AUDIO)
def main():
parser = OptionParser(option_class=eng_option)
parser.add_option("-f", "--frequency", type="eng_float",
help="set receive frequency to Hz", metavar="Hz")
parser.add_option("-R", "--rx-subdev-spec", type="subdev",
help="select USRP Rx side A or B", metavar="SUBDEV")
parser.add_option("-c", "--calibration", type="eng_float", default=0.0,
help="set frequency offset to Hz", metavar="Hz")
parser.add_option("-g", "--gain", type="int", default=None,
help="set RF gain", metavar="dB")
parser.add_option("-m", "--modulation", type="choice", choices=('AM','FM','WFM'),
help="set modulation type (AM,FM)", metavar="TYPE")
parser.add_option("-o", "--output-rate", type="int", default=32000,
help="set audio output rate to RATE", metavar="RATE")
parser.add_option("-r", "--rf-squelch", type="eng_float", default=-50.0,
help="set RF squelch to dB", metavar="dB")
parser.add_option("-p", "--ctcss", type="float",
help="set CTCSS squelch to FREQ", metavar="FREQ")
(options, args) = parser.parse_args()
if options.frequency < 1e6:
options.frequency *= 1e6
fg = app_flow_graph(options, args)
try:
fg.run()
except KeyboardInterrupt:
pass
if __name__ == "__main__":
main()