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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.1.1.1 - (hide 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 kusanagi 1.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