巅峰残狼 发表于 2014-12-24 21:04
很好很强大，支持更新

谢谢支持！！

11.11  Round-Robin调度

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

11.11.1      配置参数OSSchedRoundRobinCfg()

1. /*
   
2. ***********************************************************************************************************
   * {& a9 X& R5 y6 t' I
3. *                                      配置ROUND-ROBIN调度参数
   
4. *
   
5. * 函数功能: 调用此函数用更改ROUND-ROBIN调度的参数。
   
6. * 形    参: en                DEF_EN：使能ROUND-ROBIN
   
7. *                             DEF_DIS：禁止ROUND-ROBIN
   5 N2 x6 m4 U2 P* f* s
8. *           dflt_time_quanta  默认的时间片数，如果是0 那么就表示时间片是默认的OSCfg_TickRate_Hz / 10.
   
9. *           p_err             错误代码指针变量
   6 Q& h% a5 x$ r: k* O( B
10. *                             OS_ERR_NONE       调用成功
    ! Y8 r: g: m6 }7 G
11. * 返 回 值: 无
    - d; C3 T' S6 G
12. ***********************************************************************************************************
    - E' a* x: h& }( q% x0 }( `: K
13. */
    " d: S5 T) R& F4 B: W2 o
14. 
    
15. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    
16. void  OSSchedRoundRobinCfg (CPU_BOOLEAN   en,
    + o( E. @* U8 S4 g
17.                             OS_TICK       dflt_time_quanta,
    # g$ r8 B5 q/ N8 q
18.                             OS_ERR       *p_err)
    
19. {
    
20.     CPU_SR_ALLOC();
    ' e8 Y/ X+ |( P7 V/ \
21. 
    
22. 
    
23. #ifdef OS_SAFETY_CRITICAL
    
24.     if (p_err == (OS_ERR *)0) {
    
25.         OS_SAFETY_CRITICAL_EXCEPTION();
    ) e, t3 |9 h3 W! s
26.         return;
    
27.     }
    6 x# D1 e8 p# g/ B/ N
28. #endif
    
29. 
    ( p; F2 I  t. T' O2 F$ W
30.     CPU_CRITICAL_ENTER();                                                                        （1）
    9 z/ ?# R9 K0 t% C% o3 l( d, d8 H
31.     if (en != DEF_ENABLED) {                                                                     （2）
    
32.         OSSchedRoundRobinEn = DEF_DISABLED;
    
33.     } else {
    % o" d3 e1 {% u4 s
34.         OSSchedRoundRobinEn = DEF_ENABLED;
    5 v. T; i$ o$ G/ x6 w# y9 }" Q6 I9 ^
35.     }
    
36. 
    
37.     if (dflt_time_quanta > (OS_TICK)0) {                                                         （3）
    3 h! y# x% e: Z* y. W
38.         OSSchedRoundRobinDfltTimeQuanta = dflt_time_quanta;
    . ]- M7 S) c5 B) R
39.     } else {
    
40.         OSSchedRoundRobinDfltTimeQuanta = (OS_TICK)(OSCfg_TickRate_Hz / (OS_RATE_HZ)10);
    " `0 R% K5 l) q$ K
41.     }
    . h8 i+ t1 i0 q% Q
42.     CPU_CRITICAL_EXIT();
    1 A( G& _; B" B
43.    *p_err = OS_ERR_NONE;
    & O, J; k( d" f5 M; ^2 o+ U
44. }
    + U3 J9 k6 x# F
45. #endif

复制代码

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

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

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

3 A7 u& a2 R% _11.11.2      放弃剩余时间片OSSchedRoundRobinYield ()

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

1. /*
   0 ^- Z& i3 j: `$ h# f6 M
2. ***********************************************************************************************************
   - F* T/ I  D6 I3 J7 h; ]
3. *                                    当任务不再需要剩余时间片时放弃CPU使用权
   , a$ D) {6 ~1 k0 L, Z: Q4 U+ j
4. *
   
5. * 功能说明: 当任务的时间片还没用完的时候，可以通过此函数放弃剩余时间片，也就是放弃CPU使用权。
   7 {. v5 n! G1 x
6. * 形    参: p_err  错误代码指针变量
   
7. *                  OS_ERR_NONE                   函数调用成功
   
8. *                  OS_ERR_ROUND_ROBIN_1          此优先级下只有这一个任务，能够放弃CPU权
   & P4 [: O1 j: x) g$ \) W- _; }6 o, J
9. *                  OS_ERR_ROUND_ROBIN_DISABLED   Round Robin调度没有使能
   
10. *                  OS_ERR_SCHED_LOCKED           调度器被锁
    3 M( Z( n8 ]7 w! u5 S% T# K
11. *                  OS_ERR_YIELD_ISR              不能在中断服务程序中调用此函数
    
12. * 返 回 值: 无
    
13. * 注    意: 1) 此函数必须在任务中调用
    % P( u+ }& `/ d( l/ ?$ B
14. ***********************************************************************************************************
    8 l0 H, `7 `3 A: A" z" i5 z6 F
15. */
    
16. 
    
17. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    % W, ~  s6 d( z* U/ c) Y, w
18. void  OSSchedRoundRobinYield (OS_ERR  *p_err)
    
19. {
    
20.     OS_RDY_LIST  *p_rdy_list;
    
21.     OS_TCB       *p_tcb;
    
22.     CPU_SR_ALLOC();
    
23. 
    ' `6 s/ A( d7 y. O; b- V
24. 
    - U/ z- a  ^5 o, r+ C4 J1 \
25. 
    
26. #ifdef OS_SAFETY_CRITICAL
      a! t! g! D; l+ s- u
27.     if (p_err == (OS_ERR *)0) {
    
28.         OS_SAFETY_CRITICAL_EXCEPTION();
    
29.         return;
    
30.     }
    3 ~" D* s9 k& m
31. #endif
    7 {* R' }' y' W  \7 S
32. 
    * K5 Z7 \& x! w7 h  |
33. #if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    . Y8 g. o7 s( Z* v
34.     if (OSIntNestingCtr > (OS_NESTING_CTR)0) {      /* 不能在ISR中调用此函数 */
    4 ?* c  V- I0 F  }. v2 A
35.        *p_err = OS_ERR_YIELD_ISR;
    
36.         return;
    " ~8 T, ~: U" `0 ?9 d& `5 s
37.     }
    ) W' ~2 r3 P3 h$ g; \
38. #endif
    
39. 
    " {1 R1 z( o" v$ F
40.     if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {  /* 调度器被锁不能执行此函数  */
    2 P! T3 n5 J( T! `' D2 ]
41.        *p_err = OS_ERR_SCHED_LOCKED;
    
42.         return;
    & X: I, `) g9 w6 G) ]+ d. u$ p% ?
43.     }
    
44. 
    / [) h8 J" n* _& N
45.     if (OSSchedRoundRobinEn != DEF_TRUE) {            /* 确认round-robin已经使能 */
    
46.        *p_err = OS_ERR_ROUND_ROBIN_DISABLED;
    * x5 j+ \# ^' l- Q6 {; ^
47.         return;
    
48.     }
    $ ?* ]* \: {# d# y4 O
49. 
    
50.     CPU_CRITICAL_ENTER();
    5 e6 V3 ]& N8 b: T. g' p" L& {. r
51.     p_rdy_list = &OSRdyList[OSPrioCur];                /* 此优先级下仅有这一个任务  */               （1）
    2 @/ e4 q8 }! v. v
52.     if (p_rdy_list->NbrEntries < (OS_OBJ_QTY)2) {
    
53.         CPU_CRITICAL_EXIT();
    
54.        *p_err = OS_ERR_ROUND_ROBIN_1;
    5 s  T; z4 n" L0 V
55.         return;
    $ s5 N/ L0 G# a- G1 p9 b8 J& R! r
56.     }
    & W- H9 [1 I& v: O6 U3 i6 E
57. 
    9 W% U+ J; G7 Z6 J5 E/ `
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;
    
62.     } else {
    . U( o1 Q/ L& F- f' G
63.         p_tcb->TimeQuantaCtr = p_tcb->TimeQuanta;       /* 加载新的时间片数  */
    8 K) ~& |  U1 I! E
64.     }
    4 z; k7 x; |; |  e
65. 
    
66.     CPU_CRITICAL_EXIT();
    
67. 
    
68.     OSSched();                                          /* 运行调度器  */                             （4）
    
69.    *p_err = OS_ERR_NONE;
    
70. }
    
71. #endif

复制代码

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

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

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

4.    执行任务调度。

（续）11.11  Round-Robin调度

7 W0 x, t$ X) W6 u11.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. /*
   / w; `3 y; c2 Q2 I% p# V
2. ***********************************************************************************************************
   ( I/ R5 [& F" s- ?0 T% u: A
3. * 运行ROUND-ROBIN 调度算法
   
4. *
   6 w  p* V1 h& I) N- X' B
5. * 函数说明: 此函数每个嘀嗒定时器中断被调用，通过此函数来计算同优先级中是否有任务要执行。
   
6. * 形 参: p_rdy_list 就绪链表指针
   3 p2 ~2 `) }) L; E9 ]
7. * 返 回 值: 无
   8 I! `& ~* j, ~0 B* g7 \
8. * 注 意: 1) 内部函数调用，用户程序不能调用
   
9. ***********************************************************************************************************
   
10. */
    9 V' T+ U, S( @( {5 ~7 s
11. 
    0 U% D' L' \) g( P, ]
12. #if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    
13. void OS_SchedRoundRobin (OS_RDY_LIST *p_rdy_list)
    
14. {
    * m8 W: w# ^# R7 h
15. OS_TCB *p_tcb;
    
16. CPU_SR_ALLOC();
    
17. 
    $ H( n" [) P- `# b6 @; @
18. 
    2 \1 [4 V2 p$ [8 h1 C. u; y
19. 
    
20. if (OSSchedRoundRobinEn != DEF_TRUE) { /* 确认round-robin调度已经使能 */ （1）
    ( ]5 w- c5 A- f4 B
21. return;
    
22. }
    % s- p" G, W6 |' K+ s& a
23. 
    . _1 d5 C" z; H: e! [2 B3 }
24. CPU_CRITICAL_ENTER();
    : i( y% y6 s: ?0 o
25. p_tcb = p_rdy_list->HeadPtr;
    ; c, c" W4 w- ~( v4 G' f
26. 
    6 P$ u! y) r0 d$ t
27. if (p_tcb == (OS_TCB *)0) { （2）
    8 m& k% p+ _9 N! ]! a: [/ u
28. CPU_CRITICAL_EXIT();
    / U9 t$ Y- `& ^. o
29. return;
    
30. }
    : F# T6 N8 e. ]; x& k
31. 
    # d! @) P0 I, T# E
32. if (p_tcb == &OSIdleTaskTCB) { （3）
    / |1 ^6 _( E6 N5 Z' b9 ^0 E
33. CPU_CRITICAL_EXIT();
    
34. return;
    
35. }
    0 M) f' N; E) p2 P5 o: n
36. 
    
37. if (p_tcb->TimeQuantaCtr > (OS_TICK)0) { /* 时间片计数减一 */ （4）
    
38. p_tcb->TimeQuantaCtr--;
    
39. }
    
40. 
    / F# }) A: O9 K; ?" `6 n8 m
41. if (p_tcb->TimeQuantaCtr > (OS_TICK)0) { /* 时间片还没有用完 */ （5）
    
42. CPU_CRITICAL_EXIT();
    5 t. g' Q# i- U4 b' p0 {  {% {
43. return;
    $ H' J! k, n3 W5 R
44. }
    
45. 
    7 ]( v" ?& b+ f3 d7 o9 \* g% c
46. if (p_rdy_list->NbrEntries < (OS_OBJ_QTY)2) { /* 是否只有一个同优先级任务 */ （6）
    
47. CPU_CRITICAL_EXIT(); /* 是的，退出 */
    , ~' O: C6 Z0 X4 N. o
48. return;
    ! Z, g) H1 \  P) {6 O9 \, ]
49. }
    1 u- ?, I6 I1 O1 K  T7 }6 ?
50. 
    1 j+ P; G0 G' f
51. if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* 调度器被锁，不能执行round-robin */ （7）
    
52. CPU_CRITICAL_EXIT();
    ; U& @1 ^! @9 v8 f! T( y
53. return;
    
54. }
    
55. 
    
56. OS_RdyListMoveHeadToTail(p_rdy_list); /* 将当前的OS_TCB移到就绪链表的末尾 */ （8）
    3 y+ }6 K3 v5 \$ c
57. p_tcb = p_rdy_list->HeadPtr; /* 获取修改后的就绪链表头部OS_TCB */
    
58. if (p_tcb->TimeQuanta == (OS_TICK)0) { /* 检测是否需要使用默认的时间片 */ （9）
    
59. p_tcb->TimeQuantaCtr = OSSchedRoundRobinDfltTimeQuanta;
    $ @; }; x7 B' R% p' ~- a& _( K
60. } else {
    ( m" d1 I) e3 O5 h5 e
61. p_tcb->TimeQuantaCtr = p_tcb->TimeQuanta; /* 加载新的时间片 */
    
62. }
    8 s. b5 [9 X+ s( j( E8 t$ k. }
63. CPU_CRITICAL_EXIT();
    # M, ?: M, j8 Z( e
64. }
    
65. #endif

复制代码

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

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

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

4.     时间片减一。

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

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

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

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

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

11.11.4       函数使用举例

1. /*
   + S9 j' D" ^8 O5 K: p
2. *********************************************************************************************************
   " C4 x/ `1 @7 E" o
3. * 函数名: main
   & u4 y0 y9 h3 y% i4 g7 v
4. * 功能说明: 标准c程序入口。
   , n1 k, B6 C8 o+ f; O6 ~; h
5. * 形 参：无
   2 I  \# [+ n: z; j$ ?
6. * 返回值: 无
   
7. *********************************************************************************************************
   5 K6 v2 f" N0 L
8. */
   
9. 
   
10. int main(void)
    
11. {
    
12. OS_ERR err;
    : @1 R4 r7 f: G2 m# L3 @! U. q
13. 
    
14. OSInit(&err);
    
15. 
    . S4 D8 M1 I" K8 W' B( U, j7 J3 g
16. /* 使能并设置全局时间片个数 */
    
17. OSSchedRoundRobinCfg(DEF_ENABLED,
    
18. 8,
    5 E" X  P! Q/ A. Z+ l: X& T
19. &err);
    " x' H6 ^) d& N
20. 
    
21. OSTaskCreate((OS_TCB *)&AppTaskStartTCB,
    
22. (CPU_CHAR *)"App Task Start",
    3 G$ ?: ]# v7 q$ W& L
23. (OS_TASK_PTR )AppTaskStart,
    
24. (void *)0,
    5 E. }) M+ }/ n, G! N+ Q
25. (OS_PRIO )APP_CFG_TASK_START_PRIO,
    1 \7 F' L  M2 k
26. (CPU_STK *)&AppTaskStartStk[0],
    
27. (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE / 10,
    
28. (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,
    . X; j1 L3 c/ Y
29. (OS_MSG_QTY )0,
    
30. (OS_TICK )0,
    
31. (void *)0,
    " k) h4 c. y' s' H
32. (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
    / C. A0 l6 S: O# {8 Q
33. (OS_ERR *)&err);
    
34. 
    ; |- A4 w) W4 U: P$ k2 |* \0 a
35. OSStart(&err);
    
36. 
    ) L8 `/ m2 Z/ e) E) p9 r- D* M, @
37. return (0);
    
38. }
    
39. 
    # H: ]- |% D/ ]2 S9 D
40. 
    
41. /*
    3 I* l' R# x8 f* p# L2 _6 t
42. *********************************************************************************************************
    
43. * 函 数 名: AppTaskCom
      [0 L7 t# V% _+ P
44. * 功能说明: 此任务未使用
    + c8 \% |! [! f. q8 ^' x- |
45. * 形 参：p_arg 是在创建该任务时传递的形参
    * }$ J4 E! s% u9 l, _$ T. k
46. * 返 回 值: 无
    * y; \! B( `* i0 T
47. *********************************************************************************************************
    
48. */
    ; m! l) V- F* j0 K
49. 
    
50. static void AppTaskCOM(void *p_arg)
    
51. {
    
52. OS_ERR err;
    
53. 
    
54. (void)p_arg;
    
55. 
    
56. 
    + r2 Z3 g4 f5 S. W( }" ?" G% |$ F
57. while(1)
    : h3 C6 k2 [' [
58. {
    
59. ……
    
60. OSSchedRoundRobinYield (&err);
    2 _: t& b4 M* P) G& R
61. ……
    ' n- L: S2 u- h( g! O
62. }
    9 Q" `, z  k( v  S( c8 ]! p( l8 t! E
63. 
    5 X4 N9 t+ j2 g. a# }% p9 c8 f7 v
64. 
    
65. }

复制代码

. B- D# }0 @; R9 \5 B  Z" C

11.12  总结

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

5 r* w+ S3 V. e/ b+ \/ N  j

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

赞赞赞；

工作很细致。

楼主费心了，赞一个

很好，学习了。