CORDET Framework - C2 Implementation
CrPsPktServHkSupp.c
Go to the documentation of this file.
1 
22 #include "CrPsUserConstants.h"
23 #include "CrFwUserConstants.h"
24 #include <DataPool/CrPsDp.h>
25 #include <DataPool/CrPsDpServHk.h>
29 #include <Pckt/CrFwPckt.h>
30 
31 
39 CrPsRepNum_t getHkCreateCmdOffsetSCS(void* p, CrFwCounterU4_t NFA)
40 {
41  uint32_t pos, n2val;
42  CrFwCounterU4_t N1, i;
43 
44  N1 = getHkCreateCmdN1(p);
45  pos = sizeof(TcHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+(sizeof(CrPsParamId_t)*N1) + sizeof(CrFwCounterU4_t);
46  for (i=1;i<NFA;i++)
47  {
48  pos += sizeof(CrPsRepNum_t);
49  n2val = getPcktInt(p, pos);
50  pos += sizeof(CrFwCounterU4_t) + n2val*sizeof(CrPsParamId_t);
51  }
52  return pos;
53 }
54 
62 uint32_t getHkCreateCmdOffsetN2(void* p, CrFwCounterU4_t NFA)
63 {
64  return getHkCreateCmdOffsetSCS(p, NFA)+sizeof(CrPsRepNum_t);
65 }
66 
75 uint32_t getHkCreateCmdOffsetN2ParamId(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
76 {
77  if (N2>0)
78  {
79  N2 = N2-1;
80  }
81  return getHkCreateCmdOffsetN2(p, NFA) + sizeof(CrFwCounterU4_t) + N2*sizeof(CrPsParamId_t);
82 }
83 
89 CrFwCounterU4_t getHkCreateCmdNFA(void* p)
90 {
91  uint32_t pos;
92  CrFwCounterU4_t ret;
93 
94  pos = sizeof(TcHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+(sizeof(CrPsParamId_t)*getHkCreateCmdN1(p));
95  memcpy(&ret, &((uint8_t*)p)[pos], sizeof(CrFwCounterU4_t));
96  return __builtin_bswap32(ret);
97 }
98 
104 void setHkCreateCmdNFA(void* p, CrFwCounterU4_t NFA)
105 {
106  uint32_t pos;
107 
108  pos = sizeof(TcHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+(sizeof(CrPsParamId_t)*getHkCreateCmdN1(p));
109  NFA = __builtin_bswap32(NFA);
110  memcpy(&((uint8_t*)p)[pos], &NFA, sizeof(NFA));
111 }
112 
119 CrPsParamId_t getHkCreateCmdN1ParamIdItem(void* p, CrFwCounterU4_t N)
120 {
121  CrPsParamId_t ret;
122  uint32_t pos;
123 
124  if(N>0)
125  {
126  N=N-1;
127  }
128  pos = sizeof(TcHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+(sizeof(CrPsParamId_t)*N);
129  memcpy(&ret, &((uint8_t*)p)[pos], sizeof(CrPsParamId_t));
130  return __builtin_bswap16(ret);
131 }
132 
139 void setHkCreateCmdN1ParamIdItem(void* p, CrFwCounterU4_t N, CrPsParamId_t N1ParamId)
140 {
141  uint32_t pos;
142 
143  if(N>0)
144  {
145  N=N-1;
146  }
147  pos = sizeof(TcHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+(sizeof(CrPsParamId_t)*N);
148  N1ParamId = __builtin_bswap16(N1ParamId);
149  memcpy(&((uint8_t*)p)[pos], &N1ParamId, sizeof(N1ParamId));
150 }
151 
158 CrFwCounterU4_t getHkCreateCmdN2(void* p, CrFwCounterU4_t NFA)
159 {
160  CrFwCounterU4_t ret;
161 
162  memcpy(&ret, &((uint8_t*)p)[getHkCreateCmdOffsetN2(p, NFA)], sizeof(CrFwCounterU4_t));
163  return __builtin_bswap32(ret);
164 }
165 
172 void setHkCreateCmdN2(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
173 {
174  N2 = __builtin_bswap32(N2);
175  memcpy(&((uint8_t*)p)[getHkCreateCmdOffsetN2(p, NFA)], &N2, sizeof(CrFwCounterU4_t));
176 }
177 
184 CrPsRepNum_t getHkCreateCmdSCSampleRepNumItem(void* p, CrFwCounterU4_t NFA)
185 {
186  CrPsRepNum_t ret;
187 
188  memcpy(&ret, &((uint8_t*)p)[getHkCreateCmdOffsetSCS(p, NFA)], sizeof(CrPsRepNum_t));
189  return __builtin_bswap32(ret);
190 }
191 
198 void setHkCreateCmdSCSampleRepNumItem(void* p, CrFwCounterU4_t NFA, CrPsRepNum_t SCSampleRepNum)
199 {
200  SCSampleRepNum = __builtin_bswap32(SCSampleRepNum);
201  memcpy(&((uint8_t*)p)[getHkCreateCmdOffsetSCS(p, NFA)], &SCSampleRepNum, sizeof(CrPsRepNum_t));
202 }
203 
211 CrPsParamId_t getHkCreateCmdN2ParamIdItem(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
212 {
213  CrPsParamId_t ret;
214 
215  memcpy(&ret, &((uint8_t*)p)[getHkCreateCmdOffsetN2ParamId(p, NFA, N2)], sizeof(CrPsParamId_t));
216  return __builtin_bswap16(ret);
217 }
218 
226 void setHkCreateCmdN2ParamIdItem(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2, CrPsParamId_t N2ParamId)
227 {
228 
229  N2ParamId = __builtin_bswap16(N2ParamId);
230  memcpy(&((uint8_t*)p)[getHkCreateCmdOffsetN2ParamId(p, NFA, N2)], &N2ParamId, sizeof(CrPsParamId_t));
231 }
232 
240 uint32_t getHkRepStructRepOffsetSCS(void* p, CrFwCounterU4_t NFA)
241 {
242  uint32_t pos, n2val;
243  CrFwCounterU4_t i, N1;
244 
245  N1 = getHkRepStructRepN1(p);
246  pos = sizeof(TmHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsStatus_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+sizeof(CrPsParamId_t)*N1 + sizeof(CrFwCounterU4_t);
247 
248  for (i=1;i<NFA;i++)
249  {
250  pos = pos + sizeof(CrPsRepNum_t);
251  n2val = getPcktInt(p, pos);
252  pos = pos + sizeof(CrFwCounterU4_t) + n2val*sizeof(CrPsParamId_t);
253  }
254  return pos;
255 }
256 
264 uint32_t getHkRepStructRepOffsetN2(void* p, CrFwCounterU4_t NFA)
265 {
266  return getHkRepStructRepOffsetSCS(p, NFA)+sizeof(CrPsRepNum_t);
267 }
268 
277 uint32_t getHkRepStructRepOffsetN2ParamId(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
278 {
279  if (N2>0)
280  {
281  N2 = N2-1;
282  }
283  return getHkRepStructRepOffsetN2(p, NFA) + sizeof(CrFwCounterU4_t) + N2*sizeof(CrPsParamId_t);
284 }
285 
291 CrFwCounterU4_t getHkRepStructRepNFA(void* p)
292 {
293  uint32_t pos;
294  CrFwCounterU4_t ret;
295 
296  pos = sizeof(TmHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsStatus_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+sizeof(CrPsParamId_t)*getHkRepStructRepN1(p);
297  memcpy(&ret, &((uint8_t*)p)[pos], sizeof(CrFwCounterU4_t));
298  return __builtin_bswap32(ret);
299 }
300 
306 void setHkRepStructRepNFA(void* p, CrFwCounterU4_t src)
307 {
308  uint32_t pos;
309 
310  pos = sizeof(TmHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsStatus_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+sizeof(CrPsParamId_t)*getHkRepStructRepN1(p);
311  src = __builtin_bswap32(src);
312  memcpy(&((uint8_t*)p)[pos], &src, sizeof(CrFwCounterU4_t));
313 }
314 
322 {
323  CrPsParamId_t ret;
324  uint32_t pos;
325 
326  if(N>0)
327  {
328  N=N-1;
329  }
330  pos = sizeof(TmHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsStatus_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+sizeof(CrPsParamId_t)*N;
331  memcpy(&ret, &((uint8_t*)p)[pos], sizeof(CrPsParamId_t));
332  return __builtin_bswap16(ret);
333 }
334 
341 void setHkRepStructRepN1ParamIdItem(void* p, CrFwCounterU4_t N, CrPsParamId_t src)
342 {
343  uint32_t pos;
344 
345  if(N>0)
346  {
347  N=N-1;
348  }
349  pos = sizeof(TmHeader_t)+sizeof(CrPsSid_t)+sizeof(CrPsStatus_t)+sizeof(CrPsCollectInterval_t)+sizeof(CrFwCounterU4_t)+sizeof(CrPsParamId_t)*N;
350  src = __builtin_bswap16(src);
351  memcpy(&((uint8_t*)p)[pos], &src, sizeof(CrPsParamId_t));
352 }
353 
360 CrFwCounterU4_t getHkRepStructRepN2(void* p, CrFwCounterU4_t NFA)
361 {
362  CrFwCounterU4_t ret;
363 
364  memcpy(&ret, &((uint8_t*)p)[getHkRepStructRepOffsetN2(p, NFA)], sizeof(CrFwCounterU4_t));
365  return __builtin_bswap32(ret);
366 }
367 
374 void setHkRepStructRepN2(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
375 {
376 
377  N2 = __builtin_bswap32(N2);
378  memcpy(&((uint8_t*)p)[getHkRepStructRepOffsetN2(p, NFA)], &N2, sizeof(CrFwCounterU4_t));
379 }
380 
388 {
389  CrPsRepNum_t ret;
390 
391  memcpy(&ret, &((uint8_t*)p)[getHkRepStructRepOffsetSCS(p, NFA)], sizeof(CrPsRepNum_t));
392  return __builtin_bswap32(ret);
393 }
394 
401 void setHkRepStructRepSCSampleRepNumItem(void* p, CrFwCounterU4_t NFA, CrPsRepNum_t src)
402 {
403  src = __builtin_bswap32(src);
404  memcpy(&((uint8_t*)p)[getHkRepStructRepOffsetSCS(p, NFA)], &src, sizeof(CrPsRepNum_t));
405 }
406 
414 CrPsParamId_t getHkRepStructRepN2ParamIdItem(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
415 {
416  uint16_t ret;
417 
418  memcpy(&ret, &((uint8_t*)p)[getHkRepStructRepOffsetN2ParamId(p, NFA, N2)], sizeof(CrPsParamId_t));
419  return __builtin_bswap16(ret);
420 }
421 
429 void setHkRepStructRepN2ParamIdItem(void* p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2, CrPsParamId_t src)
430 {
431  src = __builtin_bswap16(src);
432  memcpy(&((uint8_t*)p)[getHkRepStructRepOffsetN2ParamId(p, NFA, N2)], &src, sizeof(CrPsParamId_t));
433 }
434 
441 CrPsSid_t getHkDeleteCmdRepStrucIdItem(void* p, CrFwCounterU4_t N)
442 {
443  CrPsSid_t dest;
444 
445  memcpy(&dest, &((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], sizeof(CrPsSid_t));
446  return dest;
447 }
448 
455 void setHkDeleteCmdRepStrucIdItem(void* p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
456 {
457  memcpy(&((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], &RepStrucId, sizeof(CrPsSid_t));
458 }
459 
466 CrPsSid_t getHkEnableCmdRepStrucIdItem(void* p, CrFwCounterU4_t N)
467 {
468  CrPsSid_t dest;
469 
470  memcpy(&dest, &((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], sizeof(CrPsSid_t));
471  return dest;
472 }
473 
480 void setHkEnableCmdRepStrucIdItem(void* p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
481 {
482  memcpy(&((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], &RepStrucId, sizeof(CrFwCounterU4_t));
483 }
484 
491 CrPsSid_t getHkDisableCmdRepStrucIdItem(void* p, CrFwCounterU4_t N)
492 {
493  CrPsSid_t dest;
494 
495  memcpy(&dest, &((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], sizeof(CrPsSid_t));
496  return dest;
497 }
498 
505 void setHkDisableCmdRepStrucIdItem(void* p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
506 {
507  memcpy(&((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], &RepStrucId, sizeof(CrFwCounterU4_t));
508 }
509 
516 CrPsSid_t getHkRepStructCmdRepStrucIdItem(void* p, CrFwCounterU4_t N)
517 {
518  CrPsSid_t dest;
519 
520  memcpy(&dest, &((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], sizeof(CrPsSid_t));
521  return dest;
522 }
523 
530 void setHkRepStructCmdRepStrucIdItem(void* p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
531 {
532  memcpy(&((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], &RepStrucId, sizeof(CrFwCounterU4_t));
533 }
534 
541 CrPsSid_t getHkOneShotCmdRepStrucIdItem(void* p, CrFwCounterU4_t N)
542 {
543  CrPsSid_t dest;
544 
545  memcpy(&dest, &((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], sizeof(CrPsSid_t));
546  return dest;
547 }
548 
555 void setHkOneShotCmdRepStrucIdItem(void* p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
556 {
557  memcpy(&((uint8_t*)p)[sizeof(TcHeader_t)-1+sizeof(CrFwCounterU4_t)+sizeof(CrPsSid_t)*N], &RepStrucId, sizeof(CrFwCounterU4_t));
558 }
559 
566 {
567  size_t s;
568  CrPsSid_t rdlSid, rdlSlot;
569  CrFwCounterU4_t N1, N2, NFA, i;
570 
571  s=sizeof(TmHeader_t) + sizeof(CrPsSid_t) + sizeof(CrPsStatus_t) + sizeof(CrPsCollectInterval_t) + sizeof(CrFwCounterU4_t) + sizeof(CrFwCounterU4_t) + 2;
572 
573  /* look for the slot */
574  for (rdlSlot = 0; rdlSlot < HK_N_REP_DEF; rdlSlot++)
575  {
576  rdlSid = getDpsidItem(rdlSlot);
577 
578  if (sid == rdlSid)
579  break;
580  }
581 
582  N1 = getDpnSimpleItem(rdlSlot);
583  s+=N1*sizeof(CrPsParamId_t);
584 
585  NFA = getNFA(rdlSlot);
586  for(i=0;i<NFA;i++)
587  {
588  s+=sizeof(unsigned int) + sizeof(unsigned int);
589  N2 = getDplstNSampRepItem(rdlSlot*HK_MAX_N_GR + i);
590  s+=N2*sizeof(CrPsParamId_t);
591  }
592 
593  return s;
594 }
595 
596 #if 0
597 size_t getHkRepSizeFromDp(CrPsSid_t sid)
598 {
599  size_t s;
600  CrPsSid_t rdlSid, rdlSlot;
601  CrFwCounterU4_t N1, N2, NFA, i, k;
602  CrPsParamId_t N1ParamId, N2ParamId;
603  CrPsRepNum_t SCSampleRepNum, j;
604  unsigned int offset;
605 
606  /* look for the slot */
607  for (rdlSlot = 0; rdlSlot < HK_N_REP_DEF; rdlSlot++)
608  {
609  rdlSid = getDpsidItem(rdlSlot);
610 
611  if (sid == rdlSid)
612  break;
613  }
614 
615  s=sizeof(TmHeader_t) + sizeof(CrPsSid_t) + 2;
616 
617  /* Get N1 (nSimple) from data pool, the number of simple commutated data items */
618  N1 = getDpnSimpleItem(rdlSlot);
619 
620  if (N1!=0)
621  {
622  /* Get N1 parameter IDs and put the corresponding values in the out-going packet */
623  for (i=0; i<N1; i++)
624  {
625  /* Get value for N1ParamId from data pool */
626  N1ParamId = getDplstIdItem(rdlSlot*HK_MAX_N_ITEMS + i);
627  s += getDpSize(N1ParamId);
628  }
629  }
630 
631  NFA = getNFA(rdlSlot);
632 
633  if (NFA!=0)
634  {
635  offset = 0;
636 
637  for (k=0; k<NFA; k++)
638  {
639  /* Get sample repetition number (rep[1..nGroup]) */
640  SCSampleRepNum = getDplstSampleRepItem(rdlSlot*HK_MAX_N_GR + k);
641 
642  /* Get N2 (nRep[1..nGroup]) */
643  N2 = getDplstNSampRepItem(rdlSlot*HK_MAX_N_GR + k);
644 
645  for (i=0; i<SCSampleRepNum; i++)
646  {
647  for (j=0; j<N2; j++)
648  {
649  N2ParamId = getDplstIdItem(rdlSlot*HK_MAX_N_ITEMS + N1 + offset + j);
650 
651  /* Set value in out-going packet */
652  s += getDpSize(N2ParamId);
653  }
654  }
655  /* update offset */
656  offset += N2;
657  }
658  }
659  return s;
660 }
661 #endif
662 
668 size_t getHkRepSizeFromPckt(void* p)
669 {
670  size_t s, N2ParamIdSize;
671  CrFwCounterU4_t N1, NFA, N2, j, k;
672  CrPsRepNum_t SCSampleRepNum;
673  CrPsParamId_t N1ParamId, N2ParamId;
674 
675  s=sizeof(TmHeader_t) + sizeof(CrPsSid_t) + 2;
676  N1 = getHkCreateCmdN1(p);
677  for(j=1;j<=N1;j++)
678  {
679  N1ParamId = getHkCreateCmdN1ParamIdItem(p, j);
680  s+=getDpSize(N1ParamId);
681  }
682  NFA = getHkCreateCmdNFA(p);
683  for(j=1;j<=NFA;j++)
684  {
685  SCSampleRepNum = getHkCreateCmdSCSampleRepNumItem(p,j);
686  N2 = getHkCreateCmdN2(p,j);
687  for(k=1;k<=N2;k++)
688  {
689  N2ParamId = getHkCreateCmdN2ParamIdItem(p, j, k);
690  N2ParamIdSize = getDpSize(N2ParamId);
691  s+=SCSampleRepNum*N2ParamIdSize;
692  }
693  }
694  return s;
695 }
696 
697 
703 size_t getHkPcktSize(void* p)
704 {
705  size_t s;
706  CrFwServSubType_t subserv;
707  CrFwCounterU4_t j, k, N, N1, NFA, N2;
708  CrPsSid_t sid, rdlSid, N1ParamId;
709  CrFwCounterU1_t rdlSlot;
710 
711  subserv = CrFwPcktGetServSubType(p);
712 
713  switch (subserv)
714  {
715  case 1:
716  case 2:
717  s=sizeof(TcHeader_t) + sizeof(CrPsSid_t) + sizeof(CrPsCollectInterval_t) + sizeof(CrFwCounterU4_t);
718  N1 = getHkCreateCmdN1(p);
719  for(j=1;j<=N1;j++)
720  {
721  s+=sizeof(CrPsParamId_t);
722  }
723  s+=sizeof(CrFwCounterU4_t);
724  NFA = getHkCreateCmdNFA(p);
725  for(j=1;j<=NFA;j++)
726  {
727  s+=sizeof(CrPsRepNum_t) + sizeof(CrFwCounterU4_t);
728  N2 = getHkCreateCmdN2(p,j);
729  for(k=1;k<=N2;k++)
730  {
731  s+=sizeof(CrPsParamId_t);
732  }
733  }
734  return s;
735  case 3:
736  case 4:
737  s=sizeof(TcHeader_t) + sizeof(CrFwCounterU4_t);
738  N = getHkDeleteCmdN(p);
739  for(j=1;j<=N;j++)
740  {
741  s+=sizeof(CrPsSid_t);
742  }
743  return s;
744  case 5:
745  case 7:
746  s=sizeof(TcHeader_t) + sizeof(CrFwCounterU4_t);
747  N = getHkEnableCmdN(p);
748  for(j=1;j<=N;j++)
749  {
750  s+=sizeof(CrPsSid_t);
751  }
752  return s;
753  case 6:
754  case 8:
755  N = getHkDisableCmdN(p);
756  s=sizeof(TcHeader_t) + sizeof(CrFwCounterU4_t);
757  for(j=1;j<=N;j++)
758  {
759  s+=sizeof(CrPsSid_t);
760  }
761  return s;
762  case 9:
763  case 11:
764  s=sizeof(TcHeader_t) + sizeof(CrFwCounterU4_t);
765  N = getHkRepStructCmdN(p);
766  for(j=1;j<=N;j++)
767  {
768  s+=sizeof(CrPsSid_t);
769  }
770  return s;
771  case 10:
772  case 12:
773  s=sizeof(TmHeader_t) + sizeof(CrPsSid_t) + sizeof(CrPsStatus_t) + sizeof(CrPsCollectInterval_t) + sizeof(CrFwCounterU4_t);
774  N1 = getHkRepStructRepN1(p);
775  for(j=1;j<=N1;j++)
776  {
777  s+=sizeof(CrPsParamId_t);
778  }
779  s+=sizeof(CrFwCounterU4_t);
780  NFA = getHkRepStructRepNFA(p);
781  for(j=1;j<=NFA;j++)
782  {
783  s+=sizeof(CrPsRepNum_t) + sizeof(CrFwCounterU4_t);
784  N2 = getHkRepStructRepN2(p,j);
785  for(k=1;k<=N2;k++)
786  {
787  s+=sizeof(CrPsParamId_t);
788  }
789  }
790  return s;
791  case 25:
792  case 26:
793  s=sizeof(TmHeader_t) + sizeof(CrPsSid_t);
795 
796  /* look for the slot */
797  for (rdlSlot = 0; rdlSlot < HK_N_REP_DEF; rdlSlot++)
798  {
799  rdlSid = getDpsidItem(rdlSlot);
800  if (sid == rdlSid)
801  break;
802  }
803 
804  /* Get N1 (nSimple) from data pool, the number of simple commutated data items */
805  N1 = getDpnSimpleItem(rdlSlot);
806  if (N1!=0)
807  {
808  /* Get N1 parameter IDs and put the corresponding values in the out-going packet */
809  for (j=0; j<N1; j++)
810  {
811  /* Get value for N1ParamId from data pool */
812  N1ParamId = getDplstIdItem(rdlSlot*HK_MAX_N_ITEMS + j);
813  s += getDpSize(N1ParamId);
814  }
815  }
816  return s;
817  case 27:
818  case 28:
819  s=sizeof(TcHeader_t) + sizeof(CrFwCounterU4_t);
820  N = getHkRepStructCmdN(p);
821  for(j=1;j<=N;j++)
822  {
823  s+=sizeof(CrPsSid_t);
824  }
825  return s;
826  default:
827  return 0;
828  }
829 }
830 
831 /*----------------------------------------------------------------------------*/
832 
CrFwCounterU4_t getHkRepStructRepN2(void *p, CrFwCounterU4_t NFA)
Get "N2" from "HkRepStructRep" packet.
void setHkRepStructRepNFA(void *p, CrFwCounterU4_t src)
Set "NFA" in "HkRepStructRep" packet.
uint32_t CrPsRepNum_t
Type used for the Repetition Number of a packet.
void setHkEnableCmdRepStrucIdItem(void *p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
Set "RepStrucId" in "HkEnableCmd" packet.
void setHkRepStructRepSCSampleRepNumItem(void *p, CrFwCounterU4_t NFA, CrPsRepNum_t src)
Set "SCSampleRepNum" in "HkRepStructRep" packet.
CrFwCounterU4_t i
CrPsCmd5EidStart function definitions.
CrPsParamId_t getHkRepStructRepN1ParamIdItem(void *p, CrFwCounterU4_t N)
Get "N1ParamId" arrayItem from "HkRepStructRep" packet.
CrFwDiscriminant_t CrFwPcktGetDiscriminant(CrFwPckt_t pckt)
Return the discriminant of the command or report encapsulated in a packet.
void setHkRepStructCmdRepStrucIdItem(void *p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
Set "RepStrucId" in "HkRepStructCmd" packet.
CrPsSid_t getHkOneShotCmdRepStrucIdItem(void *p, CrFwCounterU4_t N)
Get "RepStrucId" from "HkOneShotCmd" packet.
unsigned char CrFwServSubType_t
Type used for the command or report sub-type.
Header file to define all user-configurable constants and types for the IASW Application.
uint16_t CrPsParamId_t
Type used for the Parameter ID of a packet.
void setHkDeleteCmdRepStrucIdItem(void *p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
Set "RepStrucId" in "HkDeleteCmd" packet.
uint32_t getPcktInt(void *p, uint32_t pos)
Generic Getter for Int Values from a Packet.
Definition: CrPsPktUtil.c:29
Interface for accessing data pool items.
CrPsSid_t getHkDeleteCmdRepStrucIdItem(void *p, CrFwCounterU4_t N)
Get "RepStrucId" from "HkDeleteCmd" packet.
static CrFwCounterU4_t getHkEnableCmdN(void *p)
Get "N" from "HkEnableCmd" packet.
void setHkDisableCmdRepStrucIdItem(void *p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
Set "RepStrucId" in "HkDisableCmd" packet.
void setHkRepStructRepN2ParamIdItem(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2, CrPsParamId_t src)
Set "N2ParamID" in "HkRepStructRep" packet.
size_t getDpSize(ParameterId_t id)
Get the size of a datapool item by identifier.
Definition: CrPsDp.c:250
Interface for creating and accessing a report or command packet.
CrPsRepNum_t getHkRepStructRepSCSampleRepNumItem(void *p, CrFwCounterU4_t NFA)
Get "SCSampleRepNum" from "HkRepStructRep" packet.
void setHkOneShotCmdRepStrucIdItem(void *p, CrFwCounterU4_t N, CrPsSid_t RepStrucId)
Set "RepStrucId" in "HkOneShotCmd" packet.
void setHkCreateCmdN1ParamIdItem(void *p, CrFwCounterU4_t N, CrPsParamId_t N1ParamId)
Set "N1ParamId" arrayItem in "HkCreateCmd" packet.
uint32_t getHkRepStructRepOffsetSCS(void *p, CrFwCounterU4_t NFA)
Get the offset of the "SCSampleRepNum" field in a HkRepStruct packet.
CrPsRepNum_t getHkCreateCmdOffsetSCS(void *p, CrFwCounterU4_t NFA)
Get the offset of the "SCSampleRepNum" field in a HkCreate packet.
size_t getHkRepSizeFromPckt(void *p)
Get the size of a HkRep Housekeeping packet.
void setHkCreateCmdN2ParamIdItem(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2, CrPsParamId_t N2ParamId)
Set "N2ParamID" in "HkCreateCmd" packet.
CrPsSid_t getHkDisableCmdRepStrucIdItem(void *p, CrFwCounterU4_t N)
Get "RepStrucId" from "HkDisableCmd" packet.
static CrFwCounterU4_t getHkDeleteCmdN(void *p)
Get "N" from "HkDeleteCmd" packet.
uint32_t getHkCreateCmdOffsetN2(void *p, CrFwCounterU4_t NFA)
Get the offset of the "N2" field in a HkCreate packet.
static CrPsSid_t getDpsidItem(int i)
Gets the value of the i-th element in the datapool array sid.
Definition: CrPsDpServHk.h:289
CrFwCounterU4_t getHkRepStructRepNFA(void *p)
Get "NFA" from "HkCreateDiagParCmd" packet.
auxiliary Interface for accessing fields in packets of service "ServHk".
uint32_t CrPsCollectInterval_t
Type used for the Collection Interval of a packet.
static CrFwCounterU4_t getHkRepStructRepN1(void *p)
Get "N1" from "HkRepStructRep" packet.
CrFwCounterU4_t getHkCreateCmdN2(void *p, CrFwCounterU4_t NFA)
Get "N2" from "HkCreateCmd" packet.
CrPsSid_t getHkRepStructCmdRepStrucIdItem(void *p, CrFwCounterU4_t N)
Get "RepStrucId" from "HkRepStructCmd" packet.
static CrFwCounterU4_t getNFA(int i)
Gets the number of super-commutated groups (NFA) from number of sample repetition numbers (rep[]) ...
Definition: CrPsDpServHk.h:140
generic Interface for accessing fields in packets.
CrPsSid_t getHkEnableCmdRepStrucIdItem(void *p, CrFwCounterU4_t N)
Get "RepStrucId" from "HkEnableCmd" packet.
void setHkRepStructRepN1ParamIdItem(void *p, CrFwCounterU4_t N, CrPsParamId_t src)
Set "N1ParamId" arrayItem in "HkRepStructRep" packet.
size_t getHkRepStructSize(CrPsSid_t sid)
Get "RepStrucSize by SID".
CrPsParamId_t getHkRepStructRepN2ParamIdItem(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Get "N2ParamID" from "HkRepStructRep" packet.
static CrFwCounterU4_t getHkRepStructCmdN(void *p)
Get "N" from "HkRepStructCmd" packet.
void setHkCreateCmdN2(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Set "N2" in "HkCreateCmd" packet.
static CrPsNumberU2_t getDplstNSampRepItem(int i)
Gets the value of the i-th element in the datapool array lstNSampRep.
Definition: CrPsDpServHk.h:409
CrFwServSubType_t CrFwPcktGetServSubType(CrFwPckt_t pckt)
Return the service sub-type of the command or report encapsulated in a packet.
static CrFwDestSrc_t dest
Destination.
size_t getHkPcktSize(void *p)
Get the size of a Housekeeping packet.
CrPsRepNum_t getHkCreateCmdSCSampleRepNumItem(void *p, CrFwCounterU4_t NFA)
Get "SCSampleRepNum" from "HkCreateCmd" packet.
#define HK_N_REP_DEF
Number of Report Definitions in the Report Definition List (maximum number of housekeeping/diagnostic...
CrPsParamId_t getHkCreateCmdN2ParamIdItem(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Get "N2ParamID" from "HkCreateCmd" packet.
uint8_t CrPsSid_t
Type used for the Parameter Report Structure ID of a packet.
uint32_t getHkCreateCmdOffsetN2ParamId(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Get the offset of the "N2ParamId" field in a HkCreate packet.
static CrFwCounterU4_t getHkDisableCmdN(void *p)
Get "N" from "HkDisableCmd" packet.
#define HK_MAX_N_GR
Maximum number of super-commutated groups in a house- keeping/diagnostic report.
static uint16_t getDplstSampleRepItem(int i)
Gets the value of the i-th element in the datapool array lstSampleRep.
Definition: CrPsDpServHk.h:439
void setHkRepStructRepN2(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Set "N2" in "HkRepStructRep" packet.
Interface for accessing fields in packets of service "ServHk".
uint32_t getHkRepStructRepOffsetN2ParamId(void *p, CrFwCounterU4_t NFA, CrFwCounterU4_t N2)
Get the offset of the "N2ParamId" field in a HkCreate packet.
uint8_t CrPsStatus_t
Type used for the Status of a packet.
void setHkCreateCmdNFA(void *p, CrFwCounterU4_t NFA)
Set "NFA" in "HkCreateCmd" packet.
static CrPsParamId_t getDplstIdItem(int i)
Gets the value of the i-th element in the datapool array lstId.
Definition: CrPsDpServHk.h:379
CrFwCounterU4_t getHkCreateCmdNFA(void *p)
Get "NFA" from "HkCreateCmd" packet.
CrPsParamId_t getHkCreateCmdN1ParamIdItem(void *p, CrFwCounterU4_t N)
Get "N1ParamId" arrayItem from "HkCreateCmd" packet.
Interface for accessing data pool items.
unsigned char CrFwCounterU1_t
Type used for unsigned integers with a "short" range.
static CrFwCounterU4_t getHkCreateCmdN1(void *p)
Get "N1" from "HkCreateCmd" packet.
void setHkCreateCmdSCSampleRepNumItem(void *p, CrFwCounterU4_t NFA, CrPsRepNum_t SCSampleRepNum)
Set "SCSampleRepNum" in "HkCreateCmd" packet.
static CrPsNumberU2_t getDpnSimpleItem(int i)
Gets the value of the i-th element in the datapool array nSimple.
Definition: CrPsDpServHk.h:469
uint32_t getHkRepStructRepOffsetN2(void *p, CrFwCounterU4_t NFA)
Get the offset of the "N2" field in a HkRepStruct packet.
P&P Software GmbH, Copyright 2012-2013, All Rights Reserved