luat_rtos.h

浏览该文件的文档.

/*
 * Copyright (c) 2022 OpenLuat & AirM2M
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#ifndef LUAT_RTOS_H
#define LUAT_RTOS_H
 
#include "luat_base.h"
#include "luat_rtos_legacy.h"
 
typedef enum LUAT_RTOS_WAIT
{
    LUAT_NO_WAIT = 0,                        
    LUAT_WAIT_FOREVER = (uint32_t)0xFFFFFFFF 
} LUAT_RTOS_WAIT_E;
 
typedef enum
{
    LUAT_FLAG_AND       = 5,
    LUAT_FLAG_AND_CLEAR     = 6,
    LUAT_FLAG_OR            = 7,
    LUAT_FLAG_OR_CLEAR  = 8
} LUAT_FLAG_OP_E;
 
/* ------------------------------------------------ task begin------------------------------------------------ */
typedef void (*luat_rtos_task_entry) (void*);
typedef void * luat_rtos_task_handle;
int luat_rtos_task_create(luat_rtos_task_handle *task_handle, uint32_t stack_size, uint8_t priority, const char *task_name, luat_rtos_task_entry task_fun, void* user_data, uint16_t event_cout);
 
int luat_rtos_task_delete(luat_rtos_task_handle task_handle);
 
int luat_rtos_task_suspend(luat_rtos_task_handle task_handle);
 
int luat_rtos_task_resume(luat_rtos_task_handle task_handle);
 
void luat_rtos_task_suspend_all(void);
 
void luat_rtos_task_resume_all(void);
 
void luat_rtos_task_sleep(uint32_t ms);
 
luat_rtos_task_handle luat_rtos_get_current_handle(void);
 
uint32_t luat_rtos_task_get_high_water_mark(luat_rtos_task_handle task_handle);
 
void luat_rtos_task_run_time_record_enable(void);
 
void luat_rtos_task_run_time_record_print(uint8_t print_ticks);
/* ------------------------------------------------ task   end------------------------------------------------ */
/* ----------------------------------------------- event begin---------------------------------------------- */
typedef LUAT_RT_RET_TYPE (*luat_rtos_event_wait_callback_t)(LUAT_RT_CB_PARAM);
 
int luat_rtos_event_send(luat_rtos_task_handle task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3, uint32_t timeout);
 
int luat_rtos_event_recv(luat_rtos_task_handle task_handle, uint32_t wait_event_id, luat_event_t *out_event, luat_rtos_event_wait_callback_t *callback_fun, uint32_t timeout);
 
/* ----------------------------------------------- event end---------------------------------------------- */
 
/* ----------------------------------------------- message begin---------------------------------------------- */
int luat_rtos_message_send(luat_rtos_task_handle task_handle, uint32_t message_id, void *p_message);
 
int luat_rtos_message_recv(luat_rtos_task_handle task_handle, uint32_t *message_id, void **p_p_message, uint32_t timeout);
/* ----------------------------------------------- message   end---------------------------------------------- */
 
/* ---------------------------------------------- semaphore begin--------------------------------------------- */
typedef void * luat_rtos_semaphore_t;
int luat_rtos_semaphore_create(luat_rtos_semaphore_t *semaphore_handle, uint32_t init_count);
 
int luat_rtos_semaphore_delete(luat_rtos_semaphore_t semaphore_handle);
 
int luat_rtos_semaphore_take(luat_rtos_semaphore_t semaphore_handle, uint32_t timeout);
 
int luat_rtos_semaphore_release(luat_rtos_semaphore_t semaphore_handle);
/* ---------------------------------------------- semaphore   end--------------------------------------------- */
/* ------------------------------------------------ mutex begin----------------------------------------------- */
typedef void * luat_rtos_mutex_t;
int luat_rtos_mutex_create(luat_rtos_mutex_t *mutex_handle);
 
int luat_rtos_mutex_lock(luat_rtos_mutex_t mutex_handle, uint32_t timeout);
 
int luat_rtos_mutex_unlock(luat_rtos_mutex_t mutex_handle);
 
int luat_rtos_mutex_delete(luat_rtos_mutex_t mutex_handle);
 
/* ------------------------------------------------ mutex   end----------------------------------------------- */
/* ------------------------------------------------ queue begin----------------------------------------------- */
 
typedef void * luat_rtos_queue_t;
int luat_rtos_queue_create(luat_rtos_queue_t *queue_handle, uint32_t item_count, uint32_t item_size);
 
int luat_rtos_queue_delete(luat_rtos_queue_t queue_handle);
 
int luat_rtos_queue_send(luat_rtos_queue_t queue_handle, void *item, uint32_t item_size, uint32_t timeout);
 
int luat_rtos_queue_recv(luat_rtos_queue_t queue_handle, void *item, uint32_t item_size, uint32_t timeout);
 
int luat_rtos_queue_get_cnt(luat_rtos_queue_t queue_handle, uint32_t *item_cnt);
/* ------------------------------------------------ queue   end----------------------------------------------- */
/* ------------------------------------------------ flag begin----------------------------------------------- */
 
typedef void * luat_rtos_flag_t;
int luat_rtos_flag_create(luat_rtos_flag_t  *flag_handle);
int luat_rtos_flag_wait(luat_rtos_flag_t flag_handle, uint32_t mask, LUAT_FLAG_OP_E operation, uint32_t *flags,uint32_t timeout);
int luat_rtos_flag_release(luat_rtos_flag_t flag_handle, uint32_t mask, LUAT_FLAG_OP_E operation);
int luat_rtos_flag_delete(luat_rtos_flag_t flag_handle);
/* ------------------------------------------------ flag  end----------------------------------------------- */
/* ------------------------------------------------ timer begin----------------------------------------------- */
typedef void * luat_rtos_timer_t;
typedef LUAT_RT_RET_TYPE (*luat_rtos_timer_callback_t)(LUAT_RT_CB_PARAM);
int luat_rtos_timer_create(luat_rtos_timer_t *timer_handle);
 
int luat_rtos_timer_delete(luat_rtos_timer_t timer_handle);
 
int luat_rtos_timer_start(luat_rtos_timer_t timer_handle, uint32_t timeout, uint8_t repeat, luat_rtos_timer_callback_t callback_fun, void *user_param);
 
int luat_rtos_timer_stop(luat_rtos_timer_t timer_handle);
 
int luat_rtos_timer_is_active(luat_rtos_timer_t timer_handle);
 
/*------------------------------------------------ timer   end----------------------------------------------- */
/* ------------------------------------------------ critical begin----------------------------------------------- */
uint32_t luat_rtos_entry_critical(void);
 
void luat_rtos_exit_critical(uint32_t critical);
 
uint32_t luat_rtos_get_ipsr(void);
/*------------------------------------------------ critical   end----------------------------------------------- */
#endif