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 = 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)
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.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.volume_control_l, (audio_sink, 0))
self.connect((self.guts, 1), 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)
usage = "usage: %prog [options] input-samples-320kS.dat output.wav"
parser=OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-V", "--volume", type="eng_float", default=None,
help="set volume (default is midpoint)")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
input_filename = args[0]
output_filename = args[1]
self.vol = 0
# build graph
self.src = gr.file_source(gr.sizeof_gr_complex, input_filename, False)
adc_rate = 64e6 # 64 MS/s
usrp_decim = 200
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
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.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)
# wave file as final sink
if 1:
sink = gr.wavfile_sink(output_filename, 2, int(audio_rate), 16)
else:
sink = audio.sink (int (audio_rate),
options.audio_output,
False) # ok_to_block
# now wire it all together
self.connect (self.src, chan_filt, self.guts)
self.connect ((self.guts, 0), self.volume_control_l, (sink, 0))
self.connect ((self.guts, 1), self.volume_control_r, (sink, 1))
try:
self.guts.stereo_carrier_pll_recovery.squelch_enable(True)
except:
pass
#print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0]+g[1])/2
# set initial values
self.set_vol(options.volume)
try:
self.guts.stereo_carrier_pll_recovery.set_lock_threshold(options.squelch)
except:
pass
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("-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("-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")
parser.add_option("", "--freq-min", type="eng_float", default=87.9e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=108.1e6,
help="Set a maximum frequency [default=%default]")
(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
self.fm_freq_min = options.freq_min
self.fm_freq_max = options.freq_max
# build graph
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
# 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)
usrp_rate = 320e3
demod_rate = 320e3
audio_rate = 48e3
audio_decim = 10
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
nfilts = 32
chan_coeffs = gr.firdes.low_pass_2 (nfilts, # gain
nfilts*usrp_rate, # sampling rate
90e3, # passband cutoff
30e3, # stopband cutoff
70) # stopband attenuation
rrate = usrp_rate / dev_rate
self.chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts)
self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim)
chan_rate = audio_rate / (demod_rate/audio_decim)
self.rchan_filt = blks2.pfb_arb_resampler_fff(chan_rate)
self.lchan_filt = blks2.pfb_arb_resampler_fff(chan_rate)
# 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
self.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.guts)
self.connect((self.guts, 0), self.lchan_filt,
self.volume_control_l, (self.audio_sink,0))
self.connect((self.guts, 1), self.rchan_filt,
self.volume_control_r, (self.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.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0]+g[1])/2
frange = self.u.get_freq_range()
if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min):
sys.stderr.write("Radio does not support required frequency range.\n")
sys.exit(1)
if(options.freq < self.fm_freq_min or options.freq > self.fm_freq_max):
sys.stderr.write("Requested frequency is outside of required frequency range.\n")
sys.exit(1)
# 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("-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=91.2e6,
help="set frequency to FREQ",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=None,
help="set gain in dB")
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="plughw:0,0",
help="pcm device name (default is plughw:0,0)")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
# connect to USRP
usrp_decim = 250
self.u = usrp.source_c(0, usrp_decim)
print "USRP Serial: ", self.u.serial_number()
demod_rate = self.u.adc_rate() / usrp_decim # 256 kS/s
audio_decim = 8
audio_rate = demod_rate / audio_decim # 32 kS/s
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_subdev(self.u, dblist)
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 d'board", self.subdev.side_and_name()
# gain, volume, frequency
self.gain = options.gain
if options.gain is None:
self.gain = self.subdev.gain_range()[1]
self.vol = options.volume
if self.vol is None:
g = self.volume_range()
self.vol = float(g[0] + g[1]) / 2
self.freq = options.freq
if abs(self.freq) < 1e6:
self.freq *= 1e6
print "Volume:%r, Gain:%r, Freq:%3.1f MHz" % (self.vol, self.gain,
self.freq / 1e6)
# channel filter, wfm_rcv_pll
chan_filt_coeffs = optfir.low_pass(
1, # gain
demod_rate, # rate
80e3, # passband cutoff
115e3, # stopband cutoff
0.1, # passband ripple
60) # stopband attenuation
self.chan_filt = gr.fir_filter_ccf(1, chan_filt_coeffs)
self.guts = blks2.wfm_rcv_pll(demod_rate, audio_decim)
self.connect(self.u, self.chan_filt, self.guts)
# volume control, audio sink
self.volume_control_l = gr.multiply_const_ff(self.vol)
self.volume_control_r = gr.multiply_const_ff(self.vol)
self.audio_sink = audio.sink(int(audio_rate), options.audio_output,
False)
self.connect((self.guts, 0), self.volume_control_l,
(self.audio_sink, 0))
self.connect((self.guts, 1), self.volume_control_r,
(self.audio_sink, 1))
# pilot channel filter (band-pass, 18.5-19.5kHz)
pilot_filter_coeffs = gr.firdes.band_pass(
1, # gain
demod_rate, # sampling rate
18.5e3, # low cutoff
19.5e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.pilot_filter = gr.fir_filter_fff(1, pilot_filter_coeffs)
self.connect(self.guts.fm_demod, self.pilot_filter)
# RDS channel filter (band-pass, 54-60kHz)
rds_filter_coeffs = gr.firdes.band_pass(
1, # gain
demod_rate, # sampling rate
54e3, # low cutoff
60e3, # high cutoff
3e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_coeffs)
self.connect(self.guts.fm_demod, self.rds_filter)
# create 57kHz subcarrier from 19kHz pilot, downconvert RDS channel
self.mixer = gr.multiply_ff()
self.connect(self.pilot_filter, (self.mixer, 0))
self.connect(self.pilot_filter, (self.mixer, 1))
self.connect(self.pilot_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# low-pass the baseband RDS signal at 1.5kHz
rds_bb_filter_coeffs = gr.firdes.low_pass(
1, # gain
demod_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_bb_filter = gr.fir_filter_fff(1, rds_bb_filter_coeffs)
self.connect(self.mixer, self.rds_bb_filter)
# 1187.5bps = 19kHz/16
self.rds_clock = rds.freq_divider(16)
clock_taps = gr.firdes.low_pass(
1, # gain
demod_rate, # sampling rate
1.2e3, # passband cutoff
1.5e3, # transition width
gr.firdes.WIN_HANN)
self.clock_filter = gr.fir_filter_fff(1, clock_taps)
self.connect(self.pilot_filter, self.rds_clock, self.clock_filter)
# bpsk_demod, diff_decoder, rds_decoder
self.bpsk_demod = rds.bpsk_demod(demod_rate)
self.differential_decoder = gr.diff_decoder_bb(2)
self.msgq = gr.msg_queue()
self.rds_decoder = rds.data_decoder(self.msgq)
self.connect(self.rds_bb_filter, (self.bpsk_demod, 0))
self.connect(self.clock_filter, (self.bpsk_demod, 1))
self.connect(self.bpsk_demod, self.differential_decoder)
self.connect(self.differential_decoder, self.rds_decoder)
# set initial values
self.subdev.set_gain(self.gain)
self.set_vol(self.vol)
self.set_freq(self.freq)
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=91.2e6,
help="set frequency to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB")
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="plughw:0,0",
help="pcm device name (default is plughw:0,0)")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
# connect to USRP
usrp_decim = 250
self.u = usrp.source_c(0, usrp_decim)
print "USRP Serial: ", self.u.serial_number()
demod_rate = self.u.adc_rate() / usrp_decim # 256 kS/s
audio_decim = 8
audio_rate = demod_rate / audio_decim # 32 kS/s
if options.rx_subdev_spec is None:
options.rx_subdev_spec = usrp.pick_subdev(self.u, dblist)
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 d'board", self.subdev.side_and_name()
# gain, volume, frequency
self.gain = options.gain
if options.gain is None:
self.gain = self.subdev.gain_range()[1]
self.vol = options.volume
if self.vol is None:
g = self.volume_range()
self.vol = float(g[0]+g[1])/2
self.freq = options.freq
if abs(self.freq) < 1e6:
self.freq *= 1e6
print "Volume:%r, Gain:%r, Freq:%3.1f MHz" % (self.vol, self.gain, self.freq/1e6)
# channel filter, wfm_rcv_pll
chan_filt_coeffs = optfir.low_pass(
1, # gain
demod_rate, # rate
80e3, # passband cutoff
115e3, # stopband cutoff
0.1, # passband ripple
60) # stopband attenuation
self.chan_filt = gr.fir_filter_ccf (1, chan_filt_coeffs)
self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim)
self.connect(self.u, self.chan_filt, self.guts)
# volume control, audio sink
self.volume_control_l = gr.multiply_const_ff(self.vol)
self.volume_control_r = gr.multiply_const_ff(self.vol)
self.audio_sink = audio.sink(int(audio_rate), options.audio_output, False)
self.connect ((self.guts, 0), self.volume_control_l, (self.audio_sink, 0))
self.connect ((self.guts, 1), self.volume_control_r, (self.audio_sink, 1))
# pilot channel filter (band-pass, 18.5-19.5kHz)
pilot_filter_coeffs = gr.firdes.band_pass(
1, # gain
demod_rate, # sampling rate
18.5e3, # low cutoff
19.5e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.pilot_filter = gr.fir_filter_fff(1, pilot_filter_coeffs)
self.connect(self.guts.fm_demod, self.pilot_filter)
# RDS channel filter (band-pass, 54-60kHz)
rds_filter_coeffs = gr.firdes.band_pass(
1, # gain
demod_rate, # sampling rate
54e3, # low cutoff
60e3, # high cutoff
3e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_coeffs)
self.connect(self.guts.fm_demod, self.rds_filter)
# create 57kHz subcarrier from 19kHz pilot, downconvert RDS channel
self.mixer = gr.multiply_ff()
self.connect(self.pilot_filter, (self.mixer, 0))
self.connect(self.pilot_filter, (self.mixer, 1))
self.connect(self.pilot_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# low-pass the baseband RDS signal at 1.5kHz
rds_bb_filter_coeffs = gr.firdes.low_pass(
1, # gain
demod_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_bb_filter = gr.fir_filter_fff(1, rds_bb_filter_coeffs)
self.connect(self.mixer, self.rds_bb_filter)
# 1187.5bps = 19kHz/16
self.rds_clock = rds.freq_divider(16)
clock_taps = gr.firdes.low_pass(
1, # gain
demod_rate, # sampling rate
1.2e3, # passband cutoff
1.5e3, # transition width
gr.firdes.WIN_HANN)
self.clock_filter = gr.fir_filter_fff(1, clock_taps)
self.connect(self.pilot_filter, self.rds_clock, self.clock_filter)
# bpsk_demod, diff_decoder, rds_decoder
self.bpsk_demod = rds.bpsk_demod(demod_rate)
self.differential_decoder = gr.diff_decoder_bb(2)
self.msgq = gr.msg_queue()
self.rds_decoder = rds.data_decoder(self.msgq)
self.connect(self.rds_bb_filter, (self.bpsk_demod, 0))
self.connect(self.clock_filter, (self.bpsk_demod, 1))
self.connect(self.bpsk_demod, self.differential_decoder)
self.connect(self.differential_decoder, self.rds_decoder)
# set initial values
self.subdev.set_gain(self.gain)
self.set_vol(self.vol)
self.set_freq(self.freq)
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("-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("-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")
parser.add_option("", "--freq-min", type="eng_float", default=87.9e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=108.1e6,
help="Set a maximum frequency [default=%default]")
(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
self.fm_freq_min = options.freq_min
self.fm_freq_max = options.freq_max
# build graph
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
usrp_rate = 320e3
demod_rate = 320e3
audio_rate = 48e3
audio_decim = 10
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
nfilts = 32
chan_coeffs = gr.firdes.low_pass_2 (nfilts, # gain
nfilts*usrp_rate, # sampling rate
90e3, # passband cutoff
30e3, # stopband cutoff
70) # stopband attenuation
rrate = usrp_rate / dev_rate
self.chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts)
self.guts = blks2.wfm_rcv_pll (demod_rate, audio_decim)
chan_rate = audio_rate / (demod_rate/audio_decim)
self.rchan_filt = blks2.pfb_arb_resampler_fff(chan_rate)
self.lchan_filt = blks2.pfb_arb_resampler_fff(chan_rate)
# 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
self.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.guts)
self.connect((self.guts, 0), self.lchan_filt,
self.volume_control_l, (self.audio_sink,0))
self.connect((self.guts, 1), self.rchan_filt,
self.volume_control_r, (self.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.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0]+g[1])/2
frange = self.u.get_freq_range()
if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min):
sys.stderr.write("Radio does not support required frequency range.\n")
sys.exit(1)
if(options.freq < self.fm_freq_min or options.freq > self.fm_freq_max):
sys.stderr.write("Requested frequency is outside of required frequency range.\n")
sys.exit(1)
# 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")
# 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)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Fm Rx Example")
##################################################
# Variables
##################################################
self.usrp_freq = usrp_freq = 96.5e6
self.samp_rate = samp_rate = 500e3
self.xlate_tune = xlate_tune = 0
self.usrp_decim = usrp_decim = 200
self.rx_freq = rx_freq = usrp_freq
self.rf_gain = rf_gain = 15
self.filter_taps = filter_taps = firdes.low_pass(1,samp_rate,200e3,1e3)
self.af_gain = af_gain = 3
##################################################
# Blocks
##################################################
_xlate_tune_sizer = wx.BoxSizer(wx.VERTICAL)
self._xlate_tune_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_xlate_tune_sizer,
value=self.xlate_tune,
callback=self.set_xlate_tune,
label='xlate_tune',
converter=forms.float_converter(),
proportion=0,
)
self._xlate_tune_slider = forms.slider(
parent=self.GetWin(),
sizer=_xlate_tune_sizer,
value=self.xlate_tune,
callback=self.set_xlate_tune,
minimum=-250e3,
maximum=250e3,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_xlate_tune_sizer, 7, 0, 1, 5)
_usrp_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._usrp_freq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_usrp_freq_sizer,
value=self.usrp_freq,
callback=self.set_usrp_freq,
label='usrp_freq',
converter=forms.float_converter(),
proportion=0,
)
self._usrp_freq_slider = forms.slider(
parent=self.GetWin(),
sizer=_usrp_freq_sizer,
value=self.usrp_freq,
callback=self.set_usrp_freq,
minimum=88e6,
maximum=108e6,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_usrp_freq_sizer, 6, 0, 1, 5)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=13.49e3,
sample_rate=250e3,
fft_size=1024,
fft_rate=10,
average=True,
avg_alpha=500e-3,
title="FFT Plot",
peak_hold=False,
size=(1120,527),
)
self.GridAdd(self.wxgui_fftsink2_0.win, 0, 0, 5, 5)
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="addr=192.168.20.2",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(usrp_freq, 0)
self.uhd_usrp_source_0.set_gain(15, 0)
self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
self._rx_freq_static_text = forms.static_text(
parent=self.GetWin(),
value=self.rx_freq,
callback=self.set_rx_freq,
label='rx_freq',
converter=forms.float_converter(),
)
self.GridAdd(self._rx_freq_static_text, 5, 3, 1, 1)
_rf_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rf_gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rf_gain_sizer,
value=self.rf_gain,
callback=self.set_rf_gain,
label='rf_gain',
converter=forms.float_converter(),
proportion=0,
)
self._rf_gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rf_gain_sizer,
value=self.rf_gain,
callback=self.set_rf_gain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_rf_gain_sizer, 8, 0, 1, 2)
self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((3, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((3, ))
self.gr_freq_xlating_fir_filter_xxx_0 = gr.freq_xlating_fir_filter_ccc(1, (filter_taps), xlate_tune, samp_rate)
self.blks2_wfm_rcv_pll_0 = blks2.wfm_rcv_pll(
demod_rate=500e3,
audio_decimation=10,
)
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff(
interpolation=48,
decimation=50,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff(
interpolation=48,
decimation=50,
taps=None,
fractional_bw=None,
)
self.audio_sink_0 = audio.sink(48000, "", True)
_af_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._af_gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_af_gain_sizer,
value=self.af_gain,
callback=self.set_af_gain,
label='af_gain',
converter=forms.float_converter(),
proportion=0,
)
self._af_gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_af_gain_sizer,
value=self.af_gain,
callback=self.set_af_gain,
minimum=0,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_af_gain_sizer, 8, 2, 1, 2)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.blks2_wfm_rcv_pll_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_multiply_const_vxx_1, 0))
self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.gr_multiply_const_vxx_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1))
self.connect((self.blks2_wfm_rcv_pll_0, 0), (self.blks2_rational_resampler_xxx_0, 0))
self.connect((self.blks2_wfm_rcv_pll_0, 1), (self.blks2_rational_resampler_xxx_1, 0))
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] input-samples-320kS.dat output.wav"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-V",
"--volume",
type="eng_float",
default=None,
help="set volume (default is midpoint)")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
input_filename = args[0]
output_filename = args[1]
self.vol = 0
# build graph
self.src = gr.file_source(gr.sizeof_gr_complex, input_filename, False)
adc_rate = 64e6 # 64 MS/s
usrp_decim = 200
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
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.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)
# wave file as final sink
if 1:
sink = gr.wavfile_sink(output_filename, 2, int(audio_rate), 16)
else:
sink = audio.sink(int(audio_rate), options.audio_output,
False) # ok_to_block
# now wire it all together
self.connect(self.src, chan_filt, self.guts)
self.connect((self.guts, 0), self.volume_control_l, (sink, 0))
self.connect((self.guts, 1), self.volume_control_r, (sink, 1))
try:
self.guts.stereo_carrier_pll_recovery.squelch_enable(True)
except:
pass
#print "FYI: This implementation of the stereo_carrier_pll_recovery has no squelch implementation yet"
if options.volume is None:
g = self.volume_range()
options.volume = float(g[0] + g[1]) / 2
# set initial values
self.set_vol(options.volume)
try:
self.guts.stereo_carrier_pll_recovery.set_lock_threshold(
options.squelch)
except:
pass
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Fm Rx Example")
##################################################
# Variables
##################################################
self.usrp_freq = usrp_freq = 96e6
self.samp_rate = samp_rate = 500e3
self.xlate_tune = xlate_tune = 0
self.usrp_decim = usrp_decim = 200
self.rx_freq = rx_freq = usrp_freq
self.rf_gain = rf_gain = 15
self.filter_taps = filter_taps = firdes.low_pass(
1, samp_rate, 200e3, 1e3)
self.af_gain = af_gain = 3
self.Mult_constant = Mult_constant = 5
##################################################
# Blocks
##################################################
_xlate_tune_sizer = wx.BoxSizer(wx.VERTICAL)
self._xlate_tune_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_xlate_tune_sizer,
value=self.xlate_tune,
callback=self.set_xlate_tune,
label='xlate_tune',
converter=forms.float_converter(),
proportion=0,
)
self._xlate_tune_slider = forms.slider(
parent=self.GetWin(),
sizer=_xlate_tune_sizer,
value=self.xlate_tune,
callback=self.set_xlate_tune,
minimum=-250e3,
maximum=250e3,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_xlate_tune_sizer, 7, 0, 1, 5)
_usrp_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._usrp_freq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_usrp_freq_sizer,
value=self.usrp_freq,
callback=self.set_usrp_freq,
label='usrp_freq',
converter=forms.float_converter(),
proportion=0,
)
self._usrp_freq_slider = forms.slider(
parent=self.GetWin(),
sizer=_usrp_freq_sizer,
value=self.usrp_freq,
callback=self.set_usrp_freq,
minimum=88e6,
maximum=108e6,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_usrp_freq_sizer, 6, 0, 1, 5)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=13.49e3,
sample_rate=250e3,
fft_size=1024,
fft_rate=10,
average=True,
avg_alpha=500e-3,
title="FFT Plot",
peak_hold=False,
size=(1120, 527),
)
self.GridAdd(self.wxgui_fftsink2_0.win, 0, 0, 5, 5)
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="addr=192.168.10.2",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(usrp_freq, 0)
self.uhd_usrp_source_0.set_gain(15, 0)
self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
self._rx_freq_static_text = forms.static_text(
parent=self.GetWin(),
value=self.rx_freq,
callback=self.set_rx_freq,
label='rx_freq',
converter=forms.float_converter(),
)
self.GridAdd(self._rx_freq_static_text, 5, 3, 1, 1)
_rf_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rf_gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rf_gain_sizer,
value=self.rf_gain,
callback=self.set_rf_gain,
label='rf_gain',
converter=forms.float_converter(),
proportion=0,
)
self._rf_gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rf_gain_sizer,
value=self.rf_gain,
callback=self.set_rf_gain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_rf_gain_sizer, 8, 0, 1, 2)
self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((Mult_constant, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((Mult_constant, ))
self.gr_freq_xlating_fir_filter_xxx_0 = gr.freq_xlating_fir_filter_ccc(
1, (filter_taps), xlate_tune, samp_rate)
self.blks2_wfm_rcv_pll_0 = blks2.wfm_rcv_pll(
demod_rate=500e3,
audio_decimation=10,
)
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff(
interpolation=48,
decimation=50,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff(
interpolation=48,
decimation=50,
taps=None,
fractional_bw=None,
)
self.audio_sink_0 = audio.sink(48000, "", True)
_af_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._af_gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_af_gain_sizer,
value=self.af_gain,
callback=self.set_af_gain,
label='af_gain',
converter=forms.float_converter(),
proportion=0,
)
self._af_gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_af_gain_sizer,
value=self.af_gain,
callback=self.set_af_gain,
minimum=0,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_af_gain_sizer, 8, 2, 1, 2)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0),
(self.gr_freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0),
(self.blks2_wfm_rcv_pll_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0, 0),
(self.wxgui_fftsink2_0, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.blks2_rational_resampler_xxx_1, 0),
(self.gr_multiply_const_vxx_1, 0))
self.connect((self.blks2_rational_resampler_xxx_0, 0),
(self.gr_multiply_const_vxx_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1))
self.connect((self.blks2_wfm_rcv_pll_0, 0),
(self.blks2_rational_resampler_xxx_0, 0))
self.connect((self.blks2_wfm_rcv_pll_0, 1),
(self.blks2_rational_resampler_xxx_1, 0))
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")
