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.

Message Ports:

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

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.

Message Ports:

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.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_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.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_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=””)

Set up a trigger for the sink to know when to start plotting. Useful to isolate events and avoid noise.

The trigger modes are Free, Auto, Normal, and Tag (see gr::qtgui::trigger_mode). The first three are like a normal oscope trigger function. Free means free running with no trigger, auto will trigger if the trigger event is seen, but will still plot otherwise, and normal will hold until the trigger event is observed. The Tag trigger mode allows us to trigger off a specific stream tag. The tag trigger is based only on the name of the tag, so when a tag of the given name is seen, the trigger is activated.

In auto and normal mode, we look for the slope of the of the signal. Given a gr::qtgui::trigger_slope as either Positive or Negative, if the value between two samples moves in the given direction (x[1] > x[0] for Positive or x[1] < x[0] for Negative), then the trigger is activated.

With the complex time sink, each input has two lines drawn for the real and imaginary parts of the signal. When selecting the value, channel 0 is the real signal and channel 1 is the imaginary signal. For more than 1 input stream, channel 2i is the real part of the ith input and channel (2i+1) is the imaginary part of the ith input channel.

The value is specified in time based off the sample rate. If the sample rate of the block is set to 1, the delay is then also the sample number offset. This is the offset from the left-hand y-axis of the plot. It delays the signal to show the trigger event at the given delay along with some portion of the signal before the event. The delay must be within 0 - t_max where t_max is the maximum amount of time displayed on the time plot.

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

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.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_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=””)

Set up a trigger for the sink to know when to start plotting. Useful to isolate events and avoid noise.

The trigger modes are Free, Auto, Normal, and Tag (see gr::qtgui::trigger_mode). The first three are like a normal oscope trigger function. Free means free running with no trigger, auto will trigger if the trigger event is seen, but will still plot otherwise, and normal will hold until the trigger event is observed. The Tag trigger mode allows us to trigger off a specific stream tag. The tag trigger is based only on the name of the tag, so when a tag of the given name is seen, the trigger is activated.

In auto and normal mode, we look for the slope of the of the signal. Given a gr::qtgui::trigger_slope as either Positive or Negative, if the value between two samples moves in the given direction (x[1] > x[0] for Positive or x[1] < x[0] for Negative), then the trigger is activated.

The value is specified in time based off the sample rate. If the sample rate of the block is set to 1, the delay is then also the sample number offset. This is the offset from the left-hand y-axis of the plot. It delays the signal to show the trigger event at the given delay along with some portion of the signal before the event. The delay must be within 0 - t_max where t_max is the maximum amount of time displayed on the time plot.

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

Previous topic

gnuradio.fft

Next topic

gnuradio.wxgui

This Page