HARPO  5.1.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
frame.c
Go to the documentation of this file.
1 /*******************************************************************************
2 
3  _____________________
4 
5  File: frame.c
6 
7  Description: Feminos Frame Format
8 
9 
10  Author: D. Calvet, calvet@hep.saclay.cea.fr
11 
12 
13  History:
14  June 2011 : created
15 
16  March 2012: changed file name from mframe.c to frame.c
17 
18  September 2013: added code for decoding new prefix PFX_SOBE_SIZE
19  Added parameter fr_sz to Frame_Print(). In this function, pointer *fr is now
20  interpreted as the first word of the frame instead of the size field as was
21  done before. The problem with the previous version is that frame size was
22  limited to 64KB because the size was coded with two bytes. This was not an
23  issue for printing Ethernet frames, but the same code is used to printout
24  full events at the output of the event builder which can be up to 7.5 MB.
25  The size has therefore to be coded on a 32-bit integer.
26 
27 *******************************************************************************/
28 #include "frame.h"
29 #include <stdio.h>
30 
31 /*******************************************************************************
32  Frame_IsDFrame_EndOfEvent
33 *******************************************************************************/
34 int Frame_IsDFrame_EndOfEvent(void *fr)
35 {
36  unsigned short *s;
37  unsigned short sz;
38 
39  s = (unsigned short *) fr;
40  sz = *s;
41  sz = (sz / 2) - 1 - 1 - 1;
42  s+=sz;
43 
44  if ((*s & PFX_4_BIT_CONTENT_MASK) == PFX_END_OF_EVENT)
45  {
46  return(1);
47  }
48  else
49  {
50  return(0);
51  }
52 }
53 
54 /*******************************************************************************
55  Frame_IsCFrame
56 *******************************************************************************/
57 int Frame_IsCFrame(void *fr, short *err_code)
58 {
59  unsigned short *s;
60  s = (unsigned short *) fr;
61  s++;
62 
63  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_CFRAME)
64  {
65  s++;
66  *err_code = *s;
67  return(1);
68  }
69  else
70  {
71  return(0);
72  }
73 }
74 
75 /*******************************************************************************
76  Frame_IsDFrame
77 *******************************************************************************/
78 int Frame_IsDFrame(void *fr)
79 {
80  unsigned short *s;
81  s = (unsigned short *) fr;
82  s++;
83 
84  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_DFRAME)
85  {
86  return(1);
87  }
88  else
89  {
90  return(0);
91  }
92 }
93 
94 /*******************************************************************************
95  Frame_IsMsgStat
96 *******************************************************************************/
97 int Frame_IsMsgStat(void *fr)
98 {
99  unsigned short *s;
100  s = (unsigned short *) fr;
101  s++;
102 
103  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_MFRAME)
104  {
105  s++; // skip MFRAME header
106  s++; // skip size
107  if ((*s & PFX_0_BIT_CONTENT_MASK) == PFX_CMD_STATISTICS)
108  {
109  return(1);
110  }
111  else
112  {
113  return(0);
114  }
115  }
116  else
117  {
118  return(0);
119  }
120 }
121 
122 /*******************************************************************************
123  Frame_GetEventTyNbTs
124 *******************************************************************************/
125 int Frame_GetEventTyNbTs(void *fr,
126  unsigned short *ev_ty,
127  unsigned int *ev_nb,
128  unsigned short *ev_tsl,
129  unsigned short *ev_tsm,
130  unsigned short *ev_tsh)
131 {
132  unsigned short *p;
133  unsigned short r0, r1;
134 
135  p = (unsigned short *) fr;
136 
137  // Is it a Start Of Event?
138  if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_START_OF_EVENT)
139  {
140  // Get event type
141  *ev_ty = GET_EVENT_TYPE(*p);
142  p++;
143 
144  // Time Stamp lower 16-bit
145  *ev_tsl = *p;
146  p++;
147 
148  // Time Stamp middle 16-bit
149  *ev_tsm = *p;
150  p++;
151 
152  // Time Stamp upper 16-bit
153  *ev_tsh = *p;
154  p++;
155 
156  // Event Count lower 16-bit
157  r0 = *p;
158  p++;
159 
160  // Event Count upper 16-bit
161  r1 = *p;
162 
163  *ev_nb = (((unsigned int) r1) << 16) | ((unsigned int) r0);
164 
165  return(0);
166  }
167  else
168  {
169  return (-1);
170  }
171 }
172 
173 /*******************************************************************************
174  Frame_Print
175 *******************************************************************************/
176 void Frame_Print(void *fp, void *fr, int fr_sz, unsigned int vflg)
177 {
178  unsigned short *p;
179  int i, j;
180  int sz_rd;
181  int done = 0;
182  unsigned short r0, r1, r2, r3;
183  unsigned int tmp;
184  int tmp_i[10];
185  int si;
186  char *c;
187  unsigned int *ui;
188  float mean, std_dev;
189  char tmp_str[10];
190 
191  p = (unsigned short *) fr;
192 
193  done = 0;
194  i = 0;
195  sz_rd = 0;
196  si = 0;
197 
198  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_SIZE))
199  {
200  fprintf((FILE *) fp, "Frame payload: %d bytes\n", fr_sz);
201  }
202 
203  while (!done)
204  {
205  // Is it a prefix for 14-bit content?
206  if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HIT_IX)
207  {
208  r0 = GET_CARD_IX(*p);
209  r1 = GET_CHIP_IX(*p);
210  r2 = GET_CHAN_IX(*p);
211  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CH))
212  {
213  fprintf((FILE *) fp, "Card %02d Chip %01d Channel %02d\n", r0, r1, r2);
214  }
215  i++;
216  p++;
217  sz_rd+=2;
218  si = 0;
219  }
220  else if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HIT_CNT)
221  {
222  r0 = GET_CARD_IX(*p);
223  r1 = GET_CHIP_IX(*p);
224  r2 = GET_CHAN_IX(*p);
225  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CNT))
226  {
227  fprintf((FILE *) fp, "Card %02d Chip %01d Channel_Hit_Count %02d\n", r0, r1, r2);
228  }
229  i++;
230  p++;
231  sz_rd+=2;
232  }
233  else if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HISTO)
234  {
235  r0 = GET_CARD_IX(*p);
236  r1 = GET_CHIP_IX(*p);
237  r2 = GET_CHAN_IX(*p);
238  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CH))
239  {
240  fprintf((FILE *) fp, "Card %02d Chip %01d Channel %02d ", r0, r1, r2);
241  }
242  i++;
243  p++;
244  sz_rd+=2;
245  }
246  // Is it a prefix for 12-bit content?
247  else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_ADC_SAMPLE)
248  {
249  r0 = GET_ADC_DATA(*p);
250  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_CHAN_DATA))
251  {
252  fprintf((FILE *) fp, "%03d 0x%04x (%4d)\n", si, r0, r0);
253  }
254  i++;
255  p++;
256  sz_rd+=2;
257  si++;
258  }
259  else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_LAT_HISTO_BIN)
260  {
261  r0 = GET_LAT_HISTO_BIN(*p);
262  i++;
263  p++;
264  sz_rd+=2;
265  r1 = *p;
266  i++;
267  p++;
268  sz_rd+=2;
269  r2 = *p;
270  i++;
271  p++;
272  sz_rd+=2;
273  tmp = (((unsigned int) r2) << 16) | (unsigned int) (r1);
274  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
275  {
276  fprintf((FILE *) fp, "%03d %03d\n", r0, tmp);
277  }
278 
279  }
280  else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_CHIP_LAST_CELL_READ)
281  {
282  r0 = *p;
283  i++;
284  p++;
285  sz_rd+=2;
286  r1 = *p;
287  i++;
288  p++;
289  sz_rd+=2;
290  r2 = *p;
291  i++;
292  p++;
293  sz_rd+=2;
294  r3 = *p;
295  i++;
296  p++;
297  sz_rd+=2;
298  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_0))
299  {
300  fprintf((FILE *) fp, "Chip %01d Last_Cell_Read %03d (0x%03x)\n",
301  GET_LST_READ_CELL_CHIP_IX(r0),
302  GET_LST_READ_CELL(r0),
303  GET_LST_READ_CELL(r0));
304  }
305  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_1))
306  {
307  fprintf((FILE *) fp, "Chip %01d Last_Cell_Read %03d (0x%03x)\n",
308  GET_LST_READ_CELL_CHIP_IX(r1),
309  GET_LST_READ_CELL(r1),
310  GET_LST_READ_CELL(r1));
311  }
312  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_2))
313  {
314  fprintf((FILE *) fp, "Chip %01d Last_Cell_Read %03d (0x%03x)\n",
315  GET_LST_READ_CELL_CHIP_IX(r2),
316  GET_LST_READ_CELL(r2),
317  GET_LST_READ_CELL(r2));
318  }
319  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_3))
320  {
321  fprintf((FILE *) fp, "Chip %01d Last_Cell_Read %03d (0x%03x)\n",
322  GET_LST_READ_CELL_CHIP_IX(r3),
323  GET_LST_READ_CELL(r3),
324  GET_LST_READ_CELL(r3));
325  }
326  }
327  // Is it a prefix for 9-bit content?
328  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_TIME_BIN_IX)
329  {
330  r0 = GET_TIME_BIN(*p);
331  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_CHAN_DATA))
332  {
333  fprintf((FILE *) fp, "Time_Bin: %d\n", r0);
334  }
335  i++;
336  p++;
337  sz_rd+=2;
338  si = 0;
339  }
340  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_HISTO_BIN_IX)
341  {
342  r0 = GET_HISTO_BIN(*p);
343  i++;
344  p++;
345  sz_rd+=2;
346  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
347  {
348  fprintf((FILE *) fp, "Bin %3d Val %5d\n", r0, *p);
349  }
350  i++;
351  p++;
352  sz_rd+=2;
353 
354  }
355  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_PEDTHR_LIST)
356  {
357  r0 = GET_PEDTHR_LIST_FEM(*p);
358  r1 = GET_PEDTHR_LIST_ASIC(*p);
359  r2 = GET_PEDTHR_LIST_MODE(*p);
360  r3 = GET_PEDTHR_LIST_TYPE(*p);
361  i++;
362  p++;
363  sz_rd+=2;
364  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
365  {
366  if (r3 == 0) // pedestal entry
367  {
368  fprintf((FILE *) fp, "# Pedestal List for FEM %02d ASIC %01d\n", r0, r1);
369  }
370  else
371  {
372  fprintf((FILE *) fp, "# Threshold List for FEM %02d ASIC %01d\n", r0, r1);
373  }
374  fprintf((FILE *) fp, "fem %02d\n", r0);
375  }
376 
377  // Determine the number of entries
378  if (r2 == 0) // AGET
379  {
380  r2 = 71;
381  }
382  else // AFTER
383  {
384  r2 = 78;
385  }
386  // Get all entries
387  for (j=0;j<=r2; j++)
388  {
389  tmp_i[0] = (int) * ((short *) p);
390  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
391  {
392  if (r3 == 0) // pedestal entry
393  {
394  sprintf(tmp_str, "ped");
395  }
396  else
397  {
398  sprintf(tmp_str, "thr");
399  }
400  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
401  {
402  fprintf((FILE *) fp, "%s %1d %2d 0x%04x (%4d)\n", tmp_str, r1, j, *p, tmp_i[0]);
403  }
404  }
405  i++;
406  p++;
407  sz_rd+=2;
408  }
409  }
410  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_DFRAME)
411  {
412  r0 = GET_FRAMING_VERSION(*p);
413  r1 = GET_FEMID(*p);
414  i++;
415  p++;
416  sz_rd+=2;
417  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
418  {
419  fprintf((FILE *) fp, "--- Start of Data Frame (V.%01d) FEM %02d --\n", r0, r1);
420  fprintf((FILE *) fp, "Filled with %d bytes\n", *p);
421  }
422  i++;
423  p++;
424  sz_rd+=2;
425  }
426  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_MFRAME)
427  {
428  r0 = GET_FRAMING_VERSION(*p);
429  r1 = GET_FEMID(*p);
430  i++;
431  p++;
432  sz_rd+=2;
433  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
434  {
435  fprintf((FILE *) fp, "--- Start of Moni Frame (V.%01d) FEM %02d --\n", r0, r1);
436  fprintf((FILE *) fp, "Filled with %d bytes\n", *p);
437  }
438  i++;
439  p++;
440  sz_rd+=2;
441  }
442  else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_CFRAME)
443  {
444  r0 = GET_FRAMING_VERSION(*p);
445  r1 = GET_FEMID(*p);
446  i++;
447  p++;
448  sz_rd+=2;
449  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
450  {
451  fprintf((FILE *) fp, "--- Start of Config Frame (V.%01d) FEM %02d --\n", r0, r1);
452  fprintf((FILE *) fp, "Error code: %d\n", *((short *) p));
453  }
454  i++;
455  p++;
456  sz_rd+=2;
457  }
458 
459  // Is it a prefix for 8-bit content?
460  else if ((*p & PFX_8_BIT_CONTENT_MASK) == PFX_ASCII_MSG_LEN)
461  {
462  r0 = GET_ASCII_LEN(*p);
463  i++;
464  p++;
465  sz_rd+=2;
466  c = (char *) p;
467  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_ASCII))
468  {
469  for (j=0;j<r0; j++)
470  {
471  fprintf((FILE *) fp, "%c", *c);
472  c++;
473  }
474  }
475  // Skip the null string terminating character
476  r0++;
477  // But if the resulting size is odd, there is another null character that we should skip
478  if (r0 & 0x0001)
479  {
480  r0++;
481  }
482  p+=(r0>>1);
483  i+=(r0>>1);
484  sz_rd+=r0;
485  }
486  // Is it a prefix for 4-bit content?
487  else if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_START_OF_EVENT)
488  {
489  r0 = GET_EVENT_TYPE(*p);
490  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
491  {
492  fprintf((FILE *) fp, "-- Start of Event (Type %01d) --\n", r0);
493  }
494  i++;
495  p++;
496  sz_rd+=2;
497 
498  // Time Stamp lower 16-bit
499  r0 = *p;
500  i++;
501  p++;
502  sz_rd+=2;
503 
504  // Time Stamp middle 16-bit
505  r1 = *p;
506  i++;
507  p++;
508  sz_rd+=2;
509 
510  // Time Stamp upper 16-bit
511  r2 = *p;
512  i++;
513  p++;
514  sz_rd+=2;
515 
516  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
517  {
518  fprintf((FILE *) fp, "Time 0x%04x 0x%04x 0x%04x\n", r2, r1, r0);
519  }
520 
521  // Event Count lower 16-bit
522  r0 = *p;
523  i++;
524  p++;
525  sz_rd+=2;
526 
527  // Event Count upper 16-bit
528  r1 = *p;
529  i++;
530  p++;
531  sz_rd+=2;
532 
533  tmp = (((unsigned int) r1) << 16) | ((unsigned int) r0);
534  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
535  {
536  fprintf((FILE *) fp, "Event_Count 0x%08x (%d)\n", tmp, tmp);
537  }
538  }
539  else if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_END_OF_EVENT)
540  {
541  tmp = ((unsigned int) GET_EOE_SIZE(*p)) << 16;
542  i++;
543  p++;
544  sz_rd+=2;
545  tmp = tmp + (unsigned int) *p;
546  i++;
547  p++;
548  sz_rd+=2;
549  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
550  {
551  fprintf((FILE *) fp, "----- End of Event ----- (size %d bytes)\n", tmp);
552  }
553 
554  }
555 
556  // Is it a prefix for 2-bit content?
557  else if ((*p & PFX_2_BIT_CONTENT_MASK) == PFX_CH_HIT_CNT_HISTO)
558  {
559  r0 = GET_CH_HIT_CNT_HISTO_CHIP_IX(*p);
560  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
561  {
562  fprintf((FILE *) fp, "Channel Hit Count Histogram (ASIC %d)\n", r0);
563  }
564 
565  p++;
566  i++;
567  sz_rd+=2;
568 
569  // null word
570  p++;
571  i++;
572  sz_rd+=2;
573 
574  ui = (unsigned int *) p;
575 
576  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
577  {
578  fprintf((FILE *) fp, "Min Bin : %d\n", *ui);
579  }
580  ui++;
581  i+=2;
582  sz_rd+=4;
583 
584  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
585  {
586  fprintf((FILE *) fp, "Max Bin : %d\n", *ui);
587  }
588  ui++;
589  i+=2;
590  sz_rd+=4;
591 
592  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
593  {
594  fprintf((FILE *) fp, "Bin Width: %d\n", *ui);
595  }
596  ui++;
597  i+=2;
598  sz_rd+=4;
599 
600  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
601  {
602  fprintf((FILE *) fp, "Bin Count: %d\n", *ui);
603  }
604  r0 = *ui;
605  ui++;
606  i+=2;
607  sz_rd+=4;
608 
609  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
610  {
611  fprintf((FILE *) fp, "Min Value: %d\n", *ui);
612  }
613  ui++;
614  i+=2;
615  sz_rd+=4;
616 
617  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
618  {
619  fprintf((FILE *) fp, "Max Value: %d\n", *ui);
620  }
621  ui++;
622  i+=2;
623  sz_rd+=4;
624 
625  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
626  {
627  fprintf((FILE *) fp, "Mean : %.2f\n", ((float) *ui) / 100.0);
628  }
629  ui++;
630  i+=2;
631  sz_rd+=4;
632 
633  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
634  {
635  fprintf((FILE *) fp, "Std Dev : %.2f\n", ((float) *ui) / 100.0);
636  }
637  ui++;
638  i+=2;
639  sz_rd+=4;
640 
641  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
642  {
643  fprintf((FILE *) fp, "Entries : %d\n", *ui);
644  }
645  ui++;
646  i+=2;
647  sz_rd+=4;
648 
649  // Get all bins
650  for (j=0; j<r0; j++)
651  {
652  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
653  {
654  fprintf((FILE *) fp, "Bin(%2d) = %9d\n", j, *ui);
655  }
656  ui++;
657  i+=2;
658  sz_rd+=4;
659  }
660 
661  // Save last value of pointer
662  p = (unsigned short *) ui;
663  }
664 
665  // Is it a prefix for 0-bit content?
666  else if ((*p & PFX_0_BIT_CONTENT_MASK) == PFX_END_OF_FRAME)
667  {
668  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
669  {
670  fprintf((FILE *) fp, "----- End of Frame -----\n");
671  }
672  i++;
673  p++;
674  sz_rd+=2;
675  }
676  else if (*p == PFX_NULL_CONTENT)
677  {
678  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_NULLW))
679  {
680  fprintf((FILE *) fp, "null word (2 bytes)\n");
681  }
682  i++;
683  p++;
684  sz_rd+=2;
685  }
686  else if ((*p == PFX_DEADTIME_HSTAT_BINS) || (*p == PFX_EVPERIOD_HSTAT_BINS))
687  {
688  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
689  {
690  if (*p == PFX_DEADTIME_HSTAT_BINS)
691  {
692  fprintf((FILE *) fp, "Dead-time Histogram\n");
693  }
694  else
695  {
696  fprintf((FILE *) fp, "Inter Event Time Histogram\n");
697  }
698  }
699 
700  p++;
701  i++;
702  sz_rd+=2;
703 
704  // null word
705  p++;
706  i++;
707  sz_rd+=2;
708 
709  ui = (unsigned int *) p;
710 
711  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
712  {
713  fprintf((FILE *) fp, "Min Bin : %d\n", *ui);
714  }
715  ui++;
716  i+=2;
717  sz_rd+=4;
718 
719  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
720  {
721  fprintf((FILE *) fp, "Max Bin : %d\n", *ui);
722  }
723  ui++;
724  i+=2;
725  sz_rd+=4;
726 
727  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
728  {
729  fprintf((FILE *) fp, "Bin Width: %d\n", *ui);
730  }
731  ui++;
732  i+=2;
733  sz_rd+=4;
734 
735  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
736  {
737  fprintf((FILE *) fp, "Bin Count: %d\n", *ui);
738  }
739  ui++;
740  i+=2;
741  sz_rd+=4;
742 
743  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
744  {
745  fprintf((FILE *) fp, "Min Value: %d\n", *ui);
746  }
747  ui++;
748  i+=2;
749  sz_rd+=4;
750 
751  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
752  {
753  fprintf((FILE *) fp, "Max Value: %d\n", *ui);
754  }
755  ui++;
756  i+=2;
757  sz_rd+=4;
758 
759  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
760  {
761  fprintf((FILE *) fp, "Mean : %.2f\n", ((float) *ui) / 100.0);
762  }
763  ui++;
764  i+=2;
765  sz_rd+=4;
766 
767  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
768  {
769  fprintf((FILE *) fp, "Std Dev : %.2f\n", ((float) *ui) / 100.0);
770  }
771  ui++;
772  i+=2;
773  sz_rd+=4;
774 
775  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
776  {
777  fprintf((FILE *) fp, "Entries : %d\n", *ui);
778  }
779  ui++;
780  i+=2;
781  sz_rd+=4;
782 
783  // Save last value of pointer
784  p = (unsigned short *) ui;
785  }
786  else if (*p == PFX_PEDESTAL_HSTAT)
787  {
788  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
789  {
790  fprintf((FILE *) fp, "\nPedestal Histogram Statistics\n");
791  }
792  p++;
793  i++;
794  sz_rd+=2;
795 
796  ui = (unsigned int *) p;
797 
798  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
799  {
800  fprintf((FILE *) fp, "Min Bin : %d\n", *ui);
801  }
802  ui++;
803  i+=2;
804  sz_rd+=4;
805 
806  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
807  {
808  fprintf((FILE *) fp, "Max Bin : %d\n", *ui);
809  }
810  ui++;
811  i+=2;
812  sz_rd+=4;
813 
814  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
815  {
816  fprintf((FILE *) fp, "Bin Width: %d\n", *ui);
817  }
818  ui++;
819  i+=2;
820  sz_rd+=4;
821 
822  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
823  {
824  fprintf((FILE *) fp, "Bin Count: %d\n", *ui);
825  }
826  ui++;
827  i+=2;
828  sz_rd+=4;
829 
830  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
831  {
832  fprintf((FILE *) fp, "Min Value: %d\n", *ui);
833  }
834  ui++;
835  i+=2;
836  sz_rd+=4;
837 
838  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
839  {
840  fprintf((FILE *) fp, "Max Value: %d\n", *ui);
841  }
842  ui++;
843  i+=2;
844  sz_rd+=4;
845 
846  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
847  {
848  fprintf((FILE *) fp, "Mean : %.2f\n", ((float) *ui) / 100.0);
849  }
850  ui++;
851  i+=2;
852  sz_rd+=4;
853 
854  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
855  {
856  fprintf((FILE *) fp, "Std Dev : %.2f\n", ((float) *ui) / 100.0);
857  }
858  ui++;
859  i+=2;
860  sz_rd+=4;
861 
862  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
863  {
864  fprintf((FILE *) fp, "Entries : %d\n", *ui);
865  }
866  ui++;
867  i+=2;
868  sz_rd+=4;
869 
870  // Save last value of pointer
871  p = (unsigned short *) ui;
872  }
873  else if (*p == PFX_PEDESTAL_H_MD)
874  {
875  p++;
876  i++;
877  sz_rd+=2;
878 
879  ui = (unsigned int *) p;
880 
881  mean = (float) (((float) *ui) / 100.0);
882  ui++;
883  i+=2;
884  sz_rd+=4;
885 
886  std_dev = (float) (((float) *ui) / 100.0);
887  ui++;
888  i+=2;
889  sz_rd+=4;
890 
891  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
892  {
893  fprintf((FILE *) fp, "Mean/Std_dev : %.2f %.2f\n", mean, std_dev);
894  }
895 
896  // Save last value of pointer
897  p = (unsigned short *) ui;
898  }
899  else if (*p == PFX_SHISTO_BINS)
900  {
901  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
902  {
903  fprintf((FILE *) fp, "Threshold Turn-on curve\n");
904  }
905  i++;
906  p++;
907  sz_rd+=2;
908 
909  for (j=0;j<16; j++)
910  {
911  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
912  {
913  fprintf((FILE *) fp, "%d ", *p);
914  }
915  i++;
916  p++;
917  sz_rd+=2;
918  }
919  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
920  {
921  fprintf((FILE *) fp, "\n\n");
922  }
923  }
924  else if (*p == PFX_CMD_STATISTICS)
925  {
926  // Skip header
927  i++;
928  p++;
929  sz_rd+=2;
930 
931  // RX command count lower 16-bit
932  r0 = *p;
933  i++;
934  p++;
935  sz_rd+=2;
936  // RX command count upper 16-bit
937  r1 = *p;
938  i++;
939  p++;
940  sz_rd+=2;
941  tmp_i[0] = (int) ((r1 << 16) | (r0));
942 
943  // RX daq count lower 16-bit
944  r0 = *p;
945  i++;
946  p++;
947  sz_rd+=2;
948  // RX daq count upper 16-bit
949  r1 = *p;
950  i++;
951  p++;
952  sz_rd+=2;
953  tmp_i[1] = (int) ((r1 << 16) | (r0));
954 
955  // RX daq timeout lower 16-bit
956  r0 = *p;
957  i++;
958  p++;
959  sz_rd+=2;
960  // RX daq timeout upper 16-bit
961  r1 = *p;
962  i++;
963  p++;
964  sz_rd+=2;
965  tmp_i[2] = (int) ((r1 << 16) | (r0));
966 
967  // RX daq delayed lower 16-bit
968  r0 = *p;
969  i++;
970  p++;
971  sz_rd+=2;
972  // RX daq delayed upper 16-bit
973  r1 = *p;
974  i++;
975  p++;
976  sz_rd+=2;
977  tmp_i[3] = (int) ((r1 << 16) | (r0));
978 
979  // Missing daq requests lower 16-bit
980  r0 = *p;
981  i++;
982  p++;
983  sz_rd+=2;
984  // Missing daq requests upper 16-bit
985  r1 = *p;
986  i++;
987  p++;
988  sz_rd+=2;
989  tmp_i[4] = (int) ((r1 << 16) | (r0));
990 
991  // RX command error count lower 16-bit
992  r0 = *p;
993  i++;
994  p++;
995  sz_rd+=2;
996  // RX command error count upper 16-bit
997  r1 = *p;
998  i++;
999  p++;
1000  sz_rd+=2;
1001  tmp_i[5] = (int) ((r1 << 16) | (r0));
1002 
1003  // TX command reply count lower 16-bit
1004  r0 = *p;
1005  i++;
1006  p++;
1007  sz_rd+=2;
1008  // TX command reply count upper 16-bit
1009  r1 = *p;
1010  i++;
1011  p++;
1012  sz_rd+=2;
1013  tmp_i[6] = (int) ((r1 << 16) | (r0));
1014 
1015  // TX DAQ reply count lower 16-bit
1016  r0 = *p;
1017  i++;
1018  p++;
1019  sz_rd+=2;
1020  // TX DAQ reply count upper 16-bit
1021  r1 = *p;
1022  i++;
1023  p++;
1024  sz_rd+=2;
1025  tmp_i[7] = (int) ((r1 << 16) | (r0));
1026 
1027  // TX DAQ reply re-send count lower 16-bit
1028  r0 = *p;
1029  i++;
1030  p++;
1031  sz_rd+=2;
1032  // TX DAQ reply re-send count upper 16-bit
1033  r1 = *p;
1034  i++;
1035  p++;
1036  sz_rd+=2;
1037  tmp_i[8] = (int) ((r1 << 16) | (r0));
1038 
1039  if (vflg & FRAME_PRINT_ALL)
1040  {
1041  fprintf((FILE *) fp, "Server RX stat: cmd_count=%d daq_req=%d daq_timeout=%d daq_delayed=%d daq_missing=%d cmd_errors=%d\n", tmp_i[0], tmp_i[1], tmp_i[2], tmp_i[3], tmp_i[4], tmp_i[5]);
1042  fprintf((FILE *) fp, "Server TX stat: cmd_replies=%d daq_replies=%d daq_replies_resent=%d\n", tmp_i[6], tmp_i[7], tmp_i[8]);
1043  }
1044  }
1045  else if (*p == PFX_START_OF_BUILT_EVENT)
1046  {
1047  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
1048  {
1049  fprintf((FILE *) fp, "***** Start of Built Event *****\n");
1050  }
1051  i++;
1052  p++;
1053  sz_rd+=2;
1054  }
1055  else if (*p == PFX_END_OF_BUILT_EVENT)
1056  {
1057  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
1058  {
1059  fprintf((FILE *) fp, "***** End of Built Event *****\n\n");
1060  }
1061  i++;
1062  p++;
1063  sz_rd+=2;
1064  }
1065  else if (*p == PFX_SOBE_SIZE)
1066  {
1067  // Skip header
1068  i++;
1069  p++;
1070  sz_rd+=2;
1071 
1072  // Built Event Size lower 16-bit
1073  r0 = *p;
1074  i++;
1075  p++;
1076  sz_rd+=2;
1077  // Built Event Size upper 16-bit
1078  r1 = *p;
1079  i++;
1080  p++;
1081  sz_rd+=2;
1082  tmp_i[0] = (int) ((r1 << 16) | (r0));
1083 
1084  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
1085  {
1086  fprintf((FILE *) fp, "***** Start of Built Event - Size = %d bytes *****\n", tmp_i[0]);
1087  }
1088 
1089  }
1090  // No interpretable data
1091  else
1092  {
1093  fprintf((FILE *) fp, "word(%04d) : 0x%x (%d) unknown data\n", i, *p, *p);
1094  sz_rd+=2;
1095  p++;
1096  }
1097 
1098  // Check if end of packet was reached
1099  if (sz_rd == fr_sz)
1100  {
1101  done = 1;
1102  }
1103  else if (sz_rd > fr_sz)
1104  {
1105  fprintf((FILE *) fp, "Format error: read %d bytes but packet size is %d\n", sz_rd, fr_sz);
1106  done = 1;
1107  }
1108  }
1109 
1110  // Put an empty line
1111  if (vflg & FRAME_PRINT_ALL)
1112  {
1113  fprintf((FILE *) fp, "\n");
1114  }
1115 }
1116 
FRAME_PRINT_LAST_CELL_READ_2
#define FRAME_PRINT_LAST_CELL_READ_2
Definition: frame.h:191
GET_PEDTHR_LIST_TYPE
#define GET_PEDTHR_LIST_TYPE(w)
Definition: frame.h:149
GET_CH_HIT_CNT_HISTO_CHIP_IX
#define GET_CH_HIT_CNT_HISTO_CHIP_IX(w)
Definition: frame.h:169
FRAME_PRINT_HISTO_STAT
#define FRAME_PRINT_HISTO_STAT
Definition: frame.h:187
PFX_CMD_STATISTICS
#define PFX_CMD_STATISTICS
Definition: frame.h:113
PFX_END_OF_EVENT
#define PFX_END_OF_EVENT
Definition: frame.h:67
PFX_0_BIT_CONTENT_MASK
#define PFX_0_BIT_CONTENT_MASK
Definition: frame.h:107
PFX_ADC_SAMPLE
#define PFX_ADC_SAMPLE
Definition: frame.h:37
PFX_CARD_CHIP_CHAN_HIT_CNT
#define PFX_CARD_CHIP_CHAN_HIT_CNT
Definition: frame.h:29
PFX_LAT_HISTO_BIN
#define PFX_LAT_HISTO_BIN
Definition: frame.h:38
PFX_EVPERIOD_HSTAT_BINS
#define PFX_EVPERIOD_HSTAT_BINS
Definition: frame.h:116
FRAME_PRINT_NULLW
#define FRAME_PRINT_NULLW
Definition: frame.h:186
PFX_NULL_CONTENT
#define PFX_NULL_CONTENT
Definition: frame.h:123
PFX_CH_HIT_CNT_HISTO
#define PFX_CH_HIT_CNT_HISTO
Definition: frame.h:79
PFX_PEDESTAL_H_MD
#define PFX_PEDESTAL_H_MD
Definition: frame.h:111
FRAME_PRINT_LAST_CELL_READ_1
#define FRAME_PRINT_LAST_CELL_READ_1
Definition: frame.h:190
GET_FRAMING_VERSION
#define GET_FRAMING_VERSION(w)
Definition: frame.h:151
Frame_Print
void Frame_Print(void *fp, void *fr, int fr_sz, unsigned int vflg)
Definition: frame.c:176
GET_CHIP_IX
#define GET_CHIP_IX(w)
Definition: frame.h:129
PFX_DEADTIME_HSTAT_BINS
#define PFX_DEADTIME_HSTAT_BINS
Definition: frame.h:109
PFX_START_OF_EVENT
#define PFX_START_OF_EVENT
Definition: frame.h:66
PFX_END_OF_FRAME
#define PFX_END_OF_FRAME
Definition: frame.h:108
FRAME_PRINT_HIT_CH
#define FRAME_PRINT_HIT_CH
Definition: frame.h:179
FRAME_PRINT_HISTO_BINS
#define FRAME_PRINT_HISTO_BINS
Definition: frame.h:182
FRAME_PRINT_FRBND
#define FRAME_PRINT_FRBND
Definition: frame.h:184
PFX_HISTO_BIN_IX
#define PFX_HISTO_BIN_IX
Definition: frame.h:46
FRAME_PRINT_EBBND
#define FRAME_PRINT_EBBND
Definition: frame.h:193
PFX_ASCII_MSG_LEN
#define PFX_ASCII_MSG_LEN
Definition: frame.h:60
PFX_2_BIT_CONTENT_MASK
#define PFX_2_BIT_CONTENT_MASK
Definition: frame.h:78
FRAME_PRINT_ASCII
#define FRAME_PRINT_ASCII
Definition: frame.h:183
GET_EOE_SIZE
#define GET_EOE_SIZE(w)
Definition: frame.h:164
GET_FEMID
#define GET_FEMID(w)
Definition: frame.h:152
GET_LST_READ_CELL
#define GET_LST_READ_CELL(w)
Definition: frame.h:138
PFX_4_BIT_CONTENT_MASK
#define PFX_4_BIT_CONTENT_MASK
Definition: frame.h:65
FRAME_PRINT_EVBND
#define FRAME_PRINT_EVBND
Definition: frame.h:185
GET_TIME_BIN
#define GET_TIME_BIN(w)
Definition: frame.h:144
GET_LAT_HISTO_BIN
#define GET_LAT_HISTO_BIN(w)
Definition: frame.h:136
GET_EVENT_TYPE
#define GET_EVENT_TYPE(word)
Definition: dccmacro.h:38
Frame_IsMsgStat
int Frame_IsMsgStat(void *fr)
Definition: frame.c:97
PFX_12_BIT_CONTENT_MASK
#define PFX_12_BIT_CONTENT_MASK
Definition: frame.h:36
PFX_14_BIT_CONTENT_MASK
#define PFX_14_BIT_CONTENT_MASK
Definition: frame.h:27
FRAME_PRINT_LAST_CELL_READ_0
#define FRAME_PRINT_LAST_CELL_READ_0
Definition: frame.h:189
FRAME_PRINT_CHAN_DATA
#define FRAME_PRINT_CHAN_DATA
Definition: frame.h:181
GET_CHAN_IX
#define GET_CHAN_IX(w)
Definition: frame.h:130
PFX_START_OF_CFRAME
#define PFX_START_OF_CFRAME
Definition: frame.h:50
GET_PEDTHR_LIST_MODE
#define GET_PEDTHR_LIST_MODE(w)
Definition: frame.h:148
PFX_TIME_BIN_IX
#define PFX_TIME_BIN_IX
Definition: frame.h:45
GET_ADC_DATA
#define GET_ADC_DATA(w)
Definition: frame.h:135
PFX_8_BIT_CONTENT_MASK
#define PFX_8_BIT_CONTENT_MASK
Definition: frame.h:59
Frame_IsCFrame
int Frame_IsCFrame(void *fr, short *err_code)
Definition: frame.c:57
FRAME_PRINT_LISTS
#define FRAME_PRINT_LISTS
Definition: frame.h:188
PFX_START_OF_DFRAME
#define PFX_START_OF_DFRAME
Definition: frame.h:48
FRAME_PRINT_HIT_CNT
#define FRAME_PRINT_HIT_CNT
Definition: frame.h:180
PFX_START_OF_BUILT_EVENT
#define PFX_START_OF_BUILT_EVENT
Definition: frame.h:114
GET_PEDTHR_LIST_ASIC
#define GET_PEDTHR_LIST_ASIC(w)
Definition: frame.h:147
PFX_CARD_CHIP_CHAN_HISTO
#define PFX_CARD_CHIP_CHAN_HISTO
Definition: frame.h:30
FRAME_PRINT_ALL
#define FRAME_PRINT_ALL
Definition: frame.h:177
Frame_IsDFrame
int Frame_IsDFrame(void *fr)
Definition: frame.c:78
FRAME_PRINT_SIZE
#define FRAME_PRINT_SIZE
Definition: frame.h:178
PFX_CARD_CHIP_CHAN_HIT_IX
#define PFX_CARD_CHIP_CHAN_HIT_IX
Definition: frame.h:28
GET_HISTO_BIN
#define GET_HISTO_BIN(w)
Definition: frame.h:145
PFX_END_OF_BUILT_EVENT
#define PFX_END_OF_BUILT_EVENT
Definition: frame.h:115
GET_CARD_IX
#define GET_CARD_IX(w)
Definition: frame.h:128
PFX_SOBE_SIZE
#define PFX_SOBE_SIZE
Definition: frame.h:117
FRAME_PRINT_LAST_CELL_READ_3
#define FRAME_PRINT_LAST_CELL_READ_3
Definition: frame.h:192
PFX_SHISTO_BINS
#define PFX_SHISTO_BINS
Definition: frame.h:112
GET_ASCII_LEN
#define GET_ASCII_LEN(w)
Definition: frame.h:157
PFX_START_OF_MFRAME
#define PFX_START_OF_MFRAME
Definition: frame.h:49
PFX_PEDESTAL_HSTAT
#define PFX_PEDESTAL_HSTAT
Definition: frame.h:110
PFX_PEDTHR_LIST
#define PFX_PEDTHR_LIST
Definition: frame.h:47
PFX_9_BIT_CONTENT_MASK
#define PFX_9_BIT_CONTENT_MASK
Definition: frame.h:44
PFX_CHIP_LAST_CELL_READ
#define PFX_CHIP_LAST_CELL_READ
Definition: frame.h:39
Frame_GetEventTyNbTs
int Frame_GetEventTyNbTs(void *fr, unsigned short *ev_ty, unsigned int *ev_nb, unsigned short *ev_tsl, unsigned short *ev_tsm, unsigned short *ev_tsh)
Definition: frame.c:125
GET_LST_READ_CELL_CHIP_IX
#define GET_LST_READ_CELL_CHIP_IX(w)
Definition: frame.h:139
GET_PEDTHR_LIST_FEM
#define GET_PEDTHR_LIST_FEM(w)
Definition: frame.h:146
Frame_IsDFrame_EndOfEvent
int Frame_IsDFrame_EndOfEvent(void *fr)
Definition: frame.c:34
Generated by   doxygen 1.8.6