/[PAMELA software]/quicklook/dataToXML/Data/compilationInfo/src/INFN/HB_HKBuffer_INFN.c
ViewVC logotype

Contents of /quicklook/dataToXML/Data/compilationInfo/src/INFN/HB_HKBuffer_INFN.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.1.1.1 - (show annotations) (download) (vendor branch)
Tue Apr 25 09:00:20 2006 UTC (19 years, 2 months ago) by kusanagi
Branch: MAIN
CVS Tags: dataToXML1_02/01, dataToXML1_02/00, dataToXML1_03/00, dataToXML1_03/01, dataToXML1_00/00, firstRelease, dataToXML1_01/00, dataToXML1_03_02, HEAD
Changes since 1.1: +0 -0 lines
File MIME type: text/plain 
These program extract in an XML format the info contained into the ROOT files generated by YODA from the PAMELA data. To visualize the XML files in a more human readable format a collection of XSL files are given in the Data subfolder.
1 /****************************************************************************
2 * F i l e D a t a
3 * $Id: HB_HKBuffer_INFN.c,v 1.63 2005/03/13 18:11:41 sebastiani Exp $
4 * $Revision: 1.63 $
5 * $Date: 2005/03/13 18:11:41 $
6 * $RCSfile: HB_HKBuffer_INFN.c,v $
7 *
8 ****************************************************************************
9 * S W D e v e l o p m e n t E n v i r o n m e n t
10 *
11 * $Author: sebastiani $
12 ****************************************************************************
13 *
14 *****************************************************************************/
15
16
17 /*============================= Include File ================================*/
18
19 #include <src/INFN/LU_SourceFileID_INFN.h>
20 #define __FILEID__ _HB_HKBuffer_INFN__c
21 #include <src/INFN/PRH_ParamHandler_INFN.h>
22 #include <src/INFN/LU_LogUtility_INFN.h>
23 #include <src/INFN/PRH_ParamHandler_INFN_auto.h>
24 #include <src/INFN/PRH_ParamHandler_INFN_autopri.h>
25 LU_DECL_MASK();
26
27 #include <src/FileManager/MMSUManager/FT_MMSUManager_p.h>
28 #include <src/INFN/HB_HKBuffer_INFN.h>
29 #include <src/SRAMManager/SRAMPageManager/SM_SRAMPageManager_p.h>
30 #include <src/TM_TCManager/TMTCManager/TM_TMTCManager_p.h>
31
32 /*============================ Global define ================================*/
33
34 #define HB_N_BUF_SIZE 1
35
36 #define HB_EOB_LEN 16
37 #define HB_HEADER_LEN 16
38
39
40 /* table or array selector. private use only */
41 #define HB_2TAB 1
42 #define HB_2ARR 2
43
44 /*============================== global types ==============================*/
45
46 static BYTE _HB_TMTC[HB_BUF_TMTC_SIZE];
47 static BYTE _HB_LOG [HB_BUF_LOG_SIZE];
48 static BYTE _HB_MCMD[HB_BUF_MCMD_SIZE];
49 static BYTE _HB_SKETCHBOARD[HB_BUF_SKETCHBOARD_SIZE];
50 static BYTE _HB_MISC[HB_BUF_MISC_SIZE];
51 static BYTE _HB_TSB_T[HB_BUF_TSB_T_SIZE];
52 static BYTE _HB_TSB_B[HB_BUF_TSB_B_SIZE];
53 static BYTE _HB_USERDATA0[HB_BUF_USERDATA_SIZE];
54 static BYTE _HB_USERDATA1[HB_BUF_USERDATA_SIZE];
55 static BYTE _HB_USERDATA2[HB_BUF_USERDATA_SIZE];
56 static BYTE _HB_USERDATA3[HB_BUF_USERDATA_SIZE];
57 static BYTE _HB_RAW[HB_BUF_RAW_SIZE];
58
59 static DAQ_CMD_BUF HB_Buffer[HB_MAX];
60 static UINT32 HB_RecordsCounter[HB_MAX];
61 //static UINT32 HB_PktCounter[HB_MAX];
62 //static UINT32 PktCounter=0;
63 static UINT32 HB_PktType[HB_MAX];
64 static UINT32 HB_Flush_Request_Counter;
65
66 /* the writing is in BIG ENDIAN fascion */
67 #define HB_WRITE_UINT8(bufid,byte) do { \
68 HB_Buffer[bufid].buf[HB_Buffer[bufid].len] = (unsigned char)(byte); \
69 HB_Buffer[bufid].len++; \
70 } while(0)
71
72 #define HB_WRITE_UINT16(bufid,word) do { \
73 HB_WRITE_UINT8(bufid,(unsigned char)((word)>>8)); \
74 HB_WRITE_UINT8(bufid,(unsigned char)(word)); \
75 } while(0)
76
77 #define HB_WRITE_UINT32(bufid,dword) do { \
78 HB_WRITE_UINT8(bufid,(unsigned char)((dword)>>24)); \
79 HB_WRITE_UINT8(bufid,(unsigned char)((dword)>>16)); \
80 HB_WRITE_UINT8(bufid,(unsigned char)((dword)>>8)); \
81 HB_WRITE_UINT8(bufid,(unsigned char)(dword)); \
82 } while(0)
83
84 // returns the pointer to the first available byte in the buffer
85 #define HB_END_BYTE_PTR(bufid) (&(HB_Buffer[bufid].buf[HB_Buffer[bufid].len]))
86
87 #define HB_WRITE_MEMCPY(bufid,p,size) do { \
88 UINT32 tmpsize=(size); /* the compiler should optimize this */ \
89 memcpy(HB_END_BYTE_PTR(bufid),p,tmpsize); \
90 HB_Buffer[bufid].len +=tmpsize; \
91 } while(0)
92
93 #define HB_CTRL_INTERRUPT() do { \
94 if(rtems_interrupt_is_in_progress()) \
95 return CM_RC_INTERRUPT_IS_IN_PROGRESS; \
96 } while(0)
97
98
99
100 #define HB_IS_FULL_ENOUGH(bufid) (HB_Buffer[bufid].len>0)
101 #define HB_SPACE_LEFT(bufid) (HB_Buffer[bufid].size - HB_Buffer[bufid].len)
102 #define HB_BUFLEN(bufid) (HB_Buffer[bufid].len)
103
104 /*****************************************************************************/
105 /*=========================== Structure define ==============================*/
106
107
108 /*****************************************************************************/
109 /*============================ Enumerate define =============================*/
110
111 /*****************************************************************************/
112
113
114
115
116
117 /*****************************************************************************/
118
119
120 status_code HB_SemP() {
121 status_code s;
122 if((s=OS_piResourceObtain_INFN(HB_BUF_INFN_RES,RTEMS_WAIT,RTEMS_NO_TIMEOUT)) == SUCCESSFUL){
123 LU_StoreInHB(FALSE);
124 return CM_RC_SUCCESSFUL;
125 }
126 else {
127 /*@LOG SemP: error - status */
128 LU_INFN_LOG(LU_FATAL|LU_HA , LU_MASK(__FILEID__),__FILEID__,__LINE__,s);
129 return CM_RC_RES_ERR;
130 }
131 }
132
133 status_code HB_SemV() {
134 status_code s;
135 LU_StoreInHB(TRUE);
136 s=OS_piResourceRelease_INFN(HB_BUF_INFN_RES);
137 if(s == SUCCESSFUL)
138 return CM_RC_SUCCESSFUL;
139 else {
140 /*@LOG SemV: error - status */
141 LU_INFN_LOG(LU_FATAL|LU_HA, LU_MASK(__FILEID__),__FILEID__,__LINE__,s);
142 return CM_RC_RES_ERR;
143 }
144 }
145
146 status_code HB_ResetFlushRequestCounter() {
147 if(HB_SemP() == CM_RC_SUCCESSFUL) {
148 HB_Flush_Request_Counter=0;
149 HB_SemV();
150 return CM_RC_SUCCESSFUL;
151 }else
152 return CM_RC_RES_ERR;
153 }
154
155 status_code HB_GetFlushRequestFlag(BOOL *b) {
156 if(HB_SemP() == CM_RC_SUCCESSFUL && b!=NULL) {
157 *b=HB_Flush_Request_Counter>0;
158 HB_SemV();
159 return CM_RC_SUCCESSFUL;
160
161 }else
162 return CM_RC_RES_ERR;
163 }
164
165 status_code HB_Init() {
166 HB_BUF b;
167 for(b=0;b<HB_MAX;b++) {
168 HB_InitBuf_NoLock(b);
169 //HB_PktCounter[b]=0;
170 }
171 HB_Flush_Request_Counter=0;
172
173 #define HB_setpt(id) HB_PktType[HB_##id]=HB_PKTTYPE_##id;
174 HB_setpt(TMTC);
175 HB_setpt(MCMD);
176 HB_setpt(LOG);
177 HB_setpt(TSB_T);
178 HB_setpt(TSB_B);
179 HB_setpt(VARDUMP);
180 HB_setpt(ARRDUMP);
181 HB_setpt(TABDUMP);
182 HB_setpt(VAR);
183 HB_setpt(ARR);
184 HB_setpt(TAB);
185 #undef HB_setpt
186
187 LU_StoreInHB(TRUE);
188 }
189
190 status_code HB_InitBuf_NoLock(HB_BUF bufid) {
191 BYTE *buf;
192 switch(bufid) {
193 case HB_TMTC:
194 DAQ_Format_CMD_Init(&HB_Buffer[HB_TMTC],HB_BUF_TMTC_SIZE,0,_HB_TMTC);
195 break;
196 case HB_MCMD:
197 DAQ_Format_CMD_Init(&HB_Buffer[HB_MCMD],HB_BUF_MCMD_SIZE,0,_HB_MCMD);
198 break;
199 case HB_LOG:
200 DAQ_Format_CMD_Init(&HB_Buffer[HB_LOG],HB_BUF_LOG_SIZE,0,_HB_LOG);
201 break;
202 case HB_TSB_T:
203 DAQ_Format_CMD_Init(&HB_Buffer[HB_TSB_T],HB_BUF_TSB_T_SIZE,0,_HB_TSB_T);
204 break;
205 case HB_TSB_B:
206 DAQ_Format_CMD_Init(&HB_Buffer[HB_TSB_B],HB_BUF_TSB_B_SIZE,0,_HB_TSB_B);
207 break;
208 case HB_ARRDUMP:
209 case HB_TABDUMP:
210 case HB_VARDUMP:
211 case HB_VAR:
212 case HB_ARR:
213 case HB_TAB:
214 /* they are not really buffers */
215 break;
216 case HB_SKETCHBOARD:
217 DAQ_Format_CMD_Init(&HB_Buffer[HB_SKETCHBOARD],HB_BUF_SKETCHBOARD_SIZE,0,_HB_SKETCHBOARD);
218 break;
219 case HB_MISC:
220 DAQ_Format_CMD_Init(&HB_Buffer[HB_MISC],HB_BUF_MISC_SIZE,0,_HB_MISC);
221 break;
222 case HB_USERDATA0:
223 DAQ_Format_CMD_Init(&HB_Buffer[bufid],HB_BUF_USERDATA_SIZE,0,_HB_USERDATA0);
224 break;
225 case HB_USERDATA1:
226 DAQ_Format_CMD_Init(&HB_Buffer[bufid],HB_BUF_USERDATA_SIZE,0,_HB_USERDATA1);
227 break;
228 case HB_USERDATA2:
229 DAQ_Format_CMD_Init(&HB_Buffer[bufid],HB_BUF_USERDATA_SIZE,0,_HB_USERDATA2);
230 break;
231 case HB_USERDATA3:
232 DAQ_Format_CMD_Init(&HB_Buffer[bufid],HB_BUF_USERDATA_SIZE,0,_HB_USERDATA3);
233 break;
234 case HB_RAW:
235 DAQ_Format_CMD_Init(&HB_Buffer[bufid],HB_BUF_RAW_SIZE,0,_HB_RAW);
236 break;
237 defaul:
238 /*@LOG Unknown buffer id - bufid */
239 LU_INFN_LOG(LU_INTERNAL|LU_HA, LU_MASK(__FILEID__),__FILEID__,__LINE__,bufid);
240 break;
241 }
242 HB_RecordsCounter[bufid]=0;
243 return CM_RC_SUCCESSFUL;
244 }
245
246
247 status_code HB_InitBuf(HB_BUF bufid) {
248 status_code s;
249 if(HB_SemP() == CM_RC_SUCCESSFUL) {
250 s=HB_InitBuf_NoLock(bufid);
251 HB_SemV();
252 return s;
253 }else
254 return CM_RC_RES_ERR;
255 }
256
257 unsigned int HB_SpaceLeft(HB_BUF bufid) {
258 unsigned int v;
259 HB_SemP();
260 v = HB_Buffer[bufid].size - HB_Buffer[bufid].len;
261 HB_SemV();
262 return v;
263 }
264
265
266 status_code HB_WriteHeader(HB_BUF bufid,BYTE pkt_type,UINT32 len,TI_TIME obt) {
267 return DAQ_WriteHeader2Buffer(&(HB_Buffer[bufid]),
268 PM_pi_GetAndIncrPckCnt(),
269 pkt_type,
270 len,
271 obt);
272 }
273
274
275
276 status_code HB_WriteHeader_Original(HB_BUF bufid,BYTE pkt_type,UINT32 len,TI_TIME obt) {
277 UINT16 crc=0;
278 UINT32 counter = PM_pi_GetAndIncrPckCnt();
279 BYTE *start,b;
280 if(HB_Buffer[bufid].size - HB_Buffer[bufid].len < 16)
281 return CM_RC_NO_SPACE_LEFT;
282 // this shoud be not need: TI_piGetTimeInfo(&obt);
283 start=HB_END_BYTE_PTR(bufid);
284
285 HB_WRITE_UINT8(bufid,0xfa);
286 HB_WRITE_UINT8(bufid,0xfe);
287 HB_WRITE_UINT8(bufid,0xde);
288
289 HB_WRITE_UINT8(bufid,pkt_type);
290 HB_WRITE_UINT8(bufid,pkt_type);
291
292 b=(counter>>16) & 0xff;
293 HB_WRITE_UINT8(bufid,b);
294 b=(counter>>8) & 0xff;
295 HB_WRITE_UINT8(bufid,b);
296 b=(counter & 0xff);
297 HB_WRITE_UINT8(bufid,b);
298
299 HB_WRITE_UINT32(bufid,obt);
300
301 b=(len>>16) & 0xff;
302 HB_WRITE_UINT8(bufid,b);
303 b=(len>>8) & 0xff;
304 HB_WRITE_UINT8(bufid,b);
305 b=(len & 0xff);
306 HB_WRITE_UINT8(bufid,b);
307
308 crc = CM_Compute_CRC16(0,start,15);
309 b=crc & 0xff;
310 HB_WRITE_UINT8(bufid,b);
311 return CM_RC_SUCCESSFUL;
312 }
313
314 status_code HB_StoreRaw(DAQ_CMD_BUF *b) {
315 return HB_Store(HB_RAW,b->len,b->buf,HB_UNUSED,HB_UNUSED,HB_UNUSED);
316 }
317
318 status_code HB_StoreMisc(BYTE pkttype,DAQ_CMD_BUF *b) {
319 return HB_Store(HB_MISC,b->len,b->buf,HB_UNUSED,pkttype,HB_UNUSED);
320 }
321 status_code HB_StoreSketchboard() {
322 return HB_Store(HB_SKETCHBOARD,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,HB_UNUSED);
323 }
324 status_code HB_StoreVarDump() {
325 return HB_Store(HB_VARDUMP,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,HB_UNUSED);
326 }
327 status_code HB_StoreArrDump() {
328 return HB_Store(HB_ARRDUMP,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,HB_UNUSED);
329 }
330 status_code HB_StoreTabDump() {
331 return HB_Store(HB_TABDUMP,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,HB_UNUSED);
332 }
333 status_code HB_StoreTMTC() {
334 return HB_Store(HB_TMTC,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,HB_UNUSED);
335 }
336
337 status_code HB_StoreVar(BYTE id) {
338 return HB_Store(HB_VAR,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,id);
339 }
340 status_code HB_StoreArr(BYTE id) {
341 return HB_Store(HB_ARR,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,id);
342 }
343 status_code HB_StoreTab(BYTE id) {
344 return HB_Store(HB_TAB,HB_UNUSED,NULL,HB_UNUSED,HB_UNUSED,id);
345 }
346
347
348 status_code HB_StoreMcmd(MA_HEADER_MCMD* mcmd) {
349 if(mcmd)
350 return HB_Store(HB_MCMD,mcmd->Length*sizeof(UINT16),mcmd->PtrMCMD,
351 HB_UNUSED,HB_UNUSED,HB_UNUSED);
352 else
353 return CM_RC_NOINFO;
354 }
355 status_code HB_StoreUserData(BYTE bufno,UINT16 len,void *dataptr) {
356 if(bufno >= HB_USERDATA_NO)
357 return CM_RC_INVALID_BUFFER_ID;
358 return HB_Store(HB_USERDATA0+bufno,len,dataptr,
359 HB_UNUSED,HB_UNUSED,HB_UNUSED);
360 }
361 status_code HB_StoreLog(UINT16 len,void *dataptr,TI_TIME obt) {
362 return HB_Store(HB_LOG,len,dataptr,obt,HB_UNUSED,HB_UNUSED);
363 }
364 status_code HB_StoreTSB_T(DAQ_CMD_BUF *b) {
365 return HB_Store(HB_TSB_T,b->len,b->buf,HB_UNUSED,HB_UNUSED,HB_UNUSED);
366 }
367 status_code HB_StoreTSB_B(DAQ_CMD_BUF *b) {
368 return HB_Store(HB_TSB_B,b->len,b->buf,HB_UNUSED,HB_UNUSED,HB_UNUSED);
369 }
370
371
372 // A buffer is considered "to be stored" if is at least (PRH_VAR_HB_ALMOST_FULL %) is filled up
373 void HB_IS_ALMOST_FULL(HB_BUF bufid) {
374 if(HB_Buffer[bufid].len > (HB_Buffer[bufid].size * PRH_VAR_HB_ALMOST_FULL)/100)
375 HB_Flush_Request_Counter++;
376 }
377
378
379 static status_code HB_Store(HB_BUF bufid,
380 unsigned short int len,void *dataptr,
381 TI_TIME obt,
382 BYTE miscpkttype,
383 UINT32 additional) {
384 UINT32 i,size;
385 status_code s=CM_RC_SUCCESSFUL;
386 static UINT32 tmtc_tmp_array[TM_MAX_TELEMETRY];
387 BYTE *buf=(BYTE*)dataptr;
388 TI_TIME ts;
389 PRH_VAR_TYPE var;
390 PRH_VAR_TYPE *p;
391 UINT16 crc;
392 HB_BUF source;
393 UINT32 dumplen;
394 UINT32 tm_val,n,r,c,total_len;
395 BYTE *start,*start_header, b,suppl;
396 TM_TELEMETRY tm;
397 BOOL mm;
398
399 if(rtems_interrupt_is_in_progress())
400 return CM_RC_INTERRUPT_IS_IN_PROGRESS;
401 if(obt==HB_UNUSED)
402 TI_piGetTimeInfo_ms(&obt);
403 if(HB_SemP() == CM_RC_SUCCESSFUL) {
404 switch(bufid) {
405 case HB_RAW:
406 if(HB_SPACE_LEFT(HB_RAW) < len)
407 s=CM_RC_NO_SPACE_LEFT;
408 else {
409 HB_WRITE_MEMCPY(HB_RAW,buf,len);
410 HB_RecordsCounter[HB_RAW]++;
411 }
412 break;
413 case HB_VAR:
414 case HB_ARR:
415 case HB_TAB:
416 i=additional;
417 switch(bufid) {
418 case HB_VAR:
419 suppl=sizeof(BYTE) /* id */;
420 PRH_int_get_var(i,&var);
421 size=sizeof(PRH_VAR_TYPE);
422 break;
423 case HB_ARR:
424 suppl=sizeof(BYTE) /* id */ + sizeof(UINT16) /* len */;
425 PRH_int_get_arr_ptr(i,&p);
426 PRH_int_get_arr_n(i,&n);
427 PRH_SIZEOF_ARR(i,&size);
428 break;
429 case HB_TAB:
430 suppl=sizeof(BYTE) /* id */ + sizeof(BYTE) /* row */ + sizeof(BYTE) /* cols */;
431 PRH_int_get_tab_ptr(i,&p);
432 PRH_int_get_tab_dim(i,&r,&c);
433 PRH_SIZEOF_TABLE(i,&size);
434 break;
435 }
436 dumplen=size+suppl;
437 if(HB_SPACE_LEFT(HB_SKETCHBOARD)
438 <
439 HB_HEADER_LEN + /* header */
440 dumplen +
441 sizeof(UINT16) /* 2 byte crc 16 */
442 )
443 s=CM_RC_NO_SPACE_LEFT;
444 else {
445 HB_WriteHeader(HB_SKETCHBOARD,
446 HB_PktType[bufid],
447 dumplen+sizeof(UINT16),obt);
448 start=HB_END_BYTE_PTR(HB_SKETCHBOARD);
449 HB_WRITE_UINT8(HB_SKETCHBOARD,i);
450 switch(bufid) {
451 case HB_VAR:
452 HB_WRITE_UINT32(HB_SKETCHBOARD,var);
453 break;
454 case HB_ARR:
455 HB_WRITE_UINT16(HB_SKETCHBOARD,n);
456 HB_WRITE_MEMCPY(HB_SKETCHBOARD,p,size);
457 break;
458 case HB_TAB:
459 HB_WRITE_UINT8(HB_SKETCHBOARD,r);
460 HB_WRITE_UINT8(HB_SKETCHBOARD,c);
461 HB_WRITE_MEMCPY(HB_SKETCHBOARD,p,size);
462 break;
463 }
464 crc=CM_Compute_CRC16(0,start,dumplen);
465 HB_WRITE_UINT16(HB_SKETCHBOARD,crc);
466 }
467 break;
468
469 case HB_VARDUMP:
470 case HB_ARRDUMP:
471 case HB_TABDUMP:
472 switch(bufid) {
473 case HB_VARDUMP:
474 dumplen=PRH_get_var_dump_len();
475 break;
476 case HB_ARRDUMP:
477 //dumplen=PRH_TOTAL_ARR_SIZE;
478 dumplen=PRH_get_arr_dump_len();
479 break;
480 case HB_TABDUMP:
481 //dumplen=PRH_TOTAL_TAB_SIZE;
482 dumplen=PRH_get_tab_dump_len();
483 break;
484 default:
485 {
486 HB_SemV();
487 return CM_RC_INTERNAL_ERR;
488 }
489 }
490 if(HB_SPACE_LEFT(HB_SKETCHBOARD)
491 <
492 HB_HEADER_LEN + /* header */
493 sizeof(UINT32) + /* PRH_STAMP */
494 dumplen + /* len of dump */
495 sizeof(UINT16) /* 2 byte crc 16 */
496 )
497 s=CM_RC_NO_SPACE_LEFT;
498 else {
499 start_header=HB_END_BYTE_PTR(HB_SKETCHBOARD);
500 HB_WriteHeader(HB_SKETCHBOARD,
501 HB_PktType[bufid],
502 dumplen+sizeof(UINT16)+sizeof(UINT32),obt);
503 start=HB_END_BYTE_PTR(HB_SKETCHBOARD);
504 HB_WRITE_UINT32(HB_SKETCHBOARD,PRH_STAMP);
505 switch(bufid) {
506 case HB_VARDUMP:
507 for(i=0;i<PRH_VAR_MAX;i++) {
508 if(PRH_int_var_is_in_mm(i,&mm) == CM_RC_SUCCESSFUL &&
509 mm &&
510 PRH_int_get_var(i,&var) == CM_RC_SUCCESSFUL) {
511 HB_WRITE_UINT8(HB_SKETCHBOARD,i);
512 HB_WRITE_UINT32(HB_SKETCHBOARD,var);
513 }
514 }
515 break;
516 case HB_ARRDUMP:
517 for(i=0;i<PRH_ARR_MAX;i++) {
518 if(PRH_int_arr_is_in_mm(i,&mm) == CM_RC_SUCCESSFUL &&
519 mm &&
520 PRH_int_get_arr_ptr(i,&p) == CM_RC_SUCCESSFUL &&
521 PRH_int_get_arr_n(i,&n) == CM_RC_SUCCESSFUL &&
522 PRH_SIZEOF_ARR(i,&size) == CM_RC_SUCCESSFUL ) {
523 HB_WRITE_UINT8(HB_SKETCHBOARD,i);
524 HB_WRITE_UINT16(HB_SKETCHBOARD,n);
525 HB_WRITE_MEMCPY(HB_SKETCHBOARD,p,size);
526 }
527 }
528 break;
529 case HB_TABDUMP:
530 for(i=0;i<PRH_TAB_MAX;i++) {
531 if(PRH_int_tab_is_in_mm(i,&mm) == CM_RC_SUCCESSFUL &&
532 mm &&
533 PRH_int_get_tab_ptr(i,&p) == CM_RC_SUCCESSFUL &&
534 PRH_int_get_tab_dim(i,&r,&c) == CM_RC_SUCCESSFUL &&
535 PRH_SIZEOF_TABLE(i,&size) == CM_RC_SUCCESSFUL
536 ) {
537 HB_WRITE_UINT8(HB_SKETCHBOARD,i);
538 HB_WRITE_UINT8(HB_SKETCHBOARD,r);
539 HB_WRITE_UINT8(HB_SKETCHBOARD,c);
540 HB_WRITE_MEMCPY(HB_SKETCHBOARD,p,size);
541 }
542 }
543 break;
544 }
545 crc=CM_Compute_CRC16(0,start,dumplen+sizeof(UINT32)/* PRH_STAMP */);
546 HB_WRITE_UINT16(HB_SKETCHBOARD,crc);
547 }
548 break;
549 case HB_SKETCHBOARD:
550 /* put inside all the possible. Ignore function parameters */
551 HB_InitBuf_NoLock(HB_SKETCHBOARD);
552 for(source=HB_NULL;source<HB_MAX;source++) {
553 switch (source) {
554 case HB_TMTC:
555 case HB_TSB_T:
556 case HB_TSB_B:
557 case HB_LOG:
558 case HB_MCMD:
559
560 /* consider extra data: */
561 switch(source) {
562 case HB_LOG:
563 total_len=HB_Buffer[source].len+4;
564 break;
565 default:
566 total_len=HB_Buffer[source].len;
567 break;
568
569 }
570
571 if(HB_IS_FULL_ENOUGH(source) &&
572 (HB_SPACE_LEFT(HB_SKETCHBOARD) >=
573 HB_HEADER_LEN+ /* header len */
574 total_len + /* records len */
575 sizeof(UINT16) /* 2 Byte CRC 16 */
576 )
577 ) {
578 HB_WriteHeader(HB_SKETCHBOARD,
579 HB_PktType[source],
580 total_len + /* len */
581 sizeof(UINT16) /* 2 byte crc 16 */
582 ,obt);
583 start=HB_END_BYTE_PTR(HB_SKETCHBOARD);
584 /* write extra data: */
585 switch(source) {
586 case HB_LOG:
587 {
588 UINT32 tstamp=LU_GetCompilationTimeStamp();
589 HB_WRITE_UINT32(HB_SKETCHBOARD,tstamp);
590 }
591 break;
592 defaul:
593 }
594 HB_WRITE_MEMCPY(HB_SKETCHBOARD,HB_Buffer[source].buf,HB_Buffer[source].len);
595 crc=CM_Compute_CRC16(0,start,total_len);
596 HB_WRITE_UINT16(HB_SKETCHBOARD,crc);
597 HB_InitBuf_NoLock(source);
598 }
599
600 break;
601 case HB_MISC:
602 if(HB_IS_FULL_ENOUGH(source) &&
603 (HB_SPACE_LEFT(HB_SKETCHBOARD) >=
604 HB_HEADER_LEN+ /* header len */
605 HB_Buffer[source].len /* records len */
606 )
607 ) {
608 start=HB_END_BYTE_PTR(HB_SKETCHBOARD);
609 HB_WRITE_MEMCPY(HB_SKETCHBOARD,HB_Buffer[source].buf,HB_Buffer[source].len);
610 HB_InitBuf_NoLock(source);
611 }
612 break;
613 default:
614 break;
615 }
616 }
617 break;
618 case HB_LOG:
619 if(HB_SPACE_LEFT(HB_LOG) < len+sizeof(obt))
620 s=CM_RC_NO_SPACE_LEFT;
621 else {
622 HB_WRITE_UINT32(HB_LOG,obt);
623 HB_WRITE_MEMCPY(HB_LOG,buf,len);
624 HB_RecordsCounter[HB_LOG]++;
625 }
626 HB_IS_ALMOST_FULL(bufid);
627 break;
628 case HB_TSB_T:
629 case HB_TSB_B:
630 if(HB_SPACE_LEFT(bufid) <
631 sizeof(UINT32) + /* obt */
632 len /* buffer len */
633 ) {
634 s=CM_RC_NO_SPACE_LEFT;
635 }else{
636 start=HB_END_BYTE_PTR(bufid);
637 HB_WRITE_UINT32(bufid,obt);
638 HB_WRITE_MEMCPY(bufid,buf,len);
639 HB_RecordsCounter[bufid]++;
640 HB_IS_ALMOST_FULL(bufid);
641 }
642 break;
643 case HB_MCMD:
644 if(HB_SPACE_LEFT(HB_MCMD) <
645 sizeof(UINT32) + /* obt */
646 len + /* mcmd len */
647 sizeof(UINT16)) /* crc 16 */
648 s=CM_RC_NO_SPACE_LEFT;
649 else {
650 start=HB_END_BYTE_PTR(HB_MCMD);
651 HB_WRITE_UINT32(HB_MCMD,obt);
652 HB_WRITE_MEMCPY(HB_MCMD,buf,len);
653 crc=CM_Compute_CRC16(0,start,sizeof(UINT32)+len);
654 HB_WRITE_UINT16(HB_MCMD,crc);
655 HB_RecordsCounter[HB_MCMD]++;
656 }
657 HB_IS_ALMOST_FULL(bufid);
658 break;
659 case HB_TMTC:
660 if(HB_SPACE_LEFT(HB_TMTC) <
661 sizeof(UINT32) + /* OBT */
662 /* sizeof(tmtc_tmp_array) + /* size of the TMTC array */
663 16*2+16*1+1+4 +
664 1 /* 1 byte CRC */
665 )
666 s=CM_RC_NO_SPACE_LEFT;
667 else {
668 start=HB_END_BYTE_PTR(HB_TMTC);
669 total_len=HB_BUFLEN(HB_TMTC);
670
671 HB_WRITE_UINT32(HB_TMTC,obt);
672 TM_piGetAllTMValue(tmtc_tmp_array);
673
674
675 //HB_WRITE_MEMCPY(HB_TMTC,tmtc_tmp_array,sizeof(tmtc_tmp_array));
676
677
678 #define TMTC_PACK_BIT(target,tm_id) target = (target<<1)|(tmtc_tmp_array[tm_id] ? 1 : 0)
679
680 tm_val=0;
681
682 /* DIAG ACQ and BI LEVEL DIAG ACQ */
683 /* MSB */
684 TMTC_PACK_BIT(tm_val,TM_KRB_IPM1);
685 TMTC_PACK_BIT(tm_val,TM_KRB_IPM2);
686 TMTC_PACK_BIT(tm_val,TM_KRB_IPM3);
687 TMTC_PACK_BIT(tm_val,TM_KRB_IPM4);
688 TMTC_PACK_BIT(tm_val,TM_KRB_IPM5);
689 TMTC_PACK_BIT(tm_val,TM_KRB_IPM6);
690
691 TMTC_PACK_BIT(tm_val,TM_KHB_HOT_LATCHUP);
692 TMTC_PACK_BIT(tm_val,TM_KHB_COLD_LATCHUP);
693
694 TMTC_PACK_BIT(tm_val,TM_IDAQ_HOT_ALARM);
695 TMTC_PACK_BIT(tm_val,TM_IDAQ_COLD_ALARM);
696
697 TMTC_PACK_BIT(tm_val,TM_VCB_STANDBY);
698
699 TMTC_PACK_BIT(tm_val,TM_VRL_HOT);
700 TMTC_PACK_BIT(tm_val,TM_VRL_COLD);
701
702 TMTC_PACK_BIT(tm_val,TM_PSB_ALARM);
703
704 TMTC_PACK_BIT(tm_val,TM_TOFHV_HOT_ALARM);
705 TMTC_PACK_BIT(tm_val,TM_TOFHV_COLD_ALARM);
706
707 HB_WRITE_UINT16(HB_TMTC,tm_val);
708
709 /* TH ANA */
710 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_IPM_TH]);
711 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_S1_TH]);
712
713 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_S4_TH]);
714 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_S4_ND_PLATE_TH]);
715
716 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_TRK_TH1]);
717 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_TRK_TH2]);
718
719 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_FLUID_IN_TH]);
720 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_FLUID_OUT_TH]);
721
722 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_VME_TH]);
723
724 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_DCDC_TH]);
725
726 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_CPU_TH1]);
727 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_CPU_TH2]);
728
729 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_IPM_CPU_TH]);
730 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_VRL_TH1]);
731 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_VRL_TH2]);
732 HB_WRITE_UINT16(HB_TMTC,tmtc_tmp_array[TM_VME_COOL_TH]);
733
734 /* DEA ANA */
735 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM1]);
736 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM2]);
737 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM3]);
738 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM4]);
739 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM5]);
740 HB_WRITE_UINT8(HB_TMTC,tmtc_tmp_array[TM_IPM_MOV_IPM6]);
741
742
743 crc=CM_Compute_CRC16(0,start,HB_BUFLEN(HB_TMTC)-total_len);
744 b=crc & 0xff;
745 HB_WRITE_UINT8(HB_TMTC,b);
746 HB_RecordsCounter[HB_TMTC]++;
747 }
748 HB_IS_ALMOST_FULL(bufid);
749 break;
750 case HB_MISC:
751 // HB_InitBuf_NoLock(bufid);
752 if(HB_SPACE_LEFT(HB_MISC) >=
753 HB_HEADER_LEN+ /* header len */
754 len+ /* records len */
755 sizeof(UINT16) /* 2 byte crc 16 */
756 ){
757 HB_WriteHeader(bufid,
758 miscpkttype,
759 len+2,
760 obt);
761 start=HB_END_BYTE_PTR(bufid);
762 memcpy(start,dataptr,len);
763 HB_Buffer[bufid].len+=len;
764 crc=CM_Compute_CRC16(0,start,len);
765 HB_WRITE_UINT16(HB_MISC,crc);
766 }
767 else
768 s=CM_RC_NO_SPACE_LEFT;
769 HB_IS_ALMOST_FULL(bufid);
770 break;
771 case HB_USERDATA0:
772 case HB_USERDATA1:
773 case HB_USERDATA2:
774 case HB_USERDATA3:
775 /* append bytes in the buffer: */
776 if(HB_SPACE_LEFT(bufid) < len)
777 s=CM_RC_NO_SPACE_LEFT;
778 else {
779 start=HB_END_BYTE_PTR(bufid);
780 memcpy(start,buf,len);
781 HB_Buffer[bufid].len+=len;
782 }
783 break;
784 default:
785 s=CM_RC_INTERNAL_ERR;
786 break;
787 }
788 }else
789 s=CM_RC_RES_ERR;
790 if(HB_SemV())
791 s=CM_RC_RES_ERR;
792 /* TBD: Log this?
793 if(s == CM_RC_NO_SPACE_LEFT && bufid != HB_LOG)
794 LU_INFN_LOG(LU_CRITICAL, LU_MASK(__FILEID__),__FILEID__,__LINE__,s);
795 */
796 return s;
797 }
798
799
800 status_code HB_Userdata2ArrTab(BYTE what,HB_BUF bufid,BYTE id,UINT16 crc) {
801 status_code s;
802 UINT32 size;
803 if(bufid < HB_USERDATA_FIRST || bufid > HB_USERDATA_LAST)
804 return CM_RC_INVALID_BUFFER_ID;
805 if(HB_SemP() == CM_RC_SUCCESSFUL) {
806 switch(what) {
807 case HB_2ARR:
808 s=PRH_SIZEOF_ARR(id,&size);
809 break;
810 case HB_2TAB:
811 s=PRH_SIZEOF_TABLE(id,&size);
812 break;
813 }
814 if(s==CM_RC_SUCCESSFUL) {
815 if(size == HB_Buffer[bufid].len) {
816 DAQ_Compute_CRC16(&HB_Buffer[bufid]);
817 if(HB_Buffer[bufid].crc16 == crc) {
818 switch(what) {
819 case HB_2TAB:
820 s=PRH_int_set_tab_raw(id,HB_Buffer[bufid].buf);
821 break;
822 case HB_2ARR:
823 s=PRH_int_set_arr_raw(id,HB_Buffer[bufid].buf);
824 break;
825 }
826 }
827 else
828 s=CM_RC_CRC_MISMATCH;
829 }
830 else
831 s=CM_RC_INVALID_BUFFER_SIZE;
832 }
833 HB_SemV();
834 return s;
835 }else
836 return CM_RC_RES_ERR;
837 }
838
839 status_code HB_Userdata2Arr(HB_BUF bufid,BYTE id,UINT16 crc) {
840 return HB_Userdata2ArrTab(HB_2ARR,bufid,id,crc);
841 }
842
843 status_code HB_Userdata2Tab(HB_BUF bufid,BYTE id,UINT16 crc) {
844 return HB_Userdata2ArrTab(HB_2TAB,bufid,id,crc);
845 }
846
847 status_code HB_Userdata2Buf(HB_BUF bufid,DAQ_CMD_BUF *target,UINT16 crc) {
848 status_code s;
849 UINT32 size;
850 if(bufid < HB_USERDATA_FIRST || bufid > HB_USERDATA_LAST)
851 return CM_RC_INVALID_BUFFER_ID;
852 if(HB_SemP() == CM_RC_SUCCESSFUL) {
853 DAQ_Compute_CRC16(&HB_Buffer[bufid]);
854 if(HB_Buffer[bufid].crc16 != crc){
855 /*@LOG error in CRC loading external buffer - crc */
856 LU_INFN_LOG(LU_CRITICAL|LU_HA, LU_MASK(__FILEID__),__FILEID__,__LINE__,crc);
857 s=CM_RC_CRC_MISMATCH;
858 }
859 else
860 s=DAQ_Format_CopyBuffer(target,&HB_Buffer[bufid]);
861 HB_SemV();
862 return s;
863 }else
864 return CM_RC_RES_ERR;
865 }
866
867
868 status_code HB_WriteToPIF(HB_BUF buf_id) {
869 status_code s;
870 SM_STRSTAT status;
871 unsigned int count=0;
872 BOOL exit = FALSE;
873 rtems_event_set out;
874 // FT_piChangeAcqMode(SM_DIRECT); commented out because cannot change acq mode while a run is in progress
875 if(HB_SemP() == CM_RC_SUCCESSFUL) {
876 /* close the buffer : - end of buffer */
877
878 // PADDING 64
879 while(HB_Buffer[buf_id].len%64)
880 HB_WRITE_UINT8(buf_id,0xCA/*00*/);
881
882 while(count < PRH_VAR_HB_N_ATTEMPT_WRITE2PIF && !exit) {
883 count++;
884 status = DAQ_SaveBuffer2MM(&HB_Buffer[buf_id],FS_HK,PRH_VAR_HB_WRITE2PIF_TIMEOUT);
885 if(status != CM_RC_SUCCESSFUL) {
886 s = status;
887 OS_piTaskSuspend(PRH_VAR_HB_WAIT_ON_FAILED_ATTEMPT_WRITE2PIF);
888 }else {
889 HB_InitBuf_NoLock(buf_id);
890 exit = TRUE;
891 s = CM_RC_SUCCESSFUL;
892 }
893 }
894 if(!exit) {
895 /* loose data */
896 /* TBD: what to do here? */
897 HB_InitBuf_NoLock(buf_id);
898 }
899
900 }else
901 s=CM_RC_RES_ERR;
902 if(HB_SemV())
903 s=CM_RC_RES_ERR;
904
905 /*if(s==CM_RC_SUCCESSFUL)
906 HB_Store(buf_id,0,NULL,0);
907 */
908 if(s || !exit)
909 /*@LOG log the loose of data - status */
910 LU_INFN_LOG(LU_CRITICAL|LU_HA, LU_MASK(__FILEID__),__FILEID__,__LINE__,s);
911 return s;
912 }
913
914
  ViewVC Help
Powered by ViewVC 1.1.23