RKH
Loading...
Searching...
No Matches
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
60extern "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 -------------------------- */
1967void rkh_trc_init(void);
1968
1991void rkh_trc_begin(RKH_TE_ID_T eid);
1992
2004void rkh_trc_end(void);
2005
2014void rkh_trc_clear_chk(void);
2015
2023void rkh_trc_u8(rui8_t d);
2024
2032void rkh_trc_u16(rui16_t d);
2033
2041void rkh_trc_u32(rui32_t d);
2042
2050void rkh_trc_str(const char *s);
2051
2065void rkh_trc_obj(RKH_TE_ID_T tre, rui8_t *obj, const char *obj_name);
2066
2078void rkh_trc_sig(RKH_SIG_T sig, const char *sig_name);
2079
2090void rkh_trc_ao(void *ao);
2091
2103void rkh_trc_state(void *ao, rui8_t *state);
2104
2113void rkh_trc_fmt_u8(rui8_t fmt, rui8_t d);
2114
2123void rkh_trc_fmt_u16(rui8_t fmt, rui16_t d);
2124
2133void rkh_trc_fmt_u32(rui8_t fmt, rui32_t d);
2134
2142void rkh_trc_fmt_str(const char *s);
2143
2151void 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:106
RKH_TE_ID_T
rui8_t RKH_TE_ID_T
Describes a trace event identification (ID).
Definition rkhtrc_define.h:1221
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).