Implement MathSignal

[pulseview.git] / pv / data / signalbase.cpp

diff --git a/pv/data/signalbase.cpp b/pv/data/signalbase.cpp
index e1091f110d398fd02095114a57862f060f120a8d..7d420ac7017902e8cffa80aee9be976f1fa75e67 100644 (file)
--- a/pv/data/signalbase.cpp
+++ b/pv/data/signalbase.cpp
@@ -118,6 +118,12 @@ shared_ptr<sigrok::Channel> SignalBase::channel() const
        return channel_;
 }
 
+bool SignalBase::is_generated() const
+{
+       // Only signals associated with a device have a corresponding sigrok channel
+       return channel_ == nullptr;
+}
+
 bool SignalBase::enabled() const
 {
        return (channel_) ? channel_->enabled() : true;
@@ -225,13 +231,10 @@ void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
                disconnect(data.get(), SIGNAL(samples_added(shared_ptr<Segment>, uint64_t, uint64_t)),
                        this, SLOT(on_samples_added(shared_ptr<Segment>, uint64_t, uint64_t)));
 
-               if (channel_type_ == AnalogChannel) {
-                       shared_ptr<Analog> analog = analog_data();
-                       assert(analog);
-
+               shared_ptr<Analog> analog = analog_data();
+               if (analog)
                        disconnect(analog.get(), SIGNAL(min_max_changed(float, float)),
                                this, SLOT(on_min_max_changed(float, float)));
-               }
        }
 
        data_ = data;
@@ -242,13 +245,10 @@ void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
                connect(data.get(), SIGNAL(samples_added(SharedPtrToSegment, uint64_t, uint64_t)),
                        this, SLOT(on_samples_added(SharedPtrToSegment, uint64_t, uint64_t)));
 
-               if (channel_type_ == AnalogChannel) {
-                       shared_ptr<Analog> analog = analog_data();
-                       assert(analog);
-
+               shared_ptr<Analog> analog = analog_data();
+               if (analog)
                        connect(analog.get(), SIGNAL(min_max_changed(float, float)),
                                this, SLOT(on_min_max_changed(float, float)));
-               }
        }
 }
 
@@ -263,20 +263,12 @@ void SignalBase::clear_sample_data()
 
 shared_ptr<data::Analog> SignalBase::analog_data() const
 {
-       shared_ptr<Analog> result = nullptr;
-
-       if (channel_type_ == AnalogChannel)
-               result = dynamic_pointer_cast<Analog>(data_);
-
-       return result;
+       return dynamic_pointer_cast<Analog>(data_);
 }
 
 shared_ptr<data::Logic> SignalBase::logic_data() const
 {
-       shared_ptr<Logic> result = nullptr;
-
-       if (channel_type_ == LogicChannel)
-               result = dynamic_pointer_cast<Logic>(data_);
+       shared_ptr<Logic> result = dynamic_pointer_cast<Logic>(data_);
 
        if (((conversion_type_ == A2LConversionByThreshold) ||
                (conversion_type_ == A2LConversionBySchmittTrigger)))
@@ -289,25 +281,25 @@ bool SignalBase::segment_is_complete(uint32_t segment_id) const
 {
        bool result = true;
 
-       if (channel_type_ == AnalogChannel)
+       shared_ptr<Analog> adata = analog_data();
+       if (adata)
        {
-               shared_ptr<Analog> data = dynamic_pointer_cast<Analog>(data_);
-               auto segments = data->analog_segments();
+               auto segments = adata->analog_segments();
                try {
                        result = segments.at(segment_id)->is_complete();
                } catch (out_of_range&) {
                        // Do nothing
                }
-       }
-
-       if (channel_type_ == LogicChannel)
-       {
-               shared_ptr<Logic> data = dynamic_pointer_cast<Logic>(data_);
-               auto segments = data->logic_segments();
-               try {
-                       result = segments.at(segment_id)->is_complete();
-               } catch (out_of_range&) {
-                       // Do nothing
+       } else {
+               shared_ptr<Logic> ldata = logic_data();
+               if (ldata) {
+                       shared_ptr<Logic> data = dynamic_pointer_cast<Logic>(data_);
+                       auto segments = data->logic_segments();
+                       try {
+                               result = segments.at(segment_id)->is_complete();
+                       } catch (out_of_range&) {
+                               // Do nothing
+                       }
                }
        }
 
@@ -318,21 +310,16 @@ bool SignalBase::has_samples() const
 {
        bool result = false;
 
-       if (channel_type_ == AnalogChannel)
-       {
-               shared_ptr<Analog> data = dynamic_pointer_cast<Analog>(data_);
-               if (data) {
-                       auto segments = data->analog_segments();
-                       if ((segments.size() > 0) && (segments.front()->get_sample_count() > 0))
-                               result = true;
-               }
-       }
-
-       if (channel_type_ == LogicChannel)
+       shared_ptr<Analog> adata = analog_data();
+       if (adata)
        {
-               shared_ptr<Logic> data = dynamic_pointer_cast<Logic>(data_);
-               if (data) {
-                       auto segments = data->logic_segments();
+               auto segments = adata->analog_segments();
+               if ((segments.size() > 0) && (segments.front()->get_sample_count() > 0))
+                       result = true;
+       } else {
+               shared_ptr<Logic> ldata = logic_data();
+               if (ldata) {
+                       auto segments = ldata->logic_segments();
                        if ((segments.size() > 0) && (segments.front()->get_sample_count() > 0))
                                result = true;
                }
@@ -343,18 +330,13 @@ bool SignalBase::has_samples() const
 
 double SignalBase::get_samplerate() const
 {
-       if (channel_type_ == AnalogChannel)
-       {
-               shared_ptr<Analog> data = dynamic_pointer_cast<Analog>(data_);
-               if (data)
-                       return data->get_samplerate();
-       }
-
-       if (channel_type_ == LogicChannel)
-       {
-               shared_ptr<Logic> data = dynamic_pointer_cast<Logic>(data_);
-               if (data)
-                       return data->get_samplerate();
+       shared_ptr<Analog> adata = analog_data();
+       if (adata)
+               return adata->get_samplerate();
+       else {
+               shared_ptr<Logic> ldata = logic_data();
+               if (ldata)
+                       return ldata->get_samplerate();
        }
 
        // Default samplerate is 1 Hz
@@ -580,8 +562,7 @@ void SignalBase::restore_settings(QSettings &settings)
 
 bool SignalBase::conversion_is_a2l() const
 {
-       return ((channel_type_ == AnalogChannel) &&
-               ((conversion_type_ == A2LConversionByThreshold) ||
+       return (((conversion_type_ == A2LConversionByThreshold) ||
                (conversion_type_ == A2LConversionBySchmittTrigger)));
 }
 
@@ -596,7 +577,8 @@ void SignalBase::convert_single_segment_range(AnalogSegment *asegment,
                uint8_t *lsamples = new uint8_t[ConversionBlockSize];
 
                vector<shared_ptr<sigrok::Channel> > channels;
-               channels.push_back(channel_);
+               if (channel_)
+                       channels.push_back(channel_);
 
                vector<const sigrok::QuantityFlag*> mq_flags;
                const sigrok::Quantity * const mq = sigrok::Quantity::VOLTAGE;