diff --git a/bsp/simulator/SConstruct b/bsp/simulator/SConstruct index 520da3a05..760002d80 100755 --- a/bsp/simulator/SConstruct +++ b/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: diff --git a/bsp/simulator/applications/application.c b/bsp/simulator/applications/application.c index 9adca985f..500b7e6f2 100755 --- a/bsp/simulator/applications/application.c +++ b/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; } diff --git a/bsp/simulator/readme.txt b/bsp/simulator/readme.txt index 25abcd031..3dcad4a0f 100644 --- a/bsp/simulator/readme.txt +++ b/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，按照同样的方式加载即可 diff --git a/bsp/simulator/rtconfig.h b/bsp/simulator/rtconfig.h index 252e61b71..ce8c78354 100755 --- a/bsp/simulator/rtconfig.h +++ b/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 diff --git a/components/dfs/filesystems/elmfat/ff.c b/components/dfs/filesystems/elmfat/ff.c index 014d70f59..e1f2f60c7 100644 --- a/components/dfs/filesystems/elmfat/ff.c +++ b/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 */ diff --git a/components/dfs/filesystems/elmfat/ff.h b/components/dfs/filesystems/elmfat/ff.h index dfbc100ff..061dd76dc 100644 --- a/components/dfs/filesystems/elmfat/ff.h +++ b/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 diff --git a/components/dfs/src/dfs_fs.c b/components/dfs/src/dfs_fs.c index 0b2dea886..406403e51 100644 --- a/components/dfs/src/dfs_fs.c +++ b/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 (*iter == RT_NULL) + (empty == RT_NULL) ? (empty = iter) : 0; + else if (strcmp((*iter)->name, ops->name) == 0) { - /* find out an empty filesystem type entry */ - if (free_index == DFS_FILESYSTEM_TYPES_MAX) - free_index = index; + ret = -1; + break; } - else if (strcmp(filesystem_operation_table[index]->name, ops->name) == 0) - { - result = -1; - goto err; - } - } - - /* 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) + return -RT_ERROR; - if (type != 0) - { - /* set partition type */ - part->type = type; + /* 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; - /* 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"); - } - } + 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) - { - dev_id = rt_device_find(device_name); - if (dev_id == RT_NULL) - { - /* no this device */ - rt_set_errno(-DFS_STATUS_ENODEV); - - return -1; - } - } - else + if (device_name == RT_NULL) { /* which is a non-device filesystem mount */ - dev_id = RT_NULL; + dev_id = NULL; } - - /* find out 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) - break; - } - dfs_unlock(); - - /* can't find filesystem */ - if (index == DFS_FILESYSTEM_TYPES_MAX) + else if ((dev_id = rt_device_find(device_name)) == RT_NULL) { + /* no this device */ rt_set_errno(-DFS_STATUS_ENODEV); - return -1; } - ops = filesystem_operation_table[index]; + + /* find out the specific filesystem */ + dfs_lock(); + + 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(); + + 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; + } /* 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"); diff --git a/examples/kernel/cpuusage.c b/examples/kernel/cpuusage.c index 05c9b7a8c..490061ddb 100644 --- a/examples/kernel/cpuusage.c +++ b/examples/kernel/cpuusage.c @@ -1,70 +1,70 @@ #include #include -#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); } diff --git a/examples/kernel/event_simple.c b/examples/kernel/event_simple.c index 069433b90..927ed928b 100644 --- a/examples/kernel/event_simple.c +++ b/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; + 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); - } + 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); + 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); - } + /* 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_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); + /* 初始化事件对象 */ + 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); + /* 创建线程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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/heap_malloc.c b/examples/kernel/heap_malloc.c index 0a6b46cc9..271202ad8 100644 --- a/examples/kernel/heap_malloc.c +++ b/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; + 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); + 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); + 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; + 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; - rt_free(ptr4); - rt_free(ptr3); - rt_free(ptr3); - rt_free(ptr1); + rt_free(ptr4); + rt_free(ptr3); + rt_free(ptr2); + rt_free(ptr1); - if (ptr5 != RT_NULL) - { - rt_free(ptr5); - } + if (ptr5 != RT_NULL) + { + rt_free(ptr5); + } - tc_done(TC_STAT_PASSED); - -_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 diff --git a/examples/kernel/heap_realloc.c b/examples/kernel/heap_realloc.c index a4974d5bf..bc7b56a99 100644 --- a/examples/kernel/heap_realloc.c +++ b/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; + 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); + 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); + 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; + 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); + 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) 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; + 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; - rt_free(ptr4); - rt_free(ptr3); - rt_free(ptr3); - rt_free(ptr1); +_free: + rt_free(ptr4); + rt_free(ptr3); + rt_free(ptr2); + rt_free(ptr1); - if (ptr5 != RT_NULL) - { - rt_free(ptr5); - } - - tc_done(TC_STAT_PASSED); - -_failed: - tc_done(TC_STAT_FAILED); + 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 diff --git a/examples/kernel/mbox_send_wait.c b/examples/kernel/mbox_send_wait.c index 6cce513bd..86513fcb1 100644 --- a/examples/kernel/mbox_send_wait.c +++ b/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; + 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); + 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); - } - } + /* 延时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方式进行线程等待 */ + /* 初始化一个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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/mbox_simple.c b/examples/kernel/mbox_simple.c index d9b209465..5d588decb 100644 --- a/examples/kernel/mbox_simple.c +++ b/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; + 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]); - } + 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); - } + /* 延时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方式进行线程等待 */ + /* 初始化一个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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/memp_simple.c b/examples/kernel/memp_simple.c index b232de584..ab8f3b94e 100644 --- a/examples/kernel/memp_simple.c +++ b/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; + 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); - } - } + 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; - } + /* 继续申请一个内存块，因为已经没有内存块，线程应该被挂起 */ + 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; + int i; - while(1) - { - rt_kprintf("try to release block\n"); + 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); + 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; - } - } + rt_mp_free(ptr[i]); + ptr[i] = RT_NULL; + } + } - /* 休眠10个OS Tick */ - rt_thread_delay(10); - } + /* 休眠10个OS Tick */ + rt_thread_delay(10); + } } int mempool_simple_init() { - int i; - for (i = 0; i < 48; i ++) ptr[i] = RT_NULL; + int i; + for (i = 0; i < 48; i ++) ptr[i] = RT_NULL; - /* 初始化内存池对象 */ - rt_mp_init(&mp, "mp1", &mempool[0], sizeof(mempool), 80); + /* 初始化内存池对象 */ + 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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/messageq_simple.c b/examples/kernel/messageq_simple.c index f9512fc05..51b371f59 100644 --- a/examples/kernel/messageq_simple.c +++ b/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"; + int i, result; + char buf[] = "this is message No.x"; - while (1) - { - for (i = 0; i < 10; i++) - { - buf[sizeof(buf) - 2] = '0' + i; + 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); - } - } + 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); - } + /* 延时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); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */ + /* 初始化消息队列 */ + 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); + /* 创建线程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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/mutex_simple.c b/examples/kernel/mutex_simple.c index 8545ddc66..b84cef12b 100644 --- a/examples/kernel/mutex_simple.c +++ b/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); + /* 先让低优先级线程运行 */ + rt_thread_delay(10); - /* 此时thread3持有mutex，并且thread2等待持有mutex */ + /* 此时thread3持有mutex，并且thread2等待持有mutex */ - /* 检查thread2与thread3的优先级情况 */ - if (tid2->current_priority != tid3->current_priority) - { - /* 优先级不相同，测试失败 */ - tc_stat(TC_STAT_END | TC_STAT_FAILED); - return; - } + /* 检查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_err_t result; - /* 先让低优先级线程运行 */ - rt_thread_delay(5); + /* 先让低优先级线程运行 */ + rt_thread_delay(5); - while (1) - { - /* - * 试图持有互斥锁，此时thread3持有，应把thread3的优先级提升到thread2相同 - * 的优先级 - */ - result = rt_mutex_take(mutex, RT_WAITING_FOREVER); + while (1) + { + /* + * 试图持有互斥锁，此时thread3持有，应把thread3的优先级提升到thread2相同 + * 的优先级 + */ + result = rt_mutex_take(mutex, RT_WAITING_FOREVER); - if (result == RT_EOK) - { - /* 释放互斥锁 */ - rt_mutex_release(mutex); - } - } + if (result == RT_EOK) + { + /* 释放互斥锁 */ + rt_mutex_release(mutex); + } + } } /* 线程3入口 */ static void thread3_entry(void* parameter) { - rt_tick_t tick; - rt_err_t result; + 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); - } + 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) ; + /* 做一个长时间的循环，总共50个OS Tick */ + tick = rt_tick_get(); + while (rt_tick_get() - tick < 50) ; - rt_mutex_release(mutex); - rt_mutex_release(mutex); - } + 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; - } + /* 创建互斥锁 */ + 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); + /* 创建线程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); + /* 创建线程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); + /* 创建线程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; + 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); - if (mutex != RT_NULL) - { - rt_mutex_delete(mutex); - } + if (mutex != RT_NULL) + { + rt_mutex_delete(mutex); + } - /* 调度器解锁 */ - rt_exit_critical(); + /* 调度器解锁 */ + rt_exit_critical(); - /* 设置TestCase状态 */ - tc_done(TC_STAT_PASSED); + /* 设置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 diff --git a/examples/kernel/semaphore_buffer_worker.c b/examples/kernel/semaphore_buffer_worker.c index 6e5920dd6..de4647576 100644 --- a/examples/kernel/semaphore_buffer_worker.c +++ b/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; + 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 (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 (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); - } - } + 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; + 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; + 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 (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 (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; - } + 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; + return RT_TRUE; } /* 生产者线程入口 */ static void thread_entry(void* parameter) { - rt_bool_t result; - rt_uint8_t data_buffer[BUFFER_ITEM + 1]; + 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'; + 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); - } + if (result == RT_TRUE) + { + /* 获取数据成功，打印数据 */ + rt_kprintf("%s\n", data_buffer); + } - /* 做一个5 OS Tick的休眠 */ - rt_thread_delay(5); - } + /* 做一个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]; + 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; - } + 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); + /* 持有信号量 */ + 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); - } + /* 放入成功，做一个10 OS Tick的休眠 */ + rt_thread_delay(10); + } } int semaphore_buffer_worker_init() { - /* 初始化ring buffer */ - rb_init(&working_rb, working_buffer, BUFFER_SIZE); + /* 初始化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; - } + /* 创建信号量 */ + 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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/semaphore_dynamic.c b/examples/kernel/semaphore_dynamic.c index 7f2c2ffd4..dc088e6e4 100644 --- a/examples/kernel/semaphore_dynamic.c +++ b/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; + rt_err_t result; + rt_tick_t tick; - /* 获得当前的OS Tick */ - tick = rt_tick_get(); + /* 获得当前的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; - } + /* 试图持有一个信号量，如果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); - /* 释放一次信号量 */ - rt_sem_release(sem); + /* 如果失败，则测试失败 */ + 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; + } - /* 继续持有信号量，并永远等待直到持有到信号量 */ - result = rt_sem_take(sem, RT_WAITING_FOREVER); - if (result != RT_EOK) - { - /* 返回不正确，测试失败 */ - tc_done(TC_STAT_FAILED); - rt_sem_delete(sem); - return; - } + /* 释放一次信号量 */ + rt_sem_release(sem); - /* 测试成功 */ - tc_done(TC_STAT_PASSED); - /* 删除信号量 */ - rt_sem_delete(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; - } + /* 创建一个信号量，初始值是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); + /* 创建线程 */ + 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; + 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 (sem) + { + rt_sem_delete(sem); + sem = RT_NULL; + } - /* 删除信号量 */ - rt_sem_delete(sem); - } + /* 删除线程 */ + if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE) + { + rt_thread_delete(tid); + } - /* 调度器解锁 */ - rt_exit_critical(); + /* 调度器解锁 */ + rt_exit_critical(); - /* 设置TestCase状态 */ - tc_done(TC_STAT_PASSED); + /* 设置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 diff --git a/examples/kernel/semaphore_priority.c b/examples/kernel/semaphore_priority.c index c106a25d5..d6e3ce391 100644 --- a/examples/kernel/semaphore_priority.c +++ b/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; + rt_err_t result; - while (1) - { - result = rt_sem_take(sem, RT_WAITING_FOREVER); - if (result != RT_EOK) - { - tc_done(TC_STAT_FAILED); - return; - } + 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); - } + t1_count ++; + rt_kprintf("thread1: got semaphore, count: %d\n", t1_count); + } } static void thread2_entry(void* parameter) { - rt_err_t result; + rt_err_t result; - while (1) - { - result = rt_sem_take(sem, RT_WAITING_FOREVER); - if (result != RT_EOK) - { - tc_done(TC_STAT_FAILED); - return; - } + 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); - } + 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; - } + 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_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); + 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); + 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); + 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; + return 0; } #ifdef RT_USING_TC static void _tc_cleanup() { - /* lock scheduler */ - rt_enter_critical(); + /* lock scheduler */ + rt_enter_critical(); - /* delete t1, t2 and worker thread */ - rt_thread_delete(t1); - rt_thread_delete(t2); - rt_thread_delete(worker); + /* 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); + if (sem) + { + rt_sem_delete(sem); + sem = RT_NULL; + } - /* unlock scheduler */ - rt_exit_critical(); + 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 diff --git a/examples/kernel/semaphore_producer_consumer.c b/examples/kernel/semaphore_producer_consumer.c index ec0bf2234..48da71430 100644 --- a/examples/kernel/semaphore_producer_consumer.c +++ b/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; + int cnt = 0; - /* 运行100次 */ - while( cnt < 100) - { - /* 获取一个空位 */ - rt_sem_take(&sem_empty, RT_WAITING_FOREVER); + /* 运行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); + /* 修改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_sem_release(&sem_full); + cnt++; - /* 暂停一段时间 */ - rt_thread_delay(50); - } + /* 暂停一段时间 */ + rt_thread_delay(50); + } - rt_kprintf("the producer exit!\n"); + 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); + /* 初始化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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/semaphore_static.c b/examples/kernel/semaphore_static.c index b64d5cef4..cb199886a 100644 --- a/examples/kernel/semaphore_static.c +++ b/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; + rt_err_t result; + rt_tick_t tick; - /* 获得当前的OS Tick */ - tick = rt_tick_get(); + /* 获得当前的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; - } + /* 试图持有信号量，最大等待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); - /* 释放一次信号量 */ - rt_sem_release(&sem); + 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; + } - /* 永久等待方式持有信号量 */ - result = rt_sem_take(&sem, RT_WAITING_FOREVER); - if (result != RT_EOK) - { - /* 不成功则测试失败 */ - tc_done(TC_STAT_FAILED); - rt_sem_detach(&sem); - return; - } + /* 释放一次信号量 */ + rt_sem_release(&sem); - /* 测试通过 */ - tc_done(TC_STAT_PASSED); - /* 脱离信号量对象 */ - rt_sem_detach(&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; + 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; - } + /* 初始化信号量，初始值是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); + /* 初始化线程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; + 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 diff --git a/examples/kernel/tc_comm.c b/examples/kernel/tc_comm.c index 60d843171..c94475527 100644 --- a/examples/kernel/tc_comm.c +++ b/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; + unsigned int fail_count = 0; + struct finsh_syscall* index; - /* create tc semaphore */ - rt_sem_init(&_tc_sem, "tc", 0, RT_IPC_FLAG_FIFO); + /* 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; + 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); + _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_cleanup != RT_NULL) + { + /* perform testcase cleanup */ + _tc_cleanup(); + _tc_cleanup = RT_NULL; + } - rt_sem_trytake(&_tc_sem);/* by nl1031 */ + 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); - else - rt_kprintf("TestCase[%s] passed\n", _tc_current); - } - else - { - if (_tc_cleanup != RT_NULL) - { - /* perform testcase cleanup */ - _tc_cleanup(); - _tc_cleanup = RT_NULL; - } - } - } - } - } + 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"); - /* detach tc semaphore */ - rt_sem_detach(&_tc_sem); + 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; + _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(); + 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); + /* 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); + /* 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; + 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 ; - } + /* 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(); - } + /* 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); + 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); + 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; + /* set tc stat */ + _tc_stat = TC_STAT_RUNNING | TC_STAT_FAILED; - if (result == RT_EOK) - rt_thread_startup(&_tc_thread); + 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; + 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) - { + 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 diff --git a/examples/kernel/tc_comm.h b/examples/kernel/tc_comm.h index 714609768..aee1fec2d 100644 --- a/examples/kernel/tc_comm.h +++ b/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); diff --git a/examples/kernel/tc_sample.c b/examples/kernel/tc_sample.c index ea77ccda3..212875b71 100644 --- a/examples/kernel/tc_sample.c +++ b/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 diff --git a/examples/kernel/thread_delay.c b/examples/kernel/thread_delay.c index 23d25d6d5..f9404d704 100644 --- a/examples/kernel/thread_delay.c +++ b/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 diff --git a/examples/kernel/thread_delete.c b/examples/kernel/thread_delete.c index 6bae53994..72eb4ec00 100644 --- a/examples/kernel/thread_delete.c +++ b/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; + rt_uint32_t count = 0; - while (1) - { - /* 线程1采用低优先级运行，一直打印计数值 */ - // rt_kprintf("thread count: %d\n", count ++); - count ++; - } + 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拥有较高的优先级，以抢占线程1而获得执行 */ - /* 线程2启动后先睡眠10个OS Tick */ - rt_thread_delay(10); + /* 线程2启动后先睡眠10个OS Tick */ + rt_thread_delay(RT_TICK_PER_SECOND); - /* - * 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程 - * 队列 - */ - rt_thread_delete(tid1); + /* + * 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程 + * 队列 + */ + rt_thread_delete(tid1); - /* - * 线程2继续休眠10个OS Tick然后退出，线程2休眠后应切换到idle线程 - * idle线程将执行真正的线程1控制块和线程栈的删除 - */ - rt_thread_delay(10); + /* + * 线程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线 - * 程中释放) - */ + /* + * 线程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); + 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 */ + 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); + /* 创建线程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; + return 10 * RT_TICK_PER_SECOND; } #ifdef RT_USING_TC static void _tc_cleanup() { - /* lock scheduler */ - rt_enter_critical(); + /* 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); - } + /* 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(); + /* 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 diff --git a/examples/kernel/thread_detach.c b/examples/kernel/thread_detach.c index af1824ae3..9370f212e 100644 --- a/examples/kernel/thread_detach.c +++ b/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; + 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); + /* 初始化线程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); + /* 初始化线程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; + 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 diff --git a/examples/kernel/thread_dynamic.c b/examples/kernel/thread_dynamic.c index 960a40de9..0afb7f8f8 100644 --- a/examples/kernel/thread_dynamic.c +++ b/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 diff --git a/examples/kernel/thread_dynamic_simple.c b/examples/kernel/thread_dynamic_simple.c index 9d7612bdd..28944b1f3 100644 --- a/examples/kernel/thread_dynamic_simple.c +++ b/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 diff --git a/examples/kernel/thread_priority.c b/examples/kernel/thread_priority.c index 1d6fb4a80..0045b0e57 100644 --- a/examples/kernel/thread_priority.c +++ b/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; + 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); + 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; - } - } + break; + } + } } int thread_priority_init() { - rt_err_t result; + 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); + result = rt_thread_init(&thread1, + "t1", + thread1_entry, RT_NULL, + &thread1_stack[0], sizeof(thread1_stack), + THREAD_PRIORITY - 1, THREAD_TIMESLICE); - 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(&thread1); + else + tc_stat(TC_STAT_FAILED); - if (result == RT_EOK) - rt_thread_startup(&thread2); - 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); - return 0; + 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 diff --git a/examples/kernel/thread_resume.c b/examples/kernel/thread_resume.c index ac8b6cb48..cea814616 100644 --- a/examples/kernel/thread_resume.c +++ b/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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/thread_same_priority.c b/examples/kernel/thread_same_priority.c index 5e0fb8111..c7da2087a 100644 --- a/examples/kernel/thread_same_priority.c +++ b/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; + 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(&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); + 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; + 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 diff --git a/examples/kernel/thread_static.c b/examples/kernel/thread_static.c index 4547304b5..3033f2cda 100644 --- a/examples/kernel/thread_static.c +++ b/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 diff --git a/examples/kernel/thread_static_simple.c b/examples/kernel/thread_static_simple.c index 3ab8ffda0..d9e3ff6f6 100644 --- a/examples/kernel/thread_static_simple.c +++ b/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 diff --git a/examples/kernel/thread_suspend.c b/examples/kernel/thread_suspend.c index 7c019573b..947cc3cbf 100644 --- a/examples/kernel/thread_suspend.c +++ b/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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/thread_yield.c b/examples/kernel/thread_yield.c index de2c3a53a..4ed6b90e2 100644 --- a/examples/kernel/thread_yield.c +++ b/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); + /* 创建线程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); + /* 创建线程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; + 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 diff --git a/examples/kernel/timer_control.c b/examples/kernel/timer_control.c index f685f140e..9fcb0d4c4 100644 --- a/examples/kernel/timer_control.c +++ b/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 diff --git a/examples/kernel/timer_dynamic.c b/examples/kernel/timer_dynamic.c index 49262b819..1260d50c0 100644 --- a/examples/kernel/timer_dynamic.c +++ b/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 diff --git a/examples/kernel/timer_static.c b/examples/kernel/timer_static.c index bddfe63af..884927bbc 100644 --- a/examples/kernel/timer_static.c +++ b/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 diff --git a/examples/kernel/timer_stop_self.c b/examples/kernel/timer_stop_self.c index 6d1e287e5..38ec9c441 100644 --- a/examples/kernel/timer_stop_self.c +++ b/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 diff --git a/examples/kernel/timer_timeout.c b/examples/kernel/timer_timeout.c index 80241e53f..d1a7099e2 100644 --- a/examples/kernel/timer_timeout.c +++ b/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; + char buf[64]; + rt_err_t result; - /* ʼʱ */ - rt_timer_init(&timer, "timer", /* ʱ timer1 */ - timer_timeout, /* ʱʱصĴ */ - RT_NULL, /* ʱڲ */ - 1, /* ʱȣOS TickΪλ1OS Tick */ - RT_TIMER_FLAG_PERIODIC); /* Զʱ */ + /* ʼʱ */ + rt_timer_init(&timer, "timer", /* ʱ timer1 */ + timer_timeout, /* ʱʱصĴ */ + RT_NULL, /* ʱڲ */ + 1, /* ʱȣOS TickΪλ1OS Tick */ + RT_TIMER_FLAG_PERIODIC); /* Զʱ */ - while (1) - { - rt_memset(&buf[0], 0, sizeof(buf)); + 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"); - } - } + /* ϢнϢ */ + 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); /* ж̵߳ȴȵõķϢ */ + /* ʼϢ */ + 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); + /* ߳ */ + 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; + 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 diff --git a/include/rtthread.h b/include/rtthread.h index b68a301a5..0891ed9bc 100644 --- a/include/rtthread.h +++ b/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)); diff --git a/src/idle.c b/src/idle.c index ff3fde21c..7bca6c28c 100644 --- a/src/idle.c +++ b/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 @@ -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; diff --git a/src/scheduler.c b/src/scheduler.c index cefc5b8c4..a0384e899 100644 --- a/src/scheduler.c +++ b/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 @@ -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; +} /*@}*/