Merge branch 'master' into SQLite_on_ARMCC

bsp/simulator/SConstruct

@@ -7,17 +7,9 @@ if os.getenv('RTT_ROOT'):
 else:
     RTT_ROOT = os.path.normpath(os.getcwd() + '/../..')
 
-if os.getenv('RTT_RTGUI'):
-    RTT_RTGUI = os.getenv('RTT_RTGUI')
-else:
-    # set the rtgui root directory by hand
-    # empty string means use the RTGUI in svn
-    RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
-
 sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
 from building import *
 
-
 env = Environment(TARGET_ARCH='x86')
 
 Export('RTT_ROOT')
@@ -84,32 +76,7 @@ else:
 
 # prepare building environment
 
-objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False, remove_components=['rtgui'])
-if GetDepend('RT_USING_RTGUI'):
-    try:
-        if RTT_RTGUI:
-            objs += SConscript(os.path.join(RTT_RTGUI, 'SConscript'),
-                                   variant_dir='build/components/rtgui',
-                                   duplicate=0)
-            objs = objs + SConscript(RTT_RTGUI+'/../../demo/examples/SConscript',
-                        variant_dir='build/examples/gui', duplicate=0)
-        else:
-            objs += SConscript(os.path.join(RTT_ROOT + '/components/rtgui', 'SConscript'),
-                                   variant_dir='build/components/rtgui',
-                                   duplicate=0)
-            objs = objs + SConscript(RTT_ROOT + '/examples/gui/SConscript',
-                    variant_dir='build/examples/gui', duplicate=0)
-    except:
-        print
-        print 'RTGUI configuration is invalid!'
-        print 'RT_USING_RTGUI is enabled in rtconfig.h, but scons cannot find '+\
-              'RTGUI source code. In order to eliminate this error, you can '+\
-              'add RTT_RTGUI in environment to point RTGUI source code, or '+\
-              'disable RT_USING_RTGUI in rtconfig.h'
-        exit(-1);
-
-if GetDepend('RT_USING_TC'):
-    objs = objs + SConscript(RTT_ROOT + '/examples/kernel/SConscript', variant_dir = 'build/tc/kernel', duplicate=0)
+objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False)
 
 def ObjRemove(objs, remove):
     for item in objs:

bsp/simulator/applications/application.c

@@ -40,10 +40,6 @@ void rt_init_thread_entry(void *parameter)
     rt_hw_sdl_start();
 #endif /* RT_USING_RTGUI */
 
-#if defined(RT_USING_COMPONENTS_INIT) && defined(__GNUC__) && defined(RT_USING_FINSH)
-    finsh_set_device(RT_CONSOLE_DEVICE_NAME);
-#endif
-
     /* File system Initialization */
 #ifdef RT_USING_DFS
     {
@@ -94,17 +90,6 @@ void rt_init_thread_entry(void *parameter)
 #endif
 }
 
-static void rt_test_thread_entry(void *parameter)
-{
-    int i;
-    for (i = 0; i < 5; i++)
-    {
-        rt_kprintf("hello, world\n");
-        rt_thread_delay(RT_TICK_PER_SECOND);
-    }
-}
-
-
 int rt_application_init()
 {
     rt_thread_t tid;
@@ -116,12 +101,6 @@ int rt_application_init()
     if (tid != RT_NULL)
         rt_thread_startup(tid);
 
-    tid = rt_thread_create("test",
-                           rt_test_thread_entry, RT_NULL,
-                           2048, RT_THREAD_PRIORITY_MAX * 3 / 4, 20);
-    if (tid != RT_NULL)
-        rt_thread_startup(tid);
-
     return 0;
 }
 

bsp/simulator/readme.txt

@@ -1,9 +1,10 @@
 说明: 本BSP可以如下演示
 依赖软件包
-    python2.7 (python2.6使用scons --target=vs -s生成工程会出现错误） 
+    python2.7 (python2.6无法生成vs工程）
 
 一 平台及组件支持
 目前rtconfig.py中支持的编译器有
+
 1). msvc 用于windows平台
   此平台支持的组件
     kernel
@@ -24,38 +25,21 @@
     DFS, ELM FatFS, UFFS
     RTGUI
 
+请根据自己的实际情况，修改rtconfig.py中CROSS_TOOL为上述某一值。
+
 二 组件配置
 1) RTGUI
-当前代码中已经不含RTGUI源码，因此读者需要配置一下才能在simulator中使用RTGUI
-RTGUI的最新源码目前是托管在github上：https://github.com/RT-Thread/RTGUI
-共有两种方法。
-方法1 添加环境变量
-   向系统加入RTT_RTGUI环境变量，其值为刚才github上下载的rtgui源码包的路径。
-   例如笔者的rtgui源码包解压至 F:\Project\git\rt-gui\下， 则将此环境变量配置为 F:\Project\git\rt-gui\components\rtgui
-方法2 不添加环境变量
-   打开SConstruct文件，
- ....
- 10 if os.getenv('RTT_RTGUI'):
- 11     RTT_RTGUI = os.getenv('RTT_RTGUI')
- 12 else:
- 13     # set the rtgui root directory by hand
- 14     # empty string means use the RTGUI in svn
- 15     # RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
- 16     RTT_RTGUI =''         
- ....
-将15，16行修改为
- 14     # empty string means use the RTGUI in svn
- 15     RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
- 16     # RTT_RTGUI =''         
-简单说明一下：
-   1)#号表示注释，类似于c语言中的//，
-   2)其中15行的路径为你的RTGUI路径源码，注意不是压缩包路径，而是压缩包路径下的 components\rtgui目录的绝对路径。
+RTGUI的最新源码目前托管在github上：https://github.com/RT-Thread/RTGUI
+下载最新的RTGUI源码，将RTGUI源码包中components下的rtgui目录复制到Rt-thread的components目录下。
 
 三 编译
 1) 使用Visual Studio(2005以上版本)
 在当前目录中打开cmd，输入命令
 `scons --target=vs -s`
-可以生成project.vsproj，双击运行
+生成vs2005的project.vsproj，使用vs2005及以上版本可以打开(VS2005需要转换工程）。
+
+或直接生成vs2012工程
+`scons --target=vs2012 -s`
 
 2) 命令行编译
 修改rtconfig.py, 配置合适的编译器(msvc/mingw/gcc)，及其路径
@@ -73,31 +57,23 @@ RTGUI的最新源码目前是托管在github上：https://github.com/RT-Thread/R
 按下回车，出现finsh，然后输入`mkfs("elm", "sd0")`格式化SD卡，如下所示
 	finsh>>mkfs("elm", "sd0")
 			0, 0x00000000
-然后重启程序，就可以看到fatfs挂载成功了
+重启程序，可以正确挂载fat文件系统。
 
 2) 测试RTGUI
-启动后就会看到GUI窗口，分辨率800x480，此时在finsh中输入snake_main()并回车，即可运行贪吃蛇程序
+打开RTGUI组件后编译，启动在finsh中输入snake_main()并回车，可运行贪吃蛇程序
 
 3) 测试APP module
-rtconfig.h中需要打开RT_USING_MODULE
+在rtconfig.h中打开RT_USING_MODULE
+
+测试app module需要执行3步，如下a, b, c所示。
 
 a. 生成rtthread.def文件
-使用msv编译主程序时需要此文件，使用MingW编译主程序时不需要
-msvc需要此文件才能生成正确导出符号的rtthread.dll和rtthread-win32.exe。
-此目录下默认自带了一个rtthread.def文件，当修改了rtconfig.h，禁用了某些组件时，则需要重新生成rtthread.def文件.
-生成方法：
-需要借助MingW工具，修改rtconfig.py中CROSS_TOOL为'mingw'，然后打开CMD执行`scons --def`就会自动更新rtthread.def。
+执行`scons --def`可以自动生成rtthread.def。
+当修改了rtconfig.h，打开或禁用了某些组件时，需要重新生成rtthread.def文件.
 
 b. 生成主程序
-  主程序可以使用msvc和mingw生成
-  如果rtconfig.h中的使能了RTGUI，则需要参考第二节第1小节配置RTGUI
-  a.1 使用msvc
-	  修改rtconfig.py中CROSS_TOOL为'msvc'
-	  首先要保证当前目录下有合适的rtthread.def文件，如果没有对默认的rtconfig.h作修改，则使用默认的rtthread.def即可
-	  CMD命令行执行`scons -j4`，即可生成rtthread.dll和 rtthread-win32.exe
-  a.2 使用mingw
-	  修改rtconfig.py中CROSS_TOOL为'mingw'
-	  CMD命令行执行`scons -j4`，这就会生成 rtthread.dll和 rtthread-win32.exe
+
+  `scons -j4`
 
 c. 生成app module
   进入testdll目录，再次修改 testdll/SConstruct， 同样需要配置RTT_RTGUI路径，同 1中3)
@@ -107,8 +83,8 @@ c. 生成app module
 
   然后运行simulator目录下的 rtthread-win32.exe, 在finsh中运行   
     `exec("/testdll/basicapp/build/basicapp.dll")` 
-  如果觉得这个路径太长，就把 basicapp.dll复制到 simualtor目录下，执行
+  如果觉得这个路径太长，可以将basicapp.dll复制到 simualtor目录下，执行
     `exec("/basicapp.dll")`
 
   编译贪吃蛇程序
-  执行`scons --app=snake`，就会在snake/build/下生成snake.dll，按照同样的方式加载即可
+  执行`scons --app=snake`，会在snake/build/下生成snake.dll，按照同样的方式加载即可

bsp/simulator/rtconfig.h

@@ -209,7 +209,7 @@
 #define RT_LWIP_TCP_WND		8192
 
 /* SECTION: RT-Thread/GUI */
-#define RT_USING_RTGUI
+/* #define RT_USING_RTGUI */
 
 /* name length of RTGUI object */
 #define RTGUI_NAME_MAX		12

components/dfs/filesystems/elmfat/ff.c

@@ -108,12 +108,8 @@
 #if _MAX_SS != 512 && _MAX_SS != 1024 && _MAX_SS != 2048 && _MAX_SS != 4096
 #error Wrong sector size.
 #endif
-#if _MAX_SS != 512
-#define	SS(fs)	((fs)->ssize)	/* Multiple sector size */
-#else
-#define	SS(fs)	512U			/* Fixed sector size */
-#endif
 
+#define	SS(fs)	((fs)->ssize)	/* sector size */
 
 /* Reentrancy related */
 #if _FS_REENTRANT
@@ -2058,10 +2054,11 @@ FRESULT chk_mounted (	/* FR_OK(0): successful, !=0: any error occurred */
 	stat = disk_initialize(fs->drv);	/* Initialize low level disk I/O layer */
 	if (stat & STA_NOINIT)				/* Check if the initialization succeeded */
 		return FR_NOT_READY;			/* Failed to initialize due to no media or hard error */
-#if _MAX_SS != 512						/* Get disk sector size (variable sector size cfg only) */
+
+	/* Get disk sector size (variable sector size cfg only) */
 	if (disk_ioctl(fs->drv, GET_SECTOR_SIZE, &fs->ssize) != RES_OK)
 		return FR_DISK_ERR;
-#endif
+
 #if !_FS_READONLY
 	if (chk_wp && (stat & STA_PROTECT))	/* Check disk write protection if needed */
 		return FR_WRITE_PROTECTED;
@@ -3601,10 +3598,10 @@ FRESULT f_mkfs (
 	stat = disk_initialize(drv);
 	if (stat & STA_NOINIT) return FR_NOT_READY;
 	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
-#if _MAX_SS != 512					/* Get disk sector size */
+	/* Get disk sector size */
 	if (disk_ioctl(drv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK)
 		return FR_DISK_ERR;
-#endif
+
 	if (disk_ioctl(drv, GET_SECTOR_COUNT, &n_vol) != RES_OK || n_vol < 128)
 		return FR_DISK_ERR;
 	b_vol = (sfd) ? 0 : 63;	/* Volume start sector */

components/dfs/filesystems/elmfat/ff.h

@@ -84,9 +84,7 @@ typedef struct {
 	BYTE	fsi_flag;		/* fsinfo dirty flag (1:must be written back) */
 	WORD	id;				/* File system mount ID */
 	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
-#if _MAX_SS != 512
 	WORD	ssize;			/* Bytes per sector (512,1024,2048,4096) */
-#endif
 #if _FS_REENTRANT
 	_SYNC_t	sobj;			/* Identifier of sync object */
 #endif

components/dfs/src/dfs_fs.c

@@ -37,48 +37,36 @@
  *
  * @param ops the file system instance to be registered.
  *
- * @return 0 on successful, -1 on failed.
+ * @return RT_EOK on successful, -RT_ERROR on failed.
  */
 int dfs_register(const struct dfs_filesystem_operation *ops)
 {
-    int index, result;
-    int free_index;
-
-    result = 0;
-    free_index = DFS_FILESYSTEM_TYPES_MAX;
+    int ret = RT_EOK;
+    const struct dfs_filesystem_operation **empty = RT_NULL;
+    const struct dfs_filesystem_operation **iter;
 
     /* lock filesystem */
     dfs_lock();
-
     /* check if this filesystem was already registered */
-    for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++)
+    for (iter = &filesystem_operation_table[0];
+           iter < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; iter ++)
     {
-        if (filesystem_operation_table[index] == RT_NULL)
-        {
-            /* find out an empty filesystem type entry */
-            if (free_index == DFS_FILESYSTEM_TYPES_MAX)
-                free_index = index;
-        }
-        else if (strcmp(filesystem_operation_table[index]->name, ops->name) == 0)
+        /* find out an empty filesystem type entry */
+        if (*iter == RT_NULL)
+            (empty == RT_NULL) ? (empty = iter) : 0;
+        else if (strcmp((*iter)->name, ops->name) == 0)
         {
-            result = -1;
-            goto err;
+            ret = -1;
+            break;
         }
     }
 
-    /* filesystem type table full */
-    if (free_index == DFS_FILESYSTEM_TYPES_MAX)
-    {
-        result = -1;
-        goto err;
-    }
-
     /* save the filesystem's operations */
-    filesystem_operation_table[free_index] = ops;
+    if ((ret == RT_EOK) && (empty != RT_NULL))
+        *empty = ops;
 
-err:
     dfs_unlock();
-    return result;
+    return ret;
 }
 
 /**
@@ -91,37 +79,33 @@ err:
  */
 struct dfs_filesystem *dfs_filesystem_lookup(const char *path)
 {
-    struct dfs_filesystem *fs;
-    rt_uint32_t index, fspath, prefixlen;
+    struct dfs_filesystem *iter;
+    struct dfs_filesystem *fs = RT_NULL;
+    rt_uint32_t fspath, prefixlen;
 
-    fs = RT_NULL;
     prefixlen = 0;
 
     /* lock filesystem */
     dfs_lock();
 
     /* lookup it in the filesystem table */
-    for (index = 0; index < DFS_FILESYSTEMS_MAX; index++)
+    for (iter = &filesystem_table[0];
+            iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
     {
-        if (filesystem_table[index].path == RT_NULL)
+        if ((iter->path == RT_NULL) || (iter->ops == RT_NULL))
             continue;
-        else
-        {
-            fspath = strlen(filesystem_table[index].path);
-            if (fspath < prefixlen)
-                continue;
-        }
 
-        if ((filesystem_table[index].ops != RT_NULL) &&
-            (strncmp(filesystem_table[index].path, path, fspath) == 0))
-        {
-            /* check next path separator */
-            if (fspath > 1 && (strlen(path) > fspath) && (path[fspath] != '/'))
-                continue;
+        fspath = strlen(iter->path);
+        if ((fspath < prefixlen)
+            || (strncmp(iter->path, path, fspath) != 0))
+            continue;
 
-            fs = &filesystem_table[index];
-            prefixlen = fspath;
-        }
+        /* check next path separator */
+        if (fspath > 1 && (strlen(path) > fspath) && (path[fspath] != '/'))
+            continue;
+
+        fs = iter;
+        prefixlen = fspath;
     }
 
     dfs_unlock();
@@ -147,64 +131,42 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition *part,
 
     rt_uint8_t *dpt;
     rt_uint8_t type;
-    rt_err_t result;
 
     RT_ASSERT(part != RT_NULL);
     RT_ASSERT(buf != RT_NULL);
 
-    result = RT_EOK;
-
     dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE;
 
+    /* check if it is a valid partition table */
     if ((*dpt != 0x80) && (*dpt != 0x00))
-    {
-        /* which is not a partition table */
-        result = -RT_ERROR;
-
-        return result;
-    }
+        return -RT_ERROR;
 
     /* get partition type */
     type = *(dpt+4);
-
-    if (type != 0)
-    {
-        /* set partition type */
-        part->type = type;
-
-        /* get partition offset and size */
-        part->offset = *(dpt+8) | *(dpt+9)<<8 | *(dpt+10)<<16 | *(dpt+11)<<24;
-        part->size = *(dpt+12) | *(dpt+13)<<8 | *(dpt+14)<<16 | *(dpt+15)<<24;
-
-        rt_kprintf("found part[%d], begin: %d, size: ",
-                   pindex, part->offset*512);
-        if ((part->size>>11) > 0) /* MB */
-        {
-            unsigned int part_size;
-            part_size = part->size >> 11;/* MB */
-            if ((part_size>>10) > 0) /* GB */
-            {
-                /* GB */
-                rt_kprintf("%d.%d%s",part_size>>10,part_size&0x3FF,"GB\r\n");
-            }
-            else
-            {
-                /* MB */
-                rt_kprintf("%d.%d%s",part_size,(part->size>>1)&0x3FF,"MB\r\n");
-            }
-        }
-        else
-        {
-            /* KB */
-            rt_kprintf("%d%s",part->size>>1,"KB\r\n");
-        }
-    }
+    if (type == 0)
+        return -RT_ERROR;
+
+    /* set partition information
+     *    size is the number of 512-Byte */
+    part->type = type;
+    part->offset = *(dpt+8) | *(dpt+9)<<8 | *(dpt+10)<<16 | *(dpt+11)<<24;
+    part->size = *(dpt+12) | *(dpt+13)<<8 | *(dpt+14)<<16 | *(dpt+15)<<24;
+
+    rt_kprintf("found part[%d], begin: %d, size: ",
+               pindex, part->offset*512);
+    if ((part->size>>11) == 0)
+        rt_kprintf("%d%s",part->size>>1,"KB\n");     /* KB */
     else
     {
-        result = -RT_ERROR;
+        unsigned int part_size;
+        part_size = part->size >> 11;                /* MB */
+        if ((part_size>>10) == 0)
+            rt_kprintf("%d.%d%s",part_size,(part->size>>1)&0x3FF,"MB\n");
+        else
+            rt_kprintf("%d.%d%s",part_size>>10,part_size&0x3FF,"GB\n");
     }
 
-    return result;
+    return RT_EOK;
 }
 
 /**
@@ -224,57 +186,54 @@ int dfs_mount(const char   *device_name,
               unsigned long rwflag,
               const void   *data)
 {
-    const struct dfs_filesystem_operation *ops;
-    struct dfs_filesystem *fs;
-    char *fullpath=RT_NULL;
+    const struct dfs_filesystem_operation **ops;
+    struct dfs_filesystem *iter;
+    struct dfs_filesystem *fs = RT_NULL;
+    char *fullpath = RT_NULL;
     rt_device_t dev_id;
-    int index, free_index;
 
     /* open specific device */
-    if (device_name != RT_NULL)
+    if (device_name == RT_NULL)
     {
-        dev_id = rt_device_find(device_name);
-        if (dev_id == RT_NULL)
-        {
-            /* no this device */
-            rt_set_errno(-DFS_STATUS_ENODEV);
-
-            return -1;
-        }
+        /* which is a non-device filesystem mount */
+        dev_id = NULL;
     }
-    else
+    else if ((dev_id = rt_device_find(device_name)) == RT_NULL)
     {
-        /* which is a non-device filesystem mount */
-        dev_id = RT_NULL;
+        /* no this device */
+        rt_set_errno(-DFS_STATUS_ENODEV);
+        return -1;
     }
 
-    /* find out specific filesystem */
+    /* find out the specific filesystem */
     dfs_lock();
-    for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++)
-    {
-        if (filesystem_operation_table[index] == RT_NULL)
-            continue;
 
-        if (strcmp(filesystem_operation_table[index]->name, filesystemtype) == 0)
+    for (ops = &filesystem_operation_table[0];
+           ops < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; ops++)
+        if ((ops != RT_NULL) && (strcmp((*ops)->name, filesystemtype) == 0))
             break;
-    }
+
     dfs_unlock();
 
-    /* can't find filesystem */
-    if (index == DFS_FILESYSTEM_TYPES_MAX)
+    if (ops == &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX])
     {
+        /* can't find filesystem */
         rt_set_errno(-DFS_STATUS_ENODEV);
+        return -1;
+    }
 
+    /* check if there is mount implementation */
+    if ((*ops == NULL) || ((*ops)->mount == NULL))
+    {
+        rt_set_errno(-DFS_STATUS_ENOSYS);
         return -1;
     }
-    ops = filesystem_operation_table[index];
 
     /* make full path for special file */
     fullpath = dfs_normalize_path(RT_NULL, path);
     if (fullpath == RT_NULL) /* not an abstract path */
     {
         rt_set_errno(-DFS_STATUS_ENOTDIR);
-
         return -1;
     }
 
@@ -293,60 +252,52 @@ int dfs_mount(const char   *device_name,
         dfs_file_close(&fd);
     }
 
-    free_index = DFS_FILESYSTEMS_MAX;
-    /* check whether the file system mounted or not */
+    /* check whether the file system mounted or not  in the filesystem table
+     * if it is unmounted yet, find out an empty entry */
     dfs_lock();
-    for (index = 0; index < DFS_FILESYSTEMS_MAX; index ++)
+
+    for (iter = &filesystem_table[0];
+            iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
     {
-        if (filesystem_table[index].ops == RT_NULL)
-        {
-            /* find out an empty filesystem table entry */
-            if (free_index == DFS_FILESYSTEMS_MAX)
-                free_index = index;
-        }
-        else if (strcmp(filesystem_table[index].path, path) == 0)
+        /* check if it is an empty filesystem table entry? if it is, save fs */
+        if (iter->ops == RT_NULL)
+            (fs == RT_NULL) ? (fs = iter) : 0;
+        /* check if the PATH is mounted */
+        else if (strcmp(iter->path, path) == 0)
         {
             rt_set_errno(-DFS_STATUS_EINVAL);
             goto err1;
         }
     }
 
-    /* can't find en empty filesystem table entry */
-    if (free_index == DFS_FILESYSTEMS_MAX)
+    if ((fs == RT_NULL) && (iter == &filesystem_table[DFS_FILESYSTEMS_MAX]))
     {
         rt_set_errno(-DFS_STATUS_ENOSPC);
         goto err1;
     }
 
     /* register file system */
-    fs         = &(filesystem_table[free_index]);
     fs->path   = fullpath;
-    fs->ops    = ops;
+    fs->ops    = *ops;
     fs->dev_id = dev_id;
     /* release filesystem_table lock */
     dfs_unlock();
 
     /* open device, but do not check the status of device */
     if (dev_id != RT_NULL)
-        rt_device_open(fs->dev_id, RT_DEVICE_OFLAG_RDWR);
-
-    /* there is no mount implementation */
-    if (ops->mount == RT_NULL)
     {
-        if (dev_id != RT_NULL)
-            rt_device_close(dev_id);
-        dfs_lock();
-        /* clear filesystem table entry */
-        rt_memset(fs, 0, sizeof(struct dfs_filesystem));
-        dfs_unlock();
-
-        rt_free(fullpath);
-        rt_set_errno(-DFS_STATUS_ENOSYS);
-
-        return -1;
+        if (rt_device_open(fs->dev_id,
+                           RT_DEVICE_OFLAG_RDWR) != RT_EOK)
+        {
+            /* The underlaying device has error, clear the entry. */
+            dfs_lock();
+            rt_memset(fs, 0, sizeof(struct dfs_filesystem));
+            goto err1;
+        }
     }
+
     /* call mount of this filesystem */
-    else if (ops->mount(fs, rwflag, data) < 0)
+    if ((*ops)->mount(fs, rwflag, data) < 0)
     {
         /* close device */
         if (dev_id != RT_NULL)
@@ -356,19 +307,14 @@ int dfs_mount(const char   *device_name,
         dfs_lock();
         /* clear filesystem table entry */
         rt_memset(fs, 0, sizeof(struct dfs_filesystem));
-        dfs_unlock();
-
-        rt_free(fullpath);
-
-        return -1;
+        goto err1;
     }
 
     return 0;
 
 err1:
     dfs_unlock();
-    if (fullpath != RT_NULL)
-        rt_free(fullpath);
+    rt_free(fullpath);
 
     return -1;
 }
@@ -383,6 +329,7 @@ err1:
 int dfs_unmount(const char *specialfile)
 {
     char *fullpath;
+    struct dfs_filesystem *iter;
     struct dfs_filesystem *fs = RT_NULL;
 
     fullpath = dfs_normalize_path(RT_NULL, specialfile);
@@ -396,7 +343,17 @@ int dfs_unmount(const char *specialfile)
     /* lock filesystem */
     dfs_lock();
 
-    fs = dfs_filesystem_lookup(fullpath);
+    for (iter = &filesystem_table[0];
+            iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
+    {
+        /* check if the PATH is mounted */
+        if ((iter->path != NULL) && (strcmp(iter->path, fullpath) == 0))
+        {
+            fs = iter;
+            break;
+        }
+    }
+
     if (fs == RT_NULL ||
         fs->ops->unmount == RT_NULL ||
         fs->ops->unmount(fs) < 0)
@@ -437,12 +394,10 @@ err1:
 int dfs_mkfs(const char *fs_name, const char *device_name)
 {
     int index;
-    rt_device_t dev_id;
+    rt_device_t dev_id = RT_NULL;
 
     /* check device name, and it should not be NULL */
-    if (device_name == RT_NULL)
-        dev_id = RT_NULL;
-    else
+    if (device_name != RT_NULL)
         dev_id = rt_device_find(device_name);
 
     if (dev_id == RT_NULL)
@@ -458,19 +413,23 @@ int dfs_mkfs(const char *fs_name, const char *device_name)
     {
         if (filesystem_operation_table[index] != RT_NULL &&
             strcmp(filesystem_operation_table[index]->name, fs_name) == 0)
-        {
-            /* find file system operation */
-            const struct dfs_filesystem_operation *ops = filesystem_operation_table[index];
-            dfs_unlock();
-
-            if (ops->mkfs != RT_NULL)
-                return ops->mkfs(dev_id);
-
             break;
-        }
     }
     dfs_unlock();
 
+    if (index < DFS_FILESYSTEM_TYPES_MAX)
+    {
+        /* find file system operation */
+        const struct dfs_filesystem_operation *ops = filesystem_operation_table[index];
+        if (ops->mkfs == RT_NULL)
+        {
+            rt_set_errno(-DFS_STATUS_ENOSYS);
+            return -1;
+        }
+
+        return ops->mkfs(dev_id);
+    }
+
     rt_kprintf("Can not find the file system which named as %s.\n", fs_name);
     return -1;
 }
@@ -512,7 +471,7 @@ int dfs_mount_table(void)
 				mount_table[index].rwflag,
 				mount_table[index].data) != 0)
 		{
-			rt_kprintf("mount fs[%s] on %s failed.\n", mount_table[index].filesystemtype, 
+			rt_kprintf("mount fs[%s] on %s failed.\n", mount_table[index].filesystemtype,
 				mount_table[index].path);
 			return -RT_ERROR;
 		}
@@ -538,11 +497,7 @@ int df(const char *path)
     long long cap;
     struct statfs buffer;
 
-    if (path == RT_NULL)
-        result = dfs_statfs("/", &buffer);
-    else
-        result = dfs_statfs(path, &buffer);
-
+    result = dfs_statfs(path ? path : RT_NULL, &buffer);
     if (result != 0)
     {
         rt_kprintf("dfs_statfs failed.\n");

examples/kernel/cpuusage.c

@@ -1,70 +1,70 @@
 #include <rtthread.h>
 #include <rthw.h>
 
-#define CPU_USAGE_CALC_TICK	10
-#define CPU_USAGE_LOOP		100
+#define CPU_USAGE_CALC_TICK    10
+#define CPU_USAGE_LOOP        100
 
 static rt_uint8_t  cpu_usage_major = 0, cpu_usage_minor= 0;
 static rt_uint32_t total_count = 0;
 
 static void cpu_usage_idle_hook()
 {
-	rt_tick_t tick;
-	rt_uint32_t count;
-	volatile rt_uint32_t loop;
+    rt_tick_t tick;
+    rt_uint32_t count;
+    volatile rt_uint32_t loop;
 
-	if (total_count == 0)
-	{
-		/* get total count */
-		rt_enter_critical();
-		tick = rt_tick_get();
-		while(rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
-		{
-			total_count ++;
-			loop = 0;
-			while (loop < CPU_USAGE_LOOP) loop ++;
-		}
-		rt_exit_critical();
-	}
+    if (total_count == 0)
+    {
+        /* get total count */
+        rt_enter_critical();
+        tick = rt_tick_get();
+        while(rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
+        {
+            total_count ++;
+            loop = 0;
+            while (loop < CPU_USAGE_LOOP) loop ++;
+        }
+        rt_exit_critical();
+    }
 
-	count = 0;
-	/* get CPU usage */
-	tick = rt_tick_get();
-	while (rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
-	{
-		count ++;
-		loop  = 0;
-		while (loop < CPU_USAGE_LOOP) loop ++;
-	}
+    count = 0;
+    /* get CPU usage */
+    tick = rt_tick_get();
+    while (rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
+    {
+        count ++;
+        loop  = 0;
+        while (loop < CPU_USAGE_LOOP) loop ++;
+    }
 
-	/* calculate major and minor */
-	if (count < total_count)
-	{
-		count = total_count - count;
-		cpu_usage_major = (count * 100) / total_count;
-		cpu_usage_minor = ((count * 100) % total_count) * 100 / total_count;
-	}
-	else
-	{
-		total_count = count;
+    /* calculate major and minor */
+    if (count < total_count)
+    {
+        count = total_count - count;
+        cpu_usage_major = (count * 100) / total_count;
+        cpu_usage_minor = ((count * 100) % total_count) * 100 / total_count;
+    }
+    else
+    {
+        total_count = count;
 
-		/* no CPU usage */
-		cpu_usage_major = 0;
-		cpu_usage_minor = 0;
-	}
+        /* no CPU usage */
+        cpu_usage_major = 0;
+        cpu_usage_minor = 0;
+    }
 }
 
 void cpu_usage_get(rt_uint8_t *major, rt_uint8_t *minor)
 {
-	RT_ASSERT(major != RT_NULL);
-	RT_ASSERT(minor != RT_NULL);
+    RT_ASSERT(major != RT_NULL);
+    RT_ASSERT(minor != RT_NULL);
 
-	*major = cpu_usage_major;
-	*minor = cpu_usage_minor;
+    *major = cpu_usage_major;
+    *minor = cpu_usage_minor;
 }
 
 void cpu_usage_init()
 {
-	/* set idle thread hook */
-	rt_thread_idle_sethook(cpu_usage_idle_hook);
+    /* set idle thread hook */
+    rt_thread_idle_sethook(cpu_usage_idle_hook);
 }

examples/kernel/event_simple.c

@@ -20,124 +20,124 @@ static struct rt_event event;
 /* 线程1入口函数 */
 static void thread1_entry(void *param)
 {
-	rt_uint32_t e;
-
-	while (1)
-	{
-		/* receive first event */
-		if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
-			RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
-			RT_WAITING_FOREVER, &e) == RT_EOK)
-		{
-			rt_kprintf("thread1: AND recv event 0x%x\n", e);
-		}
-
-		rt_kprintf("thread1: delay 1s to prepare second event\n");
-		rt_thread_delay(10);
-
-		/* receive second event */
-		if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
-			RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
-			RT_WAITING_FOREVER, &e) == RT_EOK)
-		{
-			rt_kprintf("thread1: OR recv event 0x%x\n", e);
-		}
-
-		rt_thread_delay(5);
-	}
+    rt_uint32_t e;
+
+    while (1)
+    {
+        /* receive first event */
+        if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
+                          RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
+                          RT_WAITING_FOREVER, &e) == RT_EOK)
+        {
+            rt_kprintf("thread1: AND recv event 0x%x\n", e);
+        }
+
+        rt_kprintf("thread1: delay 1s to prepare second event\n");
+        rt_thread_delay(10);
+
+        /* receive second event */
+        if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
+                          RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                          RT_WAITING_FOREVER, &e) == RT_EOK)
+        {
+            rt_kprintf("thread1: OR recv event 0x%x\n", e);
+        }
+
+        rt_thread_delay(5);
+    }
 }
 
 /* 线程2入口函数 */
 static void thread2_entry(void *param)
 {
-	while (1)
-	{
-		rt_kprintf("thread2: send event1\n");
-		rt_event_send(&event, (1 << 3));
+    while (1)
+    {
+        rt_kprintf("thread2: send event1\n");
+        rt_event_send(&event, (1 << 3));
 
-		rt_thread_delay(10);
-	}
+        rt_thread_delay(10);
+    }
 }
 
 /* 线程3入口函数 */
 static void thread3_entry(void *param)
 {
-	while (1)
-	{
-		rt_kprintf("thread3: send event2\n");
-		rt_event_send(&event, (1 << 5));
+    while (1)
+    {
+        rt_kprintf("thread3: send event2\n");
+        rt_event_send(&event, (1 << 5));
 
-		rt_thread_delay(20);
-	}
+        rt_thread_delay(20);
+    }
 }
 
 int event_simple_init()
 {
-	/* 初始化事件对象 */
-	rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
-
-	/* 创建线程1 */
-	tid1 = rt_thread_create("t1",
-		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("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, THREAD_TIMESLICE);
-	if (tid3 != RT_NULL)
-		rt_thread_startup(tid3);
-	else
-		tc_stat(TC_STAT_END | TC_STAT_FAILED);
-
-	return 0;
+    /* 初始化事件对象 */
+    rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
+
+    /* 创建线程1 */
+    tid1 = rt_thread_create("t1",
+                            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("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, 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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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);
 
-	/* 执行事件对象脱离 */
-	rt_event_detach(&event);
+    /* 执行事件对象脱离 */
+    rt_event_detach(&event);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_event_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	event_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    event_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_event_simple, a simple event example);
@@ -145,8 +145,8 @@ FINSH_FUNCTION_EXPORT(_tc_event_simple, a simple event example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	event_simple_init();
+    event_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/heap_malloc.c

@@ -7,66 +7,68 @@
 
 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;
+    while (len)
+    {
+        if (*ptr != value)
+            return RT_FALSE;
+        ptr ++;
+        len --;
+    }
 
-		ptr ++;
-		len --;
-	}
-
-	return RT_TRUE;
+    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);
+    rt_uint8_t res = TC_STAT_PASSED;
+    rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
 
-	memset(ptr1, 1, 1);
-	memset(ptr2, 2, 13);
-	memset(ptr3, 3, 31);
-	memset(ptr4, 4, 127);
+    ptr1 = rt_malloc(1);
+    ptr2 = rt_malloc(13);
+    ptr3 = rt_malloc(31);
+    ptr4 = rt_malloc(127);
+    ptr5 = rt_malloc(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, 127) != RT_FALSE) goto _failed;
+    memset(ptr1, 1, 1);
+    memset(ptr2, 2, 13);
+    memset(ptr3, 3, 31);
+    memset(ptr4, 4, 127);
 
-	rt_free(ptr4);
-	rt_free(ptr3);
-	rt_free(ptr3);
-	rt_free(ptr1);
+    if (mem_check(ptr1, 1, 1)   == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr2, 2, 13)  == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr3, 3, 31)  == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr4, 4, 127) == RT_FALSE)
+        res = TC_STAT_FAILED;
 
-	if (ptr5 != RT_NULL)
-	{
-		rt_free(ptr5);
-	}
+    rt_free(ptr4);
+    rt_free(ptr3);
+    rt_free(ptr2);
+    rt_free(ptr1);
 
-	tc_done(TC_STAT_PASSED);
+    if (ptr5 != RT_NULL)
+    {
+        rt_free(ptr5);
+    }
 
-_failed:
-	tc_done(TC_STAT_FAILED);
+    tc_done(res);
 }
 
 #ifdef RT_USING_TC
 int _tc_heap_malloc()
 {
-	heap_malloc_init();
+    heap_malloc_init();
 
-	return 0;
+    return 0;
 }
 FINSH_FUNCTION_EXPORT(_tc_heap_malloc, a heap malloc test);
 #else
 int rt_application_init()
 {
-	heap_malloc_init();
+    heap_malloc_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/heap_realloc.c

@@ -7,77 +7,96 @@
 
 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;
+    while (len)
+    {
+        if (*ptr != value) return RT_FALSE;
 
-		ptr ++;
-		len --;
-	}
+        ptr ++;
+        len --;
+    }
 
-	return RT_TRUE;
+    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);
+    rt_uint8_t res = TC_STAT_PASSED;
+    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)
+    {
+        res = TC_STAT_FAILED;
+        goto _free;
+    }
+    if (mem_check(ptr2, 2, 13)  == RT_FALSE)
+    {
+        res = TC_STAT_FAILED;
+        goto _free;
+    }
+    if (mem_check(ptr3, 3, 31)  == RT_FALSE)
+    {
+        res = TC_STAT_FAILED;
+        goto _free;
+    }
+    if (mem_check(ptr4, 4, 127) == RT_FALSE)
+    {
+        res = TC_STAT_FAILED;
+        goto _free;
+    }
+
+    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 (ptr5)
+    {
+        rt_kprintf("realloc(ptr, 0) should return NULL\n");
+        res = TC_STAT_FAILED;
+    }
+
+    if (mem_check(ptr1, 1, 1)   == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr2, 2, 13)  == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr3, 3, 31)  == RT_FALSE)
+        res = TC_STAT_FAILED;
+    if (mem_check(ptr4, 4, 1)    == RT_FALSE)
+        res = TC_STAT_FAILED;
+
+_free:
+    rt_free(ptr4);
+    rt_free(ptr3);
+    rt_free(ptr2);
+    rt_free(ptr1);
+
+    tc_done(res);
 }
 
 #ifdef RT_USING_TC
 int _tc_heap_realloc()
 {
-	heap_realloc_init();
+    heap_realloc_init();
 
-	return 0;
+    return 0;
 }
 FINSH_FUNCTION_EXPORT(_tc_heap_realloc, a heap re-malloc test);
 #else
 int rt_application_init()
 {
-	heap_realloc_init();
+    heap_realloc_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/mbox_send_wait.c

@@ -22,110 +22,110 @@ static char mb_str2[] = "this is another mail!";
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	unsigned char* str;
-
-	while (1)
-	{
-		/* 从邮箱中收取邮件 */
-		if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
-		{
-			rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
-
-			/* 延时20个OS Tick */
-			rt_thread_delay(50);
-		}
-	}
+    unsigned char* str;
+
+    while (1)
+    {
+        /* 从邮箱中收取邮件 */
+        if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
+        {
+            rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
+
+            /* 延时20个OS Tick */
+            rt_thread_delay(50);
+        }
+    }
 }
 
 /* 线程2入口 */
 static void thread2_entry(void* parameter)
 {
-	rt_uint8_t count;
+    rt_uint8_t count;
     char  *str;
 
-	count = 0;
-	while (1)
-	{
-		count ++;
-		if (count & 0x1)
-		{
-			/* 发送mb_str1地址到邮箱中 */
+    count = 0;
+    while (1)
+    {
+        count ++;
+        if (count & 0x1)
+        {
+            /* 发送mb_str1地址到邮箱中 */
             str = mb_str1;
-		}
-		else
-		{
-			/* 发送mb_str2地址到邮箱中 */
+        }
+        else
+        {
+            /* 发送mb_str2地址到邮箱中 */
             str = mb_str2;
-		}
+        }
 
         /* 不停的发送邮件，如果满了则等待10个tick，然后超时 */
         if( rt_mb_send_wait(&mb, (rt_uint32_t)str,10) == RT_EOK )
             rt_kprintf("thread2: sent a mail to mailbox, the content:%s\n", str);
         else
             rt_kprintf("thread2: timeout while waiting to send a mail.\n");
-	}
+    }
 }
 
 int mbox_send_wait_init()
 {
-	/* 初始化一个mailbox */
-	rt_mb_init(&mb,
-		"mbt",             /* 名称是mbt */
-		&mb_pool[0],       /* 邮箱用到的内存池是mb_pool */
-		sizeof(mb_pool)/4,   /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
-		RT_IPC_FLAG_FIFO); /* 采用FIFO方式进行线程等待 */
-
-	/* 创建线程1 */
-	tid1 = rt_thread_create("t1",
-		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("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);
-
-	return 0;
+    /* 初始化一个mailbox */
+    rt_mb_init(&mb,
+               "mbt",             /* 名称是mbt */
+               &mb_pool[0],       /* 邮箱用到的内存池是mb_pool */
+               sizeof(mb_pool)/4, /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
+               RT_IPC_FLAG_FIFO); /* 采用FIFO方式进行线程等待 */
+
+    /* 创建线程1 */
+    tid1 = rt_thread_create("t1",
+                            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("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);
+
+    return 0;
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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_mb_detach(&mb);
+    /* 执行邮箱对象脱离 */
+    rt_mb_detach(&mb);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_mbox_send_wait()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	mbox_send_wait_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    mbox_send_wait_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 300;
+    /* 返回TestCase运行的最长时间 */
+    return 300;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_mbox_send_wait, a example of mailbox send wait);
@@ -133,9 +133,9 @@ FINSH_FUNCTION_EXPORT(_tc_mbox_send_wait, a example of mailbox send wait);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	mbox_send_wait_init();
+    mbox_send_wait_init();
 
-	return 0;
+    return 0;
 }
 #endif
 

examples/kernel/mbox_simple.c

@@ -22,108 +22,108 @@ static char mb_str2[] = "this is another mail!";
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	unsigned char* str;
+    unsigned char* str;
 
-	while (1)
-	{
-		rt_kprintf("thread1: try to recv a mail\n");
+    while (1)
+    {
+        rt_kprintf("thread1: try to recv a mail\n");
 
-		/* 从邮箱中收取邮件 */
-		if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
-		{
-			rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
+        /* 从邮箱中收取邮件 */
+        if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
+        {
+            rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
 
-			/* 延时10个OS Tick */
-			rt_thread_delay(10);
-		}
-	}
+            /* 延时10个OS Tick */
+            rt_thread_delay(10);
+        }
+    }
 }
 
 /* 线程2入口 */
 static void thread2_entry(void* parameter)
 {
-	rt_uint8_t count;
-
-	count = 0;
-	while (1)
-	{
-		count ++;
-		if (count & 0x1)
-		{
-			/* 发送mb_str1地址到邮箱中 */
-			rt_mb_send(&mb, (rt_uint32_t)&mb_str1[0]);
-		}
-		else
-		{
-			/* 发送mb_str2地址到邮箱中 */
-			rt_mb_send(&mb, (rt_uint32_t)&mb_str2[0]);
-		}
-
-		/* 延时20个OS Tick */
-		rt_thread_delay(20);
-	}
+    rt_uint8_t count;
+
+    count = 0;
+    while (1)
+    {
+        count ++;
+        if (count & 0x1)
+        {
+            /* 发送mb_str1地址到邮箱中 */
+            rt_mb_send(&mb, (rt_uint32_t)&mb_str1[0]);
+        }
+        else
+        {
+            /* 发送mb_str2地址到邮箱中 */
+            rt_mb_send(&mb, (rt_uint32_t)&mb_str2[0]);
+        }
+
+        /* 延时20个OS Tick */
+        rt_thread_delay(20);
+    }
 }
 
 int mbox_simple_init()
 {
-	/* 初始化一个mailbox */
-	rt_mb_init(&mb,
-		"mbt",             /* 名称是mbt */
-		&mb_pool[0],       /* 邮箱用到的内存池是mb_pool */
-		sizeof(mb_pool)/4,   /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
-		RT_IPC_FLAG_FIFO); /* 采用FIFO方式进行线程等待 */
-
-	/* 创建线程1 */
-	tid1 = rt_thread_create("t1",
-		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("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);
-
-	return 0;
+    /* 初始化一个mailbox */
+    rt_mb_init(&mb,
+               "mbt",             /* 名称是mbt */
+               &mb_pool[0],       /* 邮箱用到的内存池是mb_pool */
+               sizeof(mb_pool)/4, /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
+               RT_IPC_FLAG_FIFO); /* 采用FIFO方式进行线程等待 */
+
+    /* 创建线程1 */
+    tid1 = rt_thread_create("t1",
+                            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("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);
+
+    return 0;
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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_mb_detach(&mb);
+    /* 执行邮箱对象脱离 */
+    rt_mb_detach(&mb);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_mbox_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	mbox_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    mbox_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_mbox_simple, a simple mailbox example);
@@ -131,8 +131,8 @@ FINSH_FUNCTION_EXPORT(_tc_mbox_simple, a simple mailbox example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	mbox_simple_init();
+    mbox_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/memp_simple.c

@@ -18,115 +18,115 @@ static rt_thread_t tid2 = RT_NULL;
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	int i;
-	char *block;
-
-	while(1)
-	{
-		for (i = 0; i < 48; i++)
-		{
-			/* 申请内存块 */
-			rt_kprintf("allocate No.%d\n", i);
-			if (ptr[i] == RT_NULL)
-			{
-				ptr[i] = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
-			}
-		}
-
-		/* 继续申请一个内存块，因为已经没有内存块，线程应该被挂起 */
-		block = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
-		rt_kprintf("allocate the block mem\n");
-		/* 释放这个内存块 */
-		rt_mp_free(block);
-		block = RT_NULL;
-	}
+    int i;
+    char *block;
+
+    while(1)
+    {
+        for (i = 0; i < 48; i++)
+        {
+            /* 申请内存块 */
+            rt_kprintf("allocate No.%d\n", i);
+            if (ptr[i] == RT_NULL)
+            {
+                ptr[i] = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
+            }
+        }
+
+        /* 继续申请一个内存块，因为已经没有内存块，线程应该被挂起 */
+        block = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
+        rt_kprintf("allocate the block mem\n");
+        /* 释放这个内存块 */
+        rt_mp_free(block);
+        block = RT_NULL;
+    }
 }
 
 /* 线程2入口，线程2的优先级比线程1低，应该线程1先获得执行。*/
 static void thread2_entry(void *parameter)
 {
-	int i;
-
-	while(1)
-	{
-		rt_kprintf("try to release block\n");
-
-		for (i = 0 ; i < 48; i ++)
-		{
-			/* 释放所有分配成功的内存块 */
-			if (ptr[i] != RT_NULL)
-			{
-				rt_kprintf("release block %d\n", i);
-
-				rt_mp_free(ptr[i]);
-				ptr[i] = RT_NULL;
-			}
-		}
-
-		/* 休眠10个OS Tick */
-		rt_thread_delay(10);
-	}
+    int i;
+
+    while(1)
+    {
+        rt_kprintf("try to release block\n");
+
+        for (i = 0 ; i < 48; i ++)
+        {
+            /* 释放所有分配成功的内存块 */
+            if (ptr[i] != RT_NULL)
+            {
+                rt_kprintf("release block %d\n", i);
+
+                rt_mp_free(ptr[i]);
+                ptr[i] = RT_NULL;
+            }
+        }
+
+        /* 休眠10个OS Tick */
+        rt_thread_delay(10);
+    }
 }
 
 int mempool_simple_init()
 {
-	int i;
-	for (i = 0; i < 48; i ++) ptr[i] = RT_NULL;
-
-	/* 初始化内存池对象 */
-	rt_mp_init(&mp, "mp1", &mempool[0], sizeof(mempool), 80);
-
-	/* 创建线程1 */
-	tid1 = rt_thread_create("t1",
-		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("t2",
-		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;
+    int i;
+    for (i = 0; i < 48; i ++) ptr[i] = RT_NULL;
+
+    /* 初始化内存池对象 */
+    rt_mp_init(&mp, "mp1", &mempool[0], sizeof(mempool), 80);
+
+    /* 创建线程1 */
+    tid1 = rt_thread_create("t1",
+                            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("t2",
+                            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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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_mp_detach(&mp);
+    /* 执行内存池脱离 */
+    rt_mp_detach(&mp);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_mempool_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	mempool_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    mempool_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_mempool_simple, a memory pool example);
@@ -134,8 +134,8 @@ FINSH_FUNCTION_EXPORT(_tc_mempool_simple, a memory pool example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	mempool_simple_init();
+    mempool_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/messageq_simple.c

@@ -20,139 +20,139 @@ static char msg_pool[2048];
 /* 线程1入口函数 */
 static void thread1_entry(void* parameter)
 {
-	char buf[128];
+    char buf[128];
 
-	while (1)
-	{
-		rt_memset(&buf[0], 0, sizeof(buf));
+    while (1)
+    {
+        rt_memset(&buf[0], 0, sizeof(buf));
 
-		/* 从消息队列中接收消息 */
-		if (rt_mq_recv(&mq, &buf[0], sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
-		{
-			rt_kprintf("thread1: recv msg from message queue, the content:%s\n", buf);
-		}
+        /* 从消息队列中接收消息 */
+        if (rt_mq_recv(&mq, &buf[0], sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
+        {
+            rt_kprintf("thread1: recv msg from message queue, the content:%s\n", buf);
+        }
 
-		/* 延迟10个OS Tick */
-		rt_thread_delay(10);
-	}
+        /* 延迟10个OS Tick */
+        rt_thread_delay(10);
+    }
 }
 
 /* 线程2入口函数 */
 static void thread2_entry(void* parameter)
 {
-	int i, result;
-	char buf[] = "this is message No.x";
-
-	while (1)
-	{
-		for (i = 0; i < 10; i++)
-		{
-			buf[sizeof(buf) - 2] = '0' + i;
-
-			rt_kprintf("thread2: send message - %s\n", buf);
-			/* 发送消息到消息队列中 */
-			result = rt_mq_send(&mq, &buf[0], sizeof(buf));
-			if ( result == -RT_EFULL)
-			{
-				/* 消息队列满， 延迟1s时间 */
-				rt_kprintf("message queue full, delay 1s\n");
-				rt_thread_delay(100);
-			}
-		}
-
-		/* 延时10个OS Tick */
-		rt_thread_delay(10);
-	}
+    int i, result;
+    char buf[] = "this is message No.x";
+
+    while (1)
+    {
+        for (i = 0; i < 10; i++)
+        {
+            buf[sizeof(buf) - 2] = '0' + i;
+
+            rt_kprintf("thread2: send message - %s\n", buf);
+            /* 发送消息到消息队列中 */
+            result = rt_mq_send(&mq, &buf[0], sizeof(buf));
+            if ( result == -RT_EFULL)
+            {
+                /* 消息队列满， 延迟1s时间 */
+                rt_kprintf("message queue full, delay 1s\n");
+                rt_thread_delay(100);
+            }
+        }
+
+        /* 延时10个OS Tick */
+        rt_thread_delay(10);
+    }
 }
 
 /* 线程3入口函数 */
 static void thread3_entry(void* parameter)
 {
-	char buf[] = "this is an urgent message!";
+    char buf[] = "this is an urgent message!";
 
-	while (1)
-	{
-		rt_kprintf("thread3: send an urgent message\n");
+    while (1)
+    {
+        rt_kprintf("thread3: send an urgent message\n");
 
-		/* 发送紧急消息到消息队列中 */
-		rt_mq_urgent(&mq, &buf[0], sizeof(buf));
+        /* 发送紧急消息到消息队列中 */
+        rt_mq_urgent(&mq, &buf[0], sizeof(buf));
 
-		/* 延时25个OS Tick */
-		rt_thread_delay(25);
-	}
+        /* 延时25个OS Tick */
+        rt_thread_delay(25);
+    }
 }
 
 int messageq_simple_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); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
-
-	/* 创建线程1 */
-	tid1 = rt_thread_create("t1",
-		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("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, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
-	if (tid3 != RT_NULL)
-		rt_thread_startup(tid3);
-	else
-		tc_stat(TC_STAT_END | TC_STAT_FAILED);
-
-	return 0;
+    /* 初始化消息队列 */
+    rt_mq_init(&mq, "mqt",
+               &msg_pool[0],        /* 内存池指向msg_pool */
+               128 - sizeof(void*), /* 每个消息的大小是 128 - void* */
+               sizeof(msg_pool),    /* 内存池的大小是msg_pool的大小 */
+               RT_IPC_FLAG_FIFO);   /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
+
+    /* 创建线程1 */
+    tid1 = rt_thread_create("t1",
+                            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("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, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
+                            THREAD_STACK_SIZE, THREAD_PRIORITY, 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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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);
 
-	/* 执行消息队列对象脱离 */
-	rt_mq_detach(&mq);
+    /* 执行消息队列对象脱离 */
+    rt_mq_detach(&mq);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_messageq_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	messageq_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    messageq_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_messageq_simple, a simple message queue example);
@@ -160,8 +160,8 @@ FINSH_FUNCTION_EXPORT(_tc_messageq_simple, a simple message queue example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	messageq_simple_init();
+    messageq_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/mutex_simple.c

@@ -13,142 +13,142 @@ 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;
-	}
+    /* 先让低优先级线程运行 */
+    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);
-		}
-	}
+    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);
-	}
+    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;
+    /* 创建互斥锁 */
+    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);
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    mutex_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);
@@ -156,8 +156,8 @@ FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	mutex_simple_init();
+    mutex_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/semaphore_buffer_worker.c

@@ -12,9 +12,9 @@
 /* 一个环形buffer的实现 */
 struct rb
 {
-	rt_uint16_t read_index, write_index;
-	rt_uint8_t *buffer_ptr;
-	rt_uint16_t buffer_size;
+    rt_uint16_t read_index, write_index;
+    rt_uint8_t *buffer_ptr;
+    rt_uint16_t buffer_size;
 };
 
 /* 指向信号量控制块的指针 */
@@ -23,236 +23,236 @@ 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
+#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);
+    RT_ASSERT(rb != RT_NULL);
 
-	/* 对读写指针清零*/
-	rb->read_index = rb->write_index = 0;
+    /* 对读写指针清零*/
+    rb->read_index = rb->write_index = 0;
 
-	/* 设置环形buffer的内存数据块 */
-	rb->buffer_ptr = pool;
-	rb->buffer_size = size;
+    /* 设置环形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;
+    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;
+    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);
-	}
+    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);
-	}
+    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;
+    /* 初始化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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 删除信号量 */
-	if (sem != RT_NULL)
-		rt_sem_delete(sem);
+    /* 删除信号量 */
+    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);
+    /* 删除线程 */
+    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();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_semaphore_buffer_worker()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	semaphore_buffer_worker_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    semaphore_buffer_worker_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphore example);
@@ -260,8 +260,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphor
 /* 用户应用入口 */
 int rt_application_init()
 {
-	semaphore_buffer_worker_init();
+    semaphore_buffer_worker_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/semaphore_dynamic.c

@@ -15,105 +15,112 @@ 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);
+    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)
+    {
+        rt_tick_t new_tick = rt_tick_get();
+        /* 可以有两个 tick 的误差 */
+        if (new_tick - tick >= 12)
+        {
+            rt_kprintf("tick error to large: expect: 10, get %d\n",
+                       new_tick - tick);
+
+            /* 如果失败，则测试失败 */
+            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;
+    /* 创建一个信号量，初始值是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);
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
+
+    if (sem)
+    {
+        rt_sem_delete(sem);
+        sem = RT_NULL;
+    }
+
+    /* 删除线程 */
+    if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
+    {
+        rt_thread_delete(tid);
+    }
+
+    /* 调度器解锁 */
+    rt_exit_critical();
+
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_semaphore_dynamic()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	semaphore_dynamic_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    semaphore_dynamic_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);
@@ -121,8 +128,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	semaphore_dynamic_init();
+    semaphore_dynamic_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/semaphore_priority.c

@@ -6,123 +6,129 @@ 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);
-	}
+    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);
-	}
+    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);
+    rt_thread_delay(10);
 
-	while (1)
-	{
-		rt_sem_release(sem);
-		rt_thread_delay(5);
-	}
+    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;
+    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();
+    /* lock scheduler */
+    rt_enter_critical();
+
+    /* delete t1, t2 and worker thread */
+    rt_thread_delete(t1);
+    rt_thread_delete(t2);
+    rt_thread_delete(worker);
+
+    if (sem)
+    {
+        rt_sem_delete(sem);
+        sem = RT_NULL;
+    }
+
+    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();
+    /* set tc cleanup */
+    tc_cleanup(_tc_cleanup);
+    semaphore_priority_init();
 
-	return 50;
+    return 50;
 }
 FINSH_FUNCTION_EXPORT(_tc_semaphore_priority, a priority semaphore test);
 #else
 int rt_application_init()
 {
-	semaphore_priority_init();
+    semaphore_priority_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/semaphore_producer_consumer.c

@@ -24,122 +24,126 @@ 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");
+    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;
+    rt_uint32_t no;
+    rt_uint32_t sum;
 
-	/* 第n个线程，由入口参数传进来 */
-	no = (rt_uint32_t)parameter;
+    /* 第n个线程，由入口参数传进来 */
+    no = (rt_uint32_t)parameter;
 
-	while(1)
-	{
-		/* 获取一个满位 */
-		rt_sem_take(&sem_full, RT_WAITING_FOREVER);
+    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_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);
+        /* 释放一个空位 */
+        rt_sem_release(&sem_empty);
 
-		/* 生产者生产到100个数目，停止，消费者线程相应停止 */
-		if (get == 100) break;
+        /* 生产者生产到100个数目，停止，消费者线程相应停止 */
+        if (get == 100) break;
 
-		/* 暂停一小会时间 */
-		rt_thread_delay(10);
-	}
+        /* 暂停一小会时间 */
+        rt_thread_delay(10);
+    }
 
-	rt_kprintf("the consumer[%d] sum is %d \n ", no, sum);
-	rt_kprintf("the consumer[%d] exit!\n");
+    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;
+    /* 初始化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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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_sem_detach(&sem_lock);
+    rt_sem_detach(&sem_empty);
+    rt_sem_detach(&sem_full);
 
-	/* 调度器解锁 */
-	rt_exit_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);
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 调度器解锁 */
+    rt_exit_critical();
+
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_semaphore_producer_consumer()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	semaphore_producer_consumer_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    semaphore_producer_consumer_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer example);
@@ -147,8 +151,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer exa
 /* 用户应用入口 */
 int rt_application_init()
 {
-	semaphore_producer_consumer_init();
+    semaphore_producer_consumer_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/semaphore_static.c

@@ -17,107 +17,111 @@ 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);
+    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)
+    {
+        rt_tick_t new_tick = rt_tick_get();
+        /* 可以有两个 tick 的误差 */
+        if (new_tick - tick >= 12)
+        {
+            rt_kprintf("tick error to large: expect: 10, get %d\n",
+                       new_tick - tick);
+
+            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(void)
 {
-	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;
+    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(void)
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 执行线程脱离 */
-	if (thread.stat != RT_THREAD_CLOSE)
-	{
-		rt_thread_detach(&thread);
+    /* 执行线程脱离 */
+    if (thread.stat != RT_THREAD_CLOSE)
+    {
+        rt_thread_detach(&thread);
 
-		/* 执行信号量对象脱离 */
-		rt_sem_detach(&sem);
-	}
+        /* 执行信号量对象脱离 */
+        rt_sem_detach(&sem);
+    }
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_semaphore_static(void)
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	semaphore_static_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    semaphore_static_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);
@@ -125,8 +129,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);
 /* 用户应用入口 */
 int rt_application_init(void)
 {
-	semaphore_static_init();
+    semaphore_static_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/tc_comm.c

@@ -4,8 +4,8 @@
 #endif
 
 #ifdef RT_USING_TC
-#define TC_PRIORITY		25
-#define TC_STACK_SIZE	0x400
+#define TC_PRIORITY        25
+#define TC_STACK_SIZE    0x400
 
 static rt_uint8_t _tc_stat;
 static struct rt_semaphore _tc_sem;
@@ -20,156 +20,170 @@ 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);
+    unsigned int fail_count = 0;
+    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)
+                {
+                    /* Make sure we are going to be blocked. */
+                    rt_sem_control(&_tc_sem, RT_IPC_CMD_RESET, 0);
+                    rt_sem_take(&_tc_sem, tick * _tc_scale);
+                }
+
+                if (_tc_cleanup != RT_NULL)
+                {
+                    /* perform testcase cleanup */
+                    _tc_cleanup();
+                    _tc_cleanup = RT_NULL;
+                }
+
+                if (_tc_stat & TC_STAT_RUNNING)
+                {
+                    rt_kprintf("TestCase[%s] exit with stat TC_STAT_RUNNING."
+                               " Please fix the TC.\n",
+                               _tc_current);
+                    /* If the TC forgot to clear the flag, we do it. */
+                    _tc_stat &= ~TC_STAT_RUNNING;
+                }
+
+                if (_tc_stat & TC_STAT_FAILED)
+                {
+                    rt_kprintf("TestCase[%s] failed\n", _tc_current);
+                    fail_count++;
+                }
+                else
+                {
+                    rt_kprintf("TestCase[%s] passed\n", _tc_current);
+                }
+            }
+        }
+    }
+
+    rt_kprintf("RT-Thread TestCase Running Done!\n");
+    if (fail_count)
+    {
+        rt_kprintf("%d tests failed\n", fail_count);
+    }
+    else
+    {
+        rt_kprintf("All tests passed\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);
+    _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;
+    _tc_stat |= stat;
+    _tc_stat &= ~TC_STAT_RUNNING;
 
-	/* release semaphore */
-	rt_sem_release(&_tc_sem);
+    /* 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;
+    if (stat & TC_STAT_FAILED)
+    {
+        rt_kprintf("TestCases[%s] failed\n", _tc_current);
+    }
+    _tc_stat |= stat;
 }
 
 void tc_cleanup(void (*cleanup)())
 {
-	_tc_cleanup = 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);
+    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)
-		{
+    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);
+            rt_kprintf("%-16s -- %s\n", index->name + 4, index->desc);
 #else
-			rt_kprintf("%s\n", index->name + 4);
+            rt_kprintf("%s\n", index->name + 4);
 #endif
-		}
-	}
+        }
+    }
 }
 FINSH_FUNCTION_EXPORT(list_tc, list all testcases);
 #endif

examples/kernel/tc_comm.h

@@ -11,19 +11,19 @@
 #endif
 
 #if RT_THREAD_PRIORITY_MAX == 8
-#define THREAD_PRIORITY		6
+#define THREAD_PRIORITY        6
 #elif RT_THREAD_PRIORITY_MAX == 32
-#define THREAD_PRIORITY		25
+#define THREAD_PRIORITY        25
 #elif RT_THREAD_PRIORITY_MAX == 256
-#define THREAD_PRIORITY		200
+#define THREAD_PRIORITY        200
 #endif
-#define THREAD_STACK_SIZE	512
-#define THREAD_TIMESLICE	5
+#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
+#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);

examples/kernel/tc_sample.c

@@ -4,59 +4,59 @@
 static rt_thread_t tid = RT_NULL;
 static void sample_thread(void* parameter)
 {
-	rt_kprintf("I'm sample!\n");
+    rt_kprintf("I'm sample!\n");
 }
 static void sample_thread_cleanup(struct rt_thread *p)
 {
-	tid = RT_NULL;
-	tc_done(TC_STAT_PASSED);
+    tid = RT_NULL;
+    tc_done(TC_STAT_PASSED);
 }
 
 int sample_init()
 {
-	tid = rt_thread_create("t",
-		sample_thread, RT_NULL,
-		THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
-	if (tid != RT_NULL)
-	{
-		rt_thread_startup(tid);
-		tid->cleanup = sample_thread_cleanup;
-	}
-	else
-		tc_stat(TC_STAT_END | TC_STAT_FAILED);
+    tid = rt_thread_create("t",
+        sample_thread, RT_NULL,
+        THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+        tid->cleanup = sample_thread_cleanup;
+    }
+    else
+        tc_stat(TC_STAT_END | TC_STAT_FAILED);
 
-	return 0;
+    return 0;
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* lock scheduler */
-	rt_enter_critical();
-	/* delete thread */
-	if (tid != RT_NULL)
-	{
-		rt_kprintf("tid1 is bad\n");
-		tc_stat(TC_STAT_FAILED);
-	}
-	/* unlock scheduler */
-	rt_exit_critical();
+    /* lock scheduler */
+    rt_enter_critical();
+    /* delete thread */
+    if (tid != RT_NULL)
+    {
+        rt_kprintf("tid1 is bad\n");
+        tc_stat(TC_STAT_FAILED);
+    }
+    /* unlock scheduler */
+    rt_exit_critical();
 }
 
 int _tc_sample()
 {
-	/* set tc cleanup */
-	tc_cleanup(_tc_cleanup);
-	sample_init();
+    /* set tc cleanup */
+    tc_cleanup(_tc_cleanup);
+    sample_init();
 
-	return 25;
+    return 25;
 }
 FINSH_FUNCTION_EXPORT(_tc_sample, a thread testcase example);
 #else
 int rt_application_init()
 {
-	sample_init();
+    sample_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_delay.c

@@ -8,63 +8,63 @@ 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_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 10 tick\n");
+    tick = rt_tick_get();
+    rt_thread_delay(10);
+    if (rt_tick_get() - tick > 11)
+    {
+        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 delay 15 tick\n");
+    tick = rt_tick_get();
+    rt_thread_delay(15);
+    if (rt_tick_get() - tick > 16)
+    {
+        tc_done(TC_STAT_FAILED);
+        return;
+    }
 
-	rt_kprintf("thread exit\n");
+    rt_kprintf("thread exit\n");
 
-	tc_done(TC_STAT_PASSED);
+    tc_done(TC_STAT_PASSED);
 }
 
 rt_err_t thread_delay_init()
 {
-	rt_err_t result;
+    rt_err_t result;
 
-	result = rt_thread_init(&thread,
-		"test",
-		thread_entry, RT_NULL,
-		&thread_stack[0], sizeof(thread_stack),
-		THREAD_PRIORITY, 10);
+    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);
+    if (result == RT_EOK)
+        rt_thread_startup(&thread);
+    else
+        tc_stat(TC_STAT_END | TC_STAT_FAILED);
 
-	return result;
+    return result;
 }
 
 #ifdef RT_USING_TC
 int _tc_thread_delay()
 {
-	thread_delay_init();
+    thread_delay_init();
 
-	return 30;
+    return 30;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_delay, a thread delay test);
 #else
 int rt_application_init()
 {
-	thread_delay_init();
+    thread_delay_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_delete.c

@@ -15,130 +15,128 @@ 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 ++;
-	}
+    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;
+    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);
+    /* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
+
+    /* 线程2启动后先睡眠10个OS Tick */
+    rt_thread_delay(RT_TICK_PER_SECOND);
+
+    /*
+     * 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程
+     * 队列
+     */
+    rt_thread_delete(tid1);
+
+    /*
+     * 线程2继续休眠10个OS Tick然后退出，线程2休眠后应切换到idle线程
+     * idle线程将执行真正的线程1控制块和线程栈的删除
+     */
+    rt_thread_delay(RT_TICK_PER_SECOND);
 }
 
 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);
+    /*
+     * 线程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;
+    /* 创建线程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 10 * RT_TICK_PER_SECOND;
 }
 
 #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();
+    /* lock scheduler */
+    rt_enter_critical();
+
+    /* delete thread */
+    if (tid1 != RT_NULL)
+    {
+        rt_kprintf("tid1 is %p, should be NULL\n", tid1);
+        tc_stat(TC_STAT_FAILED);
+    }
+    if (tid2 != RT_NULL)
+    {
+        rt_kprintf("tid2 is %p, should be NULL\n", tid2);
+        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;
+    /* set tc cleanup */
+    tc_cleanup(_tc_cleanup);
+    return thread_delete_init();
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_delete, a thread delete example);
 #else
 int rt_application_init()
 {
-	thread_delete_init();
+    thread_delete_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_detach.c

@@ -18,92 +18,92 @@ static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	rt_uint32_t count = 0;
+    rt_uint32_t count = 0;
 
-	while (1)
-	{
-		/* 线程1采用低优先级运行，一直打印计数值 */
-		rt_kprintf("thread count: %d\n", count ++);
-	}
+    while (1)
+    {
+        /* 线程1采用低优先级运行，一直打印计数值 */
+        rt_kprintf("thread count: %d\n", count ++);
+    }
 }
 
 /* 线程2入口 */
 static void thread2_entry(void* parameter)
 {
-	/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
+    /* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
 
-	/* 线程2启动后先睡眠10个OS Tick */
-	rt_thread_delay(10);
+    /* 线程2启动后先睡眠10个OS Tick */
+    rt_thread_delay(10);
 
-	/*
-	 * 线程2唤醒后直接执行线程1脱离，线程1将从就绪线程队列中删除
-	 */
-	rt_thread_detach(&thread1);
+    /*
+     * 线程2唤醒后直接执行线程1脱离，线程1将从就绪线程队列中删除
+     */
+    rt_thread_detach(&thread1);
 
-	/*
-	 * 线程2继续休眠10个OS Tick然后退出
-	 */
-	rt_thread_delay(10);
+    /*
+     * 线程2继续休眠10个OS Tick然后退出
+     */
+    rt_thread_delay(10);
 
-	/*
-	 * 线程2运行结束后也将自动被从就绪队列中删除，并脱离线程队列
-	 */
+    /*
+     * 线程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;
+    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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 执行线程脱离 */
-	if (thread1.stat != RT_THREAD_CLOSE)
-		rt_thread_detach(&thread1);
-	if (thread2.stat != RT_THREAD_CLOSE)
-		rt_thread_detach(&thread2);
+    /* 执行线程脱离 */
+    if (thread1.stat != RT_THREAD_CLOSE)
+        rt_thread_detach(&thread1);
+    if (thread2.stat != RT_THREAD_CLOSE)
+        rt_thread_detach(&thread2);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_detach()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_detach_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_detach_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 25;
+    /* 返回TestCase运行的最长时间 */
+    return 25;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);
@@ -111,8 +111,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_detach_init();
+    thread_detach_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_dynamic.c

@@ -3,42 +3,42 @@
 
 static void thread_entry(void* parameter)
 {
-	rt_kprintf("thread dynamicly created ok\n");
-	rt_thread_delay(10);
-	rt_kprintf("thread exit\n");
+    rt_kprintf("thread dynamicly created ok\n");
+    rt_thread_delay(10);
+    rt_kprintf("thread exit\n");
 
-	tc_done(TC_STAT_PASSED);
+    tc_done(TC_STAT_PASSED);
 }
 
 int thread_dynamic_init()
 {
-	rt_thread_t tid;
+    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);
+    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;
+    return 0;
 }
 
 #ifdef RT_USING_TC
 int _tc_thread_dynamic()
 {
-	thread_dynamic_init();
+    thread_dynamic_init();
 
-	return 20;
+    return 20;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_dynamic, a dynamic thread test);
 #else
 int rt_application_init()
 {
-	thread_dynamic_init();
+    thread_dynamic_init();
 
-	return 0;
+    return 0;
 }
 #endif
 

examples/kernel/thread_dynamic_simple.c

@@ -12,69 +12,69 @@ 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; /* 获得正确的入口参数 */
+    rt_uint32_t count = 0;
+    rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
 
-	while (1)
-	{
-		/* 打印线程计数值输出 */
-		rt_kprintf("thread%d count: %d\n", no, count ++);
+    while (1)
+    {
+        /* 打印线程计数值输出 */
+        rt_kprintf("thread%d count: %d\n", no, count ++);
 
-		/* 休眠10个OS Tick */
-		rt_thread_delay(10);
-	}
+        /* 休眠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);
+    /* 创建线程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);
+    /* 创建线程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;
+    return 0;
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_dynamic_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_dynamic_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_dynamic_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);
@@ -82,8 +82,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_dynamic_simple_init();
+    thread_dynamic_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_priority.c

@@ -12,94 +12,94 @@ static rt_uint32_t count = 0;
  */
 static void thread1_entry(void* parameter)
 {
-	while (1)
-	{
-		count ++;
-		rt_kprintf("count = %d\n", count);
+    while (1)
+    {
+        count ++;
+        rt_kprintf("count = %d\n", count);
 
-		rt_thread_delay(10);
-	}
+        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;
-		}
-	}
+    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;
+    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();
+    /* 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);
+    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();
+    /* unlock scheduler */
+    rt_exit_critical();
 }
 int _tc_thread_priority()
 {
-	count = 0;
+    count = 0;
 
-	/* set tc cleanup */
-	tc_cleanup(_tc_cleanup);
-	thread_priority_init();
+    /* set tc cleanup */
+    tc_cleanup(_tc_cleanup);
+    thread_priority_init();
 
-	return RT_TICK_PER_SECOND;
+    return RT_TICK_PER_SECOND;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_priority, a priority thread test);
 #else
 int rt_application_init()
 {
-	thread_priority_init();
+    thread_priority_init();
 
-	return 0;
+    return 0;
 }
 #endif
 

examples/kernel/thread_resume.c

@@ -13,102 +13,102 @@ static rt_thread_t tid2 = RT_NULL;
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	/* 低优先级线程1开始运行 */
-	rt_kprintf("thread1 startup%d\n");
+    /* 低优先级线程1开始运行 */
+    rt_kprintf("thread1 startup%d\n");
 
-	/* 挂起自身 */
-	rt_kprintf("suspend thread self\n");
-	rt_thread_suspend(tid1);
-	/* 主动执行线程调度 */
-	rt_schedule();
+    /* 挂起自身 */
+    rt_kprintf("suspend thread self\n");
+    rt_thread_suspend(tid1);
+    /* 主动执行线程调度 */
+    rt_schedule();
 
-	/* 当线程1被唤醒时 */
-	rt_kprintf("thread1 resumed\n");
+    /* 当线程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;
-	}
+    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);
+    /* 延时10个OS Tick */
+    rt_thread_delay(10);
 
-	/* 唤醒线程1 */
-	rt_thread_resume(tid1);
-	rt_kprintf("thread2: to resume thread1\n");
+    /* 唤醒线程1 */
+    rt_thread_resume(tid1);
+    rt_kprintf("thread2: to resume thread1\n");
 
-	/* 延时10个OS Tick */
-	rt_thread_delay(10);
+    /* 延时10个OS Tick */
+    rt_thread_delay(10);
 
-	/* 线程2自动退出 */
+    /* 线程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;
+    /* 创建线程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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_resume()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_resume_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_resume_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 25;
+    /* 返回TestCase运行的最长时间 */
+    return 25;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_resume, a thread resume example);
@@ -116,8 +116,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_resume, a thread resume example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_resume_init();
+    thread_resume_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_same_priority.c

@@ -10,87 +10,87 @@ 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 ++;
-	}
+    while (1)
+    {
+        t1_count ++;
+    }
 }
 
 static void thread2_entry(void* parameter)
 {
-	while (1)
-	{
-		t2_count ++;
-	}
+    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;
+    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();
+    /* 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);
+    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();
+    /* unlock scheduler */
+    rt_exit_critical();
 
-	rt_kprintf("t1_count=%d t2_count=%d\n",t1_count,t2_count);
+    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);
+    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;
+    t1_count = 0;
+    t2_count = 0;
 
-	/* set tc cleanup */
-	tc_cleanup(_tc_cleanup);
+    /* set tc cleanup */
+    tc_cleanup(_tc_cleanup);
 
-	thread_same_priority_init();
+    thread_same_priority_init();
 
-	return 100;
+    return 100;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_same_priority, a same priority thread test);
 #else
 int rt_application_init()
 {
-	thread_same_priority_init();
+    thread_same_priority_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_static.c

@@ -8,45 +8,45 @@ 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");
+    rt_kprintf("thread staticly inited ok\n");
+    rt_thread_delay(10);
+    rt_kprintf("thread exit\n");
 
-	tc_done(TC_STAT_PASSED);
+    tc_done(TC_STAT_PASSED);
 }
 
 rt_err_t thread_static_init()
 {
-	rt_err_t result;
+    rt_err_t result;
 
-	result = rt_thread_init(&thread,
-		"test",
-		thread_entry, RT_NULL,
-		&thread_stack[0], sizeof(thread_stack),
-		THREAD_PRIORITY, 10);
+    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);
+    if (result == RT_EOK)
+        rt_thread_startup(&thread);
+    else
+        tc_stat(TC_STAT_END | TC_STAT_FAILED);
 
-	return result;
+    return result;
 }
 
 #ifdef RT_USING_TC
 int _tc_thread_static()
 {
-	thread_static_init();
+    thread_static_init();
 
-	return 20;
+    return 20;
 }
 FINSH_FUNCTION_EXPORT(_tc_thread_static, a static thread test);
 #else
 int rt_application_init()
 {
-	thread_static_init();
+    thread_static_init();
 
-	return 0;
+    return 0;
 }
 #endif
 

examples/kernel/thread_static_simple.c

@@ -18,73 +18,73 @@ 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; /* 获得正确的入口参数 */
+    rt_uint32_t count = 0;
+    rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
 
-	while (1)
-	{
-		/* 打印线程计数值输出 */
-		rt_kprintf("thread%d count: %d\n", no, count ++);
+    while (1)
+    {
+        /* 打印线程计数值输出 */
+        rt_kprintf("thread%d count: %d\n", no, count ++);
 
-		/* 休眠10个OS Tick */
-		rt_thread_delay(10);
-	}
+        /* 休眠10个OS Tick */
+        rt_thread_delay(10);
+    }
 }
 
 int thread_static_simple_init()
 {
-	rt_err_t result;
+    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);
+    /* 初始化线程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);
+    /* 初始化线程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;
+    return 0;
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 执行线程脱离 */
-	if (thread1.stat != RT_THREAD_CLOSE)
-		rt_thread_detach(&thread1);
-	if (thread2.stat != RT_THREAD_CLOSE)
-		rt_thread_detach(&thread2);
+    /* 执行线程脱离 */
+    if (thread1.stat != RT_THREAD_CLOSE)
+        rt_thread_detach(&thread1);
+    if (thread2.stat != RT_THREAD_CLOSE)
+        rt_thread_detach(&thread2);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_static_simple()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_static_simple_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_static_simple_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_static_simple, a static thread example);
@@ -92,8 +92,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_static_simple, a static thread example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_static_simple_init();
+    thread_static_simple_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_suspend.c

@@ -12,81 +12,81 @@ static rt_thread_t tid2 = RT_NULL;
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	rt_uint32_t count = 0;
+    rt_uint32_t count = 0;
 
-	while (1)
-	{
-		/* 线程1采用低优先级运行，一直打印计数值 */
-		rt_kprintf("thread count: %d\n", count ++);
-	}
+    while (1)
+    {
+        /* 线程1采用低优先级运行，一直打印计数值 */
+        rt_kprintf("thread count: %d\n", count ++);
+    }
 }
 
 /* 线程2入口 */
 static void thread2_entry(void* parameter)
 {
-	/* 延时10个OS Tick */
-	rt_thread_delay(10);
+    /* 延时10个OS Tick */
+    rt_thread_delay(10);
 
-	/* 挂起线程1 */
-	rt_thread_suspend(tid1);
+    /* 挂起线程1 */
+    rt_thread_suspend(tid1);
 
-	/* 延时10个OS Tick */
-	rt_thread_delay(10);
+    /* 延时10个OS Tick */
+    rt_thread_delay(10);
 
-	/* 线程2自动退出 */
-	tid2 = RT_NULL;
+    /* 线程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;
+    /* 创建线程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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_suspend()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_suspend_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_suspend_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_suspend, a thread suspend example);
@@ -94,8 +94,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_suspend, a thread suspend example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_suspend_init();
+    thread_suspend_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/thread_yield.c

@@ -10,83 +10,83 @@ static rt_thread_t tid2 = RT_NULL;
 /* 线程1入口 */
 static void thread1_entry(void* parameter)
 {
-	rt_uint32_t count = 0;
+    rt_uint32_t count = 0;
 
-	while (1)
-	{
-		/* 打印线程1的输出 */
-		rt_kprintf("thread1: count = %d\n", count ++);
+    while (1)
+    {
+        /* 打印线程1的输出 */
+        rt_kprintf("thread1: count = %d\n", count ++);
 
-		/* 执行yield后应该切换到thread2执行 */
-		rt_thread_yield();
-	}
+        /* 执行yield后应该切换到thread2执行 */
+        rt_thread_yield();
+    }
 }
 
 /* 线程2入口 */
 static void thread2_entry(void* parameter)
 {
-	rt_uint32_t count = 0;
+    rt_uint32_t count = 0;
 
-	while (1)
-	{
-		/* 打印线程2的输出 */
-		rt_kprintf("thread2: count = %d\n", count ++);
+    while (1)
+    {
+        /* 打印线程2的输出 */
+        rt_kprintf("thread2: count = %d\n", count ++);
 
-		/* 执行yield后应该切换到thread1执行 */
-		rt_thread_yield();
-	}
+        /* 执行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;
+    /* 创建线程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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    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 (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();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_thread_yield()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	thread_yield_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    thread_yield_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 30;
+    /* 返回TestCase运行的最长时间 */
+    return 30;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_thread_yield, a thread yield example);
@@ -94,8 +94,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_yield, a thread yield example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	thread_yield_init();
+    thread_yield_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/timer_control.c

@@ -13,63 +13,63 @@ static rt_uint8_t count;
 /* 定时器超时函数 */
 static void timeout1(void* parameter)
 {
-	rt_tick_t timeout = 50;
-	
-	rt_kprintf("periodic timer is timeout\n");
+    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;
-	}
+    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);
+    /* 创建定时器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_enter_critical();
 
-	/* 删除定时器对象 */
-	rt_timer_delete(timer1);
-	timer1 = RT_NULL;
+    /* 删除定时器对象 */
+    rt_timer_delete(timer1);
+    timer1 = RT_NULL;
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_timer_control()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
 
-	/* 执行定时器例程 */
-	count = 0;
-	timer_control_init();
+    /* 执行定时器例程 */
+    count = 0;
+    timer_control_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_timer_control, a timer control example);
@@ -77,8 +77,8 @@ FINSH_FUNCTION_EXPORT(_tc_timer_control, a timer control example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	timer_control_init();
+    timer_control_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/timer_dynamic.c

@@ -13,70 +13,70 @@ static rt_timer_t timer2;
 /* 定时器1超时函数 */
 static void timeout1(void* parameter)
 {
-	rt_kprintf("periodic timer is timeout\n");
+    rt_kprintf("periodic timer is timeout\n");
 }
 
 /* 定时器2超时函数 */
 static void timeout2(void* parameter)
 {
-	rt_kprintf("one shot timer is timeout\n");
+    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);
+    /* 创建定时器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); /* 单次定时器 */
+    /* 创建定时器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);
+    /* 启动定时器 */
+    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_enter_critical();
 
-	/* 删除定时器对象 */
-	rt_timer_delete(timer1);
-	rt_timer_delete(timer2);
+    /* 删除定时器对象 */
+    rt_timer_delete(timer1);
+    rt_timer_delete(timer2);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_timer_create()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
 
-	/* 执行定时器例程 */
-	timer_create_init();
+    /* 执行定时器例程 */
+    timer_create_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_timer_create, a dynamic timer example);
@@ -84,8 +84,8 @@ FINSH_FUNCTION_EXPORT(_tc_timer_create, a dynamic timer example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	timer_create_init();
+    timer_create_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/timer_static.c

@@ -13,61 +13,61 @@ static struct rt_timer timer2;
 /* 定时器1超时函数 */
 static void timeout1(void* parameter)
 {
-	rt_kprintf("periodic timer is timeout\n");
+    rt_kprintf("periodic timer is timeout\n");
 }
 
 /* 定时器2超时函数 */
 static void timeout2(void* parameter)
 {
-	rt_kprintf("one shot timer is timeout\n");
+    rt_kprintf("one shot timer is timeout\n");
 }
 
 void timer_static_init()
 {
-	/* 初始化定时器 */
-	rt_timer_init(&timer1, "timer1",  /* 定时器名字是 timer1 */
-		timeout1, /* 超时时回调的处理函数 */
-		RT_NULL, /* 超时函数的入口参数 */
-		10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
-		RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
-	rt_timer_init(&timer2, "timer2",   /* 定时器名字是 timer2 */
-		timeout2, /* 超时时回调的处理函数 */
-		RT_NULL, /* 超时函数的入口参数 */
-		30, /* 定时长度为30个OS Tick */
-		RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
+    /* 初始化定时器 */
+    rt_timer_init(&timer1, "timer1",  /* 定时器名字是 timer1 */
+        timeout1, /* 超时时回调的处理函数 */
+        RT_NULL, /* 超时函数的入口参数 */
+        10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
+        RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
+    rt_timer_init(&timer2, "timer2",   /* 定时器名字是 timer2 */
+        timeout2, /* 超时时回调的处理函数 */
+        RT_NULL, /* 超时函数的入口参数 */
+        30, /* 定时长度为30个OS Tick */
+        RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
 
-	/* 启动定时器 */
-	rt_timer_start(&timer1);
-	rt_timer_start(&timer2);
+    /* 启动定时器 */
+    rt_timer_start(&timer1);
+    rt_timer_start(&timer2);
 }
 
 #ifdef RT_USING_TC
 static void _tc_cleanup()
 {
-	/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
-	rt_enter_critical();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 执行定时器脱离 */
-	rt_timer_detach(&timer1);
-	rt_timer_detach(&timer2);
+    /* 执行定时器脱离 */
+    rt_timer_detach(&timer1);
+    rt_timer_detach(&timer2);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_timer_static()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
 
-	/* 执行定时器例程 */
-	timer_static_init();
+    /* 执行定时器例程 */
+    timer_static_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_timer_static, a static timer example);
@@ -75,8 +75,8 @@ FINSH_FUNCTION_EXPORT(_tc_timer_static, a static timer example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	timer_static_init();
+    timer_static_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/timer_stop_self.c

@@ -13,61 +13,61 @@ static rt_uint8_t count;
 /* 定时器超时函数 */
 static void timeout1(void* parameter)
 {
-	rt_kprintf("periodic timer is timeout\n");
+    rt_kprintf("periodic timer is timeout\n");
 
-	count ++;
-	/* 停止定时器自身 */
-	if (count >= 8)
-	{
-		/* 停止定时器 */
-		rt_timer_stop(timer1);
-		count = 0;
-	}
+    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);
+    /* 创建定时器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_enter_critical();
 
-	/* 删除定时器对象 */
-	rt_timer_delete(timer1);
-	timer1 = RT_NULL;
+    /* 删除定时器对象 */
+    rt_timer_delete(timer1);
+    timer1 = RT_NULL;
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_timer_stop_self()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
 
-	/* 执行定时器例程 */
-	count = 0;
-	timer_stop_self_init();
+    /* 执行定时器例程 */
+    count = 0;
+    timer_stop_self_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_timer_stop_self, a dynamic timer example);
@@ -75,8 +75,8 @@ FINSH_FUNCTION_EXPORT(_tc_timer_stop_self, a dynamic timer example);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	timer_stop_self_init();
+    timer_stop_self_init();
 
-	return 0;
+    return 0;
 }
 #endif

examples/kernel/timer_timeout.c

@@ -20,94 +20,94 @@ static struct rt_timer timer;
 static rt_uint16_t no = 0;
 static void timer_timeout(void* parameter)
 {
-	char buf[32];
-	rt_uint32_t length;
+    char buf[32];
+    rt_uint32_t length;
 
-	length = rt_snprintf(buf, sizeof(buf), "message %d", no++);
-	rt_mq_send(&mq, &buf[0], 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");
-		}
-	}
+    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;
+    /* 初始化消息队列 */
+    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();
+    /* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
+    rt_enter_critical();
 
-	/* 删除线程 */
-	if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
-		rt_thread_delete(tid);
+    /* 删除线程 */
+    if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
+        rt_thread_delete(tid);
 
-	/* 执行消息队列对象脱离 */
-	rt_mq_detach(&mq);
-	/* 执行定时器脱离 */
-	rt_timer_detach(&timer);
+    /* 执行消息队列对象脱离 */
+    rt_mq_detach(&mq);
+    /* 执行定时器脱离 */
+    rt_timer_detach(&timer);
 
-	/* 调度器解锁 */
-	rt_exit_critical();
+    /* 调度器解锁 */
+    rt_exit_critical();
 
-	/* 设置TestCase状态 */
-	tc_done(TC_STAT_PASSED);
+    /* 设置TestCase状态 */
+    tc_done(TC_STAT_PASSED);
 }
 
 int _tc_timer_timeout()
 {
-	/* 设置TestCase清理回调函数 */
-	tc_cleanup(_tc_cleanup);
-	timer_timeout_init();
+    /* 设置TestCase清理回调函数 */
+    tc_cleanup(_tc_cleanup);
+    timer_timeout_init();
 
-	/* 返回TestCase运行的最长时间 */
-	return 100;
+    /* 返回TestCase运行的最长时间 */
+    return 100;
 }
 /* 输出函数命令到finsh shell中 */
 FINSH_FUNCTION_EXPORT(_tc_timer_timeout, a thread timer testcase);
@@ -115,8 +115,8 @@ FINSH_FUNCTION_EXPORT(_tc_timer_timeout, a thread timer testcase);
 /* 用户应用入口 */
 int rt_application_init()
 {
-	timer_timeout_init();
+    timer_timeout_init();
 
-	return 0;
+    return 0;
 }
 #endif

include/rtthread.h

@@ -173,6 +173,7 @@ void rt_schedule_remove_thread(struct rt_thread *thread);
 
 void rt_enter_critical(void);
 void rt_exit_critical(void);
+rt_uint16_t rt_critical_level(void);
 
 #ifdef RT_USING_HOOK
 void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));

src/idle.c

@@ -22,6 +22,8 @@
  * 2006-03-23     Bernard      the first version
  * 2010-11-10     Bernard      add cleanup callback function in thread exit.
  * 2012-12-29     Bernard      fix compiling warning.
+ * 2013-12-21     Grissiom     let rt_thread_idle_excute loop until there is no
+ *                             dead thread.
  */
 
 #include <rthw.h>
@@ -72,8 +74,9 @@ void rt_thread_idle_sethook(void (*hook)(void))
  */
 void rt_thread_idle_excute(void)
 {
-    /* check the defunct thread list */
-    if (!rt_list_isempty(&rt_thread_defunct))
+    /* Loop until there is no dead thread. So one call to rt_thread_idle_excute
+     * will do all the cleanups. */
+    while (!rt_list_isempty(&rt_thread_defunct))
     {
         rt_base_t lock;
         rt_thread_t thread;

src/scheduler.c

@@ -34,6 +34,7 @@
  *                             issue found by kuronca
  * 2010-12-13     Bernard      add defunct list initialization even if not use heap.
  * 2011-05-10     Bernard      clean scheduler debug log.
+ * 2013-12-21     Grissiom     add rt_critical_level
  */
 
 #include <rtthread.h>
@@ -398,5 +399,14 @@ void rt_exit_critical(void)
     }
 }
 
+/**
+ * Get the scheduler lock level
+ *
+ * @return the level of the scheduler lock. 0 means unlocked.
+ */
+rt_uint16_t rt_critical_level(void)
+{
+    return rt_scheduler_lock_nest;
+}
 /*@}*/