Rev 217 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
217 | f9daq | 1 | #include "H1D.h" |
2 | #include "H2D.h" |
||
203 | f9daq | 3 | #include <formatio.h> |
195 | f9daq | 4 | #include <utility.h> |
5 | #include <ansi_c.h> |
||
203 | f9daq | 6 | #include <cvirte.h> |
195 | f9daq | 7 | #include <userint.h> |
8 | #include "drs4.h" |
||
203 | f9daq | 9 | #include "drsread.h" |
195 | f9daq | 10 | |
203 | f9daq | 11 | #define MIKRO |
12 | |||
13 | #ifdef MIKRO |
||
14 | #include "MIKRO.h" |
||
15 | #endif |
||
16 | |||
195 | f9daq | 17 | static int daq_on; |
203 | f9daq | 18 | static int ph, p2,plothandle[4]= {0,0,0,0}; |
217 | f9daq | 19 | static int scanplothandle; |
195 | f9daq | 20 | static int tfID; |
21 | static int controlID; |
||
22 | |||
203 | f9daq | 23 | #define MAX_THREADS 10 |
195 | f9daq | 24 | |
203 | f9daq | 25 | static CmtThreadPoolHandle poolHandle = 0; |
195 | f9daq | 26 | |
217 | f9daq | 27 | static float gSum[4]={0,0,0,0}; |
195 | f9daq | 28 | int main (int argc, char *argv[]) { |
203 | f9daq | 29 | short port; |
30 | if (InitCVIRTE (0, argv, 0) == 0) |
||
31 | return -1; /* out of memory */ |
||
32 | if ((ph = LoadPanel (0, "drs4.uir", PANEL)) < 0) |
||
33 | return -1; |
||
34 | if ((p2 = LoadPanel (0, "drs4.uir", SCAN)) < 0) |
||
35 | return -1; |
||
36 | SetStdioPort (CVI_STDIO_WINDOW); |
||
37 | SetSleepPolicy(VAL_SLEEP_MORE); |
||
38 | CmtNewThreadPool (MAX_THREADS, &poolHandle); |
||
39 | |||
40 | DisplayPanel (ph); |
||
41 | DisplayPanel (p2); |
||
42 | |||
43 | #ifdef MIKRO |
||
44 | GetCtrlVal(p2, SCAN_PORT, &port); |
||
45 | if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ; |
||
46 | MIKRO_Init(1,0); |
||
47 | MIKRO_Init(2,0); |
||
48 | #endif |
||
49 | |||
50 | RunUserInterface (); |
||
51 | DiscardPanel (ph); |
||
52 | DiscardPanel (p2); |
||
53 | CmtDiscardThreadPool (poolHandle); |
||
54 | MIKRO_Close (); |
||
55 | return 0; |
||
195 | f9daq | 56 | } |
57 | |||
58 | |||
210 | f9daq | 59 | char strbuf[0xFF]; |
195 | f9daq | 60 | |
210 | f9daq | 61 | int gLog=0; |
195 | f9daq | 62 | |
210 | f9daq | 63 | int printf(const char *format, ...) { |
64 | va_list aptr; |
||
65 | int ret; |
||
66 | FILE *flog; |
||
195 | f9daq | 67 | |
210 | f9daq | 68 | va_start(aptr, format); |
69 | ret = vsprintf(strbuf, format, aptr); |
||
70 | va_end(aptr); |
||
71 | SetCtrlVal(ph,PANEL_STDIO,strbuf); |
||
72 | |||
73 | if (gLog) { |
||
74 | flog = fopen ("stdio.log", "a"); |
||
75 | fprintf (flog, "%s", strbuf); |
||
76 | fclose (flog); |
||
77 | } |
||
78 | return(ret); |
||
79 | } |
||
80 | |||
81 | |||
82 | |||
195 | f9daq | 83 | static void start_timer (double tout) { |
203 | f9daq | 84 | SetCtrlAttribute (ph, PANEL_TIMER, ATTR_INTERVAL, tout); |
85 | SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 1); |
||
195 | f9daq | 86 | } |
87 | |||
88 | static void stop_timer ( void ) { |
||
203 | f9daq | 89 | SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 0); |
90 | DRSSetTimeout(); |
||
195 | f9daq | 91 | } |
92 | |||
93 | |||
94 | |||
95 | |||
96 | void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle, |
||
203 | f9daq | 97 | CmtThreadFunctionID functionID, unsigned int event, |
98 | int value, void *callbackData ) { |
||
195 | f9daq | 99 | |
203 | f9daq | 100 | daq_on=0; |
101 | //SetDimming(0); |
||
102 | printf("End of Thread \n"); |
||
103 | return ; |
||
195 | f9daq | 104 | |
105 | } |
||
106 | |||
107 | |||
217 | f9daq | 108 | static float xs[4][1024]; |
203 | f9daq | 109 | int CVICALLBACK daq(void *functionData) { |
195 | f9daq | 110 | |
111 | |||
203 | f9daq | 112 | int neve; |
113 | char filename[0xff]; |
||
114 | int imask[4]; |
||
115 | unsigned long mask; |
||
116 | int frequency; |
||
117 | double trgdelay; |
||
118 | double trglevel; |
||
119 | int trgtype; |
||
120 | int trgchannel; |
||
121 | int trgpolarity; |
||
122 | int verbose; |
||
123 | double range; |
||
124 | int pfreq; |
||
125 | int enabledoutput; |
||
126 | int neveold = 0; |
||
127 | double rate; |
||
128 | int *args = (int *) functionData; |
||
217 | f9daq | 129 | double twin[2]; |
265 | f9daq | 130 | |
201 | f9daq | 131 | |
217 | f9daq | 132 | |
203 | f9daq | 133 | GetCtrlVal(ph, PANEL_CH0, &imask[0] ); |
134 | GetCtrlVal(ph, PANEL_CH1, &imask[1] ); |
||
135 | GetCtrlVal(ph, PANEL_CH2, &imask[2] ); |
||
136 | GetCtrlVal(ph, PANEL_CH3, &imask[3] ); |
||
137 | mask = 0; |
||
138 | for (int i=0; i<4; i++) { |
||
139 | if (imask[i]) mask |= (1<<i); |
||
201 | f9daq | 140 | } |
203 | f9daq | 141 | |
265 | f9daq | 142 | |
143 | |||
203 | f9daq | 144 | GetCtrlVal(ph,PANEL_NEVE, &neve); |
145 | GetCtrlVal(ph,PANEL_DEBUG, &verbose); |
||
146 | GetCtrlVal(ph,PANEL_PFREQ, &pfreq); |
||
147 | GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput); |
||
148 | |||
149 | GetCtrlVal(ph,PANEL_FREQUENCY, &frequency); |
||
150 | GetCtrlVal(ph,PANEL_TRGDELAY, &trgdelay); |
||
151 | GetCtrlVal(ph,PANEL_TRGCHANNEL, &trgchannel); |
||
152 | |||
265 | f9daq | 153 | |
203 | f9daq | 154 | GetCtrlVal(ph,PANEL_TRGTYPE, &trgtype); |
155 | GetCtrlVal(ph,PANEL_TRGLEVEL, &trglevel); |
||
156 | GetCtrlVal(ph,PANEL_TRGPOLARITY, &trgpolarity); |
||
157 | GetCtrlVal(ph,PANEL_RANGE, &range); |
||
158 | |||
217 | f9daq | 159 | GetCtrlVal(ph,PANEL_TWIN0, &twin[0]); |
160 | GetCtrlVal(ph,PANEL_TWIN1, &twin[1]); |
||
203 | f9daq | 161 | //printf("mask=0x%x\n",mask); |
162 | |||
163 | DRSSetMask( (unsigned char)( mask & 0xF ) ); |
||
164 | |||
165 | DRSSetFrequency( frequency ); |
||
166 | DRSSetTriggerDelay(trgdelay ); |
||
167 | DRSSetTriggerChannel(trgchannel ); |
||
168 | DRSSetTriggerType( trgtype ); |
||
169 | DRSSetTriggerLevel(trglevel); |
||
170 | DRSSetTriggerPolarity(trgpolarity); |
||
171 | |||
172 | DRSSetRange ( range ); |
||
173 | |||
174 | |||
175 | |||
176 | FILE *fp= NULL; |
||
177 | |||
178 | if (enabledoutput) { |
||
217 | f9daq | 179 | if (args[0]) { |
180 | GetCtrlVal(ph, PANEL_FILENAME, filename ); |
||
181 | fp = fopen(filename,"wb"); |
||
182 | } else { |
||
183 | GetCtrlVal(p2, SCAN_FILENAME, filename ); |
||
184 | fp = fopen(filename,"ab"); |
||
185 | } |
||
203 | f9daq | 186 | } |
187 | |||
188 | static unsigned char *buffer; |
||
189 | |||
190 | int buffer_size = 0; |
||
191 | const int nBoards=1; |
||
192 | const int waveDepth=1024; |
||
207 | f9daq | 193 | |
203 | f9daq | 194 | if (buffer_size == 0) { |
207 | f9daq | 195 | buffer_size = 8; // file header + time header |
196 | buffer_size += nBoards * (4 + 4*(4+waveDepth*4)); // bin widths |
||
197 | buffer_size += 24 + nBoards * (8 + 4*(8+waveDepth*2)); |
||
198 | buffer = (unsigned char *)malloc(buffer_size); |
||
199 | } |
||
200 | |||
203 | f9daq | 201 | time_t t=0,told=0, tstart=0; |
202 | |||
203 | if (!DRSInit()) { |
||
265 | f9daq | 204 | |
203 | f9daq | 205 | time(&tstart); |
206 | told=tstart; |
||
217 | f9daq | 207 | int nev=0; |
208 | for (int k = 0;k<4;k++){ |
||
209 | gSum[k]=0; |
||
210 | } |
||
211 | for (int i=0; i<neve; i++) { |
||
203 | f9daq | 212 | start_timer(1);// 1 s timeout |
213 | int retval = DRSRead(0); |
||
214 | stop_timer(); |
||
215 | int nb = ( retval == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0; |
||
216 | SetCtrlVal(ph,PANEL_CEVE,i); |
||
217 | if (retval) i--; |
||
217 | f9daq | 218 | nev++; |
203 | f9daq | 219 | if (!daq_on) break; |
220 | time(&t); |
||
221 | if (t!=told ) { |
||
222 | rate = (i-neveold); |
||
223 | printf("%d events in %2.2f min (%d s) Rate %f Hz %s ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t)); |
||
224 | GetCtrlVal(ph,PANEL_PFREQ, &pfreq); |
||
225 | neveold = i; |
||
226 | } |
||
227 | told=t; |
||
228 | // Save data |
||
229 | if (nb>0 && fp) fwrite(buffer, 1,nb ,fp); |
||
230 | // Plot Data |
||
217 | f9daq | 231 | for (int k=0; k<4; k++) { |
232 | if ( (mask & ( 0x1<<k )) ){ |
||
233 | float *t=DRSGetTime(k); |
||
234 | float *x=DRSGetWave(k); |
||
235 | ; |
||
236 | for (int j=0 ; j<1024 ; j++) { |
||
237 | xs[k][j]= x[j]*1e-3; |
||
238 | |||
239 | if (t[j]> twin[0] && t[j] < twin[1]) gSum[k]+= fabs(xs[k][j]); |
||
240 | if (verbose) printf("[%d] %d. x= %3.2f y=%3.2f\n", k, i, t[j], x[j] ); |
||
241 | //h[k]->Fill( t[i], x[i]*1e-3); |
||
242 | } |
||
203 | f9daq | 243 | |
217 | f9daq | 244 | if (i % pfreq == 0) { |
245 | |||
246 | const int col[4]= {VAL_WHITE,VAL_RED,VAL_GREEN,VAL_BLUE}; |
||
247 | if (plothandle[k]) DeleteGraphPlot (ph, PANEL_GRAPH, plothandle[k], VAL_IMMEDIATE_DRAW); |
||
248 | plothandle[k] = PlotXY (ph, PANEL_GRAPH, t, xs[k], 1024, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[k]); |
||
249 | } |
||
203 | f9daq | 250 | } |
217 | f9daq | 251 | |
203 | f9daq | 252 | } |
253 | |||
254 | |||
255 | } |
||
256 | time(&t); |
||
217 | f9daq | 257 | printf("%d events in %2.2f min (%d s) %s",nev, (double)(t-tstart)/60.,t-tstart, ctime(&t)); |
203 | f9daq | 258 | DRSEnd(); |
259 | } |
||
260 | |||
261 | if (fp) fclose(fp); |
||
262 | |||
263 | free(buffer); |
||
264 | |||
265 | return 0; |
||
266 | |||
195 | f9daq | 267 | } |
268 | |||
269 | |||
270 | |||
203 | f9daq | 271 | int CVICALLBACK scan(void *functionData) { |
195 | f9daq | 272 | |
207 | f9daq | 273 | int dx[3]={0,0,0}; |
274 | int nx[3]={0,0,0}; |
||
275 | int x0[3]={0,0,0}; |
||
276 | int ix[3]={0,0,0}; |
||
277 | int idx[3]={0,0,0}; |
||
203 | f9daq | 278 | int size; |
207 | f9daq | 279 | char posrec[4]="POSR"; |
280 | char runbuf[4]="PRUN"; |
||
203 | f9daq | 281 | |
207 | f9daq | 282 | int n[3]; |
203 | f9daq | 283 | char filename[0xFF]; |
284 | int enabledoutput; |
||
285 | |||
286 | FILE *fp; |
||
217 | f9daq | 287 | GetCtrlVal(p2, SCAN_FILENAME, filename ); |
203 | f9daq | 288 | |
289 | GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput); |
||
290 | |||
291 | if ( GetFileInfo(filename,&size) ) { |
||
217 | f9daq | 292 | MessagePopup ("Warning","File exist. Remove it first or choose another file"); |
293 | return 0; |
||
203 | f9daq | 294 | } |
295 | GetCtrlVal(p2, SCAN_STEPX, &dx[0]); |
||
296 | GetCtrlVal(p2, SCAN_STEPY, &dx[1]); |
||
297 | GetCtrlVal(p2, SCAN_NSTEPSX, &nx[0]); |
||
298 | GetCtrlVal(p2, SCAN_NSTEPSY, &nx[1]); |
||
299 | GetCtrlVal(p2, SCAN_STARTX, &x0[0]); |
||
300 | GetCtrlVal(p2, SCAN_STARTY, &x0[1]); |
||
217 | f9daq | 301 | for (int k=0;k<4;k++) { |
302 | H2D_Init(k, "charge","Induced charge", |
||
303 | nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) , |
||
304 | nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5)); |
||
305 | H1D_Init(k, "charge","Induced charge projection x", |
||
306 | nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) ); |
||
307 | H1D_Init(100 + k, "charge","Induced charge projection y", |
||
308 | nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5) ); |
||
309 | } |
||
207 | f9daq | 310 | if (enabledoutput) { |
311 | fp = fopen(filename,"ab"); |
||
312 | if (fp) { |
||
313 | size=36; |
||
314 | fwrite(runbuf, 1,4 ,fp); |
||
315 | fwrite(&size , 1,4 ,fp); |
||
316 | fwrite(x0 , 1,4*3 ,fp); |
||
317 | fwrite(dx , 1,4*3 ,fp); |
||
318 | fwrite(nx , 1,4*3 ,fp); |
||
319 | fclose(fp); |
||
320 | } |
||
321 | } |
||
322 | |||
203 | f9daq | 323 | for (int i=0; i<nx[0]; i++) { |
324 | |||
325 | ix[0]= x0[0]+i*dx[0]; |
||
326 | #ifdef MIKRO |
||
327 | MIKRO_MoveTo(1,ix[0]); |
||
328 | #endif |
||
329 | SetCtrlVal (p2, SCAN_IX, i); |
||
330 | for (int j=0; j<nx[1]; j++) { |
||
331 | |||
332 | SetCtrlVal (p2, SCAN_IY, j); |
||
333 | |||
334 | ix[1]= x0[1]+j*dx[1]; |
||
335 | #ifdef MIKRO |
||
336 | MIKRO_MoveTo(2,ix[1]); |
||
337 | |||
338 | MIKRO_GetPosition(1,&n[0]); |
||
339 | SetCtrlVal (p2, SCAN_XP, n[0]); |
||
340 | MIKRO_GetPosition(2,&n[1]); |
||
341 | SetCtrlVal (p2, SCAN_YP, n[1]); |
||
207 | f9daq | 342 | |
343 | if (enabledoutput) { |
||
203 | f9daq | 344 | fp = fopen(filename,"ab"); |
345 | if (fp) { |
||
207 | f9daq | 346 | idx[0]=i; |
347 | idx[1]=j; |
||
348 | size=24; |
||
349 | fwrite(posrec, 1,4 ,fp); |
||
350 | fwrite(&size , 1,4 ,fp); |
||
351 | fwrite(n , 1,4*3 ,fp); |
||
352 | fwrite(idx , 1,4*3 ,fp); |
||
203 | f9daq | 353 | fclose(fp); |
354 | } |
||
355 | } |
||
356 | |||
357 | #endif |
||
358 | daq(functionData); |
||
217 | f9daq | 359 | |
360 | for (int k=0;k<4;k++) { |
||
361 | H2D_Fill(k, ix[0], ix[1] , gSum[k] ); |
||
362 | H1D_Fill(k, ix[0] , gSum[k] ); |
||
363 | H1D_Fill(100+ k, ix[1] , gSum[k] ); |
||
364 | } |
||
365 | PlotScanHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0); |
||
203 | f9daq | 366 | if (!daq_on) break; |
367 | } |
||
368 | if (!daq_on) break; |
||
369 | } |
||
370 | |||
371 | return 0; |
||
195 | f9daq | 372 | } |
373 | |||
203 | f9daq | 374 | |
195 | f9daq | 375 | int CVICALLBACK StartCB (int panel, int control, int event, |
203 | f9daq | 376 | void *callbackData, int eventData1, int eventData2) { |
377 | ThreadFunctionPtr mythread = NULL; |
||
378 | switch (event) { |
||
379 | |||
380 | case EVENT_COMMIT: |
||
381 | |||
382 | controlID=0; |
||
383 | if (panel == ph && control == PANEL_START) { |
||
384 | mythread = daq; |
||
385 | controlID= control; |
||
386 | } |
||
387 | if (panel == p2 && control == SCAN_SCAN) mythread = scan; |
||
388 | if (mythread!=NULL) { |
||
389 | printf("New Thread panel=%d button=%d\n", panel, control); |
||
390 | |||
391 | // SetDimming(1); |
||
392 | |||
393 | daq_on=1; |
||
394 | CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID, |
||
395 | DEFAULT_THREAD_PRIORITY, |
||
396 | EndOfThread, |
||
397 | EVENT_TP_THREAD_FUNCTION_END, |
||
398 | NULL, RUN_IN_SCHEDULED_THREAD, |
||
399 | &tfID); |
||
400 | } |
||
401 | break; |
||
402 | } |
||
403 | return 0; |
||
195 | f9daq | 404 | } |
405 | |||
406 | int CVICALLBACK StopCB (int panel, int control, int event, |
||
203 | f9daq | 407 | void *callbackData, int eventData1, int eventData2) { |
408 | switch (event) { |
||
409 | case EVENT_COMMIT: |
||
410 | daq_on=0; |
||
411 | break; |
||
412 | } |
||
413 | return 0; |
||
195 | f9daq | 414 | } |
415 | |||
416 | int CVICALLBACK ExitCB (int panel, int control, int event, |
||
203 | f9daq | 417 | void *callbackData, int eventData1, int eventData2) { |
418 | switch (event) { |
||
419 | case EVENT_COMMIT: |
||
420 | QuitUserInterface (0); |
||
421 | break; |
||
422 | } |
||
423 | return 0; |
||
195 | f9daq | 424 | } |
203 | f9daq | 425 | |
426 | int CVICALLBACK MoveStageCB (int panel, int control, int event, |
||
427 | void *callbackData, int eventData1, int eventData2) { |
||
428 | int axis=0, step=1000, direction=1, n; |
||
429 | switch (event) { |
||
430 | case EVENT_COMMIT: |
||
431 | |||
432 | if (panel == p2) { |
||
433 | switch (control) { |
||
434 | case SCAN_BR : |
||
435 | axis = 1; |
||
436 | direction = 1; |
||
437 | GetCtrlVal(p2, SCAN_STEPX, &step); |
||
438 | break; |
||
439 | case SCAN_BL : |
||
440 | axis = 1; |
||
441 | direction = -1; |
||
442 | GetCtrlVal(p2, SCAN_STEPX, &step); |
||
443 | break; |
||
444 | case SCAN_BU : |
||
445 | axis = 2; |
||
446 | direction = 1; |
||
447 | GetCtrlVal(p2, SCAN_STEPY, &step); |
||
448 | break; |
||
449 | case SCAN_BD : |
||
450 | axis = 2; |
||
451 | direction = -1; |
||
452 | GetCtrlVal(p2, SCAN_STEPY, &step); |
||
453 | break; |
||
454 | } |
||
455 | #ifdef MIKRO |
||
456 | MIKRO_MoveFor(axis, direction*step ); |
||
457 | MIKRO_GetPosition(axis,&n); |
||
458 | if (axis == 1) SetCtrlVal (p2, SCAN_XP, n); |
||
459 | if (axis == 2) SetCtrlVal (p2, SCAN_YP, n); |
||
460 | #endif // MIKRO |
||
461 | } |
||
462 | |||
463 | break; |
||
464 | } |
||
465 | return 0; |
||
466 | } |
||
467 | |||
468 | |||
469 | |||
470 | |||
471 | |||
472 | int CVICALLBACK GoXCB (int panel, int control, int event, |
||
473 | void *callbackData, int eventData1, int eventData2) { |
||
474 | int n2; |
||
475 | switch (event) { |
||
476 | case EVENT_COMMIT: |
||
477 | GetCtrlVal (p2, SCAN_XG, &n2); |
||
478 | #ifdef MIKRO |
||
479 | MIKRO_MoveTo(1,n2); |
||
480 | MIKRO_GetPosition(1,&n2); |
||
481 | |||
482 | #endif |
||
483 | SetCtrlVal (p2, SCAN_XP, n2); |
||
484 | break; |
||
485 | } |
||
486 | return 0; |
||
487 | } |
||
488 | |||
489 | int CVICALLBACK GoYCB (int panel, int control, int event, |
||
490 | void *callbackData, int eventData1, int eventData2) { |
||
491 | int n2; |
||
492 | switch (event) { |
||
493 | case EVENT_COMMIT: |
||
494 | GetCtrlVal (p2, SCAN_YG, &n2); |
||
495 | #ifdef MIKRO |
||
496 | MIKRO_MoveTo(2,n2); |
||
497 | MIKRO_GetPosition(2,&n2); |
||
498 | |||
499 | #endif |
||
500 | SetCtrlVal (p2, SCAN_YP, n2); |
||
501 | break; |
||
502 | } |
||
503 | return 0; |
||
504 | } |
||
505 | |||
506 | int CVICALLBACK GetCurrentPositionCB (int panel, int control, int event, |
||
507 | void *callbackData, int eventData1, int eventData2) { |
||
508 | |||
509 | int n[2]; |
||
510 | switch (event) { |
||
511 | case EVENT_COMMIT: |
||
512 | #ifdef MIKRO |
||
513 | MIKRO_GetPosition(1,&n[0]); |
||
514 | SetCtrlVal (p2, SCAN_XP, n[0]); |
||
515 | MIKRO_GetPosition(2,&n[1]); |
||
516 | SetCtrlVal (p2, SCAN_YP, n[1]); |
||
517 | #endif |
||
518 | break; |
||
519 | } |
||
520 | return 0; |
||
521 | } |
||
522 | |||
523 | int CVICALLBACK HomeCB (int panel, int control, int event, |
||
524 | void *callbackData, int eventData1, int eventData2) { |
||
525 | switch (event) { |
||
526 | case EVENT_COMMIT: |
||
527 | #ifdef MIKRO |
||
528 | MIKRO_ReferenceMove(1); |
||
529 | MIKRO_ReferenceMove(2); |
||
530 | GetCurrentPositionCB(panel, control, event, NULL, 0, 0); |
||
531 | #endif |
||
532 | break; |
||
533 | } |
||
534 | return 0; |
||
535 | } |
||
217 | f9daq | 536 | |
537 | int CVICALLBACK PlotScanHistogramCB (int panel, int control, int event, |
||
538 | void *callbackData, int eventData1, int eventData2) { |
||
539 | int hid=0; |
||
540 | int nx; |
||
541 | int ny; |
||
542 | switch (event) { |
||
543 | case EVENT_COMMIT: |
||
544 | GetCtrlVal (p2, SCAN_CHANNEL, &hid); |
||
545 | GetCtrlVal(p2, SCAN_NSTEPSX, &nx); |
||
546 | GetCtrlVal(p2, SCAN_NSTEPSY, &ny); |
||
547 | if (nx>1 && ny>1) { |
||
548 | H2D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle); |
||
549 | printf("redraw 2d\n"); |
||
550 | } else { |
||
551 | if (nx>1) { |
||
552 | printf("redraw 1d x\n"); |
||
553 | H1D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle); |
||
554 | } |
||
555 | if (ny>1) { |
||
556 | printf("redraw 1d x\n"); |
||
557 | H1D_Draw(100+hid,p2,SCAN_GRAPH,&scanplothandle); |
||
558 | } |
||
559 | } |
||
560 | break; |
||
561 | } |
||
562 | return 0; |
||
563 | } |
||
564 | |||
565 | int CVICALLBACK OpenGuiCB (int panel, int control, int event, |
||
566 | void *callbackData, int eventData1, int eventData2) { |
||
567 | switch (event) { |
||
568 | case EVENT_COMMIT: |
||
569 | DisplayPanel (ph); |
||
570 | DisplayPanel (p2); |
||
571 | break; |
||
572 | } |
||
573 | return 0; |
||
574 | } |
||
265 | f9daq | 575 | |
576 | int CVICALLBACK CalibrateCB (int panel, int control, int event, |
||
577 | void *callbackData, int eventData1, int eventData2) { |
||
578 | int status = 0; |
||
579 | switch (event) { |
||
580 | case EVENT_COMMIT: |
||
581 | status = DRSCalibrateTiming(); |
||
582 | printf("DRSCalibrateTiming() status = %d\n", status); |
||
583 | break; |
||
584 | } |
||
585 | return 0; |
||
586 | } |