FsmFramework.h

Go to the documentation of this file.

 
#ifndef __STATEMACHINE_H_
#define __STATEMACHINE_H_
 
#include <stdint.h>
#include <stdbool.h>
 
 
#ifndef SW_USE_ONENTRY
#define SW_USE_ONENTRY                 1
#endif
 
#ifndef SW_USE_ONDO
#define SW_USE_ONDO                    0
#endif
 
#ifndef SW_USE_ONEXIT
#define SW_USE_ONEXIT                  1
#endif
 
#ifndef SW_USE_TRANSITIONFUNCTION
#define SW_USE_TRANSITIONFUNCTION      1
#endif
 
 
#define IS_IN(statemachine, state)  (statemachine.s32ActualState == state)
 
typedef struct stateTableEvents sStateTable_t;
typedef sStateTable_t* psStateTable_t;
 
typedef enum specialStates
{
    FAULT_STATE = -1,            // Used in sStateTransitions_t as nextStateId for not allowed events.
    FINAL_STATE = -2             // Used in sStateTransitions_t as nextStateId for the final state.
} eSpecialStates_t;
 
typedef enum specialEvents
{
    NO_EVENT = -1,              // Can be used, if there is no event, but the state machine should be called.
    TIME_EVENT = -2             // Should be used for timer events, especially elapsing timers.
} eSpecialEvents_t;
 
typedef void (*vCallback_t)(void);
 
typedef _Bool (*bCallbackGuard_t)(void);
 
typedef struct stateTransition
{
    int32_t s32EventId;         // Associated event id for this transition.
    bCallbackGuard_t bGuardCb;  // Guard function, returns either true or false
    vCallback_t vTransitionCb;  // Transition function callback.
    int32_t s32NextStateId;     // ID of next state.
} sStateTransitions_t;
typedef sStateTransitions_t* psStateTransitions_t;
 
typedef struct stateTableEvents
{
    int32_t s32StateId;                  // ID of this state.
    vCallback_t vOnEntry;                // onEntry function callback.
    vCallback_t vOnDo;                   // While in the state function callback.
    vCallback_t vOnExit;                 // onExit function callback.
    psStateTransitions_t psStateEvents;  // Event table for this state.
    psStateTable_t psNestedStateTable;   // If this state machine has a nested state machine
} sStateTableEvents_t;
typedef sStateTableEvents_t* psStateTableEvents_t;
 
typedef struct stateMachine
{
    uint32_t u32StateMachineId;      // ID of the state machine, set by init.
 
    int32_t s32ActualState;          // Holds the actual state.
    int32_t s32NextState;            // Holds the next state after a transition.
 
    uint32_t u32StateCount;          // Number of states in this state machine.
    uint32_t u32EventCount;          // Number of events in this state machine.
 
    _Bool bStateChanged;             // Holds if the fsm changed its state after last transition.
 
    psStateTable_t psStateTable;      // Table with all states and transitions.
} sStateMachine_t;
typedef sStateMachine_t* psStateMachine_t;
 
_Bool bFsmframeworkInitialize(psStateMachine_t psStateMachine, psStateTable_t psStateTable, \
                              int32_t s32StartState, uint32_t u32StateCount, \
                              uint32_t u32EventCount, vCallback_t vInitCallback);
 
_Bool bFsmframeworkDispatchEvent(psStateMachine_t psStateMachine, int32_t s32Event);
 
 
int32_t s32FsmframeworkGetState(psStateMachine_t psStateMachine);
 
 
_Bool bFsmframeworkIsStateChanged(psStateMachine_t psStateMachine);
 
 
#endif          // __STATEMACHINE_H_