CORDET Framework - C2 Implementation
CrPsPkt.h
Go to the documentation of this file.
1 
24 #ifndef CRPSPKT_H_
25 #define CRPSPKT_H_
26 
27 #include "CrFwUserConstants.h"
28 #include "CrPsUserConstants.h"
29 #include "Pckt/CrFwPckt.h"
30 
34 typedef struct __attribute__((packed)) _TcHeader_t {
38  uint8_t block_5[2];
39 
43  uint8_t block_18[2];
44 
48  CrFwPcktLength_t PcktDataLen;
49 
53  uint8_t block_55[1];
54 
58  CrFwServType_t ServType;
59 
63  CrFwServSubType_t ServSubType;
64 
68  CrFwDestSrc_t SrcId;
69 
70 } TcHeader_t ;
71 
75 typedef struct __attribute__((packed)) _TmHeader_t {
79  uint8_t block_5[2];
80 
84  uint8_t block_18[2];
85 
89  CrFwPcktLength_t PcktDataLen;
90 
94  uint8_t block_52[1];
95 
99  CrFwServType_t ServType;
100 
104  CrFwServSubType_t ServSubType;
105 
109  CrFwDestSrc_t DestId;
110 
114  CrFwTimeStamp_t Time;
115 
116 } TmHeader_t ;
117 
123 static inline Three_Bit_t getTcHeaderPcktVersionNmb(void* p)
124 {
125  uint16_t t;
126  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
127  t = __builtin_bswap16(t);
128  t >>= 13;
129  t &= 0x7;
130  return (Three_Bit_t)t;
131 }
132 
138 static inline void setTcHeaderPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
139 {
140  uint16_t s;
141  uint16_t t;
142  s = ((uint16_t)PcktVersionNmb << 13);
143  s &= (uint16_t)0xe000;
144  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
145  t = __builtin_bswap16(t);
146  t &= (uint16_t)~0xe000;
147  t |= s;
148  t = __builtin_bswap16(t);
149  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
150 }
151 
157 static inline One_Bit_t getTcHeaderPcktType(void* p)
158 {
159  uint16_t t;
160  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
161  t = __builtin_bswap16(t);
162  t >>= 12;
163  t &= 0x1;
164  return (One_Bit_t)t;
165 }
166 
172 static inline void setTcHeaderPcktType(void* p, One_Bit_t PcktType)
173 {
174  uint16_t s;
175  uint16_t t;
176  s = ((uint16_t)PcktType << 12);
177  s &= (uint16_t)0x1000;
178  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
179  t = __builtin_bswap16(t);
180  t &= (uint16_t)~0x1000;
181  t |= s;
182  t = __builtin_bswap16(t);
183  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
184 }
185 
191 static inline One_Bit_t getTcHeaderSecHeaderFlag(void* p)
192 {
193  uint16_t t;
194  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
195  t = __builtin_bswap16(t);
196  t >>= 11;
197  t &= 0x1;
198  return (One_Bit_t)t;
199 }
200 
206 static inline void setTcHeaderSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
207 {
208  uint16_t s;
209  uint16_t t;
210  s = ((uint16_t)SecHeaderFlag << 11);
211  s &= (uint16_t)0x800;
212  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
213  t = __builtin_bswap16(t);
214  t &= (uint16_t)~0x800;
215  t |= s;
216  t = __builtin_bswap16(t);
217  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
218 }
219 
225 static inline Eleven_Bit_t getTcHeaderAPID(void* p)
226 {
227  uint32_t t;
228  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
229  t = __builtin_bswap32(t);
230  t >>= 16;
231  t &= 0x7ff;
232  return (Eleven_Bit_t)t;
233 }
234 
240 static inline void setTcHeaderAPID(void* p, Eleven_Bit_t APID)
241 {
242  uint32_t s;
243  uint32_t t;
244  s = ((uint32_t)APID << 16);
245  s &= (uint32_t)0x7ff0000;
246  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
247  t = __builtin_bswap32(t);
248  t &= (uint32_t)~0x7ff0000;
249  t |= s;
250  t = __builtin_bswap32(t);
251  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
252 }
253 
259 static inline Two_Bit_t getTcHeaderSeqFlags(void* p)
260 {
261  uint16_t t;
262  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
263  t = __builtin_bswap16(t);
264  t >>= 14;
265  t &= 0x3;
266  return (Two_Bit_t)t;
267 }
268 
274 static inline void setTcHeaderSeqFlags(void* p, Two_Bit_t SeqFlags)
275 {
276  uint16_t s;
277  uint16_t t;
278  s = ((uint16_t)SeqFlags << 14);
279  s &= (uint16_t)0xc000;
280  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
281  t = __builtin_bswap16(t);
282  t &= (uint16_t)~0xc000;
283  t |= s;
284  t = __builtin_bswap16(t);
285  (void)memcpy(&((uint8_t*)p)[2], &t, sizeof(t));
286 }
287 
293 static inline FourTeen_Bit_t getTcHeaderSeqCount(void* p)
294 {
295  uint32_t t;
296  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
297  t = __builtin_bswap32(t);
298  t >>= 16;
299  t &= 0x3fff;
300  return (FourTeen_Bit_t)t;
301 }
302 
308 static inline void setTcHeaderSeqCount(void* p, FourTeen_Bit_t SeqCount)
309 {
310  uint32_t s;
311  uint32_t t;
312  s = ((uint32_t)SeqCount << 16);
313  s &= (uint32_t)0x3fff0000;
314  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
315  t = __builtin_bswap32(t);
316  t &= (uint32_t)~0x3fff0000;
317  t |= s;
318  t = __builtin_bswap32(t);
319  (void)memcpy(&((uint8_t*)p)[2], &t, sizeof(t));
320 }
321 
327 static inline uint16_t getTcHeaderPcktDataLen(void* p)
328 {
329  TcHeader_t* t;
330  t = (TcHeader_t*)p;
331  return __builtin_bswap16(t->PcktDataLen);
332 }
333 
339 static inline void setTcHeaderPcktDataLen(void* p, uint16_t PcktDataLen)
340 {
341  TcHeader_t* t;
342  t = (TcHeader_t*)p;
343  t->PcktDataLen = __builtin_bswap16(PcktDataLen);
344 }
345 
351 static inline Four_Bit_t getTcHeaderPUSVersion(void* p)
352 {
353  uint16_t t;
354  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
355  t = __builtin_bswap16(t);
356  t >>= 12;
357  t &= 0xf;
358  return (Four_Bit_t)t;
359 }
360 
366 static inline void setTcHeaderPUSVersion(void* p, Four_Bit_t PUSVersion)
367 {
368  uint16_t s;
369  uint16_t t;
370  s = ((uint16_t)PUSVersion << 12);
371  s &= (uint16_t)0xf000;
372  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
373  t = __builtin_bswap16(t);
374  t &= (uint16_t)~0xf000;
375  t |= s;
376  t = __builtin_bswap16(t);
377  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
378 }
379 
385 static inline One_Bit_t getTcHeaderAckAccFlag(void* p)
386 {
387  uint16_t t;
388  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
389  t = __builtin_bswap16(t);
390  t >>= 11;
391  t &= 0x1;
392  return (One_Bit_t)t;
393 }
394 
400 static inline void setTcHeaderAckAccFlag(void* p, One_Bit_t AckAccFlag)
401 {
402  uint16_t s;
403  uint16_t t;
404  s = ((uint16_t)AckAccFlag << 11);
405  s &= (uint16_t)0x800;
406  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
407  t = __builtin_bswap16(t);
408  t &= (uint16_t)~0x800;
409  t |= s;
410  t = __builtin_bswap16(t);
411  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
412 }
413 
419 static inline One_Bit_t getTcHeaderAckStartFlag(void* p)
420 {
421  uint16_t t;
422  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
423  t = __builtin_bswap16(t);
424  t >>= 10;
425  t &= 0x1;
426  return (One_Bit_t)t;
427 }
428 
434 static inline void setTcHeaderAckStartFlag(void* p, One_Bit_t AckStartFlag)
435 {
436  uint16_t s;
437  uint16_t t;
438  s = ((uint16_t)AckStartFlag << 10);
439  s &= (uint16_t)0x400;
440  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
441  t = __builtin_bswap16(t);
442  t &= (uint16_t)~0x400;
443  t |= s;
444  t = __builtin_bswap16(t);
445  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
446 }
447 
453 static inline One_Bit_t getTcHeaderAckProgFlag(void* p)
454 {
455  uint16_t t;
456  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
457  t = __builtin_bswap16(t);
458  t >>= 9;
459  t &= 0x1;
460  return (One_Bit_t)t;
461 }
462 
468 static inline void setTcHeaderAckProgFlag(void* p, One_Bit_t AckProgFlag)
469 {
470  uint16_t s;
471  uint16_t t;
472  s = ((uint16_t)AckProgFlag << 9);
473  s &= (uint16_t)0x200;
474  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
475  t = __builtin_bswap16(t);
476  t &= (uint16_t)~0x200;
477  t |= s;
478  t = __builtin_bswap16(t);
479  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
480 }
481 
487 static inline One_Bit_t getTcHeaderAckTermFlag(void* p)
488 {
489  uint16_t t;
490  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
491  t = __builtin_bswap16(t);
492  t >>= 8;
493  t &= 0x1;
494  return (One_Bit_t)t;
495 }
496 
502 static inline void setTcHeaderAckTermFlag(void* p, One_Bit_t AckTermFlag)
503 {
504  uint16_t s;
505  uint16_t t;
506  s = ((uint16_t)AckTermFlag << 8);
507  s &= (uint16_t)0x100;
508  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
509  t = __builtin_bswap16(t);
510  t &= (uint16_t)~0x100;
511  t |= s;
512  t = __builtin_bswap16(t);
513  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
514 }
515 
521 static inline uint8_t getTcHeaderServType(void* p)
522 {
523  TcHeader_t* t;
524  t = (TcHeader_t*)p;
525  return t->ServType;
526 }
527 
533 static inline void setTcHeaderServType(void* p, uint8_t ServType)
534 {
535  TcHeader_t* t;
536  t = (TcHeader_t*)p;
537  t->ServType = ServType;
538 }
539 
545 static inline uint8_t getTcHeaderServSubType(void* p)
546 {
547  TcHeader_t* t;
548  t = (TcHeader_t*)p;
549  return t->ServSubType;
550 }
551 
557 static inline void setTcHeaderServSubType(void* p, uint8_t ServSubType)
558 {
559  TcHeader_t* t;
560  t = (TcHeader_t*)p;
561  t->ServSubType = ServSubType;
562 }
563 
569 static inline uint8_t getTcHeaderSrcId(void* p)
570 {
571  TcHeader_t* t;
572  t = (TcHeader_t*)p;
573  return t->SrcId;
574 }
575 
581 static inline void setTcHeaderSrcId(void* p, uint8_t SrcId)
582 {
583  TcHeader_t* t;
584  t = (TcHeader_t*)p;
585  t->SrcId = SrcId;
586 }
587 
593 static inline Three_Bit_t getTmHeaderPcktVersionNmb(void* p)
594 {
595  uint16_t t;
596  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
597  t = __builtin_bswap16(t);
598  t >>= 13;
599  t &= 0x7;
600  return (Three_Bit_t)t;
601 }
602 
608 static inline void setTmHeaderPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
609 {
610  uint16_t s;
611  uint16_t t;
612  s = ((uint16_t)PcktVersionNmb << 13);
613  s &= (uint16_t)0xe000;
614  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
615  t = __builtin_bswap16(t);
616  t &= (uint16_t)~0xe000;
617  t |= s;
618  t = __builtin_bswap16(t);
619  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
620 }
621 
627 static inline One_Bit_t getTmHeaderPcktType(void* p)
628 {
629  uint16_t t;
630  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
631  t = __builtin_bswap16(t);
632  t >>= 12;
633  t &= 0x1;
634  return (One_Bit_t)t;
635 }
636 
642 static inline void setTmHeaderPcktType(void* p, One_Bit_t PcktType)
643 {
644  uint16_t s;
645  uint16_t t;
646  s = ((uint16_t)PcktType << 12);
647  s &= (uint16_t)0x1000;
648  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
649  t = __builtin_bswap16(t);
650  t &= (uint16_t)~0x1000;
651  t |= s;
652  t = __builtin_bswap16(t);
653  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
654 }
655 
661 static inline One_Bit_t getTmHeaderSecHeaderFlag(void* p)
662 {
663  uint16_t t;
664  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
665  t = __builtin_bswap16(t);
666  t >>= 11;
667  t &= 0x1;
668  return (One_Bit_t)t;
669 }
670 
676 static inline void setTmHeaderSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
677 {
678  uint16_t s;
679  uint16_t t;
680  s = ((uint16_t)SecHeaderFlag << 11);
681  s &= (uint16_t)0x800;
682  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
683  t = __builtin_bswap16(t);
684  t &= (uint16_t)~0x800;
685  t |= s;
686  t = __builtin_bswap16(t);
687  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
688 }
689 
695 static inline Eleven_Bit_t getTmHeaderAPID(void* p)
696 {
697  uint32_t t;
698  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
699  t = __builtin_bswap32(t);
700  t >>= 16;
701  t &= 0x7ff;
702  return (Eleven_Bit_t)t;
703 }
704 
710 static inline void setTmHeaderAPID(void* p, Eleven_Bit_t APID)
711 {
712  uint32_t s;
713  uint32_t t;
714  s = ((uint32_t)APID << 16);
715  s &= (uint32_t)0x7ff0000;
716  (void)memcpy(&t, &((uint8_t*)p)[0], sizeof(t));
717  t = __builtin_bswap32(t);
718  t &= (uint32_t)~0x7ff0000;
719  t |= s;
720  t = __builtin_bswap32(t);
721  (void)memcpy(&((uint8_t*)p)[0], &t, sizeof(t));
722 }
723 
729 static inline Two_Bit_t getTmHeaderSeqFlags(void* p)
730 {
731  uint16_t t;
732  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
733  t = __builtin_bswap16(t);
734  t >>= 14;
735  t &= 0x3;
736  return (Two_Bit_t)t;
737 }
738 
744 static inline void setTmHeaderSeqFlags(void* p, Two_Bit_t SeqFlags)
745 {
746  uint16_t s;
747  uint16_t t;
748  s = ((uint16_t)SeqFlags << 14);
749  s &= (uint16_t)0xc000;
750  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
751  t = __builtin_bswap16(t);
752  t &= (uint16_t)~0xc000;
753  t |= s;
754  t = __builtin_bswap16(t);
755  (void)memcpy(&((uint8_t*)p)[2], &t, sizeof(t));
756 }
757 
763 static inline FourTeen_Bit_t getTmHeaderSeqCount(void* p)
764 {
765  uint32_t t;
766  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
767  t = __builtin_bswap32(t);
768  t >>= 16;
769  t &= 0x3fff;
770  return (FourTeen_Bit_t)t;
771 }
772 
778 static inline void setTmHeaderSeqCount(void* p, FourTeen_Bit_t SeqCount)
779 {
780  uint32_t s;
781  uint32_t t;
782  s = ((uint32_t)SeqCount << 16);
783  s &= (uint32_t)0x3fff0000;
784  (void)memcpy(&t, &((uint8_t*)p)[2], sizeof(t));
785  t = __builtin_bswap32(t);
786  t &= (uint32_t)~0x3fff0000;
787  t |= s;
788  t = __builtin_bswap32(t);
789  (void)memcpy(&((uint8_t*)p)[2], &t, sizeof(t));
790 }
791 
797 static inline uint16_t getTmHeaderPcktDataLen(void* p)
798 {
799  TmHeader_t* t;
800  t = (TmHeader_t*)p;
801  return __builtin_bswap16(t->PcktDataLen);
802 }
803 
809 static inline void setTmHeaderPcktDataLen(void* p, uint16_t PcktDataLen)
810 {
811  TmHeader_t* t;
812  t = (TmHeader_t*)p;
813  t->PcktDataLen = __builtin_bswap16(PcktDataLen);
814 }
815 
821 static inline Four_Bit_t getTmHeaderPUSVersion(void* p)
822 {
823  uint16_t t;
824  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
825  t = __builtin_bswap16(t);
826  t >>= 12;
827  t &= 0xf;
828  return (Four_Bit_t)t;
829 }
830 
836 static inline void setTmHeaderPUSVersion(void* p, Four_Bit_t PUSVersion)
837 {
838  uint16_t s;
839  uint16_t t;
840  s = ((uint16_t)PUSVersion << 12);
841  s &= (uint16_t)0xf000;
842  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
843  t = __builtin_bswap16(t);
844  t &= (uint16_t)~0xf000;
845  t |= s;
846  t = __builtin_bswap16(t);
847  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
848 }
849 
855 static inline Four_Bit_t getTmHeaderSpaceTimeRefStatus(void* p)
856 {
857  uint16_t t;
858  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
859  t = __builtin_bswap16(t);
860  t >>= 8;
861  t &= 0xf;
862  return (Four_Bit_t)t;
863 }
864 
871 static inline void setTmHeaderSpaceTimeRefStatus(void* p, Four_Bit_t SpaceTimeRefStatus)
872 {
873  uint16_t s;
874  uint16_t t;
875  s = ((uint16_t)SpaceTimeRefStatus << 8);
876  s &= (uint16_t)0xf00;
877  (void)memcpy(&t, &((uint8_t*)p)[6], sizeof(t));
878  t = __builtin_bswap16(t);
879  t &= (uint16_t)~0xf00;
880  t |= s;
881  t = __builtin_bswap16(t);
882  (void)memcpy(&((uint8_t*)p)[6], &t, sizeof(t));
883 }
884 
890 static inline uint8_t getTmHeaderServType(void* p)
891 {
892  TmHeader_t* t;
893  t = (TmHeader_t*)p;
894  return t->ServType;
895 }
896 
902 static inline void setTmHeaderServType(void* p, uint8_t ServType)
903 {
904  TmHeader_t* t;
905  t = (TmHeader_t*)p;
906  t->ServType = ServType;
907 }
908 
914 static inline uint8_t getTmHeaderServSubType(void* p)
915 {
916  TmHeader_t* t;
917  t = (TmHeader_t*)p;
918  return t->ServSubType;
919 }
920 
926 static inline void setTmHeaderServSubType(void* p, uint8_t ServSubType)
927 {
928  TmHeader_t* t;
929  t = (TmHeader_t*)p;
930  t->ServSubType = ServSubType;
931 }
932 
938 static inline uint8_t getTmHeaderDestId(void* p)
939 {
940  TmHeader_t* t;
941  t = (TmHeader_t*)p;
942  return t->DestId;
943 }
944 
950 static inline void setTmHeaderDestId(void* p, uint8_t DestId)
951 {
952  TmHeader_t* t;
953  t = (TmHeader_t*)p;
954  t->DestId = DestId;
955 }
956 
962 static inline uint8_t* getTmHeaderTimeArray(void* p)
963 {
964  TmHeader_t* t;
965  t = (TmHeader_t*)p;
966  return &t->Time.t[0];
967 }
968 
974 static inline void getTmHeaderTime(void* p, void* dest)
975 {
976  TmHeader_t* t;
977  t = (TmHeader_t*)p;
978  memcpy(dest, &t->Time.t[0], sizeof(t->Time));
979 }
980 
986 static inline void setTmHeaderTime(void* p, const void* src)
987 {
988  TmHeader_t* t;
989  t = (TmHeader_t*)p;
990  memcpy(&t->Time.t[0], src, sizeof(t->Time));
991 }
992 
993 
994 
995 static inline uint16_t CrFwPcktGetSeqCtrl(CrFwPckt_t pckt)
996 {
997  uint32_t seqflags, seqcount;
998 
999  if (CrFwPcktGetCmdRepType(pckt) == crRepType)
1000  {
1001  seqflags = getTmHeaderSeqFlags(pckt);
1002  seqcount = getTmHeaderSeqCount(pckt);
1003  }
1004  else
1005  {
1006  seqflags = getTcHeaderSeqFlags(pckt);
1007  seqcount = getTcHeaderSeqCount(pckt);
1008  }
1009 
1010  return ((seqflags << 14) & 0xc000) | (seqcount & 0x3fff);
1011 }
1012 
1013 
1014 static inline void CrFwPcktSetSeqCtrl(CrFwPckt_t pckt, uint16_t psc)
1015 {
1016  uint32_t seqflags, seqcount;
1017 
1018  seqflags = ((psc & 0xc000)>>14)&0x0003;
1019  seqcount = psc & 0x3fff;
1020 
1021  if (CrFwPcktGetCmdRepType(pckt) == crRepType)
1022  {
1023  setTmHeaderSeqFlags(pckt, seqflags);
1024  setTmHeaderSeqCount(pckt, seqcount);
1025  }
1026  else
1027  {
1028  setTmHeaderSeqFlags(pckt, seqflags);
1029  setTmHeaderSeqCount(pckt, seqcount);
1030  }
1031 
1032  return;
1033 }
1034 
1035 
1036 static inline uint16_t CrFwPcktGetApid(CrFwPckt_t pckt)
1037 {
1038  if (CrFwPcktGetCmdRepType(pckt) == crRepType)
1039  {
1040  return getTmHeaderAPID(pckt);
1041  }
1042  else
1043  {
1044  return getTcHeaderAPID(pckt);
1045  }
1046 }
1047 
1048 
1049 static inline void CrFwPcktSetApid(CrFwPckt_t pckt, uint16_t apid)
1050 {
1051  if (CrFwPcktGetCmdRepType(pckt) == crRepType)
1052  {
1053  setTmHeaderAPID(pckt, apid);
1054  }
1055  else
1056  {
1057  setTcHeaderAPID(pckt, apid);
1058  }
1059 }
1060 
1061 
1067 static inline CrPsRid_t getPcktRid(void* p)
1068 {
1069  CrPsRid_t ret;
1070  memcpy(&ret, &((uint8_t*)p)[0], sizeof(CrPsRid_t));
1071  return __builtin_bswap32(ret);
1072 }
1073 
1079 static inline void setPcktRid(void* p, CrPsRid_t Rid)
1080 {
1081  Rid = __builtin_bswap32(Rid);
1082  memcpy(&((uint8_t*)p)[0], &Rid, sizeof(CrPsRid_t));
1083 }
1084 
1085 /*----------------------------------------------------------------------------*/
1086 #endif /* CRPSPKT_H */
static uint8_t * getTmHeaderTimeArray(void *p)
Get pointer to "Time" array from "TmHeader" packet.
Definition: CrPsPkt.h:962
static void setTcHeaderAckTermFlag(void *p, One_Bit_t AckTermFlag)
Set "AckTermFlag" in "TcHeader" packet.
Definition: CrPsPkt.h:502
static void setTcHeaderSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "TcHeader" packet.
Definition: CrPsPkt.h:274
static Two_Bit_t getTcHeaderSeqFlags(void *p)
Get "SeqFlags" from "TcHeader" packet.
Definition: CrPsPkt.h:259
static void setTmHeaderSpaceTimeRefStatus(void *p, Four_Bit_t SpaceTimeRefStatus)
Set "SpaceTimeRefStatus" in "TmHeader" packet.
Definition: CrPsPkt.h:871
static Four_Bit_t getTmHeaderSpaceTimeRefStatus(void *p)
Get "SpaceTimeRefStatus" from "TmHeader" packet.
Definition: CrPsPkt.h:855
static void setTcHeaderPcktDataLen(void *p, uint16_t PcktDataLen)
Set "PcktDataLen" in "TcHeader" packet.
Definition: CrPsPkt.h:339
Report type.
Definition: CrFwConstants.h:43
static One_Bit_t getTcHeaderAckStartFlag(void *p)
Get "AckStartFlag" from "TcHeader" packet.
Definition: CrPsPkt.h:419
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.
CrFwCmdRepType_t CrFwPcktGetCmdRepType(CrFwPckt_t pckt)
Return the type of a packet (either a command packet or a report packet).
static void setTmHeaderServSubType(void *p, uint8_t ServSubType)
Set "ServSubType" in "TmHeader" packet.
Definition: CrPsPkt.h:926
static void setTmHeaderTime(void *p, const void *src)
Set "Time" array in "TmHeader" packet.
Definition: CrPsPkt.h:986
unsigned char CrFwDestSrc_t
Type used for the command or report destination and source.
Interface for creating and accessing a report or command packet.
static One_Bit_t getTmHeaderPcktType(void *p)
Get "PcktType" from "TmHeader" packet.
Definition: CrPsPkt.h:627
static FourTeen_Bit_t getTmHeaderSeqCount(void *p)
Get "SeqCount" from "TmHeader" packet.
Definition: CrPsPkt.h:763
static void getTmHeaderTime(void *p, void *dest)
Get "Time" array from "TmHeader" packet.
Definition: CrPsPkt.h:974
static void setTmHeaderAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "TmHeader" packet.
Definition: CrPsPkt.h:710
static One_Bit_t getTcHeaderSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "TcHeader" packet.
Definition: CrPsPkt.h:191
unsigned char CrFwServType_t
Type used for the service type of a command or report.
static void setTcHeaderAckProgFlag(void *p, One_Bit_t AckProgFlag)
Set "AckProgFlag" in "TcHeader" packet.
Definition: CrPsPkt.h:468
static One_Bit_t getTcHeaderAckTermFlag(void *p)
Get "AckTermFlag" from "TcHeader" packet.
Definition: CrPsPkt.h:487
static Three_Bit_t getTmHeaderPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "TmHeader" packet.
Definition: CrPsPkt.h:593
static void setTcHeaderSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "TcHeader" packet.
Definition: CrPsPkt.h:206
static void setTmHeaderDestId(void *p, uint8_t DestId)
Set "DestId" in "TmHeader" packet.
Definition: CrPsPkt.h:950
static void setTmHeaderPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "TmHeader" packet.
Definition: CrPsPkt.h:608
static void setTmHeaderSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "TmHeader" packet.
Definition: CrPsPkt.h:744
static Four_Bit_t getTmHeaderPUSVersion(void *p)
Get "PUSVersion" from "TmHeader" packet.
Definition: CrPsPkt.h:821
unsigned short int CrFwPcktLength_t
Type for the packet length.
static One_Bit_t getTmHeaderSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "TmHeader" packet.
Definition: CrPsPkt.h:661
static void setTcHeaderSrcId(void *p, uint8_t SrcId)
Set "SrcId" in "TcHeader" packet.
Definition: CrPsPkt.h:581
static Eleven_Bit_t getTmHeaderAPID(void *p)
Get "APID" from "TmHeader" packet.
Definition: CrPsPkt.h:695
static uint8_t getTcHeaderSrcId(void *p)
Get "SrcId" from "TcHeader" packet.
Definition: CrPsPkt.h:569
static void setTmHeaderPUSVersion(void *p, Four_Bit_t PUSVersion)
Set "PUSVersion" in "TmHeader" packet.
Definition: CrPsPkt.h:836
static Eleven_Bit_t getTcHeaderAPID(void *p)
Get "APID" from "TcHeader" packet.
Definition: CrPsPkt.h:225
static void setTcHeaderPUSVersion(void *p, Four_Bit_t PUSVersion)
Set "PUSVersion" in "TcHeader" packet.
Definition: CrPsPkt.h:366
static uint8_t getTmHeaderDestId(void *p)
Get "DestId" from "TmHeader" packet.
Definition: CrPsPkt.h:938
static uint8_t getTcHeaderServSubType(void *p)
Get "ServSubType" from "TcHeader" packet.
Definition: CrPsPkt.h:545
static One_Bit_t getTcHeaderAckProgFlag(void *p)
Get "AckProgFlag" from "TcHeader" packet.
Definition: CrPsPkt.h:453
struct __attribute__((packed)) _TcHeader_t
Structure for TcHeader.
Definition: CrPsPkt.h:34
static void setTmHeaderServType(void *p, uint8_t ServType)
Set "ServType" in "TmHeader" packet.
Definition: CrPsPkt.h:902
static uint16_t getTcHeaderPcktDataLen(void *p)
Get "PcktDataLen" from "TcHeader" packet.
Definition: CrPsPkt.h:327
static void setTcHeaderAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "TcHeader" packet.
Definition: CrPsPkt.h:240
static uint8_t getTcHeaderServType(void *p)
Get "ServType" from "TcHeader" packet.
Definition: CrPsPkt.h:521
static CrFwDestSrc_t dest
Destination.
static FourTeen_Bit_t getTcHeaderSeqCount(void *p)
Get "SeqCount" from "TcHeader" packet.
Definition: CrPsPkt.h:293
static Four_Bit_t getTcHeaderPUSVersion(void *p)
Get "PUSVersion" from "TcHeader" packet.
Definition: CrPsPkt.h:351
static One_Bit_t getTcHeaderPcktType(void *p)
Get "PcktType" from "TcHeader" packet.
Definition: CrPsPkt.h:157
static uint8_t getTmHeaderServType(void *p)
Get "ServType" from "TmHeader" packet.
Definition: CrPsPkt.h:890
char * CrFwPckt_t
Type for packets (see CrFwPckt.h).
Definition: CrFwConstants.h:36
static void setTcHeaderAckAccFlag(void *p, One_Bit_t AckAccFlag)
Set "AckAccFlag" in "TcHeader" packet.
Definition: CrPsPkt.h:400
static void setTcHeaderPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "TcHeader" packet.
Definition: CrPsPkt.h:138
static CrPsRid_t getPcktRid(void *p)
Getter for the RequestId from a packet.
Definition: CrPsPkt.h:1067
static Two_Bit_t getTmHeaderSeqFlags(void *p)
Get "SeqFlags" from "TmHeader" packet.
Definition: CrPsPkt.h:729
static void setTmHeaderSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "TmHeader" packet.
Definition: CrPsPkt.h:676
static void setTcHeaderServType(void *p, uint8_t ServType)
Set "ServType" in "TcHeader" packet.
Definition: CrPsPkt.h:533
static void setTcHeaderPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "TcHeader" packet.
Definition: CrPsPkt.h:172
static void setTmHeaderPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "TmHeader" packet.
Definition: CrPsPkt.h:642
static void setTcHeaderServSubType(void *p, uint8_t ServSubType)
Set "ServSubType" in "TcHeader" packet.
Definition: CrPsPkt.h:557
static void setTcHeaderAckStartFlag(void *p, One_Bit_t AckStartFlag)
Set "AckStartFlag" in "TcHeader" packet.
Definition: CrPsPkt.h:434
static void setTmHeaderSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "TmHeader" packet.
Definition: CrPsPkt.h:778
static uint8_t getTmHeaderServSubType(void *p)
Get "ServSubType" from "TmHeader" packet.
Definition: CrPsPkt.h:914
static void setPcktRid(void *p, CrPsRid_t Rid)
Setter for the RequestId from a packet.
Definition: CrPsPkt.h:1079
static uint16_t getTmHeaderPcktDataLen(void *p)
Get "PcktDataLen" from "TmHeader" packet.
Definition: CrPsPkt.h:797
static void setTcHeaderSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "TcHeader" packet.
Definition: CrPsPkt.h:308
static Three_Bit_t getTcHeaderPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "TcHeader" packet.
Definition: CrPsPkt.h:123
static One_Bit_t getTcHeaderAckAccFlag(void *p)
Get "AckAccFlag" from "TcHeader" packet.
Definition: CrPsPkt.h:385
static void setTmHeaderPcktDataLen(void *p, uint16_t PcktDataLen)
Set "PcktDataLen" in "TmHeader" packet.
Definition: CrPsPkt.h:809
unsigned int CrFwTimeStamp_t
Type used for the time stamp of a command or report.
P&P Software GmbH, Copyright 2012-2013, All Rights Reserved