FSUDAQ_Qt6/Aux/test.cpp

159 lines
4.0 KiB
C++
Raw Normal View History

#include "../macro.h"
#include "../ClassData.h"
#include "../ClassDigitizer.h"
2023-11-21 18:03:10 -05:00
#include "../MultiBuilder.h"
2023-04-11 11:13:23 -04:00
#include <TROOT.h>
#include <TSystem.h>
#include <TApplication.h>
#include <TCanvas.h>
#include <TGraph.h>
#include <TH1.h>
#include <TFile.h>
#include <TTree.h>
#include <sys/time.h> /** struct timeval, select() */
#include <termios.h> /** tcgetattr(), tcsetattr() */
#include <vector>
static struct termios g_old_kbd_mode;
2023-04-11 14:23:38 -04:00
static void cooked(void);
static void uncooked(void);
static void raw(void);
int keyboardhit();
int getch(void);
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
//^======================================
int main(int argc, char* argv[]){
2023-04-11 11:13:23 -04:00
Digitizer * digi = new Digitizer(0, 26006, false, true);
2023-10-13 18:02:19 -04:00
digi->Reset();
2023-10-12 16:27:56 -04:00
//digi->ProgramBoard_PHA();
2023-10-11 18:28:19 -04:00
//digi->WriteRegister(DPP::SoftwareClear_W, 1);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->WriteRegister(DPP::QDC::RecordLength, 31, -1); // T = N * 8 * 16
// digi->WriteRegister(DPP::QDC::PreTrigger, 60, -1);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->WriteRegister(DPP::QDC::TriggerThreshold_sub2, 17, -1);
// digi->SetBits(DPP::QDC::DPPAlgorithmControl, DPP::QDC::Bit_DPPAlgorithmControl::ChargeSensitivity, 0, -1);
// digi->SetBits(DPP::QDC::DPPAlgorithmControl, DPP::QDC::Bit_DPPAlgorithmControl::InputSmoothingFactor, 4, -1);
// digi->SetBits(DPP::QDC::DPPAlgorithmControl, DPP::QDC::Bit_DPPAlgorithmControl::BaselineAvg, 2, -1);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->WriteRegister(DPP::QDC::GateWidth, 608/16, -1);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->WriteRegister(DPP::QDC::GroupEnableMask, 0x01);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->WriteRegister(DPP::QDC::NumberEventsPerAggregate, 10, -1);
// digi->WriteRegister(DPP::AggregateOrganization, 0, -1);
// digi->WriteRegister(DPP::MaxAggregatePerBlockTransfer, 100, -1);
2023-10-11 18:28:19 -04:00
2023-11-21 18:03:10 -05:00
// digi->SetBits(DPP::QDC::DPPAlgorithmControl, DPP::QDC::Bit_DPPAlgorithmControl::Polarity, 0, -1);
2023-10-11 18:28:19 -04:00
/*
2023-10-13 18:02:19 -04:00
digi->SetBits(DPP::BoardConfiguration, DPP::Bit_BoardConfig::EnableExtra2, 1, -1);
2023-11-21 18:03:10 -05:00
digi->SetBits(DPP::BoardConfiguration, DPP::Bit_BoardConfig::RecordTrace, 0, -1);
2023-10-09 17:46:32 -04:00
Data * data = digi->GetData();
2023-11-21 18:03:10 -05:00
MultiBuilder * builder = new MultiBuilder(data, DPPType::DPP_PHA_CODE, digi->GetSerialNumber());
builder->SetTimeWindow(100);
//remove("haha_*.fsu");
//data->OpenSaveFile("haha");
2023-10-09 17:46:32 -04:00
digi->StartACQ();
2023-10-09 17:46:32 -04:00
2023-11-21 18:03:10 -05:00
for( int i = 0; i < 5; i ++ ){
2023-10-09 17:46:32 -04:00
usleep(1000*1000);
digi->ReadData();
2023-10-13 18:02:19 -04:00
data->DecodeBuffer(true, 0);
//data->DecodeBuffer(false, 2);
2023-11-21 18:03:10 -05:00
//data->SaveData();
//data->PrintStat();
data->PrintAllData(true);
2023-10-09 17:46:32 -04:00
2023-12-08 17:03:52 -05:00
//builder->BuildEvents(false, true, true);
builder->BuildEventsBackWard(20, true);
2023-10-09 17:46:32 -04:00
2023-11-21 18:03:10 -05:00
builder->PrintStat();
2023-10-09 17:46:32 -04:00
// int index = data->NumEventsDecoded[0];
// printf("-------------- %ld \n", data->Waveform1[0][index].size());
}
digi->StopACQ();
2023-11-21 18:03:10 -05:00
//data->CloseSaveFile();
builder->BuildEvents(true, true, true);
2023-12-08 17:03:52 -05:00
2023-10-13 18:02:19 -04:00
data->PrintAllData();
2023-11-21 18:03:10 -05:00
builder->PrintAllEvent(); // TODO
*/
2023-11-21 18:03:10 -05:00
digi->CloseDigitizer();
delete digi;
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
return 0;
}
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
//*********************************
//*********************************
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
static void cooked(void){
tcsetattr(0, TCSANOW, &g_old_kbd_mode);
}
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
static void uncooked(void){
struct termios new_kbd_mode;
/** put keyboard (stdin, actually) in raw, unbuffered mode */
tcgetattr(0, &g_old_kbd_mode);
memcpy(&new_kbd_mode, &g_old_kbd_mode, sizeof(struct termios));
new_kbd_mode.c_lflag &= ~(ICANON | ECHO);
new_kbd_mode.c_cc[VTIME] = 0;
new_kbd_mode.c_cc[VMIN] = 1;
tcsetattr(0, TCSANOW, &new_kbd_mode);
}
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
static void raw(void){
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
static char init;
if(init) return;
/** put keyboard (stdin, actually) in raw, unbuffered mode */
uncooked();
/** when we exit, go back to normal, "cooked" mode */
atexit(cooked);
init = 1;
}
int keyboardhit(){
struct timeval timeout;
fd_set read_handles;
int status;
2023-04-11 11:13:23 -04:00
2023-04-11 14:23:38 -04:00
raw();
/** check stdin (fd 0) for activity */
FD_ZERO(&read_handles);
FD_SET(0, &read_handles);
timeout.tv_sec = timeout.tv_usec = 0;
status = select(0 + 1, &read_handles, NULL, NULL, &timeout);
if(status < 0){
printf("select() failed in keyboardhit()\n");
exit(1);
}
return (status);
}
int getch(void){
unsigned char temp;
raw();
/** stdin = fd 0 */
if(read(0, &temp, 1) != 1) return 0;
return temp;
2023-04-11 11:13:23 -04:00
}