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=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, 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, 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,
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 __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=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)
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)
fft = gr.fft_vfc(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, 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 __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 __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_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0,0,0))
fft_sink_base.__init__(self, input_is_real=True, 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_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)
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_peak_hold(self.peak_hold)
self.set_use_persistence(self.use_persistence)
self.set_persist_alpha(self.persist_alpha)
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_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0, 0, 0))
fft_sink_base.__init__(self,
input_is_real=True,
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_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)
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_peak_hold(self.peak_hold)
self.set_use_persistence(self.use_persistence)
self.set_persist_alpha(self.persist_alpha)
