using std::shared_ptr;
using std::vector;
+using pv::data::SignalBase;
+
namespace pv {
namespace views {
namespace trace {
QColor(0x4E, 0x9A, 0x06) // Green
};
+const QPen AnalogSignal::AxisPen(QColor(0, 0, 0, 30 * 256 / 100), 2);
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 QColor AnalogSignal::ThresholdColor = QColor(0, 0, 0, 30 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorLo = QColor(255, 0, 0, 8 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorNe = QColor(0, 0, 0, 6 * 256 / 100);
+const QColor AnalogSignal::ThresholdColorHi = QColor(0, 255, 0, 8 * 256 / 100);
+
const int64_t AnalogSignal::TracePaintBlockSize = 1024 * 1024; // 4 MiB (due to float)
const float AnalogSignal::EnvelopeThreshold = 64.0f;
Signal(session, base),
scale_index_(4), // 20 per div
scale_index_drag_offset_(0),
- div_height_(3 * QFontMetrics(QApplication::font()).height()),
pos_vdivs_(1),
neg_vdivs_(1),
resolution_(0),
- conversion_type_(data::SignalBase::NoConversion),
display_type_(DisplayBoth),
autoranging_(true)
{
+ axis_pen_ = AxisPen;
+
pv::data::Analog* analog_data =
dynamic_cast<pv::data::Analog*>(data().get());
- connect(analog_data, SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
- this, SLOT(on_samples_added()));
+ connect(analog_data, SIGNAL(min_max_changed(float, float)),
+ this, SLOT(on_min_max_changed(float, float)));
+
+ GlobalSettings gs;
+ div_height_ = gs.value(GlobalSettings::Key_View_DefaultDivHeight).toInt();
base_->set_colour(SignalColours[base_->index() % countof(SignalColours)]);
update_scale();
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_);
+ settings.setValue("div_height", div_height_);
}
void AnalogSignal::restore_settings(QSettings &settings)
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();
+
+ if (settings.contains("div_height")) {
+ const int old_height = div_height_;
+ div_height_ = settings.value("div_height").toInt();
+
+ if ((div_height_ != old_height) && owner_) {
+ // Call order is important, otherwise the lazy event handler won't work
+ owner_->extents_changed(false, true);
+ owner_->row_item_appearance_changed(false, true);
+ }
+ }
}
pair<int, int> AnalogSignal::v_extents() const
void AnalogSignal::paint_back(QPainter &p, ViewItemPaintParams &pp)
{
- if (base_->enabled()) {
+ if (!base_->enabled())
+ return;
+
+ // TODO Register a change handler instead of querying this with every repaint
+ GlobalSettings settings;
+ const bool show_conversion_thresholds =
+ settings.value(GlobalSettings::Key_View_ShowConversionThresholds).toBool();
+
+ const vector<double> thresholds = base_->get_conversion_thresholds();
+
+ // Only display thresholds if we have some and we show analog samples
+ if ((thresholds.size() > 0) && show_conversion_thresholds &&
+ ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth))) {
+
+ const int visual_y = get_visual_y();
+ const pair<int, int> extents = v_extents();
+ const int top = visual_y + extents.first;
+ const int btm = visual_y + extents.second;
+
+ // Draw high/neutral/low areas
+ if (thresholds.size() == 2) {
+ const double thr_lo = visual_y - thresholds[0] * scale_;
+ const double thr_hi = visual_y - thresholds[1] * scale_;
+
+ p.fillRect(QRectF(pp.left(), top, pp.width(), thr_hi - top),
+ QBrush(ThresholdColorHi));
+ p.fillRect(QRectF(pp.left(), thr_hi, pp.width(), thr_lo - thr_hi),
+ QBrush(ThresholdColorNe));
+ p.fillRect(QRectF(pp.left(), thr_lo, pp.width(), btm - thr_lo),
+ QBrush(ThresholdColorLo));
+ } else {
+ const double thr = visual_y - thresholds[0] * scale_;
+
+ p.fillRect(QRectF(pp.left(), top, pp.width(), thr - top),
+ QBrush(ThresholdColorHi));
+ p.fillRect(QRectF(pp.left(), thr, pp.width(), btm - thr),
+ QBrush(ThresholdColorLo));
+ }
+
+ paint_axis(p, pp, get_visual_y());
+ } else {
Trace::paint_back(p, pp);
paint_axis(p, pp, get_visual_y());
}
pixels_offset, samples_per_pixel);
}
- if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth)) {
- if (((conversion_type_ == data::SignalBase::A2LConversionByTreshold) ||
- (conversion_type_ == data::SignalBase::A2LConversionBySchmittTrigger))) {
-
- paint_logic_mid(p, pp);
- }
- }
+ if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth))
+ paint_logic_mid(p, pp);
}
void AnalogSignal::paint_fore(QPainter &p, ViewItemPaintParams &pp)
int64_t sample_count = min(points_count, TracePaintBlockSize);
int64_t block_sample = 0;
- const float *sample_block = segment->get_samples(start, start + sample_count);
+ float *sample_block = new float[TracePaintBlockSize];
+ segment->get_samples(start, start + sample_count, sample_block);
const int w = 2;
for (int64_t sample = start; sample != end; sample++, block_sample++) {
if (block_sample == TracePaintBlockSize) {
block_sample = 0;
- delete[] sample_block;
sample_count = min(points_count - sample, TracePaintBlockSize);
- sample_block = segment->get_samples(sample, sample + sample_count);
+ segment->get_samples(sample, sample + sample_count, sample_block);
}
const float x = (sample / samples_per_pixel -
scale_ = div_height_ / resolution_;
}
-void AnalogSignal::update_conversion_type()
+void AnalogSignal::update_conversion_widgets()
{
- base_->set_conversion_type(conversion_type_);
+ SignalBase::ConversionType conv_type = base_->get_conversion_type();
- if (owner_)
- owner_->row_item_appearance_changed(false, true);
+ // Enable or disable widgets depending on conversion state
+ conv_threshold_cb_->setEnabled(conv_type != SignalBase::NoConversion);
+ display_type_cb_->setEnabled(conv_type != SignalBase::NoConversion);
+
+ conv_threshold_cb_->clear();
+
+ vector < pair<QString, int> > presets = base_->get_conversion_presets();
+
+ // Prevent the combo box from firing the "edit text changed" signal
+ // as that would involuntarily select the first entry
+ conv_threshold_cb_->blockSignals(true);
+
+ // Set available options depending on chosen conversion
+ for (pair<QString, int> preset : presets)
+ conv_threshold_cb_->addItem(preset.first, preset.second);
+
+ map < QString, QVariant > options = base_->get_conversion_options();
+
+ if (conv_type == SignalBase::A2LConversionByThreshold) {
+ const vector<double> thresholds = base_->get_conversion_thresholds(
+ SignalBase::A2LConversionByThreshold, true);
+ conv_threshold_cb_->addItem(
+ QString("%1V").arg(QString::number(thresholds[0], 'f', 1)), -1);
+ }
+
+ if (conv_type == SignalBase::A2LConversionBySchmittTrigger) {
+ const vector<double> thresholds = base_->get_conversion_thresholds(
+ SignalBase::A2LConversionBySchmittTrigger, true);
+ conv_threshold_cb_->addItem(QString("%1V/%2V").arg(
+ QString::number(thresholds[0], 'f', 1),
+ QString::number(thresholds[1], 'f', 1)), -1);
+ }
+
+ int preset_id = base_->get_current_conversion_preset();
+ conv_threshold_cb_->setCurrentIndex(
+ conv_threshold_cb_->findData(preset_id));
+
+ conv_threshold_cb_->blockSignals(false);
}
void AnalogSignal::perform_autoranging(bool keep_divs, bool force_update)
QFormLayout *const layout = new QFormLayout;
- // Add the number of vdivs
+ // Add div-related settings
pvdiv_sb_ = new QSpinBox(parent);
pvdiv_sb_->setRange(0, MaximumVDivs);
pvdiv_sb_->setValue(pos_vdivs_);
this, SLOT(on_neg_vdivs_changed(int)));
layout->addRow(tr("Number of neg vertical divs"), nvdiv_sb_);
+ div_height_sb_ = new QSpinBox(parent);
+ div_height_sb_->setRange(20, 1000);
+ div_height_sb_->setSingleStep(5);
+ div_height_sb_->setSuffix(tr(" pixels"));
+ div_height_sb_->setValue(div_height_);
+ connect(div_height_sb_, SIGNAL(valueChanged(int)),
+ this, SLOT(on_div_height_changed(int)));
+ layout->addRow(tr("Div height"), div_height_sb_);
+
// Add the vertical resolution
resolution_cb_ = new QComboBox(parent);
// 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);
+ conversion_cb_->addItem(tr("none"),
+ SignalBase::NoConversion);
+ conversion_cb_->addItem(tr("to logic via threshold"),
+ SignalBase::A2LConversionByThreshold);
+ conversion_cb_->addItem(tr("to logic via schmitt-trigger"),
+ SignalBase::A2LConversionBySchmittTrigger);
- cur_idx = conversion_cb_->findData(QVariant(conversion_type_));
+ cur_idx = conversion_cb_->findData(QVariant(base_->get_conversion_type()));
conversion_cb_->setCurrentIndex(cur_idx);
-// layout->addRow(tr("Conversion"), conversion_cb_);
+ layout->addRow(tr("Conversion"), conversion_cb_);
connect(conversion_cb_, SIGNAL(currentIndexChanged(int)),
this, SLOT(on_conversion_changed(int)));
+ // Add the conversion threshold settings
+ conv_threshold_cb_ = new QComboBox();
+ conv_threshold_cb_->setEditable(true);
+
+ layout->addRow(tr("Conversion threshold(s)"), conv_threshold_cb_);
+
+ connect(conv_threshold_cb_, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(on_conv_threshold_changed(int)));
+ connect(conv_threshold_cb_, SIGNAL(editTextChanged(const QString)),
+ this, SLOT(on_conv_threshold_changed())); // index will be -1
+
// 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);
+ display_type_cb_->addItem(tr("analog"), DisplayAnalog);
+ display_type_cb_->addItem(tr("converted"), DisplayConverted);
+ display_type_cb_->addItem(tr("analog+converted"), 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_);
+ layout->addRow(tr("Show traces for"), display_type_cb_);
connect(display_type_cb_, SIGNAL(currentIndexChanged(int)),
this, SLOT(on_display_type_changed(int)));
+ // Update the conversion widget contents and states
+ update_conversion_widgets();
+
form->addRow(layout);
}
-void AnalogSignal::on_samples_added()
+void AnalogSignal::on_min_max_changed(float min, float max)
{
- perform_autoranging(false, false);
+ (void)min;
+ (void)max;
+
+ if (autoranging_)
+ perform_autoranging(false, false);
}
void AnalogSignal::on_pos_vdivs_changed(int vdivs)
}
}
+void AnalogSignal::on_div_height_changed(int height)
+{
+ div_height_ = height;
+ update_scale();
+
+ if (owner_) {
+ // Call order is important, otherwise the lazy event handler won't work
+ owner_->extents_changed(false, true);
+ owner_->row_item_appearance_changed(false, true);
+ }
+}
+
void AnalogSignal::on_resolution_changed(int index)
{
scale_index_ = resolution_cb_->itemData(index).toInt();
void AnalogSignal::on_conversion_changed(int index)
{
- data::SignalBase::ConversionType old_conv_type = conversion_type_;
+ SignalBase::ConversionType old_conv_type = base_->get_conversion_type();
+
+ SignalBase::ConversionType conv_type =
+ (SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+
+ if (conv_type != old_conv_type) {
+ base_->set_conversion_type(conv_type);
+ update_conversion_widgets();
+
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
+ }
+}
+
+void AnalogSignal::on_conv_threshold_changed(int index)
+{
+ SignalBase::ConversionType conv_type = base_->get_conversion_type();
+
+ // Note: index is set to -1 if the text in the combo box matches none of
+ // the entries in the combo box
+
+ if ((index == -1) && (conv_threshold_cb_->currentText().length() == 0))
+ return;
+
+ // The combo box entry with the custom value has user_data set to -1
+ const int user_data = conv_threshold_cb_->findText(
+ conv_threshold_cb_->currentText());
+
+ const bool use_custom_thr = (index == -1) || (user_data == -1);
+
+ if (conv_type == SignalBase::A2LConversionByThreshold && use_custom_thr) {
+ // Not one of the preset values, try to parse the combo box text
+ // Note: Regex loosely based on
+ // https://txt2re.com/index-c++.php3?s=0.1V&1&-13
+ QString re1 = "([+-]?\\d*[\\.,]?\\d*)"; // Float value
+ QString re2 = "([a-zA-Z]*)"; // SI unit
+ QRegExp regex(re1 + re2);
- conversion_type_ = (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+ const QString text = conv_threshold_cb_->currentText();
+ if (!regex.exactMatch(text))
+ return; // String doesn't match the regex
- if (conversion_type_ != old_conv_type) {
- base_->set_conversion_type(conversion_type_);
- update_conversion_type();
+ QStringList tokens = regex.capturedTexts();
+
+ // For now, we simply assume that the unit is volt without modifiers
+ const double thr = tokens.at(1).toDouble();
+
+ // Only restart the conversion if the threshold was updated.
+ // We're starting a delayed conversion because the user may still be
+ // typing and the UI would lag if we kept on restarting it immediately
+ if (base_->set_conversion_option("threshold_value", thr))
+ base_->start_conversion(true);
}
+
+ if (conv_type == SignalBase::A2LConversionBySchmittTrigger && use_custom_thr) {
+ // Not one of the preset values, try to parse the combo box text
+ // Note: Regex loosely based on
+ // https://txt2re.com/index-c++.php3?s=0.1V/0.2V&2&14&-22&3&15
+ QString re1 = "([+-]?\\d*[\\.,]?\\d*)"; // Float value
+ QString re2 = "([a-zA-Z]*)"; // SI unit
+ QString re3 = "\\/"; // Forward slash, not captured
+ QString re4 = "([+-]?\\d*[\\.,]?\\d*)"; // Float value
+ QString re5 = "([a-zA-Z]*)"; // SI unit
+ QRegExp regex(re1 + re2 + re3 + re4 + re5);
+
+ const QString text = conv_threshold_cb_->currentText();
+ if (!regex.exactMatch(text))
+ return; // String doesn't match the regex
+
+ QStringList tokens = regex.capturedTexts();
+
+ // For now, we simply assume that the unit is volt without modifiers
+ const double low_thr = tokens.at(1).toDouble();
+ const double high_thr = tokens.at(3).toDouble();
+
+ // Only restart the conversion if one of the options was updated.
+ // We're starting a delayed conversion because the user may still be
+ // typing and the UI would lag if we kept on restarting it immediately
+ bool o1 = base_->set_conversion_option("threshold_value_low", low_thr);
+ bool o2 = base_->set_conversion_option("threshold_value_high", high_thr);
+ if (o1 || o2)
+ base_->start_conversion(true); // Start delayed conversion
+ }
+
+ base_->set_conversion_preset((SignalBase::ConversionPreset)index);
+
+ // Immediately start the conversion if we're not using custom values
+ // (i.e. we're using one of the presets)
+ if (!use_custom_thr)
+ base_->start_conversion();
+}
+
+void AnalogSignal::on_delayed_conversion_starter()
+{
+ base_->start_conversion();
}
void AnalogSignal::on_display_type_changed(int index)
projects / pulseview.git / blobdiff