qf.h

Go to the documentation of this file.

#ifndef qf_h
#define qf_h

#ifndef qpset_h
#include "qpset.h"
#endif

/****************************************************************************/
#ifndef QF_EVENT_SIZ_SIZE

    #define QF_EVENT_SIZ_SIZE 2
#endif
#if (QF_EVENT_SIZ_SIZE == 1)
    typedef uint8_t QEvtSize;
#elif (QF_EVENT_SIZ_SIZE == 2)

    typedef uint16_t QEvtSize;
#elif (QF_EVENT_SIZ_SIZE == 4)
    typedef uint32_t QEvtSize;
#else
    #error "QF_EVENT_SIZ_SIZE defined incorrectly, expected 1, 2, or 4"
#endif

#ifndef QF_MAX_EPOOL

    #define QF_MAX_EPOOL         3
#endif

#ifndef QF_MAX_TICK_RATE

    #define QF_MAX_TICK_RATE     1
#elif (QF_MAX_TICK_RATE > 15)
    #error "QF_MAX_TICK_RATE exceeds the maximum of 15"
#endif

#ifndef QF_TIMEEVT_CTR_SIZE

    #define QF_TIMEEVT_CTR_SIZE  2
#endif

/****************************************************************************/
struct QEQueue; /* forward declaration */

/****************************************************************************/
typedef struct QActive {
    QHsm super; 
#ifdef QF_EQUEUE_TYPE

    QF_EQUEUE_TYPE eQueue;
#endif

#ifdef QF_OS_OBJECT_TYPE

    QF_OS_OBJECT_TYPE osObject;
#endif

#ifdef QF_THREAD_TYPE

    QF_THREAD_TYPE thread;
#endif

    uint8_t prio;

#ifdef qxk_h  /* QXK kernel used? */

    uint8_t startPrio;
#endif

} QActive;

void QActive_ctor(QActive * const me, QStateHandler initial);

typedef struct {
    struct QHsmVtbl super; 
    void (*start)(QActive * const me, uint_fast8_t prio,
                  QEvt const *qSto[], uint_fast16_t qLen,
                  void *stkSto, uint_fast16_t stkSize,
                  QEvt const *ie);

#ifdef Q_SPY

    bool (*post)(QActive * const me, QEvt const * const e,
                 uint_fast16_t const margin, void const * const sender);
#else
    bool (*post)(QActive * const me, QEvt const * const e,
                 uint_fast16_t const margin);
#endif

    void (*postLIFO)(QActive * const me, QEvt const * const e);

} QActiveVtbl;


#define QACTIVE_START(me_, prio_, qSto_, qLen_, stkSto_, stkLen_, par_) do { \
    Q_ASSERT((me_)->super.vptr);                                             \
    (*((QActiveVtbl const *)((me_)->super.vptr))->start)(                    \
        (me_), (prio_), (qSto_), (qLen_), (stkSto_), (stkLen_), (par_));     \
} while (0)

#ifdef Q_SPY

    #define QACTIVE_POST(me_, e_, sender_)                                \
        ((void)(*((QActiveVtbl const *)((me_)->super.vptr))->post)((me_), \
                  (e_), QF_NO_MARGIN, (sender_)))

    #define QACTIVE_POST_X(me_, e_, margin_, sender_)               \
        ((*((QActiveVtbl const *)((me_)->super.vptr))->post)((me_), \
         (e_), (margin_), (sender_)))
#else

    #define QACTIVE_POST(me_, e_, sender_)                                \
        ((void)(*((QActiveVtbl const *)((me_)->super.vptr))->post)((me_), \
                  (e_), QF_NO_MARGIN))

    #define QACTIVE_POST_X(me_, e_, margin_, sender_)               \
        ((*((QActiveVtbl const *)((me_)->super.vptr))->post)((me_), \
                  (e_), (margin_)))

#endif

#define QACTIVE_POST_LIFO(me_, e_) \
    ((*((QActiveVtbl const *)((me_)->super.vptr))->postLIFO)((me_), (e_)))

/* protected functions for ::QActive ...*/

#ifdef QF_ACTIVE_STOP

    void QActive_stop(QActive * const me);
#endif

void QActive_subscribe(QActive const * const me, enum_t const sig);

void QActive_unsubscribe(QActive const * const me, enum_t const sig);

void QActive_unsubscribeAll(QActive const * const me);

bool QActive_defer(QActive const * const me,
                   QEQueue * const eq, QEvt const * const e);

bool QActive_recall(QActive * const me, QEQueue * const eq);

uint_fast16_t QActive_flushDeferred(QActive const * const me,
                                    QEQueue * const eq);

void QActive_setAttr(QActive *const me, uint32_t attr1, void const *attr2);


/****************************************************************************/
typedef QActive QMActive;

typedef QActiveVtbl QMActiveVtbl;

void QMActive_ctor(QMActive * const me, QStateHandler initial);


/****************************************************************************/
#if (QF_TIMEEVT_CTR_SIZE == 1)
    typedef uint8_t QTimeEvtCtr;
#elif (QF_TIMEEVT_CTR_SIZE == 2)

    typedef uint16_t QTimeEvtCtr;
#elif (QF_TIMEEVT_CTR_SIZE == 4)
    typedef uint32_t QTimeEvtCtr;
#else
    #error "QF_TIMEEVT_CTR_SIZE defined incorrectly, expected 1, 2, or 4"
#endif

typedef struct QTimeEvt {
    QEvt super; /*<! inherits ::QEvt */

    struct QTimeEvt * volatile next;

    void * volatile act;

    QTimeEvtCtr volatile ctr;

    QTimeEvtCtr interval;
} QTimeEvt;

/* public functions */

void QTimeEvt_ctorX(QTimeEvt * const me, QActive * const act,
                    enum_t const sig, uint_fast8_t tickRate);

void QTimeEvt_armX(QTimeEvt * const me,
                   QTimeEvtCtr const nTicks, QTimeEvtCtr const interval);

bool QTimeEvt_rearm(QTimeEvt * const me, QTimeEvtCtr const nTicks);

bool QTimeEvt_disarm(QTimeEvt * const me);

bool QTimeEvt_wasDisarmed(QTimeEvt * const me);

QTimeEvtCtr QTimeEvt_currCtr(QTimeEvt const * const me);


/****************************************************************************/
/* QF facilities */

typedef QPSet QSubscrList;

/* public functions */

void QF_init(void);

void QF_psInit(QSubscrList * const subscrSto, enum_t const maxSignal);

void QF_poolInit(void * const poolSto, uint_fast32_t const poolSize,
                 uint_fast16_t const evtSize);

uint_fast16_t QF_poolGetMaxBlockSize(void);

int_t QF_run(void);

void QF_stop(void);

void QF_onStartup(void);

void QF_onCleanup(void);

#ifdef Q_SPY

    void QF_publish_(QEvt const * const e, void const * const sender);

    #define QF_PUBLISH(e_, sender_) \
        (QF_publish_((e_), (void const *)(sender_)))
#else

    void QF_publish_(QEvt const * const e);
    #define QF_PUBLISH(e_, dummy_)   (QF_publish_(e_))

#endif

#ifdef Q_SPY

    void QF_tickX_(uint_fast8_t const tickRate, void const * const sender);

    #define QF_TICK_X(tickRate_, sender_) (QF_tickX_((tickRate_), (sender_)))

#else

    void QF_tickX_(uint_fast8_t const tickRate);
    #define QF_TICK_X(tickRate_, dummy)   (QF_tickX_(tickRate_))

#endif

#define QF_NO_MARGIN ((uint_fast16_t)0xFFFF)

#define QF_TICK(sender_)   QF_TICK_X((uint_fast8_t)0, (sender_))

bool QF_noTimeEvtsActiveX(uint_fast8_t const tickRate);

void QF_add_(QActive * const a);

void QF_remove_(QActive * const a);

uint_fast16_t QF_getPoolMin(uint_fast8_t const poolId);

uint_fast16_t QF_getQueueMin(uint_fast8_t const prio);

QEvt *QF_newX_(uint_fast16_t const evtSize,
               uint_fast16_t const margin, enum_t const sig);

QEvt const *QF_newRef_(QEvt const * const e, void const * const evtRef);

void QF_deleteRef_(void const * const evtRef);

#ifdef Q_EVT_CTOR /* Shall the ctor for the ::QEvt class be provided? */

    #define Q_NEW(evtT_, sig_, ...)                                   \
        (evtT_##_ctor((evtT_ *)QF_newX_((uint_fast16_t)sizeof(evtT_), \
                      QF_NO_MARGIN, (enum_t)0), (sig_), ##__VA_ARGS__))

    #define Q_NEW_X(e_, evtT_, margin_, sig_, ...) do {        \
        (e_) = (evtT_ *)QF_newX_((uint_fast16_t)sizeof(evtT_), \
                                 (margin_), (enum_t)0);        \
        if ((e_) != (evtT_ *)0) {                              \
            evtT_##_ctor((e_), (sig_), ##__VA_ARGS__);         \
        } \
     } while (0)

#else

    #define Q_NEW(evtT_, sig_)                           \
        ((evtT_ *)QF_newX_((uint_fast16_t)sizeof(evtT_), \
                           QF_NO_MARGIN, (sig_)))

    #define Q_NEW_X(e_, evtT_, margin_, sig_) ((e_) = \
        (evtT_ *)QF_newX_((uint_fast16_t)sizeof(evtT_), (margin_), (sig_)))

#endif /* Q_EVT_CTOR */

#define Q_NEW_REF(evtRef_, evtT_)  \
    ((evtRef_) = (evtT_ const *)QF_newRef_(e, (evtRef_)))

#define Q_DELETE_REF(evtRef_) do { \
    QF_deleteRef_((evtRef_)); \
    (evtRef_) = (void *)0; \
} while (0)

void QF_gc(QEvt const * const e);

void QF_bzero(void * const start, uint_fast16_t len);

#ifndef QF_CRIT_EXIT_NOP

    #define QF_CRIT_EXIT_NOP()   ((void)0)
#endif

extern QActive *QF_active_[QF_MAX_ACTIVE + 1];


/****************************************************************************/
typedef QActive QTicker;

void QTicker_ctor(QTicker * const me, uint8_t tickRate);

/****************************************************************************/
#define QF_getVersion() (QP_versionStr)

#endif /* qf_h */