StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
tpx23.cxx
1 #include <stdio.h>
2 #include <sys/types.h>
3 #include <time.h>
4 #include <stdlib.h>
5 #include <ctype.h>
6 #include <pthread.h>
7 
8 #include <rtsLog.h>
9 
10 #include <rtsSystems.h>
11 
12 #include <DAQ1000/ddl_struct.h>
13 #include <DAQ1000/rdo_cmds.h>
14 
15 #include <TPC/rowlen.h>
16 #include <TPX/tpx_altro_to_pad.h>
17 
18 #include <DAQ_TPX/tpxCore.h>
19 #include <DAQ_TPX/tpxPed.h>
20 #include <DAQ_TPX/tpxGain.h>
21 
22 #include <DAQ_ITPC/itpcPed.h> // only for itpcData!
23 
24 #ifdef THREAD_DBG_USE
25 
26 #include <MISC_LIBS/thread_dbg.h>
27 
28 #else
29 
30 #define TLOG()
31 #define TLOGX(x)
32 
33 #endif
34 
35 #include "tpx23.h"
36 
37 
38 tpxPed *tpx23::peds ;
39 tpc23_base::row_pad_t (*tpx23::rp_gain_tpx)[ROW_MAX+1][PAD_MAX+1] ;
40 
41 
42 int tpx23::from22to23(char *c_addr, int words)
43 {
44  // does NOTHING yet
45  return words ;
46 }
47 
48 inline u_int tpx23::set_rdo(int s, int r)
49 {
50 
51  sector1 = s ;
52  rdo1 = r ;
53 
54  return 0 ; // should be fee_mask
55 }
56 
57 int tpx23::fee_scan()
58 {
59  u_int *h ;
60  err = 0 ; // in class
61  int id_pre = -1 ;
62  int ch_pre = -1 ;
63  int s_cou ;
64  char retry ;
65 
66  get_token((char *)d_start,words) ;
67 
68  TLOG() ;
69 
70  if(run_type==1 || run_type==5) {
71  int r0_logical = tpx36_from_real(subdet_id,sector1,rdo1) - 1 ;
72 
73 
74  peds->valid_evts[r0_logical]++ ;
75  peds->evts[r0_logical]++ ;
76 
77  peds->sector = subdet_id ; // this is the PC id 1..36!
78 
79  if(peds->evts[r0_logical]<=3) goto done ; // skip first 3 events
80  if(peds->valid_evts[r0_logical]>1000) goto done ; // enough...
81 
82 
83  }
84 
85  // first valid FEE word is at d_start+2 ;
86  // last valid FEE word is at d_end
87  h = d_end ;
88 
89  TLOGX(rdo1) ;
90 
91  if(log_level>0) LOG(TERR,"%d: fee_scan",rdo1) ;
92 
93  u_int *h_to_continue ;
94  retry = 0 ;
95 
96  // NOTE: ALTRO scans from the end!!!
97  while(h>(d_start+2)) {
98  u_int hi, lo ;
99 
100  lo = *h-- ;
101  hi = *h-- ;
102 
103  // for intermediate hdr version
104  lo &= 0xFFFFF ;
105  hi &= 0xFFFFF ;
106 
107  int wc = ((hi&0x3F)<<4)|((lo&0xF0000)>>16) ; // altro's word count
108 
109 
110  int id = (lo&0xFF0) >> 4 ; // altro id
111  int ch = lo & 0xF ;
112 
113  // sanity checks: 0xAAA & 0xA
114  u_int aaa = hi>>6 ;
115  u_int a = (lo>>12)&0xF ;
116 
117 
118  if((aaa!= 0x2AAA)||(a!=0xA)||(wc>437)) {
119  run_errors++ ;
120  if(run_errors<20) {
121  if((online || mode) && retry==0) {
122  LOG(ERR,"S%02d:%d: aid %d:%d, %d:%d: aaa 0x%X, a 0x%X, wc %d, %d",
123  sector1,rdo1,id,ch,id_pre,ch_pre,aaa,a,wc,d_end-h) ;
124  }
125  }
126  if(1) {
127  h++ ;
128  //LOG(ERR,"Retry aaa") ;
129  retry = 1 ;
130  continue ;
131  }
132  }
133 
134  if(wc==0) {
135  id_pre = id ;
136  ch_pre = ch ;
137  continue ;
138  }
139 
140 
141  TLOGX(id) ;
142 
143 
144 // if(mode & 3) { // debugging!
145  u_int aa = ((h[1]&0xFFFFF)>>10) ;
146 
147  //LOG(TERR,"aid %d:%d: 0x%X 0x%X",id,ch,h[0]&0xFFFFF,h[1]&0xFFFFF) ;
148 
149  if(aa != 0x2AA) {
150  run_errors++ ;
151  if(run_errors<20) {
152  if((online || mode) && retry==0) {
153  LOG(ERR,"S%02d:%d: aid %d:%d, %d:%d: aaa 0x%X, a 0x%X, aa 0x%X, wc %d",
154  sector1,rdo1,id,ch,id_pre,ch_pre,aaa,a,aa,wc) ;
155  }
156  }
157 
158  if(1) {
159  h++ ;
160  //LOG(ERR,"Retry aa") ;
161  retry = 1 ;
162  continue ;
163  }
164  }
165  else {
166  //LOG(WARN,"S%02d:%d: aid %d:%d, %d:%d: aaa 0x%X, a 0x%X, aa 0x%X, wc %d",
167  // sector1,rdo1,id,ch,id_pre,ch_pre,aaa,a,aa,wc) ;
168 
169 
170  }
171 
172 // }
173 
174  if(retry) {
175  if(online || mode) {
176  if(run_errors<20) {
177  LOG(WARN,"S%02d:%d: aid %d:%d, %d:%d: aaa 0x%X, a 0x%X, wc %d, %d -- OK",
178  sector1,rdo1,id,ch,id_pre,ch_pre,aaa,a,wc,d_end-h) ;
179  }
180  }
181  }
182 
183  retry = 0 ;
184 
185  h_to_continue = h ; // h+1
186 
187  for(int i=0;i<tpx_fee_override_cou;i++) {
188  if(sector1 == tpx_fee_override[i].sector) {
189  if(rdo1==tpx_fee_override[i].rdo) {
190  int fee = id & 0xFE ;
191 
192  if(fee == tpx_fee_override[i].curr_altro) {
193  int should = tpx_fee_override[i].orig_altro ;
194 
195  if(id & 1) should |= 1 ;
196 
197  //LOG(WARN,"S%02d:%d overriding ALTRO id %d with %d",sector1,rdo1,id,should) ;
198  id = should ;
199  break ;
200  }
201  }
202  }
203  }
204 
205 
206  // this now needs to go into the canonical format!
207  int row ;
208  int pad ;
209 
210  // get row,pad & flags and skip the pad if there are flags
211  int flags = flags_row_pad(id,ch,row,pad) ;
212 
213 #if 0
214  // max wc in pedestal runs is 437
215  if(wc>437) { // garbage in the event... and now what???
216  run_errors++ ;
217  if(run_errors<10) {
218  if(online) LOG(ERR,"S%02d:%d: rp %d:%d (aid %d:%d, %d:%d) : wc %d",sector1,rdo1,row,pad,
219  id,ch,id_pre,ch_pre, wc) ;
220  }
221  //err |= 0x10000 ; // signal an error because I am breaking out
222  break ;
223  }
224 #endif
225 
226  while(wc%4) wc++ ;
227 
228  // if this is a physics run: skip pads which have flags
229  // hmm... is this right?
230  if(flags && run_type==3) {
231  if(log_level>0) {
232  LOG(TERR,"%d: rp %d:%d, flags 0x%X",rdo1,row,pad,flags) ;
233  }
234  h -= wc/2 ;
235  continue ;
236  }
237 
238 #if 0
239  // fixing a bug in fee_23a FY23 version!
240  altro_present[id][ch]++ ;
241 
242  if(altro_present[id][ch]>1) {
243  run_errors++ ;
244  if(run_errors<20) {
245  if(online) LOG(ERR,"S%02:%d: AID %d:%d already present %d",sector1,rdo1,id,ch,altro_present[id][ch]) ;
246  }
247  h -= wc/2 ;
248  continue ;
249  }
250 #endif
251 
252  u_short *d = s1_dta + last_ix ; // this is where the raw data goes...
253  //u_short d[512] ;
254 
255  if(log_level>0) {
256  LOG(TERR,"%d: rp %d:%d; last_ix %d %p",rdo1,row,pad,last_ix,d) ;
257  }
258 
259  int ix = 0 ;
260 
261  //TLOGX(row) ;
262 
263 
264  for(int i=0;i<wc;) { // NOTE: no increment!
265  lo = *h-- ;
266  hi = *h-- ;
267 
268  //lo &= 0xFFFFF ;
269  //hi &= 0xFFFFF ;
270 
271  if(ix==0) { // see if I need to skip the first dummies!!!
272  u_short dd[4] ;
273 
274  dd[0] = (hi>>10)&0x3FF ;
275  dd[1] = hi & 0x3FF ;
276  dd[2] = (lo>>10)&0x3FF ;
277  dd[3] = lo & 0x3FF ;
278 
279  int s = 0 ;
280  if(dd[0]==0x2AA) {
281  s = 1 ;
282  if(dd[1]==0x2AA) {
283  s = 2 ;
284  if(dd[2]==0x2AA) {
285  s = 3 ;
286  }
287  }
288  }
289 
290  for(;s<4;s++) {
291  d[ix++] = dd[s] ;
292  }
293  }
294  else {
295  d[ix++] = (hi>>10)&0x3FF ;
296  d[ix++] = hi & 0x3FF ;
297  d[ix++] = (lo>>10)&0x3FF ;
298  d[ix++] = lo & 0x3FF ;
299  }
300 
301  i += 4 ;
302  }
303 
304  u_short *dd = d ;
305 
306  int seq_ix = 0 ;
307  struct seq_t *seq = s1[row][pad].seq ;
308 
309  //TLOGX(row) ;
310 
311  //LOG(TERR,"Here 1") ;
312  struct sseq_t {
313  u_short t_lo ;
314  u_short t_hi ;
315  u_short d[512] ;
316  } sseq[SEQ_MAX] ;
317 
318  while(dd<(d+ix)) {
319  u_short t_lo ;
320 
321 
322  u_short t_len = *dd++ - 2 ;
323  u_short t_hi = *dd++ ;
324 
325  if(seq_ix>=(SEQ_MAX-1)) { // break if too many: note that I need to leave space for the sentinel!
326  break ;
327  }
328 
329 
330  t_lo = t_hi - t_len + 1 ;
331 
332  if(t_len>440 || t_hi>440 || t_lo>440) {
333  run_errors++ ;
334  if(run_errors<20) {
335  if(online||mode) LOG(ERR,"S%02d:%d: rp %d:%d (aid %d:%d, %d:%d), t_len %d, t_lo %d, t_hi %d; wc %d, ix %d, seq %d, %d",
336  sector1,rdo1,row,pad,
337  id,ch,id_pre,ch_pre,
338  t_len,t_lo,t_hi,wc,ix,seq_ix,d_end-h) ;
339  }
340  if(t_len>440 || t_hi>440 || t_lo>440) {
341  //err |= 0x20000 ;
342  if(1) {
343  //LOG(ERR,"Retry rp") ;
344  h = h_to_continue ;
345  retry = 1 ;
346  goto end_loop ;
347  }
348  break ;
349  }
350 
351  //if(t_hi>510) break ;
352  //if(t_lo>510) break ;
353  }
354 
355  //printf("rp %d:%d: seq %d: t_len %d, t_lo:hi %d:%d\n",row,pad,seq_ix,t_len,t_lo,t_hi) ;
356 
357  sseq[seq_ix].t_lo = t_lo ;
358  sseq[seq_ix].t_hi = t_hi ;
359  //sseq[seq_ix].dta_p = (dd-d) ; // I'm at the data now
360 
361 
362  for(int i=0;i<t_len;i++) {
363  short adc = *dd++ ;
364  sseq[seq_ix].d[i] = adc ;
365  //printf(" adc %d = %d\n",i,adc) ;
366  }
367  seq_ix++ ;
368 
369 
370  //dd += t_len ; // skip over data...
371 
372  }
373 
374  //TLOG() ;
375  if(run_type==1 || run_type==5) {
376  tpx_altro_struct a ;
377 
378  memset(&a,0,sizeof(a)) ;
379  a.what = TPX_ALTRO_DO_ADC ;
380  a.t = 1 ; //invent token
381  a.row = row ;
382  a.pad = pad ;
383  a.id = id ;
384  a.ch = ch ;
385  a.rdo = rdo1-1 ;
386  a.sector = sector1 ;
387  a.count = 435 ; // matches tb from 0..434
388 
389  int aix = 0 ;
390 
391  for(int i=(seq_ix-1);i>=0;i--) {
392  int t_len = sseq[i].t_hi - sseq[i].t_lo + 1 ;
393 
394  int ii = 0 ;
395  for(int j=(t_len-1);j>=0;j--) {
396  int adc = sseq[i].d[j] ;
397  a.adc[aix] = adc ;
398  a.tb[aix] = sseq[i].t_lo + ii ;
399  ii++ ;
400  aix++ ;
401  }
402 
403  peds->accum(&a) ;
404  }
405 
406  }
407  else if(tpx_d) {
408  tpx_d->sector = sector1 ;
409  tpx_d->rdo = rdo1 ;
410  tpx_d->row = row ;
411  tpx_d->pad = pad ;
412  tpx_d->altro = id ;
413 
414  //LOG(TERR,"%d:%d %d:%d %d:%d",sector1,rdo1,row,pad,id,ch) ;
415 
416  tpx_d->ch_start(ch) ; // sets tpx_d->ch within
417 
418  for(int i=(seq_ix-1);i>=0;i--) {
419  int t_len = sseq[i].t_hi - sseq[i].t_lo + 1 ;
420 
421  int ii = 0 ;
422  for(int j=(t_len-1);j>=0;j--) {
423  int adc = sseq[i].d[j] ;
424  int tb ;
425 
426 
427  //a.adc[aix] = adc ;
428 
429  tb = sseq[i].t_lo + ii ;
430  //a.tb[aix] = sseq[i].t_lo + ii ;
431  ii++ ;
432  //aix++ ;
433 
434  tpx_d->accum(tb,adc) ;
435  }
436 
437  }
438 
439  tpx_d->ch_done() ;
440  }
441 
442 
443 
444 
445 
446  //LOG(TERR,"Here 2") ;
447  s_cou = 0 ;
448  dd = d ;
449  seq = s1[row][pad].seq ;
450 
451 // printf("row %d, pad %d: seq_ix %d\n",row,pad,seq_ix) ;
452 
453  for(int i=(seq_ix-1);i>=0;i--) {
454  seq[s_cou].t_lo = sseq[i].t_lo;
455  seq[s_cou].t_hi = sseq[i].t_hi ;
456  seq[s_cou].dta_p = (dd-d) ;
457  seq[s_cou].blob_id = 0 ;
458 
459  int t_len = sseq[i].t_hi - sseq[i].t_lo + 1 ;
460 
461  //printf("... new seq %d: lo %d, hi %d\n",s_cou,seq[s_cou].t_lo,seq[s_cou].t_hi) ;
462 
463  for(int j=(t_len-1);j>=0;j--) {
464  *dd++ = sseq[i].d[j] ;
465  }
466  s_cou++ ;
467  }
468 
469  //TLOG() ;
470 
471  ix = dd - d ;
472 
473 // seq[s_cou].t_hi = -1 ; // sentinel; marker
474 
475 
476  sequence_cou += s_cou ;
477 
478  seq[s_cou].t_hi = -1 ;
479  s1[row][pad].ix = last_ix ; // remember where this data is
480 
481  last_ix += ix ;
482 
483 
484 #if 0
485  seq = s1[row][pad].seq ;
486  while(seq->t_hi>=0) {
487  int t_len = seq->t_hi - seq->t_lo + 1 ;
488  printf("rp %d:%d, t_lo %d, t_hi %d\n",row,pad,seq->t_lo,seq->t_hi) ;
489 
490  dd = d + seq->dta_p ;
491  for(int j=0;j<t_len;j++) {
492  printf(" adc %d: %d\n",j,dd[j]) ;
493  }
494 
495  seq++ ;
496  }
497 #endif
498 
499  id_pre = id ;
500  ch_pre = ch ;
501 
502  end_loop:;
503  }
504 
505 
506 
507  done:;
508 
509  TLOG() ;
510 
511  return err ;
512 }
513 
514 /*
515  While not strictly static, this thing should not set or use
516  any class members
517 */
518 
519 u_int tpx23::get_token_s(char *c_addr, int wds)
520 {
521  u_int *d = (u_int *)c_addr ;
522  int t, trg, daq ;
523  int trg_cou ;
524  struct trg_data *trg_d ;
525 
526  t = 4097 ;
527  trg = 0 ;
528  daq = 0 ;
529 
530  TLOGX(rdo1) ;
531 
532  int type = (d[0]>>0)&0xF ;
533  int hdr_type = (d[0]>>24)&0xF ; //0: pre-FY23 headers, 1:FY23 headers
534 // hdr_type = 1 ;
535 
536 
537  switch(type) {
538  case DDL_TYPE_LOG :
539 // LOG(WARN,"log event") ;
540  goto done ;
541  case DDL_TYPE_MSC :
542 // LOG(WARN,"msc event") ;
543  goto done ;
544  default :
545 // LOG(WARN,"%d: event %d: S%02d:%d: type %d:%d, words %d",rdo,d[1],sec,rdo,type,subtype,wds) ;
546 // goto done ;
547  break ;
548  }
549 
550 
551 // for(int i=0;i<16;i++) {
552 // LOG(TERR,"%2d = 0x%08X",i,d[i]) ;
553 // }
554 
555  TLOGX(wds) ;
556 
557  d += wds ;
558  d-- ; // at the last datum
559 
560  if(hdr_type) {
561  //0:tick,1:status,2:1,3:trg
562 
563  t = d[-2] & 0xFFF ;
564  daq = (d[-2] >> 12)&0xF ;
565  trg = (d[-2] >> 16)&0xF ;
566 
567  goto done ;
568 
569  }
570 
571  // here we are with the old, pre-FY23 header format
572  TLOGX(rdo1) ;
573 
574  d -= 2 ; // skip 2 words trailer
575 
576 
577  trg_cou = *d ;
578 
579  d -= trg_cou * (sizeof(struct trg_data)/4) ;
580 
581 
582  trg_d = (struct trg_data *)d ;
583 
584  TLOGX(trg_cou) ;
585 
586  for(int i=0;i<trg_cou;i++) {
587 // LOG(WARN,"trg_data %d: 0x%X 0x%X 0x%X",i,trg_d[i].rhic_counter, trg_d[i].csr, trg_d[i].data) ;
588 
589  switch(trg_d[i].csr & 0xFF000000) {
590  case 0xFF000000 : // FIFO stuff?
591  case 0xDD000000 : // FIFO stuff?
592  break ;
593  case 0xEE000000 : // prompt token
594  default :
595  t = trg_d[i].data & 0xFFF ;
596  daq = (trg_d[i].data >> 12)&0xF ;
597  trg = (trg_d[i].data >> 16)&0xF ;
598  goto done ;
599  }
600  }
601 
602  TLOGX(rdo1) ;
603 
604  done:;
605 
606  TLOGX(rdo1) ;
607 
608  return (trg<<16)|(daq<<12)|t ;
609 }
610 
611 u_int tpx23::get_token(char *c_addr, int wds)
612 {
613  u_int *d = (u_int *)c_addr ;
614  u_int *d_first ;
615  token = 4097 ;
616  trg_cmd = 0 ;
617  daq_cmd = 0 ;
618 
619  d_first = d ;
620 
621  err = 0 ;
622 
623 
624 // LOG(TERR,"get_token %u",d[1]) ;
625 
626  tdbg[0] = d[1] ; // RHIC counter
627 
628  d += wds ;
629  d-- ; // at the last datum
630 
631 
632 // LOG(TERR,"evt %d(hdr %d, wds %d): 0x%08X 0x%08X, 0x%08X 0x%08X 0x%08X 0x%08X",evt,hdr_version,wds,
633 // d_first[0],d_first[1],d[-3],d[-2],d[-1],d[0]) ;
634 
635  TLOGX(hdr_version) ;
636 
637  // for the new FY23 format!
638  if(hdr_version) {
639  tdbg[0] = d_first[1] ; // RHIC counter start
640  tdbg[1] = d[0] ; // RHIC counter end
641  tdbg[2] = d[-1] ; // event status
642  tdbg[3] = d[-2] ; // trg word
643 
644  tdbg[4] = d[-5] ; // at start-altro
645  tdbg[5] = d[-4] ; // at end-altr
646  tdbg[6] = d[-3] ; // before DDL
647 
648  token = d[-2] & 0xFFF ;
649  daq_cmd = (d[-2] >> 12)&0xF ;
650  trg_cmd = (d[-2] >> 16)&0xF ;
651 
652 
653  u_int evt_err = d[-1] ;
654  if(evt_err & 0xFF000000) {
655  int cou ;
656 
657  if(wds>20) cou = 20 ;
658  else cou = wds ;
659 
660  err |= 0x1 ;
661 
662  if(online) {
663  LOG(ERR,"evt_err %d:%d: 0x%08X: 0x%08X, wds %u",evt,rdo1,d_first[0],evt_err,wds) ;
664  for(int i=0;i<cou;i++) {
665  LOG(TERR," %d: 0x%08X",i,d_first[i]) ;
666  }
667  }
668  }
669 
670 
671 #if 0
672  printf(" delta evt %d: all %d: %d %d %d %d - token %d, wds %d\n",evt,tdbg[1]-tdbg[0],
673  tdbg[4]-tdbg[0],
674  tdbg[5]-tdbg[4],
675  tdbg[6]-tdbg[5],
676  tdbg[1]-tdbg[6],
677  token,wds) ;
678 
679 #endif
680 
681  d_end = d - 6 ; // last word of the ALTRO contribution
682 
683  return (trg_cmd<<16)|(daq_cmd<<12)|token ;
684 
685  }
686 
687  TLOGX(rdo1) ;
688 
689  d -= 2 ; // skip 2 words trailer to position myself at "trigger count"
690 
691  int trg_cou = *d ;
692 
693  d -= trg_cou * (sizeof(struct trg_data)/4) ; // move back 1
694 
695  TLOGX(trg_cou) ;
696 
697  struct trg_data *trg = (struct trg_data *)d ;
698  for(int i=0;i<trg_cou;i++) {
699 
700 // if(hdr_version) {
701 // LOG(TERR,"trg_data %d: 0x%X 0x%X 0x%X",i,trg[i].rhic_counter, trg[i].csr, trg[i].data) ;
702 // }
703 
704  switch(trg[i].csr & 0xFF000000) {
705  case 0xFF000000 : // FIFO stuff?
706  case 0xDD000000 : // FIFO stuff?
707  break ;
708  case 0xEE000000 : // prompt token
709  default :
710  token = trg[i].data & 0xFFF ;
711  daq_cmd = (trg[i].data >> 12)&0xF ;
712  trg_cmd = (trg[i].data >> 16)&0xF ;
713  goto done ;
714  }
715  }
716 
717  TLOG() ;
718 
719  done:;
720 
721  TLOG() ;
722 
723  d_end = d - 3 ; // very last ALTRO datum
724 
725  return (trg_cmd<<16)|(daq_cmd<<12)|token ;
726 }
727 
728 
729 // This unfortunately needs to be globally visible as per tpxCore.cxx
730 //struct tpx_rdo tpx_rdo[24][6] ;
731 
732 int tpx23::msc_dump(char *c_addr, int wds)
733 {
734 
735 
736  LOG(INFO,"msc_dump: %d bytes, should be %d: Sreal%d:%d",wds*4,sizeof(struct tpx_rdo),
737  sector1,rdo1) ;
738 
739  // modelled after tpxCore.cxx tpx_show_status
740  // struct tpx_rdo has
741  //
742  c_addr += 2*4 ; // skip 2 header words?
743 
744  memcpy(&(tpx_rdo[sector1-1][rdo1-1]),c_addr,sizeof(struct tpx_rdo)) ;
745 
746  // modify tpx_show_status to have a pointer to the data instead of this thread-unsafe tpx_rdo static!
747  err = tpx_show_status(sector1,1<<(rdo1-1),0) ;
748  if(err) {
749  if(online) LOG(ERR,"S%02d:%d: tpx_show_status %d",sector1,rdo1,err) ;
750  }
751 
752  return err ;
753 }
754 
755 int tpx23::log_dump(char *c_addr, int wds)
756 {
757  int len, cou ;
758 
759 
760 
761 
762  char *tmpbuff ;
763  int non_ascii ;
764  int do_log ;
765  u_int err_status = 0 ;
766  char *rdobuff ;
767 
768 
769  int s_real, r_real ;
770 // tpx36_to_real(subdet_id,rdo,s_real,r_real) ;
771  s_real = sector1 ;
772  r_real = rdo1 ;
773 
774  int rdo = rdo1 ;
775 
776 // do_log = (log_file) ? 0 : 1 ;
777  do_log = 1 ; // to tpx.log
778 
779 // LOG(TERR,"USing long_dump: rdo %d, log to LOG %d", rdo, do_log) ;
780 
781  non_ascii = 0 ;
782 
783  int max_cou = (words-4)*4 ;
784  rdobuff = (char *)(c_addr+2*4) ; // skip header
785 
786  // one liner or more?
787  len = strlen(rdobuff) ;
788  if(len>max_cou) len = max_cou ;
789 
790  cou = 0 ;
791 
792  tmpbuff = (char *) malloc(len+1) ;
793  memcpy(tmpbuff,rdobuff,len+1) ;
794 
795  // tokenize into strings
796  for(int i=0;i<len;i++) {
797  if(tmpbuff[i]=='\n') {
798  cou++ ;
799  tmpbuff[i] = 0 ;
800  }
801  }
802 
803 // LOG(TERR,"%d lines %s",cou,rdobuff) ;
804 
805  for(int i=0;i<(len);) { // was len+1?
806 
807  int st = i ;
808  int err = 0 ;
809 
810 
811  // check for non-printable chars; should be the same as the
812  // new SRAM check
813  for(int j=st;j<len;j++) {
814  if(tmpbuff[j] == 0) break ; // new line
815 
816  if(!isprint(tmpbuff[j])) {
817  if(tmpbuff[j] == 9) ; // skip tab
818  else {
819  LOG(WARN,"---> [%d LOG] Unprintable character 0x%02X? -- powercycle",rdo,(u_char)tmpbuff[j]) ;
820  //LOG(ERR,"But ignored for FY22") ;
821  err_status |= 1;
822  err = -1 ;
823  tmpbuff[j] = '?' ;
824  }
825  }
826 
827  }
828 
829 #if 1
830  if(strstr(tmpbuff+st,"RHIC clock: ")) {
831  if(strstr(tmpbuff+st,"EXTERNAL")) {
832  rhic_clock = 1 ;
833  }
834  else {
835  rhic_clock = 0 ; // internal
836  }
837  }
838 
839  if(strstr(tmpbuff+st,"JTAG dev ")) {
840  int ret, dev ;
841  u_int dev_id, user ;
842 
843  dev = -1 ;
844 
845 // LOG(WARN,"[S%02d:%d LOG]: JTAG:",s_real,r_real,tmpbuff+st) ;
846 
847  ret = sscanf(tmpbuff+st,"JTAG dev %d: ID 0x%X, USERcode 0x%X",&dev,&dev_id,&user) ;
848  LOG(WARN,"JTAG: ret %d, dev %d, dev_id 0x%08X, user 0x%08X",ret, dev, dev_id,user) ;
849 
850  if(ret==3 && dev>=0 && dev<5) {
851  fpga_usercode[dev] = user ;
852  }
853  }
854 #endif
855 
856  if(strstr(tmpbuff+st,"SPECIAL_0 code")) {
857  LOG(ERR,"---> SPECIAL code: RDO %d",rdo) ;
858  }
859 
860  // check for error string but just print a warning, we'll be more selective later
861  if(strstr(tmpbuff+st,"ERR")) {
862  if(strstr(tmpbuff+st,"FLASH Id")) {
863  LOG(WARN,"[S%02d:%d LOG]: contains ERR \"%s\"",s_real,r_real,tmpbuff+st) ;
864  }
865  else {
866  //err = -1 ;
867  //LOG(ERR,"[S%02d:%d LOG]: contains ERR \"%s\"",s_real,r_real,tmpbuff+st) ;
868  }
869  }
870 
871  // check for question mark in CPLD status
872  if(strstr(tmpbuff+st,"Status: Xil config")) {
873  if(strstr(tmpbuff+st,"!")) {
874  //err_status |= DET_ERR_LOCAL_PS ;
875  LOG(WARN,"---> [S%d:%d LOG] CPLD status has \"!\" -- ignored ",s_real,r_real) ;
876  //err = -1 ;
877  }
878 
879  if(strstr(tmpbuff+st,"FEE power BAD")) {
880  //err_status |= DET_ERR_OPER_PS ;
881  //LOG(ERR,"---> [S%d:%d LOG] FEE power BAD -- powercycle (ignored)",s_real,r_real) ;
882  //err = -1 ;
883  }
884  }
885 
886 
887  if(strstr(tmpbuff+st,"SRAM check failed")) {
888  err = -1 ;
889  err_status |= 2 ;
890  LOG(ERR,"---> [%d LOG] SRAM check failed -- powercycle",rdo) ;
891  }
892 
893  if(strstr(tmpbuff+st,"CPLD claims error")) {
894  err = -1 ;
895  LOG(ERR,"---> [%d LOG] CPLD claims error -- reconfig 0x300",rdo) ;
896  }
897 
898  if(strstr(tmpbuff+st,"can't configure RDO!")) {
899  LOG(ERR,"---> [%d LOG] \"can't configure RDO\" -- reconfig 0x300",rdo) ;
900 // err = -1 ;
901  }
902 
903 
904  // mostly run related
905  if(strstr(tmpbuff+st,"lost RHIC")) {
906  LOG(ERR,"---> [%d LOG] \"lost RHIC\" -- restart run",rdo) ;
907  err = -1 ;
908  }
909  if(strstr(tmpbuff+st,"NO RHIC CLOCK")) {
910  LOG(ERR,"---> [%d LOG] \"NO RHIC CLOCK\" -- restart run",rdo) ;
911  err = -1 ;
912  }
913 
914  if(strstr(tmpbuff+st,"DRIFT")) {
915  LOG(ERR,"---> [%d LOG] \"DRIFT/clock problems\" -- restart run",rdo) ;
916  err = -1 ;
917  }
918 
919 
920  if(strstr(tmpbuff+st,"CRIT")) {
921  err = -1 ;
922  LOG(ERR,"---> [%d LOG] CRIT string in log -- restart run",rdo) ;
923  }
924 
925  if(strstr(tmpbuff+st,"altro error")) {
926  err = -1 ;
927  err_status |= 3 ;
928  LOG(ERR,"---> [%d LOG] altro error -- restart run",rdo) ;
929  }
930 
931 
932  if(strstr(tmpbuff+st,"ERR ALTRO")) {
933  //err = -1 ;
934  //LOG(WARN,"---> [%d LOG] ERR ALTRO -- CHECK THIS",rdo) ;
935  }
936 
937  if(strstr(tmpbuff+st,"ERR: expired")) {
938  err = -1 ;
939  }
940 
941 
942  if(err<0) {
943  LOG(ERR,"[S%02d:%d %d]: %s",s_real,r_real,evt,tmpbuff+st) ;
944  log_is_error = 1 ;
945  }
946  else if(do_log) {
947  LOG(INFO,"[S%02d:%d %d]: %s",s_real,r_real,evt,tmpbuff+st) ;
948  }
949 
950  while(tmpbuff[i]) {
951  //LOG(WARN,"%d: %d [%c]",i,tmpbuff[i],tmpbuff[i]) ;
952  i++ ;
953  if(i>=len) break ;
954  }
955  i++ ;
956 
957  }
958 
959 // TLOG() ;
960  free(tmpbuff) ;
961 
962 #if 0
963 
964  t = time(NULL) ;
965  ctime_r(&t,tm) ;
966  tm[strlen(tm)-1] = 0 ; // kill the new-line
967 
968  switch(cou) {
969  case 0 : // no newline found
970  term_char = "\n" ;
971  buff = rdobuff ;
972  break ;
973  case 1 : // 1 newline aka 1 liner
974  buff = rdobuff ;
975  term_char = "" ;
976  break ;
977  default :
978  buff = "" ;
979  term_char = "\n" ;
980  break ;
981  }
982 
983  if(log_file == 0) {
984  return err_status;
985  }
986 
987 
988 
989  pthread_mutex_lock(&log_file_mutex) ;
990 
991 
992  fprintf(log_file,"%s[RDO %d] (%s) %s%s%s",ANSI_BLUE,rdo,
993  tm,
994  buff,
995  term_char,ANSI_RESET) ;
996 
997  if(cou > 1) {
998  fprintf(log_file,"%s",rdobuff) ;
999  }
1000 
1001  fflush(log_file) ;
1002 
1003  pthread_mutex_unlock(&log_file_mutex) ;
1004 #endif
1005 
1006  return err_status ;
1007 
1008 }
1009 
1010 
1011 int tpx23::rdo_scan(char *c_addr, int wds)
1012 {
1013  int ret = 0 ;
1014 
1015  u_int *d = (u_int *)c_addr ;
1016 
1017 
1018 
1019  int rdo = (d[0]>>8)&0xF ;
1020  int sec = (d[0]>>12)&0xFF ;
1021 
1022  subtype = (d[0]>>4)&0xF ; //class
1023  type = (d[0]>>0)&0xF ; //class
1024 
1025  hdr_version = (d[0]>>24)&0xF ;
1026 // hdr_version = 1 ;
1027 
1028  d_start = d ;
1029  token = 4096 ;
1030  trg_cmd = 0 ;
1031  daq_cmd = 0 ;
1032  err = 0 ;
1033 
1034  words = wds ;
1035 
1036  evt++ ;
1037 
1038 
1039  if((d[0]&0xF0000000)!=0xF0000000) {
1040  LOG(ERR,"%d:%d: bad header 0x%08X",evt,rdo1,d[0]) ;
1041  }
1042 
1043  if(rdo!=rdo1 || sec!=sector1) {
1044  LOG(ERR,"%d:%d: wrong sec,rdo: rdo expect %d is %d; sector expect %d is %d [0x%08X]",evt,rdo1,
1045  rdo1,rdo,sector1,sec,d[0]) ;
1046  }
1047 
1048 
1049  TLOG() ;
1050 
1051  switch(type) {
1052  case DDL_TYPE_LOG :
1053 
1054  TLOG() ;
1055  ret = log_dump(c_addr,wds) ;
1056  TLOG() ;
1057  break ;
1058  case DDL_TYPE_MSC :
1059  if(subtype==2) { // heartbeat; ignore
1060  break ;
1061  }
1062 
1063  LOG(WARN,"%d: MSC: event %d: S%02d:%d: type %d:%d, words %d",rdo1,d[1],sec,rdo,type,subtype,words) ;
1064 
1065  ret = msc_dump(c_addr, wds) ;
1066 
1067  break ;
1068  default : // ALTRO data -- and we're off
1069  evt_trgd++ ;
1070  TLOG() ;
1071  ret = fee_scan() ;
1072  TLOG() ;
1073  break ;
1074  }
1075 
1076  return ret ; // should be ret
1077 
1078 }
1079 
1080 
1081 tpx23::tpx23()
1082 {
1083 // LOG(TERR,"%s %d %p",__PRETTY_FUNCTION__,sizeof(rp_gain),rp_gain) ;
1084 
1085  rts_id = TPX_ID ;
1086 
1087 
1088  if(rp_gain_tpx==0) {
1089  rp_gain_tpx = (row_pad_t (*)[ROW_MAX+1][PAD_MAX+1]) malloc(sizeof(row_pad_t)*24*(ROW_MAX+1)*(PAD_MAX+1)) ;
1090 
1091  // initialize here!
1092  for(int s=0;s<24;s++) {
1093  for(int r=0;r<=ROW_MAX;r++) {
1094  for(int p=0;p<=PAD_MAX;p++) {
1095  rp_gain_tpx[s][r][p].gain = 1.0 ;
1096  rp_gain_tpx[s][r][p].t0 = 0.0 ;
1097  rp_gain_tpx[s][r][p].flags = 0 ;
1098  }}}
1099 
1100  }
1101 
1102  rp_gain = rp_gain_tpx ;
1103 
1104  if(peds==0) {
1105  peds = new class tpxPed ;
1106  }
1107 
1108  row_min = 14 ;
1109  row_max = 45 ;
1110  for(int row=1;row<=45;row++) rowlen[row] = tpc_rowlen[row] ;
1111 
1112  hdr_version = 0 ; // 0:pre FY23
1113 
1114  memset(fpga_usercode,0,sizeof(fpga_usercode)) ;
1115 
1116  tpx_d = 0 ;
1117 }
1118 
1119 
1120 #include <DAQ_TPX/tpxCore.h>
1121 
1122 u_char tpx23::flags_row_pad(int asic, int channel, int &row, int &pad)
1123 {
1124  row = 255 ;
1125  pad = 255 ;
1126 
1127  if(rdo1<1||rdo1>6) return 0xFF ;
1128 
1129  // I will rewrite this to make it super-fast
1130 
1131  tpx_from_altro(rdo1-1,asic,channel,row,pad) ; // from tpxCore!
1132  if(row==0 || row==255) return 0xFF ;
1133  if(pad==0 || pad==255) return 0xFF ;
1134 
1135 // row -= 13 ; // HACK: row 14 becomes row 1
1136 
1137  return rp_gain[sector1-1][row][pad].flags ;
1138 }
1139 
1140 #if 0
1141 int tpx23::run_start()
1142 {
1143 // LOG(WARN,"TPX23 run_start") ;
1144 
1145  rhic_clock = -1 ; // unknown
1146  log_is_error = 0 ;
1147 
1148  return 0 ;
1149 }
1150 #endif
tpxPed
Definition: tpxPed.h:14
tpx_altro_struct
Definition: tpxCore.h:60
tpc23_base::row_pad_t
Definition: tpc23_base.h:72
trg_data
Definition: ddl_struct.h:108
tpx_rdo
Definition: tpx_rdo.h:4
Generated by   doxygen 1.8.5