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)
#define	vsf_task_func(__name)
#define	__vsf_task(__name)
#define	vsf_task(__name)
#define	__implement_vsf_task(__name)
#define	vsf_task_begin()
#define	vsf_task_end()
#define	vsf_task_state   (vsf_this.fsm_state)
#define	implement_vsf_task(__name)
#define	imp_vsf_task(__name)
#define	vsf_task_start   vsf_teda_start
#define	__def_vsf_task(__name, ...)
#define	def_vsf_task(__name, ...)
#define	define_vsf_task(__name, ...)
#define	end_def_vsf_task(...)
#define	end_define_vsf_task(...)
#define	__declare_vsf_task(__name)
#define	declare_vsf_task(__name)
#define	dcl_vsf_task(__name)
#define	prepare_vsf_task(__name, __task)
#define	prp_vsf_task(__name, __task)
#define	__init_vsf_task(__name, __task, __pri, ...)
#define	init_vsf_task(__name, __task, __pri, ...)
#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)
#define	on_vsf_task_init()
#define	on_vsf_task_fini()
#define	on_vsf_task_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

)

Value:

vsf_task_func_##__name

vsf_task_func

#define vsf_task_func

(

__name

)

Value:

__vsf_task_func(__name)

__vsf_task

#define __vsf_task

(

__name

)

Value:

task_cb_##__name

vsf_task

#define vsf_task

(

__name

)

Value:

__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));

vsf_task_begin

#define vsf_task_begin

(

)

vsf_task_end

#define vsf_task_end

(

)

Value:

            } return fsm_rt_on_going;

vsf_task_state

#define vsf_task_state   (vsf_this.fsm_state)

implement_vsf_task

#define implement_vsf_task

(

__name

)

Value:

__implement_vsf_task(__name)

imp_vsf_task

#define imp_vsf_task

(

__name

)

Value:

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);

def_vsf_task

#define def_vsf_task	(		__name,
			... )

Value:

__def_vsf_task(__name,__VA_ARGS__)

define_vsf_task

#define define_vsf_task	(		__name,
			... )

Value:

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

)

Value:

__declare_vsf_task(__name)

dcl_vsf_task

#define dcl_vsf_task

(

__name

)

Value:

declare_vsf_task(__name)

prepare_vsf_task

#define prepare_vsf_task	(		__name,
			__task )

Value:

            do {(__task)->fsm_state = 0; } while(0)

prp_vsf_task

#define prp_vsf_task	(		__name,
			__task )

Value:

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)

init_vsf_task

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

Value:

            __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_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_eda_call_task

#define vsf_eda_call_task   vsf_task_call_task

vsf_task_call_pt

#define vsf_task_call_pt	(		__name,
			__target )

Value:

            vsf_task_call_sub(vsf_pt_func(__name), __target)

on_vsf_task_init

#define on_vsf_task_init

(

)

Value:

        if (VSF_EVT_INIT == evt)

on_vsf_task_fini

#define on_vsf_task_fini

(

)

Value:

        if (VSF_EVT_FINI == evt)

on_vsf_task_evt

#define on_vsf_task_evt

(

__evt

)

Value:

        if ((__evt) == evt)

vsf_task_wait_until

#define vsf_task_wait_until

(

...

)

Value:

            __VA_ARGS__ {} else {                                               \
                return fsm_rt_wait_for_evt;                                     \
            }

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().