group_(nullptr),
conversion_type_(NoConversion),
min_value_(0),
- max_value_(0)
+ max_value_(0),
+ index_(0),
+ error_message_("")
{
if (channel_) {
- internal_name_ = QString::fromStdString(channel_->name());
- index_ = channel_->index();
+ set_internal_name(QString::fromStdString(channel_->name()));
+ set_index(channel_->index());
}
connect(&delayed_conversion_starter_, SIGNAL(timeout()),
void SignalBase::set_internal_name(QString internal_name)
{
internal_name_ = internal_name;
+
+ // Use this name also for the QObject instance
+ setObjectName(internal_name);
}
QString SignalBase::display_name() const
return bgcolor_;
}
+QString SignalBase::get_error_message() const
+{
+ return error_message_;
+}
+
void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
{
if (data_) {
shared_ptr<data::Analog> SignalBase::analog_data() const
{
+ if (!data_)
+ return nullptr;
+
return dynamic_pointer_cast<Analog>(data_);
}
shared_ptr<data::Logic> SignalBase::logic_data() const
{
- shared_ptr<Logic> result = dynamic_pointer_cast<Logic>(data_);
+ if (!data_)
+ return nullptr;
+
+ shared_ptr<Logic> result;
if (((conversion_type_ == A2LConversionByThreshold) ||
(conversion_type_ == A2LConversionBySchmittTrigger)))
result = dynamic_pointer_cast<Logic>(converted_data_);
+ else
+ result = dynamic_pointer_cast<Logic>(data_);
return result;
}
+shared_ptr<pv::data::SignalData> SignalBase::data() const
+{
+ return data_;
+}
+
bool SignalBase::segment_is_complete(uint32_t segment_id) const
{
bool result = true;
QVariant value = settings.value("color");
// Workaround for Qt QColor serialization bug on OSX
- if ((QMetaType::Type)(value.type()) == QMetaType::QColor)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+ bool is_qcolor = (QMetaType::Type)(value.typeId()) == QMetaType::QColor;
+#else
+ bool is_qcolor = (QMetaType::Type)(value.type()) == QMetaType::QColor;
+#endif
+ if (is_qcolor)
set_color(value.value<QColor>());
else
set_color(QColor::fromRgba(value.value<uint32_t>()));
delete[] lsamples;
delete[] asamples;
}
+
+ samples_added(lsegment->segment_id(), start_sample, end_sample);
}
void SignalBase::convert_single_segment(shared_ptr<AnalogSegment> asegment,
// we do another round of sample conversion.
} while ((complete_state != old_complete_state) ||
(end_sample - old_end_sample >= ConversionBlockSize));
+
+ if (complete_state)
+ lsegment->set_complete();
}
void SignalBase::conversion_thread_proc()
shared_ptr<AnalogSegment> asegment = analog_data->analog_segments().front();
assert(asegment);
+ connect(asegment.get(), SIGNAL(completed()), this, SLOT(on_input_segment_completed()));
const shared_ptr<Logic> logic_data = dynamic_pointer_cast<Logic>(converted_data_);
assert(logic_data);
if (asegment->is_complete() &&
analog_data->analog_segments().size() > logic_data->logic_segments().size()) {
+ disconnect(asegment.get(), SIGNAL(completed()), this, SLOT(on_input_segment_completed()));
+
// There are more segments to process
segment_id++;
try {
asegment = analog_data->analog_segments().at(segment_id);
+ disconnect(asegment.get(), SIGNAL(completed()), this, SLOT(on_input_segment_completed()));
+ connect(asegment.get(), SIGNAL(completed()), this, SLOT(on_input_segment_completed()));
} catch (out_of_range&) {
qDebug() << "Conversion error for" << name() << ": no analog segment" \
<< segment_id << ", segments size is" << analog_data->analog_segments().size();
logic_data->push_segment(new_segment);
lsegment = logic_data->logic_segments().back();
- }
-
- // No more samples/segments to process, wait for data or interrupt
- if (!conversion_interrupt_) {
- unique_lock<mutex> input_lock(conversion_input_mutex_);
- conversion_input_cond_.wait(input_lock);
+ } else {
+ // No more samples/segments to process, wait for data or interrupt
+ if (!conversion_interrupt_) {
+ unique_lock<mutex> input_lock(conversion_input_mutex_);
+ conversion_input_cond_.wait(input_lock);
+ }
}
} while (!conversion_interrupt_);
+
+ disconnect(asegment.get(), SIGNAL(completed()), this, SLOT(on_input_segment_completed()));
}
void SignalBase::start_conversion(bool delayed_start)
stop_conversion();
- if (converted_data_)
+ if (converted_data_ && (converted_data_->get_segment_count() > 0)) {
converted_data_->clear();
-
- samples_cleared();
+ samples_cleared();
+ }
conversion_interrupt_ = false;
conversion_thread_ = std::thread(&SignalBase::conversion_thread_proc, this);
}
+void SignalBase::set_error_message(QString msg)
+{
+ error_message_ = msg;
+ // TODO Emulate noquote()
+ qDebug().nospace() << name() << ": " << msg;
+
+ error_message_changed(msg);
+}
+
void SignalBase::stop_conversion()
{
// Stop conversion so we can restart it from the beginning
void SignalBase::on_samples_cleared()
{
- if (converted_data_)
+ if (converted_data_ && (converted_data_->get_segment_count() > 0)) {
converted_data_->clear();
-
- samples_cleared();
+ samples_cleared();
+ }
}
void SignalBase::on_samples_added(SharedPtrToSegment segment, uint64_t start_sample,
samples_added(segment->segment_id(), start_sample, end_sample);
}
+void SignalBase::on_input_segment_completed()
+{
+ if (conversion_type_ != NoConversion)
+ if (conversion_thread_.joinable()) {
+ // Notify the conversion thread since it's running
+ conversion_input_cond_.notify_one();
+ }
+}
+
void SignalBase::on_min_max_changed(float min, float max)
{
// Restart conversion if one is enabled and uses a calculated threshold
projects / pulseview.git / blobdiff