def __init__(self, sample_rate, pspectrum_len, ref_scale, frame_rate, avg_alpha, average, n, m, nsamples, estimator='esprit'): """ Create an log10(abs(spectrum_estimate)) stream chain. Provide access to the setting the filter and sample rate. @param sample_rate Incoming stream sample rate @param pspectrum_len Number of FFT bins @param ref_scale Sets 0 dB value input amplitude @param frame_rate Output frame rate @param avg_alpha averaging (over time) constant [0.0-1.0] @param average Whether to average [True, False] @param n Parameter n for the estimator @param m Parameter m for the estimator @param nsamples Number of samples to use for estimation @param estimator Estimator to use, can be either 'esprit' or 'music' """ gr.hier_block2.__init__( self, self._name, gr.io_signature(1, 1, self._item_size), # Input signature gr.io_signature(1, 1, gr.sizeof_float * pspectrum_len)) # Output signature self._sd = blks2.stream_to_vector_decimator(item_size=self._item_size, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=nsamples) if estimator == 'esprit': est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len) elif estimator == 'music': est = specest.music_spectrum_vcf(n, m, nsamples, pspectrum_len) else: est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len) self._avg = gr.single_pole_iir_filter_ff(1.0, pspectrum_len) self._log = gr.nlog10_ff( 20, pspectrum_len, -20 * math.log10(pspectrum_len) # Adjust for number of bins - 20 * math.log10(ref_scale / 2) + 3.0) # Adjust for reference scale self.connect(self, self._sd, est, self._avg, self._log, self) self._average = average self._avg_alpha = avg_alpha self.set_avg_alpha(avg_alpha) self.set_average(average)
def __init__( self, parent, unit='%', minval=0, maxval=100, decimal_places=5, sample_rate=1, number_rate=DEFAULT_NUMBER_RATE, label='Bit Error Rate', size=DEFAULT_WIN_SIZE, show_gauge=True, **kwargs #catchall for backwards compatibility ): gr.hier_block2.__init__( self, "number_sink", gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0), ) #blocks sd = blks2.stream_to_vector_decimator( item_size=self._item_size, sample_rate=sample_rate, vec_rate=number_rate, vec_len=1, ) mult = gr.multiply_const_ff(100) add = gr.add_const_ff(1e-10) msgq = gr.msg_queue(2) sink = gr.message_sink(self._item_size, msgq, True) #connect self.connect(self, sd, mult, add, sink) #controller self.controller = pubsub() #start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = number_window( parent=parent, controller=self.controller, size=size, title=label, units=unit, real=self._real, minval=minval, maxval=maxval, decimal_places=decimal_places, show_gauge=show_gauge, msg_key=MSG_KEY, sample_rate_key=SAMPLE_RATE_KEY)
def __init__( self, parent, unit='%', minval=0, maxval=100, decimal_places=5, sample_rate=1, number_rate=DEFAULT_NUMBER_RATE, label='Bit Error Rate', size=DEFAULT_WIN_SIZE, show_gauge=True, **kwargs #catchall for backwards compatibility ): gr.hier_block2.__init__( self, "number_sink", gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0), ) #blocks sd = blks2.stream_to_vector_decimator( item_size=self._item_size, sample_rate=sample_rate, vec_rate=number_rate, vec_len=1, ) mult = gr.multiply_const_ff(100) add = gr.add_const_ff(1e-10) msgq = gr.msg_queue(2) sink = gr.message_sink(self._item_size, msgq, True) #connect self.connect(self, sd, mult, add, sink) #controller self.controller = pubsub() #start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = number_window(parent=parent, controller=self.controller, size=size, title=label, units=unit, real=self._real, minval=minval, maxval=maxval, decimal_places=decimal_places, show_gauge=show_gauge, msg_key=MSG_KEY, sample_rate_key=SAMPLE_RATE_KEY)
def __init__( self, sample_rate, pspectrum_len, ref_scale, frame_rate, avg_alpha, average, n, m, nsamples, estimator="esprit" ): """ Create an log10(abs(spectrum_estimate)) stream chain. Provide access to the setting the filter and sample rate. @param sample_rate Incoming stream sample rate @param pspectrum_len Number of FFT bins @param ref_scale Sets 0 dB value input amplitude @param frame_rate Output frame rate @param avg_alpha averaging (over time) constant [0.0-1.0] @param average Whether to average [True, False] @param n Parameter n for the estimator @param m Parameter m for the estimator @param nsamples Number of samples to use for estimation @param estimator Estimator to use, can be either 'esprit' or 'music' """ gr.hier_block2.__init__( self, self._name, gr.io_signature(1, 1, self._item_size), # Input signature gr.io_signature(1, 1, gr.sizeof_float * pspectrum_len), ) # Output signature self._sd = blks2.stream_to_vector_decimator( item_size=self._item_size, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=nsamples ) if estimator == "esprit": est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len) elif estimator == "music": est = specest.music_spectrum_vcf(n, m, nsamples, pspectrum_len) else: est = specest.esprit_spectrum_vcf(n, m, nsamples, pspectrum_len) self._avg = gr.single_pole_iir_filter_ff(1.0, pspectrum_len) self._log = gr.nlog10_ff( 20, pspectrum_len, -20 * math.log10(pspectrum_len) - 20 * math.log10(ref_scale / 2) + 3.0, # Adjust for number of bins ) # Adjust for reference scale self.connect(self, self._sd, est, self._avg, self._log, self) self._average = average self._avg_alpha = avg_alpha self.set_avg_alpha(avg_alpha) self.set_average(average)
def __init__( self, parent, title='', sample_rate=1, size=(495,450), frame_rate=5, const_size=1024, mod='DBPSK'): #init gr.hier_block2.__init__( self, "const_sink", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0), ) self.sd = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=const_size, ) self. agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100) self.gain= gr.multiply_const_cc(utils.gain[mod]) msgq = gr.msg_queue(2) sink = gr.message_sink(gr.sizeof_gr_complex*const_size, msgq, True) #connect self.connect(self, self.agc, self.gain, self.sd, sink) #controller def setter(p, k, x): p[k] = x self.controller = pubsub() #initial update common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = const_window( parent=parent, controller=self.controller, size=size, title=title, msg_key=MSG_KEY ) common.register_access_methods(self, self.win)
def __init__(self, parent, title='', sample_rate=1, size=(495, 450), frame_rate=5, const_size=1024, mod='DBPSK'): #init gr.hier_block2.__init__( self, "const_sink", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0), ) self.sd = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=const_size, ) self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100) self.gain = gr.multiply_const_cc(utils.gain[mod]) msgq = gr.msg_queue(2) sink = gr.message_sink(gr.sizeof_gr_complex * const_size, msgq, True) #connect self.connect(self, self.agc, self.gain, self.sd, sink) #controller def setter(p, k, x): p[k] = x self.controller = pubsub() #initial update common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = const_window(parent=parent, controller=self.controller, size=size, title=title, msg_key=MSG_KEY) common.register_access_methods(self, self.win)
def __init__(self, sample_rate, fft_size, ref_scale, frame_rate, avg_alpha, average, win=None): """ Create an log10(abs(fft)) stream chain. Provide access to the setting the filter and sample rate. Args: sample_rate: Incoming stream sample rate fft_size: Number of FFT bins ref_scale: Sets 0 dB value input amplitude frame_rate: Output frame rate avg_alpha: FFT averaging (over time) constant [0.0-1.0] average: Whether to average [True, False] win: the window taps generation function """ gr.hier_block2.__init__(self, self._name, gr.io_signature(1, 1, self._item_size), # Input signature gr.io_signature(1, 1, gr.sizeof_float*fft_size)) # Output signature self._sd = stream_to_vector_decimator(item_size=self._item_size, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=fft_size) if win is None: win = window.blackmanharris fft_window = win(fft_size) fft = self._fft_block[0](fft_size, True, fft_window) window_power = sum(map(lambda x: x*x, fft_window)) c2magsq = gr.complex_to_mag_squared(fft_size) self._avg = filter.single_pole_iir_filter_ff(1.0, fft_size) self._log = gr.nlog10_ff(10, fft_size, -20*math.log10(fft_size) # Adjust for number of bins -10*math.log10(window_power/fft_size) # Adjust for windowing loss -20*math.log10(ref_scale/2)) # Adjust for reference scale self.connect(self, self._sd, fft, c2magsq, self._avg, self._log, self) self._average = average self._avg_alpha = avg_alpha self.set_avg_alpha(avg_alpha) self.set_average(average)
def __init__( self, parent, title='', sample_rate=1, size=const_window.DEFAULT_WIN_SIZE, frame_rate=const_window.DEFAULT_FRAME_RATE, const_size=const_window.DEFAULT_CONST_SIZE, #mpsk recv params M=4, theta=0, loop_bw=6.28/100.0, fmax=0.06, mu=0.5, gain_mu=0.005, symbol_rate=1, omega_limit=0.005, ): #init gr.hier_block2.__init__( self, "const_sink", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0), ) #blocks sd = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=const_size, ) fmin = -fmax gain_omega = .25*gain_mu**2 #redundant, will be updated omega = 1 #set_sample_rate will update this # Costas frequency/phase recovery loop # Critically damped 2nd order PLL self._costas = digital.costas_loop_cc(loop_bw, M) # Timing recovery loop # Critically damped 2nd order DLL self._retime = digital.clock_recovery_mm_cc(omega, gain_omega, mu, gain_mu, omega_limit) #sync = gr.mpsk_receiver_cc( # M, #psk order # theta, # alpha, # beta, # fmin, # fmax, # mu, # gain_mu, # omega, # gain_omega, # omega_limit, #) agc = gr.feedforward_agc_cc(16, 1) msgq = gr.msg_queue(2) sink = gr.message_sink(gr.sizeof_gr_complex*const_size, msgq, True) #controller def setter(p, k, x): p[k] = x self.controller = pubsub() self.controller.subscribe(LOOP_BW_KEY, self._costas.set_loop_bandwidth) self.controller.publish(LOOP_BW_KEY, self._costas.get_loop_bandwidth) self.controller.subscribe(GAIN_MU_KEY, self._retime.set_gain_mu) self.controller.publish(GAIN_MU_KEY, self._retime.gain_mu) self.controller.subscribe(OMEGA_KEY, self._retime.set_omega) self.controller.publish(OMEGA_KEY, self._retime.omega) self.controller.subscribe(GAIN_OMEGA_KEY, self._retime.set_gain_omega) self.controller.publish(GAIN_OMEGA_KEY, self._retime.gain_omega) self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate) self.controller.subscribe(SAMPLE_RATE_KEY, lambda x: setter(self.controller, OMEGA_KEY, float(x)/symbol_rate)) self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate) #initial update self.controller[SAMPLE_RATE_KEY] = sample_rate #start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = const_window.const_window( parent=parent, controller=self.controller, size=size, title=title, msg_key=MSG_KEY, loop_bw_key=LOOP_BW_KEY, gain_mu_key=GAIN_MU_KEY, gain_omega_key=GAIN_OMEGA_KEY, omega_key=OMEGA_KEY, sample_rate_key=SAMPLE_RATE_KEY, ) common.register_access_methods(self, self.win) #connect self.wxgui_connect(self, self._costas, self._retime, agc, sd, sink)
def __init__( self, parent, unit="units", minval=0, maxval=1, factor=1, decimal_places=3, ref_level=0, sample_rate=1, number_rate=number_window.DEFAULT_NUMBER_RATE, average=False, avg_alpha=None, label="Number Plot", size=number_window.DEFAULT_WIN_SIZE, peak_hold=False, show_gauge=True, **kwargs # catchall for backwards compatibility ): # ensure avg alpha if avg_alpha is None: avg_alpha = 2.0 / number_rate # init gr.hier_block2.__init__(self, "number_sink", gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0)) # blocks sd = blks2.stream_to_vector_decimator( item_size=self._item_size, sample_rate=sample_rate, vec_rate=number_rate, vec_len=1 ) if self._real: mult = gr.multiply_const_ff(factor) add = gr.add_const_ff(ref_level) avg = gr.single_pole_iir_filter_ff(1.0) else: mult = gr.multiply_const_cc(factor) add = gr.add_const_cc(ref_level) avg = gr.single_pole_iir_filter_cc(1.0) msgq = gr.msg_queue(2) sink = gr.message_sink(self._item_size, msgq, True) # controller self.controller = pubsub() self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate) self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate) self.controller[AVERAGE_KEY] = average self.controller[AVG_ALPHA_KEY] = avg_alpha def update_avg(*args): if self.controller[AVERAGE_KEY]: avg.set_taps(self.controller[AVG_ALPHA_KEY]) else: avg.set_taps(1.0) update_avg() self.controller.subscribe(AVERAGE_KEY, update_avg) self.controller.subscribe(AVG_ALPHA_KEY, update_avg) # start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) # create window self.win = number_window.number_window( parent=parent, controller=self.controller, size=size, title=label, units=unit, real=self._real, minval=minval, maxval=maxval, decimal_places=decimal_places, show_gauge=show_gauge, average_key=AVERAGE_KEY, avg_alpha_key=AVG_ALPHA_KEY, peak_hold=peak_hold, msg_key=MSG_KEY, sample_rate_key=SAMPLE_RATE_KEY, ) common.register_access_methods(self, self.controller) # backwards compadibility self.set_show_gauge = self.win.show_gauges # connect self.wxgui_connect(self, sd, mult, add, avg, sink)
def __init__( self, parent, title='', sample_rate=1, size=const_window.DEFAULT_WIN_SIZE, frame_rate=const_window.DEFAULT_FRAME_RATE, const_size=const_window.DEFAULT_CONST_SIZE, #mpsk recv params M=4, theta=0, alpha=0.005, fmax=0.06, mu=0.5, gain_mu=0.005, symbol_rate=1, omega_limit=0.005, ): #init gr.hier_block2.__init__( self, "const_sink", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0), ) #blocks sd = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=sample_rate, vec_rate=frame_rate, vec_len=const_size, ) beta = .25 * alpha**2 #redundant, will be updated fmin = -fmax gain_omega = .25 * gain_mu**2 #redundant, will be updated omega = 1 #set_sample_rate will update this # Costas frequency/phase recovery loop # Critically damped 2nd order PLL self._costas = gr.costas_loop_cc(alpha, beta, fmax, fmin, M) # Timing recovery loop # Critically damped 2nd order DLL self._retime = gr.clock_recovery_mm_cc(omega, gain_omega, mu, gain_mu, omega_limit) #sync = gr.mpsk_receiver_cc( # M, #psk order # theta, # alpha, # beta, # fmin, # fmax, # mu, # gain_mu, # omega, # gain_omega, # omega_limit, #) agc = gr.feedforward_agc_cc(16, 1) msgq = gr.msg_queue(2) sink = gr.message_sink(gr.sizeof_gr_complex * const_size, msgq, True) #controller def setter(p, k, x): p[k] = x self.controller = pubsub() self.controller.subscribe(ALPHA_KEY, self._costas.set_alpha) self.controller.publish(ALPHA_KEY, self._costas.alpha) self.controller.subscribe(BETA_KEY, self._costas.set_beta) self.controller.publish(BETA_KEY, self._costas.beta) self.controller.subscribe(GAIN_MU_KEY, self._retime.set_gain_mu) self.controller.publish(GAIN_MU_KEY, self._retime.gain_mu) self.controller.subscribe(OMEGA_KEY, self._retime.set_omega) self.controller.publish(OMEGA_KEY, self._retime.omega) self.controller.subscribe(GAIN_OMEGA_KEY, self._retime.set_gain_omega) self.controller.publish(GAIN_OMEGA_KEY, self._retime.gain_omega) self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate) self.controller.subscribe( SAMPLE_RATE_KEY, lambda x: setter(self.controller, OMEGA_KEY, float(x) / symbol_rate)) self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate) #initial update self.controller[SAMPLE_RATE_KEY] = sample_rate #start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = const_window.const_window( parent=parent, controller=self.controller, size=size, title=title, msg_key=MSG_KEY, alpha_key=ALPHA_KEY, beta_key=BETA_KEY, gain_mu_key=GAIN_MU_KEY, gain_omega_key=GAIN_OMEGA_KEY, omega_key=OMEGA_KEY, sample_rate_key=SAMPLE_RATE_KEY, ) common.register_access_methods(self, self.win) #connect self.wxgui_connect(self, self._costas, self._retime, agc, sd, sink)
def __init__( self, parent, unit='units', minval=0, maxval=1, factor=1, decimal_places=3, ref_level=0, sample_rate=1, number_rate=number_window.DEFAULT_NUMBER_RATE, average=False, avg_alpha=None, label='Number Plot', size=number_window.DEFAULT_WIN_SIZE, peak_hold=False, show_gauge=True, **kwargs #catchall for backwards compatibility ): #ensure avg alpha if avg_alpha is None: avg_alpha = 2.0 / number_rate #init gr.hier_block2.__init__( self, "number_sink", gr.io_signature(1, 1, self._item_size), gr.io_signature(0, 0, 0), ) #blocks sd = blks2.stream_to_vector_decimator( item_size=self._item_size, sample_rate=sample_rate, vec_rate=number_rate, vec_len=1, ) if self._real: mult = gr.multiply_const_ff(factor) add = gr.add_const_ff(ref_level) avg = gr.single_pole_iir_filter_ff(1.0) else: mult = gr.multiply_const_cc(factor) add = gr.add_const_cc(ref_level) avg = gr.single_pole_iir_filter_cc(1.0) msgq = gr.msg_queue(2) sink = gr.message_sink(self._item_size, msgq, True) #controller self.controller = pubsub() self.controller.subscribe(SAMPLE_RATE_KEY, sd.set_sample_rate) self.controller.publish(SAMPLE_RATE_KEY, sd.sample_rate) self.controller[AVERAGE_KEY] = average self.controller[AVG_ALPHA_KEY] = avg_alpha def update_avg(*args): if self.controller[AVERAGE_KEY]: avg.set_taps(self.controller[AVG_ALPHA_KEY]) else: avg.set_taps(1.0) update_avg() self.controller.subscribe(AVERAGE_KEY, update_avg) self.controller.subscribe(AVG_ALPHA_KEY, update_avg) #start input watcher common.input_watcher(msgq, self.controller, MSG_KEY) #create window self.win = number_window.number_window( parent=parent, controller=self.controller, size=size, title=label, units=unit, real=self._real, minval=minval, maxval=maxval, decimal_places=decimal_places, show_gauge=show_gauge, average_key=AVERAGE_KEY, avg_alpha_key=AVG_ALPHA_KEY, peak_hold=peak_hold, msg_key=MSG_KEY, sample_rate_key=SAMPLE_RATE_KEY, ) common.register_access_methods(self, self.controller) #backwards compadibility self.set_show_gauge = self.win.show_gauges #connect self.wxgui_connect(self, sd, mult, add, avg, sink)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="RTL-SDR to Pure Data") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1920000 self.cur_freq_fine = cur_freq_fine = 0 self.cur_freq = cur_freq = 0 self.channels_coeffs_0 = channels_coeffs_0 = gr.firdes.low_pass(1.0,samp_rate,20000,25000,gr.firdes.WIN_HAMMING) self.channels_coeffs = channels_coeffs = gr.firdes.low_pass(1.0,samp_rate,20000,45000,gr.firdes.WIN_HAMMING) ################################################## # Blocks ################################################## self.signal_cur = gr.probe_signal_f() self.fine_cur = gr.probe_signal_f() self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.rtlsdr_source_c_0.set_sample_rate(samp_rate) self.rtlsdr_source_c_0.set_center_freq(78000000, 0) self.rtlsdr_source_c_0.set_freq_corr(0, 0) self.rtlsdr_source_c_0.set_gain_mode(0, 0) self.rtlsdr_source_c_0.set_gain(10, 0) self.rtlsdr_source_c_0.set_if_gain(24, 0) self.gr_udp_source_0_0 = gr.udp_source(gr.sizeof_float*1, "127.0.0.1", 2001, 4, True, True) self.gr_udp_source_0 = gr.udp_source(gr.sizeof_float*1, "127.0.0.1", 2000, 4, True, True) self.gr_udp_sink_0_0 = gr.udp_sink(gr.sizeof_float*2048, "127.0.0.1", 2002, 11776, True) self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), True, 1) def _cur_freq_fine_probe(): while True: val = self.fine_cur.level() try: self.set_cur_freq_fine(val) except AttributeError, e: pass time.sleep(1.0/(10)) _cur_freq_fine_thread = threading.Thread(target=_cur_freq_fine_probe) _cur_freq_fine_thread.daemon = True _cur_freq_fine_thread.start() def _cur_freq_probe(): while True: val = self.signal_cur.level() try: self.set_cur_freq(val) except AttributeError, e: pass time.sleep(1.0/(10)) _cur_freq_thread = threading.Thread(target=_cur_freq_probe) _cur_freq_thread.daemon = True _cur_freq_thread.start() self.blocks_nlog10_ff_0 = blocks.nlog10_ff(1, 2048, 0) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(2048) self.blks2_stream_to_vector_decimator_0 = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=samp_rate, vec_rate=25, vec_len=2048, ) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blks2_stream_to_vector_decimator_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_nlog10_ff_0, 0)) self.connect((self.rtlsdr_source_c_0, 0), (self.blks2_stream_to_vector_decimator_0, 0)) self.connect((self.gr_udp_source_0_0, 0), (self.fine_cur, 0)) self.connect((self.gr_udp_source_0, 0), (self.signal_cur, 0)) self.connect((self.blocks_nlog10_ff_0, 0), (self.gr_udp_sink_0_0, 0))