Movatterモバイル変換

101classQEvt {

102public:

103 std::uint32_tsig : 16;

104 std::uint32_tpoolNum_ : 8;

105 std::uint32_trefCtr_ : 8;

106 std::uint32_tfiller_;

108enumDynEvt: std::uint8_t {DYNAMIC };

118QEvt()// disallow the default ctor

119 =delete;

127};// class QEvt

142structQMState {

143QMStateconst *superstate;

144QStateHandlerconststateHandler;

145QActionHandlerconstentryAction;

146QActionHandlerconstexitAction;

147QActionHandlerconstinitAction;

148};

150structQMTranActTable {

151QMStateconst *target;

152QActionHandlerconstact[1];

153};

155unionQAsmAttr {

156QStateHandlerfun;

157QActionHandleract;

158QXThreadHandlerthr;

159QMStateconst *obj;

160QMTranActTableconst *tatbl;

161 std::uintptr_tuint;

162};

167classQAsm {

168public:

169QAsmAttrm_state;

170QAsmAttrm_temp;

174staticconstexprQStateQ_RET_SUPER {0U};

175staticconstexprQStateQ_RET_UNHANDLED {1U};

176staticconstexprQStateQ_RET_HANDLED {2U};

177staticconstexprQStateQ_RET_TRAN {3U};

178staticconstexprQStateQ_RET_TRAN_HIST {4U};

181staticconstexprQStateQ_RET_IGNORED {5U};

184staticconstexprQStateQ_RET_ENTRY {6U};

185staticconstexprQStateQ_RET_EXIT {7U};

186staticconstexprQStateQ_RET_TRAN_INIT {8U};

190staticconstexprQSignalQ_EMPTY_SIG {0U};

191staticconstexprQSignalQ_ENTRY_SIG {1U};

192staticconstexprQSignalQ_EXIT_SIG {2U};

193staticconstexprQSignalQ_INIT_SIG {3U};

205staticconstexprQMStateconst *QM_STATE_NULL {nullptr };

206staticconstexprQActionHandlerconstQ_ACTION_NULL {nullptr };

213virtualvoidinit(

214voidconst *const e,

215 std::uint_fast8_tconst qsId) = 0;

216virtualvoidinit(std::uint_fast8_tconst qsId);

217virtualvoiddispatch(

218QEvtconst *const e,

219 std::uint_fast8_tconst qsId) = 0;

220virtualboolisIn(QStateHandlerconst stateHndl) = 0;

221virtualQStateHandlergetStateHandler() const noexcept = 0;

230staticQStatetop(void *const me,QEvtconst *const e)noexcept;

232protected:

233explicitQAsm() noexcept;

276QStateqm_entry(QMStateconst *const s)constnoexcept {

278static_cast<void>(s);// unused parameter

279returnQ_RET_ENTRY;

280 }

290QStateqm_exit(QMStateconst *const s)constnoexcept {

292static_cast<void>(s);// unused parameter

293returnQ_RET_EXIT;

294 }

296};// class QAsm

299classQHsm :publicQP::QAsm {

300protected:

301explicitQHsm(QStateHandlerconst initial)noexcept;

303public:

304usingQAsm::init;

305voidinit(

306voidconst *const e,

307 std::uint_fast8_tconst qsId)override;

308voiddispatch(

309QEvtconst *const e,

310 std::uint_fast8_tconst qsId)override;

311boolisIn(QStateHandlerconst stateHndl)noexceptoverride;

312QStateHandlergetStateHandler()constnoexceptoverride;

314QStateHandlerchildState(QStateHandlerconst parentHndl)noexcept;

316private:

317 std::int_fast8_ttran_simple_(

318QStateHandler *const path,

319 std::uint_fast8_tconst qsId);

321 std::int_fast8_ttran_complex_(

322QStateHandler *const path,

323 std::uint_fast8_tconst qsId);

325voidenter_target_(

326QStateHandler *const path,

327 std::int_fast8_tconst depth,

328 std::uint_fast8_tconst qsId);

331friendclassQS;

332};// class QHsm

335classQMsm :publicQP::QAsm {

336protected:

337explicitQMsm(QStateHandlerconst initial)noexcept;

339public:

340usingQAsm::init;

341voidinit(

342voidconst *const e,

343 std::uint_fast8_tconst qsId)override;

344voiddispatch(

345QEvtconst *const e,

346 std::uint_fast8_tconst qsId)override;

347boolisIn(QStateHandlerconst stateHndl)noexceptoverride;

348QStateHandlergetStateHandler() const noexcept override;

350QMState const *childStateObj(QMState const * const parentHndl)

351 const noexcept;

352 staticQMState const *topQMState() noexcept;

354private:

355QStateexecTatbl_(

356QMTranActTable const * const tatbl,

357 std::uint_fast8_t const qsId);

358voidexitToTranSource_(

359QMState const * const curr_state,

360QMState const * const tran_source,

361 std::uint_fast8_t const qsId);

362QStateenterHistory_(

363QMState const * const hist,

364 std::uint_fast8_t const qsId);

367 friend classQS;

368};// class QMsm

443classQPSet {

444private:

445QPSetBitsm_bits0;

447QPSetBitsm_bits1;

450public:

451voidsetEmpty() noexcept;

452boolisEmpty() const noexcept;

453boolnotEmpty() const noexcept;

454boolhasElement(std::uint_fast8_t const n) const noexcept;

455voidinsert(std::uint_fast8_t const n) noexcept;

456voidremove(std::uint_fast8_t const n) noexcept;

457 std::uint_fast8_tfindMax() const noexcept;

460 friend classQS;

461};// class QPSet

464classQSubscrList {

465private:

466QPSetm_set;

469friendclassQActive;

470friendclassQS;

471};// class QSubscrList

476namespaceQF {

477voidinit();

478voidstop();

479int_trun();

481voidonStartup();

482voidonCleanup();

484constexpr std::uint_fast16_tNO_MARGIN {0xFFFFU};

485}// namespace QF

488classQActive :publicQAsm {

489private:

490 std::uint8_tm_prio;

491 std::uint8_tm_pthre;

494QACTIVE_THREAD_TYPEm_thread;

498QACTIVE_OS_OBJ_TYPEm_osObject;

502QACTIVE_EQUEUE_TYPEm_eQueue;

505protected:

506explicitQActive(QStateHandlerconst initial)noexcept;

508public:

509usingQAsm::init;

510voidinit(

511voidconst *const e,

512 std::uint_fast8_tconst qsId)override;

513voiddispatch(

514QEvtconst *const e,

515 std::uint_fast8_tconst qsId)override;

516boolisIn(QStateHandlerconst stateHndl)noexceptoverride;

517QStateHandlergetStateHandler() const noexcept override;

519QStateHandlerchildState(QStateHandler const parentHandler) noexcept;

520voidsetAttr(

521 std::uint32_t attr1,

522void const * attr2 =nullptr);

523voidstart(QPrioSpec const prioSpec,

524QEvtPtr * const qSto, std::uint_fast16_t const qLen,

525void * const stkSto, std::uint_fast16_t const stkSize,

526void const * const par =nullptr);

529voidstop();

531voidregister_() noexcept;

532voidunregister_() noexcept;

539bool postx_(QEvtconst *const e,

540 std::uint_fast16_tconst margin,

541voidconst *const sender)noexcept;

542void postLIFO(QEvtconst *const e)noexcept;

543QEvtconst * get_() noexcept;

544 static std::uint16_t getQueueUse(

545 std::uint_fast8_t const prio) noexcept;

546 static std::uint16_t getQueueFree(

547 std::uint_fast8_t const prio) noexcept;

548 static std::uint16_t getQueueMin(

549 std::uint_fast8_t const prio) noexcept;

550 staticvoid psInit(

551QSubscrList * const subscrSto,

552QSignal const maxSignal) noexcept;

553 staticvoid publish_(

554QEvt const * const e,

555void const * const sender,

556 std::uint_fast8_t const qsId) noexcept;

557void subscribe(QSignal const sig) const noexcept;

558void unsubscribe(QSignal const sig) const noexcept;

559void unsubscribeAll() const noexcept;

560bool defer(

561QEQueue * const eq,

562QEvt const * const e) const noexcept;

563bool recall(QEQueue * const eq) noexcept;

564 std::uint16_t flushDeferred(

565QEQueue * const eq,

566 std::uint_fast16_t const num = 0xFFFFU) const noexcept;

570staticvoidevtLoop_(QActive *act);

571staticQActive *fromRegistry(std::uint_fast8_tconst prio);

578QACTIVE_THREAD_TYPEconst &getThread() const &&

580 = delete;

591QACTIVE_OS_OBJ_TYPEconst &getOsObject() const &&

593 = delete;

597virtualboolpostFromISR(

598QEvtconst *const e,

599 std::uint_fast16_tconst margin,

600void * par,

601voidconst *const sender)noexcept;

603staticvoidpublishFromISR(

604QEvtconst * e,

605void * par,

606voidconst * sender)noexcept;

609private:

610voidpostFIFO_(

611QEvtconst *const e,

612voidconst *const sender);

613staticvoidmulticast_(

614QPSet *const subscrSet,

615QEvtconst *const e,

616voidconst *const sender);

619friendclassQTimeEvt;

620friendclassQTicker;

621friendclassQXThread;

622friendclassQXMutex;

623friendclassQXSemaphore;

624friendclassQMActive;

625friendclassQActiveDummy;

626friendclassQK;

627friendclassQXK;

628friendclassQS;

630friendvoidQF::init();

631friendvoidQF::stop();

632friendint_tQF::run();

633friendvoidQF::onStartup();

634friendvoidQF::onCleanup();

636};// class QActive

639classQMActive :publicQActive {

640protected:

641explicitQMActive(QStateHandlerconst initial)noexcept;

643public:

644usingQActive::init;

645voidinit(

646voidconst *const e,

647 std::uint_fast8_tconst qsId)override;

648voiddispatch(

649QEvtconst *const e,

650 std::uint_fast8_tconst qsId)override;

651boolisIn(QStateHandlerconst stateHndl)noexceptoverride;

652QStateHandlergetStateHandler()constnoexceptoverride;

654QMStateconst *childStateObj(QMStateconst *const parent)constnoexcept;

655};// class QMActive

660classQTimeEvt :publicQEvt {

661private:

662QTimeEvt *m_next;

663void *m_act;

664QTimeEvtCtrm_ctr;

665QTimeEvtCtrm_interval;

666 std::uint8_tm_tickRate;

667 std::uint8_tm_flags;

669public:

670QTimeEvt(

671QActive *const act,

672QSignalconstsig,

673 std::uint_fast8_tconst tickRate = 0U)noexcept;

674voidarmX(

675 std::uint32_tconst nTicks,

676 std::uint32_tconst interval = 0U)noexcept;

677booldisarm() noexcept;

678boolrearm(std::uint32_t const nTicks) noexcept;

679boolwasDisarmed() noexcept;

684voidconst *getAct() const &&

686 = delete;

696staticvoid tick(

697 std::uint_fast8_tconst tickRate,

698voidconst *const sender)noexcept;

701staticvoid tick1_(

702 std::uint_fast8_tconst tickRate,

703voidconst *const sender);

707staticvoidtickFromISR(

708 std::uint_fast8_tconst tickRate,

709void * par,

710voidconst * sender)noexcept;

712staticboolnoActive(std::uint_fast8_tconst tickRate)noexcept;

722QTimeEvt() noexcept;

724private:

725QTimeEvt *expire_(

726QTimeEvt * const prev_link,

727QActive const * const act,

728 std::uint_fast8_t const tickRate) noexcept;

731 friend classQXThread;

732 friend classQS;

733};// class QTimeEvt

736classQTicker : publicQActive {

737public:

738explicitQTicker(std::uint8_tconst tickRate)noexcept;

739usingQActive::init;

740voidinit(

741voidconst *const e,

742 std::uint_fast8_tconst qsId)override;

743voiddispatch(

744QEvtconst *const e,

745 std::uint_fast8_tconst qsId)override;

746voidtrig_(voidconst *const sender)noexcept;

747};// class QTicker

755inlinevoidpsInit(QSubscrList *const subscrSto,

756QSignalconst maxSignal)noexcept

757{

759QActive::psInit(subscrSto, maxSignal);

760}

763inlinevoidpublish_(QEvtconst *const e,

764voidconst *const sender, std::uint_fast8_tconst qsId)noexcept

765{

767QActive::publish_(e, sender, qsId);

768}

771staticinline std::uint_fast16_tgetQueueMin(

772 std::uint_fast8_tconst prio)noexcept

773{

775returnQActive::getQueueMin(prio);

776}

780inlinevoidtick(

781 std::uint_fast8_tconst tickRate,

782voidconst *const sender)noexcept

783{

785QTimeEvt::tick(tickRate, sender);

786}

829inline evtT_ *q_new(QSignalconst sig, Args... args) {

832 evtT_ *e =static_cast<evtT_*>(

833QP::QF::newX_(sizeof(evtT_),QP::QF::NO_MARGIN, sig));

834 e->init(args...);// immediately initialize the event (RAII)

835return e;

836 }

838inline evtT_ *q_new_x(std::uint_fast16_tconst margin,

839QSignalconst sig, Args... args)

840 {

843 evtT_ *e =

844static_cast<evtT_*>(QP::QF::newX_(sizeof(evtT_), margin, sig));

845if (e !=nullptr) {// was the allocation successfull?

846 e->init(args...);// immediately initialize the event (RAII)

847 }

849return e;

850 }

854inlinevoidq_new_ref(

855QP::QEvtconst *const e,

856 evtT_const *& evtRef)

857{

859 evtRef =static_cast<evtT_const*>(QP::QF::newRef_(e, evtRef));

860}

863inlinevoidq_delete_ref(evtT_const *& evtRef) {

864QP::QF::deleteRef_(evtRef);

865 evtRef =nullptr;// invalidate the associated event reference

866}

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

friend class QActiveDummy

virtual bool postFromISR(QEvt const *const e, std::uint_fast16_t const margin, void *par, void const *const sender) noexcept

The "FromISR" variant used in the QP port to "FreeRTOS".

QACTIVE_THREAD_TYPE m_thread

Port-dependent representation of the thread of the active object.

static std::uint16_t getQueueMin(std::uint_fast8_t const prio) noexcept

void unregister_() noexcept

Un-register the active object from the framework.

friend class QTicker

friend class QXMutex

void init(void const *const e, std::uint_fast8_t const qsId) override

Virtual function to take the top-most initial transition in the state machine.

friend class QS

static void multicast_(QPSet *const subscrSet, QEvt const *const e, void const *const sender)

void post_(QEvt const *const e, void const *const sender) noexcept

Posts an event e directly to the event queue of the active object using the First-In-First-Out (FIFO)...

void register_() noexcept

Register this active object to be managed by the framework.

void postFIFO_(QEvt const *const e, void const *const sender)

static void publishFromISR(QEvt const *e, void *par, void const *sender) noexcept

The "FromISR" variant used in the QP port to "FreeRTOS".

static void publish_(QEvt const *const e, void const *const sender, std::uint_fast8_t const qsId) noexcept

Publish event to all subscribers of a given signal e->sig.

void stop()

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

static void evtLoop_(QActive *act)

Event loop thread routine for executing an active object act (defined some in QP ports).

void setAttr(std::uint32_t attr1, void const *attr2=nullptr)

Generic setting of additional attributes (defined in some QP ports).

void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override

Virtual function to dispatch an event to the state machine.

constexpr QACTIVE_OS_OBJ_TYPE const & getOsObject() const &

constexpr std::uint8_t getPrio() const noexcept

bool isIn(QStateHandler const stateHndl) noexcept override

Virtual function to check whether the state machine is in a given state.

bool postx_(QEvt const *const e, std::uint_fast16_t const margin, void const *const sender) noexcept

Posts an event e directly to the event queue of the active object using the First-In-First-Out (FIFO)...

static QActive * fromRegistry(std::uint_fast8_t const prio)

friend class QXSemaphore

QActive(QStateHandler const initial) noexcept

QActive constructor (abstract base class).

QACTIVE_EQUEUE_TYPE m_eQueue

Port-dependent event-queue type (often QP::QEQueue).

QACTIVE_THREAD_TYPE const & getThread() const &&=delete

friend class QK

QStateHandler childState(QStateHandler const parentHandler) noexcept

constexpr QACTIVE_THREAD_TYPE const & getThread() const &

static void psInit(QSubscrList *const subscrSto, QSignal const maxSignal) noexcept

Publish event to all subscribers of a given signal e->sig.

friend class QTimeEvt

void start(QPrioSpec const prioSpec, QEvtPtr *const qSto, std::uint_fast16_t const qLen, void *const stkSto, std::uint_fast16_t const stkSize, void const *const par=nullptr)

Starts execution of an active object and registers the object with the framework.

QACTIVE_OS_OBJ_TYPE const & getOsObject() const &&=delete

void setThread(QACTIVE_THREAD_TYPE const &thr) noexcept

QStateHandler getStateHandler() const noexcept override

Virtual method for getting the current state handler.

std::uint8_t m_pthre

Preemption-threshold [1..QF_MAX_ACTIVE] of this AO.

QACTIVE_OS_OBJ_TYPE m_osObject

Port-dependent per-thread object.

std::uint8_t m_prio

QF-priority [1..QF_MAX_ACTIVE] of this AO.

friend class QMActive

friend class QXThread

friend class QXK

Abstract State Machine class (state machine interface).

QState qm_entry(QMState const *const s) noexcept

Internal helper function to execute state entry actions in QP::QMsm.

QAsm() noexcept

Constructor of the QP::QAsm base class.

QState qm_tran_hist(QMState const *const hist, void const *const tatbl) noexcept

Internal helper function to take a state transition to history in QP::QMsm.

QStateHandler state() const noexcept

static constexpr QState Q_RET_UNHANDLED

QState qm_tran(void const *const tatbl) noexcept

Internal helper function to take a state transition in QP::QMsm.

static constexpr QState Q_RET_TRAN

static constexpr QState QM_SUPER()

static constexpr QState Q_RET_ENTRY

QState qm_exit(QMState const *const s) noexcept

Internal helper function to execute state exit actions in QP::QMsm.

QState tran_hist(QStateHandler const hist) noexcept

Internal helper function to take a state transition to history in sublclasses of QP::QAsm.

QState super(QStateHandler const superstate) noexcept

Internal helper function to indicate superstate of a given state in sublclasses of QP::QAsm.

QState qm_tran_init(void const *const tatbl) noexcept

QAsmAttr m_temp

Temporary storage for target/act-table etc.

static constexpr QState Q_RET_IGNORED

virtual bool isIn(QStateHandler const stateHndl)=0

Virtual function to check whether the state machine is in a given state.

static constexpr QState Q_RET_SUPER

static constexpr QState Q_UNHANDLED()

virtual QStateHandler getStateHandler() const noexcept=0

Virtual method for getting the current state handler.

static constexpr QState Q_RET_TRAN_INIT

static constexpr QState Q_RET_TRAN_HIST

static constexpr QState Q_RET_EXIT

QMState const * stateObj() const noexcept

static constexpr QState Q_HANDLED()

virtual void init(void const *const e, std::uint_fast8_t const qsId)=0

Virtual function to take the top-most initial transition in the state machine.

QState tran(QStateHandler const target) noexcept

Internal helper function to take a state transition in sublclasses of QP::QAsm.

static constexpr QState QM_UNHANDLED()

virtual ~QAsm() noexcept

Virtual destructor of the QP::QAsm abstract base class.

static constexpr QSignal Q_INIT_SIG

static constexpr QActionHandler const Q_ACTION_NULL

QAsmAttr m_state

Current state (pointer to the current state-handler function).

virtual void dispatch(QEvt const *const e, std::uint_fast8_t const qsId)=0

Virtual function to dispatch an event to the state machine.

static constexpr QSignal Q_ENTRY_SIG

static constexpr QSignal Q_EXIT_SIG

static constexpr QSignal Q_EMPTY_SIG

static constexpr QState Q_RET_HANDLED

static constexpr QMState const * QM_STATE_NULL

static QState top(void *const me, QEvt const *const e) noexcept

Top state handler that ignores all events.

static constexpr QState QM_HANDLED()

Native QF Event Queue.

Event class.

void init(DynEvt const dummy) const noexcept

Event initialization for dynamic events (overload).

DynEvt

@ DYNAMIC

Dummy parameter for dynamic event initialization (see QEvt::QEvt(DynEvt)).

void init() const noexcept

Event initialization for dynamic events.

std::uint32_t poolNum_

Event pool number of this event.

constexpr QEvt(QSignal const s) noexcept

Event constexpr constructor applicable to immutable and mutable event instances.

std::uint32_t refCtr_

Event reference counter.

QEvt()=delete

Disallowed default event constructor.

std::uint32_t filler_

Member of QP::QEvt to make it identical size in QP/C++ and SafeQP/C++.

std::uint32_t sig

Signal of the event (see Event Signal).

friend class QS

std::int_fast8_t tran_complex_(QStateHandler *const path, std::uint_fast8_t const qsId)

void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override

Virtual function to dispatch an event to the state machine.

std::int_fast8_t tran_simple_(QStateHandler *const path, std::uint_fast8_t const qsId)

QStateHandler childState(QStateHandler const parentHndl) noexcept

Obtain the current active child state of a given parent in QP::QMsm.

void init(void const *const e, std::uint_fast8_t const qsId) override

Virtual function to take the top-most initial transition in the state machine.

QHsm(QStateHandler const initial) noexcept

void enter_target_(QStateHandler *const path, std::int_fast8_t const depth, std::uint_fast8_t const qsId)

bool isIn(QStateHandler const stateHndl) noexcept override

Check whether the HSM is in a given state.

QStateHandler getStateHandler() const noexcept override

Virtual method for getting the current state handler.

QMActive(QStateHandler const initial) noexcept

Constructor of QP::QMActive class.

QStateHandler getStateHandler() const noexcept override

Virtual method for getting the current state handler.

bool isIn(QStateHandler const stateHndl) noexcept override

Virtual function to check whether the state machine is in a given state.

void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override

Virtual function to dispatch an event to the state machine.

void init(void const *const e, std::uint_fast8_t const qsId) override

Virtual function to take the top-most initial transition in the state machine.

QMState const * childStateObj(QMState const *const parent) const noexcept

QMState const * childStateObj(QMState const *const parentHndl) const noexcept

Obtain the current active child state of a given parent in QP::QMsm.

void exitToTranSource_(QMState const *const curr_state, QMState const *const tran_source, std::uint_fast8_t const qsId)

Exit the current state up to the explicit transition source.

friend class QS

QState execTatbl_(QMTranActTable const *const tatbl, std::uint_fast8_t const qsId)

Execute transition-action table.

static QMState const * topQMState() noexcept

void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override

Virtual function to dispatch an event to the state machine.

QState enterHistory_(QMState const *const hist, std::uint_fast8_t const qsId)

Enter history of a composite state.

void init(void const *const e, std::uint_fast8_t const qsId) override

Virtual function to take the top-most initial transition in the state machine.

bool isIn(QStateHandler const stateHndl) noexcept override

Tests if a given state is part of the current active state configuration.

QMsm(QStateHandler const initial) noexcept

Constructor of QP::QMsm.

QStateHandler getStateHandler() const noexcept override

Obtain the current active state from a MSM (read only).

Set of Active Objects of up to QF_MAX_ACTIVE elements.

std::uint_fast8_t findMax() const noexcept

Find the maximum element in the set.

friend class QS

void remove(std::uint_fast8_t const n) noexcept

Remove element n from the priority-set (n = 1..QF_MAX_ACTIVE).

QPSetBits m_bits1

Bitmask for elements 33..64.

bool notEmpty() const noexcept

Find out whether the priority-set is NOT empty.

bool hasElement(std::uint_fast8_t const n) const noexcept

Find out whether the priority-set has element n.

QPSetBits m_bits0

Bitmask for elements 1..32.

void setEmpty() noexcept

Make the priority set empty.

bool isEmpty() const noexcept

Find out whether the priority-set is empty.

void insert(std::uint_fast8_t const n) noexcept

Insert element n into the priority-set (n = 1..QF_MAX_ACTIVE).

Subscriber List (for publish-subscribe).

QPSet m_set

The set of AOs that subscribed to a given event signal.

friend class QActive

friend class QS

void trig_(void const *const sender) noexcept

Asynchronously trigger the QTicker active object to perform tick processing.

void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override

Virtual function to dispatch an event to the state machine.

void init(void const *const e, std::uint_fast8_t const qsId) override

Virtual function to take the top-most initial transition in the state machine.

QTicker(std::uint8_t const tickRate) noexcept

Constructor of the QTicker Active Object class.

Time Event class.

void const * getAct() const &&=delete

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

Processes all armed time events at every clock tick.

QTimeEvt * m_next

Link to the next time event in the list.

QTimeEvt * toTimeEvt() noexcept

friend class QS

bool disarm() noexcept

Disarm a time event.

std::uint8_t m_flags

QTimeEvt(QActive *const act, QSignal const sig, std::uint_fast8_t const tickRate=0U) noexcept

The "extended" constructor to initialize a Time Event.

QTimeEvtCtr getInterval() const noexcept

static bool noActive(std::uint_fast8_t const tickRate) noexcept

Check if any time events are active at a given clock tick rate.

static void tickFromISR(std::uint_fast8_t const tickRate, void *par, void const *sender) noexcept

void * m_act

Active object that receives the time events.

QActive * toActive() noexcept

std::uint8_t m_tickRate

void armX(std::uint32_t const nTicks, std::uint32_t const interval=0U) noexcept

Arm a time event (extended version for one shot or periodic time event).

QTimeEvtCtr getCtr() const noexcept

Get the current value of the down-counter of a time event.

bool rearm(std::uint32_t const nTicks) noexcept

Rearm a time event.

std::uint8_t getTickRate() const noexcept

QTimeEvtCtr m_ctr

Down-counter of the time event.

QTimeEvtCtr m_interval

Interval for periodic time event (zero for one-shot time event).

void const * getAct() const &

bool wasDisarmed() noexcept

Check the "was disarmed" status of a time event.

friend class QXThread

eXtended (blocking) thread of the QXK preemptive kernel

QF Active Object Framework namespace.

void deleteRef_(QEvt const *const evtRef) noexcept

void onCleanup()

Cleanup QF callback.

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

QEvt * newXfromISR_(std::uint_fast16_t const evtSize, std::uint_fast16_t const margin, QSignal const sig) noexcept

void gc(QEvt const *const e) noexcept

Recycle a mutable (mutable) event.

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

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

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

evtT_ * q_new_x(std::uint_fast16_t const margin, QSignal const sig, Args... args)

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

evtT_ * q_new(QSignal const sig, Args... args)

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

void gcFromISR(QEvt const *e) noexcept

std::uint16_t getPoolUse(std::uint_fast8_t const poolNum) noexcept

constexpr std::uint_fast16_t NO_MARGIN

Special value of margin that causes asserting failure in case event allocation or event posting fails...

void init()

QF initialization.

void q_new_ref(QP::QEvt const *const e, evtT_ const *&evtRef)

Create a new reference of the current event e.

std::uint16_t getPoolMin(std::uint_fast8_t const poolNum) noexcept

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

void q_delete_ref(evtT_ const *&evtRef)

Delete a new reference of the current event e.

int_t run()

Transfers control to QF to run the application.

void stop()

Invoked by the application layer to stop the QF framework and return control to the OS/Kernel (used i...

std::uint16_t getPoolFree(std::uint_fast8_t const poolNum) noexcept

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

void onStartup()

Startup QF callback.

QP/C++ Framework namespace.

constexpr QSignal Q_USER_SIG

std::uint32_t QTimeEvtCtr

Data type to store the block-size defined based on the macro QF_TIMEEVT_CTR_SIZE.

QState(*)(void *const me) QActionHandler

Pointer to an action-handler function.

char const * version() noexcept

std::uint_fast8_t QF_LOG2(QP::QPSetBits const bitmask) noexcept

QEvt const * QEvtPtr

Pointer to const event instances passed around in QP/C++ Framework.

std::uint_fast8_t QState

Type returned from state-handler functions.

QState(*)(void *const me, QEvt const *const e) QStateHandler

Pointer to a state-handler function.

std::uint32_t QPSetBits

Bitmask for the internal representation of QPSet elements.

std::uint16_t QSignal

The signal of event QP::QEvt.

void(*)(QXThread *const me) QXThreadHandler

Pointer to an extended-thread handler function.

std::uint16_t QPrioSpec

Priority specification for Active Objects in QP.

int int_t

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

#define Q_UNUSED_PAR(par_)

Helper macro to clearly mark unused parameters of functions.

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

#define QACTIVE_OS_OBJ_TYPE

QP::QActive "OS-object" type used in various QP/C++ ports.

#define QACTIVE_EQUEUE_TYPE

QP::QActive event queue type used in various QP/C++ ports.

#define QACTIVE_THREAD_TYPE

QP::QActive "thread" type used in various QP/C++ ports.

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

QActionHandler const entryAction

QStateHandler const stateHandler

QActionHandler const exitAction

QMState const * superstate

QActionHandler const initAction

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

QMState const * target

QActionHandler const act[1]

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

std::uintptr_t uint

QMState const * obj

QStateHandler fun

QMTranActTable const * tatbl

QXThreadHandler thr

QActionHandler act