概述
& e- E& n6 `- r        每个任务都有一个32位的通知值，可以替代二值信号量，计数信号量，事件组，也可以代替长度为1的队列。
4 |6 ?+ K3 w/ S# v+ ]/ ?* g4 g8 N
2 }. ]. i9 p6 V        有以下几种方式发送通知给任务：

1.有通知未读，则不覆盖通知值

2.直接覆盖通知值
/ x& y$ ^4 S2 [
3.设置通知值一个或者多个位，当做事件组来使用

6 h: m1 }( a# ]: P4.递增/递减通知，当做信号量来使用

5 j7 }0 W' k+ A5 K& e' E4 Q" P        有以下缺点：

1.只能有一个任务接收通知消息
% Z! b; r8 t0 Q
9 Q2 f7 Y9 N* i7 _4 Z* k5 S2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。

代替二值信号量
7 v" U; J+ l+ k2 l在FreeRTOSConfig.h里开启任务通知

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

复制代码

在main.c文件里面修改代码
$ z6 w, g0 x) Q% Z8 f4 K
6 G+ n( n( H8 K5 ?7 G

1. /* USER CODE BEGIN Includes */
   # f/ p* s3 P) E, _$ T! z
2. 
   
3. #include "FreeRTOS.h"
   6 F7 q$ p' H9 o& G/ z: Q
4. #include "task.h"
   
5. #include <stdio.h>
   
6. #include <string.h>
   
7. 
   . ?3 X4 t* X$ u2 E" y* x
8. /* USER CODE END Includes */
   
9. 
   8 V- r, a" x) L7 Q$ }$ ?5 j6 L3 m4 `
10. /* USER CODE BEGIN PV */
    , s4 S6 j6 l* w0 O4 ^
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    , e' \/ E2 G/ @: S" I
14. 
    ' C, k9 @* I1 i
15. extern int f_printf(const char *format, ...);
    ) y8 P3 d$ W/ ~9 f8 ^8 |$ v' E! ~
16. /* USER CODE END PV */
    9 w% [, U4 V( m. ]
17. 
    
18. /* USER CODE BEGIN PFP */
    # B% k/ D- `' g# O+ S6 P
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    2 q2 R, B5 w# E, y, o+ a
22. /* USER CODE END PFP */
    1 \4 F# D8 `$ L' e$ m2 Z7 j
23. 
    
24. int main()
    
25. {
    + v3 |4 y5 V0 I6 p$ ~3 r" D- d% e7 X
26. 
    ! t8 ^; S$ m; u$ }! }  N
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    " {+ c  T% }" d+ O$ U" w
29.         
      B1 p7 k/ Y5 \  B; j% W
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    # {, r" L- A1 k! }: a& F" C; p' O
31.                         (const char*)   "APPTASKCREATE",
    9 U2 u& D# S. v- |: W
32.                         (uint16_t)      128,
    
33.                         (void *)        NULL,
      Q% Y9 Z; K& p) x% H/ M6 O
34.                         (UBaseType_t)   1 ,
    
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    % }3 }, r, [2 u4 \1 M& S
37.   if(xReturn == pdPASS)
    
38.         {
    
39.     f_printf("AppTask Create PASS.\r\n");
    ; `8 v! ~9 e( @0 M) p  L
40.                 vTaskStartScheduler();
    
41.         }
    ( v: Q$ ^" f4 Q/ u% m% A8 K" M
42.                                                                                                 
    ; y) o: ~9 T! h  l' g' v5 N/ L
43.   while (1)
    ' ]9 D7 q3 K0 n( b
44.   {
    + h3 h) O! Q# N; x: Q# N
45.     /* USER CODE END WHILE */
    
46.     /* USER CODE BEGIN 3 */
    9 m( w7 p$ M, D( ?; W5 q/ m8 Q3 f
47.   }
    
48.   /* USER CODE END 3 */
    ' o3 B# O4 T0 Y# p8 P9 U
49. }
    
50. 
    
51. /* USER CODE BEGIN 4 */
    
52. static void AppTaskCreate(void)
    / S: j5 k' P( p, c, p) O
53. {
    / K& x) O( |( d4 @! Y5 @
54.   BaseType_t xReturn = pdFAIL;
    
55. 
      B7 [' O* y1 L! F8 j2 G; O& N
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
57.                         (const char *)  "LEDTASKCREATE",
    
58.                         (uint16_t)      128,
    , ?3 O3 E% m4 |* k( [5 A. F% H- Z
59.                         (void *)        NULL,
    3 g! U0 g3 m+ \& x
60.   /*If the priority here is the same as the key task, printf will not print it out.        */
    
61.                         (UBaseType_t)   2,      
    & Q( G! p! M+ X! P9 F# w7 C! w/ B
62.                         (TaskHandle_t *)&LedTask_Handle);
    1 b1 w9 d0 H/ O: \8 {, n
63.   if(xReturn == pdPASS)
    
64.                 f_printf("LedTask Create PASS.\r\n");
    , A% ~( O( k8 R( e' E, h4 O
65.         
    
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
67.                         (const char *)  "KEYTASKCREATE",
    
68.                         (uint16_t)      128,
    
69.                         (void *)        NULL,
    
70.                         (UBaseType_t)   1,
    ; J6 H: M- K% D! J! @
71.                         (TaskHandle_t *)&KeyTask_Handle);
    
72.   if(xReturn == pdPASS)
    
73.         {
    : ^$ [4 G- ~! O/ U0 @6 T, V; o0 V6 Y
74.                 f_printf("KeyTask Create PASS.\r\n");
    
75.     vTaskDelete(AppTask_Handle);
    
76.         }
    
77. 
    
78. }
    * |$ T: X8 }8 Q( O6 K6 y7 A
79. static void KeyTaskCreate(void)
    
80. {
    - Q. Q% T$ \% S. ^$ H6 s8 g. V
81.         while(1)
    
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    % Y# R5 M9 v, p$ ]& \
84.           {
    , ~. R6 X+ T! T0 e: b
85.       vTaskDelay(50);
    
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    1 a+ B* j; X, ~+ R' g2 P
87.                   {
    
88.         xTaskNotifyGive(LedTask_Handle);
    
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    
90.                   }
    . \! Y; i2 I+ z
91.           }
    
92.           vTaskDelay(100);
    
93.   }
    
94. }
    ) O$ e* u4 e) |, @8 o
95. static void LedTaskCreate(void)
    - y1 x7 M1 u7 g, T' x: X
96. {
    ! n7 Y* [  N% s. G- m, K/ G# O
97.         uint32_t ulreturn=0;
    
98.         while(1)
    $ {" b+ \, Q5 F" A
99.         {
    
100.                
     7 K2 P- L$ T! z0 D& [
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     
102.                 if(ulreturn==1)
     
103.                 {
     2 m& `2 t! W7 t9 `+ X2 e
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);
     1 J. @* c) m. P
107.                         
     
108.                 }
     
109.                 else
     6 D3 |# q0 c& H
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     
111.     vTaskDelay(100);
     " W( O9 c  A: m
112.   }
     9 u  P0 v2 D% r$ V" x# D: u' ^
113. }
     ( f; m1 Q' `$ J
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     4 K  M; ~% }0 ~3 `. G9 D, _) ]
116. 在FreeRTOSConfig.h里开启任务通知
     
117. 
     : \' ^+ ?1 T5 f+ Y; _' ?4 u
118. /*Turn on task notifications.*/
     : [& B. g. O3 k8 K* L  a
119. #define configUSE_TASK_NOTIFICATIONS      1
     ' Z' v9 r; T6 W
120. 在main.c文件里面修改代码
     5 Q& f! b( T! G( S
121. 
     
122. /* USER CODE BEGIN Includes */
     
123. 
     
124. #include "FreeRTOS.h"
     $ T7 {8 {6 N% ?3 v3 _
125. #include "task.h"
     4 @% E8 X& q+ D
126. #include <stdio.h>
     / K- p' @. E; n
127. #include <string.h>
       A/ H: t3 r8 d. D
128. 
     " B1 Q# l  I- e; D/ N5 N
129. /* USER CODE END Includes */
     , H7 R  L* z% u2 S1 j; ~6 x& U' m5 r
130. 
     * \6 A5 Q. [  ?8 @( K' j% ?
131. /* USER CODE BEGIN PV */
     
132. static TaskHandle_t AppTask_Handle = NULL;
     1 T/ t, h& f4 t
133. static TaskHandle_t KeyTask_Handle = NULL;
     + R1 m: z" M! _% [3 G  N! U9 y! t
134. static TaskHandle_t LedTask_Handle = NULL;
     
135. 
     
136. extern int f_printf(const char *format, ...);
     5 U- ~  |' I+ O1 M
137. 
     
138. /* USER CODE END PV */
     
139. 
     , P( D3 w  @3 n4 G
140. /* USER CODE BEGIN PFP */
     
141. static void AppTaskCreate(void);
     " O# C7 a& L' I
142. static void KeyTaskCreate(void);
     
143. static void LedTaskCreate(void);
     
144. /* USER CODE END PFP */
     
145. 
     
146. int main()
     
147. {
     6 i5 M2 s1 s: Y3 y0 }/ A3 O" z/ i/ M
148.   /* USER CODE BEGIN WHILE */
     7 R$ S3 z8 c% B' i( I
149.   BaseType_t xReturn = pdFAIL;        
     
150. 
     2 K+ u* I" a, G, l
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     - t- v0 i3 r+ ~& O* t9 L
152.                         (const char *)  "APPTASKCREATE",
     1 u( M! i- o1 `5 E
153.                         (uint16_t)      128,
     7 b; w) C' K/ o$ ?
154.                         (void *)        NULL,
     % U, X  g/ {2 J' p$ [
155.                         (UBaseType_t)   1,
     
156.                         (TaskHandle_t*) &AppTask_Handle);
     3 }5 }" Q2 B# w9 Q7 d
157. 
     3 B$ i- ?" V5 _& F3 O
158.   if(xReturn == pdPASS)
     
159.         {
     * X' D7 ?$ z- c
160.     f_printf("AppTask Create PASS.\r\n");
     
161.     vTaskStartScheduler();
     4 G' ]) J  @) J8 t/ {
162.         }
     2 G( Q  ?8 V% B  g2 R9 l- I) R, q
163.   while (1)
     
164.   {
     
165.     /* USER CODE END WHILE */
     & H& k  x9 Q+ q9 \+ F+ Y9 Y
166. 
     2 W7 ~2 u4 G1 y4 X, t. K; ]
167.     /* USER CODE BEGIN 3 */
     : c5 z1 l; P( g; r& \8 L
168.   }
     
169.   /* USER CODE END 3 */
     
170. }
     
171. 
     
172. 
     
173. /* USER CODE BEGIN 4 */
     . j  t# O  w* ^. P$ d
174. static void AppTaskCreate(void)
     4 m$ }8 \! h' W9 ^7 Y
175. {
     
176.         BaseType_t xReturn = pdFAIL;
     % |4 x; i7 b4 t9 b' r/ d2 N* R. Y
177. 
     / u6 |$ a$ y& D0 k1 O$ k
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     5 g* p  s1 s5 a. L, v
179.                         (const char *)  "LEDTASKCREATE",
       ~0 X" U# F4 x9 W$ ^' B+ Z
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     
182.                         (UBaseType_t)   1,
     1 }$ b. g1 @- B9 j  ]' f
183.                         (TaskHandle_t *)&LedTask_Handle);
     
184.   if( xReturn == pdPASS)
     
185.           f_printf("LED Task Create PASS.\r\n");
     2 ]- v+ s. P0 e7 f  T, A( h
186.         
     
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     
188.                         (const char *)  "KEYTASKCREATE",
     " L- w5 \. E8 Q* }2 `* e  p
189.                         (uint16_t )     128,
     
190.                         (void *)        NULL,
     9 v0 I# z) O7 V- U
191.                         (UBaseType_t)   2,
     
192.                         (TaskHandle_t *)&KeyTask_Handle);
     
193.   if( xReturn == pdPASS)
     3 {3 N. ?& d5 G6 B" ^9 K
194.         {
     
195.     f_printf("KEY Task Create PASS.\r\n");
     
196.     vTaskDelete(AppTask_Handle);
     
197.         }
     
198. }
     + A9 B/ F6 p8 N% P1 t3 O$ `
199. static void KeyTaskCreate(void)
     / q" y# i1 _  A: A0 Y1 M4 O
200. {
     
201.   while(1)
     
202.         {
     
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
204.                 {
     
205.                         vTaskDelay(40);
     
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
       {5 l$ [9 Z9 O3 B- ?0 N! V! z/ U
207.                         {
     
208.                                 xTaskNotifyGive(LedTask_Handle);
     / C6 u( s8 p. ~
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     ! S/ m: x4 H4 n3 X
210.                         }
     
211.                 }
     
212.     vTaskDelay(40);
     
213.         }
     
214.                
     7 p/ D4 f; e" o1 `
215. }
     2 J' x3 C1 C$ L6 q- l; ^, N% Z
216. static void LedTaskCreate(void)
     $ L* i7 b0 n* e
217. {
     ' i+ e/ |6 Z" v& d6 @
218.         uint32_t ulValue = 0 ;
     
219.         while(1)
     8 s2 D# O% O- _* U; [
220.         {
     
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
     
222.                
     
223.                 /*Greater than 0 proves that there is still a notification value that can be
     
224.          *reduced by 1. Equal to 0 indicates that no notification is available
     * T2 y5 F( @8 s
225.          */
     2 f( h$ L. t$ ~; Q
226.                 if(ulValue >0)
     
227.                 {
     
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     . T# P/ `" }3 G" n; G
229.                         f_printf("LED Task PASS.\r\n");
     ' ]! E6 P3 p! V, Z$ c
230.                 }               
     
231.                 vTaskDelay(1500);
     1 E5 [7 L0 n% X; I
232.         }
     $ u3 Q7 x( l: h0 E- p9 |* r( `
233. }
     8 i& Y0 Q  G4 L+ n/ B  b! {5 x
234. 
     
235. /* USER CODE END 4 */

复制代码

代替事件组
在FreeRTOSConfig.h里开启任务通知

1. /*Turn on task notifications.*/
   & l: W8 f3 \( ^/ n- U# a
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

* t& ~7 U! I/ C1 v5 O# p! d9 x' k/ I在main.c文件里面修改代码

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   6 t, W& Y. Y; L/ {7 C; D
4. #include "task.h"
   + n9 ~7 Y, V5 U" k& Y
5. 
   
6. #include <stdio.h>
   
7. #include <string.h>
   
8. 
   
9. /* USER CODE END Includes */
   2 o8 o# w, |+ @5 T
10. 
    
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTask_Handle = NULL;
    5 e1 ~% D+ Y' B* _
13. static TaskHandle_t KeyTask_Handle = NULL;
    % I0 X5 X& w8 f4 ]; f  d
14. static TaskHandle_t LedTask_Handle = NULL;
    , S/ o7 ?/ D& W$ i( @
15. 
    * t. A5 R* C# @4 b5 B- x: }
16. extern int f_printf(const char *format, ...);
    % s! N( H9 l, N
17. /* USER CODE END PV */
    7 B7 d  m/ E. J* }
18. 
    
19. /* USER CODE BEGIN PFP */
    6 w- ^$ R" @1 X. c- }+ W
20. 
    
21. static void AppTaskCreate(void);
    6 b3 t" \3 X2 I5 [
22. static void KeyTaskCreate(void);
    9 M& b$ V% i6 p2 {  y
23. static void LedTaskCreate(void);
    ! ~  [$ k& R- K& a( X! e, c* y6 H
24. 
    4 g. N# }8 n' {5 a1 |6 M+ c
25. /* USER CODE END PFP */
    
26. 
    " S& D. G, ?; f
27. int main()
    
28. {
    
29.   /* USER CODE BEGIN WHILE */
    ; l, L0 M# w/ f1 B
30.   BaseType_t xReturn = pdFAIL;
    9 J/ |. B1 Z) |; C1 w
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    0 Y7 `9 R; l1 S$ z) e- \4 P
33.                             (const char *)  "",
    
34.                                                 (uint16_t)      128,
    
35.                                                 (void *)        NULL,
    ) o% v; I# X4 l* v
36.                                                 (UBaseType_t)  1,
    0 S5 [9 _0 G' O$ u% p& e
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    7 J9 J7 v# `7 q) R0 G7 j4 u
38.         if( xReturn == pdPASS)
    # L/ P9 v% S- v. k. R/ y4 ?
39.         {
    : J! d3 _/ x0 B& Y5 H
40.                 f_printf("APP Task Start.\r\n");
    
41.                 vTaskStartScheduler();
    
42.         }
    8 G( L; B- c: G; l; W1 b
43. 
    
44.   while (1)
    
45.   {
    
46.     /* USER CODE END WHILE */
    6 ~3 [* }1 T' o( p0 [. Y+ u
47. 
    
48.     /* USER CODE BEGIN 3 */
    % E  q( u& b$ W. H4 @% x- F, ^
49.   }
    
50.   /* USER CODE END 3 */
    
51. }
    ( ?- e4 ]+ e% w$ }. f9 W5 P, R$ p) a
52. 
    
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    
55. {
    8 @0 S* y4 \  S$ r
56.         BaseType_t xReturn = pdFAIL;
    3 L6 q. X: k: Q* @: O2 N- \
57.         
    6 z) n" n. I2 c' O2 L0 P$ {; R- `
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
59.                               (const char *)  "",
    
60.                                                                                                 (uint16_t)      128,
    
61.                                                                                                 (void *)        NULL,
    
62.                                                                                                 (UBaseType_t)   1,
    
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    
64.   if( xReturn == pdPASS)
    
65.                 f_printf("LED TASK PASS.\r\n");
    
66.         
    
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
68.                               (const char *)   "",
    
69.                                                                                                 (uint16_t )      128,
    
70.                                                                                                 (void *)         NULL,
    3 v3 g( j* `7 V& t1 Q# n
71.                                                                                                 (UBaseType_t)   2,
    
72.                                                                                                 (TaskHandle_t *) &KeyTask_Handle);
    
73.   if( xReturn == pdPASS)
    
74.         {
    , w6 D) \, X/ m& b. S* O( n2 c6 t0 A
75.     f_printf("KEY TASK PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    ; @" P; Q7 s, V$ p! @
77.         }                                                                                
    5 Z* G" q; S4 G. _  j; x0 `
78. }
    
79. static void KeyTaskCreate(void)
    % p! X7 U$ N( r
80. {
    8 i% F1 k, V& M4 v* U
81.   while(1)
    
82.         {
    % ^0 h$ j4 N' Q" v  |& Z3 j4 o1 H" ^
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(40);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    ( [3 `2 x) T! i. a  [' ^3 r% R3 Y6 ]
87.                         {
    
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    
89.                                 f_printf("PA0.\r\n");
    - }( a1 n0 R. @# V% ^( C  y2 ?
90.                         }
    
91.                 }
    
92.                 else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    : M6 E  v% o* Y* j6 y# {. k
93.                 {
    2 D8 v& O6 U' X% b- w' o3 N
94.                         vTaskDelay(40);
    0 r" q, P- s4 E; ^  _$ v
95.                         if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    + u4 l2 x7 o/ @4 H
96.                         {
    
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    
98.                                 f_printf("PC12.\r\n");
    9 W3 o, K6 a1 n% A+ W4 w# j
99.                         }
    
100.                 }
     ! Q9 u7 Y" N/ t
101.                
     
102.                 vTaskDelay(50);
     ' a0 T6 T. m# i0 z6 p; H
103.         }
     
104. }
     ( c7 K; n9 W+ ]& [3 w8 k
105. static void LedTaskCreate(void)
     
106. {
     1 V  C: P3 G) k0 o% p. y
107.         uint32_t ulReturn = 0;
     
108.         BaseType_t xReturn = pdFAIL;
     
109.         while(1)
     
110.         {
     ( v5 I7 _8 d" g) h6 Y
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     
112.                
     
113.                 if(xReturn == pdTRUE)
     
114.                 {
     
115.                         if( (ulReturn & 0x1)==1)
     
116.                         {
     
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
118.                                 f_printf("LED1.\r\n");
     % d& M$ S5 E& `3 [; t/ T, @1 U
119.                         }
     8 L) p" P2 W3 |: U: g" k6 [
120.                         else if( (ulReturn & 0x02)==2)
     / Q0 Q3 @: p1 t# v2 ^1 O
121.                         {
     # t9 Y% d5 O' }, G$ x; Y4 m& J- M
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     
124.                         }
     
125.                 }
     - y0 \0 U8 E- r/ O2 m1 e& B8 _
126.                 else
     7 p5 u. e4 p" u! W' M, q' f6 p# o! F
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     
129.                 vTaskDelay(1500);
     
130.         }
     . ^8 b" L' b3 x: [4 j% T& L- O
131. }
     
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
0 B5 M2 V. L; Y! t3 K. k在FreeRTOSConfig.h里开启任务通知

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

复制代码

$ p8 S- x9 o. Z6 z( @; {  K在main.c文件里面修改代码
& o' I+ t$ N7 C
7 p/ q- w, g/ T4 f9 D5 b

1. /* USER CODE BEGIN Includes */
   
2. 
   . `! n# d/ o, f# N1 ?& A9 N
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   - H- Z8 `! E+ E- A# ^% Y
5. #include <stdio.h>
   3 ~" o% `2 c! d) P
6. #include <string.h>
   , D3 e) G% i& B4 k6 m
7. 
   
8. /* USER CODE END Includes */
   6 x. f/ D' M, [$ O& X7 H1 q
9. 
   
10. /* USER CODE BEGIN PV */
    
11. static TaskHandle_t AppTask_Handle = NULL;
    % ^3 r5 D! c1 Q0 }7 o$ }
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t QueueTask_Handle = NULL;
    
14. static uint32_t Message = 0;
    
15. static uint32_t *printf_value=&Message;
    . M! ^1 I. P7 V3 E3 A) q7 |
16. extern int f_printf(const char *format, ...);
    
17. 
      H: N' x2 E) q! s/ ~1 D4 h! Y
18. /* USER CODE END PV */
    2 k1 D3 S$ Z- G
19. 
    
20. /* USER CODE BEGIN PFP */
    
21. static void AppTaskCreate(void);
    1 Y! U  m+ W) ^" }) ]
22. static void KeyTaskCreate(void);
    
23. static void QueueTaskCreate(void);
    5 f" U: L: o5 F; [! k5 b
24. /* USER CODE END PFP */
    
25. 
    
26. int main()
    
27. {
    
28.   /* USER CODE BEGIN WHILE */
    ! ]) F# c/ i* s/ h' R
29.   BaseType_t xReturn = pdFAIL;
    . K2 M) ^- M' ~8 I7 c
30.         
    
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    
32.                               (const char *)   "",
    
33.                                                   (uint16_t)       128,
    5 a  \% e* {- \# d0 u: O7 X' H
34.                                                   (void *)         NULL,
    # p. ~! A7 |; N7 n% C
35.                                                   (UBaseType_t)    1,
    
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    
37.                                                                                                 
    , t5 O$ A9 c# T
38.   if( xReturn == pdPASS)
    8 M2 F: L  {4 q& C! C8 J
39.         {
    
40.     f_printf("AppTask Start.\r\n");
    7 B3 c6 w( t# Y! U
41.                 vTaskStartScheduler();
    2 ^( r, H' Z8 T1 @6 |& O) u
42.         }
    8 a0 z( J) k" L& f% m4 i/ M" I' ^
43.         
    $ b* c1 v& X1 n1 I, s4 |( T" f  Q9 I
44.   while (1)
    
45.   {
    ! ~- |: C; O+ H) I/ B: D- a
46.     /* USER CODE END WHILE */
    
47. 
    
48.     /* USER CODE BEGIN 3 */
    
49.   }
    8 Q6 N+ e- k) q( m- u  f. H
50.   /* USER CODE END 3 */
    
51. }
    9 T- u+ Z; Z( c; C
52. 
    & X* @5 U" {# v* ?, T
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    " E4 y6 B9 P' ]
55. {
    ' [$ @; w& W7 w3 _0 I# j1 S' @
56.         BaseType_t xReturn ;
    2 X2 r8 e* U; [4 V# V! X
57.         
    
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    0 m* D( T8 F* v7 H! R! B
59.                          (const char *)  "",
    9 i2 E0 p" W% z/ u" K
60.                                                                                                  (uint16_t)      128,
    2 W% i: @2 g0 q) p- L  B( V* D
61.                                                                                                  (void *)        NULL,
    2 u8 R- c' K9 ]1 M0 _% D
62.                                                                                                  (UBaseType_t)   2,
    
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    7 H  s1 N7 ]: z' u
64.   if( xReturn ==pdPASS )
    
65.                 f_printf("QueueTask Create PASS.\r\n");
    / f% D" ?" X5 D8 Q  T0 ]
66.         
    
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    % Q! t" q* u# u# y
69.                          (uint16_t)      128,
    - y; E- |6 i8 x3 l: c5 t; F
70.                                                                                                  (void *)        NULL,
      V! M0 y9 J! @9 B  o! g1 H# U+ R, S
71.                                                                                                  (UBaseType_t)   1,
    ( f! @2 k3 G8 B# {
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    
73.   if (xReturn == pdPASS)
    2 M. L& q$ r* l
74.         {
    
75.           f_printf("KeyTask Create PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    
77.         }
    
78. }
    
79. static void KeyTaskCreate(void)
    7 l& L1 X3 C( Q! O( f4 D3 Y
80. {
    
81.         while(1)
    . K$ ^, x. C8 ?7 k% e/ I
82.         {
    
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    : o5 j; G! O- O: I' Z
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    ' b6 Q4 o8 O$ I3 B1 w) g6 Y
87.                         {
    8 X; w, c" j6 _. C5 L
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    
89.                         }
    
90.                 }
    
91.                 vTaskDelay(80);
    7 B# R8 f, l/ U7 B7 f* X
92.         }
    
93. }
    ' {* T) P, A" g6 e" K0 k3 m/ g4 k
94. static void QueueTaskCreate(void)
    % D1 A2 m. Q5 V% V  K
95. {
    
96.         while(1)
    
97.         {
    * \: s, a0 \& L0 _" p0 B
98.                 /*work.*/
    " B7 }9 X+ L9 w
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    5 T" J. e2 s0 V4 s# o" |* Y- ^. M  J' e) Y
100.                 f_printf("Message is :%d\r\n",*printf_value);
     2 S. z, x% Y! m: e6 u7 w7 ?
101.                 Message=*printf_value;
     
102.                
     & n( E8 Y: D4 Z! D$ T0 ]. O
103.                 /*The second method works too*/
     . H6 E5 Z# O' J! ~" J% t! Y
104.         /*
     2 [" s( _3 g& M1 e' i5 z. s( }
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     1 g" R% M) p8 m' O
106.                 f_printf("Message is :%d\r\n",Message);
     
107.         */
     , ]8 ^. L$ |8 G3 L
108.                 Message++;
     
109.                 if(Message > 10)
     9 C  [& v5 c$ F6 Y8 ?+ r! v
110.                         Message = 0;
     + P" K" _! S8 q+ i+ n
111.                 vTaskDelay(1000);
     
112.         }
     
113. }
     7 I- I' T% w6 X2 X1 I
114. /* USER CODE END 4 */

复制代码

" W+ g9 I+ {* ]1 @$ u- }) U