def __init__(self, fft_len, rate, sample_rate):
gr.hier_block2.__init__(self,
"psd_logger",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.fft_len = fft_len
self.rate = rate
self.sample_rate = sample_rate
self.msgq = gr.msg_queue(2)
self.log_file = open('/tmp/psd_log'+'-'+ time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"),'w')
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate/self.fft_len/self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = blocks.complex_to_mag(self.fft_len)
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.sink)
self._watcher = _queue_watcher(self.msgq, self.log_file)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width,
height):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.tune_freq = tune_freq
self.rate = rate
if width == 0 and height == 0:
rows, columns = os.popen('stty size', 'r').read().split()
self.height = int(rows) - 5
self.width = int(columns) / 2 - 10
else:
self.height = height
self.width = width
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(self.average,
self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#register message out to other blocks
self.message_port_register_hier_out("pkt_out")
#packet generator
self.packet_generator = of.chat_blocks.chat_sender()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
#MSG output
self.msg_connect(self.packet_generator, "out", self, "pkt_out")
####THREADS####
self._ascii_plotter = ascii_plotter(self.width, self.height,
self.tune_freq, self.sample_rate,
self.fft_len)
self._main = main_thread(self.msgq, self._ascii_plotter,
self.packet_generator)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, length, height): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.tune_freq = tune_freq self.rate = rate self.length = length self.height = height self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len) self.log = blocks.nlog10_ff(10, self.fft_len, -10*math.log10(self.fft_len) # Adjust for number of bins -10*math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) self._main = main_thread(self.msgq, self.fft_len, self.sample_rate, self.tune_freq, self.length, self.height)
def __init__(self, fft_len, rate, sample_rate):
gr.hier_block2.__init__(self, "psd_logger",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.rate = rate
self.sample_rate = sample_rate
self.msgq = gr.msg_queue(2)
self.log_file = open(
'/tmp/psd_log' + '-' + time.strftime("%y%m%d") + '-' +
time.strftime("%H%M%S"), 'w')
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
self.c2mag = blocks.complex_to_mag(self.fft_len)
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag,
self.sink)
self._watcher = _queue_watcher(self.msgq, self.log_file)
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, **kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = blocks.stream_to_vector(gr.sizeof_float, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_float * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = blocks.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, fft_len, sample_rate, average, rate, max_tu,
data_precision):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.rate = rate
self.max_tu = max_tu - 2 #reserve two bytes for segmentation
self.data_precision = data_precision
if data_precision:
print '32bit FFT in use (more bandwidth and precision)'
else:
print '8bit FFT in use (less bandwidth and precision)'
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, mywindow, True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(self.average,
self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#register message out to other blocks
self.message_port_register_hier_out("pdus")
self._packet_source = packet_source()
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self.msg_connect(self._packet_source, "out", self, "pdus")
####THREADS####
self._main = main_thread(self.msgq, self._packet_source, self.max_tu,
self.fft_len, self.data_precision)
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fft_size=512,
fft_rate=default_fft_rate,
average=False,
avg_alpha=None,
title='',
size=default_fftsink_size,
**kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0, 0, 0))
waterfall_sink_base.__init__(self,
input_is_real=True,
baseband_freq=baseband_freq,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average,
avg_alpha=avg_alpha,
title=title)
self.s2p = blocks.stream_to_vector(gr.sizeof_float, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_float * self.fft_size,
max(1, int(self.sample_rate / self.fft_size / self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = blocks.nlog10_ff(20, self.fft_size,
-20 * math.log10(self.fft_size))
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size,
self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag,
self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, fft_len, sens_per_sec, sample_rate, channel_space = 1, search_bw = 1, thr_leveler = 10, tune_freq = 0, alpha_avg = 1, test_duration = 1, period = 3600, trunc_band = 1, verbose = False, peak_alpha = 0, subject_channels = []): gr.hier_block2.__init__(self, "flank detector", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len #lenght of the fft for spectral analysis self.sens_per_sec = sens_per_sec #number of measurements per second (decimates) self.sample_rate = sample_rate self.channel_space = channel_space #channel space for analysis self.search_bw = search_bw #search bandwidth within each channel self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison self.tune_freq = tune_freq #center frequency self.threshold = 0 #actual value of the threshold self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements self.peak_alpha = peak_alpha #averaging factor for peak level between consecutive measurements self.subject_channels = subject_channels #channels whose flancks will be analysed self.msgq0 = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.sens_per_sec))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.multiply = blocks.multiply_const_vff(np.array([1.0/float(self.fft_len**2)]*fft_len)) self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq0, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.multiply, self.sink0) #start periodic logging self._logger = logger(period, test_duration) #self._logger = None #Watchers #statistics and power self._watcher0 = _queue0_watcher(self.msgq0, sens_per_sec, self.tune_freq, self.channel_space, self.search_bw, self.fft_len, self.sample_rate, self.thr_leveler, self.alpha_avg, test_duration, trunc_band, verbose, peak_alpha, subject_channels, self._logger)
def __init__(self, parent, baseband_freq=0, ref_scale=2.0,
y_per_div=10, y_divs=8, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, peak_hold=False,
use_persistence=False, persist_alpha=0.2, **kwargs):
gr.hier_block2.__init__(self, "fft_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, y_divs=y_divs, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title,
peak_hold=peak_hold, use_persistence=use_persistence,
persist_alpha=persist_alpha)
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2magsq = blocks.complex_to_mag_squared(self.fft_size)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_size)
# FIXME We need to add 3dB to all bins but the DC bin
self.log = blocks.nlog10_ff(10, self.fft_size,
-20*math.log10(self.fft_size) # Adjust for number of bins
-10*math.log10(power/self.fft_size) # Adjust for windowing loss
-20*math.log10(ref_scale/2)) # Adjust for reference scale
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2magsq, self.avg, self.log, self.sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
self.set_use_persistence(self.use_persistence)
self.set_persist_alpha(self.persist_alpha)
self.set_peak_hold(self.peak_hold)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, width,
height):
gr.hier_block2.__init__(self, "ascii plot",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len
self.sample_rate = sample_rate
self.average = average
self.tune_freq = tune_freq
self.rate = rate
self.width = width
self.height = height
self.msgq = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len)
self.log = blocks.nlog10_ff(
10,
self.fft_len,
-10 * math.log10(self.fft_len) # Adjust for number of bins
- 10 * math.log10(self.sample_rate)) # Adjust for sample rate
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq, True)
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.avg, self.log, self.sink)
self._main = main_thread(self.msgq, self.fft_len, self.sample_rate,
self.tune_freq, self.width, self.height)
def __init__(self,
parent,
baseband_freq=0,
ref_scale=2.0,
y_per_div=10,
y_divs=8,
ref_level=50,
sample_rate=1,
fft_size=512,
fft_rate=default_fft_rate,
average=False,
avg_alpha=None,
title='',
size=default_fftsink_size,
peak_hold=False,
use_persistence=False,
persist_alpha=0.2,
**kwargs):
gr.hier_block2.__init__(self, "fft_sink_c",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
fft_sink_base.__init__(self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
y_divs=y_divs,
ref_level=ref_level,
sample_rate=sample_rate,
fft_size=fft_size,
fft_rate=fft_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold,
use_persistence=use_persistence,
persist_alpha=persist_alpha)
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_size,
max(1, int(self.sample_rate / self.fft_size / self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap * tap
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_size)
# FIXME We need to add 3dB to all bins but the DC bin
self.log = blocks.nlog10_ff(
20,
self.fft_size,
-20 * math.log10(self.fft_size) # Adjust for number of bins
-
10 * math.log10(power / self.fft_size) # Adjust for windowing loss
- 20 * math.log10(ref_scale / 2)) # Adjust for reference scale
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size,
self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag,
self.avg, self.log, self.sink)
self.win = 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, fft_len, sens_per_sec, sample_rate, channel_space = 1, search_bw = 1, thr_leveler = 10, tune_freq = 0, alpha_avg = 1, test_duration = 1, period = 3600, trunc_band = 1, verbose = False, psd = False, waterfall = False, subject_channels = []): gr.hier_block2.__init__(self, "spectrum_sensor_v1", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) self.fft_len = fft_len #lenght of the fft for spectral analysis self.sens_per_sec = sens_per_sec #number of measurements per second (decimates) self.sample_rate = sample_rate self.channel_space = channel_space #channel space for analysis self.search_bw = search_bw #search bandwidth within each channel self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison self.tune_freq = tune_freq #center frequency self.threshold = 0 #actual value of the threshold self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements self.verbose = verbose self.trunc_band = trunc_band self.psd = psd self.waterfall = waterfall self.subject_channels = subject_channels #gnuradio msg queues self.msgq0 = gr.msg_queue(2) self.msgq1 = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.sens_per_sec))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.multiply = blocks.multiply_const_vff(np.array([1.0/float(self.fft_len**2)]*fft_len)) #MSG sinks PSD data self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq0, True) self.sink1 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq1, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.multiply, self.sink0) self.connect(self.multiply, self.sink1) #-----waterfall-----> different decimation because operates in a slower rate self.msgq2 = gr.msg_queue(2) self.sink2 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq2, True) self.one_in_n_waterfall = blocks.keep_one_in_n(gr.sizeof_float * self.fft_len, self.sens_per_sec) #keep 1 per second... self.connect(self.multiply, self.one_in_n_waterfall, self.sink2) #start periodic logging self._logger = logger(self.fft_len, period, test_duration) #Watchers #statistics and power self._stats_watcher = _stats_watcher(self.msgq0, sens_per_sec, self.tune_freq, self.channel_space, self.search_bw, self.fft_len, self.sample_rate, self.thr_leveler, self.alpha_avg, test_duration, trunc_band, verbose, self._logger) #psd if self.psd: self._psd_watcher = _psd_watcher(self.msgq1, verbose, self._logger) #waterfall if self.waterfall: self._waterfall_watcher = _waterfall_watcher(self.msgq2, verbose, self._logger)
def __init__(self,
fft_len,
sens_per_sec,
sample_rate,
channel_space=1,
search_bw=1,
tune_freq=0,
trunc_band=1,
verbose=False,
output=False,
subject_channels=[]):
gr.hier_block2.__init__(self, "multichannel_scanner",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len #lenght of the fft for spectral analysis
self.sens_per_sec = sens_per_sec #number of measurements per second (decimates)
self.sample_rate = sample_rate
self.channel_space = channel_space #channel space for analysis
self.search_bw = search_bw #search bandwidth within each channel
self.tune_freq = tune_freq #center frequency
self.verbose = verbose
self.trunc_band = trunc_band
self.output = output
self.subject_channels = subject_channels
self.subject_channels_pwr = np.array([1.0] *
len(self.subject_channels))
#gnuradio msg queues
self.msgq0 = gr.msg_queue(2)
#output top 4 freqs
self.top4 = [
self.subject_channels[0], self.subject_channels[0],
self.subject_channels[0], self.subject_channels[0]
]
#register message out to other blocks
self.message_port_register_hier_out("freq_out_0")
self.message_port_register_hier_out("freq_out_1")
self.message_port_register_hier_out("freq_out_2")
self.message_port_register_hier_out("freq_out_3")
self.message_port_register_hier_out("freq_msg_PDU")
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.sens_per_sec)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.multiply = blocks.multiply_const_vff(
np.array([1.0 / float(self.fft_len**2)] * fft_len))
#MSG sinks PSD data
self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq0, True)
#MSG output blocks to other blocks
self.message_out0 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[0])), 1000)
self.message_out1 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[1])), 1000)
self.message_out2 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[2])), 1000)
self.message_out3 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[3])), 1000)
self.PDU_messages = message_pdu(None)
#####CONNECTIONS####
print 'connecting elements'
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.multiply, self.sink0)
print 'elements connected'
#MSG output
self.msg_connect(self.message_out0, "strobe", self, "freq_out_0")
self.msg_connect(self.message_out1, "strobe", self, "freq_out_1")
self.msg_connect(self.message_out2, "strobe", self, "freq_out_2")
self.msg_connect(self.message_out3, "strobe", self, "freq_out_3")
self.msg_connect(self.PDU_messages, 'out', self, 'freq_msg_PDU')
self._output_data = output_data(self.output, self.subject_channels,
self.subject_channels_pwr,
self.PDU_messages)
self._basic_spectrum_watcher = basic_spectrum_watcher(
self.msgq0, sens_per_sec, self.tune_freq, self.channel_space,
self.search_bw, self.fft_len, self.sample_rate, trunc_band,
verbose, self.subject_channels, self.set_freqs, self._output_data)
def __init__(self,
fft_len,
sens_per_sec,
sample_rate,
channel_space=1,
search_bw=1,
thr_leveler=10,
tune_freq=0,
alpha_avg=1,
test_duration=1,
period=3600,
trunc_band=1,
verbose=False,
peak_alpha=0,
subject_channels=[]):
gr.hier_block2.__init__(self, "flank detector",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len #lenght of the fft for spectral analysis
self.sens_per_sec = sens_per_sec #number of measurements per second (decimates)
self.sample_rate = sample_rate
self.channel_space = channel_space #channel space for analysis
self.search_bw = search_bw #search bandwidth within each channel
self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison
self.tune_freq = tune_freq #center frequency
self.threshold = 0 #actual value of the threshold
self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements
self.peak_alpha = peak_alpha #averaging factor for peak level between consecutive measurements
self.subject_channels = subject_channels #channels whose flancks will be analysed
self.msgq0 = gr.msg_queue(2)
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.sens_per_sec)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.multiply = blocks.multiply_const_vff(
np.array([1.0 / float(self.fft_len**2)] * fft_len))
self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq0, True)
#####CONNECTIONS####
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.multiply, self.sink0)
#start periodic logging
self._logger = logger(period, test_duration)
#self._logger = None
#Watchers
#statistics and power
self._watcher0 = _queue0_watcher(
self.msgq0, sens_per_sec, self.tune_freq, self.channel_space,
self.search_bw, self.fft_len, self.sample_rate, self.thr_leveler,
self.alpha_avg, test_duration, trunc_band, verbose, peak_alpha,
subject_channels, self._logger)
def __init__(self, fft_len, sens_per_sec, sample_rate, channel_space = 1,
search_bw = 1, thr_leveler = 10, tune_freq = 0, alpha_avg = 1, test_duration = 1,
period = 3600, trunc_band = 1, verbose = False, stats = False, psd = False, waterfall = False, output = False, subject_channels = []):
gr.hier_block2.__init__(self,
"spectrum_sensor_v2",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len #lenght of the fft for spectral analysis
self.sens_per_sec = sens_per_sec #number of measurements per second (decimates)
self.sample_rate = sample_rate
self.channel_space = channel_space #channel space for analysis
self.search_bw = search_bw #search bandwidth within each channel
self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison
self.tune_freq = tune_freq #center frequency
self.threshold = 0 #actual value of the threshold
self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements
self.verbose = verbose
self.trunc_band = trunc_band
self.stats = stats
self.psd = psd
self.waterfall = waterfall
self.output = output
self.subject_channels = subject_channels
#data queue to share data between theads
self.q = Queue.Queue()
#gnuradio msg queues
self.msgq0 = gr.msg_queue(2)
self.msgq1 = gr.msg_queue(2)
#output top 4 freqs
self.top4 = [0, 0, 0, 0]
#register message out to other blocks
self.message_port_register_hier_in("freq_out_0")
self.message_port_register_hier_in("freq_out_1")
self.message_port_register_hier_in("freq_out_2")
self.message_port_register_hier_in("freq_out_3")
self.message_port_register_hier_in("freq_msg_PDU")
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate/self.fft_len/self.sens_per_sec)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.multiply = blocks.multiply_const_vff(np.array([1.0/float(self.fft_len**2)]*fft_len))
#MSG sinks PSD data
#stats and basic
self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq0, True)
if self.psd:
self.sink1 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq1, True)
#-----waterfall-----> different decimation because operates in a slower rate
if self.waterfall:
self.msgq2 = gr.msg_queue(2)
self.sink2 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq2, True)
self.one_in_n_waterfall = blocks.keep_one_in_n(gr.sizeof_float * self.fft_len, self.sens_per_sec) #keep 1 per second...
#MSG output blocks to other blocks
self.message_out0 = blocks.message_strobe( pmt.cons( pmt.intern("freq"), pmt.to_pmt(self.top4[0])), 1000)
self.message_out1 = blocks.message_strobe( pmt.cons( pmt.intern("freq"), pmt.to_pmt(self.top4[1])), 1000)
self.message_out2 = blocks.message_strobe( pmt.cons( pmt.intern("freq"), pmt.to_pmt(self.top4[2])), 1000)
self.message_out3 = blocks.message_strobe( pmt.cons( pmt.intern("freq"), pmt.to_pmt(self.top4[3])), 1000)
self.PDU_messages = message_pdu.message_pdu(None)
#####CONNECTIONS####
#main stream
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.multiply, self.sink0)
#psd stream
if self.psd:
self.connect(self.multiply, self.sink1)
#waterfall stream
if self.waterfall:
self.connect(self.multiply, self.one_in_n_waterfall, self.sink2)
#MSG output
self.msg_connect(self.message_out0, "strobe", self, "freq_out_0")
self.msg_connect(self.message_out1, "strobe", self, "freq_out_1")
self.msg_connect(self.message_out2, "strobe", self, "freq_out_2")
self.msg_connect(self.message_out3, "strobe", self, "freq_out_3")
self.msg_connect(self.PDU_messages, 'out', self, 'freq_msg_PDU')
#start periodic logging
if self.stats or self.psd or self.waterfall:
self._logger = logger(self.fft_len, period, test_duration)
#Watchers
#statistics and power
if self.stats:
self._stats_watcher = stats_watcher(self.msgq0, sens_per_sec, self.tune_freq, self.channel_space,
self.search_bw, self.fft_len, self.sample_rate, self.thr_leveler, self.alpha_avg, test_duration,
trunc_band, verbose, self._logger, self.q)
#psd
if self.psd:
self._psd_watcher = psd_watcher(self.msgq1, verbose, self._logger)
#waterfall
if self.waterfall:
self._waterfall_watcher = waterfall_watcher(self.msgq2, verbose, self._logger)
#output_data - start basic watcher and output data threads
if self.output:
if self.stats is not True:
self._basic_spectrum_watcher = basic_spectrum_watcher(self.msgq0, sens_per_sec, self.tune_freq, self.channel_space,
self.search_bw, self.fft_len, self.sample_rate, trunc_band, verbose, self.q)
self._output_data = output_data(self.q, self.sample_rate, self.tune_freq, self.fft_len, self.trunc_band,
self.channel_space, self.search_bw, self.output, self.subject_channels, self.top4, self.set_freqs)
#send PDU's w/ freq data
self._send_PDU_data = send_PDU_data(self.top4, self.PDU_messages)
def __init__(self, fft_len, sens_per_sec, sample_rate, channel_space = 1, search_bw = 1, thr_leveler = 10, tune_freq = 0, alpha_avg = 1, test_duration = 1, period = 3600, trunc_band = 1, verbose = False, psd = False, waterfall = False, subject_channels = []): gr.hier_block2.__init__(self, "spectrum_sensor_v1", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) self.fft_len = fft_len #lenght of the fft for spectral analysis self.sens_per_sec = sens_per_sec #number of measurements per second (decimates) self.sample_rate = sample_rate self.channel_space = channel_space #channel space for analysis self.search_bw = search_bw #search bandwidth within each channel self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison self.tune_freq = tune_freq #center frequency self.threshold = 0 #actual value of the threshold self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements self.verbose = verbose self.trunc_band = trunc_band self.psd = psd self.waterfall = waterfall self.subject_channels = subject_channels #gnuradio msg queues self.msgq0 = gr.msg_queue(2) self.msgq1 = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.sens_per_sec))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.multiply = blocks.multiply_const_vff(np.array([1.0/float(self.fft_len**2)]*fft_len)) #MSG sinks PSD data self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq0, True) self.sink1 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq1, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.multiply, self.sink0) self.connect(self.multiply, self.sink1) #-----waterfall-----> different decimation because operates in a slower rate self.msgq2 = gr.msg_queue(2) self.sink2 = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq2, True) self.one_in_n_waterfall = blocks.keep_one_in_n(gr.sizeof_float * self.fft_len, self.sens_per_sec) #keep 1 per second... self.connect(self.multiply, self.one_in_n_waterfall, self.sink2) #start periodic logging self._logger = logger(self.fft_len, period, test_duration) #Watchers #statistics and power self._stats_watcher = _stats_watcher(self.msgq0, sens_per_sec, self.tune_freq, self.channel_space, self.search_bw, self.fft_len, self.sample_rate, self.thr_leveler, self.alpha_avg, test_duration, trunc_band, verbose, self._logger) #psd if self.psd: self._psd_watcher = _psd_watcher(self.msgq1, verbose, self._logger) #waterfall if self.waterfall: self._waterfall_watcher = _waterfall_watcher(self.msgq2, verbose, self._logger)
def __init__(self,
fft_len,
sens_per_sec,
sample_rate,
channel_space=1,
search_bw=1,
thr_leveler=10,
tune_freq=0,
alpha_avg=1,
test_duration=1,
period=3600,
trunc_band=1,
verbose=False,
stats=False,
psd=False,
waterfall=False,
output=False,
subject_channels=[]):
gr.hier_block2.__init__(self, "spectrum_sensor_v2",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.fft_len = fft_len #lenght of the fft for spectral analysis
self.sens_per_sec = sens_per_sec #number of measurements per second (decimates)
self.sample_rate = sample_rate
self.channel_space = channel_space #channel space for analysis
self.search_bw = search_bw #search bandwidth within each channel
self.thr_leveler = thr_leveler #leveler factor for noise floor / threshold comparison
self.tune_freq = tune_freq #center frequency
self.threshold = 0 #actual value of the threshold
self.alpha_avg = alpha_avg #averaging factor for noise level between consecutive measurements
self.verbose = verbose
self.trunc_band = trunc_band
self.stats = stats
self.psd = psd
self.waterfall = waterfall
self.output = output
self.subject_channels = subject_channels
#data queue to share data between theads
self.q = Queue.Queue()
#gnuradio msg queues
self.msgq0 = gr.msg_queue(2)
self.msgq1 = gr.msg_queue(2)
#output top 4 freqs
self.top4 = [0, 0, 0, 0]
#register message out to other blocks
self.message_port_register_hier_out("freq_out_0")
self.message_port_register_hier_out("freq_out_1")
self.message_port_register_hier_out("freq_out_2")
self.message_port_register_hier_out("freq_out_3")
self.message_port_register_hier_out("freq_msg_PDU")
#######BLOCKS#####
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(
gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate / self.fft_len / self.sens_per_sec)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, (), True)
self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len)
self.multiply = blocks.multiply_const_vff(
np.array([1.0 / float(self.fft_len**2)] * fft_len))
#MSG sinks PSD data
#stats and basic
self.sink0 = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq0, True)
if self.psd:
self.sink1 = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq1, True)
#-----waterfall-----> different decimation because operates in a slower rate
if self.waterfall:
self.msgq2 = gr.msg_queue(2)
self.sink2 = blocks.message_sink(gr.sizeof_float * self.fft_len,
self.msgq2, True)
self.one_in_n_waterfall = blocks.keep_one_in_n(
gr.sizeof_float * self.fft_len,
self.sens_per_sec) #keep 1 per second...
#MSG output blocks to other blocks
self.message_out0 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[0])), 1000)
self.message_out1 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[1])), 1000)
self.message_out2 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[2])), 1000)
self.message_out3 = blocks.message_strobe(
pmt.cons(pmt.intern("freq"), pmt.to_pmt(self.top4[3])), 1000)
self.PDU_messages = message_pdu.message_pdu(None)
#####CONNECTIONS####
#main stream
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2,
self.multiply, self.sink0)
#psd stream
if self.psd:
self.connect(self.multiply, self.sink1)
#waterfall stream
if self.waterfall:
self.connect(self.multiply, self.one_in_n_waterfall, self.sink2)
#MSG output
self.msg_connect(self.message_out0, "strobe", self, "freq_out_0")
self.msg_connect(self.message_out1, "strobe", self, "freq_out_1")
self.msg_connect(self.message_out2, "strobe", self, "freq_out_2")
self.msg_connect(self.message_out3, "strobe", self, "freq_out_3")
self.msg_connect(self.PDU_messages, 'out', self, 'freq_msg_PDU')
#start periodic logging
if self.stats or self.psd or self.waterfall:
self._logger = logger(self.fft_len, period, test_duration)
#Watchers
#statistics and power
if self.stats:
self._stats_watcher = stats_watcher(
self.msgq0, sens_per_sec, self.tune_freq, self.channel_space,
self.search_bw, self.fft_len, self.sample_rate,
self.thr_leveler, self.alpha_avg, test_duration, trunc_band,
verbose, self._logger, self.q)
#psd
if self.psd:
self._psd_watcher = psd_watcher(self.msgq1, verbose, self._logger)
#waterfall
if self.waterfall:
self._waterfall_watcher = waterfall_watcher(
self.msgq2, verbose, self._logger)
#output_data - start basic watcher and output data threads
if self.output:
if self.stats is not True:
self._basic_spectrum_watcher = basic_spectrum_watcher(
self.msgq0, sens_per_sec, self.tune_freq,
self.channel_space, self.search_bw, self.fft_len,
self.sample_rate, trunc_band, verbose, self.q)
self._output_data = output_data(self.q, self.sample_rate,
self.tune_freq, self.fft_len,
self.trunc_band,
self.channel_space, self.search_bw,
self.output, self.subject_channels,
self.top4, self.set_freqs)
#send PDU's w/ freq data
self._send_PDU_data = send_PDU_data(self.top4, self.PDU_messages)
