rkhtrc_define.h

Go to the documentation of this file.

/*
 *  --------------------------------------------------------------------------
 *
 *                                Framework RKH
 *                                -------------
 *
 *            State-machine framework for reactive embedded systems
 *
 *                      Copyright (C) 2010 Leandro Francucci.
 *          All rights reserved. Protected by international copyright laws.
 *
 *
 *  RKH is free software: you can redistribute it and/or modify it under the
 *  terms of the GNU General Public License as published by the Free Software
 *  Foundation, either version 3 of the License, or (at your option) any
 *  later version.
 *
 *  RKH is distributed in the hope that it will be useful, but WITHOUT ANY
 *  WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with RKH, see copying.txt file.
 *
 *  Contact information:
 *  RKH web site:   http://sourceforge.net/projects/rkh-reactivesys/
 *  e-mail:         francuccilea@gmail.com
 *  ---------------------------------------------------------------------------
 */

/* -------------------------- Development history -------------------------- */
/*
 *  2017.04.15  LeFr  v2.4.05  Initial version
 */

/* -------------------------------- Authors -------------------------------- */
/*
 *  LeFr  Leandro Francucci  francuccilea@gmail.com
 */

/* --------------------------------- Notes --------------------------------- */
/* --------------------------------- Module -------------------------------- */
#ifndef __RKHTRC_DEF_H__
#define __RKHTRC_DEF_H__

/* ----------------------------- Include files ----------------------------- */
#include "rkhitl.h"

/* ---------------------- External C language linkage ---------------------- */
#ifdef __cplusplus
extern "C" {
#endif

/* --------------------------------- Macros -------------------------------- */
#define RKH_CFG_TRC_SIZEOF_TE_ID        8

#if RKH_CFG_TRC_SIZEOF_TE_ID == 8
        #define RKH_TRC_TE_ID(teid) \
            RKH_TRC_UI8(teid)
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 16
        #define RKH_TRC_TE_ID(teid) \
            RKH_TRC_UI16(teid)
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 32
        #define RKH_TRC_TE_ID(teid) \
            RKH_TRC_UI32(teid)
#else
        #define RKH_TRC_TE_ID(teid) \
            RKH_TRC_UI8(teid)
#endif

#if RKH_CFG_TRC_RTFIL_SMA_EN == RKH_ENABLED
    #define RKH_TRC_AO_ISOFF(prio) \
            && rkh_trc_symFil_isoff(RKHFilterSma, (RKH_TRC_FSLOT)(prio))
#else
    #define RKH_TRC_AO_ISOFF(prio)
#endif

#define RKH_TRC_IS_RESERVED_SIG(sig) \
    (sig == RKH_COMPLETION_EVENT) 
    
#if RKH_CFG_TRC_RTFIL_SIGNAL_EN == RKH_ENABLED
    #define RKH_TRC_SIG_ISOFF(sig) \
            && (RKH_TRC_IS_RESERVED_SIG(sig) || \
            rkh_trc_symFil_isoff(RKHFilterSignal, (RKH_TRC_FSLOT)(sig)))
#else
    #define RKH_TRC_SIG_ISOFF(sig)
#endif

/* -------------------------------- Constants ------------------------------ */
#if RKH_CFG_TRC_SIZEOF_TE_ID == 8
        #define RKH_NBITS_GROUP             3
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 16
        #define RKH_NBITS_GROUP             8
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 32
        #define RKH_NBITS_GROUP             8
#else
        #define RKH_NBITS_GROUP             3
#endif

#define RKH_NBIT_EVENT_PER_GROUP   (RKH_CFG_TRC_SIZEOF_TE_ID - \
                                        RKH_NBITS_GROUP)
#define RKH_TRC_MAX_GROUPS          RKH_BIT(RKH_NBITS_GROUP)
#define RKH_MAX_NUM_TE_PER_GROUP    RKH_BIT(RKH_NBIT_EVENT_PER_GROUP)
#define NGSH                        RKH_NBIT_EVENT_PER_GROUP
#define RKH_GRP_MASK \
        (RKH_TE_ID_T)((RKH_BIT(RKH_NBITS_GROUP) - 1) << \
                       RKH_NBIT_EVENT_PER_GROUP)
#define RKH_TE_MASK \
        (RKH_TE_ID_T)(RKH_BIT(RKH_NBIT_EVENT_PER_GROUP) - 1)

#define RKH_TRC_MAX_EVENTS \
        (RKH_MAX_NUM_TE_PER_GROUP * RKH_TRC_MAX_GROUPS)

#if ((RKH_CFG_FWK_MAX_SMA & (8 - 1)) == 0)

        #define RKH_TRC_MAX_SMA     (RKH_CFG_FWK_MAX_SMA / 8)
#else
        #define RKH_TRC_MAX_SMA     (RKH_CFG_FWK_MAX_SMA / 8 + 1)
#endif

#if ((RKH_CFG_FWK_MAX_SIGNALS & (8 - 1)) == 0)

        #define RKH_TRC_MAX_SIGNALS (RKH_CFG_FWK_MAX_SIGNALS / 8)
#else
        #define RKH_TRC_MAX_SIGNALS (RKH_CFG_FWK_MAX_SIGNALS / 8 + 1)
#endif

#define RKH_MP_START                GRPLSH(RKH_TG_MP)
#define RKH_QUE_START                GRPLSH(RKH_TG_QUE)
#define RKH_SMA_START               GRPLSH(RKH_TG_SMA)
#define RKH_SM_START                GRPLSH(RKH_TG_SM)
#define RKH_TMR_START               GRPLSH(RKH_TG_TMR)
#define RKH_FWK_START               GRPLSH(RKH_TG_FWK)
#define RKH_USR_START               GRPLSH(RKH_TG_USR)
#define RKH_UT_START                GRPLSH(RKH_TG_UT)

#define RKH_MP_TTBL_RANGE           1
#define RKH_QUE_TTBL_RANGE           1
#define RKH_SMA_TTBL_RANGE          2
#define RKH_SM_TTBL_RANGE           3
#define RKH_TIM_TTBL_RANGE          1
#define RKH_FWK_TTBL_RANGE          3
#define RKH_USR_TTBL_RANGE          4
#define RKH_UT_TTBL_RANGE           2

#define RKH_TOT_NUM_TRC_EVTS \
        (RKH_MP_TTBL_RANGE   + \
         RKH_QUE_TTBL_RANGE   + \
         RKH_SMA_TTBL_RANGE  + \
         RKH_SM_TTBL_RANGE   + \
         RKH_TIM_TTBL_RANGE  + \
         RKH_FWK_TTBL_RANGE  + \
         RKH_USR_TTBL_RANGE  + \
         RKH_UT_TTBL_RANGE)

#if (RKH_TOT_NUM_TRC_EVTS <= RKH_TOT_NUM_TRC_EVTS)
        #define RKH_TRC_MAX_EVENTS_IN_BYTES     RKH_TOT_NUM_TRC_EVTS
#else
        #error  "rkhtrc.h, the total number of trace events represented"
        #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#define RKH_MP_TTBL_OFFSET          0
#define RKH_QUE_TTBL_OFFSET          (RKH_MP_TTBL_OFFSET + RKH_MP_TTBL_RANGE)
#define RKH_SMA_TTBL_OFFSET         (RKH_QUE_TTBL_OFFSET + RKH_QUE_TTBL_RANGE)
#define RKH_SM_TTBL_OFFSET          (RKH_SMA_TTBL_OFFSET + RKH_SMA_TTBL_RANGE)
#define RKH_TIM_TTBL_OFFSET         (RKH_SM_TTBL_OFFSET + RKH_SM_TTBL_RANGE)
#define RKH_FWK_TTBL_OFFSET         (RKH_TIM_TTBL_OFFSET + RKH_TIM_TTBL_RANGE)
#define RKH_USR_TTBL_OFFSET         (RKH_FWK_TTBL_OFFSET + RKH_FWK_TTBL_RANGE)
#define RKH_UT_TTBL_OFFSET          (RKH_USR_TTBL_OFFSET + RKH_USR_TTBL_RANGE)

#define GRPLSH(grp) \
        /*(RKH_TE_ID_T)(((grp) & (rui8_t)(RKH_TRC_MAX_GROUPS - 1)) << NGSH)*/ \
        (((grp) & (RKH_TRC_MAX_GROUPS - 1)) << NGSH)

#define EXTE(te, grp) \
        (RKH_TE_ID_T)((te) - GRPLSH(grp))

#define GETGRP(e) \
        (RKH_TG_T)(((e) & RKH_GRP_MASK) >> RKH_NBIT_EVENT_PER_GROUP)
#define GETEVT(e) \
        (RKH_TE_ID_T)((e) & RKH_TE_MASK)

#define ECHANGE                     0
#define EUNCHANGE                   1

#define RKH_TRC_ALL_GROUPS      RKH_TG_NGROUP

#define RKH_TRC_ALL_EVENTS      RKH_TE_NEVENT

#define RKH_TRC_SET_ALL(mode_) \
        ((mode_) | RKH_TRC_ALL_FILTERS)

#define RKH_TRC_ALL_FILTERS     0x80
#define RKH_FILTER_MODE_MASK    ~RKH_TRC_ALL_FILTERS

#define RKH_XOR     0x20

#define RKH_FLG     0x7E

#define RKH_ESC     0x7D

/* --- RKH group of trace events ------------------------------------------- */
#define RKH_TG_MP           0

#define RKH_TG_QUE           1

#define RKH_TG_SMA          2

#define RKH_TG_SM           3

#define RKH_TG_TMR          4

#define RKH_TG_FWK          5

#define RKH_TG_USR          6

#define RKH_TG_UT           7

#define RKH_TG_NGROUP       8

/* --- Memory Pool events (MP group) --------------------------------------- */
#define RKH_TE_MP_INIT          RKH_MP_START

#define RKH_TE_MP_GET           (RKH_TE_MP_INIT + 1)

#define RKH_TE_MP_PUT           (RKH_TE_MP_GET + 1)
#define RKH_MP_END              RKH_TE_MP_PUT

/* --- Queue events (QUE group) --------------------------------------------- */
#define RKH_TE_QUE_INIT          RKH_QUE_START         

#define RKH_TE_QUE_GET           (RKH_TE_QUE_INIT + 1)

#define RKH_TE_QUE_FIFO          (RKH_TE_QUE_GET + 1)

#define RKH_TE_QUE_LIFO          (RKH_TE_QUE_FIFO + 1)

#define RKH_TE_QUE_FULL          (RKH_TE_QUE_LIFO + 1)

#define RKH_TE_QUE_DPT           (RKH_TE_QUE_FULL + 1)

#define RKH_TE_QUE_GET_LAST      (RKH_TE_QUE_DPT +1 )
#define RKH_QUE_END              RKH_TE_QUE_GET_LAST

/* --- State Machine Application events (SMA group) ------------------------ */
#define RKH_TE_SMA_ACT          RKH_SMA_START

#define RKH_TE_SMA_TERM         (RKH_TE_SMA_ACT + 1)

#define RKH_TE_SMA_GET          (RKH_TE_SMA_TERM + 1)

#define RKH_TE_SMA_FIFO         (RKH_TE_SMA_GET + 1)

#define RKH_TE_SMA_LIFO         (RKH_TE_SMA_FIFO + 1)

#define RKH_TE_SMA_REG          (RKH_TE_SMA_LIFO + 1)

#define RKH_TE_SMA_UNREG        (RKH_TE_SMA_REG + 1)

#define RKH_TE_SMA_DEFER        (RKH_TE_SMA_UNREG + 1)

#define RKH_TE_SMA_RCALL        (RKH_TE_SMA_DEFER + 1)
#define RKH_SMA_END             RKH_TE_SMA_RCALL

/* --- State machine events (SM group) ------------------------------------- */
#define RKH_TE_SM_INIT          RKH_SM_START

#define RKH_TE_SM_CLRH          (RKH_TE_SM_INIT + 1)

#define RKH_TE_SM_TRN           (RKH_TE_SM_CLRH + 1)

#define RKH_TE_SM_STATE         (RKH_TE_SM_TRN + 1)

#define RKH_TE_SM_ENSTATE       (RKH_TE_SM_STATE + 1)

#define RKH_TE_SM_EXSTATE       (RKH_TE_SM_ENSTATE + 1)

#define RKH_TE_SM_NENEX         (RKH_TE_SM_EXSTATE + 1)

#define RKH_TE_SM_NTRNACT       (RKH_TE_SM_NENEX + 1)

#define RKH_TE_SM_TS_STATE      (RKH_TE_SM_NTRNACT + 1)

#define RKH_TE_SM_EVT_PROC      (RKH_TE_SM_TS_STATE + 1)

#define RKH_TE_SM_EVT_NFOUND    (RKH_TE_SM_EVT_PROC + 1)

#define RKH_TE_SM_GRD_FALSE     (RKH_TE_SM_EVT_NFOUND + 1)

#define RKH_TE_SM_CND_NFOUND    (RKH_TE_SM_GRD_FALSE + 1)

#define RKH_TE_SM_UNKN_STATE    (RKH_TE_SM_CND_NFOUND + 1)

#define RKH_TE_SM_EX_HLEVEL     (RKH_TE_SM_UNKN_STATE + 1)

#define RKH_TE_SM_EX_TSEG       (RKH_TE_SM_EX_HLEVEL + 1)

#define RKH_TE_SM_EXE_ACT       (RKH_TE_SM_EX_TSEG + 1)

#define RKH_TE_SM_DCH           (RKH_TE_SM_EXE_ACT + 1)
#define RKH_SM_END              RKH_TE_SM_DCH

/* --- Timer events (TMR group) -------------------------------------------- */
#define RKH_TE_TMR_INIT         RKH_TMR_START

#define RKH_TE_TMR_START        (RKH_TE_TMR_INIT + 1)

#define RKH_TE_TMR_STOP         (RKH_TE_TMR_START + 1)

#define RKH_TE_TMR_TOUT         (RKH_TE_TMR_STOP + 1)

#define RKH_TE_TMR_REM          (RKH_TE_TMR_TOUT + 1)
#define RKH_TMR_END             RKH_TE_TMR_REM

/* --- Framework and misc. events (FWK group) ------------------------------ */
#define RKH_TE_FWK_EN           RKH_FWK_START

#define RKH_TE_FWK_EX           (RKH_TE_FWK_EN + 1)

#define RKH_TE_FWK_EPREG        (RKH_TE_FWK_EX + 1)

#define RKH_TE_FWK_AE           (RKH_TE_FWK_EPREG + 1)

#define RKH_TE_FWK_GC           (RKH_TE_FWK_AE + 1)

#define RKH_TE_FWK_GCR          (RKH_TE_FWK_GC + 1)

#define RKH_TE_FWK_OBJ          (RKH_TE_FWK_GCR + 1)

#define RKH_TE_FWK_SIG          (RKH_TE_FWK_OBJ + 1)

#define RKH_TE_FWK_FUN          (RKH_TE_FWK_SIG + 1)

#define RKH_TE_FWK_EXE_FUN      (RKH_TE_FWK_FUN + 1)

#define RKH_TE_FWK_SYNC_EVT     (RKH_TE_FWK_EXE_FUN + 1)

#define RKH_TE_FWK_TUSR         (RKH_TE_FWK_SYNC_EVT + 1)

#define RKH_TE_FWK_TCFG         (RKH_TE_FWK_TUSR + 1)

#define RKH_TE_FWK_ASSERT       (RKH_TE_FWK_TCFG + 1)

#define RKH_TE_FWK_AO           (RKH_TE_FWK_ASSERT + 1)

#define RKH_TE_FWK_STATE        (RKH_TE_FWK_AO + 1)

#define RKH_TE_FWK_PSTATE       (RKH_TE_FWK_STATE + 1)

#define RKH_TE_FWK_TIMER        (RKH_TE_FWK_PSTATE + 1)

#define RKH_TE_FWK_EPOOL        (RKH_TE_FWK_TIMER + 1)

#define RKH_TE_FWK_QUEUE        (RKH_TE_FWK_EPOOL + 1)

#define RKH_TE_FWK_ACTOR        (RKH_TE_FWK_QUEUE + 1)
#define RKH_FWK_END             RKH_TE_FWK_ACTOR

/* --- User events (USR group) --------------------------------------------- */
#define RKH_TE_USER             RKH_USR_START

/* --- Unit test harness events (UT group) --------------------------------- */
#define RKH_TE_UT_INIT          RKH_UT_START
#define RKH_TE_UT_CLEANUP       (RKH_TE_UT_INIT + 1)
#define RKH_TE_UT_VERIFY        (RKH_TE_UT_CLEANUP + 1)
#define RKH_TE_UT_IGNORE_GROUP  (RKH_TE_UT_VERIFY + 1)
#define RKH_TE_UT_EXPECT        (RKH_TE_UT_IGNORE_GROUP + 1)
#define RKH_TE_UT_EXPECT_ANYARGS    (RKH_TE_UT_EXPECT + 1)
#define RKH_TE_UT_IGNORE        (RKH_TE_UT_EXPECT_ANYARGS + 1)
#define RKH_TE_UT_IGNORE_ARG    (RKH_TE_UT_IGNORE + 1)
#define RKH_TE_UT_SUCCESS       (RKH_TE_UT_IGNORE_ARG + 1)
#define RKH_TE_UT_FAIL          (RKH_TE_UT_SUCCESS + 1)
#define RKH_UT_END              RKH_TE_UT_IGNORE_ARG

/* The last trace event */
#define RKH_TE_NEVENT           (RKH_UT_END + 1)

/* ------------------------- Configuration errors -------------------------- */
/*
 *  LOOK FOR WRONG #define CONSTANTS
 *
 *  This section is used to generate ERROR messages at compile time if
 *  certain #define constants are WRONG in rkhtrc.h.  This allows you to
 *  quickly determine the source of the error.
 *
 *  You SHOULD NOT change this section UNLESS you would like to add more
 *  comments as to the source of the compile time error.
 */
#if ((RKH_MP_END - RKH_MP_START) > ((RKH_MP_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_QUE_END - RKH_QUE_START) > ((RKH_QUE_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_SMA_END - RKH_SMA_START) > ((RKH_SMA_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_SM_END - RKH_SM_START) > ((RKH_SM_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_TMR_END - RKH_TMR_START) > ((RKH_TIM_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_FWK_END - RKH_FWK_START) > ((RKH_FWK_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if ((RKH_UT_END - RKH_UT_START) > ((RKH_UT_TTBL_RANGE * 8) - 1))
    #error  "rkhtrc.h, the total number of trace events represented"
    #error  "by RKH_TOT_NUM_TRC_EVTS must be <= RKH_TRC_MAX_EVENTS"
#endif

#if RKH_CFG_TRC_RTFIL_EN == RKH_ENABLED

        #define RKH_TRC_BEGIN(eid_, prio_, sig_)  \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_AO_ISOFF(prio_) \
                RKH_TRC_SIG_ISOFF(sig_)) \
            { \
                RKH_ENTER_CRITICAL_(); \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAO(eid_, sig_) \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_SIG_ISOFF(sig_)) \
            { \
                RKH_ENTER_CRITICAL_(); \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOSIG(eid_, prio_) \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_AO_ISOFF(prio_)) \
            { \
                RKH_ENTER_CRITICAL_(); \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAOSIG(eid_) \
            if (rkh_trc_isoff_(eid_)) \
            { \
                RKH_ENTER_CRITICAL_(); \
                rkh_trc_begin(eid_);

        #define RKH_TRC_END() \
            rkh_trc_end(); \
            RKH_EXIT_CRITICAL_(); \
            }

        #define RKH_TRC_BEGIN_NOCRIT(eid_, prio_, sig_) \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_AO_ISOFF(prio_) \
                RKH_TRC_SIG_ISOFF(sig_)) \
            { \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAO_NOCRIT(eid_, sig_) \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_SIG_ISOFF(sig_)) \
            { \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOSIG_NOCRIT(eid_, prio_) \
            if (rkh_trc_isoff_(eid_) \
                RKH_TRC_AO_ISOFF(prio_)) \
            { \
                rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAOSIG_NOCRIT(eid_) \
            if (rkh_trc_isoff_(eid_)) \
            { \
                rkh_trc_begin(eid_);

        #define RKH_TRC_END_NOCRIT() \
            rkh_trc_end(); \
            }
#else
        #define RKH_TRC_BEGIN(eid_, prio_, sig_) \
            RKH_ENTER_CRITICAL_(); \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAO(eid_, sig_) \
            RKH_ENTER_CRITICAL_(); \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOSIG(eid_, prio_) \
            RKH_ENTER_CRITICAL_(); \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAOSIG(eid_) \
            RKH_ENTER_CRITICAL_(); \
            rkh_trc_begin(eid_);

        #define RKH_TRC_END() \
            rkh_trc_end();  \
            RKH_EXIT_CRITICAL_();

        #define RKH_TRC_BEGIN_NOCRIT(eid_, prio_, sig_) \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAO_NOCRIT(eid_, sig_) \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOSIG_NOCRIT(eid_, prio_) \
            rkh_trc_begin(eid_);

        #define RKH_TRC_BEGIN_WOAOSIG_NOCRIT(eid_) \
            rkh_trc_begin(eid_);

        #define RKH_TRC_END_NOCRIT() \
            rkh_trc_end();
#endif

#define RKH_TRC_BEGIN_WOFIL(eid_) \
        RKH_SR_ALLOC(); \
        RKH_ENTER_CRITICAL_(); \
        rkh_trc_begin(eid_);

#define RKH_TRC_END_WOFIL() \
        rkh_trc_end(); \
        RKH_EXIT_CRITICAL_();

#define RKH_TRC_BEGIN_WOFIL_NOCRIT(eid_) \
        rkh_trc_begin(eid_);

#define RKH_TRC_END_WOFIL_NOCRIT() \
        rkh_trc_end();  \


#define RKH_TRC_BEGIN_DFT(eid_) \
        RKH_SR_ALLOC(); \
        RKH_ENTER_CRITICAL_(); \
        rkh_trc_clear_chk(); \
        RKH_TRC_TE_ID(eid_);

#define RKH_TRC_END_DFT() \
        rkh_trc_end(); \
        RKH_EXIT_CRITICAL_();

#define RKH_TRC_U8_RAW(d) \
        rkh_trc_put((d))

#define RKH_TRC_UI8(d) \
        rkh_trc_u8((rui8_t)(d))

#define RKH_TRC_UI16(d) \
        rkh_trc_u16((d))

#define RKH_TRC_UI32(d) \
        rkh_trc_u32((d))

#define RKH_TRC_STR(s) \
        rkh_trc_str((s))

#if RKH_CFG_TRC_USER_TRACE_EN == RKH_ENABLED

        #define RKH_TRC_USR_BEGIN(eid_) \
            RKH_SR_ALLOC(); \
            if (rkh_trc_isoff_(eid_)) \
            { \
                RKH_ENTER_CRITICAL_(); \
                rkh_trc_begin(eid_);

        #define RKH_TRC_USR_END() \
            rkh_trc_end(); \
            RKH_EXIT_CRITICAL_(); \
            }

        #define RKH_TRC_USR_BEGIN_NOCRIT(eid_) \
            if (rkh_trc_isoff_(eid_)) \
            { \
                rkh_trc_begin(eid_);

        #define RKH_TRC_USR_END_NOCRIT() \
            rkh_trc_end(); \
            }

        #define RKH_TUSR_I8(w_, d_) \
            rkh_trc_fmt_u8((rui8_t)(((w_) << 4)) | (rui8_t)RKH_I8_T, \
                           (d_))

        #define RKH_TUSR_UI8(w_, d_) \
            rkh_trc_fmt_u8((rui8_t)(((w_) << 4)) | (rui8_t)RKH_UI8_T, \
                           (d_))

        #define RKH_TUSR_I16(w_, d_) \
            rkh_trc_fmt_u16((rui8_t)(((w_) << 4)) | (rui8_t)RKH_I16_T, \
                            (d_))

        #define RKH_TUSR_UI16(w_, d_) \
            rkh_trc_fmt_u16((rui8_t)(((w_) << 4)) | (rui8_t)RKH_UI16_T, \
                            (d_))

        #define RKH_TUSR_I32(w_, d_) \
            rkh_trc_fmt_u32((rui8_t)(((w_) << 4)) | (rui8_t)RKH_I32_T, \
                            (d_))

        #define RKH_TUSR_UI32(w_, d_) \
            rkh_trc_fmt_u32((rui8_t)(((w_) << 4)) | (rui8_t)RKH_UI32_T, \
                            (d_))

        #define RKH_TUSR_X32(w_, d_) \
            rkh_trc_fmt_u32((rui8_t)(((w_) << 4)) | (rui8_t)RKH_X32_T, \
                            (d_))

        #define RKH_TUSR_STR(s_) \
            rkh_trc_fmt_str((s_))

        #define RKH_TUSR_MEM(mem_, size_) \
            rkh_trc_fmt_mem((mem_), (size_))

        #if RKH_CFGPORT_TRC_SIZEOF_PTR == 16
            #define RKH_TUSR_OBJ(obj_)    \
                rkh_trc_fmt_u16((rui8_t)RKH_OBJ_T, (rui16_t)(obj_))
        #elif RKH_CFGPORT_TRC_SIZEOF_PTR == 32
            #define RKH_TUSR_OBJ(obj_)    \
                rkh_trc_fmt_u32((rui8_t)RKH_OBJ_T, (rui32_t)(obj_))
        #else
            #define RKH_TUSR_OBJ(obj_)    \
                rkh_trc_fmt_u32((rui8_t)RKH_OBJ_T, (rui32_t)(obj_))
        #endif

        #if RKH_CFGPORT_TRC_SIZEOF_FUN_PTR == 16u
            #define RKH_TUSR_FUN(fun_)    \
                rkh_trc_fmt_u16((rui8_t)RKH_FUN_T, (rui16_t)(fun_))
        #elif RKH_CFGPORT_TRC_SIZEOF_FUN_PTR == 32
            #define RKH_TUSR_FUN(fun_)    \
                rkh_trc_fmt_u32((rui8_t)RKH_FUN_T, (rui32_t)(fun_))
        #else
            #define RKH_TUSR_FUN(fun_)    \
                rkh_trc_fmt_u32((rui8_t)RKH_FUN_T, (rui32_t)(fun_))
        #endif

        #if RKH_CFG_FWK_SIZEOF_EVT == 8
            #define RKH_TUSR_SIG(sig_) \
                rkh_trc_fmt_u8((rui8_t)RKH_ESIG_T, (rui8_t)(sig_))
        #elif RKH_CFG_FWK_SIZEOF_EVT == 16
            #define RKH_TUSR_SIG(sig_) \
                rkh_trc_fmt_u16((rui8_t)RKH_ESIG_T, (rui16_t)(sig_))
        #elif RKH_CFG_FWK_SIZEOF_EVT == 32
            #define RKH_TUSR_SIG(sig_) \
                rkh_trc_fmt_u32((rui8_t)RKH_ESIG_T, (rui32_t)(sig_))
        #else
            #define RKH_TUSR_SIG(sig_) \
                rkh_trc_fmt_u8((rui8_t)RKH_ESIG_T, (rui8_t)(sig_))
        #endif
#else
        #define RKH_TRC_USR_BEGIN(eid_)           (void)0;
        #define RKH_TRC_USR_END()                 (void)0
        #define RKH_TRC_USR_BEGIN_NOCRIT(eid_)    (void)0
        #define RKH_TRC_USR_END_NOCRIT()          (void)0
        #define RKH_TUSR_I8(w_, d_)               (void)0
        #define RKH_TUSR_UI8(w_, d_)              (void)0
        #define RKH_TUSR_I16(w_, d_)              (void)0
        #define RKH_TUSR_UI16(w_, d_)             (void)0
        #define RKH_TUSR_I32(w_, d_)              (void)0
        #define RKH_TUSR_UI32(w_, d_)             (void)0
        #define RKH_TUSR_X32(w_, d_)              (void)0
        #define RKH_TUSR_STR(s_)                  (void)0
        #define RKH_TUSR_MEM(mem_, size_)         (void)0
        #define RKH_TUSR_OBJ(obj_)                (void)0
        #define RKH_TUSR_FUN(fun_)                (void)0
        #define RKH_TUSR_SIG(sig_)                (void)0
#endif

#if RKH_CFGPORT_TRC_SIZEOF_PTR == 16
        #define RKH_TRC_SYM(sym)  \
            RKH_TRC_UI16((rui16_t)sym)
#elif RKH_CFGPORT_TRC_SIZEOF_PTR == 32
        #define RKH_TRC_SYM(sym)  \
            RKH_TRC_UI32((rui32_t)sym)
#else
        #define RKH_TRC_SYM(sym)  \
            RKH_TRC_UI32((rui32_t)sym)
#endif

#if defined(RKH_USE_TRC_SENDER)
        #define RKH_TRC_SNDR(sym) \
            RKH_TRC_SYM(sym)
#else
        #define RKH_TRC_SNDR(sym)
#endif

#if RKH_CFGPORT_TRC_SIZEOF_FUN_PTR == 16
        #define RKH_TRC_FUN(sym)  \
            RKH_TRC_UI16((rui16_t)sym)
#elif RKH_CFGPORT_TRC_SIZEOF_FUN_PTR == 32
        #define RKH_TRC_FUN(sym)  \
            RKH_TRC_UI32((rui32_t)sym)
#else
        #define RKH_TRC_FUN(sym)  \
            RKH_TRC_UI32((rui32_t)sym)
#endif

#if RKH_CFG_TMR_SIZEOF_NTIMER == 8
        #define RKH_TRC_NTICK(nt) \
            RKH_TRC_UI8(nt)
#elif RKH_CFG_TMR_SIZEOF_NTIMER == 16
        #define RKH_TRC_NTICK(nt) \
            RKH_TRC_UI16(nt)
#elif RKH_CFG_TMR_SIZEOF_NTIMER == 32
        #define RKH_TRC_NTICK(nt) \
            RKH_TRC_UI32(nt)
#else
        #define RKH_TRC_NTICK(nt) \
            RKH_TRC_UI8(nt)
#endif

#if RKH_CFG_MP_SIZEOF_NBLOCK == 8
        #define RKH_TRC_NBLK(nb) \
            RKH_TRC_UI8(nb)
        #if RKH_CFG_MP_GET_LWM_EN == RKH_ENABLED
            #define RKH_TRC_MP_NMIN(nm) \
                RKH_TRC_UI8(nm)
        #else
            #define RKH_TRC_MP_NMIN(nm)
        #endif
#elif RKH_CFG_MP_SIZEOF_NBLOCK == 16
        #define RKH_TRC_NBLK(nb) \
            RKH_TRC_UI16(nb)
        #if RKH_CFG_MP_GET_LWM_EN == RKH_ENABLED
            #define RKH_TRC_MP_NMIN(nm) \
                RKH_TRC_UI16(nm)
        #else
            #define RKH_TRC_MP_NMIN(nm)
        #endif
#elif RKH_CFG_MP_SIZEOF_NBLOCK == 32
        #define RKH_TRC_NBLK(nb) \
            RKH_TRC_UI32(nb)
        #if RKH_CFG_MP_GET_LWM_EN == RKH_ENABLED
            #define RKH_TRC_MP_NMIN(nm) \
                RKH_TRC_UI32(nm)
        #else
            #define RKH_TRC_MP_NMIN(nm)
        #endif
#else
        #define RKH_TRC_NBLK(nb) \
            RKH_TRC_UI8(nb)
        #if RKH_CFG_MP_GET_LWM_EN == RKH_ENABLED
            #define RKH_TRC_MP_NMIN(nm) \
                RKH_TRC_UI8(nm)
        #else
            #define RKH_TRC_MP_NMIN(nm)
        #endif
#endif

#if RKH_CFG_MP_SIZEOF_BSIZE == 8
        #define RKH_TRC_BSIZE(bs) \
            RKH_TRC_UI8(bs)
#elif RKH_CFG_MP_SIZEOF_BSIZE == 16
        #define RKH_TRC_BSIZE(bs) \
            RKH_TRC_UI16(bs)
#elif RKH_CFG_MP_SIZEOF_BSIZE == 32
        #define RKH_TRC_BSIZE(bs) \
            RKH_TRC_UI32(bs)
#else
        #define RKH_TRC_BSIZE(bs) \
            RKH_TRC_UI8(bs)
#endif

#if RKH_CFG_QUE_SIZEOF_NELEM == 8
        #define RKH_TRC_NE(ne) \
            RKH_TRC_UI8(ne)
        #if RKH_CFG_QUE_GET_LWMARK_EN == RKH_ENABLED
            #define RKH_TRC_QUE_NMIN(nm) \
                RKH_TRC_UI8(nm)
        #else
            #define RKH_TRC_QUE_NMIN(nm)
        #endif
#elif RKH_CFG_QUE_SIZEOF_NELEM == 16
        #define RKH_TRC_NE(ne) \
            RKH_TRC_UI16(ne)
        #if RKH_CFG_QUE_GET_LWMARK_EN == RKH_ENABLED
            #define RKH_TRC_QUE_NMIN(nm) \
                RKH_TRC_UI16(nm)
        #else
            #define RKH_TRC_QUE_NMIN(nm)
        #endif
#elif RKH_CFG_QUE_SIZEOF_NELEM == 32
        #define RKH_TRC_NE(ne) \
            RKH_TRC_UI32(ne)
        #if RKH_CFG_QUE_GET_LWMARK_EN == RKH_ENABLED
            #define RKH_TRC_QUE_NMIN(nm) \
                RKH_TRC_UI32(nm)
        #else
            #define RKH_TRC_QUE_NMIN(nm)
        #endif
#else
        #define RKH_TRC_NE(ne) \
            RKH_TRC_UI8(ne)
        #if RKH_CFG_QUE_GET_LWMARK_EN == RKH_ENABLED
            #define RKH_TRC_QUE_NMIN(nm) \
                RKH_TRC_UI8(nm)
        #else
            #define RKH_TRC_QUE_NMIN(nm)
        #endif
#endif

#if RKH_CFG_FWK_SIZEOF_EVT == 8
        #define RKH_TRC_SIG(e) \
            RKH_TRC_UI8(e)
#elif RKH_CFG_FWK_SIZEOF_EVT == 16
        #define RKH_TRC_SIG(e) \
            RKH_TRC_UI16(e)
#elif RKH_CFG_FWK_SIZEOF_EVT == 32
        #define RKH_TRC_SIG(e) \
            RKH_TRC_UI32(e)
#else
        #define RKH_TRC_SIG(e) \
            RKH_TRC_UI8(e)
#endif

#if RKH_CFG_FWK_SIZEOF_EVT_SIZE == 8
        #define RKH_TRC_ES(es) \
            RKH_TRC_UI8(es)
#elif RKH_CFG_FWK_SIZEOF_EVT_SIZE == 16
        #define RKH_TRC_ES(es) \
            RKH_TRC_UI16(es)
#elif RKH_CFG_FWK_SIZEOF_EVT_SIZE == 32
        #define RKH_TRC_ES(es) \
            RKH_TRC_UI32(es)
#else
        #define RKH_TRC_ES(es) \
            RKH_TRC_UI8(es)
#endif

enum RKH_TRC_FMT
{
    RKH_I8_T,       
    RKH_UI8_T,      
    RKH_I16_T,      
    RKH_UI16_T,     
    RKH_I32_T,      
    RKH_UI32_T,     
    RKH_X32_T,      
    RKH_STR_T,      
    RKH_MEM_T,      
    RKH_OBJ_T,      
    RKH_FUN_T,      
    RKH_ESIG_T      
};

/* ------------------------------- Data types ------------------------------ */
#if RKH_CFG_TRC_SIZEOF_TE_ID == 8
    typedef rui8_t RKH_TE_ID_T;
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 16
    typedef rui16_t RKH_TE_ID_T;
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 32
    typedef rui32_t RKH_TE_ID_T;
#else
    typedef rui8_t RKH_TE_ID_T;
#endif

#if RKH_CFG_TRC_TSTAMP_EN == RKH_ENABLED
    #if RKH_CFGPORT_TRC_SIZEOF_TSTAMP == 8
        typedef rui8_t RKH_TS_T;
    #elif RKH_CFGPORT_TRC_SIZEOF_TSTAMP == 16
        typedef rui16_t RKH_TS_T;
    #elif RKH_CFGPORT_TRC_SIZEOF_TSTAMP == 32
        typedef rui32_t RKH_TS_T;
    #else
        typedef rui16_t RKH_TS_T;
    #endif
#else
    typedef rui16_t RKH_TS_T;
#endif

#if RKH_CFG_TRC_SIZEOF_STREAM < 255u
    typedef rui8_t TRCQTY_T;
#else
    typedef rui16_t TRCQTY_T;
#endif

typedef rui8_t RKH_TG_T;

typedef enum RKH_SUBTE_SM_EXE_ACT
{
    RKH_SUBTE_SM_EXE_ACT_EFF,       
    RKH_SUBTE_SM_EXE_ACT_EN,        
    RKH_SUBTE_SM_EXE_ACT_EX,        
    RKH_SUBTE_SM_EXE_ACT_INI,       
    RKH_SUBTE_SM_EXE_ACT_PP,        
    RKH_SUBTE_SM_EXE_ACT_GRD        
} RKH_SUBTE_SM_EXE_ACT;

#if RKH_CFG_TRC_SIZEOF_TE_ID == 8
typedef rui8_t RKH_GM_OFFSET_T;
typedef rui8_t RKH_GM_RANGE_T;
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 16
typedef rui16_t RKH_GM_OFFSET_T;
typedef rui8_t RKH_GM_RANGE_T;
#elif RKH_CFG_TRC_SIZEOF_TE_ID == 32
typedef rui32_t RKH_GM_OFFSET_T;
typedef rui32_t RKH_GM_RANGE_T;
#else
typedef rui8_t RKH_GM_OFFSET_T;
typedef rui8_t RKH_GM_RANGE_T;
#endif

typedef struct
{
    RKH_GM_OFFSET_T offset;
    RKH_GM_RANGE_T range;
} RKH_GMTBL_T;

/* -------------------------- External variables --------------------------- */
/* -------------------------- Function prototypes -------------------------- */
/* -------------------- External C language linkage end -------------------- */
#ifdef __cplusplus
}
#endif

/* ------------------------------ Module end ------------------------------- */
#endif

/* ------------------------------ End of file ------------------------------ */