From ea0db34541b36359ffdffa15ab63203f3c56ae22 Mon Sep 17 00:00:00 2001 From: Justin Newberry Date: Thu, 30 Mar 2023 00:24:08 +0000 Subject: [PATCH] wip --- tools/cabana/dbc/dbcmanager.h | 1 + tools/cabana/tools/search.cc | 203 +++++++++++++++++++++++++++------- tools/cabana/tools/search.h | 167 +++++++++++++++++++++++++++- 3 files changed, 333 insertions(+), 38 deletions(-) diff --git a/tools/cabana/dbc/dbcmanager.h b/tools/cabana/dbc/dbcmanager.h index 31183e8199..2f833a9429 100644 --- a/tools/cabana/dbc/dbcmanager.h +++ b/tools/cabana/dbc/dbcmanager.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include #include diff --git a/tools/cabana/tools/search.cc b/tools/cabana/tools/search.cc index 3dba8cddac..d88266fe4d 100644 --- a/tools/cabana/tools/search.cc +++ b/tools/cabana/tools/search.cc @@ -2,8 +2,25 @@ #include -#include "tools/cabana/dbcmanager.h" -#include "tools/cabana/streams/abstractstream.h" + +std::map scanTypeToDisplayName { + {ExactValue, "Exact value"}, + {BiggerThan, "Bigger than..."}, + {SmallerThan, "Smaller than..."}, + {BiggerThan, "Bigger than..."}, + {ValueBetween, "Value between..."}, + {IncreasedValue, "Increased value"}, + {IncreaseValueBy, "Increased value by..."}, + {DecreasedValue, "Decreased value"}, + {DecreasedValueBy, "Decreased value by..."}, + {ChangedValue, "Changed value"}, + {UnchangedValue, "Unchanged value"}, + {UnknownInitialValue, "Unknown initial value"}, +}; + +uint64_t getBitValue(uint64_t val, int offset, int size){ + return (((1 << size) - 1) & (val >> (offset - 1))); +} SearchDlg::SearchDlg(QWidget *parent) : QDialog(parent) { setWindowTitle(tr("Search")); @@ -13,9 +30,12 @@ SearchDlg::SearchDlg(QWidget *parent) : QDialog(parent) { QHBoxLayout *scan_button_layout = new QHBoxLayout(); - QPushButton *first_scan_button = new QPushButton(QString("First Scan"), this); - QPushButton *next_scan_button = new QPushButton(QString("Next Scan"), this); - QPushButton *undo_scan_button = new QPushButton(QString("Undo Scan"), this); + first_scan_button = new QPushButton(QString("..."), this); + next_scan_button = new QPushButton(QString("Next Scan"), this); + undo_scan_button = new QPushButton(QString("Undo Scan"), this); + + undo_scan_button->setEnabled(false); + next_scan_button->setEnabled(false); QObject::connect(first_scan_button, &QPushButton::clicked, [=]() { firstScan(); }); QObject::connect(next_scan_button, &QPushButton::clicked, [=]() { nextScan(); }); @@ -27,13 +47,14 @@ SearchDlg::SearchDlg(QWidget *parent) : QDialog(parent) { QVBoxLayout *search_parameters_layout = new QVBoxLayout(); - QLineEdit *value_box = new QLineEdit(); - value_box->setValidator( new QIntValidator(this) ); + QLineEdit *value_box1 = new QLineEdit(); + value_box1->setValidator( new QIntValidator(this) ); - QObject::connect(value_box, &QLineEdit::textChanged, [=](QString value) { scan_value = value.toInt(); }); + QObject::connect(value_box1, &QLineEdit::textChanged, [=](QString value) { scan_value1 = value.toInt(); }); - QComboBox *scan_type = new QComboBox(); - scan_type->addItem(QString("Exact Value")); + scan_type = new QComboBox(); + + QObject::connect(scan_type, qOverload(&QComboBox::currentIndexChanged), [=](int index) { selectedScanType = (ScanType)(scan_type->itemData(index).toInt()); }); QHBoxLayout *bits_min_max_layout = new QHBoxLayout(); @@ -45,42 +66,92 @@ SearchDlg::SearchDlg(QWidget *parent) : QDialog(parent) { bits_max->setRange(1,32); bits_max->setValue(scan_bits_range_max); - QObject::connect(bits_min, qOverload(&QSpinBox::valueChanged), [=](int value) { scan_bits_range_min=value; }); + QObject::connect(bits_min, qOverload(&QSpinBox::valueChanged), [=](int value) { scan_bits_range_min=value; }); QObject::connect(bits_max, qOverload(&QSpinBox::valueChanged), [=](int value) { scan_bits_range_max=value; }); bits_min_max_layout->addWidget(bits_min); bits_min_max_layout->addWidget(bits_max); - search_parameters_layout->addWidget(value_box); + search_parameters_layout->addWidget(value_box1); + search_parameters_layout->addWidget(scan_type); search_parameters_layout->addLayout(bits_min_max_layout); + QVBoxLayout *search_results_layout = new QVBoxLayout(); + + numberOfSigsLabel = new QLabel(QString("Found: 0")); + search_results_layout->addWidget(numberOfSigsLabel); + + data_table = new QTableWidget(); + data_table->setRowCount(1); + data_table->setColumnCount(3); + + search_results_layout->addWidget(data_table); + main_layout->addLayout(scan_button_layout); main_layout->addLayout(search_parameters_layout); + main_layout->addLayout(search_results_layout); + + update(); } -uint64_t getBitValue(uint64_t val, int offset, int size){ - return (((1 << size) - 1) & (val >> (offset - 1))); +void SearchDlg::setRowData(int row, QString msgID, QString bitRange, QString currentValue, QString previousValue){ + QTableWidgetItem *msg_id = new QTableWidgetItem(msgID); + data_table->setItem(row, 0, msg_id); + + QTableWidgetItem *bit_range = new QTableWidgetItem(bitRange); + data_table->setItem(row, 1, bit_range); + + QTableWidgetItem *current_value = new QTableWidgetItem(currentValue); + data_table->setItem(row, 2, current_value); + + QTableWidgetItem *previous_value = new QTableWidgetItem(previousValue); + data_table->setItem(row, 3, previous_value); } -class Sig { - public: - Sig(MessageId _messageID, int _offset, int _size) : messageID(_messageID), offset(_offset), size(_size) {} +void SearchDlg::update(){ + first_scan_button->setText(scanningStarted ? "New Scan" : "First Scan"); + numberOfSigsLabel->setText(QString("Found: ") + QString::number(filteredSignals.size())); - MessageId messageID; - size_t offset; - size_t size; - - uint64_t getValue(){ - auto msg = can->can_msgs[messageID]; - uint64_t* data = (uint64_t*)(msg.dat.data()); - return getBitValue(*data, offset, size); - } -}; + ScanType selectedValue = (ScanType)(scan_type->currentData().toInt()); + + next_scan_button->setEnabled(scanningStarted); + undo_scan_button->setEnabled(false); + + scan_type->clear(); + + int selectedIndex = -1; + int i = 0; + + for(auto scanType : enabledScanTypes()){ + if(scanType == selectedValue) selectedIndex = i; + scan_type->addItem(QString::fromStdString(scanTypeToDisplayName[scanType]), QVariant(scanType)); + i++; + } + + if(selectedIndex != -1){ + scan_type->setCurrentIndex(selectedIndex); + } + + data_table->clear(); + data_table->setRowCount(filteredSignals.size() + 1); + + setRowData(0, QString("Message ID"), QString("Bit Range"), QString("Current Value"), QString("Previous Value")); + + int row=1; + for(auto &sig : filteredSignals){ + setRowData(row, sig.messageID.toString(), QString("%1:%2").arg(sig.offset).arg(sig.offset+sig.size), QString::number(sig.getValue()), QString::number(sig.previousValue)); + row++; + } + + for(auto &sig : filteredSignals){ + sig.previousValue = sig.getValue(); + } +} std::vector getAllPossibleSignals(int bits_min, int bits_max){ std::vector ret; - for(auto msg_id : can->can_msgs.keys()) { + for(auto msg_id : can->last_msgs.keys()) { for(int i = bits_min; i < bits_max+1; i++) { for(int j = 0; j < 64 - i; j++) { ret.push_back(Sig(msg_id, j, i)); @@ -91,23 +162,81 @@ std::vector getAllPossibleSignals(int bits_min, int bits_max){ return ret; } +std::vector SearchDlg::enabledScanTypes(){ + if(!scanningStarted){ + return std::vector { + ExactValue, + BiggerThan, + SmallerThan, + ValueBetween, + UnknownInitialValue + }; + } + else{ + return std::vector { + ExactValue, + BiggerThan, + SmallerThan, + ValueBetween, + IncreasedValue, + IncreaseValueBy, + DecreasedValue, + DecreasedValueBy, + ChangedValue, + UnchangedValue + }; + } +} + void SearchDlg::firstScan(){ - std::cout << scan_bits_range_min << " " << scan_bits_range_max << " " << scan_value << std::endl; + if(scanningStarted){ + filteredSignals.clear(); + scanningStarted = false; + } + else{ + filteredSignals = getAllPossibleSignals(scan_bits_range_min, scan_bits_range_max); + scanningStarted = true; - std::vector allPossibleValues = getAllPossibleSignals(scan_bits_range_min, scan_bits_range_max); + nextScan(); + } + update(); +} - std::cout << allPossibleValues.size() << std::endl; +SignalFilterer* SearchDlg::getCurrentFilterer() { + if(selectedScanType == ExactValue){ + return new ExactValueSignalFilterer(scan_value1); + } + if(selectedScanType == BiggerThan){ + return new BiggerThanSignalFilterer(scan_value1); + } + if(selectedScanType == SmallerThan){ + return new SmallerThanSignalFilterer(scan_value1); + } + if(selectedScanType == UnknownInitialValue){ + return new UnknownInitialValueSignalFilter(); + } + if(selectedScanType == UnchangedValue){ + return new UnchangedValueSignalFilter(); + } + if(selectedScanType == ChangedValue){ + return new ChangedValueSignalFilter(); + } + if(selectedScanType == IncreasedValue){ + return new IncreasedValueSignalFilter(); + } + if(selectedScanType == DecreasedValue){ + return new DecreasedValueSignalFilter(); + } - std::vector filteredValues; - std::copy_if(allPossibleValues.begin(), allPossibleValues.end(), std::back_inserter(filteredValues), [=](Sig i) { - return i.getValue() == scan_value; - }); - - std::cout << filteredValues.size() << std::endl; + return nullptr; } void SearchDlg::nextScan(){ + auto filterer = getCurrentFilterer(); + + filteredSignals = filterer->filter(filteredSignals); + update(); } void SearchDlg::undoScan(){ diff --git a/tools/cabana/tools/search.h b/tools/cabana/tools/search.h index 7d529e7c42..42ccf48639 100644 --- a/tools/cabana/tools/search.h +++ b/tools/cabana/tools/search.h @@ -8,7 +8,150 @@ #include #include #include +#include +#include +#include +#include + +#include "tools/cabana/dbc/dbcmanager.h" +#include "tools/cabana/streams/abstractstream.h" + +uint64_t getBitValue(uint64_t val, int offset, int size); + +enum ScanType { + ExactValue, + BiggerThan, + SmallerThan, + ValueBetween, + IncreasedValue, + IncreaseValueBy, + DecreasedValue, + DecreasedValueBy, + ChangedValue, + UnchangedValue, + UnknownInitialValue +}; + +class Sig { + public: + Sig(MessageId _messageID, int _offset, int _size) : messageID(_messageID), offset(_offset), size(_size) {} + + MessageId messageID; + size_t offset; + size_t size; + + uint64_t previousValue; + + uint64_t getValue(){ + auto msg = can->last_msgs[messageID]; + uint64_t* data = (uint64_t*)(msg.dat.data()); + return getBitValue(*data, offset, size); + } +}; + +class SignalFilterer { + public: + virtual bool signalMatches(Sig sig) = 0; + + std::vector filter(std::vector in) { + std::vector ret; + + std::copy_if(in.begin(), in.end(), std::back_inserter(ret), [=] (Sig sig) { return signalMatches(sig); }); + + return ret; + } +}; + +class ZeroInputSignalFilterer : public SignalFilterer { + public: + ZeroInputSignalFilterer(){ + + } +}; + +class SingleInputSignalFilterer : public SignalFilterer { + public: + SingleInputSignalFilterer(uint64_t _value) : value(_value){ + + } + protected: + uint64_t value; +}; + +class DoubleInputSignalFilterer : public SignalFilterer { + public: + DoubleInputSignalFilterer(uint64_t _value1, uint64_t _value2) : value1(_value1), value2(_value2){ + + } + protected: + uint64_t value1; + uint64_t value2; +}; + +class ExactValueSignalFilterer : public SingleInputSignalFilterer { + using SingleInputSignalFilterer::SingleInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() == value; + } +}; + +class BiggerThanSignalFilterer : public SingleInputSignalFilterer { + using SingleInputSignalFilterer::SingleInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() > value; + } +}; + +class SmallerThanSignalFilterer : public SingleInputSignalFilterer { + using SingleInputSignalFilterer::SingleInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() < value; + } +}; + +class UnknownInitialValueSignalFilter : public ZeroInputSignalFilterer { + using ZeroInputSignalFilterer::ZeroInputSignalFilterer; + + bool signalMatches(Sig sig) { + return true; + } +}; + +class IncreasedValueSignalFilter : public ZeroInputSignalFilterer { + using ZeroInputSignalFilterer::ZeroInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() > sig.previousValue; + } +}; + +class DecreasedValueSignalFilter : public ZeroInputSignalFilterer { + using ZeroInputSignalFilterer::ZeroInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() < sig.previousValue; + } +}; + +class ChangedValueSignalFilter : public ZeroInputSignalFilterer { + using ZeroInputSignalFilterer::ZeroInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() != sig.previousValue; + } +}; + +class UnchangedValueSignalFilter : public ZeroInputSignalFilterer { + using ZeroInputSignalFilterer::ZeroInputSignalFilterer; + + bool signalMatches(Sig sig) { + return sig.getValue() == sig.previousValue; + } +}; class SearchDlg : public QDialog { Q_OBJECT @@ -21,8 +164,30 @@ private: void nextScan(); void undoScan(); + void update(); + void setRowData(int row, QString msgID, QString bitRange, QString currentValue, QString previousValue); + + std::vector enabledScanTypes(); + + SignalFilterer* getCurrentFilterer(); + + bool scanningStarted = false; + uint32_t scan_bits_range_min = 1; uint32_t scan_bits_range_max = 32; - uint64_t scan_value = 0; + uint64_t scan_value1 = 0; + uint64_t scan_value2 = 0; + + std::vector filteredSignals; + + ScanType selectedScanType; + + QLabel* numberOfSigsLabel; + QComboBox *scan_type; + QPushButton *first_scan_button; + QPushButton *next_scan_button; + QPushButton *undo_scan_button; + + QTableWidget *data_table; }; \ No newline at end of file