你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32的FreeRTOS学习之列表和列表项实验(十)

[复制链接]
STMCU小助手 发布时间:2022-11-16 21:08
1. 实验目的  Y# x- T! i% ?, x8 F7 N
列表和列表项实验演练。
4 I5 N& r4 U# o2 j* t& Z. l7 P4 Q
2. 实验设计- p3 T9 _! t* H% i
本实验设计3个任务:0 B( G7 u1 z8 C& w# o" ^/ y
start_task:用来创建其他2个任务;! ^5 a0 B( _# ]  M7 L
task1_task:应用任务1,控制LED灯闪烁,提示系统正常运行;
& p* e# a9 q, x0 s1 Slist_task:列表和列表项操作任务,调用列表和列表项相关API函数,通过串口输出相应信息观察这些API函数的运行过程。
  Z, _6 ?* p& C* i1 o本实验需要用到按键,用于控制任务的运行。
+ s7 }% x' t5 Q: c
5 X- ]% k7 S# _/ Q3. 硬件
1 `+ y6 i" i1 e) O5 Q7 }7 y0 F1) 正点原子战舰v3开发板(其他板子应该也可以,主要涉及USART,LED,KEY);
* s. m- u- K$ q! p2) JLINK仿真器。
% a1 Z3 w, T0 e7 C2 ^* P& C2 l; H8 z) R$ c
4. 代码解读$ }% m4 t* a% S2 T$ I, T) \
如果不考虑usart、led、key的函数(不是本章的重点),那么主要的函数都在main.c文件里:: ~) @1 N3 w% n& B0 a( Y6 T5 }+ }

6 D( q/ E. `# p# C& ?7 n
  1. #include "sys.h"- b5 a. F6 C6 S9 T( ]3 A7 z2 e; p
  2. #include "delay.h"
    & x- e& d4 K' P' n# z
  3. #include "usart.h"
    & m6 A- R& |% n
  4. #include "led.h") j. D2 ~9 J: C8 q# H4 U
  5. #include "timer.h"
    5 o2 }+ E. k. @- f$ Y, K
  6. #include "timer.h"
    3 O' o0 x, s* f9 L0 H% q3 Z/ E
  7. #include "key.h"
    6 S, ^4 h+ ?% n! B8 B$ q
  8. #include "exti.h"
    5 e7 l6 |. A+ B) l) M5 ^8 l  T
  9. #include "FreeRTOS.h"
    8 ^, r  t  W( t6 C$ N/ G- S6 ]+ `
  10. #include "task.h"
    ! U* B- g2 M/ j- L
  11. // 开始任务
    0 \3 Q) F1 ]1 e0 Q
  12. #define START_TASK_PRIO  1           // 任务优先级
    ! V5 w: _2 B) E6 h4 e2 g
  13. #define START_STK_SIZE   128         // 任务堆栈大小
    8 g' B5 _, V& v3 h
  14. TaskHandle_t StartTask_Handler;      // 任务句柄) E4 t9 H6 u3 g* q2 j% Q
  15. void start_task(void *pvParameters); // 任务函数. J) @- z( l3 j5 s3 z3 b0 v! Q+ ]
  16. // 应用任务1
    0 K0 |0 _4 ?7 ~: Q
  17. #define TASK1_TASK_PRIO  2           // 任务优先级
    $ _, e+ a1 K$ a
  18. #define TASK1_STK_SIZE   128         // 任务堆栈大小
    8 m* M4 x" E$ x' X
  19. TaskHandle_t Task1Task_Handler;      // 任务句柄) `0 |4 M% j( o4 m% a; f; w
  20. void task1_task(void *pvParameters); // 任务函数  N6 z4 p" G: B! Z
  21. // 列表任务$ H$ ?+ k+ _8 g7 U+ x3 B: Y
  22. #define LIST_TASK_PRIO  3            // 任务优先级7 r& Z6 U- ?7 v" m
  23. #define LIST_STK_SIZE   128          // 任务堆栈大小 / l$ Z* Y7 L+ m) e3 S! s* _
  24. TaskHandle_t ListTask_Handler;       // 任务句柄
    1 }/ j) n; V- n; y4 ?4 I0 B
  25. void list_task(void *pvParameters);  // 任务函数# j% b: }" I7 A" M4 A
  26. // 定义一个测试用的列表和3个列表项
    5 h7 k  \: n. R7 h  i- U, Y
  27. List_t TestList;      // 测试用列表4 c7 T! [* [6 P' T' @/ q: h& y0 y
  28. ListItem_t ListItem1; // 测试用列表项1" v% ]& ]0 q* R2 G/ H% W
  29. ListItem_t ListItem2; // 测试用列表项21 @! T8 Q. F" }
  30. ListItem_t ListItem3; // 测试用列表项3: w1 O, `7 @& B# A2 Y( I5 u
  31. // 主函数- `. e0 d# C7 D4 M* I0 K0 Y
  32. int main(void). ]$ `% g7 J1 [. `
  33. {
    , D5 T" [1 c& A# z
  34. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);  // 设置系统中断优先级分组4  
    ' G. z; w# g! C
  35. delay_init();                                    // 延时函数初始化  
    " Z% ~/ R; l: O# {# e& U% t
  36. uart_init(115200);                               // 初始化串口
    2 R$ ]. r+ F5 p! b
  37. LED_Init();                                      // 初始化LED
    4 N+ v5 ~) m  d0 y  h' F
  38. KEY_Init();                                      // 初始化按键
    6 D% D1 p/ K- Z1 X5 g4 Z; b3 S8 m
  39. // 创建开始任务  o) ?9 _/ q5 ^, Z0 z# E2 S4 b) H/ @
  40. xTaskCreate(   (TaskFunction_t )start_task,            // 任务函数' v8 h4 ?; i- W7 u
  41.                 (const char*    )"start_task",          // 任务名称
    4 @3 P' w: P$ u8 _1 U
  42.                 (uint16_t       )START_STK_SIZE,        // 任务堆栈大小5 ~" @' a! j+ `' L, }9 {
  43.                 (void*          )NULL,                  // 传递给任务函数的参数
    9 m+ Y- x; k1 L+ m+ u$ y+ |9 ^
  44.                 (UBaseType_t    )START_TASK_PRIO,       // 任务优先级3 B4 t: q' H; I$ Q" E" `! v
  45.                 (TaskHandle_t*  )&StartTask_Handler);   // 任务句柄              8 }1 k- ^: I9 M  v% S" P8 e$ a: u
  46. vTaskStartScheduler();                                 // 开启任务调度
    ; `: w! |2 g% S  Y& c8 }
  47. }
    % t& F7 o; ~  f  |
  48. // 开始任务任务函数
    # g/ G$ S* t, C& s9 L
  49. void start_task(void *pvParameters)+ M: x# ^, |5 Q0 ?0 [* @
  50. {2 _& j' h, G3 W' n; O
  51.   taskENTER_CRITICAL();           // 进入临界区9 Q: |$ B; b4 b( v
  52.   // 创建TASK1任务# k1 D1 J: `/ F* w2 j) V
  53.   xTaskCreate(  (TaskFunction_t )task1_task,               B4 j7 w- _7 @9 ?9 Y
  54.                 (const char*    )"task1_task",           ! v- Z: S$ ?& O8 F
  55.                 (uint16_t       )TASK1_STK_SIZE,        
    : ~) Y% t  L( V
  56.                 (void*          )NULL,                  
    " {  p3 W' G: x2 t7 J
  57.                 (UBaseType_t    )TASK1_TASK_PRIO,        , p) \5 _! m/ W$ |3 j
  58.                 (TaskHandle_t*  )&Task1Task_Handler);   
    1 O- D; X3 W5 a$ T; t( E
  59.   // 创建LIST任务4 h% Q" f9 i3 y* k
  60.   xTaskCreate(  (TaskFunction_t )list_task,     $ {4 u! c4 _6 w6 m9 I7 _
  61.                 (const char*    )"list_task",   ' I* w% |: B+ ?5 V, ~
  62.                 (uint16_t       )LIST_STK_SIZE,& ?; u- {4 Q/ r9 _' n0 u! X% c
  63.                 (void*          )NULL,
    1 q6 L: E2 e. E7 O
  64.                 (UBaseType_t    )LIST_TASK_PRIO,  b, i. a& {5 H# G
  65.                 (TaskHandle_t*  )&ListTask_Handler);
    8 H6 K9 x8 I1 `. c& K
  66.   vTaskDelete(StartTask_Handler); // 删除开始任务/ X9 q# X8 f! R- E9 W- s$ o
  67.   taskEXIT_CRITICAL();            // 退出临界区8 R& @4 {! y' Q# c+ R5 ^' }
  68. }2 @- |+ |% P2 C, c2 z
  69. // task1任务函数
    6 O* y' ]8 F- y" O) s9 P8 H3 c0 p
  70. void task1_task(void *pvParameters): z* N- Z. Z# N
  71. {/ P3 d% v, e# y/ j  h+ y
  72. while(1)
    ' R. C3 W! N# M/ o/ [" B$ B- ~
  73. {- p- W6 V6 a4 q" K. g, J4 q
  74.   LED0=!LED0;
    0 K8 G( k1 ~7 E2 F6 z
  75.   vTaskDelay(500);  // 延时500ms,也就是500个时钟节拍
    * b" l* d# t( X
  76. }
    8 W3 C1 \+ C# t0 |6 B+ K) f) Q
  77. }
    # i( J; I& R2 c# O9 E7 @9 i
  78. // list任务函数
    & l; k$ u0 z/ J4 y' ^3 R! G. N( B* ^
  79. void list_task(void *pvParameters): l" I% Z/ m( v# C# ~. X
  80. {
    7 T5 `, e: [% I/ X
  81. // 第一步:初始化列表和列表项
    ( J; }" `4 j3 @1 F' |/ ?' x
  82. vListInitialise(&TestList);
    & V6 M; I7 ^: p1 T5 d5 E, W
  83. vListInitialiseItem(&ListItem1);
    ' J# T  c2 {1 [& i; N
  84. vListInitialiseItem(&ListItem2);5 o( z6 Z' L- ]% G4 o9 V3 G
  85. vListInitialiseItem(&ListItem3);3 R# A0 q: x1 R$ o2 s0 |
  86. ListItem1.xItemValue=40;   //ListItem1列表项值为40
    " A, j* ^& ~: F
  87. ListItem2.xItemValue=60;   //ListItem2列表项值为60
    0 R% O1 e; _0 F  n- S3 v& {
  88. ListItem3.xItemValue=50;   //ListItem3列表项值为50
    * ^" x- Y5 Y4 j% r. k9 Y: L' ?
  89. // 第二步:打印列表和其他列表项的地址4 L: J2 Q4 U: T- R
  90. printf("/*******************列表和列表项地址*******************/\r\n");4 V  a( M# }  `6 P1 ~6 W! a
  91. printf("项目                              地址     \r\n");
    4 w& w/ e. E  |: `+ c
  92. printf("TestList                          %#x     \r\n",(int)&TestList);
    # M" B, z0 [4 a7 E) I' U
  93. printf("TestList->pxIndex                 %#x     \r\n",(int)TestList.pxIndex);1 E* l8 d7 @0 T5 o  [% F$ \
  94. printf("TestList->xListEnd                %#x     \r\n",(int)(&TestList.xListEnd));
    7 x) R" R3 Z# H1 l/ ~8 P9 p: K( \, R
  95. printf("ListItem1                         %#x     \r\n",(int)&ListItem1);' N9 f, [  ?6 x' Q7 B* v# g) T
  96. printf("ListItem2                         %#x     \r\n",(int)&ListItem2);2 X' O$ l) ^! v/ f7 e( c2 z& P
  97. printf("ListItem3                         %#x     \r\n",(int)&ListItem3);
    ; R5 t5 N9 N) \( d
  98. printf("/************************结束**************************/\r\n");
    9 _; h6 C+ w0 H
  99. printf("按下KEY_UP键继续!\r\n\r\n\r\n");: u5 p6 U$ Y' |0 _: {2 U- d
  100. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);  // 等待KEY_UP键按下
    9 [4 z$ f8 J+ d
  101. // 第三步:向列表TestList添加列表项ListItem1,并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值,7 F) p' p5 y7 p* S1 ]+ n0 `
  102. // 通过这两个值观察列表项在列表中的连接情况。
    ! x  R1 q+ ^2 A/ k, U7 W% q  ?* S
  103. vListInsert(&TestList,&ListItem1);          // 插入列表项ListItem1
    $ Q* P. p  [4 u1 j( W' t" W" X4 l  u
  104. printf("/******************添加列表项ListItem1*****************/\r\n");: k; Z  A/ ]; v8 s# y
  105. printf("项目                              地址     \r\n");8 G9 J& H- H% w7 z$ Y5 a3 j1 x
  106. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));. t  A4 I7 V8 b1 ?
  107. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
    : |' C" u5 l1 O( @- f
  108. printf("/*******************前后向连接分割线********************/\r\n");7 t* ?$ g) |. m$ i: }; r
  109. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));! R9 |  J! L. c/ P* ~6 r" F
  110. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));0 R8 C0 S. @2 p: |9 ~8 U/ S
  111. printf("/************************结束**************************/\r\n");( d3 s* F% c9 Z2 x4 F8 g5 @! l/ q) C
  112. printf("按下KEY_UP键继续!\r\n\r\n\r\n");  I/ ?5 J$ O" C
  113. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下4 V, F* p  N8 Z5 ]2 z
  114. // 第四步:向列表TestList添加列表项ListItem2,并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值,  ]" e% C2 S" p0 ]9 y0 l+ h
  115. // 通过这两个值观察列表项在列表中的连接情况。
    8 \- t8 z7 J0 J7 B* z
  116. vListInsert(&TestList,&ListItem2); // 插入列表项ListItem2& u" j$ [7 N# g/ O0 V
  117. printf("/******************添加列表项ListItem2*****************/\r\n");" l) G3 n: j; h. a0 z
  118. printf("项目                              地址     \r\n");* \$ g4 \# M% a9 W
  119. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
    ; }0 I1 f* n- d- h. |' ?7 Z
  120. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));  D) e$ y$ ]" F4 y. M
  121. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));) Y0 W1 Z6 O  j3 M. Z( O! B# g: }
  122. printf("/*******************前后向连接分割线********************/\r\n");
    ! j! B/ K+ ?  w% m- c/ Z
  123. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
    ; g& c9 z6 ?" F/ l. w4 L/ w
  124. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));  f) X% D) D# {# D
  125. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));
    $ h1 d- F$ n+ s2 \+ n0 K
  126. printf("/************************结束**************************/\r\n");
    $ Y3 M/ F5 C6 \2 m* P4 E
  127. printf("按下KEY_UP键继续!\r\n\r\n\r\n");# k. J! H. Q2 k
  128. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下7 R$ r# m  E: ^' }3 J* O
  129. // 第五步:向列表TestList添加列表项ListItem3,并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值,
    8 ~" h: `. F9 [5 M
  130. // 通过这两个值观察列表项在列表中的连接情况。
    % P* B* \: x3 }: A" o1 Y
  131. vListInsert(&TestList,&ListItem3);                 // 插入列表项ListItem38 x9 g7 M1 M; H, N( |0 [* f
  132. printf("/******************添加列表项ListItem3*****************/\r\n");
    ; ?/ U" N3 o5 _& Y: S1 u
  133. printf("项目                              地址     \r\n");  A4 K3 P5 S& g, C$ G
  134. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));
    2 @) W8 v2 L- O% w! f2 L
  135. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
    3 t5 b' V$ K) j* d6 w8 X5 f
  136. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));
    8 b7 |4 @( O' T
  137. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));7 N: M* G& G  n/ {/ ~7 D- X
  138. printf("/*******************前后向连接分割线********************/\r\n");
    3 B9 k: ]: @6 i- R, k
  139. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));6 d4 B: U* h3 P3 h, L4 J0 D/ t
  140. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));; ?4 [1 C2 c3 j5 B) H
  141. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));. Y* }/ ?$ k# q4 x
  142. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));# r3 Y% Z' c; f; s' w! c! e; P8 _
  143. printf("/************************结束**************************/\r\n");
    # t4 N/ `" r: A! u2 P, e
  144. printf("按下KEY_UP键继续!\r\n\r\n\r\n");
    - g. H/ t* A  j! n/ }/ d
  145. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
    * J9 q& Y( ?" H. @
  146. // 第六步:删除ListItem2,并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值,
    . I- G8 \" p7 P- h' y/ e
  147. // 通过这两个值观察列表项在列表中的连接情况。
    ) \9 B. I& P# r1 R
  148. uxListRemove(&ListItem2);      //删除ListItem2
    1 ]2 D8 q) w" g, p
  149. printf("/******************删除列表项ListItem2*****************/\r\n");
    3 P" k0 ]. e" l) |1 s
  150. printf("项目                              地址     \r\n");! H; q' Q7 B8 {" P3 w# k
  151. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));. B. I8 k5 i( s5 r$ x; ^  B
  152. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));
    . @# _- a0 [5 E% [0 t8 u7 u3 Z/ F
  153. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));& A5 M$ G& K/ w5 J0 e1 ?
  154. printf("/*******************前后向连接分割线********************/\r\n");( Z, X7 J# v4 m# B+ r7 g- ^
  155. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));
    ' }4 a8 P% @; T* {) \. e
  156. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));
    $ ^! U5 X& f4 H, d! {# g5 ]
  157. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));. n) M; r# U( ~
  158. printf("/************************结束**************************/\r\n");
    # q9 f) W- b( p- ?
  159. printf("按下KEY_UP键继续!\r\n\r\n\r\n");  @+ R; t, n+ }( G8 z# I9 M
  160. while(KEY_Scan(0)!=WKUP_PRES) delay_ms(10);     // 等待KEY_UP键按下
    ! ~0 g+ h' N# w7 V- ^' |; ^
  161. // 第七步:删除ListItem2,并通过串口打印所有列表项中成员变量pxNext和pxPrevious的值,4 h# J6 ?; |  v$ w
  162. // 通过这两个值观察列表项在列表中的连接情况。
    " ]9 O4 f6 u% v8 b1 r! E6 @6 i
  163. TestList.pxIndex=TestList.pxIndex->pxNext;       // pxIndex向后移一项,这样pxIndex就会指向ListItem1。+ n  \; V/ F0 \4 Q
  164. vListInsertEnd(&TestList,&ListItem2);            // 列表末尾添加列表项ListItem2% n9 N+ C# K( u
  165. printf("/***************在末尾添加列表项ListItem2***************/\r\n");) x+ `3 C% U6 \1 T* D2 t: _8 S
  166. printf("项目                              地址      \r\n");
    , y; {* I3 @- y4 w
  167. printf("TestList->pxIndex                 %#x     \r\n",(int)TestList.pxIndex);2 [. ?9 N5 R* m- {) @- l
  168. printf("TestList->xListEnd->pxNext        %#x     \r\n",(int)(TestList.xListEnd.pxNext));' ]5 Z  `, O' c2 L/ z
  169. printf("ListItem2->pxNext                 %#x     \r\n",(int)(ListItem2.pxNext));$ Q/ \9 Z% q: _- n$ y+ a5 v
  170. printf("ListItem1->pxNext                 %#x     \r\n",(int)(ListItem1.pxNext));# O6 ?* L- i/ u* r# V3 N- M
  171. printf("ListItem3->pxNext                 %#x     \r\n",(int)(ListItem3.pxNext));
    + Y3 v$ Y6 x. J& B/ I. ]8 T
  172. printf("/*******************前后向连接分割线********************/\r\n");
    % G/ E) F+ H7 j% |4 f% c, W9 f  s
  173. printf("TestList->xListEnd->pxPrevious    %#x     \r\n",(int)(TestList.xListEnd.pxPrevious));0 k8 Z8 |. W+ b0 K9 Q1 Z
  174. printf("ListItem2->pxPrevious             %#x     \r\n",(int)(ListItem2.pxPrevious));
    8 j, g3 z: s0 I9 W" x1 z1 Q, m1 \
  175. printf("ListItem1->pxPrevious             %#x     \r\n",(int)(ListItem1.pxPrevious));9 n; m$ ^. |6 C$ f
  176. printf("ListItem3->pxPrevious             %#x     \r\n",(int)(ListItem3.pxPrevious));6 [0 v( {/ y8 `7 b, Z  V
  177. printf("/************************结束**************************/\r\n\r\n\r\n");
    7 p( n0 a- b) E
  178. while(1)3 ^: z' k* p: S8 c0 W; S4 b8 `1 {
  179. {
    7 J7 c& r, e1 f, A
  180.   LED1=!LED1;, L$ }. K0 H4 B: K# R. Z! n
  181.   vTaskDelay(1000);       // 延时1s,也就是1000个时钟节拍 ( `! h! M1 x% R% @7 Z
  182. }
    + ~( q, x0 G3 L! A
  183. }
复制代码
. Y! q6 s( E2 q8 `  i
5. 实验结果
7 s. X: V' C% n/ y8 n5 n* s系统运行后,观察串口调试助手,初始化后如下图所示:
" T& r( Y- X: Q; W 20210322135514411.png
8 g' S0 [- e3 M  I7 ^( {. w" L; {1 A4 Q
初始化后:8 h, ~9 D, n) r! K0 A. Y
pxIndex指向xListEnd,为ox200000c0;4 J* s- b& B6 P0 z7 }3 A0 }
xListEnd的地址为ox200000c0;
# k: _7 |0 {7 v1 k+ `ListItem1的地址为ox200000cc;, J2 G7 p' N" z3 X9 I$ N
ListItem2的地址为ox200000e0;
6 J' j( |' A2 a* AListItem3的地址为ox200000f4;
- q  v2 q' P1 w0 X单击按键,添加列表项ListItem1,完成后如下图所示:& I1 _) \' n+ A' P) K) B0 Z  |
- c4 V8 W5 G7 E, H3 j7 |# Y
20210322135652375.png ) h1 j$ v0 S" d! C$ B  m
7 M  g9 c( `0 b. ~
xListEnd的下一个项的地址为ox200000cc,xListEnd的上一个项的地址为ox200000cc;8 c2 [; v% Q$ [
ListItem1下一个项的地址为0x200000c0,ListItem1上一个项的地址为0x200000c0。4 v5 ?; A+ @  ]2 D6 e
因为:! J/ q. T5 @) Q! u1 _- \+ U

, @5 a9 F# @0 O8 S; ]xListEnd ————>ListItem1————>xListEnd
2 ~3 q" r! D  g& N0 o继续单击按键,添加列表项ListItem2,完成后如下图所示:
( {4 ^  j4 |4 h9 I
: ]. W! C  k/ G# l# z7 g" e 20210322140717138.png ( o- A* N3 K' T

) g/ `0 k. ]! Y8 DxListEnd的下一个项的地址为ox200000cc,xListEnd的上一个项的地址为ox200000e0;& B) X$ i* Q; E, ?) ?2 X& I" m
ListItem1下一个项的地址为0x200000e0,ListItem1上一个项的地址为0x200000c0;  W1 ]% {3 I/ K8 @/ s
ListItem2下一个项的地址为0x200000c0,ListItem2上一个项的地址为0x200000cc;( X# }, h' B5 B1 f( P
因为:
. [2 ^* Y. h" A5 s
8 M6 g' S' ^: c8 txListEnd ————>ListItem1————>ListItem2————>xListEnd% {% f9 |( D' \. C' M' q  J7 }
继续单击按键,添加列表项ListItem3,完成后如下图所示:+ O' W3 g: B: K' X0 u

& e, ?- m- T5 I+ S3 ~$ R; P0 o 20210322141643875.png
9 r: {; l8 X, d9 O
$ N; l( O2 H3 U6 r: cxListEnd的下一个项的地址为ox200000cc,xListEnd的上一个项的地址为ox200000f4;1 y# S- e( M: ]) l; q: X
ListItem1下一个项的地址为0x200000f4,ListItem1上一个项的地址为0x200000c0;
6 ?! G& R# j1 ^3 n% c, AListItem3下一个项的地址为0x200000c0,ListItem3上一个项的地址为0x200000cc;
9 _1 |* ?. E- c$ V6 S' H6 h% F. [  W因为:# \& y' I: S( G8 ~( E+ b" q1 J

% m, }# r! X, u2 U  d5 w8 NxListEnd ————>ListItem1————>ListItem3————>xListEnd
; U" g: v: j6 i, R+ W继续单击按键是,删除列表项ListItem2,完成后如下图所示:( }& D, |  H! Y0 E4 v
+ ^3 v& v7 y& R" C: L4 \5 B
20210322141902176.png   E% n# _8 q& C& N

5 L1 m- u" W; HxListEnd的下一个项的地址为ox200000cc,xListEnd的上一个项的地址为ox200000e0;/ i& }* d! f, J& P; L. s$ C! l
ListItem1下一个项的地址为0x200000f4,ListItem1上一个项的地址为0x200000c0;
' [* U7 {) t4 _4 k! cListItem3下一个项的地址为0x200000c0,ListItem3上一个项的地址为0x200000cc;/ g4 c. O- {  ^* i" A; \7 G) H: L
ListItem2下一个项的地址为0x200000c0,ListItem2上一个项的地址为0x200000f4;
. S# N" f( T0 i' q. k& E0 d因为:2 C8 Z$ i) I" B0 a- ?# e" n) \
xListEnd ————>ListItem1————>ListItem3————>ListItem2————>xListEnd4 s$ O$ ]$ P" M. E, o

/ L4 R$ `8 ?! r9 b继续单击按键,末尾添加列表项ListItem2,完成后如下图所示:% Q* H8 x/ n( o* `. H( I8 n/ I+ L

; v# Y+ E* W" v* a& s 20210322142130342.png 3 D, Y; q7 u& s9 T

$ B. r. @1 p) ]3 z: t- ^" yxListEnd的下一个项的地址为ox200000e0,xListEnd的上一个项的地址为ox200000f4;/ e8 M0 E$ {' P" V0 m( O
ListItem2下一个项的地址为0x200000cc,ListItem2上一个项的地址为0x200000c0;
* m" B7 f" a3 c  X7 v5 @ListItem1下一个项的地址为0x200000f4,ListItem1上一个项的地址为0x200000e0;
! v/ T7 a" s9 ~% V/ N, VListItem3下一个项的地址为0x200000c0,ListItem3上一个项的地址为0x200000cc;( E0 O* f1 |: x+ a: A, t3 A
因为:6 E. t& a  e. e0 t7 O# M* d

) j+ o" j7 v4 g7 W0 B6 |% fxListEnd ————>ListItem2————>ListItem1————>ListItem3————>xListEnd" @; |0 D) P+ a4 m# ]8 A" ^% e. K
6 p, _6 l7 F; Q2 g. M! {0 l
还要注意一个:
# }3 G1 ~. X" K' |$ T# y8 w5 q. x4 y0 R此时,pxIndex指向ListItem1,及其地址为0x200000cc!
( R! {  J" L7 y9 l/ f8 q9 N4 n你可以理解为,末尾添加列表项后,pxIndex指向添加该列表项的后一项地址。
7 h6 u9 x/ Q- I* C! Q6 t- H- _& z————————————————
0 w( k8 P  u' U" R) ^, ?版权声明:天亮继续睡
, ?0 S" }, [! V, d' r4 N( E' ?0 R) G+ w' s

# v& m) o* a% G  ?' @
赞 收藏 评论0 发布时间:2022-11-16 21:08

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版