Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
2301_76519099
rt-thread
提交
4c463f27
R
rt-thread
项目概览
2301_76519099
/
rt-thread
与 Fork 源项目一致
Fork自
RT-Thread / rt-thread
通知
3
Star
1
Fork
1
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
rt-thread
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
4c463f27
编写于
12月 22, 2013
作者:
G
geniusgogo
浏览文件
操作
浏览文件
下载
差异文件
Merge branch 'master' into SQLite_on_ARMCC
上级
7442414a
8b1b6456
变更
44
展开全部
隐藏空白更改
内联
并排
Showing
44 changed file
with
2431 addition
and
2491 deletion
+2431
-2491
bsp/simulator/SConstruct
bsp/simulator/SConstruct
+1
-34
bsp/simulator/applications/application.c
bsp/simulator/applications/application.c
+0
-21
bsp/simulator/readme.txt
bsp/simulator/readme.txt
+21
-45
bsp/simulator/rtconfig.h
bsp/simulator/rtconfig.h
+1
-1
components/dfs/filesystems/elmfat/ff.c
components/dfs/filesystems/elmfat/ff.c
+6
-9
components/dfs/filesystems/elmfat/ff.h
components/dfs/filesystems/elmfat/ff.h
+0
-2
components/dfs/src/dfs_fs.c
components/dfs/src/dfs_fs.c
+130
-175
examples/kernel/cpuusage.c
examples/kernel/cpuusage.c
+47
-47
examples/kernel/event_simple.c
examples/kernel/event_simple.c
+90
-90
examples/kernel/heap_malloc.c
examples/kernel/heap_malloc.c
+40
-38
examples/kernel/heap_realloc.c
examples/kernel/heap_realloc.c
+73
-54
examples/kernel/mbox_send_wait.c
examples/kernel/mbox_send_wait.c
+73
-73
examples/kernel/mbox_simple.c
examples/kernel/mbox_simple.c
+78
-78
examples/kernel/memp_simple.c
examples/kernel/memp_simple.c
+88
-88
examples/kernel/messageq_simple.c
examples/kernel/messageq_simple.c
+101
-101
examples/kernel/mutex_simple.c
examples/kernel/mutex_simple.c
+114
-114
examples/kernel/semaphore_buffer_worker.c
examples/kernel/semaphore_buffer_worker.c
+189
-189
examples/kernel/semaphore_dynamic.c
examples/kernel/semaphore_dynamic.c
+94
-87
examples/kernel/semaphore_priority.c
examples/kernel/semaphore_priority.c
+95
-89
examples/kernel/semaphore_producer_consumer.c
examples/kernel/semaphore_producer_consumer.c
+93
-89
examples/kernel/semaphore_static.c
examples/kernel/semaphore_static.c
+89
-85
examples/kernel/tc_comm.c
examples/kernel/tc_comm.c
+136
-122
examples/kernel/tc_comm.h
examples/kernel/tc_comm.h
+9
-9
examples/kernel/tc_sample.c
examples/kernel/tc_sample.c
+30
-30
examples/kernel/thread_delay.c
examples/kernel/thread_delay.c
+35
-35
examples/kernel/thread_delete.c
examples/kernel/thread_delete.c
+91
-93
examples/kernel/thread_detach.c
examples/kernel/thread_detach.c
+61
-61
examples/kernel/thread_dynamic.c
examples/kernel/thread_dynamic.c
+17
-17
examples/kernel/thread_dynamic_simple.c
examples/kernel/thread_dynamic_simple.c
+44
-44
examples/kernel/thread_priority.c
examples/kernel/thread_priority.c
+61
-61
examples/kernel/thread_resume.c
examples/kernel/thread_resume.c
+68
-68
examples/kernel/thread_same_priority.c
examples/kernel/thread_same_priority.c
+52
-52
examples/kernel/thread_static.c
examples/kernel/thread_static.c
+19
-19
examples/kernel/thread_static_simple.c
examples/kernel/thread_static_simple.c
+47
-47
examples/kernel/thread_suspend.c
examples/kernel/thread_suspend.c
+51
-51
examples/kernel/thread_yield.c
examples/kernel/thread_yield.c
+53
-53
examples/kernel/timer_control.c
examples/kernel/timer_control.c
+40
-40
examples/kernel/timer_dynamic.c
examples/kernel/timer_dynamic.c
+41
-41
examples/kernel/timer_static.c
examples/kernel/timer_static.c
+33
-33
examples/kernel/timer_stop_self.c
examples/kernel/timer_stop_self.c
+38
-38
examples/kernel/timer_timeout.c
examples/kernel/timer_timeout.c
+66
-66
include/rtthread.h
include/rtthread.h
+1
-0
src/idle.c
src/idle.c
+5
-2
src/scheduler.c
src/scheduler.c
+10
-0
未找到文件。
bsp/simulator/SConstruct
浏览文件 @
4c463f27
...
...
@@ -7,17 +7,9 @@ if os.getenv('RTT_ROOT'):
else
:
RTT_ROOT
=
os
.
path
.
normpath
(
os
.
getcwd
()
+
'/../..'
)
if
os
.
getenv
(
'RTT_RTGUI'
):
RTT_RTGUI
=
os
.
getenv
(
'RTT_RTGUI'
)
else
:
# set the rtgui root directory by hand
# empty string means use the RTGUI in svn
RTT_RTGUI
=
os
.
path
.
normpath
(
r
'F:\Project\git\rt-gui\components\rtgui'
)
sys
.
path
=
sys
.
path
+
[
os
.
path
.
join
(
RTT_ROOT
,
'tools'
)]
from
building
import
*
env
=
Environment
(
TARGET_ARCH
=
'x86'
)
Export
(
'RTT_ROOT'
)
...
...
@@ -84,32 +76,7 @@ else:
# prepare building environment
objs
=
PrepareBuilding
(
env
,
RTT_ROOT
,
has_libcpu
=
False
,
remove_components
=
[
'rtgui'
])
if
GetDepend
(
'RT_USING_RTGUI'
):
try
:
if
RTT_RTGUI
:
objs
+=
SConscript
(
os
.
path
.
join
(
RTT_RTGUI
,
'SConscript'
),
variant_dir
=
'build/components/rtgui'
,
duplicate
=
0
)
objs
=
objs
+
SConscript
(
RTT_RTGUI
+
'/../../demo/examples/SConscript'
,
variant_dir
=
'build/examples/gui'
,
duplicate
=
0
)
else
:
objs
+=
SConscript
(
os
.
path
.
join
(
RTT_ROOT
+
'/components/rtgui'
,
'SConscript'
),
variant_dir
=
'build/components/rtgui'
,
duplicate
=
0
)
objs
=
objs
+
SConscript
(
RTT_ROOT
+
'/examples/gui/SConscript'
,
variant_dir
=
'build/examples/gui'
,
duplicate
=
0
)
except
:
print
print
'RTGUI configuration is invalid!'
print
'RT_USING_RTGUI is enabled in rtconfig.h, but scons cannot find '
+
\
'RTGUI source code. In order to eliminate this error, you can '
+
\
'add RTT_RTGUI in environment to point RTGUI source code, or '
+
\
'disable RT_USING_RTGUI in rtconfig.h'
exit
(
-
1
);
if
GetDepend
(
'RT_USING_TC'
):
objs
=
objs
+
SConscript
(
RTT_ROOT
+
'/examples/kernel/SConscript'
,
variant_dir
=
'build/tc/kernel'
,
duplicate
=
0
)
objs
=
PrepareBuilding
(
env
,
RTT_ROOT
,
has_libcpu
=
False
)
def
ObjRemove
(
objs
,
remove
):
for
item
in
objs
:
...
...
bsp/simulator/applications/application.c
浏览文件 @
4c463f27
...
...
@@ -40,10 +40,6 @@ void rt_init_thread_entry(void *parameter)
rt_hw_sdl_start
();
#endif
/* RT_USING_RTGUI */
#if defined(RT_USING_COMPONENTS_INIT) && defined(__GNUC__) && defined(RT_USING_FINSH)
finsh_set_device
(
RT_CONSOLE_DEVICE_NAME
);
#endif
/* File system Initialization */
#ifdef RT_USING_DFS
{
...
...
@@ -94,17 +90,6 @@ void rt_init_thread_entry(void *parameter)
#endif
}
static
void
rt_test_thread_entry
(
void
*
parameter
)
{
int
i
;
for
(
i
=
0
;
i
<
5
;
i
++
)
{
rt_kprintf
(
"hello, world
\n
"
);
rt_thread_delay
(
RT_TICK_PER_SECOND
);
}
}
int
rt_application_init
()
{
rt_thread_t
tid
;
...
...
@@ -116,12 +101,6 @@ int rt_application_init()
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
tid
=
rt_thread_create
(
"test"
,
rt_test_thread_entry
,
RT_NULL
,
2048
,
RT_THREAD_PRIORITY_MAX
*
3
/
4
,
20
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
return
0
;
}
...
...
bsp/simulator/readme.txt
浏览文件 @
4c463f27
说明: 本BSP可以如下演示
依赖软件包
python2.7 (python2.6
使用scons --target=vs -s生成工程会出现错误)
python2.7 (python2.6
无法生成vs工程)
一 平台及组件支持
目前rtconfig.py中支持的编译器有
1). msvc 用于windows平台
此平台支持的组件
kernel
...
...
@@ -24,38 +25,21 @@
DFS, ELM FatFS, UFFS
RTGUI
请根据自己的实际情况,修改rtconfig.py中CROSS_TOOL为上述某一值。
二 组件配置
1) RTGUI
当前代码中已经不含RTGUI源码,因此读者需要配置一下才能在simulator中使用RTGUI
RTGUI的最新源码目前是托管在github上:https://github.com/RT-Thread/RTGUI
共有两种方法。
方法1 添加环境变量
向系统加入RTT_RTGUI环境变量,其值为刚才github上下载的rtgui源码包的路径。
例如笔者的rtgui源码包解压至 F:\Project\git\rt-gui\下, 则将此环境变量配置为 F:\Project\git\rt-gui\components\rtgui
方法2 不添加环境变量
打开SConstruct文件,
....
10 if os.getenv('RTT_RTGUI'):
11 RTT_RTGUI = os.getenv('RTT_RTGUI')
12 else:
13 # set the rtgui root directory by hand
14 # empty string means use the RTGUI in svn
15 # RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
16 RTT_RTGUI =''
....
将15,16行修改为
14 # empty string means use the RTGUI in svn
15 RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
16 # RTT_RTGUI =''
简单说明一下:
1)#号表示注释,类似于c语言中的//,
2)其中15行的路径为你的RTGUI路径源码,注意不是压缩包路径,而是压缩包路径下的 components\rtgui目录的绝对路径。
RTGUI的最新源码目前托管在github上:https://github.com/RT-Thread/RTGUI
下载最新的RTGUI源码,将RTGUI源码包中components下的rtgui目录复制到Rt-thread的components目录下。
三 编译
1) 使用Visual Studio(2005以上版本)
在当前目录中打开cmd,输入命令
`scons --target=vs -s`
可以生成project.vsproj,双击运行
生成vs2005的project.vsproj,使用vs2005及以上版本可以打开(VS2005需要转换工程)。
或直接生成vs2012工程
`scons --target=vs2012 -s`
2) 命令行编译
修改rtconfig.py, 配置合适的编译器(msvc/mingw/gcc),及其路径
...
...
@@ -73,31 +57,23 @@ RTGUI的最新源码目前是托管在github上:https://github.com/RT-Thread/R
按下回车,出现finsh,然后输入`mkfs("elm", "sd0")`格式化SD卡,如下所示
finsh>>mkfs("elm", "sd0")
0, 0x00000000
然后重启程序,就可以看到fatfs挂载成功了
重启程序,可以正确挂载fat文件系统。
2) 测试RTGUI
启动后就会看到GUI窗口,分辨率800x480,此时在finsh中输入snake_main()并回车,即
可运行贪吃蛇程序
打开RTGUI组件后编译,启动在finsh中输入snake_main()并回车,
可运行贪吃蛇程序
3) 测试APP module
rtconfig.h中需要打开RT_USING_MODULE
在rtconfig.h中打开RT_USING_MODULE
测试app module需要执行3步,如下a, b, c所示。
a. 生成rtthread.def文件
使用msv编译主程序时需要此文件,使用MingW编译主程序时不需要
msvc需要此文件才能生成正确导出符号的rtthread.dll和rtthread-win32.exe。
此目录下默认自带了一个rtthread.def文件,当修改了rtconfig.h,禁用了某些组件时,则需要重新生成rtthread.def文件.
生成方法:
需要借助MingW工具,修改rtconfig.py中CROSS_TOOL为'mingw',然后打开CMD执行`scons --def`就会自动更新rtthread.def。
执行`scons --def`可以自动生成rtthread.def。
当修改了rtconfig.h,打开或禁用了某些组件时,需要重新生成rtthread.def文件.
b. 生成主程序
主程序可以使用msvc和mingw生成
如果rtconfig.h中的使能了RTGUI,则需要参考第二节第1小节配置RTGUI
a.1 使用msvc
修改rtconfig.py中CROSS_TOOL为'msvc'
首先要保证当前目录下有合适的rtthread.def文件,如果没有对默认的rtconfig.h作修改,则使用默认的rtthread.def即可
CMD命令行执行`scons -j4`,即可生成rtthread.dll和 rtthread-win32.exe
a.2 使用mingw
修改rtconfig.py中CROSS_TOOL为'mingw'
CMD命令行执行`scons -j4`,这就会生成 rtthread.dll和 rtthread-win32.exe
`scons -j4`
c. 生成app module
进入testdll目录,再次修改 testdll/SConstruct, 同样需要配置RTT_RTGUI路径,同 1中3)
...
...
@@ -107,8 +83,8 @@ c. 生成app module
然后运行simulator目录下的 rtthread-win32.exe, 在finsh中运行
`exec("/testdll/basicapp/build/basicapp.dll")`
如果觉得这个路径太长,
就把
basicapp.dll复制到 simualtor目录下,执行
如果觉得这个路径太长,
可以将
basicapp.dll复制到 simualtor目录下,执行
`exec("/basicapp.dll")`
编译贪吃蛇程序
执行`scons --app=snake`,
就
会在snake/build/下生成snake.dll,按照同样的方式加载即可
执行`scons --app=snake`,会在snake/build/下生成snake.dll,按照同样的方式加载即可
bsp/simulator/rtconfig.h
浏览文件 @
4c463f27
...
...
@@ -209,7 +209,7 @@
#define RT_LWIP_TCP_WND 8192
/* SECTION: RT-Thread/GUI */
#define RT_USING_RTGUI
/* #define RT_USING_RTGUI */
/* name length of RTGUI object */
#define RTGUI_NAME_MAX 12
...
...
components/dfs/filesystems/elmfat/ff.c
浏览文件 @
4c463f27
...
...
@@ -108,12 +108,8 @@
#if _MAX_SS != 512 && _MAX_SS != 1024 && _MAX_SS != 2048 && _MAX_SS != 4096
#error Wrong sector size.
#endif
#if _MAX_SS != 512
#define SS(fs) ((fs)->ssize)
/* Multiple sector size */
#else
#define SS(fs) 512U
/* Fixed sector size */
#endif
#define SS(fs) ((fs)->ssize)
/* sector size */
/* Reentrancy related */
#if _FS_REENTRANT
...
...
@@ -2058,10 +2054,11 @@ FRESULT chk_mounted ( /* FR_OK(0): successful, !=0: any error occurred */
stat
=
disk_initialize
(
fs
->
drv
);
/* Initialize low level disk I/O layer */
if
(
stat
&
STA_NOINIT
)
/* Check if the initialization succeeded */
return
FR_NOT_READY
;
/* Failed to initialize due to no media or hard error */
#if _MAX_SS != 512
/* Get disk sector size (variable sector size cfg only) */
/* Get disk sector size (variable sector size cfg only) */
if
(
disk_ioctl
(
fs
->
drv
,
GET_SECTOR_SIZE
,
&
fs
->
ssize
)
!=
RES_OK
)
return
FR_DISK_ERR
;
#endif
#if !_FS_READONLY
if
(
chk_wp
&&
(
stat
&
STA_PROTECT
))
/* Check disk write protection if needed */
return
FR_WRITE_PROTECTED
;
...
...
@@ -3601,10 +3598,10 @@ FRESULT f_mkfs (
stat
=
disk_initialize
(
drv
);
if
(
stat
&
STA_NOINIT
)
return
FR_NOT_READY
;
if
(
stat
&
STA_PROTECT
)
return
FR_WRITE_PROTECTED
;
#if _MAX_SS != 512
/* Get disk sector size */
/* Get disk sector size */
if
(
disk_ioctl
(
drv
,
GET_SECTOR_SIZE
,
&
SS
(
fs
))
!=
RES_OK
)
return
FR_DISK_ERR
;
#endif
if
(
disk_ioctl
(
drv
,
GET_SECTOR_COUNT
,
&
n_vol
)
!=
RES_OK
||
n_vol
<
128
)
return
FR_DISK_ERR
;
b_vol
=
(
sfd
)
?
0
:
63
;
/* Volume start sector */
...
...
components/dfs/filesystems/elmfat/ff.h
浏览文件 @
4c463f27
...
...
@@ -84,9 +84,7 @@ typedef struct {
BYTE
fsi_flag
;
/* fsinfo dirty flag (1:must be written back) */
WORD
id
;
/* File system mount ID */
WORD
n_rootdir
;
/* Number of root directory entries (FAT12/16) */
#if _MAX_SS != 512
WORD
ssize
;
/* Bytes per sector (512,1024,2048,4096) */
#endif
#if _FS_REENTRANT
_SYNC_t
sobj
;
/* Identifier of sync object */
#endif
...
...
components/dfs/src/dfs_fs.c
浏览文件 @
4c463f27
...
...
@@ -37,48 +37,36 @@
*
* @param ops the file system instance to be registered.
*
* @return
0 on successful, -1
on failed.
* @return
RT_EOK on successful, -RT_ERROR
on failed.
*/
int
dfs_register
(
const
struct
dfs_filesystem_operation
*
ops
)
{
int
index
,
result
;
int
free_index
;
result
=
0
;
free_index
=
DFS_FILESYSTEM_TYPES_MAX
;
int
ret
=
RT_EOK
;
const
struct
dfs_filesystem_operation
**
empty
=
RT_NULL
;
const
struct
dfs_filesystem_operation
**
iter
;
/* lock filesystem */
dfs_lock
();
/* check if this filesystem was already registered */
for
(
index
=
0
;
index
<
DFS_FILESYSTEM_TYPES_MAX
;
index
++
)
for
(
iter
=
&
filesystem_operation_table
[
0
];
iter
<
&
filesystem_operation_table
[
DFS_FILESYSTEM_TYPES_MAX
];
iter
++
)
{
if
(
filesystem_operation_table
[
index
]
==
RT_NULL
)
{
/* find out an empty filesystem type entry */
if
(
free_index
==
DFS_FILESYSTEM_TYPES_MAX
)
free_index
=
index
;
}
else
if
(
strcmp
(
filesystem_operation_table
[
index
]
->
name
,
ops
->
name
)
==
0
)
/* find out an empty filesystem type entry */
if
(
*
iter
==
RT_NULL
)
(
empty
==
RT_NULL
)
?
(
empty
=
iter
)
:
0
;
else
if
(
strcmp
((
*
iter
)
->
name
,
ops
->
name
)
==
0
)
{
re
sul
t
=
-
1
;
goto
err
;
ret
=
-
1
;
break
;
}
}
/* filesystem type table full */
if
(
free_index
==
DFS_FILESYSTEM_TYPES_MAX
)
{
result
=
-
1
;
goto
err
;
}
/* save the filesystem's operations */
filesystem_operation_table
[
free_index
]
=
ops
;
if
((
ret
==
RT_EOK
)
&&
(
empty
!=
RT_NULL
))
*
empty
=
ops
;
err:
dfs_unlock
();
return
re
sul
t
;
return
ret
;
}
/**
...
...
@@ -91,37 +79,33 @@ err:
*/
struct
dfs_filesystem
*
dfs_filesystem_lookup
(
const
char
*
path
)
{
struct
dfs_filesystem
*
fs
;
rt_uint32_t
index
,
fspath
,
prefixlen
;
struct
dfs_filesystem
*
iter
;
struct
dfs_filesystem
*
fs
=
RT_NULL
;
rt_uint32_t
fspath
,
prefixlen
;
fs
=
RT_NULL
;
prefixlen
=
0
;
/* lock filesystem */
dfs_lock
();
/* lookup it in the filesystem table */
for
(
index
=
0
;
index
<
DFS_FILESYSTEMS_MAX
;
index
++
)
for
(
iter
=
&
filesystem_table
[
0
];
iter
<
&
filesystem_table
[
DFS_FILESYSTEMS_MAX
];
iter
++
)
{
if
(
filesystem_table
[
index
].
path
==
RT_NULL
)
if
(
(
iter
->
path
==
RT_NULL
)
||
(
iter
->
ops
==
RT_NULL
)
)
continue
;
else
{
fspath
=
strlen
(
filesystem_table
[
index
].
path
);
if
(
fspath
<
prefixlen
)
continue
;
}
if
((
filesystem_table
[
index
].
ops
!=
RT_NULL
)
&&
(
strncmp
(
filesystem_table
[
index
].
path
,
path
,
fspath
)
==
0
))
{
/* check next path separator */
if
(
fspath
>
1
&&
(
strlen
(
path
)
>
fspath
)
&&
(
path
[
fspath
]
!=
'/'
))
continue
;
fspath
=
strlen
(
iter
->
path
);
if
((
fspath
<
prefixlen
)
||
(
strncmp
(
iter
->
path
,
path
,
fspath
)
!=
0
))
continue
;
fs
=
&
filesystem_table
[
index
];
prefixlen
=
fspath
;
}
/* check next path separator */
if
(
fspath
>
1
&&
(
strlen
(
path
)
>
fspath
)
&&
(
path
[
fspath
]
!=
'/'
))
continue
;
fs
=
iter
;
prefixlen
=
fspath
;
}
dfs_unlock
();
...
...
@@ -147,64 +131,42 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition *part,
rt_uint8_t
*
dpt
;
rt_uint8_t
type
;
rt_err_t
result
;
RT_ASSERT
(
part
!=
RT_NULL
);
RT_ASSERT
(
buf
!=
RT_NULL
);
result
=
RT_EOK
;
dpt
=
buf
+
DPT_ADDRESS
+
pindex
*
DPT_ITEM_SIZE
;
/* check if it is a valid partition table */
if
((
*
dpt
!=
0x80
)
&&
(
*
dpt
!=
0x00
))
{
/* which is not a partition table */
result
=
-
RT_ERROR
;
return
result
;
}
return
-
RT_ERROR
;
/* get partition type */
type
=
*
(
dpt
+
4
);
if
(
type
!=
0
)
{
/* set partition type */
part
->
type
=
type
;
/* get partition offset and size */
part
->
offset
=
*
(
dpt
+
8
)
|
*
(
dpt
+
9
)
<<
8
|
*
(
dpt
+
10
)
<<
16
|
*
(
dpt
+
11
)
<<
24
;
part
->
size
=
*
(
dpt
+
12
)
|
*
(
dpt
+
13
)
<<
8
|
*
(
dpt
+
14
)
<<
16
|
*
(
dpt
+
15
)
<<
24
;
rt_kprintf
(
"found part[%d], begin: %d, size: "
,
pindex
,
part
->
offset
*
512
);
if
((
part
->
size
>>
11
)
>
0
)
/* MB */
{
unsigned
int
part_size
;
part_size
=
part
->
size
>>
11
;
/* MB */
if
((
part_size
>>
10
)
>
0
)
/* GB */
{
/* GB */
rt_kprintf
(
"%d.%d%s"
,
part_size
>>
10
,
part_size
&
0x3FF
,
"GB
\r\n
"
);
}
else
{
/* MB */
rt_kprintf
(
"%d.%d%s"
,
part_size
,(
part
->
size
>>
1
)
&
0x3FF
,
"MB
\r\n
"
);
}
}
else
{
/* KB */
rt_kprintf
(
"%d%s"
,
part
->
size
>>
1
,
"KB
\r\n
"
);
}
}
if
(
type
==
0
)
return
-
RT_ERROR
;
/* set partition information
* size is the number of 512-Byte */
part
->
type
=
type
;
part
->
offset
=
*
(
dpt
+
8
)
|
*
(
dpt
+
9
)
<<
8
|
*
(
dpt
+
10
)
<<
16
|
*
(
dpt
+
11
)
<<
24
;
part
->
size
=
*
(
dpt
+
12
)
|
*
(
dpt
+
13
)
<<
8
|
*
(
dpt
+
14
)
<<
16
|
*
(
dpt
+
15
)
<<
24
;
rt_kprintf
(
"found part[%d], begin: %d, size: "
,
pindex
,
part
->
offset
*
512
);
if
((
part
->
size
>>
11
)
==
0
)
rt_kprintf
(
"%d%s"
,
part
->
size
>>
1
,
"KB
\n
"
);
/* KB */
else
{
result
=
-
RT_ERROR
;
unsigned
int
part_size
;
part_size
=
part
->
size
>>
11
;
/* MB */
if
((
part_size
>>
10
)
==
0
)
rt_kprintf
(
"%d.%d%s"
,
part_size
,(
part
->
size
>>
1
)
&
0x3FF
,
"MB
\n
"
);
else
rt_kprintf
(
"%d.%d%s"
,
part_size
>>
10
,
part_size
&
0x3FF
,
"GB
\n
"
);
}
return
result
;
return
RT_EOK
;
}
/**
...
...
@@ -224,57 +186,54 @@ int dfs_mount(const char *device_name,
unsigned
long
rwflag
,
const
void
*
data
)
{
const
struct
dfs_filesystem_operation
*
ops
;
struct
dfs_filesystem
*
fs
;
char
*
fullpath
=
RT_NULL
;
const
struct
dfs_filesystem_operation
**
ops
;
struct
dfs_filesystem
*
iter
;
struct
dfs_filesystem
*
fs
=
RT_NULL
;
char
*
fullpath
=
RT_NULL
;
rt_device_t
dev_id
;
int
index
,
free_index
;
/* open specific device */
if
(
device_name
!
=
RT_NULL
)
if
(
device_name
=
=
RT_NULL
)
{
dev_id
=
rt_device_find
(
device_name
);
if
(
dev_id
==
RT_NULL
)
{
/* no this device */
rt_set_errno
(
-
DFS_STATUS_ENODEV
);
return
-
1
;
}
/* which is a non-device filesystem mount */
dev_id
=
NULL
;
}
else
else
if
((
dev_id
=
rt_device_find
(
device_name
))
==
RT_NULL
)
{
/* which is a non-device filesystem mount */
dev_id
=
RT_NULL
;
/* no this device */
rt_set_errno
(
-
DFS_STATUS_ENODEV
);
return
-
1
;
}
/* find out specific filesystem */
/* find out
the
specific filesystem */
dfs_lock
();
for
(
index
=
0
;
index
<
DFS_FILESYSTEM_TYPES_MAX
;
index
++
)
{
if
(
filesystem_operation_table
[
index
]
==
RT_NULL
)
continue
;
if
(
strcmp
(
filesystem_operation_table
[
index
]
->
name
,
filesystemtype
)
==
0
)
for
(
ops
=
&
filesystem_operation_table
[
0
];
ops
<
&
filesystem_operation_table
[
DFS_FILESYSTEM_TYPES_MAX
];
ops
++
)
if
((
ops
!=
RT_NULL
)
&&
(
strcmp
((
*
ops
)
->
name
,
filesystemtype
)
==
0
))
break
;
}
dfs_unlock
();
/* can't find filesystem */
if
(
index
==
DFS_FILESYSTEM_TYPES_MAX
)
if
(
ops
==
&
filesystem_operation_table
[
DFS_FILESYSTEM_TYPES_MAX
])
{
/* can't find filesystem */
rt_set_errno
(
-
DFS_STATUS_ENODEV
);
return
-
1
;
}
/* check if there is mount implementation */
if
((
*
ops
==
NULL
)
||
((
*
ops
)
->
mount
==
NULL
))
{
rt_set_errno
(
-
DFS_STATUS_ENOSYS
);
return
-
1
;
}
ops
=
filesystem_operation_table
[
index
];
/* make full path for special file */
fullpath
=
dfs_normalize_path
(
RT_NULL
,
path
);
if
(
fullpath
==
RT_NULL
)
/* not an abstract path */
{
rt_set_errno
(
-
DFS_STATUS_ENOTDIR
);
return
-
1
;
}
...
...
@@ -293,60 +252,52 @@ int dfs_mount(const char *device_name,
dfs_file_close
(
&
fd
);
}
free_index
=
DFS_FILESYSTEMS_MAX
;
/* check whether the file system mounted or not
*/
/* check whether the file system mounted or not in the filesystem table
* if it is unmounted yet, find out an empty entry
*/
dfs_lock
();
for
(
index
=
0
;
index
<
DFS_FILESYSTEMS_MAX
;
index
++
)
for
(
iter
=
&
filesystem_table
[
0
];
iter
<
&
filesystem_table
[
DFS_FILESYSTEMS_MAX
];
iter
++
)
{
if
(
filesystem_table
[
index
].
ops
==
RT_NULL
)
{
/* find out an empty filesystem table entry */
if
(
free_index
==
DFS_FILESYSTEMS_MAX
)
free_index
=
index
;
}
else
if
(
strcmp
(
filesystem_table
[
index
].
path
,
path
)
==
0
)
/* check if it is an empty filesystem table entry? if it is, save fs */
if
(
iter
->
ops
==
RT_NULL
)
(
fs
==
RT_NULL
)
?
(
fs
=
iter
)
:
0
;
/* check if the PATH is mounted */
else
if
(
strcmp
(
iter
->
path
,
path
)
==
0
)
{
rt_set_errno
(
-
DFS_STATUS_EINVAL
);
goto
err1
;
}
}
/* can't find en empty filesystem table entry */
if
(
free_index
==
DFS_FILESYSTEMS_MAX
)
if
((
fs
==
RT_NULL
)
&&
(
iter
==
&
filesystem_table
[
DFS_FILESYSTEMS_MAX
]))
{
rt_set_errno
(
-
DFS_STATUS_ENOSPC
);
goto
err1
;
}
/* register file system */
fs
=
&
(
filesystem_table
[
free_index
]);
fs
->
path
=
fullpath
;
fs
->
ops
=
ops
;
fs
->
ops
=
*
ops
;
fs
->
dev_id
=
dev_id
;
/* release filesystem_table lock */
dfs_unlock
();
/* open device, but do not check the status of device */
if
(
dev_id
!=
RT_NULL
)
rt_device_open
(
fs
->
dev_id
,
RT_DEVICE_OFLAG_RDWR
);
/* there is no mount implementation */
if
(
ops
->
mount
==
RT_NULL
)
{
if
(
dev_id
!=
RT_NULL
)
rt_device_close
(
dev_id
);
dfs_lock
();
/* clear filesystem table entry */
rt_memset
(
fs
,
0
,
sizeof
(
struct
dfs_filesystem
));
dfs_unlock
();
rt_free
(
fullpath
);
rt_set_errno
(
-
DFS_STATUS_ENOSYS
);
return
-
1
;
if
(
rt_device_open
(
fs
->
dev_id
,
RT_DEVICE_OFLAG_RDWR
)
!=
RT_EOK
)
{
/* The underlaying device has error, clear the entry. */
dfs_lock
();
rt_memset
(
fs
,
0
,
sizeof
(
struct
dfs_filesystem
));
goto
err1
;
}
}
/* call mount of this filesystem */
else
if
(
ops
->
mount
(
fs
,
rwflag
,
data
)
<
0
)
if
((
*
ops
)
->
mount
(
fs
,
rwflag
,
data
)
<
0
)
{
/* close device */
if
(
dev_id
!=
RT_NULL
)
...
...
@@ -356,19 +307,14 @@ int dfs_mount(const char *device_name,
dfs_lock
();
/* clear filesystem table entry */
rt_memset
(
fs
,
0
,
sizeof
(
struct
dfs_filesystem
));
dfs_unlock
();
rt_free
(
fullpath
);
return
-
1
;
goto
err1
;
}
return
0
;
err1:
dfs_unlock
();
if
(
fullpath
!=
RT_NULL
)
rt_free
(
fullpath
);
rt_free
(
fullpath
);
return
-
1
;
}
...
...
@@ -383,6 +329,7 @@ err1:
int
dfs_unmount
(
const
char
*
specialfile
)
{
char
*
fullpath
;
struct
dfs_filesystem
*
iter
;
struct
dfs_filesystem
*
fs
=
RT_NULL
;
fullpath
=
dfs_normalize_path
(
RT_NULL
,
specialfile
);
...
...
@@ -396,7 +343,17 @@ int dfs_unmount(const char *specialfile)
/* lock filesystem */
dfs_lock
();
fs
=
dfs_filesystem_lookup
(
fullpath
);
for
(
iter
=
&
filesystem_table
[
0
];
iter
<
&
filesystem_table
[
DFS_FILESYSTEMS_MAX
];
iter
++
)
{
/* check if the PATH is mounted */
if
((
iter
->
path
!=
NULL
)
&&
(
strcmp
(
iter
->
path
,
fullpath
)
==
0
))
{
fs
=
iter
;
break
;
}
}
if
(
fs
==
RT_NULL
||
fs
->
ops
->
unmount
==
RT_NULL
||
fs
->
ops
->
unmount
(
fs
)
<
0
)
...
...
@@ -437,12 +394,10 @@ err1:
int
dfs_mkfs
(
const
char
*
fs_name
,
const
char
*
device_name
)
{
int
index
;
rt_device_t
dev_id
;
rt_device_t
dev_id
=
RT_NULL
;
/* check device name, and it should not be NULL */
if
(
device_name
==
RT_NULL
)
dev_id
=
RT_NULL
;
else
if
(
device_name
!=
RT_NULL
)
dev_id
=
rt_device_find
(
device_name
);
if
(
dev_id
==
RT_NULL
)
...
...
@@ -458,19 +413,23 @@ int dfs_mkfs(const char *fs_name, const char *device_name)
{
if
(
filesystem_operation_table
[
index
]
!=
RT_NULL
&&
strcmp
(
filesystem_operation_table
[
index
]
->
name
,
fs_name
)
==
0
)
{
/* find file system operation */
const
struct
dfs_filesystem_operation
*
ops
=
filesystem_operation_table
[
index
];
dfs_unlock
();
if
(
ops
->
mkfs
!=
RT_NULL
)
return
ops
->
mkfs
(
dev_id
);
break
;
}
}
dfs_unlock
();
if
(
index
<
DFS_FILESYSTEM_TYPES_MAX
)
{
/* find file system operation */
const
struct
dfs_filesystem_operation
*
ops
=
filesystem_operation_table
[
index
];
if
(
ops
->
mkfs
==
RT_NULL
)
{
rt_set_errno
(
-
DFS_STATUS_ENOSYS
);
return
-
1
;
}
return
ops
->
mkfs
(
dev_id
);
}
rt_kprintf
(
"Can not find the file system which named as %s.
\n
"
,
fs_name
);
return
-
1
;
}
...
...
@@ -512,7 +471,7 @@ int dfs_mount_table(void)
mount_table
[
index
].
rwflag
,
mount_table
[
index
].
data
)
!=
0
)
{
rt_kprintf
(
"mount fs[%s] on %s failed.
\n
"
,
mount_table
[
index
].
filesystemtype
,
rt_kprintf
(
"mount fs[%s] on %s failed.
\n
"
,
mount_table
[
index
].
filesystemtype
,
mount_table
[
index
].
path
);
return
-
RT_ERROR
;
}
...
...
@@ -538,11 +497,7 @@ int df(const char *path)
long
long
cap
;
struct
statfs
buffer
;
if
(
path
==
RT_NULL
)
result
=
dfs_statfs
(
"/"
,
&
buffer
);
else
result
=
dfs_statfs
(
path
,
&
buffer
);
result
=
dfs_statfs
(
path
?
path
:
RT_NULL
,
&
buffer
);
if
(
result
!=
0
)
{
rt_kprintf
(
"dfs_statfs failed.
\n
"
);
...
...
examples/kernel/cpuusage.c
浏览文件 @
4c463f27
#include <rtthread.h>
#include <rthw.h>
#define CPU_USAGE_CALC_TICK
10
#define CPU_USAGE_LOOP
100
#define CPU_USAGE_CALC_TICK
10
#define CPU_USAGE_LOOP
100
static
rt_uint8_t
cpu_usage_major
=
0
,
cpu_usage_minor
=
0
;
static
rt_uint32_t
total_count
=
0
;
static
void
cpu_usage_idle_hook
()
{
rt_tick_t
tick
;
rt_uint32_t
count
;
volatile
rt_uint32_t
loop
;
rt_tick_t
tick
;
rt_uint32_t
count
;
volatile
rt_uint32_t
loop
;
if
(
total_count
==
0
)
{
/* get total count */
rt_enter_critical
();
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
CPU_USAGE_CALC_TICK
)
{
total_count
++
;
loop
=
0
;
while
(
loop
<
CPU_USAGE_LOOP
)
loop
++
;
}
rt_exit_critical
();
}
if
(
total_count
==
0
)
{
/* get total count */
rt_enter_critical
();
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
CPU_USAGE_CALC_TICK
)
{
total_count
++
;
loop
=
0
;
while
(
loop
<
CPU_USAGE_LOOP
)
loop
++
;
}
rt_exit_critical
();
}
count
=
0
;
/* get CPU usage */
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
CPU_USAGE_CALC_TICK
)
{
count
++
;
loop
=
0
;
while
(
loop
<
CPU_USAGE_LOOP
)
loop
++
;
}
count
=
0
;
/* get CPU usage */
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
CPU_USAGE_CALC_TICK
)
{
count
++
;
loop
=
0
;
while
(
loop
<
CPU_USAGE_LOOP
)
loop
++
;
}
/* calculate major and minor */
if
(
count
<
total_count
)
{
count
=
total_count
-
count
;
cpu_usage_major
=
(
count
*
100
)
/
total_count
;
cpu_usage_minor
=
((
count
*
100
)
%
total_count
)
*
100
/
total_count
;
}
else
{
total_count
=
count
;
/* calculate major and minor */
if
(
count
<
total_count
)
{
count
=
total_count
-
count
;
cpu_usage_major
=
(
count
*
100
)
/
total_count
;
cpu_usage_minor
=
((
count
*
100
)
%
total_count
)
*
100
/
total_count
;
}
else
{
total_count
=
count
;
/* no CPU usage */
cpu_usage_major
=
0
;
cpu_usage_minor
=
0
;
}
/* no CPU usage */
cpu_usage_major
=
0
;
cpu_usage_minor
=
0
;
}
}
void
cpu_usage_get
(
rt_uint8_t
*
major
,
rt_uint8_t
*
minor
)
{
RT_ASSERT
(
major
!=
RT_NULL
);
RT_ASSERT
(
minor
!=
RT_NULL
);
RT_ASSERT
(
major
!=
RT_NULL
);
RT_ASSERT
(
minor
!=
RT_NULL
);
*
major
=
cpu_usage_major
;
*
minor
=
cpu_usage_minor
;
*
major
=
cpu_usage_major
;
*
minor
=
cpu_usage_minor
;
}
void
cpu_usage_init
()
{
/* set idle thread hook */
rt_thread_idle_sethook
(
cpu_usage_idle_hook
);
/* set idle thread hook */
rt_thread_idle_sethook
(
cpu_usage_idle_hook
);
}
examples/kernel/event_simple.c
浏览文件 @
4c463f27
...
...
@@ -20,124 +20,124 @@ static struct rt_event event;
/* 线程1入口函数 */
static
void
thread1_entry
(
void
*
param
)
{
rt_uint32_t
e
;
while
(
1
)
{
/* receive first event */
if
(
rt_event_recv
(
&
event
,
((
1
<<
3
)
|
(
1
<<
5
)),
RT_EVENT_FLAG_AND
|
RT_EVENT_FLAG_CLEAR
,
RT_WAITING_FOREVER
,
&
e
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: AND recv event 0x%x
\n
"
,
e
);
}
rt_kprintf
(
"thread1: delay 1s to prepare second event
\n
"
);
rt_thread_delay
(
10
);
/* receive second event */
if
(
rt_event_recv
(
&
event
,
((
1
<<
3
)
|
(
1
<<
5
)),
RT_EVENT_FLAG_OR
|
RT_EVENT_FLAG_CLEAR
,
RT_WAITING_FOREVER
,
&
e
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: OR recv event 0x%x
\n
"
,
e
);
}
rt_thread_delay
(
5
);
}
rt_uint32_t
e
;
while
(
1
)
{
/* receive first event */
if
(
rt_event_recv
(
&
event
,
((
1
<<
3
)
|
(
1
<<
5
)),
RT_EVENT_FLAG_AND
|
RT_EVENT_FLAG_CLEAR
,
RT_WAITING_FOREVER
,
&
e
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: AND recv event 0x%x
\n
"
,
e
);
}
rt_kprintf
(
"thread1: delay 1s to prepare second event
\n
"
);
rt_thread_delay
(
10
);
/* receive second event */
if
(
rt_event_recv
(
&
event
,
((
1
<<
3
)
|
(
1
<<
5
)),
RT_EVENT_FLAG_OR
|
RT_EVENT_FLAG_CLEAR
,
RT_WAITING_FOREVER
,
&
e
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: OR recv event 0x%x
\n
"
,
e
);
}
rt_thread_delay
(
5
);
}
}
/* 线程2入口函数 */
static
void
thread2_entry
(
void
*
param
)
{
while
(
1
)
{
rt_kprintf
(
"thread2: send event1
\n
"
);
rt_event_send
(
&
event
,
(
1
<<
3
));
while
(
1
)
{
rt_kprintf
(
"thread2: send event1
\n
"
);
rt_event_send
(
&
event
,
(
1
<<
3
));
rt_thread_delay
(
10
);
}
rt_thread_delay
(
10
);
}
}
/* 线程3入口函数 */
static
void
thread3_entry
(
void
*
param
)
{
while
(
1
)
{
rt_kprintf
(
"thread3: send event2
\n
"
);
rt_event_send
(
&
event
,
(
1
<<
5
));
while
(
1
)
{
rt_kprintf
(
"thread3: send event2
\n
"
);
rt_event_send
(
&
event
,
(
1
<<
5
));
rt_thread_delay
(
20
);
}
rt_thread_delay
(
20
);
}
}
int
event_simple_init
()
{
/* 初始化事件对象 */
rt_event_init
(
&
event
,
"event"
,
RT_IPC_FLAG_FIFO
);
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread3_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化事件对象 */
rt_event_init
(
&
event
,
"event"
,
RT_IPC_FLAG_FIFO
);
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread3_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
/* 执行事件对象脱离 */
rt_event_detach
(
&
event
);
/* 执行事件对象脱离 */
rt_event_detach
(
&
event
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_event_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
event_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
event_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_event_simple
,
a
simple
event
example
);
...
...
@@ -145,8 +145,8 @@ FINSH_FUNCTION_EXPORT(_tc_event_simple, a simple event example);
/* 用户应用入口 */
int
rt_application_init
()
{
event_simple_init
();
event_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/heap_malloc.c
浏览文件 @
4c463f27
...
...
@@ -7,66 +7,68 @@
static
rt_bool_t
mem_check
(
rt_uint8_t
*
ptr
,
rt_uint8_t
value
,
rt_uint32_t
len
)
{
while
(
len
)
{
if
(
*
ptr
!=
value
)
return
RT_FALSE
;
while
(
len
)
{
if
(
*
ptr
!=
value
)
return
RT_FALSE
;
ptr
++
;
len
--
;
}
ptr
++
;
len
--
;
}
return
RT_TRUE
;
return
RT_TRUE
;
}
static
void
heap_malloc_init
()
{
rt_uint8_t
*
ptr1
,
*
ptr2
,
*
ptr3
,
*
ptr4
,
*
ptr5
;
ptr1
=
rt_malloc
(
1
);
ptr2
=
rt_malloc
(
13
);
ptr3
=
rt_malloc
(
31
);
ptr4
=
rt_malloc
(
127
);
ptr5
=
rt_malloc
(
0
);
rt_uint8_t
res
=
TC_STAT_PASSED
;
rt_uint8_t
*
ptr1
,
*
ptr2
,
*
ptr3
,
*
ptr4
,
*
ptr5
;
memset
(
ptr1
,
1
,
1
);
memset
(
ptr2
,
2
,
13
);
memset
(
ptr3
,
3
,
31
);
memset
(
ptr4
,
4
,
127
);
ptr1
=
rt_malloc
(
1
);
ptr2
=
rt_malloc
(
13
);
ptr3
=
rt_malloc
(
31
);
ptr4
=
rt_malloc
(
127
);
ptr5
=
rt_malloc
(
0
);
if
(
mem_check
(
ptr1
,
1
,
1
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr2
,
2
,
13
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr3
,
3
,
31
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr4
,
4
,
127
)
!=
RT_FALSE
)
goto
_failed
;
memset
(
ptr1
,
1
,
1
)
;
memset
(
ptr2
,
2
,
13
)
;
memset
(
ptr3
,
3
,
31
)
;
memset
(
ptr4
,
4
,
127
)
;
rt_free
(
ptr4
);
rt_free
(
ptr3
);
rt_free
(
ptr3
);
rt_free
(
ptr1
);
if
(
mem_check
(
ptr1
,
1
,
1
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr2
,
2
,
13
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr3
,
3
,
31
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr4
,
4
,
127
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
ptr5
!=
RT_NULL
)
{
rt_free
(
ptr5
);
}
rt_free
(
ptr4
);
rt_free
(
ptr3
);
rt_free
(
ptr2
);
rt_free
(
ptr1
);
tc_done
(
TC_STAT_PASSED
);
if
(
ptr5
!=
RT_NULL
)
{
rt_free
(
ptr5
);
}
_failed:
tc_done
(
TC_STAT_FAILED
);
tc_done
(
res
);
}
#ifdef RT_USING_TC
int
_tc_heap_malloc
()
{
heap_malloc_init
();
heap_malloc_init
();
return
0
;
return
0
;
}
FINSH_FUNCTION_EXPORT
(
_tc_heap_malloc
,
a
heap
malloc
test
);
#else
int
rt_application_init
()
{
heap_malloc_init
();
heap_malloc_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/heap_realloc.c
浏览文件 @
4c463f27
...
...
@@ -7,77 +7,96 @@
static
rt_bool_t
mem_check
(
rt_uint8_t
*
ptr
,
rt_uint8_t
value
,
rt_uint32_t
len
)
{
while
(
len
)
{
if
(
*
ptr
!=
value
)
return
RT_FALSE
;
while
(
len
)
{
if
(
*
ptr
!=
value
)
return
RT_FALSE
;
ptr
++
;
len
--
;
}
ptr
++
;
len
--
;
}
return
RT_TRUE
;
return
RT_TRUE
;
}
static
void
heap_realloc_init
()
{
rt_uint8_t
*
ptr1
,
*
ptr2
,
*
ptr3
,
*
ptr4
,
*
ptr5
;
ptr1
=
rt_malloc
(
1
);
ptr2
=
rt_malloc
(
13
);
ptr3
=
rt_malloc
(
31
);
ptr4
=
rt_malloc
(
127
);
ptr5
=
rt_malloc
(
0
);
memset
(
ptr1
,
1
,
1
);
memset
(
ptr2
,
2
,
13
);
memset
(
ptr3
,
3
,
31
);
memset
(
ptr4
,
4
,
127
);
if
(
mem_check
(
ptr1
,
1
,
1
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr2
,
2
,
13
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr3
,
3
,
31
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr4
,
4
,
127
)
!=
RT_FALSE
)
goto
_failed
;
ptr1
=
rt_realloc
(
ptr1
,
13
);
ptr2
=
rt_realloc
(
ptr2
,
31
);
ptr3
=
rt_realloc
(
ptr3
,
127
);
ptr4
=
rt_realloc
(
ptr4
,
1
);
ptr5
=
rt_realloc
(
ptr5
,
0
);
if
(
mem_check
(
ptr1
,
1
,
1
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr2
,
2
,
13
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr3
,
3
,
31
)
!=
RT_FALSE
)
goto
_failed
;
if
(
mem_check
(
ptr4
,
4
,
1
)
!=
RT_FALSE
)
goto
_failed
;
rt_free
(
ptr4
);
rt_free
(
ptr3
);
rt_free
(
ptr3
);
rt_free
(
ptr1
);
if
(
ptr5
!=
RT_NULL
)
{
rt_free
(
ptr5
);
}
tc_done
(
TC_STAT_PASSED
);
_failed:
tc_done
(
TC_STAT_FAILED
);
rt_uint8_t
res
=
TC_STAT_PASSED
;
rt_uint8_t
*
ptr1
,
*
ptr2
,
*
ptr3
,
*
ptr4
,
*
ptr5
;
ptr1
=
rt_malloc
(
1
);
ptr2
=
rt_malloc
(
13
);
ptr3
=
rt_malloc
(
31
);
ptr4
=
rt_malloc
(
127
);
ptr5
=
rt_malloc
(
0
);
memset
(
ptr1
,
1
,
1
);
memset
(
ptr2
,
2
,
13
);
memset
(
ptr3
,
3
,
31
);
memset
(
ptr4
,
4
,
127
);
if
(
mem_check
(
ptr1
,
1
,
1
)
==
RT_FALSE
)
{
res
=
TC_STAT_FAILED
;
goto
_free
;
}
if
(
mem_check
(
ptr2
,
2
,
13
)
==
RT_FALSE
)
{
res
=
TC_STAT_FAILED
;
goto
_free
;
}
if
(
mem_check
(
ptr3
,
3
,
31
)
==
RT_FALSE
)
{
res
=
TC_STAT_FAILED
;
goto
_free
;
}
if
(
mem_check
(
ptr4
,
4
,
127
)
==
RT_FALSE
)
{
res
=
TC_STAT_FAILED
;
goto
_free
;
}
ptr1
=
rt_realloc
(
ptr1
,
13
);
ptr2
=
rt_realloc
(
ptr2
,
31
);
ptr3
=
rt_realloc
(
ptr3
,
127
);
ptr4
=
rt_realloc
(
ptr4
,
1
);
ptr5
=
rt_realloc
(
ptr5
,
0
);
if
(
ptr5
)
{
rt_kprintf
(
"realloc(ptr, 0) should return NULL
\n
"
);
res
=
TC_STAT_FAILED
;
}
if
(
mem_check
(
ptr1
,
1
,
1
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr2
,
2
,
13
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr3
,
3
,
31
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
if
(
mem_check
(
ptr4
,
4
,
1
)
==
RT_FALSE
)
res
=
TC_STAT_FAILED
;
_free:
rt_free
(
ptr4
);
rt_free
(
ptr3
);
rt_free
(
ptr2
);
rt_free
(
ptr1
);
tc_done
(
res
);
}
#ifdef RT_USING_TC
int
_tc_heap_realloc
()
{
heap_realloc_init
();
heap_realloc_init
();
return
0
;
return
0
;
}
FINSH_FUNCTION_EXPORT
(
_tc_heap_realloc
,
a
heap
re
-
malloc
test
);
#else
int
rt_application_init
()
{
heap_realloc_init
();
heap_realloc_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/mbox_send_wait.c
浏览文件 @
4c463f27
...
...
@@ -22,110 +22,110 @@ static char mb_str2[] = "this is another mail!";
/* 线程1入口 */
static
void
thread1_entry
(
void
*
parameter
)
{
unsigned
char
*
str
;
while
(
1
)
{
/* 从邮箱中收取邮件 */
if
(
rt_mb_recv
(
&
mb
,
(
rt_uint32_t
*
)
&
str
,
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: get a mail from mailbox, the content:%s
\n
"
,
str
);
/* 延时20个OS Tick */
rt_thread_delay
(
50
);
}
}
unsigned
char
*
str
;
while
(
1
)
{
/* 从邮箱中收取邮件 */
if
(
rt_mb_recv
(
&
mb
,
(
rt_uint32_t
*
)
&
str
,
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: get a mail from mailbox, the content:%s
\n
"
,
str
);
/* 延时20个OS Tick */
rt_thread_delay
(
50
);
}
}
}
/* 线程2入口 */
static
void
thread2_entry
(
void
*
parameter
)
{
rt_uint8_t
count
;
rt_uint8_t
count
;
char
*
str
;
count
=
0
;
while
(
1
)
{
count
++
;
if
(
count
&
0x1
)
{
/* 发送mb_str1地址到邮箱中 */
count
=
0
;
while
(
1
)
{
count
++
;
if
(
count
&
0x1
)
{
/* 发送mb_str1地址到邮箱中 */
str
=
mb_str1
;
}
else
{
/* 发送mb_str2地址到邮箱中 */
}
else
{
/* 发送mb_str2地址到邮箱中 */
str
=
mb_str2
;
}
}
/* 不停的发送邮件,如果满了则等待10个tick,然后超时 */
if
(
rt_mb_send_wait
(
&
mb
,
(
rt_uint32_t
)
str
,
10
)
==
RT_EOK
)
rt_kprintf
(
"thread2: sent a mail to mailbox, the content:%s
\n
"
,
str
);
else
rt_kprintf
(
"thread2: timeout while waiting to send a mail.
\n
"
);
}
}
}
int
mbox_send_wait_init
()
{
/* 初始化一个mailbox */
rt_mb_init
(
&
mb
,
"mbt"
,
/* 名称是mbt */
&
mb_pool
[
0
],
/* 邮箱用到的内存池是mb_pool */
sizeof
(
mb_pool
)
/
4
,
/* 大小是mb_pool大小除以4,因为一封邮件的大小是4字节 */
RT_IPC_FLAG_FIFO
);
/* 采用FIFO方式进行线程等待 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化一个mailbox */
rt_mb_init
(
&
mb
,
"mbt"
,
/* 名称是mbt */
&
mb_pool
[
0
],
/* 邮箱用到的内存池是mb_pool */
sizeof
(
mb_pool
)
/
4
,
/* 大小是mb_pool大小除以4,因为一封邮件的大小是4字节 */
RT_IPC_FLAG_FIFO
);
/* 采用FIFO方式进行线程等待 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 执行邮箱对象脱离 */
rt_mb_detach
(
&
mb
);
/* 执行邮箱对象脱离 */
rt_mb_detach
(
&
mb
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_mbox_send_wait
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mbox_send_wait_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mbox_send_wait_init
();
/* 返回TestCase运行的最长时间 */
return
300
;
/* 返回TestCase运行的最长时间 */
return
300
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_mbox_send_wait
,
a
example
of
mailbox
send
wait
);
...
...
@@ -133,9 +133,9 @@ FINSH_FUNCTION_EXPORT(_tc_mbox_send_wait, a example of mailbox send wait);
/* 用户应用入口 */
int
rt_application_init
()
{
mbox_send_wait_init
();
mbox_send_wait_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/mbox_simple.c
浏览文件 @
4c463f27
...
...
@@ -22,108 +22,108 @@ static char mb_str2[] = "this is another mail!";
/* 线程1入口 */
static
void
thread1_entry
(
void
*
parameter
)
{
unsigned
char
*
str
;
unsigned
char
*
str
;
while
(
1
)
{
rt_kprintf
(
"thread1: try to recv a mail
\n
"
);
while
(
1
)
{
rt_kprintf
(
"thread1: try to recv a mail
\n
"
);
/* 从邮箱中收取邮件 */
if
(
rt_mb_recv
(
&
mb
,
(
rt_uint32_t
*
)
&
str
,
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: get a mail from mailbox, the content:%s
\n
"
,
str
);
/* 从邮箱中收取邮件 */
if
(
rt_mb_recv
(
&
mb
,
(
rt_uint32_t
*
)
&
str
,
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: get a mail from mailbox, the content:%s
\n
"
,
str
);
/* 延时10个OS Tick */
rt_thread_delay
(
10
);
}
}
/* 延时10个OS Tick */
rt_thread_delay
(
10
);
}
}
}
/* 线程2入口 */
static
void
thread2_entry
(
void
*
parameter
)
{
rt_uint8_t
count
;
count
=
0
;
while
(
1
)
{
count
++
;
if
(
count
&
0x1
)
{
/* 发送mb_str1地址到邮箱中 */
rt_mb_send
(
&
mb
,
(
rt_uint32_t
)
&
mb_str1
[
0
]);
}
else
{
/* 发送mb_str2地址到邮箱中 */
rt_mb_send
(
&
mb
,
(
rt_uint32_t
)
&
mb_str2
[
0
]);
}
/* 延时20个OS Tick */
rt_thread_delay
(
20
);
}
rt_uint8_t
count
;
count
=
0
;
while
(
1
)
{
count
++
;
if
(
count
&
0x1
)
{
/* 发送mb_str1地址到邮箱中 */
rt_mb_send
(
&
mb
,
(
rt_uint32_t
)
&
mb_str1
[
0
]);
}
else
{
/* 发送mb_str2地址到邮箱中 */
rt_mb_send
(
&
mb
,
(
rt_uint32_t
)
&
mb_str2
[
0
]);
}
/* 延时20个OS Tick */
rt_thread_delay
(
20
);
}
}
int
mbox_simple_init
()
{
/* 初始化一个mailbox */
rt_mb_init
(
&
mb
,
"mbt"
,
/* 名称是mbt */
&
mb_pool
[
0
],
/* 邮箱用到的内存池是mb_pool */
sizeof
(
mb_pool
)
/
4
,
/* 大小是mb_pool大小除以4,因为一封邮件的大小是4字节 */
RT_IPC_FLAG_FIFO
);
/* 采用FIFO方式进行线程等待 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化一个mailbox */
rt_mb_init
(
&
mb
,
"mbt"
,
/* 名称是mbt */
&
mb_pool
[
0
],
/* 邮箱用到的内存池是mb_pool */
sizeof
(
mb_pool
)
/
4
,
/* 大小是mb_pool大小除以4,因为一封邮件的大小是4字节 */
RT_IPC_FLAG_FIFO
);
/* 采用FIFO方式进行线程等待 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 执行邮箱对象脱离 */
rt_mb_detach
(
&
mb
);
/* 执行邮箱对象脱离 */
rt_mb_detach
(
&
mb
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_mbox_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mbox_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mbox_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_mbox_simple
,
a
simple
mailbox
example
);
...
...
@@ -131,8 +131,8 @@ FINSH_FUNCTION_EXPORT(_tc_mbox_simple, a simple mailbox example);
/* 用户应用入口 */
int
rt_application_init
()
{
mbox_simple_init
();
mbox_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/memp_simple.c
浏览文件 @
4c463f27
...
...
@@ -18,115 +18,115 @@ static rt_thread_t tid2 = RT_NULL;
/* 线程1入口 */
static
void
thread1_entry
(
void
*
parameter
)
{
int
i
;
char
*
block
;
while
(
1
)
{
for
(
i
=
0
;
i
<
48
;
i
++
)
{
/* 申请内存块 */
rt_kprintf
(
"allocate No.%d
\n
"
,
i
);
if
(
ptr
[
i
]
==
RT_NULL
)
{
ptr
[
i
]
=
rt_mp_alloc
(
&
mp
,
RT_WAITING_FOREVER
);
}
}
/* 继续申请一个内存块,因为已经没有内存块,线程应该被挂起 */
block
=
rt_mp_alloc
(
&
mp
,
RT_WAITING_FOREVER
);
rt_kprintf
(
"allocate the block mem
\n
"
);
/* 释放这个内存块 */
rt_mp_free
(
block
);
block
=
RT_NULL
;
}
int
i
;
char
*
block
;
while
(
1
)
{
for
(
i
=
0
;
i
<
48
;
i
++
)
{
/* 申请内存块 */
rt_kprintf
(
"allocate No.%d
\n
"
,
i
);
if
(
ptr
[
i
]
==
RT_NULL
)
{
ptr
[
i
]
=
rt_mp_alloc
(
&
mp
,
RT_WAITING_FOREVER
);
}
}
/* 继续申请一个内存块,因为已经没有内存块,线程应该被挂起 */
block
=
rt_mp_alloc
(
&
mp
,
RT_WAITING_FOREVER
);
rt_kprintf
(
"allocate the block mem
\n
"
);
/* 释放这个内存块 */
rt_mp_free
(
block
);
block
=
RT_NULL
;
}
}
/* 线程2入口,线程2的优先级比线程1低,应该线程1先获得执行。*/
static
void
thread2_entry
(
void
*
parameter
)
{
int
i
;
while
(
1
)
{
rt_kprintf
(
"try to release block
\n
"
);
for
(
i
=
0
;
i
<
48
;
i
++
)
{
/* 释放所有分配成功的内存块 */
if
(
ptr
[
i
]
!=
RT_NULL
)
{
rt_kprintf
(
"release block %d
\n
"
,
i
);
rt_mp_free
(
ptr
[
i
]);
ptr
[
i
]
=
RT_NULL
;
}
}
/* 休眠10个OS Tick */
rt_thread_delay
(
10
);
}
int
i
;
while
(
1
)
{
rt_kprintf
(
"try to release block
\n
"
);
for
(
i
=
0
;
i
<
48
;
i
++
)
{
/* 释放所有分配成功的内存块 */
if
(
ptr
[
i
]
!=
RT_NULL
)
{
rt_kprintf
(
"release block %d
\n
"
,
i
);
rt_mp_free
(
ptr
[
i
]);
ptr
[
i
]
=
RT_NULL
;
}
}
/* 休眠10个OS Tick */
rt_thread_delay
(
10
);
}
}
int
mempool_simple_init
()
{
int
i
;
for
(
i
=
0
;
i
<
48
;
i
++
)
ptr
[
i
]
=
RT_NULL
;
/* 初始化内存池对象 */
rt_mp_init
(
&
mp
,
"mp1"
,
&
mempool
[
0
],
sizeof
(
mempool
),
80
);
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
int
i
;
for
(
i
=
0
;
i
<
48
;
i
++
)
ptr
[
i
]
=
RT_NULL
;
/* 初始化内存池对象 */
rt_mp_init
(
&
mp
,
"mp1"
,
&
mempool
[
0
],
sizeof
(
mempool
),
80
);
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 执行内存池脱离 */
rt_mp_detach
(
&
mp
);
/* 执行内存池脱离 */
rt_mp_detach
(
&
mp
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_mempool_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mempool_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mempool_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_mempool_simple
,
a
memory
pool
example
);
...
...
@@ -134,8 +134,8 @@ FINSH_FUNCTION_EXPORT(_tc_mempool_simple, a memory pool example);
/* 用户应用入口 */
int
rt_application_init
()
{
mempool_simple_init
();
mempool_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/messageq_simple.c
浏览文件 @
4c463f27
...
...
@@ -20,139 +20,139 @@ static char msg_pool[2048];
/* 线程1入口函数 */
static
void
thread1_entry
(
void
*
parameter
)
{
char
buf
[
128
];
char
buf
[
128
];
while
(
1
)
{
rt_memset
(
&
buf
[
0
],
0
,
sizeof
(
buf
));
while
(
1
)
{
rt_memset
(
&
buf
[
0
],
0
,
sizeof
(
buf
));
/* 从消息队列中接收消息 */
if
(
rt_mq_recv
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
),
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: recv msg from message queue, the content:%s
\n
"
,
buf
);
}
/* 从消息队列中接收消息 */
if
(
rt_mq_recv
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
),
RT_WAITING_FOREVER
)
==
RT_EOK
)
{
rt_kprintf
(
"thread1: recv msg from message queue, the content:%s
\n
"
,
buf
);
}
/* 延迟10个OS Tick */
rt_thread_delay
(
10
);
}
/* 延迟10个OS Tick */
rt_thread_delay
(
10
);
}
}
/* 线程2入口函数 */
static
void
thread2_entry
(
void
*
parameter
)
{
int
i
,
result
;
char
buf
[]
=
"this is message No.x"
;
while
(
1
)
{
for
(
i
=
0
;
i
<
10
;
i
++
)
{
buf
[
sizeof
(
buf
)
-
2
]
=
'0'
+
i
;
rt_kprintf
(
"thread2: send message - %s
\n
"
,
buf
);
/* 发送消息到消息队列中 */
result
=
rt_mq_send
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
));
if
(
result
==
-
RT_EFULL
)
{
/* 消息队列满, 延迟1s时间 */
rt_kprintf
(
"message queue full, delay 1s
\n
"
);
rt_thread_delay
(
100
);
}
}
/* 延时10个OS Tick */
rt_thread_delay
(
10
);
}
int
i
,
result
;
char
buf
[]
=
"this is message No.x"
;
while
(
1
)
{
for
(
i
=
0
;
i
<
10
;
i
++
)
{
buf
[
sizeof
(
buf
)
-
2
]
=
'0'
+
i
;
rt_kprintf
(
"thread2: send message - %s
\n
"
,
buf
);
/* 发送消息到消息队列中 */
result
=
rt_mq_send
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
));
if
(
result
==
-
RT_EFULL
)
{
/* 消息队列满, 延迟1s时间 */
rt_kprintf
(
"message queue full, delay 1s
\n
"
);
rt_thread_delay
(
100
);
}
}
/* 延时10个OS Tick */
rt_thread_delay
(
10
);
}
}
/* 线程3入口函数 */
static
void
thread3_entry
(
void
*
parameter
)
{
char
buf
[]
=
"this is an urgent message!"
;
char
buf
[]
=
"this is an urgent message!"
;
while
(
1
)
{
rt_kprintf
(
"thread3: send an urgent message
\n
"
);
while
(
1
)
{
rt_kprintf
(
"thread3: send an urgent message
\n
"
);
/* 发送紧急消息到消息队列中 */
rt_mq_urgent
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
));
/* 发送紧急消息到消息队列中 */
rt_mq_urgent
(
&
mq
,
&
buf
[
0
],
sizeof
(
buf
));
/* 延时25个OS Tick */
rt_thread_delay
(
25
);
}
/* 延时25个OS Tick */
rt_thread_delay
(
25
);
}
}
int
messageq_simple_init
()
{
/* 初始化消息队列 */
rt_mq_init
(
&
mq
,
"mqt"
,
&
msg_pool
[
0
],
/* 内存池指向msg_pool */
128
-
sizeof
(
void
*
),
/* 每个消息的大小是 128 - void* */
sizeof
(
msg_pool
),
/* 内存池的大小是msg_pool的大小 */
RT_IPC_FLAG_FIFO
);
/* 如果有多个线程等待,按照先来先得到的方法分配消息 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化消息队列 */
rt_mq_init
(
&
mq
,
"mqt"
,
&
msg_pool
[
0
],
/* 内存池指向msg_pool */
128
-
sizeof
(
void
*
),
/* 每个消息的大小是 128 - void* */
sizeof
(
msg_pool
),
/* 内存池的大小是msg_pool的大小 */
RT_IPC_FLAG_FIFO
);
/* 如果有多个线程等待,按照先来先得到的方法分配消息 */
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
/* 执行消息队列对象脱离 */
rt_mq_detach
(
&
mq
);
/* 执行消息队列对象脱离 */
rt_mq_detach
(
&
mq
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_messageq_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
messageq_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
messageq_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_messageq_simple
,
a
simple
message
queue
example
);
...
...
@@ -160,8 +160,8 @@ FINSH_FUNCTION_EXPORT(_tc_messageq_simple, a simple message queue example);
/* 用户应用入口 */
int
rt_application_init
()
{
messageq_simple_init
();
messageq_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/mutex_simple.c
浏览文件 @
4c463f27
...
...
@@ -13,142 +13,142 @@ static rt_mutex_t mutex = RT_NULL;
/* 线程1入口 */
static
void
thread1_entry
(
void
*
parameter
)
{
/* 先让低优先级线程运行 */
rt_thread_delay
(
10
);
/* 此时thread3持有mutex,并且thread2等待持有mutex */
/* 检查thread2与thread3的优先级情况 */
if
(
tid2
->
current_priority
!=
tid3
->
current_priority
)
{
/* 优先级不相同,测试失败 */
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
/* 先让低优先级线程运行 */
rt_thread_delay
(
10
);
/* 此时thread3持有mutex,并且thread2等待持有mutex */
/* 检查thread2与thread3的优先级情况 */
if
(
tid2
->
current_priority
!=
tid3
->
current_priority
)
{
/* 优先级不相同,测试失败 */
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
}
/* 线程2入口 */
static
void
thread2_entry
(
void
*
parameter
)
{
rt_err_t
result
;
/* 先让低优先级线程运行 */
rt_thread_delay
(
5
);
while
(
1
)
{
/*
* 试图持有互斥锁,此时thread3持有,应把thread3的优先级提升到thread2相同
* 的优先级
*/
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
if
(
result
==
RT_EOK
)
{
/* 释放互斥锁 */
rt_mutex_release
(
mutex
);
}
}
rt_err_t
result
;
/* 先让低优先级线程运行 */
rt_thread_delay
(
5
);
while
(
1
)
{
/*
* 试图持有互斥锁,此时thread3持有,应把thread3的优先级提升到thread2相同
* 的优先级
*/
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
if
(
result
==
RT_EOK
)
{
/* 释放互斥锁 */
rt_mutex_release
(
mutex
);
}
}
}
/* 线程3入口 */
static
void
thread3_entry
(
void
*
parameter
)
{
rt_tick_t
tick
;
rt_err_t
result
;
while
(
1
)
{
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
}
/* 做一个长时间的循环,总共50个OS Tick */
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
50
)
;
rt_mutex_release
(
mutex
);
rt_mutex_release
(
mutex
);
}
rt_tick_t
tick
;
rt_err_t
result
;
while
(
1
)
{
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
result
=
rt_mutex_take
(
mutex
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
}
/* 做一个长时间的循环,总共50个OS Tick */
tick
=
rt_tick_get
();
while
(
rt_tick_get
()
-
tick
<
50
)
;
rt_mutex_release
(
mutex
);
rt_mutex_release
(
mutex
);
}
}
int
mutex_simple_init
()
{
/* 创建互斥锁 */
mutex
=
rt_mutex_create
(
"mutex"
,
RT_IPC_FLAG_FIFO
);
if
(
mutex
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread3_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 创建互斥锁 */
mutex
=
rt_mutex_create
(
"mutex"
,
RT_IPC_FLAG_FIFO
);
if
(
mutex
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
/* 线程入口是thread1_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
/* 线程入口是thread2_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程3 */
tid3
=
rt_thread_create
(
"t3"
,
thread3_entry
,
RT_NULL
,
/* 线程入口是thread3_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
tid3
!=
RT_NULL
)
rt_thread_startup
(
tid3
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
if
(
mutex
!=
RT_NULL
)
{
rt_mutex_delete
(
mutex
);
}
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
if
(
tid3
!=
RT_NULL
&&
tid3
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid3
);
if
(
mutex
!=
RT_NULL
)
{
rt_mutex_delete
(
mutex
);
}
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_mutex_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mutex_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
mutex_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_mutex_simple
,
sime
mutex
example
);
...
...
@@ -156,8 +156,8 @@ FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);
/* 用户应用入口 */
int
rt_application_init
()
{
mutex_simple_init
();
mutex_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/semaphore_buffer_worker.c
浏览文件 @
4c463f27
...
...
@@ -12,9 +12,9 @@
/* 一个环形buffer的实现 */
struct
rb
{
rt_uint16_t
read_index
,
write_index
;
rt_uint8_t
*
buffer_ptr
;
rt_uint16_t
buffer_size
;
rt_uint16_t
read_index
,
write_index
;
rt_uint8_t
*
buffer_ptr
;
rt_uint16_t
buffer_size
;
};
/* 指向信号量控制块的指针 */
...
...
@@ -23,236 +23,236 @@ static rt_sem_t sem = RT_NULL;
static
rt_thread_t
tid
=
RT_NULL
,
worker
=
RT_NULL
;
/* 环形buffer的内存块(用数组体现出来) */
#define BUFFER_SIZE
256
#define BUFFER_ITEM
32
#define BUFFER_SIZE
256
#define BUFFER_ITEM
32
static
rt_uint8_t
working_buffer
[
BUFFER_SIZE
];
struct
rb
working_rb
;
/* 初始化环形buffer,size指的是buffer的大小。注:这里并没对数据地址对齐做处理 */
static
void
rb_init
(
struct
rb
*
rb
,
rt_uint8_t
*
pool
,
rt_uint16_t
size
)
{
RT_ASSERT
(
rb
!=
RT_NULL
);
RT_ASSERT
(
rb
!=
RT_NULL
);
/* 对读写指针清零*/
rb
->
read_index
=
rb
->
write_index
=
0
;
/* 对读写指针清零*/
rb
->
read_index
=
rb
->
write_index
=
0
;
/* 设置环形buffer的内存数据块 */
rb
->
buffer_ptr
=
pool
;
rb
->
buffer_size
=
size
;
/* 设置环形buffer的内存数据块 */
rb
->
buffer_ptr
=
pool
;
rb
->
buffer_size
=
size
;
}
/* 向环形buffer中写入数据 */
static
rt_bool_t
rb_put
(
struct
rb
*
rb
,
const
rt_uint8_t
*
ptr
,
rt_uint16_t
length
)
{
rt_size_t
size
;
/* 判断是否有足够的剩余空间 */
if
(
rb
->
read_index
>
rb
->
write_index
)
size
=
rb
->
read_index
-
rb
->
write_index
;
else
size
=
rb
->
buffer_size
-
rb
->
write_index
+
rb
->
read_index
;
/* 没有多余的空间 */
if
(
size
<
length
)
return
RT_FALSE
;
if
(
rb
->
read_index
>
rb
->
write_index
)
{
/* read_index - write_index 即为总的空余空间 */
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
length
);
rb
->
write_index
+=
length
;
}
else
{
if
(
rb
->
buffer_size
-
rb
->
write_index
>
length
)
{
/* write_index 后面剩余的空间有足够的长度 */
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
length
);
rb
->
write_index
+=
length
;
}
else
{
/*
* write_index 后面剩余的空间不存在足够的长度,需要把部分数据复制到
* 前面的剩余空间中
*/
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
rb
->
buffer_size
-
rb
->
write_index
);
memcpy
(
&
rb
->
buffer_ptr
[
0
],
&
ptr
[
rb
->
buffer_size
-
rb
->
write_index
],
length
-
(
rb
->
buffer_size
-
rb
->
write_index
));
rb
->
write_index
=
length
-
(
rb
->
buffer_size
-
rb
->
write_index
);
}
}
return
RT_TRUE
;
rt_size_t
size
;
/* 判断是否有足够的剩余空间 */
if
(
rb
->
read_index
>
rb
->
write_index
)
size
=
rb
->
read_index
-
rb
->
write_index
;
else
size
=
rb
->
buffer_size
-
rb
->
write_index
+
rb
->
read_index
;
/* 没有多余的空间 */
if
(
size
<
length
)
return
RT_FALSE
;
if
(
rb
->
read_index
>
rb
->
write_index
)
{
/* read_index - write_index 即为总的空余空间 */
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
length
);
rb
->
write_index
+=
length
;
}
else
{
if
(
rb
->
buffer_size
-
rb
->
write_index
>
length
)
{
/* write_index 后面剩余的空间有足够的长度 */
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
length
);
rb
->
write_index
+=
length
;
}
else
{
/*
* write_index 后面剩余的空间不存在足够的长度,需要把部分数据复制到
* 前面的剩余空间中
*/
memcpy
(
&
rb
->
buffer_ptr
[
rb
->
write_index
],
ptr
,
rb
->
buffer_size
-
rb
->
write_index
);
memcpy
(
&
rb
->
buffer_ptr
[
0
],
&
ptr
[
rb
->
buffer_size
-
rb
->
write_index
],
length
-
(
rb
->
buffer_size
-
rb
->
write_index
));
rb
->
write_index
=
length
-
(
rb
->
buffer_size
-
rb
->
write_index
);
}
}
return
RT_TRUE
;
}
/* 从环形buffer中读出数据 */
static
rt_bool_t
rb_get
(
struct
rb
*
rb
,
rt_uint8_t
*
ptr
,
rt_uint16_t
length
)
{
rt_size_t
size
;
/* 判断是否有足够的数据 */
if
(
rb
->
read_index
>
rb
->
write_index
)
size
=
rb
->
buffer_size
-
rb
->
read_index
+
rb
->
write_index
;
else
size
=
rb
->
write_index
-
rb
->
read_index
;
/* 没有足够的数据 */
if
(
size
<
length
)
return
RT_FALSE
;
if
(
rb
->
read_index
>
rb
->
write_index
)
{
if
(
rb
->
buffer_size
-
rb
->
read_index
>
length
)
{
/* read_index的数据足够多,直接复制 */
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
length
);
rb
->
read_index
+=
length
;
}
else
{
/* read_index的数据不够,需要分段复制 */
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
rb
->
buffer_size
-
rb
->
read_index
);
memcpy
(
&
ptr
[
rb
->
buffer_size
-
rb
->
read_index
],
&
rb
->
buffer_ptr
[
0
],
length
-
rb
->
buffer_size
+
rb
->
read_index
);
rb
->
read_index
=
length
-
rb
->
buffer_size
+
rb
->
read_index
;
}
}
else
{
/*
* read_index要比write_index小,总的数据量够(前面已经有总数据量的判
* 断),直接复制出数据。
*/
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
length
);
rb
->
read_index
+=
length
;
}
return
RT_TRUE
;
rt_size_t
size
;
/* 判断是否有足够的数据 */
if
(
rb
->
read_index
>
rb
->
write_index
)
size
=
rb
->
buffer_size
-
rb
->
read_index
+
rb
->
write_index
;
else
size
=
rb
->
write_index
-
rb
->
read_index
;
/* 没有足够的数据 */
if
(
size
<
length
)
return
RT_FALSE
;
if
(
rb
->
read_index
>
rb
->
write_index
)
{
if
(
rb
->
buffer_size
-
rb
->
read_index
>
length
)
{
/* read_index的数据足够多,直接复制 */
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
length
);
rb
->
read_index
+=
length
;
}
else
{
/* read_index的数据不够,需要分段复制 */
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
rb
->
buffer_size
-
rb
->
read_index
);
memcpy
(
&
ptr
[
rb
->
buffer_size
-
rb
->
read_index
],
&
rb
->
buffer_ptr
[
0
],
length
-
rb
->
buffer_size
+
rb
->
read_index
);
rb
->
read_index
=
length
-
rb
->
buffer_size
+
rb
->
read_index
;
}
}
else
{
/*
* read_index要比write_index小,总的数据量够(前面已经有总数据量的判
* 断),直接复制出数据。
*/
memcpy
(
ptr
,
&
rb
->
buffer_ptr
[
rb
->
read_index
],
length
);
rb
->
read_index
+=
length
;
}
return
RT_TRUE
;
}
/* 生产者线程入口 */
static
void
thread_entry
(
void
*
parameter
)
{
rt_bool_t
result
;
rt_uint8_t
data_buffer
[
BUFFER_ITEM
+
1
];
while
(
1
)
{
/* 持有信号量 */
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
/* 从环buffer中获得数据 */
result
=
rb_get
(
&
working_rb
,
&
data_buffer
[
0
],
BUFFER_ITEM
);
/* 释放信号量 */
rt_sem_release
(
sem
);
data_buffer
[
BUFFER_ITEM
]
=
'\0'
;
if
(
result
==
RT_TRUE
)
{
/* 获取数据成功,打印数据 */
rt_kprintf
(
"%s
\n
"
,
data_buffer
);
}
/* 做一个5 OS Tick的休眠 */
rt_thread_delay
(
5
);
}
rt_bool_t
result
;
rt_uint8_t
data_buffer
[
BUFFER_ITEM
+
1
];
while
(
1
)
{
/* 持有信号量 */
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
/* 从环buffer中获得数据 */
result
=
rb_get
(
&
working_rb
,
&
data_buffer
[
0
],
BUFFER_ITEM
);
/* 释放信号量 */
rt_sem_release
(
sem
);
data_buffer
[
BUFFER_ITEM
]
=
'\0'
;
if
(
result
==
RT_TRUE
)
{
/* 获取数据成功,打印数据 */
rt_kprintf
(
"%s
\n
"
,
data_buffer
);
}
/* 做一个5 OS Tick的休眠 */
rt_thread_delay
(
5
);
}
}
/* worker线程入口 */
static
void
worker_entry
(
void
*
parameter
)
{
rt_bool_t
result
;
rt_uint32_t
index
,
setchar
;
rt_uint8_t
data_buffer
[
BUFFER_ITEM
];
setchar
=
0x21
;
while
(
1
)
{
/* 构造数据 */
for
(
index
=
0
;
index
<
BUFFER_ITEM
;
index
++
)
{
data_buffer
[
index
]
=
setchar
;
if
(
++
setchar
==
0x7f
)
setchar
=
0x21
;
}
/* 持有信号量 */
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
/* 把数据放到环形buffer中 */
result
=
rb_put
(
&
working_rb
,
&
data_buffer
[
0
],
BUFFER_ITEM
);
/* 释放信号量 */
rt_sem_release
(
sem
);
/* 放入成功,做一个10 OS Tick的休眠 */
rt_thread_delay
(
10
);
}
rt_bool_t
result
;
rt_uint32_t
index
,
setchar
;
rt_uint8_t
data_buffer
[
BUFFER_ITEM
];
setchar
=
0x21
;
while
(
1
)
{
/* 构造数据 */
for
(
index
=
0
;
index
<
BUFFER_ITEM
;
index
++
)
{
data_buffer
[
index
]
=
setchar
;
if
(
++
setchar
==
0x7f
)
setchar
=
0x21
;
}
/* 持有信号量 */
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
/* 把数据放到环形buffer中 */
result
=
rb_put
(
&
working_rb
,
&
data_buffer
[
0
],
BUFFER_ITEM
);
/* 释放信号量 */
rt_sem_release
(
sem
);
/* 放入成功,做一个10 OS Tick的休眠 */
rt_thread_delay
(
10
);
}
}
int
semaphore_buffer_worker_init
()
{
/* 初始化ring buffer */
rb_init
(
&
working_rb
,
working_buffer
,
BUFFER_SIZE
);
/* 创建信号量 */
sem
=
rt_sem_create
(
"sem"
,
1
,
RT_IPC_FLAG_FIFO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程1 */
tid
=
rt_thread_create
(
"thread"
,
thread_entry
,
RT_NULL
,
/* 线程入口是thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
worker
=
rt_thread_create
(
"worker"
,
worker_entry
,
RT_NULL
,
/* 线程入口是worker_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
worker
!=
RT_NULL
)
rt_thread_startup
(
worker
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化ring buffer */
rb_init
(
&
working_rb
,
working_buffer
,
BUFFER_SIZE
);
/* 创建信号量 */
sem
=
rt_sem_create
(
"sem"
,
1
,
RT_IPC_FLAG_FIFO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程1 */
tid
=
rt_thread_create
(
"thread"
,
thread_entry
,
RT_NULL
,
/* 线程入口是thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
worker
=
rt_thread_create
(
"worker"
,
worker_entry
,
RT_NULL
,
/* 线程入口是worker_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
worker
!=
RT_NULL
)
rt_thread_startup
(
worker
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除信号量 */
if
(
sem
!=
RT_NULL
)
rt_sem_delete
(
sem
);
/* 删除信号量 */
if
(
sem
!=
RT_NULL
)
rt_sem_delete
(
sem
);
/* 删除线程 */
if
(
tid
!=
RT_NULL
&&
tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid
);
if
(
worker
!=
RT_NULL
&&
worker
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
worker
);
/* 删除线程 */
if
(
tid
!=
RT_NULL
&&
tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid
);
if
(
worker
!=
RT_NULL
&&
worker
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
worker
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_semaphore_buffer_worker
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_buffer_worker_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_buffer_worker_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_semaphore_buffer_worker
,
a
buffer
worker
with
semaphore
example
);
...
...
@@ -260,8 +260,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphor
/* 用户应用入口 */
int
rt_application_init
()
{
semaphore_buffer_worker_init
();
semaphore_buffer_worker_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/semaphore_dynamic.c
浏览文件 @
4c463f27
...
...
@@ -15,105 +15,112 @@ static rt_sem_t sem = RT_NULL;
/* 线程入口 */
static
void
thread_entry
(
void
*
parameter
)
{
rt_err_t
result
;
rt_tick_t
tick
;
/* 获得当前的OS Tick */
tick
=
rt_tick_get
();
/* 试图持有一个信号量,如果10个OS Tick依然没拿到,则超时返回 */
result
=
rt_sem_take
(
sem
,
10
);
if
(
result
==
-
RT_ETIMEOUT
)
{
/* 判断是否刚好过去10个OS Tick */
if
(
rt_tick_get
()
-
tick
!=
10
)
{
/* 如果失败,则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
rt_kprintf
(
"take semaphore timeout
\n
"
);
}
else
{
/* 因为并没释放信号量,应该是超时返回,否则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
/* 释放一次信号量 */
rt_sem_release
(
sem
);
/* 继续持有信号量,并永远等待直到持有到信号量 */
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
/* 返回不正确,测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
/* 测试成功 */
tc_done
(
TC_STAT_PASSED
);
/* 删除信号量 */
rt_sem_delete
(
sem
);
rt_err_t
result
;
rt_tick_t
tick
;
/* 获得当前的OS Tick */
tick
=
rt_tick_get
();
/* 试图持有一个信号量,如果10个OS Tick依然没拿到,则超时返回 */
result
=
rt_sem_take
(
sem
,
10
);
if
(
result
==
-
RT_ETIMEOUT
)
{
rt_tick_t
new_tick
=
rt_tick_get
();
/* 可以有两个 tick 的误差 */
if
(
new_tick
-
tick
>=
12
)
{
rt_kprintf
(
"tick error to large: expect: 10, get %d
\n
"
,
new_tick
-
tick
);
/* 如果失败,则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
rt_kprintf
(
"take semaphore timeout
\n
"
);
}
else
{
/* 因为并没释放信号量,应该是超时返回,否则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
/* 释放一次信号量 */
rt_sem_release
(
sem
);
/* 继续持有信号量,并永远等待直到持有到信号量 */
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
/* 返回不正确,测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_delete
(
sem
);
return
;
}
/* 测试成功 */
tc_done
(
TC_STAT_PASSED
);
/* 删除信号量 */
rt_sem_delete
(
sem
);
}
int
semaphore_dynamic_init
()
{
/* 创建一个信号量,初始值是0 */
sem
=
rt_sem_create
(
"sem"
,
0
,
RT_IPC_FLAG_FIFO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程 */
tid
=
rt_thread_create
(
"thread"
,
thread_entry
,
RT_NULL
,
/* 线程入口是thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 创建一个信号量,初始值是0 */
sem
=
rt_sem_create
(
"sem"
,
0
,
RT_IPC_FLAG_FIFO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 创建线程 */
tid
=
rt_thread_create
(
"thread"
,
thread_entry
,
RT_NULL
,
/* 线程入口是thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid
!=
RT_NULL
&&
tid
->
stat
!=
RT_THREAD_CLOSE
)
{
rt_thread_delete
(
tid
);
/* 删除信号量 */
rt_sem_delete
(
sem
);
}
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
if
(
sem
)
{
rt_sem_delete
(
sem
);
sem
=
RT_NULL
;
}
/* 删除线程 */
if
(
tid
!=
RT_NULL
&&
tid
->
stat
!=
RT_THREAD_CLOSE
)
{
rt_thread_delete
(
tid
);
}
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_semaphore_dynamic
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_dynamic_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_dynamic_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_semaphore_dynamic
,
a
dynamic
semaphore
example
);
...
...
@@ -121,8 +128,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);
/* 用户应用入口 */
int
rt_application_init
()
{
semaphore_dynamic_init
();
semaphore_dynamic_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/semaphore_priority.c
浏览文件 @
4c463f27
...
...
@@ -6,123 +6,129 @@ static rt_uint8_t t1_count, t2_count;
static
rt_thread_t
t1
,
t2
,
worker
;
static
void
thread1_entry
(
void
*
parameter
)
{
rt_err_t
result
;
while
(
1
)
{
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
t1_count
++
;
rt_kprintf
(
"thread1: got semaphore, count: %d
\n
"
,
t1_count
);
}
rt_err_t
result
;
while
(
1
)
{
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
t1_count
++
;
rt_kprintf
(
"thread1: got semaphore, count: %d
\n
"
,
t1_count
);
}
}
static
void
thread2_entry
(
void
*
parameter
)
{
rt_err_t
result
;
while
(
1
)
{
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
t2_count
++
;
rt_kprintf
(
"thread2: got semaphore, count: %d
\n
"
,
t2_count
);
}
rt_err_t
result
;
while
(
1
)
{
result
=
rt_sem_take
(
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
t2_count
++
;
rt_kprintf
(
"thread2: got semaphore, count: %d
\n
"
,
t2_count
);
}
}
static
void
worker_thread_entry
(
void
*
parameter
)
{
rt_thread_delay
(
10
);
rt_thread_delay
(
10
);
while
(
1
)
{
rt_sem_release
(
sem
);
rt_thread_delay
(
5
);
}
while
(
1
)
{
rt_sem_release
(
sem
);
rt_thread_delay
(
5
);
}
}
int
semaphore_priority_init
()
{
sem
=
rt_sem_create
(
"sem"
,
0
,
RT_IPC_FLAG_PRIO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
t1_count
=
t2_count
=
0
;
t1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
t1
!=
RT_NULL
)
rt_thread_startup
(
t1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
t2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
t2
!=
RT_NULL
)
rt_thread_startup
(
t2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
worker
=
rt_thread_create
(
"worker"
,
worker_thread_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
worker
!=
RT_NULL
)
rt_thread_startup
(
worker
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
sem
=
rt_sem_create
(
"sem"
,
0
,
RT_IPC_FLAG_PRIO
);
if
(
sem
==
RT_NULL
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
t1_count
=
t2_count
=
0
;
t1
=
rt_thread_create
(
"t1"
,
thread1_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
t1
!=
RT_NULL
)
rt_thread_startup
(
t1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
t2
=
rt_thread_create
(
"t2"
,
thread2_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
t2
!=
RT_NULL
)
rt_thread_startup
(
t2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
worker
=
rt_thread_create
(
"worker"
,
worker_thread_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
worker
!=
RT_NULL
)
rt_thread_startup
(
worker
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* lock scheduler */
rt_enter_critical
();
/* delete t1, t2 and worker thread */
rt_thread_delete
(
t1
);
rt_thread_delete
(
t2
);
rt_thread_delete
(
worker
);
if
(
t1_count
>
t2_count
)
tc_done
(
TC_STAT_FAILED
);
else
tc_done
(
TC_STAT_PASSED
);
/* unlock scheduler */
rt_exit_critical
();
/* lock scheduler */
rt_enter_critical
();
/* delete t1, t2 and worker thread */
rt_thread_delete
(
t1
);
rt_thread_delete
(
t2
);
rt_thread_delete
(
worker
);
if
(
sem
)
{
rt_sem_delete
(
sem
);
sem
=
RT_NULL
;
}
if
(
t1_count
>
t2_count
)
tc_done
(
TC_STAT_FAILED
);
else
tc_done
(
TC_STAT_PASSED
);
/* unlock scheduler */
rt_exit_critical
();
}
int
_tc_semaphore_priority
()
{
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
semaphore_priority_init
();
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
semaphore_priority_init
();
return
50
;
return
50
;
}
FINSH_FUNCTION_EXPORT
(
_tc_semaphore_priority
,
a
priority
semaphore
test
);
#else
int
rt_application_init
()
{
semaphore_priority_init
();
semaphore_priority_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/semaphore_producer_consumer.c
浏览文件 @
4c463f27
...
...
@@ -24,122 +24,126 @@ struct rt_semaphore sem_empty, sem_full;
/* 生成者线程入口 */
void
producer_thread_entry
(
void
*
parameter
)
{
int
cnt
=
0
;
/* 运行100次 */
while
(
cnt
<
100
)
{
/* 获取一个空位 */
rt_sem_take
(
&
sem_empty
,
RT_WAITING_FOREVER
);
/* 修改array内容,上锁 */
rt_sem_take
(
&
sem_lock
,
RT_WAITING_FOREVER
);
array
[
set
%
MAXSEM
]
=
cnt
+
1
;
rt_kprintf
(
"the producer generates a number: %d
\n
"
,
array
[
set
%
MAXSEM
]);
set
++
;
rt_sem_release
(
&
sem_lock
);
/* 发布一个满位 */
rt_sem_release
(
&
sem_full
);
cnt
++
;
/* 暂停一段时间 */
rt_thread_delay
(
50
);
}
rt_kprintf
(
"the producer exit!
\n
"
);
int
cnt
=
0
;
/* 运行100次 */
while
(
cnt
<
100
)
{
/* 获取一个空位 */
rt_sem_take
(
&
sem_empty
,
RT_WAITING_FOREVER
);
/* 修改array内容,上锁 */
rt_sem_take
(
&
sem_lock
,
RT_WAITING_FOREVER
);
array
[
set
%
MAXSEM
]
=
cnt
+
1
;
rt_kprintf
(
"the producer generates a number: %d
\n
"
,
array
[
set
%
MAXSEM
]);
set
++
;
rt_sem_release
(
&
sem_lock
);
/* 发布一个满位 */
rt_sem_release
(
&
sem_full
);
cnt
++
;
/* 暂停一段时间 */
rt_thread_delay
(
50
);
}
rt_kprintf
(
"the producer exit!
\n
"
);
}
/* 消费者线程入口 */
void
consumer_thread_entry
(
void
*
parameter
)
{
rt_uint32_t
no
;
rt_uint32_t
sum
;
rt_uint32_t
no
;
rt_uint32_t
sum
;
/* 第n个线程,由入口参数传进来 */
no
=
(
rt_uint32_t
)
parameter
;
/* 第n个线程,由入口参数传进来 */
no
=
(
rt_uint32_t
)
parameter
;
while
(
1
)
{
/* 获取一个满位 */
rt_sem_take
(
&
sem_full
,
RT_WAITING_FOREVER
);
while
(
1
)
{
/* 获取一个满位 */
rt_sem_take
(
&
sem_full
,
RT_WAITING_FOREVER
);
/* 临界区,上锁进行操作 */
rt_sem_take
(
&
sem_lock
,
RT_WAITING_FOREVER
);
sum
+=
array
[
get
%
MAXSEM
];
rt_kprintf
(
"the consumer[%d] get a number: %d
\n
"
,
no
,
array
[
get
%
MAXSEM
]
);
get
++
;
rt_sem_release
(
&
sem_lock
);
/* 临界区,上锁进行操作 */
rt_sem_take
(
&
sem_lock
,
RT_WAITING_FOREVER
);
sum
+=
array
[
get
%
MAXSEM
];
rt_kprintf
(
"the consumer[%d] get a number: %d
\n
"
,
no
,
array
[
get
%
MAXSEM
]
);
get
++
;
rt_sem_release
(
&
sem_lock
);
/* 释放一个空位 */
rt_sem_release
(
&
sem_empty
);
/* 释放一个空位 */
rt_sem_release
(
&
sem_empty
);
/* 生产者生产到100个数目,停止,消费者线程相应停止 */
if
(
get
==
100
)
break
;
/* 生产者生产到100个数目,停止,消费者线程相应停止 */
if
(
get
==
100
)
break
;
/* 暂停一小会时间 */
rt_thread_delay
(
10
);
}
/* 暂停一小会时间 */
rt_thread_delay
(
10
);
}
rt_kprintf
(
"the consumer[%d] sum is %d
\n
"
,
no
,
sum
);
rt_kprintf
(
"the consumer[%d] exit!
\n
"
);
rt_kprintf
(
"the consumer[%d] sum is %d
\n
"
,
no
,
sum
);
rt_kprintf
(
"the consumer[%d] exit!
\n
"
);
}
int
semaphore_producer_consumer_init
()
{
/* 初始化3个信号量 */
rt_sem_init
(
&
sem_lock
,
"lock"
,
1
,
RT_IPC_FLAG_FIFO
);
rt_sem_init
(
&
sem_empty
,
"empty"
,
MAXSEM
,
RT_IPC_FLAG_FIFO
);
rt_sem_init
(
&
sem_full
,
"full"
,
0
,
RT_IPC_FLAG_FIFO
);
/* 创建线程1 */
producer_tid
=
rt_thread_create
(
"producer"
,
producer_thread_entry
,
RT_NULL
,
/* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
producer_tid
!=
RT_NULL
)
rt_thread_startup
(
producer_tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
consumer_tid
=
rt_thread_create
(
"consumer"
,
consumer_thread_entry
,
RT_NULL
,
/* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
consumer_tid
!=
RT_NULL
)
rt_thread_startup
(
consumer_tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 初始化3个信号量 */
rt_sem_init
(
&
sem_lock
,
"lock"
,
1
,
RT_IPC_FLAG_FIFO
);
rt_sem_init
(
&
sem_empty
,
"empty"
,
MAXSEM
,
RT_IPC_FLAG_FIFO
);
rt_sem_init
(
&
sem_full
,
"full"
,
0
,
RT_IPC_FLAG_FIFO
);
/* 创建线程1 */
producer_tid
=
rt_thread_create
(
"producer"
,
producer_thread_entry
,
RT_NULL
,
/* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
producer_tid
!=
RT_NULL
)
rt_thread_startup
(
producer_tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
consumer_tid
=
rt_thread_create
(
"consumer"
,
consumer_thread_entry
,
RT_NULL
,
/* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
consumer_tid
!=
RT_NULL
)
rt_thread_startup
(
consumer_tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
producer_tid
!=
RT_NULL
&&
producer_tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
producer_tid
);
if
(
consumer_tid
!=
RT_NULL
&&
consumer_tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
consumer_tid
);
rt_sem_detach
(
&
sem_lock
);
rt_sem_detach
(
&
sem_empty
);
rt_sem_detach
(
&
sem_full
);
/* 调度器解锁 */
rt_exit_critical
();
/* 删除线程 */
if
(
producer_tid
!=
RT_NULL
&&
producer_tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
producer_tid
);
if
(
consumer_tid
!=
RT_NULL
&&
consumer_tid
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
consumer_tid
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_semaphore_producer_consumer
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_producer_consumer_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_producer_consumer_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_semaphore_producer_consumer
,
producer
and
consumer
example
);
...
...
@@ -147,8 +151,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer exa
/* 用户应用入口 */
int
rt_application_init
()
{
semaphore_producer_consumer_init
();
semaphore_producer_consumer_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/semaphore_static.c
浏览文件 @
4c463f27
...
...
@@ -17,107 +17,111 @@ static struct rt_semaphore sem;
/* 线程入口 */
static
void
thread_entry
(
void
*
parameter
)
{
rt_err_t
result
;
rt_tick_t
tick
;
/* 获得当前的OS Tick */
tick
=
rt_tick_get
();
/* 试图持有信号量,最大等待10个OS Tick后返回 */
result
=
rt_sem_take
(
&
sem
,
10
);
if
(
result
==
-
RT_ETIMEOUT
)
{
/* 超时后判断是否刚好是10个OS Tick */
if
(
rt_tick_get
()
-
tick
!=
10
)
{
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
rt_kprintf
(
"take semaphore timeout
\n
"
);
}
else
{
/* 因为没有其他地方是否信号量,所以不应该成功持有信号量,否则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
/* 释放一次信号量 */
rt_sem_release
(
&
sem
);
/* 永久等待方式持有信号量 */
result
=
rt_sem_take
(
&
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
/* 不成功则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
/* 测试通过 */
tc_done
(
TC_STAT_PASSED
);
/* 脱离信号量对象 */
rt_sem_detach
(
&
sem
);
rt_err_t
result
;
rt_tick_t
tick
;
/* 获得当前的OS Tick */
tick
=
rt_tick_get
();
/* 试图持有信号量,最大等待10个OS Tick后返回 */
result
=
rt_sem_take
(
&
sem
,
10
);
if
(
result
==
-
RT_ETIMEOUT
)
{
rt_tick_t
new_tick
=
rt_tick_get
();
/* 可以有两个 tick 的误差 */
if
(
new_tick
-
tick
>=
12
)
{
rt_kprintf
(
"tick error to large: expect: 10, get %d
\n
"
,
new_tick
-
tick
);
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
rt_kprintf
(
"take semaphore timeout
\n
"
);
}
else
{
/* 因为没有其他地方是否信号量,所以不应该成功持有信号量,否则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
/* 释放一次信号量 */
rt_sem_release
(
&
sem
);
/* 永久等待方式持有信号量 */
result
=
rt_sem_take
(
&
sem
,
RT_WAITING_FOREVER
);
if
(
result
!=
RT_EOK
)
{
/* 不成功则测试失败 */
tc_done
(
TC_STAT_FAILED
);
rt_sem_detach
(
&
sem
);
return
;
}
/* 测试通过 */
tc_done
(
TC_STAT_PASSED
);
/* 脱离信号量对象 */
rt_sem_detach
(
&
sem
);
}
int
semaphore_static_init
(
void
)
{
rt_err_t
result
;
/* 初始化信号量,初始值是0 */
result
=
rt_sem_init
(
&
sem
,
"sem"
,
0
,
RT_IPC_FLAG_FIFO
);
if
(
result
!=
RT_EOK
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 初始化线程1 */
result
=
rt_thread_init
(
&
thread
,
"thread"
,
/* 线程名:thread */
thread_entry
,
RT_NULL
,
/* 线程的入口是thread_entry,入口参数是RT_NULL*/
&
thread_stack
[
0
],
sizeof
(
thread_stack
),
/* 线程栈是thread_stack */
THREAD_PRIORITY
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程1 */
rt_thread_startup
(
&
thread
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
rt_err_t
result
;
/* 初始化信号量,初始值是0 */
result
=
rt_sem_init
(
&
sem
,
"sem"
,
0
,
RT_IPC_FLAG_FIFO
);
if
(
result
!=
RT_EOK
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
/* 初始化线程1 */
result
=
rt_thread_init
(
&
thread
,
"thread"
,
/* 线程名:thread */
thread_entry
,
RT_NULL
,
/* 线程的入口是thread_entry,入口参数是RT_NULL*/
&
thread_stack
[
0
],
sizeof
(
thread_stack
),
/* 线程栈是thread_stack */
THREAD_PRIORITY
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程1 */
rt_thread_startup
(
&
thread
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
(
void
)
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 执行线程脱离 */
if
(
thread
.
stat
!=
RT_THREAD_CLOSE
)
{
rt_thread_detach
(
&
thread
);
/* 执行线程脱离 */
if
(
thread
.
stat
!=
RT_THREAD_CLOSE
)
{
rt_thread_detach
(
&
thread
);
/* 执行信号量对象脱离 */
rt_sem_detach
(
&
sem
);
}
/* 执行信号量对象脱离 */
rt_sem_detach
(
&
sem
);
}
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_semaphore_static
(
void
)
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_static_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
semaphore_static_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_semaphore_static
,
a
static
semaphore
example
);
...
...
@@ -125,8 +129,8 @@ FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);
/* 用户应用入口 */
int
rt_application_init
(
void
)
{
semaphore_static_init
();
semaphore_static_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/tc_comm.c
浏览文件 @
4c463f27
...
...
@@ -4,8 +4,8 @@
#endif
#ifdef RT_USING_TC
#define TC_PRIORITY
25
#define TC_STACK_SIZE
0x400
#define TC_PRIORITY
25
#define TC_STACK_SIZE
0x400
static
rt_uint8_t
_tc_stat
;
static
struct
rt_semaphore
_tc_sem
;
...
...
@@ -20,156 +20,170 @@ FINSH_VAR_EXPORT(_tc_scale, finsh_type_int, the testcase timer timeout scale)
void
tc_thread_entry
(
void
*
parameter
)
{
struct
finsh_syscall
*
index
;
/* create tc semaphore */
rt_sem_init
(
&
_tc_sem
,
"tc"
,
0
,
RT_IPC_FLAG_FIFO
);
while
(
_tc_stat
&
TC_STAT_RUNNING
)
{
for
(
index
=
_syscall_table_begin
;
index
<
_syscall_table_end
;
FINSH_NEXT_SYSCALL
(
index
))
{
/* search testcase */
if
(
rt_strstr
(
index
->
name
,
_tc_prefix
)
==
index
->
name
)
{
long
tick
;
_tc_current
=
index
->
name
+
4
;
rt_kprintf
(
"Run TestCase: %s
\n
"
,
_tc_current
);
_tc_stat
=
TC_STAT_PASSED
|
TC_STAT_RUNNING
;
tick
=
index
->
func
();
if
(
tick
>
0
)
{
rt_sem_take
(
&
_tc_sem
,
tick
*
_tc_scale
);
if
(
_tc_cleanup
!=
RT_NULL
)
{
/* perform testcase cleanup */
_tc_cleanup
();
_tc_cleanup
=
RT_NULL
;
}
rt_sem_trytake
(
&
_tc_sem
);
/* by nl1031 */
if
(
_tc_stat
&
TC_STAT_FAILED
)
rt_kprintf
(
"TestCase[%s] failed
\n
"
,
_tc_current
);
else
rt_kprintf
(
"TestCase[%s] passed
\n
"
,
_tc_current
);
}
else
{
if
(
_tc_cleanup
!=
RT_NULL
)
{
/* perform testcase cleanup */
_tc_cleanup
();
_tc_cleanup
=
RT_NULL
;
}
}
}
}
}
rt_kprintf
(
"RT-Thread TestCase Running Done!
\n
"
);
/* detach tc semaphore */
rt_sem_detach
(
&
_tc_sem
);
unsigned
int
fail_count
=
0
;
struct
finsh_syscall
*
index
;
/* create tc semaphore */
rt_sem_init
(
&
_tc_sem
,
"tc"
,
0
,
RT_IPC_FLAG_FIFO
);
while
(
_tc_stat
&
TC_STAT_RUNNING
)
{
for
(
index
=
_syscall_table_begin
;
index
<
_syscall_table_end
;
FINSH_NEXT_SYSCALL
(
index
))
{
/* search testcase */
if
(
rt_strstr
(
index
->
name
,
_tc_prefix
)
==
index
->
name
)
{
long
tick
;
_tc_current
=
index
->
name
+
4
;
rt_kprintf
(
"Run TestCase: %s
\n
"
,
_tc_current
);
_tc_stat
=
TC_STAT_PASSED
|
TC_STAT_RUNNING
;
tick
=
index
->
func
();
if
(
tick
>
0
)
{
/* Make sure we are going to be blocked. */
rt_sem_control
(
&
_tc_sem
,
RT_IPC_CMD_RESET
,
0
);
rt_sem_take
(
&
_tc_sem
,
tick
*
_tc_scale
);
}
if
(
_tc_cleanup
!=
RT_NULL
)
{
/* perform testcase cleanup */
_tc_cleanup
();
_tc_cleanup
=
RT_NULL
;
}
if
(
_tc_stat
&
TC_STAT_RUNNING
)
{
rt_kprintf
(
"TestCase[%s] exit with stat TC_STAT_RUNNING."
" Please fix the TC.
\n
"
,
_tc_current
);
/* If the TC forgot to clear the flag, we do it. */
_tc_stat
&=
~
TC_STAT_RUNNING
;
}
if
(
_tc_stat
&
TC_STAT_FAILED
)
{
rt_kprintf
(
"TestCase[%s] failed
\n
"
,
_tc_current
);
fail_count
++
;
}
else
{
rt_kprintf
(
"TestCase[%s] passed
\n
"
,
_tc_current
);
}
}
}
}
rt_kprintf
(
"RT-Thread TestCase Running Done!
\n
"
);
if
(
fail_count
)
{
rt_kprintf
(
"%d tests failed
\n
"
,
fail_count
);
}
else
{
rt_kprintf
(
"All tests passed
\n
"
);
}
/* detach tc semaphore */
rt_sem_detach
(
&
_tc_sem
);
}
void
tc_stop
()
{
_tc_stat
&=
~
TC_STAT_RUNNING
;
rt_thread_delay
(
RT_TICK_PER_SECOND
/
2
);
if
(
_tc_thread
.
stat
!=
RT_THREAD_INIT
)
{
/* lock scheduler */
rt_enter_critical
();
/* detach old tc thread */
rt_thread_detach
(
&
_tc_thread
);
rt_sem_detach
(
&
_tc_sem
);
/* unlock scheduler */
rt_exit_critical
();
}
rt_thread_delay
(
RT_TICK_PER_SECOND
/
2
);
_tc_stat
&=
~
TC_STAT_RUNNING
;
rt_thread_delay
(
RT_TICK_PER_SECOND
/
2
);
if
(
_tc_thread
.
stat
!=
RT_THREAD_INIT
)
{
/* lock scheduler */
rt_enter_critical
();
/* detach old tc thread */
rt_thread_detach
(
&
_tc_thread
);
rt_sem_detach
(
&
_tc_sem
);
/* unlock scheduler */
rt_exit_critical
();
}
rt_thread_delay
(
RT_TICK_PER_SECOND
/
2
);
}
FINSH_FUNCTION_EXPORT
(
tc_stop
,
stop
testcase
thread
);
void
tc_done
(
rt_uint8_t
stat
)
{
_tc_stat
|=
stat
;
_tc_stat
&=
~
TC_STAT_RUNNING
;
_tc_stat
|=
stat
;
_tc_stat
&=
~
TC_STAT_RUNNING
;
/* release semaphore */
rt_sem_release
(
&
_tc_sem
);
/* release semaphore */
rt_sem_release
(
&
_tc_sem
);
}
void
tc_stat
(
rt_uint8_t
stat
)
{
if
(
stat
&
TC_STAT_FAILED
)
{
rt_kprintf
(
"TestCases[%s] failed
\n
"
,
_tc_current
);
}
_tc_stat
|=
stat
;
if
(
stat
&
TC_STAT_FAILED
)
{
rt_kprintf
(
"TestCases[%s] failed
\n
"
,
_tc_current
);
}
_tc_stat
|=
stat
;
}
void
tc_cleanup
(
void
(
*
cleanup
)())
{
_tc_cleanup
=
cleanup
;
_tc_cleanup
=
cleanup
;
}
void
tc_start
(
const
char
*
tc_prefix
)
{
rt_err_t
result
;
/* tesecase prefix is null */
if
(
tc_prefix
==
RT_NULL
)
{
rt_kprintf
(
"TestCase Usage: tc_start(prefix)
\n\n
"
);
rt_kprintf
(
"list_tc() can list all testcases.
\n
"
);
return
;
}
/* init tc thread */
if
(
_tc_stat
&
TC_STAT_RUNNING
)
{
/* stop old tc thread */
tc_stop
();
}
rt_memset
(
_tc_prefix
,
0
,
sizeof
(
_tc_prefix
));
rt_snprintf
(
_tc_prefix
,
sizeof
(
_tc_prefix
),
"_tc_%s"
,
tc_prefix
);
result
=
rt_thread_init
(
&
_tc_thread
,
"tc"
,
tc_thread_entry
,
RT_NULL
,
&
_tc_stack
[
0
],
sizeof
(
_tc_stack
),
TC_PRIORITY
-
3
,
5
);
/* set tc stat */
_tc_stat
=
TC_STAT_RUNNING
|
TC_STAT_FAILED
;
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
_tc_thread
);
rt_err_t
result
;
/* tesecase prefix is null */
if
(
tc_prefix
==
RT_NULL
)
{
rt_kprintf
(
"TestCase Usage: tc_start(prefix)
\n\n
"
);
rt_kprintf
(
"list_tc() can list all testcases.
\n
"
);
return
;
}
/* init tc thread */
if
(
_tc_stat
&
TC_STAT_RUNNING
)
{
/* stop old tc thread */
tc_stop
();
}
rt_memset
(
_tc_prefix
,
0
,
sizeof
(
_tc_prefix
));
rt_snprintf
(
_tc_prefix
,
sizeof
(
_tc_prefix
),
"_tc_%s"
,
tc_prefix
);
result
=
rt_thread_init
(
&
_tc_thread
,
"tc"
,
tc_thread_entry
,
RT_NULL
,
&
_tc_stack
[
0
],
sizeof
(
_tc_stack
),
TC_PRIORITY
-
3
,
5
);
/* set tc stat */
_tc_stat
=
TC_STAT_RUNNING
|
TC_STAT_FAILED
;
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
_tc_thread
);
}
FINSH_FUNCTION_EXPORT
(
tc_start
,
start
testcase
with
testcase
prefix
or
name
);
void
list_tc
()
{
struct
finsh_syscall
*
index
;
rt_kprintf
(
"TestCases List:
\n
"
);
for
(
index
=
_syscall_table_begin
;
index
<
_syscall_table_end
;
FINSH_NEXT_SYSCALL
(
index
))
{
/* search testcase */
if
(
rt_strstr
(
index
->
name
,
"_tc_"
)
==
index
->
name
)
{
struct
finsh_syscall
*
index
;
rt_kprintf
(
"TestCases List:
\n
"
);
for
(
index
=
_syscall_table_begin
;
index
<
_syscall_table_end
;
FINSH_NEXT_SYSCALL
(
index
))
{
/* search testcase */
if
(
rt_strstr
(
index
->
name
,
"_tc_"
)
==
index
->
name
)
{
#ifdef FINSH_USING_DESCRIPTION
rt_kprintf
(
"%-16s -- %s
\n
"
,
index
->
name
+
4
,
index
->
desc
);
rt_kprintf
(
"%-16s -- %s
\n
"
,
index
->
name
+
4
,
index
->
desc
);
#else
rt_kprintf
(
"%s
\n
"
,
index
->
name
+
4
);
rt_kprintf
(
"%s
\n
"
,
index
->
name
+
4
);
#endif
}
}
}
}
}
FINSH_FUNCTION_EXPORT
(
list_tc
,
list
all
testcases
);
#endif
...
...
examples/kernel/tc_comm.h
浏览文件 @
4c463f27
...
...
@@ -11,19 +11,19 @@
#endif
#if RT_THREAD_PRIORITY_MAX == 8
#define THREAD_PRIORITY
6
#define THREAD_PRIORITY
6
#elif RT_THREAD_PRIORITY_MAX == 32
#define THREAD_PRIORITY
25
#define THREAD_PRIORITY
25
#elif RT_THREAD_PRIORITY_MAX == 256
#define THREAD_PRIORITY
200
#define THREAD_PRIORITY
200
#endif
#define THREAD_STACK_SIZE
512
#define THREAD_TIMESLICE
5
#define THREAD_STACK_SIZE
512
#define THREAD_TIMESLICE
5
#define TC_STAT_END
0x00
#define TC_STAT_RUNNING
0x01
#define TC_STAT_FAILED
0x10
#define TC_STAT_PASSED
0x00
#define TC_STAT_END
0x00
#define TC_STAT_RUNNING
0x01
#define TC_STAT_FAILED
0x10
#define TC_STAT_PASSED
0x00
#ifdef RT_USING_TC
void
tc_start
(
const
char
*
tc_prefix
);
...
...
examples/kernel/tc_sample.c
浏览文件 @
4c463f27
...
...
@@ -4,59 +4,59 @@
static
rt_thread_t
tid
=
RT_NULL
;
static
void
sample_thread
(
void
*
parameter
)
{
rt_kprintf
(
"I'm sample!
\n
"
);
rt_kprintf
(
"I'm sample!
\n
"
);
}
static
void
sample_thread_cleanup
(
struct
rt_thread
*
p
)
{
tid
=
RT_NULL
;
tc_done
(
TC_STAT_PASSED
);
tid
=
RT_NULL
;
tc_done
(
TC_STAT_PASSED
);
}
int
sample_init
()
{
tid
=
rt_thread_create
(
"t"
,
sample_thread
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
{
rt_thread_startup
(
tid
);
tid
->
cleanup
=
sample_thread_cleanup
;
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
tid
=
rt_thread_create
(
"t"
,
sample_thread
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
{
rt_thread_startup
(
tid
);
tid
->
cleanup
=
sample_thread_cleanup
;
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* lock scheduler */
rt_enter_critical
();
/* delete thread */
if
(
tid
!=
RT_NULL
)
{
rt_kprintf
(
"tid1 is bad
\n
"
);
tc_stat
(
TC_STAT_FAILED
);
}
/* unlock scheduler */
rt_exit_critical
();
/* lock scheduler */
rt_enter_critical
();
/* delete thread */
if
(
tid
!=
RT_NULL
)
{
rt_kprintf
(
"tid1 is bad
\n
"
);
tc_stat
(
TC_STAT_FAILED
);
}
/* unlock scheduler */
rt_exit_critical
();
}
int
_tc_sample
()
{
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
sample_init
();
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
sample_init
();
return
25
;
return
25
;
}
FINSH_FUNCTION_EXPORT
(
_tc_sample
,
a
thread
testcase
example
);
#else
int
rt_application_init
()
{
sample_init
();
sample_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_delay.c
浏览文件 @
4c463f27
...
...
@@ -8,63 +8,63 @@ static struct rt_thread thread;
static
char
thread_stack
[
THREAD_STACK_SIZE
];
static
void
thread_entry
(
void
*
parameter
)
{
rt_tick_t
tick
;
rt_kprintf
(
"thread inited ok
\n
"
);
rt_tick_t
tick
;
rt_kprintf
(
"thread inited ok
\n
"
);
rt_kprintf
(
"thread delay 10 tick
\n
"
);
tick
=
rt_tick_get
();
rt_thread_delay
(
10
);
if
(
rt_tick_get
()
-
tick
>
10
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread delay 10 tick
\n
"
);
tick
=
rt_tick_get
();
rt_thread_delay
(
10
);
if
(
rt_tick_get
()
-
tick
>
11
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread delay 15 tick
\n
"
);
tick
=
rt_tick_get
();
rt_thread_delay
(
15
);
if
(
rt_tick_get
()
-
tick
>
15
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread delay 15 tick
\n
"
);
tick
=
rt_tick_get
();
rt_thread_delay
(
15
);
if
(
rt_tick_get
()
-
tick
>
16
)
{
tc_done
(
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread exit
\n
"
);
rt_kprintf
(
"thread exit
\n
"
);
tc_done
(
TC_STAT_PASSED
);
tc_done
(
TC_STAT_PASSED
);
}
rt_err_t
thread_delay_init
()
{
rt_err_t
result
;
rt_err_t
result
;
result
=
rt_thread_init
(
&
thread
,
"test"
,
thread_entry
,
RT_NULL
,
&
thread_stack
[
0
],
sizeof
(
thread_stack
),
THREAD_PRIORITY
,
10
);
result
=
rt_thread_init
(
&
thread
,
"test"
,
thread_entry
,
RT_NULL
,
&
thread_stack
[
0
],
sizeof
(
thread_stack
),
THREAD_PRIORITY
,
10
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
result
;
return
result
;
}
#ifdef RT_USING_TC
int
_tc_thread_delay
()
{
thread_delay_init
();
thread_delay_init
();
return
30
;
return
30
;
}
FINSH_FUNCTION_EXPORT
(
_tc_thread_delay
,
a
thread
delay
test
);
#else
int
rt_application_init
()
{
thread_delay_init
();
thread_delay_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_delete.c
浏览文件 @
4c463f27
...
...
@@ -15,130 +15,128 @@ static rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;
/* 线程1的入口函数 */
static
void
thread1_entry
(
void
*
parameter
)
{
rt_uint32_t
count
=
0
;
while
(
1
)
{
/* 线程1采用低优先级运行,一直打印计数值 */
// rt_kprintf("thread count: %d\n", count ++);
count
++
;
}
rt_uint32_t
count
=
0
;
while
(
1
)
{
/* 线程1采用低优先级运行,一直打印计数值 */
// rt_kprintf("thread count: %d\n", count ++);
count
++
;
}
}
static
void
thread1_cleanup
(
struct
rt_thread
*
tid
)
{
if
(
tid
!=
tid1
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread1 end
\n
"
);
tid1
=
RT_NULL
;
if
(
tid
!=
tid1
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread1 end
\n
"
);
tid1
=
RT_NULL
;
}
/* 线程2的入口函数 */
static
void
thread2_entry
(
void
*
parameter
)
{
/* 线程2拥有较高的优先级,以抢占线程1而获得执行 */
/* 线程2启动后先睡眠10个OS Tick */
rt_thread_delay
(
10
);
/*
* 线程2唤醒后直接删除线程1,删除线程1后,线程1自动脱离就绪线程
* 队列
*/
rt_thread_delete
(
tid1
);
/*
* 线程2继续休眠10个OS Tick然后退出,线程2休眠后应切换到idle线程
* idle线程将执行真正的线程1控制块和线程栈的删除
*/
rt_thread_delay
(
10
);
/* 线程2拥有较高的优先级,以抢占线程1而获得执行 */
/* 线程2启动后先睡眠10个OS Tick */
rt_thread_delay
(
RT_TICK_PER_SECOND
);
/*
* 线程2唤醒后直接删除线程1,删除线程1后,线程1自动脱离就绪线程
* 队列
*/
rt_thread_delete
(
tid1
);
/*
* 线程2继续休眠10个OS Tick然后退出,线程2休眠后应切换到idle线程
* idle线程将执行真正的线程1控制块和线程栈的删除
*/
rt_thread_delay
(
RT_TICK_PER_SECOND
);
}
static
void
thread2_cleanup
(
struct
rt_thread
*
tid
)
{
/*
* 线程2运行结束后也将自动被删除(线程控制块和线程栈在idle线
* 程中释放)
*/
if
(
tid
!=
tid2
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread2 end
\n
"
);
tid2
=
RT_NULL
;
tc_done
(
TC_STAT_PASSED
);
/*
* 线程2运行结束后也将自动被删除(线程控制块和线程栈在idle线
* 程中释放)
*/
if
(
tid
!=
tid2
)
{
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
;
}
rt_kprintf
(
"thread2 end
\n
"
);
tid2
=
RT_NULL
;
tc_done
(
TC_STAT_PASSED
);
}
/* 线程删除示例的初始化 */
int
thread_delete_init
()
{
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
/* 线程1的名称是t1 */
thread1_entry
,
RT_NULL
,
/* 入口是thread1_entry,参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
/* 如果获得线程控制块,启动这个线程 */
{
tid1
->
cleanup
=
thread1_cleanup
;
rt_thread_startup
(
tid1
);
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程1 */
tid2
=
rt_thread_create
(
"t2"
,
/* 线程1的名称是t2 */
thread2_entry
,
RT_NULL
,
/* 入口是thread2_entry,参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
/* 如果获得线程控制块,启动这个线程 */
{
tid2
->
cleanup
=
thread2_cleanup
;
rt_thread_startup
(
tid2
);
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
/* 线程1的名称是t1 */
thread1_entry
,
RT_NULL
,
/* 入口是thread1_entry,参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
/* 如果获得线程控制块,启动这个线程 */
{
tid1
->
cleanup
=
thread1_cleanup
;
rt_thread_startup
(
tid1
);
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程1 */
tid2
=
rt_thread_create
(
"t2"
,
/* 线程1的名称是t2 */
thread2_entry
,
RT_NULL
,
/* 入口是thread2_entry,参数是RT_NULL */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
/* 如果获得线程控制块,启动这个线程 */
{
tid2
->
cleanup
=
thread2_cleanup
;
rt_thread_startup
(
tid2
);
}
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
10
*
RT_TICK_PER_SECOND
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* lock scheduler */
rt_enter_critical
();
/* delete thread */
if
(
tid1
!=
RT_NULL
)
{
rt_kprintf
(
"tid1 is bad
\n
"
);
tc_stat
(
TC_STAT_FAILED
);
}
if
(
tid2
!=
RT_NULL
)
{
rt_kprintf
(
"tid2 is bad
\n
"
);
tc_stat
(
TC_STAT_FAILED
);
}
/* unlock scheduler */
rt_exit_critical
();
/* lock scheduler */
rt_enter_critical
();
/* delete thread */
if
(
tid1
!=
RT_NULL
)
{
rt_kprintf
(
"tid1 is %p, should be NULL
\n
"
,
tid1
);
tc_stat
(
TC_STAT_FAILED
);
}
if
(
tid2
!=
RT_NULL
)
{
rt_kprintf
(
"tid2 is %p, should be NULL
\n
"
,
tid2
);
tc_stat
(
TC_STAT_FAILED
);
}
/* unlock scheduler */
rt_exit_critical
();
}
int
_tc_thread_delete
()
{
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
thread_delete_init
();
return
27
;
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
return
thread_delete_init
();
}
FINSH_FUNCTION_EXPORT
(
_tc_thread_delete
,
a
thread
delete
example
);
#else
int
rt_application_init
()
{
thread_delete_init
();
thread_delete_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_detach.c
浏览文件 @
4c463f27
...
...
@@ -18,92 +18,92 @@ static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
/* 线程1入口 */
static
void
thread1_entry
(
void
*
parameter
)
{
rt_uint32_t
count
=
0
;
rt_uint32_t
count
=
0
;
while
(
1
)
{
/* 线程1采用低优先级运行,一直打印计数值 */
rt_kprintf
(
"thread count: %d
\n
"
,
count
++
);
}
while
(
1
)
{
/* 线程1采用低优先级运行,一直打印计数值 */
rt_kprintf
(
"thread count: %d
\n
"
,
count
++
);
}
}
/* 线程2入口 */
static
void
thread2_entry
(
void
*
parameter
)
{
/* 线程2拥有较高的优先级,以抢占线程1而获得执行 */
/* 线程2拥有较高的优先级,以抢占线程1而获得执行 */
/* 线程2启动后先睡眠10个OS Tick */
rt_thread_delay
(
10
);
/* 线程2启动后先睡眠10个OS Tick */
rt_thread_delay
(
10
);
/*
* 线程2唤醒后直接执行线程1脱离,线程1将从就绪线程队列中删除
*/
rt_thread_detach
(
&
thread1
);
/*
* 线程2唤醒后直接执行线程1脱离,线程1将从就绪线程队列中删除
*/
rt_thread_detach
(
&
thread1
);
/*
* 线程2继续休眠10个OS Tick然后退出
*/
rt_thread_delay
(
10
);
/*
* 线程2继续休眠10个OS Tick然后退出
*/
rt_thread_delay
(
10
);
/*
* 线程2运行结束后也将自动被从就绪队列中删除,并脱离线程队列
*/
/*
* 线程2运行结束后也将自动被从就绪队列中删除,并脱离线程队列
*/
}
int
thread_detach_init
()
{
rt_err_t
result
;
/* 初始化线程1 */
result
=
rt_thread_init
(
&
thread1
,
"t1"
,
/* 线程名:t1 */
thread1_entry
,
RT_NULL
,
/* 线程的入口是thread1_entry,入口参数是RT_NULL*/
&
thread1_stack
[
0
],
sizeof
(
thread1_stack
),
/* 线程栈是thread1_stack */
THREAD_PRIORITY
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程1 */
rt_thread_startup
(
&
thread1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 初始化线程2 */
result
=
rt_thread_init
(
&
thread2
,
"t2"
,
/* 线程名:t2 */
thread2_entry
,
RT_NULL
,
/* 线程的入口是thread2_entry,入口参数是RT_NULL*/
&
thread2_stack
[
0
],
sizeof
(
thread2_stack
),
/* 线程栈是thread2_stack */
THREAD_PRIORITY
-
1
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程2 */
rt_thread_startup
(
&
thread2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
rt_err_t
result
;
/* 初始化线程1 */
result
=
rt_thread_init
(
&
thread1
,
"t1"
,
/* 线程名:t1 */
thread1_entry
,
RT_NULL
,
/* 线程的入口是thread1_entry,入口参数是RT_NULL*/
&
thread1_stack
[
0
],
sizeof
(
thread1_stack
),
/* 线程栈是thread1_stack */
THREAD_PRIORITY
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程1 */
rt_thread_startup
(
&
thread1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 初始化线程2 */
result
=
rt_thread_init
(
&
thread2
,
"t2"
,
/* 线程名:t2 */
thread2_entry
,
RT_NULL
,
/* 线程的入口是thread2_entry,入口参数是RT_NULL*/
&
thread2_stack
[
0
],
sizeof
(
thread2_stack
),
/* 线程栈是thread2_stack */
THREAD_PRIORITY
-
1
,
10
);
if
(
result
==
RT_EOK
)
/* 如果返回正确,启动线程2 */
rt_thread_startup
(
&
thread2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 执行线程脱离 */
if
(
thread1
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread1
);
if
(
thread2
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread2
);
/* 执行线程脱离 */
if
(
thread1
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread1
);
if
(
thread2
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread2
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_thread_detach
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
thread_detach_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
thread_detach_init
();
/* 返回TestCase运行的最长时间 */
return
25
;
/* 返回TestCase运行的最长时间 */
return
25
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_thread_detach
,
a
static
thread
example
);
...
...
@@ -111,8 +111,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);
/* 用户应用入口 */
int
rt_application_init
()
{
thread_detach_init
();
thread_detach_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_dynamic.c
浏览文件 @
4c463f27
...
...
@@ -3,42 +3,42 @@
static
void
thread_entry
(
void
*
parameter
)
{
rt_kprintf
(
"thread dynamicly created ok
\n
"
);
rt_thread_delay
(
10
);
rt_kprintf
(
"thread exit
\n
"
);
rt_kprintf
(
"thread dynamicly created ok
\n
"
);
rt_thread_delay
(
10
);
rt_kprintf
(
"thread exit
\n
"
);
tc_done
(
TC_STAT_PASSED
);
tc_done
(
TC_STAT_PASSED
);
}
int
thread_dynamic_init
()
{
rt_thread_t
tid
;
rt_thread_t
tid
;
tid
=
rt_thread_create
(
"test"
,
thread_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
tid
=
rt_thread_create
(
"test"
,
thread_entry
,
RT_NULL
,
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid
!=
RT_NULL
)
rt_thread_startup
(
tid
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
return
0
;
}
#ifdef RT_USING_TC
int
_tc_thread_dynamic
()
{
thread_dynamic_init
();
thread_dynamic_init
();
return
20
;
return
20
;
}
FINSH_FUNCTION_EXPORT
(
_tc_thread_dynamic
,
a
dynamic
thread
test
);
#else
int
rt_application_init
()
{
thread_dynamic_init
();
thread_dynamic_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_dynamic_simple.c
浏览文件 @
4c463f27
...
...
@@ -12,69 +12,69 @@ static rt_thread_t tid2 = RT_NULL;
/* 线程入口 */
static
void
thread_entry
(
void
*
parameter
)
{
rt_uint32_t
count
=
0
;
rt_uint32_t
no
=
(
rt_uint32_t
)
parameter
;
/* 获得正确的入口参数 */
rt_uint32_t
count
=
0
;
rt_uint32_t
no
=
(
rt_uint32_t
)
parameter
;
/* 获得正确的入口参数 */
while
(
1
)
{
/* 打印线程计数值输出 */
rt_kprintf
(
"thread%d count: %d
\n
"
,
no
,
count
++
);
while
(
1
)
{
/* 打印线程计数值输出 */
rt_kprintf
(
"thread%d count: %d
\n
"
,
no
,
count
++
);
/* 休眠10个OS Tick */
rt_thread_delay
(
10
);
}
/* 休眠10个OS Tick */
rt_thread_delay
(
10
);
}
}
int
thread_dynamic_simple_init
()
{
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread_entry
,
(
void
*
)
1
,
/* 线程入口是thread_entry, 入口参数是1 */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程1 */
tid1
=
rt_thread_create
(
"t1"
,
thread_entry
,
(
void
*
)
1
,
/* 线程入口是thread_entry, 入口参数是1 */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid1
!=
RT_NULL
)
rt_thread_startup
(
tid1
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread_entry
,
(
void
*
)
2
,
/* 线程入口是thread_entry, 入口参数是2 */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
/* 创建线程2 */
tid2
=
rt_thread_create
(
"t2"
,
thread_entry
,
(
void
*
)
2
,
/* 线程入口是thread_entry, 入口参数是2 */
THREAD_STACK_SIZE
,
THREAD_PRIORITY
,
THREAD_TIMESLICE
);
if
(
tid2
!=
RT_NULL
)
rt_thread_startup
(
tid2
);
else
tc_stat
(
TC_STAT_END
|
TC_STAT_FAILED
);
return
0
;
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 调度器上锁,上锁后,将不再切换到其他线程,仅响应中断 */
rt_enter_critical
();
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 删除线程 */
if
(
tid1
!=
RT_NULL
&&
tid1
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid1
);
if
(
tid2
!=
RT_NULL
&&
tid2
->
stat
!=
RT_THREAD_CLOSE
)
rt_thread_delete
(
tid2
);
/* 调度器解锁 */
rt_exit_critical
();
/* 调度器解锁 */
rt_exit_critical
();
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
/* 设置TestCase状态 */
tc_done
(
TC_STAT_PASSED
);
}
int
_tc_thread_dynamic_simple
()
{
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
thread_dynamic_simple_init
();
/* 设置TestCase清理回调函数 */
tc_cleanup
(
_tc_cleanup
);
thread_dynamic_simple_init
();
/* 返回TestCase运行的最长时间 */
return
100
;
/* 返回TestCase运行的最长时间 */
return
100
;
}
/* 输出函数命令到finsh shell中 */
FINSH_FUNCTION_EXPORT
(
_tc_thread_dynamic_simple
,
a
dynamic
thread
example
);
...
...
@@ -82,8 +82,8 @@ FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);
/* 用户应用入口 */
int
rt_application_init
()
{
thread_dynamic_simple_init
();
thread_dynamic_simple_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_priority.c
浏览文件 @
4c463f27
...
...
@@ -12,94 +12,94 @@ static rt_uint32_t count = 0;
*/
static
void
thread1_entry
(
void
*
parameter
)
{
while
(
1
)
{
count
++
;
rt_kprintf
(
"count = %d
\n
"
,
count
);
while
(
1
)
{
count
++
;
rt_kprintf
(
"count = %d
\n
"
,
count
);
rt_thread_delay
(
10
);
}
rt_thread_delay
(
10
);
}
}
static
void
thread2_entry
(
void
*
parameter
)
{
rt_tick_t
tick
;
tick
=
rt_tick_get
();
while
(
1
)
{
if
(
rt_tick_get
()
-
tick
>=
50
)
{
if
(
count
==
0
)
tc_done
(
TC_STAT_FAILED
);
else
tc_done
(
TC_STAT_PASSED
);
break
;
}
}
rt_tick_t
tick
;
tick
=
rt_tick_get
();
while
(
1
)
{
if
(
rt_tick_get
()
-
tick
>=
50
)
{
if
(
count
==
0
)
tc_done
(
TC_STAT_FAILED
);
else
tc_done
(
TC_STAT_PASSED
);
break
;
}
}
}
int
thread_priority_init
()
{
rt_err_t
result
;
result
=
rt_thread_init
(
&
thread1
,
"t1"
,
thread1_entry
,
RT_NULL
,
&
thread1_stack
[
0
],
sizeof
(
thread1_stack
),
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread1
);
else
tc_stat
(
TC_STAT_FAILED
);
rt_thread_init
(
&
thread2
,
"t2"
,
thread2_entry
,
RT_NULL
,
&
thread2_stack
[
0
],
sizeof
(
thread2_stack
),
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread2
);
else
tc_stat
(
TC_STAT_FAILED
);
return
0
;
rt_err_t
result
;
result
=
rt_thread_init
(
&
thread1
,
"t1"
,
thread1_entry
,
RT_NULL
,
&
thread1_stack
[
0
],
sizeof
(
thread1_stack
),
THREAD_PRIORITY
-
1
,
THREAD_TIMESLICE
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread1
);
else
tc_stat
(
TC_STAT_FAILED
);
rt_thread_init
(
&
thread2
,
"t2"
,
thread2_entry
,
RT_NULL
,
&
thread2_stack
[
0
],
sizeof
(
thread2_stack
),
THREAD_PRIORITY
+
1
,
THREAD_TIMESLICE
);
if
(
result
==
RT_EOK
)
rt_thread_startup
(
&
thread2
);
else
tc_stat
(
TC_STAT_FAILED
);
return
0
;
}
#ifdef RT_USING_TC
static
void
_tc_cleanup
()
{
/* lock scheduler */
rt_enter_critical
();
/* lock scheduler */
rt_enter_critical
();
if
(
thread1
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread1
);
if
(
thread2
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread2
);
if
(
thread1
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread1
);
if
(
thread2
.
stat
!=
RT_THREAD_CLOSE
)
rt_thread_detach
(
&
thread2
);
/* unlock scheduler */
rt_exit_critical
();
/* unlock scheduler */
rt_exit_critical
();
}
int
_tc_thread_priority
()
{
count
=
0
;
count
=
0
;
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
thread_priority_init
();
/* set tc cleanup */
tc_cleanup
(
_tc_cleanup
);
thread_priority_init
();
return
RT_TICK_PER_SECOND
;
return
RT_TICK_PER_SECOND
;
}
FINSH_FUNCTION_EXPORT
(
_tc_thread_priority
,
a
priority
thread
test
);
#else
int
rt_application_init
()
{
thread_priority_init
();
thread_priority_init
();
return
0
;
return
0
;
}
#endif
examples/kernel/thread_resume.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/thread_same_priority.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/thread_static.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/thread_static_simple.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/thread_suspend.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/thread_yield.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/timer_control.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/timer_dynamic.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/timer_static.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/timer_stop_self.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
examples/kernel/timer_timeout.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
include/rtthread.h
浏览文件 @
4c463f27
...
...
@@ -173,6 +173,7 @@ void rt_schedule_remove_thread(struct rt_thread *thread);
void
rt_enter_critical
(
void
);
void
rt_exit_critical
(
void
);
rt_uint16_t
rt_critical_level
(
void
);
#ifdef RT_USING_HOOK
void
rt_scheduler_sethook
(
void
(
*
hook
)(
rt_thread_t
from
,
rt_thread_t
to
));
...
...
src/idle.c
浏览文件 @
4c463f27
...
...
@@ -22,6 +22,8 @@
* 2006-03-23 Bernard the first version
* 2010-11-10 Bernard add cleanup callback function in thread exit.
* 2012-12-29 Bernard fix compiling warning.
* 2013-12-21 Grissiom let rt_thread_idle_excute loop until there is no
* dead thread.
*/
#include <rthw.h>
...
...
@@ -72,8 +74,9 @@ void rt_thread_idle_sethook(void (*hook)(void))
*/
void
rt_thread_idle_excute
(
void
)
{
/* check the defunct thread list */
if
(
!
rt_list_isempty
(
&
rt_thread_defunct
))
/* Loop until there is no dead thread. So one call to rt_thread_idle_excute
* will do all the cleanups. */
while
(
!
rt_list_isempty
(
&
rt_thread_defunct
))
{
rt_base_t
lock
;
rt_thread_t
thread
;
...
...
src/scheduler.c
浏览文件 @
4c463f27
此差异已折叠。
点击以展开。
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录