rtthread.h.svn-base

RT-Thread是发展中的下一代微内核嵌入式实时操作系统

/*
 * File      : rtthread.h
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://openlab.rt-thread.com/license/LICENSE.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-03-18     Bernard      the first version
 * 2006-04-26     Bernard      add semaphore APIs
 * 2006-08-10     Bernard      add version information
 * 2007-01-28     Bernard      rename RT_OBJECT_Class_Static to RT_Object_Class_Static
 * 2007-03-03     Bernard      clean up the definitions to rtdef.h
 */

#ifndef __RT_THREAD_H__
#define __RT_THREAD_H__

#include <rtdef.h>

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @addtogroup KernelObject
 */
/*@{*/
/*
 * kernel object interface
 */

void rt_system_object_init(void);
void rt_object_init(struct rt_object* object, enum rt_object_class_type type, const char* name);
void rt_object_detach(rt_object_t object);
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char* name);
void rt_object_delete(rt_object_t object);
rt_object_t rt_object_find(enum rt_object_class_type type, const char* name);
rt_err_t rt_object_is_systemobject(rt_object_t object);
/*@}*/

/**
 * @addtogroup Clock
 */
/*@{*/
/*
 * clock & timer interface
 */
void rt_system_tick_init(void);
rt_tick_t rt_tick_get(void);
void rt_tick_increase(void);
rt_tick_t rt_tick_from_millisecond(rt_uint32 ms);

void rt_system_timer_init(void);
void rt_timer_init(rt_timer_t timer, 
	const char* name, 
	void (*timeout)(void* parameter), void* parameter, 
	rt_tick_t time, rt_uint8 flag);
rt_err_t rt_timer_detach(rt_timer_t timer);
rt_timer_t rt_timer_create(const char* name, 
	void (*timeout)(void* parameter), void* parameter, 
	rt_tick_t time, rt_uint8 flag);
rt_err_t rt_timer_delete(rt_timer_t timer);
rt_err_t rt_timer_start(rt_timer_t timer);
rt_err_t rt_timer_stop(rt_timer_t timer);
rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8 cmd, void* arg);
/*@}*/

/**
 * @addtogroup Thread
 */
/*@{*/
/*
 * thread interface
 */
rt_err_t rt_thread_init(struct rt_thread* thread,
	const char* name,
	void (*entry)(void* parameter), void* parameter,
	void* stack_start, rt_uint32 stack_size,
	rt_uint8 priority, rt_uint32 tick);
rt_err_t rt_thread_detach(rt_thread_t thread);
rt_thread_t rt_thread_create (const char* name, 
	void (*entry)(void* parameter), void* parameter, 
	rt_uint32 stack_size, 
	rt_uint8 priority, rt_uint32 tick);
rt_thread_t rt_thread_self(void);
rt_err_t rt_thread_startup(rt_thread_t thread);
rt_err_t rt_thread_delete(rt_thread_t thread);

rt_err_t rt_thread_yield(void);
rt_err_t rt_thread_delay(rt_tick_t tick);
rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8 cmd, void* arg);
rt_err_t rt_thread_suspend(rt_thread_t thread);
rt_err_t rt_thread_resume(rt_thread_t thread);
void rt_thread_timeout(void* parameter);

#ifdef RT_USING_HOOK
void rt_thread_suspend_hook(void (*hook)(rt_thread_t thread));
void rt_thread_resume_hook (void (*hook)(rt_thread_t thread));
#endif

/*
 * idle thread interface
 */
void rt_thread_idle_init(void);
#ifdef RT_USING_HOOK
void rt_thread_idle_sethook(void (*hook)());
#endif

/*
 * schedule service
 */
void rt_system_scheduler_init(void);
void rt_system_scheduler_start(void);

void rt_schedule(void);
void rt_schedule_insert_thread(struct rt_thread* thread);
void rt_schedule_remove_thread(struct rt_thread* thread);

void rt_enter_critical(void);
void rt_exit_critical(void);

#ifdef RT_USING_HOOK
void rt_schedule_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
#endif
/*@}*/

/**
 * @addtogroup MM
 */
/*@{*/
/*
 * memory management interface
 */
#ifdef RT_USING_MEMPOOL
/*
 * memory pool interface
 */
rt_err_t rt_mp_init(struct rt_mempool* mp, const char* name, void *start, rt_size_t size, rt_size_t block_size);
rt_err_t rt_mp_detach(struct rt_mempool* mp);
rt_mp_t rt_mp_create(const char* name, rt_size_t block_count, rt_size_t block_size);
rt_err_t rt_mp_delete(rt_mp_t mp);

void *rt_mp_alloc (rt_mp_t mp, rt_int32 time);
void rt_mp_free  (void *block);

#ifdef RT_USING_HOOK
void rt_mp_alloc_sethook(void (*hook)(void *block));
void rt_mp_free_sethook(void (*hook)(void *block));
#endif
#endif

#ifdef RT_USING_HEAP
/*
 * heap memory interface
 */
void rt_system_page_init(void* begin_addr, void* end_addr);

void* rt_malloc(rt_size_t nbytes);
void rt_free (void *ptr);

#ifdef RT_USING_HOOK
void rt_malloc_sethook(void (*hook)(void *ptr, rt_uint32 size));
void rt_free_sethook(void (*hook)(void *ptr));
#endif
#endif
/*@}*/

/**
 * @addtogroup IPC
 */
/*@{*/
#ifdef RT_USING_SEMAPHORE
/*
 * semaphore interface 
 */
rt_err_t rt_sem_init (rt_sem_t sem, const char* name, rt_uint32 value, rt_uint8 flag);
rt_err_t rt_sem_detach (rt_sem_t sem);
rt_sem_t rt_sem_create (const char* name, rt_uint32 value, rt_uint8 flag);
rt_err_t rt_sem_delete (rt_sem_t sem);

rt_err_t rt_sem_take (rt_sem_t sem, rt_int32 time);
rt_err_t rt_sem_trytake(rt_sem_t sem);
rt_err_t rt_sem_release(rt_sem_t sem);
rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8 cmd, void* arg);
#endif

#ifdef RT_USING_MUTEX
/*
 * mutex interface
 */
rt_err_t rt_mutex_init (rt_mutex_t mutex, const char* name, rt_uint8 flag);
rt_err_t rt_mutex_detach (rt_mutex_t mutex);
rt_mutex_t rt_mutex_create (const char* name, rt_uint8 flag);
rt_err_t rt_mutex_delete (rt_mutex_t mutex);

rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32 time);
rt_err_t rt_mutex_release(rt_mutex_t mutex);
rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8 cmd, void* arg);
#endif

#ifdef RT_USING_FASTEVENT
/*
 * fast_event interface
 */
rt_err_t rt_fast_event_init(rt_fast_event_t event, const char* name, rt_uint8 flag);
rt_err_t rt_fast_event_detach(rt_fast_event_t event);
rt_fast_event_t rt_fast_event_create (const char* name, rt_uint8 flag);
rt_err_t rt_fast_event_delete (rt_fast_event_t event);

rt_err_t rt_fast_event_send(rt_fast_event_t event, rt_uint8 bit);
rt_err_t rt_fast_event_recv(rt_fast_event_t event, rt_uint8 bit, rt_uint8 opt, rt_int32 timeout);
rt_err_t rt_fast_event_control (rt_fast_event_t event, rt_uint8 cmd, void* arg);
#endif

#ifdef RT_USING_EVENT
/*
 * event interface
 */
rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8 flag);
rt_err_t rt_event_detach(rt_event_t event);
rt_event_t rt_event_create (const char* name, rt_uint8 flag);
rt_err_t rt_event_delete (rt_event_t event);

rt_err_t rt_event_send(rt_event_t event, rt_uint32 set);
rt_err_t rt_event_recv(rt_event_t event, rt_uint32 set, rt_uint8 opt, rt_int32 timeout, rt_uint32* recved);
rt_err_t rt_event_control (rt_event_t event, rt_uint8 cmd, void* arg);

#endif

#ifdef RT_USING_MAILBOX
/*
 * mailbox interface
 *
 */
rt_err_t rt_mb_init(rt_mailbox_t mb, const char* name, void* msgpool, rt_size_t size, rt_uint8 flag);
rt_err_t rt_mb_detach(rt_mailbox_t mb);
rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8 flag);
rt_err_t rt_mb_delete (rt_mailbox_t mb);

rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32 value);
rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32* value, rt_int32 timeout);
rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8 cmd, void* arg);
#endif

#ifdef RT_USING_MESSAGEQUEUE
/*
 * message queue interface 
 */
rt_err_t rt_mq_init(rt_mq_t mq, const char* name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8 flag);
rt_err_t rt_mq_detach(rt_mq_t mq);
rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8 flag);
rt_err_t rt_mq_delete (rt_mq_t mq);

rt_err_t rt_mq_send (rt_mq_t mq, void* buffer, rt_size_t size);
rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size);
rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32 timeout);
rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8 cmd, void* arg);
#endif
/*@}*/

#ifdef RT_USING_DEVICE
/**
 * @addtogroup Device
 */
/*@{*/
/*
 * device (I/O) system interface 
 */

rt_err_t rt_device_system_init();

rt_device_t rt_device_find(const char* name);

rt_err_t rt_device_register(rt_device_t dev, const char* name, rt_uint8 flags);
rt_err_t rt_device_unregister(rt_device_t dev);
rt_err_t rt_device_init_all();

rt_err_t rt_device_open(rt_device_t dev);
rt_err_t rt_device_close(rt_device_t dev);
rt_err_t rt_device_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
rt_err_t rt_device_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
rt_err_t rt_device_control(rt_device_t dev, rt_uint8 cmd, void* arg);
/*@}*/
#endif

#ifdef RT_USING_VM
/**
 * @addtogroup VM
 */
/*@{*/

void rt_pagetable_system_init();

void rt_mapping_add();
void rt_mapping_remove();
/*@}*/
#endif

/*
 * interrupt service
 */
typedef void (*rt_isr_handler_t)(int vector);

/*
 * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP
 */
void rt_interrupt_enter(void);
void rt_interrupt_leave(void);

/**
 * @addtogroup KernelService
 */
/*@{*/
/*
 * general kernel service
 */
void rt_snprintf(char *buf, rt_size_t size, const char *fmt, ...);
void rt_kprintf(const char *fmt, ...);

void* rt_memset(void *src, int c, rt_uint16 n);
void* rt_memcpy(void *dest, const void *src, rt_uint16 n);

rt_uint16 rt_strncmp(const char * cs, const char * ct, rt_uint16 count);
rt_uint16 rt_strlen (const char *src);
void rt_show_version(void);
/*@}*/

#ifdef __cplusplus
}
#endif
/*@}*/
#endif