task.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_TASK_H_
#define INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_TASK_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
 
#include <infuse/task_runner/schedule.h>
#include <infuse/data_logger/high_level/tdf.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum {
        TASK_EXECUTOR_THREAD,
        TASK_EXECUTOR_WORKQUEUE,
};
 
enum {
        TASK_FLAG_ARG_IS_DEVICE = BIT(0),
};
 
typedef void (*task_runner_task_fn)(const struct task_schedule *schedule,
                                    struct k_poll_signal *terminate, void *arg);
 
struct task_config {
        const char *name;
        uint8_t task_id;
        uint8_t exec_type;
        uint8_t flags;
        /* Task specific argument */
        union {
                const struct device *dev;
                const void *const_arg;
                void *arg;
        } task_arg;
        union {
                struct {
                        struct k_thread *thread;
                        task_runner_task_fn task_fn;
                        k_thread_stack_t *stack;
                        size_t stack_size;
                } thread;
                struct {
                        k_work_handler_t worker_fn;
                        void *state;
                } workqueue;
        } executor;
};
 
struct task_data {
        union {
                struct {
                        /* Workqueue item */
                        struct k_work_delayable work;
                        /* Counter for the number of times the work has been rescheduled this run */
                        int reschedule_counter;
                        /* Compile-time argument */
                        union {
                                const void *const_arg;
                                void *arg;
                        } task_arg;
                } workqueue;
        } executor;
        struct k_poll_signal terminate_signal;
        uint8_t schedule_idx;
        bool running;
        bool skip;
};
 
#define ___TASK_VAR_DEFINE(macro, ...)    macro(1, 0, __VA_ARGS__)
#define __TASK_VAR_DEFINE(...)            ___TASK_VAR_DEFINE(__VA_ARGS__)
#define _TASK_VAR_DEFINE(task)            __TASK_VAR_DEFINE(__DEBRACKET task)
#define ___TASK_CONFIG_DEFINE(macro, ...) macro(0, 1, __VA_ARGS__)
#define __TASK_CONFIG_DEFINE(...)         ___TASK_CONFIG_DEFINE(__VA_ARGS__)
#define _TASK_CONFIG_DEFINE(task)         __TASK_CONFIG_DEFINE(__DEBRACKET task)
 
/* clang-format off */
 
#define TASK_RUNNER_TASKS_DEFINE(config_name, data_name, ...)                                      \
        /* Define task specific variables */                                                       \
        FOR_EACH_NONEMPTY_TERM(_TASK_VAR_DEFINE, (;), __VA_ARGS__);                                \
        /* Define the configurations for each task */                                              \
        static const struct task_config config_name[] = {                                          \
                FOR_EACH_NONEMPTY_TERM(_TASK_CONFIG_DEFINE, (,), __VA_ARGS__)                      \
        };                                                                                         \
        /* Define the runtime task data array */                                                   \
        static struct task_data data_name[ARRAY_SIZE(config_name)]
 
/* clang-format on */
 
static inline struct task_data *task_data_from_work(struct k_work *work)
{
        struct k_work_delayable *dwork = k_work_delayable_from_work(work);
 
        return CONTAINER_OF(dwork, struct task_data, executor.workqueue.work);
}
 
const struct task_schedule *task_schedule_from_data(struct task_data *data);
 
uint8_t *task_schedule_persistent_storage(struct task_data *data);
 
void task_workqueue_reschedule(struct task_data *task, k_timeout_t delay);
 
static inline int task_runner_task_block(struct k_poll_signal *terminate_signal,
                                         k_timeout_t timeout)
{
        struct k_poll_event events[1] = {
                K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY,
                                         terminate_signal),
        };
        int signaled;
        int result;
 
        /* Block until requested timeout */
        (void)k_poll(events, 1, timeout);
        /* Determine if we have been requested to terminate */
        k_poll_signal_check(terminate_signal, &signaled, &result);
        return signaled ? 1 : 0;
}
 
static inline bool task_schedule_tdf_requested(const struct task_schedule *schedule,
                                               uint8_t tdf_mask)
{
        return (schedule->task_logging[0].tdf_mask & tdf_mask) ||
               (schedule->task_logging[1].tdf_mask & tdf_mask);
}
 
static inline void task_schedule_tdf_log_core(const struct task_schedule *schedule,
                                              uint8_t tdf_mask, uint16_t tdf_id, uint8_t tdf_len,
                                              uint8_t tdf_num, enum tdf_data_format format,
                                              uint64_t time, uint32_t idx_period, const void *data)
{
        if (schedule->task_logging[0].tdf_mask & tdf_mask) {
                tdf_data_logger_log_core(schedule->task_logging[0].loggers, tdf_id, tdf_len,
                                         tdf_num, format, time, idx_period, data);
        }
        if (schedule->task_logging[1].tdf_mask & tdf_mask) {
                tdf_data_logger_log_core(schedule->task_logging[1].loggers, tdf_id, tdf_len,
                                         tdf_num, format, time, idx_period, data);
        }
}
 
static inline void task_schedule_tdf_log_array(const struct task_schedule *schedule,
                                               uint8_t tdf_mask, uint16_t tdf_id, uint8_t tdf_len,
                                               uint8_t tdf_num, uint64_t time, uint32_t period,
                                               const void *data)
{
        task_schedule_tdf_log_core(schedule, tdf_mask, tdf_id, tdf_len, tdf_num,
                                   TDF_DATA_FORMAT_TIME_ARRAY, time, period, data);
}
 
static inline void task_schedule_tdf_log(const struct task_schedule *schedule, uint8_t tdf_mask,
                                         uint16_t tdf_id, uint8_t tdf_len, uint64_t time,
                                         const void *data)
{
        task_schedule_tdf_log_core(schedule, tdf_mask, tdf_id, tdf_len, 1, TDF_DATA_FORMAT_SINGLE,
                                   time, 0, data);
}
 
#define TASK_SCHEDULE_TDF_LOG_ARRAY(schedule, tdf_mask, tdf_id, tdf_num, tdf_time, period, data)   \
        task_schedule_tdf_log_array(schedule, tdf_mask, tdf_id, sizeof(TDF_TYPE(tdf_id)), tdf_num, \
                                    tdf_time, period, data);                                       \
        do {                                                                                       \
                __maybe_unused const TDF_TYPE(tdf_id) *_data = data;                               \
        } while (0)
 
#define TASK_SCHEDULE_TDF_LOG(schedule, tdf_mask, tdf_id, tdf_time, data)                          \
        task_schedule_tdf_log(schedule, tdf_mask, tdf_id, sizeof(TDF_TYPE(tdf_id)), tdf_time,      \
                              data);                                                               \
        do {                                                                                       \
                __maybe_unused const TDF_TYPE(tdf_id) *_data = data;                               \
        } while (0)
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_TASK_H_ */