在C51中要實現(xiàn)對時間的精確延時有以下幾種方法
其一：對于延時很短的，要求在us級的，采用“_nop_”函數(shù)，這個函數(shù)相當(dāng)匯編NOP指令，延時幾微秒，就插入個這樣的函數(shù)。
其二：對于延時比較長的，要求在大于10us，采用C51中的循環(huán)語句來實現(xiàn)。
在選擇C51中循環(huán)語句時，要注意以下幾個問題
第一、定義的C51中循環(huán)變量，盡量采用無符號字符型變量。
第二、在FOR循環(huán)語句中，盡量采用變量減減來做循環(huán)。
第三、在do…while，while語句中，循環(huán)體內(nèi)變量也采用減減方法。
這因為在C51編譯器中，對不同的循環(huán)方法，采用不同的指令來完成的。下面舉例說明：
unsigned char I;
for(i=0;i<255;i++);

unsigned char I;
for(i=255;i>0;i--);
其中，第二個循環(huán)語句C51編譯后，就用DJNZ指令來完成，相當(dāng)于如下指令：
MOV　09H，＃0FFH
LOOP： DJNZ　09H，LOOP
指令相當(dāng)簡潔，也很好計算精確的延時時間。
同樣對do…while，while循環(huán)語句中，也是如此
例：
unsigned char n;
n=255;
do{n--}
while(n);
或
n=255;
while(n)
{n--};
這兩個循環(huán)語句經(jīng)過C51編譯之后，形成DJNZ來完成的方法，故其精確時間的計算也很方便。
其三：對于要求精確延時時間更長，這時就要采用循環(huán)嵌套的方法來實現(xiàn)，因此，循環(huán)嵌套的方法常用于達(dá)到ms級的延時。
對于循環(huán)語句同樣可以采用for，do…while，while結(jié)構(gòu)來完成，每個循環(huán)體內(nèi)的變量仍然采用無符號字符變量。
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指令嵌套實現(xiàn)循環(huán)的，由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指令執(zhí)行時間。
同樣對于更長時間的延時，可以采用多重循環(huán)來完成。只要在程序設(shè)計循環(huán)語句時注意以上幾個問題。
下面給出有關(guān)在C51中延時子程序設(shè)計時要注意的問題
1、在C51中進(jìn)行精確的延時子程序設(shè)計時，盡量不要或少在延時子程序中定義局部變量，所有的延時子程序中變量通過有參函數(shù)傳遞。
2、在延時子程序設(shè)計時，采用do…while，結(jié)構(gòu)做循環(huán)體要比for結(jié)構(gòu)做循環(huán)體好。
3、在延時子程序設(shè)計時，要進(jìn)行循環(huán)體嵌套時，采用先內(nèi)循環(huán)，再減減比先減減，再內(nèi)循環(huán)要好。
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
假設(shè)參數(shù)變量i的初值為m，參數(shù)變量j的初值為n，參數(shù)變量k的初值為l，則總延時時間為：l×（n×（m×T＋2T）＋2T）＋3T，其中T為DJNZ和MOV指令執(zhí)行的時間。當(dāng)m=n=l時，精確延時為9T，最短；當(dāng)m=n=l=256時，精確延時到16908803T，最長。

采用軟件定時的計算方法

利用指令執(zhí)行周期設(shè)定，以下為一段延時程序：
指令 周期
MOV 1
DJNZ 2
NOP 1
采用循環(huán)方式定時，有程序：
MOV R5,#TIME2 ;周期1
LOOP1: MOV R6,#TIME1 ; 1
LOOP2: NOP ; 1
NOP ; 1
DJNZ R6,LOOP2 ; 2
DJNZ R5,LOOP1 ; 2
定時數(shù)=(TIME1*4+2+1)*TIM2*2+4

==============================================================================

[轉(zhuǎn)帖]Keil C51 延時程序的兩次研究
51單片機 Keil C 延時程序的簡單研究

應(yīng)用單片機的時候，經(jīng)常會遇到需要短時間延時的情況。需要的延時時間很短，一般都是幾十到幾百(us)。有時候還需要很高的精度，比如用單片機驅(qū)動DS18B20的時候，誤差容許的范圍在十幾us以內(nèi)，不然很容易出錯。這種情況下，用計時器往往有點小題大做。而在極端的情況下，計時器甚至已經(jīng)全部派上了別的用途。這時就需要我們另想別的辦法了。 以前用匯編語言寫單片機程序的時候，這個問題還是相對容易解決的。比如用的是12MHz晶振的51，打算延時20us，只要用下面的代碼，就可以滿足一般的需要：
mov r0, #09h loop:
djnz r0, loop
51單片機的指令周期是晶振頻率的1/12，也就是1us一個周期。mov r0, #09h需要2個極其周期，djnz也需要2個極其周期。那么存在r0里的數(shù)就是(20-2)/2。用這種方法，可以非常方便的實現(xiàn)256us以下時間的延時。如果需要更長時間，可以使用兩層嵌套。而且精度可以達(dá)到2us，一般來說，這已經(jīng)足夠了。 現(xiàn)在，應(yīng)用更廣泛的毫無疑問是Keil的C編譯器。相對匯編來說，C固然有很多優(yōu)點，比如程序易維護(hù)，便于理解，適合大的項目。但缺點（我覺得這是C的唯一一個缺點了）就是實時性沒有保證，無法預(yù)測代碼執(zhí)行的指令周期。因而在實時性要求高的場合，還需要匯編和C的聯(lián)合應(yīng)用。但是是不是這樣一個延時程序，也需要用匯編來實現(xiàn)呢？為了找到這個答案，我做了一個實驗。
用C語言實現(xiàn)延時程序，首先想到的就是C常用的循環(huán)語句。下面這段代碼是我經(jīng)常在網(wǎng)上看到的：
void delay2(unsigned char i)
{ for(; i != 0; i--); }
到底這段代碼能達(dá)到多高的精度呢？為了直接衡量這段代碼的效果，我把 Keil C 根據(jù)這段代碼產(chǎn)生的匯編代碼找了出來：
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)
真是不看不知道~~~一看才知道這個延時程序是多么的不準(zhǔn)點~~~光看主要的那四條語句，就需要6個機器周期。也就是說，它的精度頂多也就是6us而已，這還沒算上一條 lcall 和一條 ret。如果我們把調(diào)用函數(shù)時賦的i值根延時長度列一個表的話，就是：
i delay time/us
0 6
1 12
2 18
...
因為函數(shù)的調(diào)用需要2個時鐘周期的lcall，所以delay time比從函數(shù)代碼的執(zhí)行時間多2。順便提一下，有的朋友寫的是這樣的代碼：
void delay2(unsigned char i)
{
unsigned char a;
for(a = i; a != 0; a--);
}
可能有人認(rèn)為這會生成更長的匯編代碼來，但是事實證明：
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)
其生成的代碼是一樣的。不過這的確不是什么好的習(xí)慣。因為這里實在沒有必要再引入多余的變量。我們繼續(xù)討論正題。有的朋友為了得當(dāng)更長的延時，甚至用了這樣的代碼：
void delay2(unsigned long i)
{
for(; i != 0; i--);
}
這段代碼產(chǎn)生的匯編代碼是什么樣子的？其實不用想也知道它是如何恐怖的$#^%&%$......讓我們看一看：
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到底能不能實現(xiàn)精確的延時呢？我把代碼稍微改了一下：
void delay1(unsigned char i)
{
while(i--);
}
因為根據(jù)經(jīng)驗，越簡潔的C代碼往往也能得出越簡潔的機器代碼。那這樣結(jié)果如何呢？把它生成的匯編代碼拿出來看一看就知道了。滿懷希望的我按下了“Build target”鍵，結(jié)果打擊是巨大的：
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語句是不大一樣，不過我可以毫無疑問的說，這兩種方法的效率是一樣的。似乎到此為止了，因為我實在想不出來源程序還有什么簡化的余地。看來我就要得出來這個結(jié)論了：“如果需要us級的延時精度，需要時用匯編語言。”但是真的是這樣嗎？我還是不甘心。因為我不相信大名鼎鼎的 Keil C 編譯器居然連 djnz 都不會用？？？因為實際上程序體里只需要一句 loop: djnz r7, loop。近乎絕望之際（往往人在這種情況下確可以爆發(fā)出來，哦呵呵呵~~~），我隨手改了一下：
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)
天~~~奇跡出現(xiàn)了......我想這個程序應(yīng)該已經(jīng)可以滿足一般情況下的需要了。如果列個表格的話：
i delay time/us
1 5
2 7
3 9 ...
計算延時時間時，已經(jīng)算上了調(diào)用函數(shù)的lcall語句所花的2個時鐘周期的時間。 終于，結(jié)果已經(jīng)明了了。只要合理的運用，C還是可以達(dá)到意想不到的效果。很多朋友抱怨C效率比匯編差了很多，其實如果對Keil C的編譯原理有一個較深入的理解，是可以通過恰當(dāng)?shù)恼Z法運用，讓生成的C代碼達(dá)到最優(yōu)化。即使這看起來不大可能，但還是有一些簡單的原則可循的：
1.盡量使用unsigned型的數(shù)據(jù)結(jié)構(gòu)。
2.盡量使用char型，實在不夠用再用int，然后才是long。
3.如果有可能，不要用浮點型。
4.使用簡潔的代碼，因為按照經(jīng)驗，簡潔的C代碼往往可以生成簡潔的目標(biāo)代碼（雖說不是在所有的情況下都成立）。
5...想不起來了，哦呵呵呵~~~
===============================================================================

C51精確延時程序

C51精確延時程序再拋磚
//我看到的地方也是從別的地方轉(zhuǎn)貼，所以我不知道原作者是誰，但相信這么成熟的東西轉(zhuǎn)一下他也不會見意。

看到了個好帖，我在此在它得基礎(chǔ)上再拋拋磚！

有個好帖，從精度考慮，它得研究結(jié)果是：
void delay2(unsigned char i)
{
while(--i);
}
為最佳方法。

分析：假設(shè)外掛12M（之后都是在這基礎(chǔ)上討論）
我編譯了下，傳了些參數(shù)，并看了匯編代碼，觀察記錄了下面的數(shù)據(jù)：
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

見上可得可調(diào)度為2us，而最大誤差為6us。
精度是很高了！

但這個程序的最大延時是為518us 顯然不
能滿足實際需要，因為很多時候需要延遲比較長的時間。

那么，接下來討論將t分配為兩個字節(jié)，即uint型的時候，會出現(xiàn)什么情況。

void delay8(uint t)
{
while(--t);
}
我編譯了下，傳了些參數(shù)，并看了匯編代碼，觀察記錄了下面的數(shù)據(jù)：
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

如果把這個程序的可調(diào)度看為8us，那么最大誤差為263us，但這個延時程序還是不能滿足要求的，因為延時最大為524.551ms。

那么用ulong t呢？
一定很恐怖，不用看編譯后的匯編代碼了。。。

那么如何得到比較小的可調(diào)度，可調(diào)范圍大，并占用比較少得RAM呢？請看下面的程序：

/*--------------------------------------------------------------------
程序名稱：50us 延時
注意事項：基于1MIPS，AT89系列對應(yīng)12M晶振，W77、W78系列對應(yīng)3M晶振
例子提示：調(diào)用delay_50us（20），得到1ms延時
全局變量：無
返回： 無
--------------------------------------------------------------------*/
void delay_50us(uint t)
{
uchar j;
for(;t>0;t--)
for(j=19;j>0;j--)
;
}

我編譯了下，傳了些參數(shù)，并看了匯編代碼，觀察記錄了下面的數(shù)據(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語言已經(jīng)是可以接受了。再說要求再精確的話，就算是用匯編也得改用定時器了。

/*--------------------------------------------------------------------
程序名稱：50ms 延時
注意事項：基于1MIPS，AT89系列對應(yīng)12M晶振，W77、W78系列對應(yīng)3M晶振
例子提示：調(diào)用delay_50ms（20），得到1s延時
全局變量：無
返回： 無
--------------------------------------------------------------------*/
void delay_50ms(uint t)
{
uint j;
/****
可以在此加少許延時補償，以禰補大數(shù)值傳遞時（如delay_50ms(1000)）造成的誤差，
但付出的代價是造成傳遞小數(shù)值（delay_50ms(1)）造成更大的誤差。
因為實際應(yīng)用更多時候是傳遞小數(shù)值，所以補建議加補償！
****/
for(;t>0;t--)
for(j=6245;j>0;j--)
;
}
我編譯了下，傳了些參數(shù)，并看了匯編代碼，觀察記錄了下面的數(shù)據(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層以上的循環(huán)，而是將延時分拆為兩個程序以提高精度。應(yīng)該是比較好的做法了。