AnalogSignal: Add conversion type and display type

[pulseview.git] / pv / view / analogsignal.cpp

diff --git a/pv/view/analogsignal.cpp b/pv/view/analogsignal.cpp
index d9ac2f60afcf853d1b225a18c139854ec94ed824..1fe902251594e5e93dd9d40d2be71bbc4b39b617 100644 (file)
--- a/pv/view/analogsignal.cpp
+++ b/pv/view/analogsignal.cpp
@@ -38,14 +38,19 @@
 #include "pv/data/analogsegment.hpp"
 #include "pv/data/signalbase.hpp"
 #include "pv/view/view.hpp"
+#include "pv/globalsettings.hpp"
 
 #include <libsigrokcxx/libsigrokcxx.hpp>
 
+using std::deque;
+using std::div;
+using std::div_t;
 using std::max;
 using std::make_pair;
 using std::min;
+using std::numeric_limits;
+using std::pair;
 using std::shared_ptr;
-using std::deque;
 
 namespace pv {
 namespace views {
@@ -61,6 +66,8 @@ const QColor AnalogSignal::SignalColours[4] = {
 const QColor AnalogSignal::GridMajorColor = QColor(0, 0, 0, 40*256/100);
 const QColor AnalogSignal::GridMinorColor = QColor(0, 0, 0, 20*256/100);
 
+const QColor AnalogSignal::SamplingPointColour(0x77, 0x77, 0x77);
+
 const float AnalogSignal::EnvelopeThreshold = 256.0f;
 
 const int AnalogSignal::MaximumVDivs = 10;
@@ -80,7 +87,9 @@ AnalogSignal::AnalogSignal(
        pos_vdivs_(1),
        neg_vdivs_(1),
        resolution_(0),
-       autoranging_(1)
+       conversion_type_(data::SignalBase::NoConversion),
+       display_type_(DisplayBoth),
+       autoranging_(true)
 {
        pv::data::Analog* analog_data =
                dynamic_cast<pv::data::Analog*>(data().get());
@@ -102,6 +111,8 @@ void AnalogSignal::save_settings(QSettings &settings) const
        settings.setValue("pos_vdivs", pos_vdivs_);
        settings.setValue("neg_vdivs", neg_vdivs_);
        settings.setValue("scale_index", scale_index_);
+       settings.setValue("conversion_type", conversion_type_);
+       settings.setValue("display_type", display_type_);
        settings.setValue("autoranging", autoranging_);
 }
 
@@ -118,11 +129,17 @@ void AnalogSignal::restore_settings(QSettings &settings)
                update_scale();
        }
 
+       if (settings.contains("conversion_type"))
+               conversion_type_ = (data::SignalBase::ConversionType)(settings.value("conversion_type").toInt());
+
+       if (settings.contains("display_type"))
+               display_type_ = (DisplayType)(settings.value("display_type").toInt());
+
        if (settings.contains("autoranging"))
                autoranging_ = settings.value("autoranging").toBool();
 }
 
-std::pair<int, int> AnalogSignal::v_extents() const
+pair<int, int> AnalogSignal::v_extents() const
 {
        const int ph = pos_vdivs_ * div_height_;
        const int nh = neg_vdivs_ * div_height_;
@@ -277,24 +294,43 @@ void AnalogSignal::paint_trace(QPainter &p,
 {
        p.setPen(base_->colour());
 
-       QPointF *points = new QPointF[end - start];
+       const int64_t points_count = end - start;
+
+       QPointF *points = new QPointF[points_count];
        QPointF *point = points;
 
+       QRectF *const sampling_points = new QRectF[points_count];
+       QRectF *sampling_point = sampling_points;
+
        pv::data::SegmentAnalogDataIterator* it =
                segment->begin_sample_iteration(start);
 
+       const int w = 2;
        for (int64_t sample = start; sample != end; sample++) {
                const float x = (sample / samples_per_pixel -
                        pixels_offset) + left;
 
                *point++ = QPointF(x, y - *((float*)it->value) * scale_);
+               *sampling_point++ = QRectF(x - (w / 2), y - *((float*)it->value) * scale_ - (w / 2), w, w);
+
                segment->continue_sample_iteration(it, 1);
        }
        segment->end_sample_iteration(it);
 
-       p.drawPolyline(points, point - points);
+       p.drawPolyline(points, points_count);
+
+       // Paint the sampling points if enabled
+       GlobalSettings settings;
+       const bool show_sampling_points =
+               settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool();
+
+       if (show_sampling_points && (samples_per_pixel < 0.25)) {
+               p.setPen(SamplingPointColour);
+               p.drawRects(sampling_points, points_count);
+       }
 
        delete[] points;
+       delete[] sampling_points;
 }
 
 void AnalogSignal::paint_envelope(QPainter &p,
@@ -346,9 +382,8 @@ float AnalogSignal::get_resolution(int scale_index)
 {
        const float seq[] = {1.0f, 2.0f, 5.0f};
 
-       const int offset = std::numeric_limits<int>::max() / (2 * countof(seq));
-       const std::div_t d = std::div(
-               (int)(scale_index + countof(seq) * offset),
+       const int offset = numeric_limits<int>::max() / (2 * countof(seq));
+       const div_t d = div((int)(scale_index + countof(seq) * offset),
                countof(seq));
 
        return powf(10.0f, d.quot - offset) * seq[d.rem];
@@ -372,7 +407,7 @@ void AnalogSignal::perform_autoranging(bool force_update)
        double min = 0, max = 0;
 
        for (shared_ptr<pv::data::AnalogSegment> segment : segments) {
-               std::pair<double, double> mm = segment->get_min_max();
+               pair<double, double> mm = segment->get_min_max();
                min = std::min(min, mm.first);
                max = std::max(max, mm.second);
        }
@@ -389,6 +424,12 @@ void AnalogSignal::perform_autoranging(bool force_update)
                neg_vdivs_ = 0;
        }
 
+       // Split up the divs if there are negative values but no negative divs
+       if ((min < 0) && (neg_vdivs_ == 0)) {
+               neg_vdivs_ = pos_vdivs_ / 2;
+               pos_vdivs_ -= neg_vdivs_;
+       }
+
        double min_value_per_div;
        if ((pos_vdivs_ > 0) && (neg_vdivs_ >  0))
                min_value_per_div = std::max(max / pos_vdivs_, -min / neg_vdivs_);
@@ -437,7 +478,7 @@ void AnalogSignal::populate_popup_form(QWidget *parent, QFormLayout *form)
                resolution_cb_->insertItem(0, label, QVariant(i));
        }
 
-       const int cur_idx = resolution_cb_->findData(QVariant(scale_index_));
+       int cur_idx = resolution_cb_->findData(QVariant(scale_index_));
        resolution_cb_->setCurrentIndex(cur_idx);
 
        connect(resolution_cb_, SIGNAL(currentIndexChanged(int)),
@@ -459,6 +500,33 @@ void AnalogSignal::populate_popup_form(QWidget *parent, QFormLayout *form)
 
        layout->addRow(tr("Autoranging"), autoranging_cb);
 
+       // Add the conversion type dropdown
+       conversion_cb_ = new QComboBox();
+
+       conversion_cb_->addItem("none", data::SignalBase::NoConversion);
+       conversion_cb_->addItem("to logic via threshold", data::SignalBase::A2LConversionByTreshold);
+       conversion_cb_->addItem("to logic via schmitt-trigger", data::SignalBase::A2LConversionBySchmittTrigger);
+
+       cur_idx = conversion_cb_->findData(QVariant(conversion_type_));
+       conversion_cb_->setCurrentIndex(cur_idx);
+
+       layout->addRow(tr("Conversion"), conversion_cb_);
+
+       connect(conversion_cb_, SIGNAL(currentIndexChanged(int)),
+               this, SLOT(on_conversion_changed(int)));
+
+       // Add the display type dropdown
+       display_type_cb_ = new QComboBox();
+
+       display_type_cb_->addItem(tr("Analog"), DisplayAnalog);
+       display_type_cb_->addItem(tr("Converted"), DisplayConverted);
+       display_type_cb_->addItem(tr("Both"), DisplayBoth);
+
+       cur_idx = display_type_cb_->findData(QVariant(display_type_));
+       display_type_cb_->setCurrentIndex(cur_idx);
+
+       layout->addRow(tr("Traces to show:"), display_type_cb_);
+
        form->addRow(layout);
 }
 
@@ -524,6 +592,12 @@ void AnalogSignal::on_autoranging_changed(int state)
        }
 }
 
+void AnalogSignal::on_conversion_changed(int index)
+{
+       conversion_type_ = (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+       base_->set_conversion_type(conversion_type_);
+}
+
 } // namespace TraceView
 } // namespace views
 } // namespace pv