QP/C  7.0.0
Real-Time Embedded Framework
qutest.c
Go to the documentation of this file.
1/*============================================================================
2* QP/C Real-Time Embedded Framework (RTEF)
3* Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.
4*
5* SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
6*
7* This software is dual-licensed under the terms of the open source GNU
8* General Public License version 3 (or any later version), or alternatively,
9* under the terms of one of the closed source Quantum Leaps commercial
10* licenses.
11*
12* The terms of the open source GNU General Public License version 3
13* can be found at: <www.gnu.org/licenses/gpl-3.0>
14*
15* The terms of the closed source Quantum Leaps commercial licenses
16* can be found at: <www.state-machine.com/licensing>
17*
18* Redistributions in source code must retain this top-level comment block.
19* Plagiarizing this software to sidestep the license obligations is illegal.
20*
21* Contact information:
22* <www.state-machine.com>
23* <info@state-machine.com>
24============================================================================*/
32/* only build when Q_UTEST is defined */
33#ifdef Q_UTEST
34
35#define QP_IMPL /* this is QP implementation */
36#include "qf_port.h" /* QF port */
37#include "qf_pkg.h" /* QF package-scope interface */
38#include "qassert.h" /* QP embedded systems-friendly assertions */
39#include "qs_port.h" /* include QS port */
40#include "qs_pkg.h" /* QS facilities for pre-defined trace records */
41
43
44/* Global objects ==========================================================*/
45uint8_t volatile QF_intNest;
46
47/* QF functions ============================================================*/
49void QF_init(void) {
50 /* Clear the internal QF variables, so that the framework can start
51 * correctly even if the startup code fails to clear the uninitialized
52 * data (as is required by the C Standard).
53 */
54 QF_maxPool_ = 0U;
57 QF_intNest = 0U;
58
59 QF_bzero(&QF_active_[0], sizeof(QF_active_));
61}
62/*..........................................................................*/
64void QF_stop(void) {
65 QS_onReset();
66}
67/*..........................................................................*/
69int_t QF_run(void) {
70 /* function dictionaries for the standard API */
74
75 /* produce the QS_QF_RUN trace record */
79
80 QS_onTestLoop(); /* run the test loop */
81 QS_onCleanup(); /* application cleanup */
82 return 0; /* return no error */
83}
84
85/*..........................................................................*/
87void QActive_start_(QActive * const me, uint_fast8_t prio,
88 QEvt const * * const qSto, uint_fast16_t const qLen,
89 void * const stkSto, uint_fast16_t const stkSize,
90 void const * const par)
91{
92 (void)stkSto; /* unused parameter */
93 (void)stkSize; /* unused parameter */
94
95 /* priority must be in range */
96 Q_REQUIRE_ID(200, (0U < prio) && (prio <= QF_MAX_ACTIVE));
97
98 QEQueue_init(&me->eQueue, qSto, qLen); /* initialize the built-in queue */
99 me->prio = (uint8_t)prio; /* set the current priority of the AO */
100
101 QF_add_(me); /* make QF aware of this active object */
102
103 QHSM_INIT(&me->super, par, me->prio); /* the top-most initial tran. */
104}
105
106/*==========================================================================*/
107static void QHsmDummy_init_(QHsm * const me, void const * const par,
108 uint_fast8_t const qs_id);
109static void QHsmDummy_dispatch_(QHsm * const me, QEvt const * const e,
110 uint_fast8_t const qs_id);
111
112/*..........................................................................*/
116void QHsmDummy_ctor(QHsmDummy * const me) {
117 static struct QHsmVtable const vtable = { /* QHsm virtual table */
120#ifdef Q_SPY
122#endif
123 };
124 /* superclass' ctor */
125 QHsm_ctor(&me->super, Q_STATE_CAST(0));
126 me->super.vptr = &vtable; /* hook the vptr */
127}
128/*..........................................................................*/
130static void QHsmDummy_init_(QHsm * const me, void const * const par,
131 uint_fast8_t const qs_id)
132{
133 (void)par; /* unused parameter */
134
137 QS_OBJ_PRE_(me); /* this state machine object */
138 QS_FUN_PRE_(me->state.fun); /* the source state */
139 QS_FUN_PRE_(me->temp.fun); /* the target of the initial transition */
141}
142/*..........................................................................*/
144static void QHsmDummy_dispatch_(QHsm * const me, QEvt const * const e,
145 uint_fast8_t const qs_id)
146{
149 QS_TIME_PRE_(); /* time stamp */
150 QS_SIG_PRE_(e->sig); /* the signal of the event */
151 QS_OBJ_PRE_(me); /* this state machine object */
152 QS_FUN_PRE_(me->state.fun); /* the current state */
154}
155
156/*==========================================================================*/
157static void QActiveDummy_init_(QHsm * const me, void const * const par,
158 uint_fast8_t const qs_id);
159static void QActiveDummy_dispatch_(QHsm * const me, QEvt const * const e,
160 uint_fast8_t const qs_id);
161static bool QActiveDummy_post_(QActive * const me, QEvt const * const e,
162 uint_fast16_t const margin, void const * const sender);
163static void QActiveDummy_postLIFO_(QActive * const me, QEvt const * const e);
164static void QActiveDummy_start_(QActive * const me, uint_fast8_t prio,
165 QEvt const * * const qSto, uint_fast16_t qLen,
166 void *stkSto, uint_fast16_t stkSize,
167 void const * const par);
168
169/*..........................................................................*/
174 static QActiveVtable const vtable = { /* QActive virtual table */
177#ifdef Q_SPY
179#endif
180 },
184 };
185 /* superclass' ctor */
187 me->super.super.vptr = &vtable.super; /* hook the vptr */
188}
189/*..........................................................................*/
191static void QActiveDummy_start_(QActive * const me, uint_fast8_t prio,
192 QEvt const * * const qSto, uint_fast16_t qLen,
193 void *stkSto, uint_fast16_t stkSize,
194 void const * const par)
195{
196 /* No special preconditions for checking parameters to allow starting
197 * dummy AOs the exact same way as the real counterparts.
198 */
199 (void)qSto; /* unusuded parameter */
200 (void)qLen; /* unusuded parameter */
201 (void)stkSto; /* unusuded parameter */
202 (void)stkSize; /* unusuded parameter */
203
204 me->prio = (uint8_t)prio; /* set the current priority of the AO */
205
206 QF_add_(me); /* make QF aware of this active object */
207
208 /* the top-most initial tran. (virtual) */
209 QHSM_INIT(&me->super, par, me->prio);
210 //QS_FLUSH();
211}
212//............................................................................
213#ifdef QF_ACTIVE_STOP
215void QActive_stop(QActive * const me) {
216 QActive_unsubscribeAll(me); /* unsubscribe from all events */
217 QF_remove_(me); /* remove this object from QF */
218}
219#endif
220
221/*..........................................................................*/
223static void QActiveDummy_init_(QHsm * const me, void const * const par,
224 uint_fast8_t const qs_id)
225{
226 (void)qs_id; /* unused parameter */
227
228 QHsmDummy_init_(me, par, ((QActive const *)me)->prio);
229}
230/*..........................................................................*/
232static void QActiveDummy_dispatch_(QHsm * const me, QEvt const * const e,
233 uint_fast8_t const qs_id)
234{
235 (void)qs_id; /* unused parameter */
236
237 QHsmDummy_dispatch_(me, e, ((QActive const *)me)->prio);
238}
239/*..........................................................................*/
241static bool QActiveDummy_post_(QActive * const me, QEvt const * const e,
242 uint_fast16_t const margin,
243 void const * const sender)
244{
246
247 /* test-probe#1 for faking queue overflow */
248 bool status = true;
250 status = false;
251 if (margin == QF_NO_MARGIN) {
252 /* fake assertion Mod=qf_actq,Loc=110 */
253 Q_onAssert("qf_actq", 110);
254 }
255 )
256
258 QF_CRIT_E_();
259
260 /* is it a dynamic event? */
261 if (e->poolId_ != 0U) {
262 QF_EVT_REF_CTR_INC_(e); /* increment the reference counter */
263 }
264
265 uint_fast8_t const rec = (status ? (uint_fast8_t)QS_QF_ACTIVE_POST
266 : (uint_fast8_t)QS_QF_ACTIVE_POST_ATTEMPT);
267 QS_BEGIN_NOCRIT_PRE_(rec, me->prio)
268 QS_TIME_PRE_(); /* timestamp */
269 QS_OBJ_PRE_(sender); /* the sender object */
270 QS_SIG_PRE_(e->sig); /* the signal of the event */
271 QS_OBJ_PRE_(me); /* this active object */
272 QS_2U8_PRE_(e->poolId_, e->refCtr_); /* pool Id & refCtr of the evt */
273 QS_EQC_PRE_(0U); /* number of free entries */
274 QS_EQC_PRE_(margin); /* margin requested */
276
277 /* callback to examine the posted event under the same conditions
278 * as producing the #QS_QF_ACTIVE_POST trace record, which are:
279 * the local filter for this AO ('me->prio') is set
280 */
281 if ((QS_priv_.locFilter[me->prio >> 3U]
282 & (1U << (me->prio & 7U))) != 0U)
283 {
284 QS_onTestPost(sender, me, e, status);
285 }
286 QF_CRIT_X_();
287
288 /* recycle the event immediately, because it was not really posted */
289 QF_gc(e);
290
291 return status; /* the event is "posted" correctly */
292}
293/*..........................................................................*/
295static void QActiveDummy_postLIFO_(QActive * const me, QEvt const * const e) {
297
298 /* test-probe#1 for faking queue overflow */
300 /* fake assertion Mod=qf_actq,Loc=210 */
301 Q_onAssert("qf_actq", 210);
302 )
303
305 QF_CRIT_E_();
306
307 /* is it a dynamic event? */
308 if (e->poolId_ != 0U) {
309 QF_EVT_REF_CTR_INC_(e); /* increment the reference counter */
310 }
311
313 QS_TIME_PRE_(); /* timestamp */
314 QS_SIG_PRE_(e->sig); /* the signal of this event */
315 QS_OBJ_PRE_(me); /* this active object */
316 QS_2U8_PRE_(e->poolId_, e->refCtr_); /* pool Id & refCtr of the evt */
317 QS_EQC_PRE_(0U); /* number of free entries */
318 QS_EQC_PRE_(0U); /* min number of free entries */
320
321 /* callback to examine the posted event under the same conditions
322 * as producing the #QS_QF_ACTIVE_POST trace record, which are:
323 * the local filter for this AO ('me->prio') is set
324 */
325 if ((QS_priv_.locFilter[me->prio >> 3U]
326 & (1U << (me->prio & 7U))) != 0U)
327 {
328 QS_onTestPost((QActive *)0, me, e, true);
329 }
330
331 QF_CRIT_X_();
332
333 /* recycle the event immediately, because it was not really posted */
334 QF_gc(e);
335}
336
337/*==========================================================================*/
341
342 /* return immediately (do nothing) for Test Probe != 0 */
343 QS_TEST_PROBE(return;)
344
346 uint_fast8_t const p = QPSet_findMax(&QS_rxPriv_.readySet);
347 QActive * const a = QF_active_[p];
348
349 /* perform the run-to-completion (RTC) step...
350 * 1. retrieve the event from the AO's event queue, which by this
351 * time must be non-empty and The "Vanialla" kernel asserts it.
352 * 2. dispatch the event to the AO's state machine.
353 * 3. determine if event is garbage and collect it if so
354 */
355 QEvt const * const e = QActive_get_(a);
356 QHSM_DISPATCH(&a->super, e, a->prio);
357 QF_gc(e);
358
359 if (a->eQueue.frontEvt == (QEvt *)0) { /* empty queue? */
361 }
362 }
363}
364/*..........................................................................*/
365/* The testing version of system tick processing performs as follows:
366* 1. If the Current Time Event (TE) Object is defined and the TE is armed,
367* the TE is disarmed (if one-shot) and then posted to the recipient AO.
368* 2. The linked-list of all armed Time Events is updated.
369*/
371void QS_tickX_(uint_fast8_t const tickRate, void const * const sender) {
373 QF_CRIT_E_();
374
375 QTimeEvt *prev = &QF_timeEvtHead_[tickRate];
376
378 ++prev->ctr;
379 QS_TEC_PRE_(prev->ctr); /* tick ctr */
380 QS_U8_PRE_(tickRate); /* tick rate */
382
383 /* is current Time Event object provided? */
385 if (t != (QTimeEvt *)0) {
386
387 /* the time event must be armed */
388 Q_ASSERT_ID(810, t->ctr != 0U);
389
390 /* temp. for volatile */
391 QActive * const act = (QActive * const)(t->act);
392
393 /* the recipient AO must be provided */
394 Q_ASSERT_ID(820, act != (QActive *)0);
395
396 /* periodic time evt? */
397 if (t->interval != 0U) {
398 t->ctr = t->interval; /* rearm the time event */
399 }
400 else { /* one-shot time event: automatically disarm */
401 t->ctr = 0U; /* auto-disarm */
402 /* mark time event 't' as NOT linked */
403 t->super.refCtr_ &= (uint8_t)(~(uint8_t)QTE_IS_LINKED);
404
406 QS_OBJ_PRE_(t); /* this time event object */
407 QS_OBJ_PRE_(act); /* the target AO */
408 QS_U8_PRE_(tickRate); /* tick rate */
410 }
411
413 QS_TIME_PRE_(); /* timestamp */
414 QS_OBJ_PRE_(t); /* the time event object */
415 QS_SIG_PRE_(t->super.sig); /* signal of this time event */
416 QS_OBJ_PRE_(act); /* the target AO */
417 QS_U8_PRE_(tickRate); /* tick rate */
419
420 QF_CRIT_X_(); /* exit critical section before posting */
421
422 QACTIVE_POST(act, &t->super, sender); /* asserts if queue overflows */
423
424 QF_CRIT_E_();
425 }
426
427 /* update the linked list of time events */
428 for (;;) {
429 t = prev->next; /* advance down the time evt. list */
430
431 /* end of the list? */
432 if (t == (QTimeEvt *)0) {
433
434 /* any new time events armed since the last run of QF_tickX_()? */
435 if (QF_timeEvtHead_[tickRate].act != (void *)0) {
436
437 /* sanity check */
438 Q_ASSERT_CRIT_(830, prev != (QTimeEvt *)0);
439 prev->next = (QTimeEvt *)QF_timeEvtHead_[tickRate].act;
440 QF_timeEvtHead_[tickRate].act = (void *)0;
441 t = prev->next; /* switch to the new list */
442 }
443 else {
444 break; /* all currently armed time evts. processed */
445 }
446 }
447
448 /* time event scheduled for removal? */
449 if (t->ctr == 0U) {
450 prev->next = t->next;
451 /* mark time event 't' as NOT linked */
452 t->super.refCtr_ &= (uint8_t)(~(uint8_t)QTE_IS_LINKED);
453 /* do NOT advance the prev pointer */
454 QF_CRIT_X_(); /* exit crit. section to reduce latency */
455
456 /* prevent merging critical sections, see NOTE1 below */
458 }
459 else {
460 prev = t; /* advance to this time event */
461 QF_CRIT_X_(); /* exit crit. section to reduce latency */
462
463 /* prevent merging critical sections, see NOTE1 below */
465 }
466 QF_CRIT_E_(); /* re-enter crit. section to continue */
467 }
468
469 QF_CRIT_X_();
470}
471/*..........................................................................*/
473void QS_test_pause_(void) {
474 QS_beginRec_((uint_fast8_t)QS_TEST_PAUSED);
475 QS_endRec_();
477}
478
479/*==========================================================================*/
480Q_NORETURN Q_onAssert(char const * const module, int_t const location) {
482 QS_TIME_PRE_();
483 QS_U16_PRE_(location);
484 QS_STR_PRE_((module != (char *)0) ? module : "?");
486
487 QS_onFlush(); /* flush the assertion record to the host */
488 QS_onTestLoop(); /* loop to wait for commands (typically reset) */
489 QS_onReset(); /* in case the QUTEST loop ever returns, reset manually */
490 for (;;) { /* QS_onReset() should not return, but to ensure no-return */
491 }
492}
493
494#endif /* Q_UTEST */
Customizable and memory-efficient assertions for embedded systems.
#define Q_DEFINE_THIS_MODULE(name_)
Definition: qassert.h:102
#define Q_NORETURN
Definition: qassert.h:199
#define Q_ASSERT_ID(id_, test_)
Definition: qassert.h:135
#define Q_REQUIRE_ID(id_, test_)
Definition: qassert.h:252
#define QHSM_INIT(me_, par_, qs_id_)
Definition: qep.h:296
signed int int_t
Definition: qep.h:57
#define QHSM_DISPATCH(me_, e_, qs_id_)
Definition: qep.h:330
#define Q_STATE_CAST(handler_)
Definition: qep.h:196
#define QF_NO_MARGIN
Definition: qf.h:687
#define QACTIVE_POST(me_, e_, sender_)
Definition: qf.h:238
#define QF_CRIT_EXIT_NOP()
Definition: qf.h:871
uint_fast8_t QF_maxPool_
Definition: qf_dyn.c:48
Internal (package scope) QF/C interface.
#define QF_CRIT_STAT_
Definition: qf_pkg.h:54
#define Q_ASSERT_CRIT_(id_, test_)
Definition: qf_pkg.h:97
#define QTE_IS_LINKED
Definition: qf_pkg.h:157
#define QF_CRIT_X_()
Definition: qf_pkg.h:78
#define QF_EVT_REF_CTR_INC_(e_)
Definition: qf_pkg.h:177
#define QF_CRIT_E_()
Definition: qf_pkg.h:66
static bool QPSet_notEmpty(QPSet *const me)
Definition: qpset.h:80
static uint_fast8_t QPSet_findMax(QPSet *const me)
Definition: qpset.h:102
static void QPSet_remove(QPSet *const me, uint_fast8_t const n)
Definition: qpset.h:95
Definition: qpset.h:65
QSPrivAttr QS_priv_
Definition: qs.c:41
#define QS_CRIT_STAT_
Definition: qs.h:509
#define QS_TIME_PRE_()
Definition: qs.h:220
#define QS_FUN_DICTIONARY(fun_)
Definition: qs.h:814
@ TE_OBJ
Definition: qs.h:900
#define QS_TEST_PROBE_DEF(fun_)
Definition: qs.h:1024
uint8_t locFilter[16]
Definition: qs.h:912
@ QS_ASSERT_FAIL
Definition: qs.h:152
@ QS_QF_TIMEEVT_AUTO_DISARM
Definition: qs.h:102
@ QS_QF_RUN
Definition: qs.h:153
@ QS_QEP_STATE_INIT
Definition: qs.h:60
@ QS_QF_ACTIVE_POST_LIFO
Definition: qs.h:74
@ QS_QF_TIMEEVT_POST
Definition: qs.h:106
@ QS_QF_ACTIVE_POST_ATTEMPT
Definition: qs.h:118
@ QS_QF_TICK
Definition: qs.h:98
@ QS_QEP_DISPATCH
Definition: qs.h:65
@ QS_TEST_PAUSED
Definition: qs.h:141
@ QS_QF_ACTIVE_POST
Definition: qs.h:73
#define QS_TEST_PROBE(code_)
Definition: qs.h:1028
#define QS_TEST_PROBE_ID(id_, code_)
Definition: qs.h:1032
Internal (package scope) QS/C interface.
#define QS_BEGIN_PRE_(rec_, qs_id_)
Definition: qs_pkg.h:114
void * currObj[MAX_OBJ]
Definition: qs_pkg.h:93
#define QS_U8_PRE_(data_)
Definition: qs_pkg.h:151
#define QS_BEGIN_NOCRIT_PRE_(rec_, qs_id_)
Definition: qs_pkg.h:138
#define QS_OBJ_PRE_(obj_)
Definition: qs_pkg.h:179
QPSet readySet
Definition: qs_pkg.h:99
#define QS_FUN_PRE_(fun_)
Definition: qs_pkg.h:182
#define QS_TEC_PRE_(ctr_)
Definition: qs_pkg.h:264
#define QS_END_NOCRIT_PRE_()
Definition: qs_pkg.h:148
#define QS_U16_PRE_(data_)
Definition: qs_pkg.h:158
#define QS_2U8_PRE_(data1_, data2_)
Definition: qs_pkg.h:154
#define QS_SIG_PRE_(sig_)
Definition: qs_pkg.h:172
#define QS_EQC_PRE_(ctr_)
Definition: qs_pkg.h:205
#define QS_STR_PRE_(msg_)
Definition: qs_pkg.h:164
#define QS_END_PRE_()
Definition: qs_pkg.h:126
QSrxPrivAttr QS_rxPriv_
Definition: qs_rx.c:40
uint8_t volatile QF_intNest
Definition: qutest.c:45
Q_NORETURN Q_onAssert(char const *const module, int_t const location)
Definition: qutest.c:480
#define QF_MAX_ACTIVE
void QActiveDummy_ctor(QActiveDummy *const me)
Definition: qutest.c:173
QActive super
Definition: qs.h:1072
static void QHsmDummy_init_(QHsm *const me, void const *const par, uint_fast8_t const qs_id)
Definition: qutest.c:130
static void QActiveDummy_init_(QHsm *const me, void const *const par, uint_fast8_t const qs_id)
Definition: qutest.c:223
static void QActiveDummy_postLIFO_(QActive *const me, QEvt const *const e)
Definition: qutest.c:295
static bool QActiveDummy_post_(QActive *const me, QEvt const *const e, uint_fast16_t const margin, void const *const sender)
Definition: qutest.c:241
static void QHsmDummy_dispatch_(QHsm *const me, QEvt const *const e, uint_fast8_t const qs_id)
Definition: qutest.c:144
static void QActiveDummy_start_(QActive *const me, uint_fast8_t prio, QEvt const **const qSto, uint_fast16_t qLen, void *stkSto, uint_fast16_t stkSize, void const *const par)
Definition: qutest.c:191
static void QActiveDummy_dispatch_(QHsm *const me, QEvt const *const e, uint_fast8_t const qs_id)
Definition: qutest.c:232
Definition: qf.h:107
void QActive_ctor(QActive *const me, QStateHandler initial)
Definition: qf_qact.c:58
bool QActive_post_(QActive *const me, QEvt const *const e, uint_fast16_t const margin, void const *const sender)
Definition: qf_actq.c:83
QEvt const * QActive_get_(QActive *const me)
Definition: qf_actq.c:310
QHsm super
Definition: qf.h:108
void QActive_postLIFO_(QActive *const me, QEvt const *const e)
Definition: qf_actq.c:221
void QActive_start_(QActive *const me, uint_fast8_t prio, QEvt const **const qSto, uint_fast16_t const qLen, void *const stkSto, uint_fast16_t const stkSize, void const *const par)
Definition: qutest.c:87
void QActive_stop(QActive *const me)
Definition: qutest.c:215
uint8_t prio
Definition: qf.h:152
void QActive_unsubscribeAll(QActive const *const me)
Definition: qf_ps.c:303
struct QHsmVtable super
Definition: qf.h:158
void QEQueue_init(QEQueue *const me, QEvt const **const qSto, uint_fast16_t const qLen)
Definition: qf_qeq.c:64
Definition: qep.h:119
QSignal sig
Definition: qep.h:123
uint8_t poolId_
Definition: qep.h:128
uint8_t volatile refCtr_
Definition: qep.h:133
void QF_bzero(void *const start, uint_fast16_t len)
Definition: qf_act.c:129
void QF_remove_(QActive *const a)
Definition: qf_act.c:98
void QF_add_(QActive *const a)
Definition: qf_act.c:65
enum_t QF_maxPubSignal_
Definition: qf_ps.c:52
QActive * QF_active_[QF_MAX_ACTIVE+1U]
Definition: qf_act.c:48
int_t QF_run(void)
Definition: qk.c:124
void QF_gc(QEvt const *const e)
Definition: qf_dyn.c:241
QSubscrList * QF_subscrList_
Definition: qf_ps.c:49
void QF_init(void)
Definition: qk.c:64
void QF_stop(void)
Definition: qk.c:98
QTimeEvt QF_timeEvtHead_[QF_MAX_TICK_RATE]
Definition: qf_time.c:47
Definition: qs.h:1056
void QHsmDummy_ctor(QHsmDummy *const me)
Definition: qutest.c:116
QHsm super
Definition: qs.h:1057
Definition: qep.h:253
struct QHsmVtable const * vptr
Definition: qep.h:254
void QHsm_ctor(QHsm *const me, QStateHandler initial)
Definition: qep_hsm.c:139
union QHsmAttr state
Definition: qep.h:255
union QHsmAttr temp
Definition: qep.h:256
QStateHandler QHsm_getStateHandler_(QHsm *const me)
Definition: qep_hsm.c:605
void QS_onReset(void)
void QS_onTestPost(void const *sender, QActive *recipient, QEvt const *e, bool status)
void QS_endRec_(void)
Definition: qs.c:399
void QS_onCleanup(void)
void QS_tickX_(uint_fast8_t const tickRate, void const *const sender)
Definition: qutest.c:371
void QS_processTestEvts_(void)
Definition: qutest.c:339
void QS_onTestLoop(void)
void QS_test_pause_(void)
Definition: qutest.c:473
void QS_beginRec_(uint_fast8_t rec)
Definition: qs.c:371
void QS_onFlush(void)
Definition: qf.h:456
struct QTimeEvt *volatile next
Definition: qf.h:460
void *volatile act
Definition: qf.h:463
QTimeEvtCtr volatile ctr
Definition: qf.h:471
QTimeEvtCtr interval
Definition: qf.h:480
QEvt super
Definition: qf.h:457
QStateHandler fun
Definition: qep.h:220