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 web site: http://sourceforge.net/projects/rkh-reactivesys/
28  * e-mail: francuccilea@gmail.com
29  * ---------------------------------------------------------------------------
30  */
31 
38 /* -------------------------- Development history -------------------------- */
39 /*
40  * 2017.04.15 LeFr v2.4.05 Initial version
41  */
42 
43 /* -------------------------------- Authors -------------------------------- */
44 /*
45  * LeFr Leandro Francucci francuccilea@gmail.com
46  */
47 
48 /* --------------------------------- Notes --------------------------------- */
49 /* --------------------------------- Module -------------------------------- */
50 #ifndef __RKHTRC_RECORD_H__
51 #define __RKHTRC_RECORD_H__
52 
53 /* ----------------------------- Include files ----------------------------- */
54 #include "rkhtrc_stream.h"
55 
56 /* ---------------------- External C language linkage ---------------------- */
57 #ifdef __cplusplus
58 extern "C" {
59 #endif
60 
61 /* --------------------------------- Macros -------------------------------- */
62 #if RKH_CFG_TRC_EN == RKH_ENABLED
63  /* --- Memory Pool (MP) ------------------------------------------------ */
64  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
65  RKH_CFG_TRC_MP_EN == RKH_ENABLED
66 
86  #define RKH_TR_MP_INIT(memPool_, nBlocks_, blockSize_) \
87  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_MP_INIT) \
88  RKH_TRC_SYM(memPool_); \
89  RKH_TRC_NBLK(nBlocks_); \
90  RKH_TRC_BSIZE(blockSize_); \
91  RKH_TRC_END()
92 
108  #define RKH_TR_MP_GET(memPool_, nFree_, nMin_) \
109  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_MP_GET) \
110  RKH_TRC_SYM(memPool_); \
111  RKH_TRC_NBLK(nFree_); \
112  RKH_TRC_MP_NMIN(nMin_); \
113  RKH_TRC_END_NOCRIT()
114 
126  #define RKH_TR_MP_PUT(memPool_, nFree_) \
127  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_MP_PUT) \
128  RKH_TRC_SYM(memPool_); \
129  RKH_TRC_NBLK(nFree_); \
130  RKH_TRC_END_NOCRIT()
131 
134  #else
135  #define RKH_TR_MP_INIT(memPool_, nBlocks_, blockSize_) (void)0
136  #define RKH_TR_MP_GET(memPool_, nFree_, nMin_) (void)0
137  #define RKH_TR_MP_PUT(memPool_, nFree_) (void)0
138  #endif
139 
140  /* --- Queue (QUE) ------------------------------------------------------ */
141  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || RKH_CFG_TRC_QUE_EN == RKH_ENABLED
142 
163  #define RKH_TR_QUE_INIT(queue_, actObj_, nElem_) \
164  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_INIT) \
165  RKH_TRC_SYM(queue_); \
166  RKH_TRC_SYM(actObj_); \
167  RKH_TRC_NE(nElem_); \
168  RKH_TRC_END()
169 
181  #define RKH_TR_QUE_GET(queue_, nElem_) \
182  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_GET) \
183  RKH_TRC_SYM(queue_); \
184  RKH_TRC_NE(nElem_); \
185  RKH_TRC_END_NOCRIT()
186 
200  #define RKH_TR_QUE_FIFO(queue_, nElem_, nMin_) \
201  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_FIFO) \
202  RKH_TRC_SYM(queue_); \
203  RKH_TRC_NE(nElem_); \
204  RKH_TRC_QUE_NMIN(nMin_); \
205  RKH_TRC_END()
206 
220  #define RKH_TR_QUE_LIFO(queue_, nElem_, nMin_) \
221  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_QUE_LIFO) \
222  RKH_TRC_SYM(queue_); \
223  RKH_TRC_NE(nElem_); \
224  RKH_TRC_QUE_NMIN(nMin_); \
225  RKH_TRC_END()
226 
237  #define RKH_TR_QUE_FULL(queue_) \
238  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_FULL) \
239  RKH_TRC_SYM(queue_); \
240  RKH_TRC_END_NOCRIT()
241 
252  #define RKH_TR_QUE_DPT(queue_) \
253  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_DPT) \
254  RKH_TRC_SYM(queue_); \
255  RKH_TRC_END_NOCRIT()
256 
267  #define RKH_TR_QUE_GET_LAST(queue_) \
268  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_QUE_GET_LAST) \
269  RKH_TRC_SYM(queue_); \
270  RKH_TRC_END_NOCRIT()
271 
274  #else
275  #define RKH_TR_QUE_INIT(queue_, actObj_, nElem_) (void)0
276  #define RKH_TR_QUE_GET(queue_, nElem_) (void)0
277  #define RKH_TR_QUE_FIFO(queue_, nElem_, nMin_) (void)0
278  #define RKH_TR_QUE_LIFO(queue_, nElem_, nMin_) (void)0
279  #define RKH_TR_QUE_FULL(queue_) (void)0
280  #define RKH_TR_QUE_DPT(queue_) (void)0
281  #define RKH_TR_QUE_GET_LAST(queue_) (void)0
282  #endif
283 
284  /* --- State Machine Application (SMA) --------------------------------- */
285  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
286  RKH_CFG_TRC_SMA_EN == RKH_ENABLED
287 
306  #define RKH_TR_SMA_ACT(actObj_, actObjPrio_, actObjQueSize_) \
307  RKH_TRC_BEGIN_WOSIG(RKH_TE_SMA_ACT, \
308  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
309  RKH_TRC_SYM(actObj_); \
310  RKH_TRC_UI8(actObjPrio_); \
311  RKH_TRC_UI8(actObjQueSize_); \
312  RKH_TRC_END()
313 
325  #define RKH_TR_SMA_TERM(actObj_, actObjPrio_) \
326  RKH_TRC_BEGIN_WOSIG(RKH_TE_SMA_TERM, \
327  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
328  RKH_TRC_SYM(actObj_); \
329  RKH_TRC_UI8(actObjPrio_); \
330  RKH_TRC_END()
331 
350  #define RKH_TR_SMA_GET(actObj_, evt_, poolID_, refCntr_, \
351  nElem_, nMin_) \
352  RKH_TRC_BEGIN(RKH_TE_SMA_GET, \
353  RKH_SMA_ACCESS_CONST(actObj_, prio), (evt_)->e) \
354  RKH_TRC_SYM(actObj_); \
355  RKH_TRC_SIG((evt_)->e); \
356  RKH_TRC_UI8(poolID_); \
357  RKH_TRC_UI8(refCntr_); \
358  RKH_TRC_NE(nElem_); \
359  RKH_TRC_QUE_NMIN(nMin_); \
360  RKH_TRC_END()
361 
380  #define RKH_TR_SMA_FIFO(actObj_, evt_, sender_, poolID_, refCntr_, \
381  nElem_, nMin_) \
382  RKH_TRC_BEGIN_NOCRIT(RKH_TE_SMA_FIFO, \
383  RKH_SMA_ACCESS_CONST(actObj_, prio), \
384  (evt_)->e) \
385  RKH_TRC_SYM(actObj_); \
386  RKH_TRC_SIG((evt_)->e); \
387  RKH_TRC_SNDR(sender_); \
388  RKH_TRC_UI8(poolID_); \
389  RKH_TRC_UI8(refCntr_); \
390  RKH_TRC_NE(nElem_); \
391  RKH_TRC_QUE_NMIN(nMin_); \
392  RKH_TRC_END_NOCRIT()
393 
412  #define RKH_TR_SMA_LIFO(actObj_, evt_, sender_, poolID_, refCntr_, \
413  nElem_, nMin_) \
414  RKH_TRC_BEGIN_NOCRIT(RKH_TE_SMA_LIFO, \
415  RKH_SMA_ACCESS_CONST(actObj_, prio), \
416  (evt_)->e) \
417  RKH_TRC_SYM(actObj_); \
418  RKH_TRC_SIG((evt_)->e); \
419  RKH_TRC_SNDR(sender_); \
420  RKH_TRC_UI8(poolID_); \
421  RKH_TRC_UI8(refCntr_); \
422  RKH_TRC_NE(nElem_); \
423  RKH_TRC_QUE_NMIN(nMin_); \
424  RKH_TRC_END_NOCRIT()
425 
437  #define RKH_TR_SMA_REG(actObj_, actObjPrio_) \
438  RKH_TRC_BEGIN_WOSIG_NOCRIT(RKH_TE_SMA_REG, \
439  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
440  RKH_TRC_SYM(actObj_); \
441  RKH_TRC_UI8(actObjPrio_); \
442  RKH_TRC_END_NOCRIT()
443 
455  #define RKH_TR_SMA_UNREG(actObj_, actObjPrio_) \
456  RKH_TRC_BEGIN_WOSIG_NOCRIT(RKH_TE_SMA_UNREG, \
457  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
458  RKH_TRC_SYM(actObj_); \
459  RKH_TRC_UI8(actObjPrio_); \
460  RKH_TRC_END_NOCRIT()
461 
473  #define RKH_TR_SMA_DEFER(queue_, evt_) \
474  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_SMA_DEFER) \
475  RKH_TRC_SYM(queue_); \
476  RKH_TRC_SIG((evt_)->e); \
477  RKH_TRC_END_NOCRIT()
478 
490  #define RKH_TR_SMA_RCALL(actObj_, evt_) \
491  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_SMA_RCALL) \
492  RKH_TRC_SYM(actObj_); \
493  RKH_TRC_SIG((evt_)->e); \
494  RKH_TRC_END_NOCRIT()
495 
498  #else
499  #define RKH_TR_SMA_ACT(actObj_, actObjPrio_, actObjQueSize_) \
500  (void)0
501  #define RKH_TR_SMA_TERM(actObj_, actObjPrio_) \
502  (void)0
503  #define RKH_TR_SMA_GET(actObj_, evt_, poolID_, refCntr_, nElem_, \
504  nMin_) \
505  (void)0
506  #define RKH_TR_SMA_FIFO(actObj_, evt_, sender_, poolID_, \
507  refCntr_, nElem_, nMin_) \
508  (void)0
509  #define RKH_TR_SMA_LIFO(actObj_, evt_, sender_, poolID_, \
510  refCntr_, nElem_, nMin_) \
511  (void)0
512  #define RKH_TR_SMA_REG(actObj_, actObjPrio_) \
513  (void)0
514  #define RKH_TR_SMA_UNREG(actObj_, actObjPrio_) \
515  (void)0
516  #define RKH_TR_SMA_DEFER(queue_, evt_) \
517  (void)0
518  #define RKH_TR_SMA_RCALL(actObj_, evt_) \
519  (void)0
520  #endif
521 
522  /* --- State machine (SM) ---------------------------------------------- */
523  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
524  RKH_CFG_TRC_SM_EN == RKH_ENABLED
525 
543  #if RKH_CFG_TRC_SM_INIT_EN == RKH_ENABLED
544  #define RKH_TR_SM_INIT(actObj_, initState_) \
545  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_INIT, \
546  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
547  RKH_TRC_SYM(actObj_); \
548  RKH_TRC_SYM(initState_); \
549  RKH_TRC_END()
550  #else
551  #define RKH_TR_SM_INIT(actObj_, initState_) (void)0
552  #endif
553 
570  #if RKH_CFG_TRC_SM_CLRH_EN == RKH_ENABLED
571  #define RKH_TR_SM_CLRH(actObj_, history_) \
572  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_CLRH, \
573  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
574  RKH_TRC_SYM(actObj_); \
575  RKH_TRC_SYM(history_); \
576  RKH_TRC_END()
577  #else
578  #define RKH_TR_SM_CLRH(actObj_, history_) (void)0
579  #endif
580 
593  #if RKH_CFG_TRC_SM_DCH_EN == RKH_ENABLED
594  #define RKH_TR_SM_DCH(actObj_, evt_, state_) \
595  RKH_TRC_BEGIN(RKH_TE_SM_DCH, \
596  RKH_SMA_ACCESS_CONST(actObj_, prio), \
597  (evt_)->e) \
598  RKH_TRC_SYM(actObj_); \
599  RKH_TRC_SIG((evt_)->e); \
600  RKH_TRC_SYM(state_); \
601  RKH_TRC_END()
602  #else
603  #define RKH_TR_SM_DCH(actObj_, evt_, state_) (void)0
604  #endif
605 
619  #if RKH_CFG_TRC_SM_TRN_EN == RKH_ENABLED
620  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) \
621  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_TRN, \
622  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
623  RKH_TRC_SYM(actObj_); \
624  RKH_TRC_SYM(sourceState_); \
625  RKH_TRC_SYM(targetState_); \
626  RKH_TRC_END()
627  #else
628  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) (void)0
629  #endif
630 
642  #if RKH_CFG_TRC_SM_STATE_EN == RKH_ENABLED
643  #define RKH_TR_SM_STATE(actObj_, state_) \
644  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_STATE, \
645  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
646  RKH_TRC_SYM(actObj_); \
647  RKH_TRC_SYM(state_); \
648  RKH_TRC_END()
649  #else
650  #define RKH_TR_SM_STATE(actObj_, state_) (void)0
651  #endif
652 
664  #if RKH_CFG_TRC_SM_ENSTATE_EN == RKH_ENABLED
665  #define RKH_TR_SM_ENSTATE(actObj_, state_) \
666  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_ENSTATE, \
667  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
668  RKH_TRC_SYM(actObj_); \
669  RKH_TRC_SYM(state_); \
670  RKH_TRC_END()
671  #else
672  #define RKH_TR_SM_ENSTATE(actObj_, state_) (void)0
673  #endif
674 
686  #if RKH_CFG_TRC_SM_EXSTATE_EN == RKH_ENABLED
687  #define RKH_TR_SM_EXSTATE(actObj_, state_) \
688  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EXSTATE, \
689  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
690  RKH_TRC_SYM(actObj_); \
691  RKH_TRC_SYM(state_); \
692  RKH_TRC_END()
693  #else
694  #define RKH_TR_SM_EXSTATE(actObj_, state_) (void)0
695  #endif
696 
709  #if RKH_CFG_TRC_SM_NENEX_EN == RKH_ENABLED
710  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
711  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_NENEX, \
712  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
713  RKH_TRC_SYM(actObj_); \
714  RKH_TRC_UI8(nEnState_); \
715  RKH_TRC_UI8(nExState_); \
716  RKH_TRC_END()
717  #else
718  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
719  (void)nEnState_
720  #endif
721 
734  #if RKH_CFG_TRC_SM_NTRNACT_EN == RKH_ENABLED
735  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) \
736  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_NTRNACT, \
737  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
738  RKH_TRC_SYM(actObj_); \
739  RKH_TRC_UI8(nta); \
740  RKH_TRC_UI8(nts); \
741  RKH_TRC_END()
742  #else
743  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) (void)0
744  #endif
745 
757  #if RKH_CFG_TRC_SM_TS_STATE_EN == RKH_ENABLED
758  #define RKH_TR_SM_TS_STATE(actObj_, state_) \
759  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_TS_STATE, \
760  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
761  RKH_TRC_SYM(actObj_); \
762  RKH_TRC_SYM(state_); \
763  RKH_TRC_END()
764  #else
765  #define RKH_TR_SM_TS_STATE(actObj_, state_) (void)0
766  #endif
767 
768  #if RKH_CFG_TRC_SM_PROCESS_EN == RKH_ENABLED
769 
782  #define RKH_TR_SM_EVT_PROC(actObj_) \
783  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EVT_PROC, \
784  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
785  RKH_TRC_SYM(actObj_); \
786  RKH_TRC_END()
787 
800  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) \
801  RKH_TRC_BEGIN(RKH_TE_SM_EVT_NFOUND, \
802  RKH_SMA_ACCESS_CONST(actObj_, prio), \
803  (evt_)->e) \
804  RKH_TRC_SYM(actObj_); \
805  RKH_TRC_SIG((evt_)->e); \
806  RKH_TRC_END()
807 
819  #define RKH_TR_SM_GRD_FALSE(actObj_) \
820  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_GRD_FALSE, \
821  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
822  RKH_TRC_SYM(actObj_); \
823  RKH_TRC_END()
824 
837  #define RKH_TR_SM_CND_NFOUND(actObj_) \
838  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_CND_NFOUND, \
839  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
840  RKH_TRC_SYM(actObj_); \
841  RKH_TRC_END()
842 
854  #define RKH_TR_SM_UNKN_STATE(actObj_) \
855  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_UNKN_STATE, \
856  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
857  RKH_TRC_SYM(actObj_); \
858  RKH_TRC_END()
859 
871  #define RKH_TR_SM_EX_HLEVEL(actObj_) \
872  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EX_HLEVEL, \
873  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
874  RKH_TRC_SYM(actObj_); \
875  RKH_TRC_END()
876 
889  #define RKH_TR_SM_EX_TSEG(actObj_) \
890  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EX_TSEG, \
891  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
892  RKH_TRC_SYM(actObj_); \
893  RKH_TRC_END()
894  #else
895  #define RKH_TR_SM_EVT_PROC(actObj_) (void)0
896  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) (void)0
897  #define RKH_TR_SM_CND_NFOUND(actObj_) (void)0
898  #define RKH_TR_SM_GRD_FALSE(actObj_) (void)0
899  #define RKH_TR_SM_UNKN_STATE(actObj_) (void)0
900  #define RKH_TR_SM_EX_HLEVEL(actObj_) (void)0
901  #define RKH_TR_SM_EX_TSEG(actObj_) (void)0
902  #endif
903 
918  #if RKH_CFG_TRC_SM_EXE_ACT_EN == RKH_ENABLED
919  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) \
920  RKH_TRC_BEGIN_WOSIG(RKH_TE_SM_EXE_ACT, \
921  RKH_SMA_ACCESS_CONST(actObj_, prio)) \
922  RKH_TRC_UI8(actionType_); \
923  RKH_TRC_SYM(actObj_); \
924  RKH_TRC_SYM(state_); \
925  RKH_TRC_FUN(action_); \
926  RKH_TRC_END()
927  #else
928  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) (void)0
929  #endif
930 
933  #else
934  #define RKH_TR_SM_INIT(actObj_, initState_) (void)0
935  #define RKH_TR_SM_CLRH(actObj_, history_) (void)0
936  #define RKH_TR_SM_DCH(actObj_, evt_, state_) (void)0
937  #define RKH_TR_SM_TRN(actObj_, sourceState_, targetState_) \
938  (void)0
939  #define RKH_TR_SM_STATE(actObj_, state_) (void)0
940  #define RKH_TR_SM_ENSTATE(actObj_, state_) (void)0
941  #define RKH_TR_SM_EXSTATE(actObj_, state_) (void)0
942  #define RKH_TR_SM_NENEX(actObj_, nEnState_, nExState_) \
943  (void)0
944  #define RKH_TR_SM_NTRNACT(actObj_, nta, nts) (void)0
945  #define RKH_TR_SM_TS_STATE(aaost) (void)0
946  #define RKH_TR_SM_EVT_PROC(actObj_) (void)0
947  #define RKH_TR_SM_EVT_NFOUND(actObj_, evt_) (void)0
948  #define RKH_TR_SM_GRD_FALSE(actObj_) (void)0
949  #define RKH_TR_SM_CND_NFOUND(actObj_) (void)0
950  #define RKH_TR_SM_UNKN_STATE(actObj_) (void)0
951  #define RKH_TR_SM_EX_HLEVEL(actObj_) (void)0
952  #define RKH_TR_SM_EX_TSEG(actObj_) (void)0
953  #define RKH_TR_SM_EXE_ACT(actionType_, actObj_, state_, action_) \
954  (void)0
955  #endif
956 
957  /* --- Timer (TIM) ----------------------------------------------------- */
958  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
959  RKH_CFG_TRC_TMR_EN == RKH_ENABLED
960 
978  #define RKH_TR_TMR_INIT(timer_, signal_) \
979  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_INIT) \
980  RKH_TRC_SYM(timer_); \
981  RKH_TRC_SIG(signal_); \
982  RKH_TRC_END_NOCRIT()
983 
997  #define RKH_TR_TMR_START(timer_, actObj_, nTicks_, period_) \
998  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_START) \
999  RKH_TRC_SYM(timer_); \
1000  RKH_TRC_SYM(actObj_); \
1001  RKH_TRC_NTICK(nTicks_); \
1002  RKH_TRC_NTICK(period_); \
1003  RKH_TRC_END_NOCRIT()
1004 
1017  #define RKH_TR_TMR_STOP(timer_, nTicks_, period_) \
1018  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_STOP) \
1019  RKH_TRC_SYM(timer_); \
1020  RKH_TRC_NTICK(nTicks_); \
1021  RKH_TRC_NTICK(period_); \
1022  RKH_TRC_END_NOCRIT()
1023 
1036  #define RKH_TR_TMR_TOUT(timer_, signal_, actObj_) \
1037  RKH_TRC_BEGIN_NOCRIT(RKH_TE_TMR_TOUT, \
1038  RKH_SMA_ACCESS_CONST(actObj_, prio), \
1039  signal_) \
1040  RKH_TRC_SYM(timer_); \
1041  RKH_TRC_SIG(signal_); \
1042  RKH_TRC_SYM(actObj_); \
1043  RKH_TRC_END_NOCRIT()
1044 
1055  #define RKH_TR_TMR_REM(timer_) \
1056  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_TMR_REM) \
1057  RKH_TRC_SYM(timer_); \
1058  RKH_TRC_END_NOCRIT()
1059 
1062  #else
1063  #define RKH_TR_TMR_INIT(timer_, signal_) (void)0
1064  #define RKH_TR_TMR_START(timer_, actObj_, nTicks_, period_) (void)0
1065  #define RKH_TR_TMR_STOP(timer_, nTicks_, period_) (void)0
1066  #define RKH_TR_TMR_TOUT(timer_, signal_, actObj_) (void)0
1067  #define RKH_TR_TMR_REM(timer_) (void)0
1068  #endif
1069 
1070  /* --- Framework (RKH) ------------------------------------------------- */
1071  #if RKH_CFG_TRC_ALL_EN == RKH_ENABLED || \
1072  RKH_CFG_TRC_FWK_EN == RKH_ENABLED
1073 
1088  #define RKH_TR_FWK_EN() \
1089  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EN) \
1090  RKH_TRC_END()
1091 
1100  #define RKH_TR_FWK_EX() \
1101  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EX) \
1102  RKH_TRC_END()
1103 
1117  #define RKH_TR_FWK_EPREG(evtPool_, storageSize_, evtSize_, \
1118  poolSize_) \
1119  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_EPREG) \
1120  RKH_TRC_UI8(evtPool_); \
1121  RKH_TRC_UI32(storageSize_); \
1122  RKH_TRC_ES(evtSize_); \
1123  RKH_TRC_NBLK(poolSize_); \
1124  RKH_TRC_END()
1125 
1146  #define RKH_TR_FWK_AE(evtSize_, evt_, nUsed_, nMin_, sender_) \
1147  RKH_TRC_BEGIN_WOAOSIG(RKH_TE_FWK_AE) \
1148  RKH_TRC_ES(evtSize_); \
1149  RKH_TRC_SIG((evt_)->e); \
1150  RKH_TRC_UI8((evt_)->pool - 1); \
1151  RKH_TRC_UI8((evt_)->nref); \
1152  RKH_TRC_NBLK(nUsed_); \
1153  RKH_TRC_MP_NMIN(nMin_); \
1154  RKH_TRC_SYM(sender_); \
1155  RKH_TRC_END()
1156 
1169  #define RKH_TR_FWK_GC(evt_, poolID_, refCnt_) \
1170  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_GC) \
1171  RKH_TRC_SIG((evt_)->e); \
1172  RKH_TRC_UI8(poolID_); \
1173  RKH_TRC_UI8(refCnt_); \
1174  RKH_TRC_END_NOCRIT()
1175 
1195  #define RKH_TR_FWK_GCR(evt_, nUsed_, nMin_, sender_) \
1196  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_GCR) \
1197  RKH_TRC_SIG((evt_)->e); \
1198  RKH_TRC_UI8((evt_)->pool - 1); \
1199  RKH_TRC_UI8((evt_)->nref); \
1200  RKH_TRC_NBLK(nUsed_); \
1201  RKH_TRC_MP_NMIN(nMin_); \
1202  RKH_TRC_SYM(sender_); \
1203  RKH_TRC_END_NOCRIT()
1204 
1205  /* --- Symbol entry table for objects -------------------------- */
1206 
1230  #define RKH_TR_FWK_OBJ(obj_) \
1231  do \
1232  { \
1233  static RKHROM char __o_n[] = # obj_; \
1234  rkh_trc_obj(RKH_TE_FWK_OBJ, (rui8_t *)obj_, \
1235  __o_n); \
1236  } \
1237  while (0)
1238 
1239  /* --- Symbol entry table for objects with name ---------------- */
1240 
1267  #define RKH_TR_FWK_OBJ_NAME(obj_, name_) \
1268  do \
1269  { \
1270  rkh_trc_obj(RKH_TE_FWK_OBJ, (rui8_t *)obj_, name_); \
1271  } \
1272  while (0)
1273 
1274  /* --- Symbol entry table for event signals -------------------- */
1275 
1309  #define RKH_TR_FWK_SIG(stateObj_) \
1310  do \
1311  { \
1312  static RKHROM char __s_n[] = # stateObj_; \
1313  rkh_trc_sig(stateObj_, __s_n); \
1314  } \
1315  while (0)
1316 
1317  /* --- Symbol entry table for functions ------------------------ */
1318 
1346  #define RKH_TR_FWK_FUN(function_) \
1347  do \
1348  { \
1349  static RKHROM char __f_n[] = #function_; \
1350  rkh_trc_obj(RKH_TE_FWK_FUN, (rui8_t *)function_, \
1351  __f_n); \
1352  } \
1353  while (0)
1354 
1376  #define RKH_TR_FWK_EXE_FUN(function_) \
1377  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_EXE_FUN) \
1378  RKH_TRC_FUN(function_); \
1379  RKH_TRC_END_WOFIL()
1380 
1408  #define RKH_TR_FWK_SYNC_EVT(function_, senderObj_, receiverObj_) \
1409  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_SYNC_EVT) \
1410  RKH_TRC_FUN(function_); \
1411  RKH_TRC_SNDR(senderObj_); \
1412  RKH_TRC_SNDR(receiverObj_); \
1413  RKH_TRC_END_WOFIL()
1414 
1415  /* --- Symbol entry table for user user-defined trace events --- */
1416 
1452  #define RKH_TR_FWK_TUSR(__e) \
1453  do \
1454  { \
1455  static RKHROM char __e_n[] = # __e; \
1456  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_TUSR) \
1457  RKH_TRC_TE_ID(EXTE(__e, RKH_TG_USR)); \
1458  RKH_TRC_STR(__e_n); \
1459  RKH_TRC_END_WOFIL() \
1460  RKH_TRC_FLUSH(); \
1461  } \
1462  while (0)
1463 
1464  /* --- Trace configuration ------------------------------------- */
1465 
1516  #define RKH_TR_FWK_TCFG(timeStamp_) \
1517  RKH_TRC_BEGIN_DFT(RKH_TE_FWK_TCFG) \
1518  RKH_TRC_UI16((rui16_t)RKH_VERSION_CODE); \
1519  RKH_TRC_UI32( \
1520  (rui32_t)( \
1521  ((rui32_t)RKH_CFG_SMA_TRC_SNDR_EN) | \
1522  ((rui32_t)RKH_CFG_TRC_RTFIL_EN << 1) | \
1523  ((rui32_t)RKH_CFG_TRC_USER_TRACE_EN << 2) | \
1524  ((rui32_t)RKH_CFG_TRC_ALL_EN << 3) | \
1525  ((rui32_t)RKH_CFG_TRC_MP_EN << 4) | \
1526  ((rui32_t)RKH_CFG_TRC_QUE_EN << 5) | \
1527  ((rui32_t)RKH_CFG_TRC_SMA_EN << 6) | \
1528  ((rui32_t)RKH_CFG_TRC_TMR_EN << 7) | \
1529  ((rui32_t)RKH_CFG_TRC_SM_EN << 8) | \
1530  ((rui32_t)RKH_CFG_TRC_FWK_EN << 9) | \
1531  ((rui32_t)RKH_CFG_TRC_ASSERT_EN << 10) | \
1532  ((rui32_t)RKH_CFG_QUE_GET_LWMARK_EN << 11) | \
1533  ((rui32_t)RKH_CFG_MP_GET_LWM_EN << 12) | \
1534  ((rui32_t)RKH_CFG_TRC_RTFIL_SMA_EN << 13) | \
1535  ((rui32_t)RKH_CFG_TRC_RTFIL_SIGNAL_EN << 14) | \
1536  ((rui32_t)RKH_CFG_TRC_NSEQ_EN << 15) | \
1537  ((rui32_t)RKH_CFG_TRC_TSTAMP_EN << 16) | \
1538  ((rui32_t)RKH_CFG_TRC_CHK_EN << 17))); \
1539  RKH_TRC_UI8( \
1540  (rui8_t)((RKH_CFG_FWK_SIZEOF_EVT / 8 << 4) | \
1541  RKH_CFGPORT_TRC_SIZEOF_TSTAMP / 8)); \
1542  RKH_TRC_UI8( \
1543  (rui8_t)((RKH_CFGPORT_TRC_SIZEOF_PTR / 8 << 4) | \
1544  RKH_CFG_TMR_SIZEOF_NTIMER / 8)); \
1545  RKH_TRC_UI8( \
1546  (rui8_t)((RKH_CFG_MP_SIZEOF_NBLOCK / 8 << 4) | \
1547  RKH_CFG_QUE_SIZEOF_NELEM / 8)); \
1548  RKH_TRC_UI8( \
1549  (rui8_t)(RKH_CFG_FWK_SIZEOF_EVT_SIZE / 8)); \
1550  RKH_TRC_UI8( \
1551  (rui8_t)((RKH_CFG_MP_SIZEOF_BSIZE / 8 << 4) | \
1552  RKH_CFG_FWK_MAX_EVT_POOL)); \
1553  RKH_TRC_UI16( \
1554  (rui16_t)(timeStamp_)); \
1555  RKH_TRC_END_DFT() \
1556  RKH_TRC_FLUSH()
1557 
1558  /* --- Assertion ----------------------------------------------- */
1559 
1571  #if RKH_CFG_TRC_ASSERT_EN == RKH_ENABLED
1572  #define RKH_TR_FWK_ASSERT(mod_, ln_) \
1573  RKH_TRC_BEGIN_WOAOSIG_NOCRIT(RKH_TE_FWK_ASSERT) \
1574  RKH_TRC_STR((RKHROM char *)mod_); \
1575  RKH_TRC_UI16((rui16_t)ln_); \
1576  RKH_TRC_END_NOCRIT() \
1577  RKH_TRC_FLUSH()
1578  #else
1579  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1580  #endif
1581 
1582  /* --- Symbol entry table for active objects ------------------- */
1583 
1611  #define RKH_TR_FWK_AO(actObj_) \
1612  do \
1613  { \
1614  rkh_trc_ao((struct RKH_SMA_T *)actObj_); \
1615  } \
1616  while (0)
1617 
1618  /* --- Symbol entry table for state objects -------------------- */
1619 
1647  #define RKH_TR_FWK_STATE(actObj_, stateObj_) \
1648  do \
1649  { \
1650  rkh_trc_state((struct RKH_SMA_T *)actObj_, \
1651  (rui8_t *)stateObj_); \
1652  } \
1653  while (0)
1654 
1655  /* --- Symbol entry table for pseudostate objects -------------- */
1656 
1685  #define RKH_TR_FWK_PSTATE(actObj_, pseudoStObj_) \
1686  do \
1687  { \
1688  rkh_trc_state((struct RKH_SMA_T *)actObj_, \
1689  (rui8_t *)pseudoStObj_); \
1690  } \
1691  while (0)
1692 
1693  /* --- Symbol entry table for timer objects -------------------- */
1694 
1716  #define RKH_TR_FWK_TIMER(timerObj_) \
1717  do \
1718  { \
1719  static RKHROM char __to_n[] = # timerObj_; \
1720  rkh_trc_obj(RKH_TE_FWK_TIMER, (rui8_t *)timerObj_, \
1721  __to_n); \
1722  } \
1723  while (0)
1724 
1725  /* --- Symbol entry table for event pool objects --------------- */
1726 
1756  #define RKH_TR_FWK_EPOOL(poolId_, poolName_) \
1757  RKH_TRC_BEGIN_WOFIL(RKH_TE_FWK_EPOOL) \
1758  RKH_TRC_UI8(poolId_); \
1759  RKH_TRC_STR(poolName_); \
1760  RKH_TRC_END_WOFIL() \
1761  RKH_TRC_FLUSH();
1762 
1763  /* --- Symbol entry table for queue objects -------------------- */
1764 
1791  #define RKH_TR_FWK_QUEUE(queueObj_) \
1792  do \
1793  { \
1794  static RKHROM char __qo_n[] = #queueObj_; \
1795  rkh_trc_obj(RKH_TE_FWK_QUEUE, (rui8_t *)queueObj_, \
1796  __qo_n); \
1797  } \
1798  while (0)
1799 
1825  #define RKH_TR_FWK_ACTOR(actorObj_, nm_) \
1826  do \
1827  { \
1828  rkh_trc_obj(RKH_TE_FWK_ACTOR, (rui8_t *)actorObj_, nm_); \
1829  } \
1830  while (0)
1831 
1834  #else
1835  #define RKH_TR_FWK_EN() (void)0
1836  #define RKH_TR_FWK_EX() (void)0
1837  #define RKH_TR_FWK_EPREG(evtPool_, storageSize_, evtSize_, \
1838  poolSize_) (void)0
1839  #define RKH_TR_FWK_AE(evtSize_, evt_, nUsed_, nMin_, sndr_) (void)0
1840  #define RKH_TR_FWK_GC(evt_, poolID_, refCnt_) (void)0
1841  #define RKH_TR_FWK_GCR(evt_, nUsed_, nMin_, sndr_) (void)0
1842  #define RKH_TR_FWK_OBJ(obj_) (void)0
1843  #define RKH_TR_FWK_OBJ_NAME(obj_, name_) (void)0
1844  #define RKH_TR_FWK_SIG(stateObj_) (void)0
1845  #define RKH_TR_FWK_FUN(stateObj_) (void)0
1846  #define RKH_TR_FWK_EXE_FUN(function_) (void)0
1847  #define RKH_TR_FWK_SYNC_EVT(function_, senderObj_, \
1848  receiverObj_) (void)0
1849  #define RKH_TR_FWK_TUSR(__e) (void)0
1850  #define RKH_TR_FWK_TCFG(timeStamp_) (void)0
1851  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1852  #define RKH_TR_FWK_AO(actObj_) (void)0
1853  #define RKH_TR_FWK_STATE(actObj_, stateObj_) (void)0
1854  #define RKH_TR_FWK_PSTATE(actObj_, pseudoStObj_) (void)0
1855  #define RKH_TR_FWK_TIMER(timerObj_) (void)0
1856  #define RKH_TR_FWK_EPOOL(evtPoolObj_) (void)0
1857  #define RKH_TR_FWK_QUEUE(queueObj_) (void)0
1858  #define RKH_TR_FWK_ACTOR(actObj_, nm_) (void)0
1859  #endif
1860 #else
1861  /* --- Memory Pool (MP) -------------------------------------------- */
1862  #define RKH_TR_MP_INIT(mp, nb, bs) (void)0
1863  #define RKH_TR_MP_GET(mp, nfree, nmin) (void)0
1864  #define RKH_TR_MP_PUT(mp, nfree) (void)0
1865 
1866  /* --- Queue (QUE) -------------------------------------------------- */
1867  #define RKH_TR_QUE_INIT(q, ao, nelem) (void)0
1868  #define RKH_TR_QUE_GET(q, nelem) (void)0
1869  #define RKH_TR_QUE_FIFO(q, nelem, nmin) (void)0
1870  #define RKH_TR_QUE_LIFO(q, nelem, nmin) (void)0
1871  #define RKH_TR_QUE_FULL(q) (void)0
1872  #define RKH_TR_QUE_DPT(q) (void)0
1873  #define RKH_TR_QUE_GET_LAST(q) (void)0
1874 
1875  /* --- State Machine Application (SMA) ----------------------------- */
1876  #define RKH_TR_SMA_ACT(ao, p, s) (void)0
1877  #define RKH_TR_SMA_TERM(ao, p) (void)0
1878  #define RKH_TR_SMA_GET(ao, ev, pid, rc, ne, nm) (void)0
1879  #define RKH_TR_SMA_FIFO(ao, ev, snr, pid, rc, ne, \
1880  nm) (void)0
1881  #define RKH_TR_SMA_LIFO(ao, ev, snr, pid, rc, ne, \
1882  nm) (void)0
1883  #define RKH_TR_SMA_REG(ao, actObjPrio_) (void)0
1884  #define RKH_TR_SMA_UNREG(ao, actObjPrio_) (void)0
1885  #define RKH_TR_SMA_DEFER(queue_, evt_) (void)0
1886  #define RKH_TR_SMA_RCALL(actObj_, evt_) (void)0
1887 
1888  /* --- State machine (SM) ------------------------------------------ */
1889  #define RKH_TR_SM_INIT(ao, ist) (void)0
1890  #define RKH_TR_SM_CLRH(ao, h) (void)0
1891  #define RKH_TR_SM_DCH(ao, ev, st) (void)0
1892  #define RKH_TR_SM_TRN(ao, sst, tst) (void)0
1893  #define RKH_TR_SM_STATE(ao, st) (void)0
1894  #define RKH_TR_SM_ENSTATE(ao, st) (void)0
1895  #define RKH_TR_SM_EXSTATE(ao, st) (void)0
1896  #define RKH_TR_SM_NENEX(ao, nen, nex) (void)0
1897  #define RKH_TR_SM_NTRNACT(ao, nta, nts) (void)0
1898  #define RKH_TR_SM_TS_STATE(ao, st) (void)0
1899  #define RKH_TR_SM_EVT_PROC(ao) (void)0
1900  #define RKH_TR_SM_EVT_NFOUND(ao, ev) (void)0
1901  #define RKH_TR_SM_GRD_FALSE(ao) (void)0
1902  #define RKH_TR_SM_CND_NFOUND(ao) (void)0
1903  #define RKH_TR_SM_UNKN_STATE(ao) (void)0
1904  #define RKH_TR_SM_EX_HLEVEL(ao) (void)0
1905  #define RKH_TR_SM_EX_TSEG(ao) (void)0
1906  #define RKH_TR_SM_EXE_ACT(act_t, ao, st, act) (void)0
1907 
1908  /* --- Timer (TIM) ------------------------------------------------- */
1909  #define RKH_TR_TMR_INIT(t, sig) (void)0
1910  #define RKH_TR_TMR_START(t, ao, nt, per) (void)0
1911  #define RKH_TR_TMR_STOP(t, nt, per) (void)0
1912  #define RKH_TR_TMR_TOUT(t, sig, ao) (void)0
1913  #define RKH_TR_TMR_REM(t) (void)0
1914 
1915  /* --- Framework (RKH) --------------------------------------------- */
1916  #define RKH_TR_FWK_EN() (void)0
1917  #define RKH_TR_FWK_EX() (void)0
1918  #define RKH_TR_FWK_EPREG(ep, ss, es, poolSize_) (void)0
1919  #define RKH_TR_FWK_AE(es, ev, nUsed_, nMin_, \
1920  sndr_) (void)0
1921  #define RKH_TR_FWK_GC(ev, pid, rc) (void)0
1922  #define RKH_TR_FWK_GCR(ev, nUsed_, nMin_, sndr_) (void)0
1923  #define RKH_TR_FWK_OBJ(__o) (void)0
1924  #define RKH_TR_FWK_OBJ_NAME(__o, __n) (void)0
1925  #define RKH_TR_FWK_SIG(__s) (void)0
1926  #define RKH_TR_FWK_FUN(__f) (void)0
1927  #define RKH_TR_FWK_EXE_FUN(__f) (void)0
1928  #define RKH_TR_FWK_SYNC_EVT(fn, snr, rcr) (void)0
1929  #define RKH_TR_FWK_TUSR(__e) (void)0
1930  #define RKH_TR_FWK_TCFG(ts_hz) (void)0
1931  #define RKH_TR_FWK_ASSERT(mod_, ln_) (void)0
1932  #define RKH_TR_FWK_AO(__ao) (void)0
1933  #define RKH_TR_FWK_STATE(__ao, __so) (void)0
1934  #define RKH_TR_FWK_PSTATE(__ao, __pso) (void)0
1935  #define RKH_TR_FWK_TIMER(__to) (void)0
1936  #define RKH_TR_FWK_EPOOL(__epo) (void)0
1937  #define RKH_TR_FWK_QUEUE(__qo) (void)0
1938  #define RKH_TR_FWK_ACTOR(actObj_, nm_) (void)0
1939 #endif
1940 
1941 /* -------------------------------- Constants ------------------------------ */
1942 /* ------------------------------- Data types ------------------------------ */
1943 /* -------------------------- External variables --------------------------- */
1944 /* -------------------------- Function prototypes -------------------------- */
1952 void rkh_trc_init(void);
1953 
1976 void rkh_trc_begin(RKH_TE_ID_T eid);
1977 
1989 void rkh_trc_end(void);
1990 
1999 void rkh_trc_clear_chk(void);
2000 
2008 void rkh_trc_u8(rui8_t d);
2009 
2017 void rkh_trc_u16(rui16_t d);
2018 
2026 void rkh_trc_u32(rui32_t d);
2027 
2035 void rkh_trc_str(const char *s);
2036 
2050 void rkh_trc_obj(RKH_TE_ID_T tre, rui8_t *obj, const char *obj_name);
2051 
2063 void rkh_trc_sig(RKH_SIG_T sig, const char *sig_name);
2064 
2075 void rkh_trc_ao(void *ao);
2076 
2088 void rkh_trc_state(void *ao, rui8_t *state);
2089 
2098 void rkh_trc_fmt_u8(rui8_t fmt, rui8_t d);
2099 
2108 void rkh_trc_fmt_u16(rui8_t fmt, rui16_t d);
2109 
2118 void rkh_trc_fmt_u32(rui8_t fmt, rui32_t d);
2119 
2127 void rkh_trc_fmt_str(const char *s);
2128 
2136 void rkh_trc_fmt_mem(rui8_t const *mem, rui8_t size);
2137 
2138 /* -------------------- External C language linkage end -------------------- */
2139 #ifdef __cplusplus
2140 }
2141 #endif
2142 
2143 /* ------------------------------ Module end ------------------------------- */
2144 #endif
2145 
2146 /* ------------------------------ End of file ------------------------------ */
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_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.
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_init
void rkh_trc_init(void)
Initializes the RKH's trace record service.
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_SIG_T
rui8_t RKH_SIG_T
Definition: rkhevt.h:98
rkh_trc_ao
void rkh_trc_ao(void *ao)
Output active object (AO) symbol record.
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_begin
void rkh_trc_begin(RKH_TE_ID_T eid)
Store the trace record header in the stream.
RKH_TE_ID_T
rui8_t RKH_TE_ID_T
Describes a trace event identification (ID).
Definition: rkhtrc_define.h:1213
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_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_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_clear_chk
void rkh_trc_clear_chk(void)
Clear to zero the trace record checksum.
rkh_trc_end
void rkh_trc_end(void)
Terminate the recorded trace event.
rkh_trc_state
void rkh_trc_state(void *ao, rui8_t *state)
Output state symbol record.
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_sig
void rkh_trc_sig(RKH_SIG_T sig, const char *sig_name)
Output signal symbol record.
rkhtrc_stream.h
Specifies the trace stream manager (circular buffer).