qpcpp/doxygen/api.dox

@namespace QP {

/*! @page api API Reference

@tableofcontents

@section api_qep QEP (Hierarchical State Machines)
QEP is a universal, UML-compliant event processor that enables developers to code UML state machines in highly readable ANSI-C, in which every state machine element is mapped to code precisely, unambiguously, and exactly once (traceability). QEP fully supports hierarchical state nesting, which is the fundamental mechanism for reusing behavior across many states instead of repeating the same actions and transitions over and over again.

<div class="separate"></div>
@subsection api_qep_hsm Hierarchical State Machines
- QHsm class
- QHsm::QHsm()
- QHsm::init()
- QHsm::dispatch()
- QHsm::isIn()
- QHsm::state()
- QHsm::top()
- QMsm class
- QMsm::QMsm()
- QMsm::isInState()
- QMsm::stateObj()
- Q_STATE_CAST()
- Q_EVT_CAST()


------------------------------------------------------------------------------
@section api_qf QF (Active Object Framework)
QF is a portable, event-driven, real-time framework for execution of active objects (concurrent state machines) specifically designed for real-time embedded (RTE) systems.

<div class="separate"></div>
@subsection api_qf_act Active Objects
- QActive class
- QActive::QActive()
- QActive::start()
- %QActive:: POST()
- %QActive:: POST_X()
- QActive::postLIFO()
- QActive::defer()
- QActive::recall()
- QActive::flushDeferred()
- QActive::stop()
- QMActive class
- QMActive::QMActive()

<div class="separate"></div>
@subsection api_qf_ps Publish-Subscribe
- ::QSubscrList (Subscriber List struct)
- QF::psInit()
- %QF:: PUBLISH()
- QActive::subscribe()
- QActive::unsubscribe()
- QActive::unsubscribeAll()

<div class="separate"></div>
@subsection api_qf_evt Dynamic Events
- QEvt class
- Q_NEW()
- Q_NEW_X()
- Q_NEW_REF()
- Q_DELETE_REF()
- QF::gc()

<div class="separate"></div>
@subsection api_qf_time Time Events
- QTimeEvt class
- QTimeEvt::QTimeEvt(QActive * const, enum_t const, uint_fast8_t const)
- QTimeEvt::armX()
- QTimeEvt::disarm()
- QTimeEvt::rearm()
- QTimeEvt::ctr()
- QTicker active object
- %QF:: TICK()
- %QF:: TICK_X()

<div class="separate"></div>
@subsection api_qf_queue Event Queues (raw thread-safe)
- QEQueue class
- QEQueue::init()
- QEQueue::post()
- QEQueue::postLIFO()
- QEQueue::get()
- QEQueue::getNFree()
- QEQueue::getNMin()
- QEQueue::isEmpty()
- QEQueueCtr()

<div class="separate"></div>
@subsection api_qf_mem Memory Pools
- QMPool class
- QMPool::init()
- QMPool::get()
- QMPool::put()


------------------------------------------------------------------------------
@section api_qs QS ("Quantum Spy" Software Tracing)
QS is a software tracing system that enables developers to monitor live event-driven QP applications with minimal target system resources and without stopping or significantly slowing down the code. QS is an ideal tool for testing, troubleshooting, and optimizing QP applications. QS can even be used to support acceptance testing in product manufacturing.

<div class="separate"></div>
@subsection api_qs_ini QS Initialization and Control
- QS_INIT()
- QS::initBuf()
- QS::getByte()
- QS::getBlock()
- QS::onStartup()
- QS::onCleanup()
- QS::onFlush()
- QS::onGetTime()

<div class="separate"></div>
@subsection api_qs_rx QS Receive-Channel (QS-RX)
- QS::rxInitBuf()
- QS::rxPut()
- QS::rxParse()
- QS::onCommand()

<div class="separate"></div>
@subsection api_qs_filter QS Filters
- QS_FILTER_ON()
- QS_FILTER_OFF()
- QS_FILTER_SM_OBJ()
- QS_FILTER_AO_OBJ()
- QS_FILTER_MP_OBJ()
- QS_FILTER_EQ_OBJ()
- QS_FILTER_TE_OBJ()
- QS_FILTER_AP_OBJ()

<div class="separate"></div>
@subsection api_qs_dict QS Dictionaries
- QS_SIG_DICTIONARY()
- QS_OBJ_DICTIONARY()
- QS_FUN_DICTIONARY()
- QS_USR_DICTIONARY()

<div class="separate"></div>
@subsection api_qs_user QS Application-Specific Records
- ::QS_USER enumeration
- QS_BEGIN()
- QS_END()
- QS_U8() / QS_I8()
- QS_U16() / QS_I16()
- QS_U32() / QS_I32()
- QS_U32_HEX()
- QS_STR()
- QS_MEM()


------------------------------------------------------------------------------
@section api_qv QV (Cooperative Kernel)
QV is a simple **cooperative** kernel (previously called "Vanilla" kernel). This kernel executes active objects one at a time, with priority-based scheduling performed before processing of each event. Due to naturally short duration of event processing in state machines, the simple QV kernel is often adequate for many real-time systems.

The QV scheduler is engaged after every RTC step of any @termref{active object} to choose the next active object to execute. The QV scheduler always chooses the highest-priority active object that has any events in its event queue. The QV scheduler then extracts the next event from this queue and dispatches it to the state machine associated with the active object. The state machine runs to completion, after which the QV scheduler runs and the cycle repeats.

Please note that because the state machines always return to the QV scheduler after each RTC step, a single stack can be used to process all state machines (memory-friendly architecture).

The QV scheduler can also very easily detect when all event queues are empty, at which point it can call the idle callback to let the application put the CPU and peripherals to a low-power sleep mode (power-friendly architecture).

Given the simplicity, portability, and low-resource consumption, the QV scheduler is very attractive. It allows you to partition the problem into active objects and execute these active objects orderly. The task-level response of this scheduler is the longest RTC step in the whole system, but because event-driven active objects don’t block, the RTC steps tend to be very short (typically just a few microseconds). Also, often you can break up longer RTC steps into shorter pieces, by posting an event to self and returning (“Reminder” state pattern). The self-posted event then triggers the continuation of longer processing.

<div class="separate"></div>
@subsection api_qv_init Kernel Initialization and Control
- QV_INIT()
- <a href="qv_8c.html#a779a1bc9482e2d489dc87751cd100fdb"><b>QF_run()</b></a>
- QV::onIdle()
- QV_CPU_SLEEP()
- QV::getVersion()


------------------------------------------------------------------------------
@section api_qk QK (Preemptive Run-to-Completion Kernel)
QK is a tiny **preemptive**, priority-based, non-blocking kernel designed specifically for executing active objects. QK runs active objects in the same way as prioritized interrupt controller (such as NVIC in ARM Cortex-M) runs interrupts using the single stack. Active objects process their events in run-to-completion (RTC) fashion and remove themselves from the call stack, the same way as nested interrupts remove themselves from the stack upon completion. At the same time high-priority active objects can preempt lower-priority active objects, just like interrupts can preempt each other under a prioritized interrupt controller. QK meets all the requirement of the Rate Monotonic Scheduling (a.k.a. Rate Monotonic Analysis RMA) and can be used in hard real-time systems.


<div class="separate"></div>
@subsection api_qk_ctrl Kernel Initialization and Control
- QK_INIT()
- <a href="qk_8c.html#a779a1bc9482e2d489dc87751cd100fdb"><b>QF_run()</b></a>
- QK::onIdle()
- QK::schedLock()
- QK::schedUnlock()
- QK::getVersion()


<div class="separate"></div>
@subsection api_qk_isr Interrupt Management
- QK_ISR_ENTRY()
- QK_ISR_EXIT()


------------------------------------------------------------------------------
@section api_qxk QXK (Preemptive Dual-Mode Run-to-Completion/Blocking RTOS Kernel)
QXK is a small, preemptive, priority-based, dual-mode **blocking** kernel that executes active objects like the @ref qk "QK kernel", but can also execute traditional __blocking__ threads (extended threads). In this respect, QXK behaves exactly as a conventional __RTOS__ (Real-Time Operating System). QXK has been designed specifically for mixing event-driven active objects with traditional blocking code, such as commercial middleware (TCP/IP stacks, UDP stacks, embedded file systems, etc.) or legacy software.


<div class="separate"></div>
@subsection api_qxk_ctrl Kernel Initialization and Control
- QXK_INIT()
- <a href="qxk_8c.html#a779a1bc9482e2d489dc87751cd100fdb"><b>QF_run()</b></a>
- QXK::onIdle()
- QXK::schedLock()
- QXK::schedUnlock()
- QXK::getVersion()


<div class="separate"></div>
@subsection api_qxk_isr Interrupt Management
- QXK_ISR_ENTRY()
- QXK_ISR_EXIT()


<div class="separate"></div>
@subsection api_qxk_xthr Extended Thread Management
- QXThread class
- QXThread::QXThread()
- QXThread::start()
- QXThread::delay()
- QXThread::delayCancel()
- QXThread::queueGet()
- Q_XTHREAD_CAST()


<div class="separate"></div>
@subsection api_qxk_sema Semaphores
- QXSemaphore class (Semaphore Control Block)
- QXSemaphore::init()
- QXSemaphore::wait()
- QXSemaphore::tryWait()
- QXSemaphore::signal()


<div class="separate"></div>
@subsection api_qxk_mutex Mutexes
- QXMutex class (Mutex Control Block)
- QXMutex::init()
- QXMutex::lock()
- QXMutex::tryLock()
- QXMutex::unlock()


<div class="separate"></div>
@subsection api_qxk_queue Message Queues
- %QXThread:: POST()
- %QXThread:: POST_X()
- QXThread::queueGet() - waiting (blocking) on message queue


<div class="separate"></div>
@subsection api_qxk_mem Memory Pools
- QMPool class
- QMPool::init()
- QMPool::get()
- QMPool::put()


<div class="separate"></div>
@subsection api_qxk_tls Thread-Local Storage
- QXK_current()
- QXK_TLS()


@next{exa}
*/

} // namespace QP