qk.h

Go to the documentation of this file.

// Product: QK/C++ platform-independent public interface
// Last Updated for Version: 4.0.03
// Date of the Last Update:  Dec 26, 2008
//
//                    Q u a n t u m     L e a P s
//                    ---------------------------
//                    innovating embedded systems
//
// Copyright (C) 2002-2008 Quantum Leaps, LLC. All rights reserved.
//
// This software may be distributed and modified under the terms of the GNU
// General Public License version 2 (GPL) as published by the Free Software
// Foundation and appearing in the file GPL.TXT included in the packaging of
// this file. Please note that GPL Section 2[b] requires that all works based
// on this software must also be made publicly available under the terms of
// the GPL ("Copyleft").
//
// Alternatively, this software may be distributed and modified under the
// terms of Quantum Leaps commercial licenses, which expressly supersede
// the GPL and are specifically designed for licensees interested in
// retaining the proprietary status of their code.
//
// Contact information:
// Quantum Leaps Web site:  http://www.quantum-leaps.com
// e-mail:                  info@quantum-leaps.com
#ifndef qk_h
#define qk_h


#include "qequeue.h"          // The QK kernel uses the native QF event queue
#include "qmpool.h"           // The QK kernel uses the native QF memory pool
#include "qpset.h"            // The QK kernel uses the native QF priority set


// QF configuration for QK

#define QF_EQUEUE_TYPE             QEQueue

#if defined(QK_TLS) || defined(QK_EXT_SAVE)











    #define QF_OS_OBJECT_TYPE      uint8_t

    #define QF_THREAD_TYPE         void *
#endif                                             /* QK_TLS || QK_EXT_SAVE */

#if (QF_MAX_ACTIVE <= 8)
    extern QPSet8  volatile QK_readySet_;                 
#else
    extern QPSet64 volatile QK_readySet_;                 
#endif

extern uint8_t volatile QK_currPrio_;     
extern uint8_t volatile QK_intNest_;              

// QK active object queue implementation .....................................

// need to define the macro appropriately for the underlying kernel/OS you're
#define QACTIVE_EQUEUE_WAIT_(me_) \
    Q_ASSERT((me_)->m_eQueue.m_frontEvt != (QEvent *)0)

#define QACTIVE_EQUEUE_SIGNAL_(me_) \
    QK_readySet_.insert((me_)->m_prio); \
    if (QK_intNest_ == (uint8_t)0) { \
        QK_SCHEDULE_(); \
    } else ((void)0)

#define QACTIVE_EQUEUE_ONEMPTY_(me_) \
    QK_readySet_.remove((me_)->m_prio)

// QK event pool operations ..................................................

#define QF_EPOOL_TYPE_              QMPool

#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
    (p_).init(poolSto_, poolSize_, evtSize_)

#define QF_EPOOL_EVENT_SIZE_(p_)    ((p_).getBlockSize())

#define QF_EPOOL_GET_(p_, e_)       ((e_) = (QEvent *)(p_).get())

#define QF_EPOOL_PUT_(p_, e_)       ((p_).put(e_))

#ifndef QK_NO_MUTEX






    typedef uint8_t QMutex;
#endif                                                          // QK_NO_MUTEX

// \note The QK scheduler, QK priority, QK ready set, etc. belong conceptually
class QK {
public:

    static char const Q_ROM * Q_ROM_VAR getVersion(void);

    static char const Q_ROM * Q_ROM_VAR getPortVersion(void);

    static void onIdle(void);

#ifndef QK_NO_MUTEX

    // \note This function should be always paired with QK::mutexUnlock().
    static QMutex mutexLock(uint8_t prioCeiling);

    static void mutexUnlock(QMutex mutex);

#endif                                                          // QK_NO_MUTEX

};

extern "C" {

void QK_init(void);

// QK scheduler and extended scheduler
#ifndef QF_INT_KEY_TYPE
    void QK_schedule_(void);                                   // QK scheduler
    void QK_scheduleExt_(void);                       // QK extended scheduler

    #define QK_SCHEDULE_()    QK_schedule_()
#else

    void QK_schedule_(QF_INT_KEY_TYPE intLockKey);

    void QK_scheduleExt_(QF_INT_KEY_TYPE intLockKey); // QK extended scheduler

    #define QK_SCHEDULE_()    QK_schedule_(intLockKey_)

#endif
}                                                                // extern "C"

// QS software tracing integration, only if enabled
#ifdef Q_SPY                                   // QS software tracing enabled?
    #ifndef qs_h
    #include "qs_port.h"                                    // include QS port
    #endif
#else
    #ifndef qs_dummy_h
    #include "qs_dummy.h"                   // disable the QS software tracing
    #endif
#endif                                                                // Q_SPY

#endif                                                                 // qk_h

---