def __init__(self):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.signal_freq = signal_freq = 5000
self.samp_rate = samp_rate = 48000
self.bw = bw = 200
##################################################
# Blocks
##################################################
self.gr_probe_ref = gr.probe_signal_f()
self.gr_probe_mag = gr.probe_signal_f()
self.gr_probe_arg = gr.probe_signal_f()
self.gr_nlog10_ff_ref = gr.nlog10_ff(1, 1, 0)
self.gr_nlog10_ff_0 = gr.nlog10_ff(1, 1, 0)
self.gr_divide_xx_0 = gr.divide_cc(1)
self.gr_complex_to_mag_ref = gr.complex_to_mag(1)
self.gr_complex_to_mag_0 = gr.complex_to_mag(1)
self.gr_complex_to_arg_0 = gr.complex_to_arg(1)
self.band_pass_filter_0_0 = gr.fir_filter_fcc(
1,
firdes.complex_band_pass(
1, samp_rate, signal_freq - bw / 2, signal_freq + bw / 2, 100, firdes.WIN_BLACKMAN, 6.76
),
)
self.band_pass_filter_0 = gr.fir_filter_fcc(
1,
firdes.complex_band_pass(
1, samp_rate, signal_freq - bw / 2, signal_freq + bw / 2, 100, firdes.WIN_BLACKMAN, 6.76
),
)
self.audio_source_0 = audio.source(samp_rate, "", True)
##################################################
# Connections
##################################################
self.connect((self.band_pass_filter_0_0, 0), (self.gr_complex_to_mag_0, 0))
self.connect((self.gr_complex_to_mag_0, 0), (self.gr_nlog10_ff_0, 0))
self.connect((self.gr_divide_xx_0, 0), (self.gr_complex_to_arg_0, 0))
self.connect((self.band_pass_filter_0_0, 0), (self.gr_divide_xx_0, 0))
self.connect((self.band_pass_filter_0, 0), (self.gr_divide_xx_0, 1))
self.connect((self.audio_source_0, 1), (self.band_pass_filter_0_0, 0))
self.connect((self.audio_source_0, 0), (self.band_pass_filter_0, 0))
self.connect((self.gr_nlog10_ff_0, 0), (self.gr_probe_mag, 0))
self.connect((self.gr_complex_to_arg_0, 0), (self.gr_probe_arg, 0))
self.connect((self.band_pass_filter_0, 0), (self.gr_complex_to_mag_ref, 0))
self.connect((self.gr_complex_to_mag_ref, 0), (self.gr_nlog10_ff_ref, 0))
self.connect((self.gr_nlog10_ff_ref, 0), (self.gr_probe_ref, 0))
def supply_rx_baseband(self):
## RX Spectrum
if self.__dict__.has_key('rx_baseband'):
return self.rx_baseband
config = self.config
fftlen = config.fft_length
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex, fftlen)
rxs_trigger = blocks.vector_source_b(concatenate([[1], [0] * 199]),
True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen, True, [], True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01, fftlen)
rxs_logdb = gr.nlog10_ff(20.0, fftlen, -20 * log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float * fftlen, 50)
t = self.u if self.filter is None else self.filter
self.connect(rxs_trigger, (rxs_sampler, 1))
self.connect(t, rxs_sampler, rxs_window, rxs_spectrum, rxs_mag,
rxs_avg, rxs_logdb, rxs_decimate_rate)
if self._options.log:
log_to_file(self, rxs_decimate_rate, "data/supply_rx.float")
self.rx_baseband = rxs_decimate_rate
return rxs_decimate_rate
def __init__(self, fg, parent, baseband_freq=0,
y_per_div=10, ref_level=100, sample_rate=1, fft_size=512,
fft_rate=20, average=False, avg_alpha=None, title='',
size=default_fftsink_size):
fft_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
y_per_div=y_per_div, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
s2p = gr.serial_to_parallel(gr.sizeof_float, fft_size)
one_in_n = gr.keep_one_in_n(gr.sizeof_float * fft_size,
int(sample_rate/fft_size/fft_rate))
mywindow = window.blackmanharris(fft_size)
fft = gr.fft_vfc(self.fft_size, True, mywindow)
#fft = gr.fft_vfc(fft_size, True, True)
c2mag = gr.complex_to_mag(fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
log = gr.nlog10_ff(20, fft_size)
sink = gr.file_descriptor_sink(gr.sizeof_float * fft_size, self.w_fd)
fg.connect (s2p, one_in_n, fft, c2mag, self.avg, log, sink)
gr.hier_block.__init__(self, fg, s2p, sink)
self.fg = fg
self.gl_fft_window(self)
def __init__(self, fg, 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, peak_hold=False):
fft_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
y_per_div=y_per_div, 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)
s2p = gr.stream_to_vector(gr.sizeof_float, 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)))
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vfc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
# FIXME We need to add 3dB to all bins but the DC bin
log = gr.nlog10_ff(20, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
fg.connect (s2p, self.one_in_n, fft, c2mag, self.avg, log, sink)
gr.hier_block.__init__(self, fg, s2p, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
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 = gr.serial_to_parallel(gr.sizeof_float, 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)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = gr.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = gr.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 main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
add_options(parser, expert_grp)
(options, args) = parser.parse_args ()
fft_length = options.fft_length or 512
file = options.file or "input.compl"
out = options.out or "output.compl"
src = gr.file_source(gr.sizeof_gr_complex,file)
sampler = ofdm.vector_sampler( gr.sizeof_gr_complex, fft_length )
trig = gr.vector_source_b([1],True)
fft = gr.fft_vcc( fft_length, True, [], True )
mag = gr.complex_to_mag( fft_length )
avg = gr.single_pole_iir_filter_ff(0.01, fft_length)
nlog = gr.nlog10_ff( 20, fft_length, -10*math.log10(fft_length) )
dst = gr.file_sink( gr.sizeof_float * fft_length, out )
fg = gr.top_block()
fg.connect( src, sampler, fft, mag, avg, nlog, dst )
fg.connect( trig, (sampler,1))
# fg.connect(src,limit,
# gr.stream_to_vector(gr.sizeof_gr_complex,fft_length),
# fft,
# gr.multiply_const_vcc([1./fft_length]*fft_length),
# gr.complex_to_mag(fft_length),
# gr.nlog10_ff(10.0,fft_length),
# dst)
# fg.connect( src, fft, dst )
fg.run()
print "done"
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):
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 = gr.serial_to_parallel(gr.sizeof_float, 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)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = gr.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = gr.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, 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 = gr.nlog10_ff(10, 1, 0)
self.gr_complex_to_mag_squared_0 = gr.complex_to_mag_squared(1)
self.fir_filter_xxx_0 = filter.fir_filter_fff(samp_per_sym, (16 * [1.0 / 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, sc_y_per_div=0.5, sc_ref_level=40, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=15, average=False, avg_alpha=None, title='',
size=default_ra_fftsink_size, peak_hold=False, ofunc=None,
xydfunc=None):
gr.hier_block2.__init__(self, "ra_fft_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0, 0, 0))
ra_fft_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
y_per_div=y_per_div, sc_y_per_div=sc_y_per_div,
sc_ref_level=sc_ref_level, 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, ofunc=ofunc,
xydfunc=xydfunc)
self.binwidth = float(sample_rate/2.0)/float(fft_size)
s2p = gr.serial_to_parallel(gr.sizeof_float, fft_size)
one_in_n = gr.keep_one_in_n(gr.sizeof_float * fft_size,
max(1, int(sample_rate/fft_size/fft_rate)))
mywindow = window.blackmanharris(fft_size)
fft = gr.fft_vfc(fft_size, True, mywindow)
c2mag = gr.complex_to_mag(fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
log = gr.nlog10_ff(20, fft_size, -20*math.log10(fft_size))
sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True)
self.connect (self, s2p, one_in_n, fft, c2mag, self.avg, log, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, fg, parent, baseband_freq=0,
ref_level=0, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, report=None, span=40, ofunc=None, xydfunc=None):
waterfall_sink_base.__init__(self, input_is_real=False,
baseband_freq=baseband_freq,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha,
title=title)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.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)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
log = gr.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.block_list = (s2p, self.one_in_n, fft, c2mag, self.avg, log, sink)
self.reconnect( fg )
gr.hier_block.__init__(self, fg, s2p, sink)
self.win = waterfall_window(self, parent, size=size, report=report,
ref_level=ref_level, span=span, ofunc=ofunc, xydfunc=xydfunc)
self.set_average(self.average)
def __init__(
self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title="",
size=default_facsink_size,
peak_hold=False,
):
fac_sink_base.__init__(
self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold,
)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))
)
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(
20, self.fac_size, -20 * math.log10(self.fac_size)
) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def supply_rx_baseband(self):
## RX Spectrum
if self.__dict__.has_key('rx_baseband'):
return self.rx_baseband
config = self.config
fftlen = config.fft_length
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen)
rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen,True,[],True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen)
rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,50)
t = self.u if self.filter is None else self.filter
self.connect(rxs_trigger,(rxs_sampler,1))
self.connect(t,rxs_sampler,rxs_window,
rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate)
if self._options.log:
log_to_file(self, rxs_decimate_rate, "data/supply_rx.float")
self.rx_baseband = rxs_decimate_rate
return rxs_decimate_rate
def main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
add_options(parser, expert_grp)
(options, args) = parser.parse_args()
fft_length = options.fft_length or 512
file = options.file or "input.compl"
out = options.out or "output.compl"
src = gr.file_source(gr.sizeof_gr_complex, file)
sampler = ofdm.vector_sampler(gr.sizeof_gr_complex, fft_length)
trig = gr.vector_source_b([1], True)
fft = gr.fft_vcc(fft_length, True, [], True)
mag = gr.complex_to_mag(fft_length)
avg = gr.single_pole_iir_filter_ff(0.01, fft_length)
nlog = gr.nlog10_ff(20, fft_length, -10 * math.log10(fft_length))
dst = gr.file_sink(gr.sizeof_float * fft_length, out)
fg = gr.top_block()
fg.connect(src, sampler, fft, mag, avg, nlog, dst)
fg.connect(trig, (sampler, 1))
# fg.connect(src,limit,
# gr.stream_to_vector(gr.sizeof_gr_complex,fft_length),
# fft,
# gr.multiply_const_vcc([1./fft_length]*fft_length),
# gr.complex_to_mag(fft_length),
# gr.nlog10_ff(10.0,fft_length),
# dst)
# fg.connect( src, fft, dst )
fg.run()
print "done"
def publish_rx_spectrum(self,fftlen):
## RX Spectrum
fftlen = 256
my_window = window.hamming(fftlen) #.blackmanharris(fftlen)
rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen)
rxs_trigger = gr.vector_source_b(concatenate([[1],[0]*199]),True)
rxs_window = blocks.multiply_const_vcc(my_window)
rxs_spectrum = gr.fft_vcc(fftlen,True,[],True)
rxs_mag = gr.complex_to_mag(fftlen)
rxs_avg = gr.single_pole_iir_filter_ff(0.01,fftlen)
rxs_logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1)
msgq = gr.msg_queue(5)
rxs_msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True)
self.connect(rxs_trigger,(rxs_sampler,1))
t = self.u if self.filter is None else self.filter
self.connect(t,rxs_sampler,rxs_window,
rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate,
rxs_msg_sink)
self.servants.append(corba_data_buffer_servant("spectrum",fftlen,msgq))
print "RXS trigger unique id", rxs_trigger.unique_id()
print "Publishing RX baseband under id: spectrum"
def __init__(self, sample_rate, fft_size, ref_scale, frame_rate, avg_alpha, average):
"""!
Create an log10(abs(fft)) stream chain.
Provide access to the setting the filter and sample rate.
@param sample_rate Incoming stream sample rate
@param fft_size Number of FFT bins
@param ref_scale Sets 0 dB value input amplitude
@param frame_rate Output frame rate
@param avg_alpha FFT averaging (over time) constant [0.0-1.0]
@param average Whether to average [True, False]
"""
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 = stream_to_vector_decimator(item_size=self._item_size,
sample_rate=sample_rate,
vec_rate=frame_rate,
vec_len=fft_size)
fft_window = window.blackmanharris(fft_size)
fft = self._fft_block[0](fft_size, True, fft_window)
window_power = sum(map(lambda x: x*x, fft_window))
c2mag = gr.complex_to_mag(fft_size)
self._avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
self._log = gr.nlog10_ff(20, fft_size,
-10*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, c2mag, self._avg, self._log, self)
self.set_average(average)
self.set_avg_alpha(avg_alpha)
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 = blks2.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 = gr.single_pole_iir_filter_ff(1.0, pspectrum_len)
self._log = gr.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,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title="",
size=default_facsink_size,
peak_hold=False,
):
fac_sink_base.__init__(
self,
input_is_real=True,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold,
)
s2p = gr.stream_to_vector(gr.sizeof_float, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_float * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))
)
# windowing removed...
fac = gr.fft_vfc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(self.fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fac_size)
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
# FIXME We need to add 3dB to all bins but the DC bin
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(self.fac_size))
sink = gr.message_sink(gr.sizeof_float * self.fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink)
# gr.hier_block.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
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 = gr.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 = gr.nlog10_ff(10, self.options.fft_len)
self.connect(self.head, self.specest, lin2db, self.sink)
self.ylabelstr = 'Power Spectrum Density / dBW/rad'
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
size=default_facsink_size,
peak_hold=False):
fac_sink_base.__init__(self,
input_is_real=True,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_float, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_float * self.fac_size,
max(1, int(self.sample_rate / self.fac_size / self.fac_rate)))
# windowing removed...
fac = gr.fft_vfc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(self.fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fac_size)
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
# FIXME We need to add 3dB to all bins but the DC bin
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(self.fac_size))
sink = gr.message_sink(gr.sizeof_float * self.fac_size, self.msgq,
True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag,
self.avg, log, sink)
# gr.hier_block.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
size=default_facsink_size,
peak_hold=False):
fac_sink_base.__init__(self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size,
max(1, int(self.sample_rate / self.fac_size / self.fac_rate)))
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(
self.fac_size)) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag,
self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def test_001(self):
src_data = (-10, 0, 10, 100, 1000, 10000, 100000)
expected_result = (-180, -180, 10, 20, 30, 40, 50)
src = gr.vector_source_f(src_data)
op = gr.nlog10_ff(10)
dst = gr.vector_sink_f()
self.tb.connect (src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual (expected_result, result_data)
def __init__(self,
parent,
baseband_freq=0,
ref_level=0,
sample_rate=1,
fft_size=512,
fft_rate=default_fft_rate,
average=False,
avg_alpha=None,
title='',
size=default_fftsink_size,
report=None,
span=40,
ofunc=None,
xydfunc=None):
gr.hier_block2.__init__(self, "waterfall_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
waterfall_sink_base.__init__(self,
input_is_real=False,
baseband_freq=baseband_freq,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average,
avg_alpha=avg_alpha,
title=title)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.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)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fft_size)
log = gr.nlog10_ff(20, self.fft_size, -20 * math.log10(self.fft_size))
sink = gr.message_sink(gr.sizeof_float * self.fft_size, self.msgq,
True)
self.connect(self, s2p, self.one_in_n, fft, c2mag, self.avg, log, sink)
self.win = waterfall_window(self,
parent,
size=size,
report=report,
ref_level=ref_level,
span=span,
ofunc=ofunc,
xydfunc=xydfunc)
self.set_average(self.average)
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 = gr.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 publish_spectrum(self,fftlen):
spectrum = gr.fft_vcc(fftlen,True,[],True)
mag = gr.complex_to_mag(fftlen)
logdb = gr.nlog10_ff(20.0,fftlen,-20*log10(fftlen))
decimate_rate = gr.keep_one_in_n(gr.sizeof_gr_complex*fftlen,10)
msgq = gr.msg_queue(10)
msg_sink = gr.message_sink(gr.sizeof_float*fftlen,msgq,True)
self.connect(self.filter,gr.stream_to_vector(gr.sizeof_gr_complex,fftlen),
decimate_rate,spectrum,mag,logdb,msg_sink)
self.servants.append(corba_data_buffer_servant("tx_spectrum",fftlen,msgq))
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.
@param sample_rate Incoming stream sample rate
@param fft_size Number of FFT bins
@param ref_scale Sets 0 dB value input amplitude
@param frame_rate Output frame rate
@param avg_alpha FFT averaging (over time) constant [0.0-1.0]
@param average Whether to average [True, False]
@param 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 = 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 = gr.complex_to_mag_squared(fft_size)
self._avg = gr.single_pole_iir_filter_ff(1.0, fft_size)
self._log = gr.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, 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 = blks2.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 = gr.single_pole_iir_filter_ff(1.0, pspectrum_len)
self._log = gr.nlog10_ff(
20,
pspectrum_len,
-20 * math.log10(pspectrum_len) - 20 * math.log10(ref_scale / 2) + 3.0, # Adjust for number of bins
) # 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, 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/FFT_SIZE #options.fft_length
self._fft_length = FFT_SIZE #options.fft_length
self._occupied_tones = FFT_SIZE #options.occupied_tones
self.msgq = gr.msg_queue()
# linklab , setup the sensing path
# FIXME: some components are not necessary
self.s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
self.fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.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 = gr.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 = gr.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, fg):
self.split = gr.multiply_const_ff(1)
self.sqr = gr.multiply_ff()
self.int0 = gr.iir_filter_ffd([.004, 0], [0, .999])
self.offs = gr.add_const_ff(-30)
self.gain = gr.multiply_const_ff(70)
self.log = gr.nlog10_ff(10, 1)
self.agc = gr.divide_ff()
fg.connect(self.split, (self.agc, 0))
fg.connect(self.split, (self.sqr, 0))
fg.connect(self.split, (self.sqr, 1))
fg.connect(self.sqr, self.int0)
fg.connect(self.int0, self.log)
fg.connect(self.log, self.offs)
fg.connect(self.offs, self.gain)
fg.connect(self.gain, (self.agc, 1))
gr.hier_block.__init__(self, fg, self.split, self.agc)
def __init__(self, fg):
self.split = gr.multiply_const_ff(1)
self.sqr = gr.multiply_ff()
self.int0 = gr.iir_filter_ffd([0.004, 0], [0, 0.999])
self.offs = gr.add_const_ff(-30)
self.gain = gr.multiply_const_ff(70)
self.log = gr.nlog10_ff(10, 1)
self.agc = gr.divide_ff()
fg.connect(self.split, (self.agc, 0))
fg.connect(self.split, (self.sqr, 0))
fg.connect(self.split, (self.sqr, 1))
fg.connect(self.sqr, self.int0)
fg.connect(self.int0, self.log)
fg.connect(self.log, self.offs)
fg.connect(self.offs, self.gain)
fg.connect(self.gain, (self.agc, 1))
gr.hier_block.__init__(self, fg, self.split, self.agc)
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 = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.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 = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.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 = gr.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 = gr.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 = 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, 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 = gr.nlog10_ff(10, 1, 0) self.gr_complex_to_mag_squared_0 = gr.complex_to_mag_squared(1) self.fir_filter_xxx_0 = 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, 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 = 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 = gr.complex_to_mag_squared(fft_size)
self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size)
self._log = gr.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, data_tones, num_symbols, mode=0):
symbol_size = data_tones * gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "SNR",
gr.io_signature2(2,2, symbol_size, symbol_size),
gr.io_signature(1,1, gr.sizeof_float))
sub = gr.sub_cc(data_tones)
self.connect((self,0), (sub,0))
self.connect((self,1), (sub,1))
err = gr.complex_to_mag_squared(data_tones);
self.connect(sub, err);
pow = gr.complex_to_mag_squared(data_tones);
self.connect((self,1), pow);
if mode == 0:
# one snr per symbol (num_symbols is ignored)
snr = gr.divide_ff()
self.connect(pow, gr.vector_to_stream(gr.sizeof_float, data_tones),
gr.integrate_ff(data_tones), (snr,0))
self.connect(err, gr.vector_to_stream(gr.sizeof_float, data_tones),
gr.integrate_ff(data_tones), (snr,1))
out = snr
elif mode == 1:
# one snr per packet
snr = gr.divide_ff()
self.connect(pow, gr.vector_to_stream(gr.sizeof_float, data_tones),
gr.integrate_ff(data_tones*num_symbols), (snr,0))
self.connect(err, gr.vector_to_stream(gr.sizeof_float, data_tones),
gr.integrate_ff(data_tones*num_symbols), (snr,1))
out = snr
elif mode == 2:
# one snr per frequency bin
snr = gr.divide_ff(data_tones)
self.connect(pow, raw.symbol_avg(data_tones, num_symbols), (snr,0))
self.connect(err, raw.symbol_avg(data_tones, num_symbols), (snr,1))
out = gr.vector_to_stream(gr.sizeof_float, data_tones)
self.connect(snr, out)
self.connect(out, gr.nlog10_ff(10), 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 = gr.multiply_const_ff( 1 )
self.sqr = gr.multiply_ff( )
self.int0 = gr.iir_filter_ffd( [.004, 0], [0, .999] )
self.offs = gr.add_const_ff( -30 )
self.gain = gr.multiply_const_ff( 70 )
self.log = gr.nlog10_ff( 10, 1 )
self.agc = gr.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 = gr.multiply_const_ff(1)
self.sqr = gr.multiply_ff()
self.int0 = gr.iir_filter_ffd([.004, 0], [0, .999])
self.offs = gr.add_const_ff(-30)
self.gain = gr.multiply_const_ff(70)
self.log = gr.nlog10_ff(10, 1)
self.agc = gr.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, subc, vlen, ss):
gr.hier_block2.__init__(
self, "new_snr_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen),
gr.io_signature(1, 1, gr.sizeof_float))
print "Created Milan's SNR estimator"
trigger = [0] * vlen
trigger[0] = 1
u = range(vlen / ss * (ss - 1))
zeros_ind = map(lambda z: z + 1 + z / (ss - 1), u)
skip1 = skip(gr.sizeof_gr_complex, vlen)
for x in zeros_ind:
skip1.skip(x)
#print "skipped zeros",zeros_ind
v = range(vlen / ss)
ones_ind = map(lambda z: z * ss, v)
skip2 = skip(gr.sizeof_gr_complex, vlen)
for x in ones_ind:
skip2.skip(x)
#print "skipped ones",ones_ind
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
s2v1 = gr.stream_to_vector(gr.sizeof_gr_complex, vlen / ss)
trigger_src_1 = gr.vector_source_b(trigger, True)
s2v2 = gr.stream_to_vector(gr.sizeof_gr_complex, vlen / ss * (ss - 1))
trigger_src_2 = gr.vector_source_b(trigger, True)
mag_sq_ones = gr.complex_to_mag_squared(vlen / ss)
mag_sq_zeros = gr.complex_to_mag_squared(vlen / ss * (ss - 1))
filt_ones = gr.single_pole_iir_filter_ff(0.1, vlen / ss)
filt_zeros = gr.single_pole_iir_filter_ff(0.1, vlen / ss * (ss - 1))
sum_ones = vector_sum_vff(vlen / ss)
sum_zeros = vector_sum_vff(vlen / ss * (ss - 1))
D = gr.divide_ff()
P = gr.multiply_ff()
mult1 = gr.multiply_const_ff(ss - 1.0)
add1 = gr.add_const_ff(-1.0)
mult2 = gr.multiply_const_ff(1. / ss)
scsnrdb = gr.nlog10_ff(10, 1, 0)
filt_end = gr.single_pole_iir_filter_ff(0.1)
self.connect(self, v2s, skip1, s2v1, mag_sq_ones, filt_ones, sum_ones)
self.connect(trigger_src_1, (skip1, 1))
self.connect(v2s, skip2, s2v2, mag_sq_zeros, filt_zeros, sum_zeros)
self.connect(trigger_src_2, (skip2, 1))
self.connect(sum_ones, D)
self.connect(sum_zeros, (D, 1))
self.connect(D, mult1, add1, mult2)
self.connect(mult2, scsnrdb, filt_end, self)
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 = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = gr.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 = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
self.c2mag = gr.complex_to_mag(self.fft_size)
self.avg = gr.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 = gr.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 = gr.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 = 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):
gr.top_block.__init__(self)
usage = "usage: %prog [options] min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option("-B", "--fusb-block-size", type="int", default=0,
help="specify fast usb block size [default=%default]")
parser.add_option("-N", "--fusb-nblocks", type="int", default=0,
help="specify number of fast usb blocks [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if 1:
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# build graph
self.u = usrp.source_c(fusb_block_size=options.fusb_block_size,
fusb_nblocks=options.fusb_nblocks)
adc_rate = self.u.adc_rate() # 64 MS/s
usrp_decim = options.decim
self.u.set_decim_rate(usrp_decim)
usrp_rate = adc_rate / usrp_decim
self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.gain = float(g[0]+g[1])/2
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self):
gr.top_block.__init__(self)
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
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=5e-5, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=50e-5, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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"
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001
self.src = msdd.source_simple(self.address, self.port)
self.src.set_decim_rate(self.decim)
self.set_gain(self.gain)
self.set_freq(self.min_freq)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
norm = gr.multiply_const_cc(1.0/self.fft_size)
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * self.int_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.int_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
self.connect(self.src, s2v, fft, c2mag, log, stats)
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=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float",
default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequency [default=%default]")
parser.add_option("", "--channel-bandwidth", type="eng_float",
default=12.5e3, metavar="Hz",
help="channel bandwidth of fft bins in Hz [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
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")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
# swap them
self.min_freq, self.max_freq = self.max_freq, self.min_freq
self.fft_size = options.fft_size
self.channel_bandwidth = options.channel_bandwidth
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.usrp_rate = usrp_rate = options.samp_rate
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self):
gr.top_block.__init__(self)
# Build an options parser to bring in information from the user on usage
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-g", "--gain", type="eng_float", default=32,
help="set gain in dB (default is midpoint)")
parser.add_option("", "--tune-delay", type="eng_float", default=5e-5, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=50e-5, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
# get user-provided info on address of MSDD and frequency to sweep
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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"
# Sampling rate is hardcoded and cannot be read off device
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001 # required port for UDP packets
# which board, op mode, adx, port
# self.src = msdd.source_c(0, 1, self.address, self.port) # build source object
self.conv = gr.interleaved_short_to_complex();
self.src = msdd.source_simple(self.address,self.port);
self.src.set_decim_rate(self.decim) # set decimation rate
# self.src.set_desired_packet_size(0, 1460) # set packet size to collect
self.set_gain(self.gain) # set receiver's attenuation
self.set_freq(self.min_freq) # set receiver's rx frequency
# restructure into vector format for FFT input
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
# set up FFT processing block
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap*tap
# calculate magnitude squared of output of FFT
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
# Calculate the frequency steps to use in the collection over the whole bandwidth
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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
# use these values to set receiver settling time between samples and sampling time
# the default values provided seem to work well with the MSDD over 100 Mbps ethernet
tune_delay = max(0, int(round(options.tune_delay * self.int_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.int_rate / self.fft_size))) # in fft_frames
# set up message callback routine to get data from bin_statistics_f block
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self) # hang on to this to keep it from being GC'd
# FIXME this block doesn't like to work with negatives because of the "d_max[i]=0" on line
# 151 of gr_bin_statistics_f.cc file. Set this to -10000 or something to get it to work.
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME there's a concern over the speed of the log calculation
# We can probably calculate the log inside the stats block
self.connect(self.src, self.conv, s2v, fft, c2mag, log, stats)
def __init__(self, demod_class, rx_callback, options, source_block):
gr.hier_block2.__init__(self, "receive_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
options = copy.copy(
options) # make a copy so we can destructively modify
self._verbose = options.verbose
self._bitrate = options.bitrate # desired bit rate
self._rx_callback = rx_callback # this callback is fired when a packet arrives
self._demod_class = demod_class # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
# Get demod_kwargs
demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
#Give hooks of usrp to blocks downstream
self.source_block = source_block
#########################################
# Build Blocks
#########################################
# Build the demodulator
self.demodulator = self._demod_class(**demod_kwargs)
# Make sure the channel BW factor is between 1 and sps/2
# or the filter won't work.
if (self._chbw_factor < 1.0
or self._chbw_factor > self.samples_per_symbol() / 2):
sys.stderr.write(
"Channel bandwidth factor ({0}) must be within the range [1.0, {1}].\n"
.format(self._chbw_factor,
self.samples_per_symbol() / 2))
sys.exit(1)
# Design filter to get actual channel we want
sw_decim = 1
chan_coeffs = gr.firdes.low_pass(
1.0, # gain
sw_decim * self.samples_per_symbol(), # sampling rate
self._chbw_factor, # midpoint of trans. band
0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
# receiver
self.packet_receiver = \
digital.demod_pkts(self.demodulator,
access_code=None,
callback=self._rx_callback,
threshold=-1)
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha)
# Display some information about the setup
if self._verbose:
self._print_verbage()
# More Carrier Sensing with FFT
#self.gr_vector_sink = gr.vector_sink_c(1024)
#self.gr_stream_to_vector = gr.stream_to_vector(gr.sizeof_gr_complex*1, 1024)
#self.gr_head = gr.head(gr.sizeof_gr_complex*1024, 1024)
#self.fft = fft.fft_vcc(1024, True, (window.blackmanharris(1024)), True, 1)
# Parameters
usrp_rate = options.bitrate
self.fft_size = 1024
self.min_freq = 2.4e9 - 0.75e6
self.max_freq = 2.4e9 + 0.75e6
self.tune_delay = 0.001
self.dwell_delay = 0.01
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#self.freq_step = 0.75 * usrp_rate
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = math.ceil((self.max_freq - self.min_freq) / self.freq_step)
#self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.freq_step = 1.5e6
self.min_center_freq = self.min_freq
nsteps = 1
self.max_center_freq = self.max_freq
self.next_freq = self.min_center_freq
tune_delay = max(0,
int(round(self.tune_delay * usrp_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(self.dwell_delay * usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
######################################################
# Connect Blocks Together
######################################################
#channel-filter-->Probe_Avg_Mag_Sqrd
# -->Packet_Receiver (Demod Done Here!!)
#
# connect FFT sampler to system
#self.connect(self, self.gr_stream_to_vector, self.fft, self.gr_vector_sink)
# connect block input to channel filter
self.connect(self, self.channel_filter)
# connect the channel input filter to the carrier power detector
self.connect(self.channel_filter, self.probe)
# connect channel filter to the packet receiver
self.connect(self.channel_filter, self.packet_receiver)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.channel_filter, s2v, fft, c2mag, stats)
def __init__(self):
gr.top_block.__init__(self)
# Build an options parser to bring in information from the user on usage
usage = "usage: %prog [options] host min_freq max_freq"
parser = OptionParser(option_class=eng_option, usage=usage)
parser.add_option("-g",
"--gain",
type="eng_float",
default=32,
help="set gain in dB (default is midpoint)")
parser.add_option(
"",
"--tune-delay",
type="eng_float",
default=5e-5,
metavar="SECS",
help=
"time to delay (in seconds) after changing frequency [default=%default]"
)
parser.add_option(
"",
"--dwell-delay",
type="eng_float",
default=50e-5,
metavar="SECS",
help=
"time to dwell (in seconds) at a given frequncy [default=%default]"
)
parser.add_option("-F",
"--fft-size",
type="int",
default=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d",
"--decim",
type="intx",
default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("",
"--real-time",
action="store_true",
default=False,
help="Attempt to enable real-time scheduling")
(options, args) = parser.parse_args()
if len(args) != 3:
parser.print_help()
sys.exit(1)
# get user-provided info on address of MSDD and frequency to sweep
self.address = args[0]
self.min_freq = eng_notation.str_to_num(args[1])
self.max_freq = eng_notation.str_to_num(args[2])
self.decim = options.decim
self.gain = options.gain
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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"
# Sampling rate is hardcoded and cannot be read off device
adc_rate = 102.4e6
self.int_rate = adc_rate / self.decim
print "Sampling rate: ", self.int_rate
# build graph
self.port = 10001 # required port for UDP packets
# which board, op mode, adx, port
# self.src = msdd.source_c(0, 1, self.address, self.port) # build source object
self.conv = gr.interleaved_short_to_complex()
self.src = msdd.source_simple(self.address, self.port)
self.src.set_decim_rate(self.decim) # set decimation rate
# self.src.set_desired_packet_size(0, 1460) # set packet size to collect
self.set_gain(self.gain) # set receiver's attenuation
self.set_freq(self.min_freq) # set receiver's rx frequency
# restructure into vector format for FFT input
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
# set up FFT processing block
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow, True)
power = 0
for tap in mywindow:
power += tap * tap
# calculate magnitude squared of output of FFT
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to % of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.percent = 0.4
# Calculate the frequency steps to use in the collection over the whole bandwidth
self.freq_step = self.percent * self.int_rate
self.min_center_freq = self.min_freq + self.freq_step / 2
nsteps = 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
# use these values to set receiver settling time between samples and sampling time
# the default values provided seem to work well with the MSDD over 100 Mbps ethernet
tune_delay = max(0,
int(
round(options.tune_delay * self.int_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(options.dwell_delay * self.int_rate /
self.fft_size))) # in fft_frames
# set up message callback routine to get data from bin_statistics_f block
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(
self) # hang on to this to keep it from being GC'd
# FIXME this block doesn't like to work with negatives because of the "d_max[i]=0" on line
# 151 of gr_bin_statistics_f.cc file. Set this to -10000 or something to get it to work.
stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME there's a concern over the speed of the log calculation
# We can probably calculate the log inside the stats block
self.connect(self.src, self.conv, s2v, fft, c2mag, log, stats)
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("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
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=1e-4, 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=256,
help="specify number of FFT bins [default=%default]")
parser.add_option("-d", "--decim", type="intx", default=16,
help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
parser.add_option("-f", "--freq", type="eng_float",
default = 5.2e9, help="set USRP2 carrier frequency, [default=%default]",
metavar="FREQ")
(options, args) = parser.parse_args()
#if len(args) != 2:
#parser.print_help()
#sys.exit(1)
#self.min_freq = eng_notation.str_to_num(args[0])
#self.max_freq = eng_notation.str_to_num(args[1])
self.min_freq = options.freq
self.max_freq = options.freq
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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 = usrp2.source_32fc()
adc_rate = self.u.adc_rate() # 64 MS/s
usrp2_decim = options.decim
self.u.set_decim(usrp2_decim)
usrp2_rate = adc_rate / usrp2_decim
#self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
#self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
#print "Using RX d'board %s" % (self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp2_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * usrp2_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp2_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
#options.gain = float(g[0]+g[1])/2
options.gain = max(min(options.gain, g[1]), g[0] )
self.u.set_gain(options.gain)
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=1e-3, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float",
default=10e-3, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=256,
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")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
if self.min_freq > self.max_freq:
# swap them
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:
# 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)
usrp_rate = options.samp_rate
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
self.freq_step = 0.75 * usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
self.set_gain(options.gain)
print "gain =", options.gain
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("-R", "--rx-subdev-spec", type="subdev", default=(0,0),
help="select USRP Rx side A or B (default=A)")
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=.01, metavar="SECS",
help="time to delay (in seconds) after changing frequency [default=%default]")
parser.add_option("", "--dwell-delay", type="eng_float", default=.05, metavar="SECS",
help="time to dwell (in seconds) at a given frequncy [default=%default]")
parser.add_option("-F", "--fft-size", type="int", default=1024,
help="specify number of FFT bins [default=%default]")
#updated 2011 May 27, MR
parser.add_option("-s", "--samp_rate", type="intx", default=6000000,
help="set sample rate to SAMP_RATE [default=%default]")
parser.add_option("", "--chan-bandwidth", type="intx", default=6000000,
help="set channel bw [default=%default]")
#parser.add_option("-d", "--decim", type="intx", default=16,
# help="set decimation to DECIM [default=%default]")
parser.add_option("", "--real-time", action="store_true", default=False,
help="Attempt to enable real-time scheduling")
#parser.add_option("-B", "--fusb-block-size", type="int", default=0,
# help="specify fast usb block size [default=%default]")
#parser.add_option("-N", "--fusb-nblocks", type="int", default=0,
# help="specify number of fast usb blocks [default=%default]")
#options added 2011 May 31, MR
parser.add_option("", "--threshold", type="eng_float", default=-70,
help="set detection threshold [default=%default]")
parser.add_option("", "--num-tests", type="intx", default=200,
help="set the number of times to test the frequency band [default=%default]")
parser.add_option("", "--log-file", action="store_true", default=False,
help="log output to a file")
(options, args) = parser.parse_args()
if len(args) != 2:
parser.print_help()
sys.exit(1)
self.num_tests = options.num_tests
self.threshold = options.threshold
self.samp_rate = options.samp_rate
self.min_freq = eng_notation.str_to_num(args[0])
self.max_freq = eng_notation.str_to_num(args[1])
self.log_file = options.log_file
self.num_channels = int((self.max_freq - self.min_freq)/self.samp_rate) + 2
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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"
#removed 2011 May 27, MR
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
#if 1:
# if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
# if realtime: # be more aggressive
# options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
# options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
# else:
# options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
# options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# build graph
#updated 2011 May 27, MR
self.u = uhd.usrp_source(device_addr="", io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1)
self.u.set_subdev_spec("", 0)
self.u.set_antenna("TX/RX", 0)
self.u.set_samp_rate(options.samp_rate)
#self.u = usrp.source_c(fusb_block_size=options.fusb_block_size,
# fusb_nblocks=options.fusb_nblocks)
#adc_rate = self.u.adc_rate() # 64 MS/s
#usrp_decim = options.decim
#self.u.set_decim_rate(usrp_decim)
self.usrp_rate = self.u.get_samp_rate() #adc_rate / usrp_decim
print "sample rate is", self.usrp_rate
#self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec))
#self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec)
print "Using RX d'board %s" % (self.u.get_dboard_sensor_names(chan=0))#(self.subdev.side_and_name(),)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
#self.freq_step = 0.75 * self.usrp_rate
self.freq_step = options.chan_bandwidth
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * self.usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self.u, s2v, fft, c2mag, log, stats)
self.connect(self.u, s2v, fft, c2mag, stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
# updated 2011 May 31, MR
#g = self.subdev.gain_range()
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2
self.set_gain(options.gain)
print "gain =", options.gain
def __init__(self):
gr.top_block.__init__(self, "Simple QAM Simulation")
Qt.QWidget.__init__(self)
self.setWindowTitle("Simple QAM Simulation")
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
##################################################
# Variables
##################################################
self.constellation_cardinality = constellation_cardinality = 16
self.const_object = const_object = constellations()['qam'](
constellation_cardinality)
self.snr_db = snr_db = 20
self.constellation = constellation = const_object.points()
self.sps = sps = 8
self.samp_rate = samp_rate = 250000
self.noise_amp = noise_amp = sqrt((10**(-snr_db / 10.)) / 2.)
self.constellation_power = constellation_power = sqrt(
sum([abs(i)**2
for i in constellation]) / constellation_cardinality)
##################################################
# Blocks
##################################################
self.tabid_0 = Qt.QTabWidget()
self.tabid_0_widget_0 = Qt.QWidget()
self.tabid_0_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_0_widget_0)
self.tabid_0_grid_layout_0 = Qt.QGridLayout()
self.tabid_0_layout_0.addLayout(self.tabid_0_grid_layout_0)
self.tabid_0.addTab(self.tabid_0_widget_0, "TX")
self.tabid_0_widget_1 = Qt.QWidget()
self.tabid_0_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_0_widget_1)
self.tabid_0_grid_layout_1 = Qt.QGridLayout()
self.tabid_0_layout_1.addLayout(self.tabid_0_grid_layout_1)
self.tabid_0.addTab(self.tabid_0_widget_1, "CHANNEL")
self.tabid_0_widget_2 = Qt.QWidget()
self.tabid_0_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_0_widget_2)
self.tabid_0_grid_layout_2 = Qt.QGridLayout()
self.tabid_0_layout_2.addLayout(self.tabid_0_grid_layout_2)
self.tabid_0.addTab(self.tabid_0_widget_2, "RX")
self.top_grid_layout.addWidget(self.tabid_0, 30, 0, 10, 100)
self.tabid_2 = Qt.QTabWidget()
self.tabid_2_widget_0 = Qt.QWidget()
self.tabid_2_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_2_widget_0)
self.tabid_2_grid_layout_0 = Qt.QGridLayout()
self.tabid_2_layout_0.addLayout(self.tabid_2_grid_layout_0)
self.tabid_2.addTab(self.tabid_2_widget_0, "symbol-based")
self.tabid_2_widget_1 = Qt.QWidget()
self.tabid_2_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_2_widget_1)
self.tabid_2_grid_layout_1 = Qt.QGridLayout()
self.tabid_2_layout_1.addLayout(self.tabid_2_grid_layout_1)
self.tabid_2.addTab(self.tabid_2_widget_1, "bit-based")
self.tabid_2_widget_2 = Qt.QWidget()
self.tabid_2_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_2_widget_2)
self.tabid_2_grid_layout_2 = Qt.QGridLayout()
self.tabid_2_layout_2.addLayout(self.tabid_2_grid_layout_2)
self.tabid_2.addTab(self.tabid_2_widget_2, "BER")
self.tabid_0_layout_2.addWidget(self.tabid_2)
self.tabid_1 = Qt.QTabWidget()
self.tabid_1_widget_0 = Qt.QWidget()
self.tabid_1_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_1_widget_0)
self.tabid_1_grid_layout_0 = Qt.QGridLayout()
self.tabid_1_layout_0.addLayout(self.tabid_1_grid_layout_0)
self.tabid_1.addTab(self.tabid_1_widget_0, "bit-based")
self.tabid_1_widget_1 = Qt.QWidget()
self.tabid_1_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_1_widget_1)
self.tabid_1_grid_layout_1 = Qt.QGridLayout()
self.tabid_1_layout_1.addLayout(self.tabid_1_grid_layout_1)
self.tabid_1.addTab(self.tabid_1_widget_1, "scrambled")
self.tabid_1_widget_2 = Qt.QWidget()
self.tabid_1_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tabid_1_widget_2)
self.tabid_1_grid_layout_2 = Qt.QGridLayout()
self.tabid_1_layout_2.addLayout(self.tabid_1_grid_layout_2)
self.tabid_1.addTab(self.tabid_1_widget_2, "symbol-based")
self.tabid_0_grid_layout_0.addWidget(self.tabid_1, 0, 0, 10, 10)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
1024, #size
samp_rate, #bw
"QT GUI Plot", #name
1 #number of inputs
)
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.tabid_2_layout_2.addWidget(self._qtgui_time_sink_x_0_win)
self.qtgui_sink_x_0_1_0_0 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
False, #plotfreq
False, #plotwaterfall
True, #plottime
True, #plotconst
)
self._qtgui_sink_x_0_1_0_0_win = sip.wrapinstance(
self.qtgui_sink_x_0_1_0_0.pyqwidget(), Qt.QWidget)
self.tabid_1_layout_0.addWidget(self._qtgui_sink_x_0_1_0_0_win)
self.qtgui_sink_x_0_1_0 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
True, #plotfreq
False, #plotwaterfall
True, #plottime
True, #plotconst
)
self._qtgui_sink_x_0_1_0_win = sip.wrapinstance(
self.qtgui_sink_x_0_1_0.pyqwidget(), Qt.QWidget)
self.tabid_1_layout_1.addWidget(self._qtgui_sink_x_0_1_0_win)
self.qtgui_sink_x_0_1 = qtgui.sink_c(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
False, #plotfreq
False, #plotwaterfall
True, #plottime
True, #plotconst
)
self._qtgui_sink_x_0_1_win = sip.wrapinstance(
self.qtgui_sink_x_0_1.pyqwidget(), Qt.QWidget)
self.tabid_1_layout_2.addWidget(self._qtgui_sink_x_0_1_win)
self.qtgui_sink_x_0_0_0_0 = qtgui.sink_c(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
True, #plotfreq
False, #plotwaterfall
True, #plottime
True, #plotconst
)
self._qtgui_sink_x_0_0_0_0_win = sip.wrapinstance(
self.qtgui_sink_x_0_0_0_0.pyqwidget(), Qt.QWidget)
self.tabid_2_layout_0.addWidget(self._qtgui_sink_x_0_0_0_0_win)
self.qtgui_sink_x_0_0_0 = qtgui.sink_f(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
False, #plotfreq
False, #plotwaterfall
True, #plottime
True, #plotconst
)
self._qtgui_sink_x_0_0_0_win = sip.wrapinstance(
self.qtgui_sink_x_0_0_0.pyqwidget(), Qt.QWidget)
self.tabid_2_layout_1.addWidget(self._qtgui_sink_x_0_0_0_win)
self.qtgui_sink_x_0_0 = qtgui.sink_c(
1024, #fftsize
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"QT GUI Plot", #name
True, #plotfreq
False, #plotwaterfall
True, #plottime
False, #plotconst
)
self._qtgui_sink_x_0_0_win = sip.wrapinstance(
self.qtgui_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.tabid_0_layout_1.addWidget(self._qtgui_sink_x_0_0_win)
self.gr_vector_source_x_0_0 = gr.vector_source_b(([1, 0]), True, 1)
self.gr_vector_source_x_0 = gr.vector_source_b(([1, 0]), True, 1)
self.gr_unpack_k_bits_bb_0 = gr.unpack_k_bits_bb(
int(log2(constellation_cardinality)))
self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex * 1, samp_rate)
self.gr_pack_k_bits_bb_0 = gr.pack_k_bits_bb(
int(log2(constellation_cardinality)))
self.gr_null_sink_0 = gr.null_sink(gr.sizeof_char * 1)
self.gr_noise_source_x_0 = gr.noise_source_c(gr.GR_GAUSSIAN, noise_amp,
0)
self.gr_nlog10_ff_0 = gr.nlog10_ff(1, 1, 0)
self.gr_multiply_const_vxx_0_0 = gr.multiply_const_vcc(
(1. / constellation_power, ))
self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc(
(constellation_power, ))
self.gr_file_sink_0_1_0 = gr.file_sink(gr.sizeof_gr_complex * 1,
"rx_sym.32fc")
self.gr_file_sink_0_1_0.set_unbuffered(False)
self.gr_file_sink_0_1 = gr.file_sink(gr.sizeof_gr_complex * 1,
"tx_sym.32fc")
self.gr_file_sink_0_1.set_unbuffered(False)
self.gr_file_sink_0_0 = gr.file_sink(gr.sizeof_char * 1, "rx.8b")
self.gr_file_sink_0_0.set_unbuffered(False)
self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char * 1, "tx.8b")
self.gr_file_sink_0.set_unbuffered(False)
self.gr_descrambler_bb_0 = gr.descrambler_bb(0xe4001, 0x7ffff, 19)
self.gr_char_to_float_1_0 = gr.char_to_float(1, 1)
self.gr_char_to_float_1 = gr.char_to_float(1, 1)
self.gr_char_to_float_0 = gr.char_to_float(1, 1)
self.gr_add_xx_0 = gr.add_vcc(1)
self.digital_scrambler_bb_0 = digital.scrambler_bb(
0xe4001, 0x7fffF, 19)
self.digital_constellation_receiver_cb_0 = digital.constellation_receiver_cb(
const_object.base(), 6.28 / 100, -0.25, +0.25)
self.digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bc(
(constellation), 1)
self.blks2_error_rate_0 = grc_blks2.error_rate(
type='BER',
win_size=samp_rate,
bits_per_symbol=1,
)
##################################################
# Connections
##################################################
self.connect((self.gr_vector_source_x_0, 0),
(self.digital_scrambler_bb_0, 0))
self.connect((self.digital_scrambler_bb_0, 0),
(self.gr_pack_k_bits_bb_0, 0))
self.connect((self.gr_pack_k_bits_bb_0, 0),
(self.digital_chunks_to_symbols_xx_0, 0))
self.connect((self.digital_constellation_receiver_cb_0, 0),
(self.gr_file_sink_0_0, 0))
self.connect((self.digital_constellation_receiver_cb_0, 0),
(self.gr_unpack_k_bits_bb_0, 0))
self.connect((self.gr_unpack_k_bits_bb_0, 0),
(self.gr_descrambler_bb_0, 0))
self.connect((self.gr_descrambler_bb_0, 0), (self.gr_null_sink_0, 0))
self.connect((self.gr_multiply_const_vxx_0, 0),
(self.digital_constellation_receiver_cb_0, 0))
self.connect((self.gr_descrambler_bb_0, 0),
(self.gr_char_to_float_0, 0))
self.connect((self.gr_char_to_float_0, 0),
(self.qtgui_sink_x_0_0_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.gr_throttle_0, 0))
self.connect((self.gr_noise_source_x_0, 0), (self.gr_add_xx_0, 1))
self.connect((self.digital_chunks_to_symbols_xx_0, 0),
(self.gr_multiply_const_vxx_0_0, 0))
self.connect((self.gr_multiply_const_vxx_0_0, 0),
(self.gr_file_sink_0_1, 0))
self.connect((self.gr_multiply_const_vxx_0_0, 0),
(self.qtgui_sink_x_0_1, 0))
self.connect((self.gr_char_to_float_1, 0),
(self.qtgui_sink_x_0_1_0, 0))
self.connect((self.gr_pack_k_bits_bb_0, 0),
(self.gr_char_to_float_1, 0))
self.connect((self.gr_pack_k_bits_bb_0, 0), (self.gr_file_sink_0, 0))
self.connect((self.gr_char_to_float_1_0, 0),
(self.qtgui_sink_x_0_1_0_0, 0))
self.connect((self.gr_vector_source_x_0, 0),
(self.gr_char_to_float_1_0, 0))
self.connect((self.gr_multiply_const_vxx_0_0, 0),
(self.gr_add_xx_0, 0))
self.connect((self.gr_add_xx_0, 0), (self.qtgui_sink_x_0_0, 0))
self.connect((self.gr_throttle_0, 0),
(self.gr_multiply_const_vxx_0, 0))
self.connect((self.gr_throttle_0, 0), (self.gr_file_sink_0_1_0, 0))
self.connect((self.gr_throttle_0, 0), (self.qtgui_sink_x_0_0_0_0, 0))
self.connect((self.gr_nlog10_ff_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blks2_error_rate_0, 0), (self.gr_nlog10_ff_0, 0))
self.connect((self.gr_vector_source_x_0_0, 0),
(self.blks2_error_rate_0, 0))
self.connect((self.gr_descrambler_bb_0, 0),
(self.blks2_error_rate_0, 1))
def __init__(self, subc, vlen, ss):
gr.hier_block2.__init__(
self,
"new_snr_estimator",
gr.io_signature(2, 2, gr.sizeof_gr_complex * vlen),
#gr.io_signature2(2,2,gr.sizeof_float*vlen,gr.sizeof_float*vlen/ss*(ss-1)))
gr.io_signature2(2, 2, gr.sizeof_float * vlen, gr.sizeof_float))
print "Created Milan's SINR estimator 3"
# trigger = [0]*vlen
# trigger[0] = 1
#
# v = range (vlen/ss)
# ones_ind= map(lambda z: z*ss,v)
#
# skip2_pr0 = skip(gr.sizeof_gr_complex,vlen)
# skip2_pr1 = skip(gr.sizeof_gr_complex,vlen)
# for x in ones_ind:
# skip2_pr0.skip(x)
# skip2_pr1.skip(x)
#
# #print "skipped ones",ones_ind
#
# v2s_pr0 = gr.vector_to_stream(gr.sizeof_gr_complex,vlen)
# v2s_pr1 = gr.vector_to_stream(gr.sizeof_gr_complex,vlen)
#
# s2v2_pr0 = gr.stream_to_vector(gr.sizeof_gr_complex,vlen/ss*(ss-1))
# trigger_src_2_pr0 = gr.vector_source_b(trigger,True)
# s2v2_pr1 = gr.stream_to_vector(gr.sizeof_gr_complex,vlen/ss*(ss-1))
# trigger_src_2_pr1 = gr.vector_source_b(trigger,True)
#
# mag_sq_zeros_pr0 = gr.complex_to_mag_squared(vlen/ss*(ss-1))
# mag_sq_zeros_pr1 = gr.complex_to_mag_squared(vlen/ss*(ss-1))
#
#
# filt_zeros_pr0 = gr.single_pole_iir_filter_ff(0.01,vlen/ss*(ss-1))
# filt_zeros_pr1 = gr.single_pole_iir_filter_ff(0.01,vlen/ss*(ss-1))
# v1 = vlen/ss*(ss-1)
# vevc1 =[-1]*v1
# neg_nomin_z = gr.multiply_const_vff(vevc1)
# div_z=gr.divide_ff(vlen/ss*(ss-1))
# on_zeros = gr.add_const_vff(vevc1)
# sum_zeros = add_vff(vlen/ss*(ss-1))
#
# For average
#sum_all = vector_sum_vff(vlen)
#mult = gr.multiply_const_ff(1./vlen)
scsnr_db_av = gr.nlog10_ff(10, 1, 0)
filt_end_av = gr.single_pole_iir_filter_ff(0.1)
#
#
# self.connect((self,0),v2s_pr0,skip2_pr0,s2v2_pr0,mag_sq_zeros_pr0,filt_zeros_pr0)
# self.connect(trigger_src_2_pr0,(skip2_pr0,1))
#
#
#
# self.connect((self,1),v2s_pr1,skip2_pr1,s2v2_pr1,mag_sq_zeros_pr1,filt_zeros_pr1)
# self.connect(trigger_src_2_pr1,(skip2_pr1,1))
#
#
# # On zeros
# self.connect(filt_zeros_pr1,(sum_zeros,0))
# self.connect(filt_zeros_pr0,neg_nomin_z,(sum_zeros,1))
# self.connect(sum_zeros,div_z)
# self.connect(filt_zeros_pr0,(div_z,1))
estimator = sinr_estimator2(vlen, ss)
scsnr_db = gr.nlog10_ff(10, vlen, 0)
filt_end = gr.single_pole_iir_filter_ff(0.1, vlen)
dd = []
for i in range(vlen / ss):
dd.extend([i * ss])
#print dd
#interpolator = sinr_interpolator(vlen, ss,dd)
self.connect((self, 0), (estimator, 0))
self.connect((self, 1), (estimator, 1))
self.connect(estimator, filt_end, scsnr_db, self)
self.connect((estimator, 1), scsnr_db_av, filt_end_av, (self, 1))
def __init__(self, usrp_rate, tuner_callback, options):
gr.hier_block2.__init__(self, "sense_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.usrp_rate = usrp_rate
self.usrp_tune = tuner_callback
self.num_tests = options.num_tests
self.threshold = options.threshold
self.min_freq = options.start_freq
self.max_freq = options.end_freq
if self.min_freq > self.max_freq:
self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.fft_size
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
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
self.freq_step = self.usrp_rate
self.min_center_freq = self.min_freq + self.freq_step/2
nsteps = 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 * self.usrp_rate / self.fft_size))) # in fft_frames
dwell_delay = max(1, int(round(options.dwell_delay * self.usrp_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 = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay, dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self, s2v, fft, c2mag, log, stats)
self.connect(self, s2v, fft, c2mag, stats)
def __init__(self, tuner_callback, options):
gr.hier_block2.__init__(
self,
"sense_path",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.usrp_rate = options.channel_rate
self.usrp_tune = tuner_callback
self.threshold = options.threshold
#self.freq_step = options.chan_bandwidth
#self.min_freq = options.start_freq
#self.max_freq = options.end_freq
self.hold_freq = False
self.channels = [
600000000, 620000000, 625000000, 640000000, 645000000, 650000000
]
self.current_chan = 0
self.num_channels = len(
self.channels) #(self.max_freq - self.min_freq)/self.freq_step
#if self.min_freq > self.max_freq:
# self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them
self.fft_size = options.sense_fft_size
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
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
# FIXME the log10 primitive is dog slow
log = gr.nlog10_ff(
10, self.fft_size, -20 * math.log10(self.fft_size) -
10 * math.log10(power / self.fft_size))
# Set the freq_step to 75% of the actual data throughput.
# This allows us to discard the bins on both ends of the spectrum.
#changed on 2011 May 31, MR -- maybe change back at some point
#self.min_center_freq = self.min_freq + self.freq_step/2
#nsteps = 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.channels[
self.current_chan] #self.min_center_freq
tune_delay = max(0,
int(
round(options.tune_delay * self.usrp_rate /
self.fft_size))) # in fft_frames
dwell_delay = max(1,
int(
round(options.dwell_delay * self.usrp_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
self.stats = gr.bin_statistics_f(self.fft_size, self.msgq,
self._tune_callback, tune_delay,
dwell_delay)
# FIXME leave out the log10 until we speed it up
#self.connect(self, s2v, fft, c2mag, log, stats)
self.connect(self, s2v, fft, c2mag, self.stats)
