第15章    互斥信号量

    本章节开始讲解RTX的另一个重要的资源共享机制---互斥信号量（Mutex，即Mutual Exclusion的缩写）。注意，建议初学者学习完上个章节的信号量后再学习本章节的互斥信号量。

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

15.1 互斥信号量

15.2 互斥信号量API函数

15.3 实验例程说明

15.4      总结

15.1  互斥信号量
15.1.1  互斥信号量的概念及其作用

    互斥信号量就是信号量的一种特殊形式，也就是信号量初始值为1的情况。有些RTOS中也将信号量初始值设置为1的情况称之为二值信号量。为什么叫二值信号量呢？因为信号量资源被获取了，信号量值就是0，信号量资源被释放，信号量值就是1，把这种只有0和1两种情况的信号量称之为二值信号量。互斥信号量的主要作用就是对资源实现互斥访问。下面举一个通过二值信号量实现资源独享，即互斥访问的例子，让大家有一个形象的认识

运行条件：

1.  让两个任务Task1和Task2都有运行串口打印printf，这里我们就对函数printf通过二值信号量实现互斥访问。如果不对函数printf进行互斥访问，串口打印容易出现乱码。

2.  用信号量实现二值信号量只需将信号量的初始值设置为1即可。

代码实现：

创建二值信号量

1. 
   
2. OS_SEM semaphore;
   1 Z* G) F2 `8 \6 `, {' P
3. 
   
4. /*
   
5. *********************************************************************************************************
   
6. *    函 数 名: AppObjCreate
   
7. *    功能说明: 创建任务通信机制
   
8. *    形    参: 无
   
9. *    返 回 值: 无
   & G1 C/ g; h. a0 n2 B
10. *********************************************************************************************************
    
11. */
    4 _: `& e% O/ ~; L2 y7 |* [
12. static void AppObjCreate (void)
    
13. {
    , O$ l: I( d# f1 Z3 B
14.      /* 创建二值信号量，实现对互斥资源的独享 */
    
15.      os_sem_init (semaphore, 0);
    ) R# b( y  V) P5 s5 G. H- d6 O
16. }

复制代码

; c) F, O! Q, y' A6 ~/ l

通过二值信号量实现对printf函数互斥访问的两个任务

1. /*
   / j6 }" K0 p% D/ b
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskLED
   
4. *    功能说明: 串口打印
   
5. *    形    参: 无
   " p$ J" |* J' H
6. *    返 回 值: 无
   , c$ O  [- J2 \
7. *   优 先 级: 2
   
8. *********************************************************************************************************
   / l3 l/ w1 ]( s; x# x% G2 v
9. */
   
10. __task void AppTaskLED(void)
    - `- _) b8 R8 b, F' G
11. {
    
12.      const uint16_t usFrequency = 1000; /* 延迟周期 */
    
13.    
    ! {2 ]) D5 a* O; \
14.      /* 设置延迟周期 */
    , x6 s- U% H# m# i* X! e9 g- d6 j
15.      os_itv_set(usFrequency);
    $ Z+ Z$ V' c4 f
16.    
    
17.     while(1)
    
18.     {
    
19. 
    
20.          /* 永久等待互斥资源可用 */
    
21. os_sem_wait (&semaphore, 0xffff);
    
22.          printf("任务AppTaskLED正在运行\r\n");
    , e# `  w- {# c) h4 J' x/ }
23.          /* 释放互斥资源 */
    
24.          os_sem_send (&semaphore);
    + J' B3 R3 |6 g+ `+ `* Z$ D8 c6 d& W
25.         
    
26.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
27.          os_itv_wait();
    : i/ n% K" |' s. }- x( p6 p1 t) m
28.     }
    
29. }
    
30. 
    5 t3 h$ j9 A9 ^/ q: K
31. /*
    
32. *********************************************************************************************************
    " z9 ^# }! E( o8 {. @: w. i2 V
33. *    函 数 名: AppTaskMsgPro
    5 \$ {  O  P  ^( ]4 r" |
34. *    功能说明: 串口打印
    
35. *    形    参: 无
    " b2 o" A5 W/ F
36. *    返 回 值: 无
    / L' U- j: P  M* l! L
37. *   优 先 级: 3
    
38. *********************************************************************************************************
    
39. */
    % A" p8 \, }, W0 x
40. __task void AppTaskMsgPro(void)
    # i" v# {2 b0 f/ \
41. {
    
42.      const uint16_t usFrequency = 1000; /* 延迟周期 */
    8 q% H8 ^, A) {+ K
43.    
    
44.      /* 设置延迟周期 */
    , q4 t# }# \0 E9 ^$ u+ v( q+ s
45.      os_itv_set(usFrequency);
    : T& K* Y& W" z; U* K
46.    
    
47.     while(1)
    
48.     {
    7 h- B; B: J$ \1 P) K7 H# L( F
49.          /* 永久等待互斥资源可以 */
    
50. os_sem_wait (&semaphore, 0xffff);
    . T5 |& H4 `$ N6 x) I0 v
51.          printf("任务AppTaskMsgPro正在运行\r\n");
    2 b- X# k4 N( t% ^: }8 u
52.          /* 释放互斥资源 */
    
53.          os_sem_send (&semaphore);
    
54. 
    4 m2 z  y) K% I% G
55.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    & s& v' l% B% C  _& d+ R/ k
56.          os_itv_wait();
      k) e5 m/ l4 S0 t! F
57.     }
    
58. }

复制代码

    有了上面二值信号量的认识之后，互斥信号量跟二值信号量又有什么区别呢？互斥信号量可以防止优先级翻转，而二值信号量不支持，下面我们就讲解一下优先级翻转问题。

2 b7 g2 |7 z; {* r15.1.2  优先级翻转问题

    下面我们通过如下的框图来说明一下优先级翻转的问题，让大家有一个形象的认识。

                              

运行条件：

1.  创建3个任务Task1，Task2和Task3，优先级分别为3，2，1。也就是Task1的优先级最高

2.  任务Task1和Task3互斥访问串口打印printf，采用二值信号实现互斥访问。

3.  起初Task3通过二值信号量正在调用printf，被任务Task1抢占，开始执行任务Task1，也就是上图的起始位置。

运行过程描述如下：

1.  任务Task1运行的过程需要调用函数printf，发现任务Task3正在调用，任务Task1会被挂起，等待Task3释放函数printf。

2.  在调度器的作用下，任务Task3得到运行，Task3运行的过程中，由于任务Task2就绪，抢占了Task3的运行。优先级翻转问题就出在这里了，从任务执行的现象上看，任务Task1需要等待Task2执行完毕才有机会得到执行，这个与抢占式调度正好反了，正常情况下应该是高优先级任务抢占低优先级任务的执行，这里成了高优先级任务Task1等待低优先级任务Task2完成。所以这种情况被称之为优先级翻转问题。

3.  任务Task2执行完毕后，任务Task3恢复执行，Task3释放互斥资源后，任务Task1得到互斥资源，从而可以继续执行。

上面就是一个产生优先级翻转问题的现象。

3 U4 W' R' `. X5 X2 Y9 g- W' ]15.1.3  RTX互斥信号量的实现

    RTX互斥信号量是怎么实现的呢？其实相比二值信号量就是解决了一下优先级翻转的问题。下面我们通过如下的框图来说明一下RTX互斥信号量的实现，让大家有一个形象的认识。

运行条件：

1.  创建2个任务Task1和Task2，优先级分别为1和3，也就是任务Task2的优先级最高

2.  任务Task1和Task2互斥访问串口打印printf。

3.  使用RTX的互斥信号量实现串口打印printf的互斥访问。

运行过程描述如下：

1.  低优先级任务Task1执行过程中先获得互斥资源printf的执行。此时任务Task2抢占了任务Task1的执行，任务Task1被挂起。任务Task2得到执行。

2.  任务Task2执行过程中也需要调用互斥资源，但是发现任务Task1正在访问，此时任务Task1的优先级会被提升到跟Task2同一个优先级，也就是优先级3，这个就是所谓的优先级继承（Priorityinheritance），这样就有效的防止了优先级翻转问题。任务Task2被挂起，任务Task1有新的优先级继续执行。

3.  任务Task1执行完毕并释放互斥资源后，优先级恢复到原来的水平。由于互斥资源可以使用，任务Task2获得互斥资源后开始执行。

7 |5 Z4 |, m$ Z

上面就是一个简单RTX互斥信号量的实现过程。

15.1.4 RTX中断方式互斥信号量的实现

    互斥信号量仅支持用在RTX的任务中，中断函数中不可使用。

: ]5 s) P: e& W5 \) `: k

15.2 互斥信号量API函数

    使用如下3个函数可以实现RTX的互斥信号量：

os_mut_init

os_mut_release

os_mut_wait

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

                              

下面我们也对这3个函数依次进行讲解：

15.2.1  函数os_mut_init

函数原型：

1. void os_mut_init (
   
2.     OS_ID mutex );    /* OS_MUT类型变量 */

复制代码

函数描述：

函数os_mut_init用于互斥信号量的初始化并设置初始值。

（1）第1个参数填写数据类型为OS_MUT的变量，同时也作为ID标识

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

1.     函数的参数必须是OS_MUT类型的。

使用举例：

1. #include <rtl.h>
   2 n8 L, E1 y: V9 ~7 U
2. 
   5 H7 C3 H0 @/ v8 p
3. static OS_MUT mutex;
   # U+ o( S# @: ?4 s3 S. w
4. 
   $ L- G* D2 c8 J) m
5. /*
   
6. *********************************************************************************************************
   
7. *         函 数 名: AppObjCreate
   
8. *         功能说明: 创建任务通信机制
   ) g2 v' @  m, V! r2 A; p
9. *         形    参: 无
     b- I) {+ f" ]% m
10. *         返 回 值: 无
    
11. *********************************************************************************************************
    
12. */
    5 t3 V$ h1 X: @2 N# s1 [
13. static void AppObjCreate (void)
    
14. {
    
15. /* 创建互斥信号量 */
    5 g6 W  [, I& K& ?: A- l8 s
16. os_mut_init (&mutex);
    * i1 D  i9 @' T
17. }

复制代码

2 y8 s$ W7 f5 X$ e0 f  Q4 c15.2.2 函数os_mut_wait

函数原型：

1. OS_RESULT os_mut_wait (
   
2.     OS_ID mutex,        /* OS_MUT类型变量 */
   
3.     U16   timeout );    /* 超时时间 */

复制代码

& `, s( M) A/ I

函数描述：

函数os_mut_wait用于获取互斥信号量资源，如果互斥资源可用，那么调用函数os_mut_wait后可以成功获取互斥资源，在此函数的源码将计数值加1（互斥信号量源码的实现上跟信号量不同）。如果互斥资源不可用，调用此函数的任务将由运行态转到挂起态，等待信号量资源可用，也就是计数值为0的时候。

如果一个低优先级的任务通过互斥信号量正在访问互斥资源，那么当一个高优先级的任务也通过互斥信号量访问这个互斥资源的话，会将这个低优先级任务的优先级提升到和高优先级任务一样的优先级，这就是所谓的优先级继承，通过优先级继承可以有效防止优先级翻转问题。当低优先级任务释放了互斥资源之后，重新恢复到原来的优先级。

（1）第1个参数填写数据类型为OS_MUT的变量，同时也作为ID标识

（2）第2个参数表示设在的等待时间，范围0-0xFFFF，当参数设置为0-0xFFFE时，表示等待这么多个时钟节拍，参数设置为0xFFFF时表示无限等待直到互斥资源可用。

（3）函数返回OS_R_MUT表示函数设置的超时时间范围内收到互斥信号量可用资源。

      函数返回OS_R_TMO表示超时。

      函数返回OS_R_OK表示无需等待，立即获得互斥资源。

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

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

使用举例：

1. #include <rtl.h>
   
2. 
   6 A% B/ x! w3 A  ?/ J. G' g1 i
3. static OS_MUT mutex;
   
4. 
   
5. /*
   1 G5 w# R4 u" L& u, \
6. *********************************************************************************************************
   # I$ J9 E% M+ m7 T
7. *   函 数 名: AppTaskLED
   
8. *   功能说明: LED闪烁，并串口打印任务正在运行
   
9. *   形    参: 无
   8 x& e8 r. S5 k5 {% \
10. *   返 回 值: 无
    & ^. W3 j0 l6 n4 R3 [+ E2 V
11. *   优 先 级: 2
    ; A; {# r/ p* S9 E8 L
12. *********************************************************************************************************
    
13. */
      P! d3 {7 C) d$ ~. z
14. __task void AppTaskLED(void)
    
15. {
    3 U5 h: n* o% y5 B, j- [. N
16. const uint16_t usFrequency = 1000; /* 延迟周期 */
    1 y! ?$ ]4 m' |0 o
17.          
    2 z/ d6 f0 D( R$ M6 ?
18. /* 设置延迟周期 */
    * I& n6 o3 f/ E" {; y! D8 p; @
19. os_itv_set(usFrequency);
    
20.          
    
21.     while(1)
    
22.     {
    
23.          bsp_LedToggle(2);
    
24.          bsp_LedToggle(3);
    
25. 
    
26.          /* 永久等待互斥资源可以 */
    
27.          os_mut_wait (&mutex, 0xffff);
    
28.          printf("任务AppTaskLED正在运行\r\n");
    
29.          /* 释放互斥资源 */
    
30.          os_mut_release (&mutex);
    , R) X: g6 ~+ q0 q- e0 e2 V
31.                   
    
32.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    3 L' P1 x( J. d% f) x
33.          os_itv_wait();
    
34.     }
    7 H$ A* b' \0 A
35. }

复制代码

. ^+ ]' B! m" c0 k+ B  r/ J% Z+ {
- e& B5 _/ _$ V+ q0 ~# _; D9 _# z' n15.2.3 函数os_mut_release

函数原型：

1. OS_RESULT os_mut_release (
   4 r8 w* w0 \6 X6 {1 J
2.         OS_ID mutex );    /* OS_MUT类型变量 */

复制代码

函数描述：

函数os_mut_release用于释放互斥资源，调用此函数会将计数值减1。只有当计数值减到0的时候其它的任务才可以获取互斥资源。也就是说如果用户调用os_mut_wait和os_mut_release，需要配套使用。通过函数os_mut_wait实现互斥信号量计数值加1，通过函数os_mut_release实现互斥信号量计数值减1操作，这样的话，这两个函数可以实现嵌套调用，但是一定要保证成对调用，要不会造成互斥资源无法正确释放。

如果拥有互斥资源的任务的优先级被提升了，那么此函数会恢复任务以前的优先级。

u 第1个参数参数填写数据类型为OS_MUT的变量，同时也作为ID标识。

u 返回值OS_R_OK，表示互斥信号量成功释放。

返回值OS_R_NOR，表示互斥信号量的内部计数值已经是0或者调用此函数的任务不是互斥资源的拥有者。

% |1 h3 k6 w5 g4 b1 c5 ]

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

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

使用举例：

1. #include <rtl.h>
   8 D# L( q7 h0 H0 w
2. 
   
3. static OS_MUT mutex;
   6 c7 Z" `- Y+ L
4. 
   ; {0 i: G$ m1 z, n8 U
5. /*
   ' Y, @4 w# Z5 V. I0 U8 n
6. *********************************************************************************************************
   4 O/ b0 M) S& T7 A
7. *   函 数 名: AppTaskLED
   
8. *   功能说明: LED闪烁，并串口打印任务正在运行
   " r$ `: g) T3 |- X8 [
9. *   形    参: 无
   : M6 P( U! k% Y7 D5 J
10. *   返 回 值: 无
    
11. *   优 先 级: 2
    7 \+ g3 w3 q/ k! H3 ]2 M
12. *********************************************************************************************************
    : E! O) M" `  ?- ~; _: |1 a
13. */
    
14. __task void AppTaskLED(void)
    
15. {
    " b0 a: A+ p, |! H
16. const uint16_t usFrequency = 1000; /* 延迟周期 */
    & |5 J9 j% i) S# c+ @- f, k
17.          
    ) [' Q, W, e$ h/ O  e
18. /* 设置延迟周期 */
    
19. os_itv_set(usFrequency);
    , ]5 F2 n& Z1 m0 H
20.          
    
21.     while(1)
    * d( J2 {5 `; B5 o4 r3 Y! M( @2 `: y
22.     {
    1 Y$ e$ T8 @# T7 N, E9 J
23.          bsp_LedToggle(2);
    7 s) F- ~$ x# I
24.          bsp_LedToggle(3);
    3 I! A8 L- [  h  L9 @
25. 
    
26.          /* 永久等待互斥资源可以 */
      D$ \5 ?, ]7 w9 C: b' r5 v" i
27.          os_mut_wait (&mutex, 0xffff);
    
28.          printf("任务AppTaskLED正在运行\r\n");
    
29.          /* 释放互斥资源 */
    * h, i( Q" S7 J. U  ^9 F
30.          os_mut_release (&mutex);
    ) I  D2 n* w4 N+ I" ~) o: O
31.                   
    3 c% p. j$ X* [' N4 D
32.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    / A' h  g7 o0 w  D$ l
33.          os_itv_wait();
    
34.     }
    ) D! D, _$ p' G
35. }

复制代码

" Q) m; Y7 H$ M

15.3 实验例程说明 * o% `0 J. b* Z1 l2 l6 `9 V6 \3 C15.3.1 STM32F103开发板实验 配套例子：     V4-413_RTX实验_互斥信号量 实验目的：     1. 学习RTX的互斥信号量 实验内容：      1. K1按键按下，串口打印。      2. 在调用printf函数的地方都加上互斥信号量，防止多个任务调用此函数造成冲突，以至于串口打印出现乱码。      3. 各个任务实现的功能如下：     AppTaskUserIF任务  ：按键消息处理。     AppTaskLED任务     ：LED闪烁和串口打印。     AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁和串口打印。     AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。 RTX配置：        RTX配置向导详情如下：                                / @) a# F$ O3 `% x/ c1 K1 \ Task Configuration         Number of concurrent running tasks           允许创建4个任务，实际创建了如下四个任务                 AppTaskUserIF任务   ：按键消息处理。                 AppTaskLED任务     ：LED闪烁和串口打印                 AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁和串口打印。                 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初始化： /* ********************************************************************************************************* *    函 数 名: main 1 z( Q  s) x+ ^8 o, F0 l# { *    功能说明: 标准c程序入口。 *    形    参: 无 ( x8 M) h* C2 A+ r0 @ *    返 回 值: 无 * N$ E7 Z4 D7 x# S2 r( {: Z ********************************************************************************************************* */ int main (void) - |$ W( q5 o& {3 n3 ^+ h2 o {         /* 初始化外设 */      bsp_Init();     " I  ]" V4 C6 e) n7 I, J      /* 创建启动任务 */ 9 O* ?7 g: I( f1 }6 Q      os_sys_init_user (AppTaskStart,             /* 任务函数 */ 8 {; ]) s, K/ K/ L, _1 H                        4,                        /* 任务优先级 */                        &AppTaskStartStk,         /* 任务栈 */ 3 `% A  _" e& g* @2 R; X6 V                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */ ' Y6 Q7 \! [+ X. f* S      while(1); } 复制代码 ! `. w1 g( g' k) H9 ^6 z6 X7 V ' Q% K9 q  \# `: k RTX任务创建： /* / r& z, x5 b( N/ l' K/ C/ O ********************************************************************************************************* : d0 F3 z; [$ ^0 Q *    函 数 名: AppTaskCreate *    功能说明: 创建应用任务 *    形    参: 无 ( y! T2 M) c8 ? *    返 回 值: 无 ********************************************************************************************************* # `5 f* _* o+ d- @% d5 [1 } */ $ r* u1 v5 I6 ^/ A3 V static void AppTaskCreate (void) 1 m& a/ Y$ l7 i( ?& q {      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */                                            1,                         /* 任务优先级 */                                            &AppTaskUserIFStk,         /* 任务栈 */                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */          HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */                                         2,                       /* 任务优先级 */                                         &AppTaskLEDStk,          /* 任务栈 */ ! L: [" n3 }+ M! T                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */     3 }% l- }+ Y9 _' e      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */ - \; E. e# I4 u! p" |: Y( M                                            3,                         /* 任务优先级 */ & b& n) M% }, t3 d) s9 l                                            &AppTaskMsgProStk,         /* 任务栈 */                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */ . y$ K/ |/ \, d( ^: q+ O } 复制代码 8 M4 A+ g4 ]* n/ c; Z 互斥信号量创建 static OS_MUT mutex; /* 3 ^% e' b; R# I7 P) T5 U ********************************************************************************************************* ; c* F; \% ^. _ *   函 数 名: AppTaskLED : i" R2 a( k9 _" n *   功能说明: LED闪烁，并串口打印任务正在运行 *   形    参: 无 *   返 回 值: 无 *   优 先 级: 2 : d# a- i, Z& Q  Z6 y ********************************************************************************************************* */ 复制代码 四个RTX任务的实现： /* 8 s9 m& N3 Z' m* x3 k2 t ********************************************************************************************************* *    函 数 名: AppTaskUserIF 2 q/ u: \9 k0 m) a, {9 Z: ]# j) N *    功能说明: 按键消息处理      + ]3 P; [( G! s* V7 a *    形    参: 无 *    返 回 值: 无 *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反) ********************************************************************************************************* - e! n& g0 C7 ~: X */ - L' K( e$ K3 ^* ]& H& r0 C __task void AppTaskUserIF(void) {      uint8_t ucKeyCode; . i- I" q$ M3 t, L8 p5 C5 ^5 r     while(1) 3 T2 p4 ^; g2 ]     { # y$ Z. D# D: v          ucKeyCode = bsp_GetKey();                   if (ucKeyCode != KEY_NONE) / X" Q+ z' L) y' W; G" \, `" B( P2 f          { 4 M7 `$ V4 Z3 ^- q0 ?               switch (ucKeyCode)               { 7 u% m9 ?/ v- m6 ~$ f                    /* K1键按下，打印调试说明 */ 3 [2 K/ P  ^' ^# c1 f, n3 z' M                    case KEY_DOWN_K1:                        /* 永久等待互斥资源可以 */ ( g, M; Z7 d3 f0 C4 f9 J                        os_mut_wait (&mutex, 0xffff);                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");                        /* 释放互斥资源 */ 5 y& j* D% `1 d; D. i9 r4 `3 o                        os_mut_release (&mutex);                        break;                      /* 其他的键值不处理 */ 6 s' {& d1 A# {# r! b6 N4 X8 O. ^. ^+ R' Q                    default:                                            break;               }          } 3 D- s8 {& y+ ^* N) ^# S  G# E! V                   os_dly_wait(20); 9 B" s& ]+ _; V, ]3 S+ a      } } 6 p0 o7 P" }& E2 A- C" j6 z) a$ v /* 1 H+ H/ |4 i% r, v3 j7 c3 a& @ ********************************************************************************************************* *    函 数 名: AppTaskLED *    功能说明: LED闪烁和串口打印 * {: `7 J" U" h6 y *    形    参: 无 ; `- z' L4 F5 B, j* v& ~ *    返 回 值: 无 / v/ }. J" T( a *   优 先 级: 2 ********************************************************************************************************* 3 @' {. t* `# i9 t1 F/ d */ __task void AppTaskLED(void) 6 h5 T, I, q, M7 ^; i5 W5 { { : h1 S+ y0 k" Y1 c9 B  |5 w' s      const uint16_t usFrequency = 1000; /* 延迟周期 */          /* 设置延迟周期 */ , K" P- H8 }" b( W+ F- B4 `2 z. l      os_itv_set(usFrequency);     6 d) b& `1 F2 U, T' q7 Z% D     while(1) ! X% y2 i7 _7 |, V" B0 h     {          bsp_LedToggle(2);          bsp_LedToggle(3); " \6 z' k: b' z4 Q; p  }9 J- p* t          /* 永久等待互斥资源可以 */          os_mut_wait (&mutex, 0xffff); ' r) }( Q2 o' g/ U          printf("任务AppTaskLED正在运行\r\n");   T: I. I6 j1 P3 \4 u, _& C          /* 释放互斥资源 */ 1 w! b  h/ ?$ y4 C6 Q3 i          os_mut_release (&mutex); * p- M' G) \* v4 c0 @                   /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/          os_itv_wait(); $ P9 h9 X# V# g- f/ W9 g$ S6 u     } & ?/ k! L; M5 \& \$ t) P6 ~ } 8 V! J# F$ w) N+ i* I+ J /* 0 Z% B% d3 t2 y4 K' k0 E6 w ********************************************************************************************************* 6 P: m" f) J$ T# n# m* O" N8 m *    函 数 名: AppTaskMsgPro 6 v8 K6 D  o4 b2 {6 H *    功能说明: 消息处理，这里是用作LED闪烁和串口打印 *    形    参: 无 *    返 回 值: 无 *   优 先 级: 3 " [  u+ T7 y( r5 i1 T ********************************************************************************************************* */ __task void AppTaskMsgPro(void) {      const uint16_t usFrequency = 1000; /* 延迟周期 */     7 h  r6 N1 C1 o& K. _9 _. p      /* 设置延迟周期 */ : k6 F9 B+ F5 ]. j/ Q% P      os_itv_set(usFrequency);         while(1) & \% p9 w( I  t5 U- ?2 Y     {          bsp_LedToggle(1); ' G% B1 W, G/ t0 g3 q          bsp_LedToggle(4); , B( w$ c. n; X' X ) v! x- G" ^5 R+ V0 i2 u) a          /* 永久等待互斥资源可以 */          os_mut_wait (&mutex, 0xffff);          printf("任务AppTaskMsgPro正在运行\r\n"); & K- h% s+ }+ l          /* 释放互斥资源 */          os_mut_release (&mutex);          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/          os_itv_wait();     } 3 z0 N' L5 w9 z% x$ S) J% K1 g/ ^ } 6 n5 k# ^  h+ l6 E# Z# U /*   m# ]1 b1 p6 d6 K$ O5 P ********************************************************************************************************* 1 V: j1 _! M8 q2 U/ X4 R4 R  [0 z; E3 q *    函 数 名: AppTaskStart *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。 . Q) A  A" x/ V8 v# D- \, S5 ^ *    形    参: 无 *    返 回 值: 无 *   优 先 级: 4 ********************************************************************************************************* 2 s/ ^# C0 z4 f( d' y5 k9 u */ 6 H2 g% \0 b' b, t) b __task void AppTaskStart(void) { $ {2 @, Q3 f9 b( e0 l      /* 创建任务 */ 7 D. U- _% Q2 g1 Q$ X" O7 x3 S/ y      AppTaskCreate(); . D* h1 Z$ A0 C) b. G( g! Z          /* 创建任务通信机制 */      AppObjCreate();     5 l0 k8 K$ k% V- ?6 z     while(1) / ^6 f& z5 M0 a* f! M3 k- ], d, [5 ?( c     { . \0 i: z% E6 j7 H/ V1 p7 F, ^          /* 按键扫描 */ * w! R3 e1 S& f! N          bsp_KeyScan();         os_dly_wait(10); % s/ P' [2 n, Z0 }1 B* c0 _: K     } } 复制代码

15.3.2 STM32F407开发板实验

配套例子：

    V4-413_RTX实验_互斥信号量

实验目的：

    1. 学习RTX的互斥信号量

实验内容：

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

    2. 在调用printf函数的地方都加上互斥信号量，防止多个任务调用此函数造成冲突，以至于串口打印出现乱码。

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

    AppTaskUserIF任务 ：按键消息处理。

    AppTaskLED任务     ：LED闪烁和串口打印。

    AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁和串口打印。

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

RTX配置：

    RTX配置向导详情如下：

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

     AppTaskLED任务     ：LED闪烁和串口打印。

   AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁和串口打印。

                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. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: 标准c程序入口。
     w6 {! _1 `! v5 f3 d7 x) U. c6 ^
5. *    形    参: 无
   
6. *    返 回 值: 无
   % M8 ~0 U% v! c9 X
7. *********************************************************************************************************
   
8. */
   
9. int main (void)
   , ?0 P' M% j" m& t2 Y
10. {   
    " @2 k- X+ Y6 O/ a" T& ]$ h
11.      /* 初始化外设 */
    
12.      bsp_Init();
    
13.    
    
14.      /* 创建启动任务 */
    
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    ; t  k# e& _  i' w  e! K
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    9 W$ H: ?) {3 K
19.      while(1);
    ( d2 b& }! F9 h: _$ e* H$ L& K
20. }
    

复制代码

2 @# V. n. a  G

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   : t! D/ @6 n. B1 P7 B- u
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   $ m6 Q4 R& `- l# c
7. *********************************************************************************************************
   ! S. o+ ~! k; S3 b/ Q, V/ @
8. */
   
9. static void AppTaskCreate (void)
   , @2 Q$ }( _# j  ^+ {9 l
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    / S  V2 D/ O9 W' |
12.                                            1,                         /* 任务优先级 */
    " J1 V0 p# F. r8 c) Z0 }
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    1 ^+ z1 X3 C* R% L) g
15.    
    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    ! C& [2 M/ D! R6 t" O" k
17.                                         2,                       /* 任务优先级 */
    
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    2 ^# K0 U  b5 B# A; h9 s" a& Z6 [8 ]
20.    
    ) d2 W8 N/ W, a
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    3 t  Y: s) W& N8 J
22.                                            3,                         /* 任务优先级 */
    # g4 h. T% {8 X8 ?) r$ A3 `! H& c
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    - d1 Y' Q' b  r1 z/ o  n4 s
25. }

复制代码

: [2 Y( R/ Q' L! L! k

- G3 d9 Z2 v! e) t

互斥信号量创建

1. static OS_MUT mutex;
   
2. 
   1 Z& F1 `( U. Z8 t* {) v- g
3. /*
   , i, c: i, s, u! C8 B3 D
4. *********************************************************************************************************
   1 s3 v  _; \1 }" [, ~: S
5. *   函 数 名: AppTaskLED
   2 W3 A5 B; h; a. u
6. *   功能说明: LED闪烁，并串口打印任务正在运行
   
7. *   形    参: 无
   - n4 E* v) \5 A
8. *   返 回 值: 无
   & D' u) u2 _" }  Z3 a& t7 K
9. *   优 先 级: 2
   * N/ w" R6 q; a# _( y+ W' l
10. *********************************************************************************************************
    
11. */

复制代码

% O+ v9 y+ n) U- x

四个RTX任务的实现：

1. /*
   5 {4 A3 p2 `: z7 \
2. *********************************************************************************************************
   4 C9 ^2 G( c, r: W. K. n
3. *    函 数 名: AppTaskUserIF
   
4. *    功能说明: 按键消息处理     
   : \; O" @6 U) e5 ]' f; p
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
8. *********************************************************************************************************
   * {  c: d9 a+ A
9. */
   ! G; N* }1 r: P( @& N1 A
10. __task void AppTaskUserIF(void)
      |. g1 ]9 L8 w3 J1 M" v6 p
11. {
    
12.      uint8_t ucKeyCode;
    
13. 
    ' x/ y1 j. L& I. ^8 D4 A9 _
14.     while(1)
    
15.     {
    
16.          ucKeyCode = bsp_GetKey();
    
17.         
      Q& O+ ]8 i0 I9 v4 u( e( ^
18.          if (ucKeyCode != KEY_NONE)
    6 a0 T" D4 f1 b1 b$ Z  q- Y
19.          {
    
20.               switch (ucKeyCode)
    + _$ c6 {4 h5 T2 p* O3 ?; u
21.               {
    
22.                    /* K1键按下，打印调试说明 */
    
23.                    case KEY_DOWN_K1:
    . e) C6 Z( D2 i. d! |" X2 m
24.                        /* 永久等待互斥资源可以 */
    
25.                        os_mut_wait (&mutex, 0xffff);
    " w2 i& w) Z/ ?  {$ y
26.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
27.                        /* 释放互斥资源 */
    ! S* n1 \8 c  K4 q
28.                        os_mut_release (&mutex);
    " A( r% C# t: D- v. k
29.                        break;  
    
30. 
    # ]0 W6 ?$ L" s7 J( H
31.                    /* 其他的键值不处理 */
    " Q, }/ `# ]. v# ?; Q* O
32.                    default:                    
    1 a/ d8 A* _2 i6 j& X7 u6 D; c4 \
33.                        break;
    
34.               }
    
35.          }
    0 W* Y+ E% B; a! r3 m
36.         
    - K# a. f: l: T, Q3 T
37.          os_dly_wait(20);
    
38.      }
    
39. }
    1 P" [+ _$ v: C0 A
40. 
    ! O7 K  a& k. e% P9 b# P
41. /*
    
42. *********************************************************************************************************
    
43. *    函 数 名: AppTaskLED
    
44. *    功能说明: LED闪烁和串口打印
    $ l6 I+ q# w+ j% I  p& y, o- F
45. *    形    参: 无
      f6 q9 p4 U2 {1 z' J( z1 X0 c
46. *    返 回 值: 无
    
47. *   优 先 级: 2
    
48. *********************************************************************************************************
    # ^, h8 H1 G9 b) x0 B, M! G
49. */
    
50. __task void AppTaskLED(void)
    3 H: L8 J% B: p, U1 c5 f8 g, J; W
51. {
    5 k$ s; k4 C; p" K8 n# ]& t
52.      const uint16_t usFrequency = 1000; /* 延迟周期 */
    
53.    
    9 ^7 q, P! S. K: H1 y) M
54.      /* 设置延迟周期 */
    ; p2 [7 p: y7 C7 |- |9 X
55.      os_itv_set(usFrequency);
    ) ]) ]/ r/ k8 L& [" T! _
56.    
    ' x. o2 }9 E% S, y. k2 ~6 z
57.     while(1)
    
58.     {
    
59.          bsp_LedToggle(2);
    
60.          bsp_LedToggle(3);
    % H0 t7 @, X9 e! _1 U- A
61. 
    
62.          /* 永久等待互斥资源可以 */
    
63.          os_mut_wait (&mutex, 0xffff);
    8 I' j5 }) d+ ~& E
64.          printf("任务AppTaskLED正在运行\r\n");
    
65.          /* 释放互斥资源 */
    
66.          os_mut_release (&mutex);
    
67.         
    
68.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
69.          os_itv_wait();
    / }) T1 P3 M5 P* q
70.     }
    
71. }
    ' i8 ~9 `% @7 C4 X: s( i9 ^2 D
72. 
    9 S7 m; G" a- S; ^6 S' T3 }
73. /*
    
74. *********************************************************************************************************
    
75. *    函 数 名: AppTaskMsgPro
    2 y$ w2 Z. n. m2 C1 N
76. *    功能说明: 消息处理，这里是用作LED闪烁和串口打印
    # e* E: m! T9 K" R  o0 I; x
77. *    形    参: 无
    ( \% q) v1 Y/ X- Y# k, q( b6 y% o
78. *    返 回 值: 无
    $ g8 t) F% G7 f' a
79. *   优 先 级: 3
    
80. *********************************************************************************************************
    
81. */
    
82. __task void AppTaskMsgPro(void)
    + d, F) T; V/ K4 S. m2 t
83. {
    
84.      const uint16_t usFrequency = 1000; /* 延迟周期 */
    
85.    
    
86.      /* 设置延迟周期 */
    4 S& [! d8 z  ~4 {5 w
87.      os_itv_set(usFrequency);
    1 J+ M8 @+ u  Z7 g, o" i2 y
88.    
    : H' e/ ?& m6 p  I7 Y
89.     while(1)
    $ ~; R$ R; V/ a% o: T
90.     {
    9 E. G+ _9 q6 ?# b2 c" ^
91.          bsp_LedToggle(1);
    * ?8 R6 _, E0 d+ n8 a: Y$ R
92.          bsp_LedToggle(4);
    
93. 
    
94.          /* 永久等待互斥资源可以 */
    
95.          os_mut_wait (&mutex, 0xffff);
    
96.          printf("任务AppTaskMsgPro正在运行\r\n");
    6 Z) i* t8 R! s# X2 _; C7 h
97.          /* 释放互斥资源 */
    
98.          os_mut_release (&mutex);
    
99. 
    0 J- c0 B; n; w; N$ b
100.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
     / n- Q2 L. t, o" |, l+ {! A2 k
101.          os_itv_wait();
     4 O3 n7 W/ a: ^' j* [5 v* v( \
102.     }
     4 e; v  u( p/ Z" D- ~8 M
103. 
     
104. }
     
105. 
     + p* V# r3 t  q5 a2 Q& r* K/ d/ z
106. /*
     - l1 t! t' Y% l# X* f$ y) `
107. *********************************************************************************************************
     % L- H2 z, [2 U0 d% m
108. *    函 数 名: AppTaskStart
     
109. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     8 C4 I8 k5 r0 R' s* |& w5 z. I
110. *    形    参: 无
     
111. *    返 回 值: 无
     
112. *   优 先 级: 4
     ' d5 v: A1 N; O; o0 L" O$ u
113. *********************************************************************************************************
     
114. */
     9 n9 |4 h+ A  E7 A* L: ]4 z# G
115. __task void AppTaskStart(void)
     ( k) c+ ^/ `$ k0 a: p! U& I& U$ |
116. {
     
117.      /* 创建任务 */
     1 P" U+ G! _7 Z" J8 P
118.      AppTaskCreate();
     9 A: \- C& a/ A8 A1 O+ {
119.    
     
120.      /* 创建任务通信机制 */
     ( W" k' L; h5 x+ e. t# J' K2 w9 V( x
121.      AppObjCreate();
     
122.    
     
123.     while(1)
     
124.     {
     $ H$ x- O$ }2 X9 d" J3 G$ K
125.          /* 按键扫描 */
     
126.          bsp_KeyScan();
     + D/ o3 |, v* V
127.         os_dly_wait(10);
     ' \! b+ v1 y. _1 G* y+ Y
128.     }
     & V/ m) `% p7 Y* V$ I
129. }

复制代码

" U- {( M6 J: @  N# c

15.4 总结

    本章节主要为大家讲解了另一个重要的资源共享机制-互斥信号量，其中优先级翻转是互斥信号量中一个比较重要的概念，初学者要花些时间去掌握这个知识点。