QP/C++ platform-independent public interface. More...

Go to the source code of this file.

Classes
class	QP::QEvt
	Event class. More...

struct	QP::QMState
	State object for the QP::QMsm class (QM State Machine) More...

struct	QP::QMTranActTable
	Transition-Action Table for the QP::QMsm State Machine. More...

union	QP::QAsmAttr
	Attribute of for the QP::QAsm class (Abstract State Machine) More...

class	QP::QAsm
	Abstract State Machine class (state machine interface) More...

class	QP::QHsm
	Hierarchical State Machine class (QHsm-style state machine implementation strategy) More...

class	QP::QMsm
	Hierarchical State Machine class (QMsm-style state machine implementation strategy) More...

class	QP::QPSet
	Set of Active Objects of up to QF_MAX_ACTIVE elements. More...

class	QP::QSubscrList
	Subscriber List (for publish-subscribe) More...

class	QP::QPtrDis

class	QP::QActive
	Active object class (based on the QHsm implementation strategy) More...

class	QP::QMActive
	Active object class (based on QMsm implementation strategy) More...

class	QP::QTimeEvt
	Time Event class. More...

class	QP::QTicker
	"Ticker" Active Object class More...

Namespaces
namespace	QP
	QP/C++ framework.

namespace	QP::QF
	QF Active Object Framework.

Macros
#define	QP_VERSION_STR "8.0.0"
	Version string complying with Semantic Versioning

#define	QP_VERSION 800U
	Version number for internal use (must correspond to QP_VERSION_STR)

#define	QP_RELEASE 0x7055936FU
	Encrypted current QP release for internal use (7.3.5 on 2024-05-31)

#define	Q_STATE_DECL(state_)

#define	Q_STATE_DEF(subclass_, state_)

#define	Q_HANDLED() (Q_RET_HANDLED)

#define	Q_UNHANDLED() (Q_RET_UNHANDLED)

#define	Q_EVT_CAST(subclass_) (static_cast<subclass_ const *>(e))

#define	Q_STATE_CAST(handler_) (reinterpret_cast<QP::QStateHandler>(handler_))

#define	QM_STATE_DECL(state_)

#define	QM_ACTION_DECL(action_)

#define	QM_STATE_DEF(subclass_, state_)

#define	QM_ACTION_DEF(subclass_, action_)

#define	QM_HANDLED() (Q_RET_HANDLED)
	Macro to call in a QM state-handler when it handled an event. Applicable only to QMsm subclasses.

#define	QM_UNHANDLED() (Q_RET_HANDLED)
	Indicate that an internal transition has been "unhandled" due to a guard condition. Applicable only to QMsm subclasses.

#define	QM_SUPER() (Q_RET_SUPER)
	Macro to call in a QM state-handler when it designates the superstate to handle an event. Applicable only to QP::QMSMs.

#define	QM_STATE_NULL (nullptr)
	Macro to provide strictly-typed zero-state to use for submachines. Applicable to subclasses of QP::QMsm.

#define	Q_ACTION_NULL (nullptr)

#define	Q_UNUSED_PAR(par_) (static_cast<void>(par_))
	Helper macro to clearly mark unused parameters of functions.

#define	Q_DIM(array_) (sizeof(array_) / sizeof((array_)[0U]))

#define	Q_UINT2PTR_CAST(type_, uint_) (reinterpret_cast<type_ *>(uint_))
	Perform cast from unsigned integer `uint_` to pointer of type `type_`

#define	INIT(qsId_) init((qsId_))

#define	DISPATCH(e_, qsId_) dispatch((e_), (qsId_))

#define	Q_PRIO(prio_, pthre_) (static_cast<QP::QPrioSpec>((prio_) \| (pthre_) << 8U))

#define	Q_NEW(evtT_, sig_, ...) (QP::QF::q_new<evtT_>((sig_), __VA_ARGS__))

#define	Q_NEW_X(evtT_, margin_, sig_, ...) (QP::QF::q_new_x<evtT_>((margin_), (sig_), __VA_ARGS__))

#define	Q_NEW_REF(evtRef_, evtT_) (QP::QF::q_new_ref<evtT_>(e, (evtRef_)))

#define	Q_DELETE_REF(evtRef_)

#define	PUBLISH(e_, sender_) publish_((e_), (sender_), (sender_)->getPrio())

#define	POST(e_, sender_) post_((e_), QP::QF::NO_MARGIN, (sender_))
	Invoke the direct event posting facility QP::QActive::post_()

#define	POST_X(e_, margin_, sender_) post_((e_), (margin_), (sender_))

#define	TICK_X(tickRate_, sender_) tick((tickRate_), (sender_))

#define	TICK(sender_) TICK_X(0U, (sender_))

#define	TRIG(sender_) trig_((sender_))

#define	QF_CRIT_EXIT_NOP() (static_cast<void>(0))

#define	QF_MEM_SYS() (static_cast<void>(0))

#define	QF_MEM_APP() (static_cast<void>(0))

Typedefs
using	int_t = int
	Alias for assertion-ID numbers in QP assertions and return from QP::QF::run()

using	enum_t = int

using	float32_t = float
	Alias for IEEE 754 32-bit floating point number.

using	float64_t = double
	Alias for IEEE 754 64-bit floating point number.

using	QP::QSignal = std::uint16_t
	The signal of event QP::QEvt.

using	QP::QState = std::uint_fast8_t
	Type returned from state-handler functions.

using	QP::QStateHandler = QState ()(void const me, QEvt const * const e)
	Pointer to a state-handler function.

using	QP::QActionHandler = QState ()(void const me)
	Pointer to an action-handler function.

using	QP::QXThreadHandler = void ()(QXThread const me)
	Pointer to an extended-thread handler function.

using	QP::QPrioSpec = std::uint16_t
	Priority specification for Active Objects in QP.

using	QP::QEvtPtr = QEvt const *
	Pointer to const event instances passed around in QP Framework.

using	QP::QTimeEvtCtr = std::uint32_t
	Data type to store the block-size defined based on the macro QF_TIMEEVT_CTR_SIZE.

using	QP::QPSetBits = std::uint32_t

Functions
std::uint_fast8_t	QP::QF_LOG2 (QP::QPSetBits x) noexcept

void	QP::QF::init ()

void	QP::QF::stop ()

int_t	QP::QF::run ()

void	QP::QF::onStartup ()

void	QP::QF::onCleanup ()

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

void	QP::QF::publish_ (QEvt const const e, void const const sender, std::uint_fast8_t const qsId) noexcept

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

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

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

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

std::uint_fast16_t	QP::QF::getPoolMin (std::uint_fast8_t const poolNum) noexcept

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

void	QP::QF::gc (QEvt const *const e) noexcept
	Recycle a mutable (mutable) event.

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

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

template<class evtT_ , typename... Args>
evtT_ *	QP::QF::q_new (enum_t const sig, Args... args)

template<class evtT_ , typename... Args>
evtT_ *	QP::QF::q_new_x (std::uint_fast16_t const margin, enum_t const sig, Args... args)

template<class evtT_ >
void	QP::QF::q_new_ref (QP::QEvt const const e, evtT_ const &evtRef)

template<class evtT_ >
void	QP::QF::q_delete_ref (evtT_ const *&evtRef)

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

void	QP::QF::gcFromISR (QEvt const *e) noexcept

void	QF_onContextSw (QP::QActive prev, QP::QActive next)

Variables
constexpr char const	QP::versionStr [] {QP_VERSION_STR}
	the current QP version number string in ROM, based on QP_VERSION_STR

constexpr enum_t	QP::Q_USER_SIG {4}

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

Detailed Description

QP/C++ platform-independent public interface.

Backward Traceability

DVP_QP_MC4_D04_08 : Directive 4.8(Advisory): If a pointer to a structure or union is never dereferenced within a translation unit then the implementation of the object should be hidden

Definition in file qp.hpp.

Macro Definition Documentation

◆ QP_VERSION_STR

#define QP_VERSION_STR "8.0.0"

Version string complying with Semantic Versioning

Details: QP_VERSION_STR is a zero-terminated version string in the form MAJOR.MINOR.PATCH compliant with Semantic Versioning.

Examples:

7.3.5-rc.1 — version 7.3.5 release-candidate-1
7.3.5 — version 7.3.5 (final release)

Definition at line 39 of file qp.hpp.

◆ QP_VERSION

#define QP_VERSION 800U

Version number for internal use (must correspond to QP_VERSION_STR)

Details: QP_VERSION is an unsigned integer constant of the form MAJOR|MINOR|PATCH corresponding to QP_VERSION_STR, with digits merged together. For example QP_VERSION_STR == "7.3.5-rc.1" results in QP_VERSION == 735.

Definition at line 40 of file qp.hpp.

◆ QP_RELEASE

#define QP_RELEASE 0x7055936FU

Encrypted current QP release for internal use (7.3.5 on 2024-05-31)

Details: QP_RELEASE contains information about QP_VERSION (e.g., 735) and release date (e.g., 2023-06-30).

Definition at line 41 of file qp.hpp.

◆ Q_STATE_DECL

#define Q_STATE_DECL ( state_ )

Value:

QP::QState state_ ## _h(QP::QEvt const * const e); \

static QP::QState state_(void * const me, QP::QEvt const * const e)

QP::QEvt

Event class.

Definition qp.hpp:131

QP::QState

std::uint_fast8_t QState

Type returned from state-handler functions.

Definition qp.hpp:165

Definition at line 436 of file qp.hpp.

◆ Q_STATE_DEF

#define Q_STATE_DEF	(		subclass_,
			state_ )

Value:

    QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) { \
        return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
    QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)

Definition at line 441 of file qp.hpp.

◆ Q_HANDLED

#define Q_HANDLED ( ) (Q_RET_HANDLED)

Indicate that an action has been "handled". Applies to entry/exit actions and to internal transitions in QP::QHsm state machines.

Backward Traceability

Usage: Q_STATE_DEF(ToasterOven, toasting) {

QP::QState status_;

switch (e->sig) {

case Q_ENTRY_SIG: {

PRINTF_S("%s;", "toasting");

status_ = Q_HANDLED(); // <===

break;

}

. . .

}

return status_;

}

Q_STATE_DEF
#define Q_STATE_DEF(subclass_, state_)
Definition qp.hpp:441

Q_HANDLED
#define Q_HANDLED()
Definition qp.hpp:447

Definition at line 447 of file qp.hpp.

◆ Q_UNHANDLED

#define Q_UNHANDLED ( ) (Q_RET_UNHANDLED)

Indicate that an internal transition has been "unhandled" due to a guard condition. Applies to internal transitions in QP::QHsm state machines.

Details: This macro must be called when a state-handler attempts to handle an event but a guard condition evaluates to 'false' and there is no other explicit way of handling the event. Applicable only to QP::QHsm subclasses.

Usage: Q_STATE_DEF(Philo, hungry) {

QP::QState status_;

switch (e->sig) {

. . .

case EAT_SIG: {

if (Q_EVT_CAST(TableEvt)->philoId == m_id) {

status_ = tran(&eating);

}

else {

status_ = Q_UNHANDLED(); // <===

}

break;

}

. . .

}

return status_;

}

Q_EVT_CAST
#define Q_EVT_CAST(subclass_)
Definition qp.hpp:453

Q_UNHANDLED
#define Q_UNHANDLED()
Definition qp.hpp:450

Definition at line 450 of file qp.hpp.

◆ Q_EVT_CAST

#define Q_EVT_CAST ( subclass_ ) (static_cast<subclass_ const *>(e))

Perform downcast of an event onto a subclass of QP::QEvt class_

Details: This macro encapsulates the downcast of QP::QEvt pointers, which violates MISRA-C:2023 Rule 11.3(R). This macro helps to localize this deviation.

Parameters

subclass_ a subclass of QP::QEvt

Note: The macro performs down-cast from the event pointer e.

Backward Traceability

SRS_QP_EVT_30

Usage: Q_STATE_DEF(Table, serving) {

QP::QState status_;

switch (e->sig) {

. . .

case HUNGRY_SIG: {

std::uint8_t n = Q_EVT_CAST(TableEvt)->philoId; // <===

. . .

break;

}

. . .

}

return status_;

}

Definition at line 453 of file qp.hpp.

◆ Q_STATE_CAST

#define Q_STATE_CAST ( handler_ ) (reinterpret_cast<QP::QStateHandler>(handler_))

Perform cast to QP::QStateHandler.

Details: This macro encapsulates the cast of a specific state handler function pointer to QP::QStateHandler, which violates MISRA:C-2023 Rule 11.1(R). This macro helps to localize this deviation.

Parameters

handler_ state handler (function pointer)

Backward Traceability

Usage: Philo::Philo()

: QActive(Q_STATE_CAST(&initial)), // <===

m_timeEvt(this, TIMEOUT_SIG, 0U),

m_id(0xFFU)

{}

Q_STATE_CAST
#define Q_STATE_CAST(handler_)
Definition qp.hpp:456

Definition at line 456 of file qp.hpp.

◆ QM_STATE_DECL

#define QM_STATE_DECL ( state_ )

Value:

    QP::QState state_ ## _h(QP::QEvt const * const e); \
    static QP::QState state_(void * const me, QP::QEvt const * const e); \
    static QP::QMState const state_ ## _s

Definition at line 460 of file qp.hpp.

◆ QM_ACTION_DECL

#define QM_ACTION_DECL ( action_ )

Value:

QP::QState action_ ## _h(); \

static QP::QState action_(void * const me)

Definition at line 466 of file qp.hpp.

◆ QM_STATE_DEF

#define QM_STATE_DEF	(		subclass_,
			state_ )

Value:

    QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) {\
        return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
    QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)

Definition at line 471 of file qp.hpp.

◆ QM_ACTION_DEF

#define QM_ACTION_DEF	(		subclass_,
			action_ )

Value:

    QP::QState subclass_::action_(void * const me) { \
        return static_cast<subclass_ *>(me)->action_ ## _h(); } \
    QP::QState subclass_::action_ ## _h()

Definition at line 477 of file qp.hpp.

◆ QM_HANDLED

#define QM_HANDLED ( ) (Q_RET_HANDLED)

Macro to call in a QM state-handler when it handled an event. Applicable only to QMsm subclasses.

Definition at line 483 of file qp.hpp.

◆ QM_UNHANDLED

#define QM_UNHANDLED ( ) (Q_RET_HANDLED)

Indicate that an internal transition has been "unhandled" due to a guard condition. Applicable only to QMsm subclasses.

Details: This macro must be called when a state-handler attempts to handle an event but a guard condition evaluates to 'false' and there is no other explicit way of handling the event.

Definition at line 486 of file qp.hpp.

◆ QM_SUPER

#define QM_SUPER ( ) (Q_RET_SUPER)

Macro to call in a QM state-handler when it designates the superstate to handle an event. Applicable only to QP::QMSMs.

Definition at line 489 of file qp.hpp.

◆ QM_STATE_NULL

#define QM_STATE_NULL (nullptr)

Macro to provide strictly-typed zero-state to use for submachines. Applicable to subclasses of QP::QMsm.

Definition at line 492 of file qp.hpp.

◆ Q_ACTION_NULL

#define Q_ACTION_NULL (nullptr)

Macro to provide strictly-typed zero-action to terminate action lists in the transition-action-tables

Definition at line 495 of file qp.hpp.

◆ Q_UNUSED_PAR

#define Q_UNUSED_PAR ( par_ ) (static_cast<void>(par_))

Helper macro to clearly mark unused parameters of functions.

Definition at line 498 of file qp.hpp.

◆ Q_DIM

#define Q_DIM ( array_ ) (sizeof(array_) / sizeof((array_)[0U]))

Definition at line 501 of file qp.hpp.

◆ Q_UINT2PTR_CAST

#define Q_UINT2PTR_CAST	(		type_,
			uint_ ) (reinterpret_cast<type_ *>(uint_))

Perform cast from unsigned integer uint_ to pointer of type type_

Details: This macro encapsulates the cast to (type_ *), which QP ports or application might use to access embedded hardware registers. Such uses can trigger PC-Lint "Note 923: cast from int to pointer" and this macro helps to encapsulate this deviation.

Definition at line 504 of file qp.hpp.

◆ INIT

#define INIT ( qsId_ ) init((qsId_))

Definition at line 508 of file qp.hpp.

◆ DISPATCH

#define DISPATCH	(		e_,
			qsId_ ) dispatch((e_), (qsId_))

Definition at line 518 of file qp.hpp.

◆ Q_PRIO

#define Q_PRIO	(		prio_,
			pthre_ ) (static_cast<QP::QPrioSpec>((prio_) \| (pthre_) << 8U))

Create a QP::QPrioSpec object to specify priority of an AO or a thread

Parameters

[in]	prio_	QF priority [1..QF_MAX_ACTIVE]
[in]	pthre_	Preemption threshold [1..QF_MAX_ACTIVE]

Returns: The combined 16-bit priority specification (prio_ in bits [0..7] and pthre_ in bits [8..15].

Definition at line 1223 of file qp.hpp.

◆ Q_NEW

#define Q_NEW	(	evtT_,
		sig_,
		... ) (QP::QF::q_new<evtT_>((sig_), __VA_ARGS__))

Macro to allocate a dynamic event and asserting successful allocation.

Details: This deprecated macro is equivalent to invoking the function template QP::QF::q_new<evtT_>(sig_, ...).

Deprecated

See also: QP::QF::q_new()

Parameters

[in]	evtT_	event type (class name) of the event to allocate
[in]	sig_	signal to assign to the newly allocated event

Returns: A valid event pointer of the type evtT_*.

Definition at line 1233 of file qp.hpp.

◆ Q_NEW_X

#define Q_NEW_X	(	evtT_,
		margin_,
		sig_,
		... ) (QP::QF::q_new_x<evtT_>((margin_), (sig_), __VA_ARGS__))

Macro to allocate a dynamic event without asserting successful allocation.

Details: This deprecated macro is equivalent to invoking the function template QP::QF::q_new_x<evtT_>(margin_, sig_, ...).

Deprecated

See also: QP::QF::q_new_x()

Parameters

[in]	evtT_	event type (class name) of the event to allocate
[in]	margin_	number of events that must remain available in the given pool after this allocation. The special value QF_NO_MARGIN causes asserting failure in case event allocation fails.
[in]	sig_	signal to assign to the newly allocated event

Returns: An event pointer of the type evtT_* or nullptr if the event cannot be allocated with the specified margin_ of events still left in the event pool.

Definition at line 1243 of file qp.hpp.

◆ Q_NEW_REF

#define Q_NEW_REF	(		evtRef_,
			evtT_ ) (QP::QF::q_new_ref<evtT_>(e, (evtRef_)))

Create a new reference of the current event e

Details: This deprecated macro is equivalent to invoking the function template QP::QF::q_new_ref<evtT_>(e, evtRef).

Deprecated

See also: QP::QF::q_new_ref()

Parameters

[in,out]	evtRef_	event reference to create
[in]	evtT_	event type (class name) of the event reference

Definition at line 1247 of file qp.hpp.

◆ Q_DELETE_REF

#define Q_DELETE_REF ( evtRef_ )

Value:

    do { \
    QP::QF::deleteRef_((evtRef_)); \
    (evtRef_) = nullptr; \
} while (false)

Delete the event reference

Details: This deprecated macro is equivalent to invoking the function template QP::QF::q_new_ref<evtT_>(e, evtRef).

Deprecated

See also: QP::QF::q_delete_ref()

Parameters

[in,out] evtRef_ event reference to delete

Definition at line 1250 of file qp.hpp.

◆ PUBLISH

#define PUBLISH	(		e_,
			sender_ ) publish_((e_), (sender_), (sender_)->getPrio())

Publish an event to all subscriber Active Objects.

Details: If Q_SPY is defined, this macro calls QActive_publish_() with the sender_ parameter to identify the publisher of the event. Otherwise, sender_ is not used.

Parameters

[in]	e_	pointer to the posted event
[in]	sender_	pointer to the sender object (actually used only when Q_SPY is defined)

Note: The pointer to the sender_ object is not necessarily a pointer to an active object. In fact, if QACTIVE_PUBLISH() is called from an interrupt or other context, you can create a unique object just to unambiguously identify the sender of the event.

Definition at line 1257 of file qp.hpp.

◆ POST

#define POST	(		e_,
			sender_ ) post_((e_), QP::QF::NO_MARGIN, (sender_))

Invoke the direct event posting facility QP::QActive::post_()

Details: This macro asserts if the queue overflows and cannot accept the event.

Parameters

[in]	e_	pointer to the event to post
[in]	sender_	pointer to the sender object.

Note: The sender_ parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined). When QS software tracing is disabled, this macro does not use the sender_ parameter, so it does not need to be defined.; The sender_ parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined). When QS software tracing is disabled, this macro does not use the sender_ parameter, so it does not need to be defined.

See also

QP::QActive::post_()

Backward Traceability

DVP_QP_MC4_R11_03A : Rule 11.3(Required): A cast shall not be performed between a pointer to object type and a pointer to a different object type (object-oriented upcast)
DVP-QP-PCLP-826 : Suspicious pointer-to-pointer conversion (area too small)

Definition at line 1268 of file qp.hpp.

◆ POST_X

#define POST_X	(	e_,
		margin_,
		sender_ ) post_((e_), (margin_), (sender_))

Invoke the direct event posting facility QActive_post_() without delivery guarantee

Details: This macro does not assert if the queue overflows and cannot accept the event with the specified margin of free slots remaining.

Parameters

[in]	e_	pointer to the event to post
[in]	margin_	the minimum free slots in the queue, which must still be available after posting the event. The special value QF::NO_MARGIN causes asserting failure in case event posting fails.
[in]	sender_	pointer to the sender object.

Returns: 'true' if the posting succeeded, and 'false' if the posting failed due to insufficient margin of free entries available in the queue.

Note: The sender_ parameter is actually only used when QS tracing is enabled (macro Q_SPY is defined). When QS software tracing is disabled, the POST_X() macro does not pass the sender_ parameter, so the overhead of passing this extra parameter is entirely avoided.; The pointer to the sender object is not necessarily a pointer to an active object. In fact, if POST_X() is called from an interrupt or other context, you can create a unique object just to unambiguously identify the sender of the event.

Backward Traceability

Definition at line 1278 of file qp.hpp.

◆ TICK_X

#define TICK_X	(		tickRate_,
			sender_ ) tick((tickRate_), (sender_))

Invoke the system clock tick processing QP::QTimeEvt::tick_()

Details: This macro is the recommended way of invoking clock tick processing, because it provides the vital information for software tracing and avoids any overhead when the tracing is disabled.

Parameters

[in]	tickRate_	clock tick rate to be serviced through this call
[in]	sender_	pointer to the sender object. This parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined)

Note: When QS software tracing is disabled, the macro calls QTimeEvt::tick_() without the sender parameter, so the overhead of passing this extra parameter is entirely avoided.; The pointer to the sender object is not necessarily a pointer to an active object. In fact, when TICK_X() is called from an interrupt, you would create a unique object just to unambiguously identify the ISR as the sender of the time events.

Definition at line 1289 of file qp.hpp.

◆ TICK

#define TICK ( sender_ ) TICK_X(0U, (sender_))

Invoke the system clock tick processing for tick rate 0

Definition at line 1298 of file qp.hpp.

◆ TRIG

#define TRIG ( sender_ ) trig_((sender_))

Asynchronously trigger the QP::QTicker::trig_() AO to perform tick processing.

Details: This macro is the recommended way to trigger clock tick processing, because it provides the vital information for software tracing and avoids any overhead when the tracing is disabled.

Parameters

[in] sender_ pointer to the sender object. This parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined)

Note: When QS software tracing is disabled, the macro calls QTicker_trig_() without the sender parameter, so the overhead of passing this extra parameter is entirely avoided.; The pointer to the sender object is not necessarily a pointer to an active object. In fact, when QTICKER_TRIG() is called from an interrupt, you would create a unique object just to unambiguously identify the ISR as the sender of the time events.

Definition at line 1302 of file qp.hpp.

◆ QF_CRIT_EXIT_NOP

#define QF_CRIT_EXIT_NOP ( ) (static_cast<void>(0))

No-operation for exiting a critical section

Details: In some QF ports the critical section exit takes effect only on the next machine instruction. If this next instruction is another entry to a critical section, the critical section won't be really exited, but rather the two adjacent critical sections would be merged. The QF_CRIT_EXIT_NOP() macro contains minimal code required to prevent such merging of critical sections in such merging of critical sections in QF ports, in which it can occur.

Definition at line 1312 of file qp.hpp.

◆ QF_MEM_SYS

#define QF_MEM_SYS ( ) (static_cast<void>(0))

Definition at line 1317 of file qp.hpp.

◆ QF_MEM_APP

#define QF_MEM_APP ( ) (static_cast<void>(0))

Definition at line 1322 of file qp.hpp.

Typedef Documentation

◆ int_t

using int_t = int

Alias for assertion-ID numbers in QP assertions and return from QP::QF::run()

Definition at line 96 of file qp.hpp.

◆ enum_t

using enum_t = int

Definition at line 99 of file qp.hpp.

◆ float32_t

using float32_t = float

Alias for IEEE 754 32-bit floating point number.

Note: QP/C++ does not use floating-point types anywhere in the internal implementation, except in QS software tracing, where utilities for output of floating-point numbers are provided for application-specific trace records.

Definition at line 102 of file qp.hpp.

◆ float64_t

using float64_t = double

Alias for IEEE 754 64-bit floating point number.

Note: QP/C++ does not use floating-point types anywhere in the internal implementation, except in QS software tracing, where utilities for output of floating-point numbers are provided for application-specific trace records.

Definition at line 105 of file qp.hpp.

Function Documentation

◆ QF_onContextSw()

void QF_onContextSw	(	QP::QActive *	prev,
		QP::QActive *	next )

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ QP_VERSION_STR

◆ QP_VERSION

◆ QP_RELEASE

◆ Q_STATE_DECL

◆ Q_STATE_DEF

◆ Q_HANDLED

◆ Q_UNHANDLED

◆ Q_EVT_CAST

◆ Q_STATE_CAST

◆ QM_STATE_DECL

◆ QM_ACTION_DECL

◆ QM_STATE_DEF

◆ QM_ACTION_DEF

◆ QM_HANDLED

◆ QM_UNHANDLED

◆ QM_SUPER

◆ QM_STATE_NULL

◆ Q_ACTION_NULL

◆ Q_UNUSED_PAR

◆ Q_DIM

◆ Q_UINT2PTR_CAST

◆ INIT

◆ DISPATCH

◆ Q_PRIO

◆ Q_NEW

◆ Q_NEW_X

◆ Q_NEW_REF

◆ Q_DELETE_REF

◆ PUBLISH

◆ POST

◆ POST_X

◆ TICK_X

◆ TICK

◆ TRIG

◆ QF_CRIT_EXIT_NOP

◆ QF_MEM_SYS

◆ QF_MEM_APP

Typedef Documentation

◆ int_t

◆ enum_t

◆ float32_t

◆ float64_t

Function Documentation

◆ QF_onContextSw()