qk.h

Go to the documentation of this file.

// Product: QK/C++ platform-independent public interface
// Last Updated for Version: 4.3.00
// Date of the Last Update:  Nov 01, 2011
//
//                    Q u a n t u m     L e a P s
//                    ---------------------------
//                    innovating embedded systems
//
// Copyright (C) 2002-2011 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 <= 8U)
#ifdef Q_USE_NAMESPACE
    extern "C" QP::QPSet8  volatile QK_readySet_;         
#else
    extern "C" QPSet8  volatile QK_readySet_;             
#endif
#else
#ifdef Q_USE_NAMESPACE
    extern "C" QP::QPSet64 volatile QK_readySet_;         
#else
    extern "C" QPSet64 volatile QK_readySet_;             
#endif
#endif

extern "C" uint8_t volatile QK_currPrio_; 
extern "C" 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) { \
        uint8_t p = QK_schedPrio_(); \
        if (p != (uint8_t)0) { \
            QK_sched_(p); \
        } \
    } 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_))

#ifdef Q_USE_NAMESPACE
namespace QP {
#endif


#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 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

};

#ifdef Q_USE_NAMESPACE
}                                                              // namespace QP
#endif


extern "C" {

void QK_init(void);

void QK_sched_(uint8_t p);

void QK_schedExt_(uint8_t p);

uint8_t QK_schedPrio_(void);

}                                                                // 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