巅峰残狼 发表于 2014-12-24 21:04
, d* T7 o0 f$ E( a  i很好很强大，支持更新

4 U6 M3 Z# o2 e: C* Z- e谢谢支持！！

11.11  Round-Robin调度

    μCOS-III中的时间片调度功能做的很完善，支持全局的时间片设置，也支持每个任务的单独设置。关于时间片调度，咱们在前几期教程也有讲解。

11.11.1      配置参数OSSchedRoundRobinCfg()

1. /*
   
2. ***********************************************************************************************************
   
3. *                                      配置ROUND-ROBIN调度参数
   ) z! k8 d9 K3 z, a: P+ k- d
4. *
   - I# ~4 m4 D# e/ c
5. * 函数功能: 调用此函数用更改ROUND-ROBIN调度的参数。
   
6. * 形    参: en                DEF_EN：使能ROUND-ROBIN
   
7. *                             DEF_DIS：禁止ROUND-ROBIN
   
8. *           dflt_time_quanta  默认的时间片数，如果是0 那么就表示时间片是默认的OSCfg_TickRate_Hz / 10.
   
9. *           p_err             错误代码指针变量
   
10. *                             OS_ERR_NONE       调用成功
    
11. * 返 回 值: 无
    
12. ***********************************************************************************************************
    
13. */
    1 E2 V: W) \9 G7 I& @! L
14. 
    2 g3 q/ g, R3 g9 B
15. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    2 j1 l+ W! D8 p$ O( B. q( J+ `" }8 U
16. void  OSSchedRoundRobinCfg (CPU_BOOLEAN   en,
    2 Z- i) v! Y; n/ }
17.                             OS_TICK       dflt_time_quanta,
    * O  U7 `4 p0 P% C4 ^" o" }' H
18.                             OS_ERR       *p_err)
    
19. {
    
20.     CPU_SR_ALLOC();
    & T. [, h: e0 S5 k1 X3 o
21. 
    
22. 
    9 n4 m% @5 a; L5 a  R" `4 B
23. #ifdef OS_SAFETY_CRITICAL
    
24.     if (p_err == (OS_ERR *)0) {
    + V9 @7 Y$ x) f. _  j. ?
25.         OS_SAFETY_CRITICAL_EXCEPTION();
    . L4 s6 u1 S. v2 j* W0 r1 o$ S
26.         return;
    
27.     }
    ! f+ t0 m0 F1 i: I
28. #endif
    
29. 
    ; g" v- c" ~/ D4 t! D3 Y
30.     CPU_CRITICAL_ENTER();                                                                        （1）
      N& |: ~/ ?& f9 I5 f5 \3 v
31.     if (en != DEF_ENABLED) {                                                                     （2）
    3 x: h# d# ]# Y" P8 [
32.         OSSchedRoundRobinEn = DEF_DISABLED;
    - I4 E; E* v3 y. ^4 j  y+ k- v) \
33.     } else {
    9 K! T4 y& a1 x7 i3 d
34.         OSSchedRoundRobinEn = DEF_ENABLED;
    4 ~2 [$ b  p/ A/ G& J, F
35.     }
    
36. 
    
37.     if (dflt_time_quanta > (OS_TICK)0) {                                                         （3）
    
38.         OSSchedRoundRobinDfltTimeQuanta = dflt_time_quanta;
    % @5 [0 s) O" t2 n  e# P, j/ i
39.     } else {
    
40.         OSSchedRoundRobinDfltTimeQuanta = (OS_TICK)(OSCfg_TickRate_Hz / (OS_RATE_HZ)10);
    + `. u3 i8 T( G3 h: y; Z
41.     }
    
42.     CPU_CRITICAL_EXIT();
    $ x6 H6 c' y$ L5 \0 `
43.    *p_err = OS_ERR_NONE;
    ) I. \8 o1 p6 n1 p+ v7 Z  s. z
44. }
    
45. #endif

复制代码

1.    由于这几个参数是全局变量，所以必须关闭中断。

2.    根据形参设置是否使能时间片调度。

3.    变量OSSchedRoundRobinDfltTimeQuanta是用来设置默认的时间片个数，也就是说，如果程序中没有单独配置任务的时间片个数，就会使用这个默认时间片个数。

11.11.2      放弃剩余时间片OSSchedRoundRobinYield ()

    这个函数的主要功能就是任务在完成工作的情况下，如果还有剩余的时间片，可以放弃这些时间去执行另外的同优先级任务（切记，是另外的同优先级任务）

1. /*
   / V+ ~6 @1 E' U/ v1 ?
2. ***********************************************************************************************************
   ( s6 w- J! T3 W( U
3. *                                    当任务不再需要剩余时间片时放弃CPU使用权
   5 ^1 B2 b3 h0 d6 C9 z( D
4. *
   % _& f" N6 U  ~
5. * 功能说明: 当任务的时间片还没用完的时候，可以通过此函数放弃剩余时间片，也就是放弃CPU使用权。
   % Q  J5 ?& t4 n% r
6. * 形    参: p_err  错误代码指针变量
   
7. *                  OS_ERR_NONE                   函数调用成功
   ; T* Q6 t6 E6 z
8. *                  OS_ERR_ROUND_ROBIN_1          此优先级下只有这一个任务，能够放弃CPU权
   
9. *                  OS_ERR_ROUND_ROBIN_DISABLED   Round Robin调度没有使能
   
10. *                  OS_ERR_SCHED_LOCKED           调度器被锁
    
11. *                  OS_ERR_YIELD_ISR              不能在中断服务程序中调用此函数
    
12. * 返 回 值: 无
    
13. * 注    意: 1) 此函数必须在任务中调用
    
14. ***********************************************************************************************************
    
15. */
    
16. 
    4 d7 P; p& O/ f# Z5 R8 r
17. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    4 C& Q& E5 V- {  ~1 J
18. void  OSSchedRoundRobinYield (OS_ERR  *p_err)
    ) t8 a+ [! L; S: M- g  w
19. {
    
20.     OS_RDY_LIST  *p_rdy_list;
    
21.     OS_TCB       *p_tcb;
    
22.     CPU_SR_ALLOC();
    : q+ r4 T! e: e
23. 
    
24. 
    : W( p4 P. d7 L
25. 
    - _9 P. t4 `/ \. E  s. s9 v
26. #ifdef OS_SAFETY_CRITICAL
    
27.     if (p_err == (OS_ERR *)0) {
    . w4 l7 @/ t2 \' Z4 j3 @
28.         OS_SAFETY_CRITICAL_EXCEPTION();
    
29.         return;
    & |( z5 V" r, a. K
30.     }
    
31. #endif
    
32. 
    ! N* U* f) G& d+ X# `& n6 Y, w
33. #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    
34.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {      /* 不能在ISR中调用此函数 */
    $ F% B& n! M8 w3 {. [
35.        *p_err = OS_ERR_YIELD_ISR;
    
36.         return;
    
37.     }
    
38. #endif
    
39. 
    ; \. g9 i7 v8 o! k% l8 b9 Q$ G3 n
40.     if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {  /* 调度器被锁不能执行此函数  */
    
41.        *p_err = OS_ERR_SCHED_LOCKED;
    
42.         return;
    7 v" u+ _& ]2 k. I7 v* Q/ v0 w$ D
43.     }
    
44. 
    
45.     if (OSSchedRoundRobinEn != DEF_TRUE) {            /* 确认round-robin已经使能 */
    
46.        *p_err = OS_ERR_ROUND_ROBIN_DISABLED;
    
47.         return;
    
48.     }
    # i, G! x4 a0 b
49. 
      w* c7 M' B+ m$ _$ |
50.     CPU_CRITICAL_ENTER();
    " h9 o7 }- u+ U* g) r0 l+ J: s) A
51.     p_rdy_list = &OSRdyList[OSPrioCur];                /* 此优先级下仅有这一个任务  */               （1）
    
52.     if (p_rdy_list->NbrEntries < (OS_OBJ_QTY)2) {
    
53.         CPU_CRITICAL_EXIT();
    
54.        *p_err = OS_ERR_ROUND_ROBIN_1;
    , h- I4 G( _, i; e- Y& S, s7 F. d
55.         return;
    , a+ O2 F" s# z- U' |
56.     }
    
57. 
    
58.     OS_RdyListMoveHeadToTail(p_rdy_list);               /* 移动当前任务的TCB到列表末  */            （2）
    
59.     p_tcb = p_rdy_list->HeadPtr;                        /* 获取列表首端的TCB  */
    
60.     if (p_tcb->TimeQuanta == (OS_TICK)0) {              /* 是0，使用默认的时间片数 */                （3）
    
61.         p_tcb->TimeQuantaCtr = OSSchedRoundRobinDfltTimeQuanta;
    % H% h; u& {3 `+ h6 d/ h( D6 ]
62.     } else {
    
63.         p_tcb->TimeQuantaCtr = p_tcb->TimeQuanta;       /* 加载新的时间片数  */
    . A5 ?% n3 M' k6 J( L+ U8 z
64.     }
    
65. 
    
66.     CPU_CRITICAL_EXIT();
    
67. 
    - x9 K$ S* F2 ?& d) t9 O2 C, Q
68.     OSSched();                                          /* 运行调度器  */                             （4）
    ) F" |* N1 T( a0 K- U
69.    *p_err = OS_ERR_NONE;
    
70. }
    6 T& M' u2 G, h
71. #endif

复制代码

1.    获取此优先级的就绪链表。从而得到此优先级下任务的个数，如果同优先级下只有一个任务，将退出这个函数。

2.    移动同优先级就绪链表中任务的位置，从实现同优先级下任务的切换。

3.    参数p_tcb->TimeQuanta = 0的时候就会使用默认的时间片个数，如果非0，就会给这个任务的时间片计数器赋予相应的时间片个数。

4.    执行任务调度。

（续）11.11  Round-Robin调度

11.11.3       Round-Robin调度算法OS_SchedRoundRobin ()

    当多个任务有相同的优先级时，μCOS-III允许任务在切换到另一个任务前运行特定的时间，也就是大家常说的时间片。这个过程就是Round-Robin调度或者时间片调度。如果任务不需要将所有的时间片用完，可以调用上面讲的函数OSSchedRoundRobinYield ()，放弃剩余时间片从而切换到同优先级的另一个任务。μCOS-III支持用户在系统运行过程中使能或者禁止时间片调度，同时也支持全局的时间片设置，也支持每个任务的单独设置。

    为了更好的说明Round-Robin调度算法，下面举一个例子（截图来自官方书籍）：Task #1，Task #2，Task #3都运行在优先级 X，任务运行的时间片个数都是4。

1.     一开始是Task #3在运行，运行期间每个嘀嗒定时器中断都会让Task #3的时间片计数减一。

2.     第四次进入嘀嗒定时器中断后，Task #3的4个时间片已经用完。

3.     切换到同优先级就绪链表中下一个任务Task #1。

4.     Task #1开始运行直到时间片用完。

5.     切换到Task #3运行。

6.     Task #3运行一段时间后，调用函数OSSchedRoundRobinYield ()放弃剩余时间片。

7.     切换到Task #1运行。

8.     这里要特别注意：Task #1会运行4个时间片，图片上面画的不是很准确。

    有了上面基础后，在解析一下相关函数。

1. /*
   ) a" s) D# R1 s+ V& E
2. ***********************************************************************************************************
   / G3 e+ y  s  b! ]; e) k
3. * 运行ROUND-ROBIN 调度算法
   
4. *
   6 Y8 W  r! m, ?- }# c: k" j
5. * 函数说明: 此函数每个嘀嗒定时器中断被调用，通过此函数来计算同优先级中是否有任务要执行。
   
6. * 形 参: p_rdy_list 就绪链表指针
   
7. * 返 回 值: 无
   ! z7 [# |4 w( `% P2 O2 C4 {. j
8. * 注 意: 1) 内部函数调用，用户程序不能调用
   ( E# t- ^# E+ n6 m; x
9. ***********************************************************************************************************
   
10. */
    6 l/ Z% ?9 d' |! [) m. [
11. 
    . D9 T4 q: F) J$ z
12. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    : x, J8 x0 ^, O) h6 ?$ H; ?1 j
13. void OS_SchedRoundRobin (OS_RDY_LIST *p_rdy_list)
    
14. {
    
15. OS_TCB *p_tcb;
    
16. CPU_SR_ALLOC();
    3 N1 K1 z! O  @0 b9 l0 a8 ^
17. 
    
18. 
      D% w! u( E# s+ p
19. 
    * @  W0 X$ d% v, n
20. if (OSSchedRoundRobinEn != DEF_TRUE) { /* 确认round-robin调度已经使能 */ （1）
    " q/ \1 W" J& |8 X4 d, q9 o2 F
21. return;
    6 W* n% _- O# [7 N' w1 K
22. }
    : a5 W) ^, x7 n
23. 
    
24. CPU_CRITICAL_ENTER();
    " S! ~# z, C. z; c& q$ ^8 @/ G9 W
25. p_tcb = p_rdy_list->HeadPtr;
    
26. 
    + ^$ T1 ^. u5 C% i
27. if (p_tcb == (OS_TCB *)0) { （2）
    - ~- H/ s, D+ H' E8 d  d
28. CPU_CRITICAL_EXIT();
    
29. return;
    
30. }
    
31. 
    ! z$ W. G  n; j  j
32. if (p_tcb == &OSIdleTaskTCB) { （3）
    
33. CPU_CRITICAL_EXIT();
    8 _  [* q. R& Y8 C! M6 G; B( r* `9 M
34. return;
    0 T; N& F# p- P' K0 B% o; @
35. }
    
36. 
    ; L' i- i1 F- F/ _$ |2 }
37. if (p_tcb->TimeQuantaCtr > (OS_TICK)0) { /* 时间片计数减一 */ （4）
    
38. p_tcb->TimeQuantaCtr--;
    
39. }
    
40. 
    $ G+ R7 G5 U' N3 w0 `; R
41. if (p_tcb->TimeQuantaCtr > (OS_TICK)0) { /* 时间片还没有用完 */ （5）
    
42. CPU_CRITICAL_EXIT();
    
43. return;
    
44. }
    3 q7 Y* ]! g8 V% K1 }
45. 
    
46. if (p_rdy_list->NbrEntries < (OS_OBJ_QTY)2) { /* 是否只有一个同优先级任务 */ （6）
    & l6 f1 e2 Z8 k; j0 _  h
47. CPU_CRITICAL_EXIT(); /* 是的，退出 */
    - p; v/ c3 y  t9 X" D0 _0 P
48. return;
    
49. }
    
50. 
    
51. if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* 调度器被锁，不能执行round-robin */ （7）
    
52. CPU_CRITICAL_EXIT();
    
53. return;
    
54. }
    3 h( D3 t% M# N1 z: c
55. 
    
56. OS_RdyListMoveHeadToTail(p_rdy_list); /* 将当前的OS_TCB移到就绪链表的末尾 */ （8）
    # Q2 u) o2 i3 n. C: _% y% [. H
57. p_tcb = p_rdy_list->HeadPtr; /* 获取修改后的就绪链表头部OS_TCB */
    
58. if (p_tcb->TimeQuanta == (OS_TICK)0) { /* 检测是否需要使用默认的时间片 */ （9）
    
59. p_tcb->TimeQuantaCtr = OSSchedRoundRobinDfltTimeQuanta;
    
60. } else {
    
61. p_tcb->TimeQuantaCtr = p_tcb->TimeQuanta; /* 加载新的时间片 */
    
62. }
    . ^, C, D; ?# z- l% i: ~
63. CPU_CRITICAL_EXIT();
    
64. }
    2 `, T2 a2 H  z! L( _5 e! K  l7 m
65. #endif

复制代码

1.     检测Round-Robin调度是否使能。

2.     确保此优先级下存在任务。

3.     这句话的意思是说：不允许用户将应用任务的优先级设置的和空闲任务优先级一样，也就是说空闲任务的优先级下不能有其它任务。

4.     时间片减一。

5.     任务的时间片还没有用完，退出继续执行。

6.     同优先级下必须有两个及其以上的任务才能继续往下执行。

7.     如果调度器被锁，不能执行Round-Robin调度。

8.     通过调整同优先级下的就绪链表获得下一个要执行的任务。

9.     判断使用全局的默认时间片个数还是使用单独设计的时间片个数。

/ C6 ?- C5 n9 G$ i+ a; S9 a11.11.4       函数使用举例

1. /*
   4 V: U) z6 K8 p% Y: T! d2 Q
2. *********************************************************************************************************
   
3. * 函数名: main
   
4. * 功能说明: 标准c程序入口。
   
5. * 形 参：无
   ) n+ f% W9 k! j) v$ d  z2 U
6. * 返回值: 无
   # H2 E! q9 o$ e# M' m6 `3 G( m5 g
7. *********************************************************************************************************
   
8. */
   
9. 
   
10. int main(void)
    
11. {
    9 h7 P1 F. c4 l9 i! L
12. OS_ERR err;
    0 K4 ^( l+ a' E% w8 ?8 k8 b! I
13. 
    9 h2 z' e- Y" U# y% ~7 P+ z) a
14. OSInit(&err);
    
15. 
    % l0 q# J) E8 B$ j" ?& |. L- i
16. /* 使能并设置全局时间片个数 */
    
17. OSSchedRoundRobinCfg(DEF_ENABLED,
    
18. 8,
    
19. &err);
    
20. 
    ' m% ]1 v  J/ S1 w/ w9 j# j8 w
21. OSTaskCreate((OS_TCB *)&AppTaskStartTCB,
    6 X' c+ t/ k7 C" Z, g0 Y
22. (CPU_CHAR *)"App Task Start",
    - }+ ]! g& y/ n0 s; _* A
23. (OS_TASK_PTR )AppTaskStart,
    1 b/ Q# K) y- r0 K  z
24. (void *)0,
    ; @+ P/ K$ c( `* A1 z
25. (OS_PRIO )APP_CFG_TASK_START_PRIO,
    
26. (CPU_STK *)&AppTaskStartStk[0],
    6 w6 w. ~& _! r8 X# o7 y: @7 H
27. (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE / 10,
    3 ^# F4 b5 P2 G" [9 q/ j+ }
28. (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,
    - G. N) Q  U1 U) Y$ R. L
29. (OS_MSG_QTY )0,
    & |# E/ Q- n- x/ c
30. (OS_TICK )0,
    
31. (void *)0,
    
32. (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
    , K" K/ J  r/ ~7 u& J1 [' v
33. (OS_ERR *)&err);
    * M3 l. x) ^4 j3 ?
34. 
    8 l3 `7 i0 ^* t+ M+ s9 y
35. OSStart(&err);
    
36. 
    0 x  a1 B+ r$ o9 p5 e6 M
37. return (0);
    ) F0 B8 h1 W& l# [! p+ P- I8 q. A  |
38. }
    7 K# x. U/ u% R  @
39. 
    
40. 
    
41. /*
    
42. *********************************************************************************************************
    - a. J7 s8 Z; o# G" p
43. * 函 数 名: AppTaskCom
    # q$ I& I- _  h
44. * 功能说明: 此任务未使用
    & O% l% G$ _' p; e0 m9 E* U
45. * 形 参：p_arg 是在创建该任务时传递的形参
    
46. * 返 回 值: 无
    
47. *********************************************************************************************************
    " O9 b0 C0 j5 W$ t7 v. Y
48. */
    8 l) z4 H0 m, s7 w6 d- a) {6 \
49. 
    
50. static void AppTaskCOM(void *p_arg)
    ; y  B! S0 t( a9 T) h
51. {
    , D( m6 C% D3 V* ^) G  G
52. OS_ERR err;
    ) w; g( T# x- @# k" s
53. 
    2 ^; I! J1 |9 i$ y
54. (void)p_arg;
    : W4 D; k( R& t( m% [, E$ Y
55. 
    ' Z# f" Q# x+ [1 u
56. 
    
57. while(1)
    6 x$ @' n5 ^8 D/ @( y1 b$ z
58. {
    ( n9 H4 U. o9 f
59. ……
    
60. OSSchedRoundRobinYield (&err);
    
61. ……
    : m( ?, X8 f; c0 ?1 Q3 t
62. }
    
63. 
    
64. 
    
65. }

复制代码

$ b* e- R; n! g% @& m/ A3 L4 }# i

11.12  总结

    本期教程涉及到的内容较多，如果是初学的，一定要多花点时间消耗下，如果学习过程中遇到很多问题，不要担心，随着后面教程的进行会理解的更深刻。

0 R6 S: _; R; p  P" ^# w& S% M) `& r

辛苦。。。。。。。。。。。学习

赞赞赞；

工作很细致。

楼主费心了，赞一个

很好，学习了。