QP/C  5.8.2
qxk.c File Reference

QXK preemptive dual-mode kernel core functions. More...

#include "qf_port.h"
#include "qxk_pkg.h"
#include "qassert.h"
#include "qs_port.h"

Go to the source code of this file.

Macros

#define QP_IMPL   /* this is QP implementation */
 

Functions

void QF_init (void)
 QF initialization. More...
 
void QF_stop (void)
 Function invoked by the application layer to stop the QF application and return control to the OS/Kernel. More...
 
static void initial_events (void)
 process all events posted during initialization
 
int_t QF_run (void)
 Transfers control to QF to run the application. More...
 
void QActive_start_ (QActive *const me, uint_fast8_t prio, QEvt const *qSto[], uint_fast16_t qLen, void *stkSto, uint_fast16_t stkSize, QEvt const *ie)
 Implementation of the active object start operation. More...
 
void QActive_stop (QActive *const me)
 Stops execution of an active object and removes it from the framework's supervision. More...
 
uint_fast8_t QXK_sched_ (void)
 QXK scheduler finds the highest-priority thread ready to run. More...
 
void QXK_activate_ (void)
 QXK activator activates the next active object. More...
 

Variables

QXK_Attr QXK_attr_
 global attributes of the QXK kernel
 
static QXThread l_idleThread
 

Detailed Description

QXK preemptive dual-mode kernel core functions.

Definition in file qxk.c.

Function Documentation

◆ QActive_start_()

void QActive_start_ ( QActive *const  me,
uint_fast8_t  prio,
QEvt const *  qSto[],
uint_fast16_t  qLen,
void *  stkSto,
uint_fast16_t  stkSize,
QEvt const *  ie 
)

Implementation of the active object start operation.

Description
Starts execution of the AO and registers the AO with the framework. Also takes the top-most initial transition in the AO's state machine. This initial transition is taken in the callee's thread of execution.
Parameters
[in,out]mepointer (see Object Orientation)
[in]priopriority at which to start the active object
[in]qStopointer to the storage for the ring buffer of the event queue (used only with the built-in QEQueue)
[in]qLenlength of the event queue (in events)
[in]stkStopointer to the stack storage (used only when per-AO stack is needed)
[in]stkSizestack size (in bytes)
[in]iepointer to the initial event (might be NULL).
Note
This function should be called via the macro QACTIVE_START().
Usage
The following example shows starting an AO when a per-task stack is needed:
int main() {
static Philo l_philo[N]; /* N Philo active objects */
static QEvt const *l_philQueueSto[N][N]; /* storage for event queues */
static int l_philoStk[N][256]; /* stacks for the Philo active objects */
. . .
for (n = 0; n < N; ++n) {
TableEvt ie; /* initialization event for the Philo SM */
ie.philNum = n;
Philo_ctor(&l_philo[n]);
QACTIVE_START((QActive *)&l_philo[n], /* Philo pointer */
(uint_fast8_t)(n*10 + 1), /* priority */
l_philoQueueSto[n], Q_DIM(l_philoQueueSto[n]), /* queue */
l_philoStk[n], sizeof(l_philoStk[n]), /* per AO stack */
&ie.super); /* initialization event */
}
. . .
}
Precondition
the priority must be in range and the stack storage must not be provided, because the QV kernel does not need per-AO stacks.

Definition at line 174 of file qxk.c.

◆ QActive_stop()

void QActive_stop ( QActive *const  me)

Stops execution of an active object and removes it from the framework's supervision.

Description
This function must be called from within the AO that needs to stop. In other words, an AO should stop itself rather than being stopped by someone else. This policy works best, because only the AO itself "knows" when it has reached the appropriate state for the shutdown.
Note
By the time the AO calls QActive_stop(), it should have unsubscribed from all events and no more events should be directly-posted to it.
Precondition
QActive_stop() must be called from the AO that wants to stop.

Definition at line 218 of file qxk.c.

◆ QF_init()

void QF_init ( void  )

QF initialization.

Description
Initializes QF and must be called exactly once before any other QF function. Typically, QF_init() is called from main() even before initializing the Board Support Package (BSP).
Note
QF_init() clears the internal QF variables, so that the framework can start correctly even if the startup code fails to clear the uninitialized data (as is required by the C Standard).

Definition at line 74 of file qxk.c.

◆ QF_run()

int_t QF_run ( void  )

Transfers control to QF to run the application.

Description
QP::QF::run() is typically called from your startup code after you initialize the QF and start at least one basic- or extended-thread (with QP::QActive::start() or QP::QXThread::start(), respectively).
Returns
In QXK, the QF_run() function does not return.

Definition at line 135 of file qxk.c.

◆ QF_stop()

void QF_stop ( void  )

Function invoked by the application layer to stop the QF application and return control to the OS/Kernel.

Description
This function stops the QF application. After calling this function, QF attempts to gracefully stop the application. This graceful shutdown might take some time to complete. The typical use of this function is for terminating the QF application to return back to the operating system or for handling fatal errors that require shutting down (and possibly re-setting) the system.
See also
QF_onCleanup()

Definition at line 109 of file qxk.c.

◆ QXK_activate_()

void QXK_activate_ ( void  )

QXK activator activates the next active object.

Attention
QXK_activate_() must be always called with interrupts disabled and returns with interrupts disabled.
Note
The activate function might enable interrupts internally, but it always returns with interrupts disabled.

Definition at line 325 of file qxk.c.

◆ QXK_sched_()

uint_fast8_t QXK_sched_ ( void  )

QXK scheduler finds the highest-priority thread ready to run.

Description
The QXK scheduler finds the priority of the highest-priority thread that is ready to run.
Returns
the 1-based priority of the the active object to run next, or zero if no eligible active object is found.
Attention
QXK_sched_() must be always called with interrupts disabled and returns with interrupts disabled.

Definition at line 247 of file qxk.c.