gnuradio.qtgui

Provides a GUI interface using the QT backend.

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

A graphical sink to display freq, spec, time, and const plots.

This is a QT-based graphical sink the takes a complex stream and plots it. The default action is to plot the signal as a PSD (FFT), spectrogram (waterfall), time domain I&Q, and constellation (I vs. Q) plots. The plots may be turned off by setting the appropriate boolean value in the constructor to False.

Constructor Specific Documentation:

Build a complex qtgui sink.

Parameters:

• fftsize – size of the FFT to compute and display
• wintype – type of window to apply (see gnuradio/filter/firdes.h)
• fc – center frequency of signal (use for x-axis labels)
• bw – bandwidth of signal (used to set x-axis labels)
• name – title for the plot
• plotfreq – Toggle frequency plot on/off
• plotwaterfall – Toggle waterfall plot on/off
• plottime – Toggle time plot on/off
• plotconst – Toggle constellation plot on/off
• parent – a QWidget parent object, if any

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.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_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.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

A graphical sink to display freq, spec, and time.

This is a QT-based graphical sink the takes a float stream and plots it. The default action is to plot the signal as a PSD (FFT), spectrogram (waterfall), and time domain plots. The plots may be turned off by setting the appropriate boolean value in the constructor to False.

Constructor Specific Documentation:

Build a floating point qtgui sink.

Parameters:

• fftsize – size of the FFT to compute and display
• wintype – type of window to apply (see gnuradio/filter/firdes.h)
• fc – center frequency of signal (use for x-axis labels)
• bw – bandwidth of signal (used to set x-axis labels)
• name – title for the plot
• plotfreq – Toggle frequency plot on/off
• plotwaterfall – Toggle waterfall plot on/off
• plottime – Toggle time plot on/off
• plotconst – Toggle constellation plot on/off
• parent – a QWidget parent object, if any

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.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_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.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_sink_c(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) → time_sink_c_sptr

A graphical sink to display multiple signals in time.

This is a QT-based graphical sink the takes set of a complex streams and plots them in the time domain. For each signal, both the signal’s I and Q parts are plotted, and they are all plotted with a different color, and the and functions can be used to change the lable and color for a given input number.

Constructor Specific Documentation:

Build complex time sink.

Parameters:

• size – number of points to plot at once
• samp_rate – sample rate (used to set x-axis labels)
• name – title for the plot
• nconnections – number of signals connected to sink
• parent – a QWidget parent object, if any

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.enable_autoscale(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_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.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.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

A graphical sink to display multiple signals in time.

This is a QT-based graphical sink the takes set of a float streams and plots them in the time domain. Each signal is plotted with a different color, and the and functions can be used to change the lable and color for a given input number.

Constructor Specific Documentation:

Build floating point time sink.

Parameters:

• size – number of points to plot at once
• samp_rate – sample rate (used to set x-axis labels)
• name – title for the plot
• nconnections – number of signals connected to sink
• parent – a QWidget parent object, if any

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.enable_autoscale(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_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.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.thread_priority(time_sink_f_sptr self) → int

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