936 lines
35 KiB
C++
936 lines
35 KiB
C++
#include "scope.h"
|
|
|
|
#include <QValueAxis>
|
|
#include <QRandomGenerator>
|
|
#include <QGroupBox>
|
|
#include <QStandardItemModel>
|
|
#include <QLabel>
|
|
|
|
#define MaxDisplayTraceDataLength 2000 //data point,
|
|
|
|
Scope::Scope(Digitizer2Gen **digi, unsigned int nDigi, ReadDataThread ** readDataThread, QMainWindow *parent) : QMainWindow(parent){
|
|
this->digi = digi;
|
|
this->nDigi = nDigi;
|
|
if( nDigi > MaxNumberOfDigitizer ) {
|
|
this->nDigi = MaxNumberOfChannel;
|
|
qDebug() << "Please increase the MaxNumberOfChannel";
|
|
}
|
|
this->readDataThread = readDataThread;
|
|
|
|
setWindowTitle("Scope");
|
|
setGeometry(0, 0, 1000, 800);
|
|
setWindowFlags( this->windowFlags() & ~Qt::WindowCloseButtonHint );
|
|
|
|
allowChange = false;
|
|
originalValueSet = 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->setAnimationDuration(1); // msec
|
|
plot->setAnimationOptions(QChart::NoAnimation);
|
|
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 TimingThread();
|
|
updateTraceThread->SetWaitTimeSec(0.2);
|
|
connect(updateTraceThread, &TimingThread::TimeUp, 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 RComboBox(this);
|
|
cbScopeCh = new RComboBox(this);
|
|
layout->addWidget(cbScopeDigi, rowID, 0);
|
|
layout->addWidget(cbScopeCh, rowID, 1);
|
|
|
|
allowChange = false;
|
|
cbScopeDigi->clear(); ///this will also trigger RComboBox::currentIndexChanged
|
|
cbScopeCh->clear();
|
|
for( unsigned int i = 0 ; i < nDigi; i++) {
|
|
cbScopeDigi->addItem("Digi-" + QString::number(digi[i]->GetSerialNumber()), i);
|
|
}
|
|
cbScopeDigi->setCurrentIndex(1);
|
|
allowChange = true;
|
|
|
|
connect(cbScopeDigi, &RComboBox::currentIndexChanged, this, &Scope::ChangeDigitizer);
|
|
|
|
connect(cbScopeCh, &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
digiMTX[iDigi].lock();
|
|
ReadScopeSettings();
|
|
RestoreSettings(false);
|
|
if( digi[iDigi]->IsAcqOn()){
|
|
digi[iDigi]->WriteValue(PHA::CH::ChannelEnable, "False", -1);
|
|
digi[iDigi]->WriteValue(PHA::CH::ChannelEnable, "True", ch);
|
|
}
|
|
digiMTX[iDigi].unlock();
|
|
|
|
});
|
|
|
|
bnScopeReset = new QPushButton("ReProgram Channels", this);
|
|
layout->addWidget(bnScopeReset, rowID, 2);
|
|
connect(bnScopeReset, &QPushButton::clicked, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
//digi[iDigi]->Reset();
|
|
digi[iDigi]->ProgramChannels();
|
|
//SendLogMsg("Reset Digi-" + QString::number(digi[iDigi]->GetSerialNumber()) + " and Set Default PHA.");
|
|
ReadScopeSettings();
|
|
UpdateOtherPanels();
|
|
SendLogMsg("Re-program all Channels to default PHA settings");
|
|
});
|
|
|
|
bnScopeReadSettings = new QPushButton("Read Ch. Settings", this);
|
|
layout->addWidget(bnScopeReadSettings, rowID, 3);
|
|
connect(bnScopeReadSettings, &QPushButton::clicked, this, [=](){
|
|
if( !allowChange ) return;
|
|
ReadScopeSettings();
|
|
UpdateOtherPanels();
|
|
});
|
|
|
|
//TODO----- add copy settings and paste settings
|
|
chkSetAllChannel = new QCheckBox("apply to all channels", this);
|
|
layout->addWidget(chkSetAllChannel, rowID, 4);
|
|
|
|
//------------ Probe selection
|
|
rowID ++;
|
|
|
|
//TODO --- add None for probel selection
|
|
cbAnaProbe[0] = new RComboBox(this);
|
|
cbAnaProbe[1] = new RComboBox(this);
|
|
cbDigProbe[0] = new RComboBox(this);
|
|
cbDigProbe[1] = new RComboBox(this);
|
|
cbDigProbe[2] = new RComboBox(this);
|
|
cbDigProbe[3] = new RComboBox(this);
|
|
|
|
connect(cbAnaProbe[0], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbAnaProbe, 2);});
|
|
connect(cbAnaProbe[1], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbAnaProbe, 2);});
|
|
|
|
connect(cbAnaProbe[0], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(anaProbeList[0], (cbAnaProbe[0]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].unlock();
|
|
});
|
|
|
|
connect(cbAnaProbe[1], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(anaProbeList[1], (cbAnaProbe[1]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].unlock();
|
|
});
|
|
|
|
connect(cbDigProbe[0], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[1], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[2], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
connect(cbDigProbe[3], &RComboBox::currentIndexChanged, this, [=](){ this->ProbeChange(cbDigProbe, 4);});
|
|
|
|
connect(cbDigProbe[0], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(digiProbeList[0], (cbDigProbe[0]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].unlock();
|
|
});
|
|
connect(cbDigProbe[1], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(digiProbeList[1], (cbDigProbe[1]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].unlock();
|
|
});
|
|
connect(cbDigProbe[2], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(digiProbeList[2], (cbDigProbe[2]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].unlock();
|
|
});
|
|
connect(cbDigProbe[3], &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
digiMTX[iDigi].lock();
|
|
digi[iDigi]->WriteValue(digiProbeList[3], (cbDigProbe[3]->currentData()).toString().toStdString(), ch);
|
|
digiMTX[iDigi].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);
|
|
|
|
for( int i = 0; i < 6; i++) layout->setColumnStretch(i, 1);
|
|
|
|
rowID ++;
|
|
|
|
{//------------ wave settings
|
|
settingBox = new QGroupBox("Channel Settings (need ACQ stop)", this);
|
|
layout->addWidget(settingBox, rowID, 0, 1, 6);
|
|
|
|
bLayout = new QGridLayout(settingBox);
|
|
bLayout->setSpacing(0);
|
|
|
|
if( digi[0]->GetFPGAType() == DPPType::PHA ) SetupPHA();
|
|
|
|
if( digi[0]->GetFPGAType() == DPPType::PSD ) SetupPSD();
|
|
|
|
}
|
|
|
|
//Trigger the ChangeDigitizer()
|
|
cbScopeDigi->setCurrentIndex(0);
|
|
cbScopeCh->setCurrentIndex(1);
|
|
cbScopeCh->setCurrentIndex(0);
|
|
|
|
//------------ plot view
|
|
rowID ++;
|
|
TraceView * plotView = new TraceView(plot);
|
|
plotView->setRenderHints(QPainter::Antialiasing);
|
|
layout->addWidget(plotView, rowID, 0, 1, 6);
|
|
|
|
//------------- Key binding
|
|
rowID ++;
|
|
QLabel * lbhints = new QLabel("Type 'r' to restore view, '+/-' Zoom in/out, arrow key to pan.", this);
|
|
layout->addWidget(lbhints, rowID, 0, 1, 4);
|
|
|
|
QLabel * lbinfo = new QLabel("Trace update every " + QString::number(updateTraceThread->GetWaitTimeinSec()) + " sec.", this);
|
|
lbinfo->setAlignment(Qt::AlignRight);
|
|
layout->addWidget(lbinfo, rowID, 5);
|
|
|
|
rowID ++;
|
|
QLabel * lbinfo2 = new QLabel("Maximum time range is " + QString::number(MaxDisplayTraceDataLength * PHA::TraceStep) + " ns due to processing speed.", this);
|
|
layout->addWidget(lbinfo2, rowID, 0, 1, 5);
|
|
|
|
//------------ close button
|
|
rowID ++;
|
|
bnScopeStart = new QPushButton("Start", this);
|
|
layout->addWidget(bnScopeStart, rowID, 0);
|
|
bnScopeStart->setEnabled(true);
|
|
connect(bnScopeStart, &QPushButton::clicked, this, [=](){this->StartScope();});
|
|
|
|
bnScopeStop = new QPushButton("Stop", this);
|
|
layout->addWidget(bnScopeStop, rowID, 1);
|
|
bnScopeStop->setEnabled(false);
|
|
connect(bnScopeStop, &QPushButton::clicked, this, &Scope::StopScope);
|
|
|
|
QLabel * lbTriggerRate = new QLabel("Trigger Rate [Hz] : ", this);
|
|
lbTriggerRate->setAlignment(Qt::AlignCenter | Qt::AlignRight);
|
|
layout->addWidget(lbTriggerRate, rowID, 2);
|
|
|
|
leTriggerRate = new QLineEdit(this);
|
|
leTriggerRate->setAlignment(Qt::AlignRight);
|
|
leTriggerRate->setReadOnly(true);
|
|
layout->addWidget(leTriggerRate, rowID, 3);
|
|
|
|
QPushButton * bnClose = new QPushButton("Close", this);
|
|
layout->addWidget(bnClose, rowID, 5);
|
|
connect(bnClose, &QPushButton::clicked, this, &Scope::close);
|
|
|
|
show();
|
|
|
|
//StartScope();
|
|
|
|
UpdateSettingsFromMemeory();
|
|
|
|
oldDigi = cbScopeDigi->currentIndex();
|
|
oldCh = cbScopeCh->currentIndex();;
|
|
waveSaving = digi[oldDigi]->ReadValue(PHA::CH::WaveSaving, oldCh);
|
|
waveTriggerSource = digi[oldDigi]->ReadValue(PHA::CH::WaveTriggerSource, oldCh);
|
|
clockSource = digi[oldDigi]->ReadValue(PHA::DIG::ClockSource);
|
|
startSource = digi[oldDigi]->ReadValue(PHA::DIG::StartSource);
|
|
syncOutMode = digi[oldDigi]->ReadValue(PHA::DIG::SyncOutMode);
|
|
|
|
for( int ch2 = 0 ; ch2 < digi[oldDigi]->GetNChannels(); ch2 ++){
|
|
channelEnable[oldDigi][ch2] = digi[oldDigi]->ReadValue(PHA::CH::ChannelEnable, ch2);
|
|
}
|
|
originalValueSet = true;
|
|
}
|
|
|
|
Scope::~Scope(){
|
|
printf("------- %s \n", __func__);
|
|
StopScope();
|
|
updateTraceThread->Stop();
|
|
updateTraceThread->quit();
|
|
updateTraceThread->wait();
|
|
delete updateTraceThread;
|
|
for( int i = 0; i < 6; i++) delete dataTrace[i];
|
|
delete plot;
|
|
printf("------- end of %s \n", __func__);
|
|
}
|
|
|
|
void Scope::ChangeDigitizer(){
|
|
|
|
int index = cbScopeDigi->currentIndex();
|
|
if( index == -1 ) return;
|
|
allowChange = false;
|
|
|
|
cbScopeCh->clear();
|
|
for( int i = 0; i < digi[index]->GetNChannels(); i++){
|
|
cbScopeCh->addItem("ch-" + QString::number(i), i);
|
|
}
|
|
cbScopeCh->setCurrentIndex(0);
|
|
|
|
anaProbeList.clear();
|
|
digiProbeList.clear();
|
|
if( digi[index]->GetFPGAType() == DPPType::PHA ) {
|
|
anaProbeList.push_back(PHA::CH::WaveAnalogProbe0);
|
|
anaProbeList.push_back(PHA::CH::WaveAnalogProbe1);
|
|
digiProbeList.push_back(PHA::CH::WaveDigitalProbe0);
|
|
digiProbeList.push_back(PHA::CH::WaveDigitalProbe1);
|
|
digiProbeList.push_back(PHA::CH::WaveDigitalProbe2);
|
|
digiProbeList.push_back(PHA::CH::WaveDigitalProbe3);
|
|
}
|
|
if( digi[index]->GetFPGAType() == DPPType::PSD){
|
|
anaProbeList.push_back(PSD::CH::WaveAnalogProbe0);
|
|
anaProbeList.push_back(PSD::CH::WaveAnalogProbe1);
|
|
digiProbeList.push_back(PSD::CH::WaveDigitalProbe0);
|
|
digiProbeList.push_back(PSD::CH::WaveDigitalProbe1);
|
|
digiProbeList.push_back(PSD::CH::WaveDigitalProbe2);
|
|
digiProbeList.push_back(PSD::CH::WaveDigitalProbe3);
|
|
}
|
|
|
|
cbAnaProbe[0]->clear();
|
|
cbAnaProbe[1]->clear();
|
|
|
|
for( int i = 0; i < (int) anaProbeList[0].GetAnswers().size(); i++ ) {
|
|
cbAnaProbe[0]->addItem(QString::fromStdString((anaProbeList[0].GetAnswers())[i].second),
|
|
QString::fromStdString((anaProbeList[0].GetAnswers())[i].first));
|
|
}
|
|
for( int i = 0; i < cbAnaProbe[0]->count() ; i++) cbAnaProbe[1]->addItem(cbAnaProbe[0]->itemText(i), cbAnaProbe[0]->itemData(i));
|
|
|
|
cbDigProbe[0]->clear();
|
|
cbDigProbe[1]->clear();
|
|
cbDigProbe[2]->clear();
|
|
cbDigProbe[3]->clear();
|
|
for( int i = 0; i < (int) digiProbeList[0].GetAnswers().size(); i++ ) {
|
|
cbDigProbe[0]->addItem(QString::fromStdString((digiProbeList[0].GetAnswers())[i].second),
|
|
QString::fromStdString((digiProbeList[0].GetAnswers())[i].first));
|
|
}
|
|
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));
|
|
}
|
|
|
|
if( digi[index]->GetFPGAType() == DPPType::PHA ) SetupPHA();
|
|
|
|
if( digi[index]->GetFPGAType() == DPPType::PSD ) SetupPSD();
|
|
|
|
|
|
digiMTX[index].lock();
|
|
ReadScopeSettings();
|
|
|
|
if( digi[index]->IsAcqOn() ){
|
|
digi[index]->WriteValue(PHA::CH::ChannelEnable, "False", -1);
|
|
digi[index]->WriteValue(PHA::CH::ChannelEnable, "True", cbScopeCh->currentIndex());
|
|
}
|
|
digiMTX[index].unlock();
|
|
allowChange = true;
|
|
|
|
}
|
|
|
|
void Scope::CleanUpSettingsGroupBox(){
|
|
QList<QLabel *> labelChildren1 = settingBox->findChildren<QLabel *>();
|
|
for( int i = 0; i < labelChildren1.size(); i++) delete labelChildren1[i];
|
|
|
|
QList<RComboBox *> labelChildren2 = settingBox->findChildren<RComboBox *>();
|
|
for( int i = 0; i < labelChildren2.size(); i++) delete labelChildren2[i];
|
|
|
|
QList<RSpinBox *> labelChildren3 = settingBox->findChildren<RSpinBox *>();
|
|
for( int i = 0; i < labelChildren3.size(); i++) delete labelChildren3[i];
|
|
}
|
|
|
|
void Scope::SetupPHA(){
|
|
|
|
CleanUpSettingsGroupBox();
|
|
|
|
ScopeMakeSpinBox(sbRL, "Record Lenght [ns] ", bLayout, 0, 0, PHA::CH::RecordLength);
|
|
ScopeMakeSpinBox(sbThreshold, "Threshold [LSB] ", bLayout, 0, 2, PHA::CH::TriggerThreshold);
|
|
ScopeMakeComoBox(cbPolarity, "Polarity ", bLayout, 0, 4, PHA::CH::Polarity);
|
|
ScopeMakeComoBox(cbWaveRes, "Wave Re. ", bLayout, 0, 6, PHA::CH::WaveResolution);
|
|
|
|
//------------------ next row
|
|
ScopeMakeSpinBox(sbPT, "Pre Trigger [ns] ", bLayout, 1, 0, PHA::CH::PreTrigger);
|
|
ScopeMakeSpinBox(sbDCOffset, "DC offset [%] ", bLayout, 1, 2, PHA::CH::DC_Offset);
|
|
ScopeMakeSpinBox(sbTimeRiseTime, "Trigger Rise Time [ns] ", bLayout, 1, 4, PHA::CH::TimeFilterRiseTime);
|
|
ScopeMakeSpinBox(sbTimeGuard, "Trigger Guard [ns] ", bLayout, 1, 6, PHA::CH::TimeFilterRetriggerGuard);
|
|
|
|
//----------------- next row
|
|
ScopeMakeSpinBox(sbTrapRiseTime, "Trap. Rise Time [ns] ", bLayout, 2, 0, PHA::CH::EnergyFilterRiseTime);
|
|
ScopeMakeSpinBox(sbTrapFlatTop, "Trap. Flat Top [ns] ", bLayout, 2, 2, PHA::CH::EnergyFilterFlatTop);
|
|
ScopeMakeSpinBox(sbTrapPoleZero, "Trap. Pole Zero [ns] ", bLayout, 2, 4, PHA::CH::EnergyFilterPoleZero);
|
|
ScopeMakeSpinBox(sbEnergyFineGain, "Energy Fine Gain ", bLayout, 2, 6, PHA::CH::EnergyFilterFineGain);
|
|
|
|
//----------------- next row
|
|
ScopeMakeSpinBox(sbTrapPeaking, "Trap. Peaking [%] ", bLayout, 3, 0, PHA::CH::EnergyFilterPeakingPosition);
|
|
ScopeMakeComoBox(cbTrapPeakAvg, "Trap. Peaking ", bLayout, 3, 2, PHA::CH::EnergyFilterPeakingAvg);
|
|
ScopeMakeSpinBox(sbBaselineGuard, "Baseline Guard [ns] ", bLayout, 3, 4, PHA::CH::EnergyFilterBaselineGuard);
|
|
ScopeMakeComoBox(cbBaselineAvg, "Baseline Avg ", bLayout, 3, 6, PHA::CH::EnergyFilterBaselineAvg);
|
|
|
|
//----------------- next row
|
|
ScopeMakeSpinBox(sbPileUpGuard, "Pile-up Guard [ns] ", bLayout, 4, 0, PHA::CH::EnergyFilterPileUpGuard);
|
|
ScopeMakeComoBox(cbLowFreqFilter, "Low Freq. Filter ", bLayout, 4, 2, PHA::CH::EnergyFilterLowFreqFilter);
|
|
|
|
}
|
|
|
|
void Scope::SetupPSD(){
|
|
|
|
CleanUpSettingsGroupBox();
|
|
|
|
ScopeMakeSpinBox(sbRL, "Record Lenght [ns] ", bLayout, 0, 0, PSD::CH::RecordLength);
|
|
ScopeMakeSpinBox(sbThreshold, "Threshold [LSB] ", bLayout, 0, 2, PSD::CH::TriggerThreshold);
|
|
ScopeMakeComoBox(cbPolarity, "Polarity ", bLayout, 0, 4, PSD::CH::Polarity);
|
|
ScopeMakeComoBox(cbWaveRes, "Wave Re. ", bLayout, 0, 6, PSD::CH::WaveResolution);
|
|
|
|
//------------------ next row
|
|
ScopeMakeSpinBox(sbPT, "Pre Trigger [ns] ", bLayout, 1, 0, PSD::CH::PreTrigger);
|
|
ScopeMakeSpinBox(sbDCOffset, "DC offset [%] ", bLayout, 1, 2, PSD::CH::DC_Offset);
|
|
ScopeMakeComoBox(cbbADCInputBaselineAvg, "ADC BL Avg. ", bLayout, 1, 4, PSD::CH::ADCInputBaselineAvg);
|
|
ScopeMakeSpinBox(spbADCInputBaselineGuard, "ADC BL Guard [ns] ", bLayout, 1, 6, PSD::CH::ADCInputBaselineGuard);
|
|
|
|
//------------------ next row
|
|
ScopeMakeSpinBox(spbCFDDelay, "CFD Delay [ns] ", bLayout, 2, 0, PSD::CH::CFDDelay);
|
|
ScopeMakeSpinBox(spbCFDFraction, "CFD Frac. [%] ", bLayout, 2, 2, PSD::CH::CFDFraction);
|
|
ScopeMakeComoBox(cbbSmoothingFactor, "Smoothing ", bLayout, 2, 4, PSD::CH::SmoothingFactor);
|
|
ScopeMakeSpinBox(spbAbsBaseline, "Abs. BL ", bLayout, 2, 6, PSD::CH::AbsoluteBaseline);
|
|
|
|
//------------------ next row
|
|
ScopeMakeComoBox(cbbTriggerFilter, "Trig. Filter ", bLayout, 3, 0, PSD::CH::TriggerFilterSelection);
|
|
ScopeMakeComoBox(cbbTimeFilterSmoothing, "Trig. Smooth ", bLayout, 3, 2, PSD::CH::TimeFilterSmoothing);
|
|
ScopeMakeSpinBox(spbTimeFilterReTriggerGuard, "Trig. Guard [ns] ", bLayout, 3, 4, PSD::CH::TimeFilterRetriggerGuard);
|
|
ScopeMakeSpinBox(spbPileupGap, "PileUp Gap [ns] ", bLayout, 3, 6, PSD::CH::PileupGap);
|
|
|
|
//------------------ next row
|
|
ScopeMakeSpinBox(spbGateLong, "Long Gate [ns] ", bLayout, 4, 0, PSD::CH::GateLongLength);
|
|
ScopeMakeSpinBox(spbGateShort, "Shart Gate [ns] ", bLayout, 4, 2, PSD::CH::GateLongLength);
|
|
ScopeMakeSpinBox(spbGateOffset, "Gate offset [ns] ", bLayout, 4, 4, PSD::CH::GateLongLength);
|
|
ScopeMakeComoBox(cbbEnergyGain, "Energy Gain ", bLayout, 4, 6, PSD::CH::EnergyGain);
|
|
|
|
|
|
}
|
|
|
|
void Scope::ReadScopeSettings(){
|
|
|
|
if( !isVisible() ) return;
|
|
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
if( !digi[iDigi] || digi[iDigi]->IsDummy() || !digi[iDigi]->IsConnected()) return;
|
|
|
|
UpdateSettingsFromMemeory();
|
|
|
|
}
|
|
|
|
void Scope::UpdateSettingsFromMemeory(){
|
|
if( !isVisible() ) return;
|
|
|
|
printf("Scope::%s\n", __func__);
|
|
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
if( !digi[iDigi] || digi[iDigi]->IsDummy() || !digi[iDigi]->IsConnected()) return;
|
|
|
|
allowChange = false;
|
|
|
|
int ch = cbScopeCh->currentIndex();
|
|
|
|
for( int i = 0 ; i < 2; i++){
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PHA ) ScopeReadComboBoxValue(iDigi, ch, cbAnaProbe[i], PHA::CH::AnalogProbe[i]);
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PSD ) ScopeReadComboBoxValue(iDigi, ch, cbAnaProbe[i], PSD::CH::AnalogProbe[i]);
|
|
}
|
|
|
|
for( int i = 0 ; i < 4; i++){
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PHA ) ScopeReadComboBoxValue(iDigi, ch, cbDigProbe[i], PHA::CH::DigitalProbe[i]);
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PSD ) ScopeReadComboBoxValue(iDigi, ch, cbDigProbe[i], PSD::CH::DigitalProbe[i]);
|
|
}
|
|
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PHA ){
|
|
ScopeReadComboBoxValue(iDigi, ch, cbPolarity, PHA::CH::Polarity);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbWaveRes, PHA::CH::WaveResolution);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbTrapPeakAvg, PHA::CH::EnergyFilterPeakingAvg);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbBaselineAvg, PHA::CH::EnergyFilterBaselineAvg);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbLowFreqFilter, PHA::CH::EnergyFilterLowFreqFilter);
|
|
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbRL, PHA::CH::RecordLength);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbPT, PHA::CH::PreTrigger);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbDCOffset, PHA::CH::DC_Offset);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbThreshold, PHA::CH::TriggerThreshold);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTimeRiseTime, PHA::CH::TimeFilterRiseTime);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTimeGuard, PHA::CH::TimeFilterRetriggerGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapRiseTime, PHA::CH::EnergyFilterRiseTime);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapFlatTop, PHA::CH::EnergyFilterFlatTop);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapPoleZero, PHA::CH::EnergyFilterPoleZero);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbEnergyFineGain, PHA::CH::EnergyFilterFineGain);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbTrapPeaking, PHA::CH::EnergyFilterPeakingPosition);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbBaselineGuard, PHA::CH::EnergyFilterBaselineGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbPileUpGuard, PHA::CH::EnergyFilterPileUpGuard);
|
|
|
|
sbRL->setStyleSheet("");
|
|
sbPT->setStyleSheet("");
|
|
sbThreshold->setStyleSheet("");
|
|
sbTimeRiseTime->setStyleSheet("");
|
|
sbTimeGuard->setStyleSheet("");
|
|
sbTrapRiseTime->setStyleSheet("");
|
|
sbTrapFlatTop->setStyleSheet("");
|
|
sbTrapPoleZero->setStyleSheet("");
|
|
sbEnergyFineGain->setStyleSheet("");
|
|
sbTrapPeaking->setStyleSheet("");
|
|
sbBaselineGuard->setStyleSheet("");
|
|
sbPileUpGuard->setStyleSheet("");
|
|
}
|
|
|
|
if( digi[iDigi]->GetFPGAType() == DPPType::PSD ){
|
|
|
|
ScopeReadComboBoxValue(iDigi, ch, cbPolarity, PSD::CH::Polarity);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbWaveRes, PSD::CH::WaveResolution);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbbADCInputBaselineAvg, PSD::CH::ADCInputBaselineAvg);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbbSmoothingFactor, PSD::CH::SmoothingFactor);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbbTriggerFilter, PSD::CH::TriggerFilterSelection);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbbTimeFilterSmoothing, PSD::CH::TimeFilterSmoothing);
|
|
ScopeReadComboBoxValue(iDigi, ch, cbbEnergyGain, PSD::CH::EnergyGain);
|
|
|
|
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbRL, PSD::CH::RecordLength);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbThreshold, PSD::CH::TriggerThreshold);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbPT, PSD::CH::PreTrigger);
|
|
ScopeReadSpinBoxValue(iDigi, ch, sbDCOffset, PSD::CH::DC_Offset);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbADCInputBaselineGuard, PSD::CH::ADCInputBaselineGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbCFDDelay, PSD::CH::CFDDelay);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbCFDFraction, PSD::CH::CFDFraction);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbAbsBaseline, PSD::CH::AbsoluteBaseline);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbTimeFilterReTriggerGuard, PSD::CH::TimeFilterRetriggerGuard);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbPileupGap, PSD::CH::PileupGap);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbGateLong, PSD::CH::GateLongLength);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbGateShort, PSD::CH::GateShortLength);
|
|
ScopeReadSpinBoxValue(iDigi, ch, spbGateOffset, PSD::CH::GateOffset);
|
|
|
|
cbPolarity->setStyleSheet("");
|
|
cbWaveRes->setStyleSheet("");
|
|
cbbADCInputBaselineAvg->setStyleSheet("");
|
|
cbbSmoothingFactor->setStyleSheet("");
|
|
cbbTriggerFilter->setStyleSheet("");
|
|
cbbTimeFilterSmoothing->setStyleSheet("");
|
|
cbbEnergyGain->setStyleSheet("");
|
|
|
|
sbRL->setStyleSheet("");
|
|
sbThreshold->setStyleSheet("");
|
|
sbPT->setStyleSheet("");
|
|
sbDCOffset->setStyleSheet("");
|
|
spbADCInputBaselineGuard->setStyleSheet("");
|
|
spbCFDDelay->setStyleSheet("");
|
|
spbCFDFraction->setStyleSheet("");
|
|
spbAbsBaseline->setStyleSheet("");
|
|
spbTimeFilterReTriggerGuard->setStyleSheet("");
|
|
spbPileupGap->setStyleSheet("");
|
|
spbGateLong->setStyleSheet("");
|
|
spbGateShort->setStyleSheet("");
|
|
spbGateOffset->setStyleSheet("");
|
|
|
|
}
|
|
|
|
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::RestoreSettings(bool changeBoard){
|
|
|
|
if( !originalValueSet) return;
|
|
|
|
//restore for old digi and old ch
|
|
if( changeBoard ){
|
|
digi[oldDigi]->WriteValue(PHA::DIG::ClockSource, clockSource);
|
|
digi[oldDigi]->WriteValue(PHA::DIG::StartSource, startSource);
|
|
digi[oldDigi]->WriteValue(PHA::DIG::SyncOutMode, syncOutMode);
|
|
}
|
|
digi[oldDigi]->WriteValue(PHA::CH::WaveSaving, waveSaving, oldCh);
|
|
digi[oldDigi]->WriteValue(PHA::CH::WaveTriggerSource, waveTriggerSource, oldCh);
|
|
|
|
// back up data for new digi and ch
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
|
|
waveSaving = digi[iDigi]->ReadValue(PHA::CH::WaveSaving, ch);
|
|
waveTriggerSource = digi[iDigi]->ReadValue(PHA::CH::WaveTriggerSource, ch);
|
|
if( changeBoard ){
|
|
clockSource = digi[iDigi]->ReadValue(PHA::DIG::ClockSource);
|
|
startSource = digi[iDigi]->ReadValue(PHA::DIG::StartSource);
|
|
syncOutMode = digi[iDigi]->ReadValue(PHA::DIG::SyncOutMode);
|
|
}
|
|
oldDigi = iDigi;
|
|
oldCh = ch;
|
|
}
|
|
|
|
void Scope::StartScope(){
|
|
|
|
if( !digi ) return;
|
|
|
|
for( int iDigi = 0 ; iDigi < nDigi; iDigi ++ ){
|
|
|
|
if( digi[iDigi]->IsDummy() ) return;
|
|
|
|
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();
|
|
|
|
/// the settings are the same for PHA and PSD
|
|
for( int ch2 = 0 ; ch2 < digi[iDigi]->GetNChannels(); ch2 ++){
|
|
channelEnable[iDigi][ch2] = digi[iDigi]->ReadValue(PHA::CH::ChannelEnable, ch2);
|
|
}
|
|
digi[iDigi]->WriteValue(PHA::CH::ChannelEnable, "False", -1);
|
|
|
|
if( iDigi == cbScopeDigi->currentIndex() ){
|
|
clockSource = digi[iDigi]->ReadValue(PHA::DIG::ClockSource);
|
|
startSource = digi[iDigi]->ReadValue(PHA::DIG::StartSource);
|
|
syncOutMode = digi[iDigi]->ReadValue(PHA::DIG::SyncOutMode);
|
|
waveSaving = digi[iDigi]->ReadValue(PHA::CH::WaveSaving, ch);
|
|
waveTriggerSource = digi[iDigi]->ReadValue(PHA::CH::WaveTriggerSource, ch);
|
|
oldDigi = iDigi;
|
|
oldCh = ch;
|
|
|
|
digi[iDigi]->WriteValue(PHA::CH::ChannelEnable, "True", ch);
|
|
digi[iDigi]->WriteValue(PHA::CH::WaveSaving, "Always", ch);
|
|
digi[iDigi]->WriteValue(PHA::CH::WaveTriggerSource, "ChSelfTrigger", ch);
|
|
|
|
digi[iDigi]->WriteValue(PHA::DIG::ClockSource, "Internal");
|
|
digi[iDigi]->WriteValue(PHA::DIG::StartSource, "SWcmd");
|
|
digi[iDigi]->WriteValue(PHA::DIG::SyncOutMode, "Disabled");
|
|
|
|
}
|
|
|
|
digi[iDigi]->SetDataFormat(DataFormat::ALL);
|
|
digi[iDigi]->StartACQ();
|
|
|
|
readDataThread[iDigi]->SetSaveData(false);
|
|
readDataThread[iDigi]->start();
|
|
|
|
updateTraceThread->start();
|
|
|
|
ScopeControlOnOff(false);
|
|
emit TellSettingsPanelControlOnOff();
|
|
}
|
|
emit TellACQOnOff(true);
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::StopScope(){
|
|
|
|
printf("%s\n", __func__);
|
|
|
|
updateTraceThread->Stop();
|
|
updateTraceThread->quit();
|
|
updateTraceThread->wait();
|
|
|
|
/// the settings are the same for PHA and PSD
|
|
|
|
if(digi){
|
|
for(int i = 0; i < nDigi; i++){
|
|
if( digi[i]->IsDummy() ) continue;
|
|
|
|
readDataThread[i]->Stop();
|
|
readDataThread[i]->quit();
|
|
readDataThread[i]->wait();
|
|
|
|
digiMTX[i].lock();
|
|
digi[i]->StopACQ();
|
|
for( int ch2 = 0 ; ch2 < digi[i]->GetNChannels(); ch2 ++){
|
|
digi[i]->WriteValue(PHA::CH::ChannelEnable, channelEnable[i][ch2], ch2);
|
|
}
|
|
RestoreSettings(true);
|
|
digiMTX[i].unlock();
|
|
}
|
|
|
|
emit TellACQOnOff(false);
|
|
}
|
|
|
|
ScopeControlOnOff(true);
|
|
emit TellSettingsPanelControlOnOff();
|
|
|
|
allowChange = true;
|
|
}
|
|
|
|
void Scope::UpdateScope(){
|
|
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
int sample2ns = PHA::TraceStep * (1 << cbWaveRes->currentIndex());
|
|
|
|
emit UpdateScalar();
|
|
|
|
/// the settings are the same for PHA and PSD
|
|
|
|
if( digi ){
|
|
|
|
digiMTX[iDigi].lock();
|
|
std::string time = digi[iDigi]->ReadValue(PHA::CH::ChannelRealtime, ch); // for refreashing SelfTrgRate and SavedCount
|
|
std::string haha = digi[iDigi]->ReadValue(PHA::CH::SelfTrgRate, ch);
|
|
leTriggerRate->setText(QString::fromStdString(haha));
|
|
|
|
//unsigned int traceLength = qMin((int) digi[iDigi]->hit->traceLenght, MaxDisplayTraceDataLength);
|
|
unsigned int traceLength = qMin( atoi(digi[iDigi]->GetSettingValueFromMemory(PHA::CH::RecordLength, ch).c_str())/sample2ns, MaxDisplayTraceDataLength );
|
|
|
|
if( atoi(haha.c_str()) == 0 ) {
|
|
digiMTX[iDigi].unlock();
|
|
|
|
for( int j = 0; j < 6; j++){
|
|
QVector<QPointF> points;
|
|
for( unsigned int i = 0 ; i < traceLength; i++) points.append(QPointF(sample2ns * i , j > 1 ? 0 : (j+1)*1000));
|
|
dataTrace[j]->replace(points);
|
|
}
|
|
plot->axes(Qt::Horizontal).first()->setRange(0, sample2ns * traceLength);
|
|
return;
|
|
}
|
|
|
|
//printf("%s, traceLength : %d , %d\n", __func__, traceLength, digi[iDigi]->hit->analog_probes[0][10]);
|
|
|
|
for( int j = 0; j < 2; j++) {
|
|
QVector<QPointF> points;
|
|
for( unsigned int i = 0 ; i < traceLength; i++) points.append(QPointF(sample2ns * i , digi[iDigi]->hit->analog_probes[j][i]));
|
|
dataTrace[j]->replace(points);
|
|
}
|
|
for( int j = 0; j < 4; j++) {
|
|
QVector<QPointF> points;
|
|
for( unsigned int i = 0 ; i < traceLength; i++) points.append(QPointF(sample2ns * i , (j+1)*5000 + 4000*digi[iDigi]->hit->digital_probes[j][i]));
|
|
dataTrace[j+2]->replace(points);
|
|
}
|
|
//digi[iDigi]->hit->ClearTrace();
|
|
digiMTX[iDigi].unlock();
|
|
plot->axes(Qt::Horizontal).first()->setRange(0, sample2ns * traceLength);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void Scope::ProbeChange(RComboBox * cb[], const int size ){
|
|
|
|
if( allowChange == false ) return;
|
|
|
|
//printf("%s\n", __func__);
|
|
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);
|
|
}
|
|
}
|
|
|
|
//int ID = cbScopeDigi->currentIndex();
|
|
//digiMTX[ID].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[ID].unlock();
|
|
|
|
}
|
|
|
|
void Scope::ScopeControlOnOff(bool on){
|
|
|
|
bnScopeStop->setEnabled(!on);
|
|
bnScopeStart->setEnabled(on);
|
|
bnScopeReset->setEnabled(on);
|
|
bnScopeReadSettings->setEnabled(on);
|
|
|
|
if( digi[cbScopeDigi->currentIndex()]->GetFPGAType() == DPPType::PHA ){
|
|
sbRL->setEnabled(on);
|
|
sbPT->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);
|
|
cbBaselineAvg->setEnabled(on);
|
|
|
|
//sbDCOffset->setEnabled(on);
|
|
//sbThreshold->setEnabled(on);
|
|
//sbBaselineGuard->setEnabled(on);
|
|
//sbPileUpGuard->setEnabled(on);
|
|
//cbLowFreqFilter->setEnabled(on);
|
|
}
|
|
|
|
if( digi[cbScopeDigi->currentIndex()]->GetFPGAType() == DPPType::PSD ){
|
|
|
|
cbPolarity->setEnabled(on);
|
|
cbWaveRes->setEnabled(on);
|
|
cbbADCInputBaselineAvg->setEnabled(on);
|
|
cbbSmoothingFactor->setEnabled(on);
|
|
cbbTriggerFilter->setEnabled(on);
|
|
cbbTimeFilterSmoothing->setEnabled(on);
|
|
cbbEnergyGain->setEnabled(on);
|
|
|
|
sbRL->setEnabled(on);
|
|
sbPT->setEnabled(on);
|
|
|
|
//sbThreshold->setEnabled(on);
|
|
//sbDCOffset->setEnabled(on);
|
|
|
|
//spbADCInputBaselineGuard->setEnabled(on);
|
|
//spbCFDDelay->setEnabled(on);
|
|
//spbCFDFraction->setEnabled(on);
|
|
//spbAbsBaseline->setEnabled(on);
|
|
//spbTimeFilterReTriggerGuard->setEnabled(on);
|
|
//spbPileupGap->setEnabled(on);
|
|
//spbGateLong->setEnabled(on);
|
|
//spbGateShort->setEnabled(on);
|
|
//spbGateOffset->setEnabled(on);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void Scope::ScopeReadSpinBoxValue(int iDigi, int ch, RSpinBox *sb, const Reg digPara){
|
|
std::string ans = digi[iDigi]->GetSettingValueFromMemory(digPara, ch);
|
|
sb->setValue(atoi(ans.c_str()));
|
|
}
|
|
|
|
void Scope::ScopeReadComboBoxValue(int iDigi, int ch, RComboBox *cb, const Reg digPara){
|
|
std::string ans = digi[iDigi]->GetSettingValueFromMemory(digPara, ch);
|
|
int index = cb->findData(QString::fromStdString(ans));
|
|
if( index >= 0 && index < cb->count()) {
|
|
cb->setCurrentIndex(index);
|
|
}else{
|
|
qDebug() << QString::fromStdString(ans);
|
|
}
|
|
}
|
|
|
|
void Scope::ScopeMakeSpinBox(RSpinBox * &sb, QString str, QGridLayout *layout, int row, int col, const Reg digPara){
|
|
//printf("%s\n", __func__);
|
|
QLabel * lb = new QLabel(str, settingBox);
|
|
lb->setAlignment(Qt::AlignRight | Qt::AlignCenter);
|
|
layout->addWidget(lb, row, col);
|
|
sb = new RSpinBox(settingBox);
|
|
sb->setMinimum(atof(digPara.GetAnswers()[0].first.c_str()));
|
|
sb->setMaximum(atof(digPara.GetAnswers()[1].first.c_str()));
|
|
sb->setSingleStep(atof(digPara.GetAnswers()[2].first.c_str()));
|
|
layout->addWidget(sb, row, col+1);
|
|
connect(sb, &RSpinBox::valueChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
sb->setStyleSheet("color:blue");
|
|
});
|
|
connect(sb, &RSpinBox::returnPressed, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
if( sb->decimals() == 0 && sb->singleStep() != 1) {
|
|
double step = sb->singleStep();
|
|
double value = sb->value();
|
|
sb->setValue( (std::round(value/step)*step));
|
|
}
|
|
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
QString msg;
|
|
msg = QString::fromStdString(digPara.GetPara()) + "|DIG:"+ QString::number(digi[iDigi]->GetSerialNumber()) + ",CH:" + (ch == -1 ? "All" : QString::number(ch));
|
|
msg += " = " + QString::number(sb->value());
|
|
if( digi[iDigi]->WriteValue(digPara, std::to_string(sb->value()), ch)){
|
|
SendLogMsg(msg + "|OK.");
|
|
sb->setStyleSheet("");
|
|
UpdateSettingsFromMemeory();
|
|
UpdateOtherPanels();
|
|
}else{
|
|
SendLogMsg(msg + "|Fail.");
|
|
sb->setStyleSheet("color:red;");
|
|
}
|
|
});
|
|
|
|
|
|
}
|
|
|
|
void Scope::ScopeMakeComoBox(RComboBox * &cb, QString str, QGridLayout *layout, int row, int col, const Reg digPara){
|
|
QLabel * lb = new QLabel(str, settingBox);
|
|
lb->setAlignment(Qt::AlignRight | Qt::AlignCenter);
|
|
layout->addWidget(lb, row, col);
|
|
|
|
cb = new RComboBox(settingBox);
|
|
for( int i = 0 ; i < (int) digPara.GetAnswers().size(); i++){
|
|
cb->addItem(QString::fromStdString((digPara.GetAnswers())[i].second), QString::fromStdString((digPara.GetAnswers())[i].first));
|
|
}
|
|
layout->addWidget(cb, row, col+1);
|
|
|
|
connect(cb, &RComboBox::currentIndexChanged, this, [=](){
|
|
if( !allowChange ) return;
|
|
int iDigi = cbScopeDigi->currentIndex();
|
|
int ch = cbScopeCh->currentIndex();
|
|
if( chkSetAllChannel->isChecked() ) ch = -1;
|
|
QString msg;
|
|
msg = QString::fromStdString(digPara.GetPara()) + "|DIG:"+ QString::number(digi[iDigi]->GetSerialNumber()) + ",CH:" + (ch == -1 ? "All" : QString::number(ch));
|
|
msg += " = " + cb->currentData().toString();
|
|
if( digi[iDigi]->WriteValue(digPara, cb->currentData().toString().toStdString(), ch)){
|
|
SendLogMsg(msg + "|OK.");
|
|
cb->setStyleSheet("");
|
|
UpdateSettingsFromMemeory();
|
|
UpdateOtherPanels();
|
|
}else{
|
|
SendLogMsg(msg + "|Fail.");
|
|
cb->setStyleSheet("color:red;");
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|