概述
        每个任务都有一个32位的通知值，可以替代二值信号量，计数信号量，事件组，也可以代替长度为1的队列。
# Q3 M* B( \8 @  H7 _
- c0 j' v/ r, |6 a        有以下几种方式发送通知给任务：
$ m4 U& p: }6 {$ P. y
" D# q0 ]  o: O* D  U) o. l9 s1.有通知未读，则不覆盖通知值

2.直接覆盖通知值
+ h! J* ^! A* L2 E' _
! G& o$ \. p5 E% Q* }3.设置通知值一个或者多个位，当做事件组来使用

4.递增/递减通知，当做信号量来使用

        有以下缺点：

. K  C: w! k- m$ X- j# t1.只能有一个任务接收通知消息
5 {0 \1 v. F' F0 v7 t2 U1 a; j& a
2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。

代替二值信号量
在FreeRTOSConfig.h里开启任务通知

1. /*Turn on task notifications.*/
   ( `/ b3 v0 p9 x- _% j2 v
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

! P, k, S3 s* X7 v1 p! T3 ^在main.c文件里面修改代码
; B" \! [) U, H. P
8 _: q; l" E1 A

1. /* USER CODE BEGIN Includes */
   ! H1 i+ x, _+ H  y) Q# p. h3 Y( t) ]1 z: o
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   , L- H- A2 ?' p0 F9 ^8 ~! w2 C
5. #include <stdio.h>
   5 ?2 G% X: X" W1 }3 ~
6. #include <string.h>
   
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    % e6 h# k' ~( U' O* g  B, n, B2 e: m9 s
11. static TaskHandle_t AppTask_Handle = NULL;
    7 F- n9 q- Y$ F% Z; }2 i
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    
14. 
    " @6 I9 m) i3 H- X: r, ^6 \
15. extern int f_printf(const char *format, ...);
    ; a5 a- T2 W* z# B2 T  Z1 N  h
16. /* USER CODE END PV */
    
17. 
    ' E; L" T$ H2 n+ G$ R$ g
18. /* USER CODE BEGIN PFP */
    / g7 w/ Z2 z, P$ t0 V
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    
22. /* USER CODE END PFP */
    
23. 
    , Q! |8 y( Z) J1 x6 u) |9 [% \" B4 o
24. int main()
    # _; Q0 `' N, I% t) V& ^7 d* t  `* X+ U
25. {
    & Q/ f; m3 b# v% Z+ i
26. 
    
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    : `( S) G- A/ ^; u! K
29.         
    
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    . l8 s3 [" ?6 C) K! N6 Q4 ~6 D0 P
31.                         (const char*)   "APPTASKCREATE",
    
32.                         (uint16_t)      128,
    
33.                         (void *)        NULL,
    
34.                         (UBaseType_t)   1 ,
    , Q! {: `8 A; m4 \) K/ e( [' _
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    8 b- X" u, ?8 \6 {$ s2 E3 o/ R/ N
37.   if(xReturn == pdPASS)
    ) P& m8 q% h* l, N& X% B. i
38.         {
    0 a! `1 _' q% J! ~* Y
39.     f_printf("AppTask Create PASS.\r\n");
    3 j1 B* `; o% _% |. s1 E" C& m
40.                 vTaskStartScheduler();
    9 S6 O4 Q0 V7 O% r
41.         }
    $ {0 T5 Q3 T+ P* z
42.                                                                                                 
    & k/ P6 Q8 W2 S: z
43.   while (1)
    8 A; D6 x" B9 w6 o
44.   {
    
45.     /* USER CODE END WHILE */
    # b7 o. i' y' X* |5 y
46.     /* USER CODE BEGIN 3 */
    $ M: ~4 @, R3 L' b: ~* R0 w
47.   }
    
48.   /* USER CODE END 3 */
    
49. }
    
50. 
    
51. /* USER CODE BEGIN 4 */
    / x9 F9 J3 u5 b9 v' d
52. static void AppTaskCreate(void)
    2 @+ S) R8 b% o  _3 X# Q; l
53. {
    4 {7 @9 [- L& P5 s" M) p
54.   BaseType_t xReturn = pdFAIL;
    
55. 
    7 y3 b3 k4 @5 G6 _& v& r* T: U* q
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
57.                         (const char *)  "LEDTASKCREATE",
    - n, r% D* A7 L
58.                         (uint16_t)      128,
    & v  r! @, `7 w( p% v2 ?
59.                         (void *)        NULL,
    
60.   /*If the priority here is the same as the key task, printf will not print it out.        */
    
61.                         (UBaseType_t)   2,      
    
62.                         (TaskHandle_t *)&LedTask_Handle);
    8 M" F# A2 B, j! X8 N
63.   if(xReturn == pdPASS)
    
64.                 f_printf("LedTask Create PASS.\r\n");
    
65.         
    
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
67.                         (const char *)  "KEYTASKCREATE",
    ; T7 }5 l8 l7 ~" B, Q5 J* L
68.                         (uint16_t)      128,
    7 d/ ~8 Y$ X0 |$ E( x
69.                         (void *)        NULL,
    % I: c: \; X  O7 n
70.                         (UBaseType_t)   1,
    ' R, B0 b7 \% w' _, P) X
71.                         (TaskHandle_t *)&KeyTask_Handle);
    
72.   if(xReturn == pdPASS)
    
73.         {
    
74.                 f_printf("KeyTask Create PASS.\r\n");
      ]7 J) X% v, H+ ~/ ^
75.     vTaskDelete(AppTask_Handle);
    $ S. O. @" w  X! k# V" i
76.         }
    
77. 
    
78. }
    ' {* E. i& S* D% N$ D" W/ w$ |
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    : J5 L1 F6 V% R' D- n$ w& ^
82.         {
    ; a4 g3 O+ C, n& k
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.           {
    
85.       vTaskDelay(50);
    
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                   {
      R9 L2 L8 x$ C" @4 t: }1 u8 A
88.         xTaskNotifyGive(LedTask_Handle);
    
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    ! ]* Z/ Z2 u' M3 `& D
90.                   }
    5 z: u" b& `( W( R
91.           }
    
92.           vTaskDelay(100);
    " O" Y/ C& `) d% E6 Y3 J. c
93.   }
    7 m" c; ~/ m& i- r' s# g
94. }
    2 g8 g. M! ]9 e' ^9 x
95. static void LedTaskCreate(void)
    
96. {
    
97.         uint32_t ulreturn=0;
    
98.         while(1)
    ( \! z3 H: @% H% F4 d+ n0 K
99.         {
    
100.                
     5 M& Y# p& i/ X  i
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     # K3 Z2 T/ J" r: R9 P. s- r
102.                 if(ulreturn==1)
     $ x9 T9 Y/ c( k. E5 l
103.                 {
     
104.                         /*It won’t be printed out at the same level*/
     
105.                   f_printf("LedTask TAKE PASS.\r\n");
     
106.             HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
107.                         
     6 d; M6 w( M3 Y; {
108.                 }
     : G+ A3 ^6 x) [
109.                 else
     8 u+ A- d( [3 o- u; J
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     
111.     vTaskDelay(100);
     
112.   }
     + ~, ~  |/ e8 s
113. }
     
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     : J7 I$ w" |0 b8 S& v
117. 
     + W' j- M7 C2 b3 Z2 y9 P8 J
118. /*Turn on task notifications.*/
     
119. #define configUSE_TASK_NOTIFICATIONS      1
     + E1 E: d; T+ M. M& F
120. 在main.c文件里面修改代码
     
121. 
     1 h( F0 a$ t" q8 {5 t
122. /* USER CODE BEGIN Includes */
     
123. 
     / N2 G7 ~% g: m. E4 M, l. n3 a
124. #include "FreeRTOS.h"
     ' f# z" e* H- Q0 d. n
125. #include "task.h"
     2 P! @  B; ^  K! I1 H+ |/ l( f
126. #include <stdio.h>
     2 R3 m* t$ l) N; z# a. i
127. #include <string.h>
     2 b: J, X/ ^9 E, M' [% b8 w$ A
128. 
     % \$ ^; u/ @$ \  q" N7 k# [) F
129. /* USER CODE END Includes */
     
130. 
     
131. /* USER CODE BEGIN PV */
     9 X8 [7 H7 w# @4 m& W* Z8 ~% E
132. static TaskHandle_t AppTask_Handle = NULL;
     
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     ) B$ Q6 z: Q) E5 U4 M5 u
135. 
     
136. extern int f_printf(const char *format, ...);
     ! G$ `3 {5 p1 [
137. 
     
138. /* USER CODE END PV */
     / _% P& X: }* ~/ r/ H. H: C( D
139. 
     
140. /* USER CODE BEGIN PFP */
     * K7 I7 q; t3 ?6 z, J
141. static void AppTaskCreate(void);
     8 i, Q  a; \5 q8 H- U. V6 K
142. static void KeyTaskCreate(void);
     - L; K. }! l/ p
143. static void LedTaskCreate(void);
     - a! X. C$ X- b
144. /* USER CODE END PFP */
     
145. 
     
146. int main()
     
147. {
     * U7 ?# z$ s5 z+ x( Z
148.   /* USER CODE BEGIN WHILE */
     
149.   BaseType_t xReturn = pdFAIL;        
     
150. 
     
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     
152.                         (const char *)  "APPTASKCREATE",
     / A7 t1 L/ M5 A" Q
153.                         (uint16_t)      128,
     ! d, E7 F2 N2 Q3 F; }# l* B. A3 m
154.                         (void *)        NULL,
     
155.                         (UBaseType_t)   1,
     8 ]8 Y  s# g9 n1 \$ C: M4 B) g
156.                         (TaskHandle_t*) &AppTask_Handle);
     
157. 
     
158.   if(xReturn == pdPASS)
     . G2 n2 Z0 g% J2 z5 J1 R
159.         {
     * J% ?+ s) _/ Y+ e! p8 U. s8 A
160.     f_printf("AppTask Create PASS.\r\n");
     1 O; \5 s. G2 }
161.     vTaskStartScheduler();
     * p* f  [7 B! B' Y3 G0 i6 M
162.         }
     
163.   while (1)
     
164.   {
     
165.     /* USER CODE END WHILE */
     ! f( f2 I; k' |
166. 
     
167.     /* USER CODE BEGIN 3 */
     7 T7 l8 M5 y2 M$ R6 G
168.   }
     ( R/ g8 _1 N) }
169.   /* USER CODE END 3 */
     2 U% s- }' F3 A6 j1 P* S% l5 b" P4 g
170. }
     
171. 
     
172. 
     
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     ( B1 `$ \# K  g* n. s0 K( N1 \
175. {
     
176.         BaseType_t xReturn = pdFAIL;
     
177. 
     
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     # {$ ]8 |7 N8 a* J: T, s5 X
179.                         (const char *)  "LEDTASKCREATE",
     0 R2 s3 v" X  n5 h3 P, G. n+ Y
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     $ F# j9 @! p0 L; E% _
182.                         (UBaseType_t)   1,
     9 d4 R. R9 S5 ~- Z
183.                         (TaskHandle_t *)&LedTask_Handle);
     
184.   if( xReturn == pdPASS)
     , y% c" i* U$ W
185.           f_printf("LED Task Create PASS.\r\n");
     - ?  r$ [3 `0 M, n* v
186.         
     
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     ( p7 @% Y4 Q/ W1 K  \/ C
188.                         (const char *)  "KEYTASKCREATE",
     # y2 u9 F7 |, k) o, }
189.                         (uint16_t )     128,
     
190.                         (void *)        NULL,
     
191.                         (UBaseType_t)   2,
     9 p5 m$ C0 y. P0 r0 \, B9 @( N' B
192.                         (TaskHandle_t *)&KeyTask_Handle);
     
193.   if( xReturn == pdPASS)
     # S/ J2 e, |) ?2 i
194.         {
     ) v/ j+ |: }, b" a' j- B
195.     f_printf("KEY Task Create PASS.\r\n");
     
196.     vTaskDelete(AppTask_Handle);
     
197.         }
     
198. }
       z" o/ ^. ]' T4 B. ?" \% u
199. static void KeyTaskCreate(void)
     9 f! Z$ L5 y' J) x7 R# _. J
200. {
     , X) n$ L* i! _! M, Z4 P: f
201.   while(1)
     ( o/ l0 P' {/ l. T: L2 q; I
202.         {
     
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     ( s; X, @1 r3 }3 D
204.                 {
     9 r5 z6 @1 d: W, g# _4 l
205.                         vTaskDelay(40);
     0 b+ z# S- w9 m! r1 I1 b
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     + o7 w- u! I4 F2 X$ x- z$ }
207.                         {
     
208.                                 xTaskNotifyGive(LedTask_Handle);
     # |* i! B# r$ W( E2 s$ z$ q$ U
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     
210.                         }
     # B3 Y1 j+ X; d! F4 G, b! v
211.                 }
     
212.     vTaskDelay(40);
     + S# v& ~7 \; p8 c
213.         }
     
214.                
     
215. }
     
216. static void LedTaskCreate(void)
     2 \7 e7 s1 ]- r
217. {
     0 K8 q. j9 [  z0 a+ o% z
218.         uint32_t ulValue = 0 ;
     9 y8 F% G; w/ }. U6 G$ ~0 c. {3 k
219.         while(1)
     ( g- w" M9 D: }4 f1 x% r3 L- v2 Q
220.         {
     ! X# p: h- R- k7 I
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
     
222.                
     ) \+ ^' s3 S: }* b, e
223.                 /*Greater than 0 proves that there is still a notification value that can be
     - F0 [" N: o+ |: K, H
224.          *reduced by 1. Equal to 0 indicates that no notification is available
     8 ~, ~5 x1 J7 D% k& o0 j
225.          */
     
226.                 if(ulValue >0)
     * I/ p  e8 F1 Z  v
227.                 {
     / v9 ?3 v! J3 i+ [/ d2 N$ V9 O+ \
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
229.                         f_printf("LED Task PASS.\r\n");
     
230.                 }               
     * P  O: t+ u1 \, Z
231.                 vTaskDelay(1500);
     
232.         }
     # `3 G( D: O3 v+ }  f+ ^/ B
233. }
     
234. 
     ' L9 A4 \% c; `3 c% }2 b
235. /* USER CODE END 4 */

复制代码

" `; R. T! G3 q$ N/ q代替事件组
! D" F: C" g% P$ h- E. Y在FreeRTOSConfig.h里开启任务通知
: L0 X0 K# _3 F$ P8 X
7 M( s$ }/ r( S0 o- B, K% N

1. /*Turn on task notifications.*/
   : J* Z6 G$ c. t6 P5 [
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

( ^' w, G0 B1 p4 f+ M在main.c文件里面修改代码

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   3 R) W6 |. n. [2 P( v
5. 
   " b' X! ^$ b$ Q
6. #include <stdio.h>
   0 |7 A0 @$ p8 ~7 o% z( @' ]4 V; c
7. #include <string.h>
   
8. 
   ) p% \' x5 }+ g% {8 r  n1 h$ _0 v! t
9. /* USER CODE END Includes */
   
10. 
    ) s: Z5 y: z3 V3 u6 h4 i
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTask_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    / l, v  @) i. n! O" P: }
14. static TaskHandle_t LedTask_Handle = NULL;
    
15. 
    - l3 E2 h& x' ^7 ?
16. extern int f_printf(const char *format, ...);
    8 z9 @6 q8 }/ x6 B* K
17. /* USER CODE END PV */
    
18. 
    7 E( Q( x9 p& d& g% K+ }/ r; O; Y
19. /* USER CODE BEGIN PFP */
    5 |: X1 ]$ s" R1 L) P; P+ j
20. 
    
21. static void AppTaskCreate(void);
    4 o) m8 I4 |. n
22. static void KeyTaskCreate(void);
    
23. static void LedTaskCreate(void);
    8 M3 @6 e  T+ S( k' U( r+ n& N
24. 
    ( z; w$ Q! X8 t* v
25. /* USER CODE END PFP */
    : Q& d! `; N/ b/ T& }7 a
26. 
    
27. int main()
    5 ^( h3 S& X+ I
28. {
    8 d& G& Q9 Q0 f& r7 V% i$ C, a
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    5 y1 _5 u4 \! W" e& l5 M; p6 L! O1 Y
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    6 Q  A; D, t$ E
33.                             (const char *)  "",
    0 ~- w# S" ]  ^$ h
34.                                                 (uint16_t)      128,
    
35.                                                 (void *)        NULL,
    : s8 o% ]' Y; s/ q
36.                                                 (UBaseType_t)  1,
    / M+ U: e: K7 D2 `/ x5 g9 y7 H1 t
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    
38.         if( xReturn == pdPASS)
    - Z" J. N7 m0 t  t  F3 T7 f
39.         {
    ! a) v- n+ o$ Z% I* o9 C  y7 M
40.                 f_printf("APP Task Start.\r\n");
    , C6 [- f1 x6 f. f% x4 \" u
41.                 vTaskStartScheduler();
    
42.         }
    
43. 
    
44.   while (1)
    / G9 K2 I5 u; H4 Q
45.   {
    ) e" k4 ]' o1 Q. K7 s$ E
46.     /* USER CODE END WHILE */
    0 Z! Y! g2 i8 l% a% A
47. 
    
48.     /* USER CODE BEGIN 3 */
    4 z) w  I! a+ F! {6 w2 Z: ~
49.   }
    ! A+ P. M2 T6 X( q- ~* D
50.   /* USER CODE END 3 */
    + o$ J, C$ E8 b5 f% z
51. }
    
52. 
    
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    ( }; A5 u, K7 Q  t' C
55. {
    
56.         BaseType_t xReturn = pdFAIL;
    % m6 j* V/ h" r2 o; D" d
57.         
    3 c% }0 @. {, x! O- I1 e
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
59.                               (const char *)  "",
    ' x2 {- K9 I7 H$ J: C4 j. J2 C% ^
60.                                                                                                 (uint16_t)      128,
    ! V% B1 `* S4 a% ]( y3 B
61.                                                                                                 (void *)        NULL,
    
62.                                                                                                 (UBaseType_t)   1,
    
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    
64.   if( xReturn == pdPASS)
    ( N6 e' Q% s) w: V' }7 B+ G
65.                 f_printf("LED TASK PASS.\r\n");
    
66.         
    % Z2 Y2 P5 J4 v
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
68.                               (const char *)   "",
    
69.                                                                                                 (uint16_t )      128,
    , l: m8 J; i  k, T
70.                                                                                                 (void *)         NULL,
    
71.                                                                                                 (UBaseType_t)   2,
    ; n6 D6 h% \4 B0 X% x2 I
72.                                                                                                 (TaskHandle_t *) &KeyTask_Handle);
    
73.   if( xReturn == pdPASS)
    9 `4 q7 j) L6 a! a. r6 `$ K
74.         {
    3 R$ o7 b( C7 t7 y- Q; T3 i
75.     f_printf("KEY TASK PASS.\r\n");
    2 N- s1 v1 R; Q) M: h- p
76.                 vTaskDelete(AppTask_Handle);
    8 i# ^  Q- y% E+ S' V5 [
77.         }                                                                                
    
78. }
    
79. static void KeyTaskCreate(void)
    : ~5 F" {- {+ j, @
80. {
    
81.   while(1)
    9 H* ]* Q2 p+ }) t8 D  J" G8 _1 m
82.         {
    0 w, J  r7 W7 }$ \. E
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    4 b( w5 N# Q# J: i4 ^# t
84.                 {
      k3 U, r/ ?" s, b$ G. l  X
85.                         vTaskDelay(40);
    . O/ H. L4 S5 \
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    ' Y9 ?7 g! t3 R& ]6 s% r: m
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    
89.                                 f_printf("PA0.\r\n");
    ! E" M! f8 Q5 H0 J8 J: ]9 z; H, ]
90.                         }
    
91.                 }
    
92.                 else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    / G; d2 f7 }. H0 `9 X# {
93.                 {
    
94.                         vTaskDelay(40);
    
95.                         if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    0 @; o. |* i, u) r2 [
96.                         {
    * i7 F* T( k( B& ]$ s
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    
98.                                 f_printf("PC12.\r\n");
      }8 V6 ^' b# j- x. k" l
99.                         }
    . O* Z# Z5 L$ \1 a6 u
100.                 }
     5 a4 ~# p0 `* _8 k
101.                
     
102.                 vTaskDelay(50);
     
103.         }
     + M5 O/ v' Z9 l+ Y! b" L
104. }
     
105. static void LedTaskCreate(void)
     
106. {
     
107.         uint32_t ulReturn = 0;
     
108.         BaseType_t xReturn = pdFAIL;
     5 J/ G( q8 n9 P* L4 v5 a/ \
109.         while(1)
     6 k. r9 S6 P$ ~& o, l. s$ D+ g% p
110.         {
     
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     
112.                
     - v* y* V0 D8 ^# y+ w( Y1 `; o& x3 o
113.                 if(xReturn == pdTRUE)
     
114.                 {
     , g) P0 ]+ Q  I6 c; J
115.                         if( (ulReturn & 0x1)==1)
     2 l. l* C+ V' p: ~: o0 |
116.                         {
     ' k0 J. Y% \" N" h: ^( h
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     % v1 ]7 ]. |' s$ a
118.                                 f_printf("LED1.\r\n");
       o6 N9 B+ K( s8 W% v# s
119.                         }
     
120.                         else if( (ulReturn & 0x02)==2)
     
121.                         {
     
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     
124.                         }
     ) Q0 R" J/ e1 L8 S( x/ I/ Y7 b1 Q
125.                 }
     0 A# @4 n/ T# @; K
126.                 else
     
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     
129.                 vTaskDelay(1500);
     : Z, T! e2 N! d4 h9 v9 v
130.         }
     
131. }
     " i! Q8 i( p  G
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
在FreeRTOSConfig.h里开启任务通知
) a  s8 W8 ]2 g9 e9 U

1. /*Turn on task notifications.*/
   - m+ @. `! L, w# J2 i8 t7 u9 B
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

在main.c文件里面修改代码
, n4 ?6 `" y1 y

1. /* USER CODE BEGIN Includes */
   6 z. M5 O7 l3 ^: m# U( v+ o$ v% j
2. 
   , V6 v: m7 r0 m
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   ; w# s. b. C7 x
5. #include <stdio.h>
   
6. #include <string.h>
   1 S' t, s6 g8 Z. i0 B6 @' P1 E1 g) j
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    
11. static TaskHandle_t AppTask_Handle = NULL;
    4 c: Y! x. T% q5 M
12. static TaskHandle_t KeyTask_Handle = NULL;
    / F5 |, \2 h! O, y, L; u, }
13. static TaskHandle_t QueueTask_Handle = NULL;
    6 m1 J2 q8 i3 Q! q1 k
14. static uint32_t Message = 0;
    5 v: u& R5 Q8 G3 M* l, B
15. static uint32_t *printf_value=&Message;
    : p$ h9 m1 f2 Y1 A
16. extern int f_printf(const char *format, ...);
    
17. 
    
18. /* USER CODE END PV */
    
19. 
    1 k$ x* z; j2 q& X
20. /* USER CODE BEGIN PFP */
    
21. static void AppTaskCreate(void);
    3 F/ ^/ W$ m1 P5 R! Z8 T
22. static void KeyTaskCreate(void);
    
23. static void QueueTaskCreate(void);
    
24. /* USER CODE END PFP */
    
25. 
    
26. int main()
    
27. {
    
28.   /* USER CODE BEGIN WHILE */
    
29.   BaseType_t xReturn = pdFAIL;
    # B# g7 C! A+ P) K
30.         
      s0 `( a8 ~  a5 S+ V" P% v% d+ [% _
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    
32.                               (const char *)   "",
    ( ~3 e6 |. \: q0 ]% o4 S0 X
33.                                                   (uint16_t)       128,
    
34.                                                   (void *)         NULL,
    
35.                                                   (UBaseType_t)    1,
    
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    $ S; N0 Z* _" |" T$ a
37.                                                                                                 
    
38.   if( xReturn == pdPASS)
    2 J( c" W4 d. i- M
39.         {
    / X3 _5 W/ l' t8 G, `
40.     f_printf("AppTask Start.\r\n");
    3 i' {- W. f5 X; L5 D5 ~2 t
41.                 vTaskStartScheduler();
    
42.         }
    
43.         
    
44.   while (1)
    $ O, R4 w! L: ~0 o! T
45.   {
    . i% [$ M! {9 m# K, T- {
46.     /* USER CODE END WHILE */
    . m, j& f* a8 G) O) c
47. 
    
48.     /* USER CODE BEGIN 3 */
    + o% [  Q( N/ \) B
49.   }
    7 ?( J2 W8 i) \% e( ]+ i
50.   /* USER CODE END 3 */
    
51. }
    
52. 
      c; d) p% G# B  Q7 C* ^$ V
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    
55. {
    
56.         BaseType_t xReturn ;
    " y: r3 W9 ^% Y- T* @7 D
57.         
    " L, [  T+ p4 e9 D: K- A; t
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    
59.                          (const char *)  "",
    6 s; ^* K& [$ l2 |6 p2 g' j2 P
60.                                                                                                  (uint16_t)      128,
    
61.                                                                                                  (void *)        NULL,
    
62.                                                                                                  (UBaseType_t)   2,
    
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    
64.   if( xReturn ==pdPASS )
    2 n1 I4 E, b' X+ R* f$ K
65.                 f_printf("QueueTask Create PASS.\r\n");
    ! q1 J- [9 d( e
66.         
    4 p( ?+ O+ K4 W3 |8 ]$ h0 {$ X+ q' ]
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    
69.                          (uint16_t)      128,
    9 A6 s& R* s7 {
70.                                                                                                  (void *)        NULL,
    
71.                                                                                                  (UBaseType_t)   1,
    , C, |4 W0 a; W9 z/ x0 ~, @6 i
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    : ]( c3 E- L" O0 `+ \3 U" T# C! z6 ]7 g
73.   if (xReturn == pdPASS)
    0 j5 C) @7 U/ a
74.         {
    : E3 b, h; o7 t8 ?
75.           f_printf("KeyTask Create PASS.\r\n");
    % o3 j' w9 ^% X) j/ K7 N. W& ]) H( P
76.                 vTaskDelete(AppTask_Handle);
    
77.         }
    1 G* F/ G# k# G$ q" n9 \
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    + G- R9 {" t# X# R" J8 k% K# u
81.         while(1)
    
82.         {
    4 B9 @% O) `5 x1 v
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    6 r' H( {9 t, I2 \5 _* Z( j: |8 a9 M
84.                 {
    
85.                         vTaskDelay(80);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    
89.                         }
    * `; {5 n7 R; \5 ]1 \
90.                 }
    
91.                 vTaskDelay(80);
    1 E' k* y8 K$ V% d4 t0 F3 M" A
92.         }
    7 G. T) U% i4 b
93. }
    
94. static void QueueTaskCreate(void)
    
95. {
    
96.         while(1)
    
97.         {
    7 ?8 }- B1 ^2 ?2 H1 K: |- U
98.                 /*work.*/
    
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    
100.                 f_printf("Message is :%d\r\n",*printf_value);
     & k5 l# I5 U6 I+ G3 E; z. Z% H
101.                 Message=*printf_value;
     ; n. `5 A$ i' q7 E( T
102.                
     - y$ b- _3 ^2 h8 T( ~) f
103.                 /*The second method works too*/
     
104.         /*
     9 U0 {5 ~* c% g
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     
106.                 f_printf("Message is :%d\r\n",Message);
     
107.         */
     & t8 |) ?% x) K6 x0 R( N& o- p
108.                 Message++;
     
109.                 if(Message > 10)
     
110.                         Message = 0;
     - O+ b' v* \2 T, C6 ~6 \
111.                 vTaskDelay(1000);
     1 t9 D! ]7 ~9 f2 ]# F8 k4 y
112.         }
     / Y$ I0 \$ ^2 l7 V5 _
113. }
     2 p$ o8 E' j6 N
114. /* USER CODE END 4 */

复制代码

% }- j3 F6 H* n1 `" i