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)