概述
  j* [+ a, W$ E5 u5 I' J( L        每个任务都有一个32位的通知值，可以替代二值信号量，计数信号量，事件组，也可以代替长度为1的队列。

        有以下几种方式发送通知给任务：

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

6 M' j' f4 [. \$ |4 z- @$ b" A9 @2.直接覆盖通知值

# T4 P3 m' i( b/ f- m3.设置通知值一个或者多个位，当做事件组来使用

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

/ ?  C" @3 h  x3 d7 C        有以下缺点：
+ {/ z/ ^8 B/ W) k) |" _6 f1 ~' r
. `- C, U4 R1 ~% S1.只能有一个任务接收通知消息
% ]7 a2 a( W! w2 @. j3 D! ]9 K4 X
2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。

, y' o) Y1 P. |代替二值信号量
9 A  q& e' j# S2 U9 O在FreeRTOSConfig.h里开启任务通知
0 a8 w+ M, f3 f+ E' ?7 C) ~

1. /*Turn on task notifications.*/
   0 b$ A/ f" Y; G0 h$ o$ M2 R) E
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

5 [. F" b, l' Q) w, A在main.c文件里面修改代码

; x# d' q- _% J6 ]) H

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   ) a6 }: w% y. J* p5 W  ~
4. #include "task.h"
   3 ?1 t$ p) k- ]4 S
5. #include <stdio.h>
   
6. #include <string.h>
   9 `& I( B6 F+ a* i, U4 J& ?
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    7 e9 K+ y/ p1 _2 L. t! t1 m  ?$ J
11. static TaskHandle_t AppTask_Handle = NULL;
    
12. static TaskHandle_t KeyTask_Handle = NULL;
    
13. static TaskHandle_t LedTask_Handle = NULL;
    
14. 
    + T6 x; n8 l7 y$ `
15. extern int f_printf(const char *format, ...);
    
16. /* USER CODE END PV */
    5 {3 S: f7 L) K) v
17. 
    & h- s" `5 N3 y. A4 f. z( ]
18. /* USER CODE BEGIN PFP */
    0 O# r& \! _- U+ _7 m- Z
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    $ K  I) t; W# T! N
22. /* USER CODE END PFP */
    / H0 x& q+ g) }* G* f4 p
23. 
    
24. int main()
    5 u# a5 \. y1 s' K2 a' }
25. {
    
26. 
    
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    
29.         
      i+ A; e& k3 Q! u) p. D/ a
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
31.                         (const char*)   "APPTASKCREATE",
    0 t5 y" H8 e0 q- v, {8 F! W
32.                         (uint16_t)      128,
    ( v. h0 p, ~6 M( q
33.                         (void *)        NULL,
    5 c- Z# U& |7 J/ o  t2 T; k& m
34.                         (UBaseType_t)   1 ,
    
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    , T' |- T/ l1 e# h$ E) x) @. e
37.   if(xReturn == pdPASS)
    
38.         {
    6 L1 c+ s6 t9 J# W
39.     f_printf("AppTask Create PASS.\r\n");
    7 }# @5 ]  K4 z( R
40.                 vTaskStartScheduler();
    
41.         }
    - a  J& G  ]7 |$ n6 l
42.                                                                                                 
    ' b2 a* b7 J# v% T: g9 C2 O
43.   while (1)
    ' p  j" X: S" F  `8 v) j! v" Q
44.   {
    
45.     /* USER CODE END WHILE */
    % D2 Y$ n' [; A2 L1 T
46.     /* USER CODE BEGIN 3 */
    ) Y( Z- a2 @6 c6 P3 ?/ ~
47.   }
    8 `. A1 X6 d3 F) c7 w) x# q
48.   /* USER CODE END 3 */
    
49. }
    # D* M8 P( j$ u( Z
50. 
      T: E; c0 m# t6 E
51. /* USER CODE BEGIN 4 */
    
52. static void AppTaskCreate(void)
    $ ^  K0 Y/ T$ \/ B2 v4 B  P
53. {
      C& L$ H# X" M0 n2 g/ r
54.   BaseType_t xReturn = pdFAIL;
    
55. 
    
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    , P" q/ E' J9 Y4 p
57.                         (const char *)  "LEDTASKCREATE",
    7 s8 v4 Y) H' E' u# f" ^
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,      
    3 S/ J( y& [8 V. I& q- S. c
62.                         (TaskHandle_t *)&LedTask_Handle);
    . v# t' q: G: J- G: M+ y4 ]
63.   if(xReturn == pdPASS)
    1 v( \8 a( v$ T: e1 a7 N
64.                 f_printf("LedTask Create PASS.\r\n");
      h% J' T0 t9 H% u7 i7 i) r6 P0 R* l; s
65.         
    0 B/ v: I" k" S% p0 y/ f" K9 O& g# j0 [
66.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
67.                         (const char *)  "KEYTASKCREATE",
      A/ N4 }6 x3 w5 m$ g  S
68.                         (uint16_t)      128,
    
69.                         (void *)        NULL,
    / N# f" x  A6 u4 ?! Q- G
70.                         (UBaseType_t)   1,
    
71.                         (TaskHandle_t *)&KeyTask_Handle);
    
72.   if(xReturn == pdPASS)
    
73.         {
    : `4 I; |6 M5 F, Y( V  u
74.                 f_printf("KeyTask Create PASS.\r\n");
    
75.     vTaskDelete(AppTask_Handle);
    8 K1 o2 u+ E) u: U
76.         }
    
77. 
    - F' R3 n' k# B, ]% }8 E
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    & f, V2 c$ K  m7 [+ A( |0 S
82.         {
    : b. ]9 g# d( p* ^4 r
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.           {
    : u! O. C, [. R' U) p1 E
85.       vTaskDelay(50);
    $ \& F; X9 C$ U
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                   {
    % T6 i( _: r& x. J, J
88.         xTaskNotifyGive(LedTask_Handle);
    
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    
90.                   }
      b. Y8 u. n! y+ G+ g
91.           }
    
92.           vTaskDelay(100);
    6 N1 N% O6 U8 |5 B  }
93.   }
    
94. }
    ; S! ~4 }# _! h; l% b% o
95. static void LedTaskCreate(void)
    : w; K, ?0 f9 S4 ~8 I9 f
96. {
    
97.         uint32_t ulreturn=0;
    
98.         while(1)
    5 z* {8 w# T/ u' ?$ O+ o
99.         {
    
100.                
     . V. c- S# V7 v& J3 Y% Z% m! @1 B
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     5 Q6 B, C4 C" ?+ v4 ?
102.                 if(ulreturn==1)
     ! B$ N; A+ ]2 W; o1 m4 }% V
103.                 {
     
104.                         /*It won’t be printed out at the same level*/
     9 G  S9 \7 Y) _2 x  H; q- @# W8 w
105.                   f_printf("LedTask TAKE PASS.\r\n");
     & x5 U4 }2 Y/ h6 c- R0 x# n; h
106.             HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
107.                         
     ! E3 r$ e! [5 q  F, G; b' H3 p
108.                 }
     6 t6 [/ L4 `# {; J5 A, z1 A& f9 V
109.                 else
     
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     
111.     vTaskDelay(100);
     " ~; g' T$ j" O/ a$ _8 {$ F* [
112.   }
     
113. }
     
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     2 G4 K) @# g) y
117. 
     
118. /*Turn on task notifications.*/
     
119. #define configUSE_TASK_NOTIFICATIONS      1
     / @( T7 `% R, |3 y" A
120. 在main.c文件里面修改代码
     
121. 
     ! H- ^$ X  ?6 r* M. g! V
122. /* USER CODE BEGIN Includes */
     / i( R% R1 |( D. C* f+ E
123. 
     
124. #include "FreeRTOS.h"
     
125. #include "task.h"
     
126. #include <stdio.h>
     
127. #include <string.h>
     
128. 
     
129. /* USER CODE END Includes */
     9 W# d! U% q, Q, V- Q- M" J
130. 
     
131. /* USER CODE BEGIN PV */
     % e* k: @# B5 F) J( m
132. static TaskHandle_t AppTask_Handle = NULL;
     
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     9 w: k) n+ u. a: `, |" l
135. 
     
136. extern int f_printf(const char *format, ...);
     
137. 
     ( c1 }8 V# Z8 X' m5 c
138. /* USER CODE END PV */
     $ }" B$ ^1 |4 \+ ?
139. 
     6 n2 s# m, W. f3 M! \# R8 A
140. /* USER CODE BEGIN PFP */
     
141. static void AppTaskCreate(void);
     8 l; B4 u8 D" R" n2 u( E; e
142. static void KeyTaskCreate(void);
     " Q; m" C/ @) \' u0 U# X; _7 O
143. static void LedTaskCreate(void);
     / ~- K3 Z- E- b' w' q3 |5 N
144. /* USER CODE END PFP */
     * O2 z; Z$ D" u' _$ s
145. 
     9 ], Q5 d0 e/ V( F2 u: W
146. int main()
     
147. {
     
148.   /* USER CODE BEGIN WHILE */
     9 h( [% [) i0 j* }8 g2 q
149.   BaseType_t xReturn = pdFAIL;        
     . w/ A# R5 F2 d7 H6 r  A8 l
150. 
     / n0 R. q! X7 Q" S% i
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     
152.                         (const char *)  "APPTASKCREATE",
     
153.                         (uint16_t)      128,
     
154.                         (void *)        NULL,
     
155.                         (UBaseType_t)   1,
     " Y& G9 `4 c* T
156.                         (TaskHandle_t*) &AppTask_Handle);
     ; M; r' A' F8 X" e
157. 
       G6 J' x. Z# s; ?9 p1 }
158.   if(xReturn == pdPASS)
     
159.         {
     : a9 A3 {2 h! g% k  {8 o$ [; B
160.     f_printf("AppTask Create PASS.\r\n");
     2 L( @& Y, {, u" e1 e. z* _
161.     vTaskStartScheduler();
     
162.         }
     
163.   while (1)
     + ]4 G0 G1 B8 U$ \* `7 K
164.   {
     
165.     /* USER CODE END WHILE */
     
166. 
     
167.     /* USER CODE BEGIN 3 */
     
168.   }
     / ^) v8 s$ h% s
169.   /* USER CODE END 3 */
     
170. }
     
171. 
     5 n: F; g8 E8 k7 f: b
172. 
     
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     
175. {
     ( O- I) k* k8 V/ M& w$ x# D$ U
176.         BaseType_t xReturn = pdFAIL;
     $ U% s9 m. f' ]! b& B/ S8 M
177. 
     ' B: @/ H  g7 c7 U+ M
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     - _! u/ R) r0 [6 A9 n
179.                         (const char *)  "LEDTASKCREATE",
     ( y- w6 P/ p) u0 c& P
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     
182.                         (UBaseType_t)   1,
     1 x  h# f% I% i$ a! [
183.                         (TaskHandle_t *)&LedTask_Handle);
     5 X- V: N1 s1 K5 d9 ~, F
184.   if( xReturn == pdPASS)
     
185.           f_printf("LED Task Create PASS.\r\n");
     9 f" g/ r5 P8 U+ T$ }  y# ~
186.         
     8 J0 S# w3 ~% _% F. P2 F, E0 x
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     1 A- B# N0 l% s* \) }) R, E, y: E
188.                         (const char *)  "KEYTASKCREATE",
     $ V6 A5 W  H* n
189.                         (uint16_t )     128,
     
190.                         (void *)        NULL,
     
191.                         (UBaseType_t)   2,
     % {' L, V& }# L5 }
192.                         (TaskHandle_t *)&KeyTask_Handle);
     % w! {0 P& f. t& C0 p1 }
193.   if( xReturn == pdPASS)
     
194.         {
     
195.     f_printf("KEY Task Create PASS.\r\n");
     
196.     vTaskDelete(AppTask_Handle);
     
197.         }
     
198. }
     
199. static void KeyTaskCreate(void)
     0 C6 T9 A9 |$ I  C0 @! X
200. {
     - m% M* b4 D7 z8 ?8 W! H
201.   while(1)
     
202.         {
     9 w6 y; _( V/ z! h# {% @5 L
203.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     % j& g+ I7 J: M, I; j/ |0 W% G
204.                 {
     
205.                         vTaskDelay(40);
     
206.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
207.                         {
     
208.                                 xTaskNotifyGive(LedTask_Handle);
     
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     . k: X* L3 e) [) D, b/ C
210.                         }
     
211.                 }
     
212.     vTaskDelay(40);
     : @" x6 j9 N7 z% b  H
213.         }
     
214.                
       R6 D8 p1 R- ^
215. }
     . A: h, [! z6 m9 _) F2 ?
216. static void LedTaskCreate(void)
     % K4 _; U" W6 ?1 v3 N! T# \
217. {
     4 C# k- l( I6 q' ^6 B
218.         uint32_t ulValue = 0 ;
     7 H4 O* Q. J! U
219.         while(1)
     
220.         {
     
221.     ulValue = ulTaskNotifyTake( pdFALSE , 0);
     
222.                
     8 ^  m) ]9 |  v$ [2 L: L
223.                 /*Greater than 0 proves that there is still a notification value that can be
     ) l0 [  H0 _. S4 a. D
224.          *reduced by 1. Equal to 0 indicates that no notification is available
     ( A( ?) I: V  [0 V, E( h  c
225.          */
     
226.                 if(ulValue >0)
     
227.                 {
     , f" E" b6 Q+ l: n
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     2 W8 z( c0 z. q5 @) {$ b5 i# V; n
229.                         f_printf("LED Task PASS.\r\n");
     + R0 k1 z3 }) @# F
230.                 }               
     - K5 T2 [& S, u9 n2 L( l4 Q2 ~( W8 m- L
231.                 vTaskDelay(1500);
     
232.         }
     
233. }
     ( h, l: L. g/ [3 e8 d2 P0 ?
234. 
     , r1 s+ E  _7 g3 B3 ]1 q
235. /* USER CODE END 4 */

复制代码

" @: p5 z( _, G& V2 G6 q5 c; E( D代替事件组
7 c0 [( p/ \* i# @4 h$ D在FreeRTOSConfig.h里开启任务通知
! |: s3 L$ @* m2 _' @' L1 t
5 d% L  d, u0 K) M2 ]* A# S8 i

1. /*Turn on task notifications.*/
   ( r+ A7 L. }" U0 i& s' p
2. #define configUSE_TASK_NOTIFICATIONS      1

复制代码

在main.c文件里面修改代码
, ]0 `# V1 o' w: @" n- `  ^

1. /* USER CODE BEGIN Includes */
   
2. 
   ' |) s. }- Z) Q& J& t
3. #include "FreeRTOS.h"
   - H8 R! e+ t" l
4. #include "task.h"
   
5. 
   - ~) F9 Y1 C3 V, }( w  K3 r
6. #include <stdio.h>
   
7. #include <string.h>
   
8. 
   # J' ~% S7 ?! _, [
9. /* USER CODE END Includes */
   - W! E+ V9 @0 I3 n8 D
10. 
    ) ^0 B% [1 g/ q* d3 v3 ~" S
11. /* USER CODE BEGIN PV */
    9 F$ ?* {9 `( z$ }  C9 }. F
12. static TaskHandle_t AppTask_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    3 ^6 Q2 U5 I. P% |# _% u! }( V- L( @
14. static TaskHandle_t LedTask_Handle = NULL;
    
15. 
    
16. extern int f_printf(const char *format, ...);
    - w# a5 x% F$ T$ B) h
17. /* USER CODE END PV */
    ; V2 {6 f4 D# u3 t+ g
18. 
    
19. /* USER CODE BEGIN PFP */
    
20. 
    
21. static void AppTaskCreate(void);
    
22. static void KeyTaskCreate(void);
    
23. static void LedTaskCreate(void);
    
24. 
    
25. /* USER CODE END PFP */
    
26. 
    
27. int main()
    . g1 K, v& U# w$ F5 d! a
28. {
    % \! b$ G; W( P; C% h9 [
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
33.                             (const char *)  "",
    5 C2 E) r  y. E; F- `6 r
34.                                                 (uint16_t)      128,
    
35.                                                 (void *)        NULL,
    
36.                                                 (UBaseType_t)  1,
    
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    9 {, ]  Y4 V8 |; I5 V
38.         if( xReturn == pdPASS)
    , f, {( n/ u  b) }
39.         {
    
40.                 f_printf("APP Task Start.\r\n");
    
41.                 vTaskStartScheduler();
    % h1 m5 y$ [& s( A4 @3 o" F
42.         }
    
43. 
    
44.   while (1)
    6 v) e+ I) S5 ?! \7 N  P
45.   {
    
46.     /* USER CODE END WHILE */
    : u3 N9 M) ?/ [, K: U7 B* C
47. 
    1 p* w6 M: s' p; I$ A, r
48.     /* USER CODE BEGIN 3 */
    # |7 c; r' M$ u0 d6 K4 \9 {
49.   }
    ' h, S/ m5 K1 ^* {
50.   /* USER CODE END 3 */
    . P: t! P; i+ O4 t, G1 i" h
51. }
    
52. 
    9 A1 ~: @& f. H7 g& A0 N( X- X2 v
53. /* USER CODE BEGIN 4 */
    9 _4 ~6 Q; w+ s9 h- m0 J7 I
54. static void AppTaskCreate(void)
    0 B. _& x6 K& J& [0 V2 p1 P
55. {
    
56.         BaseType_t xReturn = pdFAIL;
    - q' ]( ?9 J: y+ `0 p; h
57.         
    
58.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    5 \" P7 Y& J* x# f# f
59.                               (const char *)  "",
    
60.                                                                                                 (uint16_t)      128,
    
61.                                                                                                 (void *)        NULL,
    - }. K4 m6 ]' Z& b6 u& v( Z" Q
62.                                                                                                 (UBaseType_t)   1,
    3 X4 R  ?$ O1 w, r
63.                                                                                                 (TaskHandle_t*) &LedTask_Handle);
    # i% d! z2 C7 c1 o5 N- c
64.   if( xReturn == pdPASS)
    
65.                 f_printf("LED TASK PASS.\r\n");
    $ A" }9 h# l' U5 Z8 `# D- k5 K
66.         
    8 X. [. k) O3 {0 O# O
67.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    7 F+ L/ Z- i* q: ]% o% d
68.                               (const char *)   "",
    . z/ T' e* I; A: ?2 y
69.                                                                                                 (uint16_t )      128,
    ' \1 `$ w: y2 x  e+ M
70.                                                                                                 (void *)         NULL,
    # q! ^6 l* W+ @! H! W% u: b
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);
    
77.         }                                                                                
    $ ], T  m; h$ Y' i1 X+ t
78. }
    + W: s/ U& T9 g7 v/ M! G  o
79. static void KeyTaskCreate(void)
    
80. {
    # J! ^  S+ ?2 J" M
81.   while(1)
    
82.         {
    * y% y! _9 V) s
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    4 o" ~7 ]$ V& E9 h2 D2 H
84.                 {
    " v0 D  r" V! U0 D
85.                         vTaskDelay(40);
    . \) C/ A4 d! N" }2 F
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    
88.                                 xTaskNotify(LedTask_Handle,0x00000001,eSetBits);
    
89.                                 f_printf("PA0.\r\n");
    - E4 S2 x( V' @; V/ |# Y9 ?
90.                         }
    
91.                 }
    
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)
    4 N& ~+ G- `# Q, C, r. Q9 R( x
96.                         {
    
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
      V  S& y  T6 R1 c0 p2 c
98.                                 f_printf("PC12.\r\n");
    
99.                         }
    
100.                 }
     
101.                
     
102.                 vTaskDelay(50);
     
103.         }
     1 L- r7 j; ^+ p! R
104. }
     ( l. [2 V6 s  c8 C( h
105. static void LedTaskCreate(void)
     ; @5 ]! Z# X+ I4 Y
106. {
     
107.         uint32_t ulReturn = 0;
     0 T# X% y; R6 ~+ S% {5 k4 C7 o
108.         BaseType_t xReturn = pdFAIL;
     " b" v3 [+ l3 |6 c# E: X! H
109.         while(1)
     
110.         {
       p5 j: [0 Z' X5 V" m& J
111.                 xReturn = xTaskNotifyWait( 0 , 0x00000003 , &ulReturn, portMAX_DELAY);
     
112.                
     , S; F7 t0 P1 x/ H+ y* P
113.                 if(xReturn == pdTRUE)
     
114.                 {
     
115.                         if( (ulReturn & 0x1)==1)
     * {( p' b  K& x
116.                         {
     
117.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
118.                                 f_printf("LED1.\r\n");
     
119.                         }
     # {& T" P5 N. y+ Q3 V
120.                         else if( (ulReturn & 0x02)==2)
     - B# I7 g* z6 o5 P. |9 r' r5 d
121.                         {
     
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     
124.                         }
     % v" X7 D6 a! L8 {4 M/ j
125.                 }
     : P& q1 J( b% v1 T& j* ], `& g# ?
126.                 else
     
127.                         f_printf("Read Notify FAIL.\r\n");
     5 H- Z1 s% A+ S, P9 ~) s% c
128. 
     
129.                 vTaskDelay(1500);
     ; O0 {( _' @2 r) c$ O1 V0 j
130.         }
     
131. }
     
132. /* USER CODE END 4 */

复制代码

6 c# _; f. D2 h- W  I- i" \代替长度为1的消息队列
在FreeRTOSConfig.h里开启任务通知

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

复制代码

' t! @+ W0 y! u1 a4 ~. Q1 f在main.c文件里面修改代码

4 r5 ^0 F1 w4 y- R

1. /* USER CODE BEGIN Includes */
   . o  C1 ]' A' |  F9 L( b
2. 
   2 \0 v, d  j5 D& a% o
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include <stdio.h>
   
6. #include <string.h>
   0 E* ~) n8 ?* b
7. 
   
8. /* USER CODE END Includes */
   
9. 
   
10. /* USER CODE BEGIN PV */
    
11. static TaskHandle_t AppTask_Handle = NULL;
    
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;
    * R9 s+ r* |( [4 c( Z6 c. D4 P
16. extern int f_printf(const char *format, ...);
    
17. 
    
18. /* USER CODE END PV */
    % J: I' i4 f4 D& H( u: x6 R
19. 
    & i- B( ]$ z8 W4 @
20. /* USER CODE BEGIN PFP */
    
21. static void AppTaskCreate(void);
    
22. static void KeyTaskCreate(void);
    ) w5 {$ V3 o3 v- Z6 n& w
23. static void QueueTaskCreate(void);
    5 V' U. v* \* s1 _: ^6 w& K
24. /* USER CODE END PFP */
    
25. 
    % j" {3 m' M( {. z8 W3 p
26. int main()
    
27. {
    4 o6 m: P  m  s! k
28.   /* USER CODE BEGIN WHILE */
    8 W* i) s/ J$ ?3 f" z- T4 h
29.   BaseType_t xReturn = pdFAIL;
    
30.         
    / F8 A% D+ K- n6 B
31.         xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,
    
32.                               (const char *)   "",
    
33.                                                   (uint16_t)       128,
    
34.                                                   (void *)         NULL,
    
35.                                                   (UBaseType_t)    1,
    
36.                                                   (TaskHandle_t *) &AppTask_Handle);
    
37.                                                                                                 
    
38.   if( xReturn == pdPASS)
    ( X$ Q4 @8 J2 b, E; a; `* Q5 {+ [& r
39.         {
    5 C' I% I0 M. w  M$ C- t7 Q
40.     f_printf("AppTask Start.\r\n");
    
41.                 vTaskStartScheduler();
    ) l7 C- S+ u$ @% ~5 J
42.         }
    * A& S* W+ ^6 L$ A) P" R6 S* n1 ^' s5 P
43.         
    7 ]/ Q! B# Z: X4 l; O% E$ d+ w- v1 b
44.   while (1)
    . G6 |; O4 n; M" i3 P
45.   {
    
46.     /* USER CODE END WHILE */
    
47. 
    4 y, ^+ a( t, J, g  i
48.     /* USER CODE BEGIN 3 */
    
49.   }
      V( W: a! o+ T: V! U# ~
50.   /* USER CODE END 3 */
    4 d; _3 Q4 n( V; ?
51. }
    : \) a) r% h# W8 b: j
52. 
    
53. /* USER CODE BEGIN 4 */
    ) X/ H, w0 ^9 L0 z
54. static void AppTaskCreate(void)
      J! @* ~/ P- m, ?. @0 g
55. {
    / d/ G9 C/ ]! G$ N
56.         BaseType_t xReturn ;
    
57.         
    % l" u# s  X$ p: n1 [+ l/ s: O
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    
59.                          (const char *)  "",
    
60.                                                                                                  (uint16_t)      128,
    
61.                                                                                                  (void *)        NULL,
    
62.                                                                                                  (UBaseType_t)   2,
    , V* d" Y& G: v
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    
64.   if( xReturn ==pdPASS )
      f# e$ _7 l3 r2 [( I5 v( _2 z& j
65.                 f_printf("QueueTask Create PASS.\r\n");
    $ T! `# p/ c1 w4 ?: s4 x$ g
66.         
    
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    3 B, @. j% r+ y8 E) l, l
69.                          (uint16_t)      128,
    
70.                                                                                                  (void *)        NULL,
    ) [' _2 T  e% h+ X/ o4 Q
71.                                                                                                  (UBaseType_t)   1,
    , Q' F% |" r+ l" \
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
      n# ]" T* P) i0 A  r2 s) t
73.   if (xReturn == pdPASS)
    0 m$ r, ?- C: A6 r! e/ Q
74.         {
    
75.           f_printf("KeyTask Create PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    
77.         }
    
78. }
    
79. static void KeyTaskCreate(void)
    * U* H; j) u0 s: [' a
80. {
    
81.         while(1)
    
82.         {
    * A' n  E% H3 J, z: [1 }; J
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    & w8 J4 e# u  R( e! s& T$ ~4 z, I
87.                         {
    
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    * v" K' O' V1 T, d4 Q5 ~/ ^* \0 s
89.                         }
    
90.                 }
    
91.                 vTaskDelay(80);
    
92.         }
    ( |8 j: X2 Z! U$ F6 v0 Q- ~
93. }
    . `: \0 b" }0 E; m; \0 P( m' a* D" f
94. static void QueueTaskCreate(void)
    
95. {
    
96.         while(1)
    : \2 K) v# E; p9 O3 p4 f9 F
97.         {
    % f1 R3 Q9 @9 j, N
98.                 /*work.*/
    
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    ! A3 ?( Y- e' w; i1 e, Q0 j
100.                 f_printf("Message is :%d\r\n",*printf_value);
     ! J: _  H$ R# N2 P* u
101.                 Message=*printf_value;
     
102.                
     8 y7 H" |6 |& V$ n! z0 s$ v
103.                 /*The second method works too*/
     0 j" B$ l: l- x, y6 b: a- _& [
104.         /*
     ' [0 f2 v; C9 j/ x2 V" u& ]1 ^
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     4 e2 G7 m+ b2 j% I. q
106.                 f_printf("Message is :%d\r\n",Message);
     # x+ j( ^# s8 j' e( [7 W9 `
107.         */
     1 r0 w) S( x" y- j* T3 o; V" Z
108.                 Message++;
     
109.                 if(Message > 10)
     3 W& q! \, I# ~! o# @3 h
110.                         Message = 0;
     ' v- r* N5 m" M+ A
111.                 vTaskDelay(1000);
     8 m" Q" W+ x* u- L- ~$ w5 f
112.         }
     
113. }
     ; t/ w7 B! H+ x" C( j7 F
114. /* USER CODE END 4 */

复制代码

4 x- v4 e4 L' o. v