66,6 → 66,12 |
void SetPosition(); |
void GetPosition(); |
void HomePosition(); |
|
void InitializeScope(); |
void StartScopeAcq(); |
void CustomScopeCommand(); |
void SelectedMeasType(int mtype); |
|
void SaveFile(); |
void StartAcq(); |
|
101,6 → 107,7 |
double tdctimeconversion = 45.0909; |
double lenconversion = 0.3595; |
int oscOn; |
const char *allMeasNames[11] = {"Amplitude","Area","Delay","Fall","Frequency","Maximum","Mean","Minimum","Peak-to-peak","Peak width","Rise"}; |
|
// ROOT file variable structure ----------- |
struct EventHeader { |
119,9 → 126,17 |
int tdcdata[8]; |
} evtdata; |
|
struct EventMeas { |
double measdata; |
} evtmeas; |
|
TFile *inroot; |
TFile *outroot; |
|
// Test graphs for scope measurements |
TCanvas *wCanvas; |
TGraph *testgraph; |
|
//--------------------------------------------------------------- |
// Global variables |
|
134,6 → 149,7 |
TGNumberEntry *vHardlimit; |
TGNumberEntry *NCH; |
TGTextEntry *laserInfo; |
TGNumberEntry *chtemp; |
TGCheckButton *cleanOn; |
|
TGTab *setTab; |
197,6 → 213,16 |
TGNumberEntry *accError; |
TGCheckButton *exfitplots; |
|
//TGButtonGroup *sChangroup; |
TGCheckButton *sCH[8]; |
TGComboBox *sMeasType; |
TGCheckButton *sCamaclink; |
TGTextEntry *scopeCommand; |
TGTextEntry *scopeReturn; |
TGTextButton *sendScopeCustom; |
TGComboBox *sMeasgroup; |
TGTextButton *scopeInit; |
|
Bool_t firstrun = kTRUE; |
Bool_t started; |
Bool_t cleanPlots = kTRUE; |
287,6 → 313,71 |
printf("Outfile (remove_from_last): %s\n", outname); |
} |
|
void SeqNumber(int innum, int maxnum, char *outstr) |
{ |
int zeronum = 5; |
|
// Check how many zeroes we need to add to get sequential numbers |
if( (maxnum > 0) && (maxnum < 1000) ) |
zeronum = 2; |
else if( (maxnum >= 1000) && (maxnum < 10000) ) |
zeronum = 3; |
else if( (maxnum >= 10000) && (maxnum < 100000) ) |
zeronum = 4; |
else if( (maxnum >= 100000) && (maxnum < 1000000) ) |
zeronum = 5; |
|
// Make the sequence number depending on the number of zeroes |
if(zeronum == 2) |
{ |
if(innum < 10) |
sprintf(outstr, "00%d", innum); |
else if( (innum >= 10) && (innum < 100) ) |
sprintf(outstr, "0%d", innum); |
else if( (innum >= 100) && (innum < 1000) ) |
sprintf(outstr, "%d", innum); |
} |
else if(zeronum == 3) |
{ |
if(innum < 10) |
sprintf(outstr, "000%d", innum); |
else if( (innum >= 10) && (innum < 100) ) |
sprintf(outstr, "00%d", innum); |
else if( (innum >= 100) && (innum < 1000) ) |
sprintf(outstr, "0%d", innum); |
else if( (innum >= 1000) && (innum < 10000) ) |
sprintf(outstr, "%d", innum); |
} |
else if(zeronum == 4) |
{ |
if(innum < 10) |
sprintf(outstr, "0000%d", innum); |
else if( (innum >= 10) && (innum < 100) ) |
sprintf(outstr, "000%d", innum); |
else if( (innum >= 100) && (innum < 1000) ) |
sprintf(outstr, "00%d", innum); |
else if( (innum >= 1000) && (innum < 10000) ) |
sprintf(outstr, "0%d", innum); |
else if( (innum >= 10000) && (innum < 100000) ) |
sprintf(outstr, "%d", innum); |
} |
else if(zeronum == 5) |
{ |
if(innum < 10) |
sprintf(outstr, "00000%d", innum); |
else if( (innum >= 10) && (innum < 100) ) |
sprintf(outstr, "0000%d", innum); |
else if( (innum >= 100) && (innum < 1000) ) |
sprintf(outstr, "000%d", innum); |
else if( (innum >= 1000) && (innum < 10000) ) |
sprintf(outstr, "00%d", innum); |
else if( (innum >= 10000) && (innum < 100000) ) |
sprintf(outstr, "0%d", innum); |
else if( (innum >= 100000) && (innum < 1000000) ) |
sprintf(outstr, "%d", innum); |
} |
} |
|
// Peak detection function |
int npeaks; |
double FindPeaks(double *x, double *par) |
385,7 → 476,6 |
int scopeState = -1; |
char *IPaddr = (char*)oscIP->GetText(); |
int IPcorr = 0; |
char buf[BSIZE]; |
|
if(oscOn == 0) |
{ |
396,12 → 486,13 |
|
if( (IPaddr != NULL) && (IPcorr == 3) ) |
{ |
#if WORKSTAT == 'I' |
#if WORKSTAT == 'I' || WORKSTAT == 'S' |
printf("Connecting to oscilloscope.\n"); |
retTemp = gScopeDaq->connect(IPaddr); |
scopeState = 1; // For testing instead of making a real connection |
#else |
scopeState = 1; |
retTemp = 0; |
#endif |
} |
else |
410,40 → 501,71 |
printf("Please enter a valid scope IP address.\n"); |
} |
} |
else if(oscOn == 1) |
else if(oscOn > 0) |
{ |
#if WORKSTAT == 'I' |
#if WORKSTAT == 'I' || WORKSTAT == 'S' |
printf("Disconnecting from oscilloscope.\n"); |
retTemp = gScopeDaq->disconnect(IPaddr); |
scopeState = -1; // For testing instead of making a real disconnection |
#else |
scopeState = -1; |
retTemp = 0; |
#endif |
} |
|
if(retTemp == 0) |
{ |
if(scopeState >= 0) |
{ |
setTab->SetEnabled(1, kTRUE); |
setTab->SetEnabled(2, kTRUE); |
oscIP->SetEnabled(kFALSE); |
oscConnect->SetText("Disconnect"); |
oscConnect->SetTextJustify(36); |
oscConnect->SetWrapLength(-1); |
oscConnect->Resize(60,22); |
|
for(int i = 0; i < 8; i++) |
{ |
sCH[i]->SetState(kButtonUp); |
sCH[i]->SetEnabled(kFALSE); |
} |
sMeasType->SetEnabled(kTRUE); |
sCamaclink->SetState(kButtonUp); |
sCamaclink->SetEnabled(kFALSE); |
scopeCommand->SetEnabled(kTRUE); |
sendScopeCustom->SetEnabled(kTRUE); |
sMeasgroup->SetEnabled(kFALSE); |
scopeInit->SetEnabled(kFALSE); |
|
oscOn = 1; |
} |
else |
{ |
setTab->SetEnabled(1, kFALSE); |
setTab->SetEnabled(2, kFALSE); |
oscIP->SetEnabled(kTRUE); |
oscConnect->SetText("Connect"); |
oscConnect->SetTextJustify(36); |
oscConnect->SetWrapLength(-1); |
oscConnect->Resize(60,22); |
|
for(int i = 0; i < 8; i++) |
{ |
sCH[i]->SetState(kButtonUp); |
sCH[i]->SetEnabled(kFALSE); |
} |
sMeasType->Select(0); |
sMeasType->SetEnabled(kFALSE); |
sCamaclink->SetState(kButtonUp); |
sCamaclink->SetEnabled(kFALSE); |
scopeCommand->SetEnabled(kFALSE); |
sendScopeCustom->SetEnabled(kFALSE); |
sMeasgroup->SetEnabled(kFALSE); |
scopeInit->SetEnabled(kFALSE); |
|
oscOn = 0; |
} |
} |
else |
printf("Error! Connecting/disconnecting failed.\n"); |
} |
|
// Set the output voltage |
void TGAppMainFrame::SetVoltOut() |
633,6 → 755,195 |
#endif |
} |
|
// Initialize the currently connected scope for measurements |
void TGAppMainFrame::InitializeScope() |
{ |
int iTemp; |
int chTemp[8]; |
for(int i = 0; i < 8; i++) chTemp[i] = -1; |
gScopeDaq->scopeUseType = sMeasType->GetSelected(); |
|
// Check what channels are selected |
iTemp = 0; |
for(int i = 0; i < 8; i++) |
{ |
if(sCH[i]->IsDown()) |
{ |
chTemp[iTemp] = i; |
iTemp++; |
} |
} |
if(iTemp == 0) |
{ |
// If no channel is selected, we select the first one |
chTemp[0] = 0; |
iTemp++; |
sCH[0]->SetState(kButtonDown); |
} |
// If measurement is used, only use the first selected channel |
if(gScopeDaq->scopeUseType == 2) |
{ |
for(int i = 1; i < iTemp; i++) |
sCH[chTemp[i]]->SetState(kButtonUp); |
iTemp = 1; |
} |
|
gScopeDaq->scopeChanNr = iTemp; |
for(int i = 0; i < 8; i++) gScopeDaq->scopeChans[i] = chTemp[i]; |
|
// Check which measurement is selected |
gScopeDaq->scopeMeasSel = sMeasgroup->GetSelected(); |
|
gScopeDaq->init(); |
} |
|
// Run a scope measurement |
void TGAppMainFrame::StartScopeAcq() |
{ |
// Lock the scope front panel |
gScopeDaq->lockunlock(true); |
|
retTemp = gScopeDaq->event(); |
|
if(gScopeDaq->scopeUseType == 1) |
{ |
char len[16]; |
int sval; |
short *spoints; |
|
if(retTemp == 0) |
{ |
// Read the number of y bytes at beginning of CURVE binary data |
memcpy(len, &gScopeDaq->eventbuf[1],1); |
len[1] = 0; |
sval = atoi(len); |
// printf("Number of y bytes = %d\n", sval); |
|
// Read the data |
spoints = (short *)(&gScopeDaq->eventbuf[2+sval]); |
|
// Read the number of data points |
memcpy(len, &gScopeDaq->eventbuf[2],sval); |
len[sval] = 0; |
sval = atoi(len); |
// printf("Number of data points = %d\n", sval/2); |
|
double *grafx, *grafy; |
grafx = new double[sval/2]; |
grafy = new double[sval/2]; |
// Parse data and graph it |
for(int i = 0; i < sval/2; i++) |
{ |
grafx[i] = i*gScopeDaq->tektime*10./(sval/2.); |
grafy[i] = ((double)spoints[i]*5.*gScopeDaq->tekvolt/32767.) - (gScopeDaq->choffset*gScopeDaq->tekvolt); |
} |
|
wCanvas->cd(); |
testgraph = new TGraph(sval/2, grafx, grafy); |
testgraph->GetXaxis()->SetTitle("Time [s]"); |
testgraph->GetXaxis()->SetRangeUser(grafx[0], grafx[(sval/2)-1]); |
testgraph->GetYaxis()->SetTitle("Voltage [V]"); |
testgraph->Draw("AL"); |
wCanvas->Modified(); |
wCanvas->Update(); |
|
delete[] grafx; |
delete[] grafy; |
} |
} |
else if(gScopeDaq->scopeUseType == 2) |
{ |
if(retTemp == 0) |
{ |
if(gScopeDaq->measubuf < 1.e-4) |
printf("Measurement: %le\n", gScopeDaq->measubuf); |
else |
printf("Measurement: %lf\n", gScopeDaq->measubuf); |
} |
} |
|
// Unlock the scope front panel |
gScopeDaq->lockunlock(false); |
} |
|
// Send a custom command to the scope |
void TGAppMainFrame::CustomScopeCommand() |
{ |
char *cmd = (char*)scopeCommand->GetText(); |
char ret[100000]; |
if( strchr(cmd, '?') == NULL) |
{ |
printf("Sending command: %s\n", cmd); |
#if WORKSTAT == 'I' || WORKSTAT == 'S' |
gScopeDaq->customCommand(cmd, false, ret); |
#endif |
} |
else |
{ |
printf("Sending query: %s\n", cmd); |
#if WORKSTAT == 'I' || WORKSTAT == 'S' |
gScopeDaq->customCommand(cmd, true, ret); |
#endif |
} |
|
#if WORKSTAT == 'I' || WORKSTAT == 'S' |
scopeReturn->SetText(ret); |
#endif |
} |
|
// When we select the measurement type, change other scope settings accordingly |
void TGAppMainFrame::SelectedMeasType(int mtype) |
{ |
// No waveform analysis |
if(mtype == 0) |
{ |
for(int i = 0; i < 8; i++) |
{ |
sCH[i]->SetState(kButtonUp); |
sCH[i]->SetEnabled(kFALSE); |
} |
sMeasType->SetEnabled(kTRUE); |
sCamaclink->SetState(kButtonUp); |
sCamaclink->SetEnabled(kFALSE); |
scopeCommand->SetEnabled(kTRUE); |
sendScopeCustom->SetEnabled(kTRUE); |
sMeasgroup->SetEnabled(kFALSE); |
scopeInit->SetEnabled(kFALSE); |
|
oscOn = 1; |
} |
// Complete waveform acquisition |
else if(mtype == 1) |
{ |
for(int i = 0; i < 8; i++) |
sCH[i]->SetEnabled(kTRUE); |
sMeasType->SetEnabled(kTRUE); |
sCamaclink->SetState(kButtonDown); |
sCamaclink->SetEnabled(kTRUE); |
scopeCommand->SetEnabled(kTRUE); |
sendScopeCustom->SetEnabled(kTRUE); |
sMeasgroup->SetEnabled(kFALSE); |
scopeInit->SetEnabled(kTRUE); |
|
oscOn = 2; |
} |
// Waveform measurements |
else if(mtype == 2) |
{ |
for(int i = 0; i < 8; i++) |
sCH[i]->SetEnabled(kTRUE); |
sMeasType->SetEnabled(kTRUE); |
sCamaclink->SetState(kButtonUp); |
sCamaclink->SetEnabled(kTRUE); |
scopeCommand->SetEnabled(kTRUE); |
sendScopeCustom->SetEnabled(kTRUE); |
sMeasgroup->SetEnabled(kTRUE); |
scopeInit->SetEnabled(kTRUE); |
|
oscOn = 3; |
} |
} |
|
// Make breakdown voltage plot |
void TGAppMainFrame::MakeBreakdownPlot(int nrp, double *volt, double *volterr, double *psep1, double *pseperr1, double *psep2, double *pseperr2, double *psep3, double *pseperr3, char *plotfile) |
{ |
1350,7 → 1661,9 |
float progVal; |
|
char ctemp[256]; |
char ctemp2[256]; |
char fname[256]; |
int itemp = 0; |
|
remove_ext((char*)fileName->GetText(), ctemp); |
// printf("Save name: %s\nNo extension: %s\n", fileName->GetText(), ctemp); |
1366,20 → 1679,55 |
{ |
if(zaxisscan == 0) |
{ |
if(runCase < 10) |
sprintf(fname, "%s_0000%d%s", ctemp, runCase, histExt); |
else if( (runCase >= 10) && (runCase < 100) ) |
sprintf(fname, "%s_000%d%s", ctemp, runCase, histExt); |
else if( (runCase >= 100) && (runCase < 1000) ) |
sprintf(fname, "%s_00%d%s", ctemp, runCase, histExt); |
else if( (runCase >= 1000) && (runCase < 10000) ) |
sprintf(fname, "%s_0%d%s", ctemp, runCase, histExt); |
else if( (runCase >= 10000) && (runCase < 100000) ) |
sprintf(fname, "%s_%d%s", ctemp, runCase, histExt); |
if( (voltscanOn->IsOn()) && (vOutStep->GetNumber() > 0.) ) |
SeqNumber(runCase, (int)((vOutStop->GetNumber())-(vOutStart->GetNumber()))/(vOutStep->GetNumber()), ctemp2); |
else if( surfscanOn->IsOn() ) |
{ |
if( xPosStep->GetNumber() == 0 ) |
itemp = 1; |
else |
itemp = (int)((xPosMax->GetNumber())-(xPosMin->GetNumber()))/(xPosStep->GetNumber()); |
|
if( yPosStep->GetNumber() == 0 ) |
itemp *= 1; |
else |
itemp *= (int)((yPosMax->GetNumber())-(yPosMin->GetNumber()))/(yPosStep->GetNumber()); |
SeqNumber(runCase, itemp, ctemp2); |
} |
sprintf(fname, "%s_%s%s", ctemp, ctemp2, histExt); |
} |
else if(zaxisscan == 1) |
{ |
if(runCase < 10) |
SeqNumber((int)zPos->GetNumber(), (int)zPosMax->GetNumber(), ctemp2); |
|
if( (voltscanOn->IsOn()) && (vOutStep->GetNumber() > 0.) ) |
{ |
sprintf(fname, "%s_z%s_", ctemp, ctemp2); |
SeqNumber(runCase, (int)((vOutStop->GetNumber())-(vOutStart->GetNumber()))/(vOutStep->GetNumber())+1, ctemp2); |
strcat(fname, ctemp2); |
strcat(fname, histExt); |
} |
else if( surfscanOn->IsOn() ) |
{ |
sprintf(fname, "%s_z%s_", ctemp, ctemp2); |
|
if( xPosStep->GetNumber() == 0 ) |
itemp = 1; |
else |
itemp = (int)((xPosMax->GetNumber())-(xPosMin->GetNumber()))/(xPosStep->GetNumber())+1; |
|
if( yPosStep->GetNumber() == 0 ) |
itemp *= 1; |
else |
itemp *= (int)((yPosMax->GetNumber())-(yPosMin->GetNumber()))/(yPosStep->GetNumber())+1; |
SeqNumber(runCase, itemp, ctemp2); |
strcat(fname, ctemp2); |
strcat(fname, histExt); |
} |
else |
sprintf(fname, "%s_z%s%s", ctemp, ctemp2, histExt); |
|
/* if(runCase < 10) |
sprintf(fname, "%s_z%d_0000%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt); |
else if( (runCase >= 10) && (runCase < 100) ) |
sprintf(fname, "%s_z%d_000%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt); |
1389,8 → 1737,8 |
sprintf(fname, "%s_z%d_0%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt); |
else if( (runCase >= 10000) && (runCase < 100000) ) |
sprintf(fname, "%s_z%d_0%d%s", ctemp, (int)zPos->GetNumber(), runCase, histExt); |
*/ } |
} |
} |
else if( !voltscanOn->IsOn() && !surfscanOn->IsOn() ) |
sprintf(fname, "%s%s", ctemp, histExt); |
// printf("Rootfile: %s\n", fname); |
1405,7 → 1753,8 |
outroot = new TFile(fname, "RECREATE"); |
|
TTree *header_data = new TTree("header_data", "Header information for the measurement."); |
TTree *meas_data = new TTree("meas_data", "Saved measurement data."); |
TTree *meas_data = new TTree("meas_data", "Saved ADC and TDC measurement data."); |
TTree *scope_data = new TTree("scope_data", "Saved scope measurement data."); |
|
// Branches for the header |
header_data->Branch("nrch", &evtheader.nrch, "nrch/I"); |
1423,7 → 1772,7 |
evtheader.xpos = (int)xPos->GetNumber(); |
evtheader.ypos = (int)yPos->GetNumber(); |
evtheader.zpos = (int)zPos->GetNumber(); |
evtheader.temperature = 25.0; // Still to do!!! |
evtheader.temperature = (double)chtemp->GetNumber(); |
sprintf(evtheader.laserinfo, "%s", laserInfo->GetText()); |
|
char histtime[256]; |
1451,6 → 1800,37 |
meas_data->Branch(ctemp, &evtdata.tdcdata[i], fname); |
} |
|
// Initialize the scope before measurement |
if( sCamaclink->IsDown() ) |
InitializeScope(); |
|
// Branch for scope measurement data |
if(gScopeDaq->scopeUseType == 2) // only if we select waveform measurement |
{ |
if(gScopeDaq->scopeMeasSel == 0) |
scope_data->Branch("amp", &evtmeas.measdata, "amp/D"); |
else if(gScopeDaq->scopeMeasSel == 1) |
scope_data->Branch("area", &evtmeas.measdata, "area/D"); |
else if(gScopeDaq->scopeMeasSel == 2) |
scope_data->Branch("delay", &evtmeas.measdata, "delay/D"); |
else if(gScopeDaq->scopeMeasSel == 3) |
scope_data->Branch("fall", &evtmeas.measdata, "fall/D"); |
else if(gScopeDaq->scopeMeasSel == 4) |
scope_data->Branch("freq", &evtmeas.measdata, "freq/D"); |
else if(gScopeDaq->scopeMeasSel == 5) |
scope_data->Branch("max", &evtmeas.measdata, "max/D"); |
else if(gScopeDaq->scopeMeasSel == 6) |
scope_data->Branch("mean", &evtmeas.measdata, "mean/D"); |
else if(gScopeDaq->scopeMeasSel == 7) |
scope_data->Branch("min", &evtmeas.measdata, "min/D"); |
else if(gScopeDaq->scopeMeasSel == 8) |
scope_data->Branch("pk2p", &evtmeas.measdata, "pk2p/D"); |
else if(gScopeDaq->scopeMeasSel == 9) |
scope_data->Branch("pwidth", &evtmeas.measdata, "pwidth/D"); |
else if(gScopeDaq->scopeMeasSel == 10) |
scope_data->Branch("rise", &evtmeas.measdata, "rise/D"); |
} |
|
int neve = (int) evtNum->GetNumber(); |
int allEvt, zProg; |
zProg = 1; |
1500,9 → 1880,21 |
evtdata.tdcdata[i/2] = (int)adc; |
else if(i % 2 == 1) // ADC |
evtdata.adcdata[i/2] = (int)adc; |
|
// Start plotting the scope waveform |
if( (gScopeDaq->scopeUseType == 1) && (sCamaclink->IsDown()) ) |
StartScopeAcq(); |
} |
meas_data->Fill(); |
|
// Start making a scope measurement |
if( (gScopeDaq->scopeUseType == 2) && (sCamaclink->IsDown()) ) |
{ |
StartScopeAcq(); |
evtmeas.measdata = gScopeDaq->measubuf; |
} |
scope_data->Fill(); |
|
n++; |
nc += evtheader.nrch; |
nb -= evtheader.nrch; |
1532,8 → 1924,10 |
|
header_data->Write(); |
meas_data->Write(); |
scope_data->Write(); |
delete header_data; |
delete meas_data; |
delete scope_data; |
|
outroot->Close(); |
} |
1608,7 → 2002,7 |
fflush(stdout); |
|
printf("Waiting for voltage change...\n"); |
sleep(5); |
sleep(3); |
vOut->SetNumber(currentVoltage); |
printf("Continuing...\n"); |
|
2792,6 → 3186,15 |
fH1->AddFrame(laserInfo, f2); |
mdiFrame->AddFrame(fH1, f2); |
|
// Chamber temperature (will only be manually set until we can get it directly from the chamber) |
fH1 = new TGHorizontalFrame(mdiFrame, subgroup[0], 30); |
lab = new TGLabel(fH1, "Chamber temp.:"); |
fH1->AddFrame(lab, f0center2d); |
chtemp = new TGNumberEntry(fH1, 25.0, 6, 999, TGNumberFormat::kNESRealOne, TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, -70., 150.); |
chtemp->Resize(60,22); |
fH1->AddFrame(chtemp, f0center2d); |
mdiFrame->AddFrame(fH1, f2); |
|
mdiFrame->SetMdiHints(kMdiMinimize); |
mdiFrame->SetWindowName("Settings pane"); |
mdiFrame->MapSubwindows(); |
3026,23 → 3429,121 |
fT1->AddFrame(fH1, f1); |
|
// Waveform tab |
fT1 = setTab->AddTab("Waveform"); |
fT1 = setTab->AddTab("Waveform analysis"); |
fH1 = new TGHorizontalFrame(fT1, subwin[0], subgroup[1], kFixedHeight); |
lab = new TGLabel(fH1, "Waveform controls"); |
fH1->AddFrame(lab, f0center2d); |
fT1->AddFrame(fH1, f0); |
subgroup[0] = 1*subwin[0]/2-12; |
fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1]/3, kFixedWidth); |
|
// Wave measurements tab |
fT1 = setTab->AddTab("Measurement"); |
fH1 = new TGHorizontalFrame(fT1, subwin[0], subgroup[1], kFixedHeight); |
lab = new TGLabel(fH1, "Waveform measurement controls"); |
fH1->AddFrame(lab, f0center2d); |
fT1->AddFrame(fH1, f0); |
fG1 = new TGGroupFrame(fV1, "Acquisition channel"); |
|
// Selection of channels |
fH2 = new TGHorizontalFrame(fG1, subgroup[0], 100); |
sCH[0] = new TGCheckButton(fH2, "CH1"); |
sCH[0]->Resize(50,22); |
sCH[0]->SetState(kButtonUp); |
fH2->AddFrame(sCH[0], f0centerx); |
sCH[1] = new TGCheckButton(fH2, "CH2"); |
sCH[1]->Resize(50,22); |
sCH[1]->SetState(kButtonUp); |
fH2->AddFrame(sCH[1], f0centerx); |
sCH[2] = new TGCheckButton(fH2, "CH3"); |
sCH[2]->Resize(50,22); |
sCH[2]->SetState(kButtonUp); |
fH2->AddFrame(sCH[2], f0centerx); |
sCH[3] = new TGCheckButton(fH2, "CH4"); |
sCH[3]->Resize(50,22); |
sCH[3]->SetState(kButtonUp); |
fH2->AddFrame(sCH[3], f0centerx); |
fG1->AddFrame(fH2, f0centerx); |
|
// Selection of MATH channels |
fH2 = new TGHorizontalFrame(fG1, subgroup[0], 100); |
sCH[4] = new TGCheckButton(fH2, "MATH1"); |
sCH[4]->Resize(50,22); |
sCH[4]->SetState(kButtonUp); |
fH2->AddFrame(sCH[4], f0centerx); |
sCH[5] = new TGCheckButton(fH2, "MATH2"); |
sCH[5]->Resize(50,22); |
sCH[5]->SetState(kButtonUp); |
fH2->AddFrame(sCH[5], f0centerx); |
sCH[6] = new TGCheckButton(fH2, "MATH3"); |
sCH[6]->Resize(50,22); |
sCH[6]->SetState(kButtonUp); |
fH2->AddFrame(sCH[6], f0centerx); |
sCH[7] = new TGCheckButton(fH2, "MATH4"); |
sCH[7]->Resize(50,22); |
sCH[7]->SetState(kButtonUp); |
fH2->AddFrame(sCH[7], f0centerx); |
fG1->AddFrame(fH2, f0centerx); |
|
fV1->AddFrame(fG1, f2); |
|
// Selection of measurement type |
fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30); |
lab = new TGLabel(fH2, "Scope use type:"); |
fH2->AddFrame(lab, f0center2d); |
sMeasType = new TGComboBox(fH2, 200); |
sMeasType->AddEntry("No waveform analysis", 0); |
sMeasType->AddEntry("Waveform acquisition", 1); |
sMeasType->AddEntry("Measurement", 2); |
sMeasType->Resize(150,22); |
sMeasType->Select(0); |
fH2->AddFrame(sMeasType, f0center2d); |
fV1->AddFrame(fH2, f2); |
|
// Link waveform analysis to CAMAC acquisition |
sCamaclink = new TGCheckButton(fV1, "Link waveform to CAMAC acquisition"); |
sCamaclink->Resize(200,22); |
sCamaclink->SetState(kButtonUp); |
fV1->AddFrame(sCamaclink, f0centerx); |
|
// Custom command interface for the scope |
lab = new TGLabel(fV1, "Custom scope command:"); |
fV1->AddFrame(lab, new TGLayoutHints(kLHintsLeft | kLHintsTop,2,2,10,2) ); |
fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30); |
scopeCommand = new TGTextEntry(fH2, ""); |
scopeCommand->Resize(subgroup[0]-45,22); |
fH2->AddFrame(scopeCommand, f2); |
sendScopeCustom = new TGTextButton(fH2, "Send"); |
sendScopeCustom->SetTextJustify(36); |
sendScopeCustom->SetWrapLength(-1); |
sendScopeCustom->Resize(80,22); |
fH2->AddFrame(sendScopeCustom, f0centery); |
fV1->AddFrame(fH2, f0); |
|
// Return value for custom scope command |
lab = new TGLabel(fV1, "Return:"); |
fV1->AddFrame(lab, new TGLayoutHints(kLHintsLeft | kLHintsTop,2,2,10,2) ); |
scopeReturn = new TGTextEntry(fV1, ""); |
scopeReturn->Resize(subgroup[0],22); |
fV1->AddFrame(scopeReturn, f2); |
|
fH1->AddFrame(fV1, f0); |
|
// Wave measurement type |
fV1 = new TGVerticalFrame(fH1, subgroup[0], subgroup[1]/3, kFixedWidth); |
fH2 = new TGHorizontalFrame(fV1, subgroup[0], 30); |
lab = new TGLabel(fH2, "Meas. type:"); |
fH2->AddFrame(lab, f0center2d); |
sMeasgroup = new TGComboBox(fH2, 200); |
for(int i = 0; i < 11; i++) |
sMeasgroup->AddEntry(allMeasNames[i], i); |
sMeasgroup->Resize(150,22); |
sMeasgroup->Select(4); |
fH2->AddFrame(sMeasgroup, f0center2d); |
fV1->AddFrame(fH2, f2); |
|
// Initialize current acquisition settings |
scopeInit = new TGTextButton(fV1, "Initialize scope"); |
scopeInit->SetTextJustify(36); |
scopeInit->SetWrapLength(-1); |
scopeInit->Resize(80,22); |
fV1->AddFrame(scopeInit, f0centerx); |
|
fH1->AddFrame(fV1, f0); |
fT1->AddFrame(fH1, f1); |
|
mdiFrame->AddFrame(setTab, f0); |
// Disable the two tabs regarding the Scope if not connected to one |
setTab->SetEnabled(1,kFALSE); |
setTab->SetEnabled(2,kFALSE); |
|
// Bottom pane (File controls) |
subgroup[0] = subwin[0]-20; |
3403,10 → 3904,26 |
logscale->Connect("Clicked()", "TGAppMainFrame", this, "SetHistRange()"); |
exportHist->Connect("Clicked()", "TGAppMainFrame", this, "HistogramExport()"); |
|
scopeInit->Connect("Clicked()", "TGAppMainFrame", this, "InitializeScope()"); |
sendScopeCustom->Connect("Clicked()", "TGAppMainFrame", this, "CustomScopeCommand()"); |
sMeasType->Connect("Selected(Int_t)", "TGAppMainFrame", this, "SelectedMeasType(Int_t)"); |
|
started = kFALSE; |
|
for(int i = 0; i < 8; i++) sCH[i]->SetEnabled(kFALSE); |
sMeasType->SetEnabled(kFALSE); |
sCamaclink->SetEnabled(kFALSE); |
scopeCommand->SetEnabled(kFALSE); |
sendScopeCustom->SetEnabled(kFALSE); |
sMeasgroup->SetEnabled(kFALSE); |
scopeInit->SetEnabled(kFALSE); |
|
EnableVoltScan(); |
EnableSurfScan(); |
EnableZaxisScan(); |
|
// Testing canvas for scope waveforms |
wCanvas = new TCanvas("wCanvas", "Waveform canvas", 600, 300); |
} |
|
//--------------------------------------------------------------- |