C51由于其可读性和可移植性很强，在单片机中得到广泛的运用，但在某些时分由于C51编写的程序对在有准确时刻要求下，或许就得要用汇编言语来编写，但在C51是否也能完结时刻的准确操控呢？答案是必定的。
在C51中要完结对时刻的准确延时有以下几种办法
其一：关于延时很短的，要求在us级的，选用“_nop_”函数，这个函数适当汇编NOP指令，延时几微秒，就刺进个这样的函数。
其二：关于延时比较长的，要求在大于10us，选用C51中的循环句子来完结。
在挑选C51中循环句子时，要留意以下几个问题
榜首、界说的C51中循环变量，尽量选用无符号字符型变量。
第二、在FOR循环句子中，尽量选用变量减减来做循环。
第三、在do…while，while句子中，循环体内变量也选用减减办法。
这由于在C51编译器中，对不同的循环办法，选用不同的指令来完结的。下面举例说明：
unsigned char I;
for(i=0;i<255;i++);
unsigned char I;
for(i=255;i>0;i–);
其间，第二个循环句子C51编译后，就用DJNZ指令来完结，适当于如下指令：
MOV 09H，＃0FFH
LOOP： DJNZ 09H，LOOP
指令适当简练，也很好核算准确的延时时刻。
相同对do…while，while循环句子中，也是如此
例：
unsigned char n;
n=255;
do{n–}
while(n);
或
n=255;
while(n)
{n–};
这两个循环句子经过C51编译之后，构成DJNZ来完结的办法，故其准确时刻的核算也很便利。
其三：关于要求准确延时时刻更长，这时就要选用循环嵌套的办法来完结，因而，循环嵌套的办法常用于到达ms级的延时。
关于循环句子相同能够选用for，do…while，while结构来完结，每个循环体内的变量依然选用无符号字符变量。
unsigned char i,j
for(i=255;i>0;i–)
for(j=255;j>0;j–);
或
unsigned char i,j
i=255;
do{j=255;
do{j–}
while(j);
i–;
}
while(i);
或
unsigned char i,j
i=255;
while(i)
{j=255;
while(j)
{j–};
i–;
}
这三种办法都是用DJNZ指令嵌套完结循环的，由C51编译器用下面的指令组合来完结的
MOV R7，＃0FFH
LOOP2： MOV R6，＃0FFH
LOOP1： DJNZ R6，LOOP1
DJNZ R7，LOOP2
这些指令的组合在汇编言语中选用DJNZ指令来做延时用，因而它的时刻准确核算也是很简略，假上面变量i的初值为m，变量j的初值为n，则总延时时刻为：m×（n×T＋T），其间T为DJNZ指令履行时刻。
相同关于更长时刻的延时，能够选用多重循环来完结。只需在程序设计循环句子时留意以上几个问题。
下面给出有关在C51中延时子程序设计时要留意的问题
1、在C51中进行准确的延时子程序设计时，尽量不要或少在延时子程序中界说局部变量，一切的延时子程序中变量经过有参函数传递。
2、在延时子程序设计时，选用do…while，结构做循环体要比for结构做循环体好。
3、在延时子程序设计时，要进行循环体嵌套时，选用先内循环，再减减比先减减，再内循环要好。
unsigned char delay(unsigned char i,unsigned char j,unsigned char k)
{unsigned char b,c;
b=j;
c=k;
do{
do{
do{k–};
while(k);
k=c;
j–;};
while(j);
j=b;
i–;};
while(i);
}
这准确延时子程序就被C51编译为有下面的指令组合完结
delay延时子程序如下：
MOV R6，05H
MOV R4，03H
C0012： DJNZ R3， C0012
MOV R3，04H
DJNZ R5， C0012
MOV R5，06H
DJNZ R7， C0012
RET
假定参数变量i的初值为m，参数变量j的初值为n，参数变量k的初值为l，则总延时时刻为：l×（n×（m×T＋2T）＋2T）＋3T，其间T为DJNZ和MOV指令履行的时刻。当m=n=l时，准确延时为9T，最短；当m=n=l=256时，准确延时到16908803T，最长。
选用软件守时的核算办法
运用指令履行周期设定，以下为一段延时程序：
指令 周期
MOV 1
DJNZ 2
NOP 1
选用循环办法守时，有程序：
MOV R5,#TIME2 ;周期1
LOOP1: MOV R6,#TIME1 ; 1
LOOP2: NOP ; 1
NOP ; 1
DJNZ R6,LOOP2 ; 2
DJNZ R5,LOOP1 ; 2
守时数=(TIME1*4+2+1)*TIM2*2+4
==============================================================================
[转帖]Keil C51 延时程序的两次研讨
51单片机 Keil C 延时程序的简略研讨
运用单片机的时分，常常会遇到需求短时刻延时的状况。需求的延时时刻很短，一般都是几十到几百(us)。有时分还需求很高的精度，比方用单片机驱动DS18B20的时分，差错容许的规模在十几us以内，否则很简略犯错。这种状况下，用计时器往往有点小题大做。而在极点的状况下，计时器乃至现已悉数派上了其他用处。这时就需求咱们另想其他办法了。 曾经用汇编言语写单片机程序的时分，这个问题仍是相对简略处理的。比方用的是12MHz晶振的51，计划延时20us，只需用下面的代码，就能够满意一般的需求：
mov r0, #09h loop:
djnz r0, loop
51单片机的指令周期是晶振频率的1/12，也便是1us一个周期。mov r0, #09h需求2个极端周期，djnz也需求2个极端周期。那么存在r0里的数便是(20-2)/2。用这种办法，能够十分便利的完结256us以下时刻的延时。假如需求更长时刻，能够运用两层嵌套。并且精度能够到达2us，一般来说，这现已足够了。 现在，运用更广泛的毫无疑问是Keil的C编译器。相对汇编来说，C固然有许多长处，比方程序易保护，便于了解，合适大的项目。但缺陷（我觉得这是C的仅有一个缺陷了）便是实时性没有确保，无法猜测代码履行的指令周期。因而在实时性要求高的场合，还需求汇编和C的联合运用。可是是不是这样一个延时程序，也需求用汇编来完结呢？为了找到这个答案，我做了一个试验。
用C言语完结延时程序，首要想到的便是C常用的循环句子。下面这段代码是我常常在网上看到的：
void delay2(unsigned char i)
{ for(; i != 0; i–); }
究竟这段代码能到达多高的精度呢？为了直接衡量这段代码的作用，我把 Keil C 依据这段代码发生的汇编代码找了出来：
FUNCTION _delay2 (BEGIN)
SOURCE LINE # 18
—- Variable i assigned to Register R7 —-
SOURCE LINE # 19
SOURCE LINE # 20
0000 ?C0007:
0000 EF MOV A,R7
0001 6003 JZ ?C0010
0003 1F DEC R7
0004 80FA SJMP ?C0007
SOURCE LINE # 21
0006 ?C0010:
0006 22 RET
FUNCTION _delay2 (END)
真是不看不知道~~~一看才知道这个延时程序是多么的不准点~~~光看首要的那四条句子，就需求6个机器周期。也便是说，它的精度顶多也便是6us罢了，这还没算上一条 lcall 和一条 ret。假如咱们把调用函数时赋的i值根延时长度列一个表的话，便是：
i delay time/us
0 6
1 12
2 18
…
由于函数的调用需求2个时钟周期的lcall，所以delay time比从函数代码的履行时刻多2。趁便提一下，有的朋友写的是这样的代码：
void delay2(unsigned char i)
{
unsigned char a;
for(a = i; a != 0; a–);
}
或许有人以为这会生成更长的汇编代码来，可是事实证明：
FUNCTION _delay2 (BEGIN)
SOURCE LINE # 18
—- Variable i assigned to Register R7 —-
SOURCE LINE # 19
SOURCE LINE # 21
—- Variable a assigned to Register R7 —-
0000 ?C0007:
0000 EF MOV A,R7
0001 6003 JZ ?C0010
0003 1F DEC R7
0004 80FA SJMP ?C0007
SOURCE LINE # 22
0006 ?C0010:
0006 22 RET
FUNCTION _delay2 (END)
其生成的代码是相同的。不过这确实不是什么好的习气。由于这儿真实没有必要再引进剩余的变量。咱们持续评论正题。有的朋友为了妥当更长的延时，乃至用了这样的代码：
void delay2(unsigned long i)
{
for(; i != 0; i–);
}
这段代码发生的汇编代码是什么姿态的？其实不必想也知道它是怎么恐惧的$#^%&%$……让咱们看一看：
FUNCTION _delay2 (BEGIN)
SOURCE LINE # 18
0000 8F00 R
MOV i+03H,R7
0002 8E00 R
MOV i+02H,R6
0004 8D00 R
MOV i+01H,R5
0006 8C00 R
MOV i,R4
SOURCE LINE # 19
SOURCE LINE # 20
0008 ?C0007:
0008 E4 CLR A
0009 FF MOV R7,A
000A FE MOV R6,A
000B FD MOV R5,A
000C FC MOV R4,A
000D AB00 R MOV R3,i+03H
000F AA00 R MOV R2,i+02H
0011 A900 R MOV R1,i+01H
0013 A800 R MOV R0,i
0015 C3 CLR C
0016 120000 E LCALL ?C?ULCMP
0019 601A JZ ?C0010
001B E500 R MOV A,i+03H
001D 24FF ADD A,#0FFH
001F F500 R MOV i+03H,A
0021 E500 R MOV A,i+02H
0023 34FF ADDC A,#0FFH
0025 F500 R MOV i+02H,A
0027 E500 R MOV A,i+01H
0029 34FF ADDC A,#0FFH
002B F500 R MOV i+01H,A
002D E500 R MOV A,i
002F 34FF ADDC A,#0FFH
0031 F500 R MOV i,A
0033 80D3 SJMP ?C0007
SOURCE LINE # 21
0035 ?C0010:
0035 22 RET
FUNCTION _delay2 (END)
呵呵，这倒是确实能够推迟很长时刻~~~可是毫无精度可言了。 那么，用C究竟能不能完结准确的延时呢？我把代码略微改了一下：
void delay1(unsigned char i)
{
while(i–);
}
由于依据经历，越简练的C代码往往也能得出越简练的机器代码。那这样成果怎么呢？把它生成的汇编代码拿出来看一看就知道了。满怀希望的我按下了“Build target”键，成果冲击是巨大的：
FUNCTION _delay1 (BEGIN)
SOURCE LINE # 13
—- Variable i assigned to Register R7 —-
SOURCE LINE # 14
0000 ?C0004:
SOURCE LINE # 15
0000 AE07 MOV R6,AR7
0002 1F DEC R7
0003 EE MOV A,R6
0004 70FA JNZ ?C0004
SOURCE LINE # 16
0006 ?C0006:
0006 22 RET
FUNCTION _delay1 (END)
虽然生成的代码跟用for句子是不大相同，不过我能够毫无疑问的说，这两种办法的功率是相同的。好像到此为止了，由于我真实想不出来历程序还有什么简化的地步。看来我就要得出来这个定论了：“假如需求us级的延时精度，需求时用汇编言语。”可是真的是这样吗？我仍是不甘心。由于我不信任大名鼎鼎的 Keil C 编译器竟然连 djnz 都不会用？？？由于实践上程序体里只需求一句 loop: djnz r7, loop。近乎失望之际（往往人在这种状况下确能够迸发出来，哦呵呵呵~~~），我顺手改了一下：
void delay1(unsigned char i)
{
while(–i);
}
心猿意马的编译，看源码：
FUNCTION _delay1 (BEGIN)
SOURCE LINE # 13
—- Variable i assigned to Register R7 —-
SOURCE LINE # 14
0000 ?C0004:
SOURCE LINE # 15
0000 DFFE DJNZ R7,?C0004
SOURCE LINE # 16
0002 ?C0006:
0002 22 RET
FUNCTION _delay1 (END)
天~~~奇观呈现了……我想这个程序应该现已能够满意一般状况下的需求了。假如列个表格的话：
i delay time/us
1 5
2 7
3 9 …
核算延时时刻时，现已算上了调用函数的lcall句子所花的2个时钟周期的时刻。 总算，成果现已明了了。只需合理的运用，C仍是能够到达意想不到的作用。许多朋友诉苦C功率比汇编差了许多，其实假如对Keil C的编译原理有一个较深化的了解，是能够经过恰当的语法运用，让生成的C代码到达最优化。即便这看起来不大或许，但仍是有一些简略的准则可循的：
1.尽量运用unsigned型的数据结构。
2.尽量运用char型，真实不够用再用int，然后才是long。
3.假如有或许，不要用浮点型。
4.运用简练的代码，由于依照经历，简练的C代码往往能够生成简练的方针代码（虽然不是在一切的状况下都建立）。
5…想不起来了，哦呵呵呵~~~
===============================================================================
C51准确延时程序
C51准确延时程序再抛砖
//我看到的当地也是从其他当地转贴，所以我不知道原作者是谁，但信任这么老练的东西转一下他也不会见意。
看到了个好帖，我在此在它得基础上再抛抛砖！
有个好帖，从精度考虑，它得研讨成果是：
void delay2(unsigned char i)
{
while(–i);
}
为最佳办法。
剖析：假定外挂12M（之后都是在这基础上评论）
我编译了下，传了些参数，并看了汇编代码，调查记录了下面的数据：
delay2(0):延时518us 518-2*256=6
delay2(1):延时7us（原帖写“5us”是错的，^_^）
delay2(10):延时25us 25-20=5
delay2(20):延时45us 45-40=5
delay2(100):延时205us 205-200=5
delay2(200):延时405us 405-400=5
见上可得可调度为2us，而最大差错为6us。
精度是很高了！
但这个程序的最大延时是为518us 明显不
能满意实践需求，由于许多时分需求推迟比较长的时刻。
那么，接下来评论将t分配为两个字节，即uint型的时分，会呈现什么状况。
void delay8(uint t)
{
while(–t);
}
我编译了下，传了些参数，并看了汇编代码，调查记录了下面的数据：
delay8(0):延时524551us 524551-8*65536=263
delay8(1):延时15us
delay8(10):延时85us 85-80=5
delay8(100):延时806us 806-800=6
delay8(1000):延时8009us 8009-8000=9
delay8(10000):延时80045us 80045-8000=45
delay8(65535):延时524542us 524542-524280=262
假如把这个程序的可调度看为8us，那么最大差错为263us，但这个延时程序仍是不能满意要求的，由于延时最大为524.551ms。
那么用ulong t呢？
必定很恐惧，不必看编译后的汇编代码了。。。
那么怎么得到比较小的可调度，可调规模大，并占用比较少得RAM呢？请看下面的程序：
/*——————————————————————–
程序称号：50us 延时
留意事项：根据1MIPS，AT89系列对应12M晶振，W77、W78系列对应3M晶振
比如提示：调用delay_50us（20），得到1ms延时
全局变量：无
回来： 无
——————————————————————–*/
void delay_50us(uint t)
{
uchar j;
for(;t>0;t–)
for(j=19;j>0;j–)
;
}
我编译了下，传了些参数，并看了汇编代码，调查记录了下面的数据：
delay_50us(1):延时63us 63-50=13
delay_50us(10):延时513us 503-500=13
delay_50us(100):延时5013us 5013-5000=13
delay_50us(1000):延时50022us 50022-50000=22
赫赫，延时50ms，差错只是22us，作为C言语现已是能够承受了。再说要求再准确的话，就算是用汇编也得改用守时器了。
/*——————————————————————–
程序称号：50ms 延时
留意事项：根据1MIPS，AT89系列对应12M晶振，W77、W78系列对应3M晶振
比如提示：调用delay_50ms（20），得到1s延时
全局变量：无
回来： 无
——————————————————————–*/
void delay_50ms(uint t)
{
uint j;
/****
能够在此加少量延时补偿，以祢补大数值传递时（如delay_50ms(1000)）形成的差错，
但支付的价值是形成传递小数值（delay_50ms(1)）形成更大的差错。
由于实践运用更多时分是传递小数值，所以补主张加补偿！
****/
for(;t>0;t–)
for(j=6245;j>0;j–)
;
}
我编译了下，传了些参数，并看了汇编代码，调查记录了下面的数据：
delay_50ms(1):延时50 010 10us
delay_50ms(10):延时499 983 17us
delay_50ms(100):延时4 999 713 287us
delay_50ms(1000):延时4 997 022 2.978ms
赫赫，延时50s，差错只是2.978ms，能够承受！
上面程序没有才用long，也没选用3层以上的循环，而是将延时分拆为两个程序以进步精度。应该是比较好的做法了。
