C语言延时计算公式
c语言延时计算公式
分类：Work Log|标签：单片机应用
2007-09-1322:35阅读(?)评论(0)
今天在看单片机C编程的时候，突然想到在许多的编程中使用软件延时的方法，进行单片机的延时控制。但是不是很清楚为会么如下的方法能够做到准确的延时。程序如下：
void delay(void)
{
unsigned char i,j,k;
for(i=15;i>0;i--)
for(j=202;j>0;j--)
for(k=81;k>0;k--);
}
使用Keil uVersion2进行编译产生了汇编程序看了一下，原来在循环中使用的跳转语句是DJNZ。结合Rn及直接地址进行操作，DJNZ的指令机器周期为2us（晶振为12MHZ时）。上面一段程序的汇编语句如下：
C:0x00137F0F MOV R7,#0x0F;1us
;－－－－－－－－－－－－－－－－－
C:0x00157ECA MOV R6,#0xCA;1us
;－－－－－－－－－－－－－－－－－
C:0x00177D51MOV R5,#0x51;1us
C:0x0019DDFE DJNZ R5,C:0019;2us for(k=81;k>0;k--)
C:0x001B DEFA DJNZ R6,C:0017;2us for(j=202;j>0;j--)
;－－－－－－－－－－－－－－－－－－
C:0x001D DFF6DJNZ R7,C:0015;2us for(i=15;i>0;i--)
其中（;）及其后面的内容是为了方便说明加上去了。
现在我们来计算这段代码执行时所需的时间。
for(k=81;k>0;k--)这一个循环所需时间为：1+2×81
执行完for(j=202;j>0;j--)这一个循环的时间为：1＋（1＋2×81＋2）×202执行完三个循环的总时间为：1＋〔1＋（1＋2×81＋2）×202＋2〕×15
最后加上调用子程序的时间2us和返回的时间2us，整个延时程序的时间就是
1＋〔1＋（1＋2×81＋2）×202＋2〕×15＋2＋2＝
〔3＋（3＋2×81）×202〕×15＋5＝500000us＝500ms
这个值应该是一个准确的延时时间。
总结：在使用汇编语言进行延时设计时，其计算方法是：先从最里层的循环进行时间计算，再往外层循环时行计算。一层层往外叠加，最后不要忘记子程序的调用及返回的时间也要加上去。
单片机C语言(for)延时计算
C程序中可使用不同类型的变量来进行延时设计。经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时应该使用unsigned char作为延时变量。以某晶振为12MHz的单片机为例，晶振为12MHz即一个机器周期为1us。 一. 500ms延时子程序 程序: void delay500ms(void) { unsigned char i,j,k; for(i=15;i>0;i--) for(j=202;j>0;j--) for(k=81;k>0;k--); } 计算分析: 程序共有三层循环 一层循环n:R5*2 = 81*2 = 162us DJNZ 2us 二层循环m:R6*(n+3) = 202*165 = 33330us DJNZ 2us + R5赋值1us = 3us 三层循环: R7*(m+3) = 15*33333 = 499995us DJNZ 2us + R6赋值1us = 3us 循环外: 5us 子程序调用2us + 子程序返回2us + R7赋值1us = 5us 延时总时间= 三层循环+ 循环外= 499995+5 = 500000us =500ms 计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5 二. 200ms延时子程序 程序: void delay200ms(void) { unsigned char i,j,k;
for(i=5;i>0;i--) for(j=132;j>0;j--) for(k=150;k>0;k--); } 三. 10ms延时子程序程序: void delay10ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=4;j>0;j--) for(k=248;k>0;k--); } 四. 1s延时子程序 程序: void delay1s(void) { unsigned char h,i,j,k; for(h=5;h>0;h--) for(i=4;i>0;i--) for(j=116;j>0;j--) for(k=214;k>0;k--); }
汇编语言比较准确延时程序
便于初学者，较为精确的延时程序 ;***************************************************************** ;延时10uS ;***************************************************************** time10us: mov r5,#05h ;11us djnz r5,$ ret ;***************************************************************** ;延时50uS ;***************************************************************** time50us: mov r5,#19h ;51us djnz r5,$ ret ;***************************************************************** ;延时100uS ;***************************************************************** time100us: mov r5,#31h ;99.6us djnz r5,$ ret ;***************************************************************** ;延时200uS ;***************************************************************** time200us: mov r5,#64h ;201us djnz r5,$ ret ;***************************************************************** ;延时250uS ;***************************************************************** time250us: mov r5,#7ch ;249.6us djnz r5,$ ret ;***************************************************************** ;延时350uS
延时子程序计算方法
学习MCS-51单片机，如果用软件延时实现时钟，会接触到如下形式的延时子程序：delay:mov R5,#data1 d1:mov R6,#data2 d2:mov R7,#data3 d3:djnz R7,d3 djnz R6,d2 djnz R5,d1 Ret 其精确延时时间公式：t=（2*R5*R6*R7+3*R5*R6+3*R5+3）*T （“*”表示乘法，T表示一个机器周期的时间）近似延时时间公式：t=2*R5*R6*R7 *T 假如data1,data2,data3分别为50，40，248，并假定单片机晶振为12M，一个机器周期为10-6S，则10分钟后，时钟超前量超过1.11秒，24小时后时钟超前159.876秒（约2分40秒）。这都是data1,data2,data3三个数字造成的，精度比较差，建议C描述。
上表中e=-1的行（共11行）满足（2*R5*R6*R7+3*R5*R6+3*R5+3）=999，999 e=1的行（共2行）满足（2*R5*R6*R7+3*R5*R6+3*R5+3）=1，000，001 假如单片机晶振为12M，一个机器周期为10-6S，若要得到精确的延时一秒的子程序，则可以在之程序的Ret返回指令之前加一个机器周期为1的指令（比如nop指令）， data1,data2,data3选择e=-1的行。比如选择第一个e=-1行，则精确的延时一秒的子程序可以写成： delay:mov R5,#167 d1:mov R6,#171 d2:mov R7,#16 d3:djnz R7,d3 djnz R6,d2
djnz R5,d1 nop ；注意不要遗漏这一句 Ret 附： #include"iostReam.h" #include"math.h" int x=1,y=1,z=1,a,b,c,d,e(999989),f(0),g(0),i,j,k; void main() { foR(i=1;i<255;i++) { foR(j=1;j<255;j++) { foR(k=1;k<255;k++) { d=x*y*z*2+3*x*y+3*x+3-1000000; if(d==-1) { e=d;a=x;b=y;c=z; f++; cout<<"e="< Keil C51程序设计中几种精确延时方法 2008-04-03 08:48 实现延时通常有两种方法：一种是硬件延时，要用到定时器/计数器，这种方法可以提高CPU的工作效率，也能做到精确延时；另一种是软件延时，这种方法主要采用循环体进行。 1 使用定时器/计数器实现精确延时 单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率，后两种的一个机器周期分别为1 μs和2 μs，便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536 μs。若定时器工作在方式2，则可实现极短时间的精确延时；如使用其他定时方式，则要考虑重装定时初值的时间（重装定时器初值占用2个机器周期）。 在实际应用中，定时常采用中断方式，如进行适当的循环可实现几秒甚至更长时间的延时。使用定时器/计数器延时从程序的执行效率和稳定性两方面考虑都是最佳的方案。但应该注意，C51编写的中断服务程序编译后会自动加上PUSH ACC、PUSH PSW、POP PSW和POP ACC语句，执行时占用了4个机器周期；如程序中还有计数值加1语句，则又会占用1个机器周期。这些语句所消耗的时间在计算定时初值时要考虑进去，从初值中减去以达到最小误差的目的。 2 软件延时与时间计算 在很多情况下，定时器/计数器经常被用作其他用途，这时候就只能用软件方法延时。下面介绍几种软件延时的方法。 2.1 短暂延时 可以在C文件中通过使用带_NOP_( )语句的函数实现，定义一系列不同的延时函数，如Delay10us( )、Delay25us( )、Delay40us( )等存放在一个自定义的C文件中，需要时在主程序中直接调用。如延时10 μs 的延时函数可编写如下： void Delay10us( ) { _NOP_( ); _NOP_( ); _NOP_( ) _NOP_( ); C51精确延时程序 一、、看了网上延时程序的帖子挺多，我也说点。 用keil调试， void yanshi( uint n ) { uchar data i="0"; for(i=0;i<N;I++); return; } 延时时间=12*（n*12+17）/fosc 用keil测时功能很容易得到这个关系，很精确，偏差不过几us. 可以自己编一些延时程序，也可以很方便的得到关系式，只是系数不同. 二、、//我看到的地方也是从别的地方转贴，所以我不知道原作者是谁，但相信这么成熟的东西转一下他也不会见意。看到了个好帖，我在此在它得基础上再抛抛砖！ 有个好帖，从精度考虑，它得研究结果是： 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型的时候，会出现什么情况。 汇编延时程序算法详解 摘要计算机反复执行一段程序以达到延时的目的称为软件延时，单片机应用程序中经常需要短时间延时，有时要求很高的精度，网上或书中虽然有现成的公式可以套用，但在部分算法讲解中发现有错误之处，而且延时的具体算法讲得并不清楚，相当一部分人对此仍很模糊，授人鱼,不如授之以渔，本文将以12MHZ晶振为例，详细讲解MCS-51单片机中汇编程序延时的精确算法。 关键词 51单片机汇编延时算法 指令周期、机器周期与时钟周期 指令周期：CPU执行一条指令所需要的时间称为指令周期，它是以机器周期为单位的，指令不同，所需的机器周期也不同。 时钟周期：也称为振荡周期，一个时钟周期＝晶振的倒数。 MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。 MCS-51单片机的指令有单字节、双字节和三字节的，它们的指令周期不尽相同，一个单周期指令包含一个机器周期，即12个时钟周期，所以一条单周期指令被执行所占时间为12*（1/12000000）=1μs。 程序分析 例1 50ms 延时子程序： DEL：MOV R7，#200 ① DEL1：MOV R6，#125 ② DEL2：DJNZ R6，DEL2 ③ DJNZ R7，DEL1 ④ RET ⑤ 精确延时时间为：1+（1*200）+（2*125*200）+（2*200）+2 =（2*125+3）*200+3 ⑥ =50603μs ≈50ms 由⑥整理出公式（只限上述写法）延时时间=（2*内循环+3）*外循环+3 ⑦ 详解：DEL这个子程序共有五条指令，现在分别就每一条指令被执行的次数和所耗时间进行分析。 第一句：MOV R7，#200 在整个子程序中只被执行一次，且为单周期指令，所以耗时1μs 第二句：MOV R6，#125 从②看到④只要R7-1不为0，就会返回到这句，共执行了R7次，共耗时200μs 第三句：DJNZ R6，DEL2 只要R6-1不为0,就反复执行此句（内循环R6次），又受外循环R7控制，所以共执行R6*R7次，因是双周期指令，所以耗时2*R6*R7μs。 例2 1秒延时子程序： DEL：MOV R7,#10 ① DEL1：MOV R6，#200 ② DEL2：MOV R5，#248 ③ DJNZ R5，$ ④ DJNZ R6，DEL2 ⑤ DJNZ R7，DEL1 ⑥ RET ⑦ 对每条指令进行计算得出精确延时时间为： 1+（1*10）+（1*200*10）+（2*248*200*10）+（2*200*10）+（2*10）+2 =[（2*248+3）*200+3]*10+3 ⑧ =998033μs≈1s 由⑧整理得：延时时间=[（2*第一层循环+3）*第二层循环+3]*第三层循环+3 ⑨ 此式适用三层循环以内的程序，也验证了例1中式⑦（第三层循环相当于1）的成立。 注意，要实现较长时间的延时，一般采用多重循环，有时会在程式序里加入NOP指令，这时公式⑨不再适用，下面举例分析。 例3仍以1秒延时为例 DEL：MOV R7,#10 1指令周期1 DEL1：MOV R6，#0FFH 1指令周期10 DEL2：MOV R5，#80H 1指令周期255*10=2550 第四章MCS-51汇编语言程序设计 重点及难点： 单片机汇编语言程序设计的基本概念、伪指令、单片机汇编语言程序的三种基本结构形式、常用汇编语言程序设计。 教学基本要求： 1、掌握汇编语言程序设计的基本概念； 2、掌握伪指令的格式、功能和使用方法； 3、掌握顺序结构、分支结构和循环结构程序设计的步骤和方法； 4、掌握常用汇编语言程序设计步骤和方法。 教学内容 §4.1汇编语言程序设计概述 一、汇编语言的特点 （1）助记符指令和机器指令一一对应，所以用汇编语言编写的程序效率高，占用存储空间小，运行速度快，因此汇编语言能编写出最优化的程序。 （2）使用汇编语言编程比使用高级语言困难，因为汇编语言是面向计算机的，汇编语言的程序设计人员必须对计算机硬件有相当深入的了解。 （3）汇编语言能直接访问存储器及接口电路，也能处理中断，因此汇编语言程序能够直接管理和控制硬件设备。 （4）汇编语言缺乏通用性，程序不易移植，各种计算机都有自己的汇编语言，不同计算机的汇编语言之间不能通用；但是掌握了一种计算机系统的汇编语言后，学习其他的汇编语言就不太困难了。 二、汇编语言的语句格式 [<标号>]：<操作码> [<操作数>]；[<注释>] 三、汇编语言程序设计的步骤与特点 （1）建立数学模型 （2）确定算法 （3）制定程序流程图 （4）确定数据结构 （5）写出源程序 （6）上机调试程序 §4.2伪指令 伪指令是程序员发给汇编程序的命令，也称为汇编命令或汇编程序控制指令。 MCS- 51常见汇编语言程序中常用的伪指令： 第四章MCS-51汇编语言程序设计91 1．ORG （ORiGin）汇编起始地址命令 [<标号：>] ORG <地址> 2．END （END of assembly）汇编终止命令 [<标号：>] END [<表达式>] 3．EQU （EQUate）赋值命令 <字符名称> EQU <赋值项> 4．DB （Define Byte）定义字节命令 [<标号：>] DB <8位数表> 5．DW （Define Word）定义数据字命令 [<标号：>] DW <16位数表> 6．DS （Define Stonage ）定义存储区命令 [<标号：>] DW <16位数表> 7．BIT位定义命令 <字符名称> BIT <位地址> 8．DA TA数据地址赋值命令 <字符名称> DATA <表达式> §4.3单片机汇编语言程序的基本结构形式 一、顺序程序 [例4-1]三字节无符号数相加，其中被加数在内部RAM的50H、51H和52H单元中；加数在内部RAM的53H、5414和55H单元中；要求把相加之和存放在50H、51H和52H单元中，进位存放在位寻址区的00H位中。 MOV R0 ，# 52H ；被加数的低字节地址 MOV R1 ，# 55H ；加数的低字节地址 MOV A ，@ R0 ADD A ，@ R1 ；低字节相加 MOV @ R0 ， A ；存低字节相加结果 DEC R0 DEC R1 MOV A ，@ R0 ADDC A ，@ R1 ；中间字节带进位相加 MOV @ R0 ， A ；存中间字节相加结果 DEC R0 DEC R1 MOV A ，@ R0 ADDC A ，@ R1 ；高字节带进位相加 MOV @ R0 ， A ；存高字节相加结果 CLR A ;延时5秒左右 DELAY5S:PUSH 04H PUSH 05H PUSH 06H MOV R4,#50 DELAY5S_0:MOV R5,#20 DELAY5S_1:MOV R6,#24 5 DJNZ R6,$ DJNZ R5,DELAY5S_1 DJNZ R4,DELAY5S_ POP 06H POP 05H POP 04H RE T ;513微秒延时程序 DELAY: MOV R2,#0FEH DELAY1: DJNZ R2,DELAY1 RET ;10毫秒延时程序 DL10MS: MOV R3,#14H DL10MS1:LCALL DELAY DJNZ R3,DL10MS1 RET ;0.1s延时程序12mhz DELAY: MOV R6,#250 DL1: MOV R7,#200 DL2: DJNZ R6,DL2 DJNZ R7,DL1 RET ;延时1046549微秒(12mhz) ;具体的计算公式是: ;((((r7*2+1)+2)*r6+1)+2)*r5+1+4 = ((r7*2+3)*r6+3) *r5+5 DEL : MOV R5,#08H DEL1: MOV R6,#0FFH DEL2: MOV R7,#0FFH DJNZ R7,$ DJNZ R6,DEL2 DJNZ R5,DEL1 RET ;1秒延时子程序是以12MHz晶振 Delay1S:mov r1,#50 del0: mov r2,#91 del1: mov r3,#100 djnz r3,$ djnz r2,del1 djnz r1,del0 Ret ;1秒延时子程序是以12MHz晶振为例算指令周期耗时KK: MOV R5,#10 ;1指令周期1 K1: MOV R6,#0FFH ;1指令周期10 K2: MOV R7,#80H ;1指令周期256*10=2560 K3: NOP ;1指令周期 128*256*10=327680 DJNZ R7,K3 ;2指令周期 2*128*256*10=655360 DJNZ R6,K2 ;2指令周期 2*256*10=5120 DJNZ R5,K1 ;2指令周期2*10=20 RET ;2指令周期21+10+2560+327680+655360+5120+20+2=990753 ;约等于1秒1秒=1000000微秒 ;这个算下来也只有0.998抄 T_0: MOV R7,#10; D1: MOV R6,#200; D2: MOV R5,#248; DJNZ R5,$ DJNZ R6,D2; DJNZ R7,D1; RET ;这样算下来应该是1.000011秒 T_0: MOV R7,#10; D1: MOV R6,#200; D2: NOP MOV R5,#248; DJNZ R5,$ DJNZ R6,D2; 怎么用C语言做单片机的精确延时在单片机应用中，经常会遇到需要短时间延时的情况，一般都是几十到几百μs，并且需要很高的精度(比如用单片机驱动DS18B20时，误差容许的范围在十几μs以内，不然很容易出错)；而某些情况下延时时间较长，用计时器往往有点小题大做。另外在特殊情况下，计时器甚至已经全部用于其他方面的定时处理，此时就只能使用软件定时了[1]。 1C语言程序延时 Keil C51的编程语言常用的有2种：一种是汇编语言；另一种是C语言。用汇编语言写单片机程序时，精确时间延时是相对容易解决的。比如，用的是晶振频率为12MHz 的AT89C51，打算延时20μs，51单片机的指令周期是晶振频率的1/12，即一个机器周期为1μs；“MOV R0,#X”需要2个机器周期，DJNZ也需要2个机器周期，单循环延时时间t=2X+3(X为装入寄存器R0的时间常数)[2]。这样，存入R0里的数初始化为8即可，其精度可以达到1μs。用这种方法，可以非常方便地实现512μs以下时间的延时。如果需要更长时间，可以使用两层或更多层的嵌套，当然其精度误差会随着嵌套层的增加而成倍增加。 虽然汇编语言的机器代码生成效率很高，但可读性却并不强，复杂一点的程序就更难读懂；而C语言在大多数情况下，其机器代码生成效率和汇编语言相当，但可读性和可移植性却远远超过汇编语言，且C语言还可以嵌入汇编程序来解决高时效性的代码编写问题。就开发周期而言，中大型软件的编写使用C语言的开发周期通常要比汇编语言短很多，因此研究C语言程序的精确延时性能具有重要的意义。 C程序中可使用不同类型的变量来进行延时设计。经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时应该使用unsigned char作为延时变量。 2单层循环延时精度分析 下面是进行μs级延时的while程序代码。 延时函数： void delay1(unsigned char i){ while(i);} 主函数： void main(){ while(1){ delay1(i); } } 使用Keil C51的反汇编功能，延时函数的汇编代码如下： C:0x00E6AE07MOVR6,0x07 C:0x00E81FDECR7 C:0x00E9EEMOVA,R6 C:0x00EA70FAJNZC:00E6 C:0x00EC22RET 图1断点设置位置图 通过对i赋值为10，在主程序中图1所示的位置设置断点。经过测试，第1次执行到断点处的时间为457μs，再次执行到该处的时间为531μs，第3次执行到断点处的时间为605μs，10次while循环的时间为74μs，整个测试结果如图2所示。 图2使用i--方式测试仿真结果图 通过对汇编代码分析，时间延迟t=7X+4(其中X为i的取值)。测试表明，for循环方式虽然生成的代码与用while语句不大一样，但是这两种方法的效率几乎相同。C语言中的自减方式有两种，前面都使用的是i--的方式，能不能使用--i方式来获得不同的效果呢？将前面的主函数保持不变，delay1函数修改为下面的方式：void delay1(unsigned char i){ while(--i);} 同样进行反汇编，得到如下结果： C:0x00E3DFFEDJNZR7, C:00E3C:0x00E522RET 比较发现，--i的汇编代码效率明显高于i--方式。由于只有1条语句DJNZ，执行只需要2个时钟周期，1个时钟周期按1μs计算，其延时精度为2μs；另外，RET 单片机C51延时时间怎样计算？ C程序中可使用不同类型的变量来进行延时设计。经实验测试，使用unsigned char类型具有比unsigned int 更优化的代码，在使用时应该使用unsigned char作为延时变量。以某晶振为12MHz的单片机为例，晶振为12MHz即一个机器周期为1us。 一. 500ms延时子程序 程序: void delay500ms(void) { unsigned char i,j,k; for(i=15;i>0;i--) for(j=202;j>0;j--) for(k=81;k>0;k--); } 计算分析: 程序共有三层循环 一层循环n:R5*2 = 81*2 = 162us DJNZ 2us 二层循环m:R6*(n+3) = 202*165 = 33330us DJNZ 2us + R5赋值 1us = 3us 三层循环: R7*(m+3) = 15*33333 = 499995us DJNZ 2us + R6赋值 1us = 3us 循环外: 5us 子程序调用 2us + 子程序返回 2us + R7赋值 1us = 5us 延时总时间 = 三层循环 + 循环外 = 499995+5 = 500000us =500ms 计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5 二. 200ms延时子程序 程序: void delay200ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=132;j>0;j--) for(k=150;k>0;k--); } 三. 10ms延时子程序 程序: void delay10ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=4;j>0;j--) for(k=248;k>0;k--); } 四. 1s延时子程序 程序: void delay1s(void) { unsigned char h,i,j,k; 51单片机精确延时源程序 一、晶振为 11.0592MHz，12T 1、延时 1ms: （1）汇编语言： 代码如下： DELAY1MS: ;误差 -0.651041666667us MOV R6,#04H DL0: MOV R5,#71H DJNZ R5,$ DJNZ R6,DL0 RET （2）C语言： void delay1ms(void) //误差 -0.651041666667us { unsigned char a,b; for(b=4;b>0;b--) for(a=113;a>0;a--); } 2、延时 10MS： （1）汇编语言： DELAY10MS: ;误差 -0.000000000002us MOV R6,#97H DL0: MOV R5,#1DH DJNZ R5,$ DJNZ R6,DL0 RET （2）C语言： void delay10ms(void) //误差 -0.000000000002us { unsigned char a,b; for(b=151;b>0;b--) for(a=29;a>0;a--); } 3、延时 100MS： （1）汇编语言： DELAY100MS: ;误差 -0.000000000021us MOV R7,#23H DL1: MOV R6,#0AH I 棋影淘宝店：https://www.sodocs.net/doc/8215531102.html,QQ：149034219 DL0: MOV R5,#82H DJNZ R5,$ DJNZ R6,DL0 DJNZ R7,DL1 RET （2）C语言： void delay100ms(void) //误差 -0.000000000021us { unsigned char a,b,c; for(c=35;c>0;c--) for(b=10;b>0;b--) for(a=130;a>0;a--); } 4、延时 1S： （1）汇编语言： DELAY1S: ;误差 -0.00000000024us MOV R7,#5FH DL1: MOV R6,#1AH DL0: MOV R5,#0B9H DJNZ R5,$ DJNZ R6,DL0 DJNZ R7,DL1 RET （2）C语言： void delay1s(void) //误差 -0.00000000024us { unsigned char a,b,c; for(c=95;c>0;c--) for(b=26;b>0;b--) 延时程序在单片机编程中使用非常广泛,但一些读者在学习中不知道延时程序怎么编程,不知道机器 周期和指令周期的区别,不知道延时程序指令的用法, ,本文就此问题从延时程序的基本概念、机器周期和指 令周期的区别和联系、相关指令的用法等用图解法的形式详尽的回答读者 我们知道程序设计是单片机开发最重要的工作，而程序在执行过程中常常需要完成延时的功能。例如 在交通灯的控制程序中，需要控制红灯亮的时间持续30秒，就可以通过延时程序来完成。延时程序是如何 实现的呢？下面让我们先来了解一些相关的概念。 一、机器周期和指令周期 1．机器周期是指单片机完成一个基本操作所花费的时间，一般使用微秒来计量单片机的运行速度， 51 单片机的一个机器周期包括12 个时钟振荡周期，也就是说如果51 单片机采用12MHz 晶振，那么执行 一个机器周期就只需要1μs；如果采用的是6MHz 的晶振，那么执行一个机器周期就需要2 μs。 2 ．指令周期是指单片机执行一条指令所需要的时间，一般利用单片机的机器周期来计量指令周期。 在51 单片机里有单周期指令（执行这条指令只需一个机器周期），双周期指令（执行这条指令只需要两个 机器周期），四周期指令（执行这条指令需要四个机器周期）。除了乘、除两条指令是四周期指令，其余均 为单周期或双周期指令。也就是说，如果51 单片机采用的是12MHz 晶振，那么它执行一条指令一般只需 1~2 微秒的时间；如果采用的是6MH 晶振，执行一条指令一般就需2~4 微秒的时间。 现在的单片机有很多种型号，但在每个型号的单片机器件手册中都会详细说明执行各种指令所需的机 器周期，了解以上概念后，那么可以依据单片机器件手册中的指令执行周期和单片机所用晶振频率来完成 需要精确延时时间的延时程序。 二、延时指令 在单片机编程里面并没有真正的延时指令，从上面的概念中我们知道单片机每执行一条指令都需要一 定的时间，所以要达到延时的效果，只须让单片机不断地执行没有具体实际意义的指令，从而达到了延时 的效果。 1．数据传送指令 MOV 数据传送指令功能是将数据从一个地方复制、拷贝到另一个地方。 如：MOV R7，#80H ；将数据80H 送到寄存器R7，这时寄存器R7 里面存放着80H，就单这条 指令而言并没有任何实际意义，而执行该指令则需要一个机器周期。 2．空操作指令 NOP 空操作指令功能只是让单片机执行没有意义的操作，消耗一个机器周期。 3．循环转移指令 DJNZ 循环转移指令功能是将第一个数进行减1 并判断是否为0，不为0 则转移到指定地点；为0 则往下执行。 如：DJNZ R7，KK ；将寄存器R7 的内容减1 并判断寄存器R7 里的内容减完1 后是否为0，如果 不为0 则转移到地址标号为KK 的地方；如果为0 则执行下一条指令。这条指令需要2 个机器周期。 利用以上三条指令的组合就可以比较精确地编写出所需要的延时程序。 三、1 秒延时子程序、流程图及时间计算（以单片机晶振为12MHz 为例， 1 个机器周期需要1μs） 了解了以上的内容，现在让我们来看看 c语言中的精确延时程序举例 我在网上到看了一些关于延时的讨论,其中有篇文章51单片机Keil C 延时程序的简单研究,作者：InfiniteSpace Studio/isjfk 写得不错,他是用while(--i);产生DJNZ 来实现精确延时,后来有人说如果while里面不能放其它语句,否则也不行,用do-while就可以,具体怎样我没有去试.所有这些都没有给出具体的实例程序来.还看到一些延时的例子多多少少总有点 延时差.为此我用for循环写了几个延时的子程序贴上来,希望能对初学者有所帮助.(晶振12 MHz,一个机器周期1us.) 一. 500ms延时子程序程序: void delay500ms(void) { unsigned char i,j,k; for(i=15;i>0;i--) for(j=202;j>0; j--) for(k=81;k>0;k--); } 产生的汇编: C:0x0800 7F0F MOV R7,#0x0F C:0x0802 7ECA MOV R6,#0xCA C:0x0804 7D51 MOV R5,#0x51 C:0x0806 DDFE DJNZ R5,C:0806 C:0x0808 DEFA DJNZ R6,C:0804 C:0x080A DFF6 DJNZ R7,C:0802 C:0x080C 22 RET 计算分析: 程序共有三层循环一层循环n:R5*2 = 81*2 = 162us DJNZ 2us 二层循环m: R6*(n+3) = 202*165 = 33330us DJNZ 2us + R5赋值1us = 3us 三层循环: R7*(m +3) = 15*33333 = 499995us DJNZ 2us + R6赋值1us = 3us 循环外: 5us 子程序调用2us + 子程序返回2us + R7赋值1us = 5us 延时总时间= 三层循环+ 循环外= 499995+5 = 500000us =500ms 计算公式:延时时间= [(2*R5+3)*R6+3]*R7+5 二. 200ms延时子程序程序: void delay200ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=132;j>0;j--) for(k=150;k>0;k--); } 产生的汇编 汇编延时程序大集合 2009-05-31 19:24 各种汇编延时程序大集合 ;513微秒延时程序 DELAY: MOV R2,#0FEH DELAY1: DJNZ R2,DELAY1 RET ;10毫秒延时程序 DL10MS: MOV R3,#14H DL10MS1:LCALL DELAY DJNZ R3,DL10MS1 RET ;0.1s延时程序12mhz DELAY: MOV R6,#250 DL1: MOV R7,#200 DL2: DJNZ R6,DL2 DJNZ R7,DL1 RET ;延时1046549微秒(12mhz) ;具体的计算公式是: ;((((r7*2+1)+2)*r6+1)+2)*r5+1+4 = ((r7*2+3)*r6+3) *r5+5 DEL : MOV R5,#08H DEL1: MOV R6,#0FFH DEL2: MOV R7,#0FFH DJNZ R7,$ DJNZ R6,DEL2 DJNZ R5,DEL1 RET ;1秒延时子程序是以12MHz晶振 Delay1S:mov r1,#50 del0: mov r2,#91 del1: mov r3,#100 djnz r3,$ djnz r2,del1 djnz r1,del0 Ret ;1秒延时子程序是以12MHz晶振为例算指令周期耗时 KK: MOV R5,#10 ;1指令周期1 K1: MOV R6,#0FFH ;1指令周期10 K2: MOV R7,#80H ;1指令周期256*10=2560 K3: NOP ;1指令周期 128*256*10=327680 DJNZ R7,K3 ;2指令周期 2*128*256*10=655360 DJNZ R6,K2 ;2指令周期 2*256*10=5120 DJNZ R5,K1 ;2指令周期2*10=20 RET ;2指令周期21+10+2560+327680+655360+5120+20+2=990753 ;约等于1秒1秒=1000000微秒 ;这个算下来也只有0.998抄 T_0: MOV R7,#10; D1: MOV R6,#200; D2: MOV R5,#248; DJNZ R5,$ DJNZ R6,D2; DJNZ R7,D1; RET ;这样算下来应该是1.000011秒 T_0: MOV R7,#10; D1: MOV R6,#200; D2: NOP MOV R5,#248; 单片机延时计算 1.10ms延时程序（for循环嵌套） ********************************************************************* 文件名称：void delay_10ms()功能：10ms延时参数：单片机晶振12MHz ********************************************************************* void delay_10ms() { unsigned inti,j; for(i=0;i<10;i++) { for(j=0;j<124;j++); } } **i和j定义为int整型时，for循环执行时间为8个机器周期，当i和j定义为char 字符型时，for循环执行时间3个机器周期。“；”一个机器周 期，每次调用for循环2个机器周期。 **则执行本段延时程序是内循环时间t1=8*124+3个机器周期，其中“8”执行for 循环指令时间；“124”为for循环次数；“3”为每次调用 for循环指令的时间。外循环t2=t1*10+8*10+3其中“10”为for循环次数；“8”为一次for循环指令调用和执行时间；“10”为调用for循环 次数，3为调用for循环指令时间。 **所以本程序延时t=（（8*124）+3）*10+8*10+3=10033=10.033ms≈10ms。 注意：变量为整型时，每次调用for循环需要3个机器周期的调用时间，执行for 循环判断需要8个机器周期的执行时间；字符型变量时，每次调用for循环需要2个机器周期的调用时间，执行for循环判断需要3个机器周期的执行时间。 Keil C51精确延时程序 程序说明如下： 振荡频率：12MHz 机器周期=12/振荡频率=12/12000000=1us #include 一、关于单片机周期的几个概念 时钟周期 时钟周期也称为振荡周期，定义为时钟脉冲的倒数（可以这样来理解，时钟周期就是单片机外接晶振的倒数，例如12MHz 的晶振，它的时间周期就是1/12 us），是计算机中最基本的、最小的时间单位。 在一个时钟周期内，CPU仅完成一个最基本的动作。 机器周期 完成一个基本操作所需要的时间称为机器周期。 以51 为例,晶振12M，时钟周期（晶振周期）就是（1/12） μs，一个机器周期包 含12 个时钟周期，一个机器周期就是1μ s。 指令周期： 执行一条指令所需要的时间，一般由若干个机器周期组成。指令不同，所需 的机器周期也不同。 对于一些简单的的单字节指令，在取指令周期中，指令取出到指令寄存器后，立即译码执行，不再需要其它的机器周期。对于一些比较复杂的指令，例如转移指令、乘法指令，则需要两个或者两个以上的机器周期。 2.延时常用指令的机器周期 1.指令含义 DJNZ：减 1 条件转移指令这是一组把减 1 与条件转移两种功能结合在一起的指令，共2条。DJNZ Rn，rel ；Rn←（Rn）-1 ；若（Rn）=0，则PC←（PC）+2 ；顺序执行； 若（Rn）≠ 0，则PC←（PC）+2+rel，转移到rel 所在位置 DJNZ direct，rel ；direct ←（direct ）-1 ；若（direct）= 0，则PC←（PC）+3；顺序执行；若（direct）≠ 0，则PC←（PC）+3+rel，转移到rel 所 在位置 2.DJNZ Rn,rel 指令详解例： MOV R7，#5 DEL:DJNZ R7,DEL; r在el本例中指标号DEL 三、51 单片机延时时间的计算方法和延时程序设计 1.单层循环 由上例可知，当Rn赋值为几，循环就执行几次，上例执行 5 次，因此本例执行的机器周期个数=1（MOV R7，#5）+2（DJNZ R7,DE）L ×5=11，以12MHz的晶振为例，执行时间（延时时间）=机器周期个数×1μs=11μ s，当设定立即数为0 时，循环程序最多执行256 次，即延时时间最多256μ s。 2.双层循环 1）格式： DELL:MOV R，7 #bb DELL1:MOV R6，#aa DELL2:DJNZ R6,DELL2; 在rel本句中指标号DELL2 DJNZ R7,DELL1; re在l 本句中指标号DELL1 注意：循环的格式，写错很容易变成死循环，格式中的Rn 和标号可随意指定。 2）执行过程 用汇编语言编写1ms延时程序 实验题目：设计延时时间1ms的程序 实验目的：通过该延时时间程序的实验设计，了解运行程序时的我们可以通过该程序进行程序的延时操作，以便达到我们的操作目的。 实验设备：计算机一台。 实验程序：参考附录A 实验内容： 题目分析：题目是让计算机做一些无用的操作，来拖延时间。可以根据一条指令执行时间需要几个时钟周期，即几个微妙，来编程延时程序，也就可以利用循环程序结构。 由查表可得，我们可以用PUSHF和POPF指令来进行编程。而延时的时间主要取决于循环体及循环次数。而PUSHF和POPF指令分别为10和8个时钟节拍，LOOP BX指令为3.4个时钟节拍，即此循环体需要用10+8+3.4=21.4拍，而每个时钟节拍是根据此系统的晶振频率而定的。假设系统用的是8Mhz的晶振，则每个时钟节拍需要0.125μs,因此我们可以根据下列公 式算出循环次数： 换算成十六进制数为176H。下图为程序流程图： 六、实验总结：此程序中内循环是1ms时间，而在外循环中的两条控制指令DEC和JNZ所对应的时钟节拍分别为2个和4个，一共只需0.75μs,与1ms比较极短，所以我们在外循环里忽略不计了，外循环的循环初值为1000次，对应的十六进制为3E8H。有时候我们需要计算机为我们“空”一点时间来进行空操作，即什么也不用做，我们可以通过上述的延时时间子程序来达到目的。 附录A 延时1ms的程序如下： START: MOV CX,176H ;初始化，设定循环次数CX=376 LP1:PUSHF ;循环体 POPF LOOP LP1 ; CX CX-1,若CX0转LP1 HLT ;暂停 延时1s的程序如下： MOV BX,3E8H ; BX 1000 LP2：MOV CX,176H LP1: PUSHF POPF 延时1ms程序段 LOOP LP1 DEC BX DEC BX ; BX BX-1 JNZ LP2 ;ZF=0时，转至LP2,即BX0时转 HLT ;暂停 参考文献 郑学坚，周斌编著.微型计算机原理及应用（第三版）.清华大学出版社.2001KeilC51程序设计中几种精确延时方法
C语言延时程序
汇编延时程序算法详解
51汇编语言程序设计
多种延时汇编程序集合
用C语言实现精确的延时
单片机延时计算
51单片机精确延时源程序
汇编延时程序讲解
c语言中的精确延时程序举例
延时子程序
单片机延时计算
Keil C51精确延时程序(C语言)
51单片机延时时间计算和延时程序设计
用汇编语言编写1ms延时程序