1
0

rtthread.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437
  1. /*
  2. * File : rtthread.h
  3. * This file is part of RT-Thread RTOS
  4. * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
  5. *
  6. * The license and distribution terms for this file may be
  7. * found in the file LICENSE in this distribution or at
  8. * http://www.rt-thread.org/license/LICENSE
  9. *
  10. * Change Logs:
  11. * Date Author Notes
  12. * 2006-03-18 Bernard the first version
  13. * 2006-04-26 Bernard add semaphore APIs
  14. * 2006-08-10 Bernard add version information
  15. * 2007-01-28 Bernard rename RT_OBJECT_Class_Static to RT_Object_Class_Static
  16. * 2007-03-03 Bernard clean up the definitions to rtdef.h
  17. * 2010-04-11 yi.qiu add module feature
  18. */
  19. #ifndef __RT_THREAD_H__
  20. #define __RT_THREAD_H__
  21. #include <rtdef.h>
  22. #include <rtdebug.h>
  23. #include <rtservice.h>
  24. #include <rtm.h>
  25. #ifdef __cplusplus
  26. extern "C" {
  27. #endif
  28. /**
  29. * @addtogroup KernelObject
  30. */
  31. /*@{*/
  32. /*
  33. * kernel object interface
  34. */
  35. void rt_system_object_init(void);
  36. struct rt_object_information *rt_object_get_information(enum rt_object_class_type type);
  37. void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name);
  38. void rt_object_detach(rt_object_t object);
  39. rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);
  40. void rt_object_delete(rt_object_t object);
  41. rt_bool_t rt_object_is_systemobject(rt_object_t object);
  42. rt_object_t rt_object_find(const char *name, rt_uint8_t type);
  43. #ifdef RT_USING_HOOK
  44. void rt_object_attach_sethook(void (*hook)(struct rt_object *object));
  45. void rt_object_detach_sethook(void (*hook)(struct rt_object *object));
  46. void rt_object_trytake_sethook(void (*hook)(struct rt_object *object));
  47. void rt_object_take_sethook(void (*hook)(struct rt_object *object));
  48. void rt_object_put_sethook(void (*hook)(struct rt_object *object));
  49. #endif
  50. /*@}*/
  51. /**
  52. * @addtogroup Clock
  53. */
  54. /*@{*/
  55. /*
  56. * clock & timer interface
  57. */
  58. void rt_system_tick_init(void);
  59. rt_tick_t rt_tick_get(void);
  60. void rt_tick_set(rt_tick_t tick);
  61. void rt_tick_increase(void);
  62. rt_tick_t rt_tick_from_millisecond(rt_uint32_t ms);
  63. void rt_system_timer_init(void);
  64. void rt_system_timer_thread_init(void);
  65. void rt_timer_init(rt_timer_t timer,
  66. const char *name,
  67. void (*timeout)(void *parameter), void *parameter,
  68. rt_tick_t time, rt_uint8_t flag);
  69. rt_err_t rt_timer_detach(rt_timer_t timer);
  70. rt_timer_t rt_timer_create(const char *name,
  71. void (*timeout)(void *parameter), void *parameter,
  72. rt_tick_t time, rt_uint8_t flag);
  73. rt_err_t rt_timer_delete(rt_timer_t timer);
  74. rt_err_t rt_timer_start(rt_timer_t timer);
  75. rt_err_t rt_timer_stop(rt_timer_t timer);
  76. rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg);
  77. rt_tick_t rt_timer_next_timeout_tick(void);
  78. void rt_timer_check(void);
  79. #ifdef RT_USING_HOOK
  80. void rt_timer_timeout_sethook(void (*hook)(struct rt_timer *timer));
  81. #endif
  82. /*@}*/
  83. /**
  84. * @addtogroup Thread
  85. */
  86. /*@{*/
  87. /*
  88. * thread interface
  89. */
  90. rt_err_t rt_thread_init(struct rt_thread *thread,
  91. const char *name,
  92. void (*entry)(void *parameter), void *parameter,
  93. void *stack_start, rt_uint32_t stack_size,
  94. rt_uint8_t priority, rt_uint32_t tick);
  95. rt_err_t rt_thread_detach(rt_thread_t thread);
  96. rt_thread_t rt_thread_create(const char *name,
  97. void (*entry)(void *parameter), void *parameter,
  98. rt_uint32_t stack_size,
  99. rt_uint8_t priority, rt_uint32_t tick);
  100. rt_thread_t rt_thread_self(void);
  101. rt_thread_t rt_thread_find(char *name);
  102. rt_err_t rt_thread_startup(rt_thread_t thread);
  103. rt_err_t rt_thread_delete(rt_thread_t thread);
  104. rt_err_t rt_thread_yield(void);
  105. rt_err_t rt_thread_delay(rt_tick_t tick);
  106. rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg);
  107. rt_err_t rt_thread_suspend(rt_thread_t thread);
  108. rt_err_t rt_thread_resume(rt_thread_t thread);
  109. void rt_thread_timeout(void *parameter);
  110. /*
  111. * idle thread interface
  112. */
  113. void rt_thread_idle_init(void);
  114. #ifdef RT_USING_HOOK
  115. void rt_thread_idle_sethook(void (*hook)(void));
  116. #endif
  117. void rt_thread_idle_excute(void);
  118. /*
  119. * schedule service
  120. */
  121. void rt_system_scheduler_init(void);
  122. void rt_system_scheduler_start(void);
  123. void rt_schedule(void);
  124. void rt_schedule_insert_thread(struct rt_thread *thread);
  125. void rt_schedule_remove_thread(struct rt_thread *thread);
  126. void rt_enter_critical(void);
  127. void rt_exit_critical(void);
  128. #ifdef RT_USING_HOOK
  129. void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
  130. #endif
  131. /*@}*/
  132. /**
  133. * @addtogroup MM
  134. */
  135. /*@{*/
  136. /*
  137. * memory management interface
  138. */
  139. #ifdef RT_USING_MEMPOOL
  140. /*
  141. * memory pool interface
  142. */
  143. rt_err_t rt_mp_init(struct rt_mempool *mp, const char *name, void *start, rt_size_t size, rt_size_t block_size);
  144. rt_err_t rt_mp_detach(struct rt_mempool *mp);
  145. rt_mp_t rt_mp_create(const char *name, rt_size_t block_count, rt_size_t block_size);
  146. rt_err_t rt_mp_delete(rt_mp_t mp);
  147. void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);
  148. void rt_mp_free(void *block);
  149. #ifdef RT_USING_HOOK
  150. void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block));
  151. void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block));
  152. #endif
  153. #endif
  154. #ifdef RT_USING_HEAP
  155. /*
  156. * heap memory interface
  157. */
  158. void rt_system_heap_init(void *begin_addr, void *end_addr);
  159. void *rt_malloc(rt_size_t nbytes);
  160. void rt_free(void *ptr);
  161. void *rt_realloc(void *ptr, rt_size_t nbytes);
  162. void *rt_calloc(rt_size_t count, rt_size_t size);
  163. void *rt_malloc_align(rt_size_t size, rt_size_t align);
  164. void rt_free_align(void *ptr);
  165. void rt_memory_info(rt_uint32_t *total, rt_uint32_t *used, rt_uint32_t *max_used);
  166. #ifdef RT_USING_SLAB
  167. void *rt_page_alloc(rt_size_t npages);
  168. void rt_page_free(void *addr, rt_size_t npages);
  169. #endif
  170. #ifdef RT_USING_HOOK
  171. void rt_malloc_sethook(void (*hook)(void *ptr, rt_uint32_t size));
  172. void rt_free_sethook(void (*hook)(void *ptr));
  173. #endif
  174. #endif
  175. #ifdef RT_USING_MEMHEAP
  176. /**
  177. * memory heap object interface
  178. */
  179. rt_err_t rt_memheap_init(struct rt_memheap* memheap, const char* name,
  180. void *start_addr, rt_uint32_t size);
  181. rt_err_t rt_memheap_detach(struct rt_memheap* heap);
  182. void* rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size);
  183. void rt_memheap_free(void* ptr);
  184. #endif
  185. /*@}*/
  186. /**
  187. * @addtogroup IPC
  188. */
  189. /*@{*/
  190. #ifdef RT_USING_SEMAPHORE
  191. /*
  192. * semaphore interface
  193. */
  194. rt_err_t rt_sem_init(rt_sem_t sem, const char *name, rt_uint32_t value, rt_uint8_t flag);
  195. rt_err_t rt_sem_detach(rt_sem_t sem);
  196. rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag);
  197. rt_err_t rt_sem_delete(rt_sem_t sem);
  198. rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time);
  199. rt_err_t rt_sem_trytake(rt_sem_t sem);
  200. rt_err_t rt_sem_release(rt_sem_t sem);
  201. rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void *arg);
  202. #endif
  203. #ifdef RT_USING_MUTEX
  204. /*
  205. * mutex interface
  206. */
  207. rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);
  208. rt_err_t rt_mutex_detach(rt_mutex_t mutex);
  209. rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);
  210. rt_err_t rt_mutex_delete(rt_mutex_t mutex);
  211. rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time);
  212. rt_err_t rt_mutex_release(rt_mutex_t mutex);
  213. rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void *arg);
  214. #endif
  215. #ifdef RT_USING_EVENT
  216. /*
  217. * event interface
  218. */
  219. rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag);
  220. rt_err_t rt_event_detach(rt_event_t event);
  221. rt_event_t rt_event_create(const char *name, rt_uint8_t flag);
  222. rt_err_t rt_event_delete(rt_event_t event);
  223. rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
  224. 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);
  225. rt_err_t rt_event_control(rt_event_t event, rt_uint8_t cmd, void *arg);
  226. #endif
  227. #ifdef RT_USING_MAILBOX
  228. /*
  229. * mailbox interface
  230. */
  231. rt_err_t rt_mb_init(rt_mailbox_t mb, const char *name, void *msgpool, rt_size_t size, rt_uint8_t flag);
  232. rt_err_t rt_mb_detach(rt_mailbox_t mb);
  233. rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag);
  234. rt_err_t rt_mb_delete(rt_mailbox_t mb);
  235. rt_err_t rt_mb_send(rt_mailbox_t mb, rt_uint32_t value);
  236. rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
  237. rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_uint32_t *value, rt_int32_t timeout);
  238. rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void *arg);
  239. #endif
  240. #ifdef RT_USING_MESSAGEQUEUE
  241. /*
  242. * message queue interface
  243. */
  244. 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);
  245. rt_err_t rt_mq_detach(rt_mq_t mq);
  246. rt_mq_t rt_mq_create(const char *name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag);
  247. rt_err_t rt_mq_delete(rt_mq_t mq);
  248. rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size);
  249. rt_err_t rt_mq_urgent(rt_mq_t mq, void *buffer, rt_size_t size);
  250. rt_err_t rt_mq_recv(rt_mq_t mq, void *buffer, rt_size_t size, rt_int32_t timeout);
  251. rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void *arg);
  252. #endif
  253. /*@}*/
  254. #ifdef RT_USING_DEVICE
  255. /**
  256. * @addtogroup Device
  257. */
  258. /*@{*/
  259. /*
  260. * device (I/O) system interface
  261. */
  262. rt_device_t rt_device_find(const char *name);
  263. rt_err_t rt_device_register(rt_device_t dev, const char *name, rt_uint16_t flags);
  264. rt_err_t rt_device_unregister(rt_device_t dev);
  265. rt_err_t rt_device_init_all(void);
  266. 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));
  267. rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_device_t dev, void *buffer));
  268. rt_err_t rt_device_init (rt_device_t dev);
  269. rt_err_t rt_device_open (rt_device_t dev, rt_uint16_t oflag);
  270. rt_err_t rt_device_close(rt_device_t dev);
  271. rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
  272. rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
  273. rt_err_t rt_device_control(rt_device_t dev, rt_uint8_t cmd, void *arg);
  274. /*@}*/
  275. #endif
  276. #ifdef RT_USING_MODULE
  277. /**
  278. * @addtogroup Module
  279. */
  280. /*@{*/
  281. /*
  282. * module interface
  283. */
  284. rt_module_t rt_module_load(const char *name, void *module_ptr);
  285. rt_err_t rt_module_unload(rt_module_t module);
  286. rt_module_t rt_module_open(const char *filename);
  287. void *rt_module_malloc(rt_size_t size);
  288. void *rt_module_realloc(void *ptr, rt_size_t size);
  289. void rt_module_free(rt_module_t module, void *addr);
  290. rt_module_t rt_module_self(void);
  291. rt_err_t rt_module_set(rt_module_t module);
  292. rt_module_t rt_module_find(const char *name);
  293. #ifdef RT_USING_HOOK
  294. void rt_module_load_sethook(void (*hook)(rt_module_t module));
  295. void rt_module_unload_sethook(void (*hook)(rt_module_t module));
  296. #endif
  297. /*@}*/
  298. #endif
  299. /*
  300. * interrupt service
  301. */
  302. typedef void (*rt_isr_handler_t)(int vector);
  303. /*
  304. * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP
  305. */
  306. void rt_interrupt_enter(void);
  307. void rt_interrupt_leave(void);
  308. /*
  309. * the number of nested interrupts.
  310. */
  311. rt_uint8_t rt_interrupt_get_nest(void);
  312. /**
  313. * application module
  314. */
  315. void rt_system_module_init(void);
  316. /**
  317. * @addtogroup KernelService
  318. */
  319. /*@{*/
  320. /*
  321. * general kernel service
  322. */
  323. void rt_kprintf(const char *fmt, ...);
  324. rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
  325. rt_int32_t rt_sprintf(char *buf ,const char *format, ...);
  326. rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
  327. #ifdef RT_USING_DEVICE
  328. rt_device_t rt_console_set_device(const char *name);
  329. #endif
  330. rt_err_t rt_get_errno(void);
  331. void rt_set_errno(rt_err_t no);
  332. int *_rt_errno(void);
  333. #ifndef RT_USING_NEWLIB
  334. #ifndef errno
  335. #define errno *_rt_errno()
  336. #endif
  337. #endif
  338. void *rt_memset(void *src, int c, rt_ubase_t n);
  339. void *rt_memcpy(void *dest, const void *src, rt_ubase_t n);
  340. rt_ubase_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count);
  341. rt_ubase_t rt_strcmp (const char *cs, const char *ct);
  342. rt_ubase_t rt_strlen (const char *src);
  343. char *rt_strdup(const char *s);
  344. char *rt_strstr(const char *str1, const char *str2);
  345. rt_int32_t rt_sscanf(const char *buf, const char *fmt, ...);
  346. char *rt_strncpy(char *dest, const char *src, rt_ubase_t n);
  347. void *rt_memmove(void *dest, const void *src, rt_ubase_t n);
  348. rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_ubase_t count);
  349. rt_uint32_t rt_strcasecmp(const char *a, const char *b);
  350. void rt_show_version(void);
  351. /*@}*/
  352. #ifdef __cplusplus
  353. }
  354. #endif
  355. #endif