对于搞单片机的特别用8051系列工程师来说，谈到单片机的RTOS，很多时候会问一句：“为什么要用RTOS?单片机就这一点资源，使用RTOS能保证效率吗?”

, A8 }& L+ t* X* j

对于这个问题，我会反问：“你用单片机的目的是什么?是为了用单片机的C编程，单片机的汇编编程甚至于用单片机的二进制指令编程?”上个世纪80年代，工程师用二进制指令给Z80编程，现在还有谁在用?现在还有人死抱着汇编不放，但越来越多的人工程师使用C编程(我起初也是使用汇编的)，为什么?因为我们的目的是在有限的时间甚至是不充足的时间内把项目保质保量的完成！使用什么工具和方法是次要的(如果你的项目以成本放在第一位，则另当别论，这时，也是要考虑开发时间的)。时间就是金钱啊，一个产品在单片机上增加些许成本是可以接受的。况且，使用8051系列单片机时，单片机资源也常有富余，CPU一般情况也只是空转，这就为它使用RTOS创造了条件。

那么，使用RTOS的好处呢?我举一个例子吧。假设我们编一个串行通讯程序，通讯协议如下：

数据包长度为NBYTE，起始字节为STARTBYTE1,STARTBYTE2，最后一个字节为检验和，中间字节不可能出现连续出现STARTBYTE1，STARTBYTE2。

第一种方法，在中断中处理协议：

1. 
   0 X0 P! w7 m8 Z1 R  K6 V
2. unsigned char Buf[NBYTE-2];bit GetRight=0;
   # G% F6 h: b" k4 S% w
3. void comm(void) interrupt 4//"串行口中断"{
   
4. static unsigned char Sum,Flag=0,i;
   8 [: S. z6 e. f2 `/ N
5. unsigned char temp;
   # b- j2 q7 B5 ~" Z
6. if(RI==1)
   
7. {
   
8. RI=0;
   2 v7 G, B1 @" O
9. temp=SBUF;
   5 n& j: B1 @4 h. y* u
10. switch(Flag)
    
11. {
    " O! U7 {- g# k! A5 _  h& X
12. case 0:
    
13. if(temp==STARTBYTE1)
    % D' w  Q  x* n6 t
14. {
    
15. Flag=1;
    2 E8 ~. Y9 T7 ^* T9 y, L" g
16. }
    6 n. m. J, m) w
17. break;
    5 g% K- l# e$ a
18. case 1:
    
19. if(temp==STARTBYTE2)
    8 o* t) Q2 j* g2 o, u; S8 b4 N
20. {
    " e4 G, G/ |+ v: H2 T) }, @
21. Sum=STARTBYTE1+STARTBYTE2;
    & e2 z: W9 ?" U. R' c
22. i=0;
    . b. Z8 H/ P+ @) ^" E
23. Flag=2;
    3 C5 g$ [+ B" o
24. break;
    
25. }
    6 P" t8 h7 p3 T
26. if(temp==STARTBYTE1) break;
    2 R6 v7 T" c' O$ I6 R
27. Flag=0;
    
28. break;
    
29. case 2:
    7 W+ j: y$ N# C) }/ ~1 [
30. if(temp==STARTBYTE1)
    . X: B  n( F5 X9 f9 h* u+ A
31. {
    
32. Flag=3;
    
33. break;
    & P. `0 `: v  E  U2 r# i& P# B, o
34. }
    2 @" B3 _8 A* }4 l  @" |# W
35. Sum+=temp;
    
36. if((i>=(NBYTE-3))&&Sum==0)
    0 ^( f: V# B9 S* G( Y& |" c
37. {
    
38. GetRight=1;
    6 Z% |& a3 b: W0 p& l3 a
39. Flag=0;
    
40. break;
    ! v  x; G: ]8 O) u
41. }
    
42. Buf[i++]=temp;
    7 v+ V# ~2 b7 D3 D4 P! F
43. break;
    9 b8 |) W  d  h" P* |2 B
44. case 3:
    
45. if(temp==STARTBYTE2)
    
46. {
    
47. Sum=STARTBYTE1+STARTBYTE2;
    3 m& r2 v( }- R' V' x0 Z, y; r8 o1 C7 r
48. Flag=2;
    - m% d  S6 {8 ~: f2 v& W
49. i=0;
    
50. break;
    
51. }
    " K9 P  B9 z! B' u5 b
52. Sum+=STARTBYTE1;
    4 u* Q2 M  u( s
53. if((i>=(NBYTE-3))&&Sum==0)
    
54. {
    0 ?' j2 o: T' J7 w- w
55. GetRight=1;
    
56. Flag=0;
    9 k4 L/ n+ y# V+ @
57. break;
    
58. }
    
59. Buf[i++]=STARTBYTE1;
    
60. if(temp==STARTBYTE1)
    
61. {
    8 j" T& P7 U4 {4 Z7 w/ M
62. break;
    # ]/ z4 c6 P$ h. f) F0 y
63. }
      @) C9 j# B0 B1 N3 K: s
64. Sum+=temp;
    # ?. r; Y) n& h3 [3 o1 ?: h2 D
65. if((i>=(NBYTE-3))&&Sum==0)
    
66. {
    , I8 q. q7 \8 N: d) _
67. GetRight=1;
    : X5 d# n. J  \8 x8 S' l( C
68. Flag=0;
    ( o( G' P( p: p3 K5 U" H
69. break;
    ( c! w7 d( d. I. `9 d. D& B5 n
70. }
    
71. Buf[i++]=temp;
    " m6 g0 w4 a3 ?0 x) t
72. Flag=2;
    
73. break;
    
74. }
    
75. }}
    

复制代码

第二种方法，使用队列中断函数：
  v/ L8 e0 P/ i* @; f& e

1. <font color="#001000"><font style="background-color:rgb(255, 255, 255)">
   " P0 S) ], v' T7 N+ q, D0 u% W
2. void comm(void) interrupt 4//"串行口中断"{
   
3. if(RI==1)
   
4. {
   
5. RI=0;
   - d4 _! s/ s; J  V
6. SBUF 入队;
   0 [' e9 ~8 t* M! m8 J
7. }}</font></font>
   / C: P& L9 l( l; V

复制代码

主程序不断调用的函数：

1. 
   1 I% N6 Z. m+ S$ T6 P
2. unsigned char Buf[NBYTE-2];
   ' Q0 d+ S; T- J0 V+ s9 }" H
3. unsigned char ReadSerial(unsigned char *cp){
   8 G8 F8 K' x& w' Y$ `
4. unsigned char i;
   , p( Q% M& x, x* k2 P: m- b
5. unsigned char temp,Sum;
   
6. temp=队列中数据个数;
   
7. if(temp<(NBYTE)) return 0;
   
8. 出队 temp;
   
9. if(temp!=STARTBYTE1) return 0;
   
10. temp=队列首字节;
    
11. if(temp!=STARTBYTE2) return 0;
    0 i8 K* O7 x" y: Y% x, r" I4 c: e
12. 出队 temp;
    ( ~  W) e2 J: p
13. sum=STARTBYTE1+STARTBYTE2;
    4 o/ B7 Y* r4 h
14. for(i=0;i
    
15. {
    / }: J4 R4 T# q* ~
16. temp=队列首字节;
    + m+ c6 k0 M6 o3 w2 T- ]
17. if(temp==STARTBYTE1)
    ; X6 j9 N5 C& a3 z
18. {
    - u% T  U% `9 T- M8 N
19. temp=队列次首字节;
    
20. if(temp==STARTBYTE2) return 0;
    
21. }
    " n/ [! Y, j' j" t
22. 出队 temp;
    
23. *cp++=temp;
    + Q2 i- F: h. z. F
24. Sum+=temp;
    
25. }
    . S/ m) ~% |3 V% [& \% O
26. temp=队列首字节;
    
27. Sum+=temp;
    % X9 I1 i' H$ \$ }9 s
28. if(Sum!=0) return 0;
    
29. 出队 temp;
    
30. return 1;}
    

复制代码

第三种方法，使用RTOS中断函数：
  @$ K) p% \& o+ y" R; G7 s7 A

1. 
   0 C& l6 Z5 p9 v
2. void comm(void) interrupt 4//"串行口中断"{
   2 C+ H& j% p+ A- u3 ^6 p: Z
3. OS_INT_ENTER();
   , Y% w9 z: K$ M' t# j7 \+ I
4. if(RI==1)
   9 y4 U: U" _. e: Q7 Z7 y
5. {
   
6. RI=0;
   3 H! B7 r+ L8 }5 d( N+ A
7. OSIntSendSignal(RECIVE_TASK_ID);
   ; ~$ z% h8 l4 |( I7 |2 |
8. }
   # y6 q' [: `+ V. Q8 m! `
9. OSIntExit();}
   ! {) \* W: I- J. M
10. ID为RECIVE_TASK_ID的任务
    
11. void Recuve(void){
    8 h. b; F+ M" |7 ?. k
12. unsigned char temp,temp1,Sum,i;
    . @7 V; P7 s0 \
13. OSWait(K_SIG,0);
    ! D9 B+ T6 Y# x% ?8 E
14. temp=SBUF;
    
15. while(1)
    
16. {
    9 D/ F. H( L* e7 @
17. while(1)
    ( p1 P4 A9 P# _' w1 Q2 D
18. {
    
19. OSWait(K_SIG,0);
    
20. temp1=SBUF;
    
21. if((temp==STARTBYTE1)&&(temp1==STARTBYTE2)) break;
    , w% v! I5 ^9 e9 w
22. temp=temp1;
    
23. }
    
24. Sum=STARTBYTE1+STARTBYTE2;
    1 j0 S) |1 `2 g) p
25. OSWait(K_SIG,0);
    / M1 l7 ]4 F% f+ Z+ Y
26. temp=SBUF;
    / u+ s, G! U  _# m/ i5 N
27. for(i=0;i
    + [  _) Y$ V& K/ H6 h
28. {
    
29. OSWait(K_SIG,0);
    
30. temp1=SBUF;
    ) e2 x& Z2 u( Y, z" i& K, H
31. if((temp==STARTBYTE1)&&(temp1==STARTBYTE2))
    
32. {
      R( n  h2 K$ y% N7 ?: i
33. OSWait(K_SIG,0);
    & N& Y, D2 i* S
34. temp=SBUF;
    5 `& ]" R5 ^7 z5 X6 M! ^" G1 t
35. i=-1;
    6 O7 r. [% V3 F1 ?
36. Sum=STARTBYTE1+STARTBYTE2;
    
37. continue;
    
38. }
    
39. Buf[i]=temp;
    
40. Sum+=temp;
    
41. temp=temp1;
    
42. }
    & h" t, ?# j& T% {9 R* i
43. Sum+=temp1;
    ; P5 E9 Z2 y3 |0 h0 Y
44. if(Sum==0) OSSendSignal(命令解释任务 ID);
    
45. }}

复制代码

8 V6 R. U+ f6 Z' F

以下为这几种方法的比较：

4 L5 o$ ?! }5 K( |- C( b! C

可读性和编程容易性方面，第三钟方法最好(如果允许使用goto语句，程序更加简单易读)，第二种次之(因为要编队列程序)，第一种最差。如果协议更加复杂，这方面更加明显。程序简单易读，自然出错机会小了。

RAM占用方面，第三种方法较少，第二种最多(因为队列占用大量空间)，第一种最少。

中断执行时间方面，第三种方法最长，第二种最短，第一种较长。

从功能方面，第三种方法最强，它还可以进行超时处理(虽然例子程序没有)，其它方法均不行。

如果数据来的太快，命令处理程序来不及处理，三种方法处理方式不太一样，第一种和第三种方法类似：丢弃以前数据，第二种则是丢弃后到的数据。而且，第二种方法必须等命令处理程序完成后才处理下一个数据包，而第一种和第三种方只需命令处理程序将数据收取后就可处理下一个数据包。也就是说，第一种和第三种与命令处理程序并行处理，第二种方法为串行处理。

现在，一般情况下，开发的效率第一，执行的效率(包括执行时间和资源占用)第二。在这种情况下，降低些许效率换取开发的效率的较大提高，何乐而不为?何况，单个模块的执行的效率高不等于整个程序执行效率高。例如，如果程序需要等待一段时间，一般用程序延时或定时器延时。无论何种方法，CPU不再处理其它工作，效率很低。而用RTOS，等待的时候CPU可以处理其它工作，效率得到提高。

6 \& N% X( T' P, `3 |

以下摘自《uC/OS-II--源码公开的实时嵌入式操作系统》

! b$ C, }% v3 v1 H- H

“实时内核也称为实时操作系统或RTOS。使用它使得实时应用程序的设计和扩展变得容易。不需要大的改动就可以增加新的功能。通过应用程序分割为若干独立的任务，RTOS使得应用程序的设计过程大为简化。使用可剥夺性的内核时，所有时间要求苛刻的事件都得到了尽可能快捷、有效的处理。通过有效的服务；如信号量、邮箱、队列、延时、超时等；RTOS使得资源得到更好的利用。

8 Y% m, U; g9 [( H5 {0 `+ D

“如果应用项目对额外的需求可以承受，应该考虑使用实时内核。这些额外的需求是：内核的价格，额外ROM/RAM开销，2至4百分点的CPU额外负担。

“还有没提到的一个因素是使用实时内核增加的价格成本。在一些应用中，价格就是一切，以至于对使用RTOS连想都不敢想。”

总而言之，适用的就是最好的，不要拒绝RTOS，在它适用的情况下，它工作得很好。

: K. h! k' F4 k6 B+ A9 }