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

        有以下几种方式发送通知给任务：
' z0 {" }6 i" W! ~/ L, c# r5 I
1.有通知未读，则不覆盖通知值
( ^* j+ F) B1 q% k( y% B( s
5 C( ?5 T# R/ O2.直接覆盖通知值
$ j- A- \+ A5 c7 L
3.设置通知值一个或者多个位，当做事件组来使用

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

        有以下缺点：
2 T+ L" H3 r" G
5 n: {, m* G" b) W0 P9 ?+ b4 v: T1.只能有一个任务接收通知消息
+ j8 w& Z6 B, z8 K) H% i: Y
; D3 T5 o! M, N$ _. ]2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。
$ m, I4 n# D1 o; }! H" e8 f% @9 B1 X
代替二值信号量
在FreeRTOSConfig.h里开启任务通知
" o$ _, I/ t2 z% q9 J4 [- q0 y

1. /*Turn on task notifications.*/
   1 Z/ N' G- {% c! d& x: p7 R
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

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

1. /* USER CODE BEGIN Includes */
   9 n% A8 A. [* |3 m  S" G3 r
2. 
   ; _, d' t, @$ l) U5 u
3. #include "FreeRTOS.h"
   # [" W5 S% Z+ o  `
4. #include "task.h"
   ! b: K5 c$ m5 }# k; f" D- ?
5. #include <stdio.h>
   
6. #include <string.h>
   
7. 
   ) g8 \" Y) x& c: o8 N+ w7 k
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    1 v3 d: S/ X( x$ M) n
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    
14. 
    
15. extern int f_printf(const char *format, ...);
    
16. /* USER CODE END PV */
    
17. 
    
18. /* USER CODE BEGIN PFP */
    4 ]! |7 E$ \  O( m
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    
22. /* USER CODE END PFP */
    2 _. N+ I' y  f8 j, t, V1 g& g
23. 
    
24. int main()
    
25. {
    8 X6 B: g4 J: {; W
26. 
    ! m3 j4 X* |6 B8 }
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    - N* I, H2 t4 M0 M
29.         
    
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    ' P0 g" s4 k& g$ C  B) O7 k) R
31.                         (const char*)   "APPTASKCREATE",
    4 c3 A; ?$ g3 @$ ]) b& \
32.                         (uint16_t)      128,
    , e% }" Y. ~7 A9 z  t8 `
33.                         (void *)        NULL,
    
34.                         (UBaseType_t)   1 ,
    8 b3 C9 m. b' A7 L
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    
37.   if(xReturn == pdPASS)
    0 {/ g. k9 H7 F% W/ I- D
38.         {
    
39.     f_printf("AppTask Create PASS.\r\n");
    & r/ R' m1 m0 T$ y4 t8 o
40.                 vTaskStartScheduler();
    
41.         }
    
42.                                                                                                 
    
43.   while (1)
    # E( y  K% H$ ~4 i
44.   {
    
45.     /* USER CODE END WHILE */
    
46.     /* USER CODE BEGIN 3 */
      b0 ~% `# d* _: K* }) i4 M( Z
47.   }
    ; W1 P) P( m* o1 r
48.   /* USER CODE END 3 */
    
49. }
    ( U; ]/ s( Z( ]
50. 
    
51. /* USER CODE BEGIN 4 */
    * w# s3 I. n+ M& u
52. static void AppTaskCreate(void)
    
53. {
    
54.   BaseType_t xReturn = pdFAIL;
    
55. 
    3 G- h4 Y  j3 P$ z
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    2 x* O  R: z: o: z. R
57.                         (const char *)  "LEDTASKCREATE",
    - \7 X7 h9 r. E( G+ F% w3 D( ?9 X
58.                         (uint16_t)      128,
    9 N; \& e# e) ~7 K5 E2 q
59.                         (void *)        NULL,
    
60.   /*If the priority here is the same as the key task, printf will not print it out.        */
    4 _0 a. `% b  a" l7 S
61.                         (UBaseType_t)   2,      
    " }: |0 _# {+ R8 j$ ^1 m4 c$ c" j9 |
62.                         (TaskHandle_t *)&LedTask_Handle);
    
63.   if(xReturn == pdPASS)
    
64.                 f_printf("LedTask Create PASS.\r\n");
    
65.         
    
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
67.                         (const char *)  "KEYTASKCREATE",
    
68.                         (uint16_t)      128,
    
69.                         (void *)        NULL,
    " J1 t6 ]" g) \+ {
70.                         (UBaseType_t)   1,
    : S  t% b7 b, \# W4 L$ L  z
71.                         (TaskHandle_t *)&KeyTask_Handle);
    9 @* k. [3 \- v( U# t6 d! F
72.   if(xReturn == pdPASS)
    9 Q3 a5 V  F7 C' @. S' I
73.         {
    
74.                 f_printf("KeyTask Create PASS.\r\n");
    ; P% q/ y- {" w7 ~8 E
75.     vTaskDelete(AppTask_Handle);
    * t% A1 _- e, s1 H
76.         }
    
77. 
    ; V9 V* K' K; ~$ V! f) m, |: r
78. }
    - R: j5 A( H( u9 p3 |/ d4 y
79. static void KeyTaskCreate(void)
    . W# z# c6 ]& I
80. {
    
81.         while(1)
    
82.         {
    2 ]" Z1 q% s0 z+ c
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    9 x3 n$ e; n: }
84.           {
    ; R4 A9 @; }2 R( }; _7 z1 q  P
85.       vTaskDelay(50);
      c) `! u0 R' U) r9 v
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    5 @: s; X4 Z' v5 l) f. \1 W* ]0 E
87.                   {
    
88.         xTaskNotifyGive(LedTask_Handle);
    
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    / _8 n3 G1 D, Y
90.                   }
    
91.           }
    
92.           vTaskDelay(100);
    7 g1 r6 v2 b' U) o+ ?
93.   }
    
94. }
    ; F/ q9 A! z# r: m7 f/ |% s
95. static void LedTaskCreate(void)
    ; R8 d+ _5 [% K7 j* }  X
96. {
    0 U$ V( o% Q0 Q$ j+ v
97.         uint32_t ulreturn=0;
    . ~! |  U: i5 `) R
98.         while(1)
    
99.         {
    
100.                
     
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     & X! n8 R8 v( T+ }) l6 I
102.                 if(ulreturn==1)
     
103.                 {
     
104.                         /*It won’t be printed out at the same level*/
     % \% Z: ^1 c2 f; e# @! {
105.                   f_printf("LedTask TAKE PASS.\r\n");
     - r) E0 [8 c. e" Q% U
106.             HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     $ s* F7 g. o; M+ h" L& [9 x
107.                         
     
108.                 }
     7 n. V/ \% c) U  X1 ?
109.                 else
     ( }: V, O, L5 }
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     0 a( o0 T1 H# E6 a
111.     vTaskDelay(100);
     ) k8 v8 W& d3 k) O" D; w
112.   }
     ) N( _  w! ?1 _' }
113. }
     " n( C: v! k+ l8 Q8 U9 H2 R
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     
117. 
     
118. /*Turn on task notifications.*/
     # W4 _" D' y* O5 E" U3 E
119. #define configUSE_TASK_NOTIFICATIONS      1
     
120. 在main.c文件里面修改代码
     
121. 
     6 ?9 k! o  w, {& z0 Z" y" M
122. /* USER CODE BEGIN Includes */
     $ |" _( d( W; Z3 Z% ^( c6 k0 A
123. 
     ; o0 O8 d  E7 B3 {, f8 L
124. #include "FreeRTOS.h"
     
125. #include "task.h"
       N3 D" c7 t+ c; F; [8 m
126. #include <stdio.h>
     1 O* d$ K- U0 N; P4 U: l: Y
127. #include <string.h>
     1 k0 J- N1 z+ P3 Q
128. 
     
129. /* USER CODE END Includes */
     
130. 
     
131. /* USER CODE BEGIN PV */
     
132. static TaskHandle_t AppTask_Handle = NULL;
     % g# h) k, v6 P) h  g. h- W
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     
135. 
     8 l9 c; K% ^1 ]* M" k8 ~6 F
136. extern int f_printf(const char *format, ...);
     / S8 I0 n1 p' K1 p) g9 c
137. 
     - I  }- k7 |* y
138. /* USER CODE END PV */
     $ d6 Y: A2 T8 o8 K# m2 |- U
139. 
     
140. /* USER CODE BEGIN PFP */
     + E5 t2 }0 B+ `
141. static void AppTaskCreate(void);
       w+ f0 {) Q; D$ W7 t4 R
142. static void KeyTaskCreate(void);
     
143. static void LedTaskCreate(void);
     ; m  H( y9 W: i8 P, l" Z
144. /* USER CODE END PFP */
     + V1 [: ]: ^3 P' i% g
145. 
     : Y* d/ t/ w& f2 Y- a5 D/ L  G+ _
146. int main()
     
147. {
     - o6 M6 |) S: V+ L  M$ E
148.   /* USER CODE BEGIN WHILE */
     
149.   BaseType_t xReturn = pdFAIL;        
     
150. 
     
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     % }; X& Y- o! a# S% I  M
152.                         (const char *)  "APPTASKCREATE",
     ; J0 }8 z) [) d2 j) P; o' ^
153.                         (uint16_t)      128,
     
154.                         (void *)        NULL,
     . t8 Q# g) z* m, j' I* q( d; Z
155.                         (UBaseType_t)   1,
     6 s4 V9 n- _: t; \, `' u
156.                         (TaskHandle_t*) &AppTask_Handle);
     5 g- n; Z3 A" d$ }8 Q$ ~
157. 
     
158.   if(xReturn == pdPASS)
     8 b9 r% a# e5 s$ L0 `, F' i7 U
159.         {
     
160.     f_printf("AppTask Create PASS.\r\n");
     
161.     vTaskStartScheduler();
     + z; }# p, E% B( L
162.         }
     ; T! W3 A" c5 a; u
163.   while (1)
     6 a7 b( {+ ~6 s3 Y6 y- y
164.   {
     4 I9 Q7 ]: f0 z5 m
165.     /* USER CODE END WHILE */
     
166. 
     / l3 L. ^$ N8 P& i& C
167.     /* USER CODE BEGIN 3 */
     
168.   }
     
169.   /* USER CODE END 3 */
     9 h; E7 d  K- z( i7 ]$ ~
170. }
     
171. 
     0 y$ I7 m. N- f4 C+ ]6 t
172. 
       F- V7 ?. u% K% {
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     
175. {
     
176.         BaseType_t xReturn = pdFAIL;
     
177. 
     / U" Y; ?  j& O5 Z. e3 E3 ]
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     6 C+ `8 \+ e5 G
179.                         (const char *)  "LEDTASKCREATE",
     
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     " T9 \. n# Q% @" w) T
182.                         (UBaseType_t)   1,
     
183.                         (TaskHandle_t *)&LedTask_Handle);
     ( J0 g! b  g' t
184.   if( xReturn == pdPASS)
     
185.           f_printf("LED Task Create PASS.\r\n");
     + K# d( H6 e: r8 u. k5 E' P
186.         
     + [2 M6 o# \4 H# r* g
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     : B) j& `" s2 J: F9 c
188.                         (const char *)  "KEYTASKCREATE",
     
189.                         (uint16_t )     128,
     ( T, A% ?. o* x6 y# P0 I' l( y
190.                         (void *)        NULL,
     
191.                         (UBaseType_t)   2,
       j! [5 c4 t+ T( \
192.                         (TaskHandle_t *)&KeyTask_Handle);
     
193.   if( xReturn == pdPASS)
     3 q0 ~0 [1 p9 ?; B
194.         {
     % Q$ Q% `5 A5 u- A# K
195.     f_printf("KEY Task Create PASS.\r\n");
     
196.     vTaskDelete(AppTask_Handle);
     
197.         }
     ( c8 d, B* k! b$ n9 u) v8 `2 p* k. J' q
198. }
     
199. static void KeyTaskCreate(void)
     
200. {
     
201.   while(1)
     , f: F7 y$ X' W- a1 J
202.         {
     
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     ' s( w9 a7 @: }5 ]+ g8 _
204.                 {
     
205.                         vTaskDelay(40);
     4 J& \* h! @1 B1 E3 E* `' B. t. o
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
207.                         {
     : c, I3 S/ v7 A) \& I
208.                                 xTaskNotifyGive(LedTask_Handle);
     ; x; o1 h2 `0 o# O4 m2 e+ q
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     
210.                         }
     8 Q* U6 H2 Z# R% W
211.                 }
     
212.     vTaskDelay(40);
     & f( X7 g& i( l9 N3 u; S/ x
213.         }
     & }7 c! V4 H% `+ R4 J: S
214.                
     
215. }
     
216. static void LedTaskCreate(void)
     % _" i+ O5 y' v5 c
217. {
     
218.         uint32_t ulValue = 0 ;
     
219.         while(1)
     
220.         {
     7 G! y( l  F- W2 N; |
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
     0 Y0 t: X0 H* ?- `
222.                
     
223.                 /*Greater than 0 proves that there is still a notification value that can be
     7 w: V% a& I7 q8 Q. r8 ^  i
224.          *reduced by 1. Equal to 0 indicates that no notification is available
     % d+ g, C, Q0 N! t5 N) B* I
225.          */
     
226.                 if(ulValue >0)
     
227.                 {
     
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
229.                         f_printf("LED Task PASS.\r\n");
     9 c$ h, M4 X' I) g9 j) A) A* c- B/ I
230.                 }               
     
231.                 vTaskDelay(1500);
     ) a. I4 d6 i. l) u* V4 i
232.         }
     5 u: C& J/ K+ i& G2 V3 p
233. }
     
234. 
     ' u5 q" M( F2 ~( ~. u' Y8 t2 N
235. /* USER CODE END 4 */

复制代码

代替事件组
4 b: Q" @- q2 u9 Y8 _3 f在FreeRTOSConfig.h里开启任务通知
1 j, y0 `/ e+ G( M" S

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

复制代码

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

1. /* USER CODE BEGIN Includes */
   
2. 
   7 d4 m4 o$ K/ r- a0 N. k3 |4 q
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   . d' p- v2 ]/ J0 Q% N% B9 f
5. 
   
6. #include <stdio.h>
   
7. #include <string.h>
   
8. 
   
9. /* USER CODE END Includes */
   * V6 |9 A6 w& }/ \/ l
10. 
    - X5 N" H0 J) `
11. /* USER CODE BEGIN PV */
    : m8 g. a. v. C1 e( ^
12. static TaskHandle_t AppTask_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    & g( \9 E8 n" U- H
14. static TaskHandle_t LedTask_Handle = NULL;
    
15. 
    & e& _7 B" d$ }( j% m4 W. _/ N* x
16. extern int f_printf(const char *format, ...);
    6 @' @0 b9 i7 Q' r0 n
17. /* USER CODE END PV */
    
18. 
    
19. /* USER CODE BEGIN PFP */
    
20. 
    
21. static void AppTaskCreate(void);
    % }6 q% A) g" i
22. static void KeyTaskCreate(void);
    
23. static void LedTaskCreate(void);
    
24. 
    
25. /* USER CODE END PFP */
    
26. 
    
27. int main()
    9 d- S- L6 n" [$ n# Y6 R* P
28. {
    
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    - x% I1 e* y. L
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
33.                             (const char *)  "",
    2 `$ s+ f1 @! W9 ]% J
34.                                                 (uint16_t)      128,
    2 h: i% Y1 z8 E: q
35.                                                 (void *)        NULL,
    ! p$ z$ {* o3 ~1 N* l7 Y. v  b
36.                                                 (UBaseType_t)  1,
    8 }* O  V0 @3 _2 q+ @5 p; Y
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    
38.         if( xReturn == pdPASS)
    , W* S( U7 F; H! i- B8 F# c( }
39.         {
    # h/ q( s- ^8 g( {
40.                 f_printf("APP Task Start.\r\n");
    
41.                 vTaskStartScheduler();
    
42.         }
    2 r( U4 \& d& j3 `$ x$ d1 x. k5 L" T
43. 
    4 z3 b$ ]) G" j/ z9 B0 J, \
44.   while (1)
    % ]0 y9 O. y( j0 q* a
45.   {
    5 n# b9 ?9 L% f- X/ P3 {
46.     /* USER CODE END WHILE */
    ) q1 J2 @: ~% Q: c" @3 n0 K
47. 
    & n$ E% @0 @% `: L+ O8 u
48.     /* USER CODE BEGIN 3 */
    2 L  O4 R$ U6 c& I
49.   }
    
50.   /* USER CODE END 3 */
    9 y0 X# s/ L8 M0 u* n
51. }
    
52. 
    
53. /* USER CODE BEGIN 4 */
    : m% A6 V$ Y# s: I" E, _  A1 x
54. static void AppTaskCreate(void)
    
55. {
    1 C8 B  f" H& O
56.         BaseType_t xReturn = pdFAIL;
    
57.         
    
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
59.                               (const char *)  "",
    ' `5 `* R6 ]1 D. n
60.                                                                                                 (uint16_t)      128,
    
61.                                                                                                 (void *)        NULL,
    
62.                                                                                                 (UBaseType_t)   1,
    / ^  C# X% Y: |3 H
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    & q& X* {# S+ @8 O3 ?% `* m
64.   if( xReturn == pdPASS)
    + H6 h/ Z/ e5 D; k0 _3 b% D  o0 T
65.                 f_printf("LED TASK PASS.\r\n");
    . b/ \: N# p" e6 u  S4 }
66.         
    . j$ I: m. n5 _$ _! N
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    - ]0 Y6 h& l, G/ y/ w0 d# D5 I& |
68.                               (const char *)   "",
    
69.                                                                                                 (uint16_t )      128,
    ) l- x! Z0 N4 S* `+ W; w! F4 P
70.                                                                                                 (void *)         NULL,
    
71.                                                                                                 (UBaseType_t)   2,
    9 r+ \: o8 ?; V! d: D) N* \
72.                                                                                                 (TaskHandle_t *) &KeyTask_Handle);
    ! X' M: D! a! [& s
73.   if( xReturn == pdPASS)
    
74.         {
      Z& E, y1 q4 ~$ C* i2 P
75.     f_printf("KEY TASK PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    4 Y' Y  T; K. a6 l
77.         }                                                                                
    
78. }
    3 J% r: B; [0 K6 S2 j7 w- X# b: f7 x% Z
79. static void KeyTaskCreate(void)
    : r$ h' Y+ l5 u4 u0 g1 q
80. {
    
81.   while(1)
    
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    - z; c: e& \) }0 i4 J  g" |: u
84.                 {
    
85.                         vTaskDelay(40);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    
89.                                 f_printf("PA0.\r\n");
    
90.                         }
    7 @$ p* \' m+ ]& s
91.                 }
    2 X8 q( U/ f% j7 x- k
92.                 else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    . k! N" B) t1 j
93.                 {
    # T. p' {8 H# g
94.                         vTaskDelay(40);
    
95.                         if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    
96.                         {
    
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    
98.                                 f_printf("PC12.\r\n");
    
99.                         }
    * X6 e  L( q, w- r+ ^
100.                 }
     + _% S+ B3 V6 r9 u
101.                
     + r9 n9 T" o7 @3 Q2 ?
102.                 vTaskDelay(50);
     0 x; d; P9 p+ m  C
103.         }
     
104. }
     
105. static void LedTaskCreate(void)
     0 @4 I& Q) A. C0 T8 ]$ y, V
106. {
     
107.         uint32_t ulReturn = 0;
     # S" J7 s, S, c. p" d
108.         BaseType_t xReturn = pdFAIL;
     
109.         while(1)
     
110.         {
     
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     $ Y1 F+ D4 g* }8 i4 q0 G% I
112.                
     
113.                 if(xReturn == pdTRUE)
     0 l! _, B( c- H6 G; P, G5 t
114.                 {
     
115.                         if( (ulReturn & 0x1)==1)
     
116.                         {
     
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
118.                                 f_printf("LED1.\r\n");
     2 t; Q; l1 {- J4 P9 |% K$ |
119.                         }
     
120.                         else if( (ulReturn & 0x02)==2)
     
121.                         {
     % z, {6 Z: F1 h+ I7 M4 r: U, o$ c
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     - |, u6 e2 P" I- j
123.                                 f_printf("LED2.\r\n");
     6 c6 C+ W; _! A3 ]7 ?- w
124.                         }
     
125.                 }
     . L( f9 D1 o7 }4 L$ J( \7 |; e
126.                 else
     
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     
129.                 vTaskDelay(1500);
     0 S8 t; H; u3 W8 {, `
130.         }
     , k* s% N" Z. H4 a0 l5 E- V6 z6 d
131. }
     
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
8 A& ?' ^, z6 O* z/ M3 f在FreeRTOSConfig.h里开启任务通知

1. /*Turn on task notifications.*/
   : U7 R- J, B; Z& i" t; f1 ^
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

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

4 G# ~" C8 F1 e

1. /* USER CODE BEGIN Includes */
   
2. 
   : ], B; S( v5 _. b# W& N: N
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   , b  J/ }" n" @
5. #include <stdio.h>
   
6. #include <string.h>
   2 X/ X3 C- _( A+ `; M
7. 
   3 b/ {8 t* r. d  a8 {, {! `: }
8. /* USER CODE END Includes */
   # A7 t1 v8 X7 ^; [/ X' ~
9. 
   ' O) @. e4 P/ \7 _
10. /* USER CODE BEGIN PV */
    $ p9 n8 p6 E* L$ x( B0 M% T* u/ c
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t QueueTask_Handle = NULL;
    5 B) v; U1 a& C; x
14. static uint32_t Message = 0;
    
15. static uint32_t *printf_value=&Message;
    
16. extern int f_printf(const char *format, ...);
    # f4 l4 u+ }' m
17. 
    
18. /* USER CODE END PV */
    # L" C# j& O$ K; u/ ~: ?# b
19. 
    + J! x; r* ]* U" J1 F
20. /* USER CODE BEGIN PFP */
    $ K; l  `. L9 i# K
21. static void AppTaskCreate(void);
    
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 */
    3 n$ i; K2 k1 d  ~
29.   BaseType_t xReturn = pdFAIL;
    
30.         
    
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    
32.                               (const char *)   "",
    5 P: M) q: A' p( x& k' X) O8 V
33.                                                   (uint16_t)       128,
    
34.                                                   (void *)         NULL,
    / [+ G7 L4 a& j$ |+ w/ _/ N, l
35.                                                   (UBaseType_t)    1,
    
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    7 ?  r4 Q3 [3 N) B8 K
37.                                                                                                 
    
38.   if( xReturn == pdPASS)
    
39.         {
    
40.     f_printf("AppTask Start.\r\n");
    3 v* B/ b2 G7 N& P5 R" A5 ?
41.                 vTaskStartScheduler();
    - r! u+ }3 u) E
42.         }
    ; z/ D: q0 i3 f( ^, [
43.         
    
44.   while (1)
    
45.   {
    1 M( E& c- a; e2 C4 ]0 z$ m- j/ X
46.     /* USER CODE END WHILE */
    0 i6 a& g' ~7 i, h: D4 X
47. 
    
48.     /* USER CODE BEGIN 3 */
    
49.   }
    
50.   /* USER CODE END 3 */
    
51. }
    6 m( s3 Y9 q- Y/ a
52. 
    0 Y6 F1 l) q4 a
53. /* USER CODE BEGIN 4 */
    3 o/ D0 U# ^2 ~" \0 N
54. static void AppTaskCreate(void)
    
55. {
    , ?4 V* T$ v: C' V- \+ B" u
56.         BaseType_t xReturn ;
    
57.         
    ( K1 a; r2 b7 D- ^  M1 T* H* T
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    5 n4 x: L4 J7 a" i- ?9 ^# c/ h
59.                          (const char *)  "",
    
60.                                                                                                  (uint16_t)      128,
    9 M8 m7 x. \7 P. F9 x' E
61.                                                                                                  (void *)        NULL,
    
62.                                                                                                  (UBaseType_t)   2,
    
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    + Z! V& S! d; m# {- o; r
64.   if( xReturn ==pdPASS )
    , f. V( h0 _2 I1 c4 W1 V3 g. l- f
65.                 f_printf("QueueTask Create PASS.\r\n");
    
66.         
    
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    7 x: ?4 e# p8 }0 X+ [) k5 @) b
69.                          (uint16_t)      128,
    8 m7 Q2 k( c3 l; T& v
70.                                                                                                  (void *)        NULL,
    6 R. i- Z: s1 ?
71.                                                                                                  (UBaseType_t)   1,
    # C' K9 I$ E' _+ M1 |" C
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    
73.   if (xReturn == pdPASS)
      C4 N/ R4 r$ Z4 _- P/ k0 H
74.         {
    : p( ~6 c  R8 b1 W+ i" y+ O
75.           f_printf("KeyTask Create PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    ! T- ?, g( `5 y3 X2 k
77.         }
    
78. }
    9 ]7 f+ R. l* {3 X6 F* B
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    ' @9 Y% v! a1 m9 c
82.         {
    
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    / t) l2 D  f2 `8 T
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    % N4 I; X" _8 i# e# o5 F: C4 B
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    + m: c# s5 b6 o
89.                         }
    2 F$ ^: K' v& K6 Y* A( ]8 D' V
90.                 }
    
91.                 vTaskDelay(80);
    
92.         }
    
93. }
    
94. static void QueueTaskCreate(void)
    * n  c3 e/ L3 `6 k0 o* A& I* U
95. {
    
96.         while(1)
    ; @6 ~! a& R7 o
97.         {
    4 f" T) V4 b# _9 p3 |7 ]! j
98.                 /*work.*/
    
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    3 s: [! ~+ v7 n( {3 }8 O7 ^# N
100.                 f_printf("Message is :%d\r\n",*printf_value);
     
101.                 Message=*printf_value;
     , O4 W% O+ r5 y2 ^
102.                
     0 @: J$ H" R0 {% j) k% v! r
103.                 /*The second method works too*/
     
104.         /*
     
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     7 U  ]! m* E: @' A6 N+ [. `
106.                 f_printf("Message is :%d\r\n",Message);
     9 c7 \1 ]5 ^, j) b8 g
107.         */
     * K+ Y5 k& ^$ S  G& u- T- I7 n
108.                 Message++;
     
109.                 if(Message > 10)
     
110.                         Message = 0;
     , u. ?9 j+ }& o8 C" _% L+ P
111.                 vTaskDelay(1000);
     8 q* ^. p* ^4 B. _( m( o
112.         }
     
113. }
     
114. /* USER CODE END 4 */

复制代码

5 i' T2 z) S* F# w
' O2 d2 W+ G3 B' V( T