FSUDAQ/test.cpp

#include "ClassData.h"
#include "ClassDigitizer.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() */

static struct termios g_old_kbd_mode;

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


unsigned long get_time(){
  unsigned long time_us;
  struct timeval t1;
  struct timezone tz;
  gettimeofday(&t1, &tz);
  time_us = (t1.tv_sec) * 1000000 + t1.tv_usec;
  return time_us;
}

int main(int argc, char* argv[]){
  
  /**////##################### Demo for loading and change setting without open a digitizer
  Digitizer * dig = new Digitizer();
  dig->OpenDigitizer(0, 1, false, true);
  dig->LoadSettingBinary("setting_323.bin");
  
  //dig->ProgramPHABoard();
  
  //dig->PrintSettingFromMemory();
  ///dig->SaveSettingAsText("haha.txt");
  
  for( int i = 0; i < dig->GetNChannel(); i++){
    dig->WriteRegister(Register::DPP::NumberEventsPerAggregate_G, 2, i); 
    dig->WriteRegister(Register::DPP::RecordLength_G, 200, i); 
  }
  dig->WriteRegister(Register::DPP::MaxAggregatePerBlockTransfer, 5, 0);
  dig->WriteRegister(Register::DPP::BoardConfiguration, 0x0F8115); /// has Extra2
  //dig->WriteRegister(Register::DPP::BoardConfiguration, 0x0D8115); /// no Extra2
  
  
  unsigned int bSize =  dig->CalByteForBuffer();
  printf("                Buffer Size : %8u byte = %.2f MB \n", bSize, bSize/1024./1024.);

  usleep(1e6);


  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 > bSize ? size - bSize : bSize - size);
  
  ///Block
  /// 1 -> 128
  /// 2 -> 240
  /// 3 -> 352
  /// 4 -> 464
  /// 5 -> 576
  
  delete buffer;

  //delete dig;
  
  /**///#####################  test with 2 digitizers

  /**
  const int nBoard = 2;
  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[i]->OpenSettingBinary("setting_" + to_string(dig[i]->GetSerialNumber()) + ".bin");
    dig[i]->LoadSettingBinary("setting_" + to_string(dig[0]->GetSerialNumber()) + ".bin");
  }

  dig[0]->SaveSettingAsText("haha.txt");
  
  
  
  delete dig[0];
  delete dig[1];
  
  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->AllocateMemory();
  
  remove("test.bin");
  
  dig[0]->StartACQ();
  
  std::vector<unsigned short> haha ;

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

  while(true){
   
    if(keyboardhit()) {
      break;
    }
    
    usleep(50000);
    dig[0]->ReadData();
    
    if( data->nByte > 0 ){
      data->SaveBuffer("test");
      data->DecodeBuffer(0);
      
      unsigned short nData = data->NumEvents[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->NumEvents[i]);
      }
      
      for( int i = 0; i < data->NumEvents[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");
    }
    
    
  }
  
  dig[0]->StopACQ();
  
  app->Run();
  
  delete [] dig;
  
  /*********************/
  
  return 0;
}