Subversion Repositories f9daq

Rev

Rev 207 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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
   
435
    return 0;
501
    return 0;
436
}
502
}
437
 
503
 
438
 
504
 
439
 
505
 
440
char filename[0xFF]="";
506
char filename[0xFF]="";
441
char rootfile[0xFF]="";
507
char rootfile[0xFF]="";
442
int  neve          =  0;
508
int  neve          =  0;
443
int  verbose       =  0;
509
int  verbose       =  0;
444
 
510
 
445
void Init(int argc, char **argv){
511
void Init(int argc, char **argv){
446
   DRSParameters = drssettings::instance();
512
   DRSParameters = drssettings::instance();
447
   char c;
513
   char c;
448
   
514
   
449
   extern char *optarg;
515
   extern char *optarg;
450
   extern int optind;
516
   extern int optind;
451
   extern int optopt;
517
   extern int optopt;
452
   while ((c = getopt (argc, argv, "a:o:v:m:n:f:d:r:h:t:p:l:")) != -1){
518
   while ((c = getopt (argc, argv, "a:o:v:m:n:f:d:r:h:t:p:l:")) != -1){
453
 
519
 
454
        switch (c)
520
        switch (c)
455
        {
521
        {
456
 
522
 
457
        case 'a':
523
        case 'a':
458
            sprintf(rootfile,"%s", optarg );
524
            sprintf(rootfile,"%s", optarg );
459
            break;       // root output
525
            break;       // root output
460
 
526
 
461
        case 'o':
527
        case 'o':
462
            sprintf(filename,"%s", optarg );
528
            sprintf(filename,"%s", optarg );
463
            break;       // output
529
            break;       // output
464
 
530
 
465
        case 'v':
531
        case 'v':
466
             verbose = atoi(optarg);
532
             verbose = atoi(optarg);
467
            break;                       // verbosity
533
            break;                       // verbosity
468
        case 'm':{
534
        case 'm':{
469
            unsigned long ul = strtoul (optarg,NULL,0);
535
            unsigned long ul = strtoul (optarg,NULL,0);
470
            DRSSetMask( (unsigned char)( ul & 0xF ) ) ;
536
            DRSSetMask( (unsigned char)( ul & 0xF ) ) ;
471
            break;
537
            break;
472
        }                               // channel mask
538
        }                               // channel mask
473
        case 'n':
539
        case 'n':
474
            neve =  atoi (optarg);
540
            neve =  atoi (optarg);
475
            break;                          // number of events or number of scan points
541
            break;                          // number of events or number of scan points
476
 
542
 
477
        case 'f':
543
        case 'f':
478
            DRSSetFrequency( atoi (optarg) );
544
            DRSSetFrequency( atoi (optarg) );
479
            break;                          // sampling frequency
545
            break;                          // sampling frequency
480
 
546
 
481
        case 'd':
547
        case 'd':
482
            DRSSetTriggerDelay(  atof (optarg) );
548
            DRSSetTriggerDelay(  atof (optarg) );
483
            break;                          // trigger delay
549
            break;                          // trigger delay
484
        case 'p':
550
        case 'p':
485
            DRSSetTriggerPolarity( atoi (optarg));
551
            DRSSetTriggerPolarity( atoi (optarg));
486
            break;                          // trigger polarity
552
            break;                          // trigger polarity
487
        case 'l':
553
        case 'l':
488
            DRSSetTriggerLevel(atoi (optarg));
554
            DRSSetTriggerLevel(atoi (optarg));
489
            break;                          // trigger level
555
            break;                          // trigger level
490
 
556
 
491
 
557
 
492
        case 'r':
558
        case 'r':
493
            DRSSetRange (  atof (optarg) );
559
            DRSSetRange (  atof (optarg) );
494
            break;                          // range 
560
            break;                          // range 
495
        case 'h':
561
        case 'h':
496
            DRSSetTriggerType( atoi (optarg) );
562
            DRSSetTriggerType( atoi (optarg) );
497
            break;         // send sotware trigger before reading out the dat
563
            break;         // send sotware trigger before reading out the dat
498
        case 't':
564
        case 't':
499
            DRSSetTriggerChannel( atoi(optarg) );
565
            DRSSetTriggerChannel( atoi(optarg) );
500
            break;         // trigger channel
566
            break;         // trigger channel
501
 
567
 
502
 
568
 
503
        case '?':
569
        case '?':
504
            if (optopt == 'c')
570
            if (optopt == 'c')
505
                fprintf (stderr, "Option -%c requires an argument.\n", optopt);
571
                fprintf (stderr, "Option -%c requires an argument.\n", optopt);
506
            else if (isprint (optopt))
572
            else if (isprint (optopt))
507
                fprintf (stderr, "Unknown option `-%c'.\n", optopt);
573
                fprintf (stderr, "Unknown option `-%c'.\n", optopt);
508
            else
574
            else
509
                fprintf (stderr,
575
                fprintf (stderr,
510
                         "Unknown option character `\\x%x'.\n",
576
                         "Unknown option character `\\x%x'.\n",
511
                         optopt);
577
                         optopt);
512
            abort ();
578
            abort ();
513
        default:
579
        default:
514
            abort ();
580
            abort ();
515
        }
581
        }
516
    }
582
    }
517
    //for (int i=optind; i<argc; i++) data = strtoul (argv[i],NULL,0);
583
    //for (int i=optind; i<argc; i++) data = strtoul (argv[i],NULL,0);
518
 
584
 
519
}
585
}
520
 
586
 
521
int ctrl_c=0;
587
int ctrl_c=0;
522
DLLEXPORT void DRSSigInt ( int )
588
DLLEXPORT void DRSSigInt ( int )
523
{
589
{
524
    ctrl_c = 1;
590
    ctrl_c = 1;
525
    printf("->>> CTRL+c !!!\n");
591
    printf("->>> CTRL+c !!!\n");
526
}
592
}
527
 
593
 
528
//#ifdef __CINT__
594
//#ifdef __CINT__
529
int main(int argc, char **argv){
595
int main(int argc, char **argv){
530
//#else
596
//#else
531
//int drsread(int argc, char **argv){   
597
//int drsread(int argc, char **argv){   
532
//#endif
598
//#endif
533
 
599
 
534
 if (signal (SIGINT, DRSSigInt) == SIG_ERR) {
600
 if (signal (SIGINT, DRSSigInt) == SIG_ERR) {
535
   perror ("sigignore");
601
   perror ("sigignore");
536
 }
602
 }
537
 
603
 
538
 
604
 
539
Init(argc, argv);
605
Init(argc, argv);
540
if (argc==1) { help(); return 0; }
606
if (argc==1) { help(); return 0; }
541
 
607
 
542
FILE *fp=NULL;
608
FILE *fp=NULL;
543
if (strlen(filename)>0) {
609
if (strlen(filename)>0) {
544
  if (verbose) printf("Data in the file:%s\n", filename);
610
  if (verbose) printf("Data in the file:%s\n", filename);
545
  fp=fopen(filename,"wb");
611
  fp=fopen(filename,"wb");
546
}
612
}
547
 
613
 
548
TFile *rfile= NULL;
614
TFile *rfile= NULL;
549
if (strlen(rootfile)>0) {
615
if (strlen(rootfile)>0) {
550
  if (verbose) printf("Data in the file:%s\n", rootfile);  
616
  if (verbose) printf("Data in the file:%s\n", rootfile);  
551
  rfile = new TFile(rootfile,"RECREATE");
617
  rfile = new TFile(rootfile,"RECREATE");
552
}
618
}
553
 
619
 
554
 
620
 
555
TCanvas *c = new TCanvas(); c->Divide(2,2);
621
TCanvas *c = new TCanvas(); c->Divide(2,2);
556
c->Draw();
622
c->Draw();
557
for (int i=0;i<4;i++){
623
for (int i=0;i<4;i++){
558
   if (! (DRSParameters->mask & ( 0x1<<i ))  ) continue;       
624
   if (! (DRSParameters->mask & ( 0x1<<i ))  ) continue;       
559
   char name[0xff];
625
   char name[0xff];
560
   sprintf(name,"h%d",i);
626
   sprintf(name,"h%d",i);
561
   h[i]=new TH2F(name,name,1024,0,204,1024,-0.6+DRSParameters->range,0.6+DRSParameters->range);
627
   h[i]=new TH2F(name,name,1024,0,204,1024,-0.6+DRSParameters->range,0.6+DRSParameters->range);
562
   c->cd(i+1); h[i]->Draw("colz");
628
   c->cd(i+1); h[i]->Draw("colz");
563
   
629
   
564
}
630
}
565
 
631
 
566
 
632
 
567
 
633
 
568
//---------------------------------------
634
//---------------------------------------
569
static unsigned char *buffer;
635
static unsigned char *buffer;
570
static int buffer_size = 0;
636
static int buffer_size = 0;
571
const int nBoards=1;
637
const int nBoards=1;
572
const int waveDepth=1024;
638
const int waveDepth=1024;
573
if (buffer_size == 0) {
639
if (buffer_size == 0) {
574
         buffer_size =  4 +  nBoards * (4 + 4*(4+waveDepth*4));
640
         buffer_size =  4 +  nBoards * (4 + 4*(4+waveDepth*4));
575
         buffer_size += 24 + nBoards * (8 + 4*(4+waveDepth*2));
641
         buffer_size += 24 + nBoards * (8 + 4*(4+waveDepth*2));
576
         buffer = (unsigned char *)malloc(buffer_size);
642
         buffer = (unsigned char *)malloc(buffer_size);
577
}
643
}
578
   
644
   
579
time_t t,told, tstart;
645
time_t t,told, tstart;
580
if (!DRSInit()){
646
if (!DRSInit()){
581
  time(&tstart);
647
  time(&tstart);
582
  told=tstart;
648
  told=tstart;
583
  int i=0;
649
  int i=0;
584
  for (i=0; i<neve; i++) {
650
  for (i=0; i<neve; i++) {
585
    int nb =  (DRSRead(1) == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
651
    int nb =  (DRSRead(1) == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
586
       
652
       
587
        if (DRSTimeout) i--;
653
        if (DRSTimeout) i--;
588
    if (ctrl_c) break;
654
    if (ctrl_c) break;
589
    time(&t);
655
    time(&t);
590
    if (t!=told ) {
656
    if (t!=told ) {
591
                printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
657
                printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
592
                c->Modified(); c->Update();
658
                c->Modified(); c->Update();
593
        }      
659
        }      
594
    told=t;
660
    told=t;
595
// Save data    
661
// Save data    
596
        if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
662
        if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
597
// Plot Data
663
// Plot Data
598
        for (int k=0;k<4;k++){
664
        for (int k=0;k<4;k++){
599
        if (! (DRSParameters->mask & ( 0x1<<k ))  ) continue;
665
        if (! (DRSParameters->mask & ( 0x1<<k ))  ) continue;
600
        float *t=DRSGetTime(k);
666
        float *t=DRSGetTime(k);
601
        float *x=DRSGetWave(k);        
667
        float *x=DRSGetWave(k);        
602
            for (int i=0 ; i<1024 ; i++) {
668
            for (int i=0 ; i<1024 ; i++) {
603
           if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[i], x[i] );
669
           if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[i], x[i] );
604
           h[k]->Fill( t[i], x[i]*1e-3);
670
           h[k]->Fill( t[i], x[i]*1e-3);
605
        }
671
        }
606
        }
672
        }
607
  }
673
  }
608
  time(&t);
674
  time(&t);
609
  printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
675
  printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,int(t-tstart), ctime(&t));
610
 
676
 
611
  DRSEnd();
677
  DRSEnd();
612
}
678
}
613
//---------------------------------------
679
//---------------------------------------
614
if (rfile !=NULL) rfile->Write();
680
if (rfile !=NULL) rfile->Write();
615
if (fp) fclose(fp);
681
if (fp) fclose(fp);
616
if (c) c->SaveAs("drsread.pdf");
682
if (c) c->SaveAs("drsread.pdf");
617
// TApplication* theApp = new TApplication("App", NULL, NULL);
683
// TApplication* theApp = new TApplication("App", NULL, NULL);
618
// theApp->Run();
684
// theApp->Run();
619
 
685
 
620
 
686
 
621
   
687
   
622
}
688
}
623
 
689
 
624
#endif
690
#endif
625
 
691