kernel.h

浏览该文件的文档.

/*
 * Copyright (C) 2015-2021 Alibaba Group Holding Limited
 */

#ifndef AOS_KERNEL_H
#define AOS_KERNEL_H

#include <stdlib.h>
#include <stddef.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <aos/osal_debug.h>

#ifdef __cplusplus
extern "C" {
#endif

/* Define the AliOS-Things' Version */
#define SYSINFO_KERNEL_VERSION "AOS-R-3.3.0"
/* Defined for API with delay time */
#define AOS_WAIT_FOREVER 0xffffffffu
#define AOS_NO_WAIT 0x0
/* Define default aos task priority*/
#ifndef AOS_DEFAULT_APP_PRI
#define AOS_DEFAULT_APP_PRI 32
#endif

#define AOS_EVENT_AND 0x02u
#define AOS_EVENT_AND_CLEAR 0x03u
#define AOS_EVENT_OR 0x00u
#define AOS_EVENT_OR_CLEAR 0x01u
#define AOS_TASK_NONE 0x0u
#define AOS_TASK_AUTORUN 0x01u
#define AOS_TIMER_NONE 0x0u
#define AOS_TIMER_AUTORUN 0x01u
#define AOS_TIMER_REPEAT 0x02u
/* Define the handle for all aos module */
typedef void * aos_hdl_t;
/* Define the main handle for task module */
typedef aos_hdl_t aos_task_t;
/* Define the main handle for mutex module */
typedef aos_hdl_t aos_mutex_t;
/* Define the main handle for sem module */
typedef aos_hdl_t aos_sem_t;
/* Define the main handle for queue module */
typedef aos_hdl_t aos_event_t;
/* Define the main handle for event module */
typedef aos_hdl_t aos_queue_t;
/* Define the main handle for timer module */
typedef aos_hdl_t aos_timer_t;
/* Define the data type for task key index */
typedef uint32_t aos_task_key_t;
/* Define the data type for function return */
typedef int32_t aos_status_t;
/* Define the main handle for spinlock module */
typedef struct {
 volatile uint32_t owner; /* cpu index of owner */
} aos_spinlock_t;

/* Define the data type for spinlock irq save value */
typedef long aos_irqsave_t;
aos_status_t aos_task_create(aos_task_t *task, const char *name, void (*fn)(void *),
 void *arg,void *stack_buf, size_t stack_size, int32_t prio, uint32_t options);

aos_status_t aos_task_suspend(aos_task_t *task);

aos_status_t aos_task_resume(aos_task_t *task);

void aos_task_exit(int32_t code);

aos_status_t aos_task_delete(aos_task_t *task);

aos_status_t aos_task_yield(void);

aos_status_t aos_task_name_get(aos_task_t *task, char *buf, size_t buf_size);

aos_task_t aos_task_self(void);

aos_status_t aos_task_key_create(aos_task_key_t *key);

void aos_task_key_delete(aos_task_key_t key);

aos_status_t aos_task_setspecific(aos_task_key_t key, void *vp);

void *aos_task_getspecific(aos_task_key_t key);

aos_status_t aos_mutex_create(aos_mutex_t *mutex, uint32_t options);

void aos_mutex_free(aos_mutex_t *mutex);

aos_status_t aos_mutex_lock(aos_mutex_t *mutex, uint32_t timeout);

aos_status_t aos_mutex_unlock(aos_mutex_t *mutex);

aos_status_t aos_sem_create(aos_sem_t *sem, uint32_t count, uint32_t options);
void aos_sem_free(aos_sem_t *sem);

aos_status_t aos_sem_wait(aos_sem_t *sem, uint32_t timeout);

void aos_sem_signal(aos_sem_t *sem);

void aos_sem_signal_all(aos_sem_t *sem);

aos_status_t aos_event_create(aos_event_t *event, uint32_t value, uint32_t options);

void aos_event_free(aos_event_t *event);


aos_status_t aos_event_get(aos_event_t *event, uint32_t value, uint32_t opt, uint32_t *actl_value, uint32_t timeout);

aos_status_t aos_event_set(aos_event_t *event, uint32_t value, uint32_t opt);

aos_status_t aos_queue_create(aos_queue_t *queue, size_t size, size_t max_msg, uint32_t options);
void aos_queue_free(aos_queue_t *queue);

aos_status_t aos_queue_send(aos_queue_t *queue, void *msg, size_t size);

aos_status_t aos_queue_recv(aos_queue_t *queue, uint32_t ms, void *msg, size_t *size);

aos_status_t aos_queue_get_count(aos_queue_t *queue);

aos_status_t aos_timer_create(aos_timer_t *timer, void (*fn)(void *, void *), void *arg,
 uint32_t ms, uint32_t options);

void aos_timer_free(aos_timer_t *timer);

aos_status_t aos_timer_start(aos_timer_t *timer);

aos_status_t aos_timer_stop(aos_timer_t *timer);

aos_status_t aos_timer_change(aos_timer_t *timer, uint32_t ms);

aos_status_t aos_timer_change_once(aos_timer_t *timer, uint32_t ms);

void aos_spin_lock_init(aos_spinlock_t *spinlock);

void aos_spin_lock(aos_spinlock_t *spinlock);

void aos_spin_unlock(aos_spinlock_t *spinlock);

aos_irqsave_t aos_spin_lock_irqsave(aos_spinlock_t *spinlock);

void aos_spin_unlock_irqrestore(aos_spinlock_t *spinlock, aos_irqsave_t flag);

void *aos_realloc(void *mem, size_t size);

void *aos_malloc(size_t size);

void *aos_calloc(size_t nitems, size_t size);

void *aos_zalloc(size_t size);

void aos_alloc_trace(void *addr, uintptr_t allocator);

void aos_free(void *mem);

void aos_calendar_time_set(uint64_t now_ms);

uint64_t aos_calendar_time_get(void);

uint64_t aos_calendar_localtime_get(void);

uint64_t aos_now(void);

uint64_t aos_now_ms(void);

aos_status_t aos_now_time_str(char *buffer, size_t len);

void aos_msleep(uint32_t ms);

void aos_srand(uint32_t seed);

int32_t aos_rand(void);

void aos_reboot(void);

int32_t aos_get_hz(void);

aos_status_t aos_version_str_get(char *buf, size_t len);

void aos_init(void);

void aos_start(void);

/* The following APIs is marked deprecated and is not recommended */

aos_status_t aos_task_new(const char *name, void (*fn)(void *), void *arg, size_t stack_size);

aos_status_t aos_task_new_ext(aos_task_t *task, const char *name, void (*fn)(void *),
 void *arg, size_t stack_size, int32_t prio);

aos_status_t aos_mutex_new(aos_mutex_t *mutex);

bool aos_mutex_is_valid(aos_mutex_t *mutex);

aos_status_t aos_sem_new(aos_sem_t *sem, uint32_t count);

bool aos_sem_is_valid(aos_sem_t *sem);

aos_status_t aos_event_new(aos_event_t *event, uint32_t value);

bool aos_event_is_valid(aos_event_t *event);

aos_status_t aos_queue_new(aos_queue_t *queue, void *buf, size_t size, size_t max_msg);

bool aos_queue_is_valid(aos_queue_t *queue);

void *aos_queue_buf_ptr(aos_queue_t *queue);

aos_status_t aos_timer_new(aos_timer_t *timer, void (*fn)(void *, void *), void *arg,
 uint32_t ms, bool repeat);

aos_status_t aos_timer_new_ext(aos_timer_t *timer, void (*fn)(void *, void *), void *arg,
 uint32_t ms, bool repeat, bool autorun);

#ifdef __cplusplus
}
#endif

#endif /* AOS_KERNEL_H */