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
|
/* -*- c++ -*- */
/*
* Copyright 2011-2013,2015 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
#ifndef INCLUDED_QTGUI_TIME_SINK_F_H
#define INCLUDED_QTGUI_TIME_SINK_F_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>
namespace gr {
namespace qtgui {
/*!
* \brief A graphical sink to display multiple signals in time.
* \ingroup instrumentation_blk
* \ingroup qtgui_blk
*
* \details
* 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 \a set_title and \a set_color functions
* can be used to change the label and color for a given input number.
*
* The sink supports plotting streaming float data or
* messages. The message port is named "in". The two modes cannot
* be used simultaneously, and \p nconnections should be set to 0
* when using the message mode. GRC handles this issue by
* providing the "Float Message" type that removes the streaming
* port(s).
*
* This sink can plot messages that contain either uniform vectors
* of float 32 values (pmt::is_f32vector) or PDUs where the data
* is a uniform vector of float 32 values.
*/
class QTGUI_API time_sink_f : virtual public sync_block
{
public:
// gr::qtgui::time_sink_f::sptr
typedef boost::shared_ptr<time_sink_f> sptr;
/*!
* \brief Build floating point time sink
*
* \param size number of points to plot at once
* \param samp_rate sample rate (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 size,
double samp_rate,
const std::string& name,
unsigned 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_y_axis(double min, double max) = 0;
virtual void set_y_label(const std::string& label, const std::string& unit = "") = 0;
virtual void set_update_time(double t) = 0;
virtual void set_title(const std::string& title) = 0;
virtual void set_line_label(unsigned int which, const std::string& line) = 0;
virtual void set_line_color(unsigned int which, const std::string& color) = 0;
virtual void set_line_width(unsigned int which, int width) = 0;
virtual void set_line_style(unsigned int which, int style) = 0;
virtual void set_line_marker(unsigned int which, int marker) = 0;
virtual void set_nsamps(const int newsize) = 0;
virtual void set_samp_rate(const double samp_rate) = 0;
virtual void set_line_alpha(unsigned 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
* 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 \p delay 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.
*
* \param mode The trigger_mode: free, auto, normal, or tag.
* \param slope The trigger_slope: positive or negative. Only
* used for auto and normal modes.
* \param level The magnitude of the trigger even for auto or normal modes.
* \param delay The delay (in units of time) for where the trigger happens.
* \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,
trigger_slope slope,
float level,
float delay,
int channel,
const std::string& tag_key = "") = 0;
virtual std::string title() = 0;
virtual std::string line_label(unsigned int which) = 0;
virtual std::string line_color(unsigned int which) = 0;
virtual int line_width(unsigned int which) = 0;
virtual int line_style(unsigned int which) = 0;
virtual int line_marker(unsigned int which) = 0;
virtual double line_alpha(unsigned 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 enable_stem_plot(bool en = true) = 0;
virtual void enable_semilogx(bool en = true) = 0;
virtual void enable_semilogy(bool en = true) = 0;
virtual void enable_control_panel(bool en = true) = 0;
virtual void enable_tags(unsigned int which, bool en) = 0;
virtual void enable_tags(bool en) = 0;
virtual void enable_axis_labels(bool en = true) = 0;
virtual void disable_legend() = 0;
virtual int nsamps() const = 0;
virtual void reset() = 0;
QApplication* d_qApplication;
};
} /* namespace qtgui */
} /* namespace gr */
#endif /* INCLUDED_QTGUI_TIME_SINK_F_H */
|
