rtthread.h 11.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * 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
qiuyiuestc's avatar
qiuyiuestc 已提交
17
 * 2010-04-11     yi.qiu      add module feature
18 19 20 21 22 23
 */

#ifndef __RT_THREAD_H__
#define __RT_THREAD_H__

#include <rtdef.h>
24
#include <rtdebug.h>
25 26 27 28 29 30 31 32 33 34 35 36 37 38

#ifdef __cplusplus
extern "C" {
#endif

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

void rt_system_object_init(void);
39
struct rt_object_information *rt_object_get_information(enum rt_object_class_type type);
40 41 42 43 44
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_err_t rt_object_is_systemobject(rt_object_t object);
45
rt_object_t rt_object_find(const char* name, rt_uint8_t type);
46 47 48 49 50 51 52 53 54

#ifdef RT_USING_HOOK
void rt_object_attach_sethook(void (*hook)(struct rt_object* object));
void rt_object_detach_sethook(void (*hook)(struct rt_object* object));
void rt_object_trytake_sethook(void (*hook)(struct rt_object* object));
void rt_object_take_sethook(void (*hook)(struct rt_object* object));
void rt_object_put_sethook(void (*hook)(struct rt_object* object));
#endif

55 56 57 58 59 60 61 62 63 64 65
/*@}*/

/**
 * @addtogroup Clock
 */
/*@{*/
/*
 * clock & timer interface
 */
void rt_system_tick_init(void);
rt_tick_t rt_tick_get(void);
66
void rt_tick_set(rt_tick_t tick);
67 68 69 70
void rt_tick_increase(void);
rt_tick_t rt_tick_from_millisecond(rt_uint32_t ms);

void rt_system_timer_init(void);
71 72
void rt_system_timer_thread_init(void);

73 74 75 76 77 78 79 80 81 82 83 84
void rt_timer_init(rt_timer_t timer,
	const char* name,
	void (*timeout)(void* parameter), void* parameter,
	rt_tick_t time, rt_uint8_t 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_t 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_t cmd, void* arg);
85 86 87 88

#ifdef RT_USING_HOOK
void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer));
#endif
89 90 91 92 93 94 95 96 97
/*@}*/

/**
 * @addtogroup Thread
 */
/*@{*/
/*
 * thread interface
 */
qiuyiuestc's avatar
qiuyiuestc 已提交
98
rt_err_t rt_thread_init(struct rt_thread* thread,
99 100 101 102
	const char* name,
	void (*entry)(void* parameter), void* parameter,
	void* stack_start, rt_uint32_t stack_size,
	rt_uint8_t priority, rt_uint32_t tick);
qiuyiuestc's avatar
qiuyiuestc 已提交
103 104
rt_err_t rt_thread_detach(rt_thread_t thread);
rt_thread_t rt_thread_create (const char* name,
105 106 107
	void (*entry)(void* parameter), void* parameter,
	rt_uint32_t stack_size,
	rt_uint8_t priority, rt_uint32_t tick);
qiuyiuestc's avatar
qiuyiuestc 已提交
108 109 110 111 112 113 114 115 116 117 118
rt_thread_t rt_thread_self(void);
rt_thread_t rt_thread_find(char* name);
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_t 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);
119 120 121 122 123 124 125 126

/*
 * idle thread interface
 */
void rt_thread_idle_init(void);
#ifdef RT_USING_HOOK
void rt_thread_idle_sethook(void (*hook)(void));
#endif
B
bernard.xiong 已提交
127
void rt_thread_idle_excute(void);
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

/*
 * 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
143
void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
#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_t time);
void rt_mp_free  (void *block);

#ifdef RT_USING_HOOK
167 168
void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool* mp, void *block));
void rt_mp_free_sethook(void (*hook)(struct rt_mempool* mp, void *block));
169 170 171 172 173 174 175 176 177 178 179 180
#endif
#endif

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

void* rt_malloc(rt_size_t nbytes);
void rt_free (void *ptr);
void* rt_realloc(void *ptr, rt_size_t nbytes);
181
void *rt_calloc(rt_size_t count, rt_size_t size);
182

183
void rt_memory_info(rt_uint32_t *total, 
184 185
	rt_uint32_t *used,
	rt_uint32_t *max_used);
186

qiuyiuestc's avatar
qiuyiuestc 已提交
187 188 189 190 191
#ifdef RT_USING_SLAB
void *rt_page_alloc(rt_size_t npages);
void rt_page_free(void *addr, rt_size_t npages);
#endif

192 193 194 195
#ifdef RT_USING_HOOK
void rt_malloc_sethook(void (*hook)(void *ptr, rt_uint32_t size));
void rt_free_sethook(void (*hook)(void *ptr));
#endif
qiuyiuestc's avatar
qiuyiuestc 已提交
196

197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
#endif
/*@}*/

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

rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t 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_t 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_t flag);
rt_err_t rt_mutex_detach (rt_mutex_t mutex);
rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag);
rt_err_t rt_mutex_delete (rt_mutex_t mutex);

rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time);
rt_err_t rt_mutex_release(rt_mutex_t mutex);
rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t 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_t flag);
rt_err_t rt_event_detach(rt_event_t event);
rt_event_t rt_event_create (const char* name, rt_uint8_t flag);
rt_err_t rt_event_delete (rt_event_t event);

rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t* recved);
rt_err_t rt_event_control (rt_event_t event, rt_uint8_t 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_t 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_t flag);
rt_err_t rt_mb_delete (rt_mailbox_t mb);

rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32_t value);
259
rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout);
rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t 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_t 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_t 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_t timeout);
rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg);
#endif
/*@}*/

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

rt_device_t rt_device_find(const char* name);

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

rt_err_t rt_device_set_rx_indicate(rt_device_t dev, rt_err_t (*rx_ind )(rt_device_t dev, rt_size_t size));
rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_device_t dev, void *buffer));

B
bernard.xiong 已提交
298
rt_err_t  rt_device_init (rt_device_t dev);
299 300 301 302 303 304 305 306
rt_err_t  rt_device_open (rt_device_t dev, rt_uint16_t oflag);
rt_err_t  rt_device_close(rt_device_t dev);
rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
rt_size_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_t cmd, void* arg);
/*@}*/
#endif

qiuyiuestc's avatar
qiuyiuestc 已提交
307 308 309 310 311 312 313 314 315
#ifdef RT_USING_MODULE
/**
 * @addtogroup Module
 */
/*@{*/
/*
 * module interface
 */

qiuyiuestc's avatar
qiuyiuestc 已提交
316
rt_module_t rt_module_load(const char* name, void* module_ptr);
qiuyiuestc's avatar
qiuyiuestc 已提交
317
rt_err_t rt_module_unload(rt_module_t module);
qiuyiuestc's avatar
qiuyiuestc 已提交
318
rt_module_t rt_module_open(const char* filename);
qiuyiuestc's avatar
qiuyiuestc 已提交
319 320 321
void *rt_module_malloc(rt_size_t size);
void *rt_module_realloc(void *ptr, rt_size_t size);
void rt_module_free(rt_module_t module, void *addr);
qiuyiuestc's avatar
qiuyiuestc 已提交
322
rt_module_t rt_module_self (void);
qiuyiuestc's avatar
qiuyiuestc 已提交
323
rt_err_t rt_module_set (rt_module_t module);
qiuyiuestc's avatar
qiuyiuestc 已提交
324
rt_module_t rt_module_find(const char* name);
qiuyiuestc's avatar
qiuyiuestc 已提交
325 326 327 328 329 330

#ifdef RT_USING_HOOK
void rt_module_load_sethook(void (*hook)(rt_module_t module));
void rt_module_unload_sethook(void (*hook)(rt_module_t module));
#endif

qiuyiuestc's avatar
qiuyiuestc 已提交
331
#endif
B
bernard.xiong@gmail.com 已提交
332
/*@}*/
qiuyiuestc's avatar
qiuyiuestc 已提交
333
 
334 335 336 337 338 339 340 341 342 343
/*
 * 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);
344 345 346 347
/*
 * the number of nested interrupts.
 */
rt_uint8_t rt_interrupt_get_nest(void);
348 349 350 351 352 353 354 355 356 357 358

/**
 * @addtogroup KernelService
 */
/*@{*/
/*
 * general kernel service
 */
rt_int32_t rt_sprintf(char *buf ,const char *format,...);
rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
rt_int32_t rt_sprintf(char *buf ,const char *format,...);
qiuyiuestc's avatar
qiuyiuestc 已提交
359 360
rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);

361
#ifdef RT_USING_DEVICE
362
rt_device_t rt_console_set_device(const char* name);
363
#endif
364 365 366 367
void rt_kprintf(const char *fmt, ...);

rt_err_t rt_get_errno(void);
void rt_set_errno(rt_err_t no);
368 369 370 371 372 373
int *_rt_errno(void);
#ifndef RT_USING_NEWLIB
#ifndef errno
#define errno	*_rt_errno()
#endif
#endif
374 375 376 377 378

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

rt_ubase_t rt_strncmp(const char * cs, const char * ct, rt_ubase_t count);
qiuyiuestc's avatar
qiuyiuestc 已提交
379
rt_ubase_t rt_strcmp (const char *cs, const char *ct);
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
rt_ubase_t rt_strlen (const char *src);
char *rt_strdup(const char *s);

char * rt_strstr( const char * str1, const char * str2 );
rt_int32_t rt_sscanf(const char * buf, const char * fmt, ...);
char *rt_strncpy(char *dest, const char *src, rt_ubase_t n);
void* rt_memmove(void *dest, const void *src, rt_ubase_t n);
rt_int32_t rt_memcmp(const void * cs,const void * ct, rt_ubase_t count);
rt_uint32_t rt_strcasecmp(const char *a, const char *b);

void rt_show_version(void);

/*@}*/

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