概述
        每个任务都有一个32位的通知值，可以替代二值信号量，计数信号量，事件组，也可以代替长度为1的队列。

        有以下几种方式发送通知给任务：
; d8 p) t+ F' o. I8 y% S
1 M# e% f" Z8 z4 X1.有通知未读，则不覆盖通知值

2.直接覆盖通知值
0 U3 `1 K1 C! e! }
3.设置通知值一个或者多个位，当做事件组来使用
1 ]( Q: k) k( p) H+ i
  D, u) L% u: K! M' W6 H0 W4.递增/递减通知，当做信号量来使用
: v5 J' p* j6 }& D' {" r
        有以下缺点：
6 I2 i- P# B( ]8 c' R* o6 p% E3 O2 C
1.只能有一个任务接收通知消息
$ y& R, a. |3 @1 o
- d+ J3 ?0 @5 c4 k5 m2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。
2 j- V) V( Q' _; N4 J" S
$ M- m0 c+ P3 ]' _2 s3 {代替二值信号量
在FreeRTOSConfig.h里开启任务通知

1. /*Turn on task notifications.*/
   
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

在main.c文件里面修改代码
& O6 W7 k* Z, O' R- d6 [+ @& E

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include <stdio.h>
   
6. #include <string.h>
   
7. 
   # `, l  W" `" W2 C" I3 |; p
8. /* USER CODE END Includes */
   7 B6 H, `# d) U
9. 
   
10. /* USER CODE BEGIN PV */
    6 P5 f0 c5 T+ W0 {
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    ; s2 J! ~! O2 z1 ^8 R- O( |
14. 
    9 \: P$ I0 S" ]; i! P9 Q1 r
15. extern int f_printf(const char *format, ...);
    
16. /* USER CODE END PV */
    
17. 
    ' v+ }" Q  }! F8 P* F
18. /* USER CODE BEGIN PFP */
    
19. static void AppTaskCreate(void);
    # ~9 W* H9 ^! o9 d4 W  s, }4 ]: @
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    / Z9 h  t$ A% _: b1 g9 X
22. /* USER CODE END PFP */
    
23. 
    : l" V# Y# N( ?9 I: w3 n
24. int main()
    ; x/ F1 i8 h1 }
25. {
    
26. 
    
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    
29.         
    
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    , C% m% Q* N  Y* z! X
31.                         (const char*)   "APPTASKCREATE",
    5 \/ R& y* x6 l9 t0 `) w3 S$ E, o
32.                         (uint16_t)      128,
    
33.                         (void *)        NULL,
    
34.                         (UBaseType_t)   1 ,
    
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    
37.   if(xReturn == pdPASS)
    1 h: f+ R) D8 T& \) e+ P
38.         {
    : ^" o) j+ J+ W1 T2 E. x* W  S
39.     f_printf("AppTask Create PASS.\r\n");
    ' R2 B' }9 @# m3 x$ Y& V4 J
40.                 vTaskStartScheduler();
    6 A$ r& [& U" n! u& `+ p  W
41.         }
    
42.                                                                                                 
      M" E% u8 [$ w1 R+ P+ [
43.   while (1)
    & X! y: [6 o2 f: q/ o  u4 L
44.   {
    
45.     /* USER CODE END WHILE */
    
46.     /* USER CODE BEGIN 3 */
    
47.   }
    ( K. w0 r  G' R# l$ u
48.   /* USER CODE END 3 */
    9 s9 Q1 n2 v; f3 P8 |6 {# Z
49. }
    * v" x% W) A+ c0 K$ X9 V; w
50. 
    , C/ n! G; ]7 z  s
51. /* USER CODE BEGIN 4 */
    % }: ^2 e3 g5 B) D8 E! ~( e: v
52. static void AppTaskCreate(void)
    8 V0 ?- y, m4 V5 L! X2 t7 v% ]7 S
53. {
    
54.   BaseType_t xReturn = pdFAIL;
      z$ A& l. A$ f/ ~
55. 
    
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    7 W; t. R: i0 J" j8 h7 M: j
57.                         (const char *)  "LEDTASKCREATE",
    , ?6 }) m9 ]& @2 d0 e; Y. o) M& e
58.                         (uint16_t)      128,
    
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);
    
63.   if(xReturn == pdPASS)
    * v6 G' n7 b! y4 x$ Z9 d' @, I; z
64.                 f_printf("LedTask Create PASS.\r\n");
    6 E0 |5 }# w' w* T; B4 J5 M- ^
65.         
    # ]9 `1 l1 W6 A3 ^) O
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    7 v( D5 w3 Q' z* _" |. @; w9 X
67.                         (const char *)  "KEYTASKCREATE",
    + M9 X! z& B. u, W: [
68.                         (uint16_t)      128,
    
69.                         (void *)        NULL,
    1 M8 |7 b! \4 y& A1 F4 y3 }) x
70.                         (UBaseType_t)   1,
    * `$ ]2 u% D7 T" U9 O' F
71.                         (TaskHandle_t *)&KeyTask_Handle);
    : @5 |9 o* \* M8 G+ a* l
72.   if(xReturn == pdPASS)
    9 n  M& N' u6 ^
73.         {
    
74.                 f_printf("KeyTask Create PASS.\r\n");
    $ F1 L( A. M7 A5 K. ^) g
75.     vTaskDelete(AppTask_Handle);
    
76.         }
    
77. 
    
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    $ m, f7 k/ r1 Y; P  I1 s# d
81.         while(1)
    ) G- h: g1 q! k' _
82.         {
    " D( ?4 s7 {& o
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    3 z4 s8 e: H9 ^( E
84.           {
    " R# w3 j* }. A
85.       vTaskDelay(50);
    6 O/ v1 k; v, L% Z6 T# ?% }
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    " P9 Y3 T( |1 Z1 K% _2 }: l
87.                   {
    
88.         xTaskNotifyGive(LedTask_Handle);
    8 ]0 p5 M; j/ V# O8 }  i
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    ! I- A! N2 |9 U2 x7 e, Q4 A9 J
90.                   }
    ; O% M# Y1 {/ i# G7 v( E
91.           }
    
92.           vTaskDelay(100);
    9 c- S, L. i0 L( G# |
93.   }
    / B0 d7 I/ o  B0 r( o$ F( s' t
94. }
    
95. static void LedTaskCreate(void)
    
96. {
    4 U" t$ g+ g7 |/ c
97.         uint32_t ulreturn=0;
    
98.         while(1)
    # V8 I8 N: }; U# W# i$ G& @
99.         {
    
100.                
     ( c* ^4 v/ {; U
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     
102.                 if(ulreturn==1)
     5 Y- C% }+ V$ [$ R! N" m) D# I1 s
103.                 {
     
104.                         /*It won’t be printed out at the same level*/
     3 V' @- V! z5 {5 r, ]' H; G
105.                   f_printf("LedTask TAKE PASS.\r\n");
     4 m  w% O. n3 F2 G2 L3 }3 l. a
106.             HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     8 O9 W4 m( K0 p: w. y) ?' s! H
107.                         
     
108.                 }
     5 b/ D2 o" t$ n
109.                 else
     4 |2 `1 W+ I& f6 u0 a' }# T% \
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     % q9 T7 P( z5 o' b8 E9 Q
111.     vTaskDelay(100);
     " u) Y) Y$ k% a
112.   }
     
113. }
     * w% J. O: E% H, H
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     
117. 
     - {: p" K! s1 q- I  Y# f7 I- `
118. /*Turn on task notifications.*/
     
119. #define configUSE_TASK_NOTIFICATIONS      1
     
120. 在main.c文件里面修改代码
     2 M! Q1 X, b+ w/ @9 V
121. 
     
122. /* USER CODE BEGIN Includes */
     . ?+ e" V/ M; d4 k
123. 
     1 V8 u' X7 I. V. H5 G  r9 U
124. #include "FreeRTOS.h"
     
125. #include "task.h"
     
126. #include <stdio.h>
     
127. #include <string.h>
     
128. 
     
129. /* USER CODE END Includes */
     
130. 
     
131. /* USER CODE BEGIN PV */
     
132. static TaskHandle_t AppTask_Handle = NULL;
     
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     
135. 
     
136. extern int f_printf(const char *format, ...);
     
137. 
     
138. /* USER CODE END PV */
     
139. 
     - V6 ?+ L' i$ e* Y1 H( `
140. /* USER CODE BEGIN PFP */
     4 r( s1 I$ h( @
141. static void AppTaskCreate(void);
     ! L1 z8 h& f7 n2 J# B4 o4 r! @9 K
142. static void KeyTaskCreate(void);
     4 W' Y1 l& x" `' \  a$ ^+ I& U4 i
143. static void LedTaskCreate(void);
     
144. /* USER CODE END PFP */
     
145. 
     
146. int main()
     ! }+ X; w: V( h. ~2 o3 O
147. {
     : s  r: {, C- K
148.   /* USER CODE BEGIN WHILE */
     3 P, G) N5 M6 }( E: V) I+ g
149.   BaseType_t xReturn = pdFAIL;        
     8 F' y* J( C+ R" k/ u: N1 O
150. 
     2 g$ T( A5 z5 U4 U- o7 x; h% ~! n
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     ! P% }2 E4 f8 E4 x4 D- W. F8 I
152.                         (const char *)  "APPTASKCREATE",
     
153.                         (uint16_t)      128,
     
154.                         (void *)        NULL,
     5 Z; J  j2 V$ b0 M
155.                         (UBaseType_t)   1,
     * t4 i0 j! q! H( B* e0 ]% R
156.                         (TaskHandle_t*) &AppTask_Handle);
     
157. 
     + l5 G( _0 J/ R- W
158.   if(xReturn == pdPASS)
     8 N5 b" B* \( B6 y2 ^
159.         {
     
160.     f_printf("AppTask Create PASS.\r\n");
     
161.     vTaskStartScheduler();
     ( o, v1 a& B6 y8 ~- F
162.         }
     
163.   while (1)
     3 d7 }7 w7 r' j0 A
164.   {
     
165.     /* USER CODE END WHILE */
     
166. 
     
167.     /* USER CODE BEGIN 3 */
     1 F. S) f7 K! K7 P
168.   }
     $ L9 O! P1 w; a" ?: {9 S
169.   /* USER CODE END 3 */
     ( {1 {6 h+ |* |) z/ X
170. }
     
171. 
     6 S' n0 A/ B9 I( x6 w
172. 
     4 f, Z% O9 D, D/ S
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     / z  u  w, b6 d( m
175. {
     
176.         BaseType_t xReturn = pdFAIL;
     
177. 
     ! Y: t- \/ a4 H- ]- p% u
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     
179.                         (const char *)  "LEDTASKCREATE",
       j5 e2 ^' ]7 Y+ y- P$ W
180.                         (uint16_t)      128,
     ; P, l2 c  z6 k- R' H- b
181.                         (void*)         NULL,
     : {" |3 K2 j% ~8 p1 e
182.                         (UBaseType_t)   1,
     
183.                         (TaskHandle_t *)&LedTask_Handle);
     
184.   if( xReturn == pdPASS)
     - t0 w$ y7 W" }
185.           f_printf("LED Task Create PASS.\r\n");
     
186.         
     # ~- v% y# ^+ d2 p2 w6 x7 x+ n: Q
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     
188.                         (const char *)  "KEYTASKCREATE",
     ' A- K) J5 E+ A6 o* L
189.                         (uint16_t )     128,
     2 c- W6 j! f7 n& Z
190.                         (void *)        NULL,
     9 x  [7 ]9 m+ q! Z3 N. \3 w
191.                         (UBaseType_t)   2,
     ' ^$ ]( E4 T8 J; h0 d
192.                         (TaskHandle_t *)&KeyTask_Handle);
     
193.   if( xReturn == pdPASS)
     
194.         {
     
195.     f_printf("KEY Task Create PASS.\r\n");
     ; y( \% {! F4 u) x' \0 m. V6 P
196.     vTaskDelete(AppTask_Handle);
     # r6 p) N- a0 ~' z
197.         }
     
198. }
     2 T8 g1 @: W0 E! Q- i
199. static void KeyTaskCreate(void)
     ; I; p/ [: P+ K7 N
200. {
     
201.   while(1)
     / f0 v2 [- S( G4 D
202.         {
     2 p& |0 E3 a% ~* o* L& ?% t
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     8 w: B" c: X' d. S% T
204.                 {
     
205.                         vTaskDelay(40);
     
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     $ Q- c. ~% v7 C# D" K; d
207.                         {
     7 F, C. u% p0 u7 D- ^5 N
208.                                 xTaskNotifyGive(LedTask_Handle);
     
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     / s! D9 ?0 E5 @& s6 D
210.                         }
     
211.                 }
     " i6 S8 e/ V- V; }0 N  D# a
212.     vTaskDelay(40);
     ! H: g, H! W! V6 C) }
213.         }
     4 E$ W* v+ S/ f% B  V
214.                
     . r, R3 A2 \6 S) i; }* `$ o2 Y
215. }
     ; F, T1 A# U3 m$ p( E' I3 Z/ X/ Q
216. static void LedTaskCreate(void)
     * f; a* D  ?9 E) O; X  ?6 R* Q
217. {
     
218.         uint32_t ulValue = 0 ;
     
219.         while(1)
       U8 |& Y/ P' s
220.         {
     ; k, Z+ g+ j. J& R; L) Z1 N) \
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
       s1 X- C+ |7 V) v2 U3 U
222.                
     
223.                 /*Greater than 0 proves that there is still a notification value that can be
     ( O6 K+ k' O, V: ?$ N
224.          *reduced by 1. Equal to 0 indicates that no notification is available
     
225.          */
     
226.                 if(ulValue >0)
     ) g6 d% y& J% G/ W
227.                 {
     
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
229.                         f_printf("LED Task PASS.\r\n");
     
230.                 }               
     9 A! P% \. U' u7 M
231.                 vTaskDelay(1500);
     
232.         }
     7 Z3 f. o( g, A% P6 O0 D8 B8 ]0 p
233. }
     
234. 
     2 G2 ^" K$ q. e# h( m& x% M9 n
235. /* USER CODE END 4 */

复制代码

代替事件组
% q* O  B1 V  M2 i9 _在FreeRTOSConfig.h里开启任务通知

1. /*Turn on task notifications.*/
   , {; j- E" G: O, |) z
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

在main.c文件里面修改代码

- y* B/ G7 ^* e% M

1. /* USER CODE BEGIN Includes */
   
2. 
   ! @/ K2 K. L* @; F0 J- l0 {  r
3. #include "FreeRTOS.h"
   " V5 e" o# I/ r; K$ h
4. #include "task.h"
   2 S- H$ T" K; Y: Q7 D
5. 
   
6. #include <stdio.h>
   6 V( g( p3 b4 |, I8 O& b
7. #include <string.h>
   
8. 
   
9. /* USER CODE END Includes */
   
10. 
    - m2 `# n6 J, T/ t- x$ f2 m) e: K
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTask_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t LedTask_Handle = NULL;
    
15. 
    
16. extern int f_printf(const char *format, ...);
    
17. /* USER CODE END PV */
    - @5 _3 ^- b8 `- y$ V# g
18. 
    - U& P) `; S$ G/ S& M! f( l; w
19. /* USER CODE BEGIN PFP */
    
20. 
    " {' _2 j- R. W" }% p1 b$ }
21. static void AppTaskCreate(void);
    
22. static void KeyTaskCreate(void);
    
23. static void LedTaskCreate(void);
    8 B5 U) ]; g0 C# R; o
24. 
    
25. /* USER CODE END PFP */
    - b" t7 |0 m, a' h/ r) T6 _1 x
26. 
    
27. int main()
    , s) v8 k' Y* g! ?4 }; G+ P& V+ _' a
28. {
    6 f* {- t& q$ o+ H* _. Q, R
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    5 h8 ^6 Q4 ?4 c) L0 Y# G, Y  i/ G% E/ l
33.                             (const char *)  "",
    ' j6 I' @8 F9 p/ G; G6 w
34.                                                 (uint16_t)      128,
    & _( F& B) I; I# Y  ^& ~
35.                                                 (void *)        NULL,
    , [) _# S3 m% S# c9 h, [
36.                                                 (UBaseType_t)  1,
    5 D( w! O% L6 m. S, x( N% `' l
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    
38.         if( xReturn == pdPASS)
    
39.         {
    
40.                 f_printf("APP Task Start.\r\n");
    . j% S* n- C: }1 C8 X: v, g
41.                 vTaskStartScheduler();
    ) D; ^% A: W% d7 `, W2 A/ C: f
42.         }
    
43. 
    
44.   while (1)
    
45.   {
    $ j0 |. f* B& R, Z1 I4 F
46.     /* USER CODE END WHILE */
    , |2 Q  f  x2 I( _5 l( B
47. 
    
48.     /* USER CODE BEGIN 3 */
    + d$ ]- i& K) J4 r; \' t
49.   }
    1 x! J: j" D; l; _- S
50.   /* USER CODE END 3 */
    
51. }
    
52. 
    & M  h5 A/ W! {& @0 [
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    + L9 z6 ]3 i3 R3 c' s8 f6 A  s
55. {
    
56.         BaseType_t xReturn = pdFAIL;
    
57.         
    
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
59.                               (const char *)  "",
    + E2 _1 U* _% G1 c: I& W
60.                                                                                                 (uint16_t)      128,
    1 z4 d4 A0 l; T9 j* e2 M$ U* B' g
61.                                                                                                 (void *)        NULL,
    0 S4 R* T3 C$ J* g* q5 W1 a3 p
62.                                                                                                 (UBaseType_t)   1,
    
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    
64.   if( xReturn == pdPASS)
    
65.                 f_printf("LED TASK PASS.\r\n");
    5 S7 }7 F8 Z6 c" [, f0 \$ H: T
66.         
    * f' Y  u+ ^$ t# d( i3 E
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    ! K2 Q! r# b- d  A. d5 l7 E
68.                               (const char *)   "",
    ) S( |: O& [) v: {( _; n
69.                                                                                                 (uint16_t )      128,
    , l! N+ E, K  c8 k% Q  A
70.                                                                                                 (void *)         NULL,
    
71.                                                                                                 (UBaseType_t)   2,
    
72.                                                                                                 (TaskHandle_t *) &KeyTask_Handle);
    
73.   if( xReturn == pdPASS)
    
74.         {
    
75.     f_printf("KEY TASK PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    1 V5 U) k! e; a5 `  D4 ~/ \
77.         }                                                                                
    ) a3 I% J: j4 \7 }! P
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    ; b- M+ @3 D+ ?( q4 {! h
81.   while(1)
    
82.         {
    9 m* n4 h& P+ F) o( {# ?
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    ' z  i& r: l1 ~) \5 C( T7 T2 L. P
84.                 {
    
85.                         vTaskDelay(40);
    $ M- m) U( W& F/ i7 @
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    - R" m9 T: C1 Z# [
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    " N% _7 V2 a, }
89.                                 f_printf("PA0.\r\n");
    
90.                         }
    - J* ]( C# e) u+ }, S/ N+ W
91.                 }
    - F4 c' M# x9 _2 s
92.                 else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    
93.                 {
    6 q3 H9 N- j* @! A4 Y7 I
94.                         vTaskDelay(40);
    
95.                         if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    
96.                         {
    0 X9 H' N9 ~- u& U4 Q; X- J
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    
98.                                 f_printf("PC12.\r\n");
    
99.                         }
    6 ?$ U  a1 H2 ^. e
100.                 }
     * S* ^# A. P" o
101.                
     / A' g9 U3 ^# n6 Z1 ~' j6 v3 i  y
102.                 vTaskDelay(50);
     
103.         }
       M3 a* [+ b& B# j7 ~, l, F
104. }
     
105. static void LedTaskCreate(void)
     1 X) A, L# Q& V" ^$ {
106. {
     % Y6 v2 u' f( H# ?
107.         uint32_t ulReturn = 0;
     ( q1 d& }: X% q' |$ W: F: t
108.         BaseType_t xReturn = pdFAIL;
     
109.         while(1)
     + Y- ~6 d" H0 O7 }& d7 }# u
110.         {
     
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     ( }$ Z0 e0 J  Y* \
112.                
     $ D/ {) C' Q0 a
113.                 if(xReturn == pdTRUE)
     " b8 V0 I- U- X- `' _- a
114.                 {
     
115.                         if( (ulReturn & 0x1)==1)
     $ Q* W/ {! H. P+ G# F
116.                         {
     + s5 V/ G0 z% Q, Q6 b- J
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
118.                                 f_printf("LED1.\r\n");
     
119.                         }
     4 [% Y" g0 o5 t- n
120.                         else if( (ulReturn & 0x02)==2)
     . ~/ b- U7 Y8 _0 p7 O2 L
121.                         {
     
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     
124.                         }
     0 w2 N8 `( c& s9 Q* f# Q* ?7 @  z3 Q/ I
125.                 }
     
126.                 else
     
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     ' N, w3 J7 B  {' W$ g# o8 G1 z$ N
129.                 vTaskDelay(1500);
     
130.         }
     . L. W* u8 j6 G- V
131. }
     3 Q* U# i& B0 J. _! }; F
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
# {1 D6 f% u& U' b在FreeRTOSConfig.h里开启任务通知
4 \; _( H. ]+ Y$ K, e& U

1. /*Turn on task notifications.*/
   
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

- ~5 I9 `. X* ]  f5 q6 _3 ~. l在main.c文件里面修改代码
$ u& M  t7 D* U* O$ I: c0 {
/ W. o* `7 ]/ m

1. /* USER CODE BEGIN Includes */
   5 V5 `# K8 V2 L; y! u1 v
2. 
   ' {; J$ K4 J9 R2 l
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   1 k( J6 P$ Y3 u  |  |' W+ Q+ v7 N7 C
5. #include <stdio.h>
   5 |! P2 \( n3 f
6. #include <string.h>
   0 p8 j! _, B+ \
7. 
   + ^# D! n( Q- Y* S& A( U
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    
11. static TaskHandle_t AppTask_Handle = NULL;
    0 @$ p1 L* z5 H4 T
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t QueueTask_Handle = NULL;
    
14. static uint32_t Message = 0;
    , a1 z6 K6 M! K$ }% O! X0 ~, {
15. static uint32_t *printf_value=&Message;
    / c2 Z1 v8 _: Z2 U6 o0 K
16. extern int f_printf(const char *format, ...);
    
17. 
    
18. /* USER CODE END PV */
    ; X7 a- O2 S, A( m  ]
19. 
    0 o( G3 x( Y; s9 Q- b" ^0 _
20. /* USER CODE BEGIN PFP */
    ' y- V& t9 \- p# N6 L- R7 d+ _
21. static void AppTaskCreate(void);
    
22. static void KeyTaskCreate(void);
    # i# o; m  {: X
23. static void QueueTaskCreate(void);
    
24. /* USER CODE END PFP */
    $ b1 m8 }9 h. Q
25. 
    
26. int main()
    
27. {
    
28.   /* USER CODE BEGIN WHILE */
    ' l" ~: |/ v2 r% U" [/ }) t# C
29.   BaseType_t xReturn = pdFAIL;
    8 n8 d9 Z9 t+ B4 j4 \) B2 S3 a! R" b6 R- M
30.         
    
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    
32.                               (const char *)   "",
    / ^9 j4 e* `# x
33.                                                   (uint16_t)       128,
    ) k0 H' |/ y& U# P6 v
34.                                                   (void *)         NULL,
    ; r# }. A9 s. \1 g9 x/ w
35.                                                   (UBaseType_t)    1,
    
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    
37.                                                                                                 
    
38.   if( xReturn == pdPASS)
    ) C+ i) B2 `+ u9 E% ^
39.         {
    
40.     f_printf("AppTask Start.\r\n");
    + t: K4 V$ a0 I; S" |& j0 H$ G) \: Y
41.                 vTaskStartScheduler();
    
42.         }
    * y2 ?7 U$ v  L  G$ v* M
43.         
    0 t& z; l8 {6 j! K, E( S' u/ g0 L! _
44.   while (1)
    + S( R5 k* J2 u5 R
45.   {
    
46.     /* USER CODE END WHILE */
    ; y9 B1 v4 E' [5 _0 P5 Y: s1 N
47. 
    
48.     /* USER CODE BEGIN 3 */
    9 R. f2 N3 b6 x' K' O  v
49.   }
    7 Y5 x0 g  F: M$ a3 Y% }
50.   /* USER CODE END 3 */
    ; j8 J! p0 h% n
51. }
    
52. 
    
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    
55. {
    * f. W3 I* ]7 l# x% u) w
56.         BaseType_t xReturn ;
    
57.         
    : Q( J; Z( R" l- C3 R4 y8 M
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    7 r/ i" q" v& [) q4 x! m% \: |* v
59.                          (const char *)  "",
    
60.                                                                                                  (uint16_t)      128,
    ( j+ e9 N9 S7 g# V$ o: m( c
61.                                                                                                  (void *)        NULL,
    ! u6 [7 Z  Q; u2 V, i+ H
62.                                                                                                  (UBaseType_t)   2,
    3 K2 i9 V5 d6 E* J7 Z3 X( M
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    1 Y; w. K  e# `8 ?- R
64.   if( xReturn ==pdPASS )
    
65.                 f_printf("QueueTask Create PASS.\r\n");
    . O' c* f: {7 b1 T. u
66.         
    
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    9 p7 z8 `8 Q9 ^' ^" t5 M
69.                          (uint16_t)      128,
    + }0 O3 D! |' J# S' P% U/ f
70.                                                                                                  (void *)        NULL,
    
71.                                                                                                  (UBaseType_t)   1,
    7 U3 Z1 R$ a) d
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    * I- h+ }8 P+ J' ~6 c$ Z
73.   if (xReturn == pdPASS)
    . B. G2 y! t6 u1 O
74.         {
    
75.           f_printf("KeyTask Create PASS.\r\n");
    ! F8 j- X' F& I# S% c4 y# S! I6 ^4 l
76.                 vTaskDelete(AppTask_Handle);
    / B  ]* `: [# L# V7 t( }: y3 {
77.         }
    ( b. I9 y9 I- v) o; H. V
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    7 X8 M9 D) E; M. u. {3 J
81.         while(1)
    . `- z( f, a  [7 x
82.         {
    " R4 E2 N& t/ m
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    ) N& Q8 {1 D! P
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    
89.                         }
    ( A. m- w7 I+ A% x- M9 `$ d% [( L
90.                 }
    
91.                 vTaskDelay(80);
    ; |# ^; M" t2 {8 J% @
92.         }
    
93. }
    
94. static void QueueTaskCreate(void)
    1 A8 [4 k( k. C% X' f- l
95. {
    ) f$ O2 x1 @" X$ b
96.         while(1)
    
97.         {
    
98.                 /*work.*/
    ! ?4 I4 C9 i$ X
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    1 u3 V! D7 d6 a" R+ }: _5 M8 x
100.                 f_printf("Message is :%d\r\n",*printf_value);
     
101.                 Message=*printf_value;
     $ Y* P5 E9 F$ s# ]; K: U4 A) o5 d+ V
102.                
     2 L. i  o! z8 F3 s" m) A
103.                 /*The second method works too*/
     8 l% A' H6 t% l8 a& x
104.         /*
     
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     , I" S' Z3 @# H- P, z
106.                 f_printf("Message is :%d\r\n",Message);
     6 {9 W" m" h3 C8 X0 U
107.         */
     , c3 P5 w/ l( R# R
108.                 Message++;
     
109.                 if(Message > 10)
     0 s7 G9 {- k+ ]8 Z6 l
110.                         Message = 0;
     8 `' `% T( `/ t
111.                 vTaskDelay(1000);
     / D" i3 j: n( k
112.         }
     / [! G# |" O; d* @4 }( U, r
113. }
     ! C+ J: G3 o4 \3 W
114. /* USER CODE END 4 */

复制代码

: e* L. n+ v: J, R5 E
0 r$ @8 I' O, P5 E