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)
{
connect(analog_data, SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
this, SLOT(on_samples_added()));
+ connect(&delayed_conversion_starter_, SIGNAL(timeout()),
+ this, SLOT(on_delayed_conversion_starter()));
+ delayed_conversion_starter_.setSingleShot(true);
+ delayed_conversion_starter_.setInterval(1000); // 1s timeout
+
+ 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
}
if ((display_type_ == DisplayConverted) || (display_type_ == DisplayBoth)) {
- if (((conversion_type_ == data::SignalBase::A2LConversionByTreshold) ||
- (conversion_type_ == data::SignalBase::A2LConversionBySchmittTrigger))) {
+ const data::SignalBase::ConversionType conv_type =
+ base_->get_conversion_type();
+
+ if (((conv_type == data::SignalBase::A2LConversionByTreshold) ||
+ (conv_type == data::SignalBase::A2LConversionBySchmittTrigger))) {
paint_logic_mid(p, pp);
}
scale_ = div_height_ / resolution_;
}
-void AnalogSignal::update_conversion_type()
+void AnalogSignal::update_conversion_widgets()
{
- base_->set_conversion_type(conversion_type_);
+ data::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 != data::SignalBase::NoConversion);
+ display_type_cb_->setEnabled(conv_type != data::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 == data::SignalBase::A2LConversionByTreshold) {
+ const vector<double> thresholds = base_->get_conversion_thresholds(
+ data::SignalBase::A2LConversionByTreshold, true);
+ conv_threshold_cb_->addItem(
+ QString("%1V").arg(QString::number(thresholds[0], 'f', 1)), -1);
+ }
+
+ if (conv_type == data::SignalBase::A2LConversionBySchmittTrigger) {
+ const vector<double> thresholds = base_->get_conversion_thresholds(
+ data::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);
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_));
+ 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+Converted"), DisplayBoth);
cur_idx = display_type_cb_->findData(QVariant(display_type_));
display_type_cb_->setCurrentIndex(cur_idx);
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_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_;
+ data::SignalBase::ConversionType old_conv_type =
+ base_->get_conversion_type();
+
+ data::SignalBase::ConversionType conv_type =
+ (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
- conversion_type_ = (data::SignalBase::ConversionType)(conversion_cb_->itemData(index).toInt());
+ if (conv_type != old_conv_type) {
+ base_->set_conversion_type(conv_type);
+ update_conversion_widgets();
- if (conversion_type_ != old_conv_type) {
- base_->set_conversion_type(conversion_type_);
- update_conversion_type();
+ if (owner_)
+ owner_->row_item_appearance_changed(false, true);
}
}
+void AnalogSignal::on_conv_threshold_changed(int index)
+{
+ data::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 == data::SignalBase::A2LConversionByTreshold && 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
+
+ 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
+ if (base_->set_conversion_option("threshold_value", thr))
+ delayed_conversion_starter_.start();
+ }
+
+ if (conv_type == data::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
+ 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)
+ delayed_conversion_starter_.start();
+ }
+
+ base_->set_conversion_preset(index);
+
+ // Immediately start the conversion if we're not asking for a delayed reaction
+ if (!delayed_conversion_starter_.isActive())
+ base_->start_conversion();
+}
+
+void AnalogSignal::on_delayed_conversion_starter()
+{
+ base_->start_conversion();
+}
+
void AnalogSignal::on_display_type_changed(int index)
{
display_type_ = (DisplayType)(display_type_cb_->itemData(index).toInt());
projects / pulseview.git / blobdiff