1. 实验目的
" y5 o8 V) r% f/ U列表和列表项实验演练。
  M# Y* Z% |9 l/ @
2. 实验设计
' D; }9 `: T; u0 J" H$ B! Q本实验设计3个任务：
start_task：用来创建其他2个任务；
task1_task：应用任务1，控制LED灯闪烁，提示系统正常运行；
; ^/ G2 |9 @) j8 M* P7 }list_task：列表和列表项操作任务，调用列表和列表项相关API函数，通过串口输出相应信息观察这些API函数的运行过程。
4 T* W2 {# a' E% V本实验需要用到按键，用于控制任务的运行。
' l0 J/ Q- t/ P
3. 硬件
1） 正点原子战舰v3开发板（其他板子应该也可以，主要涉及USART，LED，KEY）；
2） JLINK仿真器。

+ Y! F* y. V" Z: [! J$ E4. 代码解读
如果不考虑usart、led、key的函数（不是本章的重点），那么主要的函数都在main.c文件里：

2 _7 E4 G2 Q! z4 P, @% x

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   / |- c4 {/ R6 S+ p, _4 c' C
5. #include "timer.h"
   
6. #include "timer.h"
   % w- a1 o' C$ b& r/ A& v, f" D4 V6 w8 z
7. #include "key.h"
   
8. #include "exti.h"
   
9. #include "FreeRTOS.h"
   1 u) I; ^; u$ c* R; a- L& Y
10. #include "task.h"
    " u% P$ c+ u8 c5 j8 @
11. // 开始任务
    
12. #define START_TASK_PRIO  1           // 任务优先级
    
13. #define START_STK_SIZE   128         // 任务堆栈大小
    - g/ j( b+ M, k+ b  k  n) F5 V/ T
14. TaskHandle_t StartTask_Handler;      // 任务句柄
    
15. void start_task(void *pvParameters); // 任务函数
    6 h& m5 e# V+ x5 y0 m$ i, j8 q
16. // 应用任务1
    ' U! w3 e5 t' W5 L) ?) e
17. #define TASK1_TASK_PRIO  2           // 任务优先级
    * x2 r$ h' q+ P/ ^$ }
18. #define TASK1_STK_SIZE   128         // 任务堆栈大小
    
19. TaskHandle_t Task1Task_Handler;      // 任务句柄
    * h$ n0 a/ M  {
20. void task1_task(void *pvParameters); // 任务函数
    
21. // 列表任务
    + w, u4 @6 I( S* F! q
22. #define LIST_TASK_PRIO  3            // 任务优先级
    - r4 Q0 }) W) ~0 |! I1 v
23. #define LIST_STK_SIZE   128          // 任务堆栈大小
    # ^) ]0 c' t; t9 _* V
24. TaskHandle_t ListTask_Handler;       // 任务句柄
    - H0 N, P, D& t* E1 `! K
25. void list_task(void *pvParameters);  // 任务函数
    
26. // 定义一个测试用的列表和3个列表项
    1 D( r* \% @% i5 A9 v: y, j
27. List_t TestList;      // 测试用列表
    2 s3 o% U3 h4 x) q
28. ListItem_t ListItem1; // 测试用列表项1
    6 d0 J& ~- I3 m1 e! N6 ?
29. ListItem_t ListItem2; // 测试用列表项2
    * W* W- X& F- Q( Q4 T& ?
30. ListItem_t ListItem3; // 测试用列表项3
    
31. // 主函数
    
32. int main(void)
    ( n# A  p. c0 Q1 X8 g
33. {
    
34. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);  // 设置系统中断优先级分组4  
    
35. delay_init();                                    // 延时函数初始化  
    9 r! g# C; K% [
36. uart_init(115200);                               // 初始化串口
    9 u# x* \/ ^3 f0 X
37. LED_Init();                                      // 初始化LED
    4 }7 s4 f) x3 }/ s( k8 ?0 N
38. KEY_Init();                                      // 初始化按键
    
39. // 创建开始任务
    
40. xTaskCreate(   (TaskFunction_t )start_task,            // 任务函数
    : C) E  E5 Q! G
41.                 (const char*    )"start_task",          // 任务名称
    
42.                 (uint16_t       )START_STK_SIZE,        // 任务堆栈大小
    
43.                 (void*          )NULL,                  // 传递给任务函数的参数
    
44.                 (UBaseType_t    )START_TASK_PRIO,       // 任务优先级
    6 k4 K$ v& V' r9 {% G. h
45.                 (TaskHandle_t*  )&StartTask_Handler);   // 任务句柄              
    
46. vTaskStartScheduler();                                 // 开启任务调度
    
47. }
    
48. // 开始任务任务函数
    : \! P* o; O. o  }/ `) e
49. void start_task(void *pvParameters)
    
50. {
    + Y% C8 f8 E' a
51.   taskENTER_CRITICAL();           // 进入临界区
    0 ]6 Q* I, T, _4 z: b
52.   // 创建TASK1任务
    , L* M/ f+ T: G- m% B3 s4 h
53.   xTaskCreate(  (TaskFunction_t )task1_task,            
    
54.                 (const char*    )"task1_task",           
    
55.                 (uint16_t       )TASK1_STK_SIZE,        
    
56.                 (void*          )NULL,                  
    ' _3 [6 G, _5 c& |- Y
57.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    ) `# c/ G( \# @. Q4 \: p
58.                 (TaskHandle_t*  )&Task1Task_Handler);   
    
59.   // 创建LIST任务
    
60.   xTaskCreate(  (TaskFunction_t )list_task,     
    * q7 v) `1 @+ E6 H0 u* {; a) @' D
61.                 (const char*    )"list_task",   
    0 U  g& v6 v% c9 y6 }
62.                 (uint16_t       )LIST_STK_SIZE,
    
63.                 (void*          )NULL,
    
64.                 (UBaseType_t    )LIST_TASK_PRIO,
      z8 t  A% G6 s  c. o+ ?
65.                 (TaskHandle_t*  )&ListTask_Handler);
    6 ~5 \+ b* {0 g; U& k: A( g
66.   vTaskDelete(StartTask_Handler); // 删除开始任务
    
67.   taskEXIT_CRITICAL();            // 退出临界区
    4 x" u3 r; j2 }  u- J
68. }
    
69. // task1任务函数
    
70. void task1_task(void *pvParameters)
    
71. {
    
72. while(1)
    5 @4 C4 v7 z& ]7 m: E2 z$ Y' s
73. {
    - q$ {) v2 z: @- i) }
74.   LED0=!LED0;
    
75.   vTaskDelay(500);  // 延时500ms，也就是500个时钟节拍
    - J# V  C# f* Y! V$ i
76. }
    
77. }
    - x5 g( j5 o3 {' g$ \& c
78. // list任务函数
    % X) E3 h2 G* ?! G9 g2 W6 ^
79. void list_task(void *pvParameters)
    . i& j8 a- I$ N8 }$ d5 k
80. {
    : I! _! R& s* P7 ^
81. // 第一步：初始化列表和列表项
    3 R+ x, \) i3 P/ F; `4 V
82. vListInitialise(&TestList);
    
83. vListInitialiseItem(&ListItem1);
    - e0 T, J1 |& H0 c- x  @# [
84. vListInitialiseItem(&ListItem2);
    
85. vListInitialiseItem(&ListItem3);
    6 S! _" `- \; K: @$ q+ N
86. ListItem1.xItemValue=40;   //ListItem1列表项值为40
    
87. ListItem2.xItemValue=60;   //ListItem2列表项值为60
    
88. ListItem3.xItemValue=50;   //ListItem3列表项值为50
    ! j! B% v: O! v( h2 _# F
89. // 第二步：打印列表和其他列表项的地址
    ) Q) b0 a' y4 }5 p! z) _
90. printf("/*******************列表和列表项地址*******************/\r\n");
    
91. printf("项目                              地址     \r\n");
    
92. printf("TestList                          %#x     \r\n",(int)&TestList);
    
93. printf("TestList->pxIndex                 %#x     \r\n",(int)TestList.pxIndex);
    
94. printf("TestList->xListEnd                %#x     \r\n",(int)(&TestList.xListEnd));
    
95. printf("ListItem1                         %#x     \r\n",(int)&ListItem1);
    / c% g8 c& c% c* o! G
96. printf("ListItem2                         %#x     \r\n",(int)&ListItem2);
    + m9 h$ c2 M$ q* ~3 O) k8 {
97. printf("ListItem3                         %#x     \r\n",(int)&ListItem3);
    . o1 `- _4 l4 c2 N
98. printf("/************************结束**************************/\r\n");
    
99. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
    6 I0 W) p$ K/ h0 Q& F/ Q# T! g
100. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);  // 等待KEY_UP键按下
     
101. // 第三步：向列表TestList添加列表项ListItem1，并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值，
     
102. // 通过这两个值观察列表项在列表中的连接情况。
     8 Z# |6 n, y4 O: n' y4 P3 r5 K
103. vListInsert(&TestList,&ListItem1);          // 插入列表项ListItem1
     
104. printf("/******************添加列表项ListItem1*****************/\r\n");
     + T1 h5 e4 K7 Q5 z3 Z
105. printf("项目                              地址     \r\n");
     
106. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
     % i& b0 T: k2 ?' `. r5 `
107. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
     
108. printf("/*******************前后向连接分割线********************/\r\n");
     
109. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
     
110. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
     
111. printf("/************************结束**************************/\r\n");
     
112. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
     
113. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
     ! s) v, [& i3 {4 X8 d0 E. n
114. // 第四步：向列表TestList添加列表项ListItem2，并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值，
     
115. // 通过这两个值观察列表项在列表中的连接情况。
     $ V& o" Y$ ]0 V2 ^
116. vListInsert(&TestList,&ListItem2); // 插入列表项ListItem2
     
117. printf("/******************添加列表项ListItem2*****************/\r\n");
     
118. printf("项目                              地址     \r\n");
     
119. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
     1 g" F8 a- @% S& u& \! g
120. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
     $ O2 `) |% |& u: F. a( E5 Z
121. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));
     
122. printf("/*******************前后向连接分割线********************/\r\n");
     
123. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
     
124. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
     / d) g- ~4 @9 J2 ~5 J
125. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));
     
126. printf("/************************结束**************************/\r\n");
     5 W4 U- }* U7 \" _; x# {
127. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
     $ L; x# P9 y/ y
128. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
     0 U5 A1 J$ w4 p* f
129. // 第五步：向列表TestList添加列表项ListItem3，并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值，
     
130. // 通过这两个值观察列表项在列表中的连接情况。
       @% s+ x! x: y$ J
131. vListInsert(&TestList,&ListItem3);                 // 插入列表项ListItem3
     4 {# L9 m* F  Z2 |4 S1 m  S
132. printf("/******************添加列表项ListItem3*****************/\r\n");
     
133. printf("项目                              地址     \r\n");
     & ]9 I' k" [) U0 B* L% [1 w+ `4 `
134. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
     ' H, ^' n( w# H+ i: V. P/ s
135. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
     ) |' K& [% N$ c. [
136. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));
     / @6 B. s% E5 F3 S, j& Q/ l
137. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));
     # }0 o# f& l% @8 d5 E
138. printf("/*******************前后向连接分割线********************/\r\n");
     . Z, J  I, R4 W6 ^8 _# L- W2 j
139. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
     
140. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
     
141. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));
     + v* p  `9 P8 N# r1 F2 z
142. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));
     6 D! ]( F4 q7 p5 i9 A) y
143. printf("/************************结束**************************/\r\n");
     " i$ v7 N9 c* \" E
144. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
     
145. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
     
146. // 第六步：删除ListItem2，并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值，
     0 h  w0 b# s( n' w! N$ a
147. // 通过这两个值观察列表项在列表中的连接情况。
     
148. uxListRemove(&ListItem2);      //删除ListItem2
     
149. printf("/******************删除列表项ListItem2*****************/\r\n");
     1 j6 b. o" H4 N0 f$ K6 T2 T& T& X
150. printf("项目                              地址     \r\n");
     
151. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
     
152. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
     
153. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));
     4 x. F' C  \' s# A. A
154. printf("/*******************前后向连接分割线********************/\r\n");
     3 X* Q- j8 M: j9 E
155. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
     ' }* v5 r/ b: D1 C8 g7 M( l8 o
156. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
     - o" v) Q) f4 w% x7 Z( \
157. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));
     
158. printf("/************************结束**************************/\r\n");
     
159. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
     
160. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
     
161. // 第七步：删除ListItem2，并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值，
       i  t' t; v& s- r+ o+ d, G# X
162. // 通过这两个值观察列表项在列表中的连接情况。
     
163. TestList.pxIndex=TestList.pxIndex->pxNext;       // pxIndex向后移一项，这样pxIndex就会指向ListItem1。
     
164. vListInsertEnd(&TestList,&ListItem2);            // 列表末尾添加列表项ListItem2
     1 s! ~0 d9 M) e3 j
165. printf("/***************在末尾添加列表项ListItem2***************/\r\n");
     & {  a. m7 B+ Z
166. printf("项目                              地址      \r\n");
     4 d: m0 `  i! R1 h' p
167. printf("TestList->pxIndex                 %#x     \r\n",(int)TestList.pxIndex);
     
168. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
     3 f* V9 l, K$ c% T. V4 [( y
169. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));
     
170. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
     
171. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));
     
172. printf("/*******************前后向连接分割线********************/\r\n");
     
173. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
     
174. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));
     2 X" S# h* r4 ]- A- T6 K
175. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
     0 O- C% L# v" ~, K
176. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));
     ; z+ O- |/ A( ?3 J0 ?$ _
177. printf("/************************结束**************************/\r\n\r\n\r\n");
     
178. while(1)
     
179. {
     
180.   LED1=!LED1;
     
181.   vTaskDelay(1000);       // 延时1s，也就是1000个时钟节拍
     
182. }
     / W1 v  H( U# ^) _# t+ R0 Y/ b
183. }

复制代码

5. 实验结果
9 @5 ^: E2 H. z8 M! W系统运行后，观察串口调试助手，初始化后如下图所示：
' ]/ j/ ~4 Z7 T# Z8 e* H( p

8 F  h; {3 ~, d' @* v& G5 V/ n8 Q1 y初始化后：
- m: O- R$ Y$ F2 L# Y9 Y/ @/ mpxIndex指向xListEnd，为ox200000c0；
xListEnd的地址为ox200000c0；
0 f( E$ Z& b0 b# N2 _( ?5 ~0 X$ lListItem1的地址为ox200000cc；
ListItem2的地址为ox200000e0；
5 Y6 W* q/ ^0 P2 l4 aListItem3的地址为ox200000f4；
单击按键，添加列表项ListItem1，完成后如下图所示：
% |9 E1 F6 \& v. q8 x1 B4 p4 T
) N4 P  e$ X5 I9 i3 f
1 C6 ]" ^) W2 x) j: ]  A, C
xListEnd的下一个项的地址为ox200000cc，xListEnd的上一个项的地址为ox200000cc；
  u1 F0 W$ i; [) H) ?5 K# lListItem1下一个项的地址为0x200000c0，ListItem1上一个项的地址为0x200000c0。
因为：
2 ?: r# i$ ], z! W0 ^; b" H
( B! p; m5 E7 D! M. \8 i: y* y) WxListEnd ————>ListItem1————>xListEnd
继续单击按键，添加列表项ListItem2，完成后如下图所示：


! N& v  X. H+ u- K6 [+ H
9 ^! i( c1 F+ |! F7 j$ f# ]xListEnd的下一个项的地址为ox200000cc，xListEnd的上一个项的地址为ox200000e0；
: _4 Z. l' x( w2 s' `" R2 g9 XListItem1下一个项的地址为0x200000e0，ListItem1上一个项的地址为0x200000c0；
, E  t) Z' N# {& k7 dListItem2下一个项的地址为0x200000c0，ListItem2上一个项的地址为0x200000cc；
因为：

+ i  e" J/ p" \0 [/ y7 XxListEnd ————>ListItem1————>ListItem2————>xListEnd
继续单击按键，添加列表项ListItem3，完成后如下图所示：
$ C/ _5 o! ?) S4 Q( E
/ w% A( a" H9 m5 k

3 o  I2 `7 v/ }4 b/ d6 ?2 l8 Q2 UxListEnd的下一个项的地址为ox200000cc，xListEnd的上一个项的地址为ox200000f4；
9 J, Z8 t# ]: M2 DListItem1下一个项的地址为0x200000f4，ListItem1上一个项的地址为0x200000c0；
ListItem3下一个项的地址为0x200000c0，ListItem3上一个项的地址为0x200000cc；
0 [! h% H! A* [8 {) o& P5 P" z9 U# a因为：
6 ^" m2 ^& k8 q* z; h4 Z+ A
xListEnd ————>ListItem1————>ListItem3————>xListEnd
0 L, @* [& J5 E7 l  W5 {继续单击按键是，删除列表项ListItem2，完成后如下图所示：

' w3 w. S$ E& T/ K5 A
8 E0 D! O8 j7 F) i9 d( T
xListEnd的下一个项的地址为ox200000cc，xListEnd的上一个项的地址为ox200000e0；
& f$ R& \0 _6 _% `5 PListItem1下一个项的地址为0x200000f4，ListItem1上一个项的地址为0x200000c0；
& H5 R8 P0 Z$ O7 t) o# {+ JListItem3下一个项的地址为0x200000c0，ListItem3上一个项的地址为0x200000cc；
ListItem2下一个项的地址为0x200000c0，ListItem2上一个项的地址为0x200000f4；
因为：
# T) n5 `. M9 q  [2 \' W2 V9 VxListEnd ————>ListItem1————>ListItem3————>ListItem2————>xListEnd
6 M  N+ p7 d! V$ D7 k# L( O2 r
% f/ ^6 u3 N4 a8 F1 @5 N  D继续单击按键，末尾添加列表项ListItem2，完成后如下图所示：


: ?, h! g3 j& L
1 |' R* _' O& }xListEnd的下一个项的地址为ox200000e0，xListEnd的上一个项的地址为ox200000f4；
ListItem2下一个项的地址为0x200000cc，ListItem2上一个项的地址为0x200000c0；
ListItem1下一个项的地址为0x200000f4，ListItem1上一个项的地址为0x200000e0；
ListItem3下一个项的地址为0x200000c0，ListItem3上一个项的地址为0x200000cc；
因为：
1 r) R) Y3 Q  E; u
$ H% {& J9 \3 C% e' \xListEnd ————>ListItem2————>ListItem1————>ListItem3————>xListEnd

还要注意一个：
此时，pxIndex指向ListItem1，及其地址为0x200000cc！
你可以理解为，末尾添加列表项后，pxIndex指向添加该列表项的后一项地址。
( w9 b) v( c, S) G( H" L————————————————
版权声明：天亮继续睡

9 k$ U* [) l- s; R. I