1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* -*- c++ -*- */
/*
* Copyright 2012,2014 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* GNU Radio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDED_QTGUI_FREQ_SINK_C_H
#define INCLUDED_QTGUI_FREQ_SINK_C_H
#ifdef ENABLE_PYTHON
#include <Python.h>
#endif
#include <gnuradio/qtgui/api.h>
#include <gnuradio/qtgui/trigger_mode.h>
#include <gnuradio/sync_block.h>
#include <qapplication.h>
#include <gnuradio/filter/firdes.h>
namespace gr {
namespace qtgui {
/*!
* \brief A graphical sink to display multiple signals in frequency.
* \ingroup instrumentation_blk
* \ingroup qtgui_blk
*
* \details
* This is a QT-based graphical sink the takes set of a complex
* streams and plots the PSD. Each signal is plotted with a
* different color, and the \a set_title and \a set_color
* functions can be used to change the lable and color for a given
* input number.
*
* Message Ports:
*
* - freq (input):
* Receives a PMT pair: (intern("freq"), double(frequency).
* This is used to retune the center frequency of the
* display's x-axis.
*
* - freq (output):
* Produces a PMT pair with (intern("freq"), double(frequency).
* When a user double-clicks on the display, the block
* produces and emits a message containing the frequency of
* where on the x-axis the user clicked. This value can be
* used by other blocks to update their frequency setting.
*
* To perform click-to-tune behavior, this output 'freq'
* port can be redirected to this block's input 'freq' port
* to catch the message and update the center frequency of
* the display.
*/
class QTGUI_API freq_sink_c : virtual public sync_block
{
public:
// gr::qtgui::freq_sink_c::sptr
typedef boost::shared_ptr<freq_sink_c> sptr;
/*!
* \brief Build a complex PSD sink.
*
* \param fftsize size of the FFT to compute and display
* \param wintype type of window to apply (see gnuradio/filter/firdes.h)
* \param fc center frequency of signal (use for x-axis labels)
* \param bw bandwidth of signal (used to set x-axis labels)
* \param name title for the plot
* \param nconnections number of signals connected to sink
* \param parent a QWidget parent object, if any
*/
static sptr make(int fftsize, int wintype,
double fc, double bw,
const std::string &name,
int nconnections=1,
QWidget *parent=NULL);
virtual void exec_() = 0;
virtual QWidget* qwidget() = 0;
#ifdef ENABLE_PYTHON
virtual PyObject* pyqwidget() = 0;
#else
virtual void* pyqwidget() = 0;
#endif
virtual void set_fft_size(const int fftsize) = 0;
virtual int fft_size() const = 0;
virtual void set_fft_average(const float fftavg) = 0;
virtual float fft_average() const = 0;
virtual void set_fft_window(const gr::filter::firdes::win_type win) = 0;
virtual gr::filter::firdes::win_type fft_window() = 0;
virtual void set_frequency_range(const double centerfreq, const double bandwidth) = 0;
virtual void set_y_axis(double min, double max) = 0;
virtual void set_update_time(double t) = 0;
virtual void set_title(const std::string &title) = 0;
virtual void set_line_label(int which, const std::string &label) = 0;
virtual void set_line_color(int which, const std::string &color) = 0;
virtual void set_line_width(int which, int width) = 0;
virtual void set_line_style(int which, int style) = 0;
virtual void set_line_marker(int which, int marker) = 0;
virtual void set_line_alpha(int which, double alpha) = 0;
/*!
* 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
* 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 to see if the magnitude of
* the any FFT point is over the set level.
*
* \param mode The trigger_mode: free, auto, normal, or tag.
* \param level The magnitude of the trigger even for auto or normal modes.
* \param channel Which input channel to use for the trigger events.
* \param tag_key The name (as a string) of the tag to trigger off
* of if using the tag mode.
*/
virtual void set_trigger_mode(trigger_mode mode,
float level, int channel,
const std::string &tag_key="") = 0;
virtual std::string title() = 0;
virtual std::string line_label(int which) = 0;
virtual std::string line_color(int which) = 0;
virtual int line_width(int which) = 0;
virtual int line_style(int which) = 0;
virtual int line_marker(int which) = 0;
virtual double line_alpha(int which) = 0;
virtual void set_size(int width, int height) = 0;
virtual void enable_menu(bool en=true) = 0;
virtual void enable_grid(bool en=true) = 0;
virtual void enable_autoscale(bool en=true) = 0;
virtual void clear_max_hold() = 0;
virtual void clear_min_hold() = 0;
virtual void reset() = 0;
QApplication *d_qApplication;
};
} /* namespace qtgui */
} /* namespace gr */
#endif /* INCLUDED_QTGUI_FREQ_SINK_C_H */
|
