WebSVN – f9daq – Diff – /cvi/instr/DRS/drsread.cpp


/********************************************************************\
 
  Name:         drsread.cpp
  Created by:   Rok Pestotnik
 
  Contents:     Simple example application to read out a DRS4
                evaluation board and save into the data file
                                Interface dll for LabWindows CVI
 
\********************************************************************/
#ifdef DLLMAIN
#define DLLEXPORT  __declspec(dllexport)
#else 
#define DLLEXPORT  
#endif
 
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include <math.h>
#include <time.h>
#include <signal.h>
 
#include <TFile.h>
#include <TH2F.h>
#include <TCanvas.h>
//#include <TApplication.h>
 
#ifdef _MSC_VER
 
#include "gettimeofday.h"
#include "timer.h"
 
#define DIR_SEPARATOR '\\'
 
#elif defined(OS_LINUX) || defined(OS_DARWIN)
 
#define O_BINARY 0
#include <unistd.h>
#include <ctype.h>
#include <sys/ioctl.h>
#include <errno.h>
#define DIR_SEPARATOR '/'
#endif
 
#include "DRS.h"
#include "drsread.h"
 
 
/*------------------------------------------------------------------*/
class drssettings  {
    static drssettings *s_instance;
public:
   drssettings(){
       mask     = 0xF;
       range = 0;
       trigger_type = 1;
       sampling_frequency = 5;
       trigger_delay = 0;
       trigger_channel=0;
       trigger_polarity=false;
       trigger_level=0.05;
           
   };
   ~drssettings(){};
   static drssettings *instance()
    {
        if (!s_instance)
          s_instance = new drssettings;
        return s_instance;
    };
 
   
   unsigned char mask;
   double        range;
   int           trigger_type; // 0 software, 1 fast hardware, 2 slow hardware
   int           trigger_channel;
   int           sampling_frequency;
   double        trigger_delay;
   double        trigger_level;
   bool          trigger_polarity;
};
drssettings *drssettings::s_instance = 0;
drssettings *DRSParameters;
DLLEXPORT void DRSSetMask(int mask){ drssettings::instance()->mask;};
DLLEXPORT void DRSSetTriggerType(int type){ drssettings::instance()->trigger_type = type;};
DLLEXPORT void DRSSetFrequency(int freq){ drssettings::instance()->sampling_frequency = freq;};
DLLEXPORT void DRSSetRange(double range){ drssettings::instance()->range = range;};
DLLEXPORT void DRSSetTriggerChannel(int channel){ drssettings::instance()->trigger_channel = channel;};
DLLEXPORT void DRSSetTriggerDelay(double delay){ drssettings::instance()->trigger_delay = delay;};
DLLEXPORT void DRSSetTriggerLevel(double level){ drssettings::instance()->trigger_level = level;};
DLLEXPORT void DRSSetTriggerPolarity(int polarity){ drssettings::instance()->trigger_polarity = (polarity==1);};
 
 
static int DRSTimeout;
 
DLLEXPORT int DRSIsTimeout()
{
        return DRSTimeout;
}
 
DLLEXPORT void DRSSetTimeout ( void )
{
    DRSTimeout=1;
    printf("->>> Timer Out !!!\n");
}
 
static DRS *drs=NULL;
 
 
DLLEXPORT int DRSCalibrateTiming( )
{
   DRSBoard *b;
   if (drs == NULL) drs = new DRS();
   if (!drs) return -1;
   DRSParameters = drssettings::instance();
   
   //fCalMode = 2;
   if (drs->GetNumberOfBoards() ) {
        /* continue working with first board only */
     b = drs->GetBoard(0);
     
      if (b->GetFirmwareVersion() < 13279)
         printf("Firmware revision 13279 or later\nrequired for timing calibration\n");
      else if (b->GetInputRange() != 0)
         printf("Timing calibration can only be done\nat the -0.5V to +0.5V input range\n");
 
      else {
 
 
         /* remember current settings */
         double acalVolt   = b->GetAcalVolt();
         int    acalMode   = b->GetAcalMode();
         int    tcalFreq   = b->GetTcalFreq();
         int    tcalLevel  = b->GetTcalLevel();
         int    tcalSource = b->GetTcalSource();
         int    flag1      = b->GetTriggerEnable(0);
         int    flag2      = b->GetTriggerEnable(1);
         int    trgSource  = b->GetTriggerSource();
         int    trgDelay   = b->GetTriggerDelay();
         double range      = b->GetInputRange();
         int    config     = b->GetReadoutChannelConfig();
 
     
         int status = b->CalibrateTiming(NULL);
 
         if (!status)
            printf("Error performing timing calibration, please check waveforms and redo voltage calibration.\n");
         else
           printf("Timing calibration successfully finished.\n");
                     
 
         /* restore old values */
         b->EnableAcal(acalMode, acalVolt);
         b->EnableTcal(tcalFreq, tcalLevel);
         b->SelectClockSource(tcalSource);
         b->EnableTrigger(flag1, flag2);
         b->SetTriggerSource(trgSource);
         b->SetTriggerDelayPercent(trgDelay);
         b->SetInputRange(range);
         b->SetChannelConfig(config, 8, 8);
 
         if (b->GetBoardType() == 5)
            b->SetTranspMode(1); // Evaluation board with build-in trigger
         else
            b->SetTranspMode(1); // VPC Mezzanine board
 
         return status;
      }
     
   }
   return -1;
}
 
 
DLLEXPORT int DRSInit()
{
 
   DRSBoard *b;
   /* do drsinitial scan */
   if (drs == NULL) drs = new DRS();
   if (!drs) return -1;
   DRSParameters = drssettings::instance();
   
   /* show any found board(s) */
   for (int i=0 ; i<drs->GetNumberOfBoards() ; i++) {
      b = drs->GetBoard(i);
      printf("Found DRS4 evaluation board, serial #%d, firmware revision %d\n",
         b->GetBoardSerialNumber(), b->GetFirmwareVersion());
   }
 
   /* exit if no board found */
   int nBoards = drs->GetNumberOfBoards();
   if (nBoards == 0) {
      printf("No DRS4 evaluation board found\n");
      return -2;
   }
 
   /* continue working with first board only */
   b = drs->GetBoard(0);
 
   /* drsinitialize board */
   b->Init();
 
   /* set sampling frequency default 5 */
   b->SetFrequency(DRSParameters->sampling_frequency, true);
 
   /* enable transparent mode needed for analog trigger */
   b->SetTranspMode(1);
 
   /* set input range to -0.5V ... +0.5V -> range=0 */
   b->SetInputRange(DRSParameters->range);
 
   /* use following line to set range to 0..1V */
   //b->SetInputRange(0.5);
   
   /* use following line to turn on the internal 100 MHz clock connected to all channels  */
   //b->EnableTcal(1);
 
   /* kaj je to ....
    // Set domino mode
   // mode == 0: single sweep
   // mode == 1: run continously -- default
   b->SetDominoMode(1);
    // Set domino activity
   // mode == 0: stop during readout  
   // mode == 1: keep domino wave running -- default
   //  
   b->SetDominoActive(1);
   
   // Set readout mode
   // mode == 0: start from first bin  -- default
   // mode == 1: start from domino stop
   //
   b->SetReadoutMode(1);
   */
   
   /* use following lines to enable hardware trigger on CH1 at 50 mV positive edge */
   printf("Board Type:%d\n",b->GetBoardType() );
   if (b->GetBoardType() >= 8) {        // Evaluaiton Board V4&5
     
      b->EnableTrigger(DRSParameters->trigger_type, 0);           // enable hardware trigger - 1 fast trigger, 2 slow trigger, 0 disable hw trigger
      b->SetTriggerSource(1<<DRSParameters->trigger_channel);        // set CH1 as source // simple or of single channel
   } else if (b->GetBoardType() == 7) { // Evaluation Board V3
      b->EnableTrigger(0, 1);           // lemo off, analog trigger on
      b->SetTriggerSource(0);           // use CH1 as source
   }
   b->SetTriggerLevel(DRSParameters->trigger_level);            // 0.05 V
   b->SetTriggerPolarity(DRSParameters->trigger_polarity);        // positive edge
   
   /* use following lines to set individual trigger elvels */
   //b->SetIndividualTriggerLevel(1, 0.1);
   //b->SetIndividualTriggerLevel(2, 0.2);
   //b->SetIndividualTriggerLevel(3, 0.3);
   //b->SetIndividualTriggerLevel(4, 0.4);
   //b->SetTriggerSource(15);
   
   b->SetTriggerDelayNs( DRSParameters->trigger_delay);             // zero ns trigger delay
   
   /* use following lines to enable the external trigger */
   //if (b->GetBoardType() == 8) {     // Evaluaiton Board V4
   //   b->EnableTrigger(1, 0);           // enable hardware trigger
   //   b->SetTriggerSource(1<<4);        // set external trigger as source
   //} else {                          // Evaluation Board V3
   //   b->EnableTrigger(1, 0);           // lemo on, analog trigger off
   // }
 
   return 0;
 
 
}
 
static float DRSTimeArray[8][1024];
static float DRSWaveArray[8][1024];
 
DLLEXPORT float * DRSGetTime(int ch){ return DRSTimeArray[ch];}
DLLEXPORT float * DRSGetWave(int ch){ return DRSWaveArray[ch];}
 
DLLEXPORT int DRSRead( int DRStimer)
{
 
   DRSBoard *b = drs->GetBoard(0);
 
     
 
      /* wait for trigger */
         
 
      int tout=1000; /* timeout in mili seconds */
      DRSTimeout=0;
 
      if (DRStimer) start_timer(tout, &DRSSetTimeout);
       
          /* start board (activate domino wave) */
      b->StartDomino();
           
      if (!DRSParameters->trigger_type) b->SoftTrigger();
         
      while (b->IsBusy()){
                       
        if (DRSTimeout) {
          printf("Waiting for Trigger.. at line %d\n",  __LINE__);
 
          if (DRStimer) stop_timer();
         
          return -1;
        }
          };
     
 
      if (DRStimer) stop_timer();
 
   
       
      /* read all waveforms */
      b->TransferWaves(0, 8);
 
 
      for (int k=0;k<4;k++){
        if (! (DRSParameters->mask & ( 0x1<<k ))  ) continue;
      /* Note: On the evaluation board input #1 is connected to channel 0 and 1 of
       the DRS chip, input #2 is connected to channel 2 and 3 and so on. So to
       get the input #2 we have to read DRS channel #2, not #1. */
 
      /* read time (X) array of k-th channel in ns and waveform (Y) array of k-th channel in mV */
        b->GetTime(0, 2*k, b->GetTriggerCell(DRSParameters->trigger_channel), DRSTimeArray[k]);
        b->GetWave(0, 2*k, DRSWaveArray[k]);
       
         
      }
 
  return 0;    
}
 
DLLEXPORT int DRSEnd(){
   
   /* delete DRS object -> close USB connection */
   if (drs) delete drs;
   drs = NULL;
   return 0;
}
 
 
 
DLLEXPORT int DRSToBuffer( unsigned char *p, int m_evSerial  )
{
 
   unsigned short d;
   float t;
   unsigned char *p0 = p;
 
   int m_nBoards    = drs->GetNumberOfBoards();
   int m_waveDepth  = 1024 ;// 2048
   int m_inputRange = drs->GetBoard(0)->GetInputRange();  
   time_t rawtime;
   time ( &rawtime );
   struct tm m_evTimestamp;
   m_evTimestamp = *(localtime ( &rawtime ));
   struct timeval mtime;
   gettimeofday(&mtime, NULL);
     
      if (m_evSerial == 0) {
                 memcpy(p, "DRS2", 4); // File identifier and version
         p += 4;
         // time calibration header
                 memcpy(p, "TIME", 4);
         p += 4;
         for (int b=0 ; b<m_nBoards ; b++) {
            // store board serial number
            sprintf((char *)p, "B#");
            p += 2;
            *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber();
            p += sizeof(unsigned short);
 
            for (int i=0 ; i<4 ; i++) {
               if (DRSParameters->mask & (0x1<<i)) {
                  sprintf((char *)p, "C%03d", i+1);
                  p += 4;
                  float tcal[2048];
                  drs->GetBoard(b)->GetTimeCalibration(0, i*2, 0, tcal, 0);
                  for (int j=0 ; j<m_waveDepth ; j++) {
                     // save binary time as 32-bit float value
                     if (m_waveDepth == 2048) {
                        t = (tcal[j]+tcal[j+1])/2;
                        j++;
                     } else
                        t = tcal[j];
                     *(float *)p = t;
                     p += sizeof(float);
                  }
               }
            }
         }
      }
 
 
 
      memcpy(p, "EHDR", 4);
      p += 4;
      *(int *)p = m_evSerial;
      p += sizeof(int);
      *(unsigned short *)p = m_evTimestamp.tm_year;
      p += sizeof(unsigned short);
      *(unsigned short *)p = m_evTimestamp.tm_mon;
      p += sizeof(unsigned short);
      *(unsigned short *)p = m_evTimestamp.tm_mday;
      p += sizeof(unsigned short);
      *(unsigned short *)p = m_evTimestamp.tm_hour;
      p += sizeof(unsigned short);
      *(unsigned short *)p = m_evTimestamp.tm_min;
      p += sizeof(unsigned short);
      *(unsigned short *)p = m_evTimestamp.tm_sec;
      p += sizeof(unsigned short);
      *(unsigned short *)p = mtime.tv_usec/1000;
      p += sizeof(unsigned short);
      *(unsigned short *)p = (unsigned short)(m_inputRange * 1000); // range
      p += sizeof(unsigned short);
     
      int b=0; // only for board 0
 
         // store board serial number
         sprintf((char *)p, "B#");
         p += 2;
         *(unsigned short *)p = drs->GetBoard(b)->GetBoardSerialNumber();
         p += sizeof(unsigned short);
         
         // store trigger cell
         sprintf((char *)p, "T#");
         p += 2;
         *(unsigned short *)p = drs->GetBoard(b)->GetTriggerCell(DRSParameters->trigger_channel);
         p += sizeof(unsigned short);
         
         for (int i=0 ; i<4 ; i++) {
            if (DRSParameters->mask & (0x1<<i)) {
               sprintf((char *)p, "C%03d", i+1);
               p += 4;
                           unsigned int s = drs->GetBoard(b)->GetScaler(i);
               memcpy(p, &s, sizeof(int));
               p += sizeof(int);
               for (int j=0 ; j<m_waveDepth ; j++) {
                  // save binary date as 16-bit value:
                  // 0 = -0.5V,  65535 = +0.5V    for range 0
                  // 0 = -0.05V, 65535 = +0.95V   for range 0.45
                  if (m_waveDepth == 2048) {
                     // in cascaded mode, save 1024 values as averages of the 2048 values
                     d = (unsigned short)(((DRSWaveArray[i][j]+DRSWaveArray[i][j+1])/2000.0 - m_inputRange + 0.5) * 65535);
                     *(unsigned short *)p = d;
                     p += sizeof(unsigned short);
                     j++;
                  } else {
                     d = (unsigned short)((DRSWaveArray[i][j]/1000.0 - m_inputRange + 0.5) * 65535);
                     *(unsigned short *)p = d;
                     p += sizeof(unsigned short);
                  }
               }
            }
         }
   
   return (p-p0); // return number of bytes
}
 
 
 
#ifdef MAIN
 
 
 
#include "XGetopt.h"
#include "getopt.h"
 
TH2F *h[4];
 
typedef struct {
   char           recid[4];
   unsigned int posx, posy, posz;
   unsigned int iposx, iposy, iposz;
} POSREC;
 
 
int help() {
    printf ("*********************************************************************************:\n");
    printf ("Usage: Read of the DRS4 PSI board and dump of the waveforms in the file:\n\n");
    printf ("Arguments: \n");
    printf ("-v verbosity \n");
    printf ("-a output rootfile \n");
    printf ("-o output filename \n");
    printf ("-r range \n");
    printf ("-n number of events\n");
    printf ("-m channel bit mask\n");
    printf ("-h trigger type (0 software, 1 fast hardware, 2 slow hardware)\n");
    printf ("-d trigger delay in ns\n");
    printf ("-f sampling frequency\n");
    printf ("-t trigger channel\n");
        printf ("-l trigger level\n");
        printf ("-p trigger polarity (0 positive\n");
    printf ("*********************************************************************************:\n");
    printf ("Examples:\n\n");
   
    return 0;
}
 
 
 
char filename[0xFF]="";
char rootfile[0xFF]="";
int  neve          =  0;
int  verbose       =  0;
 
void Init(int argc, char **argv){
   DRSParameters = drssettings::instance();
   char c;
   
   extern char *optarg;
   extern int optind;
   extern int optopt;
   while ((c = getopt (argc, argv, "a:o:v:m:n:f:d:r:h:t:p:l:")) != -1){
 
        switch (c)
        {
 
        case 'a':
            sprintf(rootfile,"%s", optarg );
            break;       // root output
 
        case 'o':
            sprintf(filename,"%s", optarg );
            break;       // output
 
        case 'v':
             verbose = atoi(optarg);
            break;                       // verbosity
        case 'm':{
            unsigned long ul = strtoul (optarg,NULL,0);
            DRSSetMask( (unsigned char)( ul & 0xF ) ) ;
            break;
        }                               // channel mask
        case 'n':
            neve =  atoi (optarg);
            break;                          // number of events or number of scan points
 
        case 'f':
            DRSSetFrequency( atoi (optarg) );
            break;                          // sampling frequency
 
        case 'd':
            DRSSetTriggerDelay(  atof (optarg) );
            break;                          // trigger delay
        case 'p':
            DRSSetTriggerPolarity( atoi (optarg));
            break;                          // trigger polarity
        case 'l':
            DRSSetTriggerLevel(atoi (optarg));
            break;                          // trigger level
 
 
        case 'r':
            DRSSetRange (  atof (optarg) );
            break;                          // range 
        case 'h':
            DRSSetTriggerType( atoi (optarg) );
            break;         // send sotware trigger before reading out the dat
        case 't':
            DRSSetTriggerChannel( atoi(optarg) );
            break;         // trigger channel
 
 
        case '?':
            if (optopt == 'c')
                fprintf (stderr, "Option -%c requires an argument.\n", optopt);
            else if (isprint (optopt))
                fprintf (stderr, "Unknown option `-%c'.\n", optopt);
            else
                fprintf (stderr,
                         "Unknown option character `\\x%x'.\n",
                         optopt);
            abort ();
        default:
            abort ();
        }
    }
    //for (int i=optind; i<argc; i++) data = strtoul (argv[i],NULL,0);
 
}
 
int ctrl_c=0;
DLLEXPORT void DRSSigInt ( int )
{
    ctrl_c = 1;
    printf("->>> CTRL+c !!!\n");
}
 
//#ifdef __CINT__
int main(int argc, char **argv){
//#else
//int drsread(int argc, char **argv){   
//#endif
 
 if (signal (SIGINT, DRSSigInt) == SIG_ERR) {
   perror ("sigignore");
 }
 
 
Init(argc, argv);
if (argc==1) { help(); return 0; }
 
FILE *fp=NULL;
if (strlen(filename)>0) {
  if (verbose) printf("Data in the file:%s\n", filename);
  fp=fopen(filename,"wb");
}
 
TFile *rfile= NULL;
if (strlen(rootfile)>0) {
  if (verbose) printf("Data in the file:%s\n", rootfile);  
  rfile = new TFile(rootfile,"RECREATE");
}
 
 
TCanvas *c = new TCanvas(); c->Divide(2,2);
c->Draw();
for (int i=0;i<4;i++){
   if (! (DRSParameters->mask & ( 0x1<<i ))  ) continue;       
   char name[0xff];
   sprintf(name,"h%d",i);
   h[i]=new TH2F(name,name,1024,0,204,1024,-0.6+DRSParameters->range,0.6+DRSParameters->range);
   c->cd(i+1); h[i]->Draw("colz");
   
}
 
 
 
//---------------------------------------
static unsigned char *buffer;
static int buffer_size = 0;
const int nBoards=1;
const int waveDepth=1024;
if (buffer_size == 0) {
         buffer_size =  4 +  nBoards * (4 + 4*(4+waveDepth*4));
         buffer_size += 24 + nBoards * (8 + 4*(4+waveDepth*2));
         buffer = (unsigned char *)malloc(buffer_size);
}
   
time_t t,told, tstart;
if (!DRSInit()){
  time(&tstart);
  told=tstart;
  int i=0;
  for (i=0; i<neve; i++) {
    int nb =  (DRSRead(1) == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
       
        if (DRSTimeout) i--;
    if (ctrl_c) break;
    time(&t);
    if (t!=told ) {
                printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
                c->Modified(); c->Update();
        }      
    told=t;
// Save data    
        if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
// Plot Data
        for (int k=0;k<4;k++){
        if (! (DRSParameters->mask & ( 0x1<<k ))  ) continue;
        float *t=DRSGetTime(k);
        float *x=DRSGetWave(k);        
            for (int i=0 ; i<1024 ; i++) {
           if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[i], x[i] );
           h[k]->Fill( t[i], x[i]*1e-3);
        }
        }
  }
  time(&t);
  printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
 
  DRSEnd();
}
//---------------------------------------
if (rfile !=NULL) rfile->Write();
if (fp) fclose(fp);
if (c) c->SaveAs("drsread.pdf");
// TApplication* theApp = new TApplication("App", NULL, NULL);
// theApp->Run();
 
 
   
}
 
#endif
 

Rev 207	Rev 265
1	/********************************************************************\	1	/********************************************************************\
2		2
3	Name: drsread.cpp	3	Name: drsread.cpp
4	Created by: Rok Pestotnik	4	Created by: Rok Pestotnik
5		5
6	Contents: Simple example application to read out a DRS4	6	Contents: Simple example application to read out a DRS4
7	evaluation board and save into the data file	7	evaluation board and save into the data file
8	Interface dll for LabWindows CVI	8	Interface dll for LabWindows CVI
9		9
10	\********************************************************************/	10	\********************************************************************/
11	#ifdef DLLMAIN	11	#ifdef DLLMAIN
12	#define DLLEXPORT __declspec(dllexport)	12	#define DLLEXPORT __declspec(dllexport)
13	#else	13	#else
14	#define DLLEXPORT	14	#define DLLEXPORT
15	#endif	15	#endif
16		16
17		17
18	#include <stdio.h>	18	#include <stdio.h>
19	#include <string.h>	19	#include <string.h>
20	#include <stdlib.h>	20	#include <stdlib.h>
21		21
22	#include <math.h>	22	#include <math.h>
23	#include <time.h>	23	#include <time.h>
24	#include <signal.h>	24	#include <signal.h>
25		25
26	#include <TFile.h>	26	#include <TFile.h>
27	#include <TH2F.h>	27	#include <TH2F.h>
28	#include <TCanvas.h>	28	#include <TCanvas.h>
29	//#include <TApplication.h>	29	//#include <TApplication.h>
30		30
31	#ifdef _MSC_VER	31	#ifdef _MSC_VER
32		32
33	#include "gettimeofday.h"	33	#include "gettimeofday.h"
34	#include "timer.h"	34	#include "timer.h"
35		35
36	#define DIR_SEPARATOR '\\'	36	#define DIR_SEPARATOR '\\'
37		37
38	#elif defined(OS_LINUX) \|\| defined(OS_DARWIN)	38	#elif defined(OS_LINUX) \|\| defined(OS_DARWIN)
39		39
40	#define O_BINARY 0	40	#define O_BINARY 0
41	#include <unistd.h>	41	#include <unistd.h>
42	#include <ctype.h>	42	#include <ctype.h>
43	#include <sys/ioctl.h>	43	#include <sys/ioctl.h>
44	#include <errno.h>	44	#include <errno.h>
45	#define DIR_SEPARATOR '/'	45	#define DIR_SEPARATOR '/'
46	#endif	46	#endif
47		47
48	#include "DRS.h"	48	#include "DRS.h"
49	#include "drsread.h"	49	#include "drsread.h"
50		50
51		51
52	/------------------------------------------------------------------/	52	/------------------------------------------------------------------/
53	class drssettings {	53	class drssettings {
54	static drssettings *s_instance;	54	static drssettings *s_instance;
55	public:	55	public:
56	drssettings(){	56	drssettings(){
57	mask = 0xF;	57	mask = 0xF;
58	range = 0;	58	range = 0;
59	trigger_type = 1;	59	trigger_type = 1;
60	sampling_frequency = 5;	60	sampling_frequency = 5;
61	trigger_delay = 0;	61	trigger_delay = 0;
62	trigger_channel=0;	62	trigger_channel=0;
63	trigger_polarity=false;	63	trigger_polarity=false;
64	trigger_level=0.05;	64	trigger_level=0.05;
65		65
66	};	66	};
67	~drssettings(){};	67	~drssettings(){};
68	static drssettings *instance()	68	static drssettings *instance()
69	{	69	{
70	if (!s_instance)	70	if (!s_instance)
71	s_instance = new drssettings;	71	s_instance = new drssettings;
72	return s_instance;	72	return s_instance;
73	};	73	};
74		74
75		75
76	unsigned char mask;	76	unsigned char mask;
77	double range;	77	double range;
78	int trigger_type; // 0 software, 1 fast hardware, 2 slow hardware	78	int trigger_type; // 0 software, 1 fast hardware, 2 slow hardware
79	int trigger_channel;	79	int trigger_channel;
80	int sampling_frequency;	80	int sampling_frequency;
81	double trigger_delay;	81	double trigger_delay;
82	double trigger_level;	82	double trigger_level;
83	bool trigger_polarity;	83	bool trigger_polarity;
84	};	84	};
85	drssettings *drssettings::s_instance = 0;	85	drssettings *drssettings::s_instance = 0;
86	drssettings *DRSParameters;	86	drssettings *DRSParameters;
87	DLLEXPORT void DRSSetMask(int mask){ drssettings::instance()->mask;};	87	DLLEXPORT void DRSSetMask(int mask){ drssettings::instance()->mask;};
88	DLLEXPORT void DRSSetTriggerType(int type){ drssettings::instance()->trigger_type = type;};	88	DLLEXPORT void DRSSetTriggerType(int type){ drssettings::instance()->trigger_type = type;};
89	DLLEXPORT void DRSSetFrequency(int freq){ drssettings::instance()->sampling_frequency = freq;};	89	DLLEXPORT void DRSSetFrequency(int freq){ drssettings::instance()->sampling_frequency = freq;};
90	DLLEXPORT void DRSSetRange(double range){ drssettings::instance()->range = range;};	90	DLLEXPORT void DRSSetRange(double range){ drssettings::instance()->range = range;};
91	DLLEXPORT void DRSSetTriggerChannel(int channel){ drssettings::instance()->trigger_channel = channel;};	91	DLLEXPORT void DRSSetTriggerChannel(int channel){ drssettings::instance()->trigger_channel = channel;};
92	DLLEXPORT void DRSSetTriggerDelay(double delay){ drssettings::instance()->trigger_delay = delay;};	92	DLLEXPORT void DRSSetTriggerDelay(double delay){ drssettings::instance()->trigger_delay = delay;};
93	DLLEXPORT void DRSSetTriggerLevel(double level){ drssettings::instance()->trigger_level = level;};	93	DLLEXPORT void DRSSetTriggerLevel(double level){ drssettings::instance()->trigger_level = level;};
94	DLLEXPORT void DRSSetTriggerPolarity(int polarity){ drssettings::instance()->trigger_polarity = (polarity==1);};	94	DLLEXPORT void DRSSetTriggerPolarity(int polarity){ drssettings::instance()->trigger_polarity = (polarity==1);};
95		95
96		96
97	static int DRSTimeout;	97	static int DRSTimeout;
98		98
99	DLLEXPORT int DRSIsTimeout()	99	DLLEXPORT int DRSIsTimeout()
100	{	100	{
101	return DRSTimeout;	101	return DRSTimeout;
102	}	102	}
103		103
104	DLLEXPORT void DRSSetTimeout ( void )	104	DLLEXPORT void DRSSetTimeout ( void )
105	{	105	{
106	DRSTimeout=1;	106	DRSTimeout=1;
107	printf("->>> Timer Out !!!\n");	107	printf("->>> Timer Out !!!\n");
108	}	108	}
109		109
110	static DRS *drs=NULL;	110	static DRS *drs=NULL;
-		111
-		112
-		113	DLLEXPORT int DRSCalibrateTiming( )
-		114	{
-		115	DRSBoard *b;
-		116	if (drs == NULL) drs = new DRS();
-		117	if (!drs) return -1;
-		118	DRSParameters = drssettings::instance();
-		119
-		120	//fCalMode = 2;
-		121	if (drs->GetNumberOfBoards() ) {
-		122	/* continue working with first board only */
-		123	b = drs->GetBoard(0);
-		124
-		125	if (b->GetFirmwareVersion() < 13279)
-		126	printf("Firmware revision 13279 or later\nrequired for timing calibration\n");
-		127	else if (b->GetInputRange() != 0)
-		128	printf("Timing calibration can only be done\nat the -0.5V to +0.5V input range\n");
-		129
-		130	else {
-		131
-		132
-		133	/* remember current settings */
-		134	double acalVolt = b->GetAcalVolt();
-		135	int acalMode = b->GetAcalMode();
-		136	int tcalFreq = b->GetTcalFreq();
-		137	int tcalLevel = b->GetTcalLevel();
-		138	int tcalSource = b->GetTcalSource();
-		139	int flag1 = b->GetTriggerEnable(0);
-		140	int flag2 = b->GetTriggerEnable(1);
-		141	int trgSource = b->GetTriggerSource();
-		142	int trgDelay = b->GetTriggerDelay();
-		143	double range = b->GetInputRange();
-		144	int config = b->GetReadoutChannelConfig();
-		145
-		146
-		147	int status = b->CalibrateTiming(NULL);
-		148
-		149	if (!status)
-		150	printf("Error performing timing calibration, please check waveforms and redo voltage calibration.\n");
-		151	else
-		152	printf("Timing calibration successfully finished.\n");
-		153
-		154
-		155	/* restore old values */
-		156	b->EnableAcal(acalMode, acalVolt);
-		157	b->EnableTcal(tcalFreq, tcalLevel);
-		158	b->SelectClockSource(tcalSource);
-		159	b->EnableTrigger(flag1, flag2);
-		160	b->SetTriggerSource(trgSource);
-		161	b->SetTriggerDelayPercent(trgDelay);
-		162	b->SetInputRange(range);
-		163	b->SetChannelConfig(config, 8, 8);
-		164
-		165	if (b->GetBoardType() == 5)
-		166	b->SetTranspMode(1); // Evaluation board with build-in trigger
-		167	else
-		168	b->SetTranspMode(1); // VPC Mezzanine board
-		169
-		170	return status;
-		171	}
-		172
-		173	}
-		174	return -1;
-		175	}
-		176
111		177
112	DLLEXPORT int DRSInit()	178	DLLEXPORT int DRSInit()
113	{	179	{
114		180
115	DRSBoard *b;	181	DRSBoard *b;
116	/* do drsinitial scan */	182	/* do drsinitial scan */
117	drs = new DRS();	183	if (drs == NULL) drs = new DRS();
118	if (!drs) return -1;	184	if (!drs) return -1;
119	DRSParameters = drssettings::instance();	185	DRSParameters = drssettings::instance();
120		186
121	/* show any found board(s) */	187	/* show any found board(s) */
122	for (int i=0 ; i<drs->GetNumberOfBoards() ; i++) {	188	for (int i=0 ; i<drs->GetNumberOfBoards() ; i++) {
123	b = drs->GetBoard(i);	189	b = drs->GetBoard(i);
124	printf("Found DRS4 evaluation board, serial #%d, firmware revision %d\n",	190	printf("Found DRS4 evaluation board, serial #%d, firmware revision %d\n",
125	b->GetBoardSerialNumber(), b->GetFirmwareVersion());	191	b->GetBoardSerialNumber(), b->GetFirmwareVersion());
126	}	192	}
127		193
128	/* exit if no board found */	194	/* exit if no board found */
129	int nBoards = drs->GetNumberOfBoards();	195	int nBoards = drs->GetNumberOfBoards();
130	if (nBoards == 0) {	196	if (nBoards == 0) {
131	printf("No DRS4 evaluation board found\n");	197	printf("No DRS4 evaluation board found\n");
132	return -2;	198	return -2;
133	}	199	}
134		200
135	/* continue working with first board only */	201	/* continue working with first board only */
136	b = drs->GetBoard(0);	202	b = drs->GetBoard(0);
137		203
138	/* drsinitialize board */	204	/* drsinitialize board */
139	b->Init();	205	b->Init();
140		206
141	/* set sampling frequency default 5 */	207	/* set sampling frequency default 5 */
142	b->SetFrequency(DRSParameters->sampling_frequency, true);	208	b->SetFrequency(DRSParameters->sampling_frequency, true);
143		209
144	/* enable transparent mode needed for analog trigger */	210	/* enable transparent mode needed for analog trigger */
145	b->SetTranspMode(1);	211	b->SetTranspMode(1);
146		212
147	/* set input range to -0.5V ... +0.5V -> range=0 */	213	/* set input range to -0.5V ... +0.5V -> range=0 */
148	b->SetInputRange(DRSParameters->range);	214	b->SetInputRange(DRSParameters->range);
149		215
150	/* use following line to set range to 0..1V */	216	/* use following line to set range to 0..1V */
151	//b->SetInputRange(0.5);	217	//b->SetInputRange(0.5);
152		218
153	/* use following line to turn on the internal 100 MHz clock connected to all channels */	219	/* use following line to turn on the internal 100 MHz clock connected to all channels */
154	//b->EnableTcal(1);	220	//b->EnableTcal(1);
155		221
156	/* kaj je to ....	222	/* kaj je to ....
157	// Set domino mode	223	// Set domino mode
158	// mode == 0: single sweep	224	// mode == 0: single sweep
159	// mode == 1: run continously -- default	225	// mode == 1: run continously -- default
160	b->SetDominoMode(1);	226	b->SetDominoMode(1);
161	// Set domino activity	227	// Set domino activity
162	// mode == 0: stop during readout	228	// mode == 0: stop during readout
163	// mode == 1: keep domino wave running -- default	229	// mode == 1: keep domino wave running -- default
164	//	230	//
165	b->SetDominoActive(1);	231	b->SetDominoActive(1);
166		232
167	// Set readout mode	233	// Set readout mode
168	// mode == 0: start from first bin -- default	234	// mode == 0: start from first bin -- default
169	// mode == 1: start from domino stop	235	// mode == 1: start from domino stop
170	//	236	//
171	b->SetReadoutMode(1);	237	b->SetReadoutMode(1);
172	*/	238	*/
173		239
174	/* use following lines to enable hardware trigger on CH1 at 50 mV positive edge */	240	/* use following lines to enable hardware trigger on CH1 at 50 mV positive edge */
175	printf("Board Type:%d\n",b->GetBoardType() );	241	printf("Board Type:%d\n",b->GetBoardType() );
176	if (b->GetBoardType() >= 8) { // Evaluaiton Board V4&5	242	if (b->GetBoardType() >= 8) { // Evaluaiton Board V4&5
177		243
178	b->EnableTrigger(DRSParameters->trigger_type, 0); // enable hardware trigger - 1 fast trigger, 2 slow trigger, 0 disable hw trigger	244	b->EnableTrigger(DRSParameters->trigger_type, 0); // enable hardware trigger - 1 fast trigger, 2 slow trigger, 0 disable hw trigger
179	b->SetTriggerSource(1<<DRSParameters->trigger_channel); // set CH1 as source // simple or of single channel	245	b->SetTriggerSource(1<<DRSParameters->trigger_channel); // set CH1 as source // simple or of single channel
180	} else if (b->GetBoardType() == 7) { // Evaluation Board V3	246	} else if (b->GetBoardType() == 7) { // Evaluation Board V3
181	b->EnableTrigger(0, 1); // lemo off, analog trigger on	247	b->EnableTrigger(0, 1); // lemo off, analog trigger on
182	b->SetTriggerSource(0); // use CH1 as source	248	b->SetTriggerSource(0); // use CH1 as source
183	}	249	}
184	b->SetTriggerLevel(DRSParameters->trigger_level); // 0.05 V	250	b->SetTriggerLevel(DRSParameters->trigger_level); // 0.05 V
185	b->SetTriggerPolarity(DRSParameters->trigger_polarity); // positive edge	251	b->SetTriggerPolarity(DRSParameters->trigger_polarity); // positive edge
186		252
187	/* use following lines to set individual trigger elvels */	253	/* use following lines to set individual trigger elvels */
188	//b->SetIndividualTriggerLevel(1, 0.1);	254	//b->SetIndividualTriggerLevel(1, 0.1);
189	//b->SetIndividualTriggerLevel(2, 0.2);	255	//b->SetIndividualTriggerLevel(2, 0.2);
190	//b->SetIndividualTriggerLevel(3, 0.3);	256	//b->SetIndividualTriggerLevel(3, 0.3);
191	//b->SetIndividualTriggerLevel(4, 0.4);	257	//b->SetIndividualTriggerLevel(4, 0.4);
192	//b->SetTriggerSource(15);	258	//b->SetTriggerSource(15);
193		259
194	b->SetTriggerDelayNs( DRSParameters->trigger_delay); // zero ns trigger delay	260	b->SetTriggerDelayNs( DRSParameters->trigger_delay); // zero ns trigger delay
195		261
196	/* use following lines to enable the external trigger */	262	/* use following lines to enable the external trigger */
197	//if (b->GetBoardType() == 8) { // Evaluaiton Board V4	263	//if (b->GetBoardType() == 8) { // Evaluaiton Board V4
198	// b->EnableTrigger(1, 0); // enable hardware trigger	264	// b->EnableTrigger(1, 0); // enable hardware trigger
199	// b->SetTriggerSource(1<<4); // set external trigger as source	265	// b->SetTriggerSource(1<<4); // set external trigger as source
200	//} else { // Evaluation Board V3	266	//} else { // Evaluation Board V3
201	// b->EnableTrigger(1, 0); // lemo on, analog trigger off	267	// b->EnableTrigger(1, 0); // lemo on, analog trigger off
202	// }	268	// }
203		269
204	return 0;	270	return 0;
205		271
206		272
207	}	273	}
208		274
209	static float DRSTimeArray[8][1024];	275	static float DRSTimeArray[8][1024];
210	static float DRSWaveArray[8][1024];	276	static float DRSWaveArray[8][1024];
211		277
212	DLLEXPORT float * DRSGetTime(int ch){ return DRSTimeArray[ch];}	278	DLLEXPORT float * DRSGetTime(int ch){ return DRSTimeArray[ch];}
213	DLLEXPORT float * DRSGetWave(int ch){ return DRSWaveArray[ch];}	279	DLLEXPORT float * DRSGetWave(int ch){ return DRSWaveArray[ch];}
214		280
215	DLLEXPORT int DRSRead( int DRStimer)	281	DLLEXPORT int DRSRead( int DRStimer)
216	{	282	{
217		283
218	DRSBoard *b = drs->GetBoard(0);	284	DRSBoard *b = drs->GetBoard(0);
219		285
220		286
221		287
222	/* wait for trigger */	288	/* wait for trigger */
223		289
224		290
225	int tout=1000; /* timeout in mili seconds */	291	int tout=1000; /* timeout in mili seconds */
226	DRSTimeout=0;	292	DRSTimeout=0;
227		293
228	if (DRStimer) start_timer(tout, &DRSSetTimeout);	294	if (DRStimer) start_timer(tout, &DRSSetTimeout);
229		295
230	/* start board (activate domino wave) */	296	/* start board (activate domino wave) */
231	b->StartDomino();	297	b->StartDomino();
232		298
233	if (!DRSParameters->trigger_type) b->SoftTrigger();	299	if (!DRSParameters->trigger_type) b->SoftTrigger();
234		300
235	while (b->IsBusy()){	301	while (b->IsBusy()){
236		302
237	if (DRSTimeout) {	303	if (DRSTimeout) {
238	printf("Waiting for Trigger.. at line %d\n", __LINE__);	304	printf("Waiting for Trigger.. at line %d\n", __LINE__);
239		305
240	if (DRStimer) stop_timer();	306	if (DRStimer) stop_timer();
241		307
242	return -1;	308	return -1;
243	}	309	}
244	};	310	};
245		311
246		312
247	if (DRStimer) stop_timer();	313	if (DRStimer) stop_timer();
248		314
249		315
250		316
251	/* read all waveforms */	317	/* read all waveforms */
252	b->TransferWaves(0, 8);	318	b->TransferWaves(0, 8);
253		319
254		320
255	for (int k=0;k<4;k++){	321	for (int k=0;k<4;k++){
256	if (! (DRSParameters->mask & ( 0x1<<k )) ) continue;	322	if (! (DRSParameters->mask & ( 0x1<<k )) ) continue;
257	/* Note: On the evaluation board input #1 is connected to channel 0 and 1 of	323	/* Note: On the evaluation board input #1 is connected to channel 0 and 1 of
258	the DRS chip, input #2 is connected to channel 2 and 3 and so on. So to	324	the DRS chip, input #2 is connected to channel 2 and 3 and so on. So to
259	get the input #2 we have to read DRS channel #2, not #1. */	325	get the input #2 we have to read DRS channel #2, not #1. */
260		326
261	/* read time (X) array of k-th channel in ns and waveform (Y) array of k-th channel in mV */	327	/* read time (X) array of k-th channel in ns and waveform (Y) array of k-th channel in mV */
262	b->GetTime(0, 2*k, b->GetTriggerCell(DRSParameters->trigger_channel), DRSTimeArray[k]);	328	b->GetTime(0, 2*k, b->GetTriggerCell(DRSParameters->trigger_channel), DRSTimeArray[k]);
263	b->GetWave(0, 2*k, DRSWaveArray[k]);	329	b->GetWave(0, 2*k, DRSWaveArray[k]);
264		330
265		331
266	}	332	}
267		333
268	return 0;	334	return 0;
269	}	335	}
270		336
271	DLLEXPORT int DRSEnd(){	337	DLLEXPORT int DRSEnd(){
272		338
273	/* delete DRS object -> close USB connection */	339	/* delete DRS object -> close USB connection */
274	if (drs) delete drs;	340	if (drs) delete drs;
275	drs = NULL;	341	drs = NULL;
276	return 0;	342	return 0;
277	}	343	}
278		344
279		345
280		346
281	DLLEXPORT int DRSToBuffer( unsigned char *p, int m_evSerial )	347	DLLEXPORT int DRSToBuffer( unsigned char *p, int m_evSerial )
282	{	348	{
283		349
284	unsigned short d;	350	unsigned short d;
285	float t;	351	float t;
286	unsigned char *p0 = p;	352	unsigned char *p0 = p;
287		353
288	int m_nBoards = drs->GetNumberOfBoards();	354	int m_nBoards = drs->GetNumberOfBoards();
289	int m_waveDepth = 1024 ;// 2048	355	int m_waveDepth = 1024 ;// 2048
290	int m_inputRange = drs->GetBoard(0)->GetInputRange();	356	int m_inputRange = drs->GetBoard(0)->GetInputRange();
291	time_t rawtime;	357	time_t rawtime;
292	time ( &rawtime );	358	time ( &rawtime );
293	struct tm m_evTimestamp;	359	struct tm m_evTimestamp;
294	m_evTimestamp = *(localtime ( &rawtime ));	360	m_evTimestamp = *(localtime ( &rawtime ));
295	struct timeval mtime;	361	struct timeval mtime;
296	gettimeofday(&mtime, NULL);	362	gettimeofday(&mtime, NULL);
297		363
298	if (m_evSerial == 0) {	364	if (m_evSerial == 0) {
299	memcpy(p, "DRS2", 4); // File identifier and version	365	memcpy(p, "DRS2", 4); // File identifier and version
300	p += 4;	366	p += 4;
301	// time calibration header	367	// time calibration header
302	memcpy(p, "TIME", 4);	368	memcpy(p, "TIME", 4);
303	p += 4;	369	p += 4;
304	for (int b=0 ; b<m_nBoards ; b++) {	370	for (int b=0 ; b<m_nBoards ; b++) {
305	// store board serial number	371	// store board serial number
306	sprintf((char *)p, "B#");	372	sprintf((char *)p, "B#");
307	p += 2;	373	p += 2;
308	(unsigned short )p = drs->GetBoard(b)->GetBoardSerialNumber();	374	(unsigned short )p = drs->GetBoard(b)->GetBoardSerialNumber();
309	p += sizeof(unsigned short);	375	p += sizeof(unsigned short);
310		376
311	for (int i=0 ; i<4 ; i++) {	377	for (int i=0 ; i<4 ; i++) {
312	if (DRSParameters->mask & (0x1<<i)) {	378	if (DRSParameters->mask & (0x1<<i)) {
313	sprintf((char *)p, "C%03d", i+1);	379	sprintf((char *)p, "C%03d", i+1);
314	p += 4;	380	p += 4;
315	float tcal[2048];	381	float tcal[2048];
316	drs->GetBoard(b)->GetTimeCalibration(0, i*2, 0, tcal, 0);	382	drs->GetBoard(b)->GetTimeCalibration(0, i*2, 0, tcal, 0);
317	for (int j=0 ; j<m_waveDepth ; j++) {	383	for (int j=0 ; j<m_waveDepth ; j++) {
318	// save binary time as 32-bit float value	384	// save binary time as 32-bit float value
319	if (m_waveDepth == 2048) {	385	if (m_waveDepth == 2048) {
320	t = (tcal[j]+tcal[j+1])/2;	386	t = (tcal[j]+tcal[j+1])/2;
321	j++;	387	j++;
322	} else	388	} else
323	t = tcal[j];	389	t = tcal[j];
324	(float )p = t;	390	(float )p = t;
325	p += sizeof(float);	391	p += sizeof(float);
326	}	392	}
327	}	393	}
328	}	394	}
329	}	395	}
330	}	396	}
331		397
332		398
333		399
334	memcpy(p, "EHDR", 4);	400	memcpy(p, "EHDR", 4);
335	p += 4;	401	p += 4;
336	(int )p = m_evSerial;	402	(int )p = m_evSerial;
337	p += sizeof(int);	403	p += sizeof(int);
338	(unsigned short )p = m_evTimestamp.tm_year;	404	(unsigned short )p = m_evTimestamp.tm_year;
339	p += sizeof(unsigned short);	405	p += sizeof(unsigned short);
340	(unsigned short )p = m_evTimestamp.tm_mon;	406	(unsigned short )p = m_evTimestamp.tm_mon;
341	p += sizeof(unsigned short);	407	p += sizeof(unsigned short);
342	(unsigned short )p = m_evTimestamp.tm_mday;	408	(unsigned short )p = m_evTimestamp.tm_mday;
343	p += sizeof(unsigned short);	409	p += sizeof(unsigned short);
344	(unsigned short )p = m_evTimestamp.tm_hour;	410	(unsigned short )p = m_evTimestamp.tm_hour;
345	p += sizeof(unsigned short);	411	p += sizeof(unsigned short);
346	(unsigned short )p = m_evTimestamp.tm_min;	412	(unsigned short )p = m_evTimestamp.tm_min;
347	p += sizeof(unsigned short);	413	p += sizeof(unsigned short);
348	(unsigned short )p = m_evTimestamp.tm_sec;	414	(unsigned short )p = m_evTimestamp.tm_sec;
349	p += sizeof(unsigned short);	415	p += sizeof(unsigned short);
350	(unsigned short )p = mtime.tv_usec/1000;	416	(unsigned short )p = mtime.tv_usec/1000;
351	p += sizeof(unsigned short);	417	p += sizeof(unsigned short);
352	(unsigned short )p = (unsigned short)(m_inputRange * 1000); // range	418	(unsigned short )p = (unsigned short)(m_inputRange * 1000); // range
353	p += sizeof(unsigned short);	419	p += sizeof(unsigned short);
354		420
355	int b=0; // only for board 0	421	int b=0; // only for board 0
356		422
357	// store board serial number	423	// store board serial number
358	sprintf((char *)p, "B#");	424	sprintf((char *)p, "B#");
359	p += 2;	425	p += 2;
360	(unsigned short )p = drs->GetBoard(b)->GetBoardSerialNumber();	426	(unsigned short )p = drs->GetBoard(b)->GetBoardSerialNumber();
361	p += sizeof(unsigned short);	427	p += sizeof(unsigned short);
362		428
363	// store trigger cell	429	// store trigger cell
364	sprintf((char *)p, "T#");	430	sprintf((char *)p, "T#");
365	p += 2;	431	p += 2;
366	(unsigned short )p = drs->GetBoard(b)->GetTriggerCell(DRSParameters->trigger_channel);	432	(unsigned short )p = drs->GetBoard(b)->GetTriggerCell(DRSParameters->trigger_channel);
367	p += sizeof(unsigned short);	433	p += sizeof(unsigned short);
368		434
369	for (int i=0 ; i<4 ; i++) {	435	for (int i=0 ; i<4 ; i++) {
370	if (DRSParameters->mask & (0x1<<i)) {	436	if (DRSParameters->mask & (0x1<<i)) {
371	sprintf((char *)p, "C%03d", i+1);	437	sprintf((char *)p, "C%03d", i+1);
372	p += 4;	438	p += 4;
373	unsigned int s = drs->GetBoard(b)->GetScaler(i);	439	unsigned int s = drs->GetBoard(b)->GetScaler(i);
374	memcpy(p, &s, sizeof(int));	440	memcpy(p, &s, sizeof(int));
375	p += sizeof(int);	441	p += sizeof(int);
376	for (int j=0 ; j<m_waveDepth ; j++) {	442	for (int j=0 ; j<m_waveDepth ; j++) {
377	// save binary date as 16-bit value:	443	// save binary date as 16-bit value:
378	// 0 = -0.5V, 65535 = +0.5V for range 0	444	// 0 = -0.5V, 65535 = +0.5V for range 0
379	// 0 = -0.05V, 65535 = +0.95V for range 0.45	445	// 0 = -0.05V, 65535 = +0.95V for range 0.45
380	if (m_waveDepth == 2048) {	446	if (m_waveDepth == 2048) {
381	// in cascaded mode, save 1024 values as averages of the 2048 values	447	// in cascaded mode, save 1024 values as averages of the 2048 values
382	d = (unsigned short)(((DRSWaveArray[i][j]+DRSWaveArray[i][j+1])/2000.0 - m_inputRange + 0.5) * 65535);	448	d = (unsigned short)(((DRSWaveArray[i][j]+DRSWaveArray[i][j+1])/2000.0 - m_inputRange + 0.5) * 65535);
383	(unsigned short )p = d;	449	(unsigned short )p = d;
384	p += sizeof(unsigned short);	450	p += sizeof(unsigned short);
385	j++;	451	j++;
386	} else {	452	} else {
387	d = (unsigned short)((DRSWaveArray[i][j]/1000.0 - m_inputRange + 0.5) * 65535);	453	d = (unsigned short)((DRSWaveArray[i][j]/1000.0 - m_inputRange + 0.5) * 65535);
388	(unsigned short )p = d;	454	(unsigned short )p = d;
389	p += sizeof(unsigned short);	455	p += sizeof(unsigned short);
390	}	456	}
391	}	457	}
392	}	458	}
393	}	459	}
394		460
395	return (p-p0); // return number of bytes	461	return (p-p0); // return number of bytes
396	}	462	}
397		463
398		464
399		465
400	#ifdef MAIN	466	#ifdef MAIN
401		467
402		468
403		469
404	#include "XGetopt.h"	470	#include "XGetopt.h"
405	#include "getopt.h"	471	#include "getopt.h"
406		472
407	TH2F *h[4];	473	TH2F *h[4];
408		474
409	typedef struct {	475	typedef struct {
410	char recid[4];	476	char recid[4];
411	unsigned int posx, posy, posz;	477	unsigned int posx, posy, posz;
412	unsigned int iposx, iposy, iposz;	478	unsigned int iposx, iposy, iposz;
413	} POSREC;	479	} POSREC;
414		480
415		481
416	int help() {	482	int help() {
417	printf ("*********************************************************************************:\n");	483	printf ("*********************************************************************************:\n");
418	printf ("Usage: Read of the DRS4 PSI board and dump of the waveforms in the file:\n\n");	484	printf ("Usage: Read of the DRS4 PSI board and dump of the waveforms in the file:\n\n");
419	printf ("Arguments: \n");	485	printf ("Arguments: \n");
420	printf ("-v verbosity \n");	486	printf ("-v verbosity \n");
421	printf ("-a output rootfile \n");	487	printf ("-a output rootfile \n");
422	printf ("-o output filename \n");	488	printf ("-o output filename \n");
423	printf ("-r range \n");	489	printf ("-r range \n");
424	printf ("-n number of events\n");	490	printf ("-n number of events\n");
425	printf ("-m channel bit mask\n");	491	printf ("-m channel bit mask\n");
426	printf ("-h trigger type (0 software, 1 fast hardware, 2 slow hardware)\n");	492	printf ("-h trigger type (0 software, 1 fast hardware, 2 slow hardware)\n");
427	printf ("-d trigger delay in ns\n");	493	printf ("-d trigger delay in ns\n");
428	printf ("-f sampling frequency\n");	494	printf ("-f sampling frequency\n");
429	printf ("-t trigger channel\n");	495	printf ("-t trigger channel\n");
430	printf ("-l trigger level\n");	496	printf ("-l trigger level\n");
431	printf ("-p trigger polarity (0 positive\n");	497	printf ("-p trigger polarity (0 positive\n");
432	printf ("*********************************************************************************:\n");	498	printf ("*********************************************************************************:\n");
433	printf ("Examples:\n\n");	499	printf ("Examples:\n\n");
434		500

Subversion Repositories f9daq

(root)/cvi/instr/DRS/drsread.cpp – Rev 207 → 265