def __init__(self, sample_rate, fft_size, ref_scale, frame_rate):
gr.hier_block2.__init__(
self, "logpowerfft_win", gr.io_signature(1, 1,
gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float * fft_size))
self._sd = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=fft_size)
fft_window = fft_lib.window_hamming(fft_size)
fft = fft_lib.fft_vcc(fft_size, True, fft_window, True)
window_power = sum([x * x for x in fft_window])
c2magsq = blocks.complex_to_mag_squared(fft_size)
self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
self._log = blocks.nlog10_ff(
10,
fft_size,
-20 * math.log10(fft_size) # Adjust for number of bins
- 10 * math.log10(
float(window_power) / fft_size) # Adjust for windowing loss
- 20 *
math.log10(float(ref_scale) / 2)) # Adjust for reference scale
self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, length, height): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.tune_freq = tune_freq self.rate = rate self.length = length self.height = height self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len) self.log = blocks.nlog10_ff(10, self.fft_len, -10*math.log10(self.fft_len) # Adjust for number of bins -10*math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) self._main = main_thread(self.msgq, self.fft_len, self.sample_rate, self.tune_freq, self.length, self.height)
def __init__(self, auto_carrier, carrier, all_spectrum, freq_central, samp_rate, nintems, signal_bw, noise_bw, avg_alpha, average, win):
"""
Estimates the SNR.
Provide access to the setting the filter and sample rate.
Args:
sample_rate: Incoming stream sample rate
nintems: Number of FFT bins
avg_alpha: FFT averaging (over time) constant [0.0-1.0]
average: Whether to average [True, False]
win: the window taps generation function
auto_carrier: To allow self-detection of the carrier, so the highest bin [True, False]
carrier: To evalutaion of the CNR or SNR [True, False]
all_spectrum: To set the whole spectrum (less the signal's one) to evaluate noise power density [True, False]
freq_central: Sets the central frequency (for the bandwidth) of the signal (in the CNR mode, it is the manual set of the carrier's frequency)
signal_bw: Sets the bandwidth (for the SNR mode) of the signal to the power evaluation
noise_bw: Sets the bandwidth (if all_sepctrum is false) of the noise to the power evaluation
"""
gr.hier_block2.__init__(self, "snr_estimator_cfv",
gr.io_signature(1,1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2,2, gr.sizeof_float, gr.sizeof_float * nintems)) # Output signature
self.auto_carrier = auto_carrier
self.carrier = carrier
self.all_spectrum = all_spectrum
self.freq_central = freq_central
self.samp_rate = samp_rate
self.nintems = nintems
self.signal_bw = signal_bw
self.noise_bw = noise_bw
self.avg_alpha = avg_alpha
self.average = average
self.win = win
fft_window = self.win(self.nintems)
self.fft = fft.fft_vcc(self.nintems, True, fft_window, True)
self._sd = blocks.stream_to_vector(gr.sizeof_gr_complex, self.nintems)
self.c2magsq = blocks.complex_to_mag_squared(self.nintems)
self._avg = filter.single_pole_iir_filter_ff(1.0, self.nintems)
self.snr = flaress.snr(self.auto_carrier, self.carrier, self.all_spectrum, self.freq_central, self.samp_rate, self.nintems, self.signal_bw, self.noise_bw)
window_power = sum(map(lambda x: x*x, fft_window))
self.log = blocks.nlog10_ff(10, self.nintems,
-20*math.log10(self.nintems) # Adjust for number of bins
-10*math.log10(float(window_power)/self.nintems) # Adjust for windowing loss
-20*math.log10(float(2)/2)) # Adjust for reference scale
self.connect(self, self._sd, self.fft, self.c2magsq, self._avg, self.snr, (self, 0))
self.connect(self._avg, self.log, (self, 1))
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width,
height):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.tune_freq = tune_freq
self.rate = rate
if width == 0 and height == 0:
rows, columns = os.popen('stty size', 'r').read().split()
self.height = int(rows) - 5
self.width = int(columns) / 2 - 10
else:
self.height = height
self.width = width
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(self.average,
self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#register message out to other blocks
self.message_port_register_hier_out("pkt_out")
#packet generator
self.packet_generator = of.chat_blocks.chat_sender()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
#MSG output
self.msg_connect(self.packet_generator, "out", self, "pkt_out")
####THREADS####
self._ascii_plotter = ascii_plotter(self.width, self.height,
self.tune_freq, self.sample_rate,
self.fft_len)
self._main = main_thread(self.msgq, self._ascii_plotter,
self.packet_generator)
def __init__(self, sample_rate, fac_size, fac_rate):
gr.hier_block2.__init__(self, "fast_autocorrelator_c",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
# Parameters
self.sample_rate = sample_rate
self.fac_size = fac_size
self.fac_rate = fac_rate
self.window = ()
# Block Objects For Float Fast Autocorrelator
self.stream_to_vector = blocks.stream_to_vector(
gr.sizeof_float, fac_size)
self.keep_one_in_n = blocks.keep_one_in_n(
gr.sizeof_float * fac_size,
max(1, int(sample_rate / fac_size / fac_rate)))
self.fac_fft = fft.fft_vfc(fac_size, True, self.window)
self.complex_to_mag = blocks.complex_to_mag(fac_size)
self.fac_complex_to_mag = blocks.complex_to_mag(fac_size)
self.nlog10_ff = blocks.nlog10_ff(20, fac_size,
-20 * math.log10(fac_size))
self.single_pole_iir_filter_ff = filter.single_pole_iir_filter_ff(
1, fac_size)
self.fft_vfc = fft.fft_vfc(fac_size, True, self.window)
self.vector_to_stream = blocks.vector_to_stream(
gr.sizeof_float, self.fac_size)
# Connections for Auto Correlator
self.connect(self, self.stream_to_vector, self.keep_one_in_n,
self.fft_vfc, self.complex_to_mag, self.fac_fft,
self.fac_complex_to_mag, self.single_pole_iir_filter_ff,
self.nlog10_ff, self.vector_to_stream, self)
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, **kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = blocks.stream_to_vector(gr.sizeof_float, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_float * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = blocks.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self,
sample_rate,
pspectrum_len,
ref_scale,
frame_rate,
avg_alpha,
average,
n,
m,
nsamples,
estimator='esprit'):
"""
Create an log10(abs(spectrum_estimate)) stream chain.
Provide access to the setting the filter and sample rate.
@param sample_rate Incoming stream sample rate
@param pspectrum_len Number of FFT bins
@param ref_scale Sets 0 dB value input amplitude
@param frame_rate Output frame rate
@param avg_alpha averaging (over time) constant [0.0-1.0]
@param average Whether to average [True, False]
@param n Parameter n for the estimator
@param m Parameter m for the estimator
@param nsamples Number of samples to use for estimation
@param estimator Estimator to use, can be either 'esprit' or 'music'
"""
gr.hier_block2.__init__(
self,
self._name,
gr.io_signature(1, 1, self._item_size), # Input signature
gr.io_signature(1, 1, gr.sizeof_float *
pspectrum_len)) # Output signature
self._sd = blocks.stream_to_vector_decimator(item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=nsamples)
if estimator == 'esprit':
est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len)
elif estimator == 'music':
est = specest.music_spectrum_vcf(n, m, nsamples, pspectrum_len)
else:
est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len)
self._avg = filter.single_pole_iir_filter_ff(1.0, pspectrum_len)
self._log = blocks.nlog10_ff(
20,
pspectrum_len,
-20 * math.log10(pspectrum_len) # Adjust for number of bins
- 20 * math.log10(ref_scale / 2) +
3.0) # Adjust for reference scale
self.connect(self, self._sd, est, self._avg, self._log, self)
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def __init__(self,
sample_rate,
fft_size,
ref_scale,
frame_rate,
avg_alpha,
average,
win=None,
shift=False):
"""
Create an log10(abs(fft)) stream chain.
Provide access to the setting the filter and sample rate.
Args:
sample_rate: Incoming stream sample rate
fft_size: Number of FFT bins
ref_scale: Sets 0 dB value input amplitude
frame_rate: Output frame rate
avg_alpha: FFT averaging (over time) constant [0.0-1.0]
average: Whether to average [True, False]
win: the window taps generation function
shift: shift zero-frequency component to center of spectrum
"""
gr.hier_block2.__init__(
self,
self._name,
# Input signature
gr.io_signature(1, 1, self._item_size),
gr.io_signature(1, 1,
gr.sizeof_float * fft_size)) # Output signature
self._sd = blocks.stream_to_vector_decimator(item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=fft_size)
if win is None:
win = window.blackmanharris
fft_window = win(fft_size)
fft = self._fft_block[0](fft_size, True, fft_window, shift=shift)
window_power = sum([x * x for x in fft_window])
c2magsq = blocks.complex_to_mag_squared(fft_size)
self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
self._log = blocks.nlog10_ff(
10,
fft_size,
# Adjust for number of bins
-20 * math.log10(fft_size) -
# Adjust for windowing loss
10 * math.log10(float(window_power) / fft_size) - 20 *
math.log10(float(ref_scale) / 2)) # Adjust for reference scale
self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def _setup_foot(self):
""" Sets up everything after the spectral estimation. """
if self.options.linear:
self.connect(self.head, self.specest, self.sink)
self.ylabelstr = 'Power Spectrum Density / W/rad'
else:
lin2db = blocks.nlog10_ff(10, self.options.fft_len)
self.connect(self.head, self.specest, lin2db, self.sink)
self.ylabelstr = 'Power Spectrum Density / dBW/rad'
def _setup_foot(self):
""" Sets up everything after the spectral estimation. """
if self.options.linear:
self.connect(self.head, self.specest, self.sink)
self.ylabelstr = 'Power Spectrum Density / W/rad'
else:
lin2db = blocks.nlog10_ff(10, self.options.fft_len)
self.connect(self.head, self.specest, lin2db, self.sink)
self.ylabelstr = 'Power Spectrum Density / dBW/rad'
def set_body(self):
"""
1) Disconnect old stuff, if necessary.
2) Set up the new block.
3) Connect everything.
"""
self.lock()
if (self.body is not None and self.decimator is not None
and self.foot is not None):
self.sink.watcher.quit()
self.disconnect((self.decimator, 0), (self.body, 0))
self.disconnect((self.body, 0), (self.foot, 0))
self.disconnect((self.foot, 0), (self.sink, 0))
elif (self.body is not None and self.decimator is not None
and self.foot is None):
self.sink.watcher.quit()
self.disconnect((self.decimator, 0), (self.body, 0))
self.disconnect((self.body, 0), (self.sink, 0))
try:
(self.est_input_block_len,
self.fft_size) = estimators[self.estimator].setup_block(
self.shift_fft)
except KeyError:
print "Unknown estimator selected."
except RuntimeError:
print "Could not initialize Estimator (wrong settings?) !"
self.body = estimators[self.estimator].block
self.decimation = 1
self.sink = plot_sink(gr.sizeof_float, self.fft_size, self.main_box,
numpy.float32, self.samp_rate, self.center_f)
if (self.scale == "Logarithmic"):
try:
self.foot = blocks.nlog10_ff(10, self.fft_size)
except RuntimeError:
print "Wrong sink-data!"
self.connect((self.foot, 0), (self.sink, 0))
elif (self.scale == "Linear"):
try:
self.foot = None
except RuntimeError:
print "Wrong sink-data!"
else:
print "Wrong scale-settings!"
if (self.body is not None and self.decimator is not None):
self.connect((self.decimator, 0), (self.body, 0))
if (self.scale == "Logarithmic"):
self.connect((self.body, 0), (self.foot, 0))
elif (self.scale == "Linear"):
self.connect((self.body, 0), (self.sink, 0))
else:
print "Wrong scale-settings!"
self.main_box.first_run = 0
self.unlock()
def test_001(self):
src_data = (1, 10, 100, 1000, 10000, 100000)
expected_result = (0, 10, 20, 30, 40, 50)
src = blocks.vector_source_f(src_data)
op = blocks.nlog10_ff(10)
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
def test_001(self):
src_data = (1, 10, 100, 1000, 10000, 100000)
expected_result = (0, 10, 20, 30, 40, 50)
src = blocks.vector_source_f(src_data)
op = blocks.nlog10_ff(10)
dst = blocks.vector_sink_f()
self.tb.connect (src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual (expected_result, result_data, 5)
def __init__(self, fft_len, sample_rate, average, rate, max_tu,
data_precision):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.rate = rate
self.max_tu = max_tu - 2 #reserve two bytes for segmentation
self.data_precision = data_precision
if data_precision:
print '32bit FFT in use (more bandwidth and precision)'
else:
print '8bit FFT in use (less bandwidth and precision)'
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, mywindow, True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(self.average,
self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#register message out to other blocks
self.message_port_register_hier_out("pdus")
self._packet_source = packet_source()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self.msg_connect(self._packet_source, "out", self, "pdus")
####THREADS####
self._main = main_thread(self.msgq, self._packet_source, self.max_tu,
self.fft_len, self.data_precision)
def set_body(self):
"""
1) Disconnect old stuff, if necessary.
2) Set up the new block.
3) Connect everything.
"""
self.lock()
if(self.body is not None and self.decimator is not None and self.foot is not None):
self.sink.watcher.quit()
self.disconnect((self.decimator, 0), (self.body, 0))
self.disconnect((self.body, 0), (self.foot, 0))
self.disconnect((self.foot, 0), (self.sink, 0))
elif(self.body is not None and self.decimator is not None and self.foot is None):
self.sink.watcher.quit()
self.disconnect((self.decimator, 0), (self.body, 0))
self.disconnect((self.body, 0), (self.sink, 0))
try:
(self.est_input_block_len,
self.fft_size) = estimators[self.estimator].setup_block(self.shift_fft)
except KeyError:
print "Unknown estimator selected."
except RuntimeError:
print "Could not initialize Estimator (wrong settings?) !"
self.body = estimators[self.estimator].block
self.decimation = 1
self.sink = plot_sink(gr.sizeof_float, self.fft_size, self.main_box,
numpy.float32, self.samp_rate, self.center_f)
if(self.scale == "Logarithmic"):
try:
self.foot = blocks.nlog10_ff(10, self.fft_size)
except RuntimeError:
print "Wrong sink-data!"
self.connect((self.foot, 0), (self.sink, 0))
elif(self.scale == "Linear"):
try:
self.foot = None
except RuntimeError:
print "Wrong sink-data!"
else:
print "Wrong scale-settings!"
if(self.body is not None and self.decimator is not None):
self.connect((self.decimator, 0), (self.body, 0))
if(self.scale == "Logarithmic"):
self.connect((self.body, 0), (self.foot, 0))
elif(self.scale == "Linear"):
self.connect((self.body, 0), (self.sink, 0))
else:
print "Wrong scale-settings!"
self.main_box.first_run = 0
self.unlock()
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1E6
self.gain = gain = 0
self.f0 = f0 = 3.625E9
self.bandwidth = bandwidth = 5
##################################################
# Blocks
##################################################
self.uhd_usrp_source_1 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_1.set_samp_rate(samp_rate)
self.uhd_usrp_source_1.set_center_freq(f0, 0)
self.uhd_usrp_source_1.set_gain(gain, 0)
self.uhd_usrp_source_1.set_antenna("TX/RX", 0)
self.uhd_usrp_source_1.set_bandwidth(bandwidth, 0)
self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex * 1, 20)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex * 1, 1000)
self.blocks_file_sink_1 = blocks.file_sink(
gr.sizeof_float * 1,
"/home/odroid/Documents/2ndRF/calibration/Power", False)
self.blocks_file_sink_1.set_unbuffered(False)
self.blocks_conjugate_cc_0 = blocks.conjugate_cc()
self.blocks_complex_to_real_0 = blocks.complex_to_real(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_real_0, 0),
(self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_conjugate_cc_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_head_0, 0), (self.blocks_conjugate_cc_0, 0))
self.connect((self.blocks_head_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.blocks_complex_to_real_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0),
(self.blocks_file_sink_1, 0))
self.connect((self.blocks_skiphead_0, 0), (self.blocks_head_0, 0))
self.connect((self.uhd_usrp_source_1, 0), (self.blocks_skiphead_0, 0))
def __init__(self, fft_size, samp_rate):
gr.hier_block2.__init__(
self,
"spectrum_sense",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1,
gr.sizeof_float * fft_size)) # Output signature
self.fft_size = fft_size
self.samp_rate = samp_rate
##################################################
# Blocks
##################################################
# stream to vector for fft
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
#self.one_in_n = gr.keep_one_in_n(gr.sizeof_float * self.fft_size,
# max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
# filter window
mywindow = filter.window.blackmanharris(self.fft_size)
# fft
ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
# complex to magnitude block
c2mag = blocks.complex_to_mag_squared(
self.fft_size) # use sqrt of this for power
# average
avg = filter.single_pole_iir_filter_ff(0.4, self.fft_size)
multiply_const = blocks.multiply_const_vff(
(np.ones(self.fft_size) * (1.0 / self.samp_rate)))
nlog10 = blocks.nlog10_ff(10, self.fft_size, 0)
# FIXME We need to add 3dB to all bins but the DC bin
#self.log = gr.nlog10_ff(20, self.fft_size,
# -20*math.log10(self.fft_size) # Adjust for number of bins
# -10*math.log10(power/self.fft_size) # Adjust for windowing loss
# -20*math.log10(ref_scale/2)) # Adjust for reference scale
#v2s = blocks.vector_to_stream(gr.sizeof_float*1, self.fft_size)
# connect blocks
self.connect(self, s2v, ffter, c2mag, avg, multiply_const, nlog10,
self)
def __init__(self, samp_rate, freq, fft_size):
gr.top_block.__init__(self, "Rtlsense")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate
self.freq = freq
self.fft_size = fft_size
##################################################
# Blocks
##################################################
self.vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_gr_complex * 1, fft_size)
self.stream_to_vector_1 = blocks.stream_to_vector(
gr.sizeof_float * 1, fft_size)
self.stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_size)
self.src_0 = osmosdr.source(args="numchan=" + str(1) + " " + '')
self.src_0.set_sample_rate(samp_rate)
self.src_0.set_center_freq(freq, 0)
self.src_0.set_freq_corr(0, 0)
self.src_0.set_dc_offset_mode(2, 0)
self.src_0.set_iq_balance_mode(2, 0)
self.src_0.set_gain_mode(True, 0)
self.src_0.set_gain(15, 0)
self.src_0.set_if_gain(15, 0)
self.src_0.set_bb_gain(15, 0)
self.src_0.set_antenna('', 0)
self.src_0.set_bandwidth(0, 0)
self.multiply_const_0 = blocks.multiply_const_vcc((1. / fft_size, ))
self.log10_0 = blocks.nlog10_ff(10, 1, 0)
self.freq_sink = blocks.probe_signal_vf(fft_size)
self.fft_0 = fft.fft_vcc(fft_size, True, (), False, 0)
self.complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
##################################################
# Connections
##################################################
self.connect((self.complex_to_mag_squared_0, 0), (self.log10_0, 0))
self.connect((self.fft_0, 0), (self.vector_to_stream_0, 0))
self.connect((self.log10_0, 0), (self.stream_to_vector_1, 0))
self.connect((self.multiply_const_0, 0),
(self.complex_to_mag_squared_0, 0))
self.connect((self.src_0, 0), (self.stream_to_vector_0, 0))
self.connect((self.stream_to_vector_0, 0), (self.fft_0, 0))
self.connect((self.stream_to_vector_1, 0), (self.freq_sink, 0))
self.connect((self.vector_to_stream_0, 0), (self.multiply_const_0, 0))
def __init__(self, samp_rate, freq, fft_size):
gr.top_block.__init__(self, "Usrpsense")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate
self.freq = freq
self.fft_size = fft_size
##################################################
# Blocks
##################################################
self.vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_gr_complex * 1, fft_size)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(freq, 0)
self.uhd_usrp_source_0.set_gain(10, 0)
self.uhd_usrp_source_0.set_antenna('TX/RX', 0)
self.stream_to_vector_1 = blocks.stream_to_vector(
gr.sizeof_float * 1, fft_size)
self.stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_size)
self.multiply_const_0 = blocks.multiply_const_vcc((1. / fft_size, ))
self.log10_0 = blocks.nlog10_ff(10, 1, 0)
self.freq_sink = blocks.probe_signal_vf(fft_size)
self.fft_0 = fft.fft_vcc(fft_size, True, (), False, 0)
self.complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
##################################################
# Connections
##################################################
self.connect((self.complex_to_mag_squared_0, 0), (self.log10_0, 0))
self.connect((self.fft_0, 0), (self.vector_to_stream_0, 0))
self.connect((self.log10_0, 0), (self.stream_to_vector_1, 0))
self.connect((self.multiply_const_0, 0),
(self.complex_to_mag_squared_0, 0))
self.connect((self.stream_to_vector_0, 0), (self.fft_0, 0))
self.connect((self.stream_to_vector_1, 0), (self.freq_sink, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.stream_to_vector_0, 0))
self.connect((self.vector_to_stream_0, 0), (self.multiply_const_0, 0))
def __init__(self,
samp_rate=1600000,
samp_per_sym=16,
verbose=0,
msgq=0,
freq_error=-0.0025000):
gr.hier_block2.__init__(
self,
"Wmbus Phy1",
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
gr.io_signature(0, 0, 0),
)
##################################################
# Parameters
##################################################
self.samp_rate = samp_rate
self.samp_per_sym = samp_per_sym
self.verbose = verbose
self.msgq = msgq
self.freq_error = freq_error
##################################################
# Blocks
##################################################
self.wmbus_demod_0 = wmbus_demod(
samp_rate=1600000,
samp_per_sym=16,
freq_error=-0.0025000,
)
self.gr_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.gr_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.fir_filter_xxx_0 = gnuradio.filter.fir_filter_fff(
samp_per_sym, (16 * [1. / 16]))
self.any_sink_0_1 = mbus.framer(msgq, verbose)
self.any_0 = mbus.correlate_preamble()
##################################################
# Connections
##################################################
self.connect((self.any_0, 0), (self.any_sink_0_1, 0))
self.connect((self.gr_complex_to_mag_squared_0, 0),
(self.gr_nlog10_ff_0, 0))
self.connect((self.gr_nlog10_ff_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.any_sink_0_1, 1))
self.connect((self, 0), (self.gr_complex_to_mag_squared_0, 0))
self.connect((self, 0), (self.wmbus_demod_0, 0))
self.connect((self.wmbus_demod_0, 0), (self.any_0, 0))
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fft_size=512,
fft_rate=default_fft_rate,
average=False,
avg_alpha=None,
title='',
size=default_fftsink_size,
**kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0, 0, 0))
waterfall_sink_base.__init__(self,
input_is_real=True,
baseband_freq=baseband_freq,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average,
avg_alpha=avg_alpha,
title=title)
self.s2p = blocks.stream_to_vector(gr.sizeof_float, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_float * self.fft_size,
max(1, int(self.sample_rate / self.fft_size / self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = blocks.nlog10_ff(20, self.fft_size,
-20 * math.log10(self.fft_size))
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size,
self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag,
self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, parent, baseband_freq=0, ref_scale=2.0,
y_per_div=10, y_divs=8, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, peak_hold=False,
use_persistence=False, persist_alpha=0.2, **kwargs):
gr.hier_block2.__init__(self, "fft_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, y_divs=y_divs, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title,
peak_hold=peak_hold, use_persistence=use_persistence,
persist_alpha=persist_alpha)
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2magsq = blocks.complex_to_mag_squared(self.fft_size)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_size)
# FIXME We need to add 3dB to all bins but the DC bin
self.log = blocks.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size) # Adjust for number of bins
-10*math.log10(power/self.fft_size) # Adjust for windowing loss
-20*math.log10(ref_scale/2)) # Adjust for reference scale
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2magsq, self.avg, self.log, self.sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
self.set_use_persistence(self.use_persistence)
self.set_persist_alpha(self.persist_alpha)
self.set_peak_hold(self.peak_hold)
def __init__(self, options):
gr.hier_block2.__init__(self, "sensing_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
options = copy.copy(options) # make a copy so we can destructively modify
self._verbose = options.verbose
# linklab, fft size for sensing, different from fft length for tx/rx
self.fft_size = FFT_SIZE
# interpolation rate: sensing fft size / ofdm fft size
self.interp_rate = self.fft_size/options.fft_length
self._fft_length = options.fft_length
self._occupied_tones = options.occupied_tones
self.msgq = gr.msg_queue()
# linklab , setup the sensing path
# FIXME: some components are not necessary
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
# linklab, ref scale value from default ref_scale in usrp_fft.py
ref_scale = 13490.0
# FIXME We need to add 3dB to all bins but the DC bin
self.log = blocks.nlog10_ff(20, self.fft_size,
-10*math.log10(self.fft_size) # Adjust for number of bins
-10*math.log10(power/self.fft_size) # Adjust for windowing loss
-20*math.log10(ref_scale/2)) # Adjust for reference scale
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.fft, self.c2mag, self.avg, self.log, self.sink)
def __init__(self,c_freq, bandwidth):
gr.top_block.__init__(self, "Orig Single Channel")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 200000
self.c_freq = c_freq
self.bandwidth = bandwidth
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(c_freq, 0)
self.uhd_usrp_source_0.set_gain(50, 0)
self.uhd_usrp_source_0.set_bandwidth(bandwidth, 0)
self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, 1024)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, 'mean_power.txt', False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_stream_to_vector_0, 0))
def __init__(self, sample_rate, fft_size, ref_scale, frame_rate, avg_alpha, average, win=None):
"""
Create an log10(abs(fft)) stream chain.
Provide access to the setting the filter and sample rate.
Args:
sample_rate: Incoming stream sample rate
fft_size: Number of FFT bins
ref_scale: Sets 0 dB value input amplitude
frame_rate: Output frame rate
avg_alpha: FFT averaging (over time) constant [0.0-1.0]
average: Whether to average [True, False]
win: the window taps generation function
"""
gr.hier_block2.__init__(self, self._name,
gr.io_signature(1, 1, self._item_size), # Input signature
gr.io_signature(1, 1, gr.sizeof_float*fft_size)) # Output signature
self._sd = blocks.stream_to_vector_decimator(item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=fft_size)
if win is None: win = window.blackmanharris
fft_window = win(fft_size)
fft = self._fft_block[0](fft_size, True, fft_window)
window_power = sum(map(lambda x: x*x, fft_window))
c2magsq = blocks.complex_to_mag_squared(fft_size)
self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
self._log = blocks.nlog10_ff(10, fft_size,
-20*math.log10(fft_size) # Adjust for number of bins
-10*math.log10(window_power/fft_size) # Adjust for windowing loss
-20*math.log10(ref_scale/2)) # Adjust for reference scale
self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self)
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def __init__(self, samp_rate=1600000, samp_per_sym=16, verbose=0, msgq=0, freq_error=-0.0025000): gr.hier_block2.__init__( self, "Wmbus Phy1", gr.io_signature(1, 1, gr.sizeof_gr_complex*1), gr.io_signature(0, 0, 0), ) ################################################## # Parameters ################################################## self.samp_rate = samp_rate self.samp_per_sym = samp_per_sym self.verbose = verbose self.msgq = msgq self.freq_error = freq_error ################################################## # Blocks ################################################## self.wmbus_demod_0 = wmbus_demod( samp_rate=1600000, samp_per_sym=16, freq_error=-0.0025000, ) self.gr_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0) self.gr_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1) self.fir_filter_xxx_0 = gnuradio.filter.fir_filter_fff(samp_per_sym, (16*[1./16])) self.any_sink_0_1 = mbus.framer(msgq, verbose) self.any_0 = mbus.correlate_preamble() ################################################## # Connections ################################################## self.connect((self.any_0, 0), (self.any_sink_0_1, 0)) self.connect((self.gr_complex_to_mag_squared_0, 0), (self.gr_nlog10_ff_0, 0)) self.connect((self.gr_nlog10_ff_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.any_sink_0_1, 1)) self.connect((self, 0), (self.gr_complex_to_mag_squared_0, 0)) self.connect((self, 0), (self.wmbus_demod_0, 0)) self.connect((self.wmbus_demod_0, 0), (self.any_0, 0))
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width,
height):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.tune_freq = tune_freq
self.rate = rate
self.width = width
self.height = height
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self._main = main_thread(self.msgq, self.fft_len, self.sample_rate,
self.tune_freq, self.width, self.height)
def __init__(
self, sample_rate, pspectrum_len, ref_scale,
frame_rate, avg_alpha, average, n, m,
nsamples, estimator = 'esprit'
):
"""
Create an log10(abs(spectrum_estimate)) stream chain.
Provide access to the setting the filter and sample rate.
@param sample_rate Incoming stream sample rate
@param pspectrum_len Number of FFT bins
@param ref_scale Sets 0 dB value input amplitude
@param frame_rate Output frame rate
@param avg_alpha averaging (over time) constant [0.0-1.0]
@param average Whether to average [True, False]
@param n Parameter n for the estimator
@param m Parameter m for the estimator
@param nsamples Number of samples to use for estimation
@param estimator Estimator to use, can be either 'esprit' or 'music'
"""
gr.hier_block2.__init__(self, self._name,
gr.io_signature(1, 1, self._item_size), # Input signature
gr.io_signature(1, 1, gr.sizeof_float*pspectrum_len)) # Output signature
self._sd = blocks.stream_to_vector_decimator(item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=nsamples)
if estimator == 'music':
est = specest.music_spectrum_vcf(n, m, nsamples, pspectrum_len)
else:
est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len)
self._avg = filter.single_pole_iir_filter_ff(1.0, pspectrum_len)
self._log = blocks.nlog10_ff(20, pspectrum_len,
-20*math.log10(pspectrum_len) # Adjust for number of bins
-20*math.log10(ref_scale/2)+3.0) # Adjust for reference scale
self.connect(self, self._sd, est, self._avg, self._log, self)
self._average = average
self._avg_alpha = avg_alpha
self.set_avg_alpha(avg_alpha)
self.set_average(average)
def __init__(self, sample_rate, fac_size, fac_decimation, use_db):
gr.hier_block2.__init__(
self,
"AutoCorrelator",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input sig
gr.io_signature(1, 1, gr.sizeof_float * fac_size)) # Output sig
self.fac_size = fac_size
self.fac_decimation = fac_decimation
self.sample_rate = sample_rate
streamToVec = blocks.stream_to_vector(gr.sizeof_gr_complex,
self.fac_size)
# Make sure N is at least 1
decimation = int(self.sample_rate / self.fac_size /
self.fac_decimation)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size, max(1, decimation))
# FFT Note: No windowing.
fac = fft.fft_vcc(self.fac_size, True, ())
complex2Mag = blocks.complex_to_mag(self.fac_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fac_size)
fac_fac = fft.fft_vfc(self.fac_size, True, ())
fac_c2mag = blocks.complex_to_mag(fac_size)
# There's a note in Baz's block about needing to add 3 dB to each bin but the DC bin, however it was never implemented
n = 20
k = -20 * math.log10(self.fac_size)
log = blocks.nlog10_ff(n, self.fac_size, k)
if use_db:
self.connect(self, streamToVec, self.one_in_n, fac, complex2Mag,
fac_fac, fac_c2mag, self.avg, log, self)
else:
self.connect(self, streamToVec, self.one_in_n, fac, complex2Mag,
fac_fac, fac_c2mag, self.avg, self)
def __init__(self, vlen=64):
gr.hier_block2.__init__(
self,
"Input Layer",
gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen),
gr.io_signature(1, 1, gr.sizeof_float * vlen),
)
# Blocks
fft = fft.fft_vcc(vlen, True, (window.rectangular(vlen)), True, 8)
log = blocks.nlog10_ff(20, vlen, 0)
mag = blocks.complex_to_mag(vlen)
mult = blocks.multiply_const_vcc(([
1. / float(vlen),
] * vlen))
# Connections
self.connect(self, mult)
self.connect(mult, fft)
self.connect(fft, mag)
self.connect(mag, log)
self.connect(log, self)
def __init__(self, bw=250, fftsize=512, infile="/dev/null", outfile="/dev/null", reflvl=-53, srate=2500):
gr.top_block.__init__(self, "Meteor Bb Analyser")
##################################################
# Parameters
##################################################
self.bw = bw
self.fftsize = fftsize
self.infile = infile
self.outfile = outfile
self.reflvl = reflvl
self.srate = srate
##################################################
# Blocks
##################################################
self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(0.75, fftsize)
self.low_pass_filter_0 = filter.fir_filter_ccf(srate/bw, firdes.low_pass(
1, srate, bw/2, bw/4, firdes.WIN_HAMMING, 6.76))
self.fft_vxx_0 = fft.fft_vcc(fftsize, True, (window.blackmanharris(fftsize)), False, 1)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, int(20e3),True)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fftsize)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(20, fftsize, -10*(math.log10(fftsize)))
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*1, infile, True)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*fftsize, outfile, False)
self.blocks_file_sink_0.set_unbuffered(True)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(fftsize)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_file_source_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.single_pole_iir_filter_xx_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_file_sink_0, 0))
def __init__(self):
gr.top_block.__init__(self, name="Doorbell Top Block")
# RF Config
self.threshold_min = -60
self.threshold_max = -50
self.samp_rate = samp_rate = 100e3
self.gain = gain = 30
self.freq = freq = 315e6
self.decimation = 10
# USRP
self.usrp = uhd.usrp_source("", uhd.stream_args("fc32"))
self.usrp.set_samp_rate(samp_rate)
self.usrp.set_center_freq(freq, 0)
self.usrp.set_gain(gain, 0)
self.usrp.set_antenna("TX/RX", 0)
# Low Pass Filter
self.lpf = filter.fir_filter_ccf(self.decimation,
firdes.low_pass(1, samp_rate, 50e3, 10e3, firdes.WIN_HAMMING, 6.76))
# Complex to Power (dB)
self._10log10 = blocks.nlog10_ff(10, 1, 0)
self.complex_to_mag_squared = blocks.complex_to_mag_squared(1)
# Threshold
self.threshold = blocks.threshold_ff(self.threshold_min, self.threshold_max, 0)
# Framer
self.framer = doorbell_framer()
# Connect the blocks
self.connect((self.usrp, 0), (self.lpf, 0))
self.connect((self.lpf, 0), (self.complex_to_mag_squared, 0))
self.connect((self.complex_to_mag_squared, 0), (self._10log10, 0))
self.connect((self._10log10, 0), (self.threshold, 0))
self.connect((self.threshold, 0), (self.framer, 0))
def __init__(self):
gr.hier_block2.__init__(self, "agc",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(1, 1, gr.sizeof_float))
self.split = blocks.multiply_const_ff(1)
self.sqr = blocks.multiply_ff()
self.int0 = filter.iir_filter_ffd([.004, 0], [0, .999])
self.offs = blocks.add_const_ff(-30)
self.gain = blocks.multiply_const_ff(70)
self.log = blocks.nlog10_ff(10, 1)
self.agc = blocks.divide_ff()
self.connect(self, self.split)
self.connect(self.split, (self.agc, 0))
self.connect(self.split, (self.sqr, 0))
self.connect(self.split, (self.sqr, 1))
self.connect(self.sqr, self.int0)
self.connect(self.int0, self.log)
self.connect(self.log, self.offs)
self.connect(self.offs, self.gain)
self.connect(self.gain, (self.agc, 1))
self.connect(self.agc, self)
def __init__( self ):
gr.hier_block2.__init__(self, "agc",
gr.io_signature(1,1,gr.sizeof_float),
gr.io_signature(1,1,gr.sizeof_float))
self.split = blocks.multiply_const_ff( 1 )
self.sqr = blocks.multiply_ff( )
self.int0 = filter.iir_filter_ffd( [.004, 0], [0, .999] )
self.offs = blocks.add_const_ff( -30 )
self.gain = blocks.multiply_const_ff( 70 )
self.log = blocks.nlog10_ff( 10, 1 )
self.agc = blocks.divide_ff( )
self.connect(self, self.split)
self.connect(self.split, (self.agc, 0))
self.connect(self.split, (self.sqr, 0))
self.connect(self.split, (self.sqr, 1))
self.connect(self.sqr, self.int0)
self.connect(self.int0, self.log)
self.connect(self.log, self.offs)
self.connect(self.offs, self.gain)
self.connect(self.gain, (self.agc, 1))
self.connect(self.agc, self)
def __init__(self, samp_rate, decimation, signal_taps, max_overlap=0.25,
threshold=4., fft_size=2048, center_freq=0):
gr.hier_block2.__init__(
self, "Channel Detector",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0),
)
##################################################
# Parameters
##################################################
self.samp_rate = samp_rate
self.decimation = decimation
self.fft_size = fft_size
self.center_freq = center_freq
self.signals_detected_handler = None
##################################################
# Blocks
##################################################
self.fft = fft.fft_vcc(fft_size, True, (fft.window.blackmanharris(fft_size)), True, 1)
self.stream_to_vect = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.log10 = blocks.nlog10_ff(10, fft_size, -10*math.log10(decimation))
self.integrate = blocks.integrate_ff(decimation, fft_size)
self.complex_to_mag_squared = blocks.complex_to_mag_squared(fft_size)
self.sig_det = signal_detector_base(samp_rate, fft_size, signal_taps,
threshold, max_overlap, center_freq=center_freq)
##################################################
# Connections
##################################################
self.connect((self, 0), (self.stream_to_vect, 0))
self.connect((self.stream_to_vect, 0), (self.fft, 0))
self.connect((self.fft, 0), (self.complex_to_mag_squared, 0))
self.connect((self.complex_to_mag_squared, 0), (self.integrate, 0))
self.connect((self.integrate, 0), (self.log10, 0))
self.connect((self.log10, 0), (self.sig_det, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.offset_tune_freq = offset_tune_freq = -10E3
self.band_freq = band_freq = 7.055E6
self.usrp_clk_rate = usrp_clk_rate = 200E6
self.usrp_ask_freq = usrp_ask_freq = band_freq+offset_tune_freq
self.usrp_DDC_freq = usrp_DDC_freq = np.round(usrp_ask_freq/usrp_clk_rate* 2**32)/2**32 * usrp_clk_rate
self.fine_tuner_freq = fine_tuner_freq = 0
self.coarse_tuner_freq = coarse_tuner_freq = 0
self.samp_rate = samp_rate = 250000
self.lo_freq = lo_freq = usrp_DDC_freq + coarse_tuner_freq + fine_tuner_freq - offset_tune_freq
self.record_check_box = record_check_box = False
self.file_name_string = file_name_string = str(int(time.mktime(time.gmtime())))+"UTC_"+'{:.6f}'.format(lo_freq)+"Hz"+"_"+str(int(samp_rate/100))+"sps"+".raw"
self.variable_function_probe_0 = variable_function_probe_0 = 0
self.file_name = file_name = file_name_string if record_check_box==True else "/dev/null"
self.volume = volume = 5.0
self.rx_power_label = rx_power_label = '{:.1f}'.format(variable_function_probe_0)
self.lo_freq_label = lo_freq_label = '{:.6f}'.format(lo_freq)
self.gain_offset_dB = gain_offset_dB = 18.86
self.filter_taps = filter_taps = firdes.low_pass(1.0,2.5,0.1,0.02,firdes.WIN_HAMMING)
self.filename_label = filename_label = file_name
self.cw_filter_bw = cw_filter_bw = 1000
self.RX_power_offset_dB = RX_power_offset_dB = -35.2
##################################################
# Blocks
##################################################
self._volume_layout = Qt.QVBoxLayout()
self._volume_knob = Qwt.QwtKnob()
self._volume_knob.setRange(0, 10.0, 1.0)
self._volume_knob.setValue(self.volume)
self._volume_knob.valueChanged.connect(self.set_volume)
self._volume_layout.addWidget(self._volume_knob)
self._volume_label = Qt.QLabel("Volume")
self._volume_label.setAlignment(Qt.Qt.AlignTop | Qt.Qt.AlignHCenter)
self._volume_layout.addWidget(self._volume_label)
self.top_grid_layout.addLayout(self._volume_layout, 5,6,1,1)
self._cw_filter_bw_options = (100, 500, 1000, )
self._cw_filter_bw_labels = ("100 Hz", "500 Hz", "1 kHz", )
self._cw_filter_bw_tool_bar = Qt.QToolBar(self)
self._cw_filter_bw_tool_bar.addWidget(Qt.QLabel("CW Filter BW"+": "))
self._cw_filter_bw_combo_box = Qt.QComboBox()
self._cw_filter_bw_tool_bar.addWidget(self._cw_filter_bw_combo_box)
for label in self._cw_filter_bw_labels: self._cw_filter_bw_combo_box.addItem(label)
self._cw_filter_bw_callback = lambda i: Qt.QMetaObject.invokeMethod(self._cw_filter_bw_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._cw_filter_bw_options.index(i)))
self._cw_filter_bw_callback(self.cw_filter_bw)
self._cw_filter_bw_combo_box.currentIndexChanged.connect(
lambda i: self.set_cw_filter_bw(self._cw_filter_bw_options[i]))
self.top_grid_layout.addWidget(self._cw_filter_bw_tool_bar, 5,5,1,1)
self.blocks_probe_signal_x_0 = blocks.probe_signal_f()
def _variable_function_probe_0_probe():
while True:
val = self.blocks_probe_signal_x_0.level()
try:
self.set_variable_function_probe_0(val)
except AttributeError:
pass
time.sleep(1.0 / (5))
_variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe)
_variable_function_probe_0_thread.daemon = True
_variable_function_probe_0_thread.start()
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "addr=192.168.40.2")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_subdev_spec("B:A", 0)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(usrp_ask_freq, 0)
self.uhd_usrp_source_0.set_gain(6, 0)
self._rx_power_label_tool_bar = Qt.QToolBar(self)
if None:
self._rx_power_label_formatter = None
else:
self._rx_power_label_formatter = lambda x: x
self._rx_power_label_tool_bar.addWidget(Qt.QLabel("RX Power (dBm)"+": "))
self._rx_power_label_label = Qt.QLabel(str(self._rx_power_label_formatter(self.rx_power_label)))
self._rx_power_label_tool_bar.addWidget(self._rx_power_label_label)
self.top_grid_layout.addWidget(self._rx_power_label_tool_bar, 4,7,1,1)
_record_check_box_check_box = Qt.QCheckBox("Record")
self._record_check_box_choices = {True: True, False: False}
self._record_check_box_choices_inv = dict((v,k) for k,v in self._record_check_box_choices.iteritems())
self._record_check_box_callback = lambda i: Qt.QMetaObject.invokeMethod(_record_check_box_check_box, "setChecked", Qt.Q_ARG("bool", self._record_check_box_choices_inv[i]))
self._record_check_box_callback(self.record_check_box)
_record_check_box_check_box.stateChanged.connect(lambda i: self.set_record_check_box(self._record_check_box_choices[bool(i)]))
self.top_grid_layout.addWidget(_record_check_box_check_box, 6,5,1,1)
self.rational_resampler_xxx_0 = filter.rational_resampler_fff(
interpolation=48000,
decimation=2500,
taps=None,
fractional_bw=None,
)
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
4096, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
usrp_DDC_freq, #fc
samp_rate, #bw
"Band Waterfall", #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(0.10)
self.qtgui_waterfall_sink_x_0.enable_grid(False)
if complex == type(float()):
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ["", "", "", "", "",
"", "", "", "", ""]
colors = [5, 0, 0, 0, 0,
0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-100, -70)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_waterfall_sink_x_0_win, 4,0,3,5)
self.qtgui_freq_sink_x_0_0 = qtgui.freq_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
lo_freq, #fc
samp_rate/100, #bw
str(samp_rate/100) + " Hz Channel Spectrum", #name
2 #number of inputs
)
self.qtgui_freq_sink_x_0_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0_0.set_y_axis(-120, -70)
self.qtgui_freq_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0_0.enable_grid(True)
self.qtgui_freq_sink_x_0_0.set_fft_average(1.0)
if complex == type(float()):
self.qtgui_freq_sink_x_0_0.set_plot_pos_half(not True)
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_0_win, 0,5,3,5)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
4096, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
usrp_DDC_freq, #fc
samp_rate, #bw
"Band Spectrum", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-110, -60)
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(True)
self.qtgui_freq_sink_x_0.set_fft_average(0.2)
if complex == type(float()):
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win, 0,0,3,5)
self.low_pass_filter_0_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate/100, 0.9*cw_filter_bw, 0.1*cw_filter_bw, firdes.WIN_BLACKMAN, 6.76))
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
10**(gain_offset_dB/20), samp_rate, 100E3, 20E3, firdes.WIN_HAMMING, 6.76))
self._lo_freq_label_tool_bar = Qt.QToolBar(self)
if None:
self._lo_freq_label_formatter = None
else:
self._lo_freq_label_formatter = lambda x: x
self._lo_freq_label_tool_bar.addWidget(Qt.QLabel("LO Freq (Hz)"+": "))
self._lo_freq_label_label = Qt.QLabel(str(self._lo_freq_label_formatter(self.lo_freq_label)))
self._lo_freq_label_tool_bar.addWidget(self._lo_freq_label_label)
self.top_grid_layout.addWidget(self._lo_freq_label_tool_bar, 4,6,1,1)
self.hilbert_fc_0_0 = filter.hilbert_fc(65, firdes.WIN_HAMMING, 6.76)
self.hilbert_fc_0 = filter.hilbert_fc(65, firdes.WIN_HAMMING, 6.76)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(10, (filter_taps), lo_freq - usrp_DDC_freq, samp_rate)
self.fir_filter_xxx_0_0_0 = filter.fir_filter_ccc(10, (filter_taps))
self.fir_filter_xxx_0_0_0.declare_sample_delay(0)
self._fine_tuner_freq_layout = Qt.QVBoxLayout()
self._fine_tuner_freq_tool_bar = Qt.QToolBar(self)
self._fine_tuner_freq_layout.addWidget(self._fine_tuner_freq_tool_bar)
self._fine_tuner_freq_tool_bar.addWidget(Qt.QLabel("Fine Tuner (Hz)"+": "))
class qwt_counter_pyslot(Qwt.QwtCounter):
def __init__(self, parent=None):
Qwt.QwtCounter.__init__(self, parent)
@pyqtSlot('double')
def setValue(self, value):
super(Qwt.QwtCounter, self).setValue(value)
self._fine_tuner_freq_counter = qwt_counter_pyslot()
self._fine_tuner_freq_counter.setRange(-500, 500, 1)
self._fine_tuner_freq_counter.setNumButtons(2)
self._fine_tuner_freq_counter.setValue(self.fine_tuner_freq)
self._fine_tuner_freq_tool_bar.addWidget(self._fine_tuner_freq_counter)
self._fine_tuner_freq_counter.valueChanged.connect(self.set_fine_tuner_freq)
self._fine_tuner_freq_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._fine_tuner_freq_slider.setRange(-500, 500, 1)
self._fine_tuner_freq_slider.setValue(self.fine_tuner_freq)
self._fine_tuner_freq_slider.setMinimumWidth(200)
self._fine_tuner_freq_slider.valueChanged.connect(self.set_fine_tuner_freq)
self._fine_tuner_freq_layout.addWidget(self._fine_tuner_freq_slider)
self.top_grid_layout.addLayout(self._fine_tuner_freq_layout, 3,5,1,5)
self._filename_label_tool_bar = Qt.QToolBar(self)
if None:
self._filename_label_formatter = None
else:
self._filename_label_formatter = lambda x: x
self._filename_label_tool_bar.addWidget(Qt.QLabel("File Name"+": "))
self._filename_label_label = Qt.QLabel(str(self._filename_label_formatter(self.filename_label)))
self._filename_label_tool_bar.addWidget(self._filename_label_label)
self.top_grid_layout.addWidget(self._filename_label_tool_bar, 6,6,1,3)
self._coarse_tuner_freq_layout = Qt.QVBoxLayout()
self._coarse_tuner_freq_tool_bar = Qt.QToolBar(self)
self._coarse_tuner_freq_layout.addWidget(self._coarse_tuner_freq_tool_bar)
self._coarse_tuner_freq_tool_bar.addWidget(Qt.QLabel("Coarse Tuner (Hz)"+": "))
class qwt_counter_pyslot(Qwt.QwtCounter):
def __init__(self, parent=None):
Qwt.QwtCounter.__init__(self, parent)
@pyqtSlot('double')
def setValue(self, value):
super(Qwt.QwtCounter, self).setValue(value)
self._coarse_tuner_freq_counter = qwt_counter_pyslot()
self._coarse_tuner_freq_counter.setRange(-samp_rate/2, samp_rate/2, 100)
self._coarse_tuner_freq_counter.setNumButtons(2)
self._coarse_tuner_freq_counter.setValue(self.coarse_tuner_freq)
self._coarse_tuner_freq_tool_bar.addWidget(self._coarse_tuner_freq_counter)
self._coarse_tuner_freq_counter.valueChanged.connect(self.set_coarse_tuner_freq)
self._coarse_tuner_freq_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._coarse_tuner_freq_slider.setRange(-samp_rate/2, samp_rate/2, 100)
self._coarse_tuner_freq_slider.setValue(self.coarse_tuner_freq)
self._coarse_tuner_freq_slider.setMinimumWidth(50)
self._coarse_tuner_freq_slider.valueChanged.connect(self.set_coarse_tuner_freq)
self._coarse_tuner_freq_layout.addWidget(self._coarse_tuner_freq_slider)
self.top_grid_layout.addLayout(self._coarse_tuner_freq_layout, 3,0,1,5)
self.blocks_null_sink_1_0_0 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_null_sink_1_0 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, RX_power_offset_dB)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_integrate_xx_0 = blocks.integrate_ff(500)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, file_name, False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.blocks_complex_to_float_1_0 = blocks.complex_to_float(1)
self.blocks_complex_to_float_0_0 = blocks.complex_to_float(1)
self.blocks_complex_to_float_0 = blocks.complex_to_float(1)
self.blocks_add_xx_0 = blocks.add_vff(1)
self._band_freq_options = [1.84E6, 3.598E6, 7.055E6, 2.5E6, 5.0E6, 10.0E6]
self._band_freq_labels = ["160m", "80m", "40m", "2.5 MHz", "5 MHz", "10 MHz"]
self._band_freq_tool_bar = Qt.QToolBar(self)
self._band_freq_tool_bar.addWidget(Qt.QLabel("Band"+": "))
self._band_freq_combo_box = Qt.QComboBox()
self._band_freq_tool_bar.addWidget(self._band_freq_combo_box)
for label in self._band_freq_labels: self._band_freq_combo_box.addItem(label)
self._band_freq_callback = lambda i: Qt.QMetaObject.invokeMethod(self._band_freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._band_freq_options.index(i)))
self._band_freq_callback(self.band_freq)
self._band_freq_combo_box.currentIndexChanged.connect(
lambda i: self.set_band_freq(self._band_freq_options[i]))
self.top_grid_layout.addWidget(self._band_freq_tool_bar, 4,5,1,1)
self.audio_sink_0 = audio.sink(48000, "", True)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate/100, analog.GR_COS_WAVE, 600, 1, 0)
self.analog_agc3_xx_0 = analog.agc3_cc(1e-1, 1e-4, volume/100, 1, 1)
self.analog_agc3_xx_0.set_max_gain(2**16)
##################################################
# Connections
##################################################
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.fir_filter_xxx_0_0_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.fir_filter_xxx_0_0_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.fir_filter_xxx_0_0_0, 0), (self.low_pass_filter_0_0, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.low_pass_filter_0_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.low_pass_filter_0_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0))
self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_probe_signal_x_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.qtgui_waterfall_sink_x_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.analog_agc3_xx_0, 0))
self.connect((self.analog_agc3_xx_0, 0), (self.blocks_complex_to_float_1_0, 0))
self.connect((self.fir_filter_xxx_0_0_0, 0), (self.qtgui_freq_sink_x_0_0, 0))
self.connect((self.blocks_add_xx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.audio_sink_0, 0))
self.connect((self.blocks_complex_to_float_0, 0), (self.blocks_add_xx_0, 1))
self.connect((self.blocks_complex_to_float_0_0, 1), (self.blocks_add_xx_0, 0))
self.connect((self.blocks_complex_to_float_0_0, 0), (self.blocks_null_sink_1_0_0, 0))
self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_null_sink_1_0, 0))
self.connect((self.blocks_complex_to_float_1_0, 1), (self.hilbert_fc_0, 0))
self.connect((self.hilbert_fc_0, 0), (self.blocks_complex_to_float_0, 0))
self.connect((self.blocks_complex_to_float_1_0, 0), (self.hilbert_fc_0_0, 0))
self.connect((self.hilbert_fc_0_0, 0), (self.blocks_complex_to_float_0_0, 0))
self.connect((self.low_pass_filter_0_0, 0), (self.qtgui_freq_sink_x_0_0, 1))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Output Window")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.threshold = threshold = -55
self.samp_rate = samp_rate = 2.048e6
self.freq = freq = 658e6
self.fft_size = fft_size = 1.024e3
##################################################
# Blocks
##################################################
self.notebook = self.notebook = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Spectrum")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Output")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Stream")
self.Add(self.notebook)
_threshold_sizer = wx.BoxSizer(wx.VERTICAL)
self._threshold_text_box = forms.text_box(
parent=self.notebook.GetPage(1).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.notebook.GetPage(1).GetWin(),
sizer=_threshold_sizer,
value=self.threshold,
callback=self.set_threshold,
minimum=-100,
maximum=0,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.notebook.GetPage(1).Add(_threshold_sizer)
_freq_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_text_box = forms.text_box(
parent=self.notebook.GetPage(0).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.notebook.GetPage(0).GetWin(),
sizer=_freq_sizer,
value=self.freq,
callback=self.set_freq,
minimum=10e6,
maximum=10e9,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.notebook.GetPage(0).Add(_freq_sizer)
self.wxgui_numbersink2_1 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="signal present",
minval=0,
maxval=1,
factor=1,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=None,
label="Signal Detection",
peak_hold=False,
show_gauge=True,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_1.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="dB",
minval=-120,
maxval=0,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=30e-3,
label="level",
peak_hold=False,
show_gauge=False,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.notebook.GetPage(0).GetWin(),
baseband_freq=freq,
y_per_div=5,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=30e-3,
title="Spectrum",
peak_hold=False,
win=window.rectangular,
)
self.notebook.GetPage(0).Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(20, 0)
self.rtlsdr_source_0.set_if_gain(10, 0)
self.rtlsdr_source_0.set_bb_gain(5, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.fft_1 = fft.fft_vcc(1024, True, (window.rectangular(1024)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, 1024)
self.blocks_threshold_ff_0 = blocks.threshold_ff(-100, threshold, 0)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, "/media/shashwat/DATA/Q3/Wireless Networking/gnu codes/Outputs/db_498", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1024)
self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 1.04858e6)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_divide_xx_0, 1))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_divide_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_1, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_numbersink2_1, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_divide_xx_0, 0))
self.connect((self.fft_1, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Rfile Non Rfnoc")
Qt.QWidget.__init__(self)
self.setWindowTitle("Rfile Non Rfnoc")
try:
self.setWindowIcon(Qt.QIcon.fromTheme("gnuradio-grc"))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "rfile_non_RFNoC")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 12.5e6
self.fft_size = fft_size = 625
self.num_ch = num_ch = 56
self.mywindow = mywindow = window.blackmanharris(fft_size)
self.hz_per_bin = hz_per_bin = samp_rate / fft_size
self.bandwidth = bandwidth = 10.08e6
self.window_power = window_power = sum(map(lambda x: x * x, mywindow))
self.meas_interval = meas_interval = 1e-3
self.impedance = impedance = 50.0
self.channel_bw = channel_bw = hz_per_bin * round(bandwidth / num_ch / hz_per_bin)
self.rx_gain = rx_gain = 0
self.meas_period = meas_period = max(1, int(round(meas_interval * samp_rate / fft_size)))
self.dest_host = dest_host = "129.6.142.138"
self.center_freq = center_freq = 724e6
self.Vsq2W_dB = Vsq2W_dB = -10.0 * math.log10(fft_size * int(window_power) * impedance)
self.ActualBW = ActualBW = channel_bw * num_ch
##################################################
# Blocks
##################################################
self._samp_rate_options = (12.5e6, 15.36e6, 7.68e6, 3.84e6, 1.92e6)
self._samp_rate_labels = ("12.5e6", "15.36e6", "7.68e6", "3.84e6", "1.92e6")
self._samp_rate_group_box = Qt.QGroupBox("samp_rate")
self._samp_rate_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._samp_rate_button_group = variable_chooser_button_group()
self._samp_rate_group_box.setLayout(self._samp_rate_box)
for i, label in enumerate(self._samp_rate_labels):
radio_button = Qt.QRadioButton(label)
self._samp_rate_box.addWidget(radio_button)
self._samp_rate_button_group.addButton(radio_button, i)
self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._samp_rate_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._samp_rate_options.index(i))
)
self._samp_rate_callback(self.samp_rate)
self._samp_rate_button_group.buttonClicked[int].connect(
lambda i: self.set_samp_rate(self._samp_rate_options[i])
)
self.top_layout.addWidget(self._samp_rate_group_box)
self._rx_gain_range = Range(0, 31.5, 0.5, 0, 200)
self._rx_gain_win = RangeWidget(self._rx_gain_range, self.set_rx_gain, "rx_gain", "counter_slider", float)
self.top_layout.addWidget(self._rx_gain_win)
self._num_ch_options = (56, 50, 25, 15, 8)
self._num_ch_labels = ("56", "50", "25", "15", "8")
self._num_ch_group_box = Qt.QGroupBox("num_ch")
self._num_ch_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._num_ch_button_group = variable_chooser_button_group()
self._num_ch_group_box.setLayout(self._num_ch_box)
for i, label in enumerate(self._num_ch_labels):
radio_button = Qt.QRadioButton(label)
self._num_ch_box.addWidget(radio_button)
self._num_ch_button_group.addButton(radio_button, i)
self._num_ch_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._num_ch_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._num_ch_options.index(i))
)
self._num_ch_callback(self.num_ch)
self._num_ch_button_group.buttonClicked[int].connect(lambda i: self.set_num_ch(self._num_ch_options[i]))
self.top_layout.addWidget(self._num_ch_group_box)
self._fft_size_options = (625, 1024, 512, 256, 128)
self._fft_size_labels = ("625", "1024", "512", "256", "128")
self._fft_size_tool_bar = Qt.QToolBar(self)
self._fft_size_tool_bar.addWidget(Qt.QLabel("fft_size" + ": "))
self._fft_size_combo_box = Qt.QComboBox()
self._fft_size_tool_bar.addWidget(self._fft_size_combo_box)
for label in self._fft_size_labels:
self._fft_size_combo_box.addItem(label)
self._fft_size_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._fft_size_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._fft_size_options.index(i))
)
self._fft_size_callback(self.fft_size)
self._fft_size_combo_box.currentIndexChanged.connect(lambda i: self.set_fft_size(self._fft_size_options[i]))
self.top_layout.addWidget(self._fft_size_tool_bar)
self._dest_host_options = ("pwct1.ctl.nist.gov", "129.6.230.12", "129.6.142.181", "129.6.142.138")
self._dest_host_labels = ("pwct1", "Naceur Laptop", "pwct5Desktop", "Pwct5")
self._dest_host_tool_bar = Qt.QToolBar(self)
self._dest_host_tool_bar.addWidget(Qt.QLabel(dest_host + ": "))
self._dest_host_combo_box = Qt.QComboBox()
self._dest_host_tool_bar.addWidget(self._dest_host_combo_box)
for label in self._dest_host_labels:
self._dest_host_combo_box.addItem(label)
self._dest_host_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._dest_host_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._dest_host_options.index(i))
)
self._dest_host_callback(self.dest_host)
self._dest_host_combo_box.currentIndexChanged.connect(lambda i: self.set_dest_host(self._dest_host_options[i]))
self.top_layout.addWidget(self._dest_host_tool_bar)
self._center_freq_options = (709.01e6, 782e6, 724e6)
self._center_freq_labels = ("AT&T", "Verizon", "ChannelEmulator")
self._center_freq_tool_bar = Qt.QToolBar(self)
self._center_freq_tool_bar.addWidget(Qt.QLabel("center_freq" + ": "))
self._center_freq_combo_box = Qt.QComboBox()
self._center_freq_tool_bar.addWidget(self._center_freq_combo_box)
for label in self._center_freq_labels:
self._center_freq_combo_box.addItem(label)
self._center_freq_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._center_freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._center_freq_options.index(i))
)
self._center_freq_callback(self.center_freq)
self._center_freq_combo_box.currentIndexChanged.connect(
lambda i: self.set_center_freq(self._center_freq_options[i])
)
self.top_layout.addWidget(self._center_freq_tool_bar)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("addr=172.16.20.2", "")), uhd.stream_args(cpu_format="fc32", channels=range(1))
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
self.uhd_usrp_source_0.set_gain(rx_gain, 0)
self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
self.myblocks_sslsocket_sink_0 = myblocks.sslsocket_sink(
num_ch,
dest_host,
"/home/naceur/Documents/spectrum_monitor_sensors/gr-myblocks/examples/utils/sensor.loc",
"/home/naceur/Documents/spectrum_monitor_sensors/gr-myblocks/examples/utils/sensor.sys",
"E6R16W5XS",
"NaN",
center_freq,
ActualBW,
meas_interval,
0,
)
self.myblocks_bin_statistics_0 = myblocks.bin_statistics(num_ch, meas_period)
self.myblocks_bin_aggregator_0 = myblocks.bin_aggregator(
fft_size, num_ch, samp_rate, fft_size, center_freq, ActualBW, channel_bw, [0] * fft_size
)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (mywindow), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, num_ch, 30.0 + Vsq2W_dB)
self.blocks_float_to_char_0 = blocks.float_to_char(num_ch, 1.0)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
self._bandwidth_options = (10.08e6, 9e6, 4.5e6, 2.7e6, 1.08e6)
self._bandwidth_labels = ("10.08e6", "9e6", "4.5e6", "2.7e6", "1.08e6")
self._bandwidth_tool_bar = Qt.QToolBar(self)
self._bandwidth_tool_bar.addWidget(Qt.QLabel("bandwidth" + ": "))
self._bandwidth_combo_box = Qt.QComboBox()
self._bandwidth_tool_bar.addWidget(self._bandwidth_combo_box)
for label in self._bandwidth_labels:
self._bandwidth_combo_box.addItem(label)
self._bandwidth_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._bandwidth_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._bandwidth_options.index(i))
)
self._bandwidth_callback(self.bandwidth)
self._bandwidth_combo_box.currentIndexChanged.connect(lambda i: self.set_bandwidth(self._bandwidth_options[i]))
self.top_layout.addWidget(self._bandwidth_tool_bar)
##################################################
# Connections
##################################################
self.connect((self.blocks_float_to_char_0, 0), (self.myblocks_sslsocket_sink_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_float_to_char_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.myblocks_bin_aggregator_0, 0), (self.myblocks_bin_statistics_0, 0))
self.connect((self.myblocks_bin_statistics_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.myblocks_bin_aggregator_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 7.5e6
self.decim = decim = 150
self.xlate_bw = xlate_bw = 25e3
self.usrp_gain = usrp_gain = 33
self.rx_antenna = rx_antenna = "RX2"
self.port = port = 47110
self.phase = phase = 0
self.mlen = mlen = 100
self.keep_plot = keep_plot = 16
self.keep = keep = 1
self.ip = ip = "localhost"
self.freq_offset = freq_offset = 200e3
self.fire = fire = 0
self.device_args = device_args = "type=x300, master_clock_rate=150e6"
self.calib_freq_offset = calib_freq_offset = 2e6
self.cal_freq = cal_freq = 450e6
self.baseband_rate = baseband_rate = int(samp_rate/decim)
self.angular_resolution = angular_resolution = 360
self.N_keep = N_keep = 1000
self.N = N = 512
self.M_keep = M_keep = 100
##################################################
# Blocks
##################################################
self.tabw = Qt.QTabWidget()
self.tabw_widget_0 = Qt.QWidget()
self.tabw_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tabw_widget_0)
self.tabw_grid_layout_0 = Qt.QGridLayout()
self.tabw_layout_0.addLayout(self.tabw_grid_layout_0)
self.tabw.addTab(self.tabw_widget_0, "Synchronization Setup")
self.tabw_widget_1 = Qt.QWidget()
self.tabw_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tabw_widget_1)
self.tabw_grid_layout_1 = Qt.QGridLayout()
self.tabw_layout_1.addLayout(self.tabw_grid_layout_1)
self.tabw.addTab(self.tabw_widget_1, "DOA")
self.top_layout.addWidget(self.tabw)
self._xlate_bw_layout = Qt.QVBoxLayout()
self._xlate_bw_tool_bar = Qt.QToolBar(self)
self._xlate_bw_layout.addWidget(self._xlate_bw_tool_bar)
self._xlate_bw_tool_bar.addWidget(Qt.QLabel("Xlate Bandwidth"+": "))
self._xlate_bw_counter = Qwt.QwtCounter()
self._xlate_bw_counter.setRange(0, baseband_rate, 1)
self._xlate_bw_counter.setNumButtons(2)
self._xlate_bw_counter.setValue(self.xlate_bw)
self._xlate_bw_tool_bar.addWidget(self._xlate_bw_counter)
self._xlate_bw_counter.valueChanged.connect(self.set_xlate_bw)
self._xlate_bw_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._xlate_bw_slider.setRange(0, baseband_rate, 1)
self._xlate_bw_slider.setValue(self.xlate_bw)
self._xlate_bw_slider.setMinimumWidth(200)
self._xlate_bw_slider.valueChanged.connect(self.set_xlate_bw)
self._xlate_bw_layout.addWidget(self._xlate_bw_slider)
self.tabw_grid_layout_0.addLayout(self._xlate_bw_layout, 0,2,1,1)
self._phase_layout = Qt.QVBoxLayout()
self._phase_tool_bar = Qt.QToolBar(self)
self._phase_layout.addWidget(self._phase_tool_bar)
self._phase_tool_bar.addWidget(Qt.QLabel("phase"+": "))
self._phase_counter = Qwt.QwtCounter()
self._phase_counter.setRange(-3, 3, 0.001)
self._phase_counter.setNumButtons(2)
self._phase_counter.setValue(self.phase)
self._phase_tool_bar.addWidget(self._phase_counter)
self._phase_counter.valueChanged.connect(self.set_phase)
self._phase_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._phase_slider.setRange(-3, 3, 0.001)
self._phase_slider.setValue(self.phase)
self._phase_slider.setMinimumWidth(200)
self._phase_slider.valueChanged.connect(self.set_phase)
self._phase_layout.addWidget(self._phase_slider)
self.top_layout.addLayout(self._phase_layout)
self._keep_tool_bar = Qt.QToolBar(self)
self._keep_tool_bar.addWidget(Qt.QLabel("Keep input vectors"+": "))
self._keep_line_edit = Qt.QLineEdit(str(self.keep))
self._keep_tool_bar.addWidget(self._keep_line_edit)
self._keep_line_edit.returnPressed.connect(
lambda: self.set_keep(int(self._keep_line_edit.text().toAscii())))
self.tabw_grid_layout_1.addWidget(self._keep_tool_bar, 2,1,1,1)
self._freq_offset_layout = Qt.QVBoxLayout()
self._freq_offset_tool_bar = Qt.QToolBar(self)
self._freq_offset_layout.addWidget(self._freq_offset_tool_bar)
self._freq_offset_tool_bar.addWidget(Qt.QLabel("Xlate Freq. Offset"+": "))
self._freq_offset_counter = Qwt.QwtCounter()
self._freq_offset_counter.setRange(-samp_rate/2, samp_rate/2, 1)
self._freq_offset_counter.setNumButtons(2)
self._freq_offset_counter.setValue(self.freq_offset)
self._freq_offset_tool_bar.addWidget(self._freq_offset_counter)
self._freq_offset_counter.valueChanged.connect(self.set_freq_offset)
self._freq_offset_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._freq_offset_slider.setRange(-samp_rate/2, samp_rate/2, 1)
self._freq_offset_slider.setValue(self.freq_offset)
self._freq_offset_slider.setMinimumWidth(200)
self._freq_offset_slider.valueChanged.connect(self.set_freq_offset)
self._freq_offset_layout.addWidget(self._freq_offset_slider)
self.tabw_grid_layout_0.addLayout(self._freq_offset_layout, 0,1,1,1)
self.xlate_interleave_0 = xlate_interleave(
samp_rate=samp_rate,
decim=decim,
freq_offset=freq_offset,
xlate_bw=xlate_bw,
)
self._usrp_gain_tool_bar = Qt.QToolBar(self)
self._usrp_gain_tool_bar.addWidget(Qt.QLabel("USRP RF Gain"+": "))
self._usrp_gain_line_edit = Qt.QLineEdit(str(self.usrp_gain))
self._usrp_gain_tool_bar.addWidget(self._usrp_gain_line_edit)
self._usrp_gain_line_edit.returnPressed.connect(
lambda: self.set_usrp_gain(eng_notation.str_to_num(self._usrp_gain_line_edit.text().toAscii())))
self.tabw_grid_layout_0.addWidget(self._usrp_gain_tool_bar, 0,3,1,1)
self.qtgui_time_sink_x_1 = qtgui.time_sink_f(
angular_resolution, #size
1.0/1000.0, #samp_rate
"MUSIC Spectrum", #name
1 #number of inputs
)
self.qtgui_time_sink_x_1.set_update_time(0.10)
self.qtgui_time_sink_x_1.set_y_axis(-3.0, 20.0)
self.qtgui_time_sink_x_1.enable_tags(-1, False)
self.qtgui_time_sink_x_1.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self._qtgui_time_sink_x_1_win = sip.wrapinstance(self.qtgui_time_sink_x_1.pyqwidget(), Qt.QWidget)
self.tabw_grid_layout_1.addWidget(self._qtgui_time_sink_x_1_win, 0,0,2,1)
self.missile_launcher_0 = misc.async_missile_launcher(azimuth=0.0, elevation=25.0, threshold=0.0, recal_threshold=0.0)
self.misc_numbersink_0 = misc.numbersink(float, "Angle", "Degrees", samp_rate, 0, 360, 1.0, 10, 0.0, 15, False, 0, "Angle", False, True)
self._misc_numbersink_0_win = self.misc_numbersink_0.get_pyqwidget()
self.tabw_grid_layout_1.addWidget(self._misc_numbersink_0_win, 1,1,1,1)
self.misc_music_doa_1 = misc.music_doa_helper(m=2, n=1, nsamples=N, angular_resolution=angular_resolution, frequency=cal_freq, array_spacing=0.132, antenna_array=[[0,0],[1,0]], output_spectrum=True)
self.misc_compass_0 = misc.compass(False, "nice", "simple", 15)
self._misc_compass_0_win = self.misc_compass_0.get_pyqwidget()
self.tabw_grid_layout_1.addWidget(self._misc_compass_0_win, 0,1,1,1)
self._fire_tool_bar = Qt.QToolBar(self)
self._fire_tool_bar.addWidget(Qt.QLabel("FIRE!"+": "))
self._fire_line_edit = Qt.QLineEdit(str(self.fire))
self._fire_tool_bar.addWidget(self._fire_line_edit)
self._fire_line_edit.returnPressed.connect(
lambda: self.set_fire(int(self._fire_line_edit.text().toAscii())))
self.tabw_grid_layout_1.addWidget(self._fire_tool_bar, 2,0,1,1)
self._calib_freq_offset_layout = Qt.QVBoxLayout()
self._calib_freq_offset_tool_bar = Qt.QToolBar(self)
self._calib_freq_offset_layout.addWidget(self._calib_freq_offset_tool_bar)
self._calib_freq_offset_tool_bar.addWidget(Qt.QLabel("Calibration Tone Offset"+": "))
self._calib_freq_offset_counter = Qwt.QwtCounter()
self._calib_freq_offset_counter.setRange(-samp_rate/2, samp_rate/2, 1)
self._calib_freq_offset_counter.setNumButtons(2)
self._calib_freq_offset_counter.setValue(self.calib_freq_offset)
self._calib_freq_offset_tool_bar.addWidget(self._calib_freq_offset_counter)
self._calib_freq_offset_counter.valueChanged.connect(self.set_calib_freq_offset)
self._calib_freq_offset_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._calib_freq_offset_slider.setRange(-samp_rate/2, samp_rate/2, 1)
self._calib_freq_offset_slider.setValue(self.calib_freq_offset)
self._calib_freq_offset_slider.setMinimumWidth(200)
self._calib_freq_offset_slider.valueChanged.connect(self.set_calib_freq_offset)
self._calib_freq_offset_layout.addWidget(self._calib_freq_offset_slider)
self.tabw_grid_layout_0.addLayout(self._calib_freq_offset_layout, 0,0,1,1)
self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream(gr.sizeof_float*1, angular_resolution)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, N)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, angular_resolution, 0)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((math.e**(1.0j*phase), ))
self.blocks_keep_one_in_n_1 = blocks.keep_one_in_n(gr.sizeof_float*angular_resolution, keep_plot)
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_gr_complex*N, keep)
self.blocks_add_const_vxx_0 = blocks.add_const_vff((0, ))
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 200e3, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.blocks_keep_one_in_n_0, 0), (self.misc_music_doa_1, 0))
self.connect((self.misc_music_doa_1, 0), (self.blocks_add_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.xlate_interleave_0, 1))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.blocks_throttle_0, 0), (self.xlate_interleave_0, 0))
self.connect((self.xlate_interleave_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.blocks_keep_one_in_n_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self.misc_numbersink_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self.missile_launcher_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self.misc_compass_0, 0))
self.connect((self.misc_music_doa_1, 1), (self.blocks_null_sink_0, 0))
self.connect((self.blocks_keep_one_in_n_1, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_vector_to_stream_0_0, 0))
self.connect((self.misc_music_doa_1, 2), (self.blocks_keep_one_in_n_1, 0))
self.connect((self.blocks_vector_to_stream_0_0, 0), (self.qtgui_time_sink_x_1, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
##################################################
# Variables
##################################################
self.threshold = threshold = -70
self.samp_rate = samp_rate = 2048000
self.freq = freq = 525200000
self.fft_size = fft_size = 1024
##################################################
# 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=-100,
maximum=0,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_threshold_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=478000000,
maximum=862000000,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_freq_sizer)
self.wxgui_numbersink2_1 = numbersink2.number_sink_f(
self.GetWin(),
unit="signal present",
minval=0,
maxval=1,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=None,
label="Signal Detection",
peak_hold=False,
show_gauge=True,
)
self.Add(self.wxgui_numbersink2_1.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.GetWin(),
unit="dB",
minval=-120,
maxval=0,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=True,
avg_alpha=0.030,
label="Level",
peak_hold=False,
show_gauge=True,
)
self.Add(self.wxgui_numbersink2_0.win)
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=fft_size,
fft_rate=15,
average=True,
avg_alpha=0.03,
title="Spectrum",
peak_hold=False,
win=window.rectangular,
)
self.Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_1 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_1.set_sample_rate(samp_rate)
self.rtlsdr_source_1.set_center_freq(freq, 0)
self.rtlsdr_source_1.set_freq_corr(0, 0)
self.rtlsdr_source_1.set_dc_offset_mode(0, 0)
self.rtlsdr_source_1.set_iq_balance_mode(0, 0)
self.rtlsdr_source_1.set_gain_mode(False, 0)
self.rtlsdr_source_1.set_gain(20, 0)
self.rtlsdr_source_1.set_if_gain(10, 0)
self.rtlsdr_source_1.set_bb_gain(5, 0)
self.rtlsdr_source_1.set_antenna("", 0)
self.rtlsdr_source_1.set_bandwidth(1, 0)
self.notebook = self.notebook = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "spectrum")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "output")
self.Add(self.notebook)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_size)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True)
self.blocks_threshold_ff_0 = blocks.threshold_ff(-100, threshold, threshold)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, fft_size*fft_size)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_divide_xx_0, 1))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_divide_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_numbersink2_1, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_divide_xx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rtlsdr_source_1, 0), (self.blocks_throttle_0, 0))
self.connect((self.rtlsdr_source_1, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Msod Sslsensor N210")
Qt.QWidget.__init__(self)
self.setWindowTitle("Msod Sslsensor N210")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "MSOD_SSLSensor_N210")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 12.5e6
self.fft_size = fft_size = 625
self.num_ch = num_ch = 56
self.mywindow = mywindow = window.blackmanharris(fft_size)
self.hz_per_bin = hz_per_bin = samp_rate / fft_size
self.bandwidth = bandwidth = 10.08e6
self.window_power = window_power = sum(map(lambda x: x*x, mywindow))
self.meas_interval = meas_interval = 1e-3
self.impedance = impedance = 50.0
self.channel_bw = channel_bw = hz_per_bin * round(bandwidth / num_ch / hz_per_bin)
self.device3 = variable_uhd_device3_0 = ettus.device3(uhd.device_addr_t( ",".join(('type=x300, addr=usrp02', "")) ))
self.rx_gain = rx_gain = 0
self.meas_period = meas_period = max(1, int(round(meas_interval * samp_rate / fft_size)))
self.dest_host = dest_host = "129.6.142.103"
self.center_freq = center_freq = 724e6
self.Vsq2W_dB = Vsq2W_dB = -10.0 * math.log10(fft_size * int(window_power) * impedance)
self.ActualBW = ActualBW = channel_bw * num_ch
##################################################
# Blocks
##################################################
self._samp_rate_options = (12.5e6, 15.36e6, 7.68e6, 3.84e6, 1.92e6, )
self._samp_rate_labels = ('12.5e6', '15.36e6', '7.68e6', '3.84e6', '1.92e6', )
self._samp_rate_group_box = Qt.QGroupBox('samp_rate')
self._samp_rate_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._samp_rate_button_group = variable_chooser_button_group()
self._samp_rate_group_box.setLayout(self._samp_rate_box)
for i, label in enumerate(self._samp_rate_labels):
radio_button = Qt.QRadioButton(label)
self._samp_rate_box.addWidget(radio_button)
self._samp_rate_button_group.addButton(radio_button, i)
self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(self._samp_rate_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._samp_rate_options.index(i)))
self._samp_rate_callback(self.samp_rate)
self._samp_rate_button_group.buttonClicked[int].connect(
lambda i: self.set_samp_rate(self._samp_rate_options[i]))
self.top_layout.addWidget(self._samp_rate_group_box)
self._rx_gain_range = Range(0, 31.5, 0.5, 0, 200)
self._rx_gain_win = RangeWidget(self._rx_gain_range, self.set_rx_gain, 'rx_gain', "counter_slider", float)
self.top_layout.addWidget(self._rx_gain_win)
self._num_ch_options = (56, 50, 25, 15, 8, )
self._num_ch_labels = ('56', '50', '25', '15', '8', )
self._num_ch_group_box = Qt.QGroupBox('num_ch')
self._num_ch_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._num_ch_button_group = variable_chooser_button_group()
self._num_ch_group_box.setLayout(self._num_ch_box)
for i, label in enumerate(self._num_ch_labels):
radio_button = Qt.QRadioButton(label)
self._num_ch_box.addWidget(radio_button)
self._num_ch_button_group.addButton(radio_button, i)
self._num_ch_callback = lambda i: Qt.QMetaObject.invokeMethod(self._num_ch_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._num_ch_options.index(i)))
self._num_ch_callback(self.num_ch)
self._num_ch_button_group.buttonClicked[int].connect(
lambda i: self.set_num_ch(self._num_ch_options[i]))
self.top_layout.addWidget(self._num_ch_group_box)
self._fft_size_options = (625, 1024, 512, 256, 128, )
self._fft_size_labels = ('625', '1024', '512', '256', '128', )
self._fft_size_tool_bar = Qt.QToolBar(self)
self._fft_size_tool_bar.addWidget(Qt.QLabel('fft_size'+": "))
self._fft_size_combo_box = Qt.QComboBox()
self._fft_size_tool_bar.addWidget(self._fft_size_combo_box)
for label in self._fft_size_labels: self._fft_size_combo_box.addItem(label)
self._fft_size_callback = lambda i: Qt.QMetaObject.invokeMethod(self._fft_size_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._fft_size_options.index(i)))
self._fft_size_callback(self.fft_size)
self._fft_size_combo_box.currentIndexChanged.connect(
lambda i: self.set_fft_size(self._fft_size_options[i]))
self.top_layout.addWidget(self._fft_size_tool_bar)
self._center_freq_options = (709.01e6, 782e6, 724e6, )
self._center_freq_labels = ('AT&T', 'Verizon', 'ChannelEmulator', )
self._center_freq_tool_bar = Qt.QToolBar(self)
self._center_freq_tool_bar.addWidget(Qt.QLabel('center_freq'+": "))
self._center_freq_combo_box = Qt.QComboBox()
self._center_freq_tool_bar.addWidget(self._center_freq_combo_box)
for label in self._center_freq_labels: self._center_freq_combo_box.addItem(label)
self._center_freq_callback = lambda i: Qt.QMetaObject.invokeMethod(self._center_freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._center_freq_options.index(i)))
self._center_freq_callback(self.center_freq)
self._center_freq_combo_box.currentIndexChanged.connect(
lambda i: self.set_center_freq(self._center_freq_options[i]))
self.top_layout.addWidget(self._center_freq_tool_bar)
self._bandwidth_options = (10.08e6, 9e6, 4.5e6, 2.7e6, 1.08e6, )
self._bandwidth_labels = ('10.08e6', '9e6', '4.5e6', '2.7e6', '1.08e6', )
self._bandwidth_tool_bar = Qt.QToolBar(self)
self._bandwidth_tool_bar.addWidget(Qt.QLabel('bandwidth'+": "))
self._bandwidth_combo_box = Qt.QComboBox()
self._bandwidth_tool_bar.addWidget(self._bandwidth_combo_box)
for label in self._bandwidth_labels: self._bandwidth_combo_box.addItem(label)
self._bandwidth_callback = lambda i: Qt.QMetaObject.invokeMethod(self._bandwidth_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._bandwidth_options.index(i)))
self._bandwidth_callback(self.bandwidth)
self._bandwidth_combo_box.currentIndexChanged.connect(
lambda i: self.set_bandwidth(self._bandwidth_options[i]))
self.top_layout.addWidget(self._bandwidth_tool_bar)
self.uhd_rfnoc_streamer_radio_0 = ettus.rfnoc_radio(
self.device3,
uhd.stream_args( # Tx Stream Args
cpu_format="fc32",
otw_format="sc16",
args="", # empty
),
uhd.stream_args( # Rx Stream Args
cpu_format="fc32",
otw_format="sc16",
args='',
),
1, -1
)
self.uhd_rfnoc_streamer_radio_0.set_rate(samp_rate)
for i in xrange(1):
self.uhd_rfnoc_streamer_radio_0.set_rx_freq(center_freq, i)
self.uhd_rfnoc_streamer_radio_0.set_rx_gain(rx_gain, i)
self.uhd_rfnoc_streamer_radio_0.set_rx_antenna("RX2", i)
self.uhd_rfnoc_streamer_radio_0.set_rx_dc_offset(True, i)
self.spectrum_latency_jsonfile_sink_0 = spectrum_latency.jsonfile_sink(num_ch, "/home/nae/Spectrum-Sensors/N210/Capture.N210/10-25-2016", "/raid/nae/gnuradio/src/gr-spectrum_latency/examples/utils/sensor.loc", "/raid/nae/gnuradio/src/gr-spectrum_latency/examples/utils/sensor.sys", "F37258", "12345", center_freq, bandwidth, meas_interval, 0, samp_rate, False)
self.spectrum_latency_bin_statistics_0 = spectrum_latency.bin_statistics(num_ch, meas_period)
self.spectrum_latency_bin_aggregator_0 = spectrum_latency.bin_aggregator(fft_size, num_ch, samp_rate, fft_size, center_freq, ActualBW, channel_bw, [0] * fft_size)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (mywindow), True, 1)
self._dest_host_options = ("pwct1.ctl.nist.gov", "129.6.142.103", "129.6.142.181", "pwct5.ctl.nist.gov", )
self._dest_host_labels = ('pwct1', 'NEO_VM', 'pwct5Desktop', 'Pwct5', )
self._dest_host_tool_bar = Qt.QToolBar(self)
self._dest_host_tool_bar.addWidget(Qt.QLabel(dest_host+": "))
self._dest_host_combo_box = Qt.QComboBox()
self._dest_host_tool_bar.addWidget(self._dest_host_combo_box)
for label in self._dest_host_labels: self._dest_host_combo_box.addItem(label)
self._dest_host_callback = lambda i: Qt.QMetaObject.invokeMethod(self._dest_host_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._dest_host_options.index(i)))
self._dest_host_callback(self.dest_host)
self._dest_host_combo_box.currentIndexChanged.connect(
lambda i: self.set_dest_host(self._dest_host_options[i]))
self.top_layout.addWidget(self._dest_host_tool_bar)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, num_ch, 30.0 + Vsq2W_dB)
self.blocks_float_to_char_0 = blocks.float_to_char(num_ch, 1.0)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.spectrum_latency_bin_aggregator_0, 0))
self.connect((self.blocks_float_to_char_0, 0), (self.spectrum_latency_jsonfile_sink_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_float_to_char_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.spectrum_latency_bin_aggregator_0, 0), (self.spectrum_latency_bin_statistics_0, 0))
self.connect((self.spectrum_latency_bin_statistics_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.uhd_rfnoc_streamer_radio_0, 0), (self.blocks_stream_to_vector_0, 0))
def __init__(self, samp_rate=2e6):
grc_wxgui.top_block_gui.__init__(
self, title="Amplitude calibration tool for USRP, v 0.2")
########################################################
# TODO: See if there's a sensible way to package an icon
# with this program, rather than rely on some
# particular Gnu Radio user's installation.
#
# _icon_path = "/home/dave/.local/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
# self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
########################################################
##################################################
# Parameters
#
# TODO: Add enough parameters, and the right ones,
# that the program will come up with sliders
# set conveniently for the user.
# When step-sweep support is implemented, we
# want to be able to run even w/o the GUI.
##################################################
self.samp_rate = samp_rate
##################################################
# Variables
##################################################
self.usrp_gain_slider = usrp_gain_slider = 20
self.usrp_freq_offset_slider = usrp_freq_offset_slider = -100000
self.input_signal_power = input_signal_power = -50
self.input_freq_slider = input_freq_slider = 1e9
self.cal_file = None
##################################################
# Blocks
##################################################
self._input_rowhdr_text_box = wx.StaticText(
self.GetWin(), label='\nReference Signal:\n')
font = self._input_rowhdr_text_box.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
self._input_rowhdr_text_box.SetFont(font)
self.GridAdd(self._input_rowhdr_text_box, 1, 1, 1, 1)
_input_freq_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._input_freq_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_input_freq_slider_sizer,
value=self.input_freq_slider,
callback=self.set_input_freq_slider,
label='RF input frequency (Hz)',
converter=forms.float_converter(),
proportion=0,
)
self._input_freq_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_input_freq_slider_sizer,
value=self.input_freq_slider,
callback=self.set_input_freq_slider,
minimum=10e6,
maximum=6000e6,
num_steps=20,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_input_freq_slider_sizer, 1, 2, 1, 3)
_input_signal_power_sizer = wx.BoxSizer(wx.VERTICAL)
self._input_signal_power_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_input_signal_power_sizer,
value=self.input_signal_power,
callback=self.set_input_signal_power,
label='Input signal power (dBm)',
converter=forms.float_converter(),
proportion=0,
)
self._input_signal_power_slider = forms.slider(
parent=self.GetWin(),
sizer=_input_signal_power_sizer,
value=self.input_signal_power,
callback=self.set_input_signal_power,
minimum=-70,
maximum=-20,
num_steps=50,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_input_signal_power_sizer, 1, 5, 1, 2)
self._row_spacer_1 = wx.StaticText(self.GetWin(), label="\n")
self.GridAdd(self._row_spacer_1, 2, 1, 1, 6)
self._sdr_rowhdr_text_box = wx.StaticText(self.GetWin(),
label='HackRF:')
font = self._sdr_rowhdr_text_box.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
self._sdr_rowhdr_text_box.SetFont(font)
self.GridAdd(self._sdr_rowhdr_text_box, 3, 1, 1, 1)
_usrp_freq_offset_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._usrp_freq_offset_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_usrp_freq_offset_slider_sizer,
value=self.usrp_freq_offset_slider,
callback=self.set_usrp_freq_offset_slider,
label='Freq offset',
converter=forms.float_converter(),
proportion=0,
)
self._usrp_freq_offset_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_usrp_freq_offset_slider_sizer,
value=self.usrp_freq_offset_slider,
callback=self.set_usrp_freq_offset_slider,
minimum=-200000,
maximum=200000,
num_steps=5,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_usrp_freq_offset_slider_sizer, 3, 2, 1, 3)
_usrp_gain_slider_sizer = wx.BoxSizer(wx.VERTICAL)
self._usrp_gain_slider_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_usrp_gain_slider_sizer,
value=self.usrp_gain_slider,
callback=self.set_usrp_gain_slider,
label='Gain (dB) !!!8dB step!!!',
converter=forms.float_converter(),
proportion=0,
)
self._usrp_gain_slider_slider = forms.slider(
parent=self.GetWin(),
sizer=_usrp_gain_slider_sizer,
value=self.usrp_gain_slider,
callback=self.set_usrp_gain_slider,
minimum=0,
maximum=38,
num_steps=38,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_usrp_gain_slider_sizer, 3, 5, 1, 2)
self._row_spacer_2 = wx.StaticText(self.GetWin(), label="")
self.GridAdd(self._row_spacer_2, 4, 1, 1, 6)
self.wxgui_numbersink2_0_0 = numbersink2.number_sink_f(
self.GetWin(),
unit='dBFS',
minval=-100,
maxval=10,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate / 10,
number_rate=10,
average=False,
avg_alpha=None,
label='Output power (digital)',
peak_hold=False,
show_gauge=True,
)
self.GridAdd(self.wxgui_numbersink2_0_0.win, 5, 1, 1, 2)
self.wxgui_numbersink2_0_0_1 = numbersink2.number_sink_f(
self.GetWin(),
unit='dB',
minval=-20,
maxval=80,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate / 10,
number_rate=10,
average=False,
avg_alpha=None,
label='Power conversion value\n(output dbFS -> input dBm + gain)',
peak_hold=False,
show_gauge=True,
)
self.GridAdd(self.wxgui_numbersink2_0_0_1.win, 5, 4, 1, 3)
self.data_capture_button = forms.single_button(
parent=self.GetWin(),
label="Capture this data point",
callback=self.checkbox_event,
style=wx.BU_EXACTFIT,
)
font = self.data_capture_button._button.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
self.data_capture_button._button.SetFont(font)
self.GridAdd(self.data_capture_button, 6, 4, 1, 1)
self._wrapup_text_box_1 = wx.StaticText(
self.GetWin(),
label='\n USRP LO freq:\n',
)
font = self._wrapup_text_box_1.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
self._wrapup_text_box_1.SetFont(font)
self.GridAdd(self._wrapup_text_box_1, 6, 5, 1, 1)
self._wrapup_text_box_1.SetLabel("\n USRP LO freq: {0:.0f}\n".format(
self.input_freq_slider + self.usrp_freq_offset_slider))
self._wrapup_text_box_2 = wx.StaticText(
self.GetWin(),
label='\n\n',
)
self.GridAdd(self._wrapup_text_box_2, 6, 6, 1, 1)
self.osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " +
'')
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(
input_freq_slider + usrp_freq_offset_slider, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(0, 0)
self.osmosdr_source_0.set_if_gain(usrp_gain_slider, 0)
self.osmosdr_source_0.set_bb_gain(0, 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(samp_rate, 0)
self.u = self.osmosdr_source_0
self.u_mboard_serial = ""
self.u_dboard_serial = ""
self.u_dboard_id = ""
self.u_dboard_id = ""
self._sdr_rowhdr_text_box.SetLabel(
"USRP serial # {0:s} \n{1:s} serial # {2:s} ".format(
self.u_mboard_serial, self.u_dboard_id, self.u_dboard_serial))
self.single_pole_iir_filter_xx_1_0 = filter.single_pole_iir_filter_ff(
1.0 / ((0.1) * samp_rate), 1)
self.low_pass_filter_0 = filter.fir_filter_ccf(
1,
firdes.low_pass(1, samp_rate, samp_rate / 5, samp_rate / 10,
firdes.WIN_HAMMING, 6.76))
self.dc_blocker_xx_0 = filter.dc_blocker_cc(1000, True)
self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_gr_complex * 1,
'', "")
self.blocks_tag_debug_0.set_display(True)
self.blocks_sub_xx_0 = blocks.sub_ff(1)
self.blocks_nlog10_ff_0_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_keep_one_in_n_0_0 = blocks.keep_one_in_n(
gr.sizeof_float * 1, 10)
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(
gr.sizeof_float * 1, 10)
self.blocks_complex_to_mag_squared_0_0 = blocks.complex_to_mag_squared(
1)
self.analog_const_source_x_0 = analog.sig_source_f(
0, analog.GR_CONST_WAVE, 0, 0,
input_signal_power + usrp_gain_slider)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0),
(self.blocks_keep_one_in_n_0_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0_0, 0),
(self.single_pole_iir_filter_xx_1_0, 0))
self.connect((self.blocks_keep_one_in_n_0, 0),
(self.blocks_sub_xx_0, 1))
self.connect((self.blocks_keep_one_in_n_0, 0),
(self.wxgui_numbersink2_0_0, 0))
self.connect((self.blocks_keep_one_in_n_0_0, 0),
(self.blocks_sub_xx_0, 0))
self.connect((self.blocks_nlog10_ff_0_0, 0),
(self.blocks_keep_one_in_n_0, 0))
self.connect((self.blocks_sub_xx_0, 0),
(self.wxgui_numbersink2_0_0_1, 0))
self.connect((self.dc_blocker_xx_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0),
(self.blocks_complex_to_mag_squared_0_0, 0))
self.connect((self.single_pole_iir_filter_xx_1_0, 0),
(self.blocks_nlog10_ff_0_0, 0))
self.connect((self.u, 0), (self.blocks_tag_debug_0, 0))
self.connect((self.u, 0), (self.dc_blocker_xx_0, 0))
val = self.probe_signal_detection.level()
try:
self.set_probe_detection(val)
except AttributeError, e:
pass
time.sleep(1.0 / (10))
_probe_detection_thread = threading.Thread(target=_probe_detection_probe)
_probe_detection_thread.daemon = True
_probe_detection_thread.start()
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.rectangular(fft_size)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float * 1, fft_size)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate)
self.blocks_threshold_ff_0 = blocks.threshold_ff(threshold, threshold, threshold)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(fft_size, 1.0 / fft_size, 4000)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, fft_size * fft_size)
##################################################
# Connections
##################################################
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.analog_const_source_x_0, 0), (self.blocks_divide_xx_0, 1))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_divide_xx_0, 0))
self.connect((self.blocks_divide_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_throttle_0, 0))
def __do_connect(self):
itemsize = self.__itemsize
if self.__signal_type.is_analytic():
input_length = self.__freq_resolution
output_length = self.__freq_resolution
self.__after_fft = None
else:
# use vector_to_streams to cut the output in half and discard the redundant part
input_length = self.__freq_resolution * 2
output_length = self.__freq_resolution
self.__after_fft = blocks.vector_to_streams(itemsize=output_length * gr.sizeof_float, nstreams=2)
sample_rate = self.__signal_type.get_sample_rate()
overlap_factor = int(math.ceil(_maximum_fft_rate * input_length / sample_rate))
# sanity limit -- OverlapGimmick is not free
overlap_factor = min(16, overlap_factor)
self.__frame_rate_to_decimation_conversion = sample_rate * overlap_factor / input_length
self.__gate = blocks.copy(itemsize)
self.__gate.set_enabled(not self.__paused)
overlapper = _OverlappedStreamToVector(
size=input_length,
factor=overlap_factor,
itemsize=itemsize)
self.__frame_dec = blocks.keep_one_in_n(
itemsize=itemsize * input_length,
n=int(round(self.__frame_rate_to_decimation_conversion / self.__frame_rate)))
# the actual FFT logic, which is similar to GR's logpwrfft_c
window = windows.blackmanharris(input_length)
window_power = sum(x * x for x in window)
# TODO: use fft_vfc when applicable
fft_block = (fft_vcc if itemsize == gr.sizeof_gr_complex else fft_vfc)(
fft_size=input_length,
forward=True,
window=window)
mag_squared = blocks.complex_to_mag_squared(input_length)
logarithmizer = blocks.nlog10_ff(
n=10, # the "deci" in "decibel"
vlen=input_length,
k=(
-to_dB(window_power) + # compensate for window
-to_dB(sample_rate) + # convert from power-per-sample to power-per-Hz
self.__power_offset # offset for packing into bytes
))
# It would make slightly more sense to use unsigned chars, but blocks.float_to_uchar does not support vlen.
self.__fft_converter = blocks.float_to_char(vlen=self.__freq_resolution, scale=1.0)
self.__fft_sink = MessageDistributorSink(
itemsize=output_length * gr.sizeof_char,
context=self.__context,
migrate=self.__fft_sink,
notify=self.__update_interested)
self.__scope_sink = MessageDistributorSink(
itemsize=self.__time_length * gr.sizeof_gr_complex,
context=self.__context,
migrate=self.__scope_sink,
notify=self.__update_interested)
scope_chunker = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=self.__frame_rate, # TODO doesn't need to be coupled
vec_len=self.__time_length)
# connect everything
self.__context.lock()
try:
self.disconnect_all()
self.connect(
self,
self.__gate,
overlapper,
self.__frame_dec,
fft_block,
mag_squared,
logarithmizer)
if self.__after_fft is not None:
self.connect(logarithmizer, self.__after_fft)
self.connect(self.__after_fft, self.__fft_converter, self.__fft_sink)
self.connect((self.__after_fft, 1), blocks.null_sink(gr.sizeof_float * self.__freq_resolution))
else:
self.connect(logarithmizer, self.__fft_converter, self.__fft_sink)
if self.__enable_scope:
self.connect(
self.__gate,
scope_chunker,
self.__scope_sink)
finally:
self.__context.unlock()
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="DVBT Scanner")
##################################################
# Variables
##################################################
self.threshold = threshold = -60
self.signal_level = signal_level = 0
self.samp_rate = samp_rate = 2048000
self.freq = freq = 525200000
self.fft_size = fft_size = 1024
self.detected = detected = 0
##################################################
# 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=-100,
maximum=0,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_threshold_sizer, 2, 0, 1, 1)
self.probe_signal_lvl = blocks.probe_signal_f()
self.notebook = self.notebook = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Spektrum")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Output")
self.GridAdd(self.notebook, 0, 0, 1, 1)
_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="Frequency",
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=478000000,
maximum=862000000,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_freq_sizer, 1, 0, 1, 1)
self.wxgui_numbersink2_1 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="Signal present",
minval=0,
maxval=1,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=None,
label="Signal Detection",
peak_hold=False,
show_gauge=True,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_1.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="dB",
minval=-120,
maxval=0,
factor=1.0,
decimal_places=1,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=0.03,
label="Level",
peak_hold=False,
show_gauge=True,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.notebook.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=fft_size,
fft_rate=15,
average=True,
avg_alpha=0.03,
title="FFT Plot",
peak_hold=False,
win=window.flattop,
)
self.notebook.GetPage(0).Add(self.wxgui_fftsink2_0.win)
def _signal_level_probe():
while True:
val = self.probe_signal_lvl.level()
try:
self.set_signal_level(val)
except AttributeError:
pass
time.sleep(1.0 / (5))
_signal_level_thread = threading.Thread(target=_signal_level_probe)
_signal_level_thread.daemon = True
_signal_level_thread.start()
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "hackrf=0" )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(14, 0)
self.rtlsdr_source_0.set_if_gain(24, 0)
self.rtlsdr_source_0.set_bb_gain(12, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.probe_detected = blocks.probe_signal_f()
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (window.rectangular(fft_size)), True, 1)
def _detected_probe():
while True:
val = self.probe_detected.level()
try:
self.set_detected(val)
except AttributeError:
pass
time.sleep(1.0 / (5))
_detected_thread = threading.Thread(target=_detected_probe)
_detected_thread.daemon = True
_detected_thread.start()
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_size)
self.blocks_threshold_ff_0 = blocks.threshold_ff(threshold, threshold, threshold)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(1000, 0.001, 4000)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 1048580)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_divide_xx_0, 1))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_divide_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0), (self.probe_signal_lvl, 0))
self.connect((self.blocks_moving_average_xx_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.probe_detected, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_numbersink2_1, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_divide_xx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] center_freq band_width"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None,
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6,
help="set sample rate [default=%default]")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--meas-interval", type="eng_float",
default=0.1, metavar="SECS",
help="interval over which to measure statistic (in seconds) [default=%default]")
parser.add_option("-c", "--number-channels", type="int", default=100,
help="number of uniform channels for which to report power measurements [default=%default]")
parser.add_option("-l", "--lo-offset", type="eng_float",
default=0, metavar="Hz",
help="lo_offset in Hz [default=half the sample rate]")
parser.add_option("-F", "--fft-size", type="int", default=1024,
help="specify number of FFT bins [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option("-d", "--dest-host", type="string", default="",
help="set destination host for sending data")
parser.add_option("", "--skip-DC", action="store_true", default=False,
help="skip the DC bin when mapping channels")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.center_freq = eng_notation.str_to_num(args[0])
self.bandwidth = eng_notation.str_to_num(args[1])
if not options.real_time:
realtime = False
else:
# Attempt to enable realtime scheduling
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
# build graph
self.u = uhd.usrp_source(device_addr=options.args,
stream_args=uhd.stream_args('fc32'))
# Set the subdevice spec
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
self.u.set_samp_rate(options.samp_rate)
usrp_rate = self.u.get_samp_rate()
if usrp_rate != options.samp_rate:
if usrp_rate < options.samp_rate:
# create list of allowable rates
samp_rates = self.u.get_samp_rates()
rate_list = [0.0]*len(samp_rates)
for i in range(len(rate_list)):
last_rate = samp_rates.pop()
rate_list[len(rate_list) - 1 - i] = last_rate.start()
# choose next higher rate
rate_ind = rate_list.index(usrp_rate) + 1
if rate_ind < len(rate_list):
self.u.set_samp_rate(rate_list[rate_ind])
usrp_rate = self.u.get_samp_rate()
print "New actual sample rate =", usrp_rate/1e6, "MHz"
resamp = filter.fractional_resampler_cc(0.0, usrp_rate / options.samp_rate)
self.samp_rate = options.samp_rate
if(options.lo_offset):
self.lo_offset = options.lo_offset
else:
self.lo_offset = usrp_rate / 2.0
print "LO offset set to", self.lo_offset/1e6, "MHz"
self.fft_size = options.fft_size
self.num_ch = options.number_channels
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = filter.window.blackmanharris(self.fft_size)
ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
window_power = sum(map(lambda x: x*x, mywindow))
c2mag = blocks.complex_to_mag_squared(self.fft_size)
self.bin2ch_map = [0] * self.fft_size
hz_per_bin = self.samp_rate / self.fft_size
channel_bw = hz_per_bin * round(self.bandwidth / self.num_ch / hz_per_bin)
self.bandwidth = channel_bw * self.num_ch
print "Actual width of band is", self.bandwidth/1e6, "MHz."
start_freq = self.center_freq - self.bandwidth/2.0
stop_freq = start_freq + self.bandwidth
for j in range(self.fft_size):
fj = self.bin_freq(j, self.center_freq)
if (fj >= start_freq) and (fj < stop_freq):
channel_num = int(math.floor((fj - start_freq) / channel_bw)) + 1
self.bin2ch_map[j] = channel_num
if options.skip_DC:
self.bin2ch_map[(self.fft_size + 1) / 2 + 1:] = self.bin2ch_map[(self.fft_size + 1) / 2 : -1]
self.bin2ch_map[(self.fft_size + 1) / 2] = 0
if self.bandwidth > self.samp_rate:
print "Warning: Width of band (" + str(self.bandwidth/1e6), "MHz) is greater than the sample rate (" + str(self.samp_rate/1e6), "MHz)."
self.aggr = myblocks.bin_aggregator_ff(self.fft_size, self.num_ch, self.bin2ch_map)
meas_frames = max(1, int(round(options.meas_interval * self.samp_rate / self.fft_size))) # in fft_frames
self.meas_duration = meas_frames * self.fft_size / self.samp_rate
print "Actual measurement duration =", self.meas_duration, "s"
self.stats = myblocks.bin_statistics_ff(self.num_ch, meas_frames)
# Divide magnitude-square by a constant to obtain power
# in Watts. Assumes unit of USRP source is volts.
impedance = 50.0 # ohms
Vsq2W_dB = -10.0 * math.log10(self.fft_size * window_power * impedance)
# Convert from Watts to dBm.
W2dBm = blocks.nlog10_ff(10.0, self.num_ch, 30.0 + Vsq2W_dB)
f2c = blocks.float_to_char(self.num_ch, 1.0)
self.dest_host = options.dest_host
# file descriptor is set in main loop; use dummy value for now
self.srvr = myblocks.file_descriptor_sink(self.num_ch * gr.sizeof_char, 0)
if usrp_rate > self.samp_rate:
# insert resampler
self.connect(self.u, resamp, s2v)
else:
self.connect(self.u, s2v)
self.connect(s2v, ffter, c2mag, self.aggr, self.stats, W2dBm, f2c, self.srvr)
#self.connect(s2v, ffter, c2mag, self.aggr, self.stats, W2dBm, self.srvr)
g = self.u.get_gain_range()
if options.gain is None:
# if no gain was specified, use the mid-point in dB
options.gain = float(g.start()+g.stop())/2.0
self.set_gain(options.gain)
print "gain =", options.gain, "dB in range (%0.1f dB, %0.1f dB)" % (float(g.start()), float(g.stop()))
self.atten = float(g.stop()) - options.gain
def __init__(self):
gr.top_block.__init__(self, "Msod Sslsensor Hackrf")
Qt.QWidget.__init__(self)
self.setWindowTitle("Msod Sslsensor Hackrf")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "MSOD_SSLSensor_HackRF")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 10e6
self.fft_size = fft_size = 1000
self.num_ch = num_ch = 50
self.mywindow = mywindow = window.blackmanharris(fft_size)
self.hz_per_bin = hz_per_bin = samp_rate / fft_size
self.bandwidth = bandwidth = 9e6
self.window_power = window_power = sum(map(lambda x: x*x, mywindow))
self.meas_interval = meas_interval = 1e-3
self.impedance = impedance = 50.0
self.channel_bw = channel_bw = hz_per_bin * round(bandwidth / num_ch / hz_per_bin)
self.rx_gain = rx_gain = 0
self.meas_period = meas_period = max(1, int(round(meas_interval * samp_rate / fft_size)))
self.dest_host = dest_host = "pwct5.ctl.nist.gov"
self.center_freq = center_freq = 724e6
self.Vsq2W_dB = Vsq2W_dB = -10.0 * math.log10(fft_size * int(window_power) * impedance)
self.ActualBW = ActualBW = channel_bw * num_ch
##################################################
# Blocks
##################################################
self._samp_rate_options = (10e6, 15.36e6, 7.68e6, 3.84e6, 1.92e6, )
self._samp_rate_labels = ("10e6", "15.36e6", "7.68e6", "3.84e6", "1.92e6", )
self._samp_rate_group_box = Qt.QGroupBox("samp_rate")
self._samp_rate_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._samp_rate_button_group = variable_chooser_button_group()
self._samp_rate_group_box.setLayout(self._samp_rate_box)
for i, label in enumerate(self._samp_rate_labels):
radio_button = Qt.QRadioButton(label)
self._samp_rate_box.addWidget(radio_button)
self._samp_rate_button_group.addButton(radio_button, i)
self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(self._samp_rate_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._samp_rate_options.index(i)))
self._samp_rate_callback(self.samp_rate)
self._samp_rate_button_group.buttonClicked[int].connect(
lambda i: self.set_samp_rate(self._samp_rate_options[i]))
self.top_layout.addWidget(self._samp_rate_group_box)
self._num_ch_options = (56, 50, 25, 15, 8, )
self._num_ch_labels = ("56", "50", "25", "15", "8", )
self._num_ch_group_box = Qt.QGroupBox("num_ch")
self._num_ch_box = Qt.QVBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._num_ch_button_group = variable_chooser_button_group()
self._num_ch_group_box.setLayout(self._num_ch_box)
for i, label in enumerate(self._num_ch_labels):
radio_button = Qt.QRadioButton(label)
self._num_ch_box.addWidget(radio_button)
self._num_ch_button_group.addButton(radio_button, i)
self._num_ch_callback = lambda i: Qt.QMetaObject.invokeMethod(self._num_ch_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._num_ch_options.index(i)))
self._num_ch_callback(self.num_ch)
self._num_ch_button_group.buttonClicked[int].connect(
lambda i: self.set_num_ch(self._num_ch_options[i]))
self.top_layout.addWidget(self._num_ch_group_box)
self._fft_size_options = (1000, 1024, 512, 256, 128, )
self._fft_size_labels = ("1000", "1024", "512", "256", "128", )
self._fft_size_tool_bar = Qt.QToolBar(self)
self._fft_size_tool_bar.addWidget(Qt.QLabel("fft_size"+": "))
self._fft_size_combo_box = Qt.QComboBox()
self._fft_size_tool_bar.addWidget(self._fft_size_combo_box)
for label in self._fft_size_labels: self._fft_size_combo_box.addItem(label)
self._fft_size_callback = lambda i: Qt.QMetaObject.invokeMethod(self._fft_size_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._fft_size_options.index(i)))
self._fft_size_callback(self.fft_size)
self._fft_size_combo_box.currentIndexChanged.connect(
lambda i: self.set_fft_size(self._fft_size_options[i]))
self.top_layout.addWidget(self._fft_size_tool_bar)
self._dest_host_options = ("pwct1.ctl.nist.gov", "129.6.230.12", "pwc8.ctl.nist.gov", "pwct5.ctl.nist.gov", )
self._dest_host_labels = ("pwct1", "Naceur Laptop", "pwct5Desktop", "Pwct5", )
self._dest_host_tool_bar = Qt.QToolBar(self)
self._dest_host_tool_bar.addWidget(Qt.QLabel(dest_host+": "))
self._dest_host_combo_box = Qt.QComboBox()
self._dest_host_tool_bar.addWidget(self._dest_host_combo_box)
for label in self._dest_host_labels: self._dest_host_combo_box.addItem(label)
self._dest_host_callback = lambda i: Qt.QMetaObject.invokeMethod(self._dest_host_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._dest_host_options.index(i)))
self._dest_host_callback(self.dest_host)
self._dest_host_combo_box.currentIndexChanged.connect(
lambda i: self.set_dest_host(self._dest_host_options[i]))
self.top_layout.addWidget(self._dest_host_tool_bar)
self._center_freq_options = (709.01e6, 782e6, 724e6, 729e6, )
self._center_freq_labels = ("AT&T", "Verizon", "ChannelEmulator", "HackRF Shifted Freq", )
self._center_freq_tool_bar = Qt.QToolBar(self)
self._center_freq_tool_bar.addWidget(Qt.QLabel("center_freq"+": "))
self._center_freq_combo_box = Qt.QComboBox()
self._center_freq_tool_bar.addWidget(self._center_freq_combo_box)
for label in self._center_freq_labels: self._center_freq_combo_box.addItem(label)
self._center_freq_callback = lambda i: Qt.QMetaObject.invokeMethod(self._center_freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._center_freq_options.index(i)))
self._center_freq_callback(self.center_freq)
self._center_freq_combo_box.currentIndexChanged.connect(
lambda i: self.set_center_freq(self._center_freq_options[i]))
self.top_layout.addWidget(self._center_freq_tool_bar)
self._rx_gain_range = Range(0, 31.5, 0.5, 0, 200)
self._rx_gain_win = RangeWidget(self._rx_gain_range, self.set_rx_gain, "rx_gain", "counter_slider", float)
self.top_layout.addWidget(self._rx_gain_win)
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "hackrf=0" )
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(center_freq, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(1, 0)
self.osmosdr_source_0.set_iq_balance_mode(2, 0)
self.osmosdr_source_0.set_gain_mode(True, 0)
self.osmosdr_source_0.set_gain(0, 0)
self.osmosdr_source_0.set_if_gain(32, 0)
self.osmosdr_source_0.set_bb_gain(40, 0)
self.osmosdr_source_0.set_antenna("", 0)
self.osmosdr_source_0.set_bandwidth(20e6, 0)
self.msod_sensor_sslsocket_sink_0 = msod_sensor.sslsocket_sink(num_ch, dest_host, "/raid/nae/pybombs/src/gr-msod_latency/examples/sensor_HackRF.loc", "/raid/nae/pybombs/src/gr-msod_latency/examples/sensor_HackRF.sys", "HackRF", "NaN", center_freq, ActualBW, meas_interval, 0, samp_rate, False)
self.msod_sensor_bin_statistics_0 = msod_sensor.bin_statistics(num_ch, meas_period)
self.msod_sensor_bin_aggregator_0 = msod_sensor.bin_aggregator(fft_size, num_ch, samp_rate, fft_size, center_freq, ActualBW, channel_bw, [0] * fft_size, False)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (mywindow), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, num_ch, 30.0 + Vsq2W_dB)
self.blocks_float_to_char_0 = blocks.float_to_char(num_ch, 1.0)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
self._bandwidth_options = (10.08e6, 9e6, 4.5e6, 2.7e6, 1.08e6, )
self._bandwidth_labels = ("10.08e6", "9e6", "4.5e6", "2.7e6", "1.08e6", )
self._bandwidth_tool_bar = Qt.QToolBar(self)
self._bandwidth_tool_bar.addWidget(Qt.QLabel("bandwidth"+": "))
self._bandwidth_combo_box = Qt.QComboBox()
self._bandwidth_tool_bar.addWidget(self._bandwidth_combo_box)
for label in self._bandwidth_labels: self._bandwidth_combo_box.addItem(label)
self._bandwidth_callback = lambda i: Qt.QMetaObject.invokeMethod(self._bandwidth_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._bandwidth_options.index(i)))
self._bandwidth_callback(self.bandwidth)
self._bandwidth_combo_box.currentIndexChanged.connect(
lambda i: self.set_bandwidth(self._bandwidth_options[i]))
self.top_layout.addWidget(self._bandwidth_tool_bar)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.msod_sensor_bin_aggregator_0, 0))
self.connect((self.blocks_float_to_char_0, 0), (self.msod_sensor_sslsocket_sink_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_float_to_char_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.msod_sensor_bin_aggregator_0, 0), (self.msod_sensor_bin_statistics_0, 0))
self.connect((self.msod_sensor_bin_statistics_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
def __init__(self, meta_rate=10):
gr.top_block.__init__(self, "Fox1D Playback")
Qt.QWidget.__init__(self)
self.setWindowTitle("Fox1D Playback")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "fox1d_playback")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.meta_rate = meta_rate
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 250e3
self.decim = decim = 5
self.baud = baud = 9600
self.xlate_taps_old = xlate_taps_old = firdes.low_pass(
1.0, samp_rate, samp_rate / 2, 1000, firdes.WIN_HAMMING, 6.76)
self.xlate_taps = xlate_taps = firdes.low_pass(1.0, samp_rate, 15e3,
1000,
firdes.WIN_HAMMING,
6.76)
self.volume = volume = 0.01
self.throttle_factor = throttle_factor = 1
self.samps_per_symb = samps_per_symb = samp_rate / decim / baud
self.rf_lpf_cutoff = rf_lpf_cutoff = 8e3
self.fsk_deviation_hz = fsk_deviation_hz = 4000
self.fll_loop_bw_fine = fll_loop_bw_fine = 0.0001
self.fll_loop_bw = fll_loop_bw = math.pi / 200
self.audio_lpf_cutoff = audio_lpf_cutoff = 7e3
##################################################
# Blocks
##################################################
self._volume_tool_bar = Qt.QToolBar(self)
self._volume_tool_bar.addWidget(Qt.QLabel("volume" + ": "))
self._volume_line_edit = Qt.QLineEdit(str(self.volume))
self._volume_tool_bar.addWidget(self._volume_line_edit)
self._volume_line_edit.returnPressed.connect(lambda: self.set_volume(
eng_notation.str_to_num(
str(self._volume_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._volume_tool_bar, 7, 4, 1, 2)
for r in range(7, 8):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 6):
self.top_grid_layout.setColumnStretch(c, 1)
self._throttle_factor_tool_bar = Qt.QToolBar(self)
self._throttle_factor_tool_bar.addWidget(
Qt.QLabel("throttle_factor" + ": "))
self._throttle_factor_line_edit = Qt.QLineEdit(
str(self.throttle_factor))
self._throttle_factor_tool_bar.addWidget(
self._throttle_factor_line_edit)
self._throttle_factor_line_edit.returnPressed.connect(
lambda: self.set_throttle_factor(
eng_notation.str_to_num(
str(self._throttle_factor_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._throttle_factor_tool_bar, 6, 4, 1,
2)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 6):
self.top_grid_layout.setColumnStretch(c, 1)
self._rf_lpf_cutoff_tool_bar = Qt.QToolBar(self)
self._rf_lpf_cutoff_tool_bar.addWidget(
Qt.QLabel("rf_lpf_cutoff" + ": "))
self._rf_lpf_cutoff_line_edit = Qt.QLineEdit(str(self.rf_lpf_cutoff))
self._rf_lpf_cutoff_tool_bar.addWidget(self._rf_lpf_cutoff_line_edit)
self._rf_lpf_cutoff_line_edit.returnPressed.connect(
lambda: self.set_rf_lpf_cutoff(
eng_notation.str_to_num(
str(self._rf_lpf_cutoff_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._rf_lpf_cutoff_tool_bar, 6, 0, 1,
2)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 2):
self.top_grid_layout.setColumnStretch(c, 1)
self._fll_loop_bw_fine_tool_bar = Qt.QToolBar(self)
self._fll_loop_bw_fine_tool_bar.addWidget(
Qt.QLabel("fll_loop_bw_fine" + ": "))
self._fll_loop_bw_fine_line_edit = Qt.QLineEdit(
str(self.fll_loop_bw_fine))
self._fll_loop_bw_fine_tool_bar.addWidget(
self._fll_loop_bw_fine_line_edit)
self._fll_loop_bw_fine_line_edit.returnPressed.connect(
lambda: self.set_fll_loop_bw_fine(
eng_notation.str_to_num(
str(self._fll_loop_bw_fine_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._fll_loop_bw_fine_tool_bar, 7, 2,
1, 2)
for r in range(7, 8):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(2, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self._fll_loop_bw_tool_bar = Qt.QToolBar(self)
self._fll_loop_bw_tool_bar.addWidget(Qt.QLabel("fll_loop_bw" + ": "))
self._fll_loop_bw_line_edit = Qt.QLineEdit(str(self.fll_loop_bw))
self._fll_loop_bw_tool_bar.addWidget(self._fll_loop_bw_line_edit)
self._fll_loop_bw_line_edit.returnPressed.connect(
lambda: self.set_fll_loop_bw(
eng_notation.str_to_num(
str(self._fll_loop_bw_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._fll_loop_bw_tool_bar, 6, 2, 1, 2)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(2, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self._audio_lpf_cutoff_tool_bar = Qt.QToolBar(self)
self._audio_lpf_cutoff_tool_bar.addWidget(
Qt.QLabel("audio_lpf_cutoff" + ": "))
self._audio_lpf_cutoff_line_edit = Qt.QLineEdit(
str(self.audio_lpf_cutoff))
self._audio_lpf_cutoff_tool_bar.addWidget(
self._audio_lpf_cutoff_line_edit)
self._audio_lpf_cutoff_line_edit.returnPressed.connect(
lambda: self.set_audio_lpf_cutoff(
eng_notation.str_to_num(
str(self._audio_lpf_cutoff_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._audio_lpf_cutoff_tool_bar, 7, 0,
1, 2)
for r in range(7, 8):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 2):
self.top_grid_layout.setColumnStretch(c, 1)
self.rational_resampler_xxx_1 = filter.rational_resampler_ccc(
interpolation=1,
decimation=4,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
interpolation=1,
decimation=4,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=48,
decimation=50,
taps=None,
fractional_bw=None,
)
self.qtgui_waterfall_sink_x_0_0 = qtgui.waterfall_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate / decim, #bw
"corrected", #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0_0.set_update_time(0.010)
self.qtgui_waterfall_sink_x_0_0.enable_grid(False)
self.qtgui_waterfall_sink_x_0_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
colors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0_0.set_intensity_range(-80, 0)
self._qtgui_waterfall_sink_x_0_0_win = sip.wrapinstance(
self.qtgui_waterfall_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_waterfall_sink_x_0_0_win, 2,
4, 2, 4)
for r in range(2, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate / decim, #bw
"Pre-D", #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(0.010)
self.qtgui_waterfall_sink_x_0.enable_grid(False)
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
colors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-80, 0)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(
self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_waterfall_sink_x_0_win, 0,
4, 2, 4)
for r in range(0, 2):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
1024, #size
samp_rate / decim / 50 * 48, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 8, 0, 1,
8)
for r in range(8, 9):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_number_sink_0_0_0_0_0 = qtgui.number_sink(
gr.sizeof_float, 0, qtgui.NUM_GRAPH_NONE, 1)
self.qtgui_number_sink_0_0_0_0_0.set_update_time(0.10)
self.qtgui_number_sink_0_0_0_0_0.set_title("")
labels = ['SNR', '', '', '', '', '', '', '', '', '']
units = ['dB', '', '', '', '', '', '', '', '', '']
colors = [("blue", "red"), ("black", "black"), ("black", "black"),
("black", "black"), ("black", "black"), ("black", "black"),
("black", "black"), ("black", "black"), ("black", "black"),
("black", "black")]
factor = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
for i in xrange(1):
self.qtgui_number_sink_0_0_0_0_0.set_min(i, 0)
self.qtgui_number_sink_0_0_0_0_0.set_max(i, 30)
self.qtgui_number_sink_0_0_0_0_0.set_color(i, colors[i][0],
colors[i][1])
if len(labels[i]) == 0:
self.qtgui_number_sink_0_0_0_0_0.set_label(
i, "Data {0}".format(i))
else:
self.qtgui_number_sink_0_0_0_0_0.set_label(i, labels[i])
self.qtgui_number_sink_0_0_0_0_0.set_unit(i, units[i])
self.qtgui_number_sink_0_0_0_0_0.set_factor(i, factor[i])
self.qtgui_number_sink_0_0_0_0_0.enable_autoscale(False)
self._qtgui_number_sink_0_0_0_0_0_win = sip.wrapinstance(
self.qtgui_number_sink_0_0_0_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_number_sink_0_0_0_0_0_win,
6, 6, 1, 1)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(6, 7):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_number_sink_0_0_0_0 = qtgui.number_sink(
gr.sizeof_float, 0, qtgui.NUM_GRAPH_NONE, 1)
self.qtgui_number_sink_0_0_0_0.set_update_time(0.010)
self.qtgui_number_sink_0_0_0_0.set_title("")
labels = ['Freq Offset', 'Phase', 'Error', '', '', '', '', '', '', '']
units = ['Hz', '', '', '', '', '', '', '', '', '']
colors = [("black", "black"), ("black", "black"), ("black", "black"),
("black", "black"), ("black", "black"), ("black", "black"),
("black", "black"), ("black", "black"), ("black", "black"),
("black", "black")]
factor = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
for i in xrange(1):
self.qtgui_number_sink_0_0_0_0.set_min(i, -32767)
self.qtgui_number_sink_0_0_0_0.set_max(i, 32767)
self.qtgui_number_sink_0_0_0_0.set_color(i, colors[i][0],
colors[i][1])
if len(labels[i]) == 0:
self.qtgui_number_sink_0_0_0_0.set_label(
i, "Data {0}".format(i))
else:
self.qtgui_number_sink_0_0_0_0.set_label(i, labels[i])
self.qtgui_number_sink_0_0_0_0.set_unit(i, units[i])
self.qtgui_number_sink_0_0_0_0.set_factor(i, factor[i])
self.qtgui_number_sink_0_0_0_0.enable_autoscale(False)
self._qtgui_number_sink_0_0_0_0_win = sip.wrapinstance(
self.qtgui_number_sink_0_0_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_number_sink_0_0_0_0_win, 6,
7, 1, 1)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(7, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate / decim, #bw
"Pre-D", #name
2 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.010)
self.qtgui_freq_sink_x_0.set_y_axis(-60, 0)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0,
"")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(True)
self.qtgui_freq_sink_x_0.set_fft_average(0.2)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['pre-d', 'corr', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(
self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win, 0, 0, 4,
4)
for r in range(0, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.low_pass_filter_0_0_0 = filter.fir_filter_fff(
1,
firdes.low_pass(1, samp_rate / decim / 50 * 48, audio_lpf_cutoff,
2e3, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0_0 = filter.fir_filter_ccf(
1,
firdes.low_pass(1, samp_rate / decim, rf_lpf_cutoff, 2e3,
firdes.WIN_HAMMING, 6.76))
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(
decim, (xlate_taps), 0, samp_rate)
self.digital_fll_band_edge_cc_0_0 = digital.fll_band_edge_cc(
samps_per_symb, .5, 1024, fll_loop_bw_fine)
self.digital_fll_band_edge_cc_0 = digital.fll_band_edge_cc(
samps_per_symb, .5, 1024, fll_loop_bw)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate * throttle_factor,
True)
self.blocks_tagged_stream_to_pdu_0_0 = blocks.tagged_stream_to_pdu(
blocks.float_t, 'snr')
self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(
blocks.float_t, 'rfo')
self.blocks_stream_to_tagged_stream_0_0 = blocks.stream_to_tagged_stream(
gr.sizeof_float, 1, 1, "snr")
self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(
gr.sizeof_float, 1, 1, "rfo")
self.blocks_socket_pdu_0_0 = blocks.socket_pdu("TCP_SERVER", '0.0.0.0',
'52002', 10000, False)
self.blocks_socket_pdu_0 = blocks.socket_pdu("TCP_SERVER", '0.0.0.0',
'52001', 10000, False)
self.blocks_null_sink_0_1 = blocks.null_sink(gr.sizeof_float * 1)
self.blocks_null_sink_0_0_0 = blocks.null_sink(gr.sizeof_float * 1)
self.blocks_null_sink_0_0 = blocks.null_sink(gr.sizeof_float * 1)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float * 1)
self.blocks_nlog10_ff_0_1 = blocks.nlog10_ff(10, 1, 0)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff(
(-1 * samp_rate / decim / (2 * math.pi), ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff(
(volume, ))
self.blocks_moving_average_xx_0_0_1 = blocks.moving_average_ff(
10000, 0.0001, 4000, 1)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(
100000, 0.00001, 4000, 1)
self.blocks_keep_one_in_n_0_0 = blocks.keep_one_in_n(
gr.sizeof_float * 1, int(samp_rate * meta_rate))
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(
gr.sizeof_float * 1, int(samp_rate / 4 * meta_rate))
self.blocks_file_source_0 = blocks.file_source(
gr.sizeof_gr_complex * 1,
'/home/zleffke/captures/fox1d/20180913/FOX-1D_USRP_20180913_151002.518249_UTC_250k.fc32',
False)
self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0_0 = blocks.complex_to_mag_squared(
1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.blocks_add_xx_0 = blocks.add_vff(1)
self.analog_sig_source_x_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, samp_rate / 2, 1, 0)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(
samp_rate / (2 * math.pi * fsk_deviation_hz / 8.0))
self.analog_agc2_xx_0 = analog.agc2_cc(1e-1, 1e-2, 1.0, 1.0)
self.analog_agc2_xx_0.set_max_gain(65536)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'),
(self.blocks_socket_pdu_0, 'pdus'))
self.msg_connect((self.blocks_tagged_stream_to_pdu_0_0, 'pdus'),
(self.blocks_socket_pdu_0_0, 'pdus'))
self.connect((self.analog_agc2_xx_0, 0),
(self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.low_pass_filter_0_0_0, 0))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_add_xx_0, 0),
(self.blocks_multiply_const_vxx_1, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.blocks_divide_xx_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0_0, 0),
(self.blocks_divide_xx_0, 1))
self.connect((self.blocks_divide_xx_0, 0),
(self.blocks_nlog10_ff_0_1, 0))
self.connect((self.blocks_file_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_keep_one_in_n_0, 0),
(self.blocks_stream_to_tagged_stream_0_0, 0))
self.connect((self.blocks_keep_one_in_n_0_0, 0),
(self.blocks_stream_to_tagged_stream_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.blocks_keep_one_in_n_0_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.qtgui_number_sink_0_0_0_0, 0))
self.connect((self.blocks_moving_average_xx_0_0_1, 0),
(self.blocks_keep_one_in_n_0, 0))
self.connect((self.blocks_moving_average_xx_0_0_1, 0),
(self.qtgui_number_sink_0_0_0_0_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0),
(self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.rational_resampler_xxx_1, 0))
self.connect((self.blocks_nlog10_ff_0_1, 0),
(self.blocks_moving_average_xx_0_0_1, 0))
self.connect((self.blocks_stream_to_tagged_stream_0, 0),
(self.blocks_tagged_stream_to_pdu_0, 0))
self.connect((self.blocks_stream_to_tagged_stream_0_0, 0),
(self.blocks_tagged_stream_to_pdu_0_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.analog_agc2_xx_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 1),
(self.blocks_add_xx_0, 1))
self.connect((self.digital_fll_band_edge_cc_0, 0),
(self.blocks_multiply_xx_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 2),
(self.blocks_null_sink_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 3),
(self.blocks_null_sink_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 0),
(self.low_pass_filter_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0, 0),
(self.rational_resampler_xxx_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0_0, 1),
(self.blocks_add_xx_0, 0))
self.connect((self.digital_fll_band_edge_cc_0_0, 3),
(self.blocks_null_sink_0_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0_0, 2),
(self.blocks_null_sink_0_1, 0))
self.connect((self.digital_fll_band_edge_cc_0_0, 0),
(self.qtgui_freq_sink_x_0, 1))
self.connect((self.digital_fll_band_edge_cc_0_0, 0),
(self.qtgui_waterfall_sink_x_0_0, 0))
self.connect((self.digital_fll_band_edge_cc_0_0, 0),
(self.rational_resampler_xxx_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0),
(self.digital_fll_band_edge_cc_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0),
(self.qtgui_freq_sink_x_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0),
(self.qtgui_waterfall_sink_x_0, 0))
self.connect((self.low_pass_filter_0_0, 0),
(self.digital_fll_band_edge_cc_0_0, 0))
self.connect((self.low_pass_filter_0_0_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0),
(self.analog_quadrature_demod_cf_0, 0))
self.connect((self.rational_resampler_xxx_0_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rational_resampler_xxx_1, 0),
(self.blocks_complex_to_mag_squared_0_0, 0))
def setup_snr_measurement(self):
"""
Perform SNR measurement.
It uses the data reference from the BER measurement. I.e. if that is not
setup, it will be setup. Only data subcarriers that are assigned to the
station are considered in the measurement. Note that there is no sink
prepared. You need to setup a sink, e.g. with one or more invocation
of a "publish.."-function.
SNR output is in dB.
"""
if not self.measuring_ber():
self.setup_ber_measurement()
print "Warning: Setup BER Measurement forced"
if self.measuring_snr():
return
config = station_configuration()
vlen = config.subcarriers
frame_length = config.frame_length
L = config.periodic_parts
snr_est_filt = skip(gr.sizeof_gr_complex*vlen,frame_length/2)
skipping_symbols = [0] + range(config.training_data.fbmc_no_preambles/2,frame_length/2)
for x in skipping_symbols:
snr_est_filt.skip_call(x)
#snr_est_filt = skip(gr.sizeof_gr_complex*vlen,frame_length)
#for x in range(1,frame_length):
#snr_est_filt.skip_call(x)
## NOTE HACK!! first preamble is not equalized
self.connect(self.symbol_output,snr_est_filt)
self.connect(self.frame_trigger,(snr_est_filt,1))
# snrm = self._snr_measurement = milans_snr_estimator( vlen, vlen, L )
#
# self.connect(snr_est_filt,snrm)
#
# if self._options.log:
# log_to_file(self, self._snr_measurement, "data/milan_snr.float")
#Addition for SINR estimation
if self._options.sinr_est:
snr_est_filt_2 = skip(gr.sizeof_gr_complex*vlen,frame_length)
for x in range(frame_length):
if x != config.training_data.channel_estimation_pilot[0]:
snr_est_filt_2.skip_call(x)
self.connect(self.symbol_output,snr_est_filt_2)
self.connect(self.frame_trigger,(snr_est_filt_2,1))
sinrm = self._sinr_measurement = milans_sinr_sc_estimator2( vlen, vlen, L )
self.connect(snr_est_filt,sinrm)
self.connect(snr_est_filt_2,(sinrm,1))
if self._options.log:
log_to_file(self, (self._sinr_measurement,0), "data/milan_sinr_sc.float")
log_to_file(self, (self._sinr_measurement,1), "data/milan_snr.float")
else:
#snrm = self._snr_measurement = milans_snr_estimator( vlen, vlen, L )
snr_estim = fbmc_snr_estimator( vlen, config.training_data.fbmc_no_preambles/2 -1 )
scsnrdb = filter.single_pole_iir_filter_ff(0.1)
snrm = self._snr_measurement = blocks.nlog10_ff(10,1,0)
#self.connect(self.snr_est_preamble,scsnrdb,snrm)
#terminate_stream(self,self.snr_est_preamble)
#self.connect(self.snr_est_preamble,snr_estim,scsnrdb,snrm)
#self.connect((snr_estim,1),blocks.null_sink(gr.sizeof_float))
#log_to_file(self, snrm, "data/snrm.float")
#log_to_file(self, snrm, "data/snrm.float")
collect_preambles = blocks.stream_to_vector(gr.sizeof_gr_complex*vlen, config.training_data.fbmc_no_preambles/2 -1)
self.connect(snr_est_filt, collect_preambles)
self.connect(collect_preambles,snr_estim,scsnrdb,snrm)
self.connect((snr_estim,1),blocks.null_sink(gr.sizeof_float))
def __init__(self):
gr.top_block.__init__(self, "Lab8")
Qt.QWidget.__init__(self)
self.setWindowTitle("Lab8")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "lab8")
try:
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(
self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(self.settings.value("geometry"))
except:
pass
##################################################
# Variables
##################################################
self.std_dev = std_dev = 0.05
self.samp_rate = samp_rate = 32000
self.p_xy = p_xy = 0
self.npts = npts = 8192
self.mimo_option = mimo_option = 0
self.lw = lw = 0.5
self.const_qam = const_qam = digital.constellation_calcdist(
digital.qam_16()[0],
digital.qam_16()[1], 2, 1).base()
self.const_psk = const_psk = digital.constellation_calcdist(
digital.psk_4()[0],
digital.psk_4()[1], 2, 1).base()
##################################################
# Blocks
##################################################
self.tab = Qt.QTabWidget()
self.tab_widget_0 = Qt.QWidget()
self.tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tab_widget_0)
self.tab_grid_layout_0 = Qt.QGridLayout()
self.tab_layout_0.addLayout(self.tab_grid_layout_0)
self.tab.addTab(self.tab_widget_0, 'Transmitted')
self.tab_widget_1 = Qt.QWidget()
self.tab_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tab_widget_1)
self.tab_grid_layout_1 = Qt.QGridLayout()
self.tab_layout_1.addLayout(self.tab_grid_layout_1)
self.tab.addTab(self.tab_widget_1, 'Received')
self.tab_widget_2 = Qt.QWidget()
self.tab_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tab_widget_2)
self.tab_grid_layout_2 = Qt.QGridLayout()
self.tab_layout_2.addLayout(self.tab_grid_layout_2)
self.tab.addTab(self.tab_widget_2, 'Histogram')
self.top_grid_layout.addWidget(self.tab, 1, 0, 8, 7)
for r in range(1, 9):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 7):
self.top_grid_layout.setColumnStretch(c, 1)
self._std_dev_range = Range(0, 1, 0.001, 0.05, 200)
self._std_dev_win = RangeWidget(self._std_dev_range, self.set_std_dev,
'Noise Std. Dev', "counter_slider",
float)
self.top_grid_layout.addWidget(self._std_dev_win, 0, 0, 1, 3)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 3):
self.top_grid_layout.setColumnStretch(c, 1)
self._p_xy_range = Range(0, 0.99, 0.001, 0, 200)
self._p_xy_win = RangeWidget(self._p_xy_range, self.set_p_xy,
'Correlation Pxy', "counter_slider",
float)
self.top_grid_layout.addWidget(self._p_xy_win, 0, 3, 1, 3)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(3, 6):
self.top_grid_layout.setColumnStretch(c, 1)
# Create the options list
self._mimo_option_options = (
0,
1,
)
# Create the labels list
self._mimo_option_labels = (
'Alamouti',
'MIMO',
)
# Create the combo box
# Create the radio buttons
self._mimo_option_group_box = Qt.QGroupBox('MIMO Option' + ": ")
self._mimo_option_box = Qt.QHBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._mimo_option_button_group = variable_chooser_button_group()
self._mimo_option_group_box.setLayout(self._mimo_option_box)
for i, _label in enumerate(self._mimo_option_labels):
radio_button = Qt.QRadioButton(_label)
self._mimo_option_box.addWidget(radio_button)
self._mimo_option_button_group.addButton(radio_button, i)
self._mimo_option_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._mimo_option_button_group, "updateButtonChecked",
Qt.Q_ARG("int", self._mimo_option_options.index(i)))
self._mimo_option_callback(self.mimo_option)
self._mimo_option_button_group.buttonClicked[int].connect(
lambda i: self.set_mimo_option(self._mimo_option_options[i]))
self.top_grid_layout.addWidget(self._mimo_option_group_box, 0, 6, 1, 2)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(6, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
4096, #size
1, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(0, 20)
self.qtgui_time_sink_x_0.set_y_label('Eigenvalue Ratio (dB)', "")
self.qtgui_time_sink_x_0.enable_tags(True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(True)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
labels = [
'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5',
'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10'
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow',
'dark red', 'dark green', 'dark blue'
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
for i in range(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 9, 0, 2,
8)
for r in range(9, 11):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_histogram_sink_x_0 = qtgui.histogram_sink_f(
npts, 200, -2, 2, "Histogram", 1)
self.qtgui_histogram_sink_x_0.set_update_time(0.10)
self.qtgui_histogram_sink_x_0.enable_autoscale(True)
self.qtgui_histogram_sink_x_0.enable_accumulate(False)
self.qtgui_histogram_sink_x_0.enable_grid(True)
self.qtgui_histogram_sink_x_0.enable_axis_labels(True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [3, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in range(1):
if len(labels[i]) == 0:
self.qtgui_histogram_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_histogram_sink_x_0.set_line_label(i, labels[i])
self.qtgui_histogram_sink_x_0.set_line_width(i, widths[i])
self.qtgui_histogram_sink_x_0.set_line_color(i, colors[i])
self.qtgui_histogram_sink_x_0.set_line_style(i, styles[i])
self.qtgui_histogram_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_histogram_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_histogram_sink_x_0_win = sip.wrapinstance(
self.qtgui_histogram_sink_x_0.pyqwidget(), Qt.QWidget)
self.tab_layout_2.addWidget(self._qtgui_histogram_sink_x_0_win)
self.qtgui_const_sink_x_1 = qtgui.const_sink_c(
1024, #size
"De-Correlated Constellation", #name
2 #number of inputs
)
self.qtgui_const_sink_x_1.set_update_time(0.10)
self.qtgui_const_sink_x_1.set_y_axis(-1.5, 1.5)
self.qtgui_const_sink_x_1.set_x_axis(-1.5, 1.5)
self.qtgui_const_sink_x_1.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0,
0, "")
self.qtgui_const_sink_x_1.enable_autoscale(False)
self.qtgui_const_sink_x_1.enable_grid(True)
self.qtgui_const_sink_x_1.enable_axis_labels(True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "red", "red", "red", "red", "red", "red", "red",
"red"
]
styles = [0, 2, 0, 0, 0, 0, 0, 0, 0, 0]
markers = [0, -1, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 0.2, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_1.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_1.set_line_label(i, labels[i])
self.qtgui_const_sink_x_1.set_line_width(i, widths[i])
self.qtgui_const_sink_x_1.set_line_color(i, colors[i])
self.qtgui_const_sink_x_1.set_line_style(i, styles[i])
self.qtgui_const_sink_x_1.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_1.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_1_win = sip.wrapinstance(
self.qtgui_const_sink_x_1.pyqwidget(), Qt.QWidget)
self.tab_layout_1.addWidget(self._qtgui_const_sink_x_1_win)
self.qtgui_const_sink_x_0 = qtgui.const_sink_c(
1024, #size
"Correlated Constellation", #name
2 #number of inputs
)
self.qtgui_const_sink_x_0.set_update_time(0.10)
self.qtgui_const_sink_x_0.set_y_axis(-4, 4)
self.qtgui_const_sink_x_0.set_x_axis(-4, 4)
self.qtgui_const_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0,
0, "")
self.qtgui_const_sink_x_0.enable_autoscale(False)
self.qtgui_const_sink_x_0.enable_grid(True)
self.qtgui_const_sink_x_0.enable_axis_labels(True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "red", "red", "red", "red", "red", "red", "red",
"red"
]
styles = [0, 2, 0, 0, 0, 0, 0, 0, 0, 0]
markers = [0, -1, 0, 0, 0, 0, 0, 0, 0, 0]
alphas = [1.0, 0.2, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_0.set_line_label(i, labels[i])
self.qtgui_const_sink_x_0.set_line_width(i, widths[i])
self.qtgui_const_sink_x_0.set_line_color(i, colors[i])
self.qtgui_const_sink_x_0.set_line_style(i, styles[i])
self.qtgui_const_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_0_win = sip.wrapinstance(
self.qtgui_const_sink_x_0.pyqwidget(), Qt.QWidget)
self.tab_layout_0.addWidget(self._qtgui_const_sink_x_0_win)
self.ofdm_alamouti_cc_0 = ofdm.alamouti_cc(p_xy, std_dev, mimo_option)
self.digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bc(
const_psk.points(), 1)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(
4096, 1 / 4096, 4096, 1)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_deinterleave_0 = blocks.deinterleave(
gr.sizeof_float * 1, 1)
self.blocks_complex_to_real_0 = blocks.complex_to_real(1)
self.analog_random_source_x_0 = blocks.vector_source_b(
list(map(int, numpy.random.randint(0, 4, 1000))), True)
##################################################
# Connections
##################################################
self.connect((self.analog_random_source_x_0, 0),
(self.digital_chunks_to_symbols_xx_0, 0))
self.connect((self.blocks_complex_to_real_0, 0),
(self.qtgui_histogram_sink_x_0, 0))
self.connect((self.blocks_deinterleave_0, 1),
(self.blocks_divide_xx_0, 1))
self.connect((self.blocks_deinterleave_0, 0),
(self.blocks_divide_xx_0, 0))
self.connect((self.blocks_divide_xx_0, 0),
(self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.digital_chunks_to_symbols_xx_0, 0),
(self.ofdm_alamouti_cc_0, 0))
self.connect((self.ofdm_alamouti_cc_0, 1),
(self.blocks_complex_to_real_0, 0))
self.connect((self.ofdm_alamouti_cc_0, 2),
(self.blocks_deinterleave_0, 0))
self.connect((self.ofdm_alamouti_cc_0, 0),
(self.qtgui_const_sink_x_0, 1))
self.connect((self.ofdm_alamouti_cc_0, 0),
(self.qtgui_const_sink_x_0, 0))
self.connect((self.ofdm_alamouti_cc_0, 1),
(self.qtgui_const_sink_x_1, 0))
self.connect((self.ofdm_alamouti_cc_0, 1),
(self.qtgui_const_sink_x_1, 1))
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-a", "--args", type="string", default="", help="UHD device device address args [default=%default]")
parser.add_option("", "--spec", type="string", default=None, help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None, help="select Rx Antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=1e6, help="set sample rate [default=%default]")
parser.add_option("-g", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=20e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=2048 , help="specify number of FFT bins [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False, help="Attempt to enable real-time scheduling")
parser.add_option("-d", "--decim", type="intx", default=4, help="set decimation to DECIM [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
Freq=Value('i',9475*10**5)
self.min_freq = Freq.value-(10*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more
self.max_freq = Freq.value+(10*10**6)
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq
self.fft_size = options.fft_size
if not options.real_time:
realtime = False
else:
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
realtime = True
else:
realtime = False
print "Note: failed to enable realtime scheduling"
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
if(options.spec):
self.u.set_subdev_spec(options.spec, 0)
if(options.antenna):
self.u.set_antenna(options.antenna, 0)
global size
size=self.fft_size
global samp_rate
samp_rate = 100e6/options.decim
self.u.set_samp_rate(samp_rate)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = fft.window.blackmanharris(self.fft_size)
fftvar = fft.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = blocks.complex_to_mag_squared(self.fft_size)
log = blocks.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
self.freq_step = 0 #0.75 * usrp_rate # Modified
self.min_center_freq = (self.min_freq + self.max_freq)/2
nsteps = 100 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
stats = blocks.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay)
self.connect(self.u, s2v, fftvar, c2mag, stats)
if options.gain is None:
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.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.freq_0 = freq_0 = 525.2e6
self.threshold = threshold = -60
self.samp_rate = samp_rate = 2.048e6
self.freq = freq = freq_0
##################################################
# 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=-100,
maximum=0,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_threshold_sizer)
self.wxgui_numbersink2_0_0 = numbersink2.number_sink_f(
self.GetWin(),
unit="signal present",
minval=0,
maxval=1,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=2.048e6,
number_rate=15,
average=False,
avg_alpha=None,
label="Signal detection",
peak_hold=False,
show_gauge=True,
)
self.Add(self.wxgui_numbersink2_0_0.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.GetWin(),
unit="Units",
minval=-120,
maxval=0,
factor=1.0,
decimal_places=10,
ref_level=0,
sample_rate=2048000,
number_rate=15,
average=True,
avg_alpha=0.03,
label="Level",
peak_hold=False,
show_gauge=True,
)
self.Add(self.wxgui_numbersink2_0.win)
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=2048000,
fft_size=1024,
fft_rate=15,
average=True,
avg_alpha=0.030,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_0.set_sample_rate(2.048e6)
self.rtlsdr_source_0.set_center_freq(freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(2, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(75, 0)
self.rtlsdr_source_0.set_if_gain(75, 0)
self.rtlsdr_source_0.set_bb_gain(5, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.notebook_0 = self.notebook_0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "tab1")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "tab2")
self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "tab3")
self.Add(self.notebook_0)
_freq_0_sizer = wx.BoxSizer(wx.VERTICAL)
self._freq_0_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_freq_0_sizer,
value=self.freq_0,
callback=self.set_freq_0,
label='freq_0',
converter=forms.float_converter(),
proportion=0,
)
self._freq_0_slider = forms.slider(
parent=self.GetWin(),
sizer=_freq_0_sizer,
value=self.freq_0,
callback=self.set_freq_0,
minimum=478e6,
maximum=862e6,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_freq_0_sizer)
self.fft_vxx_0 = fft.fft_vcc(1024, True, (window.rectangular(1024)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, 1024)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, 2048000,True)
self.blocks_threshold_ff_0 = blocks.threshold_ff(-100, threshold, -60)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_int*1, "/media/ubuntu/01D165566F075780/Q3/wireless networking/GNU/out1.txt", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1024)
self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 1.04858e6)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_divide_xx_0, 1))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_divide_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.wxgui_numbersink2_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.wxgui_numbersink2_0_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_divide_xx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self, "superdarn_playback_sigmf")
Qt.QWidget.__init__(self)
self.setWindowTitle("superdarn_playback_sigmf")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "superdarn_playback_sigmf")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.trig_lvl = trig_lvl = 0
self.throttle_rate = throttle_rate = 1
self.samp_rate = samp_rate = 250e3
self.decim = decim = 5
self.cutoff = cutoff = 5e3
self.coarse_freq = coarse_freq = 0
##################################################
# Blocks
##################################################
self._trig_lvl_tool_bar = Qt.QToolBar(self)
self._trig_lvl_tool_bar.addWidget(Qt.QLabel("trig_lvl"+": "))
self._trig_lvl_line_edit = Qt.QLineEdit(str(self.trig_lvl))
self._trig_lvl_tool_bar.addWidget(self._trig_lvl_line_edit)
self._trig_lvl_line_edit.returnPressed.connect(
lambda: self.set_trig_lvl(eng_notation.str_to_num(str(self._trig_lvl_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._trig_lvl_tool_bar, 7, 6, 1, 2)
for r in range(7, 8):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(6, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self._throttle_rate_tool_bar = Qt.QToolBar(self)
self._throttle_rate_tool_bar.addWidget(Qt.QLabel("throttle_rate"+": "))
self._throttle_rate_line_edit = Qt.QLineEdit(str(self.throttle_rate))
self._throttle_rate_tool_bar.addWidget(self._throttle_rate_line_edit)
self._throttle_rate_line_edit.returnPressed.connect(
lambda: self.set_throttle_rate(eng_notation.str_to_num(str(self._throttle_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._throttle_rate_tool_bar, 4, 6, 1, 2)
for r in range(4, 5):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(6, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self._samp_rate_tool_bar = Qt.QToolBar(self)
self._samp_rate_tool_bar.addWidget(Qt.QLabel("samp_rate"+": "))
self._samp_rate_line_edit = Qt.QLineEdit(str(self.samp_rate))
self._samp_rate_tool_bar.addWidget(self._samp_rate_line_edit)
self._samp_rate_line_edit.returnPressed.connect(
lambda: self.set_samp_rate(eng_notation.str_to_num(str(self._samp_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._samp_rate_tool_bar, 4, 4, 1, 2)
for r in range(4, 5):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 6):
self.top_grid_layout.setColumnStretch(c, 1)
self._cutoff_tool_bar = Qt.QToolBar(self)
self._cutoff_tool_bar.addWidget(Qt.QLabel("cutoff"+": "))
self._cutoff_line_edit = Qt.QLineEdit(str(self.cutoff))
self._cutoff_tool_bar.addWidget(self._cutoff_line_edit)
self._cutoff_line_edit.returnPressed.connect(
lambda: self.set_cutoff(eng_notation.str_to_num(str(self._cutoff_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._cutoff_tool_bar, 6, 4, 1, 2)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 6):
self.top_grid_layout.setColumnStretch(c, 1)
self._coarse_freq_range = Range(-125e3, 125e3, 1, 0, 200)
self._coarse_freq_win = RangeWidget(self._coarse_freq_range, self.set_coarse_freq, "coarse_freq", "counter_slider", float)
self.top_grid_layout.addWidget(self._coarse_freq_win, 5, 4, 1, 4)
for r in range(5, 6):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.sigmf_source_0 = gr_sigmf.source('/captures/20200731/SUPERDARN_2020-08-01T03:43:13Z.sigmf-data', "cf32" + ("_le" if sys.byteorder == "little" else "_be"), True)
self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
interpolation=1,
decimation=decim,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=1,
decimation=decim,
taps=None,
fractional_bw=None,
)
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(0.010)
self.qtgui_waterfall_sink_x_0.enable_grid(False)
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '',
'', '', '', '', '']
colors = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_waterfall_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-140, 10)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_waterfall_sink_x_0_win, 4, 0, 4, 4)
for r in range(4, 8):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
1024, #size
samp_rate/decim/decim, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.010)
self.qtgui_time_sink_x_0.set_y_axis(-30, 20)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_NORM, qtgui.TRIG_SLOPE_POS, trig_lvl, 0, 0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
if not False:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 2, 4, 2, 4)
for r in range(2, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_freq_sink_x_0_0 = qtgui.freq_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate/decim, #bw
"", #name
2 #number of inputs
)
self.qtgui_freq_sink_x_0_0.set_update_time(0.010)
self.qtgui_freq_sink_x_0_0.set_y_axis(-80, 10)
self.qtgui_freq_sink_x_0_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0_0.enable_grid(False)
self.qtgui_freq_sink_x_0_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0_0.enable_control_panel(False)
if not False:
self.qtgui_freq_sink_x_0_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_0_win, 0, 4, 2, 4)
for r in range(0, 2):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 8):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
2048, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.010)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not False:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win, 0, 0, 4, 4)
for r in range(0, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate/decim, cutoff, 1e3, firdes.WIN_HAMMING, 6.76))
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate*throttle_rate,True)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, -1*coarse_freq, 1, 0)
self.analog_agc2_xx_0 = analog.agc2_cc(1e-1, 1e-1, 1.0, 1.0)
self.analog_agc2_xx_0.set_max_gain(65536)
##################################################
# Connections
##################################################
self.connect((self.analog_agc2_xx_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.analog_agc2_xx_0, 0), (self.qtgui_freq_sink_x_0_0, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_throttle_0, 0), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.qtgui_waterfall_sink_x_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.qtgui_freq_sink_x_0_0, 1))
self.connect((self.low_pass_filter_0, 0), (self.rational_resampler_xxx_0_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.analog_agc2_xx_0, 0))
self.connect((self.rational_resampler_xxx_0_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.sigmf_source_0, 0), (self.blocks_throttle_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Ham2Mon NBFM Receiver Flow Example")
Qt.QWidget.__init__(self)
self.setWindowTitle("Ham2Mon NBFM Receiver Flow Example")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "nbfm_flow_example")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1E6
self.initial_decim = initial_decim = 5
self.samp_ratio = samp_ratio = samp_rate/1E6
self.final_rate = final_rate = samp_rate/initial_decim**2/int(samp_rate/1E6)
self.variable_low_pass_filter_taps_2 = variable_low_pass_filter_taps_2 = firdes.low_pass(1.0, final_rate, 3500, 500, firdes.WIN_HAMMING, 6.76)
self.variable_low_pass_filter_taps_1 = variable_low_pass_filter_taps_1 = firdes.low_pass(1.0, samp_rate/25, 12.5E3, 1E3, firdes.WIN_HAMMING, 6.76)
self.variable_low_pass_filter_taps_0 = variable_low_pass_filter_taps_0 = firdes.low_pass(1.0, 1, 0.090, 0.010, firdes.WIN_HAMMING, 6.76)
self.squelch_dB = squelch_dB = -70
self.gain_db = gain_db = 30
self.final_decim = final_decim = int(samp_rate/1E6)
self.file_name = file_name = "test.wav"
self.fft_length = fft_length = 256 * int(pow(2, np.ceil(np.log(samp_ratio)/np.log(2))))
self.demod_bb_freq = demod_bb_freq = 390E3
self.center_freq = center_freq = 144E6
##################################################
# Blocks
##################################################
self._squelch_dB_range = Range(-100, 0, 5, -70, 200)
self._squelch_dB_win = RangeWidget(self._squelch_dB_range, self.set_squelch_dB, "Squelch (dB)", "counter_slider", float)
self.top_grid_layout.addWidget(self._squelch_dB_win, 5,1,1,3)
self._gain_db_range = Range(0, 70, 1, 30, 200)
self._gain_db_win = RangeWidget(self._gain_db_range, self.set_gain_db, "HW Gain (dB)", "counter_slider", float)
self.top_grid_layout.addWidget(self._gain_db_win, 4,1,1,3)
self._demod_bb_freq_range = Range(-samp_rate/2, samp_rate/2, 5E3, 390E3, 200)
self._demod_bb_freq_win = RangeWidget(self._demod_bb_freq_range, self.set_demod_bb_freq, "Demod BB Freq (Hz)", "counter_slider", float)
self.top_grid_layout.addWidget(self._demod_bb_freq_win, 3,1,1,3)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
fft_length, #size
samp_rate, #samp_rate
"Averaged Spectrum", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-60, 40)
self.qtgui_time_sink_x_0.set_y_label("Power", "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 0,1,3,1)
self.qtgui_freq_sink_x_0_0 = qtgui.freq_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
final_rate, #bw
"Decimated Channel", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0_0.set_y_axis(-200, -60)
self.qtgui_freq_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0_0.enable_grid(False)
self.qtgui_freq_sink_x_0_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0_0.disable_legend()
if complex == type(float()):
self.qtgui_freq_sink_x_0_0.set_plot_pos_half(not True)
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_0_win, 3,0,3,1)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
fft_length, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
144E6, #fc
samp_rate, #bw
"Spectrum", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-120, -20)
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if complex == type(float()):
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win, 0,0,3,1)
self.pfb_arb_resampler_xxx_0 = pfb.arb_resampler_fff(
16E3/float(final_rate/5),
taps=None,
flt_size=32)
self.pfb_arb_resampler_xxx_0.declare_sample_delay(0)
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "uhd" )
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(center_freq, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(gain_db, 0)
self.osmosdr_source_0.set_if_gain(20, 0)
self.osmosdr_source_0.set_bb_gain(20, 0)
self.osmosdr_source_0.set_antenna("", 0)
self.osmosdr_source_0.set_bandwidth(samp_rate*0.8, 0)
self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc(initial_decim, (variable_low_pass_filter_taps_0), demod_bb_freq, samp_rate)
self.fir_filter_xxx_0_1 = filter.fir_filter_fff(initial_decim, (variable_low_pass_filter_taps_0))
self.fir_filter_xxx_0_1.declare_sample_delay(0)
self.fir_filter_xxx_0_0 = filter.fir_filter_ccc(int(samp_rate/1E6), (variable_low_pass_filter_taps_0))
self.fir_filter_xxx_0_0.declare_sample_delay(0)
self.fir_filter_xxx_0 = filter.fir_filter_ccc(initial_decim, (variable_low_pass_filter_taps_0))
self.fir_filter_xxx_0.declare_sample_delay(0)
self.fft_vxx_0 = fft.fft_vcc(fft_length, True, (window.blackmanharris(fft_length)), True, 1)
self.blocks_wavfile_sink_0 = blocks.wavfile_sink(file_name, 1, 16000, 8)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_length)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_length)
self.blocks_probe_signal_vx_0 = blocks.probe_signal_vf(fft_length)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, fft_length, 0)
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_gr_complex*fft_length, int(round(samp_rate/fft_length/1000)))
self.blocks_integrate_xx_0 = blocks.integrate_ff(100, fft_length)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_length)
self.audio_sink_0 = audio.sink(16000, "", True)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(0.050)
self.analog_pwr_squelch_xx_0_0 = analog.pwr_squelch_ff(-200, 0.1, 0, True)
self.analog_pwr_squelch_xx_0 = analog.pwr_squelch_cc(squelch_dB, 0.1, 0, False)
##################################################
# Connections
##################################################
self.connect((self.analog_pwr_squelch_xx_0, 0), (self.analog_quadrature_demod_cf_0, 0))
self.connect((self.analog_pwr_squelch_xx_0_0, 0), (self.blocks_wavfile_sink_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.fir_filter_xxx_0_1, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0))
self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_keep_one_in_n_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_probe_signal_vx_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.blocks_keep_one_in_n_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.fir_filter_xxx_0_0, 0))
self.connect((self.fir_filter_xxx_0_0, 0), (self.analog_pwr_squelch_xx_0, 0))
self.connect((self.fir_filter_xxx_0_0, 0), (self.qtgui_freq_sink_x_0_0, 0))
self.connect((self.fir_filter_xxx_0_1, 0), (self.pfb_arb_resampler_xxx_0, 0))
self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.pfb_arb_resampler_xxx_0, 0), (self.analog_pwr_squelch_xx_0_0, 0))
self.connect((self.pfb_arb_resampler_xxx_0, 0), (self.audio_sink_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="DVBT Scanner")
##################################################
# Variables
##################################################
self.threshold = threshold = -60
self.signal_level = signal_level = 0
self.samp_rate = samp_rate = 2048000
self.freq = freq = 525200000
self.fft_size = fft_size = 1024
self.detected = detected = 0
##################################################
# 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=-100,
maximum=0,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_threshold_sizer, 2, 0, 1, 1)
self.probe_signal_lvl = blocks.probe_signal_f()
self.notebook = self.notebook = wx.Notebook(self.GetWin(),
style=wx.NB_TOP)
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Spektrum")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Output")
self.GridAdd(self.notebook, 0, 0, 1, 1)
_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="Frequency",
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=478000000,
maximum=862000000,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_freq_sizer, 1, 0, 1, 1)
self.wxgui_numbersink2_1 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="Signal present",
minval=0,
maxval=1,
factor=1.0,
decimal_places=0,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=None,
label="Signal Detection",
peak_hold=False,
show_gauge=True,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_1.win)
self.wxgui_numbersink2_0 = numbersink2.number_sink_f(
self.notebook.GetPage(1).GetWin(),
unit="dB",
minval=-120,
maxval=0,
factor=1.0,
decimal_places=1,
ref_level=0,
sample_rate=samp_rate,
number_rate=15,
average=False,
avg_alpha=0.03,
label="Level",
peak_hold=False,
show_gauge=True,
)
self.notebook.GetPage(1).Add(self.wxgui_numbersink2_0.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.notebook.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=fft_size,
fft_rate=15,
average=True,
avg_alpha=0.03,
title="FFT Plot",
peak_hold=False,
win=window.flattop,
)
self.notebook.GetPage(0).Add(self.wxgui_fftsink2_0.win)
def _signal_level_probe():
while True:
val = self.probe_signal_lvl.level()
try:
self.set_signal_level(val)
except AttributeError:
pass
time.sleep(1.0 / (5))
_signal_level_thread = threading.Thread(target=_signal_level_probe)
_signal_level_thread.daemon = True
_signal_level_thread.start()
self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " +
"hackrf=0")
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(14, 0)
self.rtlsdr_source_0.set_if_gain(24, 0)
self.rtlsdr_source_0.set_bb_gain(12, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.probe_detected = blocks.probe_signal_f()
self.fft_vxx_0 = fft.fft_vcc(fft_size, True,
(window.rectangular(fft_size)), True, 1)
def _detected_probe():
while True:
val = self.probe_detected.level()
try:
self.set_detected(val)
except AttributeError:
pass
time.sleep(1.0 / (5))
_detected_thread = threading.Thread(target=_detected_probe)
_detected_thread.daemon = True
_detected_thread.start()
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_float * 1, fft_size)
self.blocks_threshold_ff_0 = blocks.threshold_ff(
threshold, threshold, threshold)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(10, 1, 0)
self.blocks_moving_average_xx_0 = blocks.moving_average_ff(
1000, 0.001, 4000)
self.blocks_divide_xx_0 = blocks.divide_ff(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(
fft_size)
self.analog_const_source_x_0 = analog.sig_source_f(
0, analog.GR_CONST_WAVE, 0, 0, 1048580)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0),
(self.blocks_divide_xx_0, 1))
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_divide_xx_0, 0),
(self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.blocks_threshold_ff_0, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.probe_signal_lvl, 0))
self.connect((self.blocks_moving_average_xx_0, 0),
(self.wxgui_numbersink2_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0),
(self.blocks_moving_average_xx_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.probe_detected, 0))
self.connect((self.blocks_threshold_ff_0, 0),
(self.wxgui_numbersink2_1, 0))
self.connect((self.blocks_vector_to_stream_0, 0),
(self.blocks_divide_xx_0, 0))
self.connect((self.fft_vxx_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rtlsdr_source_0, 0),
(self.blocks_stream_to_vector_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.fd = fd = 50
self.chan_rate = chan_rate = 250000
self.fdTs = fdTs = fd*(1.0/chan_rate)
self.fadeMode = fadeMode = False
##################################################
# Blocks
##################################################
_fadeMode_check_box = Qt.QCheckBox("Fading Enabled")
self._fadeMode_choices = {True: True, False: False}
self._fadeMode_choices_inv = dict((v,k) for k,v in self._fadeMode_choices.iteritems())
self._fadeMode_callback = lambda i: Qt.QMetaObject.invokeMethod(_fadeMode_check_box, "setChecked", Qt.Q_ARG("bool", self._fadeMode_choices_inv[i]))
self._fadeMode_callback(self.fadeMode)
_fadeMode_check_box.stateChanged.connect(lambda i: self.set_fadeMode(self._fadeMode_choices[bool(i)]))
self.top_layout.addWidget(_fadeMode_check_box)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("0.0.0.0", 1234), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
self.rccBlocks_rayleighChan_cc_0 = rccBlocks.rayleighChan_cc(randint(-10e3, 0), fdTs, 1.0, False, fadeMode)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
25000, #size
chan_rate, #samp_rate
"QT GUI Plot", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-50, 20)
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.qtgui_histogram_sink_x_0 = qtgui.histogram_sink_f(
1500000,
100,
0,
4,
"QT GUI Plot",
1
)
self.qtgui_histogram_sink_x_0.set_update_time(0.10)
self._qtgui_histogram_sink_x_0_win = sip.wrapinstance(self.qtgui_histogram_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_histogram_sink_x_0_win)
self._fd_tool_bar = Qt.QToolBar(self)
self._fd_tool_bar.addWidget(Qt.QLabel("Doppler Rate, Hz"+": "))
self._fd_line_edit = Qt.QLineEdit(str(self.fd))
self._fd_tool_bar.addWidget(self._fd_line_edit)
self._fd_line_edit.returnPressed.connect(
lambda: self.set_fd(eng_notation.str_to_num(self._fd_line_edit.text().toAscii())))
self.top_layout.addWidget(self._fd_tool_bar)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, chan_rate,True)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(1, 1, 0)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((20, ))
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1)
self.analog_const_source_x_0 = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, 1+1j)
##################################################
# Connections
##################################################
self.connect((self.analog_const_source_x_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.rccBlocks_rayleighChan_cc_0, 0))
self.connect((self.rccBlocks_rayleighChan_cc_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_complex_to_mag_0, 0), (self.qtgui_histogram_sink_x_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.qtgui_time_sink_x_0, 0))
def __init__(self):
gr.top_block.__init__(self, "SIMONES_Occupation")
##################################################
# Variables
##################################################
self.fft_size = fft_size = 1024
self.samp_rate = samp_rate = 20e6
self.fft_window = fft_window = window.blackmanharris(fft_size)
self.power = power = sum(x*x for x in fft_window)
self.center_freq = center_freq = 98e6
self.bandwidth = bandwidth = samp_rate
self.stop_freq = stop_freq = center_freq+(bandwidth/2)
self.start_freq = start_freq = center_freq-(bandwidth/2)
self.simon_port = simon_port = 65123
self.simon_ip = simon_ip = '127.0.0.1'
self.server_port = server_port = 65234
self.server_ip = server_ip = '127.0.0.1'
self.n = n = max(1, int(samp_rate/fft_size/15L))
self.k = k = -20*math.log10(fft_size)-10*math.log10(power/fft_size)-20*math.log10(2.0/2)
self.device = device = 'bladerf,fpga=/home/i2t/Software/source/bladeRF/pre-built/hostedx115.rbf,xb200=auto'
self.canalization = canalization = 1e6
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer((simon_ip, simon_port), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(1.0, fft_size)
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + device )
self.osmosdr_source_0.set_sample_rate(samp_rate)
self.osmosdr_source_0.set_center_freq(center_freq, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(10, 0)
self.osmosdr_source_0.set_if_gain(20, 0)
self.osmosdr_source_0.set_bb_gain(20, 0)
self.osmosdr_source_0.set_antenna("", 0)
self.osmosdr_source_0.set_bandwidth(bandwidth, 0)
self.fft_vxx_0 = fft.fft_vcc(fft_size, True, (fft_window), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_size)
self.blocks_udp_sink_0 = blocks.udp_sink(gr.sizeof_float*1, server_ip, server_port, 1472, True)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_size)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(20, fft_size, k)
self.blocks_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_gr_complex*fft_size, n)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1024)
##################################################
# Connections
##################################################
self.connect((self.blocks_keep_one_in_n_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.blocks_keep_one_in_n_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.osmosdr_source_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.blocks_complex_to_mag_0, 0), (self.single_pole_iir_filter_xx_0, 0))
self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_udp_sink_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Transceiver Test for Client Node")
Qt.QWidget.__init__(self)
self.setWindowTitle("Transceiver Test for Client Node")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
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)
self.settings = Qt.QSettings("GNU Radio", "inets_transceiver_test_client")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.sps = sps = 4
self.range_rx_gain = range_rx_gain = 0
self.range_mu = range_mu = 0.6
self.threshold = threshold = 50
self.samp_rate = samp_rate = 4e6
self.rx_gain = rx_gain = range_rx_gain
self.rrc = rrc = firdes.root_raised_cosine(1.0, sps, 1, 0.5, 11*sps)
self.range_noise = range_noise = 0
self.qpsk_mod = qpsk_mod = gnuradio.digital.constellation_qpsk().base()
self.qam16_mod = qam16_mod = gnuradio.digital.qam_constellation(16,False).base()
self.preamble = preamble = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1,1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0]
self.mu = mu = range_mu
self.diff_preamble_256 = diff_preamble_256 = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1,1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0]
self.diff_preamble_128 = diff_preamble_128 = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1,1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0][0:128]
self.bpsk_mod = bpsk_mod = gnuradio.digital.constellation_bpsk().base()
##################################################
# Blocks
##################################################
self.tab = Qt.QTabWidget()
self.tab_widget_0 = Qt.QWidget()
self.tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_0)
self.tab_grid_layout_0 = Qt.QGridLayout()
self.tab_layout_0.addLayout(self.tab_grid_layout_0)
self.tab.addTab(self.tab_widget_0, "TX")
self.tab_widget_1 = Qt.QWidget()
self.tab_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_1)
self.tab_grid_layout_1 = Qt.QGridLayout()
self.tab_layout_1.addLayout(self.tab_grid_layout_1)
self.tab.addTab(self.tab_widget_1, "RX")
self.tab_widget_2 = Qt.QWidget()
self.tab_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_2)
self.tab_grid_layout_2 = Qt.QGridLayout()
self.tab_layout_2.addLayout(self.tab_grid_layout_2)
self.tab.addTab(self.tab_widget_2, "Demod")
self.tab_widget_3 = Qt.QWidget()
self.tab_layout_3 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_3)
self.tab_grid_layout_3 = Qt.QGridLayout()
self.tab_layout_3.addLayout(self.tab_grid_layout_3)
self.tab.addTab(self.tab_widget_3, "RSSI")
self.top_layout.addWidget(self.tab)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("addr=192.168.10.2", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
self.uhd_usrp_source_0.set_center_freq(2e9, 0)
self.uhd_usrp_source_0.set_gain(rx_gain, 0)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("addr=192.168.10.2", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
"packet_len",
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
self.uhd_usrp_sink_0.set_center_freq(1.5e9, 0)
self.uhd_usrp_sink_0.set_gain(0, 0)
self._range_rx_gain_range = Range(0, 60, 1, 0, 200)
self._range_rx_gain_win = RangeWidget(self._range_rx_gain_range, self.set_range_rx_gain, "Rx Gain", "counter_slider", float)
self.top_grid_layout.addWidget(self._range_rx_gain_win, 1,0,1,1)
self._range_noise_range = Range(0, 0.01, 0.00001, 0, 200)
self._range_noise_win = RangeWidget(self._range_noise_range, self.set_range_noise, "noise", "counter_slider", float)
self.top_layout.addWidget(self._range_noise_win)
self._range_mu_range = Range(0, 1, 0.01, 0.6, 200)
self._range_mu_win = RangeWidget(self._range_mu_range, self.set_range_mu, "BB Derotation Gain", "counter_slider", float)
self.top_grid_layout.addWidget(self._range_mu_win, 2,0,1,1)
self.qtgui_time_sink_x_1 = qtgui.time_sink_f(
1000000, #size
samp_rate, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_1.set_update_time(0.10)
self.qtgui_time_sink_x_1.set_y_axis(-80, -40)
self.qtgui_time_sink_x_1.set_y_label("Amplitude", "")
self.qtgui_time_sink_x_1.enable_tags(-1, True)
self.qtgui_time_sink_x_1.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self.qtgui_time_sink_x_1.enable_autoscale(False)
self.qtgui_time_sink_x_1.enable_grid(False)
self.qtgui_time_sink_x_1.enable_axis_labels(True)
self.qtgui_time_sink_x_1.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_1.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_1.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_1.set_line_label(i, labels[i])
self.qtgui_time_sink_x_1.set_line_width(i, widths[i])
self.qtgui_time_sink_x_1.set_line_color(i, colors[i])
self.qtgui_time_sink_x_1.set_line_style(i, styles[i])
self.qtgui_time_sink_x_1.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_1.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_1_win = sip.wrapinstance(self.qtgui_time_sink_x_1.pyqwidget(), Qt.QWidget)
self.tab_layout_3.addWidget(self._qtgui_time_sink_x_1_win)
self.qtgui_time_sink_x_0_0 = qtgui.time_sink_f(
256, #size
1, #samp_rate
"Frequency Offset", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0_0.set_update_time(0.10)
self.qtgui_time_sink_x_0_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0_0.set_y_label("Amplitude", "")
self.qtgui_time_sink_x_0_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 1, 0, 0, "")
self.qtgui_time_sink_x_0_0.enable_autoscale(True)
self.qtgui_time_sink_x_0_0.enable_grid(True)
self.qtgui_time_sink_x_0_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [0, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.tab_layout_1.addWidget(self._qtgui_time_sink_x_0_0_win)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
100000, #size
samp_rate / 4, #samp_rate
"Correlation", #name
3 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 200)
self.qtgui_time_sink_x_0.set_y_label("Amplitude", "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 20, 0, 1, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(3):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.tab_layout_1.addWidget(self._qtgui_time_sink_x_0_win)
self.qtgui_const_sink_x_0_0_0 = qtgui.const_sink_c(
1024, #size
"TX Constellation", #name
1 #number of inputs
)
self.qtgui_const_sink_x_0_0_0.set_update_time(0.10)
self.qtgui_const_sink_x_0_0_0.set_y_axis(-2, 2)
self.qtgui_const_sink_x_0_0_0.set_x_axis(-2, 2)
self.qtgui_const_sink_x_0_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, "")
self.qtgui_const_sink_x_0_0_0.enable_autoscale(False)
self.qtgui_const_sink_x_0_0_0.enable_grid(True)
self.qtgui_const_sink_x_0_0_0.enable_axis_labels(True)
if not True:
self.qtgui_const_sink_x_0_0_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "red", "red", "red",
"red", "red", "red", "red", "red"]
styles = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
markers = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_0_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_0_0_0.set_line_label(i, labels[i])
self.qtgui_const_sink_x_0_0_0.set_line_width(i, widths[i])
self.qtgui_const_sink_x_0_0_0.set_line_color(i, colors[i])
self.qtgui_const_sink_x_0_0_0.set_line_style(i, styles[i])
self.qtgui_const_sink_x_0_0_0.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_0_0_0.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_0_0_0_win = sip.wrapinstance(self.qtgui_const_sink_x_0_0_0.pyqwidget(), Qt.QWidget)
self.tab_layout_0.addWidget(self._qtgui_const_sink_x_0_0_0_win)
self.qtgui_const_sink_x_0_0 = qtgui.const_sink_c(
1024, #size
"Payload", #name
1 #number of inputs
)
self.qtgui_const_sink_x_0_0.set_update_time(0.10)
self.qtgui_const_sink_x_0_0.set_y_axis(-2, 2)
self.qtgui_const_sink_x_0_0.set_x_axis(-2, 2)
self.qtgui_const_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, "fd")
self.qtgui_const_sink_x_0_0.enable_autoscale(False)
self.qtgui_const_sink_x_0_0.enable_grid(True)
self.qtgui_const_sink_x_0_0.enable_axis_labels(True)
if not True:
self.qtgui_const_sink_x_0_0.disable_legend()
labels = ["", "", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "red", "red", "red",
"red", "red", "red", "red", "red"]
styles = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
markers = [0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_const_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_const_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_const_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_const_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_const_sink_x_0_0.set_line_style(i, styles[i])
self.qtgui_const_sink_x_0_0.set_line_marker(i, markers[i])
self.qtgui_const_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_const_sink_x_0_0_win = sip.wrapinstance(self.qtgui_const_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.tab_layout_2.addWidget(self._qtgui_const_sink_x_0_0_win)
self.inets_rssi_0 = inets.rssi(0.00004)
self.inets_radio_0 = inets_radio(
constellation=qpsk_mod,
matched_filter_coeff=rrc,
mu=mu,
preamble=diff_preamble_128,
samp_rate=samp_rate,
sps=sps,
threshold=threshold,
)
self.inets_per_logger_0 = inets.per_logger()
self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", "localhost", "52001", 10000, False)
self.blocks_null_sink_1 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_nlog10_ff_0 = blocks.nlog10_ff(1, 1, 0)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((10, ))
self.blocks_complex_to_mag_0_0 = blocks.complex_to_mag(1)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1)
self.blocks_char_to_float_0 = blocks.char_to_float(1, 1)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_socket_pdu_0, 'pdus'), (self.inets_radio_0, 'in'))
self.msg_connect((self.inets_radio_0, 'out'), (self.inets_per_logger_0, 'payload_in'))
self.msg_connect((self.inets_radio_0, 'snr'), (self.inets_per_logger_0, 'snr_in'))
self.connect((self.blocks_char_to_float_0, 0), (self.qtgui_time_sink_x_0, 2))
self.connect((self.blocks_complex_to_mag_0, 0), (self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_complex_to_mag_0_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.qtgui_time_sink_x_1, 0))
self.connect((self.blocks_nlog10_ff_0, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.inets_radio_0, 5), (self.blocks_char_to_float_0, 0))
self.connect((self.inets_radio_0, 2), (self.blocks_complex_to_mag_0, 0))
self.connect((self.inets_radio_0, 1), (self.blocks_complex_to_mag_0_0, 0))
self.connect((self.inets_radio_0, 3), (self.qtgui_const_sink_x_0_0, 0))
self.connect((self.inets_radio_0, 6), (self.qtgui_const_sink_x_0_0_0, 0))
self.connect((self.inets_radio_0, 4), (self.qtgui_time_sink_x_0_0, 0))
self.connect((self.inets_radio_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.inets_rssi_0, 0), (self.blocks_nlog10_ff_0, 0))
self.connect((self.inets_rssi_0, 1), (self.blocks_null_sink_1, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.inets_radio_0, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.inets_rssi_0, 0))
