27 files changed, 2906 insertions, 2906 deletions

diff --git a/examples/kernel/SConscript b/examples/kernel/SConscript
index 3610085157..bfbc80b54a 100644
--- a/examples/kernel/SConscript
+++ b/examples/kernel/SConscript
@@ -1,39 +1,39 @@
-from building import *

-

-src = Split("""

-tc_comm.c

-thread_static.c

-thread_dynamic.c

-thread_priority.c

-thread_same_priority.c

-thread_static_simple.c

-thread_dynamic_simple.c

-thread_delete.c

-thread_detach.c

-thread_yield.c

-thread_suspend.c

-thread_resume.c

-semaphore_static.c

-semaphore_dynamic.c

-semaphore_priority.c

-semaphore_buffer_worker.c

-semaphore_producer_consumer.c

-mutex_simple.c

-event_simple.c

-mbox_simple.c

-mbox_send_wait.c

-messageq_simple.c

-timer_static.c

-timer_dynamic.c

-timer_stop_self.c

-timer_control.c

-timer_timeout.c

-heap_malloc.c

-heap_realloc.c

-memp_simple.c

-tc_sample.c

-""")

-

-group = DefineGroup('examples', src, depend = ['RT_USING_TC'])

-

-Return('group')

+from building import *
+
+src = Split("""
+tc_comm.c
+thread_static.c
+thread_dynamic.c
+thread_priority.c
+thread_same_priority.c
+thread_static_simple.c
+thread_dynamic_simple.c
+thread_delete.c
+thread_detach.c
+thread_yield.c
+thread_suspend.c
+thread_resume.c
+semaphore_static.c
+semaphore_dynamic.c
+semaphore_priority.c
+semaphore_buffer_worker.c
+semaphore_producer_consumer.c
+mutex_simple.c
+event_simple.c
+mbox_simple.c
+mbox_send_wait.c
+messageq_simple.c
+timer_static.c
+timer_dynamic.c
+timer_stop_self.c
+timer_control.c
+timer_timeout.c
+heap_malloc.c
+heap_realloc.c
+memp_simple.c
+tc_sample.c
+""")
+
+group = DefineGroup('examples', src, depend = ['RT_USING_TC'])
+
+Return('group')
diff --git a/examples/kernel/heap_malloc.c b/examples/kernel/heap_malloc.c
index 236a982fdf..0a6b46cc95 100644
--- a/examples/kernel/heap_malloc.c
+++ b/examples/kernel/heap_malloc.c
@@ -1,72 +1,72 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-/*

- * This is an example for heap malloc

- */

-

-static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)

-{

-	while (len)

-	{

-		if (*ptr != value) return RT_FALSE;

-

-		ptr ++;

-		len --;

-	}

-

-	return RT_TRUE;

-}

-

-static void heap_malloc_init()

-{

-	rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;

-

-	ptr1 = rt_malloc(1);

-	ptr2 = rt_malloc(13);

-	ptr3 = rt_malloc(31);

-	ptr4 = rt_malloc(127);

-	ptr5 = rt_malloc(0);

-

-	memset(ptr1, 1, 1);

-	memset(ptr2, 2, 13);

-	memset(ptr3, 3, 31);

-	memset(ptr4, 4, 127);

-

-	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;

-	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr4, 4, 127) != RT_FALSE) goto _failed;

-

-	rt_free(ptr4);

-	rt_free(ptr3);

-	rt_free(ptr3);

-	rt_free(ptr1);

-

-	if (ptr5 != RT_NULL)

-	{

-		rt_free(ptr5);

-	}

-

-	tc_done(TC_STAT_PASSED);

-

-_failed:

-	tc_done(TC_STAT_FAILED);

-}

-

-#ifdef RT_USING_TC

-int _tc_heap_malloc()

-{

-	heap_malloc_init();

-

-	return 0;

-}

-FINSH_FUNCTION_EXPORT(_tc_heap_malloc, a heap malloc test);

-#else

-int rt_application_init()

-{

-	heap_malloc_init();

-

-	return 0;

-}

-#endif

+#include <rtthread.h>
+#include "tc_comm.h"
+
+/*
+ * This is an example for heap malloc
+ */
+
+static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)
+{
+	while (len)
+	{
+		if (*ptr != value) return RT_FALSE;
+
+		ptr ++;
+		len --;
+	}
+
+	return RT_TRUE;
+}
+
+static void heap_malloc_init()
+{
+	rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
+
+	ptr1 = rt_malloc(1);
+	ptr2 = rt_malloc(13);
+	ptr3 = rt_malloc(31);
+	ptr4 = rt_malloc(127);
+	ptr5 = rt_malloc(0);
+
+	memset(ptr1, 1, 1);
+	memset(ptr2, 2, 13);
+	memset(ptr3, 3, 31);
+	memset(ptr4, 4, 127);
+
+	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;
+	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr4, 4, 127) != RT_FALSE) goto _failed;
+
+	rt_free(ptr4);
+	rt_free(ptr3);
+	rt_free(ptr3);
+	rt_free(ptr1);
+
+	if (ptr5 != RT_NULL)
+	{
+		rt_free(ptr5);
+	}
+
+	tc_done(TC_STAT_PASSED);
+
+_failed:
+	tc_done(TC_STAT_FAILED);
+}
+
+#ifdef RT_USING_TC
+int _tc_heap_malloc()
+{
+	heap_malloc_init();
+
+	return 0;
+}
+FINSH_FUNCTION_EXPORT(_tc_heap_malloc, a heap malloc test);
+#else
+int rt_application_init()
+{
+	heap_malloc_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/heap_realloc.c b/examples/kernel/heap_realloc.c
index 5fa96c7f30..a4974d5bf3 100644
--- a/examples/kernel/heap_realloc.c
+++ b/examples/kernel/heap_realloc.c
@@ -1,83 +1,83 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-/*

- * This is an example for heap malloc

- */

-

-static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)

-{

-	while (len)

-	{

-		if (*ptr != value) return RT_FALSE;

-

-		ptr ++;

-		len --;

-	}

-

-	return RT_TRUE;

-}

-

-static void heap_realloc_init()

-{

-	rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;

-

-	ptr1 = rt_malloc(1);

-	ptr2 = rt_malloc(13);

-	ptr3 = rt_malloc(31);

-	ptr4 = rt_malloc(127);

-	ptr5 = rt_malloc(0);

-

-	memset(ptr1, 1, 1);

-	memset(ptr2, 2, 13);

-	memset(ptr3, 3, 31);

-	memset(ptr4, 4, 127);

-

-	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;

-	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr4, 4, 127) != RT_FALSE) goto _failed;

-

-	ptr1 = rt_realloc(ptr1, 13);

-	ptr2 = rt_realloc(ptr2, 31);

-	ptr3 = rt_realloc(ptr3, 127);

-	ptr4 = rt_realloc(ptr4, 1);

-	ptr5 = rt_realloc(ptr5, 0);

-

-	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;

-	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;

-	if (mem_check(ptr4, 4, 1)	!= RT_FALSE) goto _failed;

-

-	rt_free(ptr4);

-	rt_free(ptr3);

-	rt_free(ptr3);

-	rt_free(ptr1);

-

-	if (ptr5 != RT_NULL)

-	{

-		rt_free(ptr5);

-	}

-

-	tc_done(TC_STAT_PASSED);

-

-_failed:

-	tc_done(TC_STAT_FAILED);

-}

-

-#ifdef RT_USING_TC

-int _tc_heap_realloc()

-{

-	heap_realloc_init();

-

-	return 0;

-}

-FINSH_FUNCTION_EXPORT(_tc_heap_realloc, a heap re-malloc test);

-#else

-int rt_application_init()

-{

-	heap_realloc_init();

-

-	return 0;

-}

-#endif

+#include <rtthread.h>
+#include "tc_comm.h"
+
+/*
+ * This is an example for heap malloc
+ */
+
+static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)
+{
+	while (len)
+	{
+		if (*ptr != value) return RT_FALSE;
+
+		ptr ++;
+		len --;
+	}
+
+	return RT_TRUE;
+}
+
+static void heap_realloc_init()
+{
+	rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
+
+	ptr1 = rt_malloc(1);
+	ptr2 = rt_malloc(13);
+	ptr3 = rt_malloc(31);
+	ptr4 = rt_malloc(127);
+	ptr5 = rt_malloc(0);
+
+	memset(ptr1, 1, 1);
+	memset(ptr2, 2, 13);
+	memset(ptr3, 3, 31);
+	memset(ptr4, 4, 127);
+
+	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;
+	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr4, 4, 127) != RT_FALSE) goto _failed;
+
+	ptr1 = rt_realloc(ptr1, 13);
+	ptr2 = rt_realloc(ptr2, 31);
+	ptr3 = rt_realloc(ptr3, 127);
+	ptr4 = rt_realloc(ptr4, 1);
+	ptr5 = rt_realloc(ptr5, 0);
+
+	if (mem_check(ptr1, 1, 1)   != RT_FALSE) goto _failed;
+	if (mem_check(ptr2, 2, 13)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr3, 3, 31)  != RT_FALSE) goto _failed;
+	if (mem_check(ptr4, 4, 1)	!= RT_FALSE) goto _failed;
+
+	rt_free(ptr4);
+	rt_free(ptr3);
+	rt_free(ptr3);
+	rt_free(ptr1);
+
+	if (ptr5 != RT_NULL)
+	{
+		rt_free(ptr5);
+	}
+
+	tc_done(TC_STAT_PASSED);
+
+_failed:
+	tc_done(TC_STAT_FAILED);
+}
+
+#ifdef RT_USING_TC
+int _tc_heap_realloc()
+{
+	heap_realloc_init();
+
+	return 0;
+}
+FINSH_FUNCTION_EXPORT(_tc_heap_realloc, a heap re-malloc test);
+#else
+int rt_application_init()
+{
+	heap_realloc_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/mutex_simple.c b/examples/kernel/mutex_simple.c
index c098018da0..8545ddc660 100644
--- a/examples/kernel/mutex_simple.c
+++ b/examples/kernel/mutex_simple.c
@@ -1,163 +1,163 @@
-/*

- * 程序清单：

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid1 = RT_NULL;

-static rt_thread_t tid2 = RT_NULL;

-static rt_thread_t tid3 = RT_NULL;

-static rt_mutex_t mutex = RT_NULL;

-

-/* 线程1入口 */

-static void thread1_entry(void* parameter)

-{

-	/* 先让低优先级线程运行 */

-	rt_thread_delay(10);

-

-	/* 此时thread3持有mutex，并且thread2等待持有mutex */

-

-	/* 检查thread2与thread3的优先级情况 */

-	if (tid2->current_priority != tid3->current_priority)

-	{

-		/* 优先级不相同，测试失败 */

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return;

-	}

-}

-

-/* 线程2入口 */

-static void thread2_entry(void* parameter)

-{

-	rt_err_t result;

-

-	/* 先让低优先级线程运行 */

-	rt_thread_delay(5);

-

-	while (1)

-	{

-		/*

-		 * 试图持有互斥锁，此时thread3持有，应把thread3的优先级提升到thread2相同

-		 * 的优先级

-		 */

-		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);

-

-		if (result == RT_EOK)

-		{

-			/* 释放互斥锁 */

-			rt_mutex_release(mutex);

-		}

-	}

-}

-

-/* 线程3入口 */

-static void thread3_entry(void* parameter)

-{

-	rt_tick_t tick;

-	rt_err_t result;

-

-	while (1)

-	{

-		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);

-		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);

-		if (result != RT_EOK)

-		{

-			tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		}

-

-		/* 做一个长时间的循环，总共50个OS Tick */

-		tick = rt_tick_get();

-		while (rt_tick_get() - tick < 50) ;

-

-		rt_mutex_release(mutex);

-		rt_mutex_release(mutex);

-	}

-}

-

-int mutex_simple_init()

-{

-	/* 创建互斥锁 */

-	mutex = rt_mutex_create("mutex", RT_IPC_FLAG_FIFO);

-	if (mutex == RT_NULL)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return 0;

-	}

-

-	/* 创建线程1 */

-	tid1 = rt_thread_create("t1",

-		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL)

-		rt_thread_startup(tid1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	tid2 = rt_thread_create("t2",

-		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL)

-		rt_thread_startup(tid2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程3 */

-	tid3 = rt_thread_create("t3",

-		thread3_entry, RT_NULL, /* 线程入口是thread3_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);

-	if (tid3 != RT_NULL)

-		rt_thread_startup(tid3);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid1);

-	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid2);

-	if (tid3 != RT_NULL && tid3->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid3);

-

-	if (mutex != RT_NULL)

-	{

-		rt_mutex_delete(mutex);

-	}

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_mutex_simple()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	mutex_simple_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	mutex_simple_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid1 = RT_NULL;
+static rt_thread_t tid2 = RT_NULL;
+static rt_thread_t tid3 = RT_NULL;
+static rt_mutex_t mutex = RT_NULL;
+
+/* 线程1入口 */
+static void thread1_entry(void* parameter)
+{
+	/* 先让低优先级线程运行 */
+	rt_thread_delay(10);
+
+	/* 此时thread3持有mutex，并且thread2等待持有mutex */
+
+	/* 检查thread2与thread3的优先级情况 */
+	if (tid2->current_priority != tid3->current_priority)
+	{
+		/* 优先级不相同，测试失败 */
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return;
+	}
+}
+
+/* 线程2入口 */
+static void thread2_entry(void* parameter)
+{
+	rt_err_t result;
+
+	/* 先让低优先级线程运行 */
+	rt_thread_delay(5);
+
+	while (1)
+	{
+		/*
+		 * 试图持有互斥锁，此时thread3持有，应把thread3的优先级提升到thread2相同
+		 * 的优先级
+		 */
+		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
+
+		if (result == RT_EOK)
+		{
+			/* 释放互斥锁 */
+			rt_mutex_release(mutex);
+		}
+	}
+}
+
+/* 线程3入口 */
+static void thread3_entry(void* parameter)
+{
+	rt_tick_t tick;
+	rt_err_t result;
+
+	while (1)
+	{
+		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
+		result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
+		if (result != RT_EOK)
+		{
+			tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		}
+
+		/* 做一个长时间的循环，总共50个OS Tick */
+		tick = rt_tick_get();
+		while (rt_tick_get() - tick < 50) ;
+
+		rt_mutex_release(mutex);
+		rt_mutex_release(mutex);
+	}
+}
+
+int mutex_simple_init()
+{
+	/* 创建互斥锁 */
+	mutex = rt_mutex_create("mutex", RT_IPC_FLAG_FIFO);
+	if (mutex == RT_NULL)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return 0;
+	}
+
+	/* 创建线程1 */
+	tid1 = rt_thread_create("t1",
+		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL)
+		rt_thread_startup(tid1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	tid2 = rt_thread_create("t2",
+		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL)
+		rt_thread_startup(tid2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程3 */
+	tid3 = rt_thread_create("t3",
+		thread3_entry, RT_NULL, /* 线程入口是thread3_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+	if (tid3 != RT_NULL)
+		rt_thread_startup(tid3);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid1);
+	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid2);
+	if (tid3 != RT_NULL && tid3->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid3);
+
+	if (mutex != RT_NULL)
+	{
+		rt_mutex_delete(mutex);
+	}
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_mutex_simple()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	mutex_simple_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	mutex_simple_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/semaphore_buffer_worker.c b/examples/kernel/semaphore_buffer_worker.c
index af5722547a..6e5920dd6f 100644
--- a/examples/kernel/semaphore_buffer_worker.c
+++ b/examples/kernel/semaphore_buffer_worker.c
@@ -1,267 +1,267 @@
-/*

- * 程序清单：信号量实现生产者消费者间的互斥

- *

- * 在这个程序中，会创建两个线程，一个是生成者线程worker一个是消费者线程thread

- *

- * 在数据信息生产、消费的过程中，worker负责把数据将写入到环形buffer中，而thread

- * 则从环形buffer中读出。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 一个环形buffer的实现 */

-struct rb

-{

-	rt_uint16_t read_index, write_index;

-	rt_uint8_t *buffer_ptr;

-	rt_uint16_t buffer_size;

-};

-

-/* 指向信号量控制块的指针 */

-static rt_sem_t sem = RT_NULL;

-/* 指向线程控制块的指针 */

-static rt_thread_t tid = RT_NULL, worker = RT_NULL;

-

-/* 环形buffer的内存块（用数组体现出来） */

-#define BUFFER_SIZE		256

-#define BUFFER_ITEM		32

-static rt_uint8_t working_buffer[BUFFER_SIZE];

-struct rb working_rb;

-

-/* 初始化环形buffer，size指的是buffer的大小。注：这里并没对数据地址对齐做处理 */

-static void rb_init(struct rb* rb, rt_uint8_t *pool, rt_uint16_t size)

-{

-	RT_ASSERT(rb != RT_NULL);

-

-	/* 对读写指针清零*/

-	rb->read_index = rb->write_index = 0;

-

-	/* 设置环形buffer的内存数据块 */

-	rb->buffer_ptr = pool;

-	rb->buffer_size = size;

-}

-

-/* 向环形buffer中写入数据 */

-static rt_bool_t rb_put(struct rb* rb, const rt_uint8_t *ptr, rt_uint16_t length)

-{

-	rt_size_t size;

-

-	/* 判断是否有足够的剩余空间 */

-	if (rb->read_index > rb->write_index)

-		size = rb->read_index - rb->write_index;

-	else

-		size = rb->buffer_size - rb->write_index + rb->read_index;

-

-	/* 没有多余的空间 */

-	if (size < length) return RT_FALSE;

-

-	if (rb->read_index > rb->write_index)

-	{

-		/* read_index - write_index 即为总的空余空间 */

-		memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);

-		rb->write_index += length;

-	}

-	else

-	{

-		if (rb->buffer_size - rb->write_index > length)

-		{

-			/* write_index 后面剩余的空间有足够的长度 */

-			memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);

-			rb->write_index += length;

-		}

-		else

-		{

-			/*

-			 * write_index 后面剩余的空间不存在足够的长度，需要把部分数据复制到

-			 * 前面的剩余空间中

-			 */

-			memcpy(&rb->buffer_ptr[rb->write_index], ptr,

-				rb->buffer_size - rb->write_index);

-			memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - rb->write_index],

-				length - (rb->buffer_size - rb->write_index));

-			rb->write_index = length - (rb->buffer_size - rb->write_index);

-		}

-	}

-

-	return RT_TRUE;

-}

-

-/* 从环形buffer中读出数据 */

-static rt_bool_t rb_get(struct rb* rb, rt_uint8_t *ptr, rt_uint16_t length)

-{

-	rt_size_t size;

-

-	/* 判断是否有足够的数据 */

-	if (rb->read_index > rb->write_index)

-		size = rb->buffer_size - rb->read_index + rb->write_index;

-	else

-		size = rb->write_index - rb->read_index;

-

-	/* 没有足够的数据 */

-	if (size < length) return RT_FALSE;

-

-	if (rb->read_index > rb->write_index)

-	{

-		if (rb->buffer_size - rb->read_index > length)

-		{

-			/* read_index的数据足够多，直接复制 */

-			memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);

-			rb->read_index += length;

-		}

-		else

-		{

-			/* read_index的数据不够，需要分段复制 */

-			memcpy(ptr, &rb->buffer_ptr[rb->read_index],

-				rb->buffer_size - rb->read_index);

-			memcpy(&ptr[rb->buffer_size - rb->read_index], &rb->buffer_ptr[0],

-				length - rb->buffer_size + rb->read_index);

-			rb->read_index = length - rb->buffer_size + rb->read_index;

-		}

-	}

-	else

-	{

-		/*

-		 * read_index要比write_index小，总的数据量够（前面已经有总数据量的判

-		 * 断），直接复制出数据。

-		 */

-		memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);

-		rb->read_index += length;

-	}

-

-	return RT_TRUE;

-}

-

-/* 生产者线程入口 */

-static void thread_entry(void* parameter)

-{

-	rt_bool_t result;

-	rt_uint8_t data_buffer[BUFFER_ITEM + 1];

-

-	while (1)

-	{

-		/* 持有信号量 */

-		rt_sem_take(sem, RT_WAITING_FOREVER);

-		/* 从环buffer中获得数据 */

-		result = rb_get(&working_rb, &data_buffer[0], BUFFER_ITEM);

-		/* 释放信号量 */

-		rt_sem_release(sem);

-		data_buffer[BUFFER_ITEM] = '\0';

-

-		if (result == RT_TRUE)

-		{

-			/* 获取数据成功，打印数据 */

-			rt_kprintf("%s\n", data_buffer);

-		}

-

-		/* 做一个5 OS Tick的休眠 */

-		rt_thread_delay(5);

-	}

-}

-

-/* worker线程入口 */

-static void worker_entry(void* parameter)

-{

-	rt_bool_t result;

-	rt_uint32_t index, setchar;

-	rt_uint8_t  data_buffer[BUFFER_ITEM];

-

-	setchar = 0x21;

-	while (1)

-	{

-		/* 构造数据 */

-		for(index = 0; index < BUFFER_ITEM; index++)

-		{

-			data_buffer[index] = setchar;

-			if (++setchar == 0x7f)

-				setchar = 0x21;

-		}

-

-		/* 持有信号量 */

-		rt_sem_take(sem, RT_WAITING_FOREVER);

-		/* 把数据放到环形buffer中 */

-		result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM);

-		/* 释放信号量 */

-		rt_sem_release(sem);

-

-		/* 放入成功，做一个10 OS Tick的休眠 */

-		rt_thread_delay(10);

-	}

-}

-

-int semaphore_buffer_worker_init()

-{

-	/* 初始化ring buffer */

-	rb_init(&working_rb, working_buffer, BUFFER_SIZE);

-

-	/* 创建信号量 */

-	sem = rt_sem_create("sem", 1, RT_IPC_FLAG_FIFO);

-	if (sem == RT_NULL)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return 0;

-	}

-

-	/* 创建线程1 */

-	tid = rt_thread_create("thread",

-		thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid != RT_NULL)

-		rt_thread_startup(tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	worker = rt_thread_create("worker",

-		worker_entry, RT_NULL, /* 线程入口是worker_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (worker != RT_NULL)

-		rt_thread_startup(worker);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除信号量 */

-	if (sem != RT_NULL)

-		rt_sem_delete(sem);

-

-	/* 删除线程 */

-	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid);

-	if (worker != RT_NULL && worker->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(worker);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_semaphore_buffer_worker()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	semaphore_buffer_worker_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphore example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	semaphore_buffer_worker_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：信号量实现生产者消费者间的互斥
+ *
+ * 在这个程序中，会创建两个线程，一个是生成者线程worker一个是消费者线程thread
+ *
+ * 在数据信息生产、消费的过程中，worker负责把数据将写入到环形buffer中，而thread
+ * 则从环形buffer中读出。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 一个环形buffer的实现 */
+struct rb
+{
+	rt_uint16_t read_index, write_index;
+	rt_uint8_t *buffer_ptr;
+	rt_uint16_t buffer_size;
+};
+
+/* 指向信号量控制块的指针 */
+static rt_sem_t sem = RT_NULL;
+/* 指向线程控制块的指针 */
+static rt_thread_t tid = RT_NULL, worker = RT_NULL;
+
+/* 环形buffer的内存块（用数组体现出来） */
+#define BUFFER_SIZE		256
+#define BUFFER_ITEM		32
+static rt_uint8_t working_buffer[BUFFER_SIZE];
+struct rb working_rb;
+
+/* 初始化环形buffer，size指的是buffer的大小。注：这里并没对数据地址对齐做处理 */
+static void rb_init(struct rb* rb, rt_uint8_t *pool, rt_uint16_t size)
+{
+	RT_ASSERT(rb != RT_NULL);
+
+	/* 对读写指针清零*/
+	rb->read_index = rb->write_index = 0;
+
+	/* 设置环形buffer的内存数据块 */
+	rb->buffer_ptr = pool;
+	rb->buffer_size = size;
+}
+
+/* 向环形buffer中写入数据 */
+static rt_bool_t rb_put(struct rb* rb, const rt_uint8_t *ptr, rt_uint16_t length)
+{
+	rt_size_t size;
+
+	/* 判断是否有足够的剩余空间 */
+	if (rb->read_index > rb->write_index)
+		size = rb->read_index - rb->write_index;
+	else
+		size = rb->buffer_size - rb->write_index + rb->read_index;
+
+	/* 没有多余的空间 */
+	if (size < length) return RT_FALSE;
+
+	if (rb->read_index > rb->write_index)
+	{
+		/* read_index - write_index 即为总的空余空间 */
+		memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
+		rb->write_index += length;
+	}
+	else
+	{
+		if (rb->buffer_size - rb->write_index > length)
+		{
+			/* write_index 后面剩余的空间有足够的长度 */
+			memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
+			rb->write_index += length;
+		}
+		else
+		{
+			/*
+			 * write_index 后面剩余的空间不存在足够的长度，需要把部分数据复制到
+			 * 前面的剩余空间中
+			 */
+			memcpy(&rb->buffer_ptr[rb->write_index], ptr,
+				rb->buffer_size - rb->write_index);
+			memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - rb->write_index],
+				length - (rb->buffer_size - rb->write_index));
+			rb->write_index = length - (rb->buffer_size - rb->write_index);
+		}
+	}
+
+	return RT_TRUE;
+}
+
+/* 从环形buffer中读出数据 */
+static rt_bool_t rb_get(struct rb* rb, rt_uint8_t *ptr, rt_uint16_t length)
+{
+	rt_size_t size;
+
+	/* 判断是否有足够的数据 */
+	if (rb->read_index > rb->write_index)
+		size = rb->buffer_size - rb->read_index + rb->write_index;
+	else
+		size = rb->write_index - rb->read_index;
+
+	/* 没有足够的数据 */
+	if (size < length) return RT_FALSE;
+
+	if (rb->read_index > rb->write_index)
+	{
+		if (rb->buffer_size - rb->read_index > length)
+		{
+			/* read_index的数据足够多，直接复制 */
+			memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
+			rb->read_index += length;
+		}
+		else
+		{
+			/* read_index的数据不够，需要分段复制 */
+			memcpy(ptr, &rb->buffer_ptr[rb->read_index],
+				rb->buffer_size - rb->read_index);
+			memcpy(&ptr[rb->buffer_size - rb->read_index], &rb->buffer_ptr[0],
+				length - rb->buffer_size + rb->read_index);
+			rb->read_index = length - rb->buffer_size + rb->read_index;
+		}
+	}
+	else
+	{
+		/*
+		 * read_index要比write_index小，总的数据量够（前面已经有总数据量的判
+		 * 断），直接复制出数据。
+		 */
+		memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
+		rb->read_index += length;
+	}
+
+	return RT_TRUE;
+}
+
+/* 生产者线程入口 */
+static void thread_entry(void* parameter)
+{
+	rt_bool_t result;
+	rt_uint8_t data_buffer[BUFFER_ITEM + 1];
+
+	while (1)
+	{
+		/* 持有信号量 */
+		rt_sem_take(sem, RT_WAITING_FOREVER);
+		/* 从环buffer中获得数据 */
+		result = rb_get(&working_rb, &data_buffer[0], BUFFER_ITEM);
+		/* 释放信号量 */
+		rt_sem_release(sem);
+		data_buffer[BUFFER_ITEM] = '\0';
+
+		if (result == RT_TRUE)
+		{
+			/* 获取数据成功，打印数据 */
+			rt_kprintf("%s\n", data_buffer);
+		}
+
+		/* 做一个5 OS Tick的休眠 */
+		rt_thread_delay(5);
+	}
+}
+
+/* worker线程入口 */
+static void worker_entry(void* parameter)
+{
+	rt_bool_t result;
+	rt_uint32_t index, setchar;
+	rt_uint8_t  data_buffer[BUFFER_ITEM];
+
+	setchar = 0x21;
+	while (1)
+	{
+		/* 构造数据 */
+		for(index = 0; index < BUFFER_ITEM; index++)
+		{
+			data_buffer[index] = setchar;
+			if (++setchar == 0x7f)
+				setchar = 0x21;
+		}
+
+		/* 持有信号量 */
+		rt_sem_take(sem, RT_WAITING_FOREVER);
+		/* 把数据放到环形buffer中 */
+		result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM);
+		/* 释放信号量 */
+		rt_sem_release(sem);
+
+		/* 放入成功，做一个10 OS Tick的休眠 */
+		rt_thread_delay(10);
+	}
+}
+
+int semaphore_buffer_worker_init()
+{
+	/* 初始化ring buffer */
+	rb_init(&working_rb, working_buffer, BUFFER_SIZE);
+
+	/* 创建信号量 */
+	sem = rt_sem_create("sem", 1, RT_IPC_FLAG_FIFO);
+	if (sem == RT_NULL)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return 0;
+	}
+
+	/* 创建线程1 */
+	tid = rt_thread_create("thread",
+		thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid != RT_NULL)
+		rt_thread_startup(tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	worker = rt_thread_create("worker",
+		worker_entry, RT_NULL, /* 线程入口是worker_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (worker != RT_NULL)
+		rt_thread_startup(worker);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除信号量 */
+	if (sem != RT_NULL)
+		rt_sem_delete(sem);
+
+	/* 删除线程 */
+	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid);
+	if (worker != RT_NULL && worker->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(worker);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_semaphore_buffer_worker()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	semaphore_buffer_worker_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphore example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	semaphore_buffer_worker_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/semaphore_dynamic.c b/examples/kernel/semaphore_dynamic.c
index bea4060e38..7f2c2ffd42 100644
--- a/examples/kernel/semaphore_dynamic.c
+++ b/examples/kernel/semaphore_dynamic.c
@@ -1,128 +1,128 @@
-/*

- * 程序清单：动态信号量

- *

- * 这个例子中将创建一个动态信号量（初始值为0 ）及一个动态线程，在这个动态线程中

- * 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并

- * 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid = RT_NULL;

-/* 指向信号量的指针 */

-static rt_sem_t sem = RT_NULL;

-/* 线程入口 */

-static void thread_entry(void* parameter)

-{

-	rt_err_t result;

-	rt_tick_t tick;

-

-	/* 获得当前的OS Tick */

-	tick = rt_tick_get();

-

-	/* 试图持有一个信号量，如果10个OS Tick依然没拿到，则超时返回 */

-	result = rt_sem_take(sem, 10);

-	if (result == -RT_ETIMEOUT)

-	{

-		/* 判断是否刚好过去10个OS Tick */

-		if (rt_tick_get() - tick != 10)

-		{

-			/* 如果失败，则测试失败 */

-			tc_done(TC_STAT_FAILED);

-			rt_sem_delete(sem);

-			return;

-		}

-		rt_kprintf("take semaphore timeout\n");

-	}

-	else

-	{

-		/* 因为并没释放信号量，应该是超时返回，否则测试失败 */

-		tc_done(TC_STAT_FAILED);

-		rt_sem_delete(sem);

-		return;

-	}

-

-	/* 释放一次信号量 */

-	rt_sem_release(sem);

-

-	/* 继续持有信号量，并永远等待直到持有到信号量 */

-	result = rt_sem_take(sem, RT_WAITING_FOREVER);

-	if (result != RT_EOK)

-	{

-		/* 返回不正确，测试失败 */

-		tc_done(TC_STAT_FAILED);

-		rt_sem_delete(sem);

-		return;

-	}

-

-	/* 测试成功 */

-	tc_done(TC_STAT_PASSED);

-	/* 删除信号量 */

-	rt_sem_delete(sem);

-}

-

-int semaphore_dynamic_init()

-{

-	/* 创建一个信号量，初始值是0 */

-	sem = rt_sem_create("sem", 0, RT_IPC_FLAG_FIFO);

-	if (sem == RT_NULL)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return 0;

-	}

-

-	/* 创建线程 */

-	tid = rt_thread_create("thread",

-		thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid != RT_NULL)

-		rt_thread_startup(tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)

-	{

-		rt_thread_delete(tid);

-

-		/* 删除信号量 */

-		rt_sem_delete(sem);

-	}

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_semaphore_dynamic()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	semaphore_dynamic_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	semaphore_dynamic_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：动态信号量
+ *
+ * 这个例子中将创建一个动态信号量（初始值为0 ）及一个动态线程，在这个动态线程中
+ * 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并
+ * 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid = RT_NULL;
+/* 指向信号量的指针 */
+static rt_sem_t sem = RT_NULL;
+/* 线程入口 */
+static void thread_entry(void* parameter)
+{
+	rt_err_t result;
+	rt_tick_t tick;
+
+	/* 获得当前的OS Tick */
+	tick = rt_tick_get();
+
+	/* 试图持有一个信号量，如果10个OS Tick依然没拿到，则超时返回 */
+	result = rt_sem_take(sem, 10);
+	if (result == -RT_ETIMEOUT)
+	{
+		/* 判断是否刚好过去10个OS Tick */
+		if (rt_tick_get() - tick != 10)
+		{
+			/* 如果失败，则测试失败 */
+			tc_done(TC_STAT_FAILED);
+			rt_sem_delete(sem);
+			return;
+		}
+		rt_kprintf("take semaphore timeout\n");
+	}
+	else
+	{
+		/* 因为并没释放信号量，应该是超时返回，否则测试失败 */
+		tc_done(TC_STAT_FAILED);
+		rt_sem_delete(sem);
+		return;
+	}
+
+	/* 释放一次信号量 */
+	rt_sem_release(sem);
+
+	/* 继续持有信号量，并永远等待直到持有到信号量 */
+	result = rt_sem_take(sem, RT_WAITING_FOREVER);
+	if (result != RT_EOK)
+	{
+		/* 返回不正确，测试失败 */
+		tc_done(TC_STAT_FAILED);
+		rt_sem_delete(sem);
+		return;
+	}
+
+	/* 测试成功 */
+	tc_done(TC_STAT_PASSED);
+	/* 删除信号量 */
+	rt_sem_delete(sem);
+}
+
+int semaphore_dynamic_init()
+{
+	/* 创建一个信号量，初始值是0 */
+	sem = rt_sem_create("sem", 0, RT_IPC_FLAG_FIFO);
+	if (sem == RT_NULL)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return 0;
+	}
+
+	/* 创建线程 */
+	tid = rt_thread_create("thread",
+		thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid != RT_NULL)
+		rt_thread_startup(tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
+	{
+		rt_thread_delete(tid);
+
+		/* 删除信号量 */
+		rt_sem_delete(sem);
+	}
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_semaphore_dynamic()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	semaphore_dynamic_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	semaphore_dynamic_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/semaphore_priority.c b/examples/kernel/semaphore_priority.c
index 4ee8d889e3..c106a25d5e 100644
--- a/examples/kernel/semaphore_priority.c
+++ b/examples/kernel/semaphore_priority.c
@@ -1,128 +1,128 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-static rt_sem_t sem;

-static rt_uint8_t t1_count, t2_count;

-static rt_thread_t t1, t2, worker;

-static void thread1_entry(void* parameter)

-{

-	rt_err_t result;

-

-	while (1)

-	{

-		result = rt_sem_take(sem, RT_WAITING_FOREVER);

-		if (result != RT_EOK)

-		{

-			tc_done(TC_STAT_FAILED);

-			return;

-		}

-

-		t1_count ++;

-		rt_kprintf("thread1: got semaphore, count: %d\n", t1_count);

-	}

-}

-

-static void thread2_entry(void* parameter)

-{

-	rt_err_t result;

-

-	while (1)

-	{

-		result = rt_sem_take(sem, RT_WAITING_FOREVER);

-		if (result != RT_EOK)

-		{

-			tc_done(TC_STAT_FAILED);

-			return;

-		}

-

-		t2_count ++;

-		rt_kprintf("thread2: got semaphore, count: %d\n", t2_count);

-	}

-}

-

-static void worker_thread_entry(void* parameter)

-{

-	rt_thread_delay(10);

-

-	while (1)

-	{

-		rt_sem_release(sem);

-		rt_thread_delay(5);

-	}

-}

-

-int semaphore_priority_init()

-{

-	sem = rt_sem_create("sem", 0, RT_IPC_FLAG_PRIO);

-	if (sem == RT_NULL)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return 0;

-	}

-

-	t1_count = t2_count = 0;

-

-	t1 = rt_thread_create("t1",

-		thread1_entry, RT_NULL,

-		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);

-	if (t1 != RT_NULL)

-		rt_thread_startup(t1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	t2 = rt_thread_create("t2",

-		thread2_entry, RT_NULL,

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (t2 != RT_NULL)

-		rt_thread_startup(t2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	worker = rt_thread_create("worker",

-		worker_thread_entry, RT_NULL,

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (worker != RT_NULL)

-		rt_thread_startup(worker);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* lock scheduler */

-	rt_enter_critical();

-

-	/* delete t1, t2 and worker thread */

-	rt_thread_delete(t1);

-	rt_thread_delete(t2);

-	rt_thread_delete(worker);

-

-	if (t1_count > t2_count)

-		tc_done(TC_STAT_FAILED);

-	else

-		tc_done(TC_STAT_PASSED);

-

-	/* unlock scheduler */

-	rt_exit_critical();

-}

-

-int _tc_semaphore_priority()

-{

-	/* set tc cleanup */

-	tc_cleanup(_tc_cleanup);

-	semaphore_priority_init();

-

-	return 50;

-}

-FINSH_FUNCTION_EXPORT(_tc_semaphore_priority, a priority semaphore test);

-#else

-int rt_application_init()

-{

-	semaphore_priority_init();

-

-	return 0;

-}

-#endif

+#include <rtthread.h>
+#include "tc_comm.h"
+
+static rt_sem_t sem;
+static rt_uint8_t t1_count, t2_count;
+static rt_thread_t t1, t2, worker;
+static void thread1_entry(void* parameter)
+{
+	rt_err_t result;
+
+	while (1)
+	{
+		result = rt_sem_take(sem, RT_WAITING_FOREVER);
+		if (result != RT_EOK)
+		{
+			tc_done(TC_STAT_FAILED);
+			return;
+		}
+
+		t1_count ++;
+		rt_kprintf("thread1: got semaphore, count: %d\n", t1_count);
+	}
+}
+
+static void thread2_entry(void* parameter)
+{
+	rt_err_t result;
+
+	while (1)
+	{
+		result = rt_sem_take(sem, RT_WAITING_FOREVER);
+		if (result != RT_EOK)
+		{
+			tc_done(TC_STAT_FAILED);
+			return;
+		}
+
+		t2_count ++;
+		rt_kprintf("thread2: got semaphore, count: %d\n", t2_count);
+	}
+}
+
+static void worker_thread_entry(void* parameter)
+{
+	rt_thread_delay(10);
+
+	while (1)
+	{
+		rt_sem_release(sem);
+		rt_thread_delay(5);
+	}
+}
+
+int semaphore_priority_init()
+{
+	sem = rt_sem_create("sem", 0, RT_IPC_FLAG_PRIO);
+	if (sem == RT_NULL)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return 0;
+	}
+
+	t1_count = t2_count = 0;
+
+	t1 = rt_thread_create("t1",
+		thread1_entry, RT_NULL,
+		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+	if (t1 != RT_NULL)
+		rt_thread_startup(t1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	t2 = rt_thread_create("t2",
+		thread2_entry, RT_NULL,
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (t2 != RT_NULL)
+		rt_thread_startup(t2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	worker = rt_thread_create("worker",
+		worker_thread_entry, RT_NULL,
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (worker != RT_NULL)
+		rt_thread_startup(worker);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* lock scheduler */
+	rt_enter_critical();
+
+	/* delete t1, t2 and worker thread */
+	rt_thread_delete(t1);
+	rt_thread_delete(t2);
+	rt_thread_delete(worker);
+
+	if (t1_count > t2_count)
+		tc_done(TC_STAT_FAILED);
+	else
+		tc_done(TC_STAT_PASSED);
+
+	/* unlock scheduler */
+	rt_exit_critical();
+}
+
+int _tc_semaphore_priority()
+{
+	/* set tc cleanup */
+	tc_cleanup(_tc_cleanup);
+	semaphore_priority_init();
+
+	return 50;
+}
+FINSH_FUNCTION_EXPORT(_tc_semaphore_priority, a priority semaphore test);
+#else
+int rt_application_init()
+{
+	semaphore_priority_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/semaphore_producer_consumer.c b/examples/kernel/semaphore_producer_consumer.c
index f85acc3b70..ec0bf2234c 100644
--- a/examples/kernel/semaphore_producer_consumer.c
+++ b/examples/kernel/semaphore_producer_consumer.c
@@ -1,154 +1,154 @@
-/*

- * 程序清单：生产者消费者例子

- *

- * 这个例子中将创建两个线程用于实现生产者消费者问题

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 定义最大5个元素能够被产生 */

-#define MAXSEM 5

-

-/* 用于放置生产的整数数组 */

-rt_uint32_t array[MAXSEM];

-/* 指向生产者、消费者在array数组中的读写位置 */

-static rt_uint32_t set, get;

-

-/* 指向线程控制块的指针 */

-static rt_thread_t producer_tid = RT_NULL;

-static rt_thread_t consumer_tid = RT_NULL;

-

-struct rt_semaphore sem_lock;

-struct rt_semaphore sem_empty, sem_full;

-

-/* 生成者线程入口 */

-void producer_thread_entry(void* parameter)

-{

-	int cnt = 0;

-

-	/* 运行100次 */

-	while( cnt < 100)

-	{

-		/* 获取一个空位 */

-		rt_sem_take(&sem_empty, RT_WAITING_FOREVER);

-

-		/* 修改array内容，上锁 */

-		rt_sem_take(&sem_lock, RT_WAITING_FOREVER);

-		array[set%MAXSEM] = cnt + 1;

-		rt_kprintf("the producer generates a number: %d\n", array[set%MAXSEM]);

-		set++;

-		rt_sem_release(&sem_lock);

-

-		/* 发布一个满位 */

-		rt_sem_release(&sem_full);

-		cnt++;

-

-		/* 暂停一段时间 */

-		rt_thread_delay(50);

-	}

-

-	rt_kprintf("the producer exit!\n");

-}

-

-/* 消费者线程入口 */

-void consumer_thread_entry(void* parameter)

-{

-	rt_uint32_t no;

-	rt_uint32_t sum;

-

-	/* 第n个线程，由入口参数传进来 */

-	no = (rt_uint32_t)parameter;

-

-	while(1)

-	{

-		/* 获取一个满位 */

-		rt_sem_take(&sem_full, RT_WAITING_FOREVER);

-

-		/* 临界区，上锁进行操作 */

-		rt_sem_take(&sem_lock, RT_WAITING_FOREVER);

-		sum += array[get%MAXSEM];

-		rt_kprintf("the consumer[%d] get a number: %d\n", no, array[get%MAXSEM] );

-		get++;

-		rt_sem_release(&sem_lock);

-

-		/* 释放一个空位 */

-		rt_sem_release(&sem_empty);

-

-		/* 生产者生产到100个数目，停止，消费者线程相应停止 */

-		if (get == 100) break;

-

-		/* 暂停一小会时间 */

-		rt_thread_delay(10);

-	}

-

-	rt_kprintf("the consumer[%d] sum is %d \n ", no, sum);

-	rt_kprintf("the consumer[%d] exit!\n");

-}

-

-int semaphore_producer_consumer_init()

-{

-	/* 初始化3个信号量 */

-	rt_sem_init(&sem_lock , "lock",     1,      RT_IPC_FLAG_FIFO);

-	rt_sem_init(&sem_empty, "empty",    MAXSEM, RT_IPC_FLAG_FIFO);

-	rt_sem_init(&sem_full , "full",     0,      RT_IPC_FLAG_FIFO);

-

-	/* 创建线程1 */

-	producer_tid = rt_thread_create("producer",

-		producer_thread_entry, RT_NULL, /* 线程入口是producer_thread_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (producer_tid != RT_NULL)

-		rt_thread_startup(producer_tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	consumer_tid = rt_thread_create("consumer",

-		consumer_thread_entry, RT_NULL, /* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);

-	if (consumer_tid != RT_NULL)

-		rt_thread_startup(consumer_tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (producer_tid != RT_NULL && producer_tid->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(producer_tid);

-	if (consumer_tid != RT_NULL && consumer_tid->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(consumer_tid);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_semaphore_producer_consumer()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	semaphore_producer_consumer_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	semaphore_producer_consumer_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：生产者消费者例子
+ *
+ * 这个例子中将创建两个线程用于实现生产者消费者问题
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 定义最大5个元素能够被产生 */
+#define MAXSEM 5
+
+/* 用于放置生产的整数数组 */
+rt_uint32_t array[MAXSEM];
+/* 指向生产者、消费者在array数组中的读写位置 */
+static rt_uint32_t set, get;
+
+/* 指向线程控制块的指针 */
+static rt_thread_t producer_tid = RT_NULL;
+static rt_thread_t consumer_tid = RT_NULL;
+
+struct rt_semaphore sem_lock;
+struct rt_semaphore sem_empty, sem_full;
+
+/* 生成者线程入口 */
+void producer_thread_entry(void* parameter)
+{
+	int cnt = 0;
+
+	/* 运行100次 */
+	while( cnt < 100)
+	{
+		/* 获取一个空位 */
+		rt_sem_take(&sem_empty, RT_WAITING_FOREVER);
+
+		/* 修改array内容，上锁 */
+		rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
+		array[set%MAXSEM] = cnt + 1;
+		rt_kprintf("the producer generates a number: %d\n", array[set%MAXSEM]);
+		set++;
+		rt_sem_release(&sem_lock);
+
+		/* 发布一个满位 */
+		rt_sem_release(&sem_full);
+		cnt++;
+
+		/* 暂停一段时间 */
+		rt_thread_delay(50);
+	}
+
+	rt_kprintf("the producer exit!\n");
+}
+
+/* 消费者线程入口 */
+void consumer_thread_entry(void* parameter)
+{
+	rt_uint32_t no;
+	rt_uint32_t sum;
+
+	/* 第n个线程，由入口参数传进来 */
+	no = (rt_uint32_t)parameter;
+
+	while(1)
+	{
+		/* 获取一个满位 */
+		rt_sem_take(&sem_full, RT_WAITING_FOREVER);
+
+		/* 临界区，上锁进行操作 */
+		rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
+		sum += array[get%MAXSEM];
+		rt_kprintf("the consumer[%d] get a number: %d\n", no, array[get%MAXSEM] );
+		get++;
+		rt_sem_release(&sem_lock);
+
+		/* 释放一个空位 */
+		rt_sem_release(&sem_empty);
+
+		/* 生产者生产到100个数目，停止，消费者线程相应停止 */
+		if (get == 100) break;
+
+		/* 暂停一小会时间 */
+		rt_thread_delay(10);
+	}
+
+	rt_kprintf("the consumer[%d] sum is %d \n ", no, sum);
+	rt_kprintf("the consumer[%d] exit!\n");
+}
+
+int semaphore_producer_consumer_init()
+{
+	/* 初始化3个信号量 */
+	rt_sem_init(&sem_lock , "lock",     1,      RT_IPC_FLAG_FIFO);
+	rt_sem_init(&sem_empty, "empty",    MAXSEM, RT_IPC_FLAG_FIFO);
+	rt_sem_init(&sem_full , "full",     0,      RT_IPC_FLAG_FIFO);
+
+	/* 创建线程1 */
+	producer_tid = rt_thread_create("producer",
+		producer_thread_entry, RT_NULL, /* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (producer_tid != RT_NULL)
+		rt_thread_startup(producer_tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	consumer_tid = rt_thread_create("consumer",
+		consumer_thread_entry, RT_NULL, /* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+	if (consumer_tid != RT_NULL)
+		rt_thread_startup(consumer_tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (producer_tid != RT_NULL && producer_tid->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(producer_tid);
+	if (consumer_tid != RT_NULL && consumer_tid->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(consumer_tid);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_semaphore_producer_consumer()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	semaphore_producer_consumer_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	semaphore_producer_consumer_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/semaphore_static.c b/examples/kernel/semaphore_static.c
index 717ff25c57..167b5e9055 100644
--- a/examples/kernel/semaphore_static.c
+++ b/examples/kernel/semaphore_static.c
@@ -1,132 +1,132 @@
-/*

- * 程序清单：静态信号量

- *

- * 这个例子中将创建一个静态信号量（初始值为0 ）及一个静态线程，在这个静态线程中

- * 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并

- * 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 线程控制块及栈 */

-static struct rt_thread thread;

-static rt_uint8_t thread_stack[THREAD_STACK_SIZE];

-/* 信号量控制块 */

-static struct rt_semaphore sem;

-

-/* 线程入口 */

-static void thread_entry(void* parameter)

-{

-	rt_err_t result;

-	rt_tick_t tick;

-

-	/* 获得当前的OS Tick */

-	tick = rt_tick_get();

-

-	/* 试图持有信号量，最大等待10个OS Tick后返回 */

-	result = rt_sem_take(&sem, 10);

-	if (result == -RT_ETIMEOUT)

-	{

-		/* 超时后判断是否刚好是10个OS Tick */

-		if (rt_tick_get() - tick != 10)

-		{

-			tc_done(TC_STAT_FAILED);

-			rt_sem_detach(&sem);

-			return;

-		}

-		rt_kprintf("take semaphore timeout\n");

-	}

-	else

-	{

-		/* 因为没有其他地方是否信号量，所以不应该成功持有信号量，否则测试失败 */

-		tc_done(TC_STAT_FAILED);

-		rt_sem_detach(&sem);

-		return;

-	}

-

-	/* 释放一次信号量 */

-	rt_sem_release(&sem);

-

-	/* 永久等待方式持有信号量 */

-	result = rt_sem_take(&sem, RT_WAITING_FOREVER);

-	if (result != RT_EOK)

-	{

-		/* 不成功则测试失败 */

-		tc_done(TC_STAT_FAILED);

-		rt_sem_detach(&sem);

-		return;

-	}

-

-	/* 测试通过 */

-	tc_done(TC_STAT_PASSED);

-	/* 脱离信号量对象 */

-	rt_sem_detach(&sem);

-}

-

-int semaphore_static_init()

-{

-	rt_err_t result;

-

-	/* 初始化信号量，初始值是0 */

-	result = rt_sem_init(&sem, "sem", 0, RT_IPC_FLAG_FIFO);

-	if (result != RT_EOK)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return 0;

-	}

-

-	/* 初始化线程1 */

-	result = rt_thread_init(&thread, "thread", /* 线程名：thread */

-		thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是RT_NULL*/

-		&thread_stack[0], sizeof(thread_stack), /* 线程栈是thread_stack */

-		THREAD_PRIORITY, 10);

-	if (result == RT_EOK) /* 如果返回正确，启动线程1 */

-		rt_thread_startup(&thread);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 执行线程脱离 */

-	if (thread.stat != RT_THREAD_CLOSE)

-	{

-		rt_thread_detach(&thread);

-

-		/* 执行信号量对象脱离 */

-		rt_sem_detach(&sem);

-	}

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_semaphore_static()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	semaphore_static_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_static_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：静态信号量
+ *
+ * 这个例子中将创建一个静态信号量（初始值为0 ）及一个静态线程，在这个静态线程中
+ * 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并
+ * 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 线程控制块及栈 */
+static struct rt_thread thread;
+static rt_uint8_t thread_stack[THREAD_STACK_SIZE];
+/* 信号量控制块 */
+static struct rt_semaphore sem;
+
+/* 线程入口 */
+static void thread_entry(void* parameter)
+{
+	rt_err_t result;
+	rt_tick_t tick;
+
+	/* 获得当前的OS Tick */
+	tick = rt_tick_get();
+
+	/* 试图持有信号量，最大等待10个OS Tick后返回 */
+	result = rt_sem_take(&sem, 10);
+	if (result == -RT_ETIMEOUT)
+	{
+		/* 超时后判断是否刚好是10个OS Tick */
+		if (rt_tick_get() - tick != 10)
+		{
+			tc_done(TC_STAT_FAILED);
+			rt_sem_detach(&sem);
+			return;
+		}
+		rt_kprintf("take semaphore timeout\n");
+	}
+	else
+	{
+		/* 因为没有其他地方是否信号量，所以不应该成功持有信号量，否则测试失败 */
+		tc_done(TC_STAT_FAILED);
+		rt_sem_detach(&sem);
+		return;
+	}
+
+	/* 释放一次信号量 */
+	rt_sem_release(&sem);
+
+	/* 永久等待方式持有信号量 */
+	result = rt_sem_take(&sem, RT_WAITING_FOREVER);
+	if (result != RT_EOK)
+	{
+		/* 不成功则测试失败 */
+		tc_done(TC_STAT_FAILED);
+		rt_sem_detach(&sem);
+		return;
+	}
+
+	/* 测试通过 */
+	tc_done(TC_STAT_PASSED);
+	/* 脱离信号量对象 */
+	rt_sem_detach(&sem);
+}
+
+int semaphore_static_init()
+{
+	rt_err_t result;
+
+	/* 初始化信号量，初始值是0 */
+	result = rt_sem_init(&sem, "sem", 0, RT_IPC_FLAG_FIFO);
+	if (result != RT_EOK)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return 0;
+	}
+
+	/* 初始化线程1 */
+	result = rt_thread_init(&thread, "thread", /* 线程名：thread */
+		thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是RT_NULL*/
+		&thread_stack[0], sizeof(thread_stack), /* 线程栈是thread_stack */
+		THREAD_PRIORITY, 10);
+	if (result == RT_EOK) /* 如果返回正确，启动线程1 */
+		rt_thread_startup(&thread);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 执行线程脱离 */
+	if (thread.stat != RT_THREAD_CLOSE)
+	{
+		rt_thread_detach(&thread);
+
+		/* 执行信号量对象脱离 */
+		rt_sem_detach(&sem);
+	}
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_semaphore_static()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	semaphore_static_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_static_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/tc_comm.c b/examples/kernel/tc_comm.c
index 1ec48f5398..60d843171f 100644
--- a/examples/kernel/tc_comm.c
+++ b/examples/kernel/tc_comm.c
@@ -1,176 +1,176 @@
-#include "tc_comm.h"

-#ifdef RT_USING_FINSH

-#include <finsh.h>

-#endif

-

-#ifdef RT_USING_TC

-#define TC_PRIORITY		25

-#define TC_STACK_SIZE	0x400

-

-static rt_uint8_t _tc_stat;

-static struct rt_semaphore _tc_sem;

-static struct rt_thread _tc_thread;

-static rt_uint8_t _tc_stack[TC_STACK_SIZE];

-static char _tc_prefix[64];

-static const char* _tc_current;

-static void (*_tc_cleanup)(void) = RT_NULL;

-

-static rt_uint32_t _tc_scale = 1;

-FINSH_VAR_EXPORT(_tc_scale, finsh_type_int, the testcase timer timeout scale)

-

-void tc_thread_entry(void* parameter)

-{

-	struct finsh_syscall* index;

-

-	/* create tc semaphore */

-	rt_sem_init(&_tc_sem, "tc", 0, RT_IPC_FLAG_FIFO);

-

-	while (_tc_stat & TC_STAT_RUNNING)

-	{

-		for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))

-		{

-			/* search testcase */

-			if (rt_strstr(index->name, _tc_prefix) == index->name)

-			{

-				long tick;

-

-				_tc_current = index->name + 4;

-				rt_kprintf("Run TestCase: %s\n", _tc_current);

-				_tc_stat = TC_STAT_PASSED | TC_STAT_RUNNING;

-				tick = index->func();

-				if (tick > 0)

-				{

-					rt_sem_take(&_tc_sem, tick * _tc_scale);

-

-					if (_tc_cleanup != RT_NULL)

-					{

-						/* perform testcase cleanup */

-						_tc_cleanup();

-						_tc_cleanup = RT_NULL;

-					}

-

-					rt_sem_trytake(&_tc_sem);/* by nl1031 */

-

-					if (_tc_stat & TC_STAT_FAILED)

-						rt_kprintf("TestCase[%s] failed\n", _tc_current);

-					else

-						rt_kprintf("TestCase[%s] passed\n", _tc_current);

-				}

-				else

-				{

-					if (_tc_cleanup != RT_NULL)

-					{

-						/* perform testcase cleanup */

-						_tc_cleanup();

-						_tc_cleanup = RT_NULL;

-					}

-				}

-			}

-		}

-	}

-

-	rt_kprintf("RT-Thread TestCase Running Done!\n");

-	/* detach tc semaphore */

-	rt_sem_detach(&_tc_sem);

-}

-

-void tc_stop()

-{

-	_tc_stat &= ~TC_STAT_RUNNING;

-

-	rt_thread_delay(RT_TICK_PER_SECOND/2);

-	if (_tc_thread.stat != RT_THREAD_INIT)

-	{

-		/* lock scheduler */

-		rt_enter_critical();

-

-		/* detach old tc thread */

-		rt_thread_detach(&_tc_thread);

-		rt_sem_detach(&_tc_sem);

-

-		/* unlock scheduler */

-		rt_exit_critical();

-	}

-	rt_thread_delay(RT_TICK_PER_SECOND/2);

-}

-FINSH_FUNCTION_EXPORT(tc_stop, stop testcase thread);

-

-void tc_done(rt_uint8_t stat)

-{

-	_tc_stat |= stat;

-	_tc_stat &= ~TC_STAT_RUNNING;

-

-	/* release semaphore */

-	rt_sem_release(&_tc_sem);

-}

-

-void tc_stat(rt_uint8_t stat)

-{

-	if (stat & TC_STAT_FAILED)

-	{

-		rt_kprintf("TestCases[%s] failed\n", _tc_current);

-	}

-	_tc_stat |= stat;

-}

-

-void tc_cleanup(void (*cleanup)())

-{

-	_tc_cleanup = cleanup;

-}

-

-void tc_start(const char* tc_prefix)

-{

-	rt_err_t result;

-

-	/* tesecase prefix is null */

-	if (tc_prefix == RT_NULL)

-	{

-		rt_kprintf("TestCase Usage: tc_start(prefix)\n\n");

-		rt_kprintf("list_tc() can list all testcases.\n");

-		return ;

-	}

-

-	/* init tc thread */

-	if (_tc_stat & TC_STAT_RUNNING)

-	{

-		/* stop old tc thread */

-		tc_stop();

-	}

-

-	rt_memset(_tc_prefix, 0, sizeof(_tc_prefix));

-	rt_snprintf(_tc_prefix, sizeof(_tc_prefix), "_tc_%s", tc_prefix);

-

-	result = rt_thread_init(&_tc_thread, "tc",

-		tc_thread_entry, RT_NULL,

-		&_tc_stack[0], sizeof(_tc_stack),

-		TC_PRIORITY - 3, 5);

-

-	/* set tc stat */

-	_tc_stat = TC_STAT_RUNNING | TC_STAT_FAILED;

-

-	if (result == RT_EOK)

-		rt_thread_startup(&_tc_thread);

-}

-FINSH_FUNCTION_EXPORT(tc_start, start testcase with testcase prefix or name);

-

-void list_tc()

-{

-	struct finsh_syscall* index;

-

-	rt_kprintf("TestCases List:\n");

-	for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))

-	{

-		/* search testcase */

-		if (rt_strstr(index->name, "_tc_") == index->name)

-		{

-#ifdef FINSH_USING_DESCRIPTION

-			rt_kprintf("%-16s -- %s\n", index->name + 4, index->desc);

-#else

-			rt_kprintf("%s\n", index->name + 4);

-#endif

-		}

-	}

-}

-FINSH_FUNCTION_EXPORT(list_tc, list all testcases);

-#endif

-

+#include "tc_comm.h"
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+#endif
+
+#ifdef RT_USING_TC
+#define TC_PRIORITY		25
+#define TC_STACK_SIZE	0x400
+
+static rt_uint8_t _tc_stat;
+static struct rt_semaphore _tc_sem;
+static struct rt_thread _tc_thread;
+static rt_uint8_t _tc_stack[TC_STACK_SIZE];
+static char _tc_prefix[64];
+static const char* _tc_current;
+static void (*_tc_cleanup)(void) = RT_NULL;
+
+static rt_uint32_t _tc_scale = 1;
+FINSH_VAR_EXPORT(_tc_scale, finsh_type_int, the testcase timer timeout scale)
+
+void tc_thread_entry(void* parameter)
+{
+	struct finsh_syscall* index;
+
+	/* create tc semaphore */
+	rt_sem_init(&_tc_sem, "tc", 0, RT_IPC_FLAG_FIFO);
+
+	while (_tc_stat & TC_STAT_RUNNING)
+	{
+		for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))
+		{
+			/* search testcase */
+			if (rt_strstr(index->name, _tc_prefix) == index->name)
+			{
+				long tick;
+
+				_tc_current = index->name + 4;
+				rt_kprintf("Run TestCase: %s\n", _tc_current);
+				_tc_stat = TC_STAT_PASSED | TC_STAT_RUNNING;
+				tick = index->func();
+				if (tick > 0)
+				{
+					rt_sem_take(&_tc_sem, tick * _tc_scale);
+
+					if (_tc_cleanup != RT_NULL)
+					{
+						/* perform testcase cleanup */
+						_tc_cleanup();
+						_tc_cleanup = RT_NULL;
+					}
+
+					rt_sem_trytake(&_tc_sem);/* by nl1031 */
+
+					if (_tc_stat & TC_STAT_FAILED)
+						rt_kprintf("TestCase[%s] failed\n", _tc_current);
+					else
+						rt_kprintf("TestCase[%s] passed\n", _tc_current);
+				}
+				else
+				{
+					if (_tc_cleanup != RT_NULL)
+					{
+						/* perform testcase cleanup */
+						_tc_cleanup();
+						_tc_cleanup = RT_NULL;
+					}
+				}
+			}
+		}
+	}
+
+	rt_kprintf("RT-Thread TestCase Running Done!\n");
+	/* detach tc semaphore */
+	rt_sem_detach(&_tc_sem);
+}
+
+void tc_stop()
+{
+	_tc_stat &= ~TC_STAT_RUNNING;
+
+	rt_thread_delay(RT_TICK_PER_SECOND/2);
+	if (_tc_thread.stat != RT_THREAD_INIT)
+	{
+		/* lock scheduler */
+		rt_enter_critical();
+
+		/* detach old tc thread */
+		rt_thread_detach(&_tc_thread);
+		rt_sem_detach(&_tc_sem);
+
+		/* unlock scheduler */
+		rt_exit_critical();
+	}
+	rt_thread_delay(RT_TICK_PER_SECOND/2);
+}
+FINSH_FUNCTION_EXPORT(tc_stop, stop testcase thread);
+
+void tc_done(rt_uint8_t stat)
+{
+	_tc_stat |= stat;
+	_tc_stat &= ~TC_STAT_RUNNING;
+
+	/* release semaphore */
+	rt_sem_release(&_tc_sem);
+}
+
+void tc_stat(rt_uint8_t stat)
+{
+	if (stat & TC_STAT_FAILED)
+	{
+		rt_kprintf("TestCases[%s] failed\n", _tc_current);
+	}
+	_tc_stat |= stat;
+}
+
+void tc_cleanup(void (*cleanup)())
+{
+	_tc_cleanup = cleanup;
+}
+
+void tc_start(const char* tc_prefix)
+{
+	rt_err_t result;
+
+	/* tesecase prefix is null */
+	if (tc_prefix == RT_NULL)
+	{
+		rt_kprintf("TestCase Usage: tc_start(prefix)\n\n");
+		rt_kprintf("list_tc() can list all testcases.\n");
+		return ;
+	}
+
+	/* init tc thread */
+	if (_tc_stat & TC_STAT_RUNNING)
+	{
+		/* stop old tc thread */
+		tc_stop();
+	}
+
+	rt_memset(_tc_prefix, 0, sizeof(_tc_prefix));
+	rt_snprintf(_tc_prefix, sizeof(_tc_prefix), "_tc_%s", tc_prefix);
+
+	result = rt_thread_init(&_tc_thread, "tc",
+		tc_thread_entry, RT_NULL,
+		&_tc_stack[0], sizeof(_tc_stack),
+		TC_PRIORITY - 3, 5);
+
+	/* set tc stat */
+	_tc_stat = TC_STAT_RUNNING | TC_STAT_FAILED;
+
+	if (result == RT_EOK)
+		rt_thread_startup(&_tc_thread);
+}
+FINSH_FUNCTION_EXPORT(tc_start, start testcase with testcase prefix or name);
+
+void list_tc()
+{
+	struct finsh_syscall* index;
+
+	rt_kprintf("TestCases List:\n");
+	for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))
+	{
+		/* search testcase */
+		if (rt_strstr(index->name, "_tc_") == index->name)
+		{
+#ifdef FINSH_USING_DESCRIPTION
+			rt_kprintf("%-16s -- %s\n", index->name + 4, index->desc);
+#else
+			rt_kprintf("%s\n", index->name + 4);
+#endif
+		}
+	}
+}
+FINSH_FUNCTION_EXPORT(list_tc, list all testcases);
+#endif
+
diff --git a/examples/kernel/tc_comm.h b/examples/kernel/tc_comm.h
index 9333b96815..7146097684 100644
--- a/examples/kernel/tc_comm.h
+++ b/examples/kernel/tc_comm.h
@@ -1,43 +1,43 @@
-#ifndef __TC_COMM_H__

-#define __TC_COMM_H__

-

-/* 

- * RT-Thread TestCase

- *

- */

-#include <rtthread.h>

-#ifdef RT_USING_FINSH

-#include <finsh.h>

-#endif

-

-#if RT_THREAD_PRIORITY_MAX == 8

-#define THREAD_PRIORITY		6

-#elif RT_THREAD_PRIORITY_MAX == 32

-#define THREAD_PRIORITY		25

-#elif RT_THREAD_PRIORITY_MAX == 256

-#define THREAD_PRIORITY		200

-#endif

-#define THREAD_STACK_SIZE	512

-#define THREAD_TIMESLICE	5

-

-#define TC_STAT_END		0x00

-#define TC_STAT_RUNNING	0x01

-#define TC_STAT_FAILED	0x10

-#define TC_STAT_PASSED	0x00

-

-#ifdef RT_USING_TC

-void tc_start(const char* tc_prefix);

-void tc_stop(void);

-void tc_done(rt_uint8_t state);

-void tc_stat(rt_uint8_t state);

-void tc_cleanup(void (*cleanup)(void));

-#else

-#define tc_start(x)

-#define tc_stop()

-#define tc_done(s)

-#define tc_stat(s)

-#define tc_cleanup(c)

-#endif

-

-#endif

-

+#ifndef __TC_COMM_H__
+#define __TC_COMM_H__
+
+/* 
+ * RT-Thread TestCase
+ *
+ */
+#include <rtthread.h>
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+#endif
+
+#if RT_THREAD_PRIORITY_MAX == 8
+#define THREAD_PRIORITY		6
+#elif RT_THREAD_PRIORITY_MAX == 32
+#define THREAD_PRIORITY		25
+#elif RT_THREAD_PRIORITY_MAX == 256
+#define THREAD_PRIORITY		200
+#endif
+#define THREAD_STACK_SIZE	512
+#define THREAD_TIMESLICE	5
+
+#define TC_STAT_END		0x00
+#define TC_STAT_RUNNING	0x01
+#define TC_STAT_FAILED	0x10
+#define TC_STAT_PASSED	0x00
+
+#ifdef RT_USING_TC
+void tc_start(const char* tc_prefix);
+void tc_stop(void);
+void tc_done(rt_uint8_t state);
+void tc_stat(rt_uint8_t state);
+void tc_cleanup(void (*cleanup)(void));
+#else
+#define tc_start(x)
+#define tc_stop()
+#define tc_done(s)
+#define tc_stat(s)
+#define tc_cleanup(c)
+#endif
+
+#endif
+
diff --git a/examples/kernel/thread_delay.c b/examples/kernel/thread_delay.c
index 28b579487a..23d25d6d5c 100644
--- a/examples/kernel/thread_delay.c
+++ b/examples/kernel/thread_delay.c
@@ -1,70 +1,70 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-/*

- * This is an example for delay thread

- */

-static struct rt_thread thread;

-static char thread_stack[THREAD_STACK_SIZE];

-static void thread_entry(void* parameter)

-{

-	rt_tick_t tick;

-	rt_kprintf("thread inited ok\n");

-

-	rt_kprintf("thread delay 10 tick\n");

-	tick = rt_tick_get();

-	rt_thread_delay(10);

-	if (rt_tick_get() - tick > 10)

-	{

-		tc_done(TC_STAT_FAILED);

-		return;

-	}

-

-	rt_kprintf("thread delay 15 tick\n");

-	tick = rt_tick_get();

-	rt_thread_delay(15);

-	if (rt_tick_get() - tick > 15)

-	{

-		tc_done(TC_STAT_FAILED);

-		return;

-	}

-

-	rt_kprintf("thread exit\n");

-

-	tc_done(TC_STAT_PASSED);

-}

-

-rt_err_t thread_delay_init()

-{

-	rt_err_t result;

-

-	result = rt_thread_init(&thread,

-		"test",

-		thread_entry, RT_NULL,

-		&thread_stack[0], sizeof(thread_stack),

-		THREAD_PRIORITY, 10);

-

-	if (result == RT_EOK)

-		rt_thread_startup(&thread);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return result;

-}

-

-#ifdef RT_USING_TC

-int _tc_thread_delay()

-{

-	thread_delay_init();

-

-	return 30;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_delay, a thread delay test);

-#else

-int rt_application_init()

-{

-	thread_delay_init();

-

-	return 0;

-}

-#endif

+#include <rtthread.h>
+#include "tc_comm.h"
+
+/*
+ * This is an example for delay thread
+ */
+static struct rt_thread thread;
+static char thread_stack[THREAD_STACK_SIZE];
+static void thread_entry(void* parameter)
+{
+	rt_tick_t tick;
+	rt_kprintf("thread inited ok\n");
+
+	rt_kprintf("thread delay 10 tick\n");
+	tick = rt_tick_get();
+	rt_thread_delay(10);
+	if (rt_tick_get() - tick > 10)
+	{
+		tc_done(TC_STAT_FAILED);
+		return;
+	}
+
+	rt_kprintf("thread delay 15 tick\n");
+	tick = rt_tick_get();
+	rt_thread_delay(15);
+	if (rt_tick_get() - tick > 15)
+	{
+		tc_done(TC_STAT_FAILED);
+		return;
+	}
+
+	rt_kprintf("thread exit\n");
+
+	tc_done(TC_STAT_PASSED);
+}
+
+rt_err_t thread_delay_init()
+{
+	rt_err_t result;
+
+	result = rt_thread_init(&thread,
+		"test",
+		thread_entry, RT_NULL,
+		&thread_stack[0], sizeof(thread_stack),
+		THREAD_PRIORITY, 10);
+
+	if (result == RT_EOK)
+		rt_thread_startup(&thread);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return result;
+}
+
+#ifdef RT_USING_TC
+int _tc_thread_delay()
+{
+	thread_delay_init();
+
+	return 30;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_delay, a thread delay test);
+#else
+int rt_application_init()
+{
+	thread_delay_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_delete.c b/examples/kernel/thread_delete.c
index 4c8336ca5d..6bae53994e 100644
--- a/examples/kernel/thread_delete.c
+++ b/examples/kernel/thread_delete.c
@@ -1,144 +1,144 @@
-/*

- * 程序清单：删除线程

- *

- * 这个例子会创建两个线程，在一个线程中删除另外一个线程。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/*

- * 线程删除(rt_thread_delete)函数仅适合于动态线程，为了在一个线程

- * 中访问另一个线程的控制块，所以把线程块指针声明成全局类型以供全

- * 局访问

- */

-static rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;

-/* 线程1的入口函数 */

-static void thread1_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-

-	while (1)

-	{

-		/* 线程1采用低优先级运行，一直打印计数值 */

-		// rt_kprintf("thread count: %d\n", count ++);

-		count ++;

-	}

-}

-static void thread1_cleanup(struct rt_thread *tid)

-{

-	if (tid != tid1)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return ;

-	}

-	rt_kprintf("thread1 end\n");

-	tid1 = RT_NULL;

-}

-

-/* 线程2的入口函数 */

-static void thread2_entry(void* parameter)

-{

-	/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */

-

-	/* 线程2启动后先睡眠10个OS Tick */

-	rt_thread_delay(10);

-

-	/*

-	 * 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程

-	 * 队列

-	 */

-	rt_thread_delete(tid1);

-

-	/*

-	 * 线程2继续休眠10个OS Tick然后退出，线程2休眠后应切换到idle线程

-	 * idle线程将执行真正的线程1控制块和线程栈的删除

-	 */

-	rt_thread_delay(10);

-}

-

-static void thread2_cleanup(struct rt_thread *tid)

-{

-	/*

-	 * 线程2运行结束后也将自动被删除(线程控制块和线程栈在idle线

-	 * 程中释放)

-	 */

-

-	if (tid != tid2)

-	{

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-		return ;

-	}

-	rt_kprintf("thread2 end\n");

-	tid2 = RT_NULL;

-	tc_done(TC_STAT_PASSED);

-}

-

-/* 线程删除示例的初始化 */

-int thread_delete_init()

-{

-	/* 创建线程1 */

-	tid1 = rt_thread_create("t1", /* 线程1的名称是t1 */

-		thread1_entry, RT_NULL,   /* 入口是thread1_entry，参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */

-	{

-		tid1->cleanup = thread1_cleanup;

-		rt_thread_startup(tid1);

-	}

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程1 */

-	tid2 = rt_thread_create("t2", /* 线程1的名称是t2 */

-		thread2_entry, RT_NULL,   /* 入口是thread2_entry，参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */

-	{

-		tid2->cleanup = thread2_cleanup;

-		rt_thread_startup(tid2);

-	}

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* lock scheduler */

-	rt_enter_critical();

-

-	/* delete thread */

-	if (tid1 != RT_NULL)

-	{

-		rt_kprintf("tid1 is bad\n");

-		tc_stat(TC_STAT_FAILED);

-	}

-	if (tid2 != RT_NULL)

-	{

-		rt_kprintf("tid2 is bad\n");

-		tc_stat(TC_STAT_FAILED);

-	}

-

-	/* unlock scheduler */

-	rt_exit_critical();

-}

-

-int _tc_thread_delete()

-{

-	/* set tc cleanup */

-	tc_cleanup(_tc_cleanup);

-	thread_delete_init();

-

-	return 27;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_delete, a thread delete example);

-#else

-int rt_application_init()

-{

-	thread_delete_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：删除线程
+ *
+ * 这个例子会创建两个线程，在一个线程中删除另外一个线程。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/*
+ * 线程删除(rt_thread_delete)函数仅适合于动态线程，为了在一个线程
+ * 中访问另一个线程的控制块，所以把线程块指针声明成全局类型以供全
+ * 局访问
+ */
+static rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;
+/* 线程1的入口函数 */
+static void thread1_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+
+	while (1)
+	{
+		/* 线程1采用低优先级运行，一直打印计数值 */
+		// rt_kprintf("thread count: %d\n", count ++);
+		count ++;
+	}
+}
+static void thread1_cleanup(struct rt_thread *tid)
+{
+	if (tid != tid1)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return ;
+	}
+	rt_kprintf("thread1 end\n");
+	tid1 = RT_NULL;
+}
+
+/* 线程2的入口函数 */
+static void thread2_entry(void* parameter)
+{
+	/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
+
+	/* 线程2启动后先睡眠10个OS Tick */
+	rt_thread_delay(10);
+
+	/*
+	 * 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程
+	 * 队列
+	 */
+	rt_thread_delete(tid1);
+
+	/*
+	 * 线程2继续休眠10个OS Tick然后退出，线程2休眠后应切换到idle线程
+	 * idle线程将执行真正的线程1控制块和线程栈的删除
+	 */
+	rt_thread_delay(10);
+}
+
+static void thread2_cleanup(struct rt_thread *tid)
+{
+	/*
+	 * 线程2运行结束后也将自动被删除(线程控制块和线程栈在idle线
+	 * 程中释放)
+	 */
+
+	if (tid != tid2)
+	{
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+		return ;
+	}
+	rt_kprintf("thread2 end\n");
+	tid2 = RT_NULL;
+	tc_done(TC_STAT_PASSED);
+}
+
+/* 线程删除示例的初始化 */
+int thread_delete_init()
+{
+	/* 创建线程1 */
+	tid1 = rt_thread_create("t1", /* 线程1的名称是t1 */
+		thread1_entry, RT_NULL,   /* 入口是thread1_entry，参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */
+	{
+		tid1->cleanup = thread1_cleanup;
+		rt_thread_startup(tid1);
+	}
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程1 */
+	tid2 = rt_thread_create("t2", /* 线程1的名称是t2 */
+		thread2_entry, RT_NULL,   /* 入口是thread2_entry，参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */
+	{
+		tid2->cleanup = thread2_cleanup;
+		rt_thread_startup(tid2);
+	}
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* lock scheduler */
+	rt_enter_critical();
+
+	/* delete thread */
+	if (tid1 != RT_NULL)
+	{
+		rt_kprintf("tid1 is bad\n");
+		tc_stat(TC_STAT_FAILED);
+	}
+	if (tid2 != RT_NULL)
+	{
+		rt_kprintf("tid2 is bad\n");
+		tc_stat(TC_STAT_FAILED);
+	}
+
+	/* unlock scheduler */
+	rt_exit_critical();
+}
+
+int _tc_thread_delete()
+{
+	/* set tc cleanup */
+	tc_cleanup(_tc_cleanup);
+	thread_delete_init();
+
+	return 27;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_delete, a thread delete example);
+#else
+int rt_application_init()
+{
+	thread_delete_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_detach.c b/examples/kernel/thread_detach.c
index 84c85977fb..af1824ae30 100644
--- a/examples/kernel/thread_detach.c
+++ b/examples/kernel/thread_detach.c
@@ -1,118 +1,118 @@
-/*

- * 程序清单：线程脱离

- *

- * 这个例子会创建两个线程，在其中一个线程中执行对另一个线程的脱离。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 线程1控制块 */

-static struct rt_thread thread1;

-/* 线程1栈 */

-static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];

-/* 线程2控制块 */

-static struct rt_thread thread2;

-/* 线程2栈 */

-static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];

-

-/* 线程1入口 */

-static void thread1_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-

-	while (1)

-	{

-		/* 线程1采用低优先级运行，一直打印计数值 */

-		rt_kprintf("thread count: %d\n", count ++);

-	}

-}

-

-/* 线程2入口 */

-static void thread2_entry(void* parameter)

-{

-	/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */

-

-	/* 线程2启动后先睡眠10个OS Tick */

-	rt_thread_delay(10);

-

-	/*

-	 * 线程2唤醒后直接执行线程1脱离，线程1将从就绪线程队列中删除

-	 */

-	rt_thread_detach(&thread1);

-

-	/*

-	 * 线程2继续休眠10个OS Tick然后退出

-	 */

-	rt_thread_delay(10);

-

-	/*

-	 * 线程2运行结束后也将自动被从就绪队列中删除，并脱离线程队列

-	 */

-}

-

-int thread_detach_init()

-{

-	rt_err_t result;

-

-	/* 初始化线程1 */

-	result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */

-		thread1_entry, RT_NULL, /* 线程的入口是thread1_entry，入口参数是RT_NULL*/

-		&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */

-		THREAD_PRIORITY, 10);

-	if (result == RT_EOK) /* 如果返回正确，启动线程1 */

-		rt_thread_startup(&thread1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 初始化线程2 */

-	result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */

-		thread2_entry, RT_NULL, /* 线程的入口是thread2_entry，入口参数是RT_NULL*/

-		&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */

-		THREAD_PRIORITY - 1, 10);

-	if (result == RT_EOK) /* 如果返回正确，启动线程2 */

-		rt_thread_startup(&thread2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 执行线程脱离 */

-	if (thread1.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread1);

-	if (thread2.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_detach()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_detach_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 25;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_detach_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：线程脱离
+ *
+ * 这个例子会创建两个线程，在其中一个线程中执行对另一个线程的脱离。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 线程1控制块 */
+static struct rt_thread thread1;
+/* 线程1栈 */
+static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];
+/* 线程2控制块 */
+static struct rt_thread thread2;
+/* 线程2栈 */
+static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
+
+/* 线程1入口 */
+static void thread1_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+
+	while (1)
+	{
+		/* 线程1采用低优先级运行，一直打印计数值 */
+		rt_kprintf("thread count: %d\n", count ++);
+	}
+}
+
+/* 线程2入口 */
+static void thread2_entry(void* parameter)
+{
+	/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
+
+	/* 线程2启动后先睡眠10个OS Tick */
+	rt_thread_delay(10);
+
+	/*
+	 * 线程2唤醒后直接执行线程1脱离，线程1将从就绪线程队列中删除
+	 */
+	rt_thread_detach(&thread1);
+
+	/*
+	 * 线程2继续休眠10个OS Tick然后退出
+	 */
+	rt_thread_delay(10);
+
+	/*
+	 * 线程2运行结束后也将自动被从就绪队列中删除，并脱离线程队列
+	 */
+}
+
+int thread_detach_init()
+{
+	rt_err_t result;
+
+	/* 初始化线程1 */
+	result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */
+		thread1_entry, RT_NULL, /* 线程的入口是thread1_entry，入口参数是RT_NULL*/
+		&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */
+		THREAD_PRIORITY, 10);
+	if (result == RT_EOK) /* 如果返回正确，启动线程1 */
+		rt_thread_startup(&thread1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 初始化线程2 */
+	result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */
+		thread2_entry, RT_NULL, /* 线程的入口是thread2_entry，入口参数是RT_NULL*/
+		&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */
+		THREAD_PRIORITY - 1, 10);
+	if (result == RT_EOK) /* 如果返回正确，启动线程2 */
+		rt_thread_startup(&thread2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 执行线程脱离 */
+	if (thread1.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread1);
+	if (thread2.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_detach()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_detach_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 25;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_detach_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_dynamic.c b/examples/kernel/thread_dynamic.c
index 9d1218be5d..960a40de9d 100644
--- a/examples/kernel/thread_dynamic.c
+++ b/examples/kernel/thread_dynamic.c
@@ -1,44 +1,44 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-static void thread_entry(void* parameter)

-{

-	rt_kprintf("thread dynamicly created ok\n");

-	rt_thread_delay(10);

-	rt_kprintf("thread exit\n");

-

-	tc_done(TC_STAT_PASSED);

-}

-

-int thread_dynamic_init()

-{

-	rt_thread_t tid;

-

-	tid = rt_thread_create("test",

-		thread_entry, RT_NULL,

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid != RT_NULL)

-		rt_thread_startup(tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-int _tc_thread_dynamic()

-{

-	thread_dynamic_init();

-

-	return 20;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_dynamic, a dynamic thread test);

-#else

-int rt_application_init()

-{

-	thread_dynamic_init();

-

-	return 0;

-}

-#endif

-

+#include <rtthread.h>
+#include "tc_comm.h"
+
+static void thread_entry(void* parameter)
+{
+	rt_kprintf("thread dynamicly created ok\n");
+	rt_thread_delay(10);
+	rt_kprintf("thread exit\n");
+
+	tc_done(TC_STAT_PASSED);
+}
+
+int thread_dynamic_init()
+{
+	rt_thread_t tid;
+
+	tid = rt_thread_create("test",
+		thread_entry, RT_NULL,
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid != RT_NULL)
+		rt_thread_startup(tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+int _tc_thread_dynamic()
+{
+	thread_dynamic_init();
+
+	return 20;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_dynamic, a dynamic thread test);
+#else
+int rt_application_init()
+{
+	thread_dynamic_init();
+
+	return 0;
+}
+#endif
+
diff --git a/examples/kernel/thread_dynamic_simple.c b/examples/kernel/thread_dynamic_simple.c
index c8a4b905aa..9d7612bddc 100644
--- a/examples/kernel/thread_dynamic_simple.c
+++ b/examples/kernel/thread_dynamic_simple.c
@@ -1,89 +1,89 @@
-/*

- * 程序清单：动态线程

- *

- * 这个程序会初始化2个动态线程，它们拥有共同的入口函数，但参数不相同

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid1 = RT_NULL;

-static rt_thread_t tid2 = RT_NULL;

-/* 线程入口 */

-static void thread_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-	rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */

-

-	while (1)

-	{

-		/* 打印线程计数值输出 */

-		rt_kprintf("thread%d count: %d\n", no, count ++);

-

-		/* 休眠10个OS Tick */

-		rt_thread_delay(10);

-	}

-}

-

-int thread_dynamic_simple_init()

-{

-	/* 创建线程1 */

-	tid1 = rt_thread_create("t1",

-		thread_entry, (void*)1, /* 线程入口是thread_entry, 入口参数是1 */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL)

-		rt_thread_startup(tid1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	tid2 = rt_thread_create("t2",

-		thread_entry, (void*)2, /* 线程入口是thread_entry, 入口参数是2 */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL)

-		rt_thread_startup(tid2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid1);

-	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_dynamic_simple()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_dynamic_simple_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_dynamic_simple_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：动态线程
+ *
+ * 这个程序会初始化2个动态线程，它们拥有共同的入口函数，但参数不相同
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid1 = RT_NULL;
+static rt_thread_t tid2 = RT_NULL;
+/* 线程入口 */
+static void thread_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+	rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
+
+	while (1)
+	{
+		/* 打印线程计数值输出 */
+		rt_kprintf("thread%d count: %d\n", no, count ++);
+
+		/* 休眠10个OS Tick */
+		rt_thread_delay(10);
+	}
+}
+
+int thread_dynamic_simple_init()
+{
+	/* 创建线程1 */
+	tid1 = rt_thread_create("t1",
+		thread_entry, (void*)1, /* 线程入口是thread_entry, 入口参数是1 */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL)
+		rt_thread_startup(tid1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	tid2 = rt_thread_create("t2",
+		thread_entry, (void*)2, /* 线程入口是thread_entry, 入口参数是2 */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL)
+		rt_thread_startup(tid2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid1);
+	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_dynamic_simple()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_dynamic_simple_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_dynamic_simple_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_priority.c b/examples/kernel/thread_priority.c
index 6d0692e4dc..1d6fb4a80e 100644
--- a/examples/kernel/thread_priority.c
+++ b/examples/kernel/thread_priority.c
@@ -1,105 +1,105 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-struct rt_thread thread1;

-struct rt_thread thread2;

-static char thread1_stack[THREAD_STACK_SIZE];

-static char thread2_stack[THREAD_STACK_SIZE];

-static rt_uint32_t count = 0;

-

-/*

- * the priority of thread1 > the priority of thread2

- */

-static void thread1_entry(void* parameter)

-{

-	while (1)

-	{

-		count ++;

-		rt_kprintf("count = %d\n", count);

-

-		rt_thread_delay(10);

-	}

-}

-

-static void thread2_entry(void* parameter)

-{

-	rt_tick_t tick;

-

-	tick = rt_tick_get();

-	while (1)

-	{

-		if (rt_tick_get() - tick >= 50)

-		{

-			if (count == 0)

-				tc_done(TC_STAT_FAILED);

-			else

-				tc_done(TC_STAT_PASSED);

-

-			break;

-		}

-	}

-}

-

-int thread_priority_init()

-{

-	rt_err_t result;

-

-	result = rt_thread_init(&thread1,

-		"t1",

-		thread1_entry, RT_NULL,

-		&thread1_stack[0], sizeof(thread1_stack),

-		THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	

-	if (result == RT_EOK)

-		rt_thread_startup(&thread1);

-	else

-		tc_stat(TC_STAT_FAILED);

-

-	rt_thread_init(&thread2,

-		"t2",

-		thread2_entry, RT_NULL,

-		&thread2_stack[0], sizeof(thread2_stack),

-		THREAD_PRIORITY + 1, THREAD_TIMESLICE);

-

-	if (result == RT_EOK)

-		rt_thread_startup(&thread2);

-	else

-		tc_stat(TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* lock scheduler */

-	rt_enter_critical();

-

-	if (thread1.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread1);

-	if (thread2.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread2);

-

-	/* unlock scheduler */

-	rt_exit_critical();

-}

-int _tc_thread_priority()

-{

-	count = 0;

-

-	/* set tc cleanup */

-	tc_cleanup(_tc_cleanup);

-	thread_priority_init();

-

-	return RT_TICK_PER_SECOND;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_priority, a priority thread test);

-#else

-int rt_application_init()

-{

-	thread_priority_init();

-

-	return 0;

-}

-#endif

-

+#include <rtthread.h>
+#include "tc_comm.h"
+
+struct rt_thread thread1;
+struct rt_thread thread2;
+static char thread1_stack[THREAD_STACK_SIZE];
+static char thread2_stack[THREAD_STACK_SIZE];
+static rt_uint32_t count = 0;
+
+/*
+ * the priority of thread1 > the priority of thread2
+ */
+static void thread1_entry(void* parameter)
+{
+	while (1)
+	{
+		count ++;
+		rt_kprintf("count = %d\n", count);
+
+		rt_thread_delay(10);
+	}
+}
+
+static void thread2_entry(void* parameter)
+{
+	rt_tick_t tick;
+
+	tick = rt_tick_get();
+	while (1)
+	{
+		if (rt_tick_get() - tick >= 50)
+		{
+			if (count == 0)
+				tc_done(TC_STAT_FAILED);
+			else
+				tc_done(TC_STAT_PASSED);
+
+			break;
+		}
+	}
+}
+
+int thread_priority_init()
+{
+	rt_err_t result;
+
+	result = rt_thread_init(&thread1,
+		"t1",
+		thread1_entry, RT_NULL,
+		&thread1_stack[0], sizeof(thread1_stack),
+		THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	
+	if (result == RT_EOK)
+		rt_thread_startup(&thread1);
+	else
+		tc_stat(TC_STAT_FAILED);
+
+	rt_thread_init(&thread2,
+		"t2",
+		thread2_entry, RT_NULL,
+		&thread2_stack[0], sizeof(thread2_stack),
+		THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+
+	if (result == RT_EOK)
+		rt_thread_startup(&thread2);
+	else
+		tc_stat(TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* lock scheduler */
+	rt_enter_critical();
+
+	if (thread1.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread1);
+	if (thread2.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread2);
+
+	/* unlock scheduler */
+	rt_exit_critical();
+}
+int _tc_thread_priority()
+{
+	count = 0;
+
+	/* set tc cleanup */
+	tc_cleanup(_tc_cleanup);
+	thread_priority_init();
+
+	return RT_TICK_PER_SECOND;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_priority, a priority thread test);
+#else
+int rt_application_init()
+{
+	thread_priority_init();
+
+	return 0;
+}
+#endif
+
diff --git a/examples/kernel/thread_resume.c b/examples/kernel/thread_resume.c
index e0ed6fa5f7..ac8b6cb489 100644
--- a/examples/kernel/thread_resume.c
+++ b/examples/kernel/thread_resume.c
@@ -1,123 +1,123 @@
-/*

- * 程序清单：唤醒线程

- *

- * 这个例子中将创建两个动态线程，低优先级线程将挂起自身，然后

- * 高优先级线程将在一定时刻后唤醒低优先级线程。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid1 = RT_NULL;

-static rt_thread_t tid2 = RT_NULL;

-/* 线程1入口 */

-static void thread1_entry(void* parameter)

-{

-	/* 低优先级线程1开始运行 */

-	rt_kprintf("thread1 startup%d\n");

-

-	/* 挂起自身 */

-	rt_kprintf("suspend thread self\n");

-	rt_thread_suspend(tid1);

-	/* 主动执行线程调度 */

-	rt_schedule();

-

-	/* 当线程1被唤醒时 */

-	rt_kprintf("thread1 resumed\n");

-}

-static void thread_cleanup(rt_thread_t tid)

-{

-	if (tid == tid1)

-	{

-		tid1 = RT_NULL;

-	}

-	if (tid == tid2)

-	{

-		tid = RT_NULL;

-	}

-}

-

-/* 线程2入口 */

-static void thread2_entry(void* parameter)

-{

-	/* 延时10个OS Tick */

-	rt_thread_delay(10);

-

-	/* 唤醒线程1 */

-	rt_thread_resume(tid1);

-	rt_kprintf("thread2: to resume thread1\n");

-

-	/* 延时10个OS Tick */

-	rt_thread_delay(10);

-

-	/* 线程2自动退出 */

-}

-

-int thread_resume_init()

-{

-	/* 创建线程1 */

-	tid1 = rt_thread_create("thread",

-		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL)

-	{

-		tid1->cleanup = thread_cleanup;

-		rt_thread_startup(tid1);

-	}

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	tid2 = rt_thread_create("thread",

-		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL)

-	{

-		tid2->cleanup = thread_cleanup;

-		rt_thread_startup(tid2);

-	}

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid1);

-	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_resume()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_resume_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 25;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_resume, a thread resume example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_resume_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：唤醒线程
+ *
+ * 这个例子中将创建两个动态线程，低优先级线程将挂起自身，然后
+ * 高优先级线程将在一定时刻后唤醒低优先级线程。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid1 = RT_NULL;
+static rt_thread_t tid2 = RT_NULL;
+/* 线程1入口 */
+static void thread1_entry(void* parameter)
+{
+	/* 低优先级线程1开始运行 */
+	rt_kprintf("thread1 startup%d\n");
+
+	/* 挂起自身 */
+	rt_kprintf("suspend thread self\n");
+	rt_thread_suspend(tid1);
+	/* 主动执行线程调度 */
+	rt_schedule();
+
+	/* 当线程1被唤醒时 */
+	rt_kprintf("thread1 resumed\n");
+}
+static void thread_cleanup(rt_thread_t tid)
+{
+	if (tid == tid1)
+	{
+		tid1 = RT_NULL;
+	}
+	if (tid == tid2)
+	{
+		tid = RT_NULL;
+	}
+}
+
+/* 线程2入口 */
+static void thread2_entry(void* parameter)
+{
+	/* 延时10个OS Tick */
+	rt_thread_delay(10);
+
+	/* 唤醒线程1 */
+	rt_thread_resume(tid1);
+	rt_kprintf("thread2: to resume thread1\n");
+
+	/* 延时10个OS Tick */
+	rt_thread_delay(10);
+
+	/* 线程2自动退出 */
+}
+
+int thread_resume_init()
+{
+	/* 创建线程1 */
+	tid1 = rt_thread_create("thread",
+		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL)
+	{
+		tid1->cleanup = thread_cleanup;
+		rt_thread_startup(tid1);
+	}
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	tid2 = rt_thread_create("thread",
+		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL)
+	{
+		tid2->cleanup = thread_cleanup;
+		rt_thread_startup(tid2);
+	}
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid1);
+	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_resume()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_resume_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 25;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_resume, a thread resume example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_resume_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_same_priority.c b/examples/kernel/thread_same_priority.c
index 228990ba1a..5e0fb81116 100644
--- a/examples/kernel/thread_same_priority.c
+++ b/examples/kernel/thread_same_priority.c
@@ -1,96 +1,96 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-static struct rt_thread thread1;

-static struct rt_thread thread2;

-static char thread1_stack[THREAD_STACK_SIZE];

-static char thread2_stack[THREAD_STACK_SIZE];

-

-volatile static rt_uint32_t t1_count = 0;

-volatile static rt_uint32_t t2_count = 0;

-static void thread1_entry(void* parameter)

-{

-	while (1)

-	{

-		t1_count ++;

-	}

-}

-

-static void thread2_entry(void* parameter)

-{

-	while (1)

-	{

-		t2_count ++;

-	}

-}

-

-rt_err_t thread_same_priority_init()

-{

-	rt_err_t result;

-

-	result = rt_thread_init(&thread1,

-		"t1",

-		thread1_entry, RT_NULL,

-		&thread1_stack[0], sizeof(thread1_stack),

-		THREAD_PRIORITY, 10);

-	if (result == RT_EOK)

-		rt_thread_startup(&thread1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	result = rt_thread_init(&thread2,

-		"t2",

-		thread2_entry, RT_NULL,

-		&thread2_stack[0], sizeof(thread2_stack),

-		THREAD_PRIORITY, 5);

-	if (result == RT_EOK)

-		rt_thread_startup(&thread2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return result;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* lock scheduler */

-	rt_enter_critical();

-

-	if (thread1.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread1);

-	if (thread2.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread2);

-

-	/* unlock scheduler */

-	rt_exit_critical();

-

-	rt_kprintf("t1_count=%d t2_count=%d\n",t1_count,t2_count);

-

-	if (t1_count / t2_count != 2)

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-	else

-		tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_same_priority()

-{

-	t1_count = 0;

-	t2_count = 0;

-

-	/* set tc cleanup */

-	tc_cleanup(_tc_cleanup);

-

-	thread_same_priority_init();

-

-	return 100;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_same_priority, a same priority thread test);

-#else

-int rt_application_init()

-{

-	thread_same_priority_init();

-

-	return 0;

-}

-#endif

+#include <rtthread.h>
+#include "tc_comm.h"
+
+static struct rt_thread thread1;
+static struct rt_thread thread2;
+static char thread1_stack[THREAD_STACK_SIZE];
+static char thread2_stack[THREAD_STACK_SIZE];
+
+volatile static rt_uint32_t t1_count = 0;
+volatile static rt_uint32_t t2_count = 0;
+static void thread1_entry(void* parameter)
+{
+	while (1)
+	{
+		t1_count ++;
+	}
+}
+
+static void thread2_entry(void* parameter)
+{
+	while (1)
+	{
+		t2_count ++;
+	}
+}
+
+rt_err_t thread_same_priority_init()
+{
+	rt_err_t result;
+
+	result = rt_thread_init(&thread1,
+		"t1",
+		thread1_entry, RT_NULL,
+		&thread1_stack[0], sizeof(thread1_stack),
+		THREAD_PRIORITY, 10);
+	if (result == RT_EOK)
+		rt_thread_startup(&thread1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	result = rt_thread_init(&thread2,
+		"t2",
+		thread2_entry, RT_NULL,
+		&thread2_stack[0], sizeof(thread2_stack),
+		THREAD_PRIORITY, 5);
+	if (result == RT_EOK)
+		rt_thread_startup(&thread2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return result;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* lock scheduler */
+	rt_enter_critical();
+
+	if (thread1.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread1);
+	if (thread2.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread2);
+
+	/* unlock scheduler */
+	rt_exit_critical();
+
+	rt_kprintf("t1_count=%d t2_count=%d\n",t1_count,t2_count);
+
+	if (t1_count / t2_count != 2)
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+	else
+		tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_same_priority()
+{
+	t1_count = 0;
+	t2_count = 0;
+
+	/* set tc cleanup */
+	tc_cleanup(_tc_cleanup);
+
+	thread_same_priority_init();
+
+	return 100;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_same_priority, a same priority thread test);
+#else
+int rt_application_init()
+{
+	thread_same_priority_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_static.c b/examples/kernel/thread_static.c
index 9a8c158c86..4547304b58 100644
--- a/examples/kernel/thread_static.c
+++ b/examples/kernel/thread_static.c
@@ -1,52 +1,52 @@
-#include <rtthread.h>

-#include "tc_comm.h"

-

-/*

- * This is an example for static thread

- */

-static struct rt_thread thread;

-static char thread_stack[THREAD_STACK_SIZE];

-static void thread_entry(void* parameter)

-{

-	rt_kprintf("thread staticly inited ok\n");

-	rt_thread_delay(10);

-	rt_kprintf("thread exit\n");

-

-	tc_done(TC_STAT_PASSED);

-}

-

-rt_err_t thread_static_init()

-{

-	rt_err_t result;

-

-	result = rt_thread_init(&thread,

-		"test",

-		thread_entry, RT_NULL,

-		&thread_stack[0], sizeof(thread_stack),

-		THREAD_PRIORITY, 10);

-

-	if (result == RT_EOK)

-		rt_thread_startup(&thread);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return result;

-}

-

-#ifdef RT_USING_TC

-int _tc_thread_static()

-{

-	thread_static_init();

-

-	return 20;

-}

-FINSH_FUNCTION_EXPORT(_tc_thread_static, a static thread test);

-#else

-int rt_application_init()

-{

-	thread_static_init();

-

-	return 0;

-}

-#endif

-

+#include <rtthread.h>
+#include "tc_comm.h"
+
+/*
+ * This is an example for static thread
+ */
+static struct rt_thread thread;
+static char thread_stack[THREAD_STACK_SIZE];
+static void thread_entry(void* parameter)
+{
+	rt_kprintf("thread staticly inited ok\n");
+	rt_thread_delay(10);
+	rt_kprintf("thread exit\n");
+
+	tc_done(TC_STAT_PASSED);
+}
+
+rt_err_t thread_static_init()
+{
+	rt_err_t result;
+
+	result = rt_thread_init(&thread,
+		"test",
+		thread_entry, RT_NULL,
+		&thread_stack[0], sizeof(thread_stack),
+		THREAD_PRIORITY, 10);
+
+	if (result == RT_EOK)
+		rt_thread_startup(&thread);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return result;
+}
+
+#ifdef RT_USING_TC
+int _tc_thread_static()
+{
+	thread_static_init();
+
+	return 20;
+}
+FINSH_FUNCTION_EXPORT(_tc_thread_static, a static thread test);
+#else
+int rt_application_init()
+{
+	thread_static_init();
+
+	return 0;
+}
+#endif
+
diff --git a/examples/kernel/thread_static_simple.c b/examples/kernel/thread_static_simple.c
index 61005fd23b..3ab8ffda01 100644
--- a/examples/kernel/thread_static_simple.c
+++ b/examples/kernel/thread_static_simple.c
@@ -1,99 +1,99 @@
-/*

- * 程序清单：静态线程

- *

- * 这个程序会初始化2个静态线程，它们拥有共同的入口函数，但参数不相同

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 线程1控制块 */

-static struct rt_thread thread1;

-/* 线程1栈 */

-static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];

-/* 线程2控制块 */

-static struct rt_thread thread2;

-/* 线程2栈 */

-static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];

-

-/* 线程入口 */

-static void thread_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-	rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */

-

-	while (1)

-	{

-		/* 打印线程计数值输出 */

-		rt_kprintf("thread%d count: %d\n", no, count ++);

-

-		/* 休眠10个OS Tick */

-		rt_thread_delay(10);

-	}

-}

-

-int thread_static_simple_init()

-{

-	rt_err_t result;

-

-	/* 初始化线程1 */

-	result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */

-		thread_entry, (void*)1, /* 线程的入口是thread_entry，入口参数是1 */

-		&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */

-		THREAD_PRIORITY, 10);

-	if (result == RT_EOK) /* 如果返回正确，启动线程1 */

-		rt_thread_startup(&thread1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 初始化线程2 */

-	result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */

-		thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是2 */

-		&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */

-		THREAD_PRIORITY + 1, 10);

-	if (result == RT_EOK) /* 如果返回正确，启动线程2 */

-		rt_thread_startup(&thread2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 执行线程脱离 */

-	if (thread1.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread1);

-	if (thread2.stat != RT_THREAD_CLOSE)

-		rt_thread_detach(&thread2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_static_simple()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_static_simple_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_static_simple, a static thread example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_static_simple_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：静态线程
+ *
+ * 这个程序会初始化2个静态线程，它们拥有共同的入口函数，但参数不相同
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 线程1控制块 */
+static struct rt_thread thread1;
+/* 线程1栈 */
+static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];
+/* 线程2控制块 */
+static struct rt_thread thread2;
+/* 线程2栈 */
+static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
+
+/* 线程入口 */
+static void thread_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+	rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
+
+	while (1)
+	{
+		/* 打印线程计数值输出 */
+		rt_kprintf("thread%d count: %d\n", no, count ++);
+
+		/* 休眠10个OS Tick */
+		rt_thread_delay(10);
+	}
+}
+
+int thread_static_simple_init()
+{
+	rt_err_t result;
+
+	/* 初始化线程1 */
+	result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */
+		thread_entry, (void*)1, /* 线程的入口是thread_entry，入口参数是1 */
+		&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */
+		THREAD_PRIORITY, 10);
+	if (result == RT_EOK) /* 如果返回正确，启动线程1 */
+		rt_thread_startup(&thread1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 初始化线程2 */
+	result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */
+		thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是2 */
+		&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */
+		THREAD_PRIORITY + 1, 10);
+	if (result == RT_EOK) /* 如果返回正确，启动线程2 */
+		rt_thread_startup(&thread2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 执行线程脱离 */
+	if (thread1.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread1);
+	if (thread2.stat != RT_THREAD_CLOSE)
+		rt_thread_detach(&thread2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_static_simple()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_static_simple_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_static_simple, a static thread example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_static_simple_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_suspend.c b/examples/kernel/thread_suspend.c
index b38cb8fdfb..7c019573b1 100644
--- a/examples/kernel/thread_suspend.c
+++ b/examples/kernel/thread_suspend.c
@@ -1,101 +1,101 @@
-/*

- * 程序清单：挂起线程

- *

- * 这个例子中将创建两个动态线程，高优先级线程将在一定时刻后挂起低优先级线程。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid1 = RT_NULL;

-static rt_thread_t tid2 = RT_NULL;

-/* 线程1入口 */

-static void thread1_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-

-	while (1)

-	{

-		/* 线程1采用低优先级运行，一直打印计数值 */

-		rt_kprintf("thread count: %d\n", count ++);

-	}

-}

-

-/* 线程2入口 */

-static void thread2_entry(void* parameter)

-{

-	/* 延时10个OS Tick */

-	rt_thread_delay(10);

-

-	/* 挂起线程1 */

-	rt_thread_suspend(tid1);

-

-	/* 延时10个OS Tick */

-	rt_thread_delay(10);

-

-	/* 线程2自动退出 */

-	tid2 = RT_NULL;

-}

-

-int thread_suspend_init()

-{

-	/* 创建线程1 */

-	tid1 = rt_thread_create("thread",

-		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL)

-		rt_thread_startup(tid1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	tid2 = rt_thread_create("thread",

-		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL)

-		rt_thread_startup(tid2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid1);

-	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_suspend()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_suspend_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_suspend, a thread suspend example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_suspend_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：挂起线程
+ *
+ * 这个例子中将创建两个动态线程，高优先级线程将在一定时刻后挂起低优先级线程。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid1 = RT_NULL;
+static rt_thread_t tid2 = RT_NULL;
+/* 线程1入口 */
+static void thread1_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+
+	while (1)
+	{
+		/* 线程1采用低优先级运行，一直打印计数值 */
+		rt_kprintf("thread count: %d\n", count ++);
+	}
+}
+
+/* 线程2入口 */
+static void thread2_entry(void* parameter)
+{
+	/* 延时10个OS Tick */
+	rt_thread_delay(10);
+
+	/* 挂起线程1 */
+	rt_thread_suspend(tid1);
+
+	/* 延时10个OS Tick */
+	rt_thread_delay(10);
+
+	/* 线程2自动退出 */
+	tid2 = RT_NULL;
+}
+
+int thread_suspend_init()
+{
+	/* 创建线程1 */
+	tid1 = rt_thread_create("thread",
+		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL)
+		rt_thread_startup(tid1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	tid2 = rt_thread_create("thread",
+		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL)
+		rt_thread_startup(tid2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid1);
+	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_suspend()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_suspend_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_suspend, a thread suspend example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_suspend_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/thread_yield.c b/examples/kernel/thread_yield.c
index 71244589b8..de2c3a53ac 100644
--- a/examples/kernel/thread_yield.c
+++ b/examples/kernel/thread_yield.c
@@ -1,101 +1,101 @@
-/*

- * 程序清单：

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 指向线程控制块的指针 */

-static rt_thread_t tid1 = RT_NULL;

-static rt_thread_t tid2 = RT_NULL;

-/* 线程1入口 */

-static void thread1_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-

-	while (1)

-	{

-		/* 打印线程1的输出 */

-		rt_kprintf("thread1: count = %d\n", count ++);

-

-		/* 执行yield后应该切换到thread2执行 */

-		rt_thread_yield();

-	}

-}

-

-/* 线程2入口 */

-static void thread2_entry(void* parameter)

-{

-	rt_uint32_t count = 0;

-

-	while (1)

-	{

-		/* 打印线程2的输出 */

-		rt_kprintf("thread2: count = %d\n", count ++);

-

-		/* 执行yield后应该切换到thread1执行 */

-		rt_thread_yield();

-	}

-}

-

-int thread_yield_init()

-{

-	/* 创建线程1 */

-	tid1 = rt_thread_create("thread",

-		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid1 != RT_NULL)

-		rt_thread_startup(tid1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建线程2 */

-	tid2 = rt_thread_create("thread",

-		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid2 != RT_NULL)

-		rt_thread_startup(tid2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除线程 */

-	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid1);

-	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_thread_yield()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-	thread_yield_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 30;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_thread_yield, a thread yield example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	thread_yield_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 指向线程控制块的指针 */
+static rt_thread_t tid1 = RT_NULL;
+static rt_thread_t tid2 = RT_NULL;
+/* 线程1入口 */
+static void thread1_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+
+	while (1)
+	{
+		/* 打印线程1的输出 */
+		rt_kprintf("thread1: count = %d\n", count ++);
+
+		/* 执行yield后应该切换到thread2执行 */
+		rt_thread_yield();
+	}
+}
+
+/* 线程2入口 */
+static void thread2_entry(void* parameter)
+{
+	rt_uint32_t count = 0;
+
+	while (1)
+	{
+		/* 打印线程2的输出 */
+		rt_kprintf("thread2: count = %d\n", count ++);
+
+		/* 执行yield后应该切换到thread1执行 */
+		rt_thread_yield();
+	}
+}
+
+int thread_yield_init()
+{
+	/* 创建线程1 */
+	tid1 = rt_thread_create("thread",
+		thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid1 != RT_NULL)
+		rt_thread_startup(tid1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建线程2 */
+	tid2 = rt_thread_create("thread",
+		thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid2 != RT_NULL)
+		rt_thread_startup(tid2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除线程 */
+	if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid1);
+	if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_thread_yield()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+	thread_yield_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 30;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_thread_yield, a thread yield example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	thread_yield_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/timer_control.c b/examples/kernel/timer_control.c
index f04521a752..f685f140eb 100644
--- a/examples/kernel/timer_control.c
+++ b/examples/kernel/timer_control.c
@@ -1,84 +1,84 @@
-/*

- * 程序清单：动态定时器例程

- *

- * 这个例程会创建1个动态周期型定时器对象，然后控制它进行定时时间长度的更改。

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 定时器的控制块 */

-static rt_timer_t timer1;

-static rt_uint8_t count;

-

-/* 定时器超时函数 */

-static void timeout1(void* parameter)

-{

-	rt_tick_t timeout = 50;

-	

-	rt_kprintf("periodic timer is timeout\n");

-

-	count ++;

-	/* 停止定时器自身 */

-	if (count >= 8)

-	{

-		/* 控制定时器然后更改超时时间长度 */

-		rt_timer_control(timer1, RT_TIMER_CTRL_SET_TIME, (void *)&timeout);

-		count = 0;

-	}

-}

-

-void timer_control_init()

-{

-	/* 创建定时器1 */

-	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */

-		timeout1, /* 超时时回调的处理函数 */

-		RT_NULL, /* 超时函数的入口参数 */

-		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */

-		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */

-	/* 启动定时器 */

-	if (timer1 != RT_NULL)

-		rt_timer_start(timer1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除定时器对象 */

-	rt_timer_delete(timer1);

-	timer1 = RT_NULL;

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_timer_control()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-

-	/* 执行定时器例程 */

-	count = 0;

-	timer_control_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_timer_control, a timer control example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	timer_control_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：动态定时器例程
+ *
+ * 这个例程会创建1个动态周期型定时器对象，然后控制它进行定时时间长度的更改。
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 定时器的控制块 */
+static rt_timer_t timer1;
+static rt_uint8_t count;
+
+/* 定时器超时函数 */
+static void timeout1(void* parameter)
+{
+	rt_tick_t timeout = 50;
+	
+	rt_kprintf("periodic timer is timeout\n");
+
+	count ++;
+	/* 停止定时器自身 */
+	if (count >= 8)
+	{
+		/* 控制定时器然后更改超时时间长度 */
+		rt_timer_control(timer1, RT_TIMER_CTRL_SET_TIME, (void *)&timeout);
+		count = 0;
+	}
+}
+
+void timer_control_init()
+{
+	/* 创建定时器1 */
+	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */
+		timeout1, /* 超时时回调的处理函数 */
+		RT_NULL, /* 超时函数的入口参数 */
+		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
+		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
+	/* 启动定时器 */
+	if (timer1 != RT_NULL)
+		rt_timer_start(timer1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除定时器对象 */
+	rt_timer_delete(timer1);
+	timer1 = RT_NULL;
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_timer_control()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+
+	/* 执行定时器例程 */
+	count = 0;
+	timer_control_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_timer_control, a timer control example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	timer_control_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/timer_dynamic.c b/examples/kernel/timer_dynamic.c
index b28a4c9056..49262b8193 100644
--- a/examples/kernel/timer_dynamic.c
+++ b/examples/kernel/timer_dynamic.c
@@ -1,91 +1,91 @@
-/*

- * 程序清单：动态定时器例程

- *

- * 这个例程会创建两个动态定时器对象，一个是单次定时，一个是周期性的定时

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 定时器的控制块 */

-static rt_timer_t timer1;

-static rt_timer_t timer2;

-

-/* 定时器1超时函数 */

-static void timeout1(void* parameter)

-{

-	rt_kprintf("periodic timer is timeout\n");

-}

-

-/* 定时器2超时函数 */

-static void timeout2(void* parameter)

-{

-	rt_kprintf("one shot timer is timeout\n");

-}

-

-void timer_create_init()

-{

-	/* 创建定时器1 */

-	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */

-		timeout1, /* 超时时回调的处理函数 */

-		RT_NULL, /* 超时函数的入口参数 */

-		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */

-		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */

-	/* 启动定时器 */

-	if (timer1 != RT_NULL)

-		rt_timer_start(timer1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	/* 创建定时器2 */

-	timer2 = rt_timer_create("timer2",   /* 定时器名字是 timer2 */

-		timeout2, /* 超时时回调的处理函数 */

-		RT_NULL, /* 超时函数的入口参数 */

-		30, /* 定时长度为30个OS Tick */

-		RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */

-

-	/* 启动定时器 */

-	if (timer2 != RT_NULL)

-		rt_timer_start(timer2);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除定时器对象 */

-	rt_timer_delete(timer1);

-	rt_timer_delete(timer2);

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_timer_create()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-

-	/* 执行定时器例程 */

-	timer_create_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_timer_create, a dynamic timer example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	timer_create_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：动态定时器例程
+ *
+ * 这个例程会创建两个动态定时器对象，一个是单次定时，一个是周期性的定时
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 定时器的控制块 */
+static rt_timer_t timer1;
+static rt_timer_t timer2;
+
+/* 定时器1超时函数 */
+static void timeout1(void* parameter)
+{
+	rt_kprintf("periodic timer is timeout\n");
+}
+
+/* 定时器2超时函数 */
+static void timeout2(void* parameter)
+{
+	rt_kprintf("one shot timer is timeout\n");
+}
+
+void timer_create_init()
+{
+	/* 创建定时器1 */
+	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */
+		timeout1, /* 超时时回调的处理函数 */
+		RT_NULL, /* 超时函数的入口参数 */
+		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
+		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
+	/* 启动定时器 */
+	if (timer1 != RT_NULL)
+		rt_timer_start(timer1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	/* 创建定时器2 */
+	timer2 = rt_timer_create("timer2",   /* 定时器名字是 timer2 */
+		timeout2, /* 超时时回调的处理函数 */
+		RT_NULL, /* 超时函数的入口参数 */
+		30, /* 定时长度为30个OS Tick */
+		RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
+
+	/* 启动定时器 */
+	if (timer2 != RT_NULL)
+		rt_timer_start(timer2);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除定时器对象 */
+	rt_timer_delete(timer1);
+	rt_timer_delete(timer2);
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_timer_create()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+
+	/* 执行定时器例程 */
+	timer_create_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_timer_create, a dynamic timer example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	timer_create_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/timer_stop_self.c b/examples/kernel/timer_stop_self.c
index 8a19637e52..6d1e287e54 100644
--- a/examples/kernel/timer_stop_self.c
+++ b/examples/kernel/timer_stop_self.c
@@ -1,82 +1,82 @@
-/*

- * 程序清单：动态定时器例程

- *

- * 这个例程会创建1个动态周期型定时器对象

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* 定时器的控制块 */

-static rt_timer_t timer1;

-static rt_uint8_t count;

-

-/* 定时器超时函数 */

-static void timeout1(void* parameter)

-{

-	rt_kprintf("periodic timer is timeout\n");

-

-	count ++;

-	/* 停止定时器自身 */

-	if (count >= 8)

-	{

-		/* 停止定时器 */

-		rt_timer_stop(timer1);

-		count = 0;

-	}

-}

-

-void timer_stop_self_init()

-{

-	/* 创建定时器1 */

-	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */

-		timeout1, /* 超时时回调的处理函数 */

-		RT_NULL, /* 超时函数的入口参数 */

-		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */

-		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */

-	/* 启动定时器 */

-	if (timer1 != RT_NULL)

-		rt_timer_start(timer1);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */

-	rt_enter_critical();

-

-	/* 删除定时器对象 */

-	rt_timer_delete(timer1);

-	timer1 = RT_NULL;

-

-	/* 调度器解锁 */

-	rt_exit_critical();

-

-	/* 设置TestCase状态 */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_timer_stop_self()

-{

-	/* 设置TestCase清理回调函数 */

-	tc_cleanup(_tc_cleanup);

-

-	/* 执行定时器例程 */

-	count = 0;

-	timer_stop_self_init();

-

-	/* 返回TestCase运行的最长时间 */

-	return 100;

-}

-/* 输出函数命令到finsh shell中 */

-FINSH_FUNCTION_EXPORT(_tc_timer_stop_self, a dynamic timer example);

-#else

-/* 用户应用入口 */

-int rt_application_init()

-{

-	timer_stop_self_init();

-

-	return 0;

-}

-#endif

+/*
+ * 程序清单：动态定时器例程
+ *
+ * 这个例程会创建1个动态周期型定时器对象
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* 定时器的控制块 */
+static rt_timer_t timer1;
+static rt_uint8_t count;
+
+/* 定时器超时函数 */
+static void timeout1(void* parameter)
+{
+	rt_kprintf("periodic timer is timeout\n");
+
+	count ++;
+	/* 停止定时器自身 */
+	if (count >= 8)
+	{
+		/* 停止定时器 */
+		rt_timer_stop(timer1);
+		count = 0;
+	}
+}
+
+void timer_stop_self_init()
+{
+	/* 创建定时器1 */
+	timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */
+		timeout1, /* 超时时回调的处理函数 */
+		RT_NULL, /* 超时函数的入口参数 */
+		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
+		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
+	/* 启动定时器 */
+	if (timer1 != RT_NULL)
+		rt_timer_start(timer1);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+	rt_enter_critical();
+
+	/* 删除定时器对象 */
+	rt_timer_delete(timer1);
+	timer1 = RT_NULL;
+
+	/* 调度器解锁 */
+	rt_exit_critical();
+
+	/* 设置TestCase状态 */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_timer_stop_self()
+{
+	/* 设置TestCase清理回调函数 */
+	tc_cleanup(_tc_cleanup);
+
+	/* 执行定时器例程 */
+	count = 0;
+	timer_stop_self_init();
+
+	/* 返回TestCase运行的最长时间 */
+	return 100;
+}
+/* 输出函数命令到finsh shell中 */
+FINSH_FUNCTION_EXPORT(_tc_timer_stop_self, a dynamic timer example);
+#else
+/* 用户应用入口 */
+int rt_application_init()
+{
+	timer_stop_self_init();
+
+	return 0;
+}
+#endif
diff --git a/examples/kernel/timer_timeout.c b/examples/kernel/timer_timeout.c
index d82754e557..80241e53f2 100644
--- a/examples/kernel/timer_timeout.c
+++ b/examples/kernel/timer_timeout.c
@@ -1,122 +1,122 @@
-/*

- * �����嵥����Ϣ��������

- *

- * �������ᴴ��3����̬�̣߳�һ���̻߳����Ϣ��������ȡ��Ϣ��һ���̻߳ᶨʱ����

- * Ϣ���з�����Ϣ��һ���̻߳ᶨʱ����Ϣ���з��ͽ�����Ϣ��

- */

-#include <rtthread.h>

-#include "tc_comm.h"

-

-/* ָ���߳̿��ƿ��ָ�� */

-static rt_thread_t tid = RT_NULL;

-

-/* ��Ϣ���п��ƿ� */

-static struct rt_messagequeue mq;

-/* ��Ϣ�������õ��ķ�����Ϣ���ڴ�� */

-static char msg_pool[2048];

-

-/* ��ʱ���Ŀ��ƿ� */

-static struct rt_timer timer;

-static rt_uint16_t no = 0;

-static void timer_timeout(void* parameter)

-{

-	char buf[32];

-	rt_uint32_t length;

-

-	length = rt_snprintf(buf, sizeof(buf), "message %d", no++);

-	rt_mq_send(&mq, &buf[0], length);

-}

-

-/* �߳���ں��� */

-static void thread_entry(void* parameter)

-{

-	char buf[64];

-	rt_err_t result;

-

-	/* ��ʼ����ʱ�� */

-	rt_timer_init(&timer, "timer",  /* ��ʱ�������� timer1 */

-		timer_timeout, /* ��ʱʱ�ص��Ĵ������� */

-		RT_NULL, /* ��ʱ��������ڲ��� */

-		1, /* ��ʱ���ȣ���OS TickΪ��λ����1��OS Tick */

-		RT_TIMER_FLAG_PERIODIC); /* �����Զ�ʱ�� */

-

-	while (1)

-	{

-		rt_memset(&buf[0], 0, sizeof(buf));

-

-		/* ����Ϣ�����н�����Ϣ */

-		result = rt_mq_recv(&mq, &buf[0], sizeof(buf), 1);

-		if (result == RT_EOK)

-		{

-			rt_kprintf("recv msg: %s\n", buf);

-		}

-		else if (result == -RT_ETIMEOUT)

-		{

-			rt_kprintf("recv msg timeout\n");

-		}

-	}

-}

-

-int timer_timeout_init()

-{

-	/* ��ʼ����Ϣ���� */

-	rt_mq_init(&mq, "mqt", 

-		&msg_pool[0], /* �ڴ��ָ��msg_pool */ 

-		128 - sizeof(void*), /* ÿ����Ϣ�Ĵ�С�� 128 - void* */

-		sizeof(msg_pool), /* �ڴ�صĴ�С��msg_pool�Ĵ�С */

-		RT_IPC_FLAG_FIFO); /* ����ж���̵߳ȴ������������ȵõ��ķ���������Ϣ */

-

-	/* �����߳� */

-	tid = rt_thread_create("t",

-		thread_entry, RT_NULL, /* �߳������thread_entry, ��ڲ�����RT_NULL */

-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);

-	if (tid != RT_NULL)

-		rt_thread_startup(tid);

-	else

-		tc_stat(TC_STAT_END | TC_STAT_FAILED);

-

-	return 0;

-}

-

-#ifdef RT_USING_TC

-static void _tc_cleanup()

-{

-	/* �����������������󣬽������л��������̣߳�����Ӧ�ж� */

-	rt_enter_critical();

-

-	/* ɾ���߳� */

-	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)

-		rt_thread_delete(tid);

-

-	/* ִ����Ϣ���ж������� */

-	rt_mq_detach(&mq);

-	/* ִ�ж�ʱ������ */

-	rt_timer_detach(&timer);

-

-	/* ���������� */

-	rt_exit_critical();

-

-	/* ����TestCase״̬ */

-	tc_done(TC_STAT_PASSED);

-}

-

-int _tc_timer_timeout()

-{

-	/* ����TestCase�����ص����� */

-	tc_cleanup(_tc_cleanup);

-	timer_timeout_init();

-

-	/* ����TestCase���е��ʱ�� */

-	return 100;

-}

-/* ����������finsh shell�� */

-FINSH_FUNCTION_EXPORT(_tc_timer_timeout, a thread timer testcase);

-#else

-/* �û�Ӧ����� */

-int rt_application_init()

-{

-	timer_timeout_init();

-

-	return 0;

-}

-#endif

+/*
+ * �����嵥����Ϣ��������
+ *
+ * �������ᴴ��3����̬�̣߳�һ���̻߳����Ϣ��������ȡ��Ϣ��һ���̻߳ᶨʱ����
+ * Ϣ���з�����Ϣ��һ���̻߳ᶨʱ����Ϣ���з��ͽ�����Ϣ��
+ */
+#include <rtthread.h>
+#include "tc_comm.h"
+
+/* ָ���߳̿��ƿ��ָ�� */
+static rt_thread_t tid = RT_NULL;
+
+/* ��Ϣ���п��ƿ� */
+static struct rt_messagequeue mq;
+/* ��Ϣ�������õ��ķ�����Ϣ���ڴ�� */
+static char msg_pool[2048];
+
+/* ��ʱ���Ŀ��ƿ� */
+static struct rt_timer timer;
+static rt_uint16_t no = 0;
+static void timer_timeout(void* parameter)
+{
+	char buf[32];
+	rt_uint32_t length;
+
+	length = rt_snprintf(buf, sizeof(buf), "message %d", no++);
+	rt_mq_send(&mq, &buf[0], length);
+}
+
+/* �߳���ں��� */
+static void thread_entry(void* parameter)
+{
+	char buf[64];
+	rt_err_t result;
+
+	/* ��ʼ����ʱ�� */
+	rt_timer_init(&timer, "timer",  /* ��ʱ�������� timer1 */
+		timer_timeout, /* ��ʱʱ�ص��Ĵ������� */
+		RT_NULL, /* ��ʱ��������ڲ��� */
+		1, /* ��ʱ���ȣ���OS TickΪ��λ����1��OS Tick */
+		RT_TIMER_FLAG_PERIODIC); /* �����Զ�ʱ�� */
+
+	while (1)
+	{
+		rt_memset(&buf[0], 0, sizeof(buf));
+
+		/* ����Ϣ�����н�����Ϣ */
+		result = rt_mq_recv(&mq, &buf[0], sizeof(buf), 1);
+		if (result == RT_EOK)
+		{
+			rt_kprintf("recv msg: %s\n", buf);
+		}
+		else if (result == -RT_ETIMEOUT)
+		{
+			rt_kprintf("recv msg timeout\n");
+		}
+	}
+}
+
+int timer_timeout_init()
+{
+	/* ��ʼ����Ϣ���� */
+	rt_mq_init(&mq, "mqt", 
+		&msg_pool[0], /* �ڴ��ָ��msg_pool */ 
+		128 - sizeof(void*), /* ÿ����Ϣ�Ĵ�С�� 128 - void* */
+		sizeof(msg_pool), /* �ڴ�صĴ�С��msg_pool�Ĵ�С */
+		RT_IPC_FLAG_FIFO); /* ����ж���̵߳ȴ������������ȵõ��ķ���������Ϣ */
+
+	/* �����߳� */
+	tid = rt_thread_create("t",
+		thread_entry, RT_NULL, /* �߳������thread_entry, ��ڲ�����RT_NULL */
+		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+	if (tid != RT_NULL)
+		rt_thread_startup(tid);
+	else
+		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+	return 0;
+}
+
+#ifdef RT_USING_TC
+static void _tc_cleanup()
+{
+	/* �����������������󣬽������л��������̣߳�����Ӧ�ж� */
+	rt_enter_critical();
+
+	/* ɾ���߳� */
+	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
+		rt_thread_delete(tid);
+
+	/* ִ����Ϣ���ж������� */
+	rt_mq_detach(&mq);
+	/* ִ�ж�ʱ������ */
+	rt_timer_detach(&timer);
+
+	/* ���������� */
+	rt_exit_critical();
+
+	/* ����TestCase״̬ */
+	tc_done(TC_STAT_PASSED);
+}
+
+int _tc_timer_timeout()
+{
+	/* ����TestCase�����ص����� */
+	tc_cleanup(_tc_cleanup);
+	timer_timeout_init();
+
+	/* ����TestCase���е��ʱ�� */
+	return 100;
+}
+/* ����������finsh shell�� */
+FINSH_FUNCTION_EXPORT(_tc_timer_timeout, a thread timer testcase);
+#else
+/* �û�Ӧ����� */
+int rt_application_init()
+{
+	timer_timeout_init();
+
+	return 0;
+}
+#endif