Subversion Repositories f9daq

Rev

Rev 292 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
212 f9daq 1
#include <formatio.h>
2
#include <cvirte.h>
3
#include <userint.h>
4
#include "AitGui.h"
5
#include "XYSCAN.h"
6
 
7
#include <stdbool.h>
8
#include "AitInterface.h"
9
#include "AitMduManager_DEF.h"
10
 
11
#include "H1D.h"
12
#include "H2D.h"
13
#include "H3D.h"
14
 
15
 
16
typedef unsigned short ushort;
17
typedef unsigned int uint;
18
 
19
static int ait;
20
static int xyscan;
21
//#define MIKRO
22
 
23
#ifdef MIKRO
24
#include "MIKRO.h"
25
#endif
26
 
27
static int daq_on;
28
static int plothandle[4]= {0,0,0, 0};
29
static int tfID;
30
static int controlID;
31
static int verbose;
32
 
33
#define MAX_THREADS 10
34
 
35
static CmtThreadPoolHandle poolHandle = 0;
36
 
37
 
38
/*
39
 
40
x: 140000 280000
41
 
42
*/
43
 
44
//**************************** missing declarations in the library
45
char strbuf[0xFF];
46
 
47
int gLog=0;
48
 
49
int printf(const char *format, ...) {
50
  va_list aptr;
51
  int ret;
52
  FILE *flog;
53
 
54
  va_start(aptr, format);
55
  ret = vsprintf(strbuf, format, aptr);
56
  va_end(aptr);
57
  SetCtrlVal(ait,AIT_STDIO,strbuf);
58
 
59
  if (gLog) {
60
    flog = fopen ("stdio.log", "a");
61
    fprintf (flog, "%s", strbuf);
62
    fclose (flog);
63
  }
64
  return(ret);
65
}
66
 
67
 
68
 
69
static int timeout=0;    
70
int CVICALLBACK SetTimeoutCB (int panel, int control, int event,
71
                                                                                                                        void *callbackData, int eventData1, int eventData2) {
72
        switch (event) {
73
                case EVENT_TIMER_TICK:
74
                        timeout=1;
75
                        printf("#### Timeout\n");
76
                        break;
77
        }
78
        return 0;
79
}
80
 
81
 
82
 
83
static void start_timer (double tout) {
84
        timeout = 0;
85
  SetCtrlAttribute (ait, AIT_TIMER, ATTR_INTERVAL, tout);
86
  SetCtrlAttribute (ait, AIT_TIMER, ATTR_ENABLED, 1);
87
}
88
 
89
static void stop_timer ( void ) {
90
  SetCtrlAttribute (ait, AIT_TIMER, ATTR_ENABLED, 0);
91
  //DRSSetTimeout();
92
}
93
 
94
 
95
 
96
void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
97
                               CmtThreadFunctionID functionID, unsigned int event,
98
                               int value, void *callbackData  ) {
99
 
100
  daq_on=0;
101
  //SetDimming(0);
102
  printf("End of Thread \n");
103
  return ;
104
 
105
}
106
 
107
int AitInit() {
108
  InitializeConnection();
109
  return 0;
110
}
111
 
112
 
113
int AitValidEvent() {
114
 
115
  return 1;
116
};
117
 
118
int AitToFile(FILE *fp, int n) {
119
        const int bsize=10000 ;
120
        unsigned short a[bsize] ;
121
        unsigned short buffer[2]={0x1};
122
        buffer[1] = (unsigned short)(n*CHANNELS*2);  
123
        for (int eventNum = 0; eventNum < n; eventNum++) {
124
 
125
    for (int channel = 0; channel < CHANNELS; channel++) {
126
                        int index = channel+ CHANNELS * eventNum;
127
                        if (index<bsize)
128
        a[index] = ExtractAdcData(eventNum, channel);
129
                }
130
        }
131
        fwrite(buffer, 2*sizeof(short),1,fp);
132
        return fwrite(a, 1,buffer[1],fp);
133
};
134
 
135
int AitFillHistograms(int events) {
136
  ushort rawAdcData = 0;
137
  ushort adcData = 0;
138
  int channelReceived = 0;
139
  int channelExpected = 0;
140
  bool includeSaturated = 0; // cbIncludeSaturated.Checked;
141
  ushort max[CHANNELS];
142
  ushort min[CHANNELS];
143
  ushort average[CHANNELS];
144
  int  total[CHANNELS];
145
  for (int i = 0; i < CHANNELS; i++) {
146
    min[i] = 0xFFFF;
147
    max[i] = 0;
148
    total[i] = 0;
149
  }
150
 
151
  double threshold, xysumcut;
152
  GetCtrlVal (ait, AIT_ADCTHRESHOLD, &threshold);
153
  GetCtrlVal (ait, AIT_XYCUT, &xysumcut);
154
 
155
  for (int eventNum = 0; eventNum < events; eventNum++) {
156
 
157
    int sum = 0;
158
    double a[4]= {0,0,0,0} ;
159
    for (int channel = 0; channel < CHANNELS; channel++) {
160
 
161
      rawAdcData = ExtractAdcData(eventNum, channel);
162
      if (addChannelNum == true) {
163
        channelReceived = (rawAdcData >> 12) & 0xF;
164
        channelExpected = (channel & 0xF);
165
        if (channelReceived != channelExpected) {
166
 
167
          AddMessage("ERROR in Event %d : Expected channel %d, received %d -ANALYSIS STOPPED", eventNum, channelExpected, channelReceived);
168
 
169
          //EnableRegisterScanTimer(true);
170
          return eventNum;
171
        }
172
      }
173
      adcData = (ushort)(rawAdcData & 0x0FFF);    // remove channel number
174
      //if ((includeSaturated == true) || ((includeSaturated == false) && (adcData < (ADCMAX - 2))))
175
 
176
      if (adcData>threshold) H1D_Fill(channel, adcData,1);
177
      a[channel]=adcData;
178
      total[channel] = total[channel] + adcData;
179
      if (adcData > max[channel])
180
        max[channel] = adcData;
181
      else if (adcData < min[channel])
182
        min[channel] = adcData;
183
 
184
      sum += adcData;
185
    }
186
    if (sum>threshold) {
187
      H1D_Fill(10, sum, 1 );
188
      double x = a[0]/(a[0]+a[1]);
189
      double y = a[2]/(a[2]+a[3]);
190
      if (sum>xysumcut) H2D_Fill(0, x, y , 1 );
191
    }
192
    histogramTotalEvents++;
193
  }
194
  //tbAdcStatistics.Clear();
195
  for (int channel = 0; channel < CHANNELS; channel++) {
196
    average[channel] = (ushort)(total[channel] / events);
197
 
198
    if (verbose) AddMessage(" {channel:%d}  : {min:0x%d}  {max:0x%d}  {max-min:%d}  {average:%d}\n", channel + 1, min[channel], max[channel], max[channel] - min[channel], average[channel]);
199
    //if (channel < (CHANNELS - 1))
200
    //    tbAdcStatistics.AppendText(Environment.NewLine);
201
 
202
  }
203
  //SetTextboxToTop(tbAdcStatistics);
204
  return 1;
205
};
206
 
207
 
208
int CVICALLBACK RefreshGraphs (int panel, int control, int event,
209
                               void *callbackData, int eventData1, int eventData2) {
210
  switch (event) {
211
    case EVENT_TIMER_TICK:
212
//      if (!daq_on ) return 0;
213
    case EVENT_COMMIT: {
214
 
215
      int ch=0;
216
                        int logy=0;
217
                        int updateplots=0;
218
      GetCtrlVal(ait,AIT_CH, &ch);
219
                        GetCtrlVal(ait,AIT_LOGY, &logy);
220
                  GetCtrlVal(ait,AIT_UPDATEPLOTS, &updateplots);
221
                        if (!updateplots) return 0;
222
                        if (logy){
223
                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LOG);
224
                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LOG);
225
 
226
                        } else {
227
                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LINEAR);
228
                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LINEAR);
229
 
230
                        }
231
      H1D_Draw(ch,ait,AIT_GRAPH,&plothandle[0]);
232
      H1D_Draw(10,ait,AIT_GRAPHSUM,&plothandle[1]);
233
      H2D_Draw(0,ait,AIT_GRAPHXY,&plothandle[2]);
234
 
235
 
236
    }
237
 
238
 
239
    break;
240
 
241
  }
242
  return 0;
243
}
244
 
245
 
246
 
247
int CVICALLBACK daq(void *functionData) {
248
 
249
 
250
  int neve;
251
  char filename[0xff];
252
        char fname[0xff];  
253
        char pname[0xff];
254
 
255
 
256
 
257
  int pfreq;
258
  int enabledoutput;
259
  int neveold = 0;
260
  double rate;
261
  int *args =  (int *) functionData;
262
 
263
  GetCtrlVal(ait, AIT_FILENAME, fname );
264
        GetCtrlVal(ait, AIT_PATHNAME, pname );
265
        sprintf(filename,"%s/%s", pname, fname);
266
 
267
  GetCtrlVal(ait,AIT_NEVE, &neve);
268
  GetCtrlVal(ait,AIT_DEBUG, &verbose);
269
  GetCtrlVal(ait,AIT_PFREQ, &pfreq);
270
  GetCtrlVal(ait,AIT_ENABLEDOUTPUT, &enabledoutput);
271
 
272
 
273
        int range=0;
274
        int nch = range;
275
        GetCtrlVal(ait,AIT_MAX, &range);  
276
        if (range>512) nch = 512;
277
 
278
 
279
  for (int i=0; i<4; i++) {
280
    char name[0xFF];
281
    sprintf(name,"adc%d", i);
282
 
283
    H1D_Init(i, name,name, range, 0 , range);
284
    H1D_SetTitleX(0,"ADC");
285
    H1D_SetTitleY(0,"N");
286
  }
287
  H1D_Init(10, "adcsum","adcsum", range, 0 , 4*range);
288
  H1D_SetTitleX(0,"ADC");
289
  H1D_SetTitleY(0,"N");
290
 
291
  H2D_Init(0, "cog","Center of gravity", 256, 0 ,1, 256, 0 ,1);
292
  H2D_SetTitleX(0,"x");
293
  H2D_SetTitleY(0,"y");
294
 
295
 
296
 
297
  FILE *fp= NULL;
298
 
299
  if (enabledoutput) {
300
    if (args[0]) fp =  fopen(filename,"wb");
301
    else         fp =  fopen(filename,"ab");
302
  }
303
 
304
 
305
 
306
 
307
 
308
  time_t t=0,told=0, tstart=0;
309
 
310
  if (!AitInit()) {
311
 
312
 
313
                ReadRegisters();
314
 
315
 
316
      // Update UI
317
      int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);
318
 
319
      int  value = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |
320
                   ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);
321
      SetCtrlVal (ait, AIT_GETADCGAIN, value);
322
      double valued = GetThreshold();
323
      SetCtrlVal (ait, AIT_GETADCTHRESHOLD, valued);
324
      valued = GetIntegrationTime();
325
      SetCtrlVal (ait, AIT_GETADCINTEGRATIONTIME, valued);
326
      valued = GetHvVoltage(ADDR_HV_VMON);
327
      SetCtrlVal (ait, AIT_BIASMON, valued);
328
 
329
                        value =
330
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |
331
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |
332
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |
333
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);
334
      SetCtrlVal (ait, AIT_GETADCSUMGAIN, value);
335
 
336
 
337
 
338
    RefreshGraphs (ait, 0 , EVENT_COMMIT ,NULL, 0, 0 );
339
 
340
    daq_on=1;
341
                //RefreshGraphs (ait, 0 , EVENT_TIMER_TICK ,NULL, 0, 0 );    
342
    time(&tstart);
343
    told=tstart;
344
    int i=0;
345
    for (i=0; i<neve; i++) {
346
      start_timer(1);// 1 s timeout
347
      // Set ADC reset
348
      ResetAdc(true);
349
      // Clear ADC reset
350
      ResetAdc(false);
351
      int eventsAcquired = Acquire(pfreq);
352
                        stop_timer();
353
                        if (!daq_on) break;
354
                        if (timeout) {
355
                           i--;
356
                                 printf("INFO Timeout\n");
357
                                 continue;
358
                        }
359
      int isvalid =1;
360
      if (eventsAcquired < 1) {
361
        printf("Acquired events %d\n", eventsAcquired);
362
        isvalid = 0;
363
      } else {
364
        AitFillHistograms(eventsAcquired);
365
        if (verbose) ShowEvent(1);
366
      }
367
 
368
      int nb =  ( isvalid && fp ) ? AitToFile( fp , pfreq ) : 0;
369
      SetCtrlVal(ait,AIT_CEVE,i);
370
      if (!isvalid) i--;
371
 
372
      time(&t);
373
      if (t!=told ) {
374
        rate =  (i-neveold);
375
        printf("%d events in %2.2f min (%d s) Rate %f Hz %s   ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));
376
        neveold = i;
377
                                RefreshGraphs (ait, 0 , EVENT_COMMIT ,NULL, 0, 0 );  
378
        double daqBlocksize = GetAdcEventSize() * pfreq * 2.0;
379
        double daqTimeMs = BlockTransferTime();
380
        double daqTransferRate = daqBlocksize / daqTimeMs;
381
        SetCtrlVal(ait,AIT_DAQBLOCKSIZE, daqBlocksize);
382
        SetCtrlVal(ait,AIT_DAQTIMEMS,daqTimeMs);
383
        SetCtrlVal(ait,AIT_DAQTRANSFERRATE,daqTransferRate);
384
      }
385
      told=t;
386
 
387
 
388
 
389
    }
390
    time(&t);
391
    printf("%d events in %2.2f min (%d s) %s",i+1, (double)(t-tstart)/60.,t-tstart, ctime(&t));
392
 
393
  }
394
 
395
  if (fp) fclose(fp);
396
 
397
 
398
        RefreshGraphs (ait, 0 , EVENT_TIMER_TICK ,NULL, 0, 0 );
399
  return 0;
400
 
401
}
402
 
403
 
404
int CVICALLBACK scan(void *functionData) {
405
 
406
        int dx[3]={0,0,0};
407
        int nx[3]={0,0,0};
408
        int x0[3]={0,0,0};
409
        int ix[3]={0,0,0};
410
        int idx[3]={0,0,0};  
411
        unsigned short size;
412
        unsigned short posrec={0x2};   
413
        unsigned short runbuf={0x3};
414
 
415
        int  n[3];
416
        char filename[0xFF];
417
        char fname[0xff];  
418
        char pname[0xff];
419
        int enabledoutput;
420
 
421
        FILE *fp;
422
        GetCtrlVal(ait, AIT_FILENAME, fname );
423
        GetCtrlVal(ait, AIT_PATHNAME, pname );
424
        sprintf(filename,"%s/%s", pname, fname);
425
 
426
        GetCtrlVal(ait,AIT_ENABLEDOUTPUT, &enabledoutput);
427
        int fsize;
428
        if ( GetFileInfo(filename,&fsize) ) {
429
                 MessagePopup ("Warning", "File exist. Remove it first or choose another file");
430
           return 0;
431
        }        
432
        GetCtrlVal(xyscan, SCAN_STEPX, &dx[0]);
433
        GetCtrlVal(xyscan, SCAN_STEPY, &dx[1]);
434
        GetCtrlVal(xyscan, SCAN_NSTEPSX, &nx[0]);
435
        GetCtrlVal(xyscan, SCAN_NSTEPSY, &nx[1]);
436
        GetCtrlVal(xyscan, SCAN_STARTX, &x0[0]);
437
        GetCtrlVal(xyscan, SCAN_STARTY, &x0[1]);
438
 
439
 
440
        if (enabledoutput) {
441
                                fp =  fopen(filename,"ab");
442
                                if (fp) {
443
                                         size=36;
444
                                         fwrite(&runbuf, sizeof(unsigned short),1 ,fp);
445
                                         fwrite(&size  , sizeof(unsigned short),1 ,fp);
446
                                         fwrite(x0    , 1,4*3 ,fp);
447
                                         fwrite(dx    , 1,4*3 ,fp);
448
                                         fwrite(nx    , 1,4*3 ,fp);
449
                                         fclose(fp);
450
                                }    
451
        }      
452
 
453
  for (int j=0; j<nx[1]; j++) {
454
 
455
         SetCtrlVal (xyscan, SCAN_IY, j);
456
         ix[1]= x0[1]+j*dx[1];
457
#ifdef MIKRO
458
                MIKRO_MoveTo(2,ix[1]);
459
                MIKRO_GetPosition(2,&n[1]);
460
                        SetCtrlVal (xyscan, SCAN_YP, n[1]);
461
#endif          
462
 
463
         for (int i=0; i<nx[0]; i++) {
464
                SetCtrlVal (xyscan, SCAN_IX, i);  
465
                ix[0]= x0[0]+i*dx[0];
466
#ifdef MIKRO
467
                  MIKRO_MoveTo(1,ix[0]);
468
                        MIKRO_GetPosition(1,&n[0]);
469
                        SetCtrlVal (xyscan, SCAN_XP, n[0]);
470
 
471
 
472
                        if (enabledoutput) {
473
                                fp =  fopen(filename,"ab");
474
                                if (fp) {
475
                                         time_t mtime;
476
                                         idx[0]=i;
477
                                         idx[1]=j;
478
                                         size=24+sizeof(mtime);
479
                                         fwrite(&posrec, sizeof(unsigned short),1 ,fp);
480
                                         fwrite(&size  , sizeof(unsigned short),1 ,fp);
481
                                         fwrite(n     , 1,4*3 ,fp);
482
                                         fwrite(idx    , 1,4*3 ,fp);
483
                                         time(&mtime);  
484
                                         fwrite(&mtime  , sizeof(time_t),1 ,fp);
485
                                         fclose(fp);
486
                                }    
487
                        }      
488
 
489
#endif
490
                        int newfile=0;
491
                        daq(&newfile);
492
                        if (!daq_on) break;
493
                }
494
                if (!daq_on) break;
495
        }
496
 
497
        return 0;
498
}
499
 
500
 
501
int main (int argc, char *argv[]) {
502
        short port;
503
  if (InitCVIRTE (0, argv, 0) == 0)
504
    return -1;  /* out of memory */
505
  if ((ait = LoadPanel (0, "AitGui.uir", AIT)) < 0)
506
    return -1;
507
  if ((xyscan = LoadPanel (0, "XYSCAN.uir", SCAN)) < 0)
508
    return -1;
509
  SetStdioPort (CVI_STDIO_WINDOW);
510
  SetSleepPolicy(VAL_SLEEP_MORE);
511
  CmtNewThreadPool (MAX_THREADS,  &poolHandle);
512
  DisplayPanel (ait);
513
  DisplayPanel (xyscan);
514
  AitInit();
515
 
516
 
517
#ifdef MIKRO
518
        GetCtrlVal(xyscan, SCAN_PORT, &port);
519
        if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;
520
        MIKRO_Init(1,0);
521
        MIKRO_Init(2,0);
522
#endif
523
 
524
 
525
  RunUserInterface ();
526
 
527
#ifdef MIKRO    
528
        MIKRO_Close ();
529
#endif          
530
  DiscardPanel (ait);
531
  DiscardPanel (xyscan);
532
  return 0;
533
}
534
 
535
int CVICALLBACK StopCB (int panel, int control, int event,
536
                        void *callbackData, int eventData1, int eventData2) {
537
  switch (event) {
538
    case EVENT_COMMIT:
539
      daq_on=0;
540
      break;
541
  }
542
  return 0;
543
}
544
 
545
 
546
int CVICALLBACK StartCB (int panel, int control, int event,
547
                         void *callbackData, int eventData1, int eventData2) {
548
  ThreadFunctionPtr mythread = NULL;
549
  switch (event) {
550
 
551
    case EVENT_COMMIT:
552
 
553
      controlID= control;
554
      if (panel == ait && control == AIT_START) {
555
        mythread = daq;
556
 
557
      }
558
                        if (panel == xyscan && control == SCAN_SCAN)   mythread = scan;  
559
      if (mythread!=NULL) {
560
        printf("New Thread panel=%d button=%d\n", panel, control);
561
 
562
        // SetDimming(1);
563
 
564
 
565
        CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,
566
                                          DEFAULT_THREAD_PRIORITY,
567
                                          EndOfThread,
568
                                          EVENT_TP_THREAD_FUNCTION_END,
569
                                          NULL, RUN_IN_SCHEDULED_THREAD,
570
                                          &tfID);
571
      }
572
      break;
573
  }
574
  return 0;
575
}
576
 
577
 
578
 
579
int CVICALLBACK ExitCB (int panel, int control, int event,
580
                        void *callbackData, int eventData1, int eventData2) {
581
  switch (event) {
582
    case EVENT_COMMIT:
583
      QuitUserInterface (0);
584
      break;
585
  }
586
  return 0;
587
}
588
 
589
int CVICALLBACK ReadCB (int panel, int control, int event,
590
                        void *callbackData, int eventData1, int eventData2) {
591
  switch (event) {
592
    case EVENT_COMMIT:
593
 
594
 
595
 
596
      ReadRegisters();
597
      break;
598
  }
599
  return 0;
600
}
601
 
602
int CVICALLBACK ChangeChannelCB (int panel, int control, int event,
603
                                 void *callbackData, int eventData1, int eventData2) {
604
  int ch=0;
605
  switch (event) {
606
    case EVENT_COMMIT:
607
 
608
      int logy=0;
609
      GetCtrlVal(ait,AIT_CH, &ch);
610
                        GetCtrlVal(ait,AIT_LOGY, &logy);
611
                        if (logy){
612
                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LOG);
613
                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LOG);
614
 
615
                        } else {
616
                                SetCtrlAttribute (ait, AIT_GRAPH, ATTR_YMAP_MODE, VAL_LINEAR);
617
                          SetCtrlAttribute (ait, AIT_GRAPHSUM, ATTR_YMAP_MODE, VAL_LINEAR);
618
 
619
                        }
620
      H1D_Draw(ch,ait,AIT_GRAPH,&plothandle[0]);
621
      break;
622
  }
623
  return 0;
624
}
625
 
626
 
627
 
628
 
629
 
630
int CVICALLBACK InitCB (int panel, int control, int event,
631
                        void *callbackData, int eventData1, int eventData2) {
632
  switch (event) {
633
    case EVENT_COMMIT:
634
      AitInit();
635
      break;
636
  }
637
  return 0;
638
}
639
 
640
int CVICALLBACK QuickCB (int panel, int control, int event,
641
                         void *callbackData, int eventData1, int eventData2) {
642
  switch (event) {
643
    case EVENT_COMMIT:
644
      switch (control) {
645
        case AIT_QUICKSETUP_1:
646
          QuickSetupContinuous();
647
                                        SetCtrlVal(ait,AIT_TRGTYPE, 0);
648
          break;
649
        case AIT_QUICKSETUP_2:
650
          QuickSetupDiscriminator();
651
                                        SetCtrlVal(ait,AIT_TRGTYPE, 2);
652
          break;
653
        case AIT_QUICKSETUP_3:
654
          QuickSetupTriggerOff();
655
                            break;
656
 
657
 
658
      }
659
                        float bias = GetHvVoltage(ADDR_HV_VMON);
660
      SetCtrlVal (panel, AIT_BIASMON, bias);
661
                        double  value = GetIntegrationTime();
662
      SetCtrlVal (panel, AIT_GETADCINTEGRATIONTIME, value);
663
                        value = GetThreshold();
664
      SetCtrlVal (panel, AIT_GETADCTHRESHOLD, value);
665
                        int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);
666
 
667
      int ivalue = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |
668
              ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);
669
      SetCtrlVal (panel, AIT_GETADCGAIN, ivalue);
670
                        ivalue =
671
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |
672
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |
673
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |
674
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);
675
      SetCtrlVal (panel, AIT_GETADCSUMGAIN, ivalue);
676
      break;
677
  }
678
  return 0;
679
}
680
 
681
 
682
 
683
int CVICALLBACK MoveStageCB (int panel, int control, int event,
684
                             void *callbackData, int eventData1, int eventData2) {
685
  int axis=0, step=1000, direction=1;
686
  switch (event) {
687
    case EVENT_COMMIT:
688
 
689
      if (panel == xyscan) {
690
        switch (control) {
691
          case SCAN_BR :
692
            axis = 1;
693
            direction = 1;
694
            GetCtrlVal(panel, SCAN_STEPX, &step);
695
            break;
696
          case SCAN_BL :
697
            axis = 1;
698
            direction = -1;
699
            GetCtrlVal(panel, SCAN_STEPX, &step);
700
            break;
701
          case SCAN_BU :
702
            axis = 2;
703
            direction = 1;
704
            GetCtrlVal(panel, SCAN_STEPY, &step);
705
            break;
706
          case SCAN_BD :
707
            axis = 2;
708
            direction = -1;
709
            GetCtrlVal(panel, SCAN_STEPY, &step);
710
            break;
711
        }
712
#ifdef MIKRO
713
        {
714
          int n=0;
715
          MIKRO_MoveFor(axis,  direction*step );
716
          MIKRO_GetPosition(axis,&n);
717
          if (axis == 1) SetCtrlVal (panel, SCAN_XP, n);
718
          if (axis == 2) SetCtrlVal (panel, SCAN_YP, n);
719
        }
720
#endif // MIKRO         
721
      }
722
 
723
      break;
724
  }
725
  return 0;
726
}
727
 
728
 
729
 
730
 
731
 
732
int CVICALLBACK GoXCB (int panel, int control, int event,
733
                       void *callbackData, int eventData1, int eventData2) {
734
  int n2;
735
  switch (event) {
736
    case EVENT_COMMIT:
737
      GetCtrlVal (panel, SCAN_XG, &n2);
738
#ifdef MIKRO
739
      MIKRO_MoveTo(1,n2);
740
      MIKRO_GetPosition(1,&n2);
741
 
742
#endif
743
      SetCtrlVal (panel, SCAN_XP, n2);
744
      break;
745
  }
746
  return 0;
747
}
748
 
749
int CVICALLBACK GoYCB (int panel, int control, int event,
750
                       void *callbackData, int eventData1, int eventData2) {
751
  int n2;
752
  switch (event) {
753
    case EVENT_COMMIT:
754
      GetCtrlVal (panel, SCAN_YG, &n2);
755
#ifdef MIKRO
756
      MIKRO_MoveTo(2,n2);
757
      MIKRO_GetPosition(2,&n2);
758
 
759
#endif
760
      SetCtrlVal (panel, SCAN_YP, n2);
761
      break;
762
  }
763
  return 0;
764
}
765
 
766
int CVICALLBACK GetCurrentPositionCB (int panel, int control, int event,
767
                                      void *callbackData, int eventData1, int eventData2) {
768
 
769
 
770
  switch (event) {
771
    case EVENT_COMMIT: {
772
#ifdef MIKRO
773
      int n[2];
774
      MIKRO_GetPosition(1,&n[0]);
775
      SetCtrlVal (panel, SCAN_XP, n[0]);
776
      MIKRO_GetPosition(2,&n[1]);
777
      SetCtrlVal (panel, SCAN_YP, n[1]);
778
#endif
779
      break;
780
    }
781
  }
782
  return 0;
783
}
784
 
785
int CVICALLBACK HomeCB (int panel, int control, int event,
786
                        void *callbackData, int eventData1, int eventData2) {
787
  switch (event) {
788
    case EVENT_COMMIT:
789
#ifdef MIKRO
790
      MIKRO_ReferenceMove(1);
791
      MIKRO_ReferenceMove(2);
792
      GetCurrentPositionCB(panel, control, event, NULL, 0, 0);
793
#endif
794
      break;
795
  }
796
  return 0;
797
}
798
 
799
int CVICALLBACK SetBiasCB (int panel, int control, int event,
800
                           void *callbackData, int eventData1, int eventData2) {
801
  double bias=0;
802
  switch (event) {
803
    case EVENT_COMMIT:
804
      GetCtrlVal (panel, AIT_BIAS, &bias);
805
      SetHvVoltage(ADDR_HV_CTRL, bias);
806
      bias = GetHvVoltage(ADDR_HV_VMON);
807
      SetCtrlVal (panel, AIT_BIASMON, bias);
808
      break;
809
  }
810
  return 0;
811
}
812
 
813
int CVICALLBACK SetHvOnCB (int panel, int control, int event,
814
                           void *callbackData, int eventData1, int eventData2) {
815
  int state=0;
816
  double bias;
817
  switch (event) {
818
    case EVENT_COMMIT:
819
      GetCtrlVal (panel, control, &state);
820
      if (state) SetHvOn(true);
821
      else SetHvOn(false);
822
      bias = GetHvVoltage(ADDR_HV_VMON);
823
      SetCtrlVal (panel, AIT_BIASMON, bias);
824
      break;
825
  }
826
  return 0;
827
}
828
 
829
int CVICALLBACK SetAdcIntegrationTimeCB (int panel, int control, int event,
830
    void *callbackData, int eventData1, int eventData2) {
831
 
832
  switch (event) {
833
    case EVENT_COMMIT: {
834
      double value;
835
      GetCtrlVal (panel, AIT_ADCINTEGRATIONTIME, &value);
836
      SetIntegrationTime(value);
837
      value = GetIntegrationTime();
838
      SetCtrlVal (panel, AIT_GETADCINTEGRATIONTIME, value);
839
    }
840
    break;
841
  }
842
  return 0;
843
}
844
 
845
int CVICALLBACK SetAdcThresholdCB (int panel, int control, int event,
846
                                   void *callbackData, int eventData1, int eventData2) {
847
  switch (event) {
848
    case EVENT_COMMIT: {
849
      double value;
850
      GetCtrlVal (panel, AIT_ADCTHRESHOLD, &value);
851
      SetThreshold(value);
852
      value = GetThreshold();
853
      SetCtrlVal (panel, AIT_GETADCTHRESHOLD, value);
854
    }
855
    break;
856
  }
857
  return 0;
858
}
859
 
860
int CVICALLBACK SetAdcGainCB (int panel, int control, int event,
861
                              void *callbackData, int eventData1, int eventData2) {
862
  switch (event) {
863
    case EVENT_COMMIT: {
864
      int value;
865
      GetCtrlVal (panel, AIT_ADCGAIN, &value);
866
      SetAdcGain(value);
867
      int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);
868
 
869
      value = ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN2) ? 1 : 0) << 1) |
870
              ((GetBit(csrDetector, BIT_CSR_DET_ADCGAIN1) ? 1 : 0) << 0);
871
      SetCtrlVal (panel, AIT_GETADCGAIN, value);
872
    }
873
    break;
874
  }
875
  return 0;
876
}
877
 
878
int CVICALLBACK SetAdcSumGainCB (int panel, int control, int event,
879
                                                                                                                                 void *callbackData, int eventData1, int eventData2) {
880
        switch (event) {
881
                case EVENT_COMMIT:{
882
      int value;
883
      GetCtrlVal (panel, AIT_ADCSUMGAIN, &value);
884
      SetSumGain(value);
885
      int csrDetector = ReadSD4Register(ADDR_CSR_DETECTOR);
886
                        value =
887
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN4) ? 1 : 0) << 3) |
888
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN3) ? 1 : 0) << 2) |
889
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN2) ? 1 : 0) << 1) |
890
                        ((GetBit(csrDetector, BIT_CSR_DET_SUMGAIN1) ? 1 : 0) << 0);
891
      SetCtrlVal (panel, AIT_GETADCSUMGAIN, value);
892
    }
893
 
894
                        break;
895
        }
896
        return 0;
897
}
898
 
899
int CVICALLBACK SetDiscriminatorTypeCB (int panel, int control, int event,
900
                                                                                                                                                                void *callbackData, int eventData1, int eventData2) {
901
        switch (event) {
902
                case EVENT_COMMIT:{
903
                                int trgtype;
904
                        GetCtrlVal(ait,AIT_TRGTYPE, &trgtype);
905
            EnableTrigger(trgtype);
906
                }              
907
                        break;
908
        }
909
        return 0;
910
}
911
 
912
int CVICALLBACK ResetCB (int panel, int control, int event,
913
                                                                                                 void *callbackData, int eventData1, int eventData2) {
914
        switch (event) {
915
                case EVENT_COMMIT:
916
                        ReconfigureDevice() ;
917
                        ReconnectDevice();
918
                        //ResetDevice() ;
919
                        break;
920
        }
921
        return 0;
922
}
923
 
924
int CVICALLBACK OpenScanCB (int panel, int control, int event,
925
                                                                                                                void *callbackData, int eventData1, int eventData2) {
926
        switch (event) {
927
                case EVENT_COMMIT:
928
                        DisplayPanel (xyscan);
929
                        break;
930
        }
931
        return 0;
932
}
933
 
934
int CVICALLBACK OpenMainCB (int panel, int control, int event,
935
                                                                                                                void *callbackData, int eventData1, int eventData2) {
936
        switch (event) {
937
                case EVENT_COMMIT:
938
                        DisplayPanel (ait);  
939
                        break;
940
        }
941
        return 0;
942
}