rkhsm.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 site: http://vortexmakes.com/que-es/
 *  RKH GitHub: https://github.com/vortexmakes/RKH
 *  RKH Sourceforge: https://sourceforge.net/projects/rkh-reactivesys/
 *  e-mail: lf@vortexmakes.com
 *  ---------------------------------------------------------------------------
 */
 
/* -------------------------- Development history -------------------------- */
/*
 *  2017.04.14  LeFr  v2.4.05  Initial version
 */
 
/* -------------------------------- Authors -------------------------------- */
/*
 *  LeFr  Leandro Francucci  lf@vortexmakes.com
 */
 
/* --------------------------------- Notes --------------------------------- */
/* --------------------------------- Module -------------------------------- */
#ifndef __RKHSM_H__
#define __RKHSM_H__
 
/* ----------------------------- Include files ----------------------------- */
#include "rkhevt.h"
#include "rkhitl.h"
 
/* ---------------------- External C language linkage ---------------------- */
#ifdef __cplusplus
extern "C" {
#endif
 
/* --------------------------------- Macros -------------------------------- */
#define RKH_SM_NAME(smName_)         s_##smName_
#define RKH_SM_CONST_NAME(smName_)   rs_##smName_
 
#define ELSE        rkh_sm_else
 
#define RKH_CREATE_COMP_REGION_STATE(name, en, ex, parent, defchild, \
                                     initialTrn, \
                                     kindOfHistory, hDftTrnGuard, \
                                     hDftTrnAction, hDftTarget, hRamMem) \
                                                                         \
    MKFINAL_INCOMP(name); \
    MKHIST_INCOMP(name, kindOfHistory, hDftTrnGuard, hDftTrnAction, \
                  hDftTarget, hRamMem); \
                                        \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
    RKHROM RKH_SCMP_T name = \
    { \
        {MKBASE(RKH_COMPOSITE, name), MKST(en, ex, parent)}, \
        MKCOMP(name, defchild, initialTrn, &name##Hist) \
    }
 
#define RKH_CREATE_COMP_STATE(name, en, ex, parent, defchild, history) \
                                                                       \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
    RKHROM RKH_SCMP_T name = \
    { \
        {MKBASE(RKH_COMPOSITE, name), MKST(en, ex, parent)}, \
        MKCOMP(name, defchild, NULL, history) \
    }
 
#define RKH_CREATE_FINAL_STATE(name, parent) \
                                             \
    static RKHROM RKH_TR_T name##_trtbl[] = \
        RKH_TRREG(RKH_ANY, NULL, NULL, NULL); \
    RKHROM RKH_FINAL_T name = \
    { \
        {MKBASE(RKH_FINAL, name), MKST(NULL, NULL, parent)}, \
        MKFINAL(name) \
    }
 
#define RKH_CREATE_BASIC_STATE(name, en, ex, parent, prepro) \
                                                             \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
                                             \
    RKHROM RKH_SBSC_T name = \
    { \
        {MKBASE(RKH_BASIC, name), MKST(en,ex,parent)}, \
        MKBASIC(name,prepro)  \
    }
 
#define RKH_CREATE_COND_STATE(name) \
                                    \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
                                             \
    RKHROM RKH_SCOND_T name = \
    { \
        MKBASE(RKH_CONDITIONAL, name), \
        name##_trtbl \
    }
 
#define RKH_CREATE_CHOICE_STATE(name) \
                                      \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
                                           \
    RKHROM RKH_SCHOICE_T name = \
    { \
        MKBASE(RKH_CHOICE, name), \
        name##_trtbl \
    }
 
#define RKH_CREATE_DEEP_HISTORY_STATE(name, parent, dftTrnGuard, \
                                      dftTrnAction, dftTarget) \
                                                               \
    static RKHROM RKH_ST_T *ram##name; \
    MKHISTORY(name, parent, RKH_DHISTORY, dftTrnGuard, dftTrnAction, \
              dftTarget, &ram##name)
 
#define RKH_CREATE_SHALLOW_HISTORY_STATE(name, parent, dftTrnGuard, \
                                         dftTrnAction, dftTarget) \
                                                                  \
    static RKHROM RKH_ST_T *ram##name; \
    MKHISTORY(name, parent, RKH_SHISTORY, dftTrnGuard, dftTrnAction, \
              dftTarget, &ram##name)
 
#define RKH_CREATE_SUBMACHINE_STATE(name, en, ex, parent, sbm) \
                                                               \
    extern RKHROM RKH_EXPCN_T name##_exptbl[]; \
    extern RKHROM RKH_TR_T name##_trtbl[]; \
                                             \
    RKHROM RKH_SSBM_T name = \
    { \
        {MKBASE(RKH_SUBMACHINE, name), MKST(en,ex,parent)}, \
        MKSBM(name,sbm) \
    }
 
#define RKH_CREATE_EX_CNNPNT_TABLE(name) \
    RKHROM RKH_EXPCN_T name##_exptbl[]= \
    {
 
#define RKH_EX_CNNPNT(name, expnt, act, ts) \
    {(RKH_TRN_ACT_T)act, (RKHROM struct RKH_ST_T *)ts}
 
#define RKH_END_EX_CNNPNT_TABLE     };
 
#define RKH_EN_CNNPNT(name, enpnt, subm) \
                                         \
    RKHROM RKH_SENP_T name = \
    { \
        MKBASE(RKH_ENPOINT, name), \
        MKENP(enpnt,subm) \
    }
 
#define RKH_CREATE_REF_SUBMACHINE(name, defchild, iact) \
                                                        \
    static RKHROM RKH_ST_T * rdyp_##name; \
                                            \
    RKHROM RKH_RSM_T name = \
    { \
        MKBASE(RKH_REF_SUBMACHINE, name), \
        MKMCH(defchild,iact,name) \
    }
 
#define RKH_CREATE_REF_EXPNT(name, ix, subm) \
                                             \
    RKHROM RKH_SEXP_T name = \
    { \
        MKBASE(RKH_EXPOINT, name), \
        ix, subm \
    }
 
#define RKH_CREATE_REF_ENPNT(name, act, ts, subm) \
                                                  \
    RKHROM RKH_ENPCN_T name = \
    { \
        (RKH_TRN_ACT_T)act, (RKHROM struct RKH_ST_T *)ts \
    }
 
#define RKH_CREATE_TRANS_TABLE(name) \
                                     \
    RKHROM RKH_TR_T name##_trtbl[]= \
    {
 
#define RKH_TRREG(evt_, guard_, effect_, target_) \
            MKTRN(evt_, guard_, effect_, target_)
 
#define RKH_TRINT(e, g, a)    {e, (RKH_GUARD_T)g, (RKH_TRN_ACT_T)a, NULL}
 
#define RKH_TRCOMPLETION(guard_, effect_, target_) \
    {RKH_COMPLETION_EVENT, \
     (RKH_GUARD_T)guard_, (RKH_TRN_ACT_T)effect_, target_}
 
#define RKH_END_TRANS_TABLE     {RKH_ANY, NULL, NULL, NULL}};
 
#define RKH_CREATE_BRANCH_TABLE(name) \
                                      \
    RKH_CREATE_TRANS_TABLE(name)
 
#define RKH_BRANCH(guard_, effect_, target_) \
            MKTRN(0, guard_, effect_, target_)
 
#define RKH_CREATE_HISTORY_STORAGE(compStateName) \
    static RKHROM RKH_ST_T *ramHist_##compStateName
 
#define RKH_GET_HISTORY_STORAGE(compStateName) \
    &ramHist_##compStateName
 
/*
 *  This macro is internal to RKH and the user application should
 *  not call it.
 */
#define RKH_EBTBL               {RKH_ANY, NULL, NULL, NULL}
 
#define RKH_END_BRANCH_TABLE    RKH_EBTBL};
 
#define RKH_ROOT                RKH_NULL
 
#define RKH_SM_DCLR(me_) \
            RKH_DCLR_PTR_TYPE(RKH_SM_T, me_)
 
#define RKH_SM_DCLR_TYPE(type_, me_) \
            RKH_DCLR_PTR_TYPE(type_, me_)
 
#define RKH_DCLR_COMP_STATE     extern RKHROM RKH_SCMP_T
#define RKH_DCLR_BASIC_STATE    extern RKHROM RKH_SBSC_T
#define RKH_DCLR_FINAL_STATE    extern RKHROM RKH_FINAL_T
#define RKH_DCLR_COND_STATE     extern RKHROM RKH_SCOND_T
#define RKH_DCLR_CHOICE_STATE   extern RKHROM RKH_SCHOICE_T
#define RKH_DCLR_DHIST_STATE    extern RKHROM RKH_SHIST_T
#define RKH_DCLR_SHIST_STATE    extern RKHROM RKH_SHIST_T
#define RKH_DCLR_SUBM_STATE     extern RKHROM RKH_SSBM_T
#define RKH_DCLR_REF_SUBM       extern RKHROM RKH_RSM_T
#define RKH_DCLR_ENPNT          extern RKHROM RKH_SENP_T
#define RKH_DCLR_REF_EXPNT      extern RKHROM RKH_SEXP_T
#define RKH_DCLR_REF_ENPNT      extern RKHROM RKH_ENPCN_T
#define RKH_DECLARE_TR_TBL(name) \
    extern RKHROM RKH_TR_T name##_trtbl[]
 
#define RKH_DCLR_SM_GLOBAL(sm_t, sm, gob) \
    sm_t * const gob = &s_##sm;
 
#define RKH_DCLR_SM_CONST_GLOBAL(smName) \
    extern RKHROM RKH_ROM_T RKH_SM_CONST_NAME(smName)
 
#define RKH_INIT_BASIC_STATE(name, en, ex, parent, prepro) \
    { \
        { \
            MKBASE(RKH_BASIC, name),    /* RKH_BASE_T */ \
            MKST(en, ex, parent) \
        },                              /* RKH_ST_T */ \
        MKBASIC(name, prepro) \
    } /* RKH_SBSC_T */ \
 
 
#define RKH_INIT_COMPOSITE_STATE(name, en, ex, parent, \
                                 defchild, history) \
    { \
        { \
            MKBASE(RKH_COMPOSITE, name),    /* RKH_BASE_T */ \
            MKST(en, ex, parent) \
        },                                  /* RKH_ST_T */ \
        MKCOMP(name, defchild, history) \
    }                                       /* RKH_SCMP_T */ \
 
#define RKH_GFALSE      RKH_FALSE   
#define RKH_GTRUE       RKH_TRUE    
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_CREATE(type, name, prio, ppty, initialState, \
                          initialAction, initialEvt) \
        static RKH_SM_CONST_CREATE(name, prio, ppty, initialState, \
                                   initialAction, initialEvt); \
        static type s_##name = {MKSM(&RKH_SM_CONST_NAME(name), initialState)}
#else
    #define RKH_SM_CREATE(type, name, prio, ppty, initialState, \
                          initialAction, initialEvt) \
        static type RKH_SMA_NAME(name) = {MKSM(name, prio, ppty, initialState, \
                                               initialAction, initialEvt)}
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_INIT(me_, nameSMConst_, prio_, ppty_, initialState_, \
                        initialAction_, initialEvt_) \
        ((RKH_SM_T *)me_)->romrkh = \
            (RKHROM RKH_ROM_T *)(RKH_SM_GET_CONST_OBJ(nameSMConst_)); \
        ((RKH_SM_T *)me_)->state = \
            (RKHROM struct RKH_ST_T *) \
                ((RKH_SM_GET_CONST_OBJ(nameSMConst_))->istate)
#else
    #define RKH_SM_INIT(me_, nameSMConst_, prio_, ppty_, initialState_, \
                        initialAction_, initialEvt_) \
        MKRT_SM(me_, nameSMConst_, prio_, ppty_, initialState_, \
                initialAction_, initialEvt_)
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_CONST_CREATE(name, prio, ppty, initialState, \
                                initialAction, initialEvt) \
        RKHROM RKH_ROM_T RKH_SM_CONST_NAME(name) = \
                                                MKRRKH(name, \
                                                       prio, \
                                                       ppty, \
                                                       initialState, \
                                                       initialAction, \
                                                       initialEvt)
#else
    #define RKH_SM_CONST_CREATE(name, prio, ppty, initialState, \
                                initialAction, initialEvt)
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_GET_CONST(sm) \
        ((RKH_SM_T *)sm)->romrkh
#else
    #define RKH_SM_GET_CONST(sm) \
        ((RKH_SM_T *)sm)
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_GET_CONST_OBJ(sm) \
        &RKH_SM_CONST_NAME(sm)
#else
    #define RKH_SM_GET_CONST_OBJ(sm) \
        ((RKH_SM_T *)sm)
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
    #define RKH_SM_GET_OBJ(type, sm)
#else
    #define RKH_SM_GET_OBJ(type, sm) \
        (type *)&RKH_SM_NAME(sm)
#endif
 
#define RKH_SM_DEF_PTR(sm) \
    RKH_SM_T *const sm = (RKH_SM_T *)&RKH_SM_NAME(sm)
 
#define RKH_SM_DEF_PTR_TYPE(type, sm) \
    type *const sm = (type *)&RKH_SM_NAME(sm)
 
#define RKH_GET_CSTATE_ID(me) \
    ((RKH_BASE_T *)(((RKH_SM_T *)me)->state))->id
 
#if R_TRC_AO_NAME_EN == RKH_ENABLED
    #define RKH_GET_VERTEX_NAME(vx) \
        ((struct RKH_BASE_T *)(vx))->name
#else
    #define RKH_GET_VERTEX_NAME(vx)       noname
#endif
 
/* -------------------------------- Constants ------------------------------ */
/* ------------------------------- Data types ------------------------------ */
typedef enum RKH_RCODE_T
{
    RKH_EVT_PROC,
 
    RKH_EVT_NFOUND,
 
    RKH_CND_NFOUND,
 
    RKH_GRD_FALSE,
 
    RKH_UNKN_STATE,
 
    RKH_EX_HLEVEL,
 
    RKH_EX_TSEG,
    RKH_NUM_CODES
} RKH_RCODE_T;
 
typedef enum
{
    HCAL,
 
    FLAT,
 
    RKH_NUM_HPPTY
} RKH_HPPTY_T;
 
#if RKH_CFG_SMA_ENT_ARG_SMA_EN == RKH_ENABLED
    #if RKH_CFG_SMA_ENT_ARG_STATE_EN == RKH_ENABLED
    typedef void (*RKH_ENT_ACT_T)(const RKH_SM_T *me,
                                  const RKH_ST_T *state);
    #else
    typedef void (*RKH_ENT_ACT_T)(const RKH_SM_T *me);
    #endif
#else
    #if RKH_CFG_SMA_ENT_ARG_STATE_EN == RKH_ENABLED
    typedef void (*RKH_ENT_ACT_T)(const RKH_ST_T *state);
    #else
    typedef void (*RKH_ENT_ACT_T)(void);
    #endif
#endif
 
#if RKH_CFG_SMA_EXT_ARG_SMA_EN == RKH_ENABLED
    #if RKH_CFG_SMA_ENT_ARG_STATE_EN == RKH_ENABLED
    typedef void (*RKH_EXT_ACT_T)(const RKH_SM_T *me,
                                  const RKH_ST_T *state);
    #else
    typedef void (*RKH_EXT_ACT_T)(const RKH_SM_T *me);
    #endif
#else
    #if RKH_CFG_SMA_ENT_ARG_STATE_EN == RKH_ENABLED
    typedef void (*RKH_EXT_ACT_T)(const RKH_ST_T *state);
    #else
    typedef void (*RKH_EXT_ACT_T)(void);
    #endif
#endif
 
#if RKH_CFG_SMA_PPRO_ARG_SMA_EN == RKH_ENABLED
    typedef RKH_SIG_T (*RKH_PPRO_T)(const RKH_SM_T *sma,
                                    RKH_EVT_T *pe);
#else
    typedef RKH_SIG_T (*RKH_PPRO_T)(RKH_EVT_T *pe);
#endif
 
#if (RKH_CFG_SMA_ACT_ARG_EVT_EN == RKH_ENABLED && \
     RKH_CFG_SMA_ACT_ARG_SMA_EN == RKH_ENABLED)
    typedef void (*RKH_TRN_ACT_T)(const RKH_SM_T *me,
                                  RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_ACT_ARG_EVT_EN == RKH_ENABLED && \
       RKH_CFG_SMA_ACT_ARG_SMA_EN == RKH_DISABLED)
    typedef void (*RKH_TRN_ACT_T)(RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_ACT_ARG_EVT_EN == RKH_DISABLED && \
       RKH_CFG_SMA_ACT_ARG_SMA_EN == RKH_ENABLED)
    typedef void (*RKH_TRN_ACT_T)(const RKH_SM_T *me);
#else
    typedef void (*RKH_TRN_ACT_T)(void);
#endif
 
#if (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_ENABLED && \
     RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_ENABLED)
 
    typedef rbool_t (*RKH_GUARD_T)(const RKH_SM_T *me,
                                   RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_ENABLED && \
       RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_DISABLED)
    typedef rbool_t (*RKH_GUARD_T)(RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_DISABLED && \
       RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_ENABLED)
    typedef rbool_t (*RKH_GUARD_T)(const RKH_SM_T *me);
#else
    typedef rbool_t (*RKH_GUARD_T)(void);
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
struct RKH_ROM_T
{
    rui8_t prio;
 
    rui8_t ppty;
 
#if R_TRC_AO_NAME_EN == RKH_ENABLED
    const char *name;
#endif
 
    RKHROM RKH_ST_T *istate;
 
    RKH_TRN_ACT_T iaction;
 
#if RKH_CFG_SMA_INIT_EVT_EN == RKH_ENABLED
    const RKH_EVT_T *ievent;
#endif
};
#endif
 
#if RKH_CFG_SMA_SM_CONST_EN == RKH_ENABLED
struct RKH_SM_T
{
    RKHROM RKH_ROM_T *romrkh;
 
    RKHROM RKH_ST_T *state;
 
    RKH_EVT_T* propagatedEvent;
};
#else
struct RKH_SM_T
{
    rui8_t prio;
 
    rui8_t ppty;
 
#if R_TRC_AO_NAME_EN == RKH_ENABLED
    const char *name;
#endif
 
    RKHROM RKH_ST_T *istate;
 
    RKH_TRN_ACT_T iaction;
 
#if RKH_CFG_SMA_INIT_EVT_EN == RKH_ENABLED
    const RKH_EVT_T *ievent;
#endif
 
    RKHROM RKH_ST_T *state;
 
    RKH_EVT_T* propagatedEvent;
};
#endif
 
struct RKH_BASE_T
{
    ruint type;
 
#if R_TRC_AO_NAME_EN == RKH_ENABLED
    const char *name;
#endif
};
 
struct RKH_TR_T
{
    RKH_SIG_T event;
 
    RKH_GUARD_T guard;
 
    RKH_TRN_ACT_T action;
 
    RKHROM void *target;
};
 
struct RKH_ST_T
{
    RKH_BASE_T base;
 
#if RKH_CFG_SMA_HCAL_EN == RKH_ENABLED
    RKH_ENT_ACT_T enter;
 
    RKH_EXT_ACT_T exit;
 
    RKHROM RKH_ST_T *parent;
#endif
};
 
struct RKH_SBSC_T
{
    RKH_ST_T st;
 
    RKHROM RKH_TR_T *trtbl;
 
#if RKH_CFG_SMA_PPRO_EN == RKH_ENABLED
    RKH_PPRO_T prepro;
#endif
};
 
struct RKH_SCMP_T
{
    RKH_ST_T st;
 
    RKHROM RKH_TR_T *trtbl;
 
#if RKH_CFG_SMA_PPRO_EN == RKH_ENABLED
    RKH_PPRO_T prepro;
#endif
 
#if RKH_CFG_SMA_HCAL_EN == RKH_ENABLED
    RKHROM void *defchild;
 
    RKH_TRN_ACT_T initialAction;
 
#if defined(RKH_HISTORY_ENABLED)
    RKHROM RKH_SHIST_T *history;
#endif
#endif
};
 
struct RKH_FINAL_T
{
    RKH_ST_T st;
 
    RKHROM RKH_TR_T *trtbl;
 
#if RKH_CFG_SMA_PPRO_EN == RKH_ENABLED
    RKH_PPRO_T prepro;
#endif
};
 
#if defined(RKH_SUBMACHINE_ENABLED)
struct RKH_EXPCN_T
{
    RKH_TRN_ACT_T action;
 
    RKHROM void *target;
};
 
struct RKH_ENPCN_T
{
    RKH_TRN_ACT_T action;
 
    RKHROM void *target;
};
 
struct RKH_SSBM_T
{
    RKH_ST_T st;
 
    RKHROM RKH_TR_T *trtbl;
 
    RKHROM RKH_EXPCN_T *exptbl;
 
    RKHROM RKH_RSM_T *sbm;
};
 
struct RKH_RSM_T
{
    RKH_BASE_T base;
 
    RKHROM void *defchild;
 
    RKH_TRN_ACT_T iaction;
 
    RKHROM RKH_ST_T * *dyp;
};
 
struct RKH_SENP_T
{
    RKH_BASE_T base;
 
    RKHROM RKH_ENPCN_T *enpcn;
 
    RKHROM RKH_ST_T *parent;
};
 
struct RKH_SEXP_T
{
    RKH_BASE_T base;
 
    rui8_t ix;
 
    RKHROM RKH_RSM_T *parent;
};
#endif
 
#if defined(RKH_CHOICE_OR_CONDITIONAL_ENABLED)
struct RKH_SCOND_T
{
    RKH_BASE_T base;
 
    RKHROM RKH_TR_T *trtbl;
};
#endif
 
#if defined(RKH_CHOICE_ENABLED)
struct RKH_SCHOICE_T
{
    RKH_BASE_T base;
 
    RKHROM RKH_TR_T *trtbl;
};
#endif
 
struct RKH_SHIST_T
{
    RKH_BASE_T base;
 
    RKHROM RKH_ST_T *parent;
 
    RKHROM RKH_ST_T **target;
    
    RKHROM RKH_TR_T trn;
};
 
/* -------------------------- External variables --------------------------- */
/* -------------------------- Function prototypes -------------------------- */
void rkh_sm_init(RKH_SM_T *me);
 
ruint rkh_sm_dispatch(RKH_SM_T *me, RKH_EVT_T *e);
 
void rkh_sm_ctor(RKH_SM_T *me);
 
void rkh_sm_clear_history(RKHROM RKH_SHIST_T *h);
 
#if (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_ENABLED && \
     RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_ENABLED)
rbool_t rkh_sm_else(const RKH_SM_T *sma, RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_ENABLED && \
       RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_DISABLED)
rbool_t rkh_sm_else(RKH_EVT_T *pe);
#elif (RKH_CFG_SMA_GRD_ARG_EVT_EN == RKH_DISABLED && \
       RKH_CFG_SMA_GRD_ARG_SMA_EN == RKH_ENABLED)
rbool_t rkh_sm_else(const RKH_SM_T *sma);
#else
rbool_t rkh_sm_else(void);
#endif
 
void rkh_sm_propagate(RKH_SM_T *me, RKH_EVT_T* e);
 
/* -------------------- External C language linkage end -------------------- */
#ifdef __cplusplus
}
#endif
 
/* ------------------------------ Module end ------------------------------- */
#endif
 
/* ------------------------------ End of file ------------------------------ */