schedule.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_SCHEDULE_H_
#define INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_SCHEDULE_H_
 
#include <stdint.h>
#include <stdbool.h>
 
#include <zephyr/toolchain.h>
#include <zephyr/sys/atomic.h>
 
#include <infuse/task_runner/tasks/infuse_task_args.h>
 
#ifdef __cplusplus
extern "C" {
#endif


enum task_runner_valid_type {
        TASK_LOCKED = 0x80,
        TASK_VALID_NEVER = 0,
        TASK_VALID_ALWAYS = 1,
        TASK_VALID_ACTIVE = 2,
        TASK_VALID_INACTIVE = 3,
        TASK_VALID_PERMANENTLY_RUNS = 4,
        _TASK_VALID_END,
        _TASK_VALID_MASK = 0x7F,
};

enum task_runner_periodicity_type {
        TASK_PERIODICITY_FIXED = 1,
        TASK_PERIODICITY_LOCKOUT = 2,
        TASK_PERIODICITY_AFTER = 3,
        TASK_PERIODICITY_LOCKOUT_DYNAMIC_BATTERY = 4,
        _TASK_PERIODICITY_END,
};

#define TR_NOT 0x100
#define TR_OR  0x200
#define TR_AND 0x00

 
#define _TR_STATE_BASE                 0xFF
#define _TR_NOT_BIT_COMMON(state, idx) ((state) & TR_NOT ? BIT(idx) : 0)
#define _TR_OR_BIT_COMMON(state, idx)  ((state) & TR_OR ? BIT(idx) : 0)
#define _TR_STATES_DEFINE_ALL(s0, s1, s2, s3)                                                      \
        {                                                                                          \
                .metadata = _TR_NOT_BIT_COMMON(s0, 0) | _TR_NOT_BIT_COMMON(s1, 1) |                \
                            _TR_NOT_BIT_COMMON(s2, 2) | _TR_NOT_BIT_COMMON(s3, 3) |                \
                            _TR_OR_BIT_COMMON(s0, 4) | _TR_OR_BIT_COMMON(s1, 5) |                  \
                            _TR_OR_BIT_COMMON(s2, 6) | _TR_OR_BIT_COMMON(s3, 7),                   \
                .states = {                                                                        \
                        (s0) & _TR_STATE_BASE,                                                     \
                        (s1) & _TR_STATE_BASE,                                                     \
                        (s2) & _TR_STATE_BASE,                                                     \
                        (s3) & _TR_STATE_BASE,                                                     \
                }                                                                                  \
        }
 
#define _TR_GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define _TR_STATES_1(arg1)                       _TR_STATES_DEFINE_ALL(arg1, 0, 0, 0)
#define _TR_STATES_2(arg1, arg2)                 _TR_STATES_DEFINE_ALL(arg1, arg2, 0, 0)
#define _TR_STATES_3(arg1, arg2, arg3)           _TR_STATES_DEFINE_ALL(arg1, arg2, arg3, 0)
#define _TR_STATES_4(arg1, arg2, arg3, arg4)     _TR_STATES_DEFINE_ALL(arg1, arg2, arg3, arg4)


#define TASK_STATES_DEFINE(...)                                                                    \
        _TR_GET_MACRO(__VA_ARGS__, _TR_STATES_4, _TR_STATES_3, _TR_STATES_2, _TR_STATES_1)         \
        (__VA_ARGS__)

#define TASK_STATES_START_TIMEOUT(seconds) ((seconds) / 2)

struct task_schedule_tdf_logging {
        uint8_t loggers;
        uint8_t tdf_mask;
} __packed;

struct task_schedule_state_conditions {
        uint8_t metadata;
        uint8_t states[4];
} __packed;

#define TASK_RUNNER_LOCKOUT_IGNORE_FIRST BIT(31)

struct task_schedule {
        uint8_t task_id;
        uint8_t validity;
        uint8_t periodicity_type;
        uint8_t boot_lockout_minutes;
        uint32_t timeout_s;
        struct battery_start_thresholds {
                uint8_t lower;
                uint8_t upper;
        } __packed battery_start; 

        struct battery_terminate_thresholds {
                uint8_t lower;
                uint8_t upper;
        } __packed battery_terminate; 

        union periodicity_args {
                struct periodicity_periodic {
                        uint32_t period_s;
                } __packed fixed; 

                struct periodicity_lockout {
                        uint32_t lockout_s;
                } __packed lockout; 

                struct periodicity_after {
                        uint8_t schedule_idx;
                        uint16_t duration_s;
                } __packed after; 

                struct periodicity_lockout_dynamic_battery {
                        uint16_t lockout_min;
                        uint16_t lockout_max;
                        uint8_t battery_min;
                        uint8_t battery_max;
                } __packed lockout_dynamic_battery; 
        } periodicity; 

        uint16_t states_start_timeout_2x_s;
        struct task_schedule_state_conditions states_start;
        struct task_schedule_state_conditions states_terminate;
        struct task_schedule_tdf_logging task_logging[2];
        union task_arguments task_args;
} __packed;

BUILD_ASSERT(sizeof(union task_arguments) == 17);

enum task_schedule_event {
        TASK_SCHEDULE_STARTED = 0,
        TASK_SCHEDULE_TERMINATE_REQUEST = 1,
        TASK_SCHEDULE_STOPPED = 2,
};

typedef void (*task_schedule_event_cb_t)(const struct task_schedule *schedule,
                                         enum task_schedule_event event);

struct task_schedule_state {
        struct task_schedule_state *linked;
        task_schedule_event_cb_t event_cb;
        uint32_t last_run;
        uint32_t runtime;
        uint32_t last_terminate;
        uint8_t task_idx;
#ifdef CONFIG_TASK_RUNNER_PER_SCHEDULE_STORAGE
        uint8_t runtime_state[CONFIG_TASK_RUNNER_PER_SCHEDULE_STORAGE];
#endif /* CONFIG_TASK_RUNNER_PER_SCHEDULE_STORAGE */
};

#define _TASK_SCHEDULE_MAX_SCHEDULES(schedules)                                                    \
        COND_CODE_1(CONFIG_KV_STORE_KEY_TASK_SCHEDULES,                                            \
                    (CONFIG_KV_STORE_KEY_TASK_SCHEDULES_RANGE), (ARRAY_SIZE(schedules)))

#define TASK_SCHEDULE_STATES_DEFINE(name, schedules)                                               \
        static struct task_schedule_state name[_TASK_SCHEDULE_MAX_SCHEDULES(schedules)]

bool task_schedule_validate(const struct task_schedule *schedule);

bool task_schedule_should_start(const struct task_schedule *schedule,
                                struct task_schedule_state *state, atomic_t *app_states,
                                uint32_t uptime, uint32_t epoch_time, uint8_t battery);

bool task_schedule_should_terminate(const struct task_schedule *schedule,
                                    struct task_schedule_state *state, atomic_t *app_states,
                                    uint32_t uptime, uint32_t epoch_time, uint8_t battery);

 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_TASK_RUNNER_SCHEDULE_H_ */