Aktionen

Aktionen sind wichtige Bestandteile einer Zustandsmaschine um damit das Verhalten und die Interaktion mit dem umgebenden System spezifizieren zu können.

Zustandsdiagramm

Modell

Beschreibung

In einer Zustandsmaschine können Aktionen (Actions) an verschiedenen Stellen ausgelöst werden. Möglich sind diese …

beim Betreten eines Zustands,
beim Verlassen eines Zustands,
beim Durchlaufen einer Transition.

Aktionen werden als Funktionen ohne Implementierung generiert, welche bei der Ausführung der Zustandsmaschine an den spezifizierten Stellen aufgerufen werden. Es ist vorgesehen, dass deren Implementierung nachträglich manuell hinzugefügt wird.

Bei Aktionen kann im Modell deren Sichtbarkeit durch die Eigenschaft Linkage festgelegt werden. Der Wert External führt zu „öffentlichen“ Funktionen mit Deklarationen in der *.h Datei. Der Wert Internal führt zu „privaten“ Funktionen mit Deklarationen in der *.c Datei.

Wie bereits im Beispiel der einfachsten Zustandsmaschine beschrieben, werden auch Aktionen als Bestandteil einer Unit generiert und erhalten daher auch deren Pseudo-Namespace, in diesem Fall DemoSm_.

Generierte Datei: demo_sm.h

#ifndef DEMO_SM_H
#define DEMO_SM_H



/*###########################################################################################################################################################*/
//      Type declarations
/*###########################################################################################################################################################*/


typedef enum DemoSm_StatesTag DemoSm_States;

enum DemoSm_StatesTag
{
    DemoSm_States_INVALID,
    DemoSm_States_IN_TRANSITION,
    DemoSm_States_ALPHA
};


typedef enum DemoSm_EventTag DemoSm_Event;

enum DemoSm_EventTag
{
    DemoSm_Event_INVALID,
    DemoSm_Event_TICK
};



/*###########################################################################################################################################################*/
//      Function declarations
/*###########################################################################################################################################################*/


/*===========================================================================================================================================================*/
extern void DemoSm_init(void);


/*===========================================================================================================================================================*/
extern void DemoSm_executeWithDemoSmEvent( const DemoSm_Event demoSmEvent );


/*===========================================================================================================================================================*/
extern void DemoSm_raiseFatalError(void);


/*===========================================================================================================================================================*/
extern void DemoSm_add(void);


/*===========================================================================================================================================================*/
extern void DemoSm_sub(void);


#endif // DEMO_SM_H

Generierte Datei: demo_sm.c

/*###########################################################################################################################################################*/
//      Includes
/*###########################################################################################################################################################*/
#include "demo_sm.h"
#include <stdbool.h>
#include <stddef.h>



/*###########################################################################################################################################################*/
//      Type declarations
/*###########################################################################################################################################################*/


typedef enum DemoSm_EvTypeTag DemoSm_EvType;

enum DemoSm_EvTypeTag
{
    DemoSm_EvType_DEMO_SM_EVENT
};


typedef struct DemoSm_EvObjTag DemoSm_EvObj;

struct DemoSm_EvObjTag
{
    DemoSm_EvType evType;
    DemoSm_Event  demoSmEvent;
};



/*###########################################################################################################################################################*/
//      Variables
/*###########################################################################################################################################################*/


static DemoSm_States DemoSm_currentState = DemoSm_States_INVALID;
static bool DemoSm_executionInProgress = false;



/*###########################################################################################################################################################*/
//      Internal function declarations
/*###########################################################################################################################################################*/


/*===========================================================================================================================================================*/
static void DemoSm_setState( const DemoSm_States newState );


/*===========================================================================================================================================================*/
static void DemoSm_execute( DemoSm_EvObj* const evObj );


/*===========================================================================================================================================================*/
static void DemoSm_executeStatemachine( DemoSm_EvObj* const evObj );


/*===========================================================================================================================================================*/
static void DemoSm_enterAlpha(void);


/*===========================================================================================================================================================*/
static void DemoSm_executeAlpha( DemoSm_EvObj* const evObj );


/*===========================================================================================================================================================*/
static void DemoSm_leaveAlpha(void);


/*===========================================================================================================================================================*/
static void DemoSm_div(void);



/*###########################################################################################################################################################*/
//      Internal function implementations
/*###########################################################################################################################################################*/


/*===========================================================================================================================================================*/
static void DemoSm_setState( const DemoSm_States newState )
/*===========================================================================================================================================================*/
{
    DemoSm_currentState = newState;
}



/*===========================================================================================================================================================*/
static void DemoSm_execute( DemoSm_EvObj* const evObj )
/*===========================================================================================================================================================*/
{
    if ( !DemoSm_executionInProgress )
    {
        DemoSm_executeStatemachine( evObj );
    }
    else
    {
        // recursion error
        
        DemoSm_raiseFatalError();
    }
}



/*===========================================================================================================================================================*/
static void DemoSm_executeStatemachine( DemoSm_EvObj* const evObj )
/*===========================================================================================================================================================*/
{
    DemoSm_executionInProgress = true;
    
    switch ( DemoSm_currentState )
    {
        case DemoSm_States_ALPHA:
            DemoSm_executeAlpha( evObj );
            break;
        
        
        default:
            DemoSm_raiseFatalError();
            break;
    }
    
    DemoSm_executionInProgress = false;
}



/*===========================================================================================================================================================*/
static void DemoSm_enterAlpha(void)
/*===========================================================================================================================================================*/
{
    DemoSm_setState( DemoSm_States_ALPHA );
    
    DemoSm_add();
}



/*===========================================================================================================================================================*/
static void DemoSm_executeAlpha( DemoSm_EvObj* const evObj )
/*===========================================================================================================================================================*/
{
    if ( evObj != NULL )
    {
        if ( evObj->evType == DemoSm_EvType_DEMO_SM_EVENT )
        {
            switch ( evObj->demoSmEvent )
            {
                case DemoSm_Event_TICK:
                    DemoSm_leaveAlpha();
                    
                    DemoSm_div();
                    
                    DemoSm_enterAlpha();
                    break;
                
                
                default:
                    break;
            }
        }
    }
    else
    {
        // no untriggered transitions available
    }
}



/*===========================================================================================================================================================*/
static void DemoSm_leaveAlpha(void)
/*===========================================================================================================================================================*/
{
    DemoSm_sub();
    
    DemoSm_setState( DemoSm_States_IN_TRANSITION );
}



/*===========================================================================================================================================================*/
static void DemoSm_div(void)
/*===========================================================================================================================================================*/
{
    // add your action implementation code here
}



/*###########################################################################################################################################################*/
//      External function implementations
/*###########################################################################################################################################################*/


/*===========================================================================================================================================================*/
extern void DemoSm_init(void)
/*===========================================================================================================================================================*/
{
    DemoSm_enterAlpha();
}



/*===========================================================================================================================================================*/
extern void DemoSm_executeWithDemoSmEvent( const DemoSm_Event demoSmEvent )
/*===========================================================================================================================================================*/
{
    DemoSm_EvObj evObj;


    evObj.evType = DemoSm_EvType_DEMO_SM_EVENT;
    evObj.demoSmEvent = demoSmEvent;
    
    DemoSm_execute( &evObj );
}



/*===========================================================================================================================================================*/
extern void DemoSm_raiseFatalError(void)
/*===========================================================================================================================================================*/
{
    // add your action implementation code here
}



/*===========================================================================================================================================================*/
extern void DemoSm_add(void)
/*===========================================================================================================================================================*/
{
    // add your action implementation code here
}



/*===========================================================================================================================================================*/
extern void DemoSm_sub(void)
/*===========================================================================================================================================================*/
{
    // add your action implementation code here
}