]> sigrok.org Git - pulseview.git/blob - pv/data/signalbase.cpp
Use getter for the conversion type instead of a local copy
[pulseview.git] / pv / data / signalbase.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
5  * Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include "analog.hpp"
22 #include "analogsegment.hpp"
23 #include "decode/row.hpp"
24 #include "logic.hpp"
25 #include "logicsegment.hpp"
26 #include "signalbase.hpp"
27 #include "signaldata.hpp"
28
29 #include <pv/binding/decoder.hpp>
30 #include <pv/session.hpp>
31
32 using std::dynamic_pointer_cast;
33 using std::make_shared;
34 using std::shared_ptr;
35 using std::tie;
36 using std::unique_lock;
37
38 namespace pv {
39 namespace data {
40
41 const int SignalBase::ColourBGAlpha = 8 * 256 / 100;
42 const uint64_t SignalBase::ConversionBlockSize = 4096;
43
44 SignalBase::SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type) :
45         channel_(channel),
46         channel_type_(channel_type),
47         conversion_type_(NoConversion)
48 {
49         if (channel_)
50                 internal_name_ = QString::fromStdString(channel_->name());
51 }
52
53 SignalBase::~SignalBase()
54 {
55         stop_conversion();
56 }
57
58 shared_ptr<sigrok::Channel> SignalBase::channel() const
59 {
60         return channel_;
61 }
62
63 QString SignalBase::name() const
64 {
65         return (channel_) ? QString::fromStdString(channel_->name()) : name_;
66 }
67
68 QString SignalBase::internal_name() const
69 {
70         return internal_name_;
71 }
72
73 void SignalBase::set_name(QString name)
74 {
75         if (channel_)
76                 channel_->set_name(name.toUtf8().constData());
77
78         name_ = name;
79
80         name_changed(name);
81 }
82
83 bool SignalBase::enabled() const
84 {
85         return (channel_) ? channel_->enabled() : true;
86 }
87
88 void SignalBase::set_enabled(bool value)
89 {
90         if (channel_) {
91                 channel_->set_enabled(value);
92                 enabled_changed(value);
93         }
94 }
95
96 SignalBase::ChannelType SignalBase::type() const
97 {
98         return channel_type_;
99 }
100
101 unsigned int SignalBase::index() const
102 {
103         return (channel_) ? channel_->index() : 0;
104 }
105
106 unsigned int SignalBase::logic_bit_index() const
107 {
108         if (channel_type_ == LogicChannel)
109                 return channel_->index();
110         else
111                 return 0;
112 }
113
114 QColor SignalBase::colour() const
115 {
116         return colour_;
117 }
118
119 void SignalBase::set_colour(QColor colour)
120 {
121         colour_ = colour;
122
123         bgcolour_ = colour;
124         bgcolour_.setAlpha(ColourBGAlpha);
125
126         colour_changed(colour);
127 }
128
129 QColor SignalBase::bgcolour() const
130 {
131         return bgcolour_;
132 }
133
134 void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
135 {
136         if (data_) {
137                 disconnect(data.get(), SIGNAL(samples_cleared()),
138                         this, SLOT(on_samples_cleared()));
139                 disconnect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
140                         this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
141         }
142
143         data_ = data;
144
145         if (data_) {
146                 connect(data.get(), SIGNAL(samples_cleared()),
147                         this, SLOT(on_samples_cleared()));
148                 connect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
149                         this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
150         }
151 }
152
153 shared_ptr<data::Analog> SignalBase::analog_data() const
154 {
155         shared_ptr<Analog> result = nullptr;
156
157         if (channel_type_ == AnalogChannel)
158                 result = dynamic_pointer_cast<Analog>(data_);
159
160         return result;
161 }
162
163 shared_ptr<data::Logic> SignalBase::logic_data() const
164 {
165         shared_ptr<Logic> result = nullptr;
166
167         if (channel_type_ == LogicChannel)
168                 result = dynamic_pointer_cast<Logic>(data_);
169
170         if (((conversion_type_ == A2LConversionByTreshold) ||
171                 (conversion_type_ == A2LConversionBySchmittTrigger)))
172                 result = dynamic_pointer_cast<Logic>(converted_data_);
173
174         return result;
175 }
176
177 SignalBase::ConversionType SignalBase::get_conversion_type() const
178 {
179         return conversion_type_;
180 }
181
182 void SignalBase::set_conversion_type(ConversionType t)
183 {
184         if (conversion_type_ != NoConversion) {
185                 stop_conversion();
186
187                 // Discard converted data
188                 converted_data_.reset();
189                 samples_cleared();
190         }
191
192         conversion_type_ = t;
193
194         // Re-create an empty container
195         // so that the signal is recognized as providing logic data
196         // and thus can be assigned to a decoder
197         if (conversion_is_a2l())
198                 if (!converted_data_)
199                         converted_data_ = make_shared<Logic>(1);  // Contains only one channel
200
201         start_conversion();
202
203         conversion_type_changed(t);
204 }
205
206 #ifdef ENABLE_DECODE
207 bool SignalBase::is_decode_signal() const
208 {
209         return (channel_type_ == DecodeChannel);
210 }
211 #endif
212
213 void SignalBase::save_settings(QSettings &settings) const
214 {
215         settings.setValue("name", name());
216         settings.setValue("enabled", enabled());
217         settings.setValue("colour", colour());
218         settings.setValue("conversion_type", (int)conversion_type_);
219 }
220
221 void SignalBase::restore_settings(QSettings &settings)
222 {
223         set_name(settings.value("name").toString());
224         set_enabled(settings.value("enabled").toBool());
225         set_colour(settings.value("colour").value<QColor>());
226         set_conversion_type((ConversionType)settings.value("conversion_type").toInt());
227 }
228
229 bool SignalBase::conversion_is_a2l() const
230 {
231         return ((channel_type_ == AnalogChannel) &&
232                 ((conversion_type_ == A2LConversionByTreshold) ||
233                 (conversion_type_ == A2LConversionBySchmittTrigger)));
234 }
235
236 void SignalBase::conversion_thread_proc(QObject* segment)
237 {
238         // TODO Support for multiple segments is missing
239
240         uint64_t start_sample, end_sample;
241         start_sample = end_sample = 0;
242
243         do {
244                 if (conversion_is_a2l()) {
245
246                         AnalogSegment *asegment = qobject_cast<AnalogSegment*>(segment);
247
248                         const shared_ptr<Logic> logic_data = dynamic_pointer_cast<Logic>(converted_data_);
249
250                         // Create the initial logic data segment if needed
251                         if (logic_data->segments().size() == 0) {
252                                 shared_ptr<LogicSegment> lsegment =
253                                         make_shared<LogicSegment>(*logic_data.get(), 1, asegment->samplerate());
254                                 logic_data->push_segment(lsegment);
255                         }
256
257                         LogicSegment *lsegment = dynamic_cast<LogicSegment*>(logic_data->segments().front().get());
258
259                         start_sample = lsegment->get_sample_count();
260                         end_sample = asegment->get_sample_count();
261
262                         if (end_sample > start_sample) {
263                                 float min_v, max_v;
264                                 tie(min_v, max_v) = asegment->get_min_max();
265
266                                 // Create sigrok::Analog instance
267                                 float *asamples = new float[ConversionBlockSize];
268                                 uint8_t *lsamples = new uint8_t[ConversionBlockSize];
269
270                                 vector<shared_ptr<sigrok::Channel> > channels;
271                                 channels.push_back(channel_);
272
273                                 vector<const sigrok::QuantityFlag*> mq_flags;
274                                 const sigrok::Quantity * const mq = sigrok::Quantity::VOLTAGE;
275                                 const sigrok::Unit * const unit = sigrok::Unit::VOLT;
276
277                                 shared_ptr<sigrok::Packet> packet =
278                                         Session::sr_context->create_analog_packet(channels,
279                                         asamples, ConversionBlockSize, mq, unit, mq_flags);
280
281                                 shared_ptr<sigrok::Analog> analog =
282                                         dynamic_pointer_cast<sigrok::Analog>(packet->payload());
283
284                                 // Convert
285                                 uint64_t i = start_sample;
286
287                                 if (conversion_type_ == A2LConversionByTreshold) {
288                                         const float threshold = (min_v + max_v) * 0.5;  // middle between min and max
289
290                                         // Convert as many sample blocks as we can
291                                         while ((end_sample - i) > ConversionBlockSize) {
292                                                 asegment->get_samples(i, i + ConversionBlockSize, asamples);
293
294                                                 shared_ptr<sigrok::Logic> logic =
295                                                         analog->get_logic_via_threshold(threshold, lsamples);
296
297                                                 lsegment->append_payload(logic->data_pointer(), logic->data_length());
298
299                                                 samples_added(lsegment, i, i + ConversionBlockSize);
300                                                 i += ConversionBlockSize;
301                                         }
302
303                                         // Re-create sigrok::Analog and convert remaining samples
304                                         packet = Session::sr_context->create_analog_packet(channels,
305                                                 asamples, end_sample - i, mq, unit, mq_flags);
306
307                                         analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());
308
309                                         asegment->get_samples(i, end_sample, asamples);
310                                         shared_ptr<sigrok::Logic> logic =
311                                                 analog->get_logic_via_threshold(threshold, lsamples);
312                                         lsegment->append_payload(logic->data_pointer(), logic->data_length());
313                                         samples_added(lsegment, i, end_sample);
314                                 }
315
316                                 if (conversion_type_ == A2LConversionBySchmittTrigger) {
317                                         const float amplitude = max_v - min_v;
318                                         const float center = min_v + (amplitude / 2);
319                                         const float lo_thr = center - (amplitude * 0.15); // 15% margin
320                                         const float hi_thr = center + (amplitude * 0.15); // 15% margin
321                                         uint8_t state = 0;  // TODO Use value of logic sample n-1 instead of 0
322
323                                         // Convert as many sample blocks as we can
324                                         while ((end_sample - i) > ConversionBlockSize) {
325                                                 asegment->get_samples(i, i + ConversionBlockSize, asamples);
326
327                                                 shared_ptr<sigrok::Logic> logic =
328                                                         analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
329                                                                 &state, lsamples);
330
331                                                 lsegment->append_payload(logic->data_pointer(), logic->data_length());
332
333                                                 samples_added(lsegment, i, i + ConversionBlockSize);
334                                                 i += ConversionBlockSize;
335                                         }
336
337                                         // Re-create sigrok::Analog and convert remaining samples
338                                         packet = Session::sr_context->create_analog_packet(channels,
339                                                 asamples, end_sample - i, mq, unit, mq_flags);
340
341                                         analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());
342
343                                         asegment->get_samples(i, end_sample, asamples);
344                                         shared_ptr<sigrok::Logic> logic =
345                                                 analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
346                                                         &state, lsamples);
347                                         lsegment->append_payload(logic->data_pointer(), logic->data_length());
348                                         samples_added(lsegment, i, end_sample);
349                                 }
350
351                                 // If acquisition is ongoing, start-/endsample may have changed
352                                 end_sample = asegment->get_sample_count();
353
354                                 delete[] lsamples;
355                                 delete[] asamples;
356                         }
357                 }
358
359                 if (!conversion_interrupt_ && (start_sample == end_sample)) {
360                         unique_lock<mutex> input_lock(conversion_input_mutex_);
361                         conversion_input_cond_.wait(input_lock);
362                 }
363         } while (!conversion_interrupt_);
364 }
365
366 void SignalBase::start_conversion()
367 {
368         stop_conversion();
369
370         if (conversion_is_a2l()) {
371                 shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);
372
373                 if (analog_data->analog_segments().size() > 0) {
374                         // TODO Support for multiple segments is missing
375                         AnalogSegment *asegment = analog_data->analog_segments().front().get();
376
377                         conversion_interrupt_ = false;
378                         conversion_thread_ = std::thread(
379                                 &SignalBase::conversion_thread_proc, this, asegment);
380                 }
381         }
382 }
383
384 void SignalBase::stop_conversion()
385 {
386         // Stop conversion so we can restart it from the beginning
387         conversion_interrupt_ = true;
388         conversion_input_cond_.notify_one();
389         if (conversion_thread_.joinable())
390                 conversion_thread_.join();
391 }
392
393 void SignalBase::on_samples_cleared()
394 {
395         if (converted_data_)
396                 converted_data_->clear();
397
398         samples_cleared();
399 }
400
401 void SignalBase::on_samples_added(QObject* segment, uint64_t start_sample,
402         uint64_t end_sample)
403 {
404         if (conversion_type_ != NoConversion) {
405                 if (conversion_thread_.joinable()) {
406                         // Notify the conversion thread since it's running
407                         conversion_input_cond_.notify_one();
408                 } else {
409                         // Start the conversion thread
410                         start_conversion();
411                 }
412         }
413
414         samples_added(segment, start_sample, end_sample);
415 }
416
417 void SignalBase::on_capture_state_changed(int state)
418 {
419         if (state == Session::Running) {
420                 if (conversion_type_ != NoConversion) {
421                         // Restart conversion
422                         stop_conversion();
423                         start_conversion();
424                 }
425         }
426 }
427
428 } // namespace data
429 } // namespace pv