mirror of
https://github.com/jankae/LibreVNA.git
synced 2026-04-06 23:13:43 +00:00
Move eye diagram from tools to new graph type, enable zoom/pan on graphs
This commit is contained in:
Jan Käberich
parent
329f4487ee
commit
ee3c6274ad
23 changed files with 1997 additions and 1052 deletions
938
Software/PC_Application/LibreVNA-GUI/Traces/eyediagramplot.cpp
Normal file
938
Software/PC_Application/LibreVNA-GUI/Traces/eyediagramplot.cpp
Normal file
|
|
@ -0,0 +1,938 @@
|
|||
#include "eyediagramplot.h"
|
||||
|
||||
#include "ui_eyediagrameditdialog.h"
|
||||
#include "unit.h"
|
||||
#include "Util/prbs.h"
|
||||
#include "Util/util.h"
|
||||
#include "fftcomplex.h"
|
||||
#include "preferences.h"
|
||||
#include "appwindow.h"
|
||||
|
||||
#include <random>
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
|
||||
#include <QFileDialog>
|
||||
#include <QPainter>
|
||||
#include <QPushButton>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
EyeDiagramPlot::EyeDiagramPlot(TraceModel &model, QWidget *parent)
|
||||
: TracePlot(model, parent),
|
||||
trace(nullptr),
|
||||
updating(false),
|
||||
updateScheduled(false),
|
||||
xSamples(200),
|
||||
datarate(100000000),
|
||||
highlevel(1.0),
|
||||
lowlevel(0.0),
|
||||
bitsPerSymbol(1),
|
||||
risetime(0.000000001),
|
||||
falltime(0.000000001),
|
||||
noise(0.01),
|
||||
jitter(0.0000000001),
|
||||
linearEdge(true),
|
||||
patternbits(9),
|
||||
cycles(200)
|
||||
{
|
||||
plotAreaTop = 0;
|
||||
plotAreaLeft = 0;
|
||||
plotAreaWidth = 0;
|
||||
plotAreaBottom = 0;
|
||||
|
||||
tdr = new Math::TDR;
|
||||
|
||||
calcData = &data[0];
|
||||
displayData = &data[1];
|
||||
|
||||
xAxis.set(XAxis::Type::Time, false, true, 0, 0.000001, 1);
|
||||
yAxis.set(YAxis::Type::Real, false, true, -1, 1, 1);
|
||||
initializeTraceInfo();
|
||||
|
||||
connect(tdr, &Math::TDR::outputSamplesChanged, this, &EyeDiagramPlot::triggerUpdate);
|
||||
|
||||
replot();
|
||||
}
|
||||
|
||||
EyeDiagramPlot::~EyeDiagramPlot()
|
||||
{
|
||||
while(updating) {
|
||||
std::this_thread::sleep_for(20ms);
|
||||
}
|
||||
delete tdr;
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::enableTrace(Trace *t, bool enabled)
|
||||
{
|
||||
if(enabled) {
|
||||
// only one trace at a time is allowed, disable all others
|
||||
for(auto t : traces) {
|
||||
if(t.second) {
|
||||
enableTrace(t.first, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
TracePlot::enableTrace(t, enabled);
|
||||
if(enabled) {
|
||||
trace = t;
|
||||
tdr->assignInput(trace);
|
||||
} else {
|
||||
if(trace) {
|
||||
tdr->removeInput();
|
||||
while(updating) {
|
||||
std::this_thread::sleep_for(20ms);
|
||||
}
|
||||
displayData->clear();
|
||||
calcData->clear();
|
||||
}
|
||||
trace = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::replot()
|
||||
{
|
||||
if(xAxis.getAutorange()) {
|
||||
xAxis.set(xAxis.getType(), false, true, 0, calculatedTime(), 8);
|
||||
}
|
||||
if(yAxis.getAutorange()) {
|
||||
yAxis.set(yAxis.getType(), false, true, minDisplayVoltage(), maxDisplayVoltage(), 8);
|
||||
}
|
||||
TracePlot::replot();
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::move(const QPoint &vect)
|
||||
{
|
||||
if(!xAxis.getLog()) {
|
||||
// can only move axis in linear mode
|
||||
// calculate amount of movement
|
||||
double distance = xAxis.inverseTransform(vect.x(), 0, plotAreaWidth) - xAxis.getRangeMin();
|
||||
xAxis.set(xAxis.getType(), false, false, xAxis.getRangeMin() - distance, xAxis.getRangeMax() - distance, xAxis.getRangeDiv());
|
||||
}
|
||||
if(!yAxis.getLog()) {
|
||||
// can only move axis in linear mode
|
||||
// calculate amount of movement
|
||||
double distance = yAxis.inverseTransform(vect.y(), 0, plotAreaTop - plotAreaBottom) - yAxis.getRangeMin();
|
||||
yAxis.set(yAxis.getType(), false, false, yAxis.getRangeMin() - distance, yAxis.getRangeMax() - distance, yAxis.getRangeDiv());
|
||||
}
|
||||
replot();
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::zoom(const QPoint ¢er, double factor, bool horizontally, bool vertically)
|
||||
{
|
||||
if(horizontally && !xAxis.getLog()) {
|
||||
// can only zoom axis in linear mode
|
||||
// calculate center point
|
||||
double cp = xAxis.inverseTransform(center.x(), plotAreaLeft, plotAreaLeft + plotAreaWidth);
|
||||
double min = ((xAxis.getRangeMin() - cp) * factor) + cp;
|
||||
double max = ((xAxis.getRangeMax() - cp) * factor) + cp;
|
||||
xAxis.set(xAxis.getType(), false, false, min, max, xAxis.getRangeDiv() * factor);
|
||||
}
|
||||
if(vertically) {
|
||||
// can only move axis in linear mode
|
||||
// calculate center point
|
||||
double cp = yAxis.inverseTransform(center.y(), plotAreaBottom, plotAreaTop);
|
||||
double min = ((yAxis.getRangeMin() - cp) * factor) + cp;
|
||||
double max = ((yAxis.getRangeMax() - cp) * factor) + cp;
|
||||
yAxis.set(yAxis.getType(), false, false, min, max, yAxis.getRangeDiv() * factor);
|
||||
}
|
||||
replot();
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::setAuto(bool horizontally, bool vertically)
|
||||
{
|
||||
if(horizontally) {
|
||||
xAxis.set(xAxis.getType(), xAxis.getLog(), true, xAxis.getRangeMin(), xAxis.getRangeMax(), xAxis.getRangeDiv());
|
||||
}
|
||||
if(vertically) {
|
||||
yAxis.set(yAxis.getType(), yAxis.getLog(), true, yAxis.getRangeMin(), yAxis.getRangeMax(), yAxis.getRangeDiv());
|
||||
}
|
||||
replot();
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::fromJSON(nlohmann::json j)
|
||||
{
|
||||
auto jX = j["XAxis"];
|
||||
bool xAuto = jX.value("autorange", xAxis.getAutorange());
|
||||
double xMin = jX.value("min", xAxis.getRangeMin());
|
||||
double xMax = jX.value("max", xAxis.getRangeMax());
|
||||
double xDivs = jX.value("div", xAxis.getRangeDiv());
|
||||
xAxis.set(xAxis.getType(), false, xAuto, xMin, xMax, xDivs);
|
||||
|
||||
auto jY = j["YAxis"];
|
||||
bool yAuto = jY.value("autorange", yAxis.getAutorange());
|
||||
double yMin = jY.value("min", yAxis.getRangeMin());
|
||||
double yMax = jY.value("max", yAxis.getRangeMax());
|
||||
double yDivs = jY.value("div", yAxis.getRangeDiv());
|
||||
yAxis.set(yAxis.getType(), false, yAuto, yMin, yMax, yDivs);
|
||||
|
||||
datarate = j.value("datarate", datarate);
|
||||
risetime = j.value("risetime", risetime);
|
||||
falltime = j.value("falltime", falltime);
|
||||
linearEdge = j.value("linearEdge", linearEdge);
|
||||
highlevel = j.value("highlevel", highlevel);
|
||||
lowlevel = j.value("lowlevel", lowlevel);
|
||||
bitsPerSymbol = j.value("bitPerSymbol", bitsPerSymbol);
|
||||
noise = j.value("noise", noise);
|
||||
jitter = j.value("jitter", jitter);
|
||||
patternbits = j.value("patternBits", patternbits);
|
||||
cycles = j.value("cycles", cycles);
|
||||
xSamples = j.value("xSamples", xSamples);
|
||||
|
||||
for(unsigned int hash : j["traces"]) {
|
||||
// attempt to find the traces with this hash
|
||||
bool found = false;
|
||||
for(auto t : model.getTraces()) {
|
||||
if(t->toHash() == hash) {
|
||||
enableTrace(t, true);
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!found) {
|
||||
qWarning() << "Unable to find trace with hash" << hash;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nlohmann::json EyeDiagramPlot::toJSON()
|
||||
{
|
||||
nlohmann::json j;
|
||||
nlohmann::json jX;
|
||||
jX["autorange"] = yAxis.getAutorange();
|
||||
jX["min"] = xAxis.getRangeMin();
|
||||
jX["max"] = xAxis.getRangeMax();
|
||||
jX["div"] = xAxis.getRangeDiv();
|
||||
j["XAxis"] = jX;
|
||||
nlohmann::json jY;
|
||||
jY["autorange"] = yAxis.getAutorange();
|
||||
jY["min"] = yAxis.getRangeMin();
|
||||
jY["max"] = yAxis.getRangeMax();
|
||||
jY["div"] = yAxis.getRangeDiv();
|
||||
j["YAxis"] = jY;
|
||||
nlohmann::json jtraces;
|
||||
for(auto t : traces) {
|
||||
if(t.second) {
|
||||
jtraces.push_back(t.first->toHash());
|
||||
}
|
||||
}
|
||||
j["traces"] = jtraces;
|
||||
|
||||
j["datarate"] = datarate;
|
||||
j["risetime"] = risetime;
|
||||
j["falltime"] = falltime;
|
||||
j["linearEdge"] = linearEdge;
|
||||
j["highlevel"] = highlevel;
|
||||
j["lowlevel"] = lowlevel;
|
||||
j["bitPerSymbol"] = bitsPerSymbol;
|
||||
j["noise"] = noise;
|
||||
j["jitter"] = jitter;
|
||||
j["patternBits"] = patternbits;
|
||||
j["cycles"] = cycles;
|
||||
j["xSamples"] = xSamples;
|
||||
return j;
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::axisSetupDialog()
|
||||
{
|
||||
auto d = new QDialog(this);
|
||||
d->setAttribute(Qt::WA_DeleteOnClose);
|
||||
auto ui = new Ui::EyeDiagramEditDialog;
|
||||
ui->setupUi(d);
|
||||
|
||||
ui->datarate->setUnit("bps");
|
||||
ui->datarate->setPrefixes(" kMG");
|
||||
ui->datarate->setPrecision(3);
|
||||
|
||||
ui->risetime->setUnit("s");
|
||||
ui->risetime->setPrefixes("pnum ");
|
||||
ui->risetime->setPrecision(3);
|
||||
|
||||
ui->falltime->setUnit("s");
|
||||
ui->falltime->setPrefixes("pnum ");
|
||||
ui->falltime->setPrecision(3);
|
||||
|
||||
ui->highLevel->setUnit("V");
|
||||
ui->highLevel->setPrefixes("m ");
|
||||
ui->highLevel->setPrecision(3);
|
||||
|
||||
ui->lowLevel->setUnit("V");
|
||||
ui->lowLevel->setPrefixes("m ");
|
||||
ui->lowLevel->setPrecision(3);
|
||||
|
||||
ui->noise->setUnit("V");
|
||||
ui->noise->setPrefixes("um ");
|
||||
ui->noise->setPrecision(3);
|
||||
|
||||
ui->jitter->setUnit("s");
|
||||
ui->jitter->setPrefixes("pnum ");
|
||||
ui->jitter->setPrecision(3);
|
||||
|
||||
ui->Xmin->setUnit("s");
|
||||
ui->Xmin->setPrefixes("pnum ");
|
||||
ui->Xmin->setPrecision(5);
|
||||
|
||||
ui->Xmax->setUnit("s");
|
||||
ui->Xmax->setPrefixes("pnum ");
|
||||
ui->Xmax->setPrecision(5);
|
||||
|
||||
ui->Xdivs->setUnit("s");
|
||||
ui->Xdivs->setPrefixes("pnum ");
|
||||
ui->Xdivs->setPrecision(3);
|
||||
|
||||
ui->Ymin->setUnit("V");
|
||||
ui->Ymin->setPrefixes("um ");
|
||||
ui->Ymin->setPrecision(4);
|
||||
|
||||
ui->Ymax->setUnit("V");
|
||||
ui->Ymax->setPrefixes("um ");
|
||||
ui->Ymax->setPrecision(4);
|
||||
|
||||
ui->Ydivs->setUnit("V");
|
||||
ui->Ydivs->setPrefixes("um ");
|
||||
ui->Ydivs->setPrecision(3);
|
||||
|
||||
// set initial values
|
||||
ui->datarate->setValue(datarate);
|
||||
ui->risetime->setValue(risetime);
|
||||
ui->falltime->setValue(falltime);
|
||||
ui->highLevel->setValue(highlevel);
|
||||
ui->lowLevel->setValue(lowlevel);
|
||||
ui->noise->setValue(noise);
|
||||
ui->jitter->setValue(jitter);
|
||||
|
||||
ui->signalLevels->setCurrentIndex(bitsPerSymbol - 1);
|
||||
ui->patternLength->setCurrentIndex(patternbits - 2);
|
||||
ui->fallrisetype->setCurrentIndex(linearEdge ? 0 : 1);
|
||||
|
||||
ui->displayedCycles->setValue(cycles);
|
||||
ui->pointsPerCycle->setValue(xSamples);
|
||||
|
||||
connect(ui->Xauto, &QCheckBox::toggled, [=](bool checked) {
|
||||
ui->Xmin->setEnabled(!checked);
|
||||
ui->Xmax->setEnabled(!checked);
|
||||
ui->Xdivs->setEnabled(!checked);
|
||||
});
|
||||
ui->Xauto->setChecked(xAxis.getAutorange());
|
||||
ui->Xmin->setValue(xAxis.getRangeMin());
|
||||
ui->Xmax->setValue(xAxis.getRangeMax());
|
||||
ui->Xdivs->setValue(xAxis.getRangeDiv());
|
||||
|
||||
connect(ui->Yauto, &QCheckBox::toggled, [=](bool checked) {
|
||||
ui->Ymin->setEnabled(!checked);
|
||||
ui->Ymax->setEnabled(!checked);
|
||||
ui->Ydivs->setEnabled(!checked);
|
||||
});
|
||||
ui->Yauto->setChecked(yAxis.getAutorange());
|
||||
ui->Ymin->setValue(yAxis.getRangeMin());
|
||||
ui->Ymax->setValue(yAxis.getRangeMax());
|
||||
ui->Ydivs->setValue(yAxis.getRangeDiv());
|
||||
|
||||
auto updateValues = [=](){
|
||||
std::lock_guard<std::mutex> guard(calcMutex);
|
||||
datarate = ui->datarate->value();
|
||||
risetime = ui->risetime->value();
|
||||
falltime = ui->falltime->value();
|
||||
highlevel = ui->highLevel->value();
|
||||
lowlevel = ui->lowLevel->value();
|
||||
noise = ui->noise->value();
|
||||
jitter = ui->jitter->value();
|
||||
|
||||
bitsPerSymbol = ui->signalLevels->currentIndex() + 1;
|
||||
patternbits = ui->patternLength->currentIndex() + 2;
|
||||
linearEdge = ui->fallrisetype->currentIndex() == 0;
|
||||
|
||||
cycles = ui->displayedCycles->value();
|
||||
xSamples = ui->pointsPerCycle->value();
|
||||
|
||||
xAxis.set(xAxis.getType(), false, ui->Xauto->isChecked(), ui->Xmin->value(), ui->Xmax->value(), ui->Xdivs->value());
|
||||
yAxis.set(yAxis.getType(), false, ui->Yauto->isChecked(), ui->Ymin->value(), ui->Ymax->value(), ui->Ydivs->value());
|
||||
};
|
||||
|
||||
connect(ui->buttonBox->button(QDialogButtonBox::Ok), &QPushButton::clicked, [=](){
|
||||
updateValues();
|
||||
});
|
||||
connect(ui->buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked, [=](){
|
||||
updateValues();
|
||||
});
|
||||
|
||||
if(AppWindow::showGUI()) {
|
||||
d->show();
|
||||
}
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::updateContextMenu()
|
||||
{
|
||||
contextmenu->clear();
|
||||
auto setup = new QAction("Setup...", contextmenu);
|
||||
connect(setup, &QAction::triggered, this, &EyeDiagramPlot::axisSetupDialog);
|
||||
contextmenu->addAction(setup);
|
||||
|
||||
contextmenu->addSeparator();
|
||||
auto image = new QAction("Save image...", contextmenu);
|
||||
contextmenu->addAction(image);
|
||||
connect(image, &QAction::triggered, [=]() {
|
||||
auto filename = QFileDialog::getSaveFileName(nullptr, "Save plot image", "", "PNG image files (*.png)", nullptr, QFileDialog::DontUseNativeDialog);
|
||||
if(filename.isEmpty()) {
|
||||
// aborted selection
|
||||
return;
|
||||
}
|
||||
if(filename.endsWith(".png")) {
|
||||
filename.chop(4);
|
||||
}
|
||||
filename += ".png";
|
||||
grab().save(filename);
|
||||
});
|
||||
|
||||
contextmenu->addSection("Traces");
|
||||
// Populate context menu
|
||||
for(auto t : orderedTraces()) {
|
||||
if(!supported(t)) {
|
||||
continue;
|
||||
}
|
||||
auto action = new QAction(t->name(), contextmenu);
|
||||
action->setCheckable(true);
|
||||
if(traces[t]) {
|
||||
action->setChecked(true);
|
||||
}
|
||||
connect(action, &QAction::toggled, [=](bool active) {
|
||||
enableTrace(t, active);
|
||||
});
|
||||
contextmenu->addAction(action);
|
||||
}
|
||||
|
||||
finishContextMenu();
|
||||
}
|
||||
|
||||
bool EyeDiagramPlot::positionWithinGraphArea(const QPoint &p)
|
||||
{
|
||||
return p.x() >= plotAreaLeft && p.x() <= plotAreaLeft + plotAreaWidth
|
||||
&& p.y() >= plotAreaTop && p.y() <= plotAreaBottom;
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::draw(QPainter &p)
|
||||
{
|
||||
auto &pref = Preferences::getInstance();
|
||||
|
||||
auto w = p.window();
|
||||
auto yAxisSpace = pref.Graphs.fontSizeAxis * 5.5;
|
||||
auto xAxisSpace = pref.Graphs.fontSizeAxis * 3;
|
||||
plotAreaLeft = yAxisSpace;
|
||||
plotAreaWidth = w.width() - plotAreaLeft - 10;
|
||||
plotAreaTop = 10;
|
||||
plotAreaBottom = w.height() - xAxisSpace;
|
||||
|
||||
p.setBackground(QBrush(pref.Graphs.Color.background));
|
||||
p.fillRect(0, 0, width(), height(), QBrush(pref.Graphs.Color.background));
|
||||
|
||||
auto pen = QPen(pref.Graphs.Color.axis, 0);
|
||||
pen.setCosmetic(true);
|
||||
p.setPen(pen);
|
||||
auto plotRect = QRect(plotAreaLeft, plotAreaTop, plotAreaWidth + 1, plotAreaBottom - plotAreaTop + 1);
|
||||
p.drawRect(plotRect);
|
||||
|
||||
// Y axis
|
||||
QString labelY = "Voltage";
|
||||
auto font = p.font();
|
||||
font.setPixelSize(pref.Graphs.fontSizeAxis);
|
||||
p.setFont(font);
|
||||
p.setPen(QPen(pref.Graphs.Color.axis, 1));
|
||||
p.save();
|
||||
p.translate(0, w.height()-xAxisSpace);
|
||||
p.rotate(-90);
|
||||
p.drawText(QRect(0, 0, w.height()-xAxisSpace, pref.Graphs.fontSizeAxis*1.5), Qt::AlignHCenter, labelY);
|
||||
p.restore();
|
||||
|
||||
// draw ticks
|
||||
if(yAxis.getTicks().size() > 0) {
|
||||
// this only works for evenly distributed ticks:
|
||||
auto max = qMax(abs(yAxis.getTicks().front()), abs(yAxis.getTicks().back()));
|
||||
double step;
|
||||
if(yAxis.getTicks().size() >= 2) {
|
||||
step = abs(yAxis.getTicks()[0] - yAxis.getTicks()[1]);
|
||||
} else {
|
||||
// only one tick, set arbitrary number of digits
|
||||
step = max / 1000;
|
||||
}
|
||||
int significantDigits = floor(log10(max)) - floor(log10(step)) + 1;
|
||||
|
||||
for(unsigned int j = 0; j < yAxis.getTicks().size(); j++) {
|
||||
auto yCoord = yAxis.transform(yAxis.getTicks()[j], plotAreaBottom, plotAreaTop);
|
||||
p.setPen(QPen(pref.Graphs.Color.axis, 1));
|
||||
// draw tickmark on axis
|
||||
auto tickStart = plotAreaLeft;
|
||||
auto tickLen = -2;
|
||||
p.drawLine(tickStart, yCoord, tickStart + tickLen, yCoord);
|
||||
QString unit = "";
|
||||
QString prefix = " ";
|
||||
if(pref.Graphs.showUnits) {
|
||||
unit = "V";
|
||||
prefix = "um ";
|
||||
}
|
||||
auto tickValue = Unit::ToString(yAxis.getTicks()[j], unit, prefix, significantDigits);
|
||||
p.drawText(QRectF(0, yCoord - pref.Graphs.fontSizeAxis/2 - 2, tickStart + 2 * tickLen, pref.Graphs.fontSizeAxis), Qt::AlignRight, tickValue);
|
||||
|
||||
// tick lines
|
||||
if(yCoord == plotAreaTop || yCoord == plotAreaBottom) {
|
||||
// skip tick lines right on the plot borders
|
||||
continue;
|
||||
}
|
||||
// only draw tick lines for primary axis
|
||||
if (pref.Graphs.Color.Ticks.Background.enabled) {
|
||||
if (j%2)
|
||||
{
|
||||
int yCoordTop = yAxis.transform(yAxis.getTicks()[j], plotAreaTop, plotAreaBottom);
|
||||
int yCoordBot = yAxis.transform(yAxis.getTicks()[j-1], plotAreaTop, plotAreaBottom);
|
||||
if(yCoordTop > yCoordBot) {
|
||||
auto buf = yCoordBot;
|
||||
yCoordBot = yCoordTop;
|
||||
yCoordTop = buf;
|
||||
}
|
||||
p.setBrush(pref.Graphs.Color.Ticks.Background.background);
|
||||
p.setPen(pref.Graphs.Color.Ticks.Background.background);
|
||||
auto rect = QRect(plotAreaLeft+1, yCoordTop+1, plotAreaWidth-2, yCoordBot-yCoordTop-2);
|
||||
p.drawRect(rect);
|
||||
}
|
||||
}
|
||||
p.setPen(QPen(pref.Graphs.Color.Ticks.divisions, 0.5, Qt::DashLine));
|
||||
p.drawLine(plotAreaLeft, yCoord, plotAreaLeft + plotAreaWidth, yCoord);
|
||||
}
|
||||
}
|
||||
|
||||
// X axis name
|
||||
p.setPen(QPen(pref.Graphs.Color.axis, 1));
|
||||
p.drawText(QRect(plotAreaLeft, w.height()-pref.Graphs.fontSizeAxis*1.5, plotAreaWidth, pref.Graphs.fontSizeAxis*1.5), Qt::AlignHCenter, "Time");
|
||||
|
||||
// draw X axis ticks
|
||||
if(xAxis.getTicks().size() >= 1) {
|
||||
// draw X ticks
|
||||
int significantDigits;
|
||||
// this only works for evenly distributed ticks:
|
||||
auto max = qMax(abs(xAxis.getTicks().front()), abs(xAxis.getTicks().back()));
|
||||
double step;
|
||||
if(xAxis.getTicks().size() >= 2) {
|
||||
step = abs(xAxis.getTicks()[0] - xAxis.getTicks()[1]);
|
||||
} else {
|
||||
// only one tick, set arbitrary number of digits
|
||||
step = max / 1000;
|
||||
}
|
||||
significantDigits = floor(log10(max)) - floor(log10(step)) + 1;
|
||||
QString prefixes = "fpnum kMG";
|
||||
QString unit = "";
|
||||
if(pref.Graphs.showUnits) {
|
||||
unit = xAxis.Unit();
|
||||
}
|
||||
int lastTickLabelEnd = 0;
|
||||
for(auto t : xAxis.getTicks()) {
|
||||
auto xCoord = xAxis.transform(t, plotAreaLeft, plotAreaLeft + plotAreaWidth);
|
||||
p.setPen(QPen(pref.Graphs.Color.axis, 1));
|
||||
p.drawLine(xCoord, plotAreaBottom, xCoord, plotAreaBottom + 2);
|
||||
if(xCoord != plotAreaLeft && xCoord != plotAreaLeft + plotAreaWidth) {
|
||||
p.setPen(QPen(pref.Graphs.Color.Ticks.divisions, 0.5, Qt::DashLine));
|
||||
p.drawLine(xCoord, plotAreaTop, xCoord, plotAreaBottom);
|
||||
}
|
||||
if(xCoord - 40 <= lastTickLabelEnd) {
|
||||
// would overlap previous tick label, skip
|
||||
continue;
|
||||
}
|
||||
auto tickValue = Unit::ToString(t, unit, prefixes, significantDigits);
|
||||
p.setPen(QPen(pref.Graphs.Color.axis, 1));
|
||||
QRect bounding;
|
||||
p.drawText(QRect(xCoord - pref.Graphs.fontSizeAxis*2, plotAreaBottom + 5, pref.Graphs.fontSizeAxis*4,
|
||||
pref.Graphs.fontSizeAxis), Qt::AlignHCenter, tickValue, &bounding);
|
||||
lastTickLabelEnd = bounding.x() + bounding.width();
|
||||
}
|
||||
}
|
||||
|
||||
if(displayData->size() >= 2) {
|
||||
std::lock_guard<std::mutex> guard(bufferSwitchMutex);
|
||||
unsigned int pxWidth = plotAreaWidth;
|
||||
unsigned int pxHeight = plotAreaBottom - plotAreaTop;
|
||||
std::vector<std::vector<unsigned int>> bitmap;
|
||||
bitmap.resize(pxWidth);
|
||||
for(auto &y : bitmap) {
|
||||
y.resize(pxHeight, 0);
|
||||
}
|
||||
unsigned int highestIntensity = 0;
|
||||
unsigned int numTraces = (*displayData)[0].y.size();
|
||||
|
||||
auto addLine = [&](int x0, int y0, int x1, int y1, bool skipFirst = true) {
|
||||
bool first = true;
|
||||
auto putpixel = [&](int x, int y) {
|
||||
if(skipFirst && first) {
|
||||
first = false;
|
||||
return;
|
||||
}
|
||||
if(x < 0 || x >= (int) pxWidth || y < 0 || y >= (int) pxHeight) {
|
||||
return;
|
||||
}
|
||||
auto &bin = bitmap[x][y];
|
||||
bin++;
|
||||
if(bin > highestIntensity) {
|
||||
highestIntensity = bin;
|
||||
}
|
||||
};
|
||||
|
||||
int dx = abs (x1 - x0), sx = x0 < x1 ? 1 : -1;
|
||||
int dy = -abs (y1 - y0), sy = y0 < y1 ? 1 : -1;
|
||||
int err = dx + dy, e2; /* error value e_xy */
|
||||
|
||||
for (;;){ /* loop */
|
||||
putpixel (x0,y0);
|
||||
if (x0 == x1 && y0 == y1) break;
|
||||
e2 = 2 * err;
|
||||
if (e2 >= dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
|
||||
if (e2 <= dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
|
||||
}
|
||||
};
|
||||
|
||||
// Assemble the bitmap
|
||||
for(unsigned int i=1;i<xSamples;i++) {
|
||||
int x0 = xAxis.transform((*displayData)[i-1].x, 0, pxWidth);
|
||||
int x1 = xAxis.transform((*displayData)[i].x, 0, pxWidth);
|
||||
if((x0 < 0 && x1 < 0) || (x0 >= (int) pxWidth && x1 >= (int) pxWidth)) {
|
||||
// completely out of the frame
|
||||
continue;
|
||||
}
|
||||
for(unsigned int j=0;j<numTraces;j++) {
|
||||
int y0 = yAxis.transform((*displayData)[i-1].y[j], pxHeight, 0);
|
||||
int y1 = yAxis.transform((*displayData)[i].y[j], pxHeight, 0);
|
||||
addLine(x0, y0, x1, y1, i > 1);
|
||||
}
|
||||
}
|
||||
|
||||
// draw the bitmap
|
||||
pen = QPen();
|
||||
pen.setCosmetic(true);
|
||||
for(unsigned int i=1;i<pxWidth;i++) {
|
||||
for(unsigned int j=0;j<pxHeight;j++) {
|
||||
if(bitmap[i][j] > 0) {
|
||||
double value = (double) bitmap[i][j] / highestIntensity;
|
||||
pen.setColor(Util::getIntensityGradeColor(value));
|
||||
p.setPen(pen);
|
||||
p.drawPoint(plotAreaLeft + i + 1, plotAreaTop + j + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(dropPending) {
|
||||
p.setOpacity(0.5);
|
||||
p.setBrush(Qt::white);
|
||||
p.setPen(Qt::white);
|
||||
// show drop area over whole plot
|
||||
p.drawRect(plotRect);
|
||||
auto font = p.font();
|
||||
font.setPixelSize(20);
|
||||
p.setFont(font);
|
||||
p.setOpacity(1.0);
|
||||
p.setPen(Qt::white);
|
||||
auto text = "Drop here to add\n" + dropTrace->name() + "\nto waterfall plot";
|
||||
p.drawText(plotRect, Qt::AlignCenter, text);
|
||||
}
|
||||
}
|
||||
|
||||
bool EyeDiagramPlot::supported(Trace *t)
|
||||
{
|
||||
if(t->getDataType() != Trace::DataType::Frequency) {
|
||||
// wrong domain
|
||||
return false;
|
||||
}
|
||||
if(t->isReflection()) {
|
||||
// can't work with reflection measurements
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
QString EyeDiagramPlot::mouseText(QPoint pos)
|
||||
{
|
||||
QString ret;
|
||||
if(positionWithinGraphArea(pos)) {
|
||||
// cursor within plot area
|
||||
QPointF coords = pixelToPlotValue(pos);
|
||||
int significantDigits = floor(log10(abs(xAxis.getRangeMax()))) - floor(log10((abs(xAxis.getRangeMax() - xAxis.getRangeMin())) / 1000.0)) + 1;
|
||||
ret += Unit::ToString(coords.x(), xAxis.Unit(), "fpnum kMG", significantDigits) + "\n";
|
||||
auto max = qMax(abs(yAxis.getRangeMax()), abs(yAxis.getRangeMin()));
|
||||
auto step = abs(yAxis.getRangeMax() - yAxis.getRangeMin()) / 1000.0;
|
||||
significantDigits = floor(log10(max)) - floor(log10(step)) + 1;
|
||||
ret += Unit::ToString(coords.y(), "V", yAxis.Prefixes(), significantDigits) + "\n";
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
QPoint EyeDiagramPlot::plotValueToPixel(QPointF plotValue)
|
||||
{
|
||||
QPoint p;
|
||||
p.setX(xAxis.transform(plotValue.x(), plotAreaLeft, plotAreaLeft + plotAreaWidth));
|
||||
p.setY(yAxis.transform(plotValue.y(), plotAreaBottom, plotAreaTop));
|
||||
return p;
|
||||
}
|
||||
|
||||
QPointF EyeDiagramPlot::pixelToPlotValue(QPoint pixel)
|
||||
{
|
||||
QPointF p;
|
||||
p.setX(xAxis.inverseTransform(pixel.x(), plotAreaLeft, plotAreaLeft + plotAreaWidth));
|
||||
p.setY(yAxis.inverseTransform(pixel.y(), plotAreaBottom, plotAreaTop));
|
||||
return p;
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::updateThread(unsigned int xSamples)
|
||||
{
|
||||
std::lock_guard<std::mutex> calc(calcMutex);
|
||||
do {
|
||||
updateScheduled = false;
|
||||
setStatus("Starting calculation...");
|
||||
if(!trace) {
|
||||
setStatus("No trace assigned");
|
||||
continue;
|
||||
}
|
||||
|
||||
qDebug() << "Starting eye diagram calculation";
|
||||
|
||||
// sanity check values
|
||||
if(datarate >= trace->getSample(trace->numSamples() - 1).x) {
|
||||
setStatus("Data rate too high");
|
||||
continue;
|
||||
}
|
||||
if(datarate <= 0) {
|
||||
setStatus("Data rate too low");
|
||||
continue;
|
||||
}
|
||||
if(risetime > 0.3 * 1.0 / datarate) {
|
||||
setStatus("Rise time too high");
|
||||
continue;
|
||||
}
|
||||
if(falltime > 0.3 * 1.0 / datarate) {
|
||||
setStatus("Fall time too high");
|
||||
continue;
|
||||
}
|
||||
if(jitter > 0.3 * 1.0 / datarate) {
|
||||
setStatus("Jitter too high");
|
||||
continue;
|
||||
}
|
||||
|
||||
qDebug() << "Eye calculation: input values okay";
|
||||
|
||||
// calculate timestep
|
||||
double timestep = calculatedTime() / xSamples;
|
||||
// reserve vector for input data
|
||||
std::vector<std::complex<double>> inVec(xSamples * (cycles + 1), 0.0); // needs to calculate one more cycle than required for the display (settling)
|
||||
|
||||
// resize working buffer
|
||||
calcData->clear();
|
||||
calcData->resize(xSamples);
|
||||
for(auto& s : *calcData) {
|
||||
s.y.resize(cycles, 0.0);
|
||||
}
|
||||
|
||||
setStatus("Extracting impulse response...");
|
||||
|
||||
// calculate impulse response of trace
|
||||
double eyeTimeShift = 0;
|
||||
std::vector<std::complex<double>> impulseVec;
|
||||
// determine how long the impulse response is
|
||||
auto samples = tdr->numSamples();
|
||||
if(samples == 0) {
|
||||
// TDR calculation not yet done, unable to update
|
||||
updating = false;
|
||||
setStatus("No time-domain data from trace");
|
||||
return;
|
||||
}
|
||||
auto length = tdr->getSample(samples - 1).x;
|
||||
|
||||
// determine average delay
|
||||
auto total_step = tdr->getStepResponse(samples - 1);
|
||||
for(unsigned int i=0;i<samples;i++) {
|
||||
auto step = tdr->getStepResponse(i);
|
||||
if(abs(total_step - step) <= abs(step)) {
|
||||
// mid point reached
|
||||
eyeTimeShift = tdr->getSample(i).x;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned long convolutedSize = length / timestep;
|
||||
if(convolutedSize > inVec.size()) {
|
||||
// impulse response is longer than what we display, truncate
|
||||
convolutedSize = inVec.size();
|
||||
}
|
||||
impulseVec.resize(convolutedSize);
|
||||
/*
|
||||
* we can't use the impulse response directly because we most likely need samples inbetween
|
||||
* the calculated values. Interpolation is available but if our sample spacing here is much
|
||||
* wider than the impulse response data, we might miss peaks (or severely miscalculate their
|
||||
* amplitude.
|
||||
* Instead, the step response is interpolated and the impulse response determined by deriving
|
||||
* it from the interpolated step response data. As the step response is the integrated imulse
|
||||
* response data, we can't miss narrow peaks that way.
|
||||
*/
|
||||
double lastStepResponse = 0.0;
|
||||
for(unsigned long i=0;i<convolutedSize;i++) {
|
||||
auto x = i*timestep;
|
||||
auto step = tdr->getInterpolatedStepResponse(x);
|
||||
impulseVec[i] = step - lastStepResponse;
|
||||
lastStepResponse = step;
|
||||
}
|
||||
|
||||
eyeTimeShift += (risetime + falltime) * 1.25 / 4;
|
||||
eyeTimeShift += 0.5 / datarate;
|
||||
int eyeXshift = eyeTimeShift / timestep;
|
||||
|
||||
qDebug() << "Eye calculation: TDR calculation done";
|
||||
|
||||
setStatus("Generating PRBS sequence...");
|
||||
|
||||
auto prbs = new PRBS(patternbits);
|
||||
|
||||
auto getNextLevel = [&]() -> unsigned int {
|
||||
unsigned int level = 0;
|
||||
for(unsigned int i=0;i<bitsPerSymbol;i++) {
|
||||
level <<= 1;
|
||||
if(prbs->next()) {
|
||||
level |= 0x01;
|
||||
}
|
||||
}
|
||||
return level;
|
||||
};
|
||||
|
||||
auto levelToVoltage = [=](unsigned int level) -> double {
|
||||
unsigned int maxLevel = (0x01 << bitsPerSymbol) - 1;
|
||||
return Util::Scale((double) level, 0.0, (double) maxLevel, lowlevel, highlevel);
|
||||
};
|
||||
|
||||
unsigned int currentSignal = getNextLevel();
|
||||
unsigned int nextSignal = getNextLevel();
|
||||
|
||||
// initialize random generator
|
||||
std::random_device rd1;
|
||||
std::mt19937 mt_noise(rd1());
|
||||
std::normal_distribution<> dist_noise(0, noise);
|
||||
|
||||
std::random_device rd2;
|
||||
std::mt19937 mt_jitter(rd2());
|
||||
std::normal_distribution<> dist_jitter(0, jitter);
|
||||
|
||||
unsigned int bitcnt = 1;
|
||||
double transitionTime = -10; // assume that we start with a settled input, last transition was "long" ago
|
||||
for(unsigned int i=0;i<inVec.size();i++) {
|
||||
double time = (i+eyeXshift)*timestep;
|
||||
double voltage;
|
||||
if(time >= transitionTime) {
|
||||
// currently within a bit transition
|
||||
double edgeTime = 0;
|
||||
double expTimeConstant;
|
||||
if(currentSignal < nextSignal) {
|
||||
edgeTime = risetime;
|
||||
} else if(currentSignal > nextSignal) {
|
||||
edgeTime = falltime;
|
||||
}
|
||||
if(linearEdge) {
|
||||
// edge is modeled as linear rise/fall
|
||||
// increase slightly to account for typical 10/90% fall/rise time
|
||||
edgeTime *= 1.25;
|
||||
} else {
|
||||
// edge is modeled as exponential rise/fall. Adjust time constant to match
|
||||
// selected rise/fall time (with 10-90% signal rise/fall within specified time)
|
||||
expTimeConstant = edgeTime / 2.197224577;
|
||||
edgeTime = 6 * expTimeConstant; // after six time constants, 99.7% of signal movement has happened
|
||||
}
|
||||
if(time >= transitionTime + edgeTime) {
|
||||
// bit transition settled
|
||||
voltage = levelToVoltage(nextSignal);
|
||||
// move on to the next bit
|
||||
currentSignal = nextSignal;
|
||||
nextSignal = getNextLevel();
|
||||
transitionTime = bitcnt * 1.0 / datarate + dist_jitter(mt_jitter);
|
||||
bitcnt++;
|
||||
} else {
|
||||
// still within rise or fall time
|
||||
double timeSinceEdge = time - transitionTime;
|
||||
double from = levelToVoltage(currentSignal);
|
||||
double to = levelToVoltage(nextSignal);
|
||||
if(linearEdge) {
|
||||
double edgeRatio = timeSinceEdge / edgeTime;
|
||||
voltage = from * (1.0 - edgeRatio) + to * edgeRatio;
|
||||
} else {
|
||||
voltage = from + (1.0 - exp(-timeSinceEdge/expTimeConstant)) * (to - from);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// still before the next edge
|
||||
voltage = levelToVoltage(currentSignal);
|
||||
}
|
||||
voltage += dist_noise(mt_noise);
|
||||
inVec[i] = voltage;
|
||||
}
|
||||
|
||||
// input voltage vector fully assembled
|
||||
qDebug() << "Eye calculation: input data generated";
|
||||
|
||||
setStatus("Performing convolution...");
|
||||
|
||||
qDebug() << "Convolve via FFT start";
|
||||
std::vector<std::complex<double>> outVec;
|
||||
impulseVec.resize(inVec.size(), 0.0);
|
||||
outVec.resize(inVec.size());
|
||||
Fft::convolve(inVec, impulseVec, outVec);
|
||||
qDebug() << "Convolve via FFT stop";
|
||||
|
||||
// fill data from outVec
|
||||
for(unsigned int i=0;i<xSamples;i++) {
|
||||
(*calcData)[i].x = i * timestep;
|
||||
}
|
||||
for(unsigned int i=xSamples;i<inVec.size();i++) {
|
||||
unsigned int x = i % xSamples;
|
||||
unsigned int y = i / xSamples;
|
||||
(*calcData)[x].y[y] = outVec[i].real();
|
||||
}
|
||||
|
||||
qDebug() << "Eye calculation: Convolution done";
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(bufferSwitchMutex);
|
||||
// switch buffers
|
||||
auto buf = displayData;
|
||||
displayData = calcData;
|
||||
calcData = buf;
|
||||
}
|
||||
|
||||
setStatus("Eye calculation complete");
|
||||
replot();
|
||||
} while (updateScheduled);
|
||||
updating = false;
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::triggerUpdate()
|
||||
{
|
||||
if(updating) {
|
||||
// already updating, can't start again, schedule for later
|
||||
updateScheduled = true;
|
||||
} else {
|
||||
updating = true;
|
||||
new std::thread(&EyeDiagramPlot::updateThread, this, xSamples);
|
||||
}
|
||||
}
|
||||
|
||||
void EyeDiagramPlot::setStatus(QString s)
|
||||
{
|
||||
status = s;
|
||||
emit statusChanged(s);
|
||||
}
|
||||
|
||||
double EyeDiagramPlot::calculatedTime()
|
||||
{
|
||||
return 2.0 / datarate;
|
||||
}
|
||||
|
||||
double EyeDiagramPlot::minDisplayVoltage()
|
||||
{
|
||||
auto eyeRange = highlevel - lowlevel;
|
||||
return lowlevel - eyeRange * yOverrange;
|
||||
}
|
||||
|
||||
double EyeDiagramPlot::maxDisplayVoltage()
|
||||
{
|
||||
auto eyeRange = highlevel - lowlevel;
|
||||
return highlevel + eyeRange * yOverrange;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue