qfn.h

Go to the documentation of this file.

 
#ifndef QFN_H
#define QFN_H
 
/****************************************************************************/
#ifndef QF_TIMEEVT_CTR_SIZE
    #define QF_TIMEEVT_CTR_SIZE 0U
#endif
#if (QF_TIMEEVT_CTR_SIZE == 0U)
    /* no time events */
#elif (QF_TIMEEVT_CTR_SIZE == 1U)
    typedef uint8_t QTimeEvtCtr;
#elif (QF_TIMEEVT_CTR_SIZE == 2U)
    typedef uint16_t QTimeEvtCtr;
#elif (QF_TIMEEVT_CTR_SIZE == 4U)
    typedef uint32_t QTimeEvtCtr;
#else
    #error "QF_TIMER_SIZE defined incorrectly, expected 1U, 2U, or 4U"
#endif
 
#if (QF_TIMEEVT_CTR_SIZE != 0U)
    typedef struct {
        QTimeEvtCtr nTicks;   
#ifdef QF_TIMEEVT_PERIODIC
        QTimeEvtCtr interval; 
#endif /* QF_TIMEEVT_PERIODIC */
    } QTimer;
#endif /* (QF_TIMEEVT_CTR_SIZE != 0U) */
 
#ifndef QF_MAX_TICK_RATE
    #define QF_MAX_TICK_RATE     1U
#elif (QF_MAX_TICK_RATE > 4U)
    #error "QF_MAX_TICK_RATE exceeds the 4U limit"
#endif
 
/****************************************************************************/
typedef struct QActive {
    QHsm super; 
#if (QF_TIMEEVT_CTR_SIZE != 0U)
    QTimer tickCtr[QF_MAX_TICK_RATE];
#endif /* (QF_TIMEEVT_CTR_SIZE != 0U) */
 
    uint8_t prio;
 
    uint8_t volatile head;
 
    uint8_t volatile tail;
 
    uint8_t volatile nUsed;
 
} QActive;
 
typedef struct {
    QHsmVtable super; 
#if (Q_PARAM_SIZE != 0U)
    bool (*post)(QActive * const me, uint_fast8_t const margin,
                 enum_t const sig, QParam const par);
 
    bool (*postISR)(QActive * const me, uint_fast8_t const margin,
                    enum_t const sig, QParam const par);
#else
    bool (*post)   (QActive * const me, uint_fast8_t const margin,
                    enum_t const sig);
    bool (*postISR)(QActive * const me, uint_fast8_t const margin,
                    enum_t const sig);
#endif
} QActiveVtable;
 
void QActive_ctor(QActive * const me, QStateHandler initial);
 
 
#define QF_NO_MARGIN ((uint_fast8_t)0xFF)
 
#if (Q_PARAM_SIZE != 0U)
    #define QACTIVE_POST(me_, sig_, par_) do {                      \
        QActive * const ao_ = QF_ACTIVE_CAST((me_));                \
        ((void)(*((QActiveVtable const *)(ao_->super.vptr))->post)( \
                ao_, QF_NO_MARGIN, (enum_t)(sig_), (QParam)(par_)));\
    } while (false)
 
    #define QACTIVE_POST_X(me_, margin_, sig_, par_)            \
        ((*((QActiveVtable const *)((me_)->super.vptr))->post)( \
             (me_), (margin_), (enum_t)(sig_), (QParam)(par_)))
 
    #define QACTIVE_POST_ISR(me_, sig_, par_) do {                     \
        QActive * const ao_ = QF_ACTIVE_CAST((me_));                   \
        ((void)(*((QActiveVtable const *)(ao_->super.vptr))->postISR)( \
                ao_, QF_NO_MARGIN, (enum_t)(sig_), (QParam)(par_)));   \
    } while (false)
 
    #define QACTIVE_POST_X_ISR(me_, margin_, sig_, par_)   \
        ((*((QActiveVtable const *)(                       \
            QF_ACTIVE_CAST((me_))->super.vptr))->postISR)( \
                QF_ACTIVE_CAST((me_)), (margin_),          \
                (enum_t)(sig_), (QParam)(par_)))
 
    bool QActive_postX_(QActive * const me, uint_fast8_t margin,
                        enum_t const sig, QParam const par);
 
    bool QActive_postXISR_(QActive * const me, uint_fast8_t margin,
                           enum_t const sig, QParam const par);
 
#else /* no event parameter */
 
    #define QACTIVE_POST(me_, sig_) do {                            \
        QActive * const ao_ = QF_ACTIVE_CAST((me_));                \
        ((void)(*((QActiveVtable const *)(ao_->super.vptr))->post)( \
                ao_, QF_NO_MARGIN, (enum_t)(sig_)));                \
    } while (false)
 
    #define QACTIVE_POST_X(me_, margin_, sig_)                        \
        ((*((QActiveVtable const *)((me_)->super.vptr))->post)((me_), \
                                   (margin_), (sig_)))
 
    bool QActive_postX_(QActive * const me, uint_fast8_t margin,
                        enum_t const sig);
 
    #define QACTIVE_POST_ISR(me_, sig_) do {                           \
        QActive * const ao_ = QF_ACTIVE_CAST((me_));                   \
        ((void)(*((QActiveVtable const *)(ao_->super.vptr))->postISR)( \
                ao_, QF_NO_MARGIN, (enum_t)(sig_)));                   \
    } while (false)
 
    #define QACTIVE_POST_X_ISR(me_, margin_, sig_)                     \
        ((*((QActiveVtable const *)(                                   \
            QF_ACTIVE_CAST((me_))->super.vptr))->postISR)(             \
                QF_ACTIVE_CAST((me_)), (margin_), (enum_t)(sig_)))
 
    bool QActive_postXISR_(QActive * const me, uint_fast8_t margin,
                           enum_t const sig);
#endif
 
#if (QF_TIMEEVT_CTR_SIZE != 0U)
 
    void QF_tickXISR(uint_fast8_t const tickRate);
 
#ifdef QF_TIMEEVT_PERIODIC
    void QActive_armX(QActive * const me, uint_fast8_t const tickRate,
                      QTimeEvtCtr const nTicks, QTimeEvtCtr const interval);
#else
    void QActive_armX(QActive * const me, uint_fast8_t const tickRate,
                      QTimeEvtCtr const nTicks);
#endif
 
    void QActive_disarmX(QActive * const me, uint_fast8_t const tickRate);
 
#endif /* (QF_TIMEEVT_CTR_SIZE != 0U) */
 
 
/****************************************************************************/
/* QF-nano protected methods ...*/
 
void QF_init(uint_fast8_t maxActive);
 
void QF_stop(void);
 
void QF_onStartup(void);
 
int_t QF_run(void);
 
 
/****************************************************************************/
typedef struct {
    QActive  *act;   
    QEvt     *queue; 
    uint8_t   qlen;  
} QActiveCB;
 
/*lint -save -e9067 MISRA-C:2012 Rule 8.11, extern array declared without size */
extern QActiveCB const Q_ROM QF_active[];
/*lint -restore */
 
extern uint_fast8_t QF_maxActive_;
 
extern uint_fast8_t volatile QF_readySet_;
 
#ifndef QF_LOG2
 
    extern uint8_t const Q_ROM QF_log2Lkup[16];
 
#endif
 
 
#ifdef QF_TIMEEVT_USAGE
 
    extern uint_fast8_t volatile QF_timerSetX_[QF_MAX_TICK_RATE];
 
#endif  /* QF_TIMEEVT_USAGE */
 
 
extern uint8_t const Q_ROM QF_invPow2Lkup[9];
 
 
/****************************************************************************/
#define QF_ROM_QUEUE_AT_(ao_, i_) (((QEvt *)Q_ROM_PTR((ao_)->queue))[(i_)])
 
#define QF_ROM_ACTIVE_GET_(p_) ((QActive *)Q_ROM_PTR(QF_active[(p_)].act))
 
#define QF_ACTIVE_CAST(a_)     ((QActive *)(a_))
 
#endif /* QFN_H */