FSUDAQ_Qt6/test.cpp

#include "macro.h"
#include "ClassData.h"
#include "ClassDigitizer.h"

#include "OnlineEventBuilder.h"

#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;

static void cooked(void);
static void uncooked(void);
static void raw(void);
int keyboardhit();
int getch(void);

//^======================================
int main(int argc, char* argv[]){

  const int nBoard = 1;
  Digitizer **dig = new Digitizer *[nBoard];
  
  for( int i = 0 ; i < nBoard; i++){
    int board = i % 3;
    int port = i/3;
    dig[i] = new Digitizer(board, port, false, true);
  }

  dig[0]->StopACQ();
  // dig[0]->WriteRegister(DPP::SoftwareClear_W, 1);

  // dig[0]->ProgramBoard();
  // dig[0]->ProgramPSDBoard();

  // const float ch2ns = dig[0]->GetCh2ns();

  OnlineEventBuilder * eb = new OnlineEventBuilder( dig[0] );

  Data * data =  dig[0]->GetData();

  data->OpenSaveFile("haha");

  printf("################# DPP Type : %d , %s\n", data->DPPType, data->DPPTypeStr.c_str());

  dig[0]->StartACQ();

  for( int i = 0; i < 3; i ++ ){
    usleep(100*1000);
    dig[0]->ReadData();
    data->DecodeBuffer(false, 1);
    data->PrintStat();

    data->SaveData();

    // int index = data->NumEventsDecoded[0];
    // printf("-------------- %ld \n", data->Waveform1[0][index].size());

    eb->BuildEvents(100);

  }

  dig[0]->StopACQ();


  data->PrintAllData();

  

  /*  
  TApplication * app = new TApplication("app", &argc, argv);
  TCanvas * canvas = new TCanvas("c", "haha", 1200, 400);
  canvas->Divide(3, 1);
  
  TH1F * h1 = new TH1F("h1", "count", dig[0]->GetNChannel(), 0, dig[0]->GetNChannel());
  TH1F * h2 = new TH1F("h2", "energy ch-0", 400, 0, 40000);
  
  TGraph * g1 = new TGraph();
  
  canvas->cd(1); h1->Draw("hist");
  canvas->cd(2); h2->Draw();
  canvas->cd(3); g1->Draw("AP");
  
  Data * data =  dig[0]->GetData();
  data->Allocate80MBMemory();
  
  remove("test.bin");
  
  dig[0]->StartACQ();
  
  std::vector<unsigned short> haha ;

  uint32_t PreviousTime = get_time();
  uint32_t CurrentTime = 0;
  uint32_t ElapsedTime = 0;

  int waveFormLength = dig[0]->ReadRegister(Register::DPP::RecordLength_G);

  while(true){
   
    if(keyboardhit()) {
      break;
    }
    
    usleep(1000);
    dig[0]->ReadData();
    
    if( data->nByte > 0 ){
      data->SaveBuffer("test");
      data->DecodeBuffer(0);
      
      unsigned short nData = data->DataIndex[0]; //channel-0
      haha = data->Waveform1[0][nData-1];
      for( int i = 0; i < waveFormLength; i++) g1->SetPoint(i, i*ch2ns, haha[i]);

      canvas->cd(3); g1->Draw("AP");
      
      canvas->Modified();
      canvas->Update(); 
      gSystem->ProcessEvents();
      
    }
    
    CurrentTime = get_time();
    ElapsedTime = CurrentTime - PreviousTime; /// milliseconds

    if( ElapsedTime > 1000 ){
      int temp = system("clear");
      data->PrintStat();
      
      for(int i = 0; i < dig[0]->GetNChannel(); i++){
        h1->Fill(i, data->DataIndex[i]);
      }
      
      for( int i = 0; i < data->DataIndex[0]; i++){
        h2->Fill( data->Energy[0][i]);
      }
      data->ClearData();
      
      canvas->cd(1); h1->Draw("hist");
      canvas->cd(2); h2->Draw();
      canvas->Modified();
      canvas->Update(); 
      gSystem->ProcessEvents();
      
      PreviousTime = CurrentTime;
      
      printf("Press any key to Stop\n");
    }
   
  }
  app->Run();
  */

  printf("Closing digitizers..............\n");
  for( int i = 0; i < nBoard; i++){
    if(dig[i]->IsConnected()) dig[i]->StopACQ();
    delete dig[i];
  }
  delete [] dig;
  
  /*********************/

  /**////##################### Demo for loading and change setting without open a digitizer
  
  /**
  Digitizer * dig = new Digitizer();
  dig->OpenDigitizer(0, 1, false, true);
  dig->LoadSettingBinaryToMemory("expDir/settings/setting_323.bin");

  
  //dig->ProgramPHABoard();
  //dig->OpenSettingBinary("setting_323.bin");
  //dig->ReadAllSettingsFromBoard();
  
  //dig->PrintSettingFromMemory();
  //dig->StopACQ();
  
  //dig->WriteRegister(Register::DPP::SoftwareClear_W, 1);
  
  printf("========== %d \n", dig->ReadSettingFromFile(Register::DPP::MaxAggregatePerBlockTransfer));
  
  
  ///dig->SaveSettingAsText("haha.txt");
  ///std::remove("Test_323_139_000.fsu");
  //printf("========== %d \n", dig->ReadRegister(Register::DPP::MaxAggregatePerBlockTransfer));
  
  delete dig;
  
  /**
  {///============ Checking the buffer size calculation
    unsigned short B = 10; /// BLT
    unsigned short Eg = 511; /// Event / dual channel
    bool DT = 1; /// dual trace
    bool E2 = 1; /// extra 2;
    bool Wr = 1; /// wave record;
    unsigned short AP2 = 0; /// 00 = input, 01 = Threshold, 10 = Trapezoid - Baseline, 11 = baseline  
    unsigned short AP1 = 1; /// 00 = input, 01 = RC-CR, 10 = RC-CR2, 11 = Trapezoid
    unsigned short DP1 = 0x0000; /// peaking, 
    unsigned short RL = 100; /// record Length
    unsigned short AO = 0x0;
    
    for( int i = 0; i < dig->GetNChannel(); i++){
      dig->WriteRegister(Register::DPP::NumberEventsPerAggregate_G, Eg, i); 
      dig->WriteRegister(Register::DPP::RecordLength_G, RL, i); 
    }
    dig->WriteRegister(Register::DPP::MaxAggregatePerBlockTransfer, B);
    dig->WriteRegister(Register::DPP::AggregateOrganization, AO);
    
    uint32_t bit = 0x0C0115;
    bit += (DT << 11);   
    bit += (AP1 << 12);  
    bit += (AP2 << 14);  
    bit += (Wr << 16);  
    bit += (E2 << 17);  
    bit += (DP1 << 20);
    
    printf("---- Bd Config : 0x%08X \n", bit);
    
    dig->WriteRegister(Register::DPP::BoardConfiguration, bit); 
      
    unsigned int bSize =  dig->CalByteForBuffer();

    int bbbb = (((2 + E2 + Wr*RL*4) * Eg + 2)*8 + 2)*B *4 *2 + 4 * 4; 
    printf("=========== exp Buffer size : %8u byte \n", bbbb);

    usleep(1e6);

    ///using CAEN method 
    char * buffer = NULL;
    uint32_t size;
    CAEN_DGTZ_MallocReadoutBuffer(dig->GetHandle(), (char **)& buffer, &size);
    
    printf("CAEN calculated Buffer Size : %8u byte = %.2f MB \n", size, size/1024./1024.);   
    printf("                       diff : %8u byte \n", size > 2*bSize ? size - 2*bSize : 2*bSize - size);
      
    delete buffer;
  }/**/
  
  //dig->GetData()->SetSaveWaveToMemory(true);
  
  //dig->StartACQ();
  //
  //for( int i = 0; i < 60; i++){    
  //  usleep(500*1000);
  //  dig->ReadData();
  //  printf("------------------- %d\n", i);
  //  unsigned long time1 = get_time();
  //  dig->GetData()->DecodeBuffer(false,0);
  //  unsigned long time2 = get_time();
  //  printf("********************* decode time : %lu usec\n", time2-time1);
  //  dig->GetData()->PrintStat();
  //  //dig->GetData()->SaveBuffer("Test");
  //}
  //
  //dig->StopACQ();
  

  
  return 0;
}

//*********************************
//*********************************

static void cooked(void){
  tcsetattr(0, TCSANOW, &g_old_kbd_mode);
}

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);
}

static void raw(void){

  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;
  
  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;
}