1. 任务创建和删除API函数
2 |6 s' X( ^0 R; zFreeRTOS最基本的功能是任务管理，而任务管理最基本的操作就是创建和删除任务，相关API函数如下：
' E5 Q3 m5 v' b. r* _
8 A# e5 e# u) N' Y6 A
4 V3 j5 g+ g0 q7 G. x- J1.1 函数xTaskCreate()
+ {1 W4 I; G* i0 v此函数用来创建一个任务。
任务需要RAM来保存与任务有关的状态信息（任务控制块），任务也需要一定的RAM来作为任务堆栈。如果使用函数xTaskCreate()来创建任务，那么这些所需的RAM会自动从FreeRTOS的堆中分配，因此必须提供内存管理文件（前章节有说过，默认使用heap_4.c这个内存管理文件），且宏configSUPPORT_DYNAMIC_ALLOCATION必须为1。如果使用函数xTaskCreateStatic()创建，这些RAM需要用户提供。
/ q% {& J1 |0 ^. ]4 B$ A新创建的任务默认是就绪态，如果当前没有比它更高优先级的任务运行，那么此任务就会立即进入运行态开始运行，不管在任务调度器启动前还是启动后，都可以创建任务。
函数原型如下：
" z4 r/ n8 S2 }
  |5 j2 l! a* u( s" _

1. BaseType_t  xTaskCreate(        TaskFunction_t              pxTaskCode,     // 任务函数
   7 l4 \( k8 \) [0 ?' T: p
2.                                                         const char* const          pcName,         // 任务名字，用于追踪和调试，名字长度不能超过configMAX_TASK_NAME_LEN
   & y+ q) Z3 n, o
3.                                                         const unit16_t        usStackDepth,   // 任务堆栈大小，实际申请到的大小是usStackDepth的4倍，其空闲任务堆栈大小为configMINIMAL_STACK_SIZE
   
4.                                                         void* const           pvParameters,   // 传递给任务函数的参数
   
5.                                                         UBaseType_t           uxPriority,     // 任务优先级，0 ~ configMAX_PRIORITIES-1
   
6.                                                         TaskHandle_t *const   pxCreateTask )  // 任务句柄，任务创建后会返回此任务的任务句柄，这个句柄是任务的任务堆栈。此参数用来保存这个任务句柄，其他API函数可能会使用这个句柄

复制代码

返回值： pdPASS: 任务创建成功。
! B  e2 M0 a3 B: W* J- JerrCOULD_NOT_ALLOCATE_REQUIRED_MEMORY: 任务创建失败，因为堆内存不足！

/ D% L9 C$ N' e" G! }/ W1.2 函数xTaskCreateStatic()
此函数也是用来创建任务的。
4 {% F& S* d/ w. W使用此函数创建的任务所需的RAM需要用户来提供。如要使用此函数，将configSUPPORT_STATIC_ALLOCATION定义为1。
函数原型如下：

/ Y. R- a% h0 i  R) I+ j3 j# ^

1. TaskHandle_t xTaskCreateStatic(        TaskFunction_t        pxTaskCode,     // 任务函数
   
2.                                                                 const char * const    pcName,         // 任务名字，用于追踪和调试，名字长度不能超过configMAX_TASK_NAME_LEN
   
3.                                                                 const uint32_t        ulStackDepth,   // 任务堆栈大小，由于是静态方法创建任务，任务堆栈由用户给出，此参数是一个数组的大小。
   
4.                                                                 void * const          pvParameters,   // 传递给任务函数的参数
   # ~/ Z. @8 O7 [0 d; g
5.                                                                 UBaseType_t           uxPriority,     // 任务优先级，0 ~ configMAX_PRIORITIES-1
   7 B  f9 `: A/ H' R4 e
6.                                                                 StackType_t * const   puxStackBuffer, // 任务堆栈，一般为数组，数组类型为StackType_t类型
   ( f5 ^3 K/ Y' C2 ^8 a
7.                                                                 StaticTask_t * const  pxTaskBuffer    )  // 任务控制块

复制代码

返回值：
/ g& u5 f! c0 qNULL: 创建任务失败，puxStackBuffer或pxTaskBuffer为NULL时会导致该错误发生
其他值：创建任务成功，返回任务的任务句柄
6 q# S* l& h3 Y& D. ]2 P
1.3 函数xTaskCreateRestricted()
9 c" g8 k! a. i3 }此函数也是用来创建任务的。
; [5 f4 m$ Z: |此函数要求使用的MCU有MPU（内存保护单元），用此函数创建的任务会受到MPU保护，其他功能和函数xTaskCreate()一样。
# n6 {8 d, q7 j- F( |8 K2 {函数申明如下：
0 S# l2 Y) d, M+ l# p
2 ~$ J7 A: I  h* i+ Q

1. BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )

复制代码

入口参数：
pxTaskDefinition： 指向一个结构体TaskParemeter_t，这个结构体描述了任务的任务函数、堆栈大小、优先级等。在task.h中定义。
& |$ Y( k4 Q6 g: L, @pxCreatedTask：任务句柄
返回值：
& ?0 F3 y5 A; E! A- jpdPASS：任务创建成功
其他值：任务创建失败，很有可能是因为FreeRTOS的堆太小

4 I' [6 l( M4 |- Y4 T! z1.4 函数vTaskDelete()
删除一个用函数xTaskCreate()或xTaskCreateStatic()创建的任务，被删除的任务不再存在，不再进入运行态。任务被删除后不能再使用此任务的句柄，如果此任务是用xTaskCreate()创建的，那么在此任务被删除以后，此任务之前申请的堆栈和控制块内存会在空闲任务中被释放掉，因此调用函数函数vTaskDelete()删除任务以后必须给空闲任务一定的运行时间。
! x: m* G/ |& v+ I: _1 I4 e只有由内核分配给任务的内存才会在任务被删除以后自动的释放掉，用户分配给任务的内存需要用户自行释放掉，比如某个任务中用户调用函数pvPortMalloc()分配了500字节的内存，那么在此任务删除以后用户也必须调用函数vPortFree()将这500字节内存释放掉，否则会导致内存泄漏。
' x: W- M& Q. T4 D3 S函数原型如下：
9 g& |, Q2 ~( j7 t; c: m
2 G% R  G- E, b

1. vTaskDelete( TaskHandle_t  xTaskToDelete )

复制代码

# M0 o- u( k( s' s  c' h& Z7 |2 X入口参数：xTaskToDelete： 要删除的任务的任务句柄
返回值：无
) \( e7 Z5 ^9 b. u
2. 任务创建和删除实验（动态方法）
2.1 实验目的
6 C6 ]! X( C3 S# d  [学习xTaskCreate()和vTaskDelete()这两个函数的用法。
; _* |2 u! W3 B: \- X" Z1 t" n
1 y$ Q1 t4 K; [9 D2.2 实验设计
设计三个任务：
start_task：用来创建其他两个任务；
! u% ^# _1 y- g& @# t& Ptask1_task：此任务运行5次以后会调用vTaskDelete()删除任务task2_task，此任务也会控制LED0闪烁，且周期性刷新LCD指定区背景色；
9 x9 y3 F- t6 T! mtask2_task：此任务为普通的应用任务，控制LED1闪烁，且周期性刷新LCD指定区背景色。
8 l' D2 Q' V# B* o" C- b$ N: C
2.3 硬件
1） 正点原子战舰v3开发板（其他板子应该也可以，主要涉及USART，LED，LCD）；
' V6 n% Y% I' f$ }$ a& w* p6 J# a2） JLINK仿真器。
; L" m5 H% ~2 C! U
2.4 代码解读
如果不考虑usart、led、lcd的函数（不是本章的重点），那么主要的函数都在main.c文件里：

  [5 X$ b  r' m: k9 \9 y

1. #include "sys.h"
   ' H5 t2 A5 |, M$ _4 s. a" d
2. #include "delay.h"
   ; h) O& C. j9 o8 K
3. #include "usart.h"
   
4. #include "led.h"
   : Y5 c9 Z% A+ |
5. #include "timer.h"
     l% Z( x' R- b6 O/ g* J
6. #include "lcd.h"
   
7. #include "FreeRTOS.h"
   
8. #include "task.h"
   
9. #define START_TASK_PRIO                1           // 任务优先级
   ) r3 G% M0 C1 k+ @0 ~
10. #define START_STK_SIZE                 128         // 任务堆栈大小
    
11. TaskHandle_t StartTask_Handler;         // 任务句柄
    9 ]6 o) h# Z$ ]/ _  _* Z9 v$ u
12. void start_task(void *pvParameters);    // 任务函数
    
13. #define TASK1_TASK_PRIO                2           // 任务优先级
    ( W& Y* R! c! w' G- n: ^7 r0 q
14. #define TASK1_STK_SIZE                 128         // 任务堆栈大小
    
15. TaskHandle_t Task1Task_Handler;         // 任务句柄
    & S% D% J8 @$ i7 F; e. E
16. void task1_task(void *pvParameters);    // 任务函数
    $ D# M4 }, K0 F# [) i
17. #define TASK2_TASK_PRIO                3           // 任务优先级
    0 p. F, X! [5 Y. L) b
18. #define TASK2_STK_SIZE                 128         // 任务堆栈大小        
    
19. TaskHandle_t Task2Task_Handler;         // 任务句柄
    
20. void task2_task(void *pvParameters);    // 任务函数
    : N& d  p, R- p) P% G
21. // LCD刷屏时使用的颜色
    * s" I1 Q% S( n
22. int lcd_discolor[14]={WHITE,BLACK,BLUE,BRED,GRED,GBLUE,RED,MAGENTA,GREEN,CYAN,YELLOW,BROWN,BRRED,GRAY };
    
23. // 主函数
    ) o: ~1 g" \( j/ t4 C
24. int main(void)
    7 u) T) y' p$ ]3 h2 Z8 \9 d
25. {
    , J; n/ ?+ e/ o& A8 }+ |
26.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); // 设置系统中断优先级分组4         
    
27.         delay_init();                                                        // 延时函数初始化         
    ( P% g# ^* K0 @1 M( U; K" C
28.         uart_init(115200);                                                    // 初始化串口
    
29.         LED_Init();                                                                      // 初始化LED
    + K1 N, Q& ?7 X7 j. \
30.         LCD_Init();                                                                // 初始化LCD
    ) u( o/ ]* [/ y5 h
31.         POINT_COLOR = RED;
    
32.         LCD_ShowString(30,10,200,16,16,"WarShip v3");        
    + v) Y  G1 B% H- h
33.         LCD_ShowString(30,30,200,16,16,"FreeRTOS");
    
34.         LCD_ShowString(30,50,200,16,16,"Task Creat and Del");
    . w' h: n5 {5 ?* x1 R
35.         LCD_ShowString(30,70,200,16,16,"leisure");
    
36.         LCD_ShowString(30,90,200,16,16,"2021/3/14");
    
37.         // 创建开始任务
    8 b7 `8 V* P( l$ p2 s% C
38.   xTaskCreate(        (TaskFunction_t )start_task,            // 任务函数，调用函数xTaskCreate()创建start_task任务
    
39.                 (const char*    )"start_task",          // 任务名称
    
40.                 (uint16_t       )START_STK_SIZE,        // 任务堆栈大小
    
41.                 (void*          )NULL,                  // 传递给任务函数的参数
    
42.                 (UBaseType_t    )START_TASK_PRIO,       // 任务优先级
    
43.                 (TaskHandle_t*  )&StartTask_Handler);   // 任务句柄              
    
44.   vTaskStartScheduler();                                // 调用 vTaskStartScheduler()开启FreeRTOS任务调度器，FreeRTOS开始运行
    * U8 X8 V7 N4 J& W. W- v0 ^6 N
45. }
    " m# r* n2 g  s- {
46. // 开始任务任务函数
    
47. void start_task(void *pvParameters)      // start_task任务的任务函数，此函数中还创建了另外两个任务，start_task任务职责是用来创建其他任务或信号量、消息队列等，创建完成后就可以删除掉该函数            
    
48. {
    5 T# x! k. ]! n- \) \' x, e
49.         taskENTER_CRITICAL();           // 进入临界区
    
50.   // 创建TASK1任务
    - ^/ [$ z0 B* h: v! ^' l* K
51.         xTaskCreate(  (TaskFunction_t )task1_task,            
    3 f% O' }  N1 w6 x$ _+ F
52.                 (const char*    )"task1_task",           
    
53.                 (uint16_t       )TASK1_STK_SIZE,        
    9 @# K* ]) R: U; v  F
54.                 (void*          )NULL,                  
    
55.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    ! U7 G' o9 e1 B- \) a. Z7 l' M
56.                 (TaskHandle_t*  )&Task1Task_Handler);   
    + w7 {' C1 k8 L* Z3 o
57.         // 创建TASK2任务
    ; E+ y7 b1 r" N! P3 p- `+ F) }' ]/ s
58.         xTaskCreate(        (TaskFunction_t )task2_task,     
      {# U6 n& R" F+ W: f  }+ a
59.                 (const char*    )"task2_task",   
    7 U* v2 W0 E& `+ i( Y0 ?
60.                 (uint16_t       )TASK2_STK_SIZE,
    
61.                 (void*          )NULL,
    - l& g' i3 y* T
62.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
63.                 (TaskHandle_t*  )&Task2Task_Handler);
    
64.         vTaskDelete(StartTask_Handler); // 删除开始任务，函数vTaskDelete()参数就是start_task任务的任务句柄！
    ; r; m8 w! P1 U0 [! z
65.         taskEXIT_CRITICAL();            // 退出临界区
    7 S; G! p' H' }$ ?6 D' {% p
66. }
    % ]+ _6 F2 Y1 R5 l) M
67. // task1任务函数
    
68. void task1_task(void *pvParameters) // task1_task任务函数
      d' H# ]( Q& B
69. {
    # ~2 f! r! ~& f8 D6 {& h" y
70.         u8 task1_num=0;
    & C& ]2 H5 Y4 r3 T% _6 k
71.         POINT_COLOR = BLACK;
    
72.         LCD_DrawRectangle(5,110,115,314);         // 画一个矩形        
    
73.         LCD_DrawLine(5,130,115,130);                // 画线
    - R7 [, M, p: F* M2 z
74.         POINT_COLOR = BLUE;
    
75.         LCD_ShowString(6,111,110,16,16,"Task1 Run:000");
    
76.         while(1)
    2 g5 k9 B. L6 `9 s
77.         {
    9 Y- t' [" J0 z
78.                 task1_num++;        
    $ ]2 z) O) b- d4 j. z
79.                 LED0=!LED0;
    
80.                 printf("任务1已经执行：%d次\r\n",task1_num);
    9 {, ]; V7 x+ s: [8 q; O3 \
81.                 if(task1_num==5)
    0 H  e+ [: `- Z2 v% m, K8 }
82.                 {
    
83.                         vTaskDelete(Task2Task_Handler); // 任务1执行5次删除任务2
    
84.                         printf("任务1删除了任务2!\r\n");
    ; [! b: d4 G: |2 m4 m+ `. F' E
85.                 }
    " A  _" S% |1 f
86.                 LCD_Fill(6,131,114,313,lcd_discolor[task1_num%14]); // 填充区域
    
87.                 LCD_ShowxNum(86,111,task1_num,3,16,0x80);                // 显示任务执行次数
    
88.                 vTaskDelay(1000);                                   // 延时1s，也就是1000个时钟节拍        
    . X# u: H" l  @
89.         }
    9 x$ ?" Q+ N5 C% h! j6 y4 h
90. }
    - S4 y) l/ N3 P  B
91. // task2任务函数
    
92. void task2_task(void *pvParameters)
    
93. {
    & N: e& G9 `4 d7 b, S) I9 W
94.         u8 task2_num=0;
    8 U- N; [: a7 U7 x
95.         POINT_COLOR = BLACK;
    
96.         LCD_DrawRectangle(125,110,234,314); // 画一个矩形        
    
97.         LCD_DrawLine(125,130,234,130);                // 画线
    
98.         POINT_COLOR = BLUE;
    & d0 f3 C+ _: b2 ]& y
99.         LCD_ShowString(126,111,110,16,16,"Task2 Run:000");
    
100.         while(1)
     . E7 r$ W. I" d0 d; N7 w9 L
101.         {
     
102.                 task2_num++;        
     0 U% [8 P/ C/ o: j
103.                 LED1=!LED1;
     
104.                 printf("任务2已经执行：%d次\r\n",task2_num);
     % t, t7 [- a5 ~! M8 y/ F3 U
105.                 LCD_ShowxNum(206,111,task2_num,3,16,0x80);               // 显示任务执行次数
     1 K! {* r6 a5 ~( U/ n
106.                 LCD_Fill(126,131,233,313,lcd_discolor[13-task2_num%14]); // 填充区域
     
107.     vTaskDelay(1000);                                            // 延时1s，也就是1000个时钟节拍        
     
108.         }
     
109. }

复制代码

( e, w$ F( U$ y+ R& t前面也说了，主要的函数都在main.c文件里，因为本例程里面的任务数量少，如果后期工程较大，建议将任务有关的东西，如任务堆栈、任务句柄、任务函数申明等放到一个专用的头文件里，这样方便管理。

2.5 实验结果
% E& M0 z* Y4 g


7 r. ^0 F" e% L) w( }1 s  K# q
2 a9 K" l( i1 {9 r
如上图所示，当task1运行5次以内时，task1和task2运行次数一样，当task1运行大于5次时，task2在运行第5次时被task1删除任务了，因此数值不再更新！串口调试助手上实验结果如下所示：

" ^( y# J, Y' ]7 K9 G
3 u7 S; N" G  p5 v9 V
4 ]0 R. X7 J9 G0 U上图中，我们还可以知道一件事：一开始任务1和任务2是同时运行的，但任务2的优先级比任务1高，所以先输出任务2的信息，再输出任务1的信息。当任务1运行5次后删除任务2，之后只剩下任务1在运行。

' U+ ~' J1 x  Q& @1 K8 V3. 任务创建和删除实验（静态方法）
3.1 实验目的
学习xTaskCreateStatic()函数用法，本次任务的堆栈、任务控制块由用户来指定。
. D7 w* K# s1 z! u& f4 l4 e
3.2 实验设计
参考上面的实验设计。
) ~0 r4 g4 Q# }  z" |* c
+ s& H. }$ j+ Y3.3 硬件
参考上面的硬件。
. p' n! a. D8 ?( [, x0 K* p: F) n
, h- x2 P+ \. k$ D6 P% E5 s" F7 Z3.4 系统配置
0 U4 X5 y; x! P使用静态方法创建任务的时候需要将宏configSUPPORT_STATIC_ALLOCATION设置为1，同时使用静态方法的话需要用户实现两个函数vApplicationGetIdleTaskMemory()和vApplicationGetTimerTaskMemory()。通过这两个函数来给空闲任务和定时器服务任务的任务堆栈和任务控制块分配内存，这两个函数本案例在main.c文件里定义。
! @4 C9 t4 ^2 y9 W
* m$ p6 \& _  [1 y3 x/ v5 D/ I3.5 main.c文件代码解读

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   + E2 K) {: q% i. j+ `8 [, k8 m
4. #include "led.h"
   
5. #include "timer.h"
   
6. #include "timer.h"
   
7. #include "lcd.h"
   
8. #include "FreeRTOS.h"
   ' A1 l( H" c, Z3 l3 d
9. #include "task.h"
   
10. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];      // 空闲任务任务堆栈
    1 {' ~8 p( _7 G
11. static StaticTask_t IdleTaskTCB;                                 // 空闲任务控制块
    ) ]* ^& t7 b6 w2 S
12. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH]; // 定时器服务任务堆栈
    
13. static StaticTask_t TimerTaskTCB;                                // 定时器服务任务控制块
    7 C+ ]0 o9 l4 o( g
14. #define START_TASK_PRIO                1                 // 任务优先级
    ( C8 U/ }7 ~: h. b8 R# ~
15. #define START_STK_SIZE                 128               // 任务堆栈大小        
    : K1 p# m+ A* Q  A8 ~- P' S
16. StackType_t StartTaskStack[START_STK_SIZE];   // 任务堆栈，静态创建任务需要提供任务堆栈，这里定义一个数组为任务堆栈，为StackType_t类型
    2 ?$ S+ y0 p4 a/ C
17. StaticTask_t StartTaskTCB;                    // 任务控制块，类型为StaticTask_t！
    
18. TaskHandle_t StartTask_Handler;               // 任务句柄
    2 D: B8 U( O0 }( |2 ^
19. void start_task(void *pvParameters);          // 任务函数
    
20. #define TASK1_TASK_PRIO                2                 // 任务优先级
    ( V; L  o0 x5 c
21. #define TASK1_STK_SIZE                 128               // 任务堆栈大小        
    ' R6 }7 ]& o) @0 C2 P: {
22. StackType_t Task1TaskStack[TASK1_STK_SIZE];   // 任务堆栈
    0 W2 o1 v# W" S  M' [. i
23. StaticTask_t Task1TaskTCB;                    // 任务控制块
    
24. TaskHandle_t Task1Task_Handler;               // 任务句柄
    
25. void task1_task(void *pvParameters);          // 任务函数
    
26. #define TASK2_TASK_PRIO                3                 // 任务优先级
    
27. #define TASK2_STK_SIZE                 128               // 任务堆栈大小
    ; p8 M9 ^& z8 d  \" \
28. StackType_t Task2TaskStack[TASK2_STK_SIZE];   // 任务堆栈
    
29. StaticTask_t Task2TaskTCB;                    // 任务控制块
    , C4 B- ~. w2 z2 `. O' Q
30. TaskHandle_t Task2Task_Handler;               // 任务句柄
    , U- ~3 a: Z5 ?3 j( Z
31. void task2_task(void *pvParameters);          // 任务函数
    
32. // LCD刷屏时使用的颜色
      S1 `9 A4 j' u) Q9 P, o' y
33. int lcd_discolor[14]={WHITE,BLACK,BLUE,BRED,GRED,GBLUE,RED,MAGENTA,GREEN,CYAN,YELLOW,BROWN,BRRED,GRAY};
    , u# A4 O, T" o
34. /* 获取空闲任务地任务堆栈和任务控制块内存，因为本例程使用的静态内存，因此空闲任务的任务堆栈和任务控制块的内存就应该由用户来提供，
    
35.    FreeRTOS提供了接口函数vApplicationGetIdleTaskMemory()实现此函数即可。
    5 o; Q$ v2 q! p1 ?
36.    ppxIdleTaskTCBBuffer:任务控制块内存
    
37.    ppxIdleTaskStackBuffer:任务堆栈内存
    
38.    pulIdleTaskStackSize:任务堆栈大小    */
    
39. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize)
    
40. {
    / o% W# o- Q/ [4 l2 p8 L1 `$ i
41.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
42.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    : @7 J' p" B+ \9 U' {) ^
43.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    4 S0 e  g, }$ w% ^& [9 `5 x
44. }
    6 {% i% H5 p3 E! g( d6 I" X
45. /* 获取定时器服务任务的任务堆栈和任务控制块内存
    
46.    ppxTimerTaskTCBBuffer:任务控制块内存
    0 Q0 y2 y& O0 A) s: X6 x
47.    ppxTimerTaskStackBuffer:任务堆栈内存
    
48.    pulTimerTaskStackSize:任务堆栈大小   */
    
49. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize)
    
50. {
    
51.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    $ }$ A5 r% T5 m) K1 O( C# e  [. [5 b9 u
52.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
53.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    2 Q6 T; w; y. ~1 k' [
54. }
    8 K. h) e, c0 d  r% X7 W9 l: e
55. // 主函数
    
56. int main(void)
    % x' p. ]6 |7 _3 n. R
57. {
    + N% g( Y6 N9 g& z* Z9 }' d
58.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); // 设置系统中断优先级分组4         
    3 A: _. g# v7 S* G0 ]. D, U
59.         delay_init();                                                        // 延时函数初始化         
    8 _! I6 |9 {! h7 E
60.         uart_init(115200);                                                    // 初始化串口
    7 s" X/ N  n' C& J* _  |" J6 c
61.         LED_Init();                                                                      // 初始化LED
    & I6 ^4 A  @+ @& Z
62.         LCD_Init();                                                                    // 初始化LCD
    
63.     POINT_COLOR = RED;
    2 X1 p% C# @& c9 X! b2 g
64.         LCD_ShowString(30,10,200,16,16,"WarShip v3");        
    
65.         LCD_ShowString(30,30,200,16,16,"FreeRTOS");
    
66.         LCD_ShowString(30,50,200,16,16,"Task Creat and Del");
    $ U1 Y6 A3 J4 W( w9 G
67.         LCD_ShowString(30,70,200,16,16,"leisure");
    
68.         LCD_ShowString(30,90,200,16,16,"2021/3/14");
    . [/ j' ^7 K- G8 D
69.     // 创建开始任务
    
70.         StartTask_Handler=xTaskCreateStatic((TaskFunction_t        )start_task,                // 任务函数，调用xTaskCreateStatic()函数创建任务
      G8 Y' J7 D* p: R2 u: x' K
71.                                                                                 (const char*         )"start_task",                // 任务名称
    5 a' [1 l' X+ X
72.                                                                                 (uint32_t                 )START_STK_SIZE,        // 任务堆栈大小
    
73.                                                                                 (void*                           )NULL,                                // 传递给任务函数的参数
    
74.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
    / C! c% J5 T' B4 d2 U/ R
75.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈，将定义的任务堆栈数组传递给函数
    , g, Z& ^7 {/ h( B7 W! s& J
76.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块，将定义的任务控制块传递给函数              
    
77.     vTaskStartScheduler();                                                  // 开启任务调度
    
78. }
    
79. // 开始任务任务函数
    
80. void start_task(void *pvParameters)
    " {, w: U: u) e, l2 Y1 T' u9 t
81. {
    
82.         taskENTER_CRITICAL();           // 进入临界区
    
83.   // 创建TASK1任务
    * z0 _0 G; |% W3 R$ R' T3 d
84.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
    
85.                                                                                 (const char*         )"task1_task",               
    2 f0 t7 b+ Q; N
86.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
    9 U) [' p4 k1 b0 B* {8 C
87.                                                                                 (void*                           )NULL,                                
    
88.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
    ' D2 r0 H- [. m2 o
89.                                                                                 (StackType_t*   )Task1TaskStack,        
    
90.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
    : q' d- b$ X2 T; q0 N& P9 ?9 m
91.   // 创建TASK2任务
    
92.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
    $ s# h& P% J" ]% M, X
93.                                                                                 (const char*         )"task2_task",               
    0 h) P" u$ f! `" j7 N8 k
94.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
    2 B! |  V: `9 @
95.                                                                                 (void*                           )NULL,                                
    
96.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
    
97.                                                                                 (StackType_t*   )Task2TaskStack,        
    
98.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
    ; F' H5 S! z1 d# c* g" G( n6 G
99.     vTaskDelete(StartTask_Handler); // 删除开始任务
    
100.     taskEXIT_CRITICAL();            // 退出临界区
     : T3 }" }5 C* t; Z2 q! i" L2 g- p) n
101. }
     
102. // task1任务函数
     
103. void task1_task(void *pvParameters)
     
104. {
     6 w1 @# G" v7 x: M* {2 z/ N) r
105.         u8 task1_num=0;        
     
106.         POINT_COLOR = BLACK;
     1 a2 w1 P6 x, ]$ |- }" T9 o
107.         LCD_DrawRectangle(5,110,115,314);         // 画一个矩形        
       T3 U' ^( V3 X5 S" {# R
108.         LCD_DrawLine(5,130,115,130);                // 画线
     % F' N0 H1 X2 c' m' ^( B8 }
109.         POINT_COLOR = BLUE;
     
110.         LCD_ShowString(6,111,110,16,16,"Task1 Run:000");
     
111.         while(1)
     : h+ T6 q) v3 `/ o# G" y
112.         {
     0 L( X& |' c5 T
113.                 task1_num++;        
     6 W6 A5 n3 @  a
114.                 LED0=!LED0;
     
115.                 printf("任务1已经执行：%d次\r\n",task1_num);
     , Z9 y/ L) P1 _1 v
116.                 if(task1_num==5)
     ' q2 o8 O: L; f( i+ |
117.                 {
     & L: W% G* \1 S1 ~
118.             vTaskDelete(Task2Task_Handler);
     
119.                         printf("任务1删除了任务2!\r\n");
     6 c& i! F7 t" i7 m
120.                 }
     0 B; p% h; }* a* M
121.                 LCD_Fill(6,131,114,313,lcd_discolor[task1_num%14]);   // 填充区域
     " B% n/ b6 H/ x7 N- O2 B+ ?
122.                 LCD_ShowxNum(86,111,task1_num,3,16,0x80);                  // 显示任务执行次数
     5 E4 R$ [; |( o, q* T, n. U5 w
123.         vTaskDelay(1000);                                     // 延时1s，也就是1000个时钟节拍        
     3 {3 S& F: u" c0 J; [6 _
124.         }
     8 y7 z/ ~5 b, e0 ~
125. }
     
126. // task2任务函数
     
127. void task2_task(void *pvParameters)
     0 C9 [4 X6 h$ j" _( x4 F. Z
128. {
     
129.         u8 task2_num=0;
     , ~7 H1 h3 i; I& A* U: V3 N
130.         POINT_COLOR = BLACK;
     
131.         LCD_DrawRectangle(125,110,234,314);   //画一个矩形        
     
132.         LCD_DrawLine(125,130,234,130);                  // 画线
     
133.         POINT_COLOR = BLUE;
     
134.         LCD_ShowString(126,111,110,16,16,"Task2 Run:000");
     
135.         while(1)
     5 q1 Z8 Q$ F) a& z
136.         {
     
137.                 task2_num++;        
     6 ]. S! w/ {6 r) b( P' Z
138.         LED1=!LED1;
     
139.                 printf("任务2已经执行：%d次\r\n",task2_num);
     
140.                 LCD_ShowxNum(206,111,task2_num,3,16,0x80);               // 显示任务执行次数
     % J1 f4 t. K2 @7 H, U$ d
141.                 LCD_Fill(126,131,233,313,lcd_discolor[13-task2_num%14]); // 填充区域
     / p- e( w( j. Y$ D( z$ P! x! d% J
142.         vTaskDelay(1000);                                        // 延时1s，也就是1000个时钟节拍        
     
143.         }
     5 W' [, Q5 @0 u, y$ m
144. }

复制代码

main.c文件里的函数vApplicationGetIdleTaskMemory()和vApplicationGetTimerTaskMemory()不是很复杂，用户定义静态的任务堆栈和任务控制块内存，然后将这些内存传递给函数参数。最后创建空闲任务和定时器服务任务的API函数会调用这两个函数来获取内存。
6 |, x8 F9 W1 c' ^+ c% \$ W
6 V+ Z& h' a7 I) D/ B/ ?3.6 实验结果
' }: H# @0 T9 E& y) K6 X1 ?实验结果与任务创建和删除实验（动态方法）的实验结果一样。
0 A" }6 J' t" [- G) X3 \————————————————
版权声明：天亮继续睡
2 I7 W0 t- j& y& j

' C! j9 S7 Z  P) c; \% K