VSF Documented
Macros | Typedefs | Functions
vsf_task.h File Reference
#include "./kernel/vsf_kernel_cfg.h"
#include "service/vsf_service.h"
#include "../vsf_eda.h"
#include "./vsf_pt.h"
#include "./vsf_fsm.h"

Go to the source code of this file.

Macros

#define __vsf_task_func(__name)   vsf_task_func_##__name
 
#define vsf_task_func(__name)   __vsf_task_func(__name)
 
#define __vsf_task(__name)   task_cb_##__name
 
#define vsf_task(__name)   __vsf_task(__name)
 
#define __implement_vsf_task(__name)
 
#define vsf_task_begin()
 
#define vsf_task_end()    } return fsm_rt_on_going;
 
#define vsf_task_state   (vsf_this.fsm_state)
 
#define implement_vsf_task(__name)   __implement_vsf_task(__name)
 
#define imp_vsf_task(__name)   implement_vsf_task(__name)
 
#define vsf_task_start   vsf_teda_start
 
#define __def_vsf_task(__name, ...)
 
#define def_vsf_task(__name, ...)   __def_vsf_task(__name,__VA_ARGS__)
 
#define define_vsf_task(__name, ...)   def_vsf_task(__name,__VA_ARGS__)
 
#define end_def_vsf_task(...)
 
#define end_define_vsf_task(...)
 
#define __declare_vsf_task(__name)
 
#define declare_vsf_task(__name)   __declare_vsf_task(__name)
 
#define dcl_vsf_task(__name)   declare_vsf_task(__name)
 
#define prepare_vsf_task(__name, __task)    do {(__task)->fsm_state = 0; } while(0)
 
#define prp_vsf_task(__name, __task)   prepare_vsf_task(__name, __task)
 
#define __init_vsf_task(__name, __task, __pri, ...)
 
#define init_vsf_task(__name, __task, __pri, ...)    __init_vsf_task(__name, (__task), (__pri), __VA_ARGS__)
 
#define vsf_task_call_task(__name, __target, ...)
 
#define vsf_task_call_sub(__name, __target, ...)
 
#define vsf_eda_call_task   vsf_task_call_task
 
#define vsf_task_call_pt(__name, __target)    vsf_task_call_sub(vsf_pt_func(__name), __target)
 
#define on_vsf_task_init()    if (VSF_EVT_INIT == evt)
 
#define on_vsf_task_fini()    if (VSF_EVT_FINI == evt)
 
#define on_vsf_task_evt(__evt)    if ((__evt) == evt)
 
#define vsf_task_wait_until(...)
 

Typedefs

typedef vsf_teda_t vsf_task_t
 
typedef fsm_rt_t(* vsf_task_entry_t) (uintptr_t target, vsf_evt_t evt)
 

Functions

fsm_rt_t __vsf_eda_call_task (vsf_task_entry_t entry, uintptr_t param, size_t local_size)
 

Macro Definition Documentation

◆ __vsf_task_func

#define __vsf_task_func (   __name)    vsf_task_func_##__name

◆ vsf_task_func

#define vsf_task_func (   __name)    __vsf_task_func(__name)

◆ __vsf_task

#define __vsf_task (   __name)    task_cb_##__name

◆ vsf_task

#define vsf_task (   __name)    __vsf_task(__name)

◆ __implement_vsf_task

#define __implement_vsf_task (   __name)
Value:
fsm_rt_t vsf_task_func(__name)( uintptr_t local, \
vsf_evt_t evt) \
{ \
vsf_task(__name) *vsf_pthis = \
*(vsf_task(__name) **) \
((uintptr_t)local - sizeof(uintptr_t));
__name
#define __name
Definition hci_transport_aic8800.c:552
uintptr_t
uint32_t uintptr_t
Definition stdint.h:38
vsf_evt_t
int16_t vsf_evt_t
Definition vsf_eda.h:654
fsm_rt_t
fsm_rt_t
Definition vsf_fsm.h:315
vsf_task_func
#define vsf_task_func(__name)
Definition vsf_task.h:40
vsf_task
#define vsf_task(__name)
Definition vsf_task.h:43

◆ vsf_task_begin

#define vsf_task_begin ( )

◆ vsf_task_end

#define vsf_task_end ( )     } return fsm_rt_on_going;

◆ vsf_task_state

#define vsf_task_state   (vsf_this.fsm_state)

◆ implement_vsf_task

#define implement_vsf_task (   __name)    __implement_vsf_task(__name)

◆ imp_vsf_task

#define imp_vsf_task (   __name)    implement_vsf_task(__name)

◆ vsf_task_start

#define vsf_task_start   vsf_teda_start

◆ __def_vsf_task

#define __def_vsf_task (   __name,
  ... 
)
Value:
struct task_cb_##__name { \
uint8_t fsm_state; \
__VA_ARGS__ \
}; \
struct __name { \
implement(vsf_task_t); \
implement_ex(task_cb_##__name, param); \
}; \
extern fsm_rt_t vsf_task_func_##__name( uintptr_t local, \
vsf_evt_t evt);
vsf_teda_t
Definition vsf_eda.h:834
uint8_t
unsigned char uint8_t
Definition lvgl.h:40

◆ def_vsf_task

#define def_vsf_task (   __name,
  ... 
)    __def_vsf_task(__name,__VA_ARGS__)

◆ define_vsf_task

#define define_vsf_task (   __name,
  ... 
)    def_vsf_task(__name,__VA_ARGS__)

◆ end_def_vsf_task

#define end_def_vsf_task (   ...)

◆ end_define_vsf_task

#define end_define_vsf_task (   ...)

◆ __declare_vsf_task

#define __declare_vsf_task (   __name)
Value:
typedef struct __name __name; \
typedef struct task_cb_##__name task_cb_##__name;

◆ declare_vsf_task

#define declare_vsf_task (   __name)    __declare_vsf_task(__name)

◆ dcl_vsf_task

#define dcl_vsf_task (   __name)    declare_vsf_task(__name)

◆ prepare_vsf_task

#define prepare_vsf_task (   __name,
  __task 
)     do {(__task)->fsm_state = 0; } while(0)

◆ prp_vsf_task

#define prp_vsf_task (   __name,
  __task 
)    prepare_vsf_task(__name, __task)

◆ __init_vsf_task

#define __init_vsf_task (   __name,
  __task,
  __pri,
  ... 
)
Value:
do { \
vsf_eda_cfg_t VSF_MACRO_SAFE_NAME(cfg) = { \
.fn.func = (uintptr_t)vsf_task_func(__name), \
.priority = (__pri), \
.target = (uintptr_t)&((__task)->param), \
.feature.is_subcall_has_return_value = true, \
__VA_ARGS__ \
}; \
prepare_vsf_task(__name, &((__task)->param)); \
vsf_task_start(&((__task)->use_as__vsf_task_t), \
&VSF_MACRO_SAFE_NAME(cfg)); \
} while(0)
vsf_eda_cfg_t
Definition vsf_eda.h:755
vsf_eda_cfg_t::fn
__vsf_eda_fn_t fn
Definition vsf_eda.h:756
__vsf_eda_fn_t::func
uintptr_t func
Definition vsf_eda.h:731
VSF_MACRO_SAFE_NAME
#define VSF_MACRO_SAFE_NAME(__NAME)
Definition vsf_preprocessor.h:32

◆ init_vsf_task

#define init_vsf_task (   __name,
  __task,
  __pri,
  ... 
)     __init_vsf_task(__name, (__task), (__pri), __VA_ARGS__)

◆ vsf_task_call_task

#define vsf_task_call_task (   __name,
  __target,
  ... 
)
Value:
__vsf_eda_call_task((vsf_task_entry_t)vsf_task_func(__name), \
(uintptr_t)(__target), (0, ##__VA_ARGS__))
vsf_task_entry_t
fsm_rt_t(* vsf_task_entry_t)(uintptr_t target, vsf_evt_t evt)
Definition vsf_task.h:241
__vsf_eda_call_task
fsm_rt_t __vsf_eda_call_task(vsf_task_entry_t entry, uintptr_t param, size_t local_size)
Definition vsf_task.c:49

◆ vsf_task_call_sub

#define vsf_task_call_sub (   __name,
  __target,
  ... 
)
Value:
if (VSF_ERR_NONE != __vsf_eda_call_eda( \
(vsf_task_entry_t)(__name), \
(__target), \
(0, ##__VA_ARGS))) { \
return fsm_rt_on_going; \
}
VSF_ERR_NONE
@ VSF_ERR_NONE
none error
Definition __type.h:44
__vsf_eda_call_eda
vsf_err_t __vsf_eda_call_eda(uintptr_t evthandler, uintptr_t param, size_t local_size)
Definition vsf_eda.c:727
fsm_rt_on_going
@ fsm_rt_on_going
fsm on-going
Definition vsf_fsm.h:318

◆ vsf_eda_call_task

#define vsf_eda_call_task   vsf_task_call_task

◆ vsf_task_call_pt

#define vsf_task_call_pt (   __name,
  __target 
)     vsf_task_call_sub(vsf_pt_func(__name), __target)

◆ on_vsf_task_init

#define on_vsf_task_init ( )     if (VSF_EVT_INIT == evt)

◆ on_vsf_task_fini

#define on_vsf_task_fini ( )     if (VSF_EVT_FINI == evt)

◆ on_vsf_task_evt

#define on_vsf_task_evt (   __evt)     if ((__evt) == evt)

◆ vsf_task_wait_until

#define vsf_task_wait_until (   ...)
Value:
__VA_ARGS__ {} else { \
return fsm_rt_wait_for_evt; \
}
fsm_rt_wait_for_evt
@ fsm_rt_wait_for_evt
Definition __type.h:80
Note
IMPORTANT For anything you want to wait, which is coming from vsf system, you can use vsf_task_wait_until() optionally. Those includues: VSF_EVT_XXXXX, semaphore, mutex and etc.

For VSF_EVT_XXXX, please use: vsf_task_wait_until( on_vsf_task_evt(VSF_EVT_XXXXX) ) ;

  For semaphore, please use:
  vsf_task_wait_until( vsf_sem_pend(...) ) ;


  For time, please use:
  vsf_task_wait_until( vsf_delay(...) ) ;

Typedef Documentation

◆ vsf_task_t

typedef vsf_teda_t vsf_task_t

◆ vsf_task_entry_t

typedef fsm_rt_t(* vsf_task_entry_t) (uintptr_t target, vsf_evt_t evt)

Function Documentation

◆ __vsf_eda_call_task()

fsm_rt_t __vsf_eda_call_task ( vsf_task_entry_t  entry,
uintptr_t  param,
size_t  local_size 
)
extern
Note
  • if VSF_ERR_NOT_ENOUGH_RESOURCES is detected, yield and try it again (automatically). For tasks sharing the same frame pool, if the pool is too small, only task performance will be affected, and all sub-task call will work when frame is allocated.
  • if the frame is allocated and pushed to the stack, we should yield to let the sub-task run.

Since in either way, we will yield, no need to handle the return value of vsf_eda_call().

Generated by doxygen 1.9.8