VSF Documented
Macros
vsf_fsm.h File Reference
#include "./kernel/vsf_kernel_cfg.h"
#include "utilities/vsf_utilities.h"

Go to the source code of this file.

Macros

#define VSF_KERNEL_CFG_EDA_SUPPORT_SIMPLE_FSM   DISABLED
 
#define vsf_this   (*vsf_pthis)
 
#define def_states(...)
 
#define def_params(...)   __VA_ARGS__
 
#define vsf_args(...)   ,__VA_ARGS__
 
#define vsf_fsm(__name)   vsf_task(__name)
 
#define __def_fsm(__fsm_type, ...)
 
#define def_fsm(__name, ...)    __def_fsm(__name, __VA_ARGS__)
 
#define def_simple_fsm(__name, ...)
 
#define end_def_simple_fsm(...)
 
#define __declare_fsm(__name)    declare_vsf_task(__name)
 
#define declare_vsf_fsm(__name)   __declare_fsm(__name)
 
#define __extern_fsm_initialiser(__name, ...)
 extern fsm initialisation function and provide function prototype as <__name>_fn, E.g extern_vsf_fsm_initialiser( demo_fsm ); we extern a function called: extern fsm_demo_fsm_t *demo_fsm_init( fsm_demo_fsm_t *fsm_ptr ); and a prototype definition: typedef fsm_demo_fsm_t *demo_fsm_init_fn( fsm_demo_fsm_t *fsm_ptr ); We can then use demo_fsm_init_fn to define function pointer
 
#define extern_vsf_fsm_initialiser(__name, ...)    __extern_fsm_initialiser(__name, __VA_ARGS__)
 
#define call_vsf_fsm(__name, __fsm)    vsf_task_call_task(__name, __fsm)
 
#define ____state(__state, ...)
 
#define vsf_state(__state, ...)   break; ____state(__state, __VA_ARGS__)
 
#define on_start(...)   {__VA_ARGS__;}
 
#define reset_vsf_fsm()   do { vsf_this.fsm_state = 0; } while(0);
 
#define vsf_fsm_cpl()   do {reset_vsf_fsm(); return fsm_rt_cpl;} while(0);
 
#define vsf_fsm_report(__ERROR)   do {reset_vsf_fsm(); return (fsm_rt_t)(__ERROR); } while(0);
 
#define vsf_fsm_wait_for_obj()   return fsm_rt_wait_for_obj;
 
#define vsf_fsm_on_going()   return fsm_rt_on_going;
 
#define update_state_to(__state)    { vsf_this.fsm_state = (__state); goto __state_entry_##__state;}
 fsm_continue is deprecated, should not be used anymore
 
#define transfer_to(__state)    { vsf_this.fsm_state = (__state); vsf_fsm_on_going() }
 
#define __fsm_initialiser(__name, ...)
 
#define vsf_fsm_initialiser(__name, ...)    __fsm_initialiser(__name, __VA_ARGS__)
 
#define abort_vsf_fsm_init()   return NULL;
 
#define vsf_fsm_init_body(...)
 
#define init_vsf_fsm(__name, __fsm, ...)    __name##_init(__fsm __VA_ARGS__)
 
#define init_simple_fsm(__name, __fsm, ...)    init_vsf_fsm(__fsm __VA_ARGS__)
 
#define start_vsf_fsm(__name, __fsm, __pri, ...)    init_vsf_task(__name, (__fsm), (__pri), __VA_ARGS__)
 
#define start_simple_fsm(__name, __fsm, __pri, ...)    start_vsf_fsm(__name, (__fsm), (__pri), __VA_ARGS__)
 
#define __implement_fsm_ex(__name, __type)
 
#define __body(...)
 
#define vsf_fsm_body(...)   __body(__VA_ARGS__)
 
#define vsf_fsm_begin()
 
#define vsf_fsm_end()
 
#define implement_fsm_ex(__name, __type)    __implement_fsm_ex(__name, __type)
 
#define __implement_fsm(__name)    implement_fsm_ex(__name, __name)
 
#define implement_vsf_fsm(__name, ...)   __implement_fsm(__name)
 
#define __privilege_state(__state, ...)
 
#define privilege_state(__state, ...)    __privilege_state(__state, __VA_ARGS__)
 
#define privilege_group(...)   { __VA_ARGS__;}
 
#define privilege_body(...)
 
#define __FSM_RT_TYPE__
 
#define __extern_fsm_implementation_ex(__name, __type)
 extern fsm task function and provide function prototype as <__name>_fn, E.g extern_vsf_fsm_implementation( demo_fsm ); we extern a function called: fsm_rt_t demo_fsm( fsm_demo_fsm_t *fsm_ptr ) and a prototype definition: typedef fsm_rt_t demo_fsm_fn (fsm_demo_fsm_t *fsm_ptr); We can then use demo_fsm_fn to define function pointer
 
#define declare_vsf_fsm_implementation_ex(__name, __type)    __extern_fsm_implementation_ex(__name, __type)
 
#define extern_vsf_fsm_implementation_ex(__name, __type)    __extern_fsm_implementation_ex(__name, __type)
 
#define extern_vsf_fsm_implementation(__name)    __extern_fsm_implementation_ex(__name, __name)
 
#define declare_vsf_fsm_implementation(__name)    __extern_fsm_implementation_ex(__name, __name)
 

Enumerations

finit vsf_state machine vsf_state
enum  fsm_rt_t {
  fsm_rt_err = -1 ,
  fsm_rt_cpl = 0 ,
  fsm_rt_on_going = 1 ,
  fsm_rt_wait_for_obj = 2 ,
  fsm_rt_asyn = 3
}
 

Macro Definition Documentation

◆ VSF_KERNEL_CFG_EDA_SUPPORT_SIMPLE_FSM

#define VSF_KERNEL_CFG_EDA_SUPPORT_SIMPLE_FSM   DISABLED

◆ vsf_this

#define vsf_this   (*vsf_pthis)

◆ def_states

#define def_states (   ...)
Value:
enum { \
START = 0, \
__VA_ARGS__ \
};

◆ def_params

#define def_params (   ...)    __VA_ARGS__

◆ vsf_args

#define vsf_args (   ...)    ,__VA_ARGS__

◆ vsf_fsm

#define vsf_fsm (   __name)    vsf_task(__name)

◆ __def_fsm

#define __def_fsm (   __fsm_type,
  ... 
)
Value:
def_vsf_task(__fsm_type, \
__VA_ARGS__);
def_vsf_task
#define def_vsf_task(__name,...)
Definition vsf_task.h:108

◆ def_fsm

#define def_fsm (   __name,
  ... 
)     __def_fsm(__name, __VA_ARGS__)

◆ def_simple_fsm

#define def_simple_fsm (   __name,
  ... 
)
Value:
__declare_fsm(__name); \
__def_fsm(__name, __VA_ARGS__)
__name
#define __name
Definition hci_transport_aic8800.c:552
__declare_fsm
#define __declare_fsm(__name)
Definition vsf_fsm.h:108

◆ end_def_simple_fsm

#define end_def_simple_fsm (   ...)

◆ __declare_fsm

#define __declare_fsm (   __name)     declare_vsf_task(__name)

◆ declare_vsf_fsm

#define declare_vsf_fsm (   __name)    __declare_fsm(__name)

◆ __extern_fsm_initialiser

#define __extern_fsm_initialiser (   __name,
  ... 
)
Value:
vsf_fsm(__name) *__name##_init(vsf_fsm(__name) *fsm_ptr __VA_ARGS__); \
typedef vsf_fsm(__name) *__name##_init_fn(vsf_fsm(__name) *fsm_ptr __VA_ARGS__);
_init
void _init()
Definition init.c:12
vsf_fsm
#define vsf_fsm(__name)
Definition vsf_fsm.h:81

extern fsm initialisation function and provide function prototype as <__name>_fn, E.g extern_vsf_fsm_initialiser( demo_fsm ); we extern a function called: extern fsm_demo_fsm_t *demo_fsm_init( fsm_demo_fsm_t *fsm_ptr ); and a prototype definition: typedef fsm_demo_fsm_t *demo_fsm_init_fn( fsm_demo_fsm_t *fsm_ptr ); We can then use demo_fsm_init_fn to define function pointer

◆ extern_vsf_fsm_initialiser

#define extern_vsf_fsm_initialiser (   __name,
  ... 
)     __extern_fsm_initialiser(__name, __VA_ARGS__)

◆ __extern_fsm_implementation_ex

#define __extern_fsm_implementation_ex (   __name,
  __type 
)
Value:
fsm_rt_t __name(fsm(__type) *vsf_pthis, vsf_evt_t evt); \
typedef fsm_rt_t __name##_fn( vsf_fsm(__type) *vsf_pthis, vsf_evt_t evt );
__type
#define __type
Definition hci_transport_aic8800.c:553
vsf_evt_t
int16_t vsf_evt_t
Definition vsf_eda.h:654
fsm_rt_t
fsm_rt_t
Definition vsf_fsm.h:315

extern fsm task function and provide function prototype as <__name>_fn, E.g extern_vsf_fsm_implementation( demo_fsm ); we extern a function called: fsm_rt_t demo_fsm( fsm_demo_fsm_t *fsm_ptr ) and a prototype definition: typedef fsm_rt_t demo_fsm_fn (fsm_demo_fsm_t *fsm_ptr); We can then use demo_fsm_fn to define function pointer

◆ declare_vsf_fsm_implementation_ex

#define declare_vsf_fsm_implementation_ex (   __name,
  __type 
)     __extern_fsm_implementation_ex(__name, __type)

◆ extern_vsf_fsm_implementation_ex

#define extern_vsf_fsm_implementation_ex (   __name,
  __type 
)     __extern_fsm_implementation_ex(__name, __type)

◆ extern_vsf_fsm_implementation

#define extern_vsf_fsm_implementation (   __name)     __extern_fsm_implementation_ex(__name, __name)

◆ declare_vsf_fsm_implementation

#define declare_vsf_fsm_implementation (   __name)     __extern_fsm_implementation_ex(__name, __name)

◆ call_vsf_fsm

#define call_vsf_fsm (   __name,
  __fsm 
)     vsf_task_call_task(__name, __fsm)

◆ ____state

#define ____state (   __state,
  ... 
)
Value:
case __state: \
__state_entry_##__state:{ \
__VA_ARGS__; \
};

◆ vsf_state

#define vsf_state (   __state,
  ... 
)    break; ____state(__state, __VA_ARGS__)

◆ on_start

#define on_start (   ...)    {__VA_ARGS__;}

◆ reset_vsf_fsm

#define reset_vsf_fsm ( )    do { vsf_this.fsm_state = 0; } while(0);

◆ vsf_fsm_cpl

#define vsf_fsm_cpl ( )    do {reset_vsf_fsm(); return fsm_rt_cpl;} while(0);

◆ vsf_fsm_report

#define vsf_fsm_report (   __ERROR)    do {reset_vsf_fsm(); return (fsm_rt_t)(__ERROR); } while(0);

◆ vsf_fsm_wait_for_obj

#define vsf_fsm_wait_for_obj ( )    return fsm_rt_wait_for_obj;

◆ vsf_fsm_on_going

#define vsf_fsm_on_going ( )    return fsm_rt_on_going;

◆ update_state_to

#define update_state_to (   __state)     { vsf_this.fsm_state = (__state); goto __state_entry_##__state;}

fsm_continue is deprecated, should not be used anymore

◆ transfer_to

#define transfer_to (   __state)     { vsf_this.fsm_state = (__state); vsf_fsm_on_going() }

◆ __fsm_initialiser

#define __fsm_initialiser (   __name,
  ... 
)
Value:
vsf_fsm(__name) *__name##_init(vsf_fsm(__name) *vsf_pthis __VA_ARGS__) \
{ \
VSF_KERNEL_ASSERT (NULL != vsf_pthis); \
vsf_this.fsm_state = 0;
NULL
#define NULL
Definition lvgl.h:26
vsf_this
#define vsf_this
Definition vsf_fsm.h:60

◆ vsf_fsm_initialiser

#define vsf_fsm_initialiser (   __name,
  ... 
)     __fsm_initialiser(__name, __VA_ARGS__)

◆ abort_vsf_fsm_init

#define abort_vsf_fsm_init ( )    return NULL;

◆ vsf_fsm_init_body

#define vsf_fsm_init_body (   ...)
Value:
__VA_ARGS__ \
return &vsf_this; \
}

◆ init_vsf_fsm

#define init_vsf_fsm (   __name,
  __fsm,
  ... 
)     __name##_init(__fsm __VA_ARGS__)

◆ init_simple_fsm

#define init_simple_fsm (   __name,
  __fsm,
  ... 
)     init_vsf_fsm(__fsm __VA_ARGS__)

◆ start_vsf_fsm

#define start_vsf_fsm (   __name,
  __fsm,
  __pri,
  ... 
)     init_vsf_task(__name, (__fsm), (__pri), __VA_ARGS__)

◆ start_simple_fsm

#define start_simple_fsm (   __name,
  __fsm,
  __pri,
  ... 
)     start_vsf_fsm(__name, (__fsm), (__pri), __VA_ARGS__)

◆ __implement_fsm_ex

#define __implement_fsm_ex (   __name,
  __type 
)
Value:
implement_vsf_task(__name) \
{ \
vsf_task_begin(); \
if (NULL == vsf_pthis) { \
return fsm_rt_err; \
}
fsm_rt_err
@ fsm_rt_err
fsm error, error code can be get from other interface
Definition vsf_fsm.h:316
implement_vsf_task
#define implement_vsf_task(__name)
Definition vsf_task.h:73

◆ __body

#define __body (   ...)
Value:
switch (vsf_this.fsm_state) { \
case 0: \
vsf_this.fsm_state++; \
__VA_ARGS__ \
break; \
default: \
return fsm_rt_err; \
} \
\
vsf_task_end(); \
}

◆ vsf_fsm_body

#define vsf_fsm_body (   ...)    __body(__VA_ARGS__)

◆ vsf_fsm_begin

#define vsf_fsm_begin ( )
Value:
switch (vsf_this.fsm_state) { \
case 0: \
vsf_this.fsm_state++;

◆ vsf_fsm_end

#define vsf_fsm_end ( )
Value:
break; \
default: \
return fsm_rt_err; \
} \
}vsf_task_end()
vsf_task_end
#define vsf_task_end()
Definition vsf_task.h:56

◆ implement_fsm_ex

#define implement_fsm_ex (   __name,
  __type 
)     __implement_fsm_ex(__name, __type)
Note
Debug Support: You can use body_begin() together with body_end() ! to enable debug, this means you are ale to set break ! points and single-step into those states. ! ! Example: 
  vsf_fsm_begin()
      vsf_state(xxxxx,
the range no debug is allowed )

vsf_state(xxxxx){ the range you can debug with }

vsf_fsm_end()

◆ __implement_fsm

#define __implement_fsm (   __name)     implement_fsm_ex(__name, __name)

◆ implement_vsf_fsm

#define implement_vsf_fsm (   __name,
  ... 
)    __implement_fsm(__name)

◆ __privilege_state

#define __privilege_state (   __state,
  ... 
)
Value:
break;do { \
do { \
____state(__state, __VA_ARGS__) \
} while(0); /* add extra while(0) to catch the fsm_continue()*/ \
if (vsf_this.fsm_state != (__state)) { \
break; \
} \
} while(1);

◆ privilege_state

#define privilege_state (   __state,
  ... 
)     __privilege_state(__state, __VA_ARGS__)

◆ privilege_group

#define privilege_group (   ...)    { __VA_ARGS__;}

◆ privilege_body

#define privilege_body (   ...)
Value:
do { \
switch (vsf_this.fsm_state) { \
case 0: \
vsf_this.fsm_state++; \
__VA_ARGS__ \
} \
while(1); \
\
return fsm_rt_on_going; \
}
fsm_rt_on_going
@ fsm_rt_on_going
fsm on-going
Definition vsf_fsm.h:318

◆ __FSM_RT_TYPE__

#define __FSM_RT_TYPE__

Enumeration Type Documentation

◆ fsm_rt_t

enum fsm_rt_t
Enumerator
fsm_rt_err 

fsm error, error code can be get from other interface

fsm_rt_cpl 

fsm complete

fsm_rt_on_going 

fsm on-going

fsm_rt_wait_for_obj 

fsm wait for object

fsm_rt_asyn 

fsm asynchronose complete, you can check it later.

Generated by doxygen 1.9.8