RKH
rkhtrc_record.h
Go to the documentation of this file.
1 /*
2  * --------------------------------------------------------------------------
3  *
4  * Framework RKH
5  * -------------
6  *
7  * State-machine framework for reactive embedded systems
8  *
9  * Copyright (C) 2010 Leandro Francucci.
10  * All rights reserved. Protected by international copyright laws.
11  *
12  *
13  * RKH is free software: you can redistribute it and/or modify it under the
14  * terms of the GNU General Public License as published by the Free Software
15  * Foundation, either version 3 of the License, or (at your option) any
16  * later version.
17  *
18  * RKH is distributed in the hope that it will be useful, but WITHOUT ANY
19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
21  * more details.
22  *
23  * You should have received a copy of the GNU General Public License along
24  * with RKH, see copying.txt file.
25  *
26  * Contact information:
27  * RKH site: http://vortexmakes.com/que-es/
28  * RKH GitHub: https://github.com/vortexmakes/RKH
29  * RKH Sourceforge: https://sourceforge.net/projects/rkh-reactivesys/
30  * e-mail: lf@vortexmakes.com
31  * ---------------------------------------------------------------------------
32  */
33 
40 /* -------------------------- Development history -------------------------- */
41 /*
42  * 2017.04.15 LeFr v2.4.05 Initial version
43  */
44 
45 /* -------------------------------- Authors -------------------------------- */
46 /*
47  * LeFr Leandro Francucci lf@vortexmakes.com
48  */
49 
50 /* --------------------------------- Notes --------------------------------- */
51 /* --------------------------------- Module -------------------------------- */
52 #ifndef __RKHTRC_RECORD_H__
53 #define __RKHTRC_RECORD_H__
54 
55 /* ----------------------------- Include files ----------------------------- */
56 #include "rkhtrc_stream.h"
57 
58 /* ---------------------- External C language linkage ---------------------- */
59 #ifdef __cplusplus
60 extern "C" {
61 #endif
62 
63 /* --------------------------------- Macros -------------------------------- */
64 #if RKH_CFG_TRC_EN == RKH_ENABLED
65  /* --- Memory Pool (MP) ------------------------------------------------ */
66  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
67  RKH_CFG_TRC_MP_EN == RKH_ENABLED
88  #define RKH_TR_MP_INIT(memPool_, nBlocks_, blockSize_) \
89  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_MP_INIT) \
90  RKH_TRC_SYM(memPool_); \
91  RKH_TRC_NBLK(nBlocks_); \
92  RKH_TRC_BSIZE(blockSize_); \
93  RKH_TRC_END()
94 
110  #define RKH_TR_MP_GET(memPool_, nFree_, nMin_) \
111  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_MP_GET) \
112  RKH_TRC_SYM(memPool_); \
113  RKH_TRC_NBLK(nFree_); \
114  RKH_TRC_MP_NMIN(nMin_); \
115  RKH_TRC_END_NOCRIT()
116 
128  #define RKH_TR_MP_PUT(memPool_, nFree_) \
129  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_MP_PUT) \
130  RKH_TRC_SYM(memPool_); \
131  RKH_TRC_NBLK(nFree_); \
132  RKH_TRC_END_NOCRIT()
133 
136  #else
137  #define RKH_TR_MP_INIT(memPool_, nBlocks_, blockSize_) (void)0
138  #define RKH_TR_MP_GET(memPool_, nFree_, nMin_) (void)0
139  #define RKH_TR_MP_PUT(memPool_, nFree_) (void)0
140  #endif
141 
142  /* --- Queue (QUE) ------------------------------------------------------ */
143  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || RKH_CFG_TRC_QUE_EN == RKH_ENABLED
165  #define RKH_TR_QUE_INIT(queue_, actObj_, nElem_) \
166  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_INIT) \
167  RKH_TRC_SYM(queue_); \
168  RKH_TRC_SYM(actObj_); \
169  RKH_TRC_NE(nElem_); \
170  RKH_TRC_END()
171 
183  #define RKH_TR_QUE_GET(queue_, nElem_) \
184  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_GET) \
185  RKH_TRC_SYM(queue_); \
186  RKH_TRC_NE(nElem_); \
187  RKH_TRC_END_NOCRIT()
188 
202  #define RKH_TR_QUE_FIFO(queue_, nElem_, nMin_) \
203  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_FIFO) \
204  RKH_TRC_SYM(queue_); \
205  RKH_TRC_NE(nElem_); \
206  RKH_TRC_QUE_NMIN(nMin_); \
207  RKH_TRC_END()
208 
222  #define RKH_TR_QUE_LIFO(queue_, nElem_, nMin_) \
223  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_LIFO) \
224  RKH_TRC_SYM(queue_); \
225  RKH_TRC_NE(nElem_); \
226  RKH_TRC_QUE_NMIN(nMin_); \
227  RKH_TRC_END()
228 
239  #define RKH_TR_QUE_FULL(queue_) \
240  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_FULL) \
241  RKH_TRC_SYM(queue_); \
242  RKH_TRC_END_NOCRIT()
243 
254  #define RKH_TR_QUE_DPT(queue_) \
255  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_DPT) \
256  RKH_TRC_SYM(queue_); \
257  RKH_TRC_END_NOCRIT()
258 
269  #define RKH_TR_QUE_GET_LAST(queue_) \
270  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_GET_LAST) \
271  RKH_TRC_SYM(queue_); \
272  RKH_TRC_END_NOCRIT()
273 
276  #else
277  #define RKH_TR_QUE_INIT(queue_, actObj_, nElem_) (void)0
278  #define RKH_TR_QUE_GET(queue_, nElem_) (void)0
279  #define RKH_TR_QUE_FIFO(queue_, nElem_, nMin_) (void)0
280  #define RKH_TR_QUE_LIFO(queue_, nElem_, nMin_) (void)0
281  #define RKH_TR_QUE_FULL(queue_) (void)0
282  #define RKH_TR_QUE_DPT(queue_) (void)0
283  #define RKH_TR_QUE_GET_LAST(queue_) (void)0
284  #endif
285 
286  /* --- State Machine Application (SMA) --------------------------------- */
287  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
288  RKH_CFG_TRC_SMA_EN == RKH_ENABLED
308  #define RKH_TR_SMA_ACT(actObj_, actObjPrio_, actObjQueSize_) \
309  RKH_TRC_BEGIN_WOSIG(RKH_TE_SMA_ACT, \
310  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
311  RKH_TRC_SYM(actObj_); \
312  RKH_TRC_UI8(actObjPrio_); \
313  RKH_TRC_UI8(actObjQueSize_); \
314  RKH_TRC_END()
315 
327  #define RKH_TR_SMA_TERM(actObj_, actObjPrio_) \
328  RKH_TRC_BEGIN_WOSIG(RKH_TE_SMA_TERM, \
329  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
330  RKH_TRC_SYM(actObj_); \
331  RKH_TRC_UI8(actObjPrio_); \
332  RKH_TRC_END()
333 
352  #define RKH_TR_SMA_GET(actObj_, evt_, poolID_, refCntr_, \
353  nElem_, nMin_) \
354  RKH_TRC_BEGIN(RKH_TE_SMA_GET, \
355  RKH_SMA_ACCESS_CONST(actObj_, prio), (evt_)->e) \
356  RKH_TRC_SYM(actObj_); \
357  RKH_TRC_SIG((evt_)->e); \
358  RKH_TRC_UI8(poolID_); \
359  RKH_TRC_UI8(refCntr_); \
360  RKH_TRC_NE(nElem_); \
361  RKH_TRC_QUE_NMIN(nMin_); \
362  RKH_TRC_END()
363 
382  #define RKH_TR_SMA_FIFO(actObj_, evt_, sender_, poolID_, refCntr_, \
383  nElem_, nMin_) \
384  RKH_TRC_BEGIN_NOCRIT(RKH_TE_SMA_FIFO, \
385  RKH_SMA_ACCESS_CONST(actObj_, prio), \
386  (evt_)->e) \
387  RKH_TRC_SYM(actObj_); \
388  RKH_TRC_SIG((evt_)->e); \
389  RKH_TRC_SNDR(sender_); \
390  RKH_TRC_UI8(poolID_); \
391  RKH_TRC_UI8(refCntr_); \
392  RKH_TRC_NE(nElem_); \
393  RKH_TRC_QUE_NMIN(nMin_); \
394  RKH_TRC_END_NOCRIT()
395 
414  #define RKH_TR_SMA_LIFO(actObj_, evt_, sender_, poolID_, refCntr_, \
415  nElem_, nMin_) \
416  RKH_TRC_BEGIN_NOCRIT(RKH_TE_SMA_LIFO, \
417  RKH_SMA_ACCESS_CONST(actObj_, prio), \
418  (evt_)->e) \
419  RKH_TRC_SYM(actObj_); \
420  RKH_TRC_SIG((evt_)->e); \
421  RKH_TRC_SNDR(sender_); \
422  RKH_TRC_UI8(poolID_); \
423  RKH_TRC_UI8(refCntr_); \
424  RKH_TRC_NE(nElem_); \
425  RKH_TRC_QUE_NMIN(nMin_); \
426  RKH_TRC_END_NOCRIT()
427 
439  #define RKH_TR_SMA_REG(actObj_, actObjPrio_) \
440  RKH_TRC_BEGIN_WOSIG_NOCRIT(RKH_TE_SMA_REG, \
441  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
442  RKH_TRC_SYM(actObj_); \
443  RKH_TRC_UI8(actObjPrio_); \
444  RKH_TRC_END_NOCRIT()
445 
457  #define RKH_TR_SMA_UNREG(actObj_, actObjPrio_) \
458  RKH_TRC_BEGIN_WOSIG_NOCRIT(RKH_TE_SMA_UNREG, \
459  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
460  RKH_TRC_SYM(actObj_); \
461  RKH_TRC_UI8(actObjPrio_); \
462  RKH_TRC_END_NOCRIT()
463 
475  #define RKH_TR_SMA_DEFER(queue_, evt_) \
476  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_SMA_DEFER) \
477  RKH_TRC_SYM(queue_); \
478  RKH_TRC_SIG((evt_)->e); \
479  RKH_TRC_END_NOCRIT()
480 
492  #define RKH_TR_SMA_RCALL(actObj_, evt_) \
493  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_SMA_RCALL) \
494  RKH_TRC_SYM(actObj_); \
495  RKH_TRC_SIG((evt_)->e); \
496  RKH_TRC_END_NOCRIT()
497 
500  #else
501  #define RKH_TR_SMA_ACT(actObj_, actObjPrio_, actObjQueSize_) \
502  (void)0
503  #define RKH_TR_SMA_TERM(actObj_, actObjPrio_) \
504  (void)0
505  #define RKH_TR_SMA_GET(actObj_, evt_, poolID_, refCntr_, nElem_, \
506  nMin_) \
507  (void)0
508  #define RKH_TR_SMA_FIFO(actObj_, evt_, sender_, poolID_, \
509  refCntr_, nElem_, nMin_) \
510  (void)0
511  #define RKH_TR_SMA_LIFO(actObj_, evt_, sender_, poolID_, \
512  refCntr_, nElem_, nMin_) \
513  (void)0
514  #define RKH_TR_SMA_REG(actObj_, actObjPrio_) \
515  (void)0
516  #define RKH_TR_SMA_UNREG(actObj_, actObjPrio_) \
517  (void)0
518  #define RKH_TR_SMA_DEFER(queue_, evt_) \
519  (void)0
520  #define RKH_TR_SMA_RCALL(actObj_, evt_) \
521  (void)0
522  #endif
523 
524  /* --- State machine (SM) ---------------------------------------------- */
525  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
526  RKH_CFG_TRC_SM_EN == RKH_ENABLED
545  #if RKH_CFG_TRC_SM_INIT_EN == RKH_ENABLED
546  #define RKH_TR_SM_INIT(actObj_, initState_) \
547  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_INIT, \
548  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
549  RKH_TRC_SYM(actObj_); \
550  RKH_TRC_SYM(initState_); \
551  RKH_TRC_END()
552  #else
553  #define RKH_TR_SM_INIT(actObj_, initState_) (void)0
554  #endif
555 
572  #if RKH_CFG_TRC_SM_CLRH_EN == RKH_ENABLED
573  #define RKH_TR_SM_CLRH(actObj_, history_) \
574  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_CLRH, \
575  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
576  RKH_TRC_SYM(actObj_); \
577  RKH_TRC_SYM(history_); \
578  RKH_TRC_END()
579  #else
580  #define RKH_TR_SM_CLRH(actObj_, history_) (void)0
581  #endif
582 
595  #if RKH_CFG_TRC_SM_DCH_EN == RKH_ENABLED
596  #define RKH_TR_SM_DCH(actObj_, evt_, state_) \
597  RKH_TRC_BEGIN(RKH_TE_SM_DCH, \
598  RKH_SMA_ACCESS_CONST(actObj_, prio), \
599  (evt_)->e) \
600  RKH_TRC_SYM(actObj_); \
601  RKH_TRC_SIG((evt_)->e); \
602  RKH_TRC_SYM(state_); \
603  RKH_TRC_END()
604  #else
605  #define RKH_TR_SM_DCH(actObj_, evt_, state_) (void)0
606  #endif
607 
621  #if RKH_CFG_TRC_SM_TRN_EN == RKH_ENABLED
622  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) \
623  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_TRN, \
624  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
625  RKH_TRC_SYM(actObj_); \
626  RKH_TRC_SYM(sourceState_); \
627  RKH_TRC_SYM(targetState_); \
628  RKH_TRC_END()
629  #else
630  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) (void)0
631  #endif
632 
644  #if RKH_CFG_TRC_SM_STATE_EN == RKH_ENABLED
645  #define RKH_TR_SM_STATE(actObj_, state_) \
646  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_STATE, \
647  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
648  RKH_TRC_SYM(actObj_); \
649  RKH_TRC_SYM(state_); \
650  RKH_TRC_END()
651  #else
652  #define RKH_TR_SM_STATE(actObj_, state_) (void)0
653  #endif
654 
666  #if RKH_CFG_TRC_SM_ENSTATE_EN == RKH_ENABLED
667  #define RKH_TR_SM_ENSTATE(actObj_, state_) \
668  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_ENSTATE, \
669  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
670  RKH_TRC_SYM(actObj_); \
671  RKH_TRC_SYM(state_); \
672  RKH_TRC_END()
673  #else
674  #define RKH_TR_SM_ENSTATE(actObj_, state_) (void)0
675  #endif
676 
688  #if RKH_CFG_TRC_SM_EXSTATE_EN == RKH_ENABLED
689  #define RKH_TR_SM_EXSTATE(actObj_, state_) \
690  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EXSTATE, \
691  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
692  RKH_TRC_SYM(actObj_); \
693  RKH_TRC_SYM(state_); \
694  RKH_TRC_END()
695  #else
696  #define RKH_TR_SM_EXSTATE(actObj_, state_) (void)0
697  #endif
698 
711  #if RKH_CFG_TRC_SM_NENEX_EN == RKH_ENABLED
712  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
713  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_NENEX, \
714  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
715  RKH_TRC_SYM(actObj_); \
716  RKH_TRC_UI8(nEnState_); \
717  RKH_TRC_UI8(nExState_); \
718  RKH_TRC_END()
719  #else
720  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
721  (void)nEnState_
722  #endif
723 
737  #if RKH_CFG_TRC_SM_NTRNACT_EN == RKH_ENABLED
738  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) \
739  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_NTRNACT, \
740  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
741  RKH_TRC_SYM(actObj_); \
742  RKH_TRC_UI8(nta); \
743  RKH_TRC_UI8(nts); \
744  RKH_TRC_END()
745  #else
746  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) (void)0
747  #endif
748 
760  #if RKH_CFG_TRC_SM_TS_STATE_EN == RKH_ENABLED
761  #define RKH_TR_SM_TS_STATE(actObj_, state_) \
762  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_TS_STATE, \
763  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
764  RKH_TRC_SYM(actObj_); \
765  RKH_TRC_SYM(state_); \
766  RKH_TRC_END()
767  #else
768  #define RKH_TR_SM_TS_STATE(actObj_, state_) (void)0
769  #endif
770 
771  #if RKH_CFG_TRC_SM_PROCESS_EN == RKH_ENABLED
772 
785  #define RKH_TR_SM_EVT_PROC(actObj_) \
786  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EVT_PROC, \
787  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
788  RKH_TRC_SYM(actObj_); \
789  RKH_TRC_END()
790 
803  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) \
804  RKH_TRC_BEGIN(RKH_TE_SM_EVT_NFOUND, \
805  RKH_SMA_ACCESS_CONST(actObj_, prio), \
806  (evt_)->e) \
807  RKH_TRC_SYM(actObj_); \
808  RKH_TRC_SIG((evt_)->e); \
809  RKH_TRC_END()
810 
822  #define RKH_TR_SM_GRD_FALSE(actObj_) \
823  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_GRD_FALSE, \
824  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
825  RKH_TRC_SYM(actObj_); \
826  RKH_TRC_END()
827 
840  #define RKH_TR_SM_CND_NFOUND(actObj_) \
841  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_CND_NFOUND, \
842  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
843  RKH_TRC_SYM(actObj_); \
844  RKH_TRC_END()
845 
857  #define RKH_TR_SM_UNKN_STATE(actObj_) \
858  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_UNKN_STATE, \
859  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
860  RKH_TRC_SYM(actObj_); \
861  RKH_TRC_END()
862 
874  #define RKH_TR_SM_EX_HLEVEL(actObj_) \
875  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EX_HLEVEL, \
876  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
877  RKH_TRC_SYM(actObj_); \
878  RKH_TRC_END()
879 
892  #define RKH_TR_SM_EX_TSEG(actObj_) \
893  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EX_TSEG, \
894  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
895  RKH_TRC_SYM(actObj_); \
896  RKH_TRC_END()
897  #else
898  #define RKH_TR_SM_EVT_PROC(actObj_) (void)0
899  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) (void)0
900  #define RKH_TR_SM_CND_NFOUND(actObj_) (void)0
901  #define RKH_TR_SM_GRD_FALSE(actObj_) (void)0
902  #define RKH_TR_SM_UNKN_STATE(actObj_) (void)0
903  #define RKH_TR_SM_EX_HLEVEL(actObj_) (void)0
904  #define RKH_TR_SM_EX_TSEG(actObj_) (void)0
905  #endif
906 
921  #if RKH_CFG_TRC_SM_EXE_ACT_EN == RKH_ENABLED
922  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) \
923  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EXE_ACT, \
924  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
925  RKH_TRC_UI8(actionType_); \
926  RKH_TRC_SYM(actObj_); \
927  RKH_TRC_SYM(state_); \
928  RKH_TRC_FUN(action_); \
929  RKH_TRC_END()
930  #else
931  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) (void)0
932  #endif
933 
936  #else
937  #define RKH_TR_SM_INIT(actObj_, initState_) (void)0
938  #define RKH_TR_SM_CLRH(actObj_, history_) (void)0
939  #define RKH_TR_SM_DCH(actObj_, evt_, state_) (void)0
940  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) \
941  (void)0
942  #define RKH_TR_SM_STATE(actObj_, state_) (void)0
943  #define RKH_TR_SM_ENSTATE(actObj_, state_) (void)0
944  #define RKH_TR_SM_EXSTATE(actObj_, state_) (void)0
945  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
946  (void)0
947  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) (void)0
948  #define RKH_TR_SM_TS_STATE(aaost) (void)0
949  #define RKH_TR_SM_EVT_PROC(actObj_) (void)0
950  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) (void)0
951  #define RKH_TR_SM_GRD_FALSE(actObj_) (void)0
952  #define RKH_TR_SM_CND_NFOUND(actObj_) (void)0
953  #define RKH_TR_SM_UNKN_STATE(actObj_) (void)0
954  #define RKH_TR_SM_EX_HLEVEL(actObj_) (void)0
955  #define RKH_TR_SM_EX_TSEG(actObj_) (void)0
956  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) \
957  (void)0
958  #endif
959 
960  /* --- Timer (TIM) ----------------------------------------------------- */
961  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
962  RKH_CFG_TRC_TMR_EN == RKH_ENABLED
981  #define RKH_TR_TMR_INIT(timer_, signal_) \
982  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_INIT) \
983  RKH_TRC_SYM(timer_); \
984  RKH_TRC_SIG(signal_); \
985  RKH_TRC_END_NOCRIT()
986 
1000  #define RKH_TR_TMR_START(timer_, actObj_, nTicks_, period_) \
1001  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_START) \
1002  RKH_TRC_SYM(timer_); \
1003  RKH_TRC_SYM(actObj_); \
1004  RKH_TRC_NTICK(nTicks_); \
1005  RKH_TRC_NTICK(period_); \
1006  RKH_TRC_END_NOCRIT()
1007 
1020  #define RKH_TR_TMR_STOP(timer_, nTicks_, period_) \
1021  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_STOP) \
1022  RKH_TRC_SYM(timer_); \
1023  RKH_TRC_NTICK(nTicks_); \
1024  RKH_TRC_NTICK(period_); \
1025  RKH_TRC_END_NOCRIT()
1026 
1039  #define RKH_TR_TMR_TOUT(timer_, signal_, actObj_) \
1040  RKH_TRC_BEGIN_NOCRIT(RKH_TE_TMR_TOUT, \
1041  RKH_SMA_ACCESS_CONST(actObj_, prio), \
1042  signal_) \
1043  RKH_TRC_SYM(timer_); \
1044  RKH_TRC_SIG(signal_); \
1045  RKH_TRC_SYM(actObj_); \
1046  RKH_TRC_END_NOCRIT()
1047 
1058  #define RKH_TR_TMR_REM(timer_) \
1059  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_REM) \
1060  RKH_TRC_SYM(timer_); \
1061  RKH_TRC_END_NOCRIT()
1062 
1065  #else
1066  #define RKH_TR_TMR_INIT(timer_, signal_) (void)0
1067  #define RKH_TR_TMR_START(timer_, actObj_, nTicks_, period_) (void)0
1068  #define RKH_TR_TMR_STOP(timer_, nTicks_, period_) (void)0
1069  #define RKH_TR_TMR_TOUT(timer_, signal_, actObj_) (void)0
1070  #define RKH_TR_TMR_REM(timer_) (void)0
1071  #endif
1072 
1073  /* --- Framework (RKH) ------------------------------------------------- */
1074  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
1075  RKH_CFG_TRC_FWK_EN == RKH_ENABLED
1091  #define RKH_TR_FWK_EN() \
1092  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EN) \
1093  RKH_TRC_END()
1094 
1103  #define RKH_TR_FWK_EX() \
1104  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EX) \
1105  RKH_TRC_END()
1106 
1120  #define RKH_TR_FWK_EPREG(evtPool_, storageSize_, evtSize_, \
1121  poolSize_) \
1122  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EPREG) \
1123  RKH_TRC_UI8(evtPool_); \
1124  RKH_TRC_UI32(storageSize_); \
1125  RKH_TRC_ES(evtSize_); \
1126  RKH_TRC_NBLK(poolSize_); \
1127  RKH_TRC_END()
1128 
1149  #define RKH_TR_FWK_AE(evtSize_, evt_, nUsed_, nMin_, sender_) \
1150  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_AE) \
1151  RKH_TRC_ES(evtSize_); \
1152  RKH_TRC_SIG((evt_)->e); \
1153  RKH_TRC_UI8((evt_)->pool - 1); \
1154  RKH_TRC_UI8((evt_)->nref); \
1155  RKH_TRC_NBLK(nUsed_); \
1156  RKH_TRC_MP_NMIN(nMin_); \
1157  RKH_TRC_SYM(sender_); \
1158  RKH_TRC_END()
1159 
1172  #define RKH_TR_FWK_GC(evt_, poolID_, refCnt_) \
1173  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_GC) \
1174  RKH_TRC_SIG((evt_)->e); \
1175  RKH_TRC_UI8(poolID_); \
1176  RKH_TRC_UI8(refCnt_); \
1177  RKH_TRC_END_NOCRIT()
1178 
1198  #define RKH_TR_FWK_GCR(evt_, nUsed_, nMin_, sender_) \
1199  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_GCR) \
1200  RKH_TRC_SIG((evt_)->e); \
1201  RKH_TRC_UI8((evt_)->pool - 1); \
1202  RKH_TRC_UI8((evt_)->nref); \
1203  RKH_TRC_NBLK(nUsed_); \
1204  RKH_TRC_MP_NMIN(nMin_); \
1205  RKH_TRC_SYM(sender_); \
1206  RKH_TRC_END_NOCRIT()
1207 
1208  /* --- Symbol entry table for objects -------------------------- */
1209 
1233  #define RKH_TR_FWK_OBJ(obj_) \
1234  do \
1235  { \
1236  static RKHROM char __o_n[] = # obj_; \
1237  rkh_trc_obj(RKH_TE_FWK_OBJ, (rui8_t *)obj_, \
1238  __o_n); \
1239  } \
1240  while (0)
1241 
1242  /* --- Symbol entry table for objects with name ---------------- */
1243 
1270  #define RKH_TR_FWK_OBJ_NAME(obj_, name_) \
1271  do \
1272  { \
1273  rkh_trc_obj(RKH_TE_FWK_OBJ, (rui8_t *)obj_, name_); \
1274  } \
1275  while (0)
1276 
1277  /* --- Symbol entry table for event signals -------------------- */
1278 
1312  #define RKH_TR_FWK_SIG(stateObj_) \
1313  do \
1314  { \
1315  static RKHROM char __s_n[] = # stateObj_; \
1316  rkh_trc_sig(stateObj_, __s_n); \
1317  } \
1318  while (0)
1319 
1320  /* --- Symbol entry table for functions ------------------------ */
1321 
1349  #define RKH_TR_FWK_FUN(function_) \
1350  do \
1351  { \
1352  static RKHROM char __f_n[] = #function_; \
1353  rkh_trc_obj(RKH_TE_FWK_FUN, (rui8_t *)function_, \
1354  __f_n); \
1355  } \
1356  while (0)
1357 
1379  #define RKH_TR_FWK_EXE_FUN(function_) \
1380  do \
1381  { \
1382  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_EXE_FUN) \
1383  RKH_TRC_FUN(function_); \
1384  RKH_TRC_END_WOFIL() \
1385  } \
1386  while (0)
1387 
1415  #define RKH_TR_FWK_SYNC_EVT(function_, senderObj_, receiverObj_) \
1416  do \
1417  { \
1418  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_SYNC_EVT) \
1419  RKH_TRC_FUN(function_); \
1420  RKH_TRC_SNDR(senderObj_); \
1421  RKH_TRC_SNDR(receiverObj_); \
1422  RKH_TRC_END_WOFIL() \
1423  } \
1424  while (0)
1425 
1426  /* --- Symbol entry table for user user-defined trace events --- */
1427 
1463  #define RKH_TR_FWK_TUSR(__e) \
1464  do \
1465  { \
1466  static RKHROM char __e_n[] = # __e; \
1467  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_TUSR) \
1468  RKH_TRC_TE_ID(EXTE(__e, RKH_TG_USR)); \
1469  RKH_TRC_STR(__e_n); \
1470  RKH_TRC_END_WOFIL() \
1471  RKH_TRC_FLUSH(); \
1472  } \
1473  while (0)
1474 
1475  /* --- Trace configuration ------------------------------------- */
1476 
1527  #define RKH_TR_FWK_TCFG(timeStamp_) \
1528  RKH_TRC_BEGIN_DFT(RKH_TE_FWK_TCFG) \
1529  RKH_TRC_UI16((rui16_t)RKH_VERSION_CODE); \
1530  RKH_TRC_UI32( \
1531  (rui32_t)( \
1532  ((rui32_t)RKH_CFG_SMA_TRC_SNDR_EN) | \
1533  ((rui32_t)RKH_CFG_TRC_RTFIL_EN << 1) | \
1534  ((rui32_t)RKH_CFG_TRC_USER_TRACE_EN << 2) | \
1535  ((rui32_t)RKH_CFG_TRC_ALL_EN << 3) | \
1536  ((rui32_t)RKH_CFG_TRC_MP_EN << 4) | \
1537  ((rui32_t)RKH_CFG_TRC_QUE_EN << 5) | \
1538  ((rui32_t)RKH_CFG_TRC_SMA_EN << 6) | \
1539  ((rui32_t)RKH_CFG_TRC_TMR_EN << 7) | \
1540  ((rui32_t)RKH_CFG_TRC_SM_EN << 8) | \
1541  ((rui32_t)RKH_CFG_TRC_FWK_EN << 9) | \
1542  ((rui32_t)RKH_CFG_TRC_ASSERT_EN << 10) | \
1543  ((rui32_t)RKH_CFG_QUE_GET_LWMARK_EN << 11) | \
1544  ((rui32_t)RKH_CFG_MP_GET_LWM_EN << 12) | \
1545  ((rui32_t)RKH_CFG_TRC_RTFIL_SMA_EN << 13) | \
1546  ((rui32_t)RKH_CFG_TRC_RTFIL_SIGNAL_EN << 14) | \
1547  ((rui32_t)RKH_CFG_TRC_NSEQ_EN << 15) | \
1548  ((rui32_t)RKH_CFG_TRC_TSTAMP_EN << 16) | \
1549  ((rui32_t)RKH_CFG_TRC_CHK_EN << 17))); \
1550  RKH_TRC_UI8( \
1551  (rui8_t)((RKH_CFG_FWK_SIZEOF_EVT / 8 << 4) | \
1552  RKH_CFGPORT_TRC_SIZEOF_TSTAMP / 8)); \
1553  RKH_TRC_UI8( \
1554  (rui8_t)((RKH_CFGPORT_TRC_SIZEOF_PTR / 8 << 4) | \
1555  RKH_CFG_TMR_SIZEOF_NTIMER / 8)); \
1556  RKH_TRC_UI8( \
1557  (rui8_t)((RKH_CFG_MP_SIZEOF_NBLOCK / 8 << 4) | \
1558  RKH_CFG_QUE_SIZEOF_NELEM / 8)); \
1559  RKH_TRC_UI8( \
1560  (rui8_t)(RKH_CFG_FWK_SIZEOF_EVT_SIZE / 8)); \
1561  RKH_TRC_UI8( \
1562  (rui8_t)((RKH_CFG_MP_SIZEOF_BSIZE / 8 << 4) | \
1563  RKH_CFG_FWK_MAX_EVT_POOL)); \
1564  RKH_TRC_UI16( \
1565  (rui16_t)(timeStamp_)); \
1566  RKH_TRC_END_DFT() \
1567  RKH_TRC_FLUSH()
1568 
1569  /* --- Assertion ----------------------------------------------- */
1570 
1582  #if RKH_CFG_TRC_ASSERT_EN == RKH_ENABLED
1583  #define RKH_TR_FWK_ASSERT(mod_, ln_) \
1584  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_ASSERT) \
1585  RKH_TRC_STR((RKHROM char *)mod_); \
1586  RKH_TRC_UI16((rui16_t)ln_); \
1587  RKH_TRC_END_NOCRIT() \
1588  RKH_TRC_FLUSH()
1589  #else
1590  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1591  #endif
1592 
1593  /* --- Symbol entry table for active objects ------------------- */
1594 
1622  #define RKH_TR_FWK_AO(actObj_) \
1623  do \
1624  { \
1625  rkh_trc_ao((struct RKH_SMA_T *)actObj_); \
1626  } \
1627  while (0)
1628 
1629  /* --- Symbol entry table for state objects -------------------- */
1630 
1658  #define RKH_TR_FWK_STATE(actObj_, stateObj_) \
1659  do \
1660  { \
1661  rkh_trc_state((struct RKH_SMA_T *)actObj_, \
1662  (rui8_t *)stateObj_); \
1663  } \
1664  while (0)
1665 
1666  /* --- Symbol entry table for pseudostate objects -------------- */
1667 
1696  #define RKH_TR_FWK_PSTATE(actObj_, pseudoStObj_) \
1697  do \
1698  { \
1699  rkh_trc_state((struct RKH_SMA_T *)actObj_, \
1700  (rui8_t *)pseudoStObj_); \
1701  } \
1702  while (0)
1703 
1704  /* --- Symbol entry table for timer objects -------------------- */
1705 
1727  #define RKH_TR_FWK_TIMER(timerObj_) \
1728  do \
1729  { \
1730  static RKHROM char __to_n[] = # timerObj_; \
1731  rkh_trc_obj(RKH_TE_FWK_TIMER, (rui8_t *)timerObj_, \
1732  __to_n); \
1733  } \
1734  while (0)
1735 
1736  /* --- Symbol entry table for event pool objects --------------- */
1737 
1767  #define RKH_TR_FWK_EPOOL(poolId_, poolName_) \
1768  do \
1769  { \
1770  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_EPOOL) \
1771  RKH_TRC_UI8(poolId_); \
1772  RKH_TRC_STR(poolName_); \
1773  RKH_TRC_END_WOFIL() \
1774  RKH_TRC_FLUSH(); \
1775  } \
1776  while (0)
1777 
1778  /* --- Symbol entry table for queue objects -------------------- */
1779 
1806  #define RKH_TR_FWK_QUEUE(queueObj_) \
1807  do \
1808  { \
1809  static RKHROM char __qo_n[] = #queueObj_; \
1810  rkh_trc_obj(RKH_TE_FWK_QUEUE, (rui8_t *)queueObj_, \
1811  __qo_n); \
1812  } \
1813  while (0)
1814 
1840  #define RKH_TR_FWK_ACTOR(actorObj_, nm_) \
1841  do \
1842  { \
1843  rkh_trc_obj(RKH_TE_FWK_ACTOR, (rui8_t *)actorObj_, nm_); \
1844  } \
1845  while (0)
1846 
1849  #else
1850  #define RKH_TR_FWK_EN() (void)0
1851  #define RKH_TR_FWK_EX() (void)0
1852  #define RKH_TR_FWK_EPREG(evtPool_, storageSize_, evtSize_, \
1853  poolSize_) (void)0
1854  #define RKH_TR_FWK_AE(evtSize_, evt_, nUsed_, nMin_, sndr_) (void)0
1855  #define RKH_TR_FWK_GC(evt_, poolID_, refCnt_) (void)0
1856  #define RKH_TR_FWK_GCR(evt_, nUsed_, nMin_, sndr_) (void)0
1857  #define RKH_TR_FWK_OBJ(obj_) (void)0
1858  #define RKH_TR_FWK_OBJ_NAME(obj_, name_) (void)0
1859  #define RKH_TR_FWK_SIG(stateObj_) (void)0
1860  #define RKH_TR_FWK_FUN(stateObj_) (void)0
1861  #define RKH_TR_FWK_EXE_FUN(function_) (void)0
1862  #define RKH_TR_FWK_SYNC_EVT(function_, senderObj_, \
1863  receiverObj_) (void)0
1864  #define RKH_TR_FWK_TUSR(__e) (void)0
1865  #define RKH_TR_FWK_TCFG(timeStamp_) (void)0
1866  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1867  #define RKH_TR_FWK_AO(actObj_) (void)0
1868  #define RKH_TR_FWK_STATE(actObj_, stateObj_) (void)0
1869  #define RKH_TR_FWK_PSTATE(actObj_, pseudoStObj_) (void)0
1870  #define RKH_TR_FWK_TIMER(timerObj_) (void)0
1871  #define RKH_TR_FWK_EPOOL(evtPoolObj_) (void)0
1872  #define RKH_TR_FWK_QUEUE(queueObj_) (void)0
1873  #define RKH_TR_FWK_ACTOR(actObj_, nm_) (void)0
1874  #endif
1875 #else
1876  /* --- Memory Pool (MP) -------------------------------------------- */
1877  #define RKH_TR_MP_INIT(mp, nb, bs) (void)0
1878  #define RKH_TR_MP_GET(mp, nfree, nmin) (void)0
1879  #define RKH_TR_MP_PUT(mp, nfree) (void)0
1880 
1881  /* --- Queue (QUE) -------------------------------------------------- */
1882  #define RKH_TR_QUE_INIT(q, ao, nelem) (void)0
1883  #define RKH_TR_QUE_GET(q, nelem) (void)0
1884  #define RKH_TR_QUE_FIFO(q, nelem, nmin) (void)0
1885  #define RKH_TR_QUE_LIFO(q, nelem, nmin) (void)0
1886  #define RKH_TR_QUE_FULL(q) (void)0
1887  #define RKH_TR_QUE_DPT(q) (void)0
1888  #define RKH_TR_QUE_GET_LAST(q) (void)0
1889 
1890  /* --- State Machine Application (SMA) ----------------------------- */
1891  #define RKH_TR_SMA_ACT(ao, p, s) (void)0
1892  #define RKH_TR_SMA_TERM(ao, p) (void)0
1893  #define RKH_TR_SMA_GET(ao, ev, pid, rc, ne, nm) (void)0
1894  #define RKH_TR_SMA_FIFO(ao, ev, snr, pid, rc, ne, \
1895  nm) (void)0
1896  #define RKH_TR_SMA_LIFO(ao, ev, snr, pid, rc, ne, \
1897  nm) (void)0
1898  #define RKH_TR_SMA_REG(ao, actObjPrio_) (void)0
1899  #define RKH_TR_SMA_UNREG(ao, actObjPrio_) (void)0
1900  #define RKH_TR_SMA_DEFER(queue_, evt_) (void)0
1901  #define RKH_TR_SMA_RCALL(actObj_, evt_) (void)0
1902 
1903  /* --- State machine (SM) ------------------------------------------ */
1904  #define RKH_TR_SM_INIT(ao, ist) (void)0
1905  #define RKH_TR_SM_CLRH(ao, h) (void)0
1906  #define RKH_TR_SM_DCH(ao, ev, st) (void)0
1907  #define RKH_TR_SM_TRN(ao, sst, tst) (void)0
1908  #define RKH_TR_SM_STATE(ao, st) (void)0
1909  #define RKH_TR_SM_ENSTATE(ao, st) (void)0
1910  #define RKH_TR_SM_EXSTATE(ao, st) (void)0
1911  #define RKH_TR_SM_NENEX(ao, nen, nex) (void)0
1912  #define RKH_TR_SM_NTRNACT(ao, nta, nts) (void)0
1913  #define RKH_TR_SM_TS_STATE(ao, st) (void)0
1914  #define RKH_TR_SM_EVT_PROC(ao) (void)0
1915  #define RKH_TR_SM_EVT_NFOUND(ao, ev) (void)0
1916  #define RKH_TR_SM_GRD_FALSE(ao) (void)0
1917  #define RKH_TR_SM_CND_NFOUND(ao) (void)0
1918  #define RKH_TR_SM_UNKN_STATE(ao) (void)0
1919  #define RKH_TR_SM_EX_HLEVEL(ao) (void)0
1920  #define RKH_TR_SM_EX_TSEG(ao) (void)0
1921  #define RKH_TR_SM_EXE_ACT(act_t, ao, st, act) (void)0
1922 
1923  /* --- Timer (TIM) ------------------------------------------------- */
1924  #define RKH_TR_TMR_INIT(t, sig) (void)0
1925  #define RKH_TR_TMR_START(t, ao, nt, per) (void)0
1926  #define RKH_TR_TMR_STOP(t, nt, per) (void)0
1927  #define RKH_TR_TMR_TOUT(t, sig, ao) (void)0
1928  #define RKH_TR_TMR_REM(t) (void)0
1929 
1930  /* --- Framework (RKH) --------------------------------------------- */
1931  #define RKH_TR_FWK_EN() (void)0
1932  #define RKH_TR_FWK_EX() (void)0
1933  #define RKH_TR_FWK_EPREG(ep, ss, es, poolSize_) (void)0
1934  #define RKH_TR_FWK_AE(es, ev, nUsed_, nMin_, \
1935  sndr_) (void)0
1936  #define RKH_TR_FWK_GC(ev, pid, rc) (void)0
1937  #define RKH_TR_FWK_GCR(ev, nUsed_, nMin_, sndr_) (void)0
1938  #define RKH_TR_FWK_OBJ(__o) (void)0
1939  #define RKH_TR_FWK_OBJ_NAME(__o, __n) (void)0
1940  #define RKH_TR_FWK_SIG(__s) (void)0
1941  #define RKH_TR_FWK_FUN(__f) (void)0
1942  #define RKH_TR_FWK_EXE_FUN(__f) (void)0
1943  #define RKH_TR_FWK_SYNC_EVT(fn, snr, rcr) (void)0
1944  #define RKH_TR_FWK_TUSR(__e) (void)0
1945  #define RKH_TR_FWK_TCFG(ts_hz) (void)0
1946  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1947  #define RKH_TR_FWK_AO(__ao) (void)0
1948  #define RKH_TR_FWK_STATE(__ao, __so) (void)0
1949  #define RKH_TR_FWK_PSTATE(__ao, __pso) (void)0
1950  #define RKH_TR_FWK_TIMER(__to) (void)0
1951  #define RKH_TR_FWK_EPOOL(__epo) (void)0
1952  #define RKH_TR_FWK_QUEUE(__qo) (void)0
1953  #define RKH_TR_FWK_ACTOR(actObj_, nm_) (void)0
1954 #endif
1955 
1956 /* -------------------------------- Constants ------------------------------ */
1957 /* ------------------------------- Data types ------------------------------ */
1958 /* -------------------------- External variables --------------------------- */
1959 /* -------------------------- Function prototypes -------------------------- */
1967 void rkh_trc_init(void);
1968 
1991 void rkh_trc_begin(RKH_TE_ID_T eid);
1992 
2004 void rkh_trc_end(void);
2005 
2014 void rkh_trc_clear_chk(void);
2015 
2023 void rkh_trc_u8(rui8_t d);
2024 
2032 void rkh_trc_u16(rui16_t d);
2033 
2041 void rkh_trc_u32(rui32_t d);
2042 
2050 void rkh_trc_str(const char *s);
2051 
2065 void rkh_trc_obj(RKH_TE_ID_T tre, rui8_t *obj, const char *obj_name);
2066 
2078 void rkh_trc_sig(RKH_SIG_T sig, const char *sig_name);
2079 
2090 void rkh_trc_ao(void *ao);
2091 
2103 void rkh_trc_state(void *ao, rui8_t *state);
2104 
2113 void rkh_trc_fmt_u8(rui8_t fmt, rui8_t d);
2114 
2123 void rkh_trc_fmt_u16(rui8_t fmt, rui16_t d);
2124 
2133 void rkh_trc_fmt_u32(rui8_t fmt, rui32_t d);
2134 
2142 void rkh_trc_fmt_str(const char *s);
2143 
2151 void rkh_trc_fmt_mem(rui8_t const *mem, rui8_t size);
2152 
2153 /* -------------------- External C language linkage end -------------------- */
2154 #ifdef __cplusplus
2155 }
2156 #endif
2157 
2158 /* ------------------------------ Module end ------------------------------- */
2159 #endif
2160 
2161 /* ------------------------------ End of file ------------------------------ */
RKH_SIG_T
rui8_t RKH_SIG_T
Definition: rkhevt.h:100
RKH_TE_ID_T
rui8_t RKH_TE_ID_T
Describes a trace event identification (ID).
Definition: rkhtrc_define.h:1215
rkh_trc_obj
void rkh_trc_obj(RKH_TE_ID_T tre, rui8_t *obj, const char *obj_name)
Output object symbol record.
rkh_trc_begin
void rkh_trc_begin(RKH_TE_ID_T eid)
Store the trace record header in the stream.
rkh_trc_ao
void rkh_trc_ao(void *ao)
Output active object (AO) symbol record.
rkh_trc_end
void rkh_trc_end(void)
Terminate the recorded trace event.
rkh_trc_clear_chk
void rkh_trc_clear_chk(void)
Clear to zero the trace record checksum.
rkh_trc_fmt_mem
void rkh_trc_fmt_mem(rui8_t const *mem, rui8_t size)
Output memory block of up to 255-bytes with format information.
rkh_trc_fmt_str
void rkh_trc_fmt_str(const char *s)
Store a string terminated in '\0' into the current trace event buffer with format information.
rkh_trc_str
void rkh_trc_str(const char *s)
Store a string terminated in '\0' into the current trace event buffer without format information.
rkh_trc_fmt_u8
void rkh_trc_fmt_u8(rui8_t fmt, rui8_t d)
Store a 8-bit data into the current trace event buffer with format information.
rkh_trc_u8
void rkh_trc_u8(rui8_t d)
Store a 8-bit data into the current trace event buffer without format information.
rkh_trc_init
void rkh_trc_init(void)
Initializes the RKH's trace record service.
rkh_trc_sig
void rkh_trc_sig(RKH_SIG_T sig, const char *sig_name)
Output signal symbol record.
rkh_trc_u16
void rkh_trc_u16(rui16_t d)
Store a 16-bit data into the current trace event buffer without format information.
rkh_trc_fmt_u32
void rkh_trc_fmt_u32(rui8_t fmt, rui32_t d)
Store a 32-bit data into the current trace event buffer with format information.
rkh_trc_state
void rkh_trc_state(void *ao, rui8_t *state)
Output state symbol record.
rkh_trc_u32
void rkh_trc_u32(rui32_t d)
Store a 32-bit data into the current trace event buffer without format information.
rkh_trc_fmt_u16
void rkh_trc_fmt_u16(rui8_t fmt, rui16_t d)
Store a 16-bit data into the current trace event buffer with format information.
rkhtrc_stream.h
Specifies the trace stream manager (circular buffer).