def __init__(self, args):
gr.top_block.__init__(self)
self.source = osmosdr.source_c() if not args.input_file else osmosdr.source_c("file=%s,rate=%f,repeat=%s,freq=%f" % (args.input_file, args.samplerate, args.loop, args.centerfreq))
self.source.set_freq_corr(args.freqcorr, 0)
self.source.set_sample_rate(args.samplerate)
self.source.set_center_freq(args.centerfreq, 0)
self.source.set_gain_mode(0, 0)
self.source.set_gain(10, 0)
self.source.set_if_gain(24, 0)
if args.output_file:
self.file_sink = gr.file_sink(gr.sizeof_gr_complex, args.output_file)
self.connect(self.source, self.file_sink)
def __init__(self,
filename=None,
capture=None,
verbose=False,
freq_error=-0.0021875):
gr.top_block.__init__(self)
self.verbose = verbose
self.rx_chips_min = 16
self.chip_error_threshold = 10
if None != filename:
self.source = gr.file_source(gr.sizeof_gr_complex, filename)
else:
self.source = osmosdr.source_c(args="nchan=" + str(1) + " " + "")
#print self.source.get_gain_range().to_pp_string()
self.source.set_sample_rate(1.6e6)
self.source.set_center_freq(868.95e6, 0)
self.source.set_freq_corr(0, 0)
self.source.set_gain_mode(0, 0)
# -1.0 1.5 4.0 6.5 9.0 11.5 14.0 16.5 19.0 21.5 24.0 29.0 34.0 42.0
self.source.set_gain(14, 0)
self.source.set_if_gain(42, 0)
if None != capture:
self.sink = gr.file_sink(gr.sizeof_gr_complex, capture)
else:
self.msgq = gr.msg_queue(4)
self.sink = wmbus_phy1(msgq=self.msgq,
verbose=verbose,
freq_error=freq_error)
self._watcher = _queue_watcher_thread(self.msgq, self.callback)
self.connect(self.source, self.sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = False
debug_stats = False
histogram = False
primary_user_location = 20
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = True
primary_user_location = 42
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, filename=None, capture=None, verbose=False, freq_error=-0.0021875):
gr.top_block.__init__(self)
self.verbose = verbose
self.rx_chips_min = 16
self.chip_error_threshold = 10
if None != filename:
self.source = gr.file_source(gr.sizeof_gr_complex, filename)
else:
self.source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
#print self.source.get_gain_range().to_pp_string()
self.source.set_sample_rate(1.6e6)
self.source.set_center_freq(868.95e6, 0)
self.source.set_freq_corr(0, 0)
self.source.set_gain_mode(0, 0)
# -1.0 1.5 4.0 6.5 9.0 11.5 14.0 16.5 19.0 21.5 24.0 29.0 34.0 42.0
self.source.set_gain(14, 0)
self.source.set_if_gain(42, 0)
if None != capture:
self.sink = gr.file_sink(gr.sizeof_gr_complex, capture)
else:
self.msgq = gr.msg_queue(4)
self.sink = wmbus_phy1(msgq=self.msgq, verbose=verbose, freq_error=freq_error);
self._watcher = _queue_watcher_thread(self.msgq, self.callback)
self.connect(self.source, self.sink)
def __init__(self, center_freq, offset_freq, decimate_am=1, play_audio=False):
"""Configure the RTL-SDR and GNU Radio"""
super(rtlsdr_am_stream, self).__init__()
audio_rate = 44100
device_rate = audio_rate * 25
output_rate = audio_rate / float(decimate_am)
self.rate = output_rate
self.osmosdr_source = osmosdr.source_c("")
self.osmosdr_source.set_center_freq(freq)
self.osmosdr_source.set_sample_rate(device_rate)
taps = firdes.low_pass(1, device_rate, 40000, 5000, firdes.WIN_HAMMING, 6.76)
self.freq_filter = gr.freq_xlating_fir_filter_ccc(25, taps, -freq_offs, device_rate)
self.am_demod = blks2.am_demod_cf(
channel_rate=audio_rate,
audio_decim=1,
audio_pass=5000,
audio_stop=5500,
)
self.resampler = blks2.rational_resampler_fff(
interpolation=1,
decimation=decimate_am,
)
self.sink = gr_queue.queue_sink_f()
self.connect(self.osmosdr_source, self.freq_filter, self.am_demod)
self.connect(self.am_demod, self.resampler, self.sink)
if play_audio:
self.audio_sink = audio.sink(audio_rate, "", True)
self.connect(self.am_demod, self.audio_sink)
def _setup_top_block(self):
self.tb = gr.top_block()
samp_rate = 96000
oversample = 10
center_freq = 868.280e6
# Radio receiver, initial downsampling
args = str("nchan=1 rtl=%s,buffers=16,offset_tune=1" % self.device)
osmosdr_source = osmosdr.source_c(args=args)
osmosdr_source.set_sample_rate(samp_rate*oversample)
osmosdr_source.set_center_freq(center_freq, 0)
osmosdr_source.set_freq_corr(0, 0)
osmosdr_source.set_gain_mode(1, 0)
osmosdr_source.set_gain(0, 0)
low_pass_filter = gr.fir_filter_ccf(oversample,
firdes.low_pass(1, samp_rate*oversample, 90e3, 8e3, firdes.WIN_HAMMING, 6.76))
self.tb.connect((osmosdr_source, 0), (low_pass_filter, 0))
# Squelch
self.noise_probe = gr.probe_avg_mag_sqrd_c(0, 1.0/samp_rate/1e2)
self.squelch = gr.simple_squelch_cc(self.noise_level, 1)
noise_probe_thread = threading.Thread(target=self._noise_probe_thread)
noise_probe_thread.start()
self.threads.append(noise_probe_thread)
self.tb.connect((low_pass_filter, 0), (self.noise_probe, 0))
self.tb.connect((low_pass_filter, 0), (self.squelch, 0))
# FM demodulation
quadrature_demod = gr.quadrature_demod_cf(1)
self.tb.connect((self.squelch, 0), (quadrature_demod, 0))
# Binary slicing, transformation into capture-compatible format
add_offset = gr.add_const_vff((-1e-3, ))
binary_slicer = digital.binary_slicer_fb()
char_to_float = gr.char_to_float(1, 1)
multiply_const = gr.multiply_const_vff((255, ))
float_to_uchar = gr.float_to_uchar()
pipe_sink = gr.file_sink(gr.sizeof_char*1, self.pipe)
pipe_sink.set_unbuffered(False)
self.tb.connect((quadrature_demod, 0), (add_offset, 0))
self.tb.connect((add_offset, 0), (binary_slicer, 0))
self.tb.connect((binary_slicer, 0), (char_to_float, 0))
self.tb.connect((char_to_float, 0), (multiply_const, 0))
self.tb.connect((multiply_const, 0), (float_to_uchar, 0))
self.tb.connect((float_to_uchar, 0), (pipe_sink, 0))
def __init__(self, options, queue):
gr.top_block.__init__(self)
if options.filename is not None:
self.u = gr.file_source(gr.sizeof_gr_complex, options.filename)
elif options.rtlsdr:
import osmosdr
self.u = osmosdr.source_c(options.args)
self.u.set_sample_rate(options.rate)
self.u.set_freq_corr(options.error)
if not self.u.set_center_freq(162.0e6):
print "Failed to set frequency"
self.u.set_gain_mode(0)
if options.gain is None:
options.gain = 49
self.u.set_gain(options.gain)
else:
from gnuradio import uhd
self.u = uhd.usrp_source(options.addr, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1)
if options.subdev is not None:
self.u.set_subdev_spec(options.subdev, 0)
self.u.set_samp_rate(options.rate)
self._freq_offset = options.error
#print "Frequency offset is %i" % self._freq_offset
self._actual_freq = 162.0e6 - self._freq_offset #tune between the two AIS freqs
#print "Tuning to: %fMHz" % float(self._actual_freq / 1e6)
if not(self.tune(self._actual_freq)):
print "Failed to set initial frequency"
if options.gain is None: #set to halfway
g = self.u.get_gain_range()
options.gain = (g.start()+g.stop()) / 2.0
#print "Setting gain to %i" % options.gain
#g = self.u.get_gain_range()
#print "Max gain %i" % g.stop()
#print "Min gain %i" % g.start()
self.u.set_gain(options.gain)
#here we're setting up TWO receivers, designated A and B. A is on 161.975, B is on 162.025. they both output data to the queue.
self.ais_rx(self.u, 161.975e6 - 162.0e6, "A", options, queue);
self.ais_rx(self.u, 162.025e6 - 162.0e6, "B", options, queue);
def __init__(self, options, queue):
gr.top_block.__init__(self)
if options.filename is not None:
self.u = gr.file_source(gr.sizeof_gr_complex, options.filename)
elif options.rtlsdr:
import osmosdr
self.u = osmosdr.source_c(options.args)
self.u.set_sample_rate(options.rate)
self.u.set_freq_corr(options.error)
if not self.u.set_center_freq(162.0e6):
print "Failed to set frequency"
self.u.set_gain_mode(0)
if options.gain is None:
options.gain = 49
self.u.set_gain(options.gain)
else:
from gnuradio import uhd
self.u = uhd.usrp_source(options.addr,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
if options.subdev is not None:
self.u.set_subdev_spec(options.subdev, 0)
self.u.set_samp_rate(options.rate)
self._freq_offset = options.error
#print "Frequency offset is %i" % self._freq_offset
self._actual_freq = 162.0e6 - self._freq_offset #tune between the two AIS freqs
#print "Tuning to: %fMHz" % float(self._actual_freq / 1e6)
if not (self.tune(self._actual_freq)):
print "Failed to set initial frequency"
if options.gain is None: #set to halfway
g = self.u.get_gain_range()
options.gain = (g.start() + g.stop()) / 2.0
#print "Setting gain to %i" % options.gain
self.u.set_gain(options.gain)
#here we're setting up TWO receivers, designated A and B. A is on 161.975, B is on 162.025. they both output data to the queue.
self.ais_rx(self.u, 161.975e6 - 162.0e6, "A", options, queue)
self.ais_rx(self.u, 162.025e6 - 162.0e6, "B", options, queue)
def __init__(self,
center_freq,
offset_freq,
decimate_am=1,
play_audio=False):
"""Configure the RTL-SDR and GNU Radio"""
super(rtlsdr_am_stream, self).__init__()
audio_rate = 44100
device_rate = audio_rate * 25
output_rate = audio_rate / float(decimate_am)
self.rate = output_rate
self.osmosdr_source = osmosdr.source_c("")
self.osmosdr_source.set_center_freq(freq)
self.osmosdr_source.set_sample_rate(device_rate)
taps = firdes.low_pass(1, device_rate, 40000, 5000, firdes.WIN_HAMMING,
6.76)
self.freq_filter = gr.freq_xlating_fir_filter_ccc(
25, taps, -freq_offs, device_rate)
self.am_demod = blks2.am_demod_cf(
channel_rate=audio_rate,
audio_decim=1,
audio_pass=5000,
audio_stop=5500,
)
self.resampler = blks2.rational_resampler_fff(
interpolation=1,
decimation=decimate_am,
)
self.sink = gr_queue.queue_sink_f()
self.connect(self.osmosdr_source, self.freq_filter, self.am_demod)
self.connect(self.am_demod, self.resampler, self.sink)
if play_audio:
self.audio_sink = audio.sink(audio_rate, "", True)
self.connect(self.am_demod, self.audio_sink)
def __init__(self, ssblock, freq):
gr.top_block.__init__(self)
# Constants
pfa = ssblock.pfa
pfd = ssblock.pfd
tcme = ssblock.tcme
samp_rate = ssblock.samp_rate
fft_size = ssblock.fft_size
samples_per_band = ssblock.samples_per_band
tcme = ssblock.tcme
output_pfa = ssblock.output_pfa
debug_stats = ssblock.debug_stats
histogram = ssblock.histogram
primary_user_location = ssblock.primary_user_location
nsegs_to_check = ssblock.nsegs_to_check
downconverter = ssblock.downconverter
useless_bw = ssblock.useless_bw
nframes_to_check = ssblock.nframes_to_check
nframes_to_average = ssblock.nframes_to_average
# Blocks
self.rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtlsdr_source.set_sample_rate(samp_rate)
self.rtlsdr_source.set_center_freq(freq, 0)
self.rtlsdr_source.set_freq_corr(0, 0)
self.rtlsdr_source.set_gain_mode(0, 0)
self.rtlsdr_source.set_gain(10, 0)
self.rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(self.rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.sample_rate = sample_rate = options.sample_rate
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(sample_rate)
#self.src.set_center_freq(209.936e6, 0)
self.src.set_freq_corr(0, 0)
self.src.set_gain_mode(1, 0)
self.src.set_gain(0, 0)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose
)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude
)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose)
if len(args) >= 1:
self.filename = args[0]
self.sink = blocks.file_sink(gr.sizeof_char*12288, self.filename)
#self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename)
self.connect(self.demod, self.sink)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec,0))
self.connect((self.demod,1), (self.fic_dec,1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1,self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
if self.correct_ffe_usrp:
print "--> correcting FFE on USRP"
self.run_correct_ffe_thread = True
self.ffe_updater = threading.Timer(0.1, self.correct_ffe)
self.ffe_updater.setDaemon(True)
self.ffe_updater.start()
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Victor's FM Receiver")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.freq_fine = freq_fine = 0
self.volume = volume = 1
self.transition = transition = 1000000
self.samp_rate = samp_rate = 2000000
self.quadrature = quadrature = 500000
self.freq = freq = 96900000+freq_fine
self.cutoff = cutoff = 100000
self.audio_dec = audio_dec = 10
##################################################
# Blocks
##################################################
_volume_sizer = wx.BoxSizer(wx.VERTICAL)
self._volume_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
label="Volume",
converter=forms.float_converter(),
proportion=0,
)
self._volume_slider = forms.slider(
parent=self.GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
minimum=0,
maximum=10,
num_steps=10,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_volume_sizer, 1, 0, 1, 10)
_transition_sizer = wx.BoxSizer(wx.VERTICAL)
self._transition_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_transition_sizer,
value=self.transition,
callback=self.set_transition,
label="Filter Transition Band",
converter=forms.float_converter(),
proportion=0,
)
self._transition_slider = forms.slider(
parent=self.GetWin(),
sizer=_transition_sizer,
value=self.transition,
callback=self.set_transition,
minimum=100000,
maximum=3000000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_transition_sizer, 1, 26, 1, 13)
self.notebook_0 = self.notebook_0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Pre- Filter FFT")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Pre- Filter Waterfall")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Post- Filter FFT")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Post- Filter Waterfall")
self.Add(self.notebook_0)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.freq,
callback=self.set_freq,
label="Exact Frequency",
converter=forms.float_converter(),
)
self.GridAdd(self._freq_text_box, 0, 0, 1, 10)
_cutoff_sizer = wx.BoxSizer(wx.VERTICAL)
self._cutoff_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_cutoff_sizer,
value=self.cutoff,
callback=self.set_cutoff,
label="Filter Cutoff",
converter=forms.float_converter(),
proportion=0,
)
self._cutoff_slider = forms.slider(
parent=self.GetWin(),
sizer=_cutoff_sizer,
value=self.cutoff,
callback=self.set_cutoff,
minimum=1000,
maximum=1000000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_cutoff_sizer, 1, 11, 1, 13)
self.wxgui_waterfallsink2_1 = waterfallsink2.waterfall_sink_c(
self.notebook_0.GetPage(1).GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.notebook_0.GetPage(1).Add(self.wxgui_waterfallsink2_1.win)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c(
self.notebook_0.GetPage(3).GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.notebook_0.GetPage(3).Add(self.wxgui_waterfallsink2_0.win)
self.wxgui_fftsink2_1 = fftsink2.fft_sink_c(
self.notebook_0.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.notebook_0.GetPage(0).Add(self.wxgui_fftsink2_1.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.notebook_0.GetPage(2).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
win=window.flattop,
)
self.notebook_0.GetPage(2).Add(self.wxgui_fftsink2_0.win)
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(10, 0)
self.osmosdr_source_c_0.set_if_gain(20, 0)
self.osmosdr_source_c_0.set_bb_gain(20, 0)
self.osmosdr_source_c_0.set_antenna("", 0)
self.osmosdr_source_c_0.set_bandwidth(0, 0)
self.low_pass_filter_0 = gr.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate, cutoff, transition, firdes.WIN_HAMMING, 6.76))
_freq_fine_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_fine_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_freq_fine_sizer,
value=self.freq_fine,
callback=self.set_freq_fine,
label="Fine Frequency Adjust",
converter=forms.float_converter(),
proportion=0,
)
self._freq_fine_slider = forms.slider(
parent=self.GetWin(),
sizer=_freq_fine_sizer,
value=self.freq_fine,
callback=self.set_freq_fine,
minimum=-2000000,
maximum=2000000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_freq_fine_sizer, 0, 11, 1, 30)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((volume, ))
self.blks2_wfm_rcv_0 = blks2.wfm_rcv(
quad_rate=quadrature,
audio_decimation=audio_dec,
)
self.audio_sink_0 = audio.sink(samp_rate, "", True)
##################################################
# Connections
##################################################
self.connect((self.low_pass_filter_0, 0), (self.blks2_wfm_rcv_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_1, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_waterfallsink2_1, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.wxgui_waterfallsink2_0, 0))
self.connect((self.blks2_wfm_rcv_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.audio_sink_0, 0))
def __init__(self, options):
gr.top_block.__init__(self)
self.rate = options.rate
print "Samples per second is %i" % self.rate
self._syms_per_sec = 3600;
options.audiorate = 44100
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 "Tuning channel offset: %f" % options.offset
self.freq = options.freq
self.samp_rate = samp_rate = self.rate
self.samp_per_sym = samp_per_sym = 10
self.decim = decim = 20
self.xlate_bandwidth = 14000
self.pre_channel_rate = pre_channel_rate = int(samp_rate/decim)
self.channel_rate = channel_rate = 4800*samp_per_sym
self.rtl = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtl.set_sample_rate(options.rate)
self.rtl.set_center_freq(options.centerfreq, 0)
self.rtl.set_freq_corr(options.ppm, 0)
#self.rtl.set_gain_mode(1, 0)
print "Channel Rate: %d Pre Channel Rate: %d" % (channel_rate, pre_channel_rate)
self.centerfreq = options.centerfreq
print "Setting center to (With Error): %fMHz" % (self.centerfreq - options.error)
if not(self.tune(options.centerfreq - options.error)):
print "Failed to set initial frequency"
if options.gain is None:
options.gain = 14
if options.bbgain is None:
options.bbgain = 25
if options.ifgain is None:
options.ifgain = 25
print "Setting RF gain to %i" % options.gain
print "Setting BB gain to %i" % options.bbgain
print "Setting IF gain to %i" % options.ifgain
self.rtl.set_gain(options.gain, 0)
self.rtl.set_if_gain(options.ifgain,0)
self.rtl.set_bb_gain(options.bbgain,0)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(decim, (firdes.low_pass(1, samp_rate, self.xlate_bandwidth/2, 6000)), -options.offset, samp_rate)
self.fir_filter_xxx_0 = filter.fir_filter_fff(1, ((1.0/self.samp_per_sym,)*self.samp_per_sym))
self.dsd_block_ff_0 = dsd.block_ff(dsd.dsd_FRAME_AUTO_DETECT,dsd.dsd_MOD_AUTO_SELECT,3,3,True)
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_ccc(
interpolation=channel_rate,
decimation=pre_channel_rate,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff(
interpolation=44100,
decimation=8000,
taps=None,
fractional_bw=None,
)
self.audio_sink_0 = audio.sink(44100, "", True)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1.6)
#self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.wxgui_fftsink2_0_0, 0))
self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.dsd_block_ff_0, 0), (self.blks2_rational_resampler_xxx_0, 0))
#self.connect((self.analog_quadrature_demod_cf_0, 0), (self.dsd_block_ff_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.dsd_block_ff_0, 0))
self.connect((self.rtl, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.blks2_rational_resampler_xxx_1, 0))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.analog_quadrature_demod_cf_0, 0))
def __init__(self, options, queue):
gr.top_block.__init__(self)
if options.filename is not None:
self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename)
self.rate = options.rate
else:
#self.u = uhd.usrp_source(options.addr,
# io_type=uhd.io_type.COMPLEX_FLOAT32,
# num_channels=1)
self.rtl = osmosdr.source_c(args="nchan=" + str(1) + " " + "")
self.rtl.set_sample_rate(options.rate)
self.rate = options.rate #self.rtl.get_samp_rate()
self.rtl.set_center_freq(options.centerfreq, 0)
#self.rtl.set_freq_corr(options.ppm, 0)
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:
options.gain = 10
if options.bbgain is None:
options.bbgain = 25
if options.ifgain is None:
options.ifgain = 25
print "Setting RF gain to %i" % options.gain
print "Setting BB gain to %i" % options.bbgain
print "Setting IF gain to %i" % options.ifgain
self.rtl.set_gain(options.gain, 0)
self.rtl.set_if_gain(options.ifgain, 0)
self.rtl.set_bb_gain(options.bbgain, 0)
#self.rtl.set_gain_mode(1,0)
print "Samples per second is %i" % self.rate
self._syms_per_sec = 3600
options.samples_per_second = self.rate
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.offset = gr.sig_source_c(self.rate, gr.GR_SIN_WAVE,
options.offset, 1.0, 0.0)
# for some reason using the xlating filter to do the offset makes thing barf with the HackRF, Multiply CC seems to work
options.offset = 0
self.mixer = gr.multiply_cc()
self.demod = fsk_demod(options)
self.start_correlator = gr.correlate_access_code_tag_bb(
"10101100", 0, "smartnet_preamble") #should mark start of packet
self.smartnet_deinterleave = smartnet.deinterleave()
self.smartnet_crc = smartnet.crc(queue)
#rerate = float(self.rate / float(first_decim)) / float(7200)
#print "resampling factor: %f\n" % rerate
#if rerate.is_integer():
# print "using pfb decimator\n"
# self.resamp = blks2.pfb_decimator_ccf(int(rerate))
#else:
# print "using pfb resampler\n"
# self.resamp = blks2.pfb_arb_resampler_ccf(1 / rerate)
if options.filename is None:
#self.connect(self.u, self.demod)
self.connect(self.rtl, (self.mixer, 0))
self.connect(self.offset, (self.mixer, 1))
self.connect(self.mixer, self.demod)
# self.connect(self.rtl, self.demod)
else:
self.connect(self.fs, self.demod)
self.connect(self.demod, self.start_correlator,
self.smartnet_deinterleave, self.smartnet_crc)
#hook up the audio patch
if options.audio:
self.audiorate = 48000
self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000,
gr.firdes.WIN_HANN)
self.prefilter_decim = int(
self.rate / self.audiorate
) #might have to use a rational resampler for audio
print "Prefilter decimation: %i" % self.prefilter_decim
self.audio_prefilter = gr.freq_xlating_fir_filter_ccf(
self.prefilter_decim, #decimation
self.audiotaps, #taps
0, #freq offset
self.rate) #sampling rate
#on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where
#the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch.
#self.squelch = gr.pwr_squelch_cc(options.squelch, #squelch point
# alpha = 0.1, #wat
# ramp = 10, #wat
# gate = False)
self.audiodemod = blks2.fm_demod_cf(
self.rate / self.prefilter_decim, #rate
1, #audio decimation
4000, #deviation
3000, #audio passband
4000, #audio stopband
1, #gain
75e-6) #deemphasis constant
#the filtering removes FSK data woobling from the subaudible channel (might be able to combine w/lpf above)
self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300,
50, gr.firdes.WIN_HANN)
self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps)
self.audiogain = gr.multiply_const_ff(options.volume)
self.audiosink = audio.sink(self.audiorate, "")
# self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8)
#self.mute()
if options.filename is None:
#self.connect(self.u, self.audio_prefilter)
self.connect(self.rtl, self.audio_prefilter)
else:
self.connect(self.fs, self.audio_prefilter)
# self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink)
# real self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
self.connect(self.audio_prefilter, self.audiodemod, self.audiofilt,
self.audiogain, self.audiosink)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
self.frame = frame
self.panel = panel
parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
self.sample_rate = options.sample_rate
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(self.sample_rate)
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = blocks.file_source(gr.sizeof_gr_complex, self.filename, False)
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose)
self.v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.scope = scopesink2.scope_sink_c(self.panel, title="DAB constellation sink", sample_rate=self.dab_params.sample_rate, xy_mode=True)
self.trigsink = blocks.null_sink(gr.sizeof_char)
self.sink = blocks.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod,1), self.trigsink)
# build GUI
self.connect(self.demod.deinterleave, self.v2s, self.scope)
vbox.Add(self.scope.win, 10, wx.EXPAND)
# FFT Sink
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.panel,
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=self.sample_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
vbox.Add(self.wxgui_fftsink2_0.win)
self.connect((self.src, 0), (self.wxgui_fftsink2_0, 0))
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
if self.correct_ffe_usrp:
print "--> correcting FFE on USRP"
self.run_correct_ffe_thread = True
self.ffe_updater = threading.Timer(0.1, self.correct_ffe)
self.ffe_updater.setDaemon(True)
self.ffe_updater.start()
def __init__(self, options, queue):
gr.top_block.__init__(self)
if options.filename is not None:
self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename)
self.rate = options.rate
else:
#self.u = uhd.usrp_source(options.addr,
# io_type=uhd.io_type.COMPLEX_FLOAT32,
# num_channels=1)
self.rtl = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtl.set_sample_rate(options.rate)
self.rate = options.rate #self.rtl.get_samp_rate()
self.rtl.set_center_freq(options.centerfreq, 0)
#self.rtl.set_freq_corr(options.ppm, 0)
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:
options.gain = 10
if options.bbgain is None:
options.bbgain = 25
if options.ifgain is None:
options.ifgain = 25
print "Setting RF gain to %i" % options.gain
print "Setting BB gain to %i" % options.bbgain
print "Setting IF gain to %i" % options.ifgain
self.rtl.set_gain(options.gain, 0)
self.rtl.set_if_gain(options.ifgain,0)
self.rtl.set_bb_gain(options.bbgain,0)
#self.rtl.set_gain_mode(1,0)
print "Samples per second is %i" % self.rate
self._syms_per_sec = 3600;
options.samples_per_second = self.rate
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.offset = gr.sig_source_c(self.rate, gr.GR_SIN_WAVE,
options.offset, 1.0, 0.0)
# for some reason using the xlating filter to do the offset makes thing barf with the HackRF, Multiply CC seems to work
options.offset = 0
self.mixer = gr.multiply_cc()
self.demod = fsk_demod(options)
self.start_correlator = gr.correlate_access_code_tag_bb("10101100",
0,
"smartnet_preamble") #should mark start of packet
self.smartnet_deinterleave = smartnet.deinterleave()
self.smartnet_crc = smartnet.crc(queue)
#rerate = float(self.rate / float(first_decim)) / float(7200)
#print "resampling factor: %f\n" % rerate
#if rerate.is_integer():
# print "using pfb decimator\n"
# self.resamp = blks2.pfb_decimator_ccf(int(rerate))
#else:
# print "using pfb resampler\n"
# self.resamp = blks2.pfb_arb_resampler_ccf(1 / rerate)
if options.filename is None:
#self.connect(self.u, self.demod)
self.connect(self.rtl, (self.mixer, 0))
self.connect(self.offset, (self.mixer, 1))
self.connect(self.mixer, self.demod)
# self.connect(self.rtl, self.demod)
else:
self.connect(self.fs, self.demod)
self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc)
#hook up the audio patch
if options.audio:
self.audiorate = 48000
self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, gr.firdes.WIN_HANN)
self.prefilter_decim = int(self.rate / self.audiorate) #might have to use a rational resampler for audio
print "Prefilter decimation: %i" % self.prefilter_decim
self.audio_prefilter = gr.freq_xlating_fir_filter_ccf(self.prefilter_decim, #decimation
self.audiotaps, #taps
0, #freq offset
self.rate) #sampling rate
#on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where
#the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch.
#self.squelch = gr.pwr_squelch_cc(options.squelch, #squelch point
# alpha = 0.1, #wat
# ramp = 10, #wat
# gate = False)
self.audiodemod = blks2.fm_demod_cf(self.rate/self.prefilter_decim, #rate
1, #audio decimation
4000, #deviation
3000, #audio passband
4000, #audio stopband
1, #gain
75e-6) #deemphasis constant
#the filtering removes FSK data woobling from the subaudible channel (might be able to combine w/lpf above)
self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, gr.firdes.WIN_HANN)
self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps)
self.audiogain = gr.multiply_const_ff(options.volume)
self.audiosink = audio.sink (self.audiorate, "")
# self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8)
#self.mute()
if options.filename is None:
#self.connect(self.u, self.audio_prefilter)
self.connect(self.rtl, self.audio_prefilter)
else:
self.connect(self.fs, self.audio_prefilter)
# self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink)
# real self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
self.connect(self.audio_prefilter, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.trans_width = trans_width = 20e3
self.samp_rate = samp_rate = 1152e3
self.quad_rate = quad_rate = 192e3
self.freq = freq = 91.9e6
self.cutoff_freq = cutoff_freq = 100e3
##################################################
# Blocks
##################################################
self._trans_width_text_box = forms.text_box(
parent=self.GetWin(),
value=self.trans_width,
callback=self.set_trans_width,
label="Transition Width",
converter=forms.float_converter(),
)
self.Add(self._trans_width_text_box)
self._quad_rate_text_box = forms.text_box(
parent=self.GetWin(),
value=self.quad_rate,
callback=self.set_quad_rate,
label="Quadrature Rate",
converter=forms.float_converter(),
)
self.Add(self._quad_rate_text_box)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.freq,
callback=self.set_freq,
label="Frequency",
converter=forms.float_converter(),
)
self.Add(self._freq_text_box)
self._cutoff_freq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.cutoff_freq,
callback=self.set_cutoff_freq,
label="Cutoff Frequency",
converter=forms.float_converter(),
)
self.Add(self._cutoff_freq_text_box)
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=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot - Source",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtlsdr_source_c_0.set_sample_rate(samp_rate)
self.rtlsdr_source_c_0.set_center_freq(freq, 0)
self.rtlsdr_source_c_0.set_freq_corr(0, 0)
self.rtlsdr_source_c_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_c_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_c_0.set_gain_mode(0, 0)
self.rtlsdr_source_c_0.set_gain(10, 0)
self.rtlsdr_source_c_0.set_if_gain(20, 0)
self.rtlsdr_source_c_0.set_bb_gain(20, 0)
self.rtlsdr_source_c_0.set_antenna("", 0)
self.rtlsdr_source_c_0.set_bandwidth(0, 0)
self.low_pass_filter_0 = gr.fir_filter_ccf(6, firdes.low_pass(
2, samp_rate, cutoff_freq, trans_width, firdes.WIN_HAMMING, 6.76))
self.blks2_wfm_rcv_0 = blks2.wfm_rcv(
quad_rate=quad_rate,
audio_decimation=4,
)
self.audio_sink_0 = audio.sink(48000, "", True)
##################################################
# Connections
##################################################
self.connect((self.low_pass_filter_0, 0), (self.blks2_wfm_rcv_0, 0))
self.connect((self.blks2_wfm_rcv_0, 0), (self.audio_sink_0, 0))
self.connect((self.rtlsdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.rtlsdr_source_c_0, 0), (self.low_pass_filter_0, 0))
def __init__(self, options, args, queue):
gr.top_block.__init__(self)
self.options = options
self.args = args
rate = int(options.rate)
use_resampler = False
if options.filename is None and options.udp is None and not options.rtlsdr:
#UHD source by default
from gnuradio import uhd
self.u = uhd.single_usrp_source("", uhd.io_type_t.COMPLEX_FLOAT32, 1)
time_spec = uhd.time_spec(0.0)
self.u.set_time_now(time_spec)
#if(options.rx_subdev_spec is None):
# options.rx_subdev_spec = ""
#self.u.set_subdev_spec(options.rx_subdev_spec)
if not options.antenna is None:
self.u.set_antenna(options.antenna)
self.u.set_samp_rate(rate)
rate = int(self.u.get_samp_rate()) #retrieve actual
if options.gain is None: #set to halfway
g = self.u.get_gain_range()
options.gain = (g.start()+g.stop()) / 2.0
if not(self.tune(options.freq)):
print "Failed to set initial frequency"
print "Setting gain to %i" % options.gain
self.u.set_gain(options.gain)
print "Gain is %i" % self.u.get_gain()
elif options.rtlsdr: #RTLSDR dongle
import osmosdr
self.u = osmosdr.source_c()
self.u.set_sample_rate(2.4e6) #fixed for RTL dongles
if not self.u.set_center_freq(options.freq):
print "Failed to set initial frequency"
self.u.set_gain_mode(0) #manual gain mode
if options.gain is None:
options.gain = 49
self.u.set_gain(options.gain)
print "Gain is %i" % self.u.get_gain()
use_resampler = True
else:
if options.filename is not None:
self.u = gr.file_source(gr.sizeof_gr_complex, options.filename)
elif options.udp is not None:
self.u = gr.udp_source(gr.sizeof_gr_complex, "localhost", options.udp)
else:
raise Exception("No valid source selected")
print "Rate is %i" % (rate,)
pass_all = 0
if options.output_all :
pass_all = 1
self.demod = gr.complex_to_mag()
self.avg = gr.moving_average_ff(100, 1.0/100, 400)
self.preamble = air_modes.modes_preamble(rate, options.threshold)
#self.framer = air_modes.modes_framer(rate)
self.slicer = air_modes.modes_slicer(rate, queue)
if use_resampler:
self.lpfiltcoeffs = gr.firdes.low_pass(1, 5*2.4e6, 1.2e6, 300e3)
self.resample = blks2.rational_resampler_ccf(interpolation=5, decimation=3, taps=self.lpfiltcoeffs)
self.connect(self.u, self.resample, self.demod)
else:
self.connect(self.u, self.demod)
self.connect(self.demod, self.avg)
self.connect(self.demod, (self.preamble, 0))
self.connect(self.avg, (self.preamble, 1))
self.connect((self.preamble, 0), (self.slicer, 0))
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] <filename>")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Rx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=32,
help="set decimation rate to DECIM [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args()
self.verbose = options.verbose
self.sample_rate = options.sample_rate
if len(args) == 0:
if self.verbose:
print "--> receiving from USRP"
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "offset_tune=1" )
self.src.set_sample_rate(self.sample_rate)
self.src.set_freq_corr(0)
# tune frequency
self.frequency = options.freq
self.orig_frequency = options.freq
self.set_freq(options.freq)
self.src.set_freq_corr(0)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
else:
if self.verbose:
print "--> receiving from file: " + args[0]
self.filename = args[0]
self.src = gr.file_source(gr.sizeof_gr_complex, self.filename, False)
self.dab_params = dab.parameters.dab_parameters(mode=options.dab_mode, sample_rate=self.sample_rate, verbose=options.verbose)
self.rx_params = dab.parameters.receiver_parameters(mode=options.dab_mode, softbits=True, input_fft_filter=options.filter_input, autocorrect_sample_rate=options.autocorrect_sample_rate, sample_rate_correction_factor=options.resample_fixed, verbose=options.verbose, correct_ffe=options.correct_ffe, equalize_magnitude=options.equalize_magnitude)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=self.verbose)
self.v2s = gr.vector_to_stream(gr.sizeof_gr_complex, self.dab_params.num_carriers)
self.trigsink = gr.null_sink(gr.sizeof_char)
self.sink = gr.null_sink(gr.sizeof_float*self.dab_params.num_carriers*2)
self.connect(self.src, self.demod, self.sink)
self.connect((self.demod,1), self.trigsink)
# retune USRP to correct FFE?
self.correct_ffe_usrp = options.correct_ffe_usrp
if self.correct_ffe_usrp:
print "--> correcting FFE on USRP"
self.run_correct_ffe_thread = True
self.ffe_updater = threading.Timer(0.1, self.correct_ffe)
self.ffe_updater.setDaemon(True)
self.ffe_updater.start()
def __init__(self,
freq=1698e6,
rate=2e6,
frames_file=os.environ['HOME'] +
'/data/noaa/frames/NOAA-XX.hrpt',
rtlsdr="rtl=0",
ifgain=20,
satellite='NOAA-XX',
sync_check=False,
rfgain=40):
grc_wxgui.top_block_gui.__init__(
self, title="Enhanced NOAA HRPT Receiver using USB DVB-T Dongles")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.freq = freq
self.rate = rate
self.frames_file = frames_file
self.rtlsdr = rtlsdr
self.ifgain = ifgain
self.satellite = satellite
self.sync_check = sync_check
self.rfgain = rfgain
##################################################
# Variables
##################################################
self.sym_rate = sym_rate = 600 * 1109
self.samp_rate = samp_rate = rate
self.config_filename = config_filename = os.environ[
'HOME'] + '/.gnuradio/rtlsdr_noaa_hrpt.conf'
self.sps = sps = samp_rate / sym_rate
self._saved_pll_alpha_config = ConfigParser.ConfigParser()
self._saved_pll_alpha_config.read(config_filename)
try:
saved_pll_alpha = self._saved_pll_alpha_config.getfloat(
satellite, 'pll_alpha')
except:
saved_pll_alpha = 0.005
self.saved_pll_alpha = saved_pll_alpha
self._saved_clock_alpha_config = ConfigParser.ConfigParser()
self._saved_clock_alpha_config.read(config_filename)
try:
saved_clock_alpha = self._saved_clock_alpha_config.getfloat(
satellite, 'clock_alpha')
except:
saved_clock_alpha = 0.001
self.saved_clock_alpha = saved_clock_alpha
self.sync_check_cb = sync_check_cb = sync_check
self._saved_rf_gain_config = ConfigParser.ConfigParser()
self._saved_rf_gain_config.read(config_filename)
try:
saved_rf_gain = self._saved_rf_gain_config.getfloat(
satellite, 'rf-gain')
except:
saved_rf_gain = rfgain
self.saved_rf_gain = saved_rf_gain
self._saved_if_gain_config = ConfigParser.ConfigParser()
self._saved_if_gain_config.read(config_filename)
try:
saved_if_gain = self._saved_if_gain_config.getfloat(
satellite, 'if-gain')
except:
saved_if_gain = ifgain
self.saved_if_gain = saved_if_gain
self.satellite_text = satellite_text = satellite
self.sample_rate_text = sample_rate_text = samp_rate
self.rf_gain_slider = rf_gain_slider = rfgain
self.rate_tb = rate_tb = rate
self.pll_alpha = pll_alpha = saved_pll_alpha
self.max_clock_offset = max_clock_offset = 0.1
self.max_carrier_offset = max_carrier_offset = 2 * math.pi * 100e3 / samp_rate
self.if_gain_slider = if_gain_slider = ifgain
self.hs = hs = int(sps / 2.0)
self.freq_tb = freq_tb = freq
self.frames_outfile_text = frames_outfile_text = frames_file
self.datetime_text = datetime_text = strftime("%A, %B %d %Y %H:%M:%S",
localtime())
self.clock_alpha = clock_alpha = saved_clock_alpha
##################################################
# Blocks
##################################################
_rf_gain_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._rf_gain_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rf_gain_slider_sizer,
value=self.rf_gain_slider,
callback=self.set_rf_gain_slider,
label="RF Gain",
converter=forms.int_converter(),
proportion=0,
)
self._rf_gain_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_rf_gain_slider_sizer,
value=self.rf_gain_slider,
callback=self.set_rf_gain_slider,
minimum=0,
maximum=100,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.GridAdd(_rf_gain_slider_sizer, 2, 0, 1, 1)
_if_gain_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._if_gain_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_if_gain_slider_sizer,
value=self.if_gain_slider,
callback=self.set_if_gain_slider,
label="IF Gain",
converter=forms.int_converter(),
proportion=0,
)
self._if_gain_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_if_gain_slider_sizer,
value=self.if_gain_slider,
callback=self.set_if_gain_slider,
minimum=0,
maximum=100,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.GridAdd(_if_gain_slider_sizer, 2, 1, 1, 1)
self.displays = self.displays = wx.Notebook(self.GetWin(),
style=wx.NB_TOP)
self.displays.AddPage(grc_wxgui.Panel(self.displays), "RX NOAA HRPT")
self.displays.AddPage(grc_wxgui.Panel(self.displays), "Information")
self.Add(self.displays)
_clock_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
self._clock_alpha_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_clock_alpha_sizer,
value=self.clock_alpha,
callback=self.set_clock_alpha,
label="Clock alpha",
converter=forms.float_converter(),
proportion=0,
)
self._clock_alpha_slider = forms.slider(
parent=self.GetWin(),
sizer=_clock_alpha_sizer,
value=self.clock_alpha,
callback=self.set_clock_alpha,
minimum=0.001,
maximum=0.1,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_clock_alpha_sizer, 2, 3, 1, 1)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.displays.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=5,
y_divs=10,
ref_level=-30,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=5,
average=True,
avg_alpha=0.4,
title="NOAA HRPT FFT Spectrum",
peak_hold=False,
)
self.displays.GetPage(0).Add(self.wxgui_fftsink2_0.win)
self._sync_check_cb_check_box = forms.check_box(
parent=self.GetWin(),
value=self.sync_check_cb,
callback=self.set_sync_check_cb,
label="Continuous sync check",
true=True,
false=False,
)
self.GridAdd(self._sync_check_cb_check_box, 1, 2, 1, 1)
self._satellite_text_static_text = forms.static_text(
parent=self.GetWin(),
value=self.satellite_text,
callback=self.set_satellite_text,
label="Satellite",
converter=forms.str_converter(),
)
self.GridAdd(self._satellite_text_static_text, 0, 1, 1, 1)
self._sample_rate_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.sample_rate_text,
callback=self.set_sample_rate_text,
label="Sample rate",
converter=forms.float_converter(),
)
self.displays.GetPage(1).GridAdd(self._sample_rate_text_static_text, 3,
0, 1, 1)
self._rate_tb_text_box = forms.text_box(
parent=self.GetWin(),
value=self.rate_tb,
callback=self.set_rate_tb,
label="Sample rate",
converter=forms.float_converter(),
)
self.GridAdd(self._rate_tb_text_box, 1, 0, 1, 1)
self.poesweather_noaa_hrpt_deframer_0 = poesweather.noaa_hrpt_deframer(
False)
_pll_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
self._pll_alpha_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_pll_alpha_sizer,
value=self.pll_alpha,
callback=self.set_pll_alpha,
label="PLL Alpha",
converter=forms.float_converter(),
proportion=0,
)
self._pll_alpha_slider = forms.slider(
parent=self.GetWin(),
sizer=_pll_alpha_sizer,
value=self.pll_alpha,
callback=self.set_pll_alpha,
minimum=0.005,
maximum=0.5,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_pll_alpha_sizer, 2, 2, 1, 1)
self.pll = noaa.hrpt_pll_cf(pll_alpha, pll_alpha**2 / 4.0,
max_carrier_offset)
self.osmosdr_source_c_0 = osmosdr.source_c(args="nchan=" + str(1) +
" " + rtlsdr)
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(rf_gain_slider, 0)
self.osmosdr_source_c_0.set_if_gain(if_gain_slider, 0)
self._freq_tb_text_box = forms.text_box(
parent=self.GetWin(),
value=self.freq_tb,
callback=self.set_freq_tb,
label="Frequency",
converter=forms.float_converter(),
)
self.GridAdd(self._freq_tb_text_box, 1, 1, 1, 1)
self._frames_outfile_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.frames_outfile_text,
callback=self.set_frames_outfile_text,
label="Frames filename",
converter=forms.str_converter(),
)
self.displays.GetPage(1).GridAdd(self._frames_outfile_text_static_text,
4, 0, 1, 1)
self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(
sps / 2.0, clock_alpha**2 / 4.0, 0.5, clock_alpha,
max_clock_offset)
self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb()
self._datetime_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.datetime_text,
callback=self.set_datetime_text,
label="Acquisition start",
converter=forms.str_converter(),
)
self.displays.GetPage(1).GridAdd(self._datetime_text_static_text, 2, 0,
1, 1)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(
hs, 1.0 / hs, 4000)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_short * 1,
frames_file)
self.blocks_file_sink_0.set_unbuffered(False)
self.analog_agc_xx_0 = analog.agc_cc(1e-5, 1.0, 1.0 / 32768.0, 1.0)
##################################################
# Connections
##################################################
self.connect((self.analog_agc_xx_0, 0), (self.pll, 0))
self.connect((self.pll, 0), (self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.digital_clock_recovery_mm_xx_0, 0))
self.connect((self.digital_clock_recovery_mm_xx_0, 0),
(self.digital_binary_slicer_fb_0, 0))
self.connect((self.poesweather_noaa_hrpt_deframer_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.digital_binary_slicer_fb_0, 0),
(self.poesweather_noaa_hrpt_deframer_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.analog_agc_xx_0, 0))
def __init__(self, options, queue):
gr.top_block.__init__(self, "flex_hackrf")
# Set up HackRF source
self.u = osmosdr.source_c(args="nchan=" + str(1) + " ")
# Tune hackRF
r = self.u.set_center_freq(options.freq+options.calibration, 0)
if not r:
frange = self.u.get_freq_range()
sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \
(freq, frange.start(), frange.stop()))
sys.exit(1)
if options.verbose:
print "Tuned to center frequency", (options.freq+options.calibration)/1e6, "MHz"
# if no gain was specified, use the mid-point in dB
if options.rx_gain is None:
grange = self.u.get_gain_range()
options.rx_gain = float(grange.start()+grange.stop())/2.0
print "\nNo gain specified."
print "Setting gain to %f (from [%f, %f])" % \
(options.rx_gain, grange.start(), grange.stop())
self.u.set_gain(options.rx_gain, 0)
# Grab >=3 MHz of spectrum, evenly divisible by 25 KHz channels
# (A UHD facility to get sample rate range and granularity would be useful)
self.u.set_sample_rate(3.125e6) # Works if USRP is 100 Msps and can decimate by 32
rate = self.u.get_sample_rate()
if rate != 3.125e6:
self.u.set_sample_rate(3.2e6) # Works if USRP is 64 Msps and can decimate by 20
rate = self.u.get_sample_rate()
if (rate != 3.2e6):
print "Unable to set required sample rate for >= 3MHz of 25 KHz channels."
sys.exit(1)
self.nchan = int(rate/25e3)
if options.verbose:
print "\nReceiving", rate/1e6, "MHz of bandwidth containing", self.nchan, "baseband channels."
taps = gr.firdes.low_pass(1.0,
1.0,
1.0/self.nchan*0.4,
1.0/self.nchan*0.1,
gr.firdes.WIN_HANN)
if options.verbose:
print "Channel filter has", len(taps), "taps"
self.bank = blks2.analysis_filterbank(self.nchan, taps)
self.connect(self.u, self.bank)
mid_chan = int(self.nchan/2)
for i in range(self.nchan):
if i < mid_chan:
freq = options.freq+i*25e3
else:
freq = options.freq-(self.nchan-i)*25e3
if (freq < 929.0e6 or freq > 932.0e6):
self.connect((self.bank, i), gr.null_sink(gr.sizeof_gr_complex))
else:
self.connect((self.bank, i), pager.flex_demod(queue, freq, options.verbose))
def __init__(self, freq=1698e6, rate=2e6, frames_file=os.environ['HOME'] + '/data/noaa/frames/NOAA-XX.hrpt', rtlsdr="rtl=0", ifgain=20, satellite='NOAA-XX', sync_check=False, rfgain=40):
grc_wxgui.top_block_gui.__init__(self, title="Enhanced NOAA HRPT Receiver using USB DVB-T Dongles")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.freq = freq
self.rate = rate
self.frames_file = frames_file
self.rtlsdr = rtlsdr
self.ifgain = ifgain
self.satellite = satellite
self.sync_check = sync_check
self.rfgain = rfgain
##################################################
# Variables
##################################################
self.sym_rate = sym_rate = 600*1109
self.samp_rate = samp_rate = rate
self.config_filename = config_filename = os.environ['HOME']+'/.gnuradio/rtlsdr_noaa_hrpt.conf'
self.sps = sps = samp_rate/sym_rate
self._saved_pll_alpha_config = ConfigParser.ConfigParser()
self._saved_pll_alpha_config.read(config_filename)
try: saved_pll_alpha = self._saved_pll_alpha_config.getfloat(satellite, 'pll_alpha')
except: saved_pll_alpha = 0.005
self.saved_pll_alpha = saved_pll_alpha
self._saved_clock_alpha_config = ConfigParser.ConfigParser()
self._saved_clock_alpha_config.read(config_filename)
try: saved_clock_alpha = self._saved_clock_alpha_config.getfloat(satellite, 'clock_alpha')
except: saved_clock_alpha = 0.001
self.saved_clock_alpha = saved_clock_alpha
self.sync_check_cb = sync_check_cb = sync_check
self._saved_rf_gain_config = ConfigParser.ConfigParser()
self._saved_rf_gain_config.read(config_filename)
try: saved_rf_gain = self._saved_rf_gain_config.getfloat(satellite, 'rf-gain')
except: saved_rf_gain = rfgain
self.saved_rf_gain = saved_rf_gain
self._saved_if_gain_config = ConfigParser.ConfigParser()
self._saved_if_gain_config.read(config_filename)
try: saved_if_gain = self._saved_if_gain_config.getfloat(satellite, 'if-gain')
except: saved_if_gain = ifgain
self.saved_if_gain = saved_if_gain
self.satellite_text = satellite_text = satellite
self.sample_rate_text = sample_rate_text = samp_rate
self.rf_gain_slider = rf_gain_slider = rfgain
self.rate_tb = rate_tb = rate
self.pll_alpha = pll_alpha = saved_pll_alpha
self.max_clock_offset = max_clock_offset = 0.1
self.max_carrier_offset = max_carrier_offset = 2*math.pi*100e3/samp_rate
self.if_gain_slider = if_gain_slider = ifgain
self.hs = hs = int(sps/2.0)
self.freq_tb = freq_tb = freq
self.frames_outfile_text = frames_outfile_text = frames_file
self.datetime_text = datetime_text = strftime("%A, %B %d %Y %H:%M:%S", localtime())
self.clock_alpha = clock_alpha = saved_clock_alpha
##################################################
# Blocks
##################################################
_rf_gain_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._rf_gain_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rf_gain_slider_sizer,
value=self.rf_gain_slider,
callback=self.set_rf_gain_slider,
label="RF Gain",
converter=forms.int_converter(),
proportion=0,
)
self._rf_gain_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_rf_gain_slider_sizer,
value=self.rf_gain_slider,
callback=self.set_rf_gain_slider,
minimum=0,
maximum=100,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.GridAdd(_rf_gain_slider_sizer, 2, 0, 1, 1)
_if_gain_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._if_gain_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_if_gain_slider_sizer,
value=self.if_gain_slider,
callback=self.set_if_gain_slider,
label="IF Gain",
converter=forms.int_converter(),
proportion=0,
)
self._if_gain_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_if_gain_slider_sizer,
value=self.if_gain_slider,
callback=self.set_if_gain_slider,
minimum=0,
maximum=100,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=int,
proportion=1,
)
self.GridAdd(_if_gain_slider_sizer, 2, 1, 1, 1)
self.displays = self.displays = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.displays.AddPage(grc_wxgui.Panel(self.displays), "RX NOAA HRPT")
self.displays.AddPage(grc_wxgui.Panel(self.displays), "Information")
self.Add(self.displays)
_clock_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
self._clock_alpha_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_clock_alpha_sizer,
value=self.clock_alpha,
callback=self.set_clock_alpha,
label="Clock alpha",
converter=forms.float_converter(),
proportion=0,
)
self._clock_alpha_slider = forms.slider(
parent=self.GetWin(),
sizer=_clock_alpha_sizer,
value=self.clock_alpha,
callback=self.set_clock_alpha,
minimum=0.001,
maximum=0.1,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_clock_alpha_sizer, 2, 3, 1, 1)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.displays.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=5,
y_divs=10,
ref_level=-30,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=5,
average=True,
avg_alpha=0.4,
title="NOAA HRPT FFT Spectrum",
peak_hold=False,
)
self.displays.GetPage(0).Add(self.wxgui_fftsink2_0.win)
self._sync_check_cb_check_box = forms.check_box(
parent=self.GetWin(),
value=self.sync_check_cb,
callback=self.set_sync_check_cb,
label="Continuous sync check",
true=True,
false=False,
)
self.GridAdd(self._sync_check_cb_check_box, 1, 2, 1, 1)
self._satellite_text_static_text = forms.static_text(
parent=self.GetWin(),
value=self.satellite_text,
callback=self.set_satellite_text,
label="Satellite",
converter=forms.str_converter(),
)
self.GridAdd(self._satellite_text_static_text, 0, 1, 1, 1)
self._sample_rate_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.sample_rate_text,
callback=self.set_sample_rate_text,
label="Sample rate",
converter=forms.float_converter(),
)
self.displays.GetPage(1).GridAdd(self._sample_rate_text_static_text, 3, 0, 1, 1)
self._rate_tb_text_box = forms.text_box(
parent=self.GetWin(),
value=self.rate_tb,
callback=self.set_rate_tb,
label="Sample rate",
converter=forms.float_converter(),
)
self.GridAdd(self._rate_tb_text_box, 1, 0, 1, 1)
self.poesweather_noaa_hrpt_deframer_0 = poesweather.noaa_hrpt_deframer(False)
_pll_alpha_sizer = wx.BoxSizer(wx.VERTICAL)
self._pll_alpha_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_pll_alpha_sizer,
value=self.pll_alpha,
callback=self.set_pll_alpha,
label="PLL Alpha",
converter=forms.float_converter(),
proportion=0,
)
self._pll_alpha_slider = forms.slider(
parent=self.GetWin(),
sizer=_pll_alpha_sizer,
value=self.pll_alpha,
callback=self.set_pll_alpha,
minimum=0.005,
maximum=0.5,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_pll_alpha_sizer, 2, 2, 1, 1)
self.pll = noaa.hrpt_pll_cf(pll_alpha, pll_alpha**2/4.0, max_carrier_offset)
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + rtlsdr )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(rf_gain_slider, 0)
self.osmosdr_source_c_0.set_if_gain(if_gain_slider, 0)
self._freq_tb_text_box = forms.text_box(
parent=self.GetWin(),
value=self.freq_tb,
callback=self.set_freq_tb,
label="Frequency",
converter=forms.float_converter(),
)
self.GridAdd(self._freq_tb_text_box, 1, 1, 1, 1)
self._frames_outfile_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.frames_outfile_text,
callback=self.set_frames_outfile_text,
label="Frames filename",
converter=forms.str_converter(),
)
self.displays.GetPage(1).GridAdd(self._frames_outfile_text_static_text, 4, 0, 1, 1)
self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(sps/2.0, clock_alpha**2/4.0, 0.5, clock_alpha, max_clock_offset)
self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb()
self._datetime_text_static_text = forms.static_text(
parent=self.displays.GetPage(1).GetWin(),
value=self.datetime_text,
callback=self.set_datetime_text,
label="Acquisition start",
converter=forms.str_converter(),
)
self.displays.GetPage(1).GridAdd(self._datetime_text_static_text, 2, 0, 1, 1)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(hs, 1.0/hs, 4000)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_short*1, frames_file)
self.blocks_file_sink_0.set_unbuffered(False)
self.analog_agc_xx_0 = analog.agc_cc(1e-5, 1.0, 1.0/32768.0, 1.0)
##################################################
# Connections
##################################################
self.connect((self.analog_agc_xx_0, 0), (self.pll, 0))
self.connect((self.pll, 0), (self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0), (self.digital_clock_recovery_mm_xx_0, 0))
self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0))
self.connect((self.poesweather_noaa_hrpt_deframer_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.digital_binary_slicer_fb_0, 0), (self.poesweather_noaa_hrpt_deframer_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.analog_agc_xx_0, 0))
def __init__(self, options, args, queue):
gr.top_block.__init__(self)
self.options = options
self.args = args
self.rate = int(options.rate)
if options.filename is None and options.udp is None and not options.rtlsdr:
#UHD source by default
from gnuradio import uhd
self.u = uhd.single_usrp_source(options.args, uhd.io_type_t.COMPLEX_FLOAT32, 1)
time_spec = uhd.time_spec(0.0)
self.u.set_time_now(time_spec)
#if(options.rx_subdev_spec is None):
# options.rx_subdev_spec = ""
#self.u.set_subdev_spec(options.rx_subdev_spec)
if not options.antenna is None:
self.u.set_antenna(options.antenna)
self.u.set_samp_rate(rate)
self.rate = int(self.u.get_samp_rate()) #retrieve actual
if options.gain is None: #set to halfway
g = self.u.get_gain_range()
options.gain = (g.start()+g.stop()) / 2.0
if not(self.tune(options.freq)):
print "Failed to set initial frequency"
print "Setting gain to %i" % options.gain
self.u.set_gain(options.gain)
print "Gain is %i" % self.u.get_gain()
elif options.rtlsdr: #RTLSDR dongle
import osmosdr
self.u = osmosdr.source_c(options.args)
self.u.set_sample_rate(2.4e6) #fixed for RTL dongles
if not self.u.set_center_freq(options.centerfreq - options.error):
print "Failed to set initial frequency"
self.u.set_gain_mode(0) #manual gain mode
if options.gain is None:
options.gain = 25#34
self.u.set_gain(options.gain)
print "Gain is %i" % self.u.get_gain()
use_resampler = True
self.rate=2.4e6
else:
if options.filename is not None:
self.u = gr.file_source(gr.sizeof_gr_complex, options.filename)
elif options.udp is not None:
self.u = gr.udp_source(gr.sizeof_gr_complex, "localhost", options.udp)
else:
raise Exception("No valid source selected")
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_tag_bb("10101100",0,"smartnet_preamble") #should mark start of packet #digital.
#self.start_correlator = digital.correlate_access_code_bb("10101100",0) #should mark start of packet #digital.
# self.smartnet_sync = smartnet.sync()
self.smartnet_deinterleave = smartnet.deinterleave()
# self.smartnet_parity = smartnet.parity()
self.smartnet_crc = smartnet.crc(queue)
# 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.smartnet_sync, self.smartnet_parity,
self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc)#, self.smartnet_packetize, self.parse)
def __init__(self, ahw="default", freq=150.0e6, ppm=0.0, vol=1.0, ftune=0.0, xftune=0.0, srate=1.0e6, upclo=0.0, devinfo="rtl=0", agc=0, arate=48.0e3, upce=0, mthresh=-10.0, offs=50.e3, flist="", dfifo="multimode_fifo", mbw=2.0e3, deemph=75.0e-6, dmode="NFM1"):
grc_wxgui.top_block_gui.__init__(self, title="Multimode Radio Receiver")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.ahw = ahw
self.freq = freq
self.ppm = ppm
self.vol = vol
self.ftune = ftune
self.xftune = xftune
self.srate = srate
self.upclo = upclo
self.devinfo = devinfo
self.agc = agc
self.arate = arate
self.upce = upce
self.mthresh = mthresh
self.offs = offs
self.flist = flist
self.dfifo = dfifo
self.mbw = mbw
self.deemph = deemph
self.dmode = dmode
##################################################
# Variables
##################################################
self.sc_list_str = sc_list_str = flist
self.zoom = zoom = 1
self.thresh = thresh = mthresh
self.scan_rate = scan_rate = 15
self.scan_power = scan_power = 0
self.sc_low = sc_low = 150e6
self.sc_listm = sc_listm = False
self.sc_list = sc_list = eval("["+sc_list_str+"]")
self.sc_incr = sc_incr = 12.5e3
self.sc_high = sc_high = 300e6
self.sc_ena = sc_ena = False
self.samp_rate = samp_rate = int(mh.get_good_rate(devinfo,srate))
self.rf_power = rf_power = 0
self.ifreq = ifreq = freq
self.zoomed_lp = zoomed_lp = (samp_rate/2.1)/zoom
self.wbfm = wbfm = 200e3
self.rf_d_power = rf_d_power = 0
self.mode = mode = dmode
self.logpower = logpower = math.log10(rf_power+1.0e-14)*10.0
self.cur_freq = cur_freq = mh.scan_freq_out(sc_ena,sc_low,sc_high,freq,ifreq,scan_power+1.0e-14,thresh,sc_incr,scan_rate,sc_listm,sc_list)
self.bw = bw = mbw
self.audio_int_rate = audio_int_rate = 40e3
self.zoom_taps = zoom_taps = firdes.low_pass(1.0,samp_rate,zoomed_lp,zoomed_lp/3,firdes.WIN_HAMMING,6.76)
self.xfine = xfine = xftune
self.volume = volume = vol
self.variable_static_text_1 = variable_static_text_1 = cur_freq
self.variable_static_text_0_0 = variable_static_text_0_0 = samp_rate
self.variable_static_text_0 = variable_static_text_0 = float(int(math.log10(rf_d_power+1.0e-14)*100.0)/10.0)
self.upc_offset = upc_offset = upclo
self.upc = upc = upce
self.ssbo = ssbo = -bw/2 if mode == "LSB" else 0.0
self.sc_list_len = sc_list_len = len(sc_list)
self.rfgain = rfgain = 25
self.record_file = record_file = "recording.wav"
self.record = record = False
self.offset = offset = offs
self.muted = muted = 0.0 if logpower >= thresh else 1
self.main_taps = main_taps = firdes.low_pass(1.0,wbfm,mh.get_mode_deviation(mode,bw)*1.05,mh.get_mode_deviation(mode,bw)/2.0,firdes.WIN_HAMMING,6.76)
self.k = k = wbfm/(2*math.pi*mh.get_mode_deviation(mode,bw))
self.iagc = iagc = agc
self.freq_update = freq_update = 0
self.fine = fine = ftune
self.digi_rate = digi_rate = 50e3
self.aratio = aratio = int(wbfm/audio_int_rate)
##################################################
# Blocks
##################################################
self.rf_probe = gr.probe_avg_mag_sqrd_c(0, 0.015)
self.Main = self.Main = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Main Controls")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Scan/Upconv Controls")
self.Add(self.Main)
self._zoom_chooser = forms.drop_down(
parent=self.Main.GetPage(0).GetWin(),
value=self.zoom,
callback=self.set_zoom,
label="Spectral Zoom Ratio",
choices=[1, 2, 5, 10, 20, 50, 100],
labels=[],
)
self.Main.GetPage(0).GridAdd(self._zoom_chooser, 1, 4, 1, 1)
_xfine_sizer = wx.BoxSizer(wx.VERTICAL)
self._xfine_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_xfine_sizer,
value=self.xfine,
callback=self.set_xfine,
label="Extra Fine Tuning",
converter=forms.float_converter(),
proportion=0,
)
self._xfine_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_xfine_sizer,
value=self.xfine,
callback=self.set_xfine,
minimum=-1.0e3,
maximum=1.0e3,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_xfine_sizer, 0, 3, 1, 1)
_volume_sizer = wx.BoxSizer(wx.VERTICAL)
self._volume_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
label="Volume",
converter=forms.float_converter(),
proportion=0,
)
self._volume_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_volume_sizer,
value=self.volume,
callback=self.set_volume,
minimum=1.0,
maximum=10.0,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_volume_sizer, 0, 0, 1, 1)
self._upc_offset_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.upc_offset,
callback=self.set_upc_offset,
label="Upconv. LO Freq",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._upc_offset_text_box, 3, 2, 1, 2)
self._upc_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.upc,
callback=self.set_upc,
label="Ext. Upconv.",
true=1,
false=0,
)
self.Main.GetPage(1).GridAdd(self._upc_check_box, 3, 0, 1, 1)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=self.set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=self.set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_rfgain_sizer, 2, 1, 1, 1)
self._record_file_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.record_file,
callback=self.set_record_file,
label="Recording Filename",
converter=forms.str_converter(),
)
self.Main.GetPage(0).GridAdd(self._record_file_text_box, 2, 3, 1, 3)
self._record_check_box = forms.check_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.record,
callback=self.set_record,
label="Record",
true=True,
false=False,
)
self.Main.GetPage(0).GridAdd(self._record_check_box, 2, 2, 1, 1)
_offset_sizer = wx.BoxSizer(wx.VERTICAL)
self._offset_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
label="LO Offset",
converter=forms.float_converter(),
proportion=0,
)
self._offset_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_offset_sizer,
value=self.offset,
callback=self.set_offset,
minimum=25e3,
maximum=500e3,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_offset_sizer, 1, 3, 1, 1)
self._mode_chooser = forms.drop_down(
parent=self.Main.GetPage(0).GetWin(),
value=self.mode,
callback=self.set_mode,
label="Mode",
choices=mh.get_modes_values(),
labels=mh.get_modes_names(),
)
self.Main.GetPage(0).GridAdd(self._mode_chooser, 0, 4, 1, 1)
self._iagc_check_box = forms.check_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.iagc,
callback=self.set_iagc,
label="AGC",
true=1,
false=0,
)
self.Main.GetPage(0).GridAdd(self._iagc_check_box, 2, 0, 1, 1)
def _freq_update_probe():
while True:
val = self.rf_probe.level()
try: self.set_freq_update(val)
except AttributeError, e: pass
time.sleep(1.0/(1.0/(2.5)))
_freq_update_thread = threading.Thread(target=_freq_update_probe)
_freq_update_thread.daemon = True
_freq_update_thread.start()
_fine_sizer = wx.BoxSizer(wx.VERTICAL)
self._fine_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
label="Fine Tuning",
converter=forms.float_converter(),
proportion=0,
)
self._fine_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_fine_sizer,
value=self.fine,
callback=self.set_fine,
minimum=-35e3,
maximum=35e3,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_fine_sizer, 0, 2, 1, 1)
self.display_probe = gr.probe_avg_mag_sqrd_c(0, 0.002)
_bw_sizer = wx.BoxSizer(wx.VERTICAL)
self._bw_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_bw_sizer,
value=self.bw,
callback=self.set_bw,
label="AM/SSB Bandwidth",
converter=forms.float_converter(),
proportion=0,
)
self._bw_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_bw_sizer,
value=self.bw,
callback=self.set_bw,
minimum=1.0e3,
maximum=audio_int_rate/2,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_bw_sizer, 1, 2, 1, 1)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c(
self.Main.GetPage(0).GetWin(),
baseband_freq=mh.get_last_returned(freq_update),
dynamic_range=40,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate/zoom,
fft_size=1024,
fft_rate=4,
average=True,
avg_alpha=None,
title="Spectrogram",
win=window.hamming,
)
self.Main.GetPage(0).Add(self.wxgui_waterfallsink2_0.win)
def wxgui_waterfallsink2_0_callback(x, y):
self.set_freq(x)
self.wxgui_waterfallsink2_0.set_callback(wxgui_waterfallsink2_0_callback)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.Main.GetPage(0).GetWin(),
baseband_freq=mh.get_last_returned(freq_update),
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate/zoom,
fft_size=1024,
fft_rate=4,
average=True,
avg_alpha=0.1,
title="Panorama",
peak_hold=False,
win=window.hamming,
)
self.Main.GetPage(0).Add(self.wxgui_fftsink2_0.win)
def wxgui_fftsink2_0_callback(x, y):
self.set_freq(x)
self.wxgui_fftsink2_0.set_callback(wxgui_fftsink2_0_callback)
self._variable_static_text_1_static_text = forms.static_text(
parent=self.Main.GetPage(1).GetWin(),
value=self.variable_static_text_1,
callback=self.set_variable_static_text_1,
label="Current Scan Freq",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._variable_static_text_1_static_text, 0, 5, 1, 2)
self._variable_static_text_0_0_static_text = forms.static_text(
parent=self.Main.GetPage(0).GetWin(),
value=self.variable_static_text_0_0,
callback=self.set_variable_static_text_0_0,
label="Actual srate",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._variable_static_text_0_0_static_text, 1, 5, 1, 1)
self._variable_static_text_0_static_text = forms.static_text(
parent=self.Main.GetPage(0).GetWin(),
value=self.variable_static_text_0,
callback=self.set_variable_static_text_0,
label="RF Level",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._variable_static_text_0_static_text, 1, 0, 1, 1)
_thresh_sizer = wx.BoxSizer(wx.VERTICAL)
self._thresh_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
label="Mute Threshold",
converter=forms.float_converter(),
proportion=0,
)
self._thresh_slider = forms.slider(
parent=self.Main.GetPage(0).GetWin(),
sizer=_thresh_sizer,
value=self.thresh,
callback=self.set_thresh,
minimum=-50,
maximum=10,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Main.GetPage(0).GridAdd(_thresh_sizer, 1, 1, 1, 1)
def _scan_power_probe():
while True:
val = self.rf_probe.level()
try: self.set_scan_power(val)
except AttributeError, e: pass
time.sleep(1.0/(scan_rate))
_scan_power_thread = threading.Thread(target=_scan_power_probe)
_scan_power_thread.daemon = True
_scan_power_thread.start()
self._sc_low_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_low,
callback=self.set_sc_low,
label="Scan Low",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_low_text_box, 0, 1, 1, 1)
self._sc_listm_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_listm,
callback=self.set_sc_listm,
label="Scan List Mode",
true=True,
false=False,
)
self.Main.GetPage(1).GridAdd(self._sc_listm_check_box, 2, 0, 1, 1)
self._sc_list_str_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_list_str,
callback=self.set_sc_list_str,
label="Scan List",
converter=forms.str_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_list_str_text_box, 2, 1, 1, 5)
self._sc_incr_chooser = forms.drop_down(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_incr,
callback=self.set_sc_incr,
label="Scan Increment (Hz)",
choices=[5.0e3,6.25e3,10.0e3,12.5e3,15e3,25e3],
labels=[],
)
self.Main.GetPage(1).GridAdd(self._sc_incr_chooser, 0, 0, 1, 1)
self._sc_high_text_box = forms.text_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_high,
callback=self.set_sc_high,
label="Scan High",
converter=forms.float_converter(),
)
self.Main.GetPage(1).GridAdd(self._sc_high_text_box, 0, 2, 1, 1)
self._sc_ena_check_box = forms.check_box(
parent=self.Main.GetPage(1).GetWin(),
value=self.sc_ena,
callback=self.set_sc_ena,
label="Scan Enable",
true=True,
false=False,
)
self.Main.GetPage(1).GridAdd(self._sc_ena_check_box, 0, 3, 1, 1)
def _rf_power_probe():
while True:
val = self.rf_probe.level()
try: self.set_rf_power(val)
except AttributeError, e: pass
time.sleep(1.0/(10))
_rf_power_thread = threading.Thread(target=_rf_power_probe)
_rf_power_thread.daemon = True
_rf_power_thread.start()
def _rf_d_power_probe():
while True:
val = self.display_probe.level()
try: self.set_rf_d_power(val)
except AttributeError, e: pass
time.sleep(1.0/(5))
_rf_d_power_thread = threading.Thread(target=_rf_d_power_probe)
_rf_d_power_thread.daemon = True
_rf_d_power_thread.start()
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + devinfo )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(cur_freq+offset+(upc_offset*float(upc)), 0)
self.osmosdr_source_c_0.set_freq_corr(ppm, 0)
self.osmosdr_source_c_0.set_gain_mode(iagc, 0)
self.osmosdr_source_c_0.set_gain(25 if iagc == 1 else rfgain, 0)
self.osmosdr_source_c_0.set_if_gain(20, 0)
self._ifreq_text_box = forms.text_box(
parent=self.Main.GetPage(0).GetWin(),
value=self.ifreq,
callback=self.set_ifreq,
label="Frequency",
converter=forms.float_converter(),
)
self.Main.GetPage(0).GridAdd(self._ifreq_text_box, 0, 1, 1, 1)
self.gr_wavfile_sink_0 = gr.wavfile_sink("/dev/null" if record == False else record_file, 1, int(audio_int_rate), 8)
self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(k)
self.gr_multiply_const_vxx_2 = gr.multiply_const_vff((1.0 if mh.get_mode_type(mode) == "FM" else 0.0, ))
self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((0.0 if muted else volume/4.5, ))
self.gr_multiply_const_vxx_0_0_0 = gr.multiply_const_vff((0.85 if mh.get_mode_type(mode) == "AM" else 0.0, ))
self.gr_multiply_const_vxx_0_0 = gr.multiply_const_vff((0.85 if mh.get_mode_type(mode) == "SSB" else 0.0, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc(((1.0/math.sqrt(mh.get_mode_deviation(mode,bw))*250), ))
self.gr_keep_one_in_n_1 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, aratio)
self.gr_keep_one_in_n_0_0 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, zoom)
self.gr_keep_one_in_n_0 = gr.keep_one_in_n(gr.sizeof_gr_complex*1, int(wbfm/digi_rate))
self.gr_freq_xlating_fir_filter_xxx_0_1 = gr.freq_xlating_fir_filter_ccc(1, (1.0, ), (offset+fine+xfine)/(samp_rate/1.0e6), samp_rate)
self.gr_fractional_interpolator_xx_0 = gr.fractional_interpolator_ff(0, audio_int_rate/arate)
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_gr_complex*1, "/dev/null" if mh.get_mode_type(mode) != "DIG" else dfifo)
self.gr_file_sink_0.set_unbuffered(True)
self.gr_fft_filter_xxx_3 = gr.fft_filter_ccc(1, (zoom_taps), 1)
self.gr_fft_filter_xxx_2_0 = gr.fft_filter_fff(5, (firdes.low_pass(1.0,wbfm,14.5e3,8.5e3,firdes.WIN_HAMMING,6.76)), 1)
self.gr_fft_filter_xxx_2 = gr.fft_filter_ccc(1, (main_taps), 1)
self.gr_fft_filter_xxx_0 = gr.fft_filter_ccc(int(samp_rate/wbfm), (firdes.low_pass(1.0,samp_rate,98.5e3,66e3,firdes.WIN_HAMMING,6.76)), 1)
self.gr_feedforward_agc_cc_0 = gr.feedforward_agc_cc(1024, 0.75)
self.gr_complex_to_real_0 = gr.complex_to_real(1)
self.gr_complex_to_mag_squared_0 = gr.complex_to_mag_squared(1)
self.gr_add_xx_0 = gr.add_vff(1)
self.blks2_fm_deemph_0 = blks2.fm_deemph(fs=audio_int_rate, tau=deemph)
self.audio_sink_0 = audio.sink(int(arate), ahw, True)
##################################################
# Connections
##################################################
self.connect((self.gr_multiply_const_vxx_0_0, 0), (self.gr_add_xx_0, 1))
self.connect((self.gr_fractional_interpolator_xx_0, 0), (self.gr_multiply_const_vxx_1, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 0))
self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1))
self.connect((self.gr_feedforward_agc_cc_0, 0), (self.gr_complex_to_mag_squared_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.gr_freq_xlating_fir_filter_xxx_0_1, 0))
self.connect((self.gr_multiply_const_vxx_0_0_0, 0), (self.gr_add_xx_0, 2))
self.connect((self.gr_feedforward_agc_cc_0, 0), (self.gr_complex_to_real_0, 0))
self.connect((self.gr_complex_to_real_0, 0), (self.gr_multiply_const_vxx_0_0, 0))
self.connect((self.gr_multiply_const_vxx_2, 0), (self.gr_add_xx_0, 0))
self.connect((self.gr_complex_to_mag_squared_0, 0), (self.gr_multiply_const_vxx_0_0_0, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.display_probe, 0))
self.connect((self.gr_multiply_const_vxx_0, 0), (self.rf_probe, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_fractional_interpolator_xx_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_wavfile_sink_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0_1, 0), (self.gr_fft_filter_xxx_0, 0))
self.connect((self.gr_keep_one_in_n_0, 0), (self.gr_file_sink_0, 0))
self.connect((self.gr_freq_xlating_fir_filter_xxx_0_1, 0), (self.gr_fft_filter_xxx_3, 0))
self.connect((self.gr_fft_filter_xxx_3, 0), (self.gr_keep_one_in_n_0_0, 0))
self.connect((self.gr_keep_one_in_n_0_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_keep_one_in_n_0_0, 0), (self.wxgui_waterfallsink2_0, 0))
self.connect((self.blks2_fm_deemph_0, 0), (self.gr_multiply_const_vxx_2, 0))
self.connect((self.gr_quadrature_demod_cf_0, 0), (self.gr_fft_filter_xxx_2_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_keep_one_in_n_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_multiply_const_vxx_0, 0))
self.connect((self.gr_fft_filter_xxx_0, 0), (self.gr_fft_filter_xxx_2, 0))
self.connect((self.gr_keep_one_in_n_1, 0), (self.gr_feedforward_agc_cc_0, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_keep_one_in_n_1, 0))
self.connect((self.gr_fft_filter_xxx_2, 0), (self.gr_quadrature_demod_cf_0, 0))
self.connect((self.gr_fft_filter_xxx_2_0, 0), (self.blks2_fm_deemph_0, 0))
self.synchronizer_callback = synchronizer(self)
self.converter = gr.vector_to_stream(gr.sizeof_float, 142)
self.atcmd = "AT"
self.imsi = "000000000000000"
self.tmsi = "00000000"
self.key = "0000000000000000"
self.nokey = "0000000000000000"
self.samprate = int(options.sample_rate)
self.ifreq = options.frequency
self.rfgain = options.gain
self.ppm = 0.0
self.src = osmosdr.source_c(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
self.chan = options.configuration.upper()
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.ifreq = options.frequency
self.rfgain = options.gain
self.offset = options.frequency_offset
self.src = osmosdr.source_c(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
symbol_rate = 18000
sps = 2 # output rate will be 36,000
out_sample_rate = symbol_rate * sps
options.low_pass = options.low_pass / 2.0
if sample_rate == 96000: # FunCube Dongle
first_decim = 2
else:
first_decim = 10
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass, options.low_pass * 0.2, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(first_decim, taps, self.offset, sample_rate)
self.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)
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
rerate = float(sample_rate / float(first_decim)) / float(out_sample_rate)
sys.stderr.write("resampling factor: %f\n" % rerate)
if rerate.is_integer():
sys.stderr.write("using pfb decimator\n")
self.resamp = blks2.pfb_decimator_ccf(int(rerate))
else:
sys.stderr.write("using pfb resampler\n")
self.resamp = blks2.pfb_arb_resampler_ccf(1 / rerate)
self.connect(self.src, self.tuner, self.resamp, self.demod, self.output)
self.Main = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Wideband Spectrum")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Channel Spectrum")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Soft Bits")
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
self.Add(self.Main)
def fftsink2_callback(x, y):
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
self.offset = -x
sys.stderr.write("coarse tuned to: %d Hz => %d Hz\n" % (self.offset, (self.ifreq + self.offset)))
self.tuner.set_center_freq(self.offset)
self.scope = fftsink2.fft_sink_c(self.Main.GetPage(0).GetWin(),
title="Wideband Spectrum (click to coarse tune)",
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.6)
self.Main.GetPage(0).Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz => %d Hz\n" % (self.offset, (self.ifreq + self.offset)))
self.tuner.set_center_freq(self.offset)
self.scope2 = fftsink2.fft_sink_c(self.Main.GetPage(1).GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=out_sample_rate,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.6)
self.Main.GetPage(1).Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.resamp, self.scope2)
self.scope3 = scopesink2.scope_sink_f(
self.Main.GetPage(2).GetWin(),
title="Soft Bits",
sample_rate=out_sample_rate,
v_scale=0,
v_offset=0,
t_scale=0.001,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.Main.GetPage(2).Add(self.scope3.win)
self.connect(self.demod, self.scope3)
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] output-filename")
parser.add_option("-m", "--dab-mode", type="int", default=1,
help="DAB mode [default=%default]")
parser.add_option("-F", "--filter-input", action="store_true", default=False,
help="Enable FFT filter at input")
parser.add_option('-c', '--correct-ffe', action="store_true", default=False,
help="do fine frequency correction")
parser.add_option('-u', '--correct-ffe-usrp', action="store_true", default=False,
help="do fine frequency correction by retuning the USRP instead of in software")
parser.add_option('-e', '--equalize-magnitude', action="store_true", default=False,
help="do magnitude equalization")
parser.add_option("-s", "--resample-fixed", type="eng_float", default=1,
help="resample by a fixed factor (fractional interpolation)")
parser.add_option("-S", "--autocorrect-sample-rate", action="store_true", default=False,
help="Estimate sample rate offset and resample (dynamic fractional interpolation)")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-r", "--sample-rate", type="int", default=2000000,
help="set sample rate to SAMPLE_RATE [default=%default]")
parser.add_option("-g", "--rx-gain", type="eng_float", default=None,
help="set receive gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
# if len(args)!=1:
# parser.print_help()
# sys.exit(1)
# else:
# self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
self.verbose = options.verbose
self.sample_rate = sample_rate = options.sample_rate
self.src = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.src.set_sample_rate(sample_rate)
#self.src.set_center_freq(209.936e6, 0)
self.src.set_freq_corr(0, 0)
self.src.set_gain_mode(1, 0)
self.src.set_gain(0, 0)
self.dab_params = dab.parameters.dab_parameters(
mode=options.dab_mode,
sample_rate=self.sample_rate,
verbose=options.verbose
)
self.rx_params = dab.parameters.receiver_parameters(
mode=options.dab_mode,
softbits=True,
input_fft_filter=options.filter_input,
autocorrect_sample_rate=options.autocorrect_sample_rate,
sample_rate_correction_factor=options.resample_fixed,
verbose=options.verbose,
correct_ffe=options.correct_ffe,
equalize_magnitude=options.equalize_magnitude
)
self.demod = dab.ofdm_demod(self.dab_params, self.rx_params, verbose=options.verbose)
if len(args) >= 1:
self.filename = args[0]
self.sink = gr.file_sink(gr.sizeof_char*12288, self.filename)
#self.sink = gr.file_sink(gr.sizeof_char*3072, self.filename)
self.connect(self.demod, self.sink)
# self.trigsink = gr.null_sink(gr.sizeof_char)
# self.connect((self.demod,1), self.trigsink)
self.fic_dec = dab.fic_decode(self.dab_params)
self.connect(self.src, self.demod, (self.fic_dec,0))
self.connect((self.demod,1), (self.fic_dec,1))
# tune frequency
self.frequency = options.freq
self.set_freq(options.freq)
# set gain
if options.rx_gain is None:
# if no gain was specified, use AGC
self.src.set_gain_mode(1, 0)
else:
self.src.set_gain(options.rx_gain, 0)
self.update_ui = options.verbose
if self.update_ui:
self.run_ui_update_thread = True
self.ui_updater = threading.Timer(0.1,self.update_ui_function)
self.ui_updater.setDaemon(True)
self.ui_updater.start()
self.correct_ffe_usrp = options.correct_ffe_usrp
if self.correct_ffe_usrp:
print "--> correcting FFE on USRP"
self.run_correct_ffe_thread = True
self.ffe_updater = threading.Timer(0.1, self.correct_ffe)
self.ffe_updater.setDaemon(True)
self.ffe_updater.start()
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2.5e6
self.decim = decim = 1
self.post_decim = post_decim = samp_rate / decim
self.freq_ctr2 = freq_ctr2 = 990e6
self.freq_ctr1 = freq_ctr1 = 990e6
self.cutoff = cutoff = 1e4 * 5
##################################################
# Blocks
##################################################
self.notebook_0 = self.notebook_0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "1")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "2")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "3")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "4")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "5")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "6")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "7")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "8")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "9")
self.Add(self.notebook_0)
_freq_ctr1_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_ctr1_text_box = forms.text_box(
parent=self.notebook_0.GetPage(0).GetWin(),
sizer=_freq_ctr1_sizer,
value=self.freq_ctr1,
callback=self.set_freq_ctr1,
label="center frequency",
converter=forms.float_converter(),
proportion=0,
)
self._freq_ctr1_slider = forms.slider(
parent=self.notebook_0.GetPage(0).GetWin(),
sizer=_freq_ctr1_sizer,
value=self.freq_ctr1,
callback=self.set_freq_ctr1,
minimum=989.1e6,
maximum=990.1e6,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.notebook_0.GetPage(0).Add(_freq_ctr1_sizer)
self.wxgui_scopesink2_1_0 = scopesink2.scope_sink_c(
self.notebook_0.GetPage(3).GetWin(),
title="Scope Plot",
sample_rate=post_decim,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.notebook_0.GetPage(3).Add(self.wxgui_scopesink2_1_0.win)
self.wxgui_scopesink2_1 = scopesink2.scope_sink_c(
self.notebook_0.GetPage(2).GetWin(),
title="Scope Plot",
sample_rate=post_decim,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.notebook_0.GetPage(2).Add(self.wxgui_scopesink2_1.win)
self.wxgui_numbersink2_0_0_0_1 = numbersink2.number_sink_f(
self.notebook_0.GetPage(1).GetWin(),
unit="Hz",
minval=-100,
maxval=100,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=samp_rate * 0 + post_decim,
number_rate=15,
average=False,
avg_alpha=0.001,
label="phase",
peak_hold=False,
show_gauge=False,
)
self.notebook_0.GetPage(1).Add(self.wxgui_numbersink2_0_0_0_1.win)
self.wxgui_numbersink2_0_0_0_0 = numbersink2.number_sink_f(
self.notebook_0.GetPage(1).GetWin(),
unit="Hz",
minval=-100,
maxval=100,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=samp_rate * 0 + post_decim,
number_rate=15,
average=False,
avg_alpha=0.001,
label="error",
peak_hold=False,
show_gauge=False,
)
self.notebook_0.GetPage(1).Add(self.wxgui_numbersink2_0_0_0_0.win)
self.wxgui_numbersink2_0_0_0 = numbersink2.number_sink_f(
self.notebook_0.GetPage(1).GetWin(),
unit="Hz",
minval=-100,
maxval=100,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=samp_rate * 0 + post_decim,
number_rate=15,
average=False,
avg_alpha=0.001,
label="freq",
peak_hold=False,
show_gauge=False,
)
self.notebook_0.GetPage(1).Add(self.wxgui_numbersink2_0_0_0.win)
self.wxgui_numbersink2_0_0 = numbersink2.number_sink_c(
self.notebook_0.GetPage(1).GetWin(),
unit="",
minval=-100,
maxval=100,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=samp_rate * 0 + post_decim,
number_rate=15,
average=False,
avg_alpha=0.001,
label="signal",
peak_hold=False,
show_gauge=False,
)
self.notebook_0.GetPage(1).Add(self.wxgui_numbersink2_0_0.win)
self.wxgui_fftsink2_0_0 = fftsink2.fft_sink_c(
self.notebook_0.GetPage(0).GetWin(),
baseband_freq=freq_ctr1,
y_per_div=10,
y_divs=5,
ref_level=-10,
ref_scale=2.0,
sample_rate=samp_rate * 0 + post_decim,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=0.2,
title="FFT Plot",
peak_hold=False,
)
self.notebook_0.GetPage(0).Add(self.wxgui_fftsink2_0_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.notebook_0.GetPage(0).GetWin(),
baseband_freq=freq_ctr1,
y_per_div=10,
y_divs=5,
ref_level=-10,
ref_scale=2.0,
sample_rate=samp_rate * 0 + post_decim,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=0.2,
title="FFT Plot",
peak_hold=False,
)
self.notebook_0.GetPage(0).Add(self.wxgui_fftsink2_0.win)
self.osmosdr_source_c_0 = osmosdr.source_c(args="nchan=" + str(1) + " " + "rtl=0,xtal=28.8e6,tuner_xtal=28.8e6")
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq_ctr1, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(2, 0)
self.osmosdr_source_c_0.set_gain_mode(1, 0)
self.osmosdr_source_c_0.set_gain(0, 0)
self.osmosdr_source_c_0.set_if_gain(0, 0)
self.low_pass_filter_0 = gr.fir_filter_ccf(
decim, firdes.low_pass(1, samp_rate, samp_rate / 4, samp_rate / 4, firdes.WIN_HAMMING, 6.76)
)
_freq_ctr2_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_ctr2_text_box = forms.text_box(
parent=self.notebook_0.GetPage(4).GetWin(),
sizer=_freq_ctr2_sizer,
value=self.freq_ctr2,
callback=self.set_freq_ctr2,
label="center frequency",
converter=forms.float_converter(),
proportion=0,
)
self._freq_ctr2_slider = forms.slider(
parent=self.notebook_0.GetPage(4).GetWin(),
sizer=_freq_ctr2_sizer,
value=self.freq_ctr2,
callback=self.set_freq_ctr2,
minimum=989.1e6,
maximum=990.1e6,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.notebook_0.GetPage(4).Add(_freq_ctr2_sizer)
self.digital_fll_band_edge_cc_0 = digital.fll_band_edge_cc(2, 0.05, 512, 0.008)
self.analog_pll_refout_cc_0 = analog.pll_refout_cc(math.pi / 1000, 2, -2)
##################################################
# Connections
##################################################
self.connect((self.low_pass_filter_0, 0), (self.wxgui_fftsink2_0_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.wxgui_scopesink2_1_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 2), (self.wxgui_numbersink2_0_0_0_1, 0))
self.connect((self.digital_fll_band_edge_cc_0, 3), (self.wxgui_numbersink2_0_0_0_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.digital_fll_band_edge_cc_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 1), (self.wxgui_numbersink2_0_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 0), (self.analog_pll_refout_cc_0, 0))
self.connect((self.analog_pll_refout_cc_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.analog_pll_refout_cc_0, 0), (self.wxgui_scopesink2_1, 0))
self.connect((self.analog_pll_refout_cc_0, 0), (self.wxgui_numbersink2_0_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.tune_corrector_callback = tune_corrector(self)
self.synchronizer_callback = synchronizer(self)
self.converter = gr.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source_c(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset, sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
self.receiver = gsm.receiver_cf(
self.tune_corrector_callback, self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
self.connect(self.src, self.tuner, self.interpolator, self.receiver, self.converter, self.output)
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
def fftsink2_callback(x, y):
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
sys.stderr.write("coarse tuned to: %d Hz\n" % x)
self.offset = -x
self.tuner.set_center_freq(self.offset)
self.scope = fftsink2.fft_sink_c(self.GetWin(),
title="Wideband Spectrum (click to coarse tune)",
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz\n" % self.offset)
self.tuner.set_center_freq(self.offset)
self.scope2 = fftsink2.fft_sink_c(self.GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=gsm_symb_rate * 4,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.interpolator, self.scope2)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.threshold = threshold = 1 self.samp_rate = samp_rate = 48000 self.rf_freq = rf_freq = 136780000 self.ch0ifgain = ch0ifgain = 36 self.ch0gain = ch0gain = 24 self.audiogain = audiogain = 200 ################################################## # Blocks ################################################## _threshold_sizer = wx.BoxSizer(wx.VERTICAL) self._threshold_text_box = forms.text_box( parent=self.GetWin(), sizer=_threshold_sizer, value=self.threshold, callback=self.set_threshold, label='threshold', converter=forms.float_converter(), proportion=0, ) self._threshold_slider = forms.slider( parent=self.GetWin(), sizer=_threshold_sizer, value=self.threshold, callback=self.set_threshold, minimum=0, maximum=1000, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_threshold_sizer, 1, 1, 1, 1) _ch0ifgain_sizer = wx.BoxSizer(wx.VERTICAL) self._ch0ifgain_text_box = forms.text_box( parent=self.GetWin(), sizer=_ch0ifgain_sizer, value=self.ch0ifgain, callback=self.set_ch0ifgain, label="ch0ifgain", converter=forms.float_converter(), proportion=0, ) self._ch0ifgain_slider = forms.slider( parent=self.GetWin(), sizer=_ch0ifgain_sizer, value=self.ch0ifgain, callback=self.set_ch0ifgain, minimum=0, maximum=42, num_steps=42, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_ch0ifgain_sizer, 4, 1, 1, 1) _ch0gain_sizer = wx.BoxSizer(wx.VERTICAL) self._ch0gain_text_box = forms.text_box( parent=self.GetWin(), sizer=_ch0gain_sizer, value=self.ch0gain, callback=self.set_ch0gain, label='ch0gain', converter=forms.float_converter(), proportion=0, ) self._ch0gain_slider = forms.slider( parent=self.GetWin(), sizer=_ch0gain_sizer, value=self.ch0gain, callback=self.set_ch0gain, minimum=-1, maximum=42, num_steps=43, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_ch0gain_sizer, 3, 1, 1, 1) _audiogain_sizer = wx.BoxSizer(wx.VERTICAL) self._audiogain_text_box = forms.text_box( parent=self.GetWin(), sizer=_audiogain_sizer, value=self.audiogain, callback=self.set_audiogain, label='audiogain', converter=forms.float_converter(), proportion=0, ) self._audiogain_slider = forms.slider( parent=self.GetWin(), sizer=_audiogain_sizer, value=self.audiogain, callback=self.set_audiogain, minimum=0, maximum=1000, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_audiogain_sizer, 2, 1, 1, 1) self.wxgui_fftsink2_1 = fftsink2.fft_sink_f( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=20, ref_scale=2.0, sample_rate=6000, fft_size=1024, fft_rate=10, average=False, avg_alpha=None, title="Audio", peak_hold=False, ) self.GridAdd(self.wxgui_fftsink2_1.win, 6, 1, 1, 1) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=rf_freq, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate*24, fft_size=1024, fft_rate=5, average=False, avg_alpha=None, title="RF", peak_hold=False, ) self.GridAdd(self.wxgui_fftsink2_0.win, 5, 1, 1, 1) self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.osmosdr_source_c_0.set_sample_rate(samp_rate*24) self.osmosdr_source_c_0.set_center_freq(rf_freq, 0) self.osmosdr_source_c_0.set_freq_corr(-32, 0) self.osmosdr_source_c_0.set_gain_mode(1, 0) self.osmosdr_source_c_0.set_gain(ch0gain, 0) self.osmosdr_source_c_0.set_if_gain(ch0ifgain, 0) self.low_pass_filter_0 = gr.fir_filter_ccf(6, firdes.low_pass( 1, samp_rate*24, 500000, 150000, firdes.WIN_HAMMING, 6.76)) self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((audiogain, )) self.gr_keep_one_in_n_0 = gr.keep_one_in_n(gr.sizeof_float*1, 8) self.gr_dc_blocker_0 = gr.dc_blocker_ff(64, True) self.blks2_am_demod_cf_0 = blks2.am_demod_cf( channel_rate=samp_rate*4, audio_decim=4, audio_pass=5000, audio_stop=5500, ) self.audio_sink_0 = audio.sink(samp_rate, "", True) self.acars_decodeur_0 = acars.decodeur(threshold,"/tmp/log_jmf.txt") ################################################## # Connections ################################################## self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.blks2_am_demod_cf_0, 0)) self.connect((self.osmosdr_source_c_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.audio_sink_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.acars_decodeur_0, 0)) self.connect((self.blks2_am_demod_cf_0, 0), (self.gr_dc_blocker_0, 0)) self.connect((self.gr_dc_blocker_0, 0), (self.gr_multiply_const_vxx_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.gr_keep_one_in_n_0, 0)) self.connect((self.gr_keep_one_in_n_0, 0), (self.wxgui_fftsink2_1, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 8000000
self.gain = gain = 10
self.freq = freq = 857000000
##################################################
# Blocks
##################################################
_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
label='gain',
converter=forms.float_converter(),
proportion=0,
)
self._gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_gain_sizer)
_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
label='freq',
converter=forms.float_converter(),
proportion=0,
)
self._freq_slider = forms.slider(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
minimum=855000000,
maximum=860000000,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_freq_sizer)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=freq,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.osmosdr_source_c_0 = osmosdr.source_c(args="nchan=" + str(1) +
" " + "hackrf=0")
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(14, 0)
self.osmosdr_source_c_0.set_if_gain(gain, 0)
self.osmosdr_source_c_0.set_bb_gain(gain, 0)
self.osmosdr_source_c_0.set_antenna("", 0)
self.osmosdr_source_c_0.set_bandwidth(0, 0)
##################################################
# Connections
##################################################
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Fm Rx")
Qt.QWidget.__init__(self)
self.setWindowTitle("Fm Rx")
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2e6
self.in_rate = in_rate = samp_rate
self.audio_rate = audio_rate = 44.1e3
self.volume = volume = 0.2
self.resamp_rate = resamp_rate = audio_rate/in_rate
self.nfilts = nfilts = 32
self.fm_deviation_hz = fm_deviation_hz = 75e3
##################################################
# Blocks
##################################################
self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtlsdr_source_c_0.set_sample_rate(samp_rate)
self.rtlsdr_source_c_0.set_center_freq(91.9e6, 0)
self.rtlsdr_source_c_0.set_freq_corr(0, 0)
self.rtlsdr_source_c_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_c_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_c_0.set_gain_mode(0, 0)
self.rtlsdr_source_c_0.set_gain(10, 0)
self.rtlsdr_source_c_0.set_if_gain(20, 0)
self.rtlsdr_source_c_0.set_bb_gain(20, 0)
self.rtlsdr_source_c_0.set_antenna("", 0)
self.rtlsdr_source_c_0.set_bandwidth(0, 0)
self.qtgui_sink_x_2 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
True, #plotfreq
True, #plotwaterfall
True, #plottime
True, #plotconst
)
self.qtgui_sink_x_2.set_update_time(1.0 / 10)
self._qtgui_sink_x_2_win = sip.wrapinstance(self.qtgui_sink_x_2.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_sink_x_2_win)
self.qtgui_sink_x_1 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
True, #plotfreq
True, #plotwaterfall
True, #plottime
True, #plotconst
)
self.qtgui_sink_x_1.set_update_time(1.0 / 10)
self._qtgui_sink_x_1_win = sip.wrapinstance(self.qtgui_sink_x_1.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_sink_x_1_win)
self.qtgui_sink_x_0 = qtgui.sink_c(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
91.9e6, #fc
samp_rate/2, #bw
"QT GUI Plot", #name
True, #plotfreq
True, #plotwaterfall
True, #plottime
True, #plotconst
)
self.qtgui_sink_x_0.set_update_time(1.0 / 10)
self._qtgui_sink_x_0_win = sip.wrapinstance(self.qtgui_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_sink_x_0_win)
self.pfb_arb_resampler_xxx_0 = filter.pfb.arb_resampler_fff(
resamp_rate,
taps=(firdes.low_pass_2(volume*nfilts, nfilts*in_rate, 15e3, 1e3, 60, firdes.WIN_KAISER)),
flt_size=nfilts)
self.audio_sink_0 = audio.sink(int(audio_rate), "pulse", True)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(in_rate/(2*math.pi*fm_deviation_hz/8.0))
##################################################
# Connections
##################################################
self.connect((self.pfb_arb_resampler_xxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.pfb_arb_resampler_xxx_0, 0), (self.qtgui_sink_x_2, 0))
self.connect((self.rtlsdr_source_c_0, 0), (self.qtgui_sink_x_0, 0))
self.connect((self.rtlsdr_source_c_0, 0), (self.analog_quadrature_demod_cf_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.qtgui_sink_x_1, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.pfb_arb_resampler_xxx_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.tune_corrector_callback = tune_corrector(self)
self.synchronizer_callback = synchronizer(self)
self.converter = gr.vector_to_stream(gr.sizeof_float, 142)
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source_c(options.args)
# added by scateu @ 2014-1-9
self.src.set_freq_corr(0, 0)
self.src.set_dc_offset_mode(1, 0)
self.src.set_iq_balance_mode(0, 0)
self.src.set_gain_mode(0, 0)
self.src.set_gain(14, 0)
self.src.set_if_gain(58, 0)
self.src.set_bb_gain(20, 0)
self.src.set_antenna("", 0)
self.src.set_bandwidth(0, 0)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
gsm_symb_rate = 1625000.0 / 6.0
sps = sample_rate / gsm_symb_rate / 4
out_sample_rate = gsm_symb_rate * 4
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, 145e3, 10e3,
gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(1, taps, self.offset,
sample_rate)
self.interpolator = gr.fractional_interpolator_cc(0, sps)
self.receiver = gsm.receiver_cf(self.tune_corrector_callback,
self.synchronizer_callback, 4,
options.key.replace(' ', '').lower(),
options.configuration.upper())
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
self.connect(self.src, self.tuner, self.interpolator, self.receiver,
self.converter, self.output)
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
def fftsink2_callback(x, y):
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
sys.stderr.write("coarse tuned to: %d Hz\n" % x)
self.offset = -x
self.tuner.set_center_freq(self.offset)
self.scope = fftsink2.fft_sink_c(
self.GetWin(),
title="Wideband Spectrum (click to coarse tune)",
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz\n" % self.offset)
self.tuner.set_center_freq(self.offset)
self.scope2 = fftsink2.fft_sink_c(
self.GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=gsm_symb_rate * 4,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.3)
self.Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.interpolator, self.scope2)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 8000000
self.gain = gain = 10
self.freq = freq = 857000000
##################################################
# Blocks
##################################################
_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
label='gain',
converter=forms.float_converter(),
proportion=0,
)
self._gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_gain_sizer)
_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
label='freq',
converter=forms.float_converter(),
proportion=0,
)
self._freq_slider = forms.slider(
parent=self.GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
minimum=855000000,
maximum=860000000,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_freq_sizer)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=freq,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "hackrf=0" )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(14, 0)
self.osmosdr_source_c_0.set_if_gain(gain, 0)
self.osmosdr_source_c_0.set_bb_gain(gain, 0)
self.osmosdr_source_c_0.set_antenna("", 0)
self.osmosdr_source_c_0.set_bandwidth(0, 0)
##################################################
# Connections
##################################################
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
options = get_options()
self.ifreq = options.frequency
self.rfgain = options.gain
self.src = osmosdr.source_c(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(int(options.sample_rate))
#sq5bpf: dodalem ppm
self.src.set_freq_corr(8)
if self.rfgain is None:
self.src.set_gain_mode(1)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(0)
self.src.set_gain(self.rfgain)
# may differ from the requested rate
sample_rate = self.src.get_sample_rate()
sys.stderr.write("sample rate: %d\n" % (sample_rate))
symbol_rate = 18000
sps = 2 # output rate will be 36,000
out_sample_rate = symbol_rate * sps
options.low_pass = options.low_pass / 2.0
if sample_rate == 96000: # FunCube Dongle
first_decim = 2
else:
first_decim = 10
self.offset = 0
taps = gr.firdes.low_pass(1.0, sample_rate, options.low_pass,
options.low_pass * 0.2, gr.firdes.WIN_HANN)
self.tuner = gr.freq_xlating_fir_filter_ccf(first_decim, taps,
self.offset, sample_rate)
self.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)
self.output = gr.file_sink(gr.sizeof_float, options.output_file)
rerate = float(
sample_rate / float(first_decim)) / float(out_sample_rate)
sys.stderr.write("resampling factor: %f\n" % rerate)
if rerate.is_integer():
sys.stderr.write("using pfb decimator\n")
self.resamp = blks2.pfb_decimator_ccf(int(rerate))
else:
sys.stderr.write("using pfb resampler\n")
self.resamp = blks2.pfb_arb_resampler_ccf(1 / rerate)
self.connect(self.src, self.tuner, self.resamp, self.demod,
self.output)
self.Main = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Wideband Spectrum")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Channel Spectrum")
self.Main.AddPage(grc_wxgui.Panel(self.Main), "Soft Bits")
def set_ifreq(ifreq):
self.ifreq = ifreq
self._ifreq_text_box.set_value(self.ifreq)
self.src.set_center_freq(self.ifreq)
self._ifreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq,
callback=set_ifreq,
label="Center Frequency",
converter=forms.float_converter(),
)
self.Add(self._ifreq_text_box)
def set_iagc(iagc):
self.iagc = iagc
self._agc_check_box.set_value(self.iagc)
self.src.set_gain_mode(self.iagc, 0)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
self._agc_check_box = forms.check_box(
parent=self.GetWin(),
value=self.iagc,
callback=set_iagc,
label="Automatic Gain",
true=1,
false=0,
)
self.Add(self._agc_check_box)
def set_rfgain(rfgain):
self.rfgain = rfgain
self._rfgain_slider.set_value(self.rfgain)
self._rfgain_text_box.set_value(self.rfgain)
self.src.set_gain(0 if self.iagc == 1 else self.rfgain, 0)
_rfgain_sizer = wx.BoxSizer(wx.VERTICAL)
self._rfgain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
label="RF Gain",
converter=forms.float_converter(),
proportion=0,
)
self._rfgain_slider = forms.slider(
parent=self.GetWin(),
sizer=_rfgain_sizer,
value=self.rfgain,
callback=set_rfgain,
minimum=0,
maximum=50,
num_steps=200,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_rfgain_sizer)
self.Add(self.Main)
def fftsink2_callback(x, y):
x = x - self.ifreq
sys.stderr.write("sq5bpf: x: %d \n" % x)
if abs(x / (sample_rate / 2)) > 0.9:
set_ifreq(self.ifreq + x / 2)
else:
sys.stderr.write("coarse tuned to: %d Hz\n" % x)
self.offset = -x
self.tuner.set_center_freq(self.offset)
self._rxfreq_text_box.set_value(self.ifreq -
self.offset) #sq5bpf
self.scope = fftsink2.fft_sink_c(
self.Main.GetPage(0).GetWin(),
title="Wideband Spectrum (click to coarse tune)",
baseband_freq=self.ifreq, #sq5bpf
fft_size=1024,
sample_rate=sample_rate,
ref_scale=2.0,
ref_level=0,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.6)
self.Main.GetPage(0).Add(self.scope.win)
self.scope.set_callback(fftsink2_callback)
self.connect(self.src, self.scope)
def fftsink2_callback2(x, y):
self.offset = self.offset - (x / 10)
sys.stderr.write("fine tuned to: %d Hz\n" % self.offset)
self.tuner.set_center_freq(self.offset)
self._rxfreq_text_box.set_value(self.ifreq - self.offset) #sq5bpf
self.scope2 = fftsink2.fft_sink_c(
self.Main.GetPage(1).GetWin(),
title="Channel Spectrum (click to fine tune)",
fft_size=1024,
sample_rate=out_sample_rate,
ref_scale=2.0,
ref_level=-20,
y_divs=10,
fft_rate=10,
average=False,
avg_alpha=0.6)
self.Main.GetPage(1).Add(self.scope2.win)
self.scope2.set_callback(fftsink2_callback2)
self.connect(self.resamp, self.scope2)
self.scope3 = scopesink2.scope_sink_f(
self.Main.GetPage(2).GetWin(),
title="Soft Bits",
sample_rate=out_sample_rate,
v_scale=0,
v_offset=0,
t_scale=0.001,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.Main.GetPage(2).Add(self.scope3.win)
self.connect(self.demod, self.scope3)
#sq5bpf
self._rxfreq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.ifreq - self.offset,
label="RX Freq",
converter=forms.float_converter(),
)
self.Add(self._rxfreq_text_box)
def __init__(self):
gr.top_block.__init__(self, "Key")
# super(Key, self).__init__()
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2016000 #1920000#2000000
self.offset_freq_keyboard = offset_freq_keyboard = 27195000
self.offset_freq = offset_freq = 27175000
self.center_freq = center_freq = 28000000
self.target_rate = target_rate = 48000#16000#96000
self.offset_keyboard = offset_keyboard = offset_freq_keyboard - center_freq
self.offset = offset = offset_freq - center_freq
#self.firdes_tap_overall = firdes_tap_overall = firdes.low_pass(1, samp_rate, 50000, 0100, firdes.WIN_HAMMING,
# 6.76)
self.firdes_tap_keyboard = firdes_tap_keyboard = firdes.low_pass(1, samp_rate, 20000, 0100,#5000, 5000, #20000, 10000,
firdes.WIN_HAMMING,
6.76)
##################################################
# Blocks
##################################################
self.osmosdr_source_c_0 = osmosdr.source_c(args="nchan=" + str(1) + " " + "")
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(center_freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_dc_offset_mode(1, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(01, 0)
self.osmosdr_source_c_0.set_if_gain(20, 0)
self.osmosdr_source_c_0.set_bb_gain(20, 0)
self.osmosdr_source_c_0.set_antenna("", 0)
self.osmosdr_source_c_0.set_bandwidth(0, 0)
self.low_pass_filter_0 = gr.fir_filter_fff(1, firdes.low_pass(
1, target_rate, 5e3, 01e3, firdes.WIN_HAMMING, 6.76))
self.freq_xlating_fir_filter_xxx_0_0 = filter.freq_xlating_fir_filter_ccc(int(samp_rate / target_rate),
(firdes_tap_keyboard),
offset_keyboard, samp_rate)
self.blocks_wavfile_sink_0 = blocks.wavfile_sink("/root/sdr/keyboard/44.1Ks_27Mf_quad3_keyboard.wav", 1,
target_rate, 8)
#ACL
#self.blocks_file_source_0 = blocks.file_source(gr.sizeof_float * 1, "/root/sdr/keyboard/96k_27M_float", False)
#self.blocks_file_sink_2 = blocks.file_sink(gr.sizeof_float * 1, "/root/sdr/keyboard/96k_27M_float")
#self.blocks_file_sink_2.set_unbuffered(False)
self.sink = gr_queue.queue_sink_f()
self.analog_simple_squelch_cc_0 = analog.simple_squelch_cc(-5, 1)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(2)
##################################################
# Connections
##################################################
self.connect((self.osmosdr_source_c_0, 0), (self.freq_xlating_fir_filter_xxx_0_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0_0, 0), (self.analog_simple_squelch_cc_0, 0))
self.connect((self.analog_simple_squelch_cc_0, 0), (self.analog_quadrature_demod_cf_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.blocks_wavfile_sink_0, 0))
self.connect((self.low_pass_filter_0, 0), self.sink)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="AM Receiver") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1e6 self.offset_fine = offset_fine = 0 self.offset_coarse = offset_coarse = 0 self.freq = freq = 7200000 self.LO = LO = 0 self.xlate_filter_taps = xlate_filter_taps = firdes.low_pass(1, samp_rate, 125000, 25000, firdes.WIN_HAMMING, 6.76) self.width = width = 10000 self.trans = trans = 1500 self.rx_freq = rx_freq = LO+freq+(offset_coarse+offset_fine) self.rf_gain = rf_gain = 20 self.lo_freq = lo_freq = LO self.display_selector = display_selector = 0 self.af_gain = af_gain = 1 ################################################## # Blocks ################################################## _width_sizer = wx.BoxSizer(wx.VERTICAL) self._width_text_box = forms.text_box( parent=self.GetWin(), sizer=_width_sizer, value=self.width, callback=self.set_width, label="Filter", converter=forms.float_converter(), proportion=0, ) self._width_slider = forms.slider( parent=self.GetWin(), sizer=_width_sizer, value=self.width, callback=self.set_width, minimum=2000, maximum=40000, num_steps=760, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_width_sizer, 7, 0, 1, 1) _trans_sizer = wx.BoxSizer(wx.VERTICAL) self._trans_text_box = forms.text_box( parent=self.GetWin(), sizer=_trans_sizer, value=self.trans, callback=self.set_trans, label="Trans", converter=forms.float_converter(), proportion=0, ) self._trans_slider = forms.slider( parent=self.GetWin(), sizer=_trans_sizer, value=self.trans, callback=self.set_trans, minimum=500, maximum=5000, num_steps=900, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_trans_sizer, 8, 0, 1, 1) self._rx_freq_static_text = forms.static_text( parent=self.GetWin(), value=self.rx_freq, callback=self.set_rx_freq, label="Receive", converter=forms.float_converter(), ) self.GridAdd(self._rx_freq_static_text, 5, 3, 1, 1) _offset_fine_sizer = wx.BoxSizer(wx.VERTICAL) self._offset_fine_text_box = forms.text_box( parent=self.GetWin(), sizer=_offset_fine_sizer, value=self.offset_fine, callback=self.set_offset_fine, label="Fine tune", converter=forms.float_converter(), proportion=0, ) self._offset_fine_slider = forms.slider( parent=self.GetWin(), sizer=_offset_fine_sizer, value=self.offset_fine, callback=self.set_offset_fine, minimum=-1000, maximum=1000, num_steps=400, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_offset_fine_sizer, 6, 0, 1, 2) _offset_coarse_sizer = wx.BoxSizer(wx.VERTICAL) self._offset_coarse_text_box = forms.text_box( parent=self.GetWin(), sizer=_offset_coarse_sizer, value=self.offset_coarse, callback=self.set_offset_coarse, label="Coarse tune", converter=forms.float_converter(), proportion=0, ) self._offset_coarse_slider = forms.slider( parent=self.GetWin(), sizer=_offset_coarse_sizer, value=self.offset_coarse, callback=self.set_offset_coarse, minimum=-120000, maximum=120000, num_steps=960, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_offset_coarse_sizer, 6, 2, 1, 2) self._display_selector_chooser = forms.drop_down( parent=self.GetWin(), value=self.display_selector, callback=self.set_display_selector, label="Spectrum", choices=[0, 1], labels=['Baseband','USRP'], ) self.GridAdd(self._display_selector_chooser, 5, 0, 1, 1) _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="VOL", 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=5, num_steps=50, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_af_gain_sizer, 8, 1, 1, 1) self.xlating_fir_filter = gr.freq_xlating_fir_filter_ccc(1, (xlate_filter_taps), -(offset_coarse+offset_fine), samp_rate) self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.rtlsdr_source_c_0.set_sample_rate(samp_rate) self.rtlsdr_source_c_0.set_center_freq(31e6, 0) self.rtlsdr_source_c_0.set_freq_corr(0, 0) self.rtlsdr_source_c_0.set_gain_mode(0, 0) self.rtlsdr_source_c_0.set_gain(10, 0) self.rtlsdr_source_c_0.set_if_gain(24, 0) _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", 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=50, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_rf_gain_sizer, 7, 1, 1, 1) self.low_pass_filter = gr.fir_filter_ccf(5, firdes.low_pass( 1, samp_rate, width/2, trans, firdes.WIN_HAMMING, 6.76)) self._lo_freq_static_text = forms.static_text( parent=self.GetWin(), value=self.lo_freq, callback=self.set_lo_freq, label="LO", converter=forms.float_converter(), ) self.GridAdd(self._lo_freq_static_text, 5, 2, 1, 1) self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((af_gain, )) self.gr_agc2_xx_0 = gr.agc2_cc(0.1, 10e-6, 0.9, 1.0, 1.0) self._freq_text_box = forms.text_box( parent=self.GetWin(), value=self.freq, callback=self.set_freq, label="USRP", converter=forms.float_converter(), ) self.GridAdd(self._freq_text_box, 5, 1, 1, 1) self.fftsink = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=rx_freq*display_selector, y_per_div=10, y_divs=10, ref_level=0, ref_scale=13490.0, sample_rate=samp_rate, fft_size=512, fft_rate=15, average=True, avg_alpha=0.5, title="", peak_hold=False, size=(800,300), ) self.GridAdd(self.fftsink.win, 0, 0, 5, 4) self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_ccc( interpolation=441, decimation=500, taps=None, fractional_bw=None, ) self.blks2_am_demod_cf_0 = blks2.am_demod_cf( channel_rate=44100, audio_decim=1, audio_pass=5000, audio_stop=5500, ) self.audio_sink_0 = audio.sink(44100, "", True) ################################################## # Connections ################################################## self.connect((self.xlating_fir_filter, 0), (self.fftsink, 0)) self.connect((self.xlating_fir_filter, 0), (self.low_pass_filter, 0)) self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 0)) self.connect((self.gr_multiply_const_vxx_1, 0), (self.audio_sink_0, 1)) self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.blks2_am_demod_cf_0, 0)) self.connect((self.blks2_am_demod_cf_0, 0), (self.gr_multiply_const_vxx_1, 0)) self.connect((self.low_pass_filter, 0), (self.gr_agc2_xx_0, 0)) self.connect((self.gr_agc2_xx_0, 0), (self.blks2_rational_resampler_xxx_1, 0)) self.connect((self.rtlsdr_source_c_0, 0), (self.xlating_fir_filter, 0))
def __init__(self, options, queue):
gr.top_block.__init__(self)
self.rtl = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtl.set_sample_rate(options.rate)
self.rtl.set_center_freq(options.centerfreq, 0)
self.rtl.set_freq_corr(options.ppm, 0)
self.rtl.set_gain_mode(1, 0)
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:
options.gain = 10
if options.bbgain is None:
options.bbgain = 25
if options.ifgain is None:
options.ifgain = 25
print "Setting RF gain to %i" % options.gain
print "Setting BB gain to %i" % options.bbgain
print "Setting IF gain to %i" % options.ifgain
self.rtl.set_gain(options.gain, 0)
self.rtl.set_if_gain(options.ifgain,0)
self.rtl.set_bb_gain(options.bbgain,0)
self.rate = options.rate
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.offset = gr.sig_source_c(self.rate, gr.GR_SIN_WAVE,
options.offset, 1.0, 0.0)
# for some reason using the xlating filter to do the offset makes thing barf with the HackRF, Multiply CC seems to work
options.offset = 0
self.mixer = gr.multiply_cc()
self.demod = fsk_demod(options)
self.start_correlator = gr.correlate_access_code_tag_bb("10101100",
0,
"smartnet_preamble") #should mark start of packet
self.smartnet_deinterleave = smartnet.deinterleave()
self.smartnet_crc = smartnet.crc(queue)
self.connect(self.rtl, (self.mixer, 0))
self.connect(self.offset, (self.mixer, 1))
self.connect(self.mixer, self.demod)
self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Dsd Grc")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self._config_freq_config = ConfigParser.ConfigParser()
self._config_freq_config.read(".grc_op25")
try: config_freq = self._config_freq_config.getfloat("main", "freq")
except: config_freq = 489900000
self.config_freq = config_freq
self.freq = freq = config_freq
self._config_xlate_offset_config = ConfigParser.ConfigParser()
self._config_xlate_offset_config.read(".grc_op25")
try: config_xlate_offset = self._config_xlate_offset_config.getfloat("main", "xlate_offset")
except: config_xlate_offset = 0
self.config_xlate_offset = config_xlate_offset
self.click_freq = click_freq = freq-config_xlate_offset
self.xlate_offset_fine = xlate_offset_fine = 0
self.xlate_offset = xlate_offset = freq-click_freq
self.samp_rate = samp_rate = 1000000
self.samp_per_sym = samp_per_sym = 10
self.decim = decim = 20
self._config_xlate_bandwidth_config = ConfigParser.ConfigParser()
self._config_xlate_bandwidth_config.read(".grc_op25")
try: config_xlate_bandwidth = self._config_xlate_bandwidth_config.getfloat("main", "xlate_bandwidth")
except: config_xlate_bandwidth = 24000
self.config_xlate_bandwidth = config_xlate_bandwidth
self.auto_tune_offset = auto_tune_offset = 0
self.xlate_bandwidth = xlate_bandwidth = config_xlate_bandwidth
self.variable_static_text_0 = variable_static_text_0 = freq+xlate_offset+xlate_offset_fine+auto_tune_offset
self.squelch = squelch = -65
self.pre_channel_rate = pre_channel_rate = samp_rate/decim
self.gain = gain = 25
self.fine_click_freq = fine_click_freq = 0
self.channel_rate = channel_rate = 4800*samp_per_sym
self.audio_mul = audio_mul = 0
##################################################
# Blocks
##################################################
_xlate_offset_fine_sizer = wx.BoxSizer(wx.VERTICAL)
self._xlate_offset_fine_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_xlate_offset_fine_sizer,
value=self.xlate_offset_fine,
callback=self.set_xlate_offset_fine,
label="Fine Offset",
converter=forms.float_converter(),
proportion=0,
)
self._xlate_offset_fine_slider = forms.slider(
parent=self.GetWin(),
sizer=_xlate_offset_fine_sizer,
value=self.xlate_offset_fine,
callback=self.set_xlate_offset_fine,
minimum=-10000,
maximum=10000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_xlate_offset_fine_sizer)
self._xlate_offset_text_box = forms.text_box(
parent=self.GetWin(),
value=self.xlate_offset,
callback=self.set_xlate_offset,
label="Xlate Offset",
converter=forms.float_converter(),
)
self.Add(self._xlate_offset_text_box)
_xlate_bandwidth_sizer = wx.BoxSizer(wx.VERTICAL)
self._xlate_bandwidth_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_xlate_bandwidth_sizer,
value=self.xlate_bandwidth,
callback=self.set_xlate_bandwidth,
label="Xlate BW",
converter=forms.float_converter(),
proportion=0,
)
self._xlate_bandwidth_slider = forms.slider(
parent=self.GetWin(),
sizer=_xlate_bandwidth_sizer,
value=self.xlate_bandwidth,
callback=self.set_xlate_bandwidth,
minimum=5000,
maximum=50000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_xlate_bandwidth_sizer)
self.nb = self.nb = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.nb.AddPage(grc_wxgui.Panel(self.nb), "BB-1")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "BB-2")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Xlate-1")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Xlate-2")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "4FSK")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Dibits")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Traffic")
self.Add(self.nb)
_gain_sizer = wx.BoxSizer(wx.VERTICAL)
self._gain_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
label="Gain",
converter=forms.float_converter(),
proportion=0,
)
self._gain_slider = forms.slider(
parent=self.GetWin(),
sizer=_gain_sizer,
value=self.gain,
callback=self.set_gain,
minimum=0,
maximum=50,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_gain_sizer)
self._freq_text_box = forms.text_box(
parent=self.GetWin(),
value=self.freq,
callback=self.set_freq,
label="Frequency",
converter=forms.float_converter(),
)
self.Add(self._freq_text_box)
_audio_mul_sizer = wx.BoxSizer(wx.VERTICAL)
self._audio_mul_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_audio_mul_sizer,
value=self.audio_mul,
callback=self.set_audio_mul,
label="Audio mul",
converter=forms.float_converter(),
proportion=0,
)
self._audio_mul_slider = forms.slider(
parent=self.GetWin(),
sizer=_audio_mul_sizer,
value=self.audio_mul,
callback=self.set_audio_mul,
minimum=-30,
maximum=10,
num_steps=40,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_audio_mul_sizer)
self.wxgui_waterfallsink2_0_0 = waterfallsink2.waterfall_sink_c(
self.nb.GetPage(3).GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=50,
ref_scale=2.0,
sample_rate=channel_rate,
fft_size=512,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.nb.GetPage(3).Add(self.wxgui_waterfallsink2_0_0.win)
self.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c(
self.nb.GetPage(1).GetWin(),
baseband_freq=freq,
dynamic_range=100,
ref_level=50,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=512,
fft_rate=15,
average=False,
avg_alpha=None,
title="Waterfall Plot",
)
self.nb.GetPage(1).Add(self.wxgui_waterfallsink2_0.win)
self.wxgui_scopesink2_1 = scopesink2.scope_sink_f(
self.nb.GetPage(4).GetWin(),
title="Scope Plot",
sample_rate=channel_rate,
v_scale=1.5,
v_offset=0,
t_scale=0.05,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb.GetPage(4).Add(self.wxgui_scopesink2_1.win)
self.wxgui_fftsink2_0_0 = fftsink2.fft_sink_c(
self.nb.GetPage(2).GetWin(),
baseband_freq=fine_click_freq,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=channel_rate,
fft_size=1024,
fft_rate=30,
average=True,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.nb.GetPage(2).Add(self.wxgui_fftsink2_0_0.win)
def wxgui_fftsink2_0_0_callback(x, y):
self.set_fine_click_freq(x)
self.wxgui_fftsink2_0_0.set_callback(wxgui_fftsink2_0_0_callback)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.nb.GetPage(0).GetWin(),
baseband_freq=freq,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=30,
average=True,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.nb.GetPage(0).Add(self.wxgui_fftsink2_0.win)
def wxgui_fftsink2_0_callback(x, y):
self.set_click_freq(x)
self.wxgui_fftsink2_0.set_callback(wxgui_fftsink2_0_callback)
self._variable_static_text_0_static_text = forms.static_text(
parent=self.GetWin(),
value=self.variable_static_text_0,
callback=self.set_variable_static_text_0,
label="Final freq",
converter=forms.float_converter(),
)
self.Add(self._variable_static_text_0_static_text)
_squelch_sizer = wx.BoxSizer(wx.VERTICAL)
self._squelch_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_squelch_sizer,
value=self.squelch,
callback=self.set_squelch,
label="Squelch",
converter=forms.float_converter(),
proportion=0,
)
self._squelch_slider = forms.slider(
parent=self.GetWin(),
sizer=_squelch_sizer,
value=self.squelch,
callback=self.set_squelch,
minimum=-100,
maximum=100,
num_steps=40,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_squelch_sizer)
self.osmosdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "hackrf=0" )
self.osmosdr_source_c_0.set_sample_rate(samp_rate)
self.osmosdr_source_c_0.set_center_freq(freq, 0)
self.osmosdr_source_c_0.set_freq_corr(0, 0)
self.osmosdr_source_c_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_c_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_c_0.set_gain_mode(0, 0)
self.osmosdr_source_c_0.set_gain(14, 0)
self.osmosdr_source_c_0.set_if_gain(gain, 0)
self.osmosdr_source_c_0.set_bb_gain(gain, 0)
self.osmosdr_source_c_0.set_antenna("", 0)
self.osmosdr_source_c_0.set_bandwidth(0, 0)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(decim, (firdes.low_pass(1, samp_rate, xlate_bandwidth/2, 6000)), xlate_offset+xlate_offset_fine-fine_click_freq, samp_rate)
self.fir_filter_xxx_0 = filter.fir_filter_fff(1, ((1.0/samp_per_sym,)*samp_per_sym))
self.dsd_block_ff_0 = dsd.block_ff(dsd.dsd_FRAME_P25_PHASE_1,dsd.dsd_MOD_C4FM,3,3,True)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((10.**(audio_mul/10.), ))
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_ccc(
interpolation=channel_rate,
decimation=pre_channel_rate,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_fff(
interpolation=44100,
decimation=8000,
taps=None,
fractional_bw=None,
)
self.audio_sink_0 = audio.sink(44100, "", True)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1.6)
##################################################
# Connections
##################################################
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.wxgui_fftsink2_0_0, 0))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.wxgui_waterfallsink2_0_0, 0))
self.connect((self.blks2_rational_resampler_xxx_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_waterfallsink2_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.dsd_block_ff_0, 0), (self.blks2_rational_resampler_xxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.wxgui_scopesink2_1, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.dsd_block_ff_0, 0))
self.connect((self.osmosdr_source_c_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.blks2_rational_resampler_xxx_1, 0))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.analog_quadrature_demod_cf_0, 0))
def __init__(self):
gr.top_block.__init__(self, "FM Demodulation - 91.9 MHz")
Qt.QWidget.__init__(self)
self.setWindowTitle("FM Demodulation - 91.9 MHz")
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1152e3
##################################################
# Blocks
##################################################
self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
self.rtlsdr_source_c_0.set_sample_rate(samp_rate)
self.rtlsdr_source_c_0.set_center_freq(91.9e6, 0)
self.rtlsdr_source_c_0.set_freq_corr(0, 0)
self.rtlsdr_source_c_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_c_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_c_0.set_gain_mode(0, 0)
self.rtlsdr_source_c_0.set_gain(10, 0)
self.rtlsdr_source_c_0.set_if_gain(20, 0)
self.rtlsdr_source_c_0.set_bb_gain(20, 0)
self.rtlsdr_source_c_0.set_antenna("", 0)
self.rtlsdr_source_c_0.set_bandwidth(0, 0)
self.qtgui_sink_x_1 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate/24, #bw
"QT GUI Plot - Demodulated Signal", #name
True, #plotfreq
True, #plotwaterfall
True, #plottime
True, #plotconst
)
self.qtgui_sink_x_1.set_update_time(1.0 / 10)
self._qtgui_sink_x_1_win = sip.wrapinstance(self.qtgui_sink_x_1.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_sink_x_1_win)
self.qtgui_sink_x_0 = qtgui.sink_c(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
91.9e6, #fc
samp_rate, #bw
"QT GUI Plot - Source", #name
True, #plotfreq
True, #plotwaterfall
True, #plottime
True, #plotconst
)
self.qtgui_sink_x_0.set_update_time(1.0 / 10)
self._qtgui_sink_x_0_win = sip.wrapinstance(self.qtgui_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_sink_x_0_win)
self.blks2_wfm_rcv_0 = blks2.wfm_rcv(
quad_rate=samp_rate,
audio_decimation=24,
)
self.audio_sink_0 = audio.sink(48000, "", True)
##################################################
# Connections
##################################################
self.connect((self.rtlsdr_source_c_0, 0), (self.blks2_wfm_rcv_0, 0))
self.connect((self.blks2_wfm_rcv_0, 0), (self.audio_sink_0, 0))
self.connect((self.rtlsdr_source_c_0, 0), (self.qtgui_sink_x_0, 0))
self.connect((self.blks2_wfm_rcv_0, 0), (self.qtgui_sink_x_1, 0))
