QP/C  7.2.2
Real-Time Embedded Framework
Loading...
Searching...
No Matches
qep.h File Reference

QEP/C platform-independent public interface. More...

Go to the source code of this file.

Classes

class  QEvt
 Event class. More...
 
struct  QMState
 State object for the QMsm class (QM State Machine). More...
 
struct  QMTranActTable
 Transition-Action Table for the QMsm State Machine. More...
 
union  QHsmAttr
 Attribute of for the QHsm class (Hierarchical State Machine). More...
 
class  QHsm
 Hierarchical State Machine class. More...
 
struct  QHsmVtable
 Virtual table for the QHsm class. More...
 
class  QMsm
 QM state machine implementation strategy. More...
 

Macros

#define QP_VERSION   722U
 
#define QP_VERSION_STR   "7.2.2"
 
#define QP_RELEASE   0x76BAD85DU
 
#define Q_SIGNAL_SIZE   2U
 
#define QHSM_INIT(me_, par_, qs_id_)
 
#define QHSM_DISPATCH(me_, e_, qs_id_)    ((*(me_)->vptr->dispatch)((me_), (e_), (qs_id_)))
 
#define Q_HSM_UPCAST(ptr_)   ((QHsm *)(ptr_))
 
#define Q_TRAN(target_)    ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(target_), Q_RET_TRAN)
 
#define Q_TRAN_HIST(hist_)    ((Q_HSM_UPCAST(me))->temp.fun = (hist_), Q_RET_TRAN_HIST)
 
#define Q_SUPER(super_)    ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(super_), Q_RET_SUPER)
 
#define Q_HANDLED()   (Q_RET_HANDLED)
 
#define Q_UNHANDLED()   (Q_RET_UNHANDLED)
 
#define Q_ACTION_NULL   ((QActionHandler)0)
 
#define Q_EVT_CAST(class_)   ((class_ const *)(e))
 
#define Q_STATE_CAST(handler_)   ((QStateHandler)(handler_))
 
#define Q_ACTION_CAST(action_)   ((QActionHandler)(action_))
 
#define Q_UNUSED_PAR(par_)   ((void)(par_))
 
#define Q_DIM(array_)   (sizeof(array_) / sizeof((array_)[0U]))
 
#define Q_UINT2PTR_CAST(type_, uint_)   ((type_ *)(uint_))
 
#define QEVT_INITIALIZER(sig_)   { (QSignal)(sig_), 0U, 0U }
 
#define QM_ENTRY(state_)    ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_ENTRY)
 
#define QM_EXIT(state_)    ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_EXIT)
 
#define QM_SM_EXIT(state_)    ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_EXIT)
 
#define QM_TRAN(tatbl_)
 
#define QM_TRAN_INIT(tatbl_)
 
#define QM_TRAN_HIST(history_, tatbl_)
 
#define QM_TRAN_EP(tatbl_)
 
#define QM_TRAN_XP(xp_, tatbl_)
 
#define QM_HANDLED()   (Q_RET_HANDLED)
 
#define QM_UNHANDLED()   (Q_RET_UNHANDLED)
 
#define QM_SUPER()   (Q_RET_SUPER)
 
#define QM_SUPER_SUB(host_)    ((Q_HSM_UPCAST(me))->temp.obj = (host_), Q_RET_SUPER_SUB)
 
#define QM_STATE_NULL   ((QMState *)0)
 

Typedefs

typedef int int_t
 
typedef int enum_t
 
typedef float float32_t
 
typedef double float64_t
 
typedef uint16_t QSignal
 
typedef enum QStateRet QState
 
typedef QState(* QStateHandler) (void *const me, QEvt const *const e)
 
typedef QState(* QActionHandler) (void *const me)
 
typedef void(* QXThreadHandler) (struct QXThread *const me)
 

Enumerations

enum  QStateRet {
  Q_RET_SUPER , Q_RET_SUPER_SUB , Q_RET_UNHANDLED , Q_RET_HANDLED ,
  Q_RET_IGNORED , Q_RET_ENTRY , Q_RET_EXIT , Q_RET_NULL ,
  Q_RET_TRAN , Q_RET_TRAN_INIT , Q_RET_TRAN_EP , Q_RET_TRAN_HIST ,
  Q_RET_TRAN_XP
}
 
enum  QReservedSig {
  Q_EMPTY_SIG , Q_ENTRY_SIG , Q_EXIT_SIG , Q_INIT_SIG ,
  Q_USER_SIG
}
 

Functions

int_fast8_t QHsm_tran_ (QHsm *const me, QStateHandler *const path, uint_fast8_t const qs_id)
 

Variables

char const QP_versionStr [8]
 

Class Documentation

◆ QMState

struct QMState

This class groups together the attributes of a QMsm state, such as the parent state (state nesting), the associated state handler function and the exit action handler function. These attributes are used inside the QMsm_dispatch() and QMsm_init() functions.

Traceability
Attention
The QMState class is only intended for the QM code generator and should not be used in hand-crafted code.

Definition at line 282 of file qep.h.

Class Members
struct QMState const * superstate

superstate of this state

QStateHandler const stateHandler

state handler function

QActionHandler const entryAction

entry action handler function

QActionHandler const exitAction

exit action handler function

QActionHandler const initAction

init action handler function

◆ QMTranActTable

struct QMTranActTable

Definition at line 292 of file qep.h.

Class Members
QMState const * target

target of the transition

QActionHandler const act[1]

array of actions

Macro Definition Documentation

◆ QP_VERSION

#define QP_VERSION   722U

The current QP version as an unsigned number

QP_VERSION is a decimal constant, where XX is a 1-digit or 2-digit major version number, Y is a 1-digit minor version number, and Z is a 1-digit release number.

Definition at line 53 of file qep.h.

◆ QP_VERSION_STR

#define QP_VERSION_STR   "7.2.2"

The current QP version as a zero terminated string literal.

QP_VERSION_STR is of the form "XX.Y.Z", where XX is a 1-or 2-digit major version number, Y is a 1-digit minor version number, and Z is a 1-digit release number.

Definition at line 62 of file qep.h.

◆ QP_RELEASE

#define QP_RELEASE   0x76BAD85DU

Encrypted current QP release (7.2.2) and date (2023-03-01)

Definition at line 65 of file qep.h.

◆ Q_SIGNAL_SIZE

#define Q_SIGNAL_SIZE   2U

The size (in bytes) of the signal of an event. Valid values: 1U, 2U, or 4U; default 2U

This macro can be defined in the QEP port file (qep_port.h) to configure the QSignal type. When the macro is not defined, the default of 2 bytes is applied.

Definition at line 114 of file qep.h.

◆ QHSM_INIT

#define QHSM_INIT (   me_,
  par_,
  qs_id_ 
)
Value:
do { \
Q_ASSERT((me_)->vptr); \
(*(me_)->vptr->init)((me_), (par_), (qs_id_)); \
} while (false)

Virtual call to the top-most initial transition in a HSM.

Parameters
[in,out]me_current instance pointer (see oop)
[in]par_pointer the optional initialization parameter
[in]qs_id_QS local filter ID (used only when Q_SPY is defined)
Note
Must be called only ONCE after the SM "constructor".
Traceability
Usage
The following example illustrates how to initialize a SM, and dispatch events to it:
#include "qpc.h" /* QP/C public interface */
#include "calc.h" /* Calc derived from QHsm */
Q_DEFINE_THIS_FILE
static Calc Calc_inst; /* an instance of Calc SM */
int main() {
Calc_ctor(&Calc_inst); /* Calc "constructor" invokes QHsm_ctor() */
QHSM_INIT(&Calc_inst.super, (QEvt *)0); /* trigger initial transition */
for (;;) { /* event loop */
QEvt e;
. . .
/* wait for the next event and assign it to the event object e */
. . .
QHSM_DISPATCH(&Calc_inst.super, &e); /* dispatch e */
}
return 0;
}
#define QHSM_INIT(me_, par_, qs_id_)
Definition: qep.h:892
#define QHSM_DISPATCH(me_, e_, qs_id_)
Definition: qep.h:923
QP/C public interface including backwards-compatibility layer.
Event class.
Definition: qep.h:167

Definition at line 892 of file qep.h.

◆ QHSM_DISPATCH

#define QHSM_DISPATCH (   me_,
  e_,
  qs_id_ 
)     ((*(me_)->vptr->dispatch)((me_), (e_), (qs_id_)))

Virtual call to dispatch an event to a HSM

Processes one event at a time in Run-to-Completion fashion.

Parameters
[in,out]me_current instance pointer (see oop)
[in]e_constant pointer the QEvt or a class derived from QEvt (see oop)
[in]qs_id_QS local filter ID (used only when Q_SPY is defined)
Note
Must be called after the "constructor" and after QHSM_INIT().
Traceability

Definition at line 923 of file qep.h.

◆ Q_HSM_UPCAST

#define Q_HSM_UPCAST (   ptr_)    ((QHsm *)(ptr_))

Perform upcast from a subclass of QHsm to the base class QHsm

Upcasting from a subclass to superclass is a very frequent and safe operation in object-oriented programming and object-oriented languages (such as C++) perform such upcasting automatically. However, OOP is implemented in C just as a set of coding conventions (see oop), and the C compiler does not "know" that certain types are related by inheritance. Therefore for C, the upcast must be performed explicitly. Unfortunately, pointer casting violates the advisory MISRA-C 2012 Rule 11.3(req) "A cast shall not be performed between a pointer to object type and a pointer to a different object type". This macro encapsulates this deviation and provides a descriptive name for the reason of this cast.

Definition at line 948 of file qep.h.

◆ Q_TRAN

#define Q_TRAN (   target_)     ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(target_), Q_RET_TRAN)

Perform upcast from a subclass of QHsm to the base class QHsm

Upcasting from a subclass to superclass is a very frequent and safe operation in object-oriented programming and object-oriented languages (such as C++) perform such upcasting automatically. However, OOP is implemented in C just as a set of coding conventions (see oop), and the C compiler does not "know" that certain types are related by inheritance. Therefore for C, the upcast must be performed explicitly. Unfortunately, pointer casting violates the advisory MISRA-C 2012 Rule 11.3(req) "A cast shall not be performed between a pointer to object type and a pointer to a different object type". This macro encapsulates this deviation and provides a descriptive name for the reason of this cast.

Definition at line 965 of file qep.h.

◆ Q_TRAN_HIST

#define Q_TRAN_HIST (   hist_)     ((Q_HSM_UPCAST(me))->temp.fun = (hist_), Q_RET_TRAN_HIST)

Macro to call in a state-handler when it executes a transition to history. Applicable only to HSMs.

Traceability
Usage
typedef struct {
QHsm super; /* inherit QHsm */
QStateHandler hist_doorClosed; /* history of doorClosed */
} ToastOven;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~.*/
static QState ToastOven_doorClosed(ToastOven * const me,
QEvt const * const e)
{
QState status;
switch (e->sig) {
~ ~ ~
case Q_EXIT_SIG: {
me->hist_doorClosed = QHsm_state(&me->super);
status = Q_HANDLED();
break;
}
}
return status;
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~.*/
static QState ToastOven_doorOpen(ToastOven * const me,
QEvt const * const e)
{
QState status;
switch (e->sig) {
~ ~ ~
case CLOSE_SIG: {
status = Q_TRAN_HIST(hist_doorClosed); /*<--- */
break;
}
default: {
status = Q_SUPER(&QHsm_top);
break;
}
}
return status;
}
#define Q_HANDLED()
Definition: qep.h:1002
QState(* QStateHandler)(void *const me, QEvt const *const e)
Definition: qep.h:252
enum QStateRet QState
Definition: qep.h:248
@ Q_EXIT_SIG
Definition: qep.h:319
#define Q_TRAN_HIST(hist_)
Definition: qep.h:978
#define Q_SUPER(super_)
Definition: qep.h:991
QSignal sig
Definition: qep.h:176
Hierarchical State Machine class.
Definition: qep.h:353

Definition at line 978 of file qep.h.

◆ Q_SUPER

#define Q_SUPER (   super_)     ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(super_), Q_RET_SUPER)

Macro to call in a state-handler when it designates the superstate of a given state. Applicable only to QHsm subclasses.

Traceability
Usage
QState Blinky_off(Blinky * const me, QEvt const * const e) {
QState status;
switch (e->sig) {
case Q_ENTRY_SIG: {
BSP_ledOff();
status = Q_HANDLED();
break;
}
case TIMEOUT_SIG: {
status = Q_TRAN(&Blinky_on);
break;
}
default: {
status = Q_SUPER(&QHsm_top); /*<--- */
break;
}
}
return status;
}
#define Q_TRAN(target_)
Definition: qep.h:965
@ Q_ENTRY_SIG
Definition: qep.h:318

Definition at line 991 of file qep.h.

◆ Q_HANDLED

#define Q_HANDLED ( )    (Q_RET_HANDLED)

Macro to call in a state-handler when it handles an event.

Traceability

Definition at line 1002 of file qep.h.

◆ Q_UNHANDLED

#define Q_UNHANDLED ( )    (Q_RET_UNHANDLED)

Macro to call in a state-handler when it 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 QHsm subclasses.

Definition at line 1009 of file qep.h.

◆ Q_ACTION_NULL

#define Q_ACTION_NULL   ((QActionHandler)0)

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

Definition at line 1015 of file qep.h.

◆ Q_EVT_CAST

#define Q_EVT_CAST (   class_)    ((class_ const *)(e))

Perform downcast of an event onto a subclass of QEvt class_

This macro encapsulates the downcast of QEvt pointers, which violates MISRA-C 2012 Rule 11.3(R) "A cast shall not be performed between a pointer to object type and a pointer to a different object type". This macro helps to localize this deviation.

Parameters
class_a subclass of QEvt
Traceability

Definition at line 1032 of file qep.h.

◆ Q_STATE_CAST

#define Q_STATE_CAST (   handler_)    ((QStateHandler)(handler_))

Perform cast to QStateHandler.

This macro encapsulates the cast of a specific state handler function pointer to QStateHandler, which violates MISRA:C-2012 Rule 11.1(req) "Conversions shall not be performed between a pointer to function and any other type". This macro helps to localize this deviation.

Traceability
Usage
void Calc_ctor(Calc * const me) {
/* superclass' ctor */
QHsm_ctor(&me->super, Q_STATE_CAST(&Calc_initial));
me->operand1 = 0.0;
me->operand2 = 0.0;
me->len = 0U;
me->opKey = 0U;
}
#define Q_STATE_CAST(handler_)
Definition: qep.h:1050

Definition at line 1050 of file qep.h.

◆ Q_ACTION_CAST

#define Q_ACTION_CAST (   action_)    ((QActionHandler)(action_))

Perform cast to QActionHandler.

This macro encapsulates the cast of a specific action handler function pointer to QActionHandler, which violates MISRA:C-2012 Rule 11.1(R) "Conversions shall not be performed between a pointer to function and any other type". This macro helps to localize this deviation.

Traceability

Definition at line 1065 of file qep.h.

◆ Q_UNUSED_PAR

#define Q_UNUSED_PAR (   par_)    ((void)(par_))

Helper macro to clearly mark unused parameters of functions.

Definition at line 1069 of file qep.h.

◆ Q_DIM

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

Helper macro to calculate static dimension of a 1-dim array_

Parameters
array_1-dimensional array
Returns
the length of the array (number of elements it can hold)

Definition at line 1077 of file qep.h.

◆ Q_UINT2PTR_CAST

#define Q_UINT2PTR_CAST (   type_,
  uint_ 
)    ((type_ *)(uint_))

Perform cast from unsigned integer uint_ to pointer of type type_

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 1088 of file qep.h.

◆ QEVT_INITIALIZER

#define QEVT_INITIALIZER (   sig_)    { (QSignal)(sig_), 0U, 0U }

Initializer of static constant QEvt instances

This macro encapsulates the ugly casting of enumerated signals to QSignal and constants for QEvt.poolID and QEvt.refCtr_.

Definition at line 1097 of file qep.h.

◆ QM_ENTRY

#define QM_ENTRY (   state_)     ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_ENTRY)

Macro to call in a QM action-handler when it executes an entry action. Applicable only to QMsm subclasses.

Definition at line 1104 of file qep.h.

◆ QM_EXIT

#define QM_EXIT (   state_)     ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_EXIT)

Macro to call in a QM action-handler when it executes an exit action. Applicable only to QMsm subclasses.

Definition at line 1118 of file qep.h.

◆ QM_SM_EXIT

#define QM_SM_EXIT (   state_)     ((Q_HSM_UPCAST(me))->temp.obj = (state_), Q_RET_EXIT)

Macro to call in a QM submachine exit-handler. Applicable only to subclasses of QMsm.

Definition at line 1131 of file qep.h.

◆ QM_TRAN

#define QM_TRAN (   tatbl_)
Value:
((Q_HSM_UPCAST(me))->temp.tatbl \
= (struct QMTranActTable const *)(tatbl_), Q_RET_TRAN)
@ Q_RET_TRAN
Definition: qep.h:237
#define Q_HSM_UPCAST(ptr_)
Definition: qep.h:948
Transition-Action Table for the QMsm State Machine.
Definition: qep.h:292

Macro to call in a QM state-handler when it executes a regular transition. Applicable only to QMsm subclasses.

Definition at line 1138 of file qep.h.

◆ QM_TRAN_INIT

#define QM_TRAN_INIT (   tatbl_)
Value:
((Q_HSM_UPCAST(me))->temp.tatbl \
= (struct QMTranActTable const *)(tatbl_), Q_RET_TRAN_INIT)
@ Q_RET_TRAN_INIT
Definition: qep.h:238

Macro to call in a QM state-handler when it executes an initial transition. Applicable only to QMsm subclasses.

Definition at line 1145 of file qep.h.

◆ QM_TRAN_HIST

#define QM_TRAN_HIST (   history_,
  tatbl_ 
)
Value:
((((Q_HSM_UPCAST(me))->state.obj = (history_)), \
((Q_HSM_UPCAST(me))->temp.tatbl = \
(struct QMTranActTable const *)(tatbl_))), \
@ Q_RET_TRAN_HIST
Definition: qep.h:242

Macro to call in a QM state-handler when it executes a transition to history. Applicable only to QMsm subclasses.

Definition at line 1152 of file qep.h.

◆ QM_TRAN_EP

#define QM_TRAN_EP (   tatbl_)
Value:
((Q_HSM_UPCAST(me))->temp.tatbl \
= (struct QMTranActTable const *)(tatbl_), Q_RET_TRAN_EP)
@ Q_RET_TRAN_EP
Definition: qep.h:239

Macro to call in a QM state-handler when it executes a transition to the submachine via an entry point.

Definition at line 1162 of file qep.h.

◆ QM_TRAN_XP

#define QM_TRAN_XP (   xp_,
  tatbl_ 
)
Value:
((((Q_HSM_UPCAST(me))->state.act = (xp_)), \
((Q_HSM_UPCAST(me))->temp.tatbl = \
(struct QMTranActTable const *)(tatbl_))), \
@ Q_RET_TRAN_XP
Definition: qep.h:243

Macro to call in a QM state-handler when it executes a transition to exit point. Applicable only to QMsm subclasses.

Definition at line 1169 of file qep.h.

◆ 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 1179 of file qep.h.

◆ QM_UNHANDLED

#define QM_UNHANDLED ( )    (Q_RET_UNHANDLED)

Macro to call in a QM state-handler when when it 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 QMsm subclasses.

Definition at line 1187 of file qep.h.

◆ 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 QMSMs.

Definition at line 1193 of file qep.h.

◆ QM_SUPER_SUB

#define QM_SUPER_SUB (   host_)     ((Q_HSM_UPCAST(me))->temp.obj = (host_), Q_RET_SUPER_SUB)

Macro to call in a QM submachine-handler when it designates the host state to handle an event. Applicable only to subclasses of QMsm.

Definition at line 1199 of file qep.h.

◆ QM_STATE_NULL

#define QM_STATE_NULL   ((QMState *)0)

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

Definition at line 1206 of file qep.h.

Typedef Documentation

◆ int_t

typedef int int_t

alias for line numbers in assertions and return from QF_run()

Definition at line 72 of file qep.h.

◆ enum_t

typedef int enum_t

alias for enumerations used for event signals

Definition at line 76 of file qep.h.

◆ float32_t

typedef float float32_t

alias for IEEE 754 32-bit floating point number, MISRA-C 2012 Dir 4.6(A)

Note
QP 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 88 of file qep.h.

◆ float64_t

typedef double float64_t

alias for IEEE 754 64-bit floating point number, MISRA-C 2012 Dir 4.6(A)

Note
QP 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 100 of file qep.h.

◆ QSignal

typedef uint16_t QSignal

QSignal represents the signal of an event

The relationship between an event and a signal is as follows. A signal in UML is the specification of an asynchronous stimulus that triggers reactions, and as such is an essential part of an event. (The signal conveys the type of the occurrence–what happened?) However, an event can also contain additional quantitative information about the occurrence in form of event parameters.

Definition at line 137 of file qep.h.

◆ QState

typedef enum QStateRet QState

Type returned from state-handler functions

Definition at line 248 of file qep.h.

◆ QStateHandler

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

Pointer to a state-handler function.

Definition at line 252 of file qep.h.

◆ QActionHandler

typedef QState(* QActionHandler) (void *const me)

Pointer to an action-handler function.

Definition at line 256 of file qep.h.

◆ QXThreadHandler

typedef void(* QXThreadHandler) (struct QXThread *const me)

Pointer to an eXthended thread handler function

Definition at line 264 of file qep.h.

Enumeration Type Documentation

◆ QStateRet

enum QStateRet

All possible values returned from state/action handlers

Note
The order matters for algorithmic correctness.
Enumerator
Q_RET_SUPER 

event passed to superstate to handle

Q_RET_SUPER_SUB 

event passed to submachine superstate

Q_RET_UNHANDLED 

event unhandled due to a guard

Q_RET_HANDLED 

event handled (internal transition)

Q_RET_IGNORED 

event silently ignored (bubbled up to top)

Q_RET_ENTRY 

state entry action executed

Q_RET_EXIT 

state exit action executed

Q_RET_NULL 

return value without any effect

Q_RET_TRAN 

regular transition

Q_RET_TRAN_INIT 

initial transition in a state or submachine

Q_RET_TRAN_EP 

entry-point transition into a submachine

Q_RET_TRAN_HIST 

transition to history of a given state

Q_RET_TRAN_XP 

exit-point transition out of a submachine

Definition at line 219 of file qep.h.

◆ QReservedSig

Reserved signals by the HSM-style state machine implementation strategy.

Enumerator
Q_EMPTY_SIG 

signal to execute the default case

Q_ENTRY_SIG 

signal for coding entry actions

Q_EXIT_SIG 

signal for coding exit actions

Q_INIT_SIG 

signal for coding initial transitions

Q_USER_SIG 

offset for the user signals (QP Application)

Definition at line 316 of file qep.h.

Function Documentation

◆ QHsm_tran_()

int_fast8_t QHsm_tran_ ( QHsm *const  me,
QStateHandler *const  path,
uint_fast8_t const  qs_id 
)

Helper function to execute transition sequence in a hierarchical state machine (HSM).

Parameters
[in,out]patharray of pointers to state-handler functions to execute the entry actions
[in]qs_idQS-id of this state machine (for QS local filter)
Returns
the depth of the entry path stored in the path parameter.
Traceability

Variable Documentation

◆ QP_versionStr

char const QP_versionStr[8]
extern

the current QP version number string in ROM, based on QP_VERSION_STR