qfsm.h

 
#ifndef Q_FSM_H
    #define Q_FSM_H
 
    #include "qtypes.h"
    #include "qqueues.h"
    #include "qstimers.h"
 
    #ifdef __cplusplus
    extern "C" {
    #endif
 
 
    #ifndef Q_FSM
        #define Q_FSM                           ( 1 )
    #endif
 
    #ifndef Q_FSM_MAX_NEST_DEPTH
        #define Q_FSM_MAX_NEST_DEPTH            ( 5 )
    #endif
 
    #ifndef Q_FSM_MAX_TIMEOUTS
        #define Q_FSM_MAX_TIMEOUTS              ( 3 )
    #endif
 
    #ifndef Q_FSM_PS_SIGNALS_MAX
        #define Q_FSM_PS_SIGNALS_MAX            ( 0 )
    #endif
 
    #ifndef Q_FSM_PS_SUB_PER_SIGNAL_MAX
        #define Q_FSM_PS_SUB_PER_SIGNAL_MAX     ( 0 )
    #endif
 
    #if ( Q_FSM_MAX_NEST_DEPTH < 1 )
        #error Q_FSM_MAX_NEST_DEPTH must be defined to be greater than or equal to 1.
    #endif
 
    #if ( ( Q_FSM_MAX_TIMEOUTS < 1 ) || ( Q_FSM_MAX_TIMEOUTS > 32 ) )
        #error Q_FSM_MAX_TIMEOUTS must be defined with a value between 1 to 32.
    #endif
 
    #define QSM_STATE_TOP           ( NULL )
 
    #define QSM_TSOPT_MASK          ( (qSM_TimeoutSpecOptions_t)0x00FFFFFFUL )
    /*FSM internal signals*/
    #define QSM_SIGNAL_START        ( (qSM_SigId_t)0xFFFFFFFFUL )
    #define QSM_SIGNAL_EXIT         ( (qSM_SigId_t)0xFFFFFFFEUL )
    #define QSM_SIGNAL_ENTRY        ( (qSM_SigId_t)0xFFFFFFFDUL )
    #define QSM_SIGNAL_NONE         ( (qSM_SigId_t)0xFFFFFFFCUL )
    #define QSM_SIGNAL_TIMEOUT(index)                                       \
    ( (qSM_SigId_t)0xFFFFFFFBUL - (qSM_SigId_t)( Q_FSM_MAX_TIMEOUTS - 1 )   \
    + (qSM_SigId_t)(index) )                                                \
 
    #define QSM_TSOPT_INDEX(index)                                          \
    ( ( QSM_TSOPT_MASK & (qSM_TimeoutSpecOptions_t)(index) ) )              \
 
    #define QSM_TSOPT_SET_ENTRY     ( (qSM_TimeoutSpecOptions_t)0x01000000UL )
    #define QSM_TSOPT_RST_ENTRY     ( (qSM_TimeoutSpecOptions_t)0x02000000UL )
    #define QSM_TSOPT_SET_EXIT      ( (qSM_TimeoutSpecOptions_t)0x04000000UL )
    #define QSM_TSOPT_RST_EXIT      ( (qSM_TimeoutSpecOptions_t)0x08000000UL )
    #define QSM_TSOPT_KEEP_IF_SET   ( (qSM_TimeoutSpecOptions_t)0x10000000UL )
    #define QSM_TSOPT_PERIODIC      ( (qSM_TimeoutSpecOptions_t)0x20000000UL )
 
    #define QSM_SIGNAL_RANGE_MIN    ( (qSM_SigId_t)0U )
    #define QSM_SIGNAL_RANGE_MAX                                            \
    ( (qSM_SigId_t)( 0xFFFFFFFBUL - (qSM_SigId_t)Q_FSM_MAX_TIMEOUTS ) )     \
 
    #define QSM_SIGNAL_TM_MAX       ( (qSM_SigId_t)0xFFFFFFFBUL )
    #define QSM_SIGNAL_TM_MIN       QSM_SIGNAL_TIMEOUT(0)
 
    #define QSM_SIGNAL_USER         ( QSM_SIGNAL_RANGE_MIN )
 
    typedef qUINT32_t qSM_SigId_t;
 
    typedef struct _qSM_Signal_s { // skipcq: CXX-E2000
        qSM_SigId_t id;                         
        void *sigData;                          
    } qSM_Signal_t;
 
    typedef enum {
        qSM_STATUS_BEFORE_ANY = -32767,         
        qSM_STATUS_NULL = -32766,               
        qSM_STATUS_EXIT_FAILURE = -32765,       
        qSM_STATUS_EXIT_SUCCESS = -32764,       
        qSM_STATUS_SIGNAL_HANDLED = -32763      
    }
    qSM_Status_t;
 
    typedef enum {
        qSM_TRANSITION_NO_HISTORY = 0,          
        qSM_TRANSITION_SHALLOW_HISTORY,         
        qSM_TRANSITION_DEEP_HISTORY,            
    }
    qSM_TransitionHistoryMode_t;
 
    /*fields for the qSM_Handler_t pointer*/
    /*cppcheck-suppress misra-c2012-20.7 */
    #define _qSM_HANDLER_FIELDS( pAttrib )           /* skipcq: CXX-E2000 */\
        void *StartState;                                                   \
        void *NextState;                                                    \
        pAttrib void *machine;                                              \
        pAttrib void *state;                                                \
        pAttrib void *Data;                                                 \
        pAttrib void *StateData;                                            \
        pAttrib void *SignalData;                                           \
        pAttrib qSM_SigId_t Signal;                                         \
        pAttrib qSM_Status_t Status;                                        \
        qSM_TransitionHistoryMode_t TransitionHistory                       \
 
    typedef struct _qSM_uPublicData_s { // skipcq: CXX-E2000
        _qSM_HANDLER_FIELDS( Q_NONE );
    }
    _qSM_UnprotectedPublicData_t; // skipcq: CXX-E2000
    typedef struct _qSM_pPublicData_s { // skipcq: CXX-E2000
        _qSM_HANDLER_FIELDS( const );
    }
    _qSM_ProtectedPublicData_t; // skipcq: CXX-E2000
    typedef _qSM_UnprotectedPublicData_t* qSM_UnprotectedHandler_t;
    typedef _qSM_ProtectedPublicData_t* qSM_Handler_t;
    #ifdef DOXYGEN
    typedef struct {
        void *StartState;                               
        void *NextState;                                
        const void *machine;                            
        const void *state;                              
        const void *Data;                               
        const void *StateData;                          
        const void *SignalData;                         
        const qSM_SigId_t Signal;                       
        const qSM_Status_t Status;                      
        qSM_TransitionHistoryMode_t TransitionHistory;  
    }
    qSM_Handler_t;
    #endif
 
    typedef qSM_Status_t (*qSM_StateCallback_t)( qSM_Handler_t h );
 
    typedef void (*qSM_SurroundingCallback_t)( qSM_Handler_t h );
 
    typedef qBool_t (*qSM_SignalAction_t)( qSM_Handler_t h );
 
    typedef qUINT32_t qSM_TimeoutSpecOptions_t;
 
 
    typedef struct _qSM_TimeoutStateDefinition_s { // skipcq: CXX-E2000
        qTime_t xTimeout;                                   
        qSM_TimeoutSpecOptions_t options;                   
    }
    qSM_TimeoutStateDefinition_t;
 
    typedef struct _qSM_State_s { // skipcq: CXX-E2000
        struct _qSM_State_Private_s { // skipcq: CXX-E2000
            struct _qSM_State_s *parent;                    /*< A pointer to the parent state*/
            struct _qSM_State_s *lastRunningChild;          /*< The last running child state*/
            struct _qSM_State_s *initState;                 /*< The initial state of this parent*/
            qSM_StateCallback_t sCallback;                  /*< The state callback function*/
            qSM_TimeoutStateDefinition_t *tdef;             /*< The timeout state definition*/
            void *tTable;                                   /*< A pointer to the transition table.*/
            void* sData;                                    /*< State data. Storage pointer*/
            size_t tEntries;                                /*< Number of entries on <tTable>*/
            size_t nTm;                                     /*< Number of entries on <tdef>*/
        }
        qPrivate;
    }
    qSM_State_t;
 
    typedef struct _qSM_TimeoutSpec_s { // skipcq: CXX-E2000
        qUINT32_t isPeriodic;                               /*< witch one is periodic*/
        qSTimer_t builtin_timeout[ Q_FSM_MAX_TIMEOUTS ];    /*< the built-in timeouts*/
    }
    qSM_TimeoutSpec_t;
 
    typedef struct _qSM_s { // skipcq: CXX-E2000
        struct _qSM_Private_s { // skipcq: CXX-E2000
            qSM_State_t *current;                           /*< A pointer to the current state.*/
            qSM_State_t *next;                              /*< The next state to execute. */
            qSM_State_t *source;                            /*< Source state during the last transition*/
            void *mData;                                    /*< The user storage-pointer*/
            #if ( Q_QUEUES == 1 )
                qQueue_t *sQueue;                           /*< A pointer to the signal queue.*/
            #endif
            qSM_TimeoutSpec_t *timeSpec;                    /*< A pointer to the timeout specification object*/
            qSM_SurroundingCallback_t surrounding;          /*< A callback to handle actions after and before any state. */
            qSM_State_t top;                                /*< The top most state*/
            _qSM_UnprotectedPublicData_t handler;           /*< The FSM handler argument*/
            qSM_Signal_t signalNot;                         /*< Signal exclusion variable*/
            void *owner;
        }
        qPrivate;
    }
    qSM_t;
 
    typedef struct _qSM_Transition_s { // skipcq: CXX-E2000
        qSM_SigId_t xSignal;                                
        qSM_SignalAction_t guard;                           
        qSM_State_t *nextState;                             
        qSM_TransitionHistoryMode_t historyMode;            
        void *signalData;                                   
    }
    qSM_Transition_t;
 
    typedef enum {
        qSM_ATTRIB_STATE_TOP,                               
        qSM_ATTRIB_STATE_CURRENT,                           
        qSM_ATTRIB_SIGNAL_QUEUE,                            
        qSM_ATTRIB_TIMESPEC,                                
        qSM_ATTRIB_TRANSITION_TABLE,                        
        qSM_ATTRIB_DATA,                                    
        qSM_ATTRIB_COMPOSITE_INITSTATE,                     
        qSM_ATTRIB_COMPOSITE_LASTSTATE,                     
        qSM_ATTRIB_COMPOSITE_PARENT,                        
    }
    qSM_Attribute_t;
 
    qBool_t qStateMachine_Run( qSM_t * const m,
                               qSM_Signal_t sig );
 
    qBool_t qStateMachine_Setup( qSM_t * const m,
                                 qSM_StateCallback_t topFcn,
                                 qSM_State_t * const init,
                                 qSM_SurroundingCallback_t sFcn,
                                 void *pData );
 
    qBool_t qStateMachine_StateSubscribe( qSM_t * const m,
                                          qSM_State_t * const s,
                                          qSM_State_t * const parent,
                                          qSM_StateCallback_t sFcn,
                                          qSM_State_t * const init,
                                          void *pData );
 
    qBool_t qStateMachine_Set_StateTransitions( qSM_State_t * const s,
                                                qSM_Transition_t * const table,
                                                const size_t n );
 
    qBool_t qStateMachine_InstallSignalQueue( qSM_t * const m,
                                              qQueue_t *q );
 
    qBool_t qStateMachine_SendSignal( qSM_t * const m,
                                      qSM_SigId_t sig,
                                      void *sData,
                                      const qBool_t isUrgent );
 
    qBool_t qStateMachine_InstallTimeoutSpec( qSM_t * const m,
                                              qSM_TimeoutSpec_t * const ts );
 
    qBool_t qStateMachine_Set_StateTimeouts( qSM_State_t * const s,
                                             qSM_TimeoutStateDefinition_t *tdef,
                                             const size_t n );
 
    qBool_t qStateMachine_TimeoutSet( qSM_t * const m,
                                      const qIndex_t xTimeout,
                                      const qTime_t t );
 
    qBool_t qStateMachine_TimeoutStop( qSM_t * const m,
                                       const qIndex_t xTimeout );
 
    void* qStateMachine_Get_Machine( qSM_t * const m,
                                     const qSM_Attribute_t a );
 
    void* qStateMachine_Get_State( const qSM_State_t * const s,
                                   const qSM_Attribute_t a );
 
    qBool_t qStateMachine_Set_StateCallback( qSM_State_t * const state,
                                             qSM_StateCallback_t sFcn );
 
    qBool_t qStateMachine_Set_MachineSurrounding( qSM_t * const m,
                                                  qSM_SurroundingCallback_t sFcn );
 
    qBool_t qStateMachine_SubscribeToSignal( qSM_t * const m,
                                             qSM_SigId_t s );
 
    qBool_t qStateMachine_UnsubscribeFromSignal( const qSM_t * const m,
                                                 qSM_SigId_t s );
 
    #ifdef __cplusplus
    }
    #endif
 
#endif