最好从编译出来的汇编代码来比较

1. 
   
2.   20          void delayus(unsigned char i)
   
3.   21          {
   
4.   22   1        while(i--);
   
5.   23   1      }
   
6.   24          void delayu(unsigned char i)
   
7.   25          {
   
8.   26   1        unsigned char a;
   
9.   27   1        for(a=0; a<i; a++)
   
10.   28   1        {
    
11.   29   2          _nop_();
    
12.   30   2        }
    
13.   31   1      }
    
14. 
    
15. 下面来说说汇编的传统计算方法：
    
16. 
    
17. 
    
18. 指令周期、机器周期与时钟周期
    
19.        指令周期：CPU执行一条指令所需要的时间称为指令周期，它是以机器周期为单位的，指令不同，所需的机器周期也不同。
    
20.        时钟周期：也称为振荡周期，一个时钟周期 ＝晶振的倒数。
    
21.        MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。
    
22.        MCS-单片机的指令有单字节、双字节和三字节的，它们的指令周期不尽相同，一个单周期指令包含一个机器周期，即12个时钟周期，所以一条单周期指令被执行所占时间为12*（1/12000000）=1us。
    
23. 
    
24. 了解了上面这些我们来看一个例子
    
25. 
    
26. 汇编延时子程序的延时计算问题
    
27. 对于程序
    
28.              ; FUNCTION _delayus (BEGIN)
    
29.                                            ; SOURCE LINE # 20
    
30. ;---- Variable 'i' assigned to Register 'R7' ----
    
31.                                            ; SOURCE LINE # 21
    
32.     ?C0008:
    
33.                                                                                         ; SOURCE LINE # 22
    
34.               MOV     R6,AR7 ;2指令周期
    
35.               DEC     R7     ;1指令周期
    
36.               MOV     A,R6   ;1指令周期
    
37.               JNZ     ?C0008 ;2指令周期
    
38.     ?C0009:
    
39.                                                                                         ; SOURCE LINE # 23
    
40.     ?C0010:
    
41.               RET            ;2指令周期
    
42.     ; FUNCTION _delayus (END)
    
43. 
    
44. R7 * (2+1+1+2) + 2
    
45. 整个循环执行完应该是 =(R7 * 6) + 2  指令周期
    
46. 
    
47. 
    
48.              ; FUNCTION _delayu (BEGIN)
    
49.                                            ; SOURCE LINE # 24
    
50. ;---- Variable 'i' assigned to Register 'R7' ----
    
51.                                            ; SOURCE LINE # 25
    
52.                                            ; SOURCE LINE # 27
    
53. ;---- Variable 'a' assigned to Register 'R6' ----
    
54.               CLR     A       ;1指令周期
    
55.               MOV     R6,A    ;1指令周期
    
56.     ?C0011:
    
57.               MOV     A,R6    ;1指令周期
    
58.               CLR     C       ;1指令周期
    
59.               SUBB    A,R7    ;1指令周期
    
60.               JNC     ?C0014  ;2指令周期
    
61.                                   ; SOURCE LINE # 28
    
62.                                   ; SOURCE LINE # 29
    
63.               NOP             ;1指令周期
    
64.                                   ; SOURCE LINE # 30
    
65.               INC     R6      ;1指令周期
    
66.               SJMP    ?C0011  ;2指令周期
    
67.                                   ; SOURCE LINE # 31
    
68.     ?C0014:
    
69.               RET             ;2指令周期
    
70.     ; FUNCTION _delayu (END)
    
71. 
    
72. (1+1+1+2)+ R7 *  (1+1+2+1+1+1+2) +1 +1 +2
    
73. 整个循环执行完应该是        = (R7 * 9) + 9  指令周期
    
74. 
    
75. 
    
76. 还说明一下：
    
77. 
    
78. nop指令或者_nop_(); 函数占一个机器周期，
    
79.    在stc单片机的12T模式下一个机器周期是一个振荡周期的12分频，如果你的晶振是12MHZ，那你的一个机器周期就是1微秒．一个nop指令的执行时间也就是1US
    
80. 
    
81.    当在6T模式(下载的时候可选择模式)下12M晶振的时候,一个nop就是0.5US了.
    
82. 
    
83. 
    

复制代码

肯定delayus(55)比delayu（55）延时时间更长啊。 _nop_是空操作，占用一个指令周期，while（i--）还有判断、自减操作，是好几个指令周期

12m晶振下，你的delayu（）执行一次就10us+了。

最好从编译出来的汇编代码来比较，看每个循环执行用了几个指令周期

肯定delayus(55)比delayu（55）延时时间更长啊。
_nop_是空操作，占用一个指令周期，while（i--）还有判断、自减操作，是好几个指令周期。

直接进入调试模式，看看执行一次需要多长时间，这样做演示函数不能理所当然的，要模拟。

你怎么知道是55us，仿真了吗？

delayus(55)不一定是55us,delayu（55）更加不是55us了,在C语言中的延时程序很难控制到us,只是使用延时程序能够满足DS18B20的读写时序关系就能读出或写入数据,你使用两种不同的延时,肯定有一种不符合读写时序

循环的效果是一样的，前者没有写 _nop_() 后者则写，，，，，写了_nop_()更标准一些