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 int64_t AnalogSignal::TracePaintBlockSize = 1024 * 1024; // 4 MiB (due to float)
const float AnalogSignal::EnvelopeThreshold = 64.0f;
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();
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_);
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());
pixels_offset, samples_per_pixel);
}
- if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth)) {
- if (((conversion_type_ == data::SignalBase::A2LConversionByTreshold) ||
- (conversion_type_ == data::SignalBase::A2LConversionBySchmittTrigger))) {
+ const SignalBase::ConversionType conv_type = base_->get_conversion_type();
+ if (((conv_type == SignalBase::A2LConversionByThreshold) ||
+ (conv_type == SignalBase::A2LConversionBySchmittTrigger))) {
+
+ if ((display_type_ == DisplayAnalog) || (display_type_ == DisplayBoth))
+ paint_conversion_thresholds(p, pp);
+
+ if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth))
paint_logic_mid(p, pp);
- }
}
}
delete[] e.samples;
}
+void AnalogSignal::paint_conversion_thresholds(QPainter &p,
+ ViewItemPaintParams &pp)
+{
+ if (!base_->enabled() || !base_->logic_data())
+ 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();
+
+ if (!show_conversion_thresholds)
+ return;
+
+ const vector<double> thresholds = base_->get_conversion_thresholds();
+ const int y = get_visual_y();
+
+ p.setRenderHint(QPainter::Antialiasing, false);
+
+ p.setPen(ThresholdColor);
+
+ if (thresholds.size() == 2) {
+ // Draw as hatched block because two thresholds denote lower/upper level
+ const double thr_y0 = y - thresholds[0] * scale_;
+ const double thr_y1 = y - thresholds[1] * scale_;
+ p.fillRect(QRect(pp.left(), thr_y0, pp.right(), thr_y1 - thr_y0),
+ QBrush(ThresholdColor, Qt::BDiagPattern));
+ } else {
+ // Draw as individual lines
+ for (const double thr : thresholds) {
+ const double thr_y = y - thr * scale_;
+ p.drawLine(QPointF(pp.left(), thr_y), QPointF(pp.right(), thr_y));
+ }
+ }
+
+ p.setRenderHint(QPainter::Antialiasing, true);
+}
+
void AnalogSignal::paint_logic_mid(QPainter &p, ViewItemPaintParams &pp)
{
QLineF *line;
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)
// 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_);
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_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);
+
+ const QString text = conv_threshold_cb_->currentText();
+ if (!regex.exactMatch(text))
+ return; // String doesn't match the regex
- conversion_type_ = (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+ QStringList tokens = regex.capturedTexts();
- if (conversion_type_ != old_conv_type) {
- base_->set_conversion_type(conversion_type_);
- update_conversion_type();
+ // 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