gnuradio.qtgui

Provides a GUI interface using the QT backend.

gnuradio.qtgui.ber_sink_b(pmt_vector_float esnos, int curves=1, int berminerrors=100, float berLimit=-7.0, std::vector< std::string, std::allocator< std::string > > curvenames=std::vector< std::string >(), QWidget * parent=None) → ber_sink_b_sptr

ber_sink_b_sptr.active_thread_priority(ber_sink_b_sptr self) → int

ber_sink_b_sptr.d_qApplication(ber_sink_b_sptr self) → QApplication *

ber_sink_b_sptr.declare_sample_delay(ber_sink_b_sptr self, int which, int delay)

declare_sample_delay(ber_sink_b_sptr self, unsigned int delay)

ber_sink_b_sptr.enable_autoscale(ber_sink_b_sptr self, bool en)

ber_sink_b_sptr.enable_menu(ber_sink_b_sptr self, bool en=True)

ber_sink_b_sptr.exec_(ber_sink_b_sptr self)

ber_sink_b_sptr.line_alpha(ber_sink_b_sptr self, int which) → double

ber_sink_b_sptr.line_color(ber_sink_b_sptr self, int which) → std::string

ber_sink_b_sptr.line_label(ber_sink_b_sptr self, int which) → std::string

ber_sink_b_sptr.line_marker(ber_sink_b_sptr self, int which) → int

ber_sink_b_sptr.line_style(ber_sink_b_sptr self, int which) → int

ber_sink_b_sptr.line_width(ber_sink_b_sptr self, int which) → int

ber_sink_b_sptr.message_subscribers(ber_sink_b_sptr self, swig_int_ptr which_port) → swig_int_ptr

ber_sink_b_sptr.min_noutput_items(ber_sink_b_sptr self) → int

ber_sink_b_sptr.nsamps(ber_sink_b_sptr self) → int

ber_sink_b_sptr.pc_input_buffers_full_avg(ber_sink_b_sptr self, int which) → float

pc_input_buffers_full_avg(ber_sink_b_sptr self) -> pmt_vector_float

ber_sink_b_sptr.pc_noutput_items_avg(ber_sink_b_sptr self) → float

ber_sink_b_sptr.pc_nproduced_avg(ber_sink_b_sptr self) → float

ber_sink_b_sptr.pc_output_buffers_full_avg(ber_sink_b_sptr self, int which) → float

pc_output_buffers_full_avg(ber_sink_b_sptr self) -> pmt_vector_float

ber_sink_b_sptr.pc_throughput_avg(ber_sink_b_sptr self) → float

ber_sink_b_sptr.pc_work_time_avg(ber_sink_b_sptr self) → float

ber_sink_b_sptr.pc_work_time_total(ber_sink_b_sptr self) → float

ber_sink_b_sptr.pyqwidget(ber_sink_b_sptr self) → PyObject *

ber_sink_b_sptr.sample_delay(ber_sink_b_sptr self, int which) → unsigned int

ber_sink_b_sptr.set_line_alpha(ber_sink_b_sptr self, int which, double alpha)

ber_sink_b_sptr.set_line_color(ber_sink_b_sptr self, int which, std::string const & color)

ber_sink_b_sptr.set_line_label(ber_sink_b_sptr self, int which, std::string const & label)

ber_sink_b_sptr.set_line_marker(ber_sink_b_sptr self, int which, int marker)

ber_sink_b_sptr.set_line_style(ber_sink_b_sptr self, int which, int style)

ber_sink_b_sptr.set_line_width(ber_sink_b_sptr self, int which, int width)

ber_sink_b_sptr.set_min_noutput_items(ber_sink_b_sptr self, int m)

ber_sink_b_sptr.set_size(ber_sink_b_sptr self, int width, int height)

ber_sink_b_sptr.set_thread_priority(ber_sink_b_sptr self, int priority) → int

ber_sink_b_sptr.set_title(ber_sink_b_sptr self, std::string const & title)

ber_sink_b_sptr.set_update_time(ber_sink_b_sptr self, double t)

ber_sink_b_sptr.set_x_axis(ber_sink_b_sptr self, double min, double max)

ber_sink_b_sptr.set_y_axis(ber_sink_b_sptr self, double min, double max)

ber_sink_b_sptr.thread_priority(ber_sink_b_sptr self) → int

ber_sink_b_sptr.title(ber_sink_b_sptr self) → std::string

gnuradio.qtgui.const_sink_c(int size, std::string const & name, int nconnections=1, QWidget * parent=None) → const_sink_c_sptr

const_sink_c_sptr.active_thread_priority(const_sink_c_sptr self) → int

const_sink_c_sptr.d_qApplication(const_sink_c_sptr self) → QApplication *

const_sink_c_sptr.declare_sample_delay(const_sink_c_sptr self, int which, int delay)

declare_sample_delay(const_sink_c_sptr self, unsigned int delay)

const_sink_c_sptr.disable_legend(const_sink_c_sptr self)

const_sink_c_sptr.enable_autoscale(const_sink_c_sptr self, bool en)

const_sink_c_sptr.enable_axis_labels(const_sink_c_sptr self, bool en=True)

const_sink_c_sptr.enable_grid(const_sink_c_sptr self, bool en)

const_sink_c_sptr.enable_menu(const_sink_c_sptr self, bool en=True)

const_sink_c_sptr.exec_(const_sink_c_sptr self)

const_sink_c_sptr.line_alpha(const_sink_c_sptr self, int which) → double

const_sink_c_sptr.line_color(const_sink_c_sptr self, int which) → std::string

const_sink_c_sptr.line_label(const_sink_c_sptr self, int which) → std::string

const_sink_c_sptr.line_marker(const_sink_c_sptr self, int which) → int

const_sink_c_sptr.line_style(const_sink_c_sptr self, int which) → int

const_sink_c_sptr.line_width(const_sink_c_sptr self, int which) → int

const_sink_c_sptr.message_subscribers(const_sink_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

const_sink_c_sptr.min_noutput_items(const_sink_c_sptr self) → int

const_sink_c_sptr.nsamps(const_sink_c_sptr self) → int

const_sink_c_sptr.pc_input_buffers_full_avg(const_sink_c_sptr self, int which) → float

pc_input_buffers_full_avg(const_sink_c_sptr self) -> pmt_vector_float

const_sink_c_sptr.pc_noutput_items_avg(const_sink_c_sptr self) → float

const_sink_c_sptr.pc_nproduced_avg(const_sink_c_sptr self) → float

const_sink_c_sptr.pc_output_buffers_full_avg(const_sink_c_sptr self, int which) → float

pc_output_buffers_full_avg(const_sink_c_sptr self) -> pmt_vector_float

const_sink_c_sptr.pc_throughput_avg(const_sink_c_sptr self) → float

const_sink_c_sptr.pc_work_time_avg(const_sink_c_sptr self) → float

const_sink_c_sptr.pc_work_time_total(const_sink_c_sptr self) → float

const_sink_c_sptr.pyqwidget(const_sink_c_sptr self) → PyObject *

const_sink_c_sptr.qwidget(const_sink_c_sptr self) → QWidget *

const_sink_c_sptr.reset(const_sink_c_sptr self)

const_sink_c_sptr.sample_delay(const_sink_c_sptr self, int which) → unsigned int

const_sink_c_sptr.set_line_alpha(const_sink_c_sptr self, int which, double alpha)

const_sink_c_sptr.set_line_color(const_sink_c_sptr self, int which, std::string const & color)

const_sink_c_sptr.set_line_label(const_sink_c_sptr self, int which, std::string const & label)

const_sink_c_sptr.set_line_marker(const_sink_c_sptr self, int which, int marker)

const_sink_c_sptr.set_line_style(const_sink_c_sptr self, int which, int style)

const_sink_c_sptr.set_line_width(const_sink_c_sptr self, int which, int width)

const_sink_c_sptr.set_min_noutput_items(const_sink_c_sptr self, int m)

const_sink_c_sptr.set_nsamps(const_sink_c_sptr self, int const newsize)

const_sink_c_sptr.set_size(const_sink_c_sptr self, int width, int height)

const_sink_c_sptr.set_thread_priority(const_sink_c_sptr self, int priority) → int

const_sink_c_sptr.set_title(const_sink_c_sptr self, std::string const & title)

const_sink_c_sptr.set_trigger_mode(*args, **kwargs)

set_trigger_mode(const_sink_c_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, int channel, std::string const & tag_key=””)

const_sink_c_sptr.set_update_time(const_sink_c_sptr self, double t)

const_sink_c_sptr.set_x_axis(const_sink_c_sptr self, double min, double max)

const_sink_c_sptr.set_y_axis(const_sink_c_sptr self, double min, double max)

const_sink_c_sptr.thread_priority(const_sink_c_sptr self) → int

const_sink_c_sptr.title(const_sink_c_sptr self) → std::string

gnuradio.qtgui.freq_sink_c(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) → freq_sink_c_sptr

freq_sink_c_sptr.active_thread_priority(freq_sink_c_sptr self) → int

freq_sink_c_sptr.clear_max_hold(freq_sink_c_sptr self)

freq_sink_c_sptr.clear_min_hold(freq_sink_c_sptr self)

freq_sink_c_sptr.d_qApplication(freq_sink_c_sptr self) → QApplication *

freq_sink_c_sptr.declare_sample_delay(freq_sink_c_sptr self, int which, int delay)

declare_sample_delay(freq_sink_c_sptr self, unsigned int delay)

freq_sink_c_sptr.disable_legend(freq_sink_c_sptr self)

freq_sink_c_sptr.enable_autoscale(freq_sink_c_sptr self, bool en=True)

freq_sink_c_sptr.enable_axis_labels(freq_sink_c_sptr self, bool en=True)

freq_sink_c_sptr.enable_control_panel(freq_sink_c_sptr self, bool en=True)

freq_sink_c_sptr.enable_grid(freq_sink_c_sptr self, bool en=True)

freq_sink_c_sptr.enable_max_hold(freq_sink_c_sptr self, bool en)

freq_sink_c_sptr.enable_menu(freq_sink_c_sptr self, bool en=True)

freq_sink_c_sptr.enable_min_hold(freq_sink_c_sptr self, bool en)

freq_sink_c_sptr.exec_(freq_sink_c_sptr self)

freq_sink_c_sptr.fft_average(freq_sink_c_sptr self) → float

freq_sink_c_sptr.fft_size(freq_sink_c_sptr self) → int

freq_sink_c_sptr.fft_window(freq_sink_c_sptr self) → gr::filter::firdes::win_type

freq_sink_c_sptr.line_alpha(freq_sink_c_sptr self, int which) → double

freq_sink_c_sptr.line_color(freq_sink_c_sptr self, int which) → std::string

freq_sink_c_sptr.line_label(freq_sink_c_sptr self, int which) → std::string

freq_sink_c_sptr.line_marker(freq_sink_c_sptr self, int which) → int

freq_sink_c_sptr.line_style(freq_sink_c_sptr self, int which) → int

freq_sink_c_sptr.line_width(freq_sink_c_sptr self, int which) → int

freq_sink_c_sptr.message_subscribers(freq_sink_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

freq_sink_c_sptr.min_noutput_items(freq_sink_c_sptr self) → int

freq_sink_c_sptr.pc_input_buffers_full_avg(freq_sink_c_sptr self, int which) → float

pc_input_buffers_full_avg(freq_sink_c_sptr self) -> pmt_vector_float

freq_sink_c_sptr.pc_noutput_items_avg(freq_sink_c_sptr self) → float

freq_sink_c_sptr.pc_nproduced_avg(freq_sink_c_sptr self) → float

freq_sink_c_sptr.pc_output_buffers_full_avg(freq_sink_c_sptr self, int which) → float

pc_output_buffers_full_avg(freq_sink_c_sptr self) -> pmt_vector_float

freq_sink_c_sptr.pc_throughput_avg(freq_sink_c_sptr self) → float

freq_sink_c_sptr.pc_work_time_avg(freq_sink_c_sptr self) → float

freq_sink_c_sptr.pc_work_time_total(freq_sink_c_sptr self) → float

freq_sink_c_sptr.pyqwidget(freq_sink_c_sptr self) → PyObject *

freq_sink_c_sptr.qwidget(freq_sink_c_sptr self) → QWidget *

freq_sink_c_sptr.reset(freq_sink_c_sptr self)

freq_sink_c_sptr.sample_delay(freq_sink_c_sptr self, int which) → unsigned int

freq_sink_c_sptr.set_fft_average(freq_sink_c_sptr self, float const fftavg)

freq_sink_c_sptr.set_fft_size(freq_sink_c_sptr self, int const fftsize)

freq_sink_c_sptr.set_fft_window(freq_sink_c_sptr self, gr::filter::firdes::win_type const win)

freq_sink_c_sptr.set_frequency_range(freq_sink_c_sptr self, double const centerfreq, double const bandwidth)

freq_sink_c_sptr.set_line_alpha(freq_sink_c_sptr self, int which, double alpha)

freq_sink_c_sptr.set_line_color(freq_sink_c_sptr self, int which, std::string const & color)

freq_sink_c_sptr.set_line_label(freq_sink_c_sptr self, int which, std::string const & label)

freq_sink_c_sptr.set_line_marker(freq_sink_c_sptr self, int which, int marker)

freq_sink_c_sptr.set_line_style(freq_sink_c_sptr self, int which, int style)

freq_sink_c_sptr.set_line_width(freq_sink_c_sptr self, int which, int width)

freq_sink_c_sptr.set_min_noutput_items(freq_sink_c_sptr self, int m)

freq_sink_c_sptr.set_size(freq_sink_c_sptr self, int width, int height)

freq_sink_c_sptr.set_thread_priority(freq_sink_c_sptr self, int priority) → int

freq_sink_c_sptr.set_title(freq_sink_c_sptr self, std::string const & title)

freq_sink_c_sptr.set_trigger_mode(freq_sink_c_sptr self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key="")

freq_sink_c_sptr.set_update_time(freq_sink_c_sptr self, double t)

freq_sink_c_sptr.set_y_axis(freq_sink_c_sptr self, double min, double max)

freq_sink_c_sptr.set_y_label(freq_sink_c_sptr self, std::string const & label, std::string const & unit)

freq_sink_c_sptr.thread_priority(freq_sink_c_sptr self) → int

freq_sink_c_sptr.title(freq_sink_c_sptr self) → std::string

gnuradio.qtgui.freq_sink_f(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) → freq_sink_f_sptr

freq_sink_f_sptr.active_thread_priority(freq_sink_f_sptr self) → int

freq_sink_f_sptr.clear_max_hold(freq_sink_f_sptr self)

freq_sink_f_sptr.clear_min_hold(freq_sink_f_sptr self)

freq_sink_f_sptr.d_qApplication(freq_sink_f_sptr self) → QApplication *

freq_sink_f_sptr.declare_sample_delay(freq_sink_f_sptr self, int which, int delay)

declare_sample_delay(freq_sink_f_sptr self, unsigned int delay)

freq_sink_f_sptr.disable_legend(freq_sink_f_sptr self)

freq_sink_f_sptr.enable_autoscale(freq_sink_f_sptr self, bool en=True)

freq_sink_f_sptr.enable_axis_labels(freq_sink_f_sptr self, bool en=True)

freq_sink_f_sptr.enable_control_panel(freq_sink_f_sptr self, bool en=True)

freq_sink_f_sptr.enable_grid(freq_sink_f_sptr self, bool en=True)

freq_sink_f_sptr.enable_max_hold(freq_sink_f_sptr self, bool en)

freq_sink_f_sptr.enable_menu(freq_sink_f_sptr self, bool en=True)

freq_sink_f_sptr.enable_min_hold(freq_sink_f_sptr self, bool en)

freq_sink_f_sptr.exec_(freq_sink_f_sptr self)

freq_sink_f_sptr.fft_average(freq_sink_f_sptr self) → float

freq_sink_f_sptr.fft_size(freq_sink_f_sptr self) → int

freq_sink_f_sptr.fft_window(freq_sink_f_sptr self) → gr::filter::firdes::win_type

freq_sink_f_sptr.line_alpha(freq_sink_f_sptr self, int which) → double

freq_sink_f_sptr.line_color(freq_sink_f_sptr self, int which) → std::string

freq_sink_f_sptr.line_label(freq_sink_f_sptr self, int which) → std::string

freq_sink_f_sptr.line_marker(freq_sink_f_sptr self, int which) → int

freq_sink_f_sptr.line_style(freq_sink_f_sptr self, int which) → int

freq_sink_f_sptr.line_width(freq_sink_f_sptr self, int which) → int

freq_sink_f_sptr.message_subscribers(freq_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

freq_sink_f_sptr.min_noutput_items(freq_sink_f_sptr self) → int

freq_sink_f_sptr.pc_input_buffers_full_avg(freq_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(freq_sink_f_sptr self) -> pmt_vector_float

freq_sink_f_sptr.pc_noutput_items_avg(freq_sink_f_sptr self) → float

freq_sink_f_sptr.pc_nproduced_avg(freq_sink_f_sptr self) → float

freq_sink_f_sptr.pc_output_buffers_full_avg(freq_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(freq_sink_f_sptr self) -> pmt_vector_float

freq_sink_f_sptr.pc_throughput_avg(freq_sink_f_sptr self) → float

freq_sink_f_sptr.pc_work_time_avg(freq_sink_f_sptr self) → float

freq_sink_f_sptr.pc_work_time_total(freq_sink_f_sptr self) → float

freq_sink_f_sptr.pyqwidget(freq_sink_f_sptr self) → PyObject *

freq_sink_f_sptr.qwidget(freq_sink_f_sptr self) → QWidget *

freq_sink_f_sptr.reset(freq_sink_f_sptr self)

freq_sink_f_sptr.sample_delay(freq_sink_f_sptr self, int which) → unsigned int

freq_sink_f_sptr.set_fft_average(freq_sink_f_sptr self, float const fftavg)

freq_sink_f_sptr.set_fft_size(freq_sink_f_sptr self, int const fftsize)

freq_sink_f_sptr.set_fft_window(freq_sink_f_sptr self, gr::filter::firdes::win_type const win)

freq_sink_f_sptr.set_frequency_range(freq_sink_f_sptr self, double const centerfreq, double const bandwidth)

freq_sink_f_sptr.set_line_alpha(freq_sink_f_sptr self, int which, double alpha)

freq_sink_f_sptr.set_line_color(freq_sink_f_sptr self, int which, std::string const & color)

freq_sink_f_sptr.set_line_label(freq_sink_f_sptr self, int which, std::string const & label)

freq_sink_f_sptr.set_line_marker(freq_sink_f_sptr self, int which, int marker)

freq_sink_f_sptr.set_line_style(freq_sink_f_sptr self, int which, int style)

freq_sink_f_sptr.set_line_width(freq_sink_f_sptr self, int which, int width)

freq_sink_f_sptr.set_min_noutput_items(freq_sink_f_sptr self, int m)

freq_sink_f_sptr.set_plot_pos_half(freq_sink_f_sptr self, bool half)

freq_sink_f_sptr.set_size(freq_sink_f_sptr self, int width, int height)

freq_sink_f_sptr.set_thread_priority(freq_sink_f_sptr self, int priority) → int

freq_sink_f_sptr.set_title(freq_sink_f_sptr self, std::string const & title)

freq_sink_f_sptr.set_trigger_mode(freq_sink_f_sptr self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key="")

freq_sink_f_sptr.set_update_time(freq_sink_f_sptr self, double t)

freq_sink_f_sptr.set_y_axis(freq_sink_f_sptr self, double min, double max)

freq_sink_f_sptr.set_y_label(freq_sink_f_sptr self, std::string const & label, std::string const & unit)

freq_sink_f_sptr.thread_priority(freq_sink_f_sptr self) → int

freq_sink_f_sptr.title(freq_sink_f_sptr self) → std::string

gnuradio.qtgui.histogram_sink_f(int size, int bins, double xmin, double xmax, std::string const & name, int nconnections=1, QWidget * parent=None) → histogram_sink_f_sptr

histogram_sink_f_sptr.active_thread_priority(histogram_sink_f_sptr self) → int

histogram_sink_f_sptr.autoscalex(histogram_sink_f_sptr self)

histogram_sink_f_sptr.bins(histogram_sink_f_sptr self) → int

histogram_sink_f_sptr.d_qApplication(histogram_sink_f_sptr self) → QApplication *

histogram_sink_f_sptr.declare_sample_delay(histogram_sink_f_sptr self, int which, int delay)

declare_sample_delay(histogram_sink_f_sptr self, unsigned int delay)

histogram_sink_f_sptr.disable_legend(histogram_sink_f_sptr self)

histogram_sink_f_sptr.enable_accumulate(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_autoscale(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_axis_labels(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_grid(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_menu(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_semilogx(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.enable_semilogy(histogram_sink_f_sptr self, bool en=True)

histogram_sink_f_sptr.exec_(histogram_sink_f_sptr self)

histogram_sink_f_sptr.line_alpha(histogram_sink_f_sptr self, int which) → double

histogram_sink_f_sptr.line_color(histogram_sink_f_sptr self, int which) → std::string

histogram_sink_f_sptr.line_label(histogram_sink_f_sptr self, int which) → std::string

histogram_sink_f_sptr.line_marker(histogram_sink_f_sptr self, int which) → int

histogram_sink_f_sptr.line_style(histogram_sink_f_sptr self, int which) → int

histogram_sink_f_sptr.line_width(histogram_sink_f_sptr self, int which) → int

histogram_sink_f_sptr.message_subscribers(histogram_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

histogram_sink_f_sptr.min_noutput_items(histogram_sink_f_sptr self) → int

histogram_sink_f_sptr.nsamps(histogram_sink_f_sptr self) → int

histogram_sink_f_sptr.pc_input_buffers_full_avg(histogram_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(histogram_sink_f_sptr self) -> pmt_vector_float

histogram_sink_f_sptr.pc_noutput_items_avg(histogram_sink_f_sptr self) → float

histogram_sink_f_sptr.pc_nproduced_avg(histogram_sink_f_sptr self) → float

histogram_sink_f_sptr.pc_output_buffers_full_avg(histogram_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(histogram_sink_f_sptr self) -> pmt_vector_float

histogram_sink_f_sptr.pc_throughput_avg(histogram_sink_f_sptr self) → float

histogram_sink_f_sptr.pc_work_time_avg(histogram_sink_f_sptr self) → float

histogram_sink_f_sptr.pc_work_time_total(histogram_sink_f_sptr self) → float

histogram_sink_f_sptr.pyqwidget(histogram_sink_f_sptr self) → PyObject *

histogram_sink_f_sptr.qwidget(histogram_sink_f_sptr self) → QWidget *

histogram_sink_f_sptr.reset(histogram_sink_f_sptr self)

histogram_sink_f_sptr.sample_delay(histogram_sink_f_sptr self, int which) → unsigned int

histogram_sink_f_sptr.set_bins(histogram_sink_f_sptr self, int const bins)

histogram_sink_f_sptr.set_line_alpha(histogram_sink_f_sptr self, int which, double alpha)

histogram_sink_f_sptr.set_line_color(histogram_sink_f_sptr self, int which, std::string const & color)

histogram_sink_f_sptr.set_line_label(histogram_sink_f_sptr self, int which, std::string const & line)

histogram_sink_f_sptr.set_line_marker(histogram_sink_f_sptr self, int which, int marker)

histogram_sink_f_sptr.set_line_style(histogram_sink_f_sptr self, int which, int style)

histogram_sink_f_sptr.set_line_width(histogram_sink_f_sptr self, int which, int width)

histogram_sink_f_sptr.set_min_noutput_items(histogram_sink_f_sptr self, int m)

histogram_sink_f_sptr.set_nsamps(histogram_sink_f_sptr self, int const newsize)

histogram_sink_f_sptr.set_size(histogram_sink_f_sptr self, int width, int height)

histogram_sink_f_sptr.set_thread_priority(histogram_sink_f_sptr self, int priority) → int

histogram_sink_f_sptr.set_title(histogram_sink_f_sptr self, std::string const & title)

histogram_sink_f_sptr.set_update_time(histogram_sink_f_sptr self, double t)

histogram_sink_f_sptr.set_x_axis(histogram_sink_f_sptr self, double min, double max)

histogram_sink_f_sptr.set_y_axis(histogram_sink_f_sptr self, double min, double max)

histogram_sink_f_sptr.thread_priority(histogram_sink_f_sptr self) → int

histogram_sink_f_sptr.title(histogram_sink_f_sptr self) → std::string

gnuradio.qtgui.number_sink(size_t itemsize, float average=0, gr::qtgui::graph_t graph_type=NUM_GRAPH_HORIZ, int nconnections=1, QWidget * parent=None) → number_sink_sptr

number_sink_sptr.active_thread_priority(number_sink_sptr self) → int

number_sink_sptr.average(number_sink_sptr self) → float

number_sink_sptr.color_max(number_sink_sptr self, int which) → std::string

number_sink_sptr.color_min(number_sink_sptr self, int which) → std::string

number_sink_sptr.d_qApplication(number_sink_sptr self) → QApplication *

number_sink_sptr.declare_sample_delay(number_sink_sptr self, int which, int delay)

declare_sample_delay(number_sink_sptr self, unsigned int delay)

number_sink_sptr.enable_autoscale(number_sink_sptr self, bool en=True)

number_sink_sptr.enable_menu(number_sink_sptr self, bool en=True)

number_sink_sptr.exec_(number_sink_sptr self)

number_sink_sptr.factor(number_sink_sptr self, int which) → float

number_sink_sptr.graph_type(number_sink_sptr self) → gr::qtgui::graph_t

number_sink_sptr.label(number_sink_sptr self, int which) → std::string

number_sink_sptr.max(number_sink_sptr self, int which) → float

number_sink_sptr.message_subscribers(number_sink_sptr self, swig_int_ptr which_port) → swig_int_ptr

number_sink_sptr.min(number_sink_sptr self, int which) → float

number_sink_sptr.min_noutput_items(number_sink_sptr self) → int

number_sink_sptr.pc_input_buffers_full_avg(number_sink_sptr self, int which) → float

pc_input_buffers_full_avg(number_sink_sptr self) -> pmt_vector_float

number_sink_sptr.pc_noutput_items_avg(number_sink_sptr self) → float

number_sink_sptr.pc_nproduced_avg(number_sink_sptr self) → float

number_sink_sptr.pc_output_buffers_full_avg(number_sink_sptr self, int which) → float

pc_output_buffers_full_avg(number_sink_sptr self) -> pmt_vector_float

number_sink_sptr.pc_throughput_avg(number_sink_sptr self) → float

number_sink_sptr.pc_work_time_avg(number_sink_sptr self) → float

number_sink_sptr.pc_work_time_total(number_sink_sptr self) → float

number_sink_sptr.pyqwidget(number_sink_sptr self) → PyObject *

number_sink_sptr.qwidget(number_sink_sptr self) → QWidget *

number_sink_sptr.reset(number_sink_sptr self)

number_sink_sptr.sample_delay(number_sink_sptr self, int which) → unsigned int

number_sink_sptr.set_average(number_sink_sptr self, float const avg)

number_sink_sptr.set_color(number_sink_sptr self, int which, std::string const & min, std::string const & max)

set_color(number_sink_sptr self, int which, int min, int max)

number_sink_sptr.set_factor(number_sink_sptr self, int which, float factor)

number_sink_sptr.set_graph_type(number_sink_sptr self, gr::qtgui::graph_t const type)

number_sink_sptr.set_label(number_sink_sptr self, int which, std::string const & label)

number_sink_sptr.set_max(number_sink_sptr self, int which, float max)

number_sink_sptr.set_min(number_sink_sptr self, int which, float min)

number_sink_sptr.set_min_noutput_items(number_sink_sptr self, int m)

number_sink_sptr.set_thread_priority(number_sink_sptr self, int priority) → int

number_sink_sptr.set_title(number_sink_sptr self, std::string const & title)

number_sink_sptr.set_unit(number_sink_sptr self, int which, std::string const & unit)

number_sink_sptr.set_update_time(number_sink_sptr self, double t)

number_sink_sptr.thread_priority(number_sink_sptr self) → int

number_sink_sptr.title(number_sink_sptr self) → std::string

number_sink_sptr.unit(number_sink_sptr self, int which) → std::string

gnuradio.qtgui.sink_c(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) → sink_c_sptr

sink_c_sptr.active_thread_priority(sink_c_sptr self) → int

sink_c_sptr.d_qApplication(sink_c_sptr self) → QApplication *

sink_c_sptr.declare_sample_delay(sink_c_sptr self, int which, int delay)

declare_sample_delay(sink_c_sptr self, unsigned int delay)

sink_c_sptr.enable_rf_freq(sink_c_sptr self, bool en)

sink_c_sptr.exec_(sink_c_sptr self)

sink_c_sptr.fft_size(sink_c_sptr self) → int

sink_c_sptr.message_subscribers(sink_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

sink_c_sptr.min_noutput_items(sink_c_sptr self) → int

sink_c_sptr.pc_input_buffers_full_avg(sink_c_sptr self, int which) → float

pc_input_buffers_full_avg(sink_c_sptr self) -> pmt_vector_float

sink_c_sptr.pc_noutput_items_avg(sink_c_sptr self) → float

sink_c_sptr.pc_nproduced_avg(sink_c_sptr self) → float

sink_c_sptr.pc_output_buffers_full_avg(sink_c_sptr self, int which) → float

pc_output_buffers_full_avg(sink_c_sptr self) -> pmt_vector_float

sink_c_sptr.pc_throughput_avg(sink_c_sptr self) → float

sink_c_sptr.pc_work_time_avg(sink_c_sptr self) → float

sink_c_sptr.pc_work_time_total(sink_c_sptr self) → float

sink_c_sptr.pyqwidget(sink_c_sptr self) → PyObject *

sink_c_sptr.qwidget(sink_c_sptr self) → QWidget *

sink_c_sptr.sample_delay(sink_c_sptr self, int which) → unsigned int

sink_c_sptr.set_fft_power_db(sink_c_sptr self, double min, double max)

sink_c_sptr.set_fft_size(sink_c_sptr self, int const fftsize)

sink_c_sptr.set_frequency_range(sink_c_sptr self, double const centerfreq, double const bandwidth)

sink_c_sptr.set_min_noutput_items(sink_c_sptr self, int m)

sink_c_sptr.set_thread_priority(sink_c_sptr self, int priority) → int

sink_c_sptr.set_update_time(sink_c_sptr self, double t)

sink_c_sptr.thread_priority(sink_c_sptr self) → int

gnuradio.qtgui.sink_f(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) → sink_f_sptr

sink_f_sptr.active_thread_priority(sink_f_sptr self) → int

sink_f_sptr.d_qApplication(sink_f_sptr self) → QApplication *

sink_f_sptr.declare_sample_delay(sink_f_sptr self, int which, int delay)

declare_sample_delay(sink_f_sptr self, unsigned int delay)

sink_f_sptr.enable_rf_freq(sink_f_sptr self, bool en)

sink_f_sptr.exec_(sink_f_sptr self)

sink_f_sptr.fft_size(sink_f_sptr self) → int

sink_f_sptr.message_subscribers(sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

sink_f_sptr.min_noutput_items(sink_f_sptr self) → int

sink_f_sptr.pc_input_buffers_full_avg(sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(sink_f_sptr self) -> pmt_vector_float

sink_f_sptr.pc_noutput_items_avg(sink_f_sptr self) → float

sink_f_sptr.pc_nproduced_avg(sink_f_sptr self) → float

sink_f_sptr.pc_output_buffers_full_avg(sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(sink_f_sptr self) -> pmt_vector_float

sink_f_sptr.pc_throughput_avg(sink_f_sptr self) → float

sink_f_sptr.pc_work_time_avg(sink_f_sptr self) → float

sink_f_sptr.pc_work_time_total(sink_f_sptr self) → float

sink_f_sptr.pyqwidget(sink_f_sptr self) → PyObject *

sink_f_sptr.qwidget(sink_f_sptr self) → QWidget *

sink_f_sptr.sample_delay(sink_f_sptr self, int which) → unsigned int

sink_f_sptr.set_fft_power_db(sink_f_sptr self, double min, double max)

sink_f_sptr.set_fft_size(sink_f_sptr self, int const fftsize)

sink_f_sptr.set_frequency_range(sink_f_sptr self, double const centerfreq, double const bandwidth)

sink_f_sptr.set_min_noutput_items(sink_f_sptr self, int m)

sink_f_sptr.set_thread_priority(sink_f_sptr self, int priority) → int

sink_f_sptr.set_update_time(sink_f_sptr self, double t)

sink_f_sptr.thread_priority(sink_f_sptr self) → int

gnuradio.qtgui.time_raster_sink_b(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) → time_raster_sink_b_sptr

time_raster_sink_b_sptr.active_thread_priority(time_raster_sink_b_sptr self) → int

time_raster_sink_b_sptr.color_map(time_raster_sink_b_sptr self, int which) → int

time_raster_sink_b_sptr.d_qApplication(time_raster_sink_b_sptr self) → QApplication *

time_raster_sink_b_sptr.declare_sample_delay(time_raster_sink_b_sptr self, int which, int delay)

declare_sample_delay(time_raster_sink_b_sptr self, unsigned int delay)

time_raster_sink_b_sptr.enable_autoscale(time_raster_sink_b_sptr self, bool en)

time_raster_sink_b_sptr.enable_axis_labels(time_raster_sink_b_sptr self, bool en=True)

time_raster_sink_b_sptr.enable_grid(time_raster_sink_b_sptr self, bool en)

time_raster_sink_b_sptr.enable_menu(time_raster_sink_b_sptr self, bool en)

time_raster_sink_b_sptr.exec_(time_raster_sink_b_sptr self)

time_raster_sink_b_sptr.line_alpha(time_raster_sink_b_sptr self, int which) → double

time_raster_sink_b_sptr.line_color(time_raster_sink_b_sptr self, int which) → std::string

time_raster_sink_b_sptr.line_label(time_raster_sink_b_sptr self, int which) → std::string

time_raster_sink_b_sptr.line_marker(time_raster_sink_b_sptr self, int which) → int

time_raster_sink_b_sptr.line_style(time_raster_sink_b_sptr self, int which) → int

time_raster_sink_b_sptr.line_width(time_raster_sink_b_sptr self, int which) → int

time_raster_sink_b_sptr.message_subscribers(time_raster_sink_b_sptr self, swig_int_ptr which_port) → swig_int_ptr

time_raster_sink_b_sptr.min_noutput_items(time_raster_sink_b_sptr self) → int

time_raster_sink_b_sptr.num_cols(time_raster_sink_b_sptr self) → double

time_raster_sink_b_sptr.num_rows(time_raster_sink_b_sptr self) → double

time_raster_sink_b_sptr.pc_input_buffers_full_avg(time_raster_sink_b_sptr self, int which) → float

pc_input_buffers_full_avg(time_raster_sink_b_sptr self) -> pmt_vector_float

time_raster_sink_b_sptr.pc_noutput_items_avg(time_raster_sink_b_sptr self) → float

time_raster_sink_b_sptr.pc_nproduced_avg(time_raster_sink_b_sptr self) → float

time_raster_sink_b_sptr.pc_output_buffers_full_avg(time_raster_sink_b_sptr self, int which) → float

pc_output_buffers_full_avg(time_raster_sink_b_sptr self) -> pmt_vector_float

time_raster_sink_b_sptr.pc_throughput_avg(time_raster_sink_b_sptr self) → float

time_raster_sink_b_sptr.pc_work_time_avg(time_raster_sink_b_sptr self) → float

time_raster_sink_b_sptr.pc_work_time_total(time_raster_sink_b_sptr self) → float

time_raster_sink_b_sptr.pyqwidget(time_raster_sink_b_sptr self) → PyObject *

time_raster_sink_b_sptr.qwidget(time_raster_sink_b_sptr self) → QWidget *

time_raster_sink_b_sptr.reset(time_raster_sink_b_sptr self)

time_raster_sink_b_sptr.sample_delay(time_raster_sink_b_sptr self, int which) → unsigned int

time_raster_sink_b_sptr.set_color_map(time_raster_sink_b_sptr self, int which, int const color)

time_raster_sink_b_sptr.set_intensity_range(time_raster_sink_b_sptr self, float min, float max)

time_raster_sink_b_sptr.set_line_alpha(time_raster_sink_b_sptr self, int which, double alpha)

time_raster_sink_b_sptr.set_line_color(time_raster_sink_b_sptr self, int which, std::string const & color)

time_raster_sink_b_sptr.set_line_label(time_raster_sink_b_sptr self, int which, std::string const & lable)

time_raster_sink_b_sptr.set_line_marker(time_raster_sink_b_sptr self, int which, QwtSymbol::Style marker)

time_raster_sink_b_sptr.set_line_style(time_raster_sink_b_sptr self, int which, Qt::PenStyle style)

time_raster_sink_b_sptr.set_line_width(time_raster_sink_b_sptr self, int which, int width)

time_raster_sink_b_sptr.set_min_noutput_items(time_raster_sink_b_sptr self, int m)

time_raster_sink_b_sptr.set_multiplier(time_raster_sink_b_sptr self, pmt_vector_float mult)

time_raster_sink_b_sptr.set_num_cols(time_raster_sink_b_sptr self, double cols)

time_raster_sink_b_sptr.set_num_rows(time_raster_sink_b_sptr self, double rows)

time_raster_sink_b_sptr.set_offset(time_raster_sink_b_sptr self, pmt_vector_float offset)

time_raster_sink_b_sptr.set_samp_rate(time_raster_sink_b_sptr self, double const samp_rate)

time_raster_sink_b_sptr.set_size(time_raster_sink_b_sptr self, int width, int height)

time_raster_sink_b_sptr.set_thread_priority(time_raster_sink_b_sptr self, int priority) → int

time_raster_sink_b_sptr.set_title(time_raster_sink_b_sptr self, std::string const & title)

time_raster_sink_b_sptr.set_update_time(time_raster_sink_b_sptr self, double t)

time_raster_sink_b_sptr.thread_priority(time_raster_sink_b_sptr self) → int

time_raster_sink_b_sptr.title(time_raster_sink_b_sptr self) → std::string

gnuradio.qtgui.time_raster_sink_f(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) → time_raster_sink_f_sptr

time_raster_sink_f_sptr.active_thread_priority(time_raster_sink_f_sptr self) → int

time_raster_sink_f_sptr.color_map(time_raster_sink_f_sptr self, int which) → int

time_raster_sink_f_sptr.d_qApplication(time_raster_sink_f_sptr self) → QApplication *

time_raster_sink_f_sptr.declare_sample_delay(time_raster_sink_f_sptr self, int which, int delay)

declare_sample_delay(time_raster_sink_f_sptr self, unsigned int delay)

time_raster_sink_f_sptr.enable_autoscale(time_raster_sink_f_sptr self, bool en)

time_raster_sink_f_sptr.enable_axis_labels(time_raster_sink_f_sptr self, bool en=True)

time_raster_sink_f_sptr.enable_grid(time_raster_sink_f_sptr self, bool en)

time_raster_sink_f_sptr.enable_menu(time_raster_sink_f_sptr self, bool en)

time_raster_sink_f_sptr.exec_(time_raster_sink_f_sptr self)

time_raster_sink_f_sptr.line_alpha(time_raster_sink_f_sptr self, int which) → double

time_raster_sink_f_sptr.line_color(time_raster_sink_f_sptr self, int which) → std::string

time_raster_sink_f_sptr.line_label(time_raster_sink_f_sptr self, int which) → std::string

time_raster_sink_f_sptr.line_marker(time_raster_sink_f_sptr self, int which) → int

time_raster_sink_f_sptr.line_style(time_raster_sink_f_sptr self, int which) → int

time_raster_sink_f_sptr.line_width(time_raster_sink_f_sptr self, int which) → int

time_raster_sink_f_sptr.message_subscribers(time_raster_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

time_raster_sink_f_sptr.min_noutput_items(time_raster_sink_f_sptr self) → int

time_raster_sink_f_sptr.num_cols(time_raster_sink_f_sptr self) → double

time_raster_sink_f_sptr.num_rows(time_raster_sink_f_sptr self) → double

time_raster_sink_f_sptr.pc_input_buffers_full_avg(time_raster_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(time_raster_sink_f_sptr self) -> pmt_vector_float

time_raster_sink_f_sptr.pc_noutput_items_avg(time_raster_sink_f_sptr self) → float

time_raster_sink_f_sptr.pc_nproduced_avg(time_raster_sink_f_sptr self) → float

time_raster_sink_f_sptr.pc_output_buffers_full_avg(time_raster_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(time_raster_sink_f_sptr self) -> pmt_vector_float

time_raster_sink_f_sptr.pc_throughput_avg(time_raster_sink_f_sptr self) → float

time_raster_sink_f_sptr.pc_work_time_avg(time_raster_sink_f_sptr self) → float

time_raster_sink_f_sptr.pc_work_time_total(time_raster_sink_f_sptr self) → float

time_raster_sink_f_sptr.pyqwidget(time_raster_sink_f_sptr self) → PyObject *

time_raster_sink_f_sptr.qwidget(time_raster_sink_f_sptr self) → QWidget *

time_raster_sink_f_sptr.reset(time_raster_sink_f_sptr self)

time_raster_sink_f_sptr.sample_delay(time_raster_sink_f_sptr self, int which) → unsigned int

time_raster_sink_f_sptr.set_color_map(time_raster_sink_f_sptr self, int which, int const color)

time_raster_sink_f_sptr.set_intensity_range(time_raster_sink_f_sptr self, float min, float max)

time_raster_sink_f_sptr.set_line_alpha(time_raster_sink_f_sptr self, int which, double alpha)

time_raster_sink_f_sptr.set_line_color(time_raster_sink_f_sptr self, int which, std::string const & color)

time_raster_sink_f_sptr.set_line_label(time_raster_sink_f_sptr self, int which, std::string const & lable)

time_raster_sink_f_sptr.set_line_marker(time_raster_sink_f_sptr self, int which, QwtSymbol::Style marker)

time_raster_sink_f_sptr.set_line_style(time_raster_sink_f_sptr self, int which, Qt::PenStyle style)

time_raster_sink_f_sptr.set_line_width(time_raster_sink_f_sptr self, int which, int width)

time_raster_sink_f_sptr.set_min_noutput_items(time_raster_sink_f_sptr self, int m)

time_raster_sink_f_sptr.set_multiplier(time_raster_sink_f_sptr self, pmt_vector_float mult)

time_raster_sink_f_sptr.set_num_cols(time_raster_sink_f_sptr self, double cols)

time_raster_sink_f_sptr.set_num_rows(time_raster_sink_f_sptr self, double rows)

time_raster_sink_f_sptr.set_offset(time_raster_sink_f_sptr self, pmt_vector_float offset)

time_raster_sink_f_sptr.set_samp_rate(time_raster_sink_f_sptr self, double const samp_rate)

time_raster_sink_f_sptr.set_size(time_raster_sink_f_sptr self, int width, int height)

time_raster_sink_f_sptr.set_thread_priority(time_raster_sink_f_sptr self, int priority) → int

time_raster_sink_f_sptr.set_title(time_raster_sink_f_sptr self, std::string const & title)

time_raster_sink_f_sptr.set_update_time(time_raster_sink_f_sptr self, double t)

time_raster_sink_f_sptr.thread_priority(time_raster_sink_f_sptr self) → int

time_raster_sink_f_sptr.title(time_raster_sink_f_sptr self) → std::string

gnuradio.qtgui.time_sink_c(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) → time_sink_c_sptr

time_sink_c_sptr.active_thread_priority(time_sink_c_sptr self) → int

time_sink_c_sptr.d_qApplication(time_sink_c_sptr self) → QApplication *

time_sink_c_sptr.declare_sample_delay(time_sink_c_sptr self, int which, int delay)

declare_sample_delay(time_sink_c_sptr self, unsigned int delay)

time_sink_c_sptr.disable_legend(time_sink_c_sptr self)

time_sink_c_sptr.enable_autoscale(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_axis_labels(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_control_panel(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_grid(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_menu(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_semilogx(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_semilogy(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_stem_plot(time_sink_c_sptr self, bool en=True)

time_sink_c_sptr.enable_tags(time_sink_c_sptr self, int which, bool en)

time_sink_c_sptr.exec_(time_sink_c_sptr self)

time_sink_c_sptr.line_alpha(time_sink_c_sptr self, int which) → double

time_sink_c_sptr.line_color(time_sink_c_sptr self, int which) → std::string

time_sink_c_sptr.line_label(time_sink_c_sptr self, int which) → std::string

time_sink_c_sptr.line_marker(time_sink_c_sptr self, int which) → int

time_sink_c_sptr.line_style(time_sink_c_sptr self, int which) → int

time_sink_c_sptr.line_width(time_sink_c_sptr self, int which) → int

time_sink_c_sptr.message_subscribers(time_sink_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

time_sink_c_sptr.min_noutput_items(time_sink_c_sptr self) → int

time_sink_c_sptr.nsamps(time_sink_c_sptr self) → int

time_sink_c_sptr.pc_input_buffers_full_avg(time_sink_c_sptr self, int which) → float

pc_input_buffers_full_avg(time_sink_c_sptr self) -> pmt_vector_float

time_sink_c_sptr.pc_noutput_items_avg(time_sink_c_sptr self) → float

time_sink_c_sptr.pc_nproduced_avg(time_sink_c_sptr self) → float

time_sink_c_sptr.pc_output_buffers_full_avg(time_sink_c_sptr self, int which) → float

pc_output_buffers_full_avg(time_sink_c_sptr self) -> pmt_vector_float

time_sink_c_sptr.pc_throughput_avg(time_sink_c_sptr self) → float

time_sink_c_sptr.pc_work_time_avg(time_sink_c_sptr self) → float

time_sink_c_sptr.pc_work_time_total(time_sink_c_sptr self) → float

time_sink_c_sptr.pyqwidget(time_sink_c_sptr self) → PyObject *

time_sink_c_sptr.qwidget(time_sink_c_sptr self) → QWidget *

time_sink_c_sptr.reset(time_sink_c_sptr self)

time_sink_c_sptr.sample_delay(time_sink_c_sptr self, int which) → unsigned int

time_sink_c_sptr.set_line_alpha(time_sink_c_sptr self, int which, double alpha)

time_sink_c_sptr.set_line_color(time_sink_c_sptr self, int which, std::string const & color)

time_sink_c_sptr.set_line_label(time_sink_c_sptr self, int which, std::string const & label)

time_sink_c_sptr.set_line_marker(time_sink_c_sptr self, int which, int marker)

time_sink_c_sptr.set_line_style(time_sink_c_sptr self, int which, int style)

time_sink_c_sptr.set_line_width(time_sink_c_sptr self, int which, int width)

time_sink_c_sptr.set_min_noutput_items(time_sink_c_sptr self, int m)

time_sink_c_sptr.set_nsamps(time_sink_c_sptr self, int const newsize)

time_sink_c_sptr.set_samp_rate(time_sink_c_sptr self, double const samp_rate)

time_sink_c_sptr.set_size(time_sink_c_sptr self, int width, int height)

time_sink_c_sptr.set_thread_priority(time_sink_c_sptr self, int priority) → int

time_sink_c_sptr.set_title(time_sink_c_sptr self, std::string const & title)

time_sink_c_sptr.set_trigger_mode(*args, **kwargs)

set_trigger_mode(time_sink_c_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key=””)

time_sink_c_sptr.set_update_time(time_sink_c_sptr self, double t)

time_sink_c_sptr.set_y_axis(time_sink_c_sptr self, double min, double max)

time_sink_c_sptr.set_y_label(time_sink_c_sptr self, std::string const & label, std::string const & unit="")

time_sink_c_sptr.thread_priority(time_sink_c_sptr self) → int

time_sink_c_sptr.title(time_sink_c_sptr self) → std::string

gnuradio.qtgui.time_sink_f(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) → time_sink_f_sptr

time_sink_f_sptr.active_thread_priority(time_sink_f_sptr self) → int

time_sink_f_sptr.d_qApplication(time_sink_f_sptr self) → QApplication *

time_sink_f_sptr.declare_sample_delay(time_sink_f_sptr self, int which, int delay)

declare_sample_delay(time_sink_f_sptr self, unsigned int delay)

time_sink_f_sptr.disable_legend(time_sink_f_sptr self)

time_sink_f_sptr.enable_autoscale(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_axis_labels(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_control_panel(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_grid(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_menu(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_semilogx(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_semilogy(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_stem_plot(time_sink_f_sptr self, bool en=True)

time_sink_f_sptr.enable_tags(time_sink_f_sptr self, int which, bool en)

time_sink_f_sptr.exec_(time_sink_f_sptr self)

time_sink_f_sptr.line_alpha(time_sink_f_sptr self, int which) → double

time_sink_f_sptr.line_color(time_sink_f_sptr self, int which) → std::string

time_sink_f_sptr.line_label(time_sink_f_sptr self, int which) → std::string

time_sink_f_sptr.line_marker(time_sink_f_sptr self, int which) → int

time_sink_f_sptr.line_style(time_sink_f_sptr self, int which) → int

time_sink_f_sptr.line_width(time_sink_f_sptr self, int which) → int

time_sink_f_sptr.message_subscribers(time_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

time_sink_f_sptr.min_noutput_items(time_sink_f_sptr self) → int

time_sink_f_sptr.nsamps(time_sink_f_sptr self) → int

time_sink_f_sptr.pc_input_buffers_full_avg(time_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(time_sink_f_sptr self) -> pmt_vector_float

time_sink_f_sptr.pc_noutput_items_avg(time_sink_f_sptr self) → float

time_sink_f_sptr.pc_nproduced_avg(time_sink_f_sptr self) → float

time_sink_f_sptr.pc_output_buffers_full_avg(time_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(time_sink_f_sptr self) -> pmt_vector_float

time_sink_f_sptr.pc_throughput_avg(time_sink_f_sptr self) → float

time_sink_f_sptr.pc_work_time_avg(time_sink_f_sptr self) → float

time_sink_f_sptr.pc_work_time_total(time_sink_f_sptr self) → float

time_sink_f_sptr.pyqwidget(time_sink_f_sptr self) → PyObject *

time_sink_f_sptr.qwidget(time_sink_f_sptr self) → QWidget *

time_sink_f_sptr.reset(time_sink_f_sptr self)

time_sink_f_sptr.sample_delay(time_sink_f_sptr self, int which) → unsigned int

time_sink_f_sptr.set_line_alpha(time_sink_f_sptr self, int which, double alpha)

time_sink_f_sptr.set_line_color(time_sink_f_sptr self, int which, std::string const & color)

time_sink_f_sptr.set_line_label(time_sink_f_sptr self, int which, std::string const & line)

time_sink_f_sptr.set_line_marker(time_sink_f_sptr self, int which, int marker)

time_sink_f_sptr.set_line_style(time_sink_f_sptr self, int which, int style)

time_sink_f_sptr.set_line_width(time_sink_f_sptr self, int which, int width)

time_sink_f_sptr.set_min_noutput_items(time_sink_f_sptr self, int m)

time_sink_f_sptr.set_nsamps(time_sink_f_sptr self, int const newsize)

time_sink_f_sptr.set_samp_rate(time_sink_f_sptr self, double const samp_rate)

time_sink_f_sptr.set_size(time_sink_f_sptr self, int width, int height)

time_sink_f_sptr.set_thread_priority(time_sink_f_sptr self, int priority) → int

time_sink_f_sptr.set_title(time_sink_f_sptr self, std::string const & title)

time_sink_f_sptr.set_trigger_mode(*args, **kwargs)

set_trigger_mode(time_sink_f_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key=””)

time_sink_f_sptr.set_update_time(time_sink_f_sptr self, double t)

time_sink_f_sptr.set_y_axis(time_sink_f_sptr self, double min, double max)

time_sink_f_sptr.set_y_label(time_sink_f_sptr self, std::string const & label, std::string const & unit="")

time_sink_f_sptr.thread_priority(time_sink_f_sptr self) → int

time_sink_f_sptr.title(time_sink_f_sptr self) → std::string

gnuradio.qtgui.vector_sink_f(int vlen, double x_start, double x_step, std::string const & x_axis_label, std::string const & y_axis_label, std::string const & name, int nconnections=1, QWidget * parent=None) → vector_sink_f_sptr

vector_sink_f_sptr.active_thread_priority(vector_sink_f_sptr self) → int

vector_sink_f_sptr.clear_max_hold(vector_sink_f_sptr self)

vector_sink_f_sptr.clear_min_hold(vector_sink_f_sptr self)

vector_sink_f_sptr.d_qApplication(vector_sink_f_sptr self) → QApplication *

vector_sink_f_sptr.declare_sample_delay(vector_sink_f_sptr self, int which, int delay)

declare_sample_delay(vector_sink_f_sptr self, unsigned int delay)

vector_sink_f_sptr.enable_autoscale(vector_sink_f_sptr self, bool en=True)

vector_sink_f_sptr.enable_grid(vector_sink_f_sptr self, bool en=True)

vector_sink_f_sptr.enable_menu(vector_sink_f_sptr self, bool en=True)

vector_sink_f_sptr.exec_(vector_sink_f_sptr self)

vector_sink_f_sptr.line_alpha(vector_sink_f_sptr self, int which) → double

vector_sink_f_sptr.line_color(vector_sink_f_sptr self, int which) → std::string

vector_sink_f_sptr.line_label(vector_sink_f_sptr self, int which) → std::string

vector_sink_f_sptr.line_marker(vector_sink_f_sptr self, int which) → int

vector_sink_f_sptr.line_style(vector_sink_f_sptr self, int which) → int

vector_sink_f_sptr.line_width(vector_sink_f_sptr self, int which) → int

vector_sink_f_sptr.message_subscribers(vector_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

vector_sink_f_sptr.min_noutput_items(vector_sink_f_sptr self) → int

vector_sink_f_sptr.pc_input_buffers_full_avg(vector_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

vector_sink_f_sptr.pc_noutput_items_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_nproduced_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_output_buffers_full_avg(vector_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float

vector_sink_f_sptr.pc_throughput_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_work_time_avg(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pc_work_time_total(vector_sink_f_sptr self) → float

vector_sink_f_sptr.pyqwidget(vector_sink_f_sptr self) → PyObject *

vector_sink_f_sptr.qwidget(vector_sink_f_sptr self) → QWidget *

vector_sink_f_sptr.reset(vector_sink_f_sptr self)

vector_sink_f_sptr.sample_delay(vector_sink_f_sptr self, int which) → unsigned int

vector_sink_f_sptr.set_line_alpha(vector_sink_f_sptr self, int which, double alpha)

vector_sink_f_sptr.set_line_color(vector_sink_f_sptr self, int which, std::string const & color)

vector_sink_f_sptr.set_line_label(vector_sink_f_sptr self, int which, std::string const & label)

vector_sink_f_sptr.set_line_marker(vector_sink_f_sptr self, int which, int marker)

vector_sink_f_sptr.set_line_style(vector_sink_f_sptr self, int which, int style)

vector_sink_f_sptr.set_line_width(vector_sink_f_sptr self, int which, int width)

vector_sink_f_sptr.set_min_noutput_items(vector_sink_f_sptr self, int m)

vector_sink_f_sptr.set_ref_level(vector_sink_f_sptr self, double ref_level)

vector_sink_f_sptr.set_size(vector_sink_f_sptr self, int width, int height)

vector_sink_f_sptr.set_thread_priority(vector_sink_f_sptr self, int priority) → int

vector_sink_f_sptr.set_title(vector_sink_f_sptr self, std::string const & title)

vector_sink_f_sptr.set_update_time(vector_sink_f_sptr self, double t)

vector_sink_f_sptr.set_vec_average(vector_sink_f_sptr self, float const avg)

vector_sink_f_sptr.set_x_axis(vector_sink_f_sptr self, double const start, double const step)

vector_sink_f_sptr.set_x_axis_label(vector_sink_f_sptr self, std::string const & label)

vector_sink_f_sptr.set_x_axis_units(vector_sink_f_sptr self, std::string const & units)

vector_sink_f_sptr.set_y_axis(vector_sink_f_sptr self, double min, double max)

vector_sink_f_sptr.set_y_axis_label(vector_sink_f_sptr self, std::string const & label)

vector_sink_f_sptr.set_y_axis_units(vector_sink_f_sptr self, std::string const & units)

vector_sink_f_sptr.thread_priority(vector_sink_f_sptr self) → int

vector_sink_f_sptr.title(vector_sink_f_sptr self) → std::string

vector_sink_f_sptr.vec_average(vector_sink_f_sptr self) → float

vector_sink_f_sptr.vlen(vector_sink_f_sptr self) → int

gnuradio.qtgui.waterfall_sink_c(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) → waterfall_sink_c_sptr

waterfall_sink_c_sptr.active_thread_priority(waterfall_sink_c_sptr self) → int

waterfall_sink_c_sptr.auto_scale(waterfall_sink_c_sptr self)

waterfall_sink_c_sptr.clear_data(waterfall_sink_c_sptr self)

waterfall_sink_c_sptr.color_map(waterfall_sink_c_sptr self, int which) → int

waterfall_sink_c_sptr.d_qApplication(waterfall_sink_c_sptr self) → QApplication *

waterfall_sink_c_sptr.declare_sample_delay(waterfall_sink_c_sptr self, int which, int delay)

declare_sample_delay(waterfall_sink_c_sptr self, unsigned int delay)

waterfall_sink_c_sptr.disable_legend(waterfall_sink_c_sptr self)

waterfall_sink_c_sptr.enable_axis_labels(waterfall_sink_c_sptr self, bool en=True)

waterfall_sink_c_sptr.enable_grid(waterfall_sink_c_sptr self, bool en=True)

waterfall_sink_c_sptr.enable_menu(waterfall_sink_c_sptr self, bool en=True)

waterfall_sink_c_sptr.exec_(waterfall_sink_c_sptr self)

waterfall_sink_c_sptr.fft_average(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.fft_size(waterfall_sink_c_sptr self) → int

waterfall_sink_c_sptr.fft_window(waterfall_sink_c_sptr self) → gr::filter::firdes::win_type

waterfall_sink_c_sptr.line_alpha(waterfall_sink_c_sptr self, int which) → double

waterfall_sink_c_sptr.line_label(waterfall_sink_c_sptr self, int which) → std::string

waterfall_sink_c_sptr.max_intensity(waterfall_sink_c_sptr self, int which) → double

waterfall_sink_c_sptr.message_subscribers(waterfall_sink_c_sptr self, swig_int_ptr which_port) → swig_int_ptr

waterfall_sink_c_sptr.min_intensity(waterfall_sink_c_sptr self, int which) → double

waterfall_sink_c_sptr.min_noutput_items(waterfall_sink_c_sptr self) → int

waterfall_sink_c_sptr.pc_input_buffers_full_avg(waterfall_sink_c_sptr self, int which) → float

pc_input_buffers_full_avg(waterfall_sink_c_sptr self) -> pmt_vector_float

waterfall_sink_c_sptr.pc_noutput_items_avg(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.pc_nproduced_avg(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.pc_output_buffers_full_avg(waterfall_sink_c_sptr self, int which) → float

pc_output_buffers_full_avg(waterfall_sink_c_sptr self) -> pmt_vector_float

waterfall_sink_c_sptr.pc_throughput_avg(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.pc_work_time_avg(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.pc_work_time_total(waterfall_sink_c_sptr self) → float

waterfall_sink_c_sptr.pyqwidget(waterfall_sink_c_sptr self) → PyObject *

waterfall_sink_c_sptr.qwidget(waterfall_sink_c_sptr self) → QWidget *

waterfall_sink_c_sptr.sample_delay(waterfall_sink_c_sptr self, int which) → unsigned int

waterfall_sink_c_sptr.set_color_map(waterfall_sink_c_sptr self, int which, int const color)

waterfall_sink_c_sptr.set_fft_average(waterfall_sink_c_sptr self, float const fftavg)

waterfall_sink_c_sptr.set_fft_size(waterfall_sink_c_sptr self, int const fftsize)

waterfall_sink_c_sptr.set_fft_window(waterfall_sink_c_sptr self, gr::filter::firdes::win_type const win)

waterfall_sink_c_sptr.set_frequency_range(waterfall_sink_c_sptr self, double const centerfreq, double const bandwidth)

waterfall_sink_c_sptr.set_intensity_range(waterfall_sink_c_sptr self, double const min, double const max)

waterfall_sink_c_sptr.set_line_alpha(waterfall_sink_c_sptr self, int which, double alpha)

waterfall_sink_c_sptr.set_line_label(waterfall_sink_c_sptr self, int which, std::string const & line)

waterfall_sink_c_sptr.set_min_noutput_items(waterfall_sink_c_sptr self, int m)

waterfall_sink_c_sptr.set_size(waterfall_sink_c_sptr self, int width, int height)

waterfall_sink_c_sptr.set_thread_priority(waterfall_sink_c_sptr self, int priority) → int

waterfall_sink_c_sptr.set_time_per_fft(waterfall_sink_c_sptr self, double const t)

waterfall_sink_c_sptr.set_time_title(waterfall_sink_c_sptr self, std::string const & title)

waterfall_sink_c_sptr.set_title(waterfall_sink_c_sptr self, std::string const & title)

waterfall_sink_c_sptr.set_update_time(waterfall_sink_c_sptr self, double t)

waterfall_sink_c_sptr.thread_priority(waterfall_sink_c_sptr self) → int

waterfall_sink_c_sptr.title(waterfall_sink_c_sptr self) → std::string

gnuradio.qtgui.waterfall_sink_f(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) → waterfall_sink_f_sptr

waterfall_sink_f_sptr.active_thread_priority(waterfall_sink_f_sptr self) → int

waterfall_sink_f_sptr.auto_scale(waterfall_sink_f_sptr self)

waterfall_sink_f_sptr.clear_data(waterfall_sink_f_sptr self)

waterfall_sink_f_sptr.color_map(waterfall_sink_f_sptr self, int which) → int

waterfall_sink_f_sptr.d_qApplication(waterfall_sink_f_sptr self) → QApplication *

waterfall_sink_f_sptr.declare_sample_delay(waterfall_sink_f_sptr self, int which, int delay)

declare_sample_delay(waterfall_sink_f_sptr self, unsigned int delay)

waterfall_sink_f_sptr.disable_legend(waterfall_sink_f_sptr self)

waterfall_sink_f_sptr.enable_axis_labels(waterfall_sink_f_sptr self, bool en=True)

waterfall_sink_f_sptr.enable_grid(waterfall_sink_f_sptr self, bool en=True)

waterfall_sink_f_sptr.enable_menu(waterfall_sink_f_sptr self, bool en=True)

waterfall_sink_f_sptr.exec_(waterfall_sink_f_sptr self)

waterfall_sink_f_sptr.fft_average(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.fft_size(waterfall_sink_f_sptr self) → int

waterfall_sink_f_sptr.fft_window(waterfall_sink_f_sptr self) → gr::filter::firdes::win_type

waterfall_sink_f_sptr.line_alpha(waterfall_sink_f_sptr self, int which) → double

waterfall_sink_f_sptr.line_label(waterfall_sink_f_sptr self, int which) → std::string

waterfall_sink_f_sptr.max_intensity(waterfall_sink_f_sptr self, int which) → double

waterfall_sink_f_sptr.message_subscribers(waterfall_sink_f_sptr self, swig_int_ptr which_port) → swig_int_ptr

waterfall_sink_f_sptr.min_intensity(waterfall_sink_f_sptr self, int which) → double

waterfall_sink_f_sptr.min_noutput_items(waterfall_sink_f_sptr self) → int

waterfall_sink_f_sptr.pc_input_buffers_full_avg(waterfall_sink_f_sptr self, int which) → float

pc_input_buffers_full_avg(waterfall_sink_f_sptr self) -> pmt_vector_float

waterfall_sink_f_sptr.pc_noutput_items_avg(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.pc_nproduced_avg(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.pc_output_buffers_full_avg(waterfall_sink_f_sptr self, int which) → float

pc_output_buffers_full_avg(waterfall_sink_f_sptr self) -> pmt_vector_float

waterfall_sink_f_sptr.pc_throughput_avg(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.pc_work_time_avg(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.pc_work_time_total(waterfall_sink_f_sptr self) → float

waterfall_sink_f_sptr.pyqwidget(waterfall_sink_f_sptr self) → PyObject *

waterfall_sink_f_sptr.qwidget(waterfall_sink_f_sptr self) → QWidget *

waterfall_sink_f_sptr.sample_delay(waterfall_sink_f_sptr self, int which) → unsigned int

waterfall_sink_f_sptr.set_color_map(waterfall_sink_f_sptr self, int which, int const color)

waterfall_sink_f_sptr.set_fft_average(waterfall_sink_f_sptr self, float const fftavg)

waterfall_sink_f_sptr.set_fft_size(waterfall_sink_f_sptr self, int const fftsize)

waterfall_sink_f_sptr.set_fft_window(waterfall_sink_f_sptr self, gr::filter::firdes::win_type const win)

waterfall_sink_f_sptr.set_frequency_range(waterfall_sink_f_sptr self, double const centerfreq, double const bandwidth)

waterfall_sink_f_sptr.set_intensity_range(waterfall_sink_f_sptr self, double const min, double const max)

waterfall_sink_f_sptr.set_line_alpha(waterfall_sink_f_sptr self, int which, double alpha)

waterfall_sink_f_sptr.set_line_label(waterfall_sink_f_sptr self, int which, std::string const & line)

waterfall_sink_f_sptr.set_min_noutput_items(waterfall_sink_f_sptr self, int m)

waterfall_sink_f_sptr.set_plot_pos_half(waterfall_sink_f_sptr self, bool half)

waterfall_sink_f_sptr.set_size(waterfall_sink_f_sptr self, int width, int height)

waterfall_sink_f_sptr.set_thread_priority(waterfall_sink_f_sptr self, int priority) → int

waterfall_sink_f_sptr.set_time_per_fft(waterfall_sink_f_sptr self, double const t)

waterfall_sink_f_sptr.set_time_title(waterfall_sink_f_sptr self, std::string const & title)

waterfall_sink_f_sptr.set_title(waterfall_sink_f_sptr self, std::string const & title)

waterfall_sink_f_sptr.set_update_time(waterfall_sink_f_sptr self, double t)

waterfall_sink_f_sptr.thread_priority(waterfall_sink_f_sptr self) → int

waterfall_sink_f_sptr.title(waterfall_sink_f_sptr self) → std::string