fsm.h

Go to the documentation of this file.

/* Copyright: (c) 2007 DCE Eurobot Dragon Team
 *            CTU FEE - Department of Control Engineering
 * Contacts: Tran Duy Khanh <trandk1@fel.cvut.cz>
 * License: GNU GPL v.2
 */

#ifndef __robofsm__
#define __robofsm__

#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/time.h>
#include <errno.h>
#include "fsm_common_events.h"

typedef int fsm_event;

#ifndef __FSM_ALIASES_DEFINED
#define EV_NOEVENT        __COMMON_EV_NOEVENT
#define EV_INIT           __COMMON_EV_INIT
#define EV_EXIT           __COMMON_EV_EXIT
#define EV_STATE_ENTERED  __COMMON_EV_STATE_ENTERED
#define EV_RETURN         __COMMON_EV_RETURN
#define EV_TIMEOUT        __COMMON_EV_TIMEOUT
#define EV_TIMER          __COMMON_EV_TIMER
#endif

struct robo_fsm {
        pthread_t threadid;     
        sem_t event_noticed;
        sem_t event_sent;
        fsm_event sent_event;   
        fsm_event event;        
        struct timespec now;    
        struct timespec timeout; 
        struct timespec timer;  
        int (*state)(struct robo_fsm *fsm);
        int (*last_state)(struct robo_fsm *fsm); 
        int (*fnc_stack[10])(struct robo_fsm *fsm);
        int (**fnc_sp)(struct robo_fsm *fsm);
        int debug_states;       
        char *debug_name;       
};      /* robo_fsm */

#ifdef __cplusplus
extern "C" {
#endif

void fsm_init(struct robo_fsm *fsm, char *debug_name);
int fsm_start(struct robo_fsm *fsm, pthread_attr_t *attr);
int fsm_destroy(struct robo_fsm *fsm);
void __fsm_timespec_add_ms(struct timespec *ts, struct timespec *now, long ms);
void __fsm_timespec_invalidate(struct timespec *ts);



/* FSM (Finite State Machine) */
/* do nothing */
int fsm_nop_state(struct robo_fsm *fsm);

const char *fsm_event_str(fsm_event ev);
const char *fsm_common_event_str(enum fsm_common_events ev);

#define RC_WAIT         0

#define RC_PROC         1


static inline void __fsm_signal(struct robo_fsm *fsm, fsm_event event)
{
        /* Wait for receiver to notice the previous event */
        sem_wait(&fsm->event_noticed);
        /* Send our event */
        fsm->sent_event = event;
        sem_post(&fsm->event_sent);
}

#define FSM_SIGNAL(fsm_id, event) __fsm_signal(FSM_GET_BY_ID(fsm_id), __##fsm_id##_##event)

#define DBG_STATE()     DBG_FSM_STATE(__FUNCTION__)
#define DBG_FSM_STATE(name)     do { if (fsm->debug_states) DBG("fsm %s: %s(%s)\n", fsm->debug_name, name, fsm_event_str(fsm->event)); } while(0)

#define DBG_PRINT_EVENT(msg)    DBG("%s: event: %s\n", msg, fsm_event_str(fsm->event))

#ifdef __cplusplus
}
#endif

/**********************/
/* High level FSM API */
/**********************/

#define FSM_STATE(name)                                                 \
        static inline void fsm_state_##name##_impl(struct robo_fsm *fsm, int *__ret); \
        int fsm_state_##name(struct robo_fsm *fsm) {                    \
                int ret=RC_WAIT;                                        \
                DBG_FSM_STATE(#name);                                   \
                fsm_state_##name##_impl(fsm, &ret);                     \
                return ret;                                             \
        }                                                               \
        static inline void fsm_state_##name##_impl(struct robo_fsm *fsm, int *__ret)

#define FSM_STATE_DECL(name) \
int fsm_state_##name(struct robo_fsm *fsm)

#define FSM_TIMEOUT(ms) __fsm_timespec_add_ms(&fsm->timeout, &fsm->now, (ms))

#define FSM_TIMER(ms) __fsm_timespec_add_ms(&fsm->timer, &fsm->now, (ms))

#define FSM_TIMER_STOP() __fsm_timespec_invalidate(&fsm->timer)

#ifndef __FSM_EVENT_ENUM
/* This macro is normally declared in automatically generated event
 * header file. If fsm.h is included from other files, we fall back to
 * fsm_common_events. If you get warning: "__FSM_EVENT_ENUM"
 * redefined, it means that FSM_xxx definition of event is included
 * after fsm.h, which is not correct. */
#define __FSM_EVENT_ENUM enum fsm_common_events
#endif

#define FSM_EVENT ((__FSM_EVENT_ENUM)(fsm->event))

#define FSM_TRANSITION(next)                                            \
        do {                                                            \
                FSM_TIMER_STOP();                                       \
                fsm->last_state = fsm->state;                           \
                fsm->state = &fsm_state_##next;                         \
                fsm->event = EV_STATE_ENTERED;                          \
                *__ret=RC_PROC;                                         \
        } while(0)

#define SUBFSM_TRANSITION(substate)                                     \
        do {                                                            \
                FSM_TIMER_STOP();                                       \
                *(fsm->fnc_sp++) = fsm->state;                          \
                fsm->last_state = fsm->state;                           \
                fsm->state = &fsm_state_##substate;                     \
                fsm->event = EV_STATE_ENTERED;                          \
                *__ret = RC_PROC;                                       \
                return;                                                 \
 } while(0)

#define SUBFSM_RET()                                                    \
        do {                                                            \
                fsm->last_state = fsm->state;                           \
                fsm->state = *(--fsm->fnc_sp);                          \
                fsm->event = EV_RETURN;                                 \
                *__ret = RC_PROC;                                       \
        } while(0)

#endif  /* __robofsm__ */

---