594 lines
22 KiB
C++
594 lines
22 KiB
C++
#include "scope.h"
|
|
|
|
#include <QValueAxis>
|
|
#include <QRandomGenerator>
|
|
#include <QGroupBox>
|
|
#include <QStandardItemModel>
|
|
#include <QLabel>
|
|
|
|
Scope::Scope(Digitizer2Gen **digi, unsigned int nDigi, ReadDataThread ** readDataThread, QMainWindow *parent) : QMainWindow(parent){
|
|
this->digi = digi;
|
|
this->nDigi = nDigi;
|
|
this->readDataThread = readDataThread;
|
|
|
|
setWindowTitle("Scope");
|
|
setGeometry(0, 0, 1000, 800);
|
|
setWindowFlags( this->windowFlags() & ~Qt::WindowCloseButtonHint );
|
|
|
|
allowChange = false;
|
|
|
|
plot = new Trace();
|
|
for( int i = 0; i < 6; i++) {
|
|
dataTrace[i] = new QLineSeries();
|
|
dataTrace[i]->setName("Trace " + QString::number(i));
|
|
for(int j = 0; j < 100; j ++) dataTrace[i]->append(40*j, QRandomGenerator::global()->bounded(8000) + 8000);
|
|
plot->addSeries(dataTrace[i]);
|
|
}
|
|
|
|
dataTrace[0]->setPen(QPen(Qt::red, 2));
|
|
dataTrace[1]->setPen(QPen(Qt::blue, 2));
|
|
dataTrace[2]->setPen(QPen(Qt::darkRed, 1));
|
|
dataTrace[3]->setPen(QPen(Qt::darkYellow, 1));
|
|
dataTrace[4]->setPen(QPen(Qt::darkGreen, 1));
|
|
dataTrace[5]->setPen(QPen(Qt::darkBlue, 1));
|
|
|
|
plot->setAnimationOptions(QChart::SeriesAnimations);
|
|
plot->createDefaultAxes(); /// this must be after addSeries();
|
|
/// this must be after createDefaultAxes();
|
|
QValueAxis * yaxis = qobject_cast<QValueAxis*> (plot->axes(Qt::Vertical).first());
|
|
QValueAxis * xaxis = qobject_cast<QValueAxis*> (plot->axes(Qt::Horizontal).first());
|
|
yaxis->setTickCount(6);
|
|
yaxis->setTickInterval(16384);
|
|
yaxis->setRange(-16384, 65536);
|
|
yaxis->setLabelFormat("%.0f");
|
|
|
|
xaxis->setRange(0, 5000);
|
|
xaxis->setTickCount(11);
|
|
xaxis->setLabelFormat("%.0f");
|
|
xaxis->setTitleText("Time [ns]");
|
|
|
|
updateTraceThread = new UpdateTraceThread();
|
|
connect(updateTraceThread, &UpdateTraceThread::updateTrace, this, &Scope::UpdateScope);
|
|
|
|
//*================ add Widgets
|
|
int rowID = -1;
|
|
QWidget * layoutWidget = new QWidget(this);
|
|
setCentralWidget(layoutWidget);
|
|
QGridLayout * layout = new QGridLayout(layoutWidget);
|
|
layoutWidget->setLayout(layout);
|
|
|
|
//------------ Digitizer + channel selection
|
|
rowID ++;
|
|
cbScopeDigi = new QComboBox(this);
|
|
cbScopeCh = new QComboBox(this);
|
|
layout->addWidget(cbScopeDigi, rowID, 0);
|
|
layout->addWidget(cbScopeCh, rowID, 1);
|
|
|
|
connect(cbScopeDigi, &QComboBox::currentIndexChanged, this, [=](){
|
|
//if( allowChange ) StopScope();
|
|
int index = cbScopeDigi->currentIndex();
|
|
if( index == -1 ) return;
|
|
for( int i = 0; i < digi[index]->GetNChannels(); i++){
|
|
cbScopeCh->addItem("ch-" + QString::number(i), i);
|
|
}
|
|
//if( allowChange )StartScope(index);
|
|
});
|
|
|
|
connect(cbScopeCh, &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue("0..63", DIGIPARA::CH::ChannelEnable, "false");
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::ChannelEnable, "true");
|
|
ReadScopeSettings(iDigi, ch);
|
|
digiMTX.unlock();
|
|
});
|
|
|
|
allowChange = false;
|
|
cbScopeDigi->clear(); ///this will also trigger QComboBox::currentIndexChanged
|
|
cbScopeCh->clear();
|
|
for( unsigned int i = 0 ; i < nDigi; i++) {
|
|
cbScopeDigi->addItem("Digi-" + QString::number(digi[i]->GetSerialNumber()), i);
|
|
}
|
|
allowChange = true;
|
|
|
|
|
|
bnScopeReset = new QPushButton("ReProgram Digitizer", this);
|
|
layout->addWidget(bnScopeReset, rowID, 2);
|
|
connect(bnScopeReset, &QPushButton::clicked, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
digi[iDigi]->Reset();
|
|
digi[iDigi]->ProgramPHA(false);
|
|
});
|
|
|
|
bnScopeReadSettings = new QPushButton("Read Ch. Settings", this);
|
|
layout->addWidget(bnScopeReadSettings, rowID, 3);
|
|
connect(bnScopeReadSettings, &QPushButton::clicked, this, [=](){
|
|
if( !allowChange ) return;
|
|
ReadScopeSettings(cbScopeDigi->currentIndex(), cbScopeCh->currentIndex());
|
|
});
|
|
|
|
//TODO----- add copy settings and paste settings
|
|
QCheckBox * chkSetAllChannel = new QCheckBox("apply to all channels", this);
|
|
layout->addWidget(chkSetAllChannel, rowID, 4);
|
|
chkSetAllChannel->setEnabled(false);
|
|
|
|
//------------ Probe selection
|
|
rowID ++;
|
|
//TODO --- add None
|
|
cbAnaProbe[0] = new QComboBox(this);
|
|
cbAnaProbe[0]->addItem("ADC Input", "ADCInput");
|
|
cbAnaProbe[0]->addItem("Time Filter", "TimeFilter");
|
|
cbAnaProbe[0]->addItem("Trapazoid", "EnergyFilter");
|
|
cbAnaProbe[0]->addItem("Trap. Baseline", "EnergyFilterBaseline");
|
|
cbAnaProbe[0]->addItem("Trap. - Baseline", "EnergyFilterMinusBaseline");
|
|
|
|
cbAnaProbe[1] = new QComboBox(this);
|
|
for( int i = 0; i < cbAnaProbe[0]->count() ; i++) cbAnaProbe[1]->addItem(cbAnaProbe[0]->itemText(i), cbAnaProbe[0]->itemData(i));
|
|
|
|
connect(cbAnaProbe[0], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbAnaProbe, 2);});
|
|
connect(cbAnaProbe[1], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbAnaProbe, 2);});
|
|
|
|
cbAnaProbe[0]->setCurrentIndex(1); ///trigger the AnaProbeChange
|
|
cbAnaProbe[0]->setCurrentIndex(0);
|
|
cbAnaProbe[1]->setCurrentIndex(4);
|
|
|
|
connect(cbAnaProbe[0], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveAnalogProbe0, (cbAnaProbe[0]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
|
|
connect(cbAnaProbe[1], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveAnalogProbe1, (cbAnaProbe[1]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
|
|
//TODO --- add None
|
|
cbDigProbe[0] = new QComboBox(this);
|
|
cbDigProbe[0]->addItem("Trigger", "Trigger");
|
|
cbDigProbe[0]->addItem("Time Filter Armed", "TimeFilterArmed");
|
|
cbDigProbe[0]->addItem("ReTrigger Guard", "ReTriggerGuard");
|
|
cbDigProbe[0]->addItem("Trap. basline Freeze", "EnergyFilterBaselineFreeze");
|
|
cbDigProbe[0]->addItem("Peaking", "EnergyFilterPeaking");
|
|
cbDigProbe[0]->addItem("Peak Ready", "EnergyFilterPeakReady");
|
|
cbDigProbe[0]->addItem("Pile-up Guard", "EnergyFilterPileUpGuard");
|
|
cbDigProbe[0]->addItem("Event Pile Up", "EventPileUp");
|
|
cbDigProbe[0]->addItem("ADC Saturate", "ADCSaturation");
|
|
cbDigProbe[0]->addItem("ADC Sat. Protection", "ADCSaturationProtection");
|
|
cbDigProbe[0]->addItem("Post Sat. Event", "PostSaturationEvent");
|
|
cbDigProbe[0]->addItem("Trap. Saturate", "EnergylterSaturation");
|
|
cbDigProbe[0]->addItem("ACQ Inhibit", "AcquisitionInhibit");
|
|
|
|
cbDigProbe[1] = new QComboBox(this);
|
|
cbDigProbe[2] = new QComboBox(this);
|
|
cbDigProbe[3] = new QComboBox(this);
|
|
for( int i = 0; i < cbDigProbe[0]->count() ; i++) {
|
|
cbDigProbe[1]->addItem(cbDigProbe[0]->itemText(i), cbDigProbe[0]->itemData(i));
|
|
cbDigProbe[2]->addItem(cbDigProbe[0]->itemText(i), cbDigProbe[0]->itemData(i));
|
|
cbDigProbe[3]->addItem(cbDigProbe[0]->itemText(i), cbDigProbe[0]->itemData(i));
|
|
}
|
|
|
|
connect(cbDigProbe[0], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[1], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[2], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[3], &QComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
|
|
cbDigProbe[0]->setCurrentIndex(1); ///trigger the DigProbeChange
|
|
cbDigProbe[0]->setCurrentIndex(0);
|
|
cbDigProbe[1]->setCurrentIndex(4);
|
|
cbDigProbe[2]->setCurrentIndex(5);
|
|
cbDigProbe[3]->setCurrentIndex(6);
|
|
|
|
connect(cbDigProbe[0], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveDigitalProbe0, (cbDigProbe[0]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
connect(cbDigProbe[1], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveDigitalProbe1, (cbDigProbe[1]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
connect(cbDigProbe[2], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveDigitalProbe2, (cbDigProbe[2]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
connect(cbDigProbe[3], &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::WaveDigitalProbe3, (cbDigProbe[3]->currentData()).toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
|
|
layout->addWidget(cbAnaProbe[0], rowID, 0);
|
|
layout->addWidget(cbAnaProbe[1], rowID, 1);
|
|
|
|
layout->addWidget(cbDigProbe[0], rowID, 2);
|
|
layout->addWidget(cbDigProbe[1], rowID, 3);
|
|
layout->addWidget(cbDigProbe[2], rowID, 4);
|
|
layout->addWidget(cbDigProbe[3], rowID, 5);
|
|
|
|
rowID ++;
|
|
{//------------ wave settings
|
|
QGroupBox * box = new QGroupBox("Channel Settings (need ACQ stop)", this);
|
|
layout->addWidget(box, rowID, 0, 1, 6);
|
|
|
|
QGridLayout * bLayout = new QGridLayout(box);
|
|
bLayout->setSpacing(0);
|
|
|
|
sbRL = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbRL, "Record Lenght [ns] ", bLayout, 0, 0, 32, 648000, DIGIPARA::TraceStep, DIGIPARA::CH::RecordLength);
|
|
|
|
sbThreshold = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbThreshold, "Threshold [LSB] ", bLayout, 0, 2, 0, 8191, -20, DIGIPARA::CH::TriggerThreshold);
|
|
|
|
cbPolarity = new QComboBox(this);
|
|
cbPolarity->addItem("Pos. +", "Positive");
|
|
cbPolarity->addItem("Neg. -", "Negative");
|
|
ScopeMakeComoBox(cbPolarity, "Polarity ", bLayout, 0, 4, DIGIPARA::CH::Polarity);
|
|
|
|
cbWaveRes = new QComboBox(this);
|
|
cbWaveRes->addItem(" 8 ns", "RES8");
|
|
cbWaveRes->addItem("16 ns", "RES16");
|
|
cbWaveRes->addItem("32 ns", "RES32");
|
|
cbWaveRes->addItem("64 ns", "RES64");
|
|
ScopeMakeComoBox(cbWaveRes, "Wave Re. ", bLayout, 0, 6, DIGIPARA::CH::WaveResolution);
|
|
|
|
//------------------ next row
|
|
sbPT = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbPT, "Pre Trigger [ns] ", bLayout, 1, 0, 32, 32000, DIGIPARA::TraceStep, DIGIPARA::CH::PreTrigger);
|
|
|
|
sbDCOffset = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbDCOffset, "DC offset [%] ", bLayout, 1, 2, 0, 100, -10, DIGIPARA::CH::DC_Offset);
|
|
|
|
sbTimeRiseTime = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTimeRiseTime, "Trigger Rise Time [ns] ", bLayout, 1, 4, 32, 2000, DIGIPARA::TraceStep, DIGIPARA::CH::TimeFilterRiseTime);
|
|
|
|
sbTimeGuard = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTimeGuard, "Trigger Guard [ns] ", bLayout, 1, 6, 0, 8000, DIGIPARA::TraceStep, DIGIPARA::CH::TimeFilterRetriggerGuard);
|
|
|
|
//----------------- next row
|
|
sbTrapRiseTime = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTrapRiseTime, "Trap. Rise Time [ns] ", bLayout, 2, 0, 32, 13000, DIGIPARA::TraceStep, DIGIPARA::CH::EnergyFilterRiseTime);
|
|
|
|
sbTrapFlatTop = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTrapFlatTop, "Trap. Flat Top [ns] ", bLayout, 2, 2, 32, 3000, DIGIPARA::TraceStep, DIGIPARA::CH::EnergyFilterFlatTop);
|
|
|
|
sbTrapPoleZero = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTrapPoleZero, "Trap. Pole Zero [ns] ", bLayout, 2, 4, 32, 524000, DIGIPARA::TraceStep, DIGIPARA::CH::EnergyFilterPoleZero);
|
|
|
|
sbEnergyFineGain = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbEnergyFineGain, "Energy Fine Gain ", bLayout, 2, 6, 1, 10, -1, DIGIPARA::CH::EnergyFilterFineGain);
|
|
|
|
//----------------- next row
|
|
sbTrapPeaking = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbTrapPeaking, "Trap. Peaking [%] ", bLayout, 3, 0, 1, 100, -10, DIGIPARA::CH::EnergyFilterPeakingPosition);
|
|
|
|
cbTrapPeakAvg = new QComboBox(this);
|
|
cbTrapPeakAvg->addItem(" 1 sample", "OneShot");
|
|
cbTrapPeakAvg->addItem(" 4 sample", "LowAVG");
|
|
cbTrapPeakAvg->addItem("16 sample", "MediumAVG");
|
|
cbTrapPeakAvg->addItem("64 sample", "HighAVG");
|
|
ScopeMakeComoBox(cbTrapPeakAvg, "Trap. Peaking ", bLayout, 3, 2, DIGIPARA::CH::EnergyFilterPeakingAvg);
|
|
|
|
sbBaselineGuard = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbBaselineGuard, "Baseline Guard [ns] ", bLayout, 3, 4, 0, 8000, DIGIPARA::TraceStep, DIGIPARA::CH::EnergyFilterBaselineGuard);
|
|
|
|
cbBaselineAvg = new QComboBox(this);
|
|
cbBaselineAvg->addItem(" 0 samp.", "Fixed");
|
|
cbBaselineAvg->addItem(" 16 samp.", "VeryLow");
|
|
cbBaselineAvg->addItem(" 64 samp.", "Low");
|
|
cbBaselineAvg->addItem(" 256 samp.", "MediumLow");
|
|
cbBaselineAvg->addItem(" 1024 samp.", "Medium");
|
|
cbBaselineAvg->addItem(" 4096 samp.", "MediumHigh");
|
|
cbBaselineAvg->addItem("16384 samp.", "High");
|
|
ScopeMakeComoBox(cbBaselineAvg, "Baseline Avg ", bLayout, 3, 6, DIGIPARA::CH::EnergyFilterBaselineAvg);
|
|
//----------------
|
|
|
|
sbPileUpGuard = new QSpinBox(this);
|
|
ScopeMakeSpinBox(sbPileUpGuard, "Pile-up Guard [ns] ", bLayout, 4, 0, 0, 64000, DIGIPARA::TraceStep, DIGIPARA::CH::EnergyFilterPileUpGuard);
|
|
|
|
cbLowFreqFilter = new QComboBox(this);
|
|
cbLowFreqFilter->addItem("Disabled", "Off");
|
|
cbLowFreqFilter->addItem("Enabled", "On");
|
|
ScopeMakeComoBox(cbLowFreqFilter, "Low Freq. Filter ", bLayout, 4, 2, DIGIPARA::CH::EnergyFilterLowFreqFilter);
|
|
|
|
}
|
|
|
|
//------------ plot view
|
|
rowID ++;
|
|
TraceView * plotView = new TraceView(plot);
|
|
plotView->setRenderHints(QPainter::Antialiasing);
|
|
layout->addWidget(plotView, rowID, 0, 1, 6);
|
|
|
|
//TODO zoom and pan, see Zoom Line example
|
|
|
|
//------------ close button
|
|
rowID ++;
|
|
bnScopeStart = new QPushButton("Start", this);
|
|
layout->addWidget(bnScopeStart, rowID, 0);
|
|
bnScopeStart->setEnabled(false);
|
|
connect(bnScopeStart, &QPushButton::clicked, this, [=](){this->StartScope();});
|
|
|
|
bnScopeStop = new QPushButton("Stop", this);
|
|
layout->addWidget(bnScopeStop, rowID, 1);
|
|
connect(bnScopeStop, &QPushButton::clicked, this, &Scope::StopScope);
|
|
|
|
QPushButton * bnClose = new QPushButton("Close", this);
|
|
layout->addWidget(bnClose, rowID, 5);
|
|
connect(bnClose, &QPushButton::clicked, this, &Scope::close);
|
|
|
|
|
|
show();
|
|
|
|
StartScope();
|
|
|
|
}
|
|
|
|
Scope::~Scope(){
|
|
|
|
updateTraceThread->Stop();
|
|
updateTraceThread->quit();
|
|
updateTraceThread->wait();
|
|
delete updateTraceThread;
|
|
|
|
|
|
for( int i = 0; i < 6; i++) delete dataTrace[i];
|
|
|
|
delete plot;
|
|
|
|
}
|
|
|
|
void Scope::ReadScopeSettings(int iDigi, int ch){
|
|
if( !digi[iDigi] && digi[iDigi]->IsDummy() ) return;
|
|
|
|
printf("%s\n", __func__);
|
|
|
|
allowChange = false;
|
|
|
|
for( int i = 0 ; i < 2; i++){
|
|
ScopeReadComboBoxValue(iDigi, ch, cbAnaProbe[i], DIGIPARA::CH::AnalogProbe[i]);
|
|
}
|
|
|
|
for( int i = 0 ; i < 4; i++){
|
|
ScopeReadComboBoxValue(iDigi, ch, cbDigProbe[i], DIGIPARA::CH::DigitalProbe[i]);
|
|
}
|
|
|
|
ScopeReadComboBoxValue(iDigi, ch, cbPolarity, DIGIPARA::CH::Polarity);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbWaveRes, DIGIPARA::CH::WaveResolution);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbTrapPeakAvg, DIGIPARA::CH::EnergyFilterPeakingAvg);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbBaselineAvg, DIGIPARA::CH::EnergyFilterBaselineAvg);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbLowFreqFilter, DIGIPARA::CH::EnergyFilterLowFreqFilter);
|
|
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbRL, DIGIPARA::CH::RecordLength);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbPT, DIGIPARA::CH::PreTrigger);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbDCOffset, DIGIPARA::CH::DC_Offset);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbThreshold, DIGIPARA::CH::TriggerThreshold);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTimeRiseTime, DIGIPARA::CH::TimeFilterRiseTime);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTimeGuard, DIGIPARA::CH::TimeFilterRetriggerGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapRiseTime, DIGIPARA::CH::EnergyFilterRiseTime);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapFlatTop, DIGIPARA::CH::EnergyFilterFlatTop);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapPoleZero, DIGIPARA::CH::EnergyFilterPoleZero);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbEnergyFineGain, DIGIPARA::CH::EnergyFilterFineGain);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapPeaking, DIGIPARA::CH::EnergyFilterPeakingPosition);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbBaselineGuard, DIGIPARA::CH::EnergyFilterBaselineGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbPileUpGuard, DIGIPARA::CH::EnergyFilterPileUpGuard);
|
|
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::StartScope(){
|
|
|
|
if( !digi ) return;
|
|
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
|
|
if( digi[iDigi]->IsDummy() ) return;
|
|
|
|
printf("%s\n", __func__);
|
|
|
|
int ch = cbScopeCh->currentIndex();
|
|
|
|
//*---- set digitizer to take full trace; since in scope mode, no data saving, speed would be fast (How fast?)
|
|
//* when the input rate is faster than trigger rate, Digitizer will stop data taking.
|
|
|
|
ReadScopeSettings(iDigi, ch);
|
|
|
|
digi[iDigi]->WriteChValue("0..63", DIGIPARA::CH::ChannelEnable, "false");
|
|
digi[iDigi]->WriteChValue(std::to_string(ch), DIGIPARA::CH::ChannelEnable, "true");
|
|
digi[iDigi]->SetPHADataFormat(0);
|
|
|
|
digi[iDigi]->StartACQ();
|
|
|
|
readDataThread[iDigi]->SetScopeRun(true);
|
|
readDataThread[iDigi]->start();
|
|
|
|
updateTraceThread->start();
|
|
|
|
ScopeControlOnOff(false);
|
|
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::StopScope(){
|
|
|
|
printf("%s\n", __func__);
|
|
|
|
updateTraceThread->Stop();
|
|
updateTraceThread->quit();
|
|
updateTraceThread->wait();
|
|
|
|
if(digi){
|
|
for(int i = 0; i < nDigi; i++){
|
|
if( digi[i]->IsDummy() ) continue;
|
|
digiMTX.lock();
|
|
digi[i]->StopACQ();
|
|
digi[i]->WriteChValue("0..63", DIGIPARA::CH::ChannelEnable, "true");
|
|
digiMTX.unlock();
|
|
|
|
readDataThread[i]->quit();
|
|
readDataThread[i]->wait();
|
|
|
|
}
|
|
}
|
|
|
|
ScopeControlOnOff(true);
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::UpdateScope(){
|
|
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int sample2ns = DIGIPARA::TraceStep * (1 << cbWaveRes->currentIndex());
|
|
|
|
if( digi ){
|
|
digiMTX.lock();
|
|
unsigned int traceLength = digi[iDigi]->evt->traceLenght;
|
|
unsigned int dataLength = dataTrace[0]->count();
|
|
|
|
//---- remove all points
|
|
for( int j = 0; j < 6; j++ ) dataTrace[j]->removePoints(0, dataLength);
|
|
|
|
for( unsigned int i = 0 ; i < traceLength; i++){
|
|
for( int j = 0; j < 2; j++) dataTrace[j]->append(sample2ns * i, digi[iDigi]->evt->analog_probes[j][i]);
|
|
for( int j = 2; j < 6; j++) dataTrace[j]->append(sample2ns * i, (j-1)*1000 + 4000 * digi[iDigi]->evt->digital_probes[j-2][i]);
|
|
}
|
|
|
|
digiMTX.unlock();
|
|
|
|
plot->axes(Qt::Horizontal).first()->setRange(0, sample2ns * traceLength);
|
|
}
|
|
|
|
}
|
|
|
|
void Scope::ProbeChange(QComboBox * cb[], const int size ){
|
|
|
|
QStandardItemModel * model[size] = {NULL};
|
|
for( int i = 0; i < size; i++){
|
|
model[i] = qobject_cast<QStandardItemModel*>(cb[i]->model());
|
|
}
|
|
|
|
/// Enable all items
|
|
for( int i = 0; i < cb[0]->count(); i++) {
|
|
for( int j = 0; j < size; j ++ ) model[j]->item(i)->setEnabled(true);
|
|
}
|
|
|
|
for( int i = 0; i < size; i++){
|
|
int index = cb[i]->currentIndex();
|
|
for( int j = 0; j < size; j++){
|
|
if( i == j ) continue;
|
|
model[j]->item(index)->setEnabled(false);
|
|
}
|
|
}
|
|
|
|
digiMTX.lock();
|
|
if( size == 2) {// analog probes
|
|
for( int j = 0; j < 2; j++ )dataTrace[j]->setName(cb[j]->currentText());
|
|
}
|
|
if( size == 4){ // digitial probes
|
|
for( int j = 2; j < 6; j++ )dataTrace[j]->setName(cb[j-2]->currentText());
|
|
}
|
|
digiMTX.unlock();
|
|
|
|
}
|
|
|
|
void Scope::ScopeControlOnOff(bool on){
|
|
bnScopeStop->setEnabled(!on);
|
|
|
|
bnScopeStart->setEnabled(on);
|
|
bnScopeReset->setEnabled(on);
|
|
bnScopeReadSettings->setEnabled(on);
|
|
|
|
sbRL->setEnabled(on);
|
|
sbPT->setEnabled(on);
|
|
sbDCOffset->setEnabled(on);
|
|
sbThreshold->setEnabled(on);
|
|
sbTimeRiseTime->setEnabled(on);
|
|
sbTimeGuard->setEnabled(on);
|
|
sbTrapRiseTime->setEnabled(on);
|
|
sbTrapFlatTop->setEnabled(on);
|
|
sbTrapPoleZero->setEnabled(on);
|
|
sbEnergyFineGain->setEnabled(on);
|
|
sbTrapPeaking->setEnabled(on);
|
|
cbPolarity->setEnabled(on);
|
|
cbWaveRes->setEnabled(on);
|
|
cbTrapPeakAvg->setEnabled(on);
|
|
|
|
sbBaselineGuard->setEnabled(on);
|
|
sbPileUpGuard->setEnabled(on);
|
|
cbBaselineAvg->setEnabled(on);
|
|
cbLowFreqFilter->setEnabled(on);
|
|
}
|
|
|
|
void Scope::ScopeReadSpinBoxValue(int iDigi, int ch, QSpinBox *sb, std::string digPara){
|
|
std::string ans = digi[iDigi]->ReadChValue(std::to_string(ch), digPara);
|
|
sb->setValue(atoi(ans.c_str()));
|
|
}
|
|
|
|
void Scope::ScopeReadComboBoxValue(int iDigi, int ch, QComboBox *cb, std::string digPara){
|
|
std::string ans = digi[iDigi]->ReadChValue(std::to_string(ch), digPara);
|
|
int index = cb->findData(QString::fromStdString(ans));
|
|
if( index >= 0 && index < cb->count()) {
|
|
cb->setCurrentIndex(index);
|
|
}else{
|
|
qDebug() << QString::fromStdString(ans);
|
|
}
|
|
}
|
|
|
|
void Scope::ScopeMakeSpinBox(QSpinBox *sb, QString str, QGridLayout *layout, int row, int col, int min, int max, int step, std::string digPara){
|
|
QLabel * lb = new QLabel(str, this);
|
|
lb->setAlignment(Qt::AlignRight | Qt::AlignCenter);
|
|
layout->addWidget(lb, row, col);
|
|
sb->setMinimum(min);
|
|
sb->setMaximum(max);
|
|
sb->setSingleStep(abs(step));
|
|
layout->addWidget(sb, row, col+1);
|
|
connect(sb, &QSpinBox::valueChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
if( step > 1 ) sb->setValue(step*((sb->value() + step - 1)/step));
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(cbScopeCh->currentIndex()), digPara, std::to_string(sb->value()));
|
|
digiMTX.unlock();
|
|
});
|
|
}
|
|
|
|
void Scope::ScopeMakeComoBox(QComboBox *cb, QString str, QGridLayout *layout, int row, int col, std::string digPara){
|
|
QLabel * lb = new QLabel(str, this);
|
|
lb->setAlignment(Qt::AlignRight | Qt::AlignCenter);
|
|
layout->addWidget(lb, row, col);
|
|
layout->addWidget(cb, row, col+1);
|
|
connect(cb, &QComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
digiMTX.lock();
|
|
digi[iDigi]->WriteChValue(std::to_string(cbScopeCh->currentIndex()), digPara, cb->currentData().toString().toStdString());
|
|
digiMTX.unlock();
|
|
});
|
|
}
|
|
|
|
|
|
|