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

Previous topic

gnuradio.pager

Next topic

gnuradio.trellis

This Page