#include <cmath>
#include <cstdlib>
#include <limits>
+#include <vector>
#include <QApplication>
#include <QCheckBox>
#include "analogsignal.hpp"
#include "pv/data/analog.hpp"
#include "pv/data/analogsegment.hpp"
+#include "pv/data/logic.hpp"
+#include "pv/data/logicsegment.hpp"
#include "pv/data/signalbase.hpp"
#include "pv/view/view.hpp"
+#include "pv/view/logicsignal.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;
+using std::vector;
namespace pv {
namespace views {
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;
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());
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_);
}
update_scale();
}
+ if (settings.contains("conversion_type")) {
+ conversion_type_ = (data::SignalBase::ConversionType)(settings.value("conversion_type").toInt());
+ update_conversion_type();
+ }
+
+ 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_;
if (!base_->enabled())
return;
- paint_grid(p, y, pp.left(), pp.right());
-
- const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
- base_->analog_data()->analog_segments();
- if (segments.empty())
- return;
-
- const shared_ptr<pv::data::AnalogSegment> &segment =
- segments.front();
-
- const double pixels_offset = pp.pixels_offset();
- const double samplerate = max(1.0, segment->samplerate());
- const pv::util::Timestamp& start_time = segment->start_time();
- const int64_t last_sample = segment->get_sample_count() - 1;
- const double samples_per_pixel = samplerate * pp.scale();
- const pv::util::Timestamp start = samplerate * (pp.offset() - start_time);
- const pv::util::Timestamp end = start + samples_per_pixel * pp.width();
+ if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth)) {
+ paint_grid(p, y, pp.left(), pp.right());
+
+ const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
+ base_->analog_data()->analog_segments();
+ if (segments.empty())
+ return;
+
+ const shared_ptr<pv::data::AnalogSegment> &segment =
+ segments.front();
+
+ const double pixels_offset = pp.pixels_offset();
+ const double samplerate = max(1.0, segment->samplerate());
+ const pv::util::Timestamp& start_time = segment->start_time();
+ const int64_t last_sample = segment->get_sample_count() - 1;
+ const double samples_per_pixel = samplerate * pp.scale();
+ const pv::util::Timestamp start = samplerate * (pp.offset() - start_time);
+ const pv::util::Timestamp end = start + samples_per_pixel * pp.width();
+
+ const int64_t start_sample = min(max(floor(start).convert_to<int64_t>(),
+ (int64_t)0), last_sample);
+ const int64_t end_sample = min(max((ceil(end) + 1).convert_to<int64_t>(),
+ (int64_t)0), last_sample);
+
+ if (samples_per_pixel < EnvelopeThreshold)
+ paint_trace(p, segment, y, pp.left(),
+ start_sample, end_sample,
+ pixels_offset, samples_per_pixel);
+ else
+ paint_envelope(p, segment, y, pp.left(),
+ start_sample, end_sample,
+ pixels_offset, samples_per_pixel);
+ }
- const int64_t start_sample = min(max(floor(start).convert_to<int64_t>(),
- (int64_t)0), last_sample);
- const int64_t end_sample = min(max((ceil(end) + 1).convert_to<int64_t>(),
- (int64_t)0), last_sample);
+ if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth)) {
+ if (((conversion_type_ == data::SignalBase::A2LConversionByTreshold) ||
+ (conversion_type_ == data::SignalBase::A2LConversionBySchmittTrigger))) {
- if (samples_per_pixel < EnvelopeThreshold)
- paint_trace(p, segment, y, pp.left(),
- start_sample, end_sample,
- pixels_offset, samples_per_pixel);
- else
- paint_envelope(p, segment, y, pp.left(),
- start_sample, end_sample,
- pixels_offset, samples_per_pixel);
+ paint_logic_mid(p, pp);
+ }
+ }
}
void AnalogSignal::paint_fore(QPainter &p, const ViewItemPaintParams &pp)
if (!enabled())
return;
- const int y = get_visual_y();
+ if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth)) {
+ const int y = get_visual_y();
- // Show the info section on the right side of the trace
- const QString infotext = QString("%1 V/div").arg(resolution_);
+ // Show the info section on the right side of the trace
+ const QString infotext = QString("%1 V/div").arg(resolution_);
- p.setPen(base_->colour());
- p.setFont(QApplication::font());
+ p.setPen(base_->colour());
+ p.setFont(QApplication::font());
- const QRectF bounding_rect = QRectF(pp.left(),
- y + v_extents().first,
- pp.width() - InfoTextMarginRight,
- v_extents().second - v_extents().first - InfoTextMarginBottom);
+ const QRectF bounding_rect = QRectF(pp.left(),
+ y + v_extents().first,
+ pp.width() - InfoTextMarginRight,
+ v_extents().second - v_extents().first - InfoTextMarginBottom);
- p.drawText(bounding_rect, Qt::AlignRight | Qt::AlignBottom, infotext);
+ p.drawText(bounding_rect, Qt::AlignRight | Qt::AlignBottom, infotext);
+ }
}
void AnalogSignal::paint_grid(QPainter &p, int y, int left, int right)
{
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,
delete[] e.samples;
}
+void AnalogSignal::paint_logic_mid(QPainter &p, const ViewItemPaintParams &pp)
+{
+ QLineF *line;
+
+ vector< pair<int64_t, bool> > edges;
+
+ assert(base_);
+
+ const int y = get_visual_y();
+
+ if (!base_->enabled())
+ return;
+
+ const int signal_margin =
+ QFontMetrics(QApplication::font()).height() / 2;
+
+ const int ph = min(pos_vdivs_, 1) * div_height_;
+ const int nh = min(neg_vdivs_, 1) * div_height_;
+ const float high_offset = y - ph + signal_margin + 0.5f;
+ const float low_offset = y + nh - signal_margin - 0.5f;
+
+ const deque< shared_ptr<pv::data::LogicSegment> > &segments =
+ base_->logic_data()->logic_segments();
+ if (segments.empty())
+ return;
+
+ const shared_ptr<pv::data::LogicSegment> &segment =
+ segments.front();
+
+ double samplerate = segment->samplerate();
+
+ // Show sample rate as 1Hz when it is unknown
+ if (samplerate == 0.0)
+ samplerate = 1.0;
+
+ const double pixels_offset = pp.pixels_offset();
+ const pv::util::Timestamp& start_time = segment->start_time();
+ const int64_t last_sample = segment->get_sample_count() - 1;
+ const double samples_per_pixel = samplerate * pp.scale();
+ const pv::util::Timestamp start = samplerate * (pp.offset() - start_time);
+ const pv::util::Timestamp end = start + samples_per_pixel * pp.width();
+
+ const int64_t start_sample = min(max(floor(start).convert_to<int64_t>(),
+ (int64_t)0), last_sample);
+ const uint64_t end_sample = min(max(ceil(end).convert_to<int64_t>(),
+ (int64_t)0), last_sample);
+
+ segment->get_subsampled_edges(edges, start_sample, end_sample,
+ samples_per_pixel / LogicSignal::Oversampling, 0);
+ assert(edges.size() >= 2);
+
+ // Paint the edges
+ const unsigned int edge_count = edges.size() - 2;
+ QLineF *const edge_lines = new QLineF[edge_count];
+ line = edge_lines;
+
+ for (auto i = edges.cbegin() + 1; i != edges.cend() - 1; i++) {
+ const float x = ((*i).first / samples_per_pixel -
+ pixels_offset) + pp.left();
+ *line++ = QLineF(x, high_offset, x, low_offset);
+ }
+
+ p.setPen(LogicSignal::EdgeColour);
+ p.drawLines(edge_lines, edge_count);
+ delete[] edge_lines;
+
+ // Paint the caps
+ const unsigned int max_cap_line_count = edges.size();
+ QLineF *const cap_lines = new QLineF[max_cap_line_count];
+
+ p.setPen(LogicSignal::HighColour);
+ paint_logic_caps(p, cap_lines, edges, true, samples_per_pixel,
+ pixels_offset, pp.left(), high_offset);
+ p.setPen(LogicSignal::LowColour);
+ paint_logic_caps(p, cap_lines, edges, false, samples_per_pixel,
+ pixels_offset, pp.left(), low_offset);
+
+ delete[] cap_lines;
+
+ // Return if we don't need to paint the sampling points
+ GlobalSettings settings;
+ const bool show_sampling_points =
+ settings.value(GlobalSettings::Key_View_ShowSamplingPoints).toBool();
+
+ if (!show_sampling_points || (samples_per_pixel >= 0.25))
+ return;
+
+ // Paint the sampling points
+ const uint64_t sampling_points_count = end_sample - start_sample + 1;
+ QRectF *const sampling_points = new QRectF[sampling_points_count];
+ QRectF *sampling_point = sampling_points;
+
+ const int w = 1;
+ const float y_middle = high_offset - ((high_offset - low_offset) / 2);
+ for (uint64_t i = start_sample; i < end_sample + 1; ++i) {
+ const float x = (i / samples_per_pixel - pixels_offset) + pp.left();
+ *sampling_point++ = QRectF(x - (w / 2), y_middle - (w / 2), w, w);
+ }
+
+ p.setPen(SamplingPointColour);
+ p.drawRects(sampling_points, sampling_points_count);
+ delete[] sampling_points;
+}
+
+void AnalogSignal::paint_logic_caps(QPainter &p, QLineF *const lines,
+ vector< pair<int64_t, bool> > &edges, bool level,
+ double samples_per_pixel, double pixels_offset, float x_offset,
+ float y_offset)
+{
+ QLineF *line = lines;
+
+ for (auto i = edges.begin(); i != (edges.end() - 1); i++)
+ if ((*i).second == level) {
+ *line++ = QLineF(
+ ((*i).first / samples_per_pixel -
+ pixels_offset) + x_offset, y_offset,
+ ((*(i+1)).first / samples_per_pixel -
+ pixels_offset) + x_offset, y_offset);
+ }
+
+ p.drawLines(lines, line - lines);
+}
+
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];
scale_ = div_height_ / resolution_;
}
+void AnalogSignal::update_conversion_type()
+{
+ base_->set_conversion_type(conversion_type_);
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
+
void AnalogSignal::perform_autoranging(bool force_update)
{
const deque< shared_ptr<pv::data::AnalogSegment> > &segments =
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);
}
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)),
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_);
+
+ connect(display_type_cb_, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(on_display_type_changed(int)));
+
form->addRow(layout);
}
}
}
+void AnalogSignal::on_conversion_changed(int index)
+{
+ data::SignalBase::ConversionType old_conv_type = conversion_type_;
+
+ conversion_type_ = (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+
+ if (conversion_type_ != old_conv_type) {
+ base_->set_conversion_type(conversion_type_);
+ update_conversion_type();
+ }
+}
+
+void AnalogSignal::on_display_type_changed(int index)
+{
+ display_type_ = (DisplayType)(display_type_cb_->itemData(index).toInt());
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+}
+
} // namespace TraceView
} // namespace views
} // namespace pv
projects / pulseview.git / blobdiff