qf.h

Go to the documentation of this file.

// Product: QP/C++
// Last Updated for Version: 4.5.04
// Date of the Last Update:  Feb 04, 2013
//
//                    Q u a n t u m     L e a P s
//                    ---------------------------
//                    innovating embedded systems
//
// Copyright (C) 2002-2013 Quantum Leaps, LLC. All rights reserved.
//
// This program is open source 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 2 of the License, or
// (at your option) any later version.
//
// Alternatively, this program may be distributed and modified under the
// terms of Quantum Leaps commercial licenses, which expressly supersede
// the GNU General Public License and are specifically designed for
// licensees interested in retaining the proprietary status of their code.
//
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Quantum Leaps Web sites: http://www.quantum-leaps.com
//                          http://www.state-machine.com
// e-mail:                  info@quantum-leaps.com
#ifndef qf_h
#define qf_h


#ifdef Q_EVT_CTOR
#include <new>                                            // for placement new
#endif

// apply defaults for all undefined configuration parameters
//
#ifndef QF_EVENT_SIZ_SIZE

    #define QF_EVENT_SIZ_SIZE    2
#endif

#ifndef QF_MAX_EPOOL

    #define QF_MAX_EPOOL         3
#endif

#ifndef QF_TIMEEVT_CTR_SIZE


    #define QF_TIMEEVT_CTR_SIZE  2
#endif

#if (QF_MAX_ACTIVE < 1) || (63 < QF_MAX_ACTIVE)
    #error "QF_MAX_ACTIVE not defined or out of range. Valid range is 1..63"
#endif

#ifndef QF_ACTIVE_SUPER_

    #define QF_ACTIVE_SUPER_  QHsm

    #define QF_ACTIVE_STATE_  QStateHandler

#endif

QP_BEGIN_

#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

#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

class QEQueue;                                          // forward declaration

class QActive : public QF_ACTIVE_SUPER_ {

#ifdef QF_EQUEUE_TYPE









    QF_EQUEUE_TYPE m_eQueue;
#endif

#ifdef QF_OS_OBJECT_TYPE






    QF_OS_OBJECT_TYPE m_osObject;
#endif

#ifdef QF_THREAD_TYPE






    QF_THREAD_TYPE m_thread;
#endif

    uint8_t m_prio;

public:
    void start(uint8_t const prio,
               QEvt const *qSto[], uint32_t const qLen,
               void * const stkSto, uint32_t const stkSize,
               QEvt const * const ie = static_cast<QEvt *>(0));

#ifndef Q_SPY
    void postFIFO(QEvt const * const e);
#else
    void postFIFO(QEvt const * const e, void const * const sender);
#endif

    void unsubscribeAll(void) const;

protected:
    QActive(QF_ACTIVE_STATE_ const initial) : QF_ACTIVE_SUPER_(initial) {
    }

    void postLIFO(QEvt const * const e);

    void stop(void);

    void subscribe(enum_t const sig) const;

    void unsubscribe(enum_t const sig) const;

    void defer(QEQueue * const eq, QEvt const * const e) const;

    bool recall(QEQueue * const eq);

private:

    QEvt const *get_(void);

    friend class QF;
    friend class QTimeEvt;

#ifdef qk_h                                                // is this QK port?
    friend void ::QK_schedExt_(uint8_t p);
    friend void ::QK_sched_(uint8_t p);
#endif

};

class QTimeEvt : public QEvt {
private:

    QTimeEvt *m_next;

    QActive *m_act;

    QTimeEvtCtr m_ctr;

    QTimeEvtCtr m_interval;

public:

    QTimeEvt(enum_t const s);

    void postIn(QActive * const act, QTimeEvtCtr const nTicks) {
        m_interval = static_cast<QTimeEvtCtr>(0);
        arm_(act, nTicks);
    }

    void postEvery(QActive * const act, QTimeEvtCtr const nTicks) {
        m_interval = nTicks;
        arm_(act, nTicks);
    }

    bool disarm(void);

    bool rearm(QTimeEvtCtr const nTicks);

    QTimeEvtCtr ctr(void) const;

private:

    void arm_(QActive * const act, QTimeEvtCtr const nTicks);

    friend class QF;
};


uint8_t const QF_SUBSCR_LIST_SIZE =
    static_cast<uint8_t>(((QF_MAX_ACTIVE - 1) / 8) + 1);

class QSubscrList {
private:

    uint8_t m_bits[QF_SUBSCR_LIST_SIZE];

    friend class QF;
    friend class QActive;
};

class QF {
public:

    static void init(void);

    static void psInit(QSubscrList * const subscrSto,
                       uint32_t const maxSignal);

    static void poolInit(void * const poolSto, uint32_t const poolSize,
                         uint32_t const evtSize);

    static int16_t run(void);

    static void onStartup(void);

    static void onCleanup(void);

    static void onIdle(void);

    static void stop(void);

#ifndef Q_SPY
    static void publish(QEvt const *e);
#else
    static void publish(QEvt const *e, void const *sender);
#endif

#ifndef Q_SPY
    static void tick(void);
#else
    static void tick(void const * const sender);
#endif

    static bool noTimeEvtsActive(void);

    static char_t const Q_ROM * Q_ROM_VAR getVersion(void);

    static uint32_t getPoolMargin(uint8_t const poolId);

    static uint32_t getQueueMargin(uint8_t const prio);

    static QEvt *new_(QEvtSize const evtSize, enum_t const sig);

    static void gc(QEvt const *e);

private:                              // functions to be used in QF ports only

    static void add_(QActive * const a);

public:
    static void remove_(QActive const * const a);

    static QActive *active_[];

    static void thread_(QActive *act);

    friend class QActive;
};

QP_END_

#ifdef Q_EVT_CTOR               // Provide the constructor for the QEvt class?

    #define Q_NEW(evtT_, sig_, ...) \
        (new(QP_ QF::new_( \
            static_cast<QP_ QEvtSize>(sizeof(evtT_)), (sig_))) \
            evtT_((sig_),  ##__VA_ARGS__))
#else                                    // QEvt is a POD (Plain Old Datatype)

    #define Q_NEW(evtT_, sig_) \
        (static_cast<evtT_ *>( \
            QP_ QF::new_(static_cast<QP_ QEvtSize>(sizeof(evtT_)), (sig_))))
#endif

// QS software tracing integration, only if enabled
#ifdef Q_SPY                                   // QS software tracing enabled?

    #define TICK(sender_)                  tick(sender_)

    #define PUBLISH(e_, sender_)           publish((e_), (sender_))

    #define POST(e_, sender_)              postFIFO((e_), (sender_))

#else

    #define TICK(dummy_)                   tick()
    #define PUBLISH(e_, dummy_)            publish(e_)
    #define POST(e_, dummy_)               postFIFO(e_)

#endif                                                                // Q_SPY

#endif                                                                 // qf_h