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

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

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

2.直接覆盖通知值

3.设置通知值一个或者多个位，当做事件组来使用

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

        有以下缺点：

1.只能有一个任务接收通知消息

2.只有等待通知的任务可以被阻塞，发送通知的任务都不会因为发送失败而进入阻塞。

代替二值信号量
在FreeRTOSConfig.h里开启任务通知

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

复制代码

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

1. /* USER CODE BEGIN Includes */
   
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;
    
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 */
    
19. static void AppTaskCreate(void);
    
20. static void KeyTaskCreate(void);
    
21. static void LedTaskCreate(void);
    
22. /* USER CODE END PFP */
    
23. 
    
24. int main()
    
25. {
    
26. 
    
27.   /* USER CODE BEGIN WHILE */
    
28.   BaseType_t xReturn = pdFAIL;
    
29.         
    
30.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
31.                         (const char*)   "APPTASKCREATE",
    
32.                         (uint16_t)      128,
    
33.                         (void *)        NULL,
    
34.                         (UBaseType_t)   1 ,
    
35.                         (TaskHandle_t*) &AppTask_Handle);
    
36.         
    
37.   if(xReturn == pdPASS)
    
38.         {
    
39.     f_printf("AppTask Create PASS.\r\n");
    
40.                 vTaskStartScheduler();
    
41.         }
    
42.                                                                                                 
    
43.   while (1)
    
44.   {
    
45.     /* USER CODE END WHILE */
    
46.     /* USER CODE BEGIN 3 */
    
47.   }
    
48.   /* USER CODE END 3 */
    
49. }
    
50. 
    
51. /* USER CODE BEGIN 4 */
    
52. static void AppTaskCreate(void)
    
53. {
    
54.   BaseType_t xReturn = pdFAIL;
    
55. 
    
56.         xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
57.                         (const char *)  "LEDTASKCREATE",
    
58.                         (uint16_t)      128,
    
59.                         (void *)        NULL,
    
60.   /*If the priority here is the same as the key task, printf will not print it out.        */
    
61.                         (UBaseType_t)   2,      
    
62.                         (TaskHandle_t *)&LedTask_Handle);
    
63.   if(xReturn == pdPASS)
    
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,
    
70.                         (UBaseType_t)   1,
    
71.                         (TaskHandle_t *)&KeyTask_Handle);
    
72.   if(xReturn == pdPASS)
    
73.         {
    
74.                 f_printf("KeyTask Create PASS.\r\n");
    
75.     vTaskDelete(AppTask_Handle);
    
76.         }
    
77. 
    
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.           {
    
85.       vTaskDelay(50);
    
86.       if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                   {
    
88.         xTaskNotifyGive(LedTask_Handle);
    
89.                           f_printf("Give LedTask_Handle PASS.\r\n");
    
90.                   }
    
91.           }
    
92.           vTaskDelay(100);
    
93.   }
    
94. }
    
95. static void LedTaskCreate(void)
    
96. {
    
97.         uint32_t ulreturn=0;
    
98.         while(1)
    
99.         {
    
100.                
     
101.     ulreturn=ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
     
102.                 if(ulreturn==1)
     
103.                 {
     
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);
     
107.                         
     
108.                 }
     
109.                 else
     
110.                         f_printf("LedTask TAKE FAIL.\r\n");
     
111.     vTaskDelay(100);
     
112.   }
     
113. }
     
114. /* USER CODE END 4 */
     
115. 代替计数信号量
     
116. 在FreeRTOSConfig.h里开启任务通知
     
117. 
     
118. /*Turn on task notifications.*/
     
119. #define configUSE_TASK_NOTIFICATIONS      1
     
120. 在main.c文件里面修改代码
     
121. 
     
122. /* USER CODE BEGIN Includes */
     
123. 
     
124. #include "FreeRTOS.h"
     
125. #include "task.h"
     
126. #include <stdio.h>
     
127. #include <string.h>
     
128. 
     
129. /* USER CODE END Includes */
     
130. 
     
131. /* USER CODE BEGIN PV */
     
132. static TaskHandle_t AppTask_Handle = NULL;
     
133. static TaskHandle_t KeyTask_Handle = NULL;
     
134. static TaskHandle_t LedTask_Handle = NULL;
     
135. 
     
136. extern int f_printf(const char *format, ...);
     
137. 
     
138. /* USER CODE END PV */
     
139. 
     
140. /* USER CODE BEGIN PFP */
     
141. static void AppTaskCreate(void);
     
142. static void KeyTaskCreate(void);
     
143. static void LedTaskCreate(void);
     
144. /* USER CODE END PFP */
     
145. 
     
146. int main()
     
147. {
     
148.   /* USER CODE BEGIN WHILE */
     
149.   BaseType_t xReturn = pdFAIL;        
     
150. 
     
151.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
     
152.                         (const char *)  "APPTASKCREATE",
     
153.                         (uint16_t)      128,
     
154.                         (void *)        NULL,
     
155.                         (UBaseType_t)   1,
     
156.                         (TaskHandle_t*) &AppTask_Handle);
     
157. 
     
158.   if(xReturn == pdPASS)
     
159.         {
     
160.     f_printf("AppTask Create PASS.\r\n");
     
161.     vTaskStartScheduler();
     
162.         }
     
163.   while (1)
     
164.   {
     
165.     /* USER CODE END WHILE */
     
166. 
     
167.     /* USER CODE BEGIN 3 */
     
168.   }
     
169.   /* USER CODE END 3 */
     
170. }
     
171. 
     
172. 
     
173. /* USER CODE BEGIN 4 */
     
174. static void AppTaskCreate(void)
     
175. {
     
176.         BaseType_t xReturn = pdFAIL;
     
177. 
     
178.   xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
     
179.                         (const char *)  "LEDTASKCREATE",
     
180.                         (uint16_t)      128,
     
181.                         (void*)         NULL,
     
182.                         (UBaseType_t)   1,
     
183.                         (TaskHandle_t *)&LedTask_Handle);
     
184.   if( xReturn == pdPASS)
     
185.           f_printf("LED Task Create PASS.\r\n");
     
186.         
     
187.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
     
188.                         (const char *)  "KEYTASKCREATE",
     
189.                         (uint16_t )     128,
     
190.                         (void *)        NULL,
     
191.                         (UBaseType_t)   2,
     
192.                         (TaskHandle_t *)&KeyTask_Handle);
     
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)
     
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))
     
207.                         {
     
208.                                 xTaskNotifyGive(LedTask_Handle);
     
209.                                 f_printf("LED TASK GIVE PASS.\r\n");
     
210.                         }
     
211.                 }
     
212.     vTaskDelay(40);
     
213.         }
     
214.                
     
215. }
     
216. static void LedTaskCreate(void)
     
217. {
     
218.         uint32_t ulValue = 0 ;
     
219.         while(1)
     
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
     
225.          */
     
226.                 if(ulValue >0)
     
227.                 {
     
228.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
229.                         f_printf("LED Task PASS.\r\n");
     
230.                 }               
     
231.                 vTaskDelay(1500);
     
232.         }
     
233. }
     
234. 
     
235. /* USER CODE END 4 */

复制代码

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

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

复制代码

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

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. 
   
6. #include <stdio.h>
   
7. #include <string.h>
   
8. 
   
9. /* USER CODE END Includes */
   
10. 
    
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTask_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t LedTask_Handle = NULL;
    
15. 
    
16. extern int f_printf(const char *format, ...);
    
17. /* USER CODE END PV */
    
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()
    
28. {
    
29.   /* USER CODE BEGIN WHILE */
    
30.   BaseType_t xReturn = pdFAIL;
    
31.         
    
32.   xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
33.                             (const char *)  "",
    
34.                                                 (uint16_t)      128,
    
35.                                                 (void *)        NULL,
    
36.                                                 (UBaseType_t)  1,
    
37.                                                 (TaskHandle_t *)&AppTask_Handle);
    
38.         if( xReturn == pdPASS)
    
39.         {
    
40.                 f_printf("APP Task Start.\r\n");
    
41.                 vTaskStartScheduler();
    
42.         }
    
43. 
    
44.   while (1)
    
45.   {
    
46.     /* USER CODE END WHILE */
    
47. 
    
48.     /* USER CODE BEGIN 3 */
    
49.   }
    
50.   /* USER CODE END 3 */
    
51. }
    
52. 
    
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    
55. {
    
56.         BaseType_t xReturn = pdFAIL;
    
57.         
    
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,
    
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.         }                                                                                
    
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    
81.   while(1)
    
82.         {
    
83.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
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.                         }
    
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)
    
96.                         {
    
97.                                 xTaskNotify(LedTask_Handle,0x00000002,eSetBits);
    
98.                                 f_printf("PC12.\r\n");
    
99.                         }
    
100.                 }
     
101.                
     
102.                 vTaskDelay(50);
     
103.         }
     
104. }
     
105. static void LedTaskCreate(void)
     
106. {
     
107.         uint32_t ulReturn = 0;
     
108.         BaseType_t xReturn = pdFAIL;
     
109.         while(1)
     
110.         {
     
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");
     
119.                         }
     
120.                         else if( (ulReturn & 0x02)==2)
     
121.                         {
     
122.                                 HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
123.                                 f_printf("LED2.\r\n");
     
124.                         }
     
125.                 }
     
126.                 else
     
127.                         f_printf("Read Notify FAIL.\r\n");
     
128. 
     
129.                 vTaskDelay(1500);
     
130.         }
     
131. }
     
132. /* USER CODE END 4 */

复制代码

代替长度为1的消息队列
在FreeRTOSConfig.h里开启任务通知

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

复制代码

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

1. /* USER CODE BEGIN Includes */
   
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;
    
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;
    
16. extern int f_printf(const char *format, ...);
    
17. 
    
18. /* USER CODE END PV */
    
19. 
    
20. /* USER CODE BEGIN PFP */
    
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 */
    
29.   BaseType_t xReturn = pdFAIL;
    
30.         
    
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)
    
39.         {
    
40.     f_printf("AppTask Start.\r\n");
    
41.                 vTaskStartScheduler();
    
42.         }
    
43.         
    
44.   while (1)
    
45.   {
    
46.     /* USER CODE END WHILE */
    
47. 
    
48.     /* USER CODE BEGIN 3 */
    
49.   }
    
50.   /* USER CODE END 3 */
    
51. }
    
52. 
    
53. /* USER CODE BEGIN 4 */
    
54. static void AppTaskCreate(void)
    
55. {
    
56.         BaseType_t xReturn ;
    
57.         
    
58.         xReturn = xTaskCreate( (TaskFunction_t)QueueTaskCreate,
    
59.                          (const char *)  "",
    
60.                                                                                                  (uint16_t)      128,
    
61.                                                                                                  (void *)        NULL,
    
62.                                                                                                  (UBaseType_t)   2,
    
63.                                                                                                  (TaskHandle_t *)&QueueTask_Handle);
    
64.   if( xReturn ==pdPASS )
    
65.                 f_printf("QueueTask Create PASS.\r\n");
    
66.         
    
67.         xReturn = xTaskCreate( (TaskFunction_t)KeyTaskCreate,
    
68.                          (const char *)  "",
    
69.                          (uint16_t)      128,
    
70.                                                                                                  (void *)        NULL,
    
71.                                                                                                  (UBaseType_t)   1,
    
72.                                                                                                  (TaskHandle_t *)&KeyTask_Handle);
    
73.   if (xReturn == pdPASS)
    
74.         {
    
75.           f_printf("KeyTask Create PASS.\r\n");
    
76.                 vTaskDelete(AppTask_Handle);
    
77.         }
    
78. }
    
79. static void KeyTaskCreate(void)
    
80. {
    
81.         while(1)
    
82.         {
    
83.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
84.                 {
    
85.                         vTaskDelay(80);
    
86.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
87.                         {
    
88.                                 xTaskNotify(QueueTask_Handle, (uint32_t)Message, eSetValueWithOverwrite);
    
89.                         }
    
90.                 }
    
91.                 vTaskDelay(80);
    
92.         }
    
93. }
    
94. static void QueueTaskCreate(void)
    
95. {
    
96.         while(1)
    
97.         {
    
98.                 /*work.*/
    
99.                 xTaskNotifyWait(0, 0xFFFFFFFF, printf_value, portMAX_DELAY);
    
100.                 f_printf("Message is :%d\r\n",*printf_value);
     
101.                 Message=*printf_value;
     
102.                
     
103.                 /*The second method works too*/
     
104.         /*
     
105.                 xTaskNotifyWait(0, 0xFFFFFFFF, &Message, portMAX_DELAY);
     
106.                 f_printf("Message is :%d\r\n",Message);
     
107.         */
     
108.                 Message++;
     
109.                 if(Message > 10)
     
110.                         Message = 0;
     
111.                 vTaskDelay(1000);
     
112.         }
     
113. }
     
114. /* USER CODE END 4 */

复制代码