qepn.h

Go to the documentation of this file.

 
#ifndef QEPN_H
#define QEPN_H
 
/****************************************************************************/
#define QP_VERSION      690U
 
#define QP_VERSION_STR  "6.9.0"
 
#define QP_RELEASE      0x884D22FDU
 
 
/****************************************************************************/
/* typedefs for basic numerical types; MISRA-C 2004 rule 6.3(req). */
 
typedef char char_t;
 
typedef int int_t;
 
typedef int enum_t;
 
typedef float float32_t;
 
typedef double float64_t;
 
typedef uint8_t QSignal;
 
#ifndef Q_PARAM_SIZE
    #define Q_PARAM_SIZE 0U
#endif
#if (Q_PARAM_SIZE == 0U)
#elif (Q_PARAM_SIZE == 1U)
    typedef uint8_t QParam;
#elif (Q_PARAM_SIZE == 2U)
    typedef uint16_t QParam;
#elif (Q_PARAM_SIZE == 4U)
    typedef uint32_t QParam;
#elif (Q_PARAM_SIZE == 8U)
    typedef uint64_t QParam;
#else
    #error "Q_PARAM_SIZE defined incorrectly, expected 0U, 1U, 2U, 4U or 8U"
#endif
 
/****************************************************************************/
typedef struct {
    QSignal sig; 
#if (Q_PARAM_SIZE != 0U)
    QParam par;  
#endif
} QEvt;
 
/****************************************************************************/
#define Q_SIG(me_)  (((QHsm *)(me_))->evt.sig)
 
#if (Q_PARAM_SIZE != 0U)
#define Q_PAR(me_)  (((QHsm *)(me_))->evt.par)
#endif  /* (Q_PARAM_SIZE != 0U) */
 
/****************************************************************************/
typedef uint_fast8_t QState;
 
typedef QState (*QStateHandler)(void * const me);
 
/****************************************************************************/
typedef struct QHsmVtable QHsmVtable;
 
typedef struct {
    QHsmVtable const *vptr; 
    QStateHandler state;  
    QStateHandler temp;   
    QEvt evt;  
} QHsm;
 
struct QHsmVtable {
    void (*init)(QHsm * const me);
 
    void (*dispatch)(QHsm * const me);
};
 
#define QHSM_INIT(me_) do {      \
    Q_ASSERT((me_)->vptr);       \
    (*(me_)->vptr->init)((me_)); \
} while (false)
 
#define QHSM_DISPATCH(me_) ((*(me_)->vptr->dispatch)((me_)))
 
/* public methods */
void QHsm_ctor(QHsm * const me, QStateHandler initial);
 
#define QHsm_state(me_) (Q_STATE_CAST(Q_HSM_UPCAST(me_)->state))
 
#define QHsm_childState(me_, parent_) \
    QHsm_childState_(Q_HSM_UPCAST(me_), Q_STATE_CAST(parent_))
 
QStateHandler QHsm_childState_(QHsm * const me,
                               QStateHandler const parent);
 
void QHsm_init_(QHsm * const me);
 
void QHsm_dispatch_(QHsm * const me);
 
QState QHsm_top(void const * const me);
 
 
/****************************************************************************/
/* All possible values returned from state/action handlers */
 
/* unhandled and need to "bubble up"... */
 
#define Q_RET_SUPER      ((QState)0)
 
#define Q_RET_SUPER_SUB  ((QState)1)
 
#define Q_RET_UNHANDLED  ((QState)2)
 
/* handled and do not need to "bubble up"... */
#define Q_RET_HANDLED    ((QState)3)
 
#define Q_RET_IGNORED    ((QState)4)
 
/* entry/exit... */
#define Q_RET_ENTRY      ((QState)5)
 
#define Q_RET_EXIT       ((QState)6)
 
/* no side effects */
#define Q_RET_NULL       ((QState)7)
 
/* transitions need to execute transition-action table in QHsm... */
#define Q_RET_TRAN       ((QState)8)
 
#define Q_RET_TRAN_INIT  ((QState)9)
 
#define Q_RET_TRAN_HIST  ((QState)10)
 
 
#define Q_HSM_UPCAST(ptr_) ((QHsm *)(ptr_))
 
#define Q_STATE_CAST(handler_)  ((QStateHandler)(handler_))
 
#define Q_TRAN(target_)  \
    ((Q_HSM_UPCAST(me))->temp = Q_STATE_CAST(target_), (QState)Q_RET_TRAN)
 
#define Q_TRAN_HIST(hist_)  \
    ((Q_HSM_UPCAST(me))->temp = (hist_), (QState)Q_RET_TRAN_HIST)
 
#define Q_SUPER(super_)  \
    ((Q_HSM_UPCAST(me))->temp = Q_STATE_CAST(super_), Q_RET_SUPER)
 
#define Q_HANDLED()      Q_RET_HANDLED
 
#define Q_UNHANDLED()    Q_RET_UNHANDLED
 
 
#define Q_ENTRY_SIG     ((QSignal)1)
 
#define Q_EXIT_SIG      ((QSignal)2)
 
#define Q_INIT_SIG      ((QSignal)3)
 
#define Q_TIMEOUT_SIG   ((QSignal)4)
 
#define Q_TIMEOUT1_SIG  ((QSignal)5)
 
#define Q_TIMEOUT2_SIG  ((QSignal)6)
 
#define Q_TIMEOUT3_SIG  ((QSignal)7)
 
#define Q_USER_SIG      ((QSignal)8)
 
#define Q_UINT2PTR_CAST(type_, uintptr_)  ((type_ *)(uintptr_))
 
/****************************************************************************/
/* macros for accessing data in ROM */
#ifndef Q_ROM /* if NOT defined, provide the default definition */
 
    #define Q_ROM
#endif
 
#ifndef Q_ROM_BYTE
    #define Q_ROM_BYTE(rom_var_)   (rom_var_)
#endif
 
#ifndef Q_ROM_PTR
    #define Q_ROM_PTR(rom_var_)    (rom_var_)
#endif
 
 
/****************************************************************************/
extern char_t const Q_ROM QP_versionStr[7];
 
#define QP_getVersion() (QP_versionStr)
 
#endif /* QEPN_H */