9 P. D/ K7 g6 N: x4 [第16章    消息邮箱

    前面几个章节主要给大家讲解了任务间的同步和资源共享机制，本章节为大家讲解任务间的通信机制消息邮箱，RTX的消息邮箱其实就是消息队列，注意和uCOS-II中的消息邮箱区分开，uCOS-II的消息邮箱只能实现一个数据的传递。这里的消息邮箱可以实现多个数据的传递。

    本章教程配套的例子含Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407。

16.1 消息邮箱

16.2 消息邮箱API函数

16.3 实验例程说明（任务间通信）

16.4 实验例程说明（中断方式通信）

16.5      总结

16.1  消息邮箱
: G6 h5 I5 h/ _* R16.1.1  消息邮箱的概念及其作用

    RTX的消息邮箱实际上就是消息队列，通过内核提供的服务，任务或中断服务子程序可以将一个消息（注意，RTX消息邮箱传递的是消息的地址而不是实际的数据）放入到消息队列。同样，一个或者多个任务可以通过内核服务从消息队列中得到消息。通常，先进入消息队列的消息先传给任务，也就是说，任务先得到的是最先进入到消息队列的消息，即先进先出的原则（FIFO）。

    也许有不理解的初学者会问采用消息邮箱多麻烦，搞个全局数组不是更简单，其实不然。在裸机编程时，使用全局数组的确比较方便，但是在加上RTOS后就是另一种情况了。使用全局数组相比消息邮箱主要有如下四个问题：

    （1）使用消息邮箱可以让RTOS内核有效的管理任务，全局数组是无法做到的，任务的超时等机制需要用户自己去实现。

    （2）使用了全局数组就要防止多任务的访问冲突，使用消息邮箱已经处理好了这个问题。用户无需担心。

    （3）使用消息邮箱可以有效的解决中断服务程序跟任务之间消息传递的问题。

    （4）FIFO机制更有利于数据的处理。

16.1.2  RTX任务间消息邮箱的实现

    任务间消息邮箱的实现是指各个任务之间使用消息邮箱实现任务间的通信。下面我们通过如下的框图来说明一下RTX消息邮箱的实现，让大家有一个形象的认识。

                              

运行条件：

1.  创建消息邮箱，可以存放10个消息。

2.  创建2个任务Task1和Task2，任务Task1向消息邮箱放数据地址，任务Task2从消息邮箱取数据地址。

3.  RTX的消息读取和存放仅支持FIFO方式。

运行过程主要有以下两种情况：

（1）任务Task1 向消息邮箱放数据地址，任务Task2从消息邮箱取数据地址，如果放数据地址的速度快于取数据的速度，那么会出现消息邮箱存放满的情况，RTX的消息存放函数os_mbx_send支持超时等待，可以设置超时等待，直到有位置可以存放消息放或者设置时间超时。

（2）任务Task1 向消息邮箱放数据地址，任务Task2从消息邮箱取数据地址，如果放数据地址的速度慢于取数据的速度，那么会出现消息邮箱为空的情况，RTX的消息获取函数os_mbx_wait支持超时等待，可以设置超时等待，直到消息邮箱中有消息放或者设置时间超时。

上面就是一个简单的RTX任务间消息邮箱通信过程。

16.1.3  RTX中断方式消息邮箱的实现

    RTX中断方式消息邮箱的实现是指中断函数和RTX任务之间使用消息邮箱。下面我们通过如下的框图来说明一下RTX消息邮箱的实现，让大家有一个形象的认识。

运行条件：

1.  创建消息邮箱，可以存放10个消息。

2.  创建1个任务Task1和一个串口接收中断。

3.  RTX的消息读取和存放仅支持FIFO方式。

运行过程主要有以下两种情况：

（1）中断服务程序向消息邮箱放数据地址，任务Task1从消息邮箱取数据地址，如果放数据地址的速度快于取数据的速度，那么会出现消息邮箱存放满的情况。由于中断服务程序里面的消息邮箱发送函数isr_mbx_send不支持超时设置，所有发送前要通过函数isr_mbx_check检测邮箱是否满。

（2）中断服务程序向消息邮箱放数据地址，任务Task1从消息邮箱取数据地址，如果放数据地址的速度慢于取数据的速度，那么会出现消息邮箱存为空的情况。在RTX的任务中可以通过函数os_mbx_wait获取消息，因为此函数可以设置超时等待，直到消息邮箱中有消息存放或者设置时间超时。

2 F5 i1 H7 O. W' S- `0 A: G

上面就是一个简单RTX消息邮箱通信过程。实际应用中，中断方式的消息机制切记注意以下四个问题：

1.  中断函数的执行时间越短越好，防止其它低于这个中断优先级的异常不能得到及时响应。

2.  实际应用中，建议不要在中断中实现消息处理，用户可以在中断服务程序里面发送消息通知任务，在任务中实现消息处理，这样可以有效的保证中断服务程序的实时响应。同时此任务也需要设置为高优先级，以便退出中断函数后任务可以得到及时执行。

3.  中断服务程序中一定要调用专用于中断的消息邮箱函数isr_mbx_send，isr_mbx_receive和isr_mbx_check。

4.  在RTX操作系统中实现中断函数和裸机编程是一样的。

    （1）另外强烈推荐用户将Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407的NVIC优先级分组设置为4，即：NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);这样中断优先级的管理将非常方便。

    （2）用户要在RTX多任务开启前就设置好优先级分组，一旦设置好切记不可再修改。

, e8 o; C5 ?5 S0 ^1 T/ W

16.2 消息邮箱API函数

   使用如下8个函数可以实现RTX消息邮箱：

os_mbx_check

os_mbx_declare

os_mbx_init

os_mbx_send

os_mbx_wait

isr_mbx_check

isr_mbx_receive

isr_mbx_send

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

这里我们重点的说一下函数os_mbx_declare，os_mbx_init，os_mbx_send，os_mbx_wait，isr_mbx_check和isr_mbx_send。

% S1 G7 P( g: E  v1 g- P' Y4 Z2 [16.2.1  函数os_mbx_declare

函数原型：

1. #define os_mbx_declare( \
   ( N  }( @# o' V+ P/ O5 s/ h
2.     name,               \ /* 消息邮箱名 */
   # }3 e; B8 w& u
3.     cnt )               \ /* 消息个数 */
   
4. U32 name [4 + cnt]

复制代码

函数描述：

函数os_mbx_declare定义了消息邮箱的大小和消息邮箱名，用于消息邮箱的初始化。其实就是通过宏定义的方式定义了一个数组U32类型的数组name[4 + cnt]。定义成32位数组是因为CM3/CM4是32位机，地址也就是32位的，从而指针变量也就是固定的32位变量。RTX的消息邮箱传递的是变量的地址，而不是变量的内容，所以要将邮箱定义成32位数组。

（1）第1个参数表示定义的消息邮箱名。

（2）第2个参数是邮箱支持的消息个数。

一般的应用中，消息邮箱支持20个消息就够了。

使用举例：

1. #include <rtl.h>
   
2. 
   
3. /* 声明一个支持10个消息的消息邮箱 */
   " i  F) K2 p2 Z
4. os_mbx_declare (mailbox, 10);

复制代码

" b1 S% {$ d3 @! L# E" x/ X* P$ z
16.2.2 函数os_mbx_init

函数原型：

1. void os_mbx_init (
   
2.     OS_ID mailbox,       /* 消息邮箱的ID标识 */
   
3.     U16   mbx_size );    /* 邮箱大小，单位字节 */

复制代码

函数描述：

函数os_mbx_init用于消息邮箱的初始化。其实就是将函数os_mbx_declare定义的数组进行初始化用于消息邮箱的FIFO。

（1）第1个参数填写消息邮箱的ID标识，即函数os_mbx_declare第一个参数。

（2）第2个参数填写函数os_mbx_declare定义的邮箱大小，单位字节。

使用举例：

1. #include <rtl.h>
   0 c0 x8 K2 S" E( m5 R$ @6 j
2. 
   
3. /* 声明一个支持10个消息的消息邮箱 */
   
4. os_mbx_declare (mailbox, 10);
   $ C3 ^% O  @3 Y% f! P6 R- j: v
5. 
   , t! X3 K3 \( \! B, |" I* z
6. /*
   # U) q" m2 Q. R! l" u
7. *********************************************************************************************************
   : J5 p8 G* T: v- S: z3 [) X
8. *   函 数 名: AppObjCreate
   * w7 g# f7 h  t
9. *   功能说明: 创建任务通信机制
   * {0 @+ }/ V' l' T* a$ `# v1 ^$ z
10. *   形    参: 无
    9 }: J9 r3 l3 t; p; z
11. *   返 回 值: 无
    1 h7 b! P. T* R( D) _
12. *********************************************************************************************************
    & L" H( N" t  c, s3 t; B  K' X0 b
13. */
    
14. static void AppObjCreate (void)
    " N2 e' C' o% K/ L, L4 q
15. {
    + F* w  s- {( Y/ X
16.       /* 创建消息邮箱 */
    7 ]. i7 I2 A7 Z; H- z! k
17.       os_mbx_init (&mailbox, sizeof(mailbox));
    & o- Q; ?) @8 c7 x7 H2 i2 l& S5 {
18. }

复制代码

2 h8 _6 j) Z; M: U* f& A( J: b
( Z' d: F' S% z  `5 Z16.2.3 函数os_mbx_send

函数原型：

1. OS_RESULT os_mbx_send (
   
2.     OS_ID mailbox,        /* 消息邮箱ID标识 */
   / e$ u$ m; H; ]
3.     void* message_ptr,    /* 消息指针，即数据的地址 */
   
4.     U16   timeout );      /* 超时时间设置 */

复制代码

函数描述：

函数os_mbx_send用于向消息邮箱存放数据指针，或者说数据地址。如果消息邮箱已经满了，调用此函数的任务将被挂起，等待消息邮箱可用，直到消息邮箱有空间可用或者超时时间溢出才会返回。

（1）第1个参数填写消息邮箱的ID标识，即函数os_mbx_declare第一个参数。

（2）第2个参数填写消息指针，即数据的地址。

（3）第3个参数表示设置的等待时间，范围0-0xFFFF，当参数设置为0-0xFFFE时，表示等待这么多个时钟节拍，参数设置为0xFFFF时表示无限等待直到消息邮箱有可用的空间。

（4）返回值OS_R_OK，表示消息指针成功放到消息邮箱中。

    返回值OS_R_TMO，表示消息邮箱已经满了，在设置的超时时间范围内也没有等到可用的空间。

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

1.     使用此函数前一定要调用函数os_mbx_init进行初始化。

2.     此函数用于往消息邮箱放消息指针，另一个函数os_mbx_wait用于从消息邮箱取出消息指针，取出后相应的位置也就释放出来了，方便下次存放数据。

使用举例：

1. #include <rtl.h>
   ! i; V- e7 ]; W4 N
2. 
   
3. /* 声明一个支持10个消息的消息邮箱 */
   ' l3 k* g8 I  H8 m. n& I
4. os_mbx_declare (mailbox, 10);
   
5. 
   
6. /*
   
7. *********************************************************************************************************
   
8. *   函 数 名: AppObjCreate
   # R6 _! U8 }" f  T+ d
9. *   功能说明: 创建任务通信机制
   8 r9 H# B6 O7 k! E2 J* Z: x7 M" X
10. *   形    参: 无
    
11. *   返 回 值: 无
    + x4 A) [* Q0 S( [
12. *********************************************************************************************************
    7 Q$ u4 N" {8 y4 J( j! M. O
13. */
    . h* W  _1 t! W0 E3 [; q
14. static void AppObjCreate (void)
    
15. {
    8 H( I# N! M3 T7 O
16.       /* 创建消息邮箱 */
    7 b( `) m: ?7 q0 O
17.       os_mbx_init (&mailbox, sizeof(mailbox));
    - e5 i2 t" @+ P6 v; d' a$ ^
18. }
    8 Q0 z$ [- O6 p4 F
19. 
    : a1 ]2 s% a' Z
20. /*
    
21. *********************************************************************************************************
    7 U1 e  Y4 L: }5 }& }
22. *    函 数 名: AppTaskUserIF
    
23. *    功能说明: 按键消息处理     
    : f' s  m  L1 `+ W& K% k4 V
24. *    形    参: 无
    8 j' _3 K! X5 h0 B' N  Y
25. *    返 回 值: 无
    . {! K5 k4 }3 ^$ z: {/ b
26. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
    
27. *********************************************************************************************************
    , q4 V. |" s. d! F
28. */
    8 }: h+ a/ ~0 m
29. __task void AppTaskUserIF(void)
    $ @) m( v2 [* ]4 O4 I# {- s( p+ m
30. {
    
31.      uint8_t ucMsg = 0;
    
32.      uint8_t ucKeyCode;
    ' B" Q, m. W8 w. F; e) a
33. 
    
34.     while(1)
    
35.     {
    & N  t; y% g! m) r8 h
36.          ucKeyCode = bsp_GetKey();
    
37.         
    : u5 z; l8 |2 h9 x$ e
38.          if (ucKeyCode != KEY_NONE)
    
39.          {
    
40.               switch (ucKeyCode)
    : N- f" k8 R$ e2 {2 R
41.               {
    1 z' C# j+ o# M; R
42.                    /* K1键按下，打印调试说明 */
    
43.                    case KEY_DOWN_K1:
    1 V. ]3 t7 d' V
44.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    , b. J4 h# b/ H5 t/ w8 g3 I
45.                        break;  
    
46. 
    
47.                    /* K2键按下，向消息邮箱发送数据 */
    
48.                    case KEY_DOWN_K2:
    
49.                        ucMsg++;
    
50.    
    % |6 e+ Q2 i% U1 x  `8 u: _# f
51.                        /* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
    & O# j7 T/ y9 g) s1 j2 a5 k
52.                        if(os_mbx_send (&mailbox, &ucMsg, 100) != OS_R_OK)
    ( y# C" ]: n* E3 c/ c, V; t5 q
53.                        {
    6 H0 Y! @9 M1 c
54.                             /* 发送失败，即使等待了100个时钟节拍 */
    / L! k% g: W( I$ S1 Q+ J4 K" |
55.                             printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
    . K1 [2 f( V/ ^' e; ^
56.                        }
    1 {9 e, J* R: y7 ~- ^8 F+ U% B5 f
57.                        else
    
58.                        {
    ; q" I# b0 n$ X
59.                             /* 发送成功 */
      C  s5 Q$ U9 K
60.                             printf("K2键按下，向消息邮箱发送数据成功\r\n");                          
    ( {& }, C) Q) J+ M7 C- A
61.                        }
    / ]7 k# c* D6 C; m
62. 
    
63.                        break;
    
64. 
    1 w# l, g4 c) H, ]; i
65.                    /* 其他的键值不处理 */
    " ~- F: C% b* q8 y/ X" J8 t" ^
66.                    default:                    
    3 k# f- {8 f* o+ [' `- V
67.                        break;
    
68.               }
    4 Q! ]) J0 I# `. y7 w: K- @
69.          }
    
70.         
    5 @6 G" L8 M+ w* g
71.          os_dly_wait(20);
    9 k$ ^. N8 `0 P1 r
72.      }
    
73. }

复制代码

. l5 H6 Y1 m  x+ b2 v
  o" s+ I/ n6 c. d

16.2.4 函数os_mbx_wait

函数原型：

1. OS_RESULT os_mbx_wait (
   
2.     OS_ID  mailbox,      /* 消息邮箱的ID标识 */
   
3.     void** message,      /* 存放消息指针的变量地址 */
   
4.     U16    timeout );    /* 超时时间设置 */

复制代码

# n4 J: M. `9 G4 G, P; \

函数描述：

函数os_mbx_wait用于从消息邮箱中获取消息。如果消息邮箱为空，调用此函数的任务将被挂起，直到消息邮箱有消息可用或是设置的超时时间溢出才会返回。

（1）第1个参数填写消息邮箱的ID标识，即函数os_mbx_declare第一个参数。

（2）第2个参数填写从消息邮箱中获取消息后，存放消息的指针变量。

（3）第3个参数表示设置的等待时间，范围0-0xFFFF，当参数设置为0-0xFFFE时，表示等待这么多个时钟节拍，参数设置为0xFFFF时表示无限等待直到消息邮箱有消息。

（4）返回值OS_R_OK，表示从消息邮箱中有消息，立即从消息邮箱中获得消息，无需等待。。

    返回值OS_R_TMO，表示消息邮箱为空，在设置的超时时间范围内也没有等到消息。

    返回值OS_R_MBX，表示在设置的超时时间范围内收到消息。

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

1.     使用此函数前一定要调用函数os_mbx_init进行初始化。

2.     此函数用于往消息邮箱放消息指针，另一个函数os_mbx_wait用于从消息邮箱取出消息指针，取出后相应的位置也就释放出来了，方便下次存放数据。

使用举例：

1. #include <rtl.h>
   
2. 
   4 Y! J! u) l7 j) b
3. /* 声明一个支持10个消息的消息邮箱 */
   ! g7 D6 A* r0 P/ w, D
4. os_mbx_declare (mailbox, 10);
   9 H; {) n' G7 ~
5. 
   : K6 A1 U6 C* }% F9 w9 m' V2 c& y/ l; J
6. /*
   / r! K4 F- B) Z1 A  Q
7. *********************************************************************************************************
   
8. *   函 数 名: AppObjCreate
   
9. *   功能说明: 创建任务通信机制
   
10. *   形    参: 无
      A. h* |( q) ]6 M  V! j0 Y" U  c# }
11. *   返 回 值: 无
    
12. *********************************************************************************************************
    
13. */
    : `" S' G$ C) c- X
14. static void AppObjCreate (void)
    & }& s8 N$ T8 D' @- M, i
15. {
    ) u( U8 I4 d% c. b' |
16.       /* 创建消息邮箱 */
    
17.       os_mbx_init (&mailbox, sizeof(mailbox));
    ) Y; \- ]% e9 e7 g# @# M% I
18. }
    : n& o* J6 C: v; G
19. 
    % X! x! d0 R0 V1 D/ s
20. /*
    
21. *********************************************************************************************************
    + x$ D( K8 y9 |# u
22. *    函 数 名: AppTaskMsgPro
    7 K; D. t" l8 I1 H2 i/ z
23. *    功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据
    
24. *    形    参: 无
    " ~7 x( a% ?1 R/ s5 R
25. *    返 回 值: 无
    6 S% G- C+ A( a% z0 l! }3 m
26. *   优 先 级: 3
    , P2 \/ F7 |. h* X, ?
27. *********************************************************************************************************
    ) O8 F! e  P* R$ m% A4 g
28. */
    % v& n8 m: h, M
29. __task void AppTaskMsgPro(void)
    
30. {
    + G# Q' d# b2 \1 u# [7 s7 k: t
31.      uint8_t *pMsg;
    
32.      OS_RESULT xResult;
    
33.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    
34.    
    
35.     while(1)
    
36.     {
    
37.          xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
    0 X6 c2 W3 Z+ M3 s9 B6 u6 p8 e$ \
38.         
    % j* S! e1 U* j, H$ S" c  L+ B) c
39.          switch (xResult)
    ) }9 |  _$ A7 n! {& |7 C
40.          {
    % i" p  b3 Q* [; V8 I1 e0 G
41.               /* 无需等待接受到消息邮箱数据 */
    
42.               case OS_R_OK:
    ; K0 g) d7 c( ^# o1 n
43.                    printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
    
44.                    break;  
    
45. 
    
46.               /* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
    
47.               case OS_R_MBX:
    
48.                    printf("消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
    
49.                    break;
    
50. 
    
51.               /* 超时 */
    + g& D, _5 L! t% q
52.               case OS_R_TMO:
    
53.                    bsp_LedToggle(1);
    
54.                    bsp_LedToggle(4);
    / H; {, i" S* e- n8 o) ^
55.                    break;
    5 q8 j3 \! v9 Z7 O
56.             
    
57.               /* 其他值不处理 */
    
58.               default:                    
    
59.                    break;
    
60.          }   
    
61.     }
    
62. }

复制代码

这里对函数os_mbx_wait的第二个参数再做一下解释。

（1）定义一个指针变量uint8_t *pMsg，含义：pMsg是指向uint8_t型变量的指针变量。

（2）指针变量pMsg（注意，这里说的是pMsg，不是*pMsg，前面没有*号）在内存中也是要占空间的，对于CM3/CM4内核来说是占用4个字节。指针变量pMsg里面存储的就是从消息邮箱中获取的消息指针，或者说消息地址。从而*pMsg就是pMsg所指向存储单元的实际内容。

（3）由于函数os_mbx_wait第二个参数是void **message，有两级指针，所以填写的时候要填写成os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime)。&pMsg就是表示指针变量在内存所在的地址。

（4）这里再说说void 指针类型，使用void指针类型可定义一个指针变量，但不指定它是指向哪一种类型的数据。用户在使用这种类型指针变量时可以用来指向一个抽象的类型的数据，在将它的值赋值给另一个指针变量时要进行强制类型转换使之适合于被赋值的变量的类型。比如：

    char *p1;

    void *p2;

    p1 = (char *)p2

    如果细心的同学会发现，邮箱发送函数os_mbx_send和接收函数os_mbx_wait消息指针传递都是用的void指针类型，这样就给消息数据传递带来了极大的方便，方便在哪里了呢？这样的话使用消息邮箱传递任意数据类型变量都变的十分方便，用户只需做一下强制类型转换即可。

0 _5 q* N4 O* u8 I  c' c% @16.2.5 函数isr_mbx_check

函数原型：

1. OS_RESULT isr_mbx_check (
   
2.     OS_ID mailbox );    /*消息邮箱的ID标识*/

复制代码

函数描述：

函数isr_mbx_check用来检测消息邮箱剩余空间可以存储的消息个数。建议配合函数isr_mbx_send一起使用。

u 第1个参数填写消息邮箱的ID标识，即函数os_mbx_declare第一个参数。

u 函数返回消息邮箱剩余空间可以存储的消息个数。

/ E8 @, ^0 l0 F. i) ]' G4 c

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

1.     使用此函数前一定要调用函数os_mbx_init进行初始化。

2.     此函数只能在中断服务程序中调用。

使用举例：

在中断服务程序中仅发一个消息

1. #include <rtl.h>
   
2. 
   
3. /* 声明一个支持10个消息的消息邮箱 */
   + q" H* ~% C/ @# s. {  x
4. os_mbx_declare (mailbox, 10);
   
5. 
   - R; U, _/ e$ d
6. static void AppObjCreate (void)
   
7. {
   
8.     /* 创建消息邮箱 */
   ! _9 T4 G7 o) F- @* m, g( s9 [
9.     os_mbx_init (&mailbox, sizeof(mailbox));
   
10. }
    $ O! B9 C, H9 `# h% ~% W: O% `
11. 
    + |- G1 B1 n* \
12. void EXTI0_IRQHandler (void){
    5 V1 I9 G6 V% p2 d% Y2 o
13.    ..
    & R) T) i$ g3 R2 ~
14. if (isr_mbx_check (&mailbox) != 0) {
    
15.       isr_mbx_send (&mailbox, msg);
    
16.    }
    
17.    ..
    
18. }

复制代码

& {; T* y6 X5 ]6 ?' e

在中断服务程序中发多个消息

1. #include <rtl.h>
     Q2 Q5 e8 a* Y: f; G6 B
2. 
   0 G4 d+ n) B8 \* S
3. /* 声明一个支持10个消息的消息邮箱 */
   9 g' {9 t$ l6 F; r5 I- }
4. os_mbx_declare (mailbox, 10);
   
5. 
   ; [) P/ |/ m0 |' v) K* q
6. static void AppObjCreate (void)
   " m: V2 g2 T2 U' E" l
7. {
   1 {  p! q4 [. x
8.     /* 创建消息邮箱 */
   . n& ?& k9 u1 q* I
9.     os_mbx_init (&mailbox, sizeof(mailbox));
   ) k; L* f+ s9 Z  v" V! U
10. }
    , H" B. b8 P( v. O) D$ `
11. 
    
12. void EXTI0_IRQHandler (void){
    , [( E' E5 x* h8 s! @
13.   int i,free;
      w( S: i, l) l$ a1 D: x7 Z
14.    ..
    1 D7 M2 W7 y8 c$ O* S
15.   free = isr_mbx_check (&mailbox1);
    # d& N5 M8 t7 o6 b# W* D% J
16.   for (i = 0; i < 16; i++) {
    2 |' u: Y# }/ r" ~7 ?6 {. p
17.     if (free > 0) {
    
18.       free--;
    
19.       isr_mbx_send (&mailbox1, msg);
    
20.     }
    % g( s% I3 m- o
21.   }
    
22.    ..
    , s% f0 i9 o3 I1 l, H" Q/ M& k* q
23. 
    
24. }

复制代码

2 n, w. @2 W9 O% A+ t  \* `16.2.6 函数isr_mbx_send

函数原型：  

1. void isr_mbx_send (
   5 G# P" C4 t) z( v. Z* @
2.     OS_ID mailbox,          /*消息邮箱的ID标识*/
   $ w) }- X, J  K7 q5 ?3 z
3.     void* message_ptr );    /* 消息指针，即数据的地址*/

复制代码

1 p% S  }' M+ i% N

函数描述：

函数isr_mbx_send用于向消息邮箱存放数据指针，或者说数据地址。如果消息邮箱已经满了，再次调用此函数会造成消息邮箱溢出。所以调用此函数前，强烈建议调用函数isr_mbx_check进行检测，检测是否还有空间可用。

（1）第1个参数填写消息邮箱的ID标识，即函数os_mbx_declare第一个参数。

（2）第2个参数填写消息指针，即数据的地址。

- z( r7 {0 C0 f! p

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

1.     使用此函数前一定要调用函数os_mbx_init进行初始化。

2.     为了防止消息邮箱溢出，强烈建议调用此函数前，先调用函数isr_mbx_check进行检测，检测是否还有空间可用。

使用举例：

在中断服务程序中仅发一个消息

1. #include <rtl.h>
   7 [  z" _- `$ I6 x
2. 
   
3. /* 声明一个支持10个消息的消息邮箱 */
   & T2 o; P# R( Z; j! |3 P
4. os_mbx_declare (mailbox, 10);
   1 l9 y. [( z6 C, m4 |1 k# f
5. 
   
6. static void AppObjCreate (void)
   9 d/ Z6 V& k: L% X$ _% j/ R
7. {
   + e4 i  ?, M& `2 {- d0 u
8.     /* 创建消息邮箱 */
   
9.     os_mbx_init (&mailbox, sizeof(mailbox));
   
10. }
    7 K' v$ R# `) c: D' K) R; T
11. 
    # w! k) ]9 h: |3 r
12. void EXTI0_IRQHandler (void){
    
13.    ..
    
14. if (isr_mbx_check (&mailbox) != 0) {
    5 t2 J. a" U9 h6 n
15.       isr_mbx_send (&mailbox, msg);
    5 a( E+ M; Q8 J+ Y7 _0 m) o1 ]$ }
16.    }
    
17.    ..
    
18. }

复制代码

在中断服务程序中发多个消息

1. #include <rtl.h>
   
2. 
   - e3 o& T# j2 ]$ }% t. e
3. /* 声明一个支持10个消息的消息邮箱 */
   1 z  R9 c& S9 l7 N' l
4. os_mbx_declare (mailbox, 10);
     ^) p3 _; i: _1 `8 H/ R
5. 
   $ u3 Y, I% e+ n7 p; U6 w
6. static void AppObjCreate (void)
   . C, L4 N5 B8 l/ F
7. {
   : Y9 Q+ d, n+ K- S1 B5 O: t
8.     /* 创建消息邮箱 */
   
9.     os_mbx_init (&mailbox, sizeof(mailbox));
   
10. }
    6 a4 e. X9 e8 d  q& S
11. 
    
12. void EXTI0_IRQHandler (void){
    
13.   int i,free;
    
14.    ..
    & D: N' v0 F3 K, ~  d" \
15.   free = isr_mbx_check (&mailbox1);
    
16.   for (i = 0; i < 16; i++) {
    
17.     if (free > 0) {
    ) U: u  [: f* e6 s$ w. I3 d
18.       free--;
    
19.       isr_mbx_send (&mailbox1, msg);
    
20.     }
    
21.   }
    
22.    ..
    
23. 
    
24. }

复制代码

/ I' {4 e1 d: q6 N  P

16.3 实验例程说明(任务间通信)
16.3.1 STM32F103开发板实验

配套例子：

    V4-414_RTX实验_消息邮箱

实验目的：

   1.     学习RTX的消息邮箱。

   2.     RTX的消息邮箱等同于uCOS的消息队列，uCOS的消息邮箱仅支持一个消息的收发。

实验内容：

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

    2. K2键按下，向消息邮箱发送数据。任务AppTaskMsgPro接收到消息后进行消息处理。

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

   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初始化：

1. /*
   ; ?' c# Z( K0 Y1 q  O8 E) [
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: 标准c程序入口。
   8 Z: R& Z% l9 f% I0 s3 V9 Z$ R
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   - Z% \4 n+ t& C# ~* @. M6 r! M5 p
8. */
   ' _, a% m2 _5 h8 t! S; e
9. int main (void)
   * L7 }5 d' F. p+ x: x
10. {   
    & ^2 b, L6 O! K0 ~8 C2 K
11.      /* 初始化外设 */
    
12.      bsp_Init();
    
13.    
    ) m: x; Y: r3 B# Z  ?" u
14.      /* 创建启动任务 */
    
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
    $ a: L! `; U# z8 U) j
20. }

复制代码

; T6 H3 N4 d. c6 }

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   ; {$ x9 S" C- j/ ], `* `# f) r( a  p
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   9 s5 c- {- s* Y
5. *    形    参: 无
   
6. *    返 回 值: 无
   + ^# G) r: a  ~+ g8 b8 A: M6 i
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    ; T% P& A5 C- w
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    1 r6 W6 I) V  G: [; c
15.    
    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    6 P! ^' }  R& j0 A0 E/ ?
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    6 z8 ]0 v, p1 t5 v1 c" T* J
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    9 l6 L6 @! U$ n) h$ e  P
20.    
    + y% C) |+ j  I# y0 s, A
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    0 D# _& H6 F0 o) d
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

0 u. }) ~- [. E* j, \7 I  X

创建消息邮箱：

1. /* 声明一个支持10个消息的消息邮箱 */
   
2. os_mbx_declare (mailbox, 10);
   
3. 
   / N9 x- A; B4 Q$ e
4. /*
   
5. *********************************************************************************************************
   3 s& \# J3 b$ y3 C/ X* q
6. *    函 数 名: AppObjCreate
   
7. *    功能说明: 创建任务通信机制
   
8. *    形    参: 无
   
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    
12. static void AppObjCreate (void)
    
13. {
    
14.      /* 创建消息邮箱 */
    
15.       os_mbx_init (&mailbox, sizeof(mailbox));
      g( W9 {  l% C, D8 i
16. 
    
17. }

复制代码

四个RTX任务的实现：

1. /*
   7 P% G4 U9 u. T, \* A
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskUserIF
   6 R& Z6 O; ^: K, X( X2 g
4. *    功能说明: 按键消息处理     
   ! O; d. Y# u+ ~' z& f+ d
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
8. *********************************************************************************************************
   
9. */
   9 Z7 i( J; a3 L3 l2 ~" ~7 d" \
10. __task void AppTaskUserIF(void)
    
11. {
    
12.      uint8_t ucMsg = 0;
    6 t9 M+ e: I/ y2 ]" q* R; z
13.      uint8_t ucKeyCode;
    
14. 
    3 X9 z# r$ K+ ~/ y2 X
15.     while(1)
    ( e4 ^5 o8 I" ], }8 a3 |8 a  T0 v
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    " l. d/ C5 @4 _, S8 q
20.          {
    ' u! D: O9 @1 _6 X! P% F  U, A: P
21.               switch (ucKeyCode)
    
22.               {
    
23.                    /* K1键按下，打印调试说明 */
    
24.                    case KEY_DOWN_K1:
    8 {) q0 ]1 P. e$ Z& C3 G
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    ' S: V3 L. x  Y1 l
26.                        break;  
    $ O, `- q% l& p( S3 h
27. 
    
28.                    /* K2键按下，向消息邮箱发送数据 */
    
29.                    case KEY_DOWN_K2:
    " L! k4 K0 ?! X) C4 v' L7 F$ j
30.                        ucMsg++;
    
31.    
    
32.                        /* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
    
33.                        if(os_mbx_send (&mailbox, &ucMsg, 100) != OS_R_OK)
    " l' ~( s7 K5 b, ]. u! X
34.                        {
    ) E7 c# n7 @; \
35.                             /* 发送失败，即使等待了100个时钟节拍 */
    2 \8 r- m1 f% l0 O5 a8 Z# Y/ `
36.                             printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
    $ h4 O% D. V: ?# @  J
37.                        }
    4 D. D% Q; g9 ?1 x  H7 b
38.                        else
    
39.                        {
    " p6 Q2 T6 ~5 A+ K/ C
40.                             /* 发送成功 */
    
41.                             printf("K2键按下，向消息邮箱发送数据成功\r\n");                          
    
42.                        }
    
43. 
    & G, m9 Y$ H' N) M3 X5 Y
44.                        break;
    + v  F3 n  m9 E9 p1 v2 T6 p
45. 
    3 Q4 s: s0 k$ y/ k! _3 a
46.                    /* 其他的键值不处理 */
    
47.                    default:                    
    " d$ y) s5 A7 t4 |
48.                        break;
    
49.               }
    
50.          }
    
51.         
    
52.          os_dly_wait(20);
    3 f% |9 q+ e8 E% I! c; t* s
53.      }
    
54. }
    5 S5 s/ }5 F* W  a
55. 
    
56. /*
    9 ?  v3 {$ q' o3 N/ S
57. *********************************************************************************************************
    * V& s6 `8 S5 E" e# L0 r( L
58. *    函 数 名: AppTaskLED
    
59. *    功能说明: LED闪烁。
    - J* V, q& a' ?6 q) p0 J
60. *    形    参: 无
    
61. *    返 回 值: 无
    , `) P# g2 m6 X: F; F
62. *   优 先 级: 2
    / R9 {( f+ t' A% T% n' G
63. *********************************************************************************************************
    , ~' r  z& U! J% F. f
64. */
    
65. __task void AppTaskLED(void)
    5 _) |) V5 \, k# b
66. {
    
67.      const uint16_t usFrequency = 200; /* 延迟周期 */
    0 ]. P3 o% X1 s6 i' g7 l, ]$ R
68.    
    - n8 m, V! l- h* q2 _
69.      /* 设置延迟周期 */
    / d( e3 C4 v0 K8 \
70.      os_itv_set(usFrequency);
    
71.    
    
72.     while(1)
    
73.     {
    ' P4 c$ w* L! p. v# N5 N9 p9 @
74.          bsp_LedToggle(2);
    7 `. H3 ~* E: Z. |  ^5 ]
75.          bsp_LedToggle(3);
    ; d# F5 P! a& a
76. 
    
77.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
78.          os_itv_wait();
    
79.     }
    . W! m8 [4 y1 x) x
80. }
    ( p" X1 r0 z( N1 H0 T
81. 
    
82. /*
    
83. *********************************************************************************************************
    
84. *    函 数 名: AppTaskMsgPro
    2 d" u' x: X. p7 T' R; |
85. *    功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据
    0 N' ]: r3 M* K; c0 J* }$ y) S
86. *    形    参: 无
    * J+ r2 u# l# N( i2 a* ?
87. *    返 回 值: 无
    
88. *   优 先 级: 3
    # z7 B# _8 _# b7 b
89. *********************************************************************************************************
    ( K1 G  R* Y6 |7 J3 k- A& |
90. */
    $ V5 T9 d5 B6 I; d
91. __task void AppTaskMsgPro(void)
    
92. {
    
93.      uint8_t *pMsg;
    
94.      OS_RESULT xResult;
    
95.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    $ G5 j, m: ?  W5 z0 F, \$ B
96.    
    
97.     while(1)
    / h" d8 Y1 I" x0 o* w; U$ O
98.     {
    2 n, o) ^8 `: b- M6 o8 p
99.          xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
    , T) g, r7 E! S4 O; @
100.         
     & }9 T# Q! ?# ?' `  E: A' w% v
101.          switch (xResult)
     * n" E* f. H2 N  k: X& D
102.          {
     . A# n" c% W' g2 j
103.               /* 无需等待接受到消息邮箱数据 */
     
104.               case OS_R_OK:
     
105.                    printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
     9 Z& o: z# O% E7 F* x
106.                    break;  
     
107. 
     & s) O2 K8 P7 o% s6 e2 {/ g
108.               /* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
     
109.               case OS_R_MBX:
     % @+ H4 E% O  c' Y
110.                    printf("消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
     # t' B4 v  |, f
111.                    break;
     7 Y8 V8 R$ R- l  j4 {
112. 
     0 S& f3 S9 ]. f8 n
113.               /* 超时 */
     
114.               case OS_R_TMO:
     % b& ], K9 W* ^: L& D
115.                    bsp_LedToggle(1);
     
116.                    bsp_LedToggle(4);
     9 B4 Q- N& |3 k9 }
117.                    break;
     
118.             
       C* W& P' q' k  n4 q+ L7 r
119.               /* 其他值不处理 */
     
120.               default:                    
     
121.                    break;
       o% j& N- \) ]" Z) \' k8 m3 o
122.          }   
     0 }" B9 C4 \5 Z5 j2 A6 c9 B5 m  ^
123.     }
     
124. }
     & x  K6 S  P! n$ j8 U( l+ W
125. 
     
126. /*
     " S. w4 u' j4 E
127. *********************************************************************************************************
     
128. *    函 数 名: AppTaskStart
       {6 n( Q) ^9 N( M4 a
129. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     6 s1 s* ?0 E( B- F1 b0 H# g
130. *    形    参: 无
     
131. *    返 回 值: 无
     ; w6 [, W' @: e9 |% e
132. *   优 先 级: 4
     
133. *********************************************************************************************************
     9 \: S8 U2 l8 Y0 V- S2 F1 F' V; v7 l( s
134. */
     
135. __task void AppTaskStart(void)
     
136. {
     
137.      /* 创建任务 */
     
138.      AppTaskCreate();
     1 i7 C  v: W* h! \. \
139.    
     7 H! v8 e' D$ _' W
140.      /* 创建任务通信机制 */
     6 {* [- y; H) _
141.      AppObjCreate();
     6 e, P. t$ C2 o5 [4 Z4 J6 |8 P
142.    
     
143.     while(1)
     / L; ^" [: ?' ~$ ^( J7 M
144.     {
     
145.         /* 按键扫描 */
     
146.         bsp_KeyScan();
     ' Q0 j, R' w3 O- l- p/ z
147.         os_dly_wait(10);
     2 D, D9 q$ C  c/ ]7 B% T
148.     }
     0 j$ p  C, R1 o5 p
149. }

复制代码

/ A; t% W) O' [- W" B! ~

8 T& Y- e/ i; Q

16.3.2   STM32F407开发板实验

配套例子：

    V5-414_RTX实验_消息邮箱

实验目的：

    1.     学习RTX的消息邮箱。

    2.     RTX的消息邮箱等同于uCOS的消息队列，uCOS的消息邮箱仅支持一个消息的收发。

实验内容：

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

    2. K2键按下，向消息邮箱发送数据。任务AppTaskMsgPro接收到消息后进行消息处理。

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

  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初始化：

1. /*
   / e/ d( V7 h! ~/ s, U& R
2. *********************************************************************************************************
   
3. *    函 数 名: main
   7 L5 I- y1 W* V6 w: K. {
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   ' T5 G; a! l- y
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   * N8 L& o* F; G6 t4 `: @! }% j
8. */
   8 M; i8 `- M+ c6 y; i0 @6 o. K
9. int main (void)
   
10. {   
    
11.      /* 初始化外设 */
    9 w: H7 ~' f% ^
12.      bsp_Init();
    
13.    
    7 j8 \- q. W) c6 K& |+ X9 q
14.      /* 创建启动任务 */
    5 n* q1 P( u( e' E+ |. `) X
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    4 C5 p) w( H4 S4 h# f
19.      while(1);
    7 X4 U1 |8 k3 q3 {& A
20. }

复制代码

: f9 v2 j3 C% b

RTX任务创建：

1. /*
   * R; f3 ?" j0 a
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   0 m! B0 [/ I. w0 n
5. *    形    参: 无
   . D0 k& k2 s3 D, X* Z. X
6. *    返 回 值: 无
   1 I+ ~" b3 k( o1 `
7. *********************************************************************************************************
   , r) ]3 v4 R; N4 r' C7 M/ S
8. */
   ; O3 m: N2 m0 p# U. J; V; u
9. static void AppTaskCreate (void)
   
10. {
    ' J0 e! H; n( S" \# D! U
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    " k. N8 _, m: C7 m6 U! J) L- H
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    3 w* F, k: i, @4 ~- ?
17.                                         2,                       /* 任务优先级 */
    8 O: k. x. R2 \
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    4 ]( ?- {- ?5 K  D
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    
20.    
    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    & q4 c8 W- X& N+ h
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    ; L) e: u1 Q' c% q
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    9 f1 r! `, K  \- P5 K# L2 @
25. }

复制代码

创建消息邮箱：

1. /* 声明一个支持10个消息的消息邮箱 */
   2 z. i5 K* e) a
2. os_mbx_declare (mailbox, 10);
   
3. 
   2 q! |1 W  k5 `  Z( A
4. /*
   5 G6 h& N# X/ O
5. *********************************************************************************************************
   
6. *    函 数 名: AppObjCreate
   " E: F% z; p' b# Y4 ~
7. *    功能说明: 创建任务通信机制
   
8. *    形    参: 无
   3 {( N0 S1 D$ }: O1 \1 l
9. *    返 回 值: 无
   
10. *********************************************************************************************************
      c% `; {/ Z7 u& V* e% p. E0 R$ b
11. */
    & c' C  ^. |; ?4 T
12. static void AppObjCreate (void)
    
13. {
    ; r7 m! X9 R( U' s, `
14.      /* 创建消息邮箱 */
      Z% x2 ~' A& ^: f
15.       os_mbx_init (&mailbox, sizeof(mailbox));
    
16. 
    ( @  }3 @7 M5 U; o$ Q) g4 |
17. }

复制代码

+ l, d$ ?- m$ n6 ]

四个RTX任务的实现：

1. /*
   7 z- q, u9 `* u# O+ J0 J* K3 z
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskUserIF
   
4. *    功能说明: 按键消息处理     
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   & |  ?, p0 |" ~; k  w5 Y
8. *********************************************************************************************************
   
9. */
   
10. __task void AppTaskUserIF(void)
    
11. {
    2 ^( j' u- g9 @1 C
12.      uint8_t ucMsg = 0;
    
13.      uint8_t ucKeyCode;
    9 D7 v3 L; h. P8 T4 m* W/ ]
14. 
    
15.     while(1)
    , a7 A% s4 l  {# B+ B. E* A
16.     {
    & `+ m& C+ _$ [" I  h% Z
17.          ucKeyCode = bsp_GetKey();
    
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    
20.          {
    - v. Q1 h& J! u4 h/ ~4 N
21.               switch (ucKeyCode)
    2 @! y! n& q( I/ i6 F' L" E) l
22.               {
    
23.                    /* K1键按下，打印调试说明 */
    ( `% P' Y  a/ s  @' j3 n! ~3 _8 i
24.                    case KEY_DOWN_K1:
    
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    3 {+ c5 _! l5 p/ z% ^7 d, t
26.                        break;  
    & s2 |2 E  r' Q2 N, ?
27. 
    / G- x! ~% i6 S& `  T
28.                    /* K2键按下，向消息邮箱发送数据 */
    
29.                    case KEY_DOWN_K2:
    5 G8 E+ u) Y& F5 [
30.                        ucMsg++;
    ; N% w) ~8 G0 r: c( I; R& g
31.    
    
32.                        /* 向消息邮箱发数据，如果消息邮箱满了，等待100个时钟节拍 */
    
33.                        if(os_mbx_send (&mailbox, &ucMsg, 100) != OS_R_OK)
    , G7 I. V& Q" G; D* i: V* e
34.                        {
    
35.                             /* 发送失败，即使等待了100个时钟节拍 */
    
36.                             printf("K2键按下，向消息邮箱发送数据失败，即使等待了100个时钟节拍\r\n");
    
37.                        }
    
38.                        else
    1 Z: }7 K/ |& V% I3 G
39.                        {
    % e% Z7 Y4 |3 i
40.                             /* 发送成功 */
    
41.                             printf("K2键按下，向消息邮箱发送数据成功\r\n");                          
    + t2 A8 e6 o  n3 q  u: l/ ?
42.                        }
    
43. 
    
44.                        break;
    2 b7 H$ K# b: z- [+ p( @
45. 
    , t" a( ~) h1 i4 G  ^" d: b
46.                    /* 其他的键值不处理 */
    8 m1 Y/ e8 m8 O5 F6 ^( S
47.                    default:                    
    0 g4 r0 k! H7 C
48.                        break;
    ; I8 t' t* J  |+ P: J; c# i
49.               }
    7 f8 X. f1 J3 `2 n3 b/ W# k
50.          }
    
51.         
    9 N. D3 f$ {: W4 \
52.          os_dly_wait(20);
    5 H+ _. H/ Q! l4 T) t& `/ {
53.      }
    
54. }
    ' L- L& l8 p5 U" n. m! N
55. 
    / o& l, L+ r0 {# f3 \0 w; g
56. /*
    
57. *********************************************************************************************************
    . Z: Y  F+ z# P, m) }
58. *    函 数 名: AppTaskLED
    3 s6 O4 G% A5 d' x
59. *    功能说明: LED闪烁。
    " l* C8 g  J% g, \3 o
60. *    形    参: 无
    
61. *    返 回 值: 无
    7 z+ p% o/ k& ?0 z$ F
62. *   优 先 级: 2
    
63. *********************************************************************************************************
    + P- h4 u0 X* Q* R  M& l5 r( q5 e+ }
64. */
    % @1 Q) Q) O  n
65. __task void AppTaskLED(void)
    2 u) F* l& \$ Q
66. {
    8 x% M  b! w# ?* V9 m. E
67.      const uint16_t usFrequency = 200; /* 延迟周期 */
    # v& [! D: v. C5 Q& i
68.    
    
69.      /* 设置延迟周期 */
    * X( g6 j# K5 s! @
70.      os_itv_set(usFrequency);
    4 U9 K0 B, g+ K9 V
71.    
    
72.     while(1)
    
73.     {
    * R% i  k: M- o, |
74.          bsp_LedToggle(2);
    ; y" k: y7 A# N
75.          bsp_LedToggle(3);
    . }# Q1 W  P, o) e' w
76. 
    
77.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
78.          os_itv_wait();
    
79.     }
    
80. }
    
81. 
    % Y# N# n5 s5 E; g! n2 x
82. /*
    ; c8 W# ~0 }. [# ?
83. *********************************************************************************************************
    
84. *    函 数 名: AppTaskMsgPro
    ! i3 U, M- t! j' G
85. *    功能说明: 消息处理，等待任务AppTaskUserIF发来的消息邮箱数据
    2 K. ?, P) {. L# `9 O* H- q% t
86. *    形    参: 无
    
87. *    返 回 值: 无
    $ H: [1 ~1 Q, ~
88. *   优 先 级: 3
    + v0 U: g8 |4 U- S/ x( t2 C2 w
89. *********************************************************************************************************
    
90. */
    5 g. |: }( ^/ X% @' V
91. __task void AppTaskMsgPro(void)
    % Z- X+ Y/ d7 z
92. {
    
93.      uint8_t *pMsg;
    
94.      OS_RESULT xResult;
    0 R; f! r1 Z  C! V3 s: z
95.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    ) A; O! k+ H2 U1 R" ~+ x0 F
96.    
    
97.     while(1)
    * B6 P) v- x5 v: L# I" \
98.     {
    
99.          xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
    9 F6 N: g5 k. {1 S! B! j( E  v7 C
100.         
     % S" d+ M2 ]3 v1 A2 R* u
101.          switch (xResult)
     
102.          {
     
103.               /* 无需等待接受到消息邮箱数据 */
     
104.               case OS_R_OK:
     " A3 @& W) D0 n  Y3 ^1 f
105.                    printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
     
106.                    break;  
     2 O) B. I4 ^# K; O. V2 e
107. 
     
108.               /* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
     8 P, Y3 L# A7 x, k/ u- q
109.               case OS_R_MBX:
     
110.                    printf("消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
     
111.                    break;
     
112. 
     : ?( q: A1 E4 P* i6 @
113.               /* 超时 */
     
114.               case OS_R_TMO:
     
115.                    bsp_LedToggle(1);
     
116.                    bsp_LedToggle(4);
     
117.                    break;
     3 \  K  K+ c' [7 f# v
118.             
     
119.               /* 其他值不处理 */
     
120.               default:                    
       _6 @( r* w/ R7 m
121.                    break;
     + E% `1 |+ D/ |  b2 E2 h1 C5 T
122.          }   
     . }& T% O  p- [$ s2 q
123.     }
     
124. }
     
125. 
     % `, }# n6 O2 K' Y8 m
126. /*
     
127. *********************************************************************************************************
     
128. *    函 数 名: AppTaskStart
     : I2 Z) l( y  r; ?9 K/ s8 D
129. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     
130. *    形    参: 无
       N: W9 i$ J5 M! Y, y5 ^7 U, @4 t7 b
131. *    返 回 值: 无
     
132. *   优 先 级: 4
     ; G5 x' L: N6 z
133. *********************************************************************************************************
     
134. */
     ) ?' q% I2 U3 e. w8 @4 u2 F
135. __task void AppTaskStart(void)
     % q: q! A) g( x$ ?  y7 i8 r9 D, N
136. {
     % G7 e4 f6 B: r0 Y6 c# p) g$ b; i% P4 u
137.      /* 创建任务 */
     + W$ q$ G, N: A' ]: T& [9 B
138.      AppTaskCreate();
     
139.    
     
140.      /* 创建任务通信机制 */
     ; d9 m+ q4 k2 w5 j9 F& j
141.      AppObjCreate();
     
142.    
     ( b/ p# m5 s, y6 z8 ~
143.     while(1)
     
144.     {
     
145.         /* 按键扫描 */
     
146.         bsp_KeyScan();
     
147.         os_dly_wait(10);
     
148.     }
     
149. }

复制代码

16.4 实验例程说明（中断方式通信）
2 `2 P& y2 U7 W8 b$ m16.4.1 STM32F103开发板实验

配套例子：

    V4-415_RTX实验_消息邮箱（中断方式）

实验目的：

    1.     学习RTX的消息邮箱（中断方式）

实验内容：

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

     2.K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消息邮箱数据。任务AppTaskMsgPro接收到消息后进行消息处理。

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

    AppTaskUserIF任务  ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

    AppTaskMsgPro任务 ：消息处理，等待定时器中断发来的消息邮箱数据。

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

RTX配置：

     RTX配置向导详情如下：

                              

Task Configuration

Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

                AppTaskMsgPro任务 ：消息处理，等待定时器中断发来的消息邮箱数据。

                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初始化：

1. /*
   5 U4 Y4 |5 c  h: Z* g
2. *********************************************************************************************************
   
3. *    函 数 名: main
     }- u( O, r! i) J; q0 M9 I
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   9 s5 r# H% W% h8 P; o6 i5 c
6. *    返 回 值: 无
   % ^/ {' \8 f0 [4 p
7. *********************************************************************************************************
   
8. */
   
9. int main (void)
   & b/ g1 z  U0 j* P3 f/ e
10. {   
    
11.      /* 初始化外设 */
    " a& Q/ @2 `. x2 u  g0 g9 t, C' P
12.      bsp_Init();
    
13.    
    
14.      /* 创建启动任务 */
    , R) k' u  x7 F
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    1 V+ H5 S+ G, Q1 Z
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    9 a. Q" i0 F- D+ D' _1 m
19.      while(1);
    3 b4 E# P& @4 ]5 \! ^
20. }

复制代码

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   , v. x3 G# ]' Z1 `9 l% q
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   ( R- {1 X0 W8 a' r
6. *    返 回 值: 无
   . u& H5 z" h, Y  ^" M
7. *********************************************************************************************************
   - Z6 I  K6 ^/ \. v/ z
8. */
   
9. static void AppTaskCreate (void)
   0 j  `3 i/ a* W( V0 o
10. {
    6 a$ L& J* o, S
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    # b) M. t& K; e9 w/ I1 X
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    2 U8 _8 y' g& M0 K
15.    
    # W  g% ]# p1 g2 {
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    : O2 ~5 Q* [* w1 G8 G
20.    
    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    8 u2 C1 x0 F  [0 v5 \* O% \0 l
22.                                            3,                         /* 任务优先级 */
    0 W  e- e5 X8 |. Q. x" C" ^5 w
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    7 k/ A6 j' \" o* B- q9 q8 C
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

创建消息邮箱：

1. /* 声明一个支持10个消息的消息邮箱 */
   
2. os_mbx_declare (mailbox, 10);
   6 K2 a5 z* I9 w7 m
3. 
   
4. /*
   ) A9 d5 U* @) @2 J3 _$ _+ q& J
5. *********************************************************************************************************
   
6. *    函 数 名: AppObjCreate
   
7. *    功能说明: 创建任务通信机制
   " v- d6 N+ r& X7 l9 Q
8. *    形    参: 无
   
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    0 R6 \  U3 T, h7 T+ ~2 ]
11. */
    
12. static void AppObjCreate (void)
    ' a0 |# @: T9 i' ~* Z
13. {
    ! Q0 n: P. U3 I( Z0 p
14.      /* 创建消息邮箱 */
    ; N/ l, b& L5 z: T3 h1 n
15.       os_mbx_init (&mailbox, sizeof(mailbox));
    
16. 
    : i; i& S$ T, l' {3 ^9 O4 W  [
17. }

复制代码

  M" b0 @) }# g# l1 o( q  O

四个RTX任务的实现：

1. /*
   
2. /*
   $ C8 T' W5 x9 W; A% X
3. *********************************************************************************************************
   
4. *    函 数 名: AppTaskUserIF
   # L+ q9 }" I3 z% d5 a
5. *    功能说明: 按键消息处理     
   
6. *    形    参: 无
   # |# u' q, v1 I0 `; G- Q
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   ' d) O5 N! y8 o1 v4 z' u' y
9. *********************************************************************************************************
   
10. */
    4 e0 g: P0 f0 G( ?
11. __task void AppTaskUserIF(void)
    : P% w3 ]! t, i' R
12. {
    
13.      uint8_t ucKeyCode;
    
14. 
    
15.     while(1)
    
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    / o. t7 K% j$ B! D4 S6 b7 T6 w8 J
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    
20.          {
    0 ]5 K) `! L* Q5 ^6 V! l# o( `
21.               switch (ucKeyCode)
    
22.               {
    
23.                    /* K1键按下，打印调试说明 */
    : A9 H  S2 f! X! B
24.                    case KEY_DOWN_K1:
    " n3 Y! ]8 f. K- B& z
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    ; F% [; \; x( R$ d4 o3 M' p7 _$ c
26.                        break;  
    
27.                   
    
28.                    /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消息邮箱数据 */
    " f# Q( Q" F1 S& M3 ^: s
29.                    case KEY_DOWN_K2:
    : H. M+ m1 }7 ?5 z' A
30.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消
    8 B) x( ^; P+ Z% q/ K' u7 U7 A
31. 息邮箱数据\r\n");
    ) s7 f; N; M+ V
32.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
    
33.                        break;
    ! @4 ~2 }0 ], A9 F9 C9 v
34. 
    
35.                    /* 其他的键值不处理 */
    7 R  t2 Q, f  n$ O: W2 C, S) O
36.                    default:                    
    
37.                        break;
    # P- @4 M9 \* R6 t
38.               }
    
39.          }
    4 W. v* i5 e+ b
40.         
    
41.          os_dly_wait(20);
    3 |3 S' H+ o3 q0 r, E
42.      }
    ; \% r1 o4 @  e8 ^- t/ ^# K& B
43. }
    
44. 
    * M* D/ r. Z. o0 V. a
45. /*
    
46. *********************************************************************************************************
    1 z6 ?( p  a1 C% L
47. *    函 数 名: AppTaskLED
    
48. *    功能说明: LED闪烁。
    1 }. r3 S2 i6 P* ~2 o1 n  f
49. *    形    参: 无
    , p3 U: l! n& b0 A5 C; r
50. *    返 回 值: 无
    " M, e! L: Z. U1 D* V7 n2 l
51. *   优 先 级: 2
    
52. *********************************************************************************************************
    
53. */
    
54. __task void AppTaskLED(void)
    
55. {
    . n, [" o" c! h, p% Z% @8 x" t+ p
56.      const uint16_t usFrequency = 200; /* 延迟周期 */
    
57.    
    6 V$ C4 q# v! r& w  {% H
58.      /* 设置延迟周期 */
    3 Q2 v0 j" u# Z  |
59.      os_itv_set(usFrequency);
    
60.    
    ! j' O* l$ P: t- [9 K
61.     while(1)
    ' Q+ B; |4 ]$ G" j$ F7 `
62.     {
    ( f4 g; b" H' M, h/ d& d8 w
63.          bsp_LedToggle(2);
    
64.          bsp_LedToggle(3);
    
65. 
    1 y2 ~" N1 e2 D
66.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
      ^0 _% i% H6 X0 z
67.           os_itv_wait();
    
68.     }
    
69. }
    5 ]; ?) K7 h- n7 A- s
70. 
    
71. /*
    : d* O6 c5 _9 t4 C/ ]! ?
72. *********************************************************************************************************
    
73. *    函 数 名: AppTaskMsgPro
    
74. *    功能说明: 消息处理，等待定时器中断发来的消息邮箱数据
    1 M' w/ t- U) u6 r" ?/ ]% X, R
75. *    形    参: 无
    ) h9 k; U, u8 e  Y. x9 w" a
76. *    返 回 值: 无
    
77. *   优 先 级: 3
    
78. *********************************************************************************************************
    * M. S( ^6 a( K$ T
79. */
    
80. __task void AppTaskMsgPro(void)
    & l$ d- g6 j/ [% k  D8 w# g
81. {
    
82.      uint8_t *pMsg;
    
83.      OS_RESULT xResult;
    
84.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    1 T8 M3 {9 g- i
85.    
    
86.     while(1)
    ; [8 k% J. k0 Q7 W
87.     {
    
88.          xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
    $ u' N- p- o9 [8 j0 U* o
89.         
    
90.          switch (xResult)
    : ^0 X1 E+ p. Y1 k% V5 q4 m6 K
91.          {
    
92.               /* 无需等待接受到消息邮箱数据 */
    3 R6 n6 v* m/ A: s& t! w$ P
93.               case OS_R_OK:
    5 Z8 W- k8 f: i* L) e! A5 ?8 I
94.                    printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
    
95.                    break;  
    
96. 
    $ \  @7 H, m  [$ O
97.               /* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
    3 D% X$ S4 Y' D. W; q$ g1 G7 T6 ]
98.               case OS_R_MBX:
    
99.                    printf("消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
    
100.                    break;
     % R6 u+ m* k& r
101. 
     
102.               /* 超时 */
     
103.               case OS_R_TMO:
     ) c6 v! W3 t8 W- Q. v) A! q$ q7 r' x
104.                    bsp_LedToggle(1);
     * o/ z/ b4 ^7 g9 h! M% ]
105.                    bsp_LedToggle(4);
     
106.                    break;
     
107.             
     
108.               /* 其他值不处理 */
     . {7 N  D6 O. V: L/ a' L
109.               default:                    
     # E; f  u2 @  |# L4 M4 u! q
110.                    break;
     + |" G. J+ I1 c6 x
111.          }   
     5 h$ j9 R8 o5 O) [0 C8 r: {4 t+ e
112.     }
     - U  e2 n: w* D, I% @$ z; O5 y
113. }
     3 M4 h7 d. U$ @; g5 ^
114. 
     
115. /*
     
116. *********************************************************************************************************
     + N$ f7 T% Q4 o+ m
117. *    函 数 名: AppTaskStart
     
118. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     
119. *    形    参: 无
     2 v3 V3 l( b3 m7 g% i1 D% o$ m
120. *    返 回 值: 无
     
121. *   优 先 级: 4
     : w" X; }; i8 [) ^) O
122. *********************************************************************************************************
     ! d$ y! q3 L  F
123. */
     
124. __task void AppTaskStart(void)
     
125. {
     
126.      /* 创建任务 */
     6 w7 ?0 T) {0 o" ]% v. Z8 z% |
127.      AppTaskCreate();
     
128.    
     2 u* c! t& Q# B5 a
129.      /* 创建任务通信机制 */
     ; ^8 n" q" [! b
130.      AppObjCreate();
     9 R* b  C  T# G+ H
131.    
     6 P+ e/ f  o' g8 f( m6 O- c# B
132.     while(1)
     
133.     {
     3 X, B1 U! A( Q
134.          /* 按键扫描 */
     , O/ R4 D6 l- ?0 x; `
135.          bsp_KeyScan();
       @0 W7 V+ ]4 Z- a+ l
136.         os_dly_wait(10);
     
137.     }
     
138. }

复制代码

定时器中断回调函数中实现消息邮箱数据发送：

    定时器中断的初始化和中断函数在bsp_timer.c文件中实现，这个不是教程的重点，故不作介绍。这里主要关心RTX的消息邮箱函数在中断服务程序中的使用方法。

1. /* 特别注意，RTX消息邮箱传递的是地址。
   + S" a* o9 @* G* U9 R+ N
2.    所以不要将变量定义放在中断程序中，退出中断后变量空间会释放给系统堆栈。
   
3. */
   
4. static uint8_t s_ucCount = 0;
   4 r2 [- O, g, l9 q  @) p
5. static void TIM_CallBack1(void)
   ' G9 b/ u& z5 d& L, `. }
6. {
   3 C; m5 M- f& X0 R# g* {  j0 v3 K
7.      /* 如果消息邮箱还有空间，向消息邮箱发送数据 */
   2 H5 ?+ _+ |' j2 a4 N* }+ w8 Q- M
8.      if (isr_mbx_check (&mailbox) != 0)
   
9.      {
   
10.          s_ucCount++;
    % p8 \/ N. d6 W4 I
11.          isr_mbx_send (&mailbox, &s_ucCount);     
    
12.      }
    7 }1 q5 \! U1 D! r/ O
13. }

复制代码

. T6 ^3 ]( M, [; j( J5 x( w
  ?2 ^* J, f9 a8 y

16.4.2   STM32F407开发板实验

配套例子：

    V5-415_RTX实验_消息邮箱（中断方式）

实验目的：

    1.     学习RTX的消息邮箱（中断方式）

实验内容：

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

    2.K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消息邮箱数据。任务AppTaskMsgPro接收到消息后进行消息处理。

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

  AppTaskUserIF任务  ：按键消息处理。

  AppTaskLED任务     ：LED闪烁。

  AppTaskMsgPro任务 ：消息处理，等待定时器中断发来的消息邮箱数据。

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

Number of concurrent running tasks

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

                  AppTaskUserIF任务   ：按键消息处理。

                  AppTaskLED任务     ：LED闪烁。

                  AppTaskMsgPro任务 ：消息处理，等待定时器中断发来的消息邮箱数据。

                  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初始化：

1. /*
   
2. *********************************************************************************************************
   $ G6 R! E" ^) v6 S
3. *    函 数 名: main
   : Q4 _" u4 ^  c# a! I( k
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ' E2 o! x+ d- y9 i
9. int main (void)
   ! @; f! L; s) b) K" F7 f
10. {   
    
11.      /* 初始化外设 */
    
12.      bsp_Init();
    
13.    
    
14.      /* 创建启动任务 */
    
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    8 |7 w1 b; Q% E# M% x) Y
16.                        4,                        /* 任务优先级 */
    % x$ x! r! R$ m8 h6 V+ {
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
    6 W1 B/ U" }/ D) ^3 ?& [, y/ Q
20. }

复制代码

" m1 B  S- X1 B  F) u8 n+ i+ S

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   3 f6 |" A" G) w' I4 n# q
8. */
   + S8 J+ o% y+ _4 |2 N8 A; _3 I' L" e+ U. `
9. static void AppTaskCreate (void)
   7 B9 ?: o, F4 n( a" H( S
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    . e$ s# l6 u5 \8 X8 q5 s0 X0 R- k
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    2 `* W7 g5 V% O1 {: i1 T
15.    
    # z$ R9 ^3 B5 X
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    
20.    
    + m+ R1 ~/ S+ u7 x! e: d
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

创建消息邮箱：

1. /* 声明一个支持10个消息的消息邮箱 */
   
2. os_mbx_declare (mailbox, 10);
   + H# `' V0 i. b$ {, d
3. 
   
4. /*
   - t/ K& [4 |% ]% Y! P# G% K! X
5. *********************************************************************************************************
   
6. *    函 数 名: AppObjCreate
   / o% M) a( E. @2 _) Z! |
7. *    功能说明: 创建任务通信机制
   ) [, C$ d1 w# o- \+ b0 g' X
8. *    形    参: 无
   
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    $ V+ m0 ^% ]1 H& ?
12. static void AppObjCreate (void)
      {9 l+ G3 O2 [, g7 s0 b0 Z
13. {
    ! O. e: b/ Z4 x& P+ o) J
14.      /* 创建消息邮箱 */
    ; G; l1 N2 w0 R6 y$ w
15.       os_mbx_init (&mailbox, sizeof(mailbox));
    8 `" H2 Y5 m" l5 I- M
16. 
    / A+ l0 t$ x% c& C8 a+ m: q/ F
17. }

复制代码

# v- ?* P3 d) ]4 K, ?

四个RTX任务的实现：

1. /*
   
2. /*
   
3. *********************************************************************************************************
   0 @  Z* o3 f% p! X
4. *    函 数 名: AppTaskUserIF
   + ^3 Z0 B) A2 q" N
5. *    功能说明: 按键消息处理     
   * P" ]8 Z" u( i. _8 J
6. *    形    参: 无
   - L! G$ V  s9 Y# P* r; D) r
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   " J) F6 I  {% Y* s
9. *********************************************************************************************************
   
10. */
    
11. __task void AppTaskUserIF(void)
    / u9 @- C3 [$ p& B/ A9 A6 K/ ~
12. {
    ( m( [& t" p. L6 K- f; @
13.      uint8_t ucKeyCode;
    
14. 
    " v; v7 ^: }/ V
15.     while(1)
    
16.     {
    * ~% F8 y+ s- E( i6 D
17.          ucKeyCode = bsp_GetKey();
      Y  i- l: f3 r+ G' x! |! e% T# r
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    ; E! S- n8 y) h! b) x
20.          {
    # }* K6 _1 e; `; {1 f; A6 x
21.               switch (ucKeyCode)
    
22.               {
    + r2 f# I0 b/ J
23.                    /* K1键按下，打印调试说明 */
    ; w5 a! f8 q/ v$ g. M" C
24.                    case KEY_DOWN_K1:
    * q; W" b$ I: h; Z; P" y$ E
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
26.                        break;  
    
27.                   
    
28.                    /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消息邮箱数据 */
    
29.                    case KEY_DOWN_K2:
    - ]1 [0 D' L5 @" V7 l' n
30.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送消
    
31. 息邮箱数据\r\n");
    0 A$ g$ {: _0 R( N
32.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
    
33.                        break;
    
34. 
    & L6 \" B4 B- ?1 H/ [; H
35.                    /* 其他的键值不处理 */
    3 Z3 u/ W! X1 Y4 m
36.                    default:                    
    
37.                        break;
    1 m0 K' A& z* l& y
38.               }
    
39.          }
    / q$ @/ M! m* b" K1 ]
40.         
    0 A+ I6 v4 F. {, q6 d9 |
41.          os_dly_wait(20);
    ! ~; S7 y2 [+ f( }5 s
42.      }
    
43. }
    $ b1 x. N) L+ E, ^9 h! V$ k
44. 
    
45. /*
    
46. *********************************************************************************************************
    
47. *    函 数 名: AppTaskLED
    
48. *    功能说明: LED闪烁。
    
49. *    形    参: 无
    & J8 X$ ~! S  u
50. *    返 回 值: 无
    & J( I% F4 d5 o2 d; A5 o
51. *   优 先 级: 2
    5 T+ A( x; X; x6 d
52. *********************************************************************************************************
    
53. */
    $ ^# X7 K) J8 R* P) F3 z! B
54. __task void AppTaskLED(void)
    3 ^9 X- O( f$ {0 e( W* C. u
55. {
    
56.      const uint16_t usFrequency = 200; /* 延迟周期 */
    3 X- `; o  f0 b
57.    
    4 U8 q3 i7 }2 v  y) O
58.      /* 设置延迟周期 */
    3 ~  P8 c) R" [$ s6 P5 \' L* g
59.      os_itv_set(usFrequency);
    2 W: |# b9 z; C6 B
60.    
    
61.     while(1)
    3 Z7 [3 i4 ^# n( `8 J
62.     {
    
63.          bsp_LedToggle(2);
    ' r# ~5 w7 \# }, b  r( L
64.          bsp_LedToggle(3);
    : M# O' R& T7 E; Q
65. 
    
66.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
67.          os_itv_wait();
    ( C; ?$ A3 `1 |. D  Y0 A/ t
68.     }
    ) A7 Q1 p5 }: {7 U
69. }
    
70. 
    0 b5 M- b4 t; o/ {- D
71. /*
    " e% d1 Y' U5 j, _. N2 b# n
72. *********************************************************************************************************
    $ x7 G: g; g7 x
73. *    函 数 名: AppTaskMsgPro
    7 U1 Z$ w; c; A( \
74. *    功能说明: 消息处理，等待定时器中断发来的消息邮箱数据
    
75. *    形    参: 无
    ! Y# \2 C# M/ S, K0 \
76. *    返 回 值: 无
    
77. *   优 先 级: 3
      P, J: @/ v7 a$ K6 i' b
78. *********************************************************************************************************
    
79. */
    6 d* L+ M  e( o" [5 }
80. __task void AppTaskMsgPro(void)
    : `' p5 y! K$ r
81. {
    & d; @8 |  m  I! G: l, f% j
82.      uint8_t *pMsg;
    
83.      OS_RESULT xResult;
      M2 E3 O7 u8 V! G4 C. {
84.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    
85.    
    
86.     while(1)
    6 F2 o/ Y9 M! t+ g# `( o8 B
87.     {
    
88.          xResult = os_mbx_wait(&mailbox, (void *)&pMsg, usMaxBlockTime);
    
89.         
    
90.          switch (xResult)
    2 y, {7 I* K, u' H, ^  x; d6 t9 x0 r
91.          {
    
92.               /* 无需等待接受到消息邮箱数据 */
    
93.               case OS_R_OK:
    
94.                    printf("无需等待接受到消息邮箱数据，pMsg = %d\r\n", *pMsg);
    6 Z* G3 O" Q4 A  F$ o. v
95.                    break;  
    " c3 e. [9 }! g3 ^- \/ K
96. 
    - x' `1 `" A- s' |
97.               /* 消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据 */
    
98.               case OS_R_MBX:
    
99.                    printf("消息邮箱空，usMaxBlockTime等待时间从消息邮箱内获得数据，pMsg = %d\r\n", *pMsg);
    
100.                    break;
     
101. 
     9 R4 X: s  l5 R0 f9 a
102.               /* 超时 */
     
103.               case OS_R_TMO:
     
104.                   bsp_LedToggle(1);
     
105.                    bsp_LedToggle(4);
     
106.                    break;
     
107.             
     . E% Q7 ~& s0 O0 Q$ D6 E
108.               /* 其他值不处理 */
     , X+ S! R$ `! e* w
109.               default:                    
     
110.                    break;
     
111.          }   
     - z3 E6 s- v7 [8 G( c/ c( P8 k! r
112.     }
     
113. }
     * {% d/ u# Q& ]3 A' }: a$ c6 _
114. 
     
115. /*
     
116. *********************************************************************************************************
     " S8 L. g# \  }! ?, t* [
117. *    函 数 名: AppTaskStart
     
118. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     
119. *    形    参: 无
     
120. *    返 回 值: 无
     7 X7 H: p* h6 l) j( m8 H! ?/ A
121. *   优 先 级: 4
     
122. *********************************************************************************************************
     
123. */
     1 Y7 Z' G5 c3 ]* a
124. __task void AppTaskStart(void)
     
125. {
     
126.      /* 创建任务 */
     
127.      AppTaskCreate();
     
128.    
     ) d* j9 y# R# k
129.      /* 创建任务通信机制 */
     
130.      AppObjCreate();
     % V. H! ^( B4 j; W7 i2 L
131.    
     
132.     while(1)
     
133.     {
     7 w2 z; ~6 q5 `9 a# \" v
134.          /* 按键扫描 */
     5 T1 J4 i% D4 R$ w6 [" w: b' Q
135.          bsp_KeyScan();
     $ c+ z: |$ _+ {. x* h- k$ f
136.         os_dly_wait(10);
     $ N% y3 a; R) ?. |! ?9 x; z) q
137.     }
     5 }/ d  t9 V6 M% F
138. }

复制代码

; h( m5 ~! a+ M& U; S" P/ I

定时器中断回调函数中实现消息邮箱数据发送：

    定时器中断的初始化和中断函数在bsp_timer.c文件中实现，这个不是教程的重点，故不作介绍。这里主要关心RTX的消息邮箱函数在中断服务程序中的使用方法。

1. /* 特别注意，RTX消息邮箱传递的是地址。
   
2.    所以不要将变量定义放在中断程序中，退出中断后变量空间会释放给系统堆栈。
   
3. */
   9 k0 O% b! \/ j2 X2 R, D
4. static uint8_t s_ucCount = 0;
   % x  V* Q7 O+ u$ C
5. static void TIM_CallBack1(void)
   / G& |* y3 h. ^; H  K
6. {
   : B& W% I0 C# n
7.      /* 如果消息邮箱还有空间，向消息邮箱发送数据 */
   7 _1 z0 d- p9 ^8 E& m9 J
8.      if (isr_mbx_check (&mailbox) != 0)
   
9.      {
   $ v: v- D5 I) A. d9 Q
10.          s_ucCount++;
    
11.          isr_mbx_send (&mailbox, &s_ucCount);     
    * M% y, d/ t: x1 K8 A. p  Y
12.      }
    
13. }

复制代码

16.5 总结

    本章节就为大家讲解了消息邮箱的使用，在实际项目中，消息邮箱用到的地方非常多，希望初学者认真学习并掌握。