概述
        每个任务都有一个32位的通知值，可以替代二值信号量，计数信号量，事件组，也可以代替长度为1的队列。
  U6 G1 Q1 d! v. P, |
  T% Z1 F/ c" W. p        有以下几种方式发送通知给任务：
% f  U2 N1 h. z. {
1.有通知未读，则不覆盖通知值

2.直接覆盖通知值

: M  L: S  Q. F) U9 C8 d3.设置通知值一个或者多个位，当做事件组来使用
/ G# q/ ~9 x& T: l' P' C2 o
% q# I! W0 }4 e, x2 d5 r9 b4.递增/递减通知，当做信号量来使用

        有以下缺点：

1.只能有一个任务接收通知消息
$ _! O' K, [/ T% U; B; _
2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。

代替二值信号量
) h9 z( w2 @! b6 v& D+ X7 H在FreeRTOSConfig.h里开启任务通知
( @$ N4 `( V& {3 o2 ?( s* X

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

复制代码

在main.c文件里面修改代码
/ Y, t, a' W, V

1. /* USER CODE BEGIN Includes */
   $ L' o9 `% `5 U! r7 {
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include <stdio.h>
   
6. #include <string.h>
   
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    
11. static TaskHandle_t AppTask_Handle = NULL;
    + w% K9 z) p1 P
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    3 P- z5 S/ h1 u+ Q  f& Q
14. 
    
15. extern int f_printf(const char *format, ...);
    ( r# V7 T' }9 ]. ^7 O
16. /* USER CODE END PV */
    
17. 
    
18. /* USER CODE BEGIN PFP */
    9 v7 s$ n+ h9 j7 p# A
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    : w- V' E2 x4 K8 D1 o0 S$ q' m
21. static void LedTaskCreate(void);
    
22. /* USER CODE END PFP */
    & Q$ [1 U3 H4 d3 u0 Z! M; F
23. 
    - B0 `* t  o& I  P  ~
24. int main()
    
25. {
    ! a* X7 a8 Z5 |
26. 
    
27.   /* USER CODE BEGIN WHILE */
    - _, w" W- O1 v2 T( V2 c# s
28.   BaseType_t xReturn = pdFAIL;
    
29.         
    
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    : ~4 B) [- y% m. _% Z
31.                         (const char*)   "APPTASKCREATE",
    / |: m7 o: f6 I' C( z6 w
32.                         (uint16_t)      128,
    
33.                         (void *)        NULL,
    
34.                         (UBaseType_t)   1 ,
    ; I" H- y) b6 P. J7 j
35.                         (TaskHandle_t*) &AppTask_Handle);
    & S) A8 o* }; w) S$ L  r
36.         
    
37.   if(xReturn == pdPASS)
    % \  ^; b2 n( R+ d8 B
38.         {
    8 F9 v+ x# W  F( u: i+ {2 n$ p( T+ X
39.     f_printf("AppTask Create PASS.\r\n");
    * @/ n" \. f0 l+ Z
40.                 vTaskStartScheduler();
    7 J" }9 i$ f# Z
41.         }
    9 H$ U! j, f4 T: k! e" r
42.                                                                                                 
    
43.   while (1)
    ' X  B4 t1 X$ q5 K5 H4 g  |
44.   {
    ' r5 {% X: G) h3 m; f
45.     /* USER CODE END WHILE */
    
46.     /* USER CODE BEGIN 3 */
    
47.   }
    
48.   /* USER CODE END 3 */
    
49. }
    2 S+ |; K2 I+ P1 X% `3 a9 i
50. 
    + `7 L. Q. I( u$ B
51. /* USER CODE BEGIN 4 */
      k' o7 M7 g- |0 f; [( R# c5 I
52. static void AppTaskCreate(void)
    
53. {
    
54.   BaseType_t xReturn = pdFAIL;
    
55. 
    ; r' x) K3 G( k  t
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    - ]" Q" D4 E9 g6 m4 d
57.                         (const char *)  "LEDTASKCREATE",
    
58.                         (uint16_t)      128,
    ( E* [: H! R' H, n; T
59.                         (void *)        NULL,
    # f8 W. A& p  B, @5 E% a- T* s" ~
60.   /*If the priority here is the same as the key task, printf will not print it out.        */
    % r+ M3 ~% z% m7 b
61.                         (UBaseType_t)   2,      
    4 J& E, C) ^9 b- U( C  A' x: O
62.                         (TaskHandle_t *)&LedTask_Handle);
    2 P7 R7 O; |2 `& A" |) J! I' q
63.   if(xReturn == pdPASS)
    9 w% ~# d5 A+ u% v
64.                 f_printf("LedTask Create PASS.\r\n");
    ) a2 L% ~+ i5 ^4 F5 W5 v: }
65.         
    
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
67.                         (const char *)  "KEYTASKCREATE",
    , ]/ D- y# l& i) S5 R, ?
68.                         (uint16_t)      128,
    
69.                         (void *)        NULL,
    ! R$ T5 T' ~3 i, a& s9 L# G
70.                         (UBaseType_t)   1,
    
71.                         (TaskHandle_t *)&KeyTask_Handle);
    : I/ d# C" F+ g7 ?3 y
72.   if(xReturn == pdPASS)
    / k3 O/ `7 X. C, H, {5 O9 H$ E6 J+ ?0 ^
73.         {
    
74.                 f_printf("KeyTask Create PASS.\r\n");
    + ~! J" ^6 }7 A" y$ A+ W
75.     vTaskDelete(AppTask_Handle);
    4 _- r5 i, V  c9 {
76.         }
    
77. 
    
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    ) T) l1 j" w% h1 H1 k8 W
84.           {
    
85.       vTaskDelay(50);
    7 e2 Q5 b8 L8 ]# G6 {
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    4 g! \7 I4 A2 z5 G) A5 A
87.                   {
    " \5 n( _( C1 l; b$ [6 x
88.         xTaskNotifyGive(LedTask_Handle);
    7 O2 v/ a0 v9 |9 f, Q
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    # j3 i7 U. l, |5 w3 p
90.                   }
    ; u) G0 ]* J- z: O
91.           }
    % Z: x5 S- T: k* w2 w6 Z
92.           vTaskDelay(100);
    
93.   }
    
94. }
    
95. static void LedTaskCreate(void)
    ! i3 j) C1 K0 q7 ~0 A! Y
96. {
    
97.         uint32_t ulreturn=0;
    4 L4 F( J0 j4 D- x4 T
98.         while(1)
    1 U8 o# e. Q; _; B
99.         {
    , M, S! K9 c2 i& U- i
100.                
     
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     0 N7 y! R: S! R* A) F4 _4 i
102.                 if(ulreturn==1)
     2 [6 u+ `  g/ T8 `5 x
103.                 {
     $ G" i0 Q; v' t! m4 }5 P
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);
     * {" l. H  z7 ^
107.                         
     
108.                 }
     
109.                 else
     
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     
111.     vTaskDelay(100);
     ! M! v- m: u5 T0 r8 O
112.   }
     : M+ t; P( c4 p( w9 I8 B9 C
113. }
     & m0 P+ R) T4 F4 r8 w. g
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     : F; H- ]0 o, F- G: C- o1 S4 A
117. 
     
118. /*Turn on task notifications.*/
     
119. #define configUSE_TASK_NOTIFICATIONS      1
     : l( G1 A" k9 ~
120. 在main.c文件里面修改代码
     7 X% ]% x0 ~, ~. y6 s5 _
121. 
     
122. /* USER CODE BEGIN Includes */
     % `% \$ K7 L: q+ g# p, h  T) k% r
123. 
     
124. #include "FreeRTOS.h"
     
125. #include "task.h"
     
126. #include <stdio.h>
     5 v  c+ e, w7 ]  N9 p
127. #include <string.h>
     ( y& c  k; Y7 _# R; {
128. 
     8 |+ d$ W" L* _+ q- \7 C5 T
129. /* USER CODE END Includes */
     9 M3 r$ i# c& v. ~( d: O
130. 
     
131. /* USER CODE BEGIN PV */
     
132. static TaskHandle_t AppTask_Handle = NULL;
     / w( h6 ~; w* q' ~8 W4 ?* x; S' }
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     
135. 
     # ]( U; E! G8 ]( S, P8 e
136. extern int f_printf(const char *format, ...);
     
137. 
     
138. /* USER CODE END PV */
     
139. 
     4 q9 `+ J2 w1 b$ t. `
140. /* USER CODE BEGIN PFP */
     
141. static void AppTaskCreate(void);
     : L; b3 m# u) a* @
142. static void KeyTaskCreate(void);
     
143. static void LedTaskCreate(void);
     & D' u( _& t1 m( o$ l7 P! p% _
144. /* USER CODE END PFP */
     
145. 
     , m6 F) u3 K; j0 L
146. int main()
     
147. {
     
148.   /* USER CODE BEGIN WHILE */
     
149.   BaseType_t xReturn = pdFAIL;        
     
150. 
     
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     4 H- ]9 p3 T- i9 r
152.                         (const char *)  "APPTASKCREATE",
     1 |; R2 e) F4 M7 M) l! z
153.                         (uint16_t)      128,
     9 y" ?7 u1 k3 f
154.                         (void *)        NULL,
     
155.                         (UBaseType_t)   1,
     
156.                         (TaskHandle_t*) &AppTask_Handle);
     
157. 
     * x% C( R- c* ]& A5 Y! r. ~3 ]
158.   if(xReturn == pdPASS)
     # F% }) u, r& Q& v) g
159.         {
     ; ?8 \$ F4 ?( |; y, X
160.     f_printf("AppTask Create PASS.\r\n");
     9 s9 y1 o+ O3 C3 _3 y2 j
161.     vTaskStartScheduler();
     
162.         }
     
163.   while (1)
     
164.   {
     
165.     /* USER CODE END WHILE */
     
166. 
     
167.     /* USER CODE BEGIN 3 */
     
168.   }
     $ N1 S1 E: U( m2 q8 k1 L; z/ V$ |
169.   /* USER CODE END 3 */
     6 k& Z1 |0 Y5 R* E5 k! p
170. }
     ! x$ ^9 D' ]! a. H  w# l
171. 
     
172. 
     7 l0 Q# G! f* ]( f1 }& H
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     
175. {
     $ K7 Z" J5 E; `8 l
176.         BaseType_t xReturn = pdFAIL;
     * Q. m- u6 ]' |& B8 z+ I
177. 
     8 ]& V0 \1 {% r7 s9 K" ?" z
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     
179.                         (const char *)  "LEDTASKCREATE",
     
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     
182.                         (UBaseType_t)   1,
     6 O% T& P. J6 ^
183.                         (TaskHandle_t *)&LedTask_Handle);
     
184.   if( xReturn == pdPASS)
     . Y8 }  R. n% ?) f. D; V, G0 G6 ^, q
185.           f_printf("LED Task Create PASS.\r\n");
     
186.         
     " M9 K/ }7 T+ V4 |
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     
188.                         (const char *)  "KEYTASKCREATE",
     
189.                         (uint16_t )     128,
     
190.                         (void *)        NULL,
     , C% G# B* t; f8 S
191.                         (UBaseType_t)   2,
     * R1 J' S6 w5 O, d& z4 |& y
192.                         (TaskHandle_t *)&KeyTask_Handle);
     ' M% s5 i8 M2 X' ^8 E
193.   if( xReturn == pdPASS)
     
194.         {
       }! ]! x, l% j  W
195.     f_printf("KEY Task Create PASS.\r\n");
     
196.     vTaskDelete(AppTask_Handle);
     
197.         }
     
198. }
     & J, h$ v, j  _3 Z; d
199. static void KeyTaskCreate(void)
     8 N, Z4 @$ u9 N0 l. A3 B
200. {
     
201.   while(1)
     / m& R5 F  t* J. t7 L. f+ q6 }
202.         {
     0 }& A9 F9 o$ R' h' G' [
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     1 B( K: b  h& p- B; x+ Y
204.                 {
     
205.                         vTaskDelay(40);
     
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     ( a) f# S% C( W/ C7 P- \) d1 h4 ~' n, ?
207.                         {
     
208.                                 xTaskNotifyGive(LedTask_Handle);
     
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     % l' G) T* w3 l8 C+ R/ V3 |( `7 r8 S: Y
210.                         }
     
211.                 }
     
212.     vTaskDelay(40);
     - u+ l# b$ |* d# F& C
213.         }
     
214.                
     3 a9 J0 l0 q$ f/ X* }: S) h
215. }
     
216. static void LedTaskCreate(void)
     $ |- C7 _' g) w! U5 e
217. {
     . }3 d( t: G4 h1 }
218.         uint32_t ulValue = 0 ;
     
219.         while(1)
     
220.         {
     
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
     9 Q' Q& Q5 k5 N) W8 [. T% [& Z
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
     : h( U. @2 \% r0 R3 n+ s, b8 C& t
225.          */
     
226.                 if(ulValue >0)
     . w! Y- o- @  z: Z. j. W
227.                 {
     
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
229.                         f_printf("LED Task PASS.\r\n");
     
230.                 }               
     & [$ J! y4 z7 H6 w
231.                 vTaskDelay(1500);
     
232.         }
     6 W2 c4 S7 E; @* _1 j" z0 [& a
233. }
       O  t" T. W' c  k  l5 A, S& {7 ]
234. 
     ' n1 v# l! y$ c/ w4 A
235. /* USER CODE END 4 */

复制代码

, P* C- f7 @- F+ |2 i; ?代替事件组
在FreeRTOSConfig.h里开启任务通知
+ ~) a' H! c7 b# _

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

复制代码

在main.c文件里面修改代码
2 Q, n' g5 [' J/ r
6 q: J4 g& W% X4 I

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   , F* E( Y! ~# q
4. #include "task.h"
   
5. 
   ( G% o. j6 v' M8 T% l9 b% H' Z2 ]' d
6. #include <stdio.h>
   
7. #include <string.h>
   $ R1 {0 o# v+ g  L! U
8. 
   1 I4 Y! q- h$ m5 e( {' k
9. /* USER CODE END Includes */
   
10. 
    7 E" x; W/ e8 V! p7 }! }! E
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTask_Handle = NULL;
    * J8 x( ~/ k/ A
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t LedTask_Handle = NULL;
    - l! X& o. V2 j( m8 v0 [' J: \
15. 
    " Y. ]) v% Y# t$ e! ^  K7 H  g1 B+ K
16. extern int f_printf(const char *format, ...);
    " n4 H, V  o2 t/ t% G# B
17. /* USER CODE END PV */
    
18. 
    
19. /* USER CODE BEGIN PFP */
    6 V; Q. I2 T7 m( P; v8 R
20. 
    / j) j3 ]6 W& u6 R+ u
21. static void AppTaskCreate(void);
    
22. static void KeyTaskCreate(void);
    
23. static void LedTaskCreate(void);
    
24. 
    + |( T; y4 r" x/ n
25. /* USER CODE END PFP */
    8 j$ _% L& y; I6 p! H/ U
26. 
    3 W, q1 d& Y) C' Q
27. int main()
    % D% S+ t" N  `3 c
28. {
    # m" ?. T% P, v
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    
31.         
    8 F$ t. ]5 v5 o# s
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    2 w/ U8 V5 g% x  c1 ]8 P
33.                             (const char *)  "",
    
34.                                                 (uint16_t)      128,
    ) V2 w5 s8 s$ L5 a& l- V: C
35.                                                 (void *)        NULL,
    : X: E8 {* c: {
36.                                                 (UBaseType_t)  1,
    % k  \9 w/ c' x5 y
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    $ r  ^. ]3 d0 ~
38.         if( xReturn == pdPASS)
    
39.         {
    
40.                 f_printf("APP Task Start.\r\n");
    / w, G- o' w6 [! ^% F* U
41.                 vTaskStartScheduler();
    , D$ G. J: Q3 r$ [
42.         }
    
43. 
    ' n* `, o3 A  Y# @. @9 q1 s5 T
44.   while (1)
    
45.   {
    + ]# o5 m% C$ c! M5 T
46.     /* USER CODE END WHILE */
    ' }# x# c; I! ^/ b$ j
47. 
    
48.     /* USER CODE BEGIN 3 */
    % f+ s' ^% n' U1 b3 X0 u/ D/ \* M
49.   }
    ' C! Z1 y; o$ d6 ^0 ?, f% d
50.   /* USER CODE END 3 */
    / \- r* \6 h5 D  |/ f: B
51. }
    0 T1 L7 I9 N/ i8 k' r
52. 
    
53. /* USER CODE BEGIN 4 */
    ) T1 l' ^" w# f$ |) o- B4 c# c
54. static void AppTaskCreate(void)
    9 Q8 d, ?$ G* A) R& `( I$ K3 {
55. {
    * ?1 H, y* V0 g" {9 Z: }6 x* O
56.         BaseType_t xReturn = pdFAIL;
    
57.         
    
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    3 ]; R/ W9 U! H8 d) ?
59.                               (const char *)  "",
    
60.                                                                                                 (uint16_t)      128,
    
61.                                                                                                 (void *)        NULL,
    7 r8 Y2 G. E+ Z- p
62.                                                                                                 (UBaseType_t)   1,
    
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    
64.   if( xReturn == pdPASS)
    3 K. }% D& r5 ?6 s( [. P8 a
65.                 f_printf("LED TASK PASS.\r\n");
      {+ o$ v; t1 ^8 Q) q9 j+ [5 w
66.         
    
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    4 a; A+ `: w  a+ N- R1 [/ o- }
68.                               (const char *)   "",
    
69.                                                                                                 (uint16_t )      128,
    
70.                                                                                                 (void *)         NULL,
    
71.                                                                                                 (UBaseType_t)   2,
    
72.                                                                                                 (TaskHandle_t *) &KeyTask_Handle);
    
73.   if( xReturn == pdPASS)
    
74.         {
      f- Q( E+ _4 r: A8 O9 U
75.     f_printf("KEY TASK PASS.\r\n");
    6 ^) y7 U1 b0 n. G% t
76.                 vTaskDelete(AppTask_Handle);
    
77.         }                                                                                
    ' E8 W' E& X4 p/ R7 }
78. }
    ( c1 f0 n  k+ I# X3 z7 m' ^. r
79. static void KeyTaskCreate(void)
    3 h2 F0 i$ g" q1 Q& g5 {: F' G8 ^
80. {
    / x- i/ H, \, u3 f
81.   while(1)
    " b- e+ ~% I% `1 n' {% s9 x
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    ' n8 Q7 o  e) ?: {! `
85.                         vTaskDelay(40);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    : U6 U3 L* `- i3 s
87.                         {
    
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    
89.                                 f_printf("PA0.\r\n");
    % F" k9 z) o4 J' m+ y, K$ B
90.                         }
    
91.                 }
    ( \, I: o  W% l# Z5 F5 l
92.                 else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    
93.                 {
    
94.                         vTaskDelay(40);
    
95.                         if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12) == 0)
    ! w* V" P* P( u! M5 s
96.                         {
    ( b. F" J& x, o* m2 F
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    6 L3 D) v6 Z5 v2 |7 r* |  |
98.                                 f_printf("PC12.\r\n");
    1 \) o1 a/ w2 G4 W0 [, @/ B
99.                         }
    
100.                 }
     
101.                
     
102.                 vTaskDelay(50);
     
103.         }
     
104. }
     
105. static void LedTaskCreate(void)
     
106. {
     & Y  ^0 e4 r2 o/ C9 W7 V
107.         uint32_t ulReturn = 0;
     / L2 z& ]! H/ \" ?
108.         BaseType_t xReturn = pdFAIL;
     
109.         while(1)
     
110.         {
     
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     ' Q6 {0 ^1 A  N0 ?/ m
112.                
     
113.                 if(xReturn == pdTRUE)
     ; s# E: A7 J, R: F, X+ ^5 ~( V+ S
114.                 {
     " g0 I. Z' R4 c2 A
115.                         if( (ulReturn & 0x1)==1)
     , _. E- y. P/ u# O% o7 l  k
116.                         {
     / l9 q" v: K- W+ k- O. e
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
118.                                 f_printf("LED1.\r\n");
     
119.                         }
     
120.                         else if( (ulReturn & 0x02)==2)
     
121.                         {
     
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     # A' T/ P6 Z9 t0 ?4 m  i5 T
124.                         }
     
125.                 }
     7 U  t" r, k9 O9 W  x& `$ M3 b. C
126.                 else
     $ @: K# Y: z, `% N! }
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     ) C7 Q# W: K* Y2 F7 [4 A
129.                 vTaskDelay(1500);
       _9 y4 \1 o8 X% S: W
130.         }
     
131. }
     9 ~8 Q: y% N9 C
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
在FreeRTOSConfig.h里开启任务通知
% j, H0 j/ X6 C0 w8 R' z, F

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

复制代码

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

1. /* USER CODE BEGIN Includes */
   % a* f" Z8 r2 o! b* e% }" Q
2. 
   " }% ~# k# S% {
3. #include "FreeRTOS.h"
   ; a; ~/ w: S+ w. l+ D
4. #include "task.h"
   
5. #include <stdio.h>
   7 n: k+ Z9 s1 G4 F: C
6. #include <string.h>
   . B  N9 x7 T' l5 H  w, C. ?4 M
7. 
   $ R, ?' d# }# q8 t
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
      ?. y, e7 O) `/ q+ |8 Z. k' l! w
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    2 }, s7 t$ q5 K" R' j; {/ R3 c# J1 a. @
13. static TaskHandle_t QueueTask_Handle = NULL;
    : g0 I- N/ [: G) U
14. static uint32_t Message = 0;
    7 s) k. r3 q$ }! A$ ^: t# }
15. static uint32_t *printf_value=&Message;
    1 B$ R7 [1 q, S: s9 A7 O  l; M
16. extern int f_printf(const char *format, ...);
    
17. 
    
18. /* USER CODE END PV */
    - A$ ?' H( z, w5 j
19. 
    
20. /* USER CODE BEGIN PFP */
    
21. static void AppTaskCreate(void);
    % X0 I* {9 b5 z* {# p
22. static void KeyTaskCreate(void);
    9 w! t0 ^. A4 E9 G  M% H% N& N; @7 X
23. static void QueueTaskCreate(void);
    
24. /* USER CODE END PFP */
    + E9 @% w  X1 v$ [  g( _' z  D# {4 z
25. 
    / S6 G- y' O1 k# f1 \
26. int main()
    
27. {
    ; A0 n/ t2 C: F: c
28.   /* USER CODE BEGIN WHILE */
    
29.   BaseType_t xReturn = pdFAIL;
    
30.         
    " Y1 Y1 [7 k2 f9 L* S5 Q/ G
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    ; w: Y9 r: }# }7 b' T% \4 Z
32.                               (const char *)   "",
    + Y4 h/ r3 G- I! c
33.                                                   (uint16_t)       128,
    
34.                                                   (void *)         NULL,
    1 L4 T! ^+ E+ J" ^5 F4 ~/ `
35.                                                   (UBaseType_t)    1,
    ' s% H" ~% e8 \+ B* k2 c
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    2 K) }1 m: V9 R+ q
37.                                                                                                 
    8 t" D) m# m" ^0 U" P
38.   if( xReturn == pdPASS)
    
39.         {
    0 E, I3 b) p" f: M% _& r9 k- E; U1 C) P
40.     f_printf("AppTask Start.\r\n");
    * `3 M& {- O& C- V; [) i' S9 J
41.                 vTaskStartScheduler();
    
42.         }
    
43.         
    " A2 d; X5 E5 @  e9 P7 J; G
44.   while (1)
    
45.   {
    & u" `4 d5 @; w# x/ A( l
46.     /* USER CODE END WHILE */
    
47. 
    1 _5 c$ @$ c2 H* {7 O* Y' x* s
48.     /* USER CODE BEGIN 3 */
    
49.   }
    % o+ b, z( i! v9 Y8 x- P! R
50.   /* USER CODE END 3 */
    
51. }
    
52. 
    ' H4 {0 ^: j+ l  F/ i
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    & g2 j. `8 ]2 B/ t
55. {
    
56.         BaseType_t xReturn ;
    
57.         
    
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    
59.                          (const char *)  "",
    - |0 a$ {0 H# J4 \2 n
60.                                                                                                  (uint16_t)      128,
    
61.                                                                                                  (void *)        NULL,
    ; s% j# ?$ _, f/ I
62.                                                                                                  (UBaseType_t)   2,
    ; t( `3 ]+ G% u. R0 N
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    + h1 ]* ^8 w* d  |7 G$ i! w0 x
64.   if( xReturn ==pdPASS )
    / L6 A' [" B2 Y; D& `
65.                 f_printf("QueueTask Create PASS.\r\n");
    
66.         
    8 J  W6 h5 C( H
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    & g; l" }0 K. F
68.                          (const char *)  "",
    
69.                          (uint16_t)      128,
    % P$ q0 |# n2 O# G2 M: V  Y' i
70.                                                                                                  (void *)        NULL,
    6 T4 \2 H$ @4 U
71.                                                                                                  (UBaseType_t)   1,
    : K$ K. Z, L1 C
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    
73.   if (xReturn == pdPASS)
    
74.         {
    + f- V& U# z8 T& ]2 D1 f8 Z
75.           f_printf("KeyTask Create PASS.\r\n");
    ) Q0 |) |0 Z, e. F
76.                 vTaskDelete(AppTask_Handle);
    ! ^! d+ [8 \) k
77.         }
    
78. }
    
79. static void KeyTaskCreate(void)
    ! ^7 Z( ]9 u, M/ m8 `1 _
80. {
    - q' B  Q$ P6 Y; e- S
81.         while(1)
    $ Z2 P' A7 f8 B+ v3 q& f
82.         {
    
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    # f* X3 M+ r* M$ Z/ K
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    & l- i+ i1 P, ]  b
87.                         {
    
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    
89.                         }
    
90.                 }
    
91.                 vTaskDelay(80);
    
92.         }
    
93. }
    2 i$ ?- H  w$ s4 q1 u1 g' N$ l' A
94. static void QueueTaskCreate(void)
    
95. {
    
96.         while(1)
    ) J( q% s) r# v/ H# I
97.         {
    
98.                 /*work.*/
    0 i  w  u0 d9 b* p4 W, n3 D6 D
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    # X7 I5 e$ {; M4 p; \
100.                 f_printf("Message is :%d\r\n",*printf_value);
     ' P3 G! G% L: E
101.                 Message=*printf_value;
     ! j* _1 Q' ~" N  U, _( y$ M  w8 J& Z
102.                
     7 {" `7 r9 }3 N; J: Z4 R- _
103.                 /*The second method works too*/
     
104.         /*
     / V& L2 q6 _" b0 E+ Z9 P; E* ?! e) D
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     
106.                 f_printf("Message is :%d\r\n",Message);
     
107.         */
     
108.                 Message++;
     
109.                 if(Message > 10)
     : y0 n+ W. {5 G
110.                         Message = 0;
     & u! ~/ O! g# C$ \& E4 p- W
111.                 vTaskDelay(1000);
     4 I# R# U2 c/ ?9 V# Z3 C
112.         }
     ! V0 }4 D) Q$ B! _
113. }
     - v/ d- D& I% |) o( B
114. /* USER CODE END 4 */

复制代码

; s" t" O3 H8 V6 f' J/ S