【安富莱】【RTX操作系统教程】第18章内存管理

baiyongbin2009 · 2016-02-03T05:27:07+00:00

【安富莱】【RTX操作系统教程】第18章内存管理 ãRTXæä½ç³»ç»æç¨ãç¬¬18ç« å åç®¡ç.pdf (969.74 KB, 下载次数: 45) 2016-2-3 14:51 上传点击文件名下载附件 % z# E2 y9 \5 S第18章内存管理 + [/ A# G6 F) A! y" {% ]4 Y. Y+ F 本章节为大家讲解RTX支持的内存管理。本章教程配套的例子含Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407。18.1 内存管理介绍18.2 内存管理API函数18.3 实验例程说明（4字节对齐）18.4 实验例程说明（8字节对齐）18.5 总结 ' x* M$ V3 N" m- x* L7 F* E 18.1 内存管理介绍在ANSIC中，可以用malloc()和free()2个函数动态的分配内存和释放内存，但是，在嵌入式实时操作系统中，调用malloc()和free()却是危险的，因为多次调用这两个函数会把原来很大的一块连续内场区域逐渐地分割成许多非常小而且彼此又不相邻的内存块，也就是内存碎片。由于这些内存碎片的大量存在，使得程序到后来连一段非常小的连续内存也分配不到。另外，由于内存管理算法上的原因，malloc()和free()函数的执行时间是不确定的。在RTX中，操作系统把连续的大块内存按分区来管理。每个分区中包含整数个大小相同的内存块。如图18.1所示：图18.1 内存分区利用这种机制，就可以得到和释放固定大小的内存块。这样内存的申请和释放函数的执行时间就是确定的了。在一个系统中可以有多个内存分区，这样，应用程序就可以从不同的内存分区中得到不同大小的内存块。但是特定的内存块在释放时，必须重新放回到它以前所属于的内存分区。显然，采用这样的内存管理算法，上面的内存碎片文件就得到了解决。其实RTX的内存管理也非常好理解，可以理解成一个二维数组，比如我们定义一个二维数组为：uint8_t mpool[10][32]。对应到RTX的内存管理上就是定义了10个内存块，每块大小是32字节。如果还需要其它大小的内存块，还可以多定义几个其它大小的。 % ?# X1 V6 b- H

技术帖
文章封面:	-
文章简介:	-

baiyongbin2009 回答时间：2016-2-3 14:50:52

18.2 内存管理API函数

使用如下7个函数可以实现RTX的内存管理：

_declare_box

_declare_box8

_init_box

_init_box8

_alloc_box

_calloc_box

_free_box

关于这7个函数的讲解及其使用方法可以看教程第3章3.3小节里面说的参考资料rlarm.chm文件

这里我们重点的说一下函数_declare_box，_declare_box8，_init_box，_init_box8，_alloc_box和_free_box。

) ]8 k c$ ^9 a3 `4 F
18.2.1 函数_declare_box

函数原型：

#define _declare_box( \
- m! D' m9 z; ?& ^3 U, L
pool, \ /* 内存池变量名 */
- q5 A4 F0 L* B5 E) u F9 z
size, \ /* 内存块大小，单位字节 */
{9 y6 t7 c2 C2 K- p
cnt ) \ /* 内存池中内存块的个数 */
{/ o3 c- f7 ~* l
U32 pool[((size+3)/4)*(cnt) + 3]

复制代码

函数描述：

函数_declare_box用于定义一块内存池。

（1）第1个参数填写内存池的变量名。

（2）第2个参数填写内存块的大小，单位字节。

（3）第3个参数填写内存池中内存块的个数。

使用这个函数要注意以下问题：

1. 宏定义中通过操作（size+3）/4保证了每个内存块大小是4字节的倍数，从而也就保证了每个内存块的首地址是4字节对齐的（4字节对齐的含义是地址对4求余等于0）。这里初学者也要注意数据类型的字节对齐问题。

基本数据类型的字节对齐问题

这个问题在MDK5安装目录里面的文档DUI0375G_02_mdk_armcc_user_guide.pdf里面有详细的说明,简单的说明，数据类型有几个字节，那么这个数据类型的变量就是几字节对齐，比如32位的int型有4个字节，那么此int型定义的变量就是4字节对齐，对于初学者要牢牢的记住这个知识点。

2. 内存池中额外定义的12个字节用于将内存块做指针链表，方便动态的申请和释放。

使用举例：

#include <rtl.h>
i9 n" C, \- Z; P5 t$ {
9 O/ t; ?: L0 d4 _, R$ f
#define PoolBlocks 10; C% I- W. j6 G( l
#define PoolPerBlockSize 8
$ g" Q/ s$ O$ N$ i8 s/ u
# ?- L! ^' d! a
/* 声明一个内存池，10块，每块大小8字节 */4 z+ E. E& m3 w( f2 v
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);

复制代码

4 b: i- n, b }6 N9 ]+ C18.2.2 函数_declare_box8

函数原型：

#define _declare_box8( \$ f0 C+ h! c1 ^
pool, \ /* 内存池变量名 */
6 W1 P" c t, y7 C5 H9 k7 i. D
size, \ /* 内存块大小，单位字节 */
9 i/ d3 Q/ R0 C( `( W* y. _9 J
cnt ) \ /* 内存池中内存块的个数 */
|. s' E$ L$ N, U! r0 y# _
U64 pool[((size+7)/8)*(cnt) + 2]

复制代码

函数描述：

函数_declare_box用于定义一块内存池。

（1）第1个参数填写内存池的变量名。

（2）第2个参数填写内存块的大小，单位字节。

（3）第3个参数填写内存池中内存块的个数。

使用这个函数要注意以下问题：

1. 宏定义中通过操作（size+7）/8保证了每个内存块大小是8字节的倍数，从而也就保证了每个内存块的首地址是8字节对齐的（8字节对齐的含义是地址对8求余等于0）。这里初学者也要注意数据类型的字节对齐问题。

2. 内存池中额外定义的16个字节用于将内存块做指针链表，方便动态的申请和释放。

使用举例：

#include <rtl.h>" p* Z9 `( L. h" {0 w- y* B0 s. t- e8 B
! r, l) R7 n% _9 I" H. X& u( L& c
#define PoolBlocks 10' a5 U" _" E' [+ b% j. N
#define PoolPerBlockSize 8
9 \6 Q+ J. g: p8 Y$ I9 O
4 o! U; A5 ?2 F$ @% U/ K/ c E
/* 声明一个内存池，10块，每块大小8字节 */& T' A' w- a% X& Q
_declare_box8(mpool, PoolPerBlockSize, PoolBlocks);

复制代码

% i8 U6 o5 V- |0 a; m- N18.2.3 函数_init_box

函数原型：

int _init_box (
& `" G k9 O+ L& V8 ^0 a2 {/ l4 U; {
void* box_mem, /* 内存池首地址 */
6 T- p0 o4 H" J; @
U32 box_size, /* 内存池大小，单位字节 */6 C) |; M! |9 Q* S- k; ^) c3 b
U32 blk_size ); /* 内存块大小，单位字节 */

复制代码

函数描述：

函数_init_box用于内存池的初始化，初始化时用到的参数都是源自于_declare_box。

（1）第1个参数填写内存池的首地址。

（2）第2个参数填写内存池的大小，单位字节。

（3）第3个参数填写内存块大小，单位字节。

使用这个函数要注意以下问题：

1. 强烈建议跟函数_declare_box一起使用。用户不要自己去初始化这个函数，用_declare_box声明的才是最保险的。

2. 如果用户没有使用函数_declare_box进行定义，那么要保证内存池首地址是4字节对齐的。

3. 如果用户没有使用函数_declare_box进行定义，那么要保证内存池的大小box_size至少有12个字节，因为这个12个字节是用于将内存块做成指针链表，方便动态申请和释放。

使用举例：

#include <rtl.h>
7 ]5 L! Z* r2 e7 I# Z
- q& R9 V3 {$ y: a! c- i) q
#define PoolBlocks 103 A, q3 _! L; Y: O" U3 X
#define PoolPerBlockSize 8& ]) ^* {$ x5 f0 ?) |& o7 \
, l* m1 t$ N# y F
/* 声明一个内存池，10块，每块大小8字节 */
1 j+ {# v+ c) N' u
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);
3 z( }4 E* H3 v4 a
6 ?, m: W, x! {% c0 ]$ U
/*9 F- @. C8 ^+ K# ]: Z
*********************************************************************************************************
: l) t6 x: ~4 t3 y" k0 r& Q$ m
* 函数名: AppObjCreate
) b8 \, y5 B. T- D( }" j, f$ t' F* A- p
* 功能说明: 创建任务通信机制, v: t+ j5 e; ?/ J- M; c
* 形参: 无
" a/ B: p5 \; S7 h9 S
* 返回值: 无
) b: M3 J. Q! m( F+ W l% A: R
*********************************************************************************************************
4 ]1 h3 o* H& |8 s4 R7 x( b4 i
*/5 b$ v: Y- a3 ^
static void AppObjCreate (void)
6 b2 b6 y/ k. [& l( o
{ ! S/ F8 x X1 p k! T5 }
/* 初始化内存池，4字节对齐，*/
- c2 v$ D/ n6 k: n: Q
_init_box (mpool, sizeof (mpool), PoolPerBlockSize);
) N* e0 @8 L q6 G1 H" ]" }; i) c
}

复制代码

; K; l W3 K$ H% O
18.2.4 函数_init_box8

函数原型：

int _init_box (
! y5 g$ y$ g, u; I
void* box_mem, /* 内存池首地址 */
7 x3 c1 T$ u; C% {
U32 box_size, /* 内存池大小，单位字节 */
9 S& J0 b+ {1 [3 W7 Z5 V4 x
U32 blk_size ); /* 内存块大小，单位字节 */

复制代码

函数描述：

函数_init_box8用于内存池的初始化，初始化时用到的参数都是源自于_declare_box8。

（1）第1个参数填写内存池的首地址。

（2）第2个参数填写内存池的大小，单位字节。

（3）第3个参数填写内存块大小，单位字节。

使用这个函数要注意以下问题：

1. 强烈建议跟函数_declare_box8一起使用。用户不要自己去初始化这个函数，用_declare_box声明的才是最保险的。

2. 如果用户没有使用函数_declare_box8进行定义，那么要保证内存池首地址是8字节对齐的。

3. 如果用户没有使用函数_declare_box8进行定义，那么要保证内存池的大小box_size至少有16个字节，因为这个16个字节是用于将内存块做成指针链表，方便动态申请和释放。

使用举例：

#include <rtl.h>9 _" @% v$ ?) O5 d
6 y$ {2 S3 o: z1 Y5 C5 l' A6 Y
#define PoolBlocks 10) O) O1 O1 h0 F* n* o& `$ d
#define PoolPerBlockSize 8
$ k/ d. l" D/ n; b
$ B2 o4 S- ^$ [$ i. X
/* 声明一个内存池，10块，每块大小8字节 */9 s( l7 D7 Y7 \$ R( S& d Y
_declare_box8(mpool, PoolPerBlockSize, PoolBlocks);; @9 K9 W( m$ Q9 M$ k/ U9 N
, ^8 p1 M- v' i5 I8 O: }
/*
0 e( Z7 y" p @
*********************************************************************************************************
, V. c7 ^4 S4 {
* 函数名: AppObjCreate
4 X$ L; [) {! K+ i( n2 o; ^
* 功能说明: 创建任务通信机制
6 H% f- y# x6 e" ?
* 形参: 无0 O6 {( p; O8 c- b/ R, C b0 D
* 返回值: 无9 c# n: \& F# H& x, T) C# a, G
*********************************************************************************************************
. B/ z7 P* t' G' f9 G; |. ?
*/; _8 @: g# s$ n! N# v7 R3 ~6 P9 h
static void AppObjCreate (void)1 `; n6 k& G1 u, u+ }
{ 6 a, B) \5 n5 l) a6 y, a% A6 Y, z
/* 初始化内存池，4字节对齐，*/
9 g: h4 U$ y. a1 q$ N( @' O+ O
_init_box8 (mpool, sizeof (mpool), PoolPerBlockSize);
+ ]) f, K: D% |) M7 f3 s2 Z$ o0 [
}

复制代码

0 z2 g: H/ s' S/ ]
18.2.5 函数_alloc_box

函数原型：

void *_alloc_box (5 n; x) Z7 G* H8 Q1 g) ?% x4 x" f5 B9 N
void* box_mem ); /* 内存池的首地址 */

复制代码

函数描述：

函数_alloc_box用于从首地址是box_mem的内存池中申请一个内存块。

（1）第1个参数填写内存池的首地址。

使用这个函数要注意以下问题：

1. 调用此函数前，一定要使用函数_init_box或者_init_box8进行初始化。

2. 函数_alloc_box支持重入，而且是线程安全的，也即是说用户可以没有限制的在主函数和中断中调用此函数。

使用举例：

#include <rtl.h>
! e4 [4 I( M& N
1 P9 O8 B; S7 K6 j9 l
#define PoolBlocks 10
/ [- O1 H9 H7 h/ h, y/ c
#define PoolPerBlockSize 8- ~% K( w' i5 B7 u2 g: q( P
% }1 |5 a/ ~( ~* `+ O- l. B
/* 声明一个内存池，10块，每块大小8字节 */8 A) C& q# b7 ?1 ?: s, l- [$ X0 Q
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);+ l% v, f; H A4 b# v/ o
w8 t+ U$ Z$ D5 ?9 G8 ^# T
/*
9 c3 U5 w0 d% K4 D- M q* Z) L
*********************************************************************************************************; q: J1 c! J# k* O+ E" P+ o1 w
* 函数名: AppObjCreate
+ H& ~6 [/ k, |: ~' ~
* 功能说明: 创建任务通信机制
$ ?# L, t+ m6 Q" I! d
* 形参: 无+ [/ O' U, n* {2 g
* 返回值: 无1 a$ N; B% }/ Q
*********************************************************************************************************, M! W! n, d% P8 }9 p2 ?( d
*/
2 Y4 E. Z1 W+ B2 Q: U
static void AppObjCreate (void)
o' d \% }# k! }% ]; S* T1 p
{
6 L- b5 }( p* }& S. K
/* 初始化内存池，4字节对齐，*/
+ {1 [; m+ m' o0 ?# I$ f
_init_box (mpool, sizeof (mpool), PoolPerBlockSize);
0 N* d' o" b6 g* D/ g. N4 O
}9 y2 |* p6 h: r' `- t
4 B: Q4 p& i* @4 b" o5 X% \5 d
' {7 p- N. W4 T% ^9 T) r' J
/*
- V) h: u7 E0 I* i% Y7 n: J$ Z9 E
*********************************************************************************************************- \, |+ ]- n" [ g0 b
* 函数名: AppTaskUserIF
) ?( B5 l& v; c8 D: B9 Y
* 功能说明: 按键消息处理
/ m2 {- c: A) {9 L Y
* 形参: 无# A! Y. U( i& w: N
* 返回值: 无( [8 E. U- h; q& G6 S' Z) n$ G# e
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反)
9 Q9 M( ?9 y+ z9 H/ s+ H
*********************************************************************************************************
6 z, h) o1 p N- I4 i; u7 G7 X. ?
*/
! f7 U% I: W F, ]& ]( d9 P
__task void AppTaskUserIF(void)' w" z/ o( s7 x# F( Z- B
{
% [" r5 q; K4 {9 f
uint8_t *pucMsg; . x5 C& B) T" T3 ] h
uint8_t ucKeyCode, ucCount = 0;
! o& Q5 ]8 @0 Q% ]7 f H9 v
0 V( g9 |8 t+ P9 }" m
while(1)
0 E$ k/ o" J' F) @. W
{
% |1 x U8 s5 ~9 u( M& _% L
ucKeyCode = bsp_GetKey();
% p% l/ }1 @& t9 G% N$ X$ G
4 V y9 W$ o6 x. c {6 f
if (ucKeyCode != KEY_NONE)
* i1 h9 E: ?0 H
{9 V# m. c" _8 M, v! W7 N$ _
switch (ucKeyCode)
/ V' c8 \$ G1 ^% {! x( r& n" O- g! N: n
{
( y4 L1 ~ R+ n, l! h, K- P
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */6 s2 d# g% j/ ~8 x4 S% s) `* y& ~7 |* B
case KEY_DOWN_K2:) @( O+ f7 s0 \
/* 申请一个内存块用于8位整形变量 */
; D1 {* V! x [. f
pucMsg = _alloc_box (mpool);
|; \: `7 i: M( y* ^9 X9 L' @
*pucMsg = ucCount++;
; |3 V A. {* d2 r2 x/ r& S* u
6 n; F, S8 X7 Y; o( H! l# T+ y! V( v
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
" T( n/ p& @6 |" s% q7 z
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK)
! h* C7 `/ I! z
{
# K' \1 f/ ~+ [8 k
/* 发送失败，即使等待了100个时钟节拍 */
! S, ]- ~4 P& }; t" s
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
9 E" [% `+ p6 _! t: N, N% Q& }
_free_box (mpool, pucMsg);
; M, \. \0 T7 ^. w5 B
}' ~/ i! r/ B7 ` o% |
else
- t! ~) K P3 f4 H# P+ D$ ?2 n8 I
{
; d- p5 P$ p$ }3 }7 r$ T4 i6 W
/* 发送成功 */7 j% ^8 J4 m7 q4 m
printf("K2键按下，向消息邮箱发送数据成功\r\n");
! K( h) f; a) m9 u3 E
_free_box (mpool, pucMsg);
9 S: e& `- H/ L3 o0 g' {5 Q
}
& J# w2 j' e0 I# b' I
break;
7 \1 y. F% m# N
+ T( `2 o/ Q; ~1 t
/* 其他的键值不处理 */
0 p$ t1 e# H5 W7 Q4 q; t
default:
+ O% k7 r: q( k g5 h
break;+ L- r" U" ?+ k% |' k
}. p$ Q4 o9 E% E% {4 e& X* I! u/ E
}
: w9 x/ C0 W7 Z% m
% h/ x/ J& h' \- _
os_dly_wait(20);
# w. v: J2 |$ f
}2 c2 I9 Z, |1 ~+ f
}

复制代码

$ Z: \) U2 e1 B, r$ u4 X18.2.6 函数_free_box

函数原型：

int _free_box (
1 E4 h5 ^1 Y5 ^/ u, ]
void* box_mem, /* 内存池首地址 */# ^$ ~/ B9 m6 D, x3 }
void* box ); /* 要释放的内存块首地址 */

复制代码

函数描述：

函数_free_box用于释放使用函数_alloc_box申请的内存块。

（1）第1个参数填写内存池的首地址。

（2）第2个参数填写要释放的内存块首地址。

使用这个函数要注意以下问题：

1. 此函数的第二个参数必须要填写正确，也就是用户使用的时候最好配套_alloc_box一起使用。

2. 函数_alloc_box支持重入，而且是线程安全的，也即是说用户可以没有限制的在主函数和中断中调用此函数。

使用举例：

#include <rtl.h>" m @5 F3 D' x* n9 u9 B( m/ W1 Y
! I& S }0 d7 [( j8 e- D/ [
#define PoolBlocks 10' x2 R. c% Y; t6 e) N: p& q
#define PoolPerBlockSize 8
1 c% u( Z/ Z; C$ _ v! v! m! D
+ ~# i( _! b2 r9 G* U3 Y- H1 k' y
/* 声明一个内存池，10块，每块大小8字节 */0 _9 m8 B: m4 Q) y0 U- u, W _' {9 m
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);
" {) N& y1 M- F; G
6 Z$ `4 W h! {4 `2 ~: h# k6 `
/*
I3 Z, _) ]( M( R8 ]
*********************************************************************************************************' i1 ^. W8 z9 U* X2 f
* 函数名: AppObjCreate
0 o" J2 p: ^. Y( c. ^
* 功能说明: 创建任务通信机制
* F d4 n" E3 M% |
* 形参: 无
+ R% L' K# O: m% b1 h8 u
* 返回值: 无
6 D8 t7 \0 P4 @) |+ {
*********************************************************************************************************
( k% R# y7 ]8 [1 o$ o
*/! X; I, g, w: k2 Z+ N* F
static void AppObjCreate (void)3 b @& B5 z% Z
{
1 ~7 Q! w o) I% y; w! y. A' @
/* 初始化内存池，4字节对齐，*/; Z$ W) F) z% n
_init_box (mpool, sizeof (mpool), PoolPerBlockSize);
- d* j# P2 I* A0 R q
} T5 K6 n; j8 ]/ p7 m
7 z, i5 b N' L7 x5 l/ \
^1 X- q6 {7 H
/*
* j. C3 _* C0 v% r7 Z
*********************************************************************************************************
8 L- G0 y/ ?! W; q
* 函数名: AppTaskUserIF
8 e& p( Q' S1 Z
* 功能说明: 按键消息处理
# Q" C( s0 V& p8 |
* 形参: 无
1 y! E" @( `: r' r" \
* 返回值: 无
0 \% ]2 E6 P2 R8 _0 p$ Y
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反)
6 s( k! L, y: G i0 @
*********************************************************************************************************1 }' b2 }+ }* b/ @' s1 Z
*/% R, o# v- M! j
__task void AppTaskUserIF(void)% V V3 ^. ^8 g; P# T
{
; e0 b9 M" L9 l! z
uint8_t *pucMsg;
( a. `7 l, r2 A6 p4 L/ J& T7 H! `
uint8_t ucKeyCode, ucCount = 0;
% r; A6 I' G( J
* k. r& V8 l7 u$ H* d
while(1)' k/ g h7 Z: p" g5 |
{
6 E& R! y# V; g5 I5 v8 l6 B7 F
ucKeyCode = bsp_GetKey();
% V* e U, Y/ q- v3 K+ q& B
" p5 f% k/ \ y
if (ucKeyCode != KEY_NONE)
A7 T0 p( j; i# L
{
5 n* o7 h; P+ r
switch (ucKeyCode)0 V% y8 F1 X: ~
{" s+ g2 Y/ I8 K+ Y$ q% O3 `
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */. ]# X; \$ O3 O9 B# v6 i \* n1 u
case KEY_DOWN_K2:- W( S. C8 j# K; N0 ]+ N/ Z6 k
/* 申请一个内存块用于8位整形变量 */
% y- ~1 n) ^1 Z! j
pucMsg = _alloc_box (mpool);
) H3 z6 A- M W# \- D/ P& n
*pucMsg = ucCount++;
9 ]3 e/ ^3 W0 G0 t
" Y" I! l# u. g5 t; P; M
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
3 L; r% B/ i/ z" `, f( r! L
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK) T) u0 y" t& V" x" B3 D8 I
{
) |! V1 A8 N5 _. y2 ], f
/* 发送失败，即使等待了100个时钟节拍 */
) l' i: P, o' t: Y- o7 ?
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
& L6 l& O1 V/ R% H
_free_box (mpool, pucMsg);4 U' G. T" x9 Y) A
}- i7 T7 T8 D; B- Z+ y# q' G
else/ I, q" i+ M3 h: p4 O1 r. N" _, }
{7 h1 i; U$ \1 A
/* 发送成功 */
# z2 S' t' [- f- V
printf("K2键按下，向消息邮箱发送数据成功\r\n"); 4 i O% f( Z. ?% N( q6 u7 r
_free_box (mpool, pucMsg);0 m' {2 U& D* v4 h4 C4 Q9 B6 V
}
* v& }. c: r3 v4 ]. w4 X+ |
break; . J8 ^2 \& m d
* [# g% J; V4 \5 l; j/ n
/* 其他的键值不处理 */
: V( ~" J' m7 G. K* y
default: 1 F9 }, A$ Z4 `/ X( N0 S
break;. |! d! u! r5 x2 Q/ |8 `
}
3 Z% a0 c. c' n, _- \- H/ {
}
: d# m( y. t) {+ j
7 p+ X' K" S) `. D9 {: x
os_dly_wait(20);- ^% K2 B, L+ V8 e$ P& }- S
}( J: }2 q/ s) x8 V" d+ ~$ u
}

复制代码

赞评论

baiyongbin2009 回答时间：2016-2-3 15:38:39

18.3 实验例程说明(4字节对齐)
' H# E3 F. f& @9 L; }* O18.3.1 STM32F103开发板实验

配套例子：

V4-417_RTX实验_内存管理（4字节对齐）

实验目的：

1. 学习RTX的内存管理（4字节对齐）。

2. 函数_declare_box和_init_box用于4字节对齐的内存池初始化。这里4字节对齐的含义

a.内存池的首地址是4字节对齐（4字节对齐就是地址对4求余等于0）。

b.每个内存块大小也得是4字节的倍数，这样才能保证每申请到的一个内存块的首地址也是4字节对齐。

c.4字节对齐是由RTX系统完成的。

实验内容：

1. K1按键按下，串口打印。

2. K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据。

3. K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据。

4. 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据。

5. 各个任务实现的功能如下：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

RTX配置向导详情如下：

Task Configuration

Number of concurrent running tasks

允许创建4个任务，实际创建了如下四个任务：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

创建的4个任务都是采用自定义堆栈方式。

RTX任务调试信息：

程序设计：

任务栈大小分配：

staticuint64_t AppTaskUserIFStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskLEDStk[256/8]; /* 任务栈 */

staticuint64_t AppTaskMsgProStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskStartStk[512/8]; /* 任务栈 */

将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

/*
7 @( U7 d7 C7 j
*********************************************************************************************************4 e7 V2 l4 e1 Z6 b q7 U
* 函数名: main
W/ ] }( J0 e9 V w! `0 m
* 功能说明: 标准c程序入口。, t9 R8 G5 U/ y# i) x, X% K2 W) v
* 形参: 无
7 i- K5 T7 g1 c
* 返回值: 无
1 P7 O; X. w8 F6 p$ ~
*********************************************************************************************************4 O3 H1 W. p$ @4 _% J. H; B$ N$ U
*/- n7 i8 ]) B" ]9 k* o8 P; o
int main (void)
# ~1 U) D) O/ g
{
4 P+ b& }3 n4 x
/* 初始化外设 */. S7 F, f% k% K% B' ^; I
bsp_Init();
. c. y/ s) p) X2 y( _% ~) a+ V
, i, e" A4 h# m# o
/* 创建启动任务 */
0 `: M! I9 E; F' b* x: `& e
os_sys_init_user (AppTaskStart, /* 任务函数 */) ~: k1 S. L8 h# ^
4, /* 任务优先级 */2 L& o3 b* b8 R. X* C
&AppTaskStartStk, /* 任务栈 */5 N, v8 B: z, O
sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
& \$ x: V( H4 G: J5 c2 b- W' {
while(1);# \& L, g% p4 ~+ V- ]* A" o, F
}

复制代码

RTX任务创建：

/*
( {3 ^% e3 A) r+ Y9 X5 a
*********************************************************************************************************9 [- U. a/ a- T7 [! P' G
* 函数名: AppTaskCreate
/ Y2 M; p& ^$ i$ `5 |- Y
* 功能说明: 创建应用任务
# M8 f: ]! U: ?: C+ B0 G
* 形参: 无
- \* E7 i$ @5 _; f0 F
* 返回值: 无
+ H9 ^7 L$ R/ L- G$ E
*********************************************************************************************************
: Q" u/ g! a6 F7 \5 U& _' @- \
*/! T0 I" W' N! }4 ~/ o- {" {* o, o
static void AppTaskCreate (void): e ^. X2 _6 W1 @ L
{
' z" {2 |' F) J4 ^7 u
HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF, /* 任务函数 */
3 `! S/ n8 M; P3 k/ \! n- a
1, /* 任务优先级 */
2 y4 V; h+ m: U# d4 L1 @5 ~4 x6 f+ q
&AppTaskUserIFStk, /* 任务栈 */
* V, y- o7 G$ d2 S: }# H
sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
% O y* h4 J6 d A6 X. ~
/ `2 a4 V" c# N: a- S( |5 ~1 Y$ ^
HandleTaskLED = os_tsk_create_user(AppTaskLED, /* 任务函数 */0 Y6 |; e Y- r' T3 M4 R
2, /* 任务优先级 */
( `2 }* x: O) V6 v/ `1 x
&AppTaskLEDStk, /* 任务栈 */
+ u; d, e5 H0 P9 q6 @* G
sizeof(AppTaskLEDStk)); /* 任务栈大小，单位字节数 */
8 E- g8 a& v" p% `
1 ~1 g, P! l2 Q7 S3 t
HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro, /* 任务函数 */0 E- O8 Q, z7 R3 i9 I
3, /* 任务优先级 */% N. y1 @' k4 A. [1 m
&AppTaskMsgProStk, /* 任务栈 */+ G0 ~, L6 `7 y ]2 W/ u" \
sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */: {9 ~, ` h8 Q# J
}

复制代码

内存管理的初始化和消息邮箱的创建：

#define PoolBlocks 10
! d; q3 W7 i. k2 F O+ D$ m9 [
#define PoolPerBlockSize 88 d4 u( } R7 f8 n4 ~" H
( _: h- f- ^! m, z8 Q
/* 声明一个支持10个消息的消息邮箱 */; ~# {. G2 b( \ V) H, X! G- x
os_mbx_declare (mailbox, 10);$ l- n2 L O; L/ f
* S0 J( K. c8 x1 M
/* 声明一个内存池，10块，每块大小8字节 */
8 M6 x+ j2 e' W* p- ]
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);' m4 `0 v7 e; j3 m' [: b
) y5 [2 u- [( k# @0 {, z
/*$ p# O6 ~* k4 C% j- S3 J. f5 X- g
*********************************************************************************************************
# v; O4 N* F) k. c) O- k
* 函数名: AppObjCreate5 c2 B3 K, N# b6 g
* 功能说明: 创建任务通信机制
% G3 J9 p1 d" `0 }! ]6 P5 K3 s9 d
* 形参: 无
- J8 U1 G8 i/ s m5 U% X& P
* 返回值: 无
% _" s3 B. e( s( e
*********************************************************************************************************
! Q u1 H* u1 N0 c1 c6 a
*/
/ J+ K4 }) I$ r. Q( C2 s
static void AppObjCreate (void)
3 o; X3 S( `. V* l: `6 n& K0 O4 _& ]
{
7 j. q# s* y7 }$ ~5 A' W
/* 创建消息邮箱 */
" X9 C& Z9 r w V& B# e: e( S
os_mbx_init (&mailbox, sizeof(mailbox));* n! @7 g- n' Z# i2 r& f
8 p" t6 j* w2 E4 T9 o" _+ }
/* 初始化内存池，4字节对齐，*/! D! W: [- |$ ^5 U: b8 |' O
_init_box (mpool, sizeof (mpool), PoolPerBlockSize);' w3 Y3 `) I1 [) h
}

复制代码

四个RTX任务的实现：

/* |6 p) J' O% j
*********************************************************************************************************; S) V$ m: D! f
* 函数名: AppTaskUserIF: Q2 o: f6 b$ d* V
* 功能说明: 按键消息处理
& O* l1 g% W- W/ x
* 形参: 无
% Y: e" Y' e9 A; Y5 b
* 返回值: 无
6 Z' ^- ?6 t' H4 }7 P
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反)
+ X, x: d+ p4 M' R
*********************************************************************************************************+ o# N% v& s+ S8 L, _1 }8 a4 B, b
*/5 P5 P) O+ J4 C* M# | B4 c2 i0 ?2 y
__task void AppTaskUserIF(void) W6 ~% a2 y" b" Y
{
1 l5 X) Q5 d3 _- R8 ]; M- J; H8 D
uint8_t *pucMsg;- ~/ c0 m% p. K+ b
uint16_t *pusMsg; c' a2 N! L' }' L% m
uint32_t *pulMsg;% w. C+ k! c8 I+ W% x. E2 U! L/ e0 u% A
uint8_t ucKeyCode, ucCount = 0;
d& l x8 s" _: m$ c2 F. z! K
! ], n" B: r4 {6 a3 H
while(1)
; S0 q% a0 _+ g) W3 u
{0 K8 P5 z' H8 S
ucKeyCode = bsp_GetKey();
; x9 O) W8 M+ J2 B( J* R
# g; l9 u! C+ D4 z# D7 P& g% f
if (ucKeyCode != KEY_NONE)) j% p! ^8 O4 ]6 }) C4 F. n( q
{
3 n3 f$ O5 u9 K1 S
switch (ucKeyCode)' P5 k3 v5 G4 D6 k7 c& j
{
: @/ [, N0 ^: L5 }' J" `% t
/* K1键按下，打印调试说明 */6 ~0 Y2 A9 Z' ~: s
case KEY_DOWN_K1:* J% @7 m( G* q
printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");, F- C& f6 m; B. `& d
break;
. v5 c' i, ?7 ]
0 V( `1 X* i ?4 B6 S6 i& v+ Q
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */; x% E' A* U4 C2 E/ U% C
case KEY_DOWN_K2:
/ H7 o, D: O3 P- V# Q4 _
/* 申请一个内存块用于8位整形变量 */
7 Q% T% W! O; K
pucMsg = _alloc_box (mpool);/ t8 _9 n; i+ D0 G
*pucMsg = ucCount++;& X/ F6 Y! |/ F
6 J7 ~7 \% E: V, h% ?+ A* H
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
- R5 l, Z' x0 w( J% U
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK). u2 t6 `; n( x7 G
{, ]( S) f' _$ P6 T
/* 发送失败，即使等待了100个时钟节拍 */
" O- i; X5 [; b8 A% R9 `2 G$ T
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
9 I# ]& L& w" r6 f2 a" u
_free_box (mpool, pucMsg);% \# B# }$ O) G. \2 E/ A# Q: Y& K" L I
}
* w+ `- k! \% a/ ]# c$ P
else
0 _* ~& _5 U0 c9 l U4 Y* Y
{
0 E; f+ R+ l! K, t
/* 发送成功 */
# r: n2 M, Y2 x; O5 `& ~8 s& t
printf("K2键按下，向消息邮箱发送数据成功\r\n");
, j' ~2 ?' Z' p) |
_free_box (mpool, pucMsg);
. u \- \/ v7 r0 M; X" D
}' C. l: I7 w, P) M# |& T
break; 5 n2 i; z- K' g9 U F1 l/ x( I
+ n3 t5 a9 p: D* Y+ d& `! F$ C
/* K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据 */* \9 W' g0 J$ Q- W+ \$ _
case KEY_DOWN_K3:- N' r4 ]/ Q: ^
/* 申请一个内存块用于16位整形变量 */% Y. ^9 o. e s, g! e
pusMsg = _alloc_box (mpool);
8 \4 s$ Y: e R% i& Y/ ]; \' g
*pusMsg = ucCount++;8 s/ Y9 V* o3 z- B+ C0 y3 a
( m0 _: n6 V3 F7 Z; p0 r
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
/ E( w/ O7 V% a# P$ |! P: N4 K; k0 z
if(os_mbx_send (&mailbox, pusMsg, 100) != OS_R_OK)" j2 ~) q* Y# W& b5 T3 C& ~. H1 r8 F
{
7 I) C2 ^8 p5 P7 X8 ? x2 P2 e- k
/* 发送失败，即使等待了100个时钟节拍 */7 N- E" K- v m `8 y! M% C a1 [5 w
printf("K3键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
4 h2 D; g# b4 M0 O ]
_free_box (mpool, pusMsg);% O" Q' T& T6 G3 V0 F" h x8 i
}
5 Q6 r1 c3 i: t$ M. K4 s
else1 w" [$ S/ J+ q6 u' E! m
{8 H9 q+ u# x8 b2 ?2 c
/* 发送成功 */4 e6 D- j! G; I. s4 U
printf("K3键按下，向消息邮箱发送数据成功\r\n"); 9 [' c( b( {9 `. g k; k
_free_box (mpool, pusMsg);1 D @: w ~9 f& H8 v
}
# C& O# e" N+ G$ C9 t% ?( g3 o
break;
; p3 z# ~) w/ x) C# O- [
/ g/ }/ R, ?0 U
/* 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据 */, ^) ^4 R1 W0 v
case JOY_DOWN_OK:
) B* }, c$ s l p+ Z3 W. H
/* 申请一个内存块用于32位整形变量 */
% ~3 \: V2 v$ D
pulMsg = _alloc_box (mpool);
& O$ d" N6 n2 L& A! p
*pulMsg = ucCount++;
' Y' l) N0 l" @! g. ]4 H
3 H. J, m8 S$ k2 E
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */# w* g. y5 N# T( e) Q" q/ M
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)
C! }( F9 v/ ?/ x
{
$ v" f2 g& g& L$ G% A5 N; L4 Z- w
/* 发送失败，即使等待了100个时钟节拍 */
& _0 N* t* a+ P, e$ a; y
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");8 |( q3 x& c* }5 K
_free_box (mpool, pulMsg);# T+ t0 G/ ~/ A4 G6 \
}- c: j0 U3 M( h& y& G8 q( K
else2 _, A# Q: {! U, n
{4 D* q# x- _) s7 O. f2 g' k
/* 发送成功 */7 `, A" i e5 \- ~
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n");
7 J/ q, x7 a" k( C- |
_free_box (mpool, pulMsg);
6 P8 {# w# K, |' {
}
. ]* T3 a! q. x/ n9 @ P& m
break;
# f- ]. V) x4 D# {( b
5 n& K0 Q# g6 z5 ? E
/* 其他的键值不处理 */2 `4 j) \ T+ v. g7 ~. v
default: * }% M0 v+ u+ |' f% |0 e" d
break;# e' n1 r) g( i5 w( v3 D2 _
}
) N! L0 `! p" {0 d c/ Z& V& `
}
5 v6 W- `3 N+ K2 v s: u8 t( n; T, w
0 z. @6 F! ?8 G$ e: s$ g5 ~
os_dly_wait(20);" a0 B# g0 _" r& v: n& t9 ]4 u
}
1 C' ^8 {% |; e
}( J8 T% G0 q, s6 N+ ~9 B
4 ~ @+ } e. _( l8 ~* S
/*( l. L- }( Z! D
*********************************************************************************************************" d1 I( H e) y- [
* 函数名: AppTaskLED
( U1 V5 ]/ B* c
* 功能说明: LED闪烁。& z+ S. K- m) r# V
* 形参: 无7 L( z! d0 c- ^# I) Q3 g
* 返回值: 无$ |" g8 |9 C3 p5 I
* 优先级: 2
! f7 Z$ x7 h# P8 [) ^
*********************************************************************************************************
/ ~0 Q8 q9 H, Z; a1 y- ?+ p
*/
5 U( C3 X8 E+ N) @5 g- o3 }! x
__task void AppTaskLED(void)
* \+ {- P4 i) m% F" G
{$ V+ Z! t- U1 u' P0 Y* E2 I! w
const uint16_t usFrequency = 200; /* 延迟周期 */
9 v3 H3 V6 G, u# @! g
( ?; U! y6 _- P9 m; T
/* 设置延迟周期 */: x* p0 p1 Q* \) g; o7 C
os_itv_set(usFrequency);
; R% u$ F/ y3 p6 K' a
* x5 `; Z7 K' \2 F- p$ h9 e5 S
while(1)
. B$ c& J, d% Z
{
$ E7 p) K8 V9 [
bsp_LedToggle(2);6 H9 E9 E0 A1 {
bsp_LedToggle(3);% X( z6 Z+ x( a% G5 Z
1 C, S, `. p7 V+ Y+ i. {8 T
/* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
: ^4 X& P7 E7 `: R, W
os_itv_wait();
z6 a5 M0 E; C9 {4 g$ s% n
}: A: A9 |1 t: j7 o) u" j) K) J" U
}
4 `: t/ W. v* u6 f6 {
" x2 z; _1 B0 Q6 [* v7 H0 `
/*- W; Z) Q2 q/ t2 T* a: Q% h
*********************************************************************************************************
* ?3 s! B. y& y
* 函数名: AppTaskMsgPro
& b( r2 l: q& a& c1 h
* 功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据
9 B. ^" ]) ~! F% T. e+ D; V! j0 \
* 形参: 无
" W L4 p. Z9 S. \- v
* 返回值: 无
4 h* w, N6 L" D0 D& F' o( T: Q
* 优先级: 3 9 K& D1 S: M2 d$ _5 N! W
*********************************************************************************************************
( t8 o" ]) \* r/ P% X0 ^9 C1 _) E
*/( |. p+ [( r) X1 p& n/ ]$ i
__task void AppTaskMsgPro(void)* E; X: e3 X! k, M5 f% ?: r
{' ^/ J7 c2 r. s% h% @5 O& E
uint8_t *pMsg;) x" S0 ~& A, H8 k9 e- u1 {
OS_RESULT xResult;/ H' |! }$ c# R2 v# Y1 J0 L
const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
D- X1 {$ K1 j; F+ D8 w" H+ H' S; l
3 E+ x/ u2 G7 q9 z& _. a" h
while(1)
! J' z% z4 l) n; D) K5 J& d, c: v
{
% J8 d! c# K( C. h* P% X; d6 X
xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
! ~# y V8 m# l2 v! J
3 K% y# X- v ~$ v+ V
switch (xResult)" L" u$ C1 g& l u. m7 Y* D! H- Z+ C
{3 u8 V$ r: l9 |$ h( {8 f
/* 无需等待接受到消息邮箱数据 */' U1 g1 e8 z# ~" T. W1 H: L
case OS_R_OK:
4 G; C$ Y% e8 o0 J# P& p
printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
$ C! _; M* D" b( g( ^
break; , [, @' T) G8 H. ~) F6 d
1 e# B2 z) P* w c* v' ?# J. c
/* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */. _4 Y) F) K' |/ n3 o: g0 Z
case OS_R_MBX:; H' U6 A8 R: n" |3 D$ s+ n
printf("因为消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
$ C# G* O' S% b0 V, B! t
break;
( U+ C: _1 v8 j. G
* _/ G0 p4 e& b% J5 D( \% N3 s
/* 超时 */
! K5 J' E5 d* w% T. m
case OS_R_TMO:
3 g4 b+ r+ b7 u+ G( J( A0 e
bsp_LedToggle(1);
( h, h* N9 R5 b% {
bsp_LedToggle(4);( S9 e W; \4 S- H; l, b; V
break;
+ C! A5 `. u' Y0 {
( O7 l2 ]5 X8 y. R3 S* P! O
/* 其他值不处理 */
. S. w% O4 ]! V3 z
default: \' U, u& B0 B2 o) i) ]6 O+ \1 w7 \* z
break;
* X4 t, j5 i) f$ r; T% D0 o
}
, B" R& f- G1 Z; _" v
}( O/ q9 J5 J( F% A' c
}! H3 P" w$ h7 u; t- x7 @/ o
3 |& @& c: R) K, m5 s0 n+ \5 G
/*, s3 g+ e0 [# @# z: o) ]& U
*********************************************************************************************************
, ]/ r4 u/ z" ^6 i) A8 a% k
* 函数名: AppTaskStart
' n' _' m% t7 J
* 功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
& H5 x/ ]$ ?+ b! o9 G2 E! r* \
* 形参: 无$ m! ]# b' o0 W4 H% ^- V
* 返回值: 无( i5 Q9 I: s# p) v5 [6 F! ]' M
* 优先级: 4
% D& s/ K7 Q- S+ X- R% G
*********************************************************************************************************( E; J8 [ Z7 D% d3 y
*/
- F# \: G/ Z* d5 d) g. E3 j$ K
__task void AppTaskStart(void)
+ l1 h* Z- R5 j
{
; i2 ^, b( g5 _! |: p* |4 l) M- x
/* 创建任务 */
: t3 K& z& x( r, [$ E, M5 R) q; C7 b
AppTaskCreate();" z' ?- J' [0 c5 \3 r
W" U1 s: T# Q; a6 g/ v [
/* 创建任务通信机制 */
2 T' r/ f, t9 @; w5 r* ?4 I
AppObjCreate();
( f" K1 c( J6 _
. y; o2 f3 Q4 \: }( R5 @9 n
while(1)
{
3 k" C% }5 s1 T3 X' B1 ^
/* 按键扫描 */4 u% C) @5 b) Z
bsp_KeyScan();6 D, G+ n5 y$ X: R5 W. R
os_dly_wait(10);0 A; T6 ~* j- ]: T4 I( ^* x" ^. Y
}& N9 ]% M6 k8 ~+ ^9 P4 k F
}

复制代码

# d! z- V7 c: e, q! s# V! h u3 a& |

赞评论

baiyongbin2009 回答时间：2016-2-3 15:43:10

18.3.2 STM32F407开发板实验

配套例子：

V5-417_RTX实验_内存管理（4字节对齐）

实验目的：

1. 学习RTX的内存管理（4字节对齐）。

2. 函数_declare_box和_init_box用于4字节对齐的内存池初始化。这里4字节对齐的含义

a.内存池的首地址是4字节对齐（4字节对齐就是地址对4求余等于0）。

b.每个内存块大小也得是4字节的倍数，这样才能保证每申请到的一个内存块的首地址也是4字节对齐。

c.4字节对齐是由RTX系统完成的。

实验内容：

1. K1按键按下，串口打印。

2. K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据。

3. K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据。

4. 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据。

5. 各个任务实现的功能如下：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

RTX配置向导详情如下：

Task Configuration

Number of concurrent running tasks

允许创建4个任务，实际创建了如下四个任务：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

创建的4个任务都是采用自定义堆栈方式。

RTX任务调试信息：

程序设计：

任务栈大小分配：

staticuint64_t AppTaskUserIFStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskLEDStk[256/8]; /* 任务栈 */

staticuint64_t AppTaskMsgProStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskStartStk[512/8]; /* 任务栈 */

将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

/*2 [. L' i) p8 [* V0 i# a
*********************************************************************************************************5 i3 _: L* r; I, v9 J7 k
* 函数名: main! x- U- ~7 m4 d
* 功能说明: 标准c程序入口。 I6 N3 @% N: r; t
* 形参: 无- s r! T9 b) z$ @
* 返回值: 无
, s9 R3 r; w$ E; D5 Q. }$ m7 n
*********************************************************************************************************
4 U) d1 {- @1 b5 P* n
*/
- n% v6 t6 V" V
int main (void)
+ i9 v2 c$ R! A+ L, E
{ ; o8 B0 _6 t8 \8 x8 M; |* v% z
/* 初始化外设 */
' g2 h: W8 E& u4 q
bsp_Init();
5 R3 l! P# h, Q9 S. D/ O
x& |& i4 x% V% Z) S
/* 创建启动任务 */1 {% S8 p: ^/ k D& N$ K
os_sys_init_user (AppTaskStart, /* 任务函数 */
0 g: G" f4 y% ]3 u7 ?6 @
4, /* 任务优先级 */$ e( M; }* Q: X- p6 A" P, X/ j
&AppTaskStartStk, /* 任务栈 */
- Y& D* ]' Q! L) r9 ]
sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */9 B$ @ Y n# ~! u3 f
while(1);
9 \' \8 Z. m# a- t9 l
}

复制代码

RTX任务创建：

/*/ W Y/ Y k- r
*********************************************************************************************************
7 j# Z2 j/ J$ J+ b$ |! P
* 函数名: AppTaskCreate
' C$ J4 b: R. q& H3 q+ c) [$ H; x
* 功能说明: 创建应用任务
+ Y8 |8 O3 A7 ~* `/ T
* 形参: 无. M+ y( d# p& F, U6 @! r/ n# {. j, }
* 返回值: 无% w: f& T7 y- N: h) k
*********************************************************************************************************
; l) Z' {( o; d+ N
*/
; [ |% Y/ j/ r
static void AppTaskCreate (void)
- c& J1 |7 A. z) ~; p
{
3 J' z& H( Q: P5 O) T7 Q
HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF, /* 任务函数 */
5 a6 O/ A( E$ A+ p8 Z! d& U% K) F( F8 v
1, /* 任务优先级 */! |$ P3 O) }# e" y& p, b) `
&AppTaskUserIFStk, /* 任务栈 */0 t$ j* Z- q# R1 m7 ]; q) I# j! \9 \
sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
2 v3 V) O; c+ Z0 S1 O' z
! A& Q- m) @/ }: p8 N
HandleTaskLED = os_tsk_create_user(AppTaskLED, /* 任务函数 */; }8 ^- G3 {6 r3 ~) P# Y% T
2, /* 任务优先级 */
# ~$ U9 ^% S Y) {( @6 U
&AppTaskLEDStk, /* 任务栈 */& ]( Z7 D/ Z8 ~# l+ M1 ?
sizeof(AppTaskLEDStk)); /* 任务栈大小，单位字节数 */1 [# K5 ?9 d# _/ z3 n' d2 l
9 u9 s+ P* b* T( g# L1 ]6 {* w* s
HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro, /* 任务函数 */
0 W# d/ d7 s2 ?5 e: f
3, /* 任务优先级 */ ^5 |7 y/ N$ v2 @: L# b, q, B
&AppTaskMsgProStk, /* 任务栈 */
! |$ b+ ~2 S' M+ c' C9 ?
sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */( ]4 e& `1 `! f2 l! E+ J6 q
}

复制代码

内存管理的初始化和消息邮箱的创建：

#define PoolBlocks 10& t. ]+ o. Y4 W# d
#define PoolPerBlockSize 8
{* `( S" [6 A7 X: `! d
5 y/ `8 E6 [4 `# O' [; R4 c: e. c
/* 声明一个支持10个消息的消息邮箱 */
+ j7 b5 c ~, I& U8 }& J. p
os_mbx_declare (mailbox, 10);
' ^, c, b$ z( D" r4 a- z
7 P- n: n' o( P( X
/* 声明一个内存池，10块，每块大小8字节 */# S7 @8 V( Q: S+ K2 Z8 Z% v" n
_declare_box(mpool, PoolPerBlockSize, PoolBlocks);6 Q o6 I7 {) L. q- I9 c( Q& s
9 \+ x* O* ?/ @2 ?0 j& v. M7 G# b
/*
6 v, o6 L) N% w0 w5 J
*********************************************************************************************************9 U' B- t8 [, K N" I* F
* 函数名: AppObjCreate% A/ L" j1 ^6 N/ h+ W, j
* 功能说明: 创建任务通信机制
. ]7 J) @( l- u8 g- Z! H0 E: |. v
* 形参: 无
% u; n# Y \( ]2 `1 f) y. X Y
* 返回值: 无
/ v' ] b! w- i# [: ^
*********************************************************************************************************( K' t0 C+ a* U( I5 I+ ]" y3 Z
*/: j' Z8 T7 Y! Q
static void AppObjCreate (void) ^) A9 Q( t R. K0 D* p6 G
{& g- n2 k& u* z& r7 V
/* 创建消息邮箱 */9 ?9 e& Z+ `$ L# U% a% g5 q' s N
os_mbx_init (&mailbox, sizeof(mailbox));9 J2 t# a% |6 U" r: q
0 d1 F/ B {6 J
/* 初始化内存池，4字节对齐，*/
3 }1 u2 p4 ]* l, |" C0 v8 n
_init_box (mpool, sizeof (mpool), PoolPerBlockSize);+ j3 `9 b7 Z6 g2 B
}

复制代码

四个RTX任务的实现：

/*
0 E6 @9 f4 V5 X+ ?% p
*********************************************************************************************************$ q7 i, s8 \; {* W2 z/ j% T3 z
* 函数名: AppTaskUserIF, ^' I# ]5 q* e8 F
* 功能说明: 按键消息处理
' D* `4 o. l% p2 e
* 形参: 无
' Z# U0 S, Z+ F6 ]7 ^( m3 x1 y) x
* 返回值: 无3 h6 n5 B' F* J, [4 W# u
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反), a, X) C$ F% j+ b% b
*********************************************************************************************************
- R% W' H0 n/ p- N* u
*/+ d( b' \- x/ E# X
__task void AppTaskUserIF(void)
+ p5 m; `9 f. [) U* p* N3 m* r
{
8 f# j- H0 c9 X# u3 P
uint8_t *pucMsg;6 o$ y7 u8 ?9 d, |4 A0 {
uint16_t *pusMsg;
2 s( n+ w( Q. v- b; `. i7 S" H
uint32_t *pulMsg;
* o) M5 t9 p7 W
uint8_t ucKeyCode, ucCount = 0;
# v7 K5 A8 ~7 q2 a
7 @+ G$ E% ]1 v4 y' v( D
while(1)
- g; z6 Z8 o6 q& A$ b) X$ c) h
{
9 d0 e1 h# K8 y+ A- O
ucKeyCode = bsp_GetKey();
4 j1 T q9 V$ e! F
: a/ G5 U& S. X
if (ucKeyCode != KEY_NONE)
6 E3 a4 y7 E, q# o2 b! @ W S
{
% F8 @3 Z; a7 t; B4 }/ z: w
switch (ucKeyCode)! T% x' w5 ?& }7 O. {
{$ G- v8 m1 ~- C% ^
/* K1键按下，打印调试说明 */
* l) f6 z# A# W1 R7 E
case KEY_DOWN_K1:( _+ I0 o8 K- ]0 ]" I
printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
! `4 C3 ~9 e; u9 x! U: M
break;
1 ~: I$ H6 z+ W5 c1 L$ `
' l! X' w+ h+ P# ~% t7 e
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */
' Z, q) l5 u. Q) W0 q
case KEY_DOWN_K2:
% M# T; I N$ C( p5 K
/* 申请一个内存块用于8位整形变量 */
% O' T$ y1 |- |$ } N& J# T: P
pucMsg = _alloc_box (mpool);9 w8 |9 [) k5 p& r: ]) P6 P
*pucMsg = ucCount++;) Z+ |5 m9 c9 j( O
, d' w* v' H6 j/ n$ C1 F# a
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */& f6 b6 r) ^( D3 o
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK)
|5 x0 I1 U9 g# B0 f ]; Y
{5 w+ k* U+ J$ {* ?: q! B
/* 发送失败，即使等待了100个时钟节拍 */
% b$ {6 a1 A; {2 H, Q9 q @7 |
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");. e% ?# s. U! b
_free_box (mpool, pucMsg);* l- V9 R2 ~, X7 g4 ?/ b2 Y+ o
}) R% M+ Y# F1 s
else, ?1 B* a* N8 V+ D6 n, z2 J" T, z
{
S4 g; _( P/ ?' y
/* 发送成功 */: A: Z" O6 d2 B+ ]
printf("K2键按下，向消息邮箱发送数据成功\r\n"); ! d) D4 V) Y' ?) v
_free_box (mpool, pucMsg);+ f$ g: e( ]$ i7 y- ]
}5 I" Q3 ^( L w
break; $ i. B* E* G* ^+ t' T+ H( R
. E" t5 i! X/ o5 ?3 m/ }
/* K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据 */
& G9 Z: i' u8 W& h
case KEY_DOWN_K3:
/ {' a3 v I5 D. @
/* 申请一个内存块用于16位整形变量 */) C. i4 j1 {- i
pusMsg = _alloc_box (mpool);
1 C0 O y# Z: N' D# _8 u1 K. d
*pusMsg = ucCount++;5 _$ S& Q p C( \" J
. [) E) |# V" u$ W" {* [
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
8 o. q0 c5 ^. K4 H# m9 l
if(os_mbx_send (&mailbox, pusMsg, 100) != OS_R_OK)5 f0 @2 K3 C1 z2 T+ b
{+ h6 y2 P- i. |
/* 发送失败，即使等待了100个时钟节拍 */
* ?* l) ]5 H( a: R+ D$ j6 e7 q( w
printf("K3键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
/ J$ B; f: h3 A$ M/ `7 [
_free_box (mpool, pusMsg);
: t( t) C$ B+ _0 @5 }) I- O
}& B2 Q: Z3 f9 m( ~3 T" q6 s
else
+ B! Z x, Y Z
{4 A# ?. w3 J4 D' t( M
/* 发送成功 */$ K0 F$ W( v3 o) ^ y0 n. ?- z5 I
printf("K3键按下，向消息邮箱发送数据成功\r\n");
* z5 I# V' g q9 @4 Y
_free_box (mpool, pusMsg);
$ x) x& @ n% M d7 `( b% t# x9 G
}
9 s1 Q/ f, R6 s; G, A9 \
break;
4 e4 K- j, L$ `5 Q
1 r3 a! y( I3 [3 y. @/ {
/* 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据 */
& J* u' p$ A5 S# y7 S
case JOY_DOWN_OK:3 }8 |3 c$ r+ G
/* 申请一个内存块用于32位整形变量 */
0 W" T, l* b7 ^: ?" m3 h K
pulMsg = _alloc_box (mpool);
4 V( W1 v) x! o8 r' R1 r. J7 d
*pulMsg = ucCount++;
9 B6 L, O) t8 V4 _+ _
! q) F& A V/ J ]% e4 E% b
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */6 T$ g( L" b- B( M6 x, o( c$ j& `
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)
3 I. j* U1 {& i, M& x( c, N
{
0 G* m% T) K6 R# v. a
/* 发送失败，即使等待了100个时钟节拍 */
! L* m; H7 d8 \
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
3 L- S5 d$ p; V8 F+ Q8 e
_free_box (mpool, pulMsg);
- @: Z% {7 H5 N, l
}, _, t" \( k* y7 [* Z
else
! I3 H/ e6 G2 I
{# V" Z/ C0 n) A- b* z; y
/* 发送成功 */
1 [; f1 J2 [. U) |% z
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n"); & q' p8 N. G% g' s4 a
_free_box (mpool, pulMsg);" I' r; d( M0 q4 F7 T
}% |6 Y3 w- Y) m8 J) A
break;! J% M2 b) j- [1 }
1 {' w; d7 l$ p6 c: a9 ?
/* 其他的键值不处理 */" ~: V/ q$ _9 }
default: 7 W U+ c- Z: [' Y' y* W. Z
break;! b3 J2 b$ c! B _# e+ B6 I
}
; w @6 l: [$ k' n
}' F7 U" Q" y7 I" [
% O% _$ H* ]9 ^$ N2 v
os_dly_wait(20);
6 W8 p% D2 k: U5 V4 M" E
}
& ^, k! N5 a% r4 e D0 B
}6 V8 q4 @ M4 `; ~2 t) ^0 ~
7 y4 [) V) F# l: G- f
/*
3 ^* _5 G% H6 c) D8 O
*********************************************************************************************************$ j: k g3 C0 ^+ p
* 函数名: AppTaskLED$ c/ x: A3 V) F+ J1 q$ M) M" f1 \
* 功能说明: LED闪烁。
H; h! _9 ^ I+ j. {
* 形参: 无& p0 P1 B; Z" Z* C8 v
* 返回值: 无
2 c# j, n' ]- H3 |' S( ?' Q; n+ w9 I& v
* 优先级: 2 + `* p4 |; a4 B( s! i6 a
*********************************************************************************************************
, C# h6 Z! i7 ]4 b1 y( V
*/
: ~' |) V( Q6 Z R+ D
__task void AppTaskLED(void) s$ z9 n9 z% |; e5 a1 [
{- O1 G4 C* C8 N% V7 T! `4 B
const uint16_t usFrequency = 200; /* 延迟周期 */5 m% L. Q: t, I; [1 d
) S2 ^) |+ [: P& O9 {( _0 t
/* 设置延迟周期 */
' M# q% H- g& y" g# ]% L
os_itv_set(usFrequency);
$ ~7 q* q9 R$ ? w
" q2 w$ M8 N5 r+ ]' F; T e
while(1)4 Y0 Q8 Z# [* M+ x o- k/ x
{
% [, }" \6 ]) z$ B* |
bsp_LedToggle(2);9 L) O, R" ?8 |8 c
bsp_LedToggle(3);0 `6 L" H1 W+ u% ?& r5 j5 S
( I! ?! ], f, }3 W
/* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
: F. H7 D3 @4 l' |
os_itv_wait();/ c$ w s; v, m; N! D6 Y- Y9 \; v
}4 ^/ T1 L2 m' ?5 M9 p
}2 L4 J3 N a; J K) a
6 K& b7 S5 `* n0 M5 L
/*! u5 _7 }0 G3 @
*********************************************************************************************************
, f& W* |% C- _* {$ h
* 函数名: AppTaskMsgPro$ I6 L B! ~0 w! p- w
* 功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据2 ^3 x( |9 P3 J5 R) B% l$ \
* 形参: 无* ]$ { k: [4 D: V4 s7 _
* 返回值: 无) Z& S6 b9 p9 x3 p
* 优先级: 3 ; i- _' Y1 g+ I, V1 _2 P! R" v
*********************************************************************************************************
! R6 }$ f5 y, @& ]
*/8 }4 ^' h* q# Z. G! p
__task void AppTaskMsgPro(void)
% ?/ n. Q6 l5 x: q _* L
{
7 C8 D D% v0 H# }1 s( |6 L
uint8_t *pMsg;5 V- Y7 g, N& g, \# V) x
OS_RESULT xResult;
^, n% {: b/ P9 L
const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
5 c. Q: ]0 [% k& a( R) X8 R+ `
/ j6 p/ }- r" D0 ~
while(1)
+ V4 j+ Q Z* q7 ]1 y) T
{ j3 R) k) I/ T- x( e8 l2 w- D
xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
3 i' g9 N; i; E& k' h+ ]9 h# j3 S
3 c* m; N) e! ], v2 g
switch (xResult) m% O H0 S6 ]% g! U E% v& F$ C
{
2 b8 g) J" a3 E6 ~
/* 无需等待接受到消息邮箱数据 */0 Y- Z- N) R5 ^0 c7 o
case OS_R_OK:
/ Q" D/ V( B9 o5 B4 @
printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
1 Y, o6 o b/ ?& {* Q! R
break; 8 {4 C8 G4 A1 l8 d5 c: {
J l9 r1 k* O6 z; [! h; S4 J
/* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
; Z4 X2 }0 D6 C9 I
case OS_R_MBX:
( i9 c' ]9 z: i5 \
printf("因为消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
7 g. J$ }, u4 @( t0 r/ r' J1 b3 G- _
break;
: t; K0 K! U9 h' ~- l% D7 `
1 s3 r+ K. D0 k3 }3 q
/* 超时 */5 T7 R2 u/ g j; g* m
case OS_R_TMO:) N, Q5 c4 j2 U# L$ Z' u7 a, j
bsp_LedToggle(1);3 O* Z4 V) d. s& a
bsp_LedToggle(4);3 W1 f! ?7 y4 T) a* w: c8 L
break;9 V. P1 E. Z3 T, N9 G0 u
9 a# Y; s4 @5 W+ R
/* 其他值不处理 */
U3 s4 `. T7 ?) o+ S
default: 1 F+ T+ ~+ f( X# ?( K/ _& ]
break;; W5 W# g j2 j
}
. @0 [; |. k& Z- `! Z4 l+ v2 ]
}' W# g9 R5 ]7 c/ m: x, m) b/ {
}1 ~3 B3 v6 f9 L
) S2 s* l! n: n: o: p
/*
8 K: K, L; y6 ^- Z/ U
*********************************************************************************************************7 f- h# P5 I0 q' O: ?
* 函数名: AppTaskStart* ~) X$ E/ d8 T% v+ G
* 功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。% Q& b8 ^( O# V2 |! r' Y% R' q
* 形参: 无, g& j& j S3 ?/ Z A+ |
* 返回值: 无
! w4 E# ]. ?& b
* 优先级: 4 1 O* |. u1 P4 m; F- z
*********************************************************************************************************
; G9 C, N, }; v4 @
*/, X) J3 Z# F; @; O1 L) u
__task void AppTaskStart(void)7 @0 K# x& P4 d+ @% w7 R
{* {' ~! o" Y+ c8 c# L% \
/* 创建任务 */
4 U9 }/ W9 \0 [2 m- F9 u8 |( _
AppTaskCreate();3 ]$ {' ^- l. o) R9 ^6 x; W: c
- e8 j3 A: l0 Q1 m4 a- \" K# l( h
/* 创建任务通信机制 */
9 Z9 v' A( J$ m! ~' Y; d# _
AppObjCreate();
: |: P, f C6 @8 F
) p# a: x, U; i; H
while(1)
1 J# d, g9 f* t* S& l- r" {
{
- C$ P' Q4 E- o8 s* o
/* 按键扫描 */
2 f6 z- b1 C- }7 r% q' \, P! b1 _
bsp_KeyScan();
2 p i- ]: `4 z
os_dly_wait(10);' I5 U. J' E4 r. C, [
}

复制代码

赞评论

baiyongbin2009 回答时间：2016-2-3 15:59:57

18.4 实验例程说明(8字节对齐)
A( x% r) ^$ M$ J: l, |# ?" @18.4.1 STM32F103开发板实验

配套例子：

V4-418_RTX实验_内存管理（8字节对齐）

实验目的：

1. 学习RTX的内存管理（8字节对齐）。

2. 函数_declare_box8和_init_box8用于8字节对齐的内存池初始化。这里8字节对齐的含义：

a. 内存池的首地址是8字节对齐（8字节对齐就是地址对8求余等于0）。

b. 每个内存块大小也得是8字节的倍数，这样才能保证每申请到的一个内存块的首地址也是8字节对齐。

c. 8字节对齐是由RTX系统完成的。

实验内容：

1.K1按键按下，串口打印。

2.K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据。

3.K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据。

4.摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据。

5.摇杆UP键按下，申请一个内存块用于64位整形变量，然后向消息邮箱发送数据。

6.各个任务实现的功能如下：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

RTX配置向导详情如下：

Task Configuration

Number of concurrent running tasks

允许创建4个任务，实际创建了如下四个任务：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

创建的4个任务都是采用自定义堆栈方式。

RTX任务调试信息：

程序设计：

任务栈大小分配：

staticuint64_t AppTaskUserIFStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskLEDStk[256/8]; /* 任务栈 */

staticuint64_t AppTaskMsgProStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskStartStk[512/8]; /* 任务栈 */

将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

/*
- Q! K, U2 D0 Y, v& J, t- S; ?
*********************************************************************************************************
1 Y j8 K' u5 c, V# l5 e# Q
* 函数名: main
1 z7 p3 `6 e9 n$ g$ k( w
* 功能说明: 标准c程序入口。
! l' C/ P, l/ w0 y; g5 a2 t
* 形参: 无
; d* q) f# ^, c0 F1 }
* 返回值: 无
- s y" g) q$ e+ P: b0 | p
*********************************************************************************************************
" D8 \% t, u- S1 y4 s1 _
*// ?8 g' p5 M& k9 \# W
int main (void)3 n2 f& T6 r, q1 o
{
8 t& w8 _2 L5 m6 ^6 n
/* 初始化外设 */
: L6 ?, n9 H- E+ T, x, x' t* T
bsp_Init();
* @3 `9 M/ @4 N4 X
- N- {9 t2 z& r! b Q
/* 创建启动任务 */
8 q4 Q' {: e# ^* u8 e n
os_sys_init_user (AppTaskStart, /* 任务函数 */4 |1 W: ~0 n- @' P+ t' |+ b
4, /* 任务优先级 */3 G2 ]8 m9 l, ~0 {9 X! c
&AppTaskStartStk, /* 任务栈 */# m% W1 n0 g) f
sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */+ E$ c* m- ~- m) E0 b( ^
while(1);# V G, C% U# Z3 e: [, U/ ]9 T5 L
}

复制代码

RTX任务创建：

/*
# B# S) h. b6 S1 A- R# U
*********************************************************************************************************
& m& I v: U# f( @
* 函数名: AppTaskCreate; M- E/ o$ L! r. ?4 ^, I
* 功能说明: 创建应用任务# B* O$ n1 P: r! f9 |
* 形参: 无
5 G# }( {9 }$ o( J5 }) ~' V/ X
* 返回值: 无
( \1 N( r/ z( k2 N! x+ [
*********************************************************************************************************7 n4 ]% i4 i9 \4 K, T9 N
*/
1 u' q. J+ M, O5 x
static void AppTaskCreate (void)2 ]) w, D: F' |, X7 X* W
{
. v, m! K7 `! M# D% t6 \
HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF, /* 任务函数 */7 u2 |4 y* s' m1 N3 W
1, /* 任务优先级 */
6 H! j) c! E8 u# _
&AppTaskUserIFStk, /* 任务栈 */2 m7 j+ n5 E4 T7 }
sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */4 N( t9 B3 Y$ o9 _
" _; `4 J$ i/ n% R0 p, b
HandleTaskLED = os_tsk_create_user(AppTaskLED, /* 任务函数 */
5 j, S8 V, n; V! G L
2, /* 任务优先级 */, h2 D; C) s. R3 X C- |
&AppTaskLEDStk, /* 任务栈 */" B: B5 ]$ C. m% `- v, \ J2 h: I% \
sizeof(AppTaskLEDStk)); /* 任务栈大小，单位字节数 */( N1 D( L% r$ d8 V! [0 ~0 {
( k% v' X. \% d* J* j1 K
HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro, /* 任务函数 */8 w |8 `+ b+ h3 T, A% Q
3, /* 任务优先级 */9 }5 @& X" a; G; z5 s* p
&AppTaskMsgProStk, /* 任务栈 */, {! l6 D5 R# r# U
sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */2 ]0 F9 K0 ?9 E0 t3 y* S/ R: i' A! ?
}

复制代码

内存管理的初始化和消息邮箱的创建：

#define PoolBlocks 10
; o1 \5 b% g1 o
#define PoolPerBlockSize 8, _1 ~( |# a* _. h+ X2 u
4 m' _$ I; {1 _
/* 声明一个支持10个消息的消息邮箱 */8 H' P$ h, a4 O: ^% Z$ j6 I+ ]" ^
os_mbx_declare (mailbox, 10);3 U- `# N( L/ e1 X! H1 {- N
& S6 P3 S) ^' _+ P5 _" m- e
/* 声明一个内存池，10个块，每块大小8字节 */
$ F0 ~4 O9 S# `7 k4 v& R
_declare_box8(mpool, PoolPerBlockSize, PoolBlocks);
& \/ H; q4 G' s" v
2 r D! m$ A, P
/*+ j5 Q7 [" _. i
*********************************************************************************************************8 P5 M" E" ?) L& U* {
* 函数名: AppObjCreate
, ~; C. _) t5 U) R0 `
* 功能说明: 创建任务通信机制
/ m# ^* b8 }0 w& f2 @+ ^+ W1 x6 @
* 形参: 无
d1 G% M; b7 |
* 返回值: 无
" E1 P( |; z6 C8 x2 H
*********************************************************************************************************$ k! x3 r. S+ i' z
*/
; P; r" C' p. T' `( A0 b
static void AppObjCreate (void); @0 Z( M4 `' h( o
{4 j/ J Y4 K% u5 B& y' U
/* 创建消息邮箱 */
' \4 _. b# o( n2 v @; C. K7 X+ |
os_mbx_init (&mailbox, sizeof(mailbox));! f" x7 f7 t& @
6 e. K! G5 x2 n0 }# t
/* 初始化内存池，8字节对齐，*/. @, ?. @$ z0 m5 i- v- F# R
_init_box8 (mpool, sizeof (mpool), PoolPerBlockSize);& r/ D% a* x* K6 m8 q( L, }5 n
}

复制代码

四个RTX任务的实现：

/*2 N r* s! T3 V/ ^# R2 y6 a
*********************************************************************************************************
% B* J7 S5 l7 p
* 函数名: AppTaskUserIF7 b+ J# j( S- h2 N8 R; W
* 功能说明: 按键消息处理 1 U# S2 V4 f; k, j
* 形参: 无
0 M8 p% I6 P4 H
* 返回值: 无* C0 [" y% J! L0 |& I1 g5 C
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反)1 K8 v1 ]1 J9 O2 r) }. x& e
*********************************************************************************************************
! w8 e/ Y2 ?9 Z3 H T8 h
*/2 x ?9 t4 }) ?2 v/ V
__task void AppTaskUserIF(void)
- s4 v. B- {" C" B3 s, w W" s: s
{
& v. |( X0 Z% S) |$ r8 |3 b
uint8_t *pucMsg;
. C( G/ K1 ^* j# u8 R6 T# W9 l
uint16_t *pusMsg;8 i6 c( S! U [3 E, a% i% ]
uint32_t *pulMsg;8 K7 z' f# S) Q) i/ y, g
uint64_t *pullMsg;! n, _) t$ T! ^! `
2 K% p. k; W" m# }' f/ H: W
uint8_t ucKeyCode, ucCount = 0;
# y' @+ d w1 ~* U* R1 E Y. u
. Q1 \; |" }, Z/ r% V
while(1)* S+ L/ }" |' | r. @% @
{
: H3 z8 s& _& E# L+ w$ p; v/ w# P$ x
ucKeyCode = bsp_GetKey();
) M+ [9 l1 L9 O- M0 M6 u5 q* V
( ` d8 F3 {: r. t
if (ucKeyCode != KEY_NONE)
" F( s- n! B4 D; X: g
{
% ?# F8 z! L7 H+ J4 w1 y
switch (ucKeyCode)
_) d; R; |& ~% ?. L5 y
{
- _" `2 J7 f' W. z4 R5 y, F. [
/* K1键按下，打印调试说明 */8 |( r1 u4 M! Y# X$ N: m
case KEY_DOWN_K1:3 o4 b7 G- b" G( r( o) j
printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");6 O5 b+ q/ ?# F+ O. p) Y
break;
- M2 h+ B9 n6 H; c4 c0 H4 z
% Q; I1 H0 u0 I
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */ L' T& b' L7 p
case KEY_DOWN_K2:
% \6 s* H" `/ {4 f* b1 z
/* 申请一个内存块用于8位整形变量 */6 ?* C& ^5 L! G. e8 r
pucMsg = _alloc_box (mpool);
( m1 B7 }+ a6 v! x! l- u
*pucMsg = ucCount++;
; R0 A" d8 }5 o' ~
4 B# V/ E, F7 F+ r* t P# ?
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */* _: H$ d5 Q2 [. F
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK)! {+ h8 R) n& b* C2 f& r
{
* X( ^, g* x0 j9 }& x& T7 {0 U7 V
/* 发送失败，即使等待了100个时钟节拍 */) V+ N' `" a% u* @
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");% N* f o& E+ H5 U
_free_box (mpool, pucMsg);
) x1 l/ }5 j+ C4 o a6 S! j
}
, l1 e+ L2 D8 h6 X% i; S5 R5 ^- h
else: q9 M) ]2 j% }7 C
{3 V$ I- I- L4 X- D2 {7 B3 H
/* 发送成功 */
$ `' ]. W3 e" u4 I' b
printf("K2键按下，向消息邮箱发送数据成功\r\n");
) W9 D3 J1 z% P4 H N" f8 m ]
_free_box (mpool, pucMsg);, u& j- t! M# o2 a& g @
}
' m' P- L1 m. c/ K+ r) ~+ {. ~4 c
break;
3 [9 @$ w4 V) f
8 P6 R1 y1 [3 o$ }+ T# S
/* K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据 */8 ]/ I, n' k9 V0 y' t1 @9 ]
case KEY_DOWN_K3:, b0 [+ H! G0 s, w2 C- k) x
/* 申请一个内存块用于16位整形变量 */
9 Y5 c* b& D8 R
pusMsg = _alloc_box (mpool);
( {1 w: ]4 A$ k* J+ [+ Z& u( f, f# z
*pusMsg = ucCount++;/ p2 o! v- D9 S
/ }" d; n9 X) ?$ z, y" {9 P
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
/ c2 A+ \. q5 y6 F( M) F
if(os_mbx_send (&mailbox, pusMsg, 100) != OS_R_OK)
$ z: N! }* V5 e7 r
{2 K3 t/ n2 ?+ ^+ l
/* 发送失败，即使等待了100个时钟节拍 */2 b% X9 o) w7 t/ u
printf("K3键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
. R# f. o, t' {8 ^0 P
_free_box (mpool, pusMsg);
$ }, ~% U. w. G! e
}' M, G8 f1 J, Q b( e* f
else
$ i$ |& \6 A! I) Z$ v/ S0 s
{3 \2 T) K7 c. d( ?* {
/* 发送成功 */( a' j. N, t/ Y8 p0 X9 |
printf("K3键按下，向消息邮箱发送数据成功\r\n"); 6 X0 m; U( e7 F7 z- k0 U7 _1 q
_free_box (mpool, pusMsg);
4 X" J. j9 i0 F+ M$ j$ t
}, ^8 o9 q! u% B8 j0 B
break;
. Y2 c, c, z2 S& X U% n' ^8 [# V
' r' V0 z' s+ `: J! Z2 R0 N
/* 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据 */7 v9 k( J0 K( I& |* U, P; z; O
case JOY_DOWN_OK:
- _2 k. M3 ~2 S( R/ ^- f% Y9 s
/* 申请一个内存块用于32位整形变量 */
$ o2 I8 b/ i6 Y+ A7 t
pulMsg = _alloc_box (mpool);
8 {% H" f: G5 j! @5 ~: f0 M
*pulMsg = ucCount++;
6 ]& ?1 I3 h( O$ e
$ ? |. d1 k1 ?, Q/ M" P
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
- {. m, [1 a# e5 |
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)
8 k6 T+ }" B) n0 S& R. b
{
2 ~4 g$ \: G9 S( `1 E) ?1 ]
/* 发送失败，即使等待了100个时钟节拍 */5 s0 N7 a# e A% {& ^" N4 y
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
. a% J8 u2 u3 q6 `6 r$ J
_free_box (mpool, pulMsg);. A3 v5 |' z; T; A$ P7 u7 p# d
}
" j5 R# y3 }: Q' C' D/ {
else3 b5 c, s0 _ r# }% C' M* M
{
6 \9 W( F, M+ R3 ~- Y+ @
/* 发送成功 */1 c* h: D& n: U: o" V$ k9 p
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n");
: M/ P, A) z. B. ^
_free_box (mpool, pulMsg);* E" P; [- F) P) y
}) \# _7 L2 ?- K8 |1 l
break;! F5 p9 r+ e% T5 ^
+ \) y' o* q5 S: Z% [
/* 摇杆UP键按下，申请一个内存块用于64位整形变量，然后向消息邮箱发送数据 */
8 z! T! s* V; m1 Q" C+ \* \
case JOY_DOWN_U: V& }' M# ?/ T3 y8 ^
/* 申请一个内存块用于32位整形变量 */
3 R- w: V4 z8 z: z# }: r5 J
pullMsg = _alloc_box (mpool);
: @* A5 B* Z/ d+ c
*pullMsg = ucCount++;5 q! e) @. o1 E5 Y! X$ v8 B
' m. e, z8 |/ w
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */9 E$ s6 S5 f9 b4 a1 |8 u$ G$ n
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)
: i7 t# d) ?, E2 A2 a
{
' ~: z$ t7 U5 B& H* E7 m
/* 发送失败，即使等待了100个时钟节拍 */( C: ~1 t' R% w; s
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
9 }9 ]& O# R* K
_free_box (mpool, pullMsg);! X/ ~9 i0 b$ t% ~( p3 q3 U
}# S! P) @* j% r2 S9 E4 t/ F
else
" x8 ?( M/ X: w( k9 R1 i b
{
: `& [0 F2 g+ a# \ a" \: K
/* 发送成功 */6 B2 ~, R! ]: _
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n"); ! j" u/ |2 h& ~( b0 f
_free_box (mpool, pullMsg);0 o; ]- R% _. _/ o+ e
}$ F j- ^% o- |( h7 a" C
break;
7 S( s% ? a5 \1 e) O2 R, T
2 c& R4 q! D0 R6 }- x3 O' z
/* 其他的键值不处理 */! G G n% Z7 K
default: 8 g/ p- [' Y: D7 {/ b
break;. w/ m% u/ W3 c: t+ i4 L
}
0 D2 l5 N" M# I6 T1 C1 H x' H3 C
}
' n0 u' e6 A- ~3 M& Q. D' d
. k& s6 S7 G6 o- w
os_dly_wait(20);( \, S% d- q0 ~4 E) V0 }
}3 l, ?# T( a3 n5 c
}8 T3 R+ ^" Q6 {, A9 m
4 T2 N2 c. Z% k& D; Z" P+ b) m& E
/*
4 R( E1 i* G1 P; [3 Q' J
*********************************************************************************************************2 I2 M5 W6 P6 V' R6 t2 @
* 函数名: AppTaskLED
( X. u+ ~; u7 ]6 L- s9 G
* 功能说明: LED闪烁。
! i" A$ q! u% O1 g, F7 k' Y/ d
* 形参: 无- H! D, g. ^7 \) \
* 返回值: 无
( f% l& R. ]- Q5 `/ a8 {+ k/ `
* 优先级: 2
, X j4 w' P( c" g. Q
*********************************************************************************************************# f+ o! ~" S( E2 o( n( s; L
*/
' ` z7 T5 Y7 A) F2 V
__task void AppTaskLED(void)0 ~, O! Y" M* C# J
{
1 v& H/ X4 r1 ?0 h# p7 ~% |
const uint16_t usFrequency = 200; /* 延迟周期 */4 C+ C6 L) _$ c& |9 o/ z
4 y% V; t! D/ B- S
/* 设置延迟周期 */( m4 ]) c3 N9 _; S P. U
os_itv_set(usFrequency);# p N& D: t' a( N& W! f& r0 f
8 R% C: {" G5 R3 q& \0 @) q5 p L
while(1)! t. ~5 n+ n* M2 ]" S
{& `. ]9 J6 i1 N; M
bsp_LedToggle(2);7 }' H Y3 T7 x3 h! S. O) G
bsp_LedToggle(3);
3 B4 y0 L" ]6 \- j
$ h; {: H. X9 f; j) s
/* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/; \, f7 a6 C+ ^% @6 X2 X( f4 N
os_itv_wait();- i2 O) v& O l# n
}$ S7 P& O, E' G" }0 H4 D$ y: c& ?
}$ I. E, z8 t8 L1 W9 s, n
) k# h& T$ o3 R/ ~) m% r6 ^) l5 m) y
/*
( {% h( ?6 _; ?2 `( B4 s9 L
*********************************************************************************************************( v5 D1 [' `& w
* 函数名: AppTaskMsgPro
6 j4 T+ Z& f$ ~
* 功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据
& H# N5 x% {) a* ~- E- @! }
* 形参: 无; ? X) T2 z1 g+ m) d3 I+ R
* 返回值: 无6 M/ p8 ]# X( g
* 优先级: 3
4 m8 g" _. C$ t
*********************************************************************************************************
8 \/ [7 M, Z0 G
*/
N; b% f7 E2 K2 U& b/ D
__task void AppTaskMsgPro(void)- k2 m4 L% H1 \3 u) D; Z
{" J1 E) B4 i3 T( t) ]" R" h
uint8_t *pMsg;8 M3 F8 p) k7 x% `$ \
OS_RESULT xResult;; q j* T0 T! p! B& }. A
const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
) j3 z* j* t- @4 b
# |! [; W q, L. ^( j+ O
while(1)7 I% x( `5 u% E3 G _* E# {
{
$ C- Q9 i( X9 i2 T; g
xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
" F6 ?6 }8 r2 T p7 x. ~* ]
+ J* {* P5 [, s) Z: h
switch (xResult)
1 L" r3 r+ b" d# C$ F( n
{% _7 E: p* |4 b% p: x3 s
/* 无需等待接受到消息邮箱数据 */
9 u( [: t4 H7 h
case OS_R_OK:
) H1 X# P2 v! ?8 @% y5 d4 K) E2 O6 S
printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);9 H% e6 u5 h, G% r# K+ e
break; 4 A7 i4 ~" \. u8 g, D6 ~
) S, I+ |# K) G* J" ~& h! k/ S
/* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */3 H: F. j7 T& m$ N2 @( m
case OS_R_MBX:; c3 P7 e5 b& N7 R$ E' c8 G' _
printf("因为消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);4 ^5 b2 n1 \# w( @$ |; {, a3 m1 Q" K
break;
- s! C9 H/ N* O& x" _
' X5 X0 M/ X& U+ I
/* 超时 */
) L( Q) f' [ p( t
case OS_R_TMO:, D" V" @. ]6 x0 N1 p8 O4 t! N
bsp_LedToggle(1);0 A& m' ^" ?; x& ~( j+ r# s. D
bsp_LedToggle(4);
7 K$ [$ R1 y' c. d- i
break;3 u7 L5 N7 k* {
( L4 n& m/ P9 x9 W+ L+ n
/* 其他值不处理 */
& U) N+ W9 o" \
default:
; R6 m+ b6 j# P6 n! H
break;
0 ~+ ~7 C# P4 L q$ x8 X
} y! `5 \. a' ]. F; T; s
}5 A) K$ o1 n4 E, p3 C
}

复制代码

, F- [ O) A. g

赞评论

baiyongbin2009 回答时间：2016-2-3 16:03:50

18.4.2 STM32F407开发板实验

配套例子：

V5-418_RTX实验_内存管理（8字节对齐）

实验目的：

1. 学习RTX的内存管理（8字节对齐）。

2. 函数_declare_box8和_init_box8用于8字节对齐的内存池初始化。这里8字节对齐的含义：

a. 内存池的首地址是8字节对齐（8字节对齐就是地址对8求余等于0）。

b. 每个内存块大小也得是8字节的倍数，这样才能保证每申请到的一个内存块的首地址也是8字节对齐。

c. 8字节对齐是由RTX系统完成的。

实验内容：

1.K1按键按下，串口打印。

2.K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据。

3.K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据。

4.摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据。

5.摇杆UP键按下，申请一个内存块用于64位整形变量，然后向消息邮箱发送数据。

6.各个任务实现的功能如下：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

RTX配置向导详情如下：

Task Configuration

Number of concurrent running tasks

允许创建4个任务，实际创建了如下四个任务：

AppTaskUserIF任务：按键消息处理。

AppTaskLED任务：LED闪烁。

AppTaskMsgPro任务：消息处理，等待任务AppTaskUserIF发来的消息邮箱数据。

AppTaskStart任务：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

创建的4个任务都是采用自定义堆栈方式。

RTX任务调试信息：

程序设计：

任务栈大小分配：

staticuint64_t AppTaskUserIFStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskLEDStk[256/8]; /* 任务栈 */

staticuint64_t AppTaskMsgProStk[512/8]; /* 任务栈 */

staticuint64_t AppTaskStartStk[512/8]; /* 任务栈 */

将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

/*
3 J# e0 n, I6 {* L. ?1 J
*********************************************************************************************************" C8 g( N% p, a. Y+ H0 g! Z
* 函数名: main
' W$ c% o t* p7 \( Q; H+ |: D
* 功能说明: 标准c程序入口。
& l7 k5 E! [8 t" b
* 形参: 无! ~ `7 z/ J$ d! J0 T
* 返回值: 无! y/ a. s3 W# h# Y' }
*********************************************************************************************************
9 R& K, s h$ f% n* Q0 o: s6 ^( T
*/
7 z& V" K: @6 J: |
int main (void)
8 G. k' ]% B1 j3 M
{ ! C1 Q0 f6 s; [% w f7 s" O
/* 初始化外设 */8 ]. d; E5 ?7 y# I
bsp_Init();
0 e# l( V' _; v8 L
! {* S7 j& G( B0 [7 A0 I
/* 创建启动任务 */
+ ~7 q- s6 \* a5 N. S! i
os_sys_init_user (AppTaskStart, /* 任务函数 */
* ]9 m6 K+ Z2 D2 o' v5 J
4, /* 任务优先级 */
$ N5 S* |8 P" a% }
&AppTaskStartStk, /* 任务栈 */) v& m2 D7 d* l6 B
sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */5 Y6 i' m8 l9 @$ K
while(1);/ ^ u& N9 M, ~/ {, {3 K0 h
}

复制代码

RTX任务创建：

/*
* h1 Z7 O* f- n/ O
*********************************************************************************************************! [$ S! G5 N" g- T2 g
* 函数名: AppTaskCreate
& A B! T2 n7 k0 E: k' [
* 功能说明: 创建应用任务
8 j# j9 T" v9 O6 w- F8 X c0 N
* 形参: 无
2 x5 i5 X" T9 i" Q+ z) ]- z' @
* 返回值: 无
$ f4 z% i1 M6 i% T! k- r6 o, O$ t0 ~
*********************************************************************************************************) r( I3 `1 v: G6 I' c8 P
*/
9 O6 R* u3 F" ]% W3 O) }7 U
static void AppTaskCreate (void)
7 U0 R; b+ _6 G) d/ t
{
0 _8 E$ q: p0 p
HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF, /* 任务函数 */
& o; s& P7 }1 Y1 P% `6 g* l
1, /* 任务优先级 */4 n$ I/ H0 Y# |$ h( x2 r( x: P
&AppTaskUserIFStk, /* 任务栈 */
- K& p9 m% G( {9 e8 E0 F( e
sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */# N8 {/ O, V! ~6 H. v' q/ ?' S9 z5 T
0 f" q* H+ c, l& s% q* W
HandleTaskLED = os_tsk_create_user(AppTaskLED, /* 任务函数 */
$ @9 p8 S' y/ W- L9 e) S; W. x7 {
2, /* 任务优先级 */
1 ?2 ^! P+ w# d
&AppTaskLEDStk, /* 任务栈 */
3 Q* \& g4 c( D V1 l- U, G; o
sizeof(AppTaskLEDStk)); /* 任务栈大小，单位字节数 */% ~5 t& U/ F' M: V
+ Z1 g N6 n- t, t
HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro, /* 任务函数 */! g/ b1 x4 j* [. c+ }
3, /* 任务优先级 */+ Z- B0 ` m/ V
&AppTaskMsgProStk, /* 任务栈 */
/ ~* H# G# {5 R2 i/ Z0 x4 Z$ _
sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
: @0 Y6 p) S l
}

复制代码

内存管理的初始化和消息邮箱的创建：

#define PoolBlocks 10) j) p; s/ x) R# D% H
#define PoolPerBlockSize 8
0 p" `6 o) c* Q" ?6 B
8 f+ ^# Z p( Y( z) _/ a
/* 声明一个支持10个消息的消息邮箱 */
: N) J' Y* w2 B5 V: n* w& X3 Z
os_mbx_declare (mailbox, 10);% I2 {' X: {6 f* z; O* _
& o2 n# B6 k) A2 U/ H
/* 声明一个内存池，10个块，每块大小8字节 */
, l w6 v1 k, I, U
_declare_box8(mpool, PoolPerBlockSize, PoolBlocks);
; { r. ]& Y( P8 Y5 {: }
+ r9 B4 ^/ n) P6 B6 O! o
/*
& ?4 S6 c/ P" s& j- j/ ~
*********************************************************************************************************$ L! w. j8 _: m
* 函数名: AppObjCreate
5 v4 Q6 [+ X5 }3 d3 l
* 功能说明: 创建任务通信机制' t/ I8 n( B' ~" ]5 K3 d
* 形参: 无
& K" o% F* }0 G2 E5 D0 W! {2 @
* 返回值: 无- J' ~) Z+ s: `/ f. h
********************************************************************************************************** |% B0 O' \9 G$ m
*/7 K1 U' q! T8 H8 \7 {, R2 e. {8 \
static void AppObjCreate (void). I( C2 S, h. T1 q
{
; P5 j. m9 K* ~* R: X' m- P( g
/* 创建消息邮箱 */* I- m6 v1 N9 Z( y& w- V4 X
os_mbx_init (&mailbox, sizeof(mailbox));
1 c" L4 X B& S. e1 Q
) E% |' X1 P* ^ Q b
/* 初始化内存池，8字节对齐，*/; h& f, b0 A4 {. D+ |" k" t
_init_box8 (mpool, sizeof (mpool), PoolPerBlockSize);0 U7 ?9 o% ]& |* {0 X5 {/ X
}

复制代码

四个RTX任务的实现：

/*
" A0 e+ t# s% L& u, m
*********************************************************************************************************
- u, V" }3 z; f& Z2 x" L
* 函数名: AppTaskUserIF3 q2 K4 \2 {" P$ u
* 功能说明: 按键消息处理
M# M- a" ~' W9 d# u. J
* 形参: 无0 l5 {7 V- ]% T- g
* 返回值: 无
/ N) k6 A" V v
* 优先级: 1 (数值越小优先级越低，这个跟uCOS相反)( F! P1 m" e7 P, `1 w
*********************************************************************************************************& y, L" v0 Q! ^$ L- |: `0 V
*/3 B. C* i1 v6 P8 T" N- Z
__task void AppTaskUserIF(void)6 l% B2 a* V* }9 B+ T$ i
{2 {; }* P' u$ p* U6 O
uint8_t *pucMsg;
& s# w# k! \- {0 G
uint16_t *pusMsg;
# y5 s ~$ W4 v! B) g1 @
uint32_t *pulMsg;
! U9 z, b& _: o$ s# \& W
uint64_t *pullMsg;- m& v: O. {8 m' l6 X/ q3 T$ d
: g" \* n* O# E/ D+ ~ i( q
uint8_t ucKeyCode, ucCount = 0;
4 C" ?' B! {: s" y1 T2 X
5 u5 B0 [* ]) P
while(1)8 |& H3 e) Z# L) t
{ z# N4 L8 W& \( O2 O$ G
ucKeyCode = bsp_GetKey();2 q% `: }6 b9 M
% C! `! f8 ]& {" g- j4 l
if (ucKeyCode != KEY_NONE)2 C1 Q% w& u; o0 I% E
{6 R% o: Z. a4 z. X9 F
switch (ucKeyCode)6 a9 U, W. M/ [* J' a
{6 ?9 T0 y- H' g/ b4 T! f& l
/* K1键按下，打印调试说明 */: }1 r! K7 r( F, Q# m6 z E
case KEY_DOWN_K1:& D( o$ m" L9 p9 |5 A6 s- Y) q# N
printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");6 d k9 z1 L9 j& W8 Q
break; . X; e. h$ W8 C4 ^
/ R9 X4 X( R4 h" P& f8 _
/* K2键按下，申请一个内存块用于8位整形变量，然后向消息邮箱发送数据 */6 q, v" H: _! e6 r* ?
case KEY_DOWN_K2:
2 ]9 f6 _0 b: Q/ [1 L+ E
/* 申请一个内存块用于8位整形变量 */
0 [* ~2 c$ ]/ N& I d1 H
pucMsg = _alloc_box (mpool);+ p$ V7 w' z9 o# q) d" S
*pucMsg = ucCount++;% d+ ]; m L) {: b; H! `' r
7 H6 j( o& ?6 p' t- k7 S
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */& e- ~$ r; T8 g2 ~
if(os_mbx_send (&mailbox, pucMsg, 100) != OS_R_OK)
( G/ D# P4 n) ?( x( X
{
; p, A: D# H; g7 e, P
/* 发送失败，即使等待了100个时钟节拍 */6 P$ ]/ J; ?$ Q* q
printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");( C& i4 ~8 B4 S# S1 v- Q- x# Y+ F: {
_free_box (mpool, pucMsg);
. |+ R! W) f9 r) }) [. L
}9 B5 q: u; j7 N& g+ Q- m& P% _
else9 A: m3 R: w& s3 T p5 S8 W( @
{
- {) ~/ T! h6 z0 t: E2 h
/* 发送成功 */
( c; k/ B# ?% M- l( A6 J) {
printf("K2键按下，向消息邮箱发送数据成功\r\n");
" k0 `6 a+ u( l4 t
_free_box (mpool, pucMsg);
: n% b& l7 i0 G* q5 t- C; ~
}$ |% `3 z1 }, Q0 T. M
break;
( H7 E$ v3 ?; W# C
& S8 B" s" D4 T8 U) H
/* K3键按下，申请一个内存块用于16位整形变量，然后向消息邮箱发送数据 */3 q4 z$ i: F% q% R6 Z
case KEY_DOWN_K3:
q/ `8 p8 e3 t0 M- \2 |3 v2 h
/* 申请一个内存块用于16位整形变量 */
) Q T3 z- p* z
pusMsg = _alloc_box (mpool);
4 k$ I' q- x+ W7 o$ c9 e# A, r4 w, |5 K
*pusMsg = ucCount++;
t! v" d3 f+ P# E+ |, \
- L0 ]0 w- ~6 Q
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
2 D( x9 K! X1 m. x( J, \" x" Q3 R- W
if(os_mbx_send (&mailbox, pusMsg, 100) != OS_R_OK)
" p6 [1 A$ l' v* n
{( X9 _* S; Z3 w) B M
/* 发送失败，即使等待了100个时钟节拍 */1 w; f2 J3 Z4 ]5 D" @( Q3 j3 P8 M
printf("K3键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");! V1 Z+ S/ F G% \" L( [
_free_box (mpool, pusMsg);( M% f! M- w) ]* a, e
}
0 e) q) x- T: l$ J4 k
else+ ~1 R7 N# }1 g
{9 x3 B1 }3 t4 i+ h
/* 发送成功 */
) |5 ^8 ^* H% F$ G5 b1 J, k
printf("K3键按下，向消息邮箱发送数据成功\r\n");
/ s* [- L; I, v( d L7 J; l
_free_box (mpool, pusMsg);2 t: B! ^$ ]. m! \, b
}
! w0 P9 C& @5 a5 o
break;
1 X# ~9 M$ J- }2 Y) Z' @( z, N9 p
9 A2 x3 }1 y' ]4 n( c) }
/* 摇杆OK键按下，申请一个内存块用于32位整形变量，然后向消息邮箱发送数据 */: Z$ J" `$ A! ]+ w$ d9 |! d
case JOY_DOWN_OK:
9 ]' q/ ~3 x! x# Q
/* 申请一个内存块用于32位整形变量 */& T3 n. B" [% m/ i
pulMsg = _alloc_box (mpool);
8 {" M6 r' o! z, Z, @
*pulMsg = ucCount++;; s) e7 x, W) L7 |
! ^- d% I5 G9 { s
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
) y V% {5 T: d* g/ b; `
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)
) g$ P* a; ^9 q: W
{! A7 m2 _" c7 o" l) @
/* 发送失败，即使等待了100个时钟节拍 */" [( b/ A/ G( i2 j3 |8 Z
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
8 I5 f3 n8 C5 A; T. G, J
_free_box (mpool, pulMsg);7 Y' z% l1 V; d8 o: B/ F: ^. j
}0 I$ Z/ T; e( n4 n
else
- ]6 ] O2 i" q7 o. H
{' V5 ]7 M& R( x! {. B
/* 发送成功 *// |6 {& c- H0 K4 [( Y
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n"); ], @2 N7 d p9 i+ d7 @' r* v) q
_free_box (mpool, pulMsg);
3 r: u3 ~ n1 I+ r% G& z9 H7 x2 [
}6 {7 U. E7 I# P, Z0 W# E
break;! z: Y0 g) _9 |. S
8 T5 B! q& h: Q$ n4 h9 I& C
/* 摇杆UP键按下，申请一个内存块用于64位整形变量，然后向消息邮箱发送数据 */
- N0 A$ d( W+ H5 B/ u9 c+ [2 C
case JOY_DOWN_U:) {7 S* h2 j8 J! x' E
/* 申请一个内存块用于32位整形变量 */
' z+ ~ P* R+ b& y9 E" [ C
pullMsg = _alloc_box (mpool);5 }$ Y T1 Z6 h: @/ D2 ]0 `
*pullMsg = ucCount++;
) U+ O {! F9 w% F* K
0 X9 Z! w# ]7 \3 j& u0 y' e( ?$ }; K
/* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */- L+ z8 s+ R- }2 ]$ k
if(os_mbx_send (&mailbox, pulMsg, 100) != OS_R_OK)) c( ]+ u. Q i- Q: x% V- b" I
{/ V4 s. {' L* z0 A6 y- N$ D0 _; A
/* 发送失败，即使等待了100个时钟节拍 */
6 \4 x# {8 l9 U: d, ^/ n9 X: L
printf("摇杆OK键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
% p) I; X1 a0 t9 |2 ^- x
_free_box (mpool, pullMsg);
" n- F/ B: r4 j' o2 e' `5 f
}* S7 H4 v& F9 ]
else
; d0 h1 b# O- K
{5 W+ |- p' u9 D; T' r0 j3 P
/* 发送成功 */$ D* I: Y4 ?2 i) u
printf("摇杆OK键按下，向消息邮箱发送数据成功\r\n");
( a$ M3 V. @ n ^
_free_box (mpool, pullMsg);8 H, `! B+ O) W# `+ H9 K* b
}; L, s* h% [6 F& u( }# D( u
break;8 T3 Q& T/ H) N% n2 [/ Q
! T. |! Q. G% S" [# _
/* 其他的键值不处理 */
' v3 i3 Y) r" m4 c
default: ( k4 T" q# Z# X1 f3 c, C
break;& C: X/ ]* i O4 p
}
) h) T3 B- k# r+ E3 \
}
5 o* w0 t, T0 N# L0 }/ O q, {4 r
1 D ?- s* X8 f0 J/ y
os_dly_wait(20);% Z% e" ]$ U1 ^5 i+ x+ M
}
* O6 ^. H r' l. N1 ]2 K& ?
}
5 A- Z% G8 M+ ?" r$ g6 D8 f4 O
# j' S& z0 B* s6 r# K& x
/*
; r6 t0 R% O' y( _3 {
*********************************************************************************************************
7 x) o8 _8 L ?+ @5 z
* 函数名: AppTaskLED
* s- D. B3 Z; o: J% }1 g% T) m( s; R
* 功能说明: LED闪烁。. C d$ o: L- y8 [* t/ q# o( f
* 形参: 无* h/ L& {3 r) n- {! e
* 返回值: 无
* v8 w" r: I! A+ ?0 s
* 优先级: 2 7 { I) i- [" E; w0 F3 Q
*********************************************************************************************************
7 L9 k2 T3 N- i6 I* f
*/3 z! X: `- k6 c
__task void AppTaskLED(void)* _! }5 U( G( Q3 L% m s* A( {
{+ G* P7 e1 c+ g5 G0 g
const uint16_t usFrequency = 200; /* 延迟周期 */- u9 ?& X" F& i0 f% Y
# L) A9 C7 o5 f! R9 w# {: r
/* 设置延迟周期 */
1 p% }; x; W% \; [
os_itv_set(usFrequency);4 ~# I& N) F, f# n' w9 Q6 g
/ M$ a0 j8 [3 O/ v
while(1)
/ a8 P6 H' K3 p1 C
{
" Q' ]. ^) R) I, p: Z. S+ N3 ^
bsp_LedToggle(2);7 L& n. h- b7 ~* d; a
bsp_LedToggle(3);
$ S/ u$ v% _- J" }" a
! W) s1 X2 k2 f1 e
/* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
$ w9 V4 {% ^7 [# q
os_itv_wait();( M. g u" k K: _0 Z3 @
}
& w2 ?9 \: H6 ~# s7 T
}; s1 j6 F5 e C# o2 _$ ~; Q
. P6 I+ H% g; f5 ~2 I/ Q
/*
* B; e9 z7 W r+ J
*********************************************************************************************************
6 B" \" U) i$ L$ N. \ _$ m
* 函数名: AppTaskMsgPro
% }; O5 Q5 K; C, W4 v
* 功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据5 v% `) v0 b7 U) v0 _+ a4 w: q
* 形参: 无- T1 {% @' W& h$ F% U
* 返回值: 无: s* R& L9 J: Y7 g! q3 Q- `2 S
* 优先级: 3 3 I8 J- \; `! C( S4 J
*********************************************************************************************************9 U: s# s; @* u% O& t* T5 \
*/- g+ `2 b, ]5 |, E& @% G; J3 ]
__task void AppTaskMsgPro(void)9 u, ?. ?: W+ @2 }( g' F# i
{2 v5 h) k2 S) A" g a& V5 ~
uint8_t *pMsg;
# J' ]& G( p* P8 j+ b# k
OS_RESULT xResult;5 X u K9 Z! W. c/ ^9 E( B, W
const uint16_t usMaxBlockTime = 200; /* 延迟周期 */+ l& V: h( ~3 q( n, N& G
J5 W( o* r$ y% F
while(1)4 S4 n- @1 C" G0 `+ _. d) s$ E0 D
{
, ]0 {8 w" \+ W. `3 E/ s0 B( I
xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);0 P+ p. ^2 @' s+ J8 e9 L& w
$ [; ?* }6 |8 f s
switch (xResult)4 P& t0 f6 L6 {) @- m! Z: K$ Q0 T
{
/* 无需等待接受到消息邮箱数据 */& e3 R: J) g- ?& Q; d! t
case OS_R_OK:& e% A; v! Z6 c% q! x
printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
t" B" t9 T- C( r2 _; ?
break; + ~* d% |0 @( R" y
0 H. ?0 R- Y$ v) C2 P8 K
/* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */: x) _& O+ c0 R4 a# P& }
case OS_R_MBX:
/ R# I9 y* n P
printf("因为消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
; |, v# b: q q# W
break;3 }6 Q1 m. v4 ~) Y; j' T; H
% i) `7 d _9 X9 ^( K
/* 超时 */
2 z% H; x( j' n- _9 S9 i( |
case OS_R_TMO:
1 Z. A- |' z' v. h4 ?2 a2 t
bsp_LedToggle(1);
( N, D8 [; s' K
bsp_LedToggle(4);/ ?$ |5 z+ @: U0 R- f/ [
break;- L* }( t3 C. y
$ ^: g n9 u6 ], o2 t3 N
/* 其他值不处理 */ ?0 `5 P) |* y0 y0 m& i
default:
: ^' V. r3 r/ w4 Y( c
break;9 w! V4 ~( ]* }: w: H
} + W5 I% S: n1 z3 c6 ?1 c; d
}% A y5 Z9 U. {2 i7 d9 M
}

复制代码

赞评论

baiyongbin2009 回答时间：2016-2-3 16:04:25

18.5 总结

本章节主要为大家讲解了RTX内存管理的实现方法，关于嵌入式内存管理的方案还有很多，有兴趣的同学可以查阅相关资料了解一下。

赞评论

stary666 回答时间：2016-2-3 16:09:47

看看，，，，，，，，，，，，

赞评论

看不透说不穿回答时间：2019-3-24 12:58:13

有个问题请教下，RTX 邮箱传递的是数据地址，上面的例子动态生成一个内存，数据邮箱发送完后释放了内存，邮箱的接收端收到地址，但是如果数据没有来得及处理会不会用的不是真实数据，因为地址已经被释放，可能其他地方的风险。

赞评论

所属标签

STM32团队

最新内容