QF Active Object Framework. More...

Classes
class	Attr
	Private attributes of the QF framework. More...

Functions
void	init ()

void	stop ()

int_t	run ()

void	onStartup ()

void	onCleanup ()

void	psInit (QSubscrList *const subscrSto, enum_t const maxSignal) noexcept

void	publish_ (QEvt const const e, void const const sender, std::uint_fast8_t const qs_id) noexcept

void	tick (std::uint_fast8_t const tickRate, void const *const sender) noexcept

std::uint_fast16_t	getQueueMin (std::uint_fast8_t const prio) noexcept

void	poolInit (void *const poolSto, std::uint_fast32_t const poolSize, std::uint_fast16_t const evtSize) noexcept

std::uint_fast16_t	poolGetMaxBlockSize () noexcept

std::uint_fast16_t	getPoolMin (std::uint_fast8_t const poolId) noexcept

QEvt *	newX_ (std::uint_fast16_t const evtSize, std::uint_fast16_t const margin, enum_t const sig) noexcept

void	gc (QEvt const *const e) noexcept

QEvt const *	newRef_ (QEvt const const e, QEvt const const evtRef) noexcept

void	deleteRef_ (QEvt const *const evtRef) noexcept

void	bzero_ (void *const start, std::uint_fast16_t const len) noexcept

Variables
constexpr std::uint_fast16_t	NO_MARGIN {0xFFFFU}

QF::Attr	priv_

Detailed Description

QF Active Object Framework.

Function Documentation

◆ init()

void QP::QF::init ( void )

QF initialization

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).

Traceability

DVR-QP-MC4-R11_08

Definition at line 310 of file qk.cpp.

◆ stop()

void QP::QF::stop ( )

Invoked by the application layer to stop the QF framework and return control to the OS/Kernel (used in some QF ports).

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.

Attention: After calling QF_stop() the application must terminate and cannot continue. In particular, QF_stop() is not intended to be followed by a call to QF_init() to "resurrect" the application.

Definition at line 338 of file qk.cpp.

◆ run()

int_t QP::QF::run ( )

Transfers control to QF to run the application.

QF::run() is typically called from your startup code after you initialize the QF and start at least one active object with QActive::start().

Returns: Typically in embedded systems QF::run() does not return, but in case QF runs on top of a General-Purpose OS (GPOS), QF::run() returns the error status with value 0 representing success.

Definition at line 344 of file qk.cpp.

◆ onStartup()

QP::QF::onStartup ( )

Startup QF callback.

The purpose of the QF_onStartup() callback is to configure and enable hardware interrupts. The callback is invoked from QF_run(), right before starting the underlying real-time kernel. By that time, the application is considered ready to receive and service interrupts.

This function is application-specific and is not implemented in QF, but rather in the Board Support Package (BSP) for the given application.

◆ onCleanup()

void QP::QF::onCleanup ( )

◆ psInit()

void QP::QF::psInit	(	QSubscrList *const	subscrSto,
		enum_t const	maxSignal
	)

inlinenoexcept

Deprecated:

Definition at line 1036 of file qp.hpp.

◆ publish_()

void QP::QF::publish_	(	QEvt const *const	e,
		void const *const	sender,
		std::uint_fast8_t const	qs_id
	)

inlinenoexcept

Deprecated:

Definition at line 1045 of file qp.hpp.

◆ tick()

void QP::QF::tick	(	std::uint_fast8_t const	tickRate,
		void const *const	sender
	)

inlinenoexcept

Deprecated:

Definition at line 1055 of file qp.hpp.

◆ getQueueMin()

QP::QF::getQueueMin ( std::uint_fast8_t const prio )

inlinenoexcept

Deprecated:

This function returns the minimum of free entries of the given event queue.

Queries the minimum of free ever present in the given event queue of an active object with priority prio, since the active object was started.

Note: This function is available only when the native QF event queue implementation is used. Requesting the queue minimum of an unused priority level raises an assertion in the QF. (A priority level becomes used in QF after the call to the QActive_register_() function.)

Parameters

[in] prio Priority of the active object, whose queue is queried

Returns: The minimum of free ever present in the given event queue of an active object with priority prio, since the active object was started.

Definition at line 1064 of file qp.hpp.

◆ poolInit()

void QP::QF::poolInit	(	void *const	poolSto,
		std::uint_fast32_t const	poolSize,
		std::uint_fast16_t const	evtSize
	)

noexcept

Event pool initialization for dynamic allocation of events.

This function initializes one event pool at a time and must be called exactly once for each event pool before the pool can be used.

Parameters

[in]	poolSto	pointer to the storage for the event pool
[in]	poolSize	size of the storage for the pool in bytes
[in]	evtSize	the block-size of the pool in bytes, which determines the maximum size of events that can be allocated from the pool.

Precondition qf_dyn:200

the number of event-pools initialized so far must not exceed the maximum QF_MAX_EPOOL

Precondition qf_dyn:201

except the first event-pool 0, the event-size of the previously initialized event pool must not exceed the next event size.

You might initialize many event pools by making many consecutive calls to the QF_poolInit() function. However, for the simplicity of the internal implementation, you must initialize event pools in the ascending order of the event size.

Remarks: Many RTOSes provide fixed block-size heaps, a.k.a. memory pools that can be adapted for QF event-pools. In case the pools from the RTOS are not used, QF provides a native memory pool implementation (::QMPool). The macro QF_EPOOL_TYPE_ determines the type of event pool used by a particular QF port.

Note: The actual number of events available in the pool might be actually less than (poolSize / evtSize) due to the internal alignment of the blocks that the pool might perform. You can always check the capacity of the pool by calling QF_getPoolMin().; The dynamic allocation of events is optional, meaning that you might choose not to use mutable events. In that case calling QF_poolInit() and using up memory for the memory blocks is unnecessary.

Definition at line 73 of file qf_dyn.cpp.

◆ poolGetMaxBlockSize()

std::uint_fast16_t QP::QF::poolGetMaxBlockSize ( )

noexcept

Obtain the block size of any registered event pools.

Obtain the block size of any registered event pools

Definition at line 116 of file qf_dyn.cpp.

◆ getPoolMin()

std::uint_fast16_t QP::QF::getPoolMin ( std::uint_fast8_t const poolId )

noexcept

Obtain the minimum of free entries of the given event pool.

This function obtains the minimum number of free blocks in the given event pool since this pool has been initialized by a call to QF_poolInit().

Parameters

[in] poolId event pool ID in the range 1..max_pool, where max_pool is the number of event pools initialized with the function QF_poolInit().

Returns: the minimum number of unused blocks in the given event pool.

Precondition qf_dyn:400

the poolId must be in range

Definition at line 121 of file qf_dyn.cpp.

◆ newX_()

QEvt * QP::QF::newX_	(	std::uint_fast16_t const	evtSize,
		std::uint_fast16_t const	margin,
		enum_t const	sig
	)

noexcept

Definition at line 139 of file qf_dyn.cpp.

◆ gc()

void QP::QF::gc ( QEvt const *const e )

noexcept

Recycle a mutable (mutable) event

This function implements a simple garbage collector for the mutable events. Only mutable events are candidates for recycling. (A mutable event is one that is allocated from an event-pool, which is determined as non-zero QEvt_getPoolId_(e)) Next, the function decrements the reference counter of the event (e->refCtr_), and recycles the event only if the counter drops to zero (meaning that no more references are outstanding for this event). The mutable event is recycled by returning it to the pool from which it was originally allocated.

Parameters

[in] e pointer to the event to recycle

Note: QF invokes the garbage collector at all appropriate contexts, when an event can become garbage (automatic garbage collection), so the application code should have no need to call QF_gc() directly. The QF_gc() function is exposed only for special cases when your application sends mutable events to the "raw" thread-safe queues (see ::QEQueue). Such queues are processed outside of QF and the automatic garbage collection is NOT performed for these events. In this case you need to call QF_gc() explicitly.

Traceability

DVR-QP-MC4-R11_08

Definition at line 218 of file qf_dyn.cpp.

◆ newRef_()

QEvt const * QP::QF::newRef_	(	QEvt const *const	e,
		QEvt const *const	evtRef
	)

noexcept

Definition at line 274 of file qf_dyn.cpp.

◆ deleteRef_()

void QP::QF::deleteRef_ ( QEvt const *const evtRef )

noexcept

Definition at line 309 of file qf_dyn.cpp.

◆ bzero_()

void QP::QF::bzero_	(	void *const	start,
		std::uint_fast16_t const	len
	)

noexcept

Definition at line 81 of file qf_act.cpp.

Variable Documentation

◆ NO_MARGIN

constexpr std::uint_fast16_t QP::QF::NO_MARGIN {0xFFFFU}

constexpr

Definition at line 1069 of file qp.hpp.

◆ priv_

QF::Attr QP::QF::priv_

Definition at line 78 of file qf_act.cpp.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ init()

◆ stop()

◆ run()

◆ onStartup()

◆ onCleanup()

◆ psInit()

◆ publish_()

◆ tick()

◆ getQueueMin()

◆ poolInit()

◆ poolGetMaxBlockSize()

◆ getPoolMin()

◆ newX_()

◆ gc()

◆ newRef_()

◆ deleteRef_()

◆ bzero_()

Variable Documentation

◆ NO_MARGIN

◆ priv_