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://www.fayfayspace.org/license/LICENSE.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-03-18     Bernard      the first version
 * 2006-04-26     Bernard      add semaphore APIs
 */

#ifndef __RT_THREAD_H__
#define __RT_THREAD_H__

/**
 * @file rtthread.h
 * @brief RT-Thread APIs definitions
 */

#include <rtconfig.h>

#ifdef __cplusplus
extern "C" {
#endif

/*!
 * @addtogroup xgKernel
 */

/* RT-Thread definitions */
typedef rt_int16  rt_err_t;
typedef rt_uint32 rt_time_t;
typedef rt_uint32 rt_tick_t;

typedef rt_base_t  rt_flag_t;
typedef rt_ubase_t rt_size_t;

/* RT-Thread error code definitions */
#define RT_EOK				0
#define RT_ERROR			1
#define RT_ETIMEOUT			2
#define RT_EFULL			3
#define RT_EEMPTY			4

#ifdef RT_DEBUG
#define RT_ASSERT(EX)		if (!(EX)) { rt_kprintf("(%s) assert failed at %s:%d \n", #EX, __FILE__, __LINE__); while (1);}
#else
#define RT_ASSERT(EX)
#endif

#define RT_ALIGN_SIZE			4
#define RT_ALIGN(size, align)	(((size) + (align) - 1) & ~((align)-1))
#define RT_NULL 				((void *)0)

/*
 * list
 */
struct rt_list_node
{
	struct rt_list_node *next;
	struct rt_list_node *prev;
};
typedef struct rt_list_node rt_list_t;

/*
 * object
 */ 
struct rt_object
{
	char      name[RT_NAME_MAX];
	rt_uint8  type;
	rt_uint8  flag;

	rt_list_t list;
};
typedef struct rt_object* rt_object_t;

enum rt_object_class_type
{
	RT_Object_Class_Thread = 0,
#ifdef RT_USING_PROCESS
	RT_Object_Class_Process,
#endif
#ifdef RT_USING_SEMAPHORE
	RT_Object_Class_Semaphore,
#endif
#ifdef RT_USING_MUTEX
	RT_Object_Class_Mutex,
#endif
#ifdef RT_USING_FASTEVENT
	RT_Object_Class_FastEvent,
#endif
#ifdef RT_USING_EVENT
	RT_Object_Class_Event,
#endif
#ifdef RT_USING_MAILBOX
	RT_Object_Class_MailBox,
#endif
#ifdef RT_USING_MESSAGEQUEUE
	RT_Object_Class_MessageQueue,
#endif
#ifdef RT_USING_MEMPOOL
	RT_Object_Class_MemPool,
#endif
	RT_Object_Class_Timer,
	RT_Object_Class_Unknown,
	RT_OBJECT_Class_Static = 0x80
};

struct rt_object_information
{
	enum rt_object_class_type type;	/* object class type */
	rt_list_t object_list;			/* object list */
	rt_size_t object_size;			/* object size */
};

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);

/* timer */
#define RT_TIMER_FLAG_DEACTIVATED		0x0
#define RT_TIMER_FLAG_ACTIVATED			0x1
#define RT_TIMER_FLAG_ONE_SHOT			0x0
#define RT_TIMER_FLAG_PERIODIC			0x2

#define RT_TIMER_CTRL_SET_TIME			0x0
#define RT_TIMER_CTRL_GET_TIME			0x1
#define RT_TIMER_CTRL_SET_ONESHOT		0x2
#define RT_TIMER_CTRL_SET_PERIODIC		0x3

struct rt_timer
{
	struct rt_object parent;

	rt_list_t list;						/* the node of timer list */

	void (*timeout_func)(void* parameter);/* timeout function */
	void *parameter;					/* timeout function's parameter */

	rt_tick_t init_tick;				/* timer timeout tick */
	rt_tick_t timeout_tick;				/* timeout tick */
};
typedef struct rt_timer* rt_timer_t;

/* process */
#ifdef RT_USING_PROCESS
struct rt_process
{
};
typedef struct rt_process* rt_pid_t;
#endif /* end of RT_USING_PROCESS */

/*
 * Thread
 */

/* thread state definitions */
#define RT_THREAD_RUNNING	0x0
#define RT_THREAD_READY		0x1
#define RT_THREAD_SUSPEND	0x2
#define RT_THREAD_BLOCK		RT_THREAD_SUSPEND
#define RT_THREAD_CLOSE		0x3
#define RT_THREAD_INIT		RT_THREAD_CLOSE

#define RT_THREAD_FLAGS_TIMERSLICE 	0x01

#define RT_THREAD_CTRL_STARTUP			0x00
#define RT_THREAD_CTRL_CLOSE			0x01
#define RT_THREAD_CTRL_CHANGE_PRIORITY	0x02
#define RT_THREAD_CTRL_INFO				0x03

#if 0
#define RT_THREAD_MAX	1024
struct rt_thread* rt_thread_id[RT_THREAD_MAX];
struct rt_thread** rt_thread_id_free;
#endif

typedef struct rt_thread* rt_thread_t;
struct rt_thread
{
	char        name[RT_NAME_MAX];			/* the name of thread */
	rt_uint8	type;						/* type of object */
	rt_uint8   	flags;						/* thread's flags */

	rt_list_t	list;						/* the object list */

	rt_thread_t tid;						/* the thread id */
	rt_list_t	tlist;						/* the thread list */

#ifdef RT_USING_PROCESS
	rt_tid_t 	tid;
	rt_pid_t    pid;						/* the proccess id */
	rt_list_t	plist;						/* the list in same process */
#endif

	void*		sp;							/* stack point */
	void*		entry;						/* entry */
	void*       parameter;					/* parameter */
	void*       stack_addr;					/* stack address */
	rt_uint16   stack_size;					/* stack size */

	rt_err_t    error;						/* error code */

	/* priority */
	rt_uint8	current_priority;			/* current priority */
	rt_uint8	init_priority;				/* initialized priority */

	rt_uint8 	number;
	rt_uint32	number_mask;

	rt_uint8	high_mask;

	/* thread event */
	rt_uint32 	event_set;
	rt_uint8	event_info;

	/* thread stat */
	rt_uint8    stat;

	rt_ubase_t	init_tick;					/* thread's tick */
	rt_ubase_t 	remaining_tick;				/* remaining tick */

	struct rt_timer thread_timer;			/* thread timer */
};

void rt_system_thread_init(void);
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_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_create_hook (void (*hook)(rt_thread_t thread));
void rt_thread_delete_hook (void (*hook)(rt_thread_t thread));
void rt_thread_suspend_hook(void (*hook)(rt_thread_t thread));
void rt_thread_resume_hook (void (*hook)(rt_thread_t thread));
#endif

void rt_thread_idle_init(void);
#ifdef RT_USING_HOOK
void rt_thread_idle_sethook(void (*hook)());
#endif

/*
 * schedule
 */
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_hook(void (*hook)(rt_thread_t from, rt_thread_t to));
#endif

/*
 * clock & timer
 */
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_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);

/*
 * memory 
 * heap & partition
 */
#ifdef RT_USING_MEMPOOL
struct rt_mempool
{
	struct rt_object parent;

	void* start_address;
	rt_size_t size;

	rt_size_t block_size;
	rt_uint8* block_list;

	rt_size_t block_total_count;
	rt_size_t block_free_count;

	rt_list_t suspend_thread;
	rt_size_t suspend_thread_count;
};
typedef struct rt_mempool* rt_mp_t;

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(void *mp_start, 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);
#endif

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

/*
 * ipc & sync
 */
#define RT_IPC_FLAG_FIFO	0x00
#define RT_IPC_FLAG_PRIO	0x01

#define RT_WAITING_FOREVER	-1
#define RT_WAITING_NO		0

struct rt_ipc_object
{
	struct rt_object parent;

	rt_list_t suspend_thread;
	rt_uint32 suspend_thread_count;
};

#ifdef RT_USING_SEMAPHORE 
struct rt_semaphore
{
	struct rt_ipc_object parent;

	rt_base_t value;
};
typedef struct rt_semaphore* rt_sem_t;

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
struct rt_mutex
{
	struct rt_ipc_object parent;

	rt_base_t value;

	struct rt_thread* owner;
	rt_uint8 original_priority;

	rt_base_t hold;
};
typedef struct rt_mutex* rt_mutex_t;

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

#if defined(RT_USING_EVENT) || defined(RT_USING_FASTEVENT)
#define RT_EVENT_FLAG_AND		0x01
#define RT_EVENT_FLAG_OR		0x02
#define RT_EVENT_FLAG_CLEAR		0x04
#endif

#ifdef RT_USING_FASTEVENT
struct rt_fast_event
{
	struct rt_object parent;

	rt_uint32 set;

	rt_list_t thread_list[RT_EVENT_LENGTH];
};
typedef struct rt_fast_event* rt_fast_event_t;

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
struct rt_event
{
	struct rt_ipc_object parent;

	rt_uint32 set;
};
typedef struct rt_event* rt_event_t;

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
struct rt_mailbox
{
	struct rt_ipc_object parent;

	rt_uint32* msg_pool;

	rt_size_t size;

	rt_ubase_t entry;
	rt_ubase_t in_offset, out_offset;
};
typedef struct rt_mailbox* rt_mailbox_t;

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
struct rt_messagequeue
{
	struct rt_ipc_object parent;

	void* msg_pool;

	rt_size_t msg_size;
	rt_size_t max_msgs;

	void* msg_queue_head;
	void* msg_queue_tail;
	void* msg_queue_free;

	rt_ubase_t entry;
};
typedef struct rt_messagequeue* rt_mq_t;

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

/*
 * interrupt
 */
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);

/* service */
void rt_sprintf(char *buf, const char *fmt, ...);
void rt_kprintf(const char *fmt, ...);

/*@}*/

#ifdef __cplusplus
}
#endif

#endif