qs.h

Go to the documentation of this file.

/*$file${include::qs.h} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*
* Model: qpc.qm
* File:  ${include::qs.h}
*
* This code has been generated by QM 5.2.1 <www.state-machine.com/qm>.
* DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
*
* This code is covered by the following QP license:
* License #    : LicenseRef-QL-dual
* Issued to    : Any user of the QP/C real-time embedded framework
* Framework(s) : qpc
* Support ends : 2023-12-31
* License scope:
*
* Copyright (C) 2005 Quantum Leaps, LLC <state-machine.com>.
*
* SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
*
* This software is dual-licensed under the terms of the open source GNU
* General Public License version 3 (or any later version), or alternatively,
* under the terms of one of the closed source Quantum Leaps commercial
* licenses.
*
* The terms of the open source GNU General Public License version 3
* can be found at: <www.gnu.org/licenses/gpl-3.0>
*
* The terms of the closed source Quantum Leaps commercial licenses
* can be found at: <www.state-machine.com/licensing>
*
* Redistributions in source code must retain this top-level comment block.
* Plagiarizing this software to sidestep the license obligations is illegal.
*
* Contact information:
* <www.state-machine.com/licensing>
* <info@state-machine.com>
*/
/*$endhead${include::qs.h} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
#ifndef QS_H
#define QS_H
 
#ifndef Q_SPY
    #error "Q_SPY must be defined to include qs.h"
#endif
 
/*==========================================================================*/
/*$declare${QS-config} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QS-config::QS_TIME_SIZE} ...............................................*/
#ifndef QS_TIME_SIZE
#define QS_TIME_SIZE 4U
#endif /* ndef QS_TIME_SIZE */
 
/*${QS-config::QS_TIME_SIZE defined incorrectly~} ..........................*/
#if (QS_TIME_SIZE != 1U) && (QS_TIME_SIZE != 2U) && (QS_TIME_SIZE != 4U)
#error QS_TIME_SIZE defined incorrectly, expected 1U, 2U, or 4U;
#endif /*  (QS_TIME_SIZE != 1U) && (QS_TIME_SIZE != 2U) && (QS_TIME_SIZE != 4U) */
/*$enddecl${QS-config} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
/*==========================================================================*/
/*$declare${QS} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QS::QSTimeCtr} .........................................................*/
#if (QS_TIME_SIZE == 4U) 
typedef uint32_t QSTimeCtr;
#endif /*  (QS_TIME_SIZE == 4U)  */
 
/*${QS::QSTimeCtr} .........................................................*/
#if (QS_TIME_SIZE == 2U) 
typedef uint16_t QSTimeCtr;
#endif /*  (QS_TIME_SIZE == 2U)  */
 
/*${QS::QSTimeCtr} .........................................................*/
#if (QS_TIME_SIZE == 1U) 
typedef uint8_t QSTimeCtr;
#endif /*  (QS_TIME_SIZE == 1U)  */
 
/*${QS::QSFun} .............................................................*/
#if (QS_FUN_PTR_SIZE == 4U) 
typedef uint32_t QSFun;
#endif /*  (QS_FUN_PTR_SIZE == 4U)  */
 
/*${QS::QSFun} .............................................................*/
#if (QS_FUN_PTR_SIZE == 8U) 
typedef uint64_t QSFun;
#endif /*  (QS_FUN_PTR_SIZE == 8U)  */
 
/*${QS::QSFun} .............................................................*/
#if (QS_FUN_PTR_SIZE == 2U) 
typedef uint16_t QSFun;
#endif /*  (QS_FUN_PTR_SIZE == 2U)  */
 
/*${QS::QSFun} .............................................................*/
#if (QS_FUN_PTR_SIZE == 1U) 
typedef uint8_t QSFun;
#endif /*  (QS_FUN_PTR_SIZE == 1U)  */
 
/*${QS::QSCtr} .............................................................*/
typedef uint_fast16_t QSCtr;
 
/*${QS::QSpyPre} ...........................................................*/
enum QSpyPre {
    /* [0] QS session (not maskable) */
    QS_EMPTY,             
    /* [1] SM records */
    QS_QEP_STATE_ENTRY,   
    QS_QEP_STATE_EXIT,    
    QS_QEP_STATE_INIT,    
    QS_QEP_INIT_TRAN,     
    QS_QEP_INTERN_TRAN,   
    QS_QEP_TRAN,          
    QS_QEP_IGNORED,       
    QS_QEP_DISPATCH,      
    QS_QEP_UNHANDLED,     
    /* [10] Active Object (AO) records */
    QS_QF_ACTIVE_DEFER,   
    QS_QF_ACTIVE_RECALL,  
    QS_QF_ACTIVE_SUBSCRIBE,   
    QS_QF_ACTIVE_UNSUBSCRIBE, 
    QS_QF_ACTIVE_POST,      
    QS_QF_ACTIVE_POST_LIFO, 
    QS_QF_ACTIVE_GET,     
    QS_QF_ACTIVE_GET_LAST,
    QS_QF_ACTIVE_RECALL_ATTEMPT, 
    /* [19] Event Queue (EQ) records */
    QS_QF_EQUEUE_POST,      
    QS_QF_EQUEUE_POST_LIFO, 
    QS_QF_EQUEUE_GET,     
    QS_QF_EQUEUE_GET_LAST,
    /* [23] Framework (QF) records */
    QS_QF_NEW_ATTEMPT,   
    /* [24] Memory Pool (MP) records */
    QS_QF_MPOOL_GET,      
    QS_QF_MPOOL_PUT,      
    /* [26] Additional Framework (QF) records */
    QS_QF_PUBLISH,        
    QS_QF_NEW_REF,        
    QS_QF_NEW,            
    QS_QF_GC_ATTEMPT,     
    QS_QF_GC,             
    QS_QF_TICK,           
    /* [32] Time Event (TE) records */
    QS_QF_TIMEEVT_ARM,    
    QS_QF_TIMEEVT_AUTO_DISARM, 
    QS_QF_TIMEEVT_DISARM_ATTEMPT,
    QS_QF_TIMEEVT_DISARM, 
    QS_QF_TIMEEVT_REARM,  
    QS_QF_TIMEEVT_POST,   
    /* [38] Additional Framework (QF) records */
    QS_QF_DELETE_REF,     
    QS_QF_CRIT_ENTRY,     
    QS_QF_CRIT_EXIT,      
    QS_QF_ISR_ENTRY,      
    QS_QF_ISR_EXIT,       
    QS_QF_INT_DISABLE,    
    QS_QF_INT_ENABLE,     
    /* [45] Additional Active Object (AO) records */
    QS_QF_ACTIVE_POST_ATTEMPT,
    /* [46] Additional Event Queue (EQ) records */
    QS_QF_EQUEUE_POST_ATTEMPT,
    /* [47] Additional Memory Pool (MP) records */
    QS_QF_MPOOL_GET_ATTEMPT,  
    /* [48] Scheduler (SC) records */
    QS_MUTEX_LOCK,        
    QS_MUTEX_UNLOCK,      
    QS_SCHED_LOCK,        
    QS_SCHED_UNLOCK,      
    QS_SCHED_NEXT,        
    QS_SCHED_IDLE,        
    QS_SCHED_RESUME,      
    /* [55] Additional QEP records */
    QS_QEP_TRAN_HIST,     
    QS_QEP_TRAN_EP,       
    QS_QEP_TRAN_XP,       
    /* [58] Miscellaneous QS records (not maskable) */
    QS_TEST_PAUSED,       
    QS_TEST_PROBE_GET,    
    QS_SIG_DICT,          
    QS_OBJ_DICT,          
    QS_FUN_DICT,          
    QS_USR_DICT,          
    QS_TARGET_INFO,       
    QS_TARGET_DONE,       
    QS_RX_STATUS,         
    QS_QUERY_DATA,        
    QS_PEEK_DATA,         
    QS_ASSERT_FAIL,       
    QS_QF_RUN,            
    QS_MAX,               
};
 
/*${QS::QSpyGroups} ........................................................*/
enum QSpyGroups {
    QS_ALL_RECORDS = 0xF0,
    QS_SM_RECORDS,        
    QS_AO_RECORDS,        
    QS_EQ_RECORDS,        
    QS_MP_RECORDS,        
    QS_TE_RECORDS,        
    QS_QF_RECORDS,        
    QS_SC_RECORDS,        
    QS_U0_RECORDS,        
    QS_U1_RECORDS,        
    QS_U2_RECORDS,        
    QS_U3_RECORDS,        
    QS_U4_RECORDS,        
    QS_UA_RECORDS         
};
 
/*${QS::QSpyUserOffsets} ...................................................*/
enum QSpyUserOffsets {
    QS_USER  = 100,   
    QS_USER0 = (enum_t)QS_USER,      
    QS_USER1 = (enum_t)QS_USER0 + 5, 
    QS_USER2 = (enum_t)QS_USER1 + 5, 
    QS_USER3 = (enum_t)QS_USER2 + 5, 
    QS_USER4 = (enum_t)QS_USER3 + 5  
};
 
/*${QS::QSpyIdOffsets} .....................................................*/
enum QSpyIdOffsets {
    QS_AO_ID = 0,  
    QS_EP_ID = 64, 
    QS_EQ_ID = 80, 
    QS_AP_ID = 96, 
};
 
/*${QS::QSpyIdGroups} ......................................................*/
enum QSpyIdGroups {
    QS_ALL_IDS = 0xF0,                      
    QS_AO_IDS  = (0x80 + (enum_t)QS_AO_ID), 
    QS_EP_IDS  = (0x80 + (enum_t)QS_EP_ID), 
    QS_EQ_IDS  = (0x80 + (enum_t)QS_EQ_ID), 
    QS_AP_IDS  = (0x80 + (enum_t)QS_AP_ID), 
};
 
/*${QS::QSpyFunPtr} ........................................................*/
typedef void (* QSpyFunPtr )(void);
 
/*${QS::QS_EOD} ............................................................*/
#define QS_EOD ((uint16_t)0xFFFFU)
 
/*${QS::QSpyId} ............................................................*/
typedef struct { uint8_t prio; } QSpyId;
 
/*${QS::QS-tx::tx} .........................................................*/
typedef struct {
/* public: */
 
    uint8_t glbFilter[16];
 
    uint8_t locFilter[16];
 
    void const * locFilter_AP;
 
    uint8_t * buf;
 
    QSCtr end;
 
    QSCtr volatile head;
 
    QSCtr volatile tail;
 
    QSCtr volatile used;
 
    uint8_t volatile seq;
 
    uint8_t volatile chksum;
 
    uint8_t volatile critNest;
} QS_tx;
 
/*${QS::QS-tx::preType} ....................................................*/
enum QS_preType {
    QS_I8_T,              
    QS_U8_T,              
    QS_I16_T,             
    QS_U16_T,             
    QS_I32_T,             
    QS_U32_T,             
    QS_F32_T,             
    QS_F64_T,             
    QS_STR_T,             
    QS_MEM_T,             
    QS_SIG_T,             
    QS_OBJ_T,             
    QS_FUN_T,             
    QS_I64_T,             
    QS_U64_T,             
    QS_HEX_FMT            
};
 
/*${QS::QS-tx::priv_} ......................................................*/
extern QS_tx QS_priv_;
 
/*${QS::QS-tx::initBuf} ....................................................*/
void QS_initBuf(
    uint8_t * const sto,
    uint_fast16_t const stoSize);
 
/*${QS::QS-tx::getByte} ....................................................*/
uint16_t QS_getByte(void);
 
/*${QS::QS-tx::getBlock} ...................................................*/
uint8_t const * QS_getBlock(uint16_t * const pNbytes);
 
/*${QS::QS-tx::glbFilter_} .................................................*/
void QS_glbFilter_(int_fast16_t const filter);
 
/*${QS::QS-tx::locFilter_} .................................................*/
void QS_locFilter_(int_fast16_t const filter);
 
/*${QS::QS-tx::doOutput} ...................................................*/
void QS_doOutput(void);
 
/*${QS::QS-tx::beginRec_} ..................................................*/
void QS_beginRec_(uint_fast8_t const rec);
 
/*${QS::QS-tx::endRec_} ....................................................*/
void QS_endRec_(void);
 
/*${QS::QS-tx::u8_raw_} ....................................................*/
void QS_u8_raw_(uint8_t const d);
 
/*${QS::QS-tx::2u8_raw_} ...................................................*/
void QS_2u8_raw_(
    uint8_t const d1,
    uint8_t const d2);
 
/*${QS::QS-tx::u16_raw_} ...................................................*/
void QS_u16_raw_(uint16_t d);
 
/*${QS::QS-tx::u32_raw_} ...................................................*/
void QS_u32_raw_(uint32_t d);
 
/*${QS::QS-tx::obj_raw_} ...................................................*/
void QS_obj_raw_(void const * const obj);
 
/*${QS::QS-tx::str_raw_} ...................................................*/
void QS_str_raw_(char const * str);
 
/*${QS::QS-tx::u8_fmt_} ....................................................*/
void QS_u8_fmt_(
    uint8_t const format,
    uint8_t const d);
 
/*${QS::QS-tx::u16_fmt_} ...................................................*/
void QS_u16_fmt_(
    uint8_t format,
    uint16_t d);
 
/*${QS::QS-tx::u32_fmt_} ...................................................*/
void QS_u32_fmt_(
    uint8_t format,
    uint32_t d);
 
/*${QS::QS-tx::str_fmt_} ...................................................*/
void QS_str_fmt_(char const * str);
 
/*${QS::QS-tx::mem_fmt_} ...................................................*/
void QS_mem_fmt_(
    uint8_t const * blk,
    uint8_t size);
 
/*${QS::QS-tx::sig_dict_pre_} ..............................................*/
void QS_sig_dict_pre_(
    enum_t const sig,
    void const * const obj,
    char const * const name);
 
/*${QS::QS-tx::obj_dict_pre_} ..............................................*/
void QS_obj_dict_pre_(
    void const * const obj,
    char const * const name);
 
/*${QS::QS-tx::obj_arr_dict_pre_} ..........................................*/
void QS_obj_arr_dict_pre_(
    void const * const obj,
    uint_fast16_t const idx,
    char const * const name);
 
/*${QS::QS-tx::fun_dict_pre_} ..............................................*/
void QS_fun_dict_pre_(
    QSpyFunPtr fun,
    char const * const name);
 
/*${QS::QS-tx::usr_dict_pre_} ..............................................*/
void QS_usr_dict_pre_(
    enum_t const rec,
    char const * const name);
 
/*${QS::QS-tx::ASSERTION} ..................................................*/
void QS_ASSERTION(
    char const * const module,
    int_t const loc,
    uint32_t const delay);
 
/*${QS::QS-tx::target_info_pre_} ...........................................*/
void QS_target_info_pre_(uint8_t const isReset);
 
/*${QS::QS-tx::onStartup} ..................................................*/
uint8_t QS_onStartup(void const * arg);
 
/*${QS::QS-tx::onCleanup} ..................................................*/
void QS_onCleanup(void);
 
/*${QS::QS-tx::onFlush} ....................................................*/
void QS_onFlush(void);
 
/*${QS::QS-tx::onGetTime} ..................................................*/
QSTimeCtr QS_onGetTime(void);
 
/*${QS::QS-tx-64bit::u64_raw_} .............................................*/
void QS_u64_raw_(uint64_t d);
 
/*${QS::QS-tx-64bit::u64_fmt_} .............................................*/
void QS_u64_fmt_(
    uint8_t format,
    uint64_t d);
 
/*${QS::QS-tx-fp::f32_fmt_} ................................................*/
void QS_f32_fmt_(
    uint8_t format,
    float32_t d);
 
/*${QS::QS-tx-fp::f64_fmt_} ................................................*/
void QS_f64_fmt_(
    uint8_t format,
    float64_t d);
 
/*${QS::QS-rx::rx} .........................................................*/
typedef struct {
/* public: */
    void * currObj[8];
    uint8_t * buf;
    QSCtr  end;
    QSCtr volatile head;
    QSCtr volatile tail;
#ifdef Q_UTEST
    bool inTestLoop;
#endif /* def Q_UTEST */
} QS_rx;
 
/*${QS::QS-rx::rxPriv_} ....................................................*/
extern QS_rx QS_rxPriv_;
 
/*${QS::QS-rx::QSpyObjKind} ................................................*/
enum QS_QSpyObjKind {
    SM_OBJ,    
    AO_OBJ,    
    MP_OBJ,    
    EQ_OBJ,    
    TE_OBJ,    
    AP_OBJ,    
    MAX_OBJ
};
 
/*${QS::QS-rx::OSpyObjCombnation} ..........................................*/
enum QS_OSpyObjCombnation {
    SM_AO_OBJ = (enum_t)MAX_OBJ 
};
 
/*${QS::QS-rx::rxInitBuf} ..................................................*/
void QS_rxInitBuf(
    uint8_t * const sto,
    uint16_t const stoSize);
 
/*${QS::QS-rx::rxPut} ......................................................*/
static inline bool QS_rxPut(uint8_t const b) {
    QSCtr head = QS_rxPriv_.head + 1U;
    if (head == QS_rxPriv_.end) {
        head = 0U;
    }
    if (head != QS_rxPriv_.tail) { /* buffer NOT full? */
        QS_rxPriv_.buf[QS_rxPriv_.head] = b;
        QS_rxPriv_.head = head; /* update the head to a *valid* index */
        return true;  /* byte placed in the buffer */
    }
    else {
        return false; /* byte NOT placed in the buffer */
    }
}
 
/*${QS::QS-rx::rxGetNfree} .................................................*/
uint16_t QS_rxGetNfree(void);
 
/*${QS::QS-rx::doInput} ....................................................*/
void QS_doInput(void);
 
/*${QS::QS-rx::setCurrObj} .................................................*/
void QS_setCurrObj(
    uint8_t obj_kind,
    void * obj_ptr);
 
/*${QS::QS-rx::queryCurrObj} ...............................................*/
void QS_queryCurrObj(uint8_t obj_kind);
 
/*${QS::QS-rx::rxParse} ....................................................*/
void QS_rxParse(void);
 
/*${QS::QS-rx::rxHandleGoodFrame_} .........................................*/
void QS_rxHandleGoodFrame_(uint8_t const state);
 
/*${QS::QS-rx::onReset} ....................................................*/
void QS_onReset(void);
 
/*${QS::QS-rx::onCommand} ..................................................*/
void QS_onCommand(
    uint8_t cmdId,
    uint32_t param1,
    uint32_t param2,
    uint32_t param3);
 
/*${QS::QS-rx::RX_PUT} .....................................................*/
bool QS_RX_PUT(uint8_t const b);
/*$enddecl${QS} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
/*==========================================================================*/
/*$declare${QS-macros} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QS-macros::QS_INIT} ....................................................*/
#define QS_INIT(arg_) (QS_onStartup(arg_))
 
/*${QS-macros::QS_EXIT} ....................................................*/
#define QS_EXIT() (QS_onCleanup())
 
/*${QS-macros::QS_OUTPUT} ..................................................*/
#define QS_OUTPUT() (QS_output())
 
/*${QS-macros::QS_RX_INPUT} ................................................*/
#define QS_RX_INPUT() (QS_rx_input())
 
/*${QS-macros::QS_GLB_FILTER} ..............................................*/
#define QS_GLB_FILTER(rec_) (QS_glbFilter_((int_fast16_t)(rec_)))
 
/*${QS-macros::QS_LOC_FILTER} ..............................................*/
#define QS_LOC_FILTER(qs_id_) (QS_locFilter_((int_fast16_t)(qs_id_)))
 
/*${QS-macros::QS_BEGIN_ID} ................................................*/
#define QS_BEGIN_ID(rec_, qs_id_) \
if (QS_GLB_CHECK_(rec_) && QS_LOC_CHECK_(qs_id_)) { \
    QS_CRIT_STAT_ \
    QS_CRIT_E_(); \
    QS_beginRec_((uint_fast8_t)(rec_)); \
    QS_TIME_PRE_(); {
 
/*${QS-macros::QS_END} .....................................................*/
#define QS_END() } \
    QS_endRec_(); \
    QS_CRIT_X_(); \
}
 
/*${QS-macros::QS_FLUSH} ...................................................*/
#define QS_FLUSH() (QS_onFlush())
 
/*${QS-macros::QS_BEGIN_NOCRIT} ............................................*/
#define QS_BEGIN_NOCRIT(rec_, qs_id_) \
if (QS_GLB_CHECK_(rec_) && QS_LOC_CHECK_(qs_id_)) { \
    QS_beginRec_((uint_fast8_t)(rec_)); \
    QS_TIME_PRE_(); {
 
/*${QS-macros::QS_END_NOCRIT} ..............................................*/
#define QS_END_NOCRIT() } \
    QS_endRec_();\
}
 
/*${QS-macros::QS_GLB_CHECK_} ..............................................*/
#define QS_GLB_CHECK_(rec_) \
    (((uint_fast8_t)QS_priv_.glbFilter[(uint_fast8_t)(rec_) >> 3U]  \
          & ((uint_fast8_t)1U << ((uint_fast8_t)(rec_) & 7U))) != 0U)
 
/*${QS-macros::QS_LOC_CHECK_} ..............................................*/
#define QS_LOC_CHECK_(qs_id_) \
    (((uint_fast8_t)QS_priv_.locFilter[(uint_fast8_t)(qs_id_) >> 3U] \
          & ((uint_fast8_t)1U << ((uint_fast8_t)(qs_id_) & 7U))) != 0U)
 
/*${QS-macros::QS_REC_DONE} ................................................*/
#ifndef QS_REC_DONE
#define QS_REC_DONE() ((void)0)
#endif /* ndef QS_REC_DONE */
 
/*${QS-macros::QS_I8} ......................................................*/
#define QS_I8(width_, data_) \
    (QS_u8_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_I8_T, (data_)))
 
/*${QS-macros::QS_U8} ......................................................*/
#define QS_U8(width_, data_) \
    (QS_u8_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_U8_T, (data_)))
 
/*${QS-macros::QS_I16} .....................................................*/
#define QS_I16(width_, data_) \
    (QS_u16_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_I16_T, (data_)))
 
/*${QS-macros::QS_U16} .....................................................*/
#define QS_U16(width_, data_) \
    (QS_u16_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_U16_T, (data_)))
 
/*${QS-macros::QS_I32} .....................................................*/
#define QS_I32(width_, data_) \
    (QS_u32_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_I32_T, (data_)))
 
/*${QS-macros::QS_U32} .....................................................*/
#define QS_U32(width_, data_) \
    (QS_u32_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_U32_T, (data_)))
 
/*${QS-macros::QS_I64} .....................................................*/
#define QS_I64(width_, data_) \
    (QS_u64_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_I64_T, (data_)))
 
/*${QS-macros::QS_U64} .....................................................*/
#define QS_U64(width_, data_) \
    (QS_u64_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_U64_T, (data_)))
 
/*${QS-macros::QS_F32} .....................................................*/
#define QS_F32(width_, data_) \
    (QS_f32_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_F32_T, (data_)))
 
/*${QS-macros::QS_F64} .....................................................*/
#define QS_F64(width_, data_) \
    (QS_f64_fmt_((uint8_t)(((width_) << 4)) | (uint8_t)QS_F64_T, (data_)))
 
/*${QS-macros::QS_STR} .....................................................*/
#define QS_STR(str_) (QS_str_fmt_((str_)))
 
/*${QS-macros::QS_MEM} .....................................................*/
#define QS_MEM(mem_, size_) (QS_mem_fmt_((mem_), (size_)))
 
/*${QS-macros::QS_TIME_PRE_} ...............................................*/
#if (QS_TIME_SIZE == 4U)
#define QS_TIME_PRE_() (QS_u32_raw_(QS_onGetTime()))
#endif /*  (QS_TIME_SIZE == 4U) */
 
/*${QS-macros::QS_TIME_PRE_} ...............................................*/
#if (QS_TIME_SIZE == 2U)
#define QS_TIME_PRE_() (QS_u16_raw_(QS_onGetTime()))
#endif /*  (QS_TIME_SIZE == 2U) */
 
/*${QS-macros::QS_TIME_PRE_} ...............................................*/
#if (QS_TIME_SIZE == 1U)
#define QS_TIME_PRE_() (QS_u8_raw_(QS_onGetTime()))
#endif /*  (QS_TIME_SIZE == 1U) */
 
/*${QS-macros::QS_OBJ} .....................................................*/
#if (QS_OBJ_PTR_SIZE == 4U)
#define QS_OBJ(obj_) (QS_u32_fmt_(QS_OBJ_T, (uint32_t)(obj_)))
#endif /*  (QS_OBJ_PTR_SIZE == 4U) */
 
/*${QS-macros::QS_OBJ} .....................................................*/
#if (QS_OBJ_PTR_SIZE == 2U)
#define QS_OBJ(obj_) (QS_u16_fmt_(QS_OBJ_T, (uint16_t)(obj_)))
#endif /*  (QS_OBJ_PTR_SIZE == 2U) */
 
/*${QS-macros::QS_OBJ} .....................................................*/
#if (QS_OBJ_PTR_SIZE == 1U)
#define QS_OBJ(obj_) (QS_u8_fmt_(QS_OBJ_T, (uint8_t)(obj_)))
#endif /*  (QS_OBJ_PTR_SIZE == 1U) */
 
/*${QS-macros::QS_OBJ} .....................................................*/
#if (QS_OBJ_PTR_SIZE == 8U)
#define QS_OBJ(obj_) (QS_u64_fmt_(QS_OBJ_T, (uint64_t)(obj_)))
#endif /*  (QS_OBJ_PTR_SIZE == 8U) */
 
/*${QS-macros::QS_FUN} .....................................................*/
#if (QS_FUN_PTR_SIZE == 4U)
/* Output formatted function pointer to the QS record */
#define QS_FUN(fun_) (QS_u32_fmt_(QS_FUN_T, (uint32_t)(fun_)))
#endif /*  (QS_FUN_PTR_SIZE == 4U) */
 
/*${QS-macros::QS_FUN} .....................................................*/
#if (QS_FUN_PTR_SIZE == 2U)
#define QS_FUN(fun_) (QS_u16_fmt_(QS_FUN_T, (uint16_t)(fun_)))
#endif /*  (QS_FUN_PTR_SIZE == 2U) */
 
/*${QS-macros::QS_FUN} .....................................................*/
#if (QS_FUN_PTR_SIZE == 1U)
#define QS_FUN(fun_) (QS_u8_fmt_(QS_FUN_T, (uint8_t)(fun_)))
#endif /*  (QS_FUN_PTR_SIZE == 1U) */
 
/*${QS-macros::QS_FUN} .....................................................*/
#if (QS_FUN_PTR_SIZE == 8U)
#define QS_FUN(fun_) (QS_u64_fmt_(QS_FUN_T, (uint64_t)(fun_)))
#endif /*  (QS_FUN_PTR_SIZE == 8U) */
 
/*${QS-macros::QS_SIG} .....................................................*/
#if (Q_SIGNAL_SIZE == 4U)
#define QS_SIG(sig_, obj_) \
        QS_u32_fmt_(QS_SIG_T, (sig_)); \
        QS_obj_raw_(obj_)
#endif /*  (Q_SIGNAL_SIZE == 4U) */
 
/*${QS-macros::QS_SIG} .....................................................*/
#if (Q_SIGNAL_SIZE == 2U)
#define QS_SIG(sig_, obj_) \
        QS_u16_fmt_(QS_SIG_T, (sig_)); \
        QS_obj_raw_(obj_)
#endif /*  (Q_SIGNAL_SIZE == 2U) */
 
/*${QS-macros::QS_SIG} .....................................................*/
#if (Q_SIGNAL_SIZE == 1U)
#define QS_SIG(sig_, obj_) \
        QS_u8_fmt_(QS_SIG_T, (sig_)); \
        QS_obj_raw_(obj_)
#endif /*  (Q_SIGNAL_SIZE == 1U) */
 
/*${QS-macros::QS_SIG_DICTIONARY} ..........................................*/
#define QS_SIG_DICTIONARY(sig_, obj_) \
    (QS_sig_dict_pre_((sig_), (obj_), #sig_))
 
/*${QS-macros::QS_OBJ_DICTIONARY} ..........................................*/
#define QS_OBJ_DICTIONARY(obj_) \
    (QS_obj_dict_pre_((obj_), #obj_))
 
/*${QS-macros::QS_OBJ_ARR_DICTIONARY} ......................................*/
#define QS_OBJ_ARR_DICTIONARY(obj_, idx_) \
    (QS_obj_arr_dict_pre_((obj_), (idx_), #obj_))
 
/*${QS-macros::QS_FUN_DICTIONARY} ..........................................*/
#define QS_FUN_DICTIONARY(fun_) \
    (QS_fun_dict_pre_((void (*)(void))(fun_), #fun_))
 
/*${QS-macros::QS_USR_DICTIONARY} ..........................................*/
#define QS_USR_DICTIONARY(rec_) \
    (QS_usr_dict_pre_((rec_), #rec_))
 
/*${QS-macros::QF_QS_CRIT_ENTRY} ...........................................*/
void QF_QS_CRIT_ENTRY(void);
 
/*${QS-macros::QF_QS_CRIT_EXIT} ............................................*/
void QF_QS_CRIT_EXIT(void);
 
/*${QS-macros::QF_QS_ISR_ENTRY} ............................................*/
void QF_QS_ISR_ENTRY(
    uint_fast8_t const isrnest,
    uint_fast8_t const prio_);
 
/*${QS-macros::QF_QS_ISR_EXIT} .............................................*/
void QF_QS_ISR_EXIT(
    uint_fast8_t isrnest,
    uint_fast8_t prio);
 
/*${QS-macros::QF_QS_ACTION} ...............................................*/
#define QF_QS_ACTION(act_) (act_)
/*$enddecl${QS-macros} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
/*==========================================================================*/
/* Facilities for QS critical section */
 
/* QS-specific critical section */
#ifdef QS_CRIT_ENTRY /* separate QS critical section defined? */
 
#ifndef QS_CRIT_STAT_TYPE
    #define QS_CRIT_STAT_
    #define QS_CRIT_E_()     QS_CRIT_ENTRY(dummy)
    #define QS_CRIT_X_()     QS_CRIT_EXIT(dummy); QS_REC_DONE()
#else
    #define QS_CRIT_STAT_    QS_CRIT_STAT_TYPE critStat_;
    #define QS_CRIT_E_()     QS_CRIT_ENTRY(critStat_)
    #define QS_CRIT_X_()     QS_CRIT_EXIT(critStat_); QS_REC_DONE()
#endif /* QS_CRIT_STAT_TYPE */
 
#else /* separate QS critical section not defined--use the QF definition */
 
#ifndef QF_CRIT_STAT_TYPE
    #define QS_CRIT_STAT_
 
    #define QS_CRIT_E_()     QF_CRIT_ENTRY(dummy)
 
    #define QS_CRIT_X_()     QF_CRIT_EXIT(dummy); QS_REC_DONE()
 
#elif (!defined QS_CRIT_STAT_)
 
    #define QS_CRIT_STAT_    QF_CRIT_STAT_TYPE critStat_;
    #define QS_CRIT_E_()     QF_CRIT_ENTRY(critStat_)
    #define QS_CRIT_X_()     QF_CRIT_EXIT(critStat_); QS_REC_DONE()
 
#endif /* simple unconditional interrupt disabling used */
 
#endif /* separate QS critical section not defined */
 
/*==========================================================================*/
/* Macros for use in QUTest only */
#ifdef Q_UTEST
 
/*$declare${QUTest} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QUTest::QS::TProbe} ....................................................*/
struct QS_TProbe {
    QSFun    addr;
    uint32_t data;
    uint8_t  idx;
};
 
/*${QUTest::QS::TestData} ..................................................*/
struct QS_TestData {
    struct QS_TProbe tpBuf[16]; 
    uint8_t   tpNum;     
    QSTimeCtr testTime;  
};
 
/*${QUTest::QS::testData} ..................................................*/
extern struct QS_TestData QS_testData;
 
/*${QUTest::QS::processTestEvts_} ..........................................*/
void QS_processTestEvts_(void);
 
/*${QUTest::QS::test_pause_} ...............................................*/
void QS_test_pause_(void);
 
/*${QUTest::QS::getTestProbe_} .............................................*/
uint32_t QS_getTestProbe_(QSpyFunPtr api);
 
/*${QUTest::QS::onTestSetup} ...............................................*/
void QS_onTestSetup(void);
 
/*${QUTest::QS::onTestTeardown} ............................................*/
void QS_onTestTeardown(void);
 
/*${QUTest::QS::onTestEvt} .................................................*/
void QS_onTestEvt(QEvt * e);
 
/*${QUTest::QS::onTestPost} ................................................*/
void QS_onTestPost(
    void const * sender,
    QActive * recipient,
    QEvt const * e,
    bool status);
 
/*${QUTest::QS::onTestLoop} ................................................*/
void QS_onTestLoop(void);
 
/*${QUTest::QHsmDummy} .....................................................*/
typedef struct {
/* protected: */
    QHsm super;
} QHsmDummy;
 
/* public: */
 
void QHsmDummy_ctor(QHsmDummy * const me);
 
void QHsmDummy_init_(
    QHsm * const me,
    void const * const par,
    uint_fast8_t const qs_id);
 
void QHsmDummy_dispatch_(
    QHsm * const me,
    QEvt const * const e,
    uint_fast8_t const qs_id);
 
/*${QUTest::QActiveDummy} ..................................................*/
typedef struct {
/* protected: */
    QActive super;
} QActiveDummy;
 
/* public: */
 
void QActiveDummy_ctor(QActiveDummy * const me);
 
void QActiveDummy_init_(
    QHsm * const me,
    void const * const par,
    uint_fast8_t const qs_id);
 
void QActiveDummy_dispatch_(
    QHsm * const me,
    QEvt const * const e,
    uint_fast8_t const qs_id);
 
void QActiveDummy_start_(
    QActive * const me,
    uint_fast8_t const prio,
    QEvt const * * const qSto,
    uint_fast16_t const qLen,
    void * const stkSto,
    uint_fast16_t const stkSize,
    void const * const par);
 
bool QActiveDummy_post_(
    QActive * const me,
    QEvt const * const e,
    uint_fast16_t const margin,
    void const * const sender);
 
void QActiveDummy_postLIFO_(
    QActive * const me,
    QEvt const * const e);
 
/*${QUTest::QUTEST_ON_POST} ................................................*/
#define QUTEST_ON_POST 124
/*$enddecl${QUTest} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
#define QS_TEST_PROBE_DEF(fun_) \
    uint32_t const qs_tp_ = QS_getTestProbe_((void (*)(void))(fun_));
 
#define QS_TEST_PROBE(code_) \
    if (qs_tp_ != 0U) { code_ }
 
#define QS_TEST_PROBE_ID(id_, code_) \
    if (qs_tp_ == (uint32_t)(id_)) { code_ }
 
#define QS_TEST_PAUSE()  (QS_test_pause_())
 
#else /* Q_UTEST not defined */
 
/* dummy definitions when not building for QUTEST */
#define QS_TEST_PROBE_DEF(fun_)
#define QS_TEST_PROBE(code_)
#define QS_TEST_PROBE_ID(id_, code_)
#define QS_TEST_PAUSE()  ((void)0)
 
#endif /* Q_UTEST */
 
#endif /* def QS_H */