C51精确延时程序.docx

C51精确延时程序.docx

《C51精确延时程序.docx》由会员分享，可在线阅读，更多相关《C51精确延时程序.docx（24页珍藏版）》请在冰点文库上搜索。

C51精确延时程序

C51精确延时程序

默认分类2008-05-2621:

08:

54阅读77评论0  字号：

大中小 订阅

有个好帖，从精度考虑，它得研究结果是：

 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晶振，W77W78系列对应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晶振，W77W78系列对应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层以上的循环，而是将延时分拆为两个程序以提高精度应该是比较好的做法了

实现延时通常有两种方法：

一种是硬件延时，要用到定时器/计数器，这种方法可以提高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_（ ）;

　　　　_NOP_（ ）;

　　　　_NOP_（ ）;

　　}

　　Delay10us（ ）函数中共用了6个_NOP_（ ）语句，每个语句执行时间为1 μs。

主函数调用Delay10us（ ）时，先执行一个LCALL指令（2 μs），然后执行6个_NOP_（ ）语句（6 μs），最后执行了一个RET指令（2 μs），所以执行上述函数时共需要10 μs。

　　可以把这一函数当作基本延时函数，在其他函数中调用，即嵌套调用\[4\]，以实现较长时间的延时；但需要注意，如在Delay40us（ ）中直接调用4次Delay10us（ ）函数，得到的延时时间将是42 μs，而不是40 μs。

这是因为执行Delay40us（ ）时，先执行了一次LCALL指令（2 μs），然后开始执行第一个Delay10us（ ），执行完最后一个Delay10us（ ）时，直接返回到主程序。

依此类推，如果是两层嵌套调用，如在Delay80us（ ）中两次调用Delay40us（ ），则也要先执行一次LCALL指令（2 μs），然后执行两次Delay40us（ ）函数（84 μs），所以，实际延时时间为86 μs。

简言之，只有最内层的函数执行RET指令。

该指令直接返回到上级函数或主函数。

如在Delay80μs（ ）中直接调用8次Delay10us（ ），此时的延时时间为82 μs。

通过修改基本延时函数和适当的组合调用，上述方法可以实现不同时间的延时。

2.2  在C51中嵌套汇编程序段实现延时

　　在C51中通过预处理指令#pragma asm和#pragma endasm可以嵌套汇编语言语句。

用户编写的汇编语言紧跟在#pragma asm之后，在#pragma endasm之前结束。

　　如：

#pragma asm

　　　　…

　　　　汇编语言程序段

　　　　…

　　　　#pragma endasm

　　延时函数可设置入口参数，可将参数定义为unsigned char、int或long型。

根据参数与返回值的传递规则，这时参数和函数返回值位于R7、R7R6、R7R6R5中。

在应用时应注意以下几点：

　　◆ #pragma asm、#pragma endasm不允许嵌套使用；

　　◆ 在程序的开头应加上预处理指令#pragma asm，在该指令之前只能有注释或其他预处理指令；

　　◆ 当使用asm语句时，编译系统并不输出目标模块，而只输出汇编源文件；

　　◆ asm只能用小写字母，如果把asm写成大写，编译系统就把它作为普通变量；

　　◆ #pragma asm、#pragma endasm和 asm只能在函数内使用。

　　将汇编语言与C51结合起来，充分发挥各自的优势，无疑是单片机开发人员的最佳选择。

2.3  使用示波器确定延时时间

    利用示波器来测定延时程序执行时间。

方法如下：

编写一个实现延时的函数，在该函数的开始置某个I/O口线如P1.0为高电平，在函数的最后清P1.0为低电平。

在主程序中循环调用该延时函数，通过示波器测量P1.0引脚上的高电平时间即可确定延时函数的执行时间。

方法如下：

　　sbit T_point = P1^0;

　　void Dly1ms（void） {

　　　　unsigned int i,j;

　　　　while 

（1） {

　　　　　　T_point = 1;

　　　　　　for（i=0;i<2;i++）{

　　　　　　　　for（j=0;j<124;j++）{;}

　　　　　　}

　　　　　　T_point = 0;

　　　　　　for（i=0;i<1;i++）{

　　　　　　　　for（j=0;j<124;j++）{;}

　　　　　　}

　　　　}

　　}

　　void main （void） {

　　　　Dly1ms（）;

　　}

　　把P1.0接入示波器，运行上面的程序，可以看到P1.0输出的波形为周期是3 ms的方波。

其中，高电平为2 ms，低电平为1 ms，即for循环结构“for（j=0;j<124;j++） {;}”的执行时间为1 ms。

通过改变循环次数，可得到不同时间的延时。

当然，也可以不用for循环而用别的语句实现延时。

这里讨论的只是确定延时的方法。

2.4  使用反汇编工具计算延时时间

　　用Keil C51中的反汇编工具计算延时时间，在反汇编窗口中可用源程序和汇编程序的混合代码或汇编代码显示目标应用程序。

为了说明这种方法，还使用“for （i=0;i

在程序中加入这一循环结构，首先选择build taget，然后单击start/stop debug session按钮进入程序调试窗口，最后打开Disassembly window，找出与这部分循环结构相对应的汇编代码，具体如下：

　　C:

0x000FE4CLRA//1T

　　C:

0x0010FEMOVR6,A//1T

　　C:

0x0011EEMOVA,R6//1T

　　C:

0x0012C3CLRC//1T

　　C:

0x00139FSUBBA,DlyT //1T

　　C:

0x00145003JNCC:

0019//2T

　　C:

0x00160E INCR6//1T

　　C:

0x001780F8SJMPC:

0011//2T

　　可以看出，0x000F～0x0017一共8条语句，分析语句可以发现并不是每条语句都执行DlyT次。

核心循环只有0x0011~0x0017共6条语句，总共8个机器周期，第1次循环先执行“CLR A”和“MOV R6，A”两条语句，需要2个机器周期，每循环1次需要8个机器周期，但最后1次循环需要5个机器周期。

DlyT次核心循环语句消耗（2+DlyT×8+5）个机器周期，当系统采用12 MHz时，精度为7 μs。

　　当采用while （DlyT--）循环体时，DlyT的值存放在R7中。

相对应的汇编代码如下：

　　C:

0x000FAE07MOVR6, R7//1T

　　C:

0x00111F DECR7//1T

　　C:

0x0012EE MOVA,R6//1T

　　C:

0x001370FAJNZC:

000F//2T

　　循环语句执行的时间为（DlyT+1）×5个机器周期，即这种循环结构的延时精度为5 μs。

　　通过实验发现，如将while （DlyT--）改为while （--DlyT），经过反汇编后得到如下代码：

　　C:

0x0014DFFE DJNZR7,C:

0014//2T

　　可以看出，这时代码只有1句，共占用2个机器周期，精度达到2 μs，循环体耗时DlyT×2个机器周期；但这时应该注意，DlyT初始值不能为0。

注意：

计算时间时还应加上函数调用和函数返回各2个机器周期时间。

谈谈51单片机延时子程序

   延时程序在单片机编程中使用非常广泛,但一些读者在学习中不知道延时程序怎么编程,不知道机器

周期和指令周期的区别,不知道延时程序指令的用法,,本文就此问题从延时程序的基本概念、机器周期和指

令周期的区别和联系、相关指令的用法等用图解法的形式详尽的回答读者

  我们知道程序设计是单片机开发最重要的工作，而程序在执行过程中常常需要完成延时的功能。

例如

在交通灯的控制程序中，需要控制红灯亮的时间持续30秒，就可以通过延时程序来完成。

延时程序是如何

实现的呢？

下面让我们先来了解一些相关的概念。

一、机器周期和指令周期

1．机器周期是指单片机完成一个基本操作所花费的时间，一般使用微秒来计量单片机的运行速度，

51单片机的一个机器周期包括12个时钟振荡周期，也就是说如果51单片机采用12MHz晶振，那么执行

一个机器周期就只需要1μs；如果采用的是6MHz的晶振，那么执行一个机器周期就需要2μs。

  2．指令周期是指单片机执行一条指令所需要的时间，一般利用单片机的机器周期来计量指令周期。

在51单片机里有单周期指令（执行这条指令只需一个机器周期），双周期指令（执行这条指令只需要两个

机器周期），四周期指令（执行这条指令需要四个机器周期）。

除了乘、除两条指令是四周期指令，其余均

为单周期或双周期指令。

也就是说，如果51单片机采用的是12MHz晶振，那么它执行一条指令一般只需

1~2微秒的时间；如果采用的是6MH晶振，执行一条指令一般就需2~4微秒的时间。

  现在的单片机有很多种型号，但在每个型号的单片机器件手册中都会详细说明执行各种指令所需的机

器周期，了解以上概念后，那么可以依据单片机器件手册中的指令执行周期和单片机所用晶振频率来完成

需要精确延时时间的延时程序。

二、延时指令

  在单片机编程里面并没有真正的延时指令，从上面的概念中我们知道单片机每执行一条指令都需要一

定的时间，所以要达到延时的效果，只须让单片机不断地执行没有具体实际意义的指令，从而达到了延时

的效果。

1．数据传送指令MOV

  数据传送指令功能是将数据从一个地方复制、拷贝到另一个地方。

  如：

MOVR7，#80H  ；将数据80H送到寄存器R7，这时寄存器R7里面存放着80H，就单这条

指令而言并没有任何实际意义，而执行该指令则需要一个机器周期。

2．空操作指令NOP

  空操作指令功能只是让单片机执行没有意义的操作，消耗一个机器周期。

3．循环转移指令DJNZ

  循环转移指令功能是将第一个数进行减1并判断是否为0，不为0则转移到指定地点；为0则往下执行。

  如：

DJNZR7，KK；将寄存器R7的内容减1并判断寄存器R7里的内容减完1后是否为0，如果

  不为0则转移到地址标号为KK的地方；如果为0则执行下一条指令。

这条指令需要2个机器周期。

  利用以上三条指令的组合就可以比较精确地编写出所需要的延时程序。

三、1秒延时子程序、流程图及时间计算（以单片机晶振为12MHz为例，1个机器周期需要1μs）

了解了以上的内容，现在让我们来看看

程序总共所需时间：

1+10+2560+330240+660480+5120+20+2=998433μs≈1S

  在这里运行这段程序共需998433μs，还差1567μs才达到1S的，所以想要达到完美的1S延时，需

要在返回指令RET前再添加一些指令让它把1567μs的延时完成。

有兴趣的读者可以自己试着添加完成。

最后补充一点，编写程序时一般将延时程序编写成独立的子程序，而所谓子程序也就是一个实现某个功能

的小模块。

这样在主程序中就可以方便地反复调用编写好的延时子程序。

  小提示：

循环转移指令（DJNZ）除了可以给定地址标号让其跳转外，还可以将地址标号改成$，这样

程序就跳回本指令执行。

例如：

  DJNZR7，$；R7内容减1不为0，则再次执行本指令；为0则往下执行，当R7的值改为10

时，则执行完该条程序所需的时间为2*10=20μs。

51单片机汇编延时程序算法详解

将以12MHZ晶振为例，详细讲解MCS-51单片机中汇编程序延时的精确算法。

指令周期、机器周期与时钟周期

　　指令周期：

CPU执行一条指令所需要的时间称为指令周期，它是以机器周期为单位的，指令不同，所需的机器周期也不同。

　　时钟周期：

也称为振荡周期，一个时钟周期＝晶振的倒数。

　　MCS-51单片机的一个机器周期=6个状态周期=12个时钟周期。

　　MCS-51单片机的指令有单字节、双字节和三字节的，它们的指令周期不尽相同，一个单周期指令包含一个机器周期，即12个时钟周期，所以一条单周期指令被执行所占时间为12*（1/12000000）=1μs。

　　程序分析

　　例150ms延时子程序：

　　DEL：

MOVR7，#200①

　　DEL1：

MOVR6，#125②

　　DEL2：

DJNZR6，DEL2③

　　DJNZR7，DEL1④

　　RET⑤

　　精确延时时间为：

1+（1*200）+（2*125*200）+（2*200）+2

　　=（2*125+3）*200+3⑥

　　=50603μs

　　≈50ms

　　由⑥整理出公式（只限上述写法）延时时间=（2*内循环+3）*外循环+3⑦

详解：

DEL这个子程序共有五条指令，现在分别就每一条指令被执行的次数和所耗时间进行分析。

　　第一句：

MOVR7，#200在整个子程序中只被执行一次，且为单周期指令，所以耗时1μs

　　第二句：

MOVR6，#125从②看到④只要R7-1不为0，就会返回到这句，共执行了R7次，共耗时200μs

　　第三句：

DJNZR6，DEL2只要R6-1不为0,就反复执行此句（内循环R6次），又受外循环R7控制，所以共执行R6*R7次，因是双周期指令，所以耗时2*R6*R7μs。

　　例21秒延时子程序：

　　DEL：

MOVR7,#10①

　　DEL1：

MOVR6，#200②

　　DEL2：

MOVR5，#248③

　　DJNZR5，$④

　　DJNZR6，DEL2⑤

　　DJNZR7，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：

MOVR7,#101指令周期1

　　DEL1：

MOVR6，#0FFH1指令周期10

　　DEL2：

MOVR5，#80H1指令周期255*10=2550

　　KONG：

NOP1指令周期128*255*10=326400

　　DJNZR5，$2指令周期2*128*255*10=652800

　　DJNZR6，DEL22指令周期2*255*10=5110

　　DJNZR7，DEL12指令周期2*10=20

　　RET2

　　延时时间=1+10+2550+326400+652800+5110+20+2=986893μs约为1s

　　整理得：

延时时间=[（3*第一层循环+3）*第二层循环+3]*第三层循环+3⑩

　　结论：

针对初学者的困惑，对汇编程序的延时算法进行了分步讲解，并就几种不同写法分别总结出相应的计算公式，只要仔细阅读例1中的详解，并用例2、例3来加深理解，一定会掌握各种类型程序的算法并加以运用。

单片机延时子程序

1）延时为:

20ms晶振12M

1+（1+2*248+2）*4+1+1+1=20000US=20MS

用汇编..优点就是精确...

缺点就是算有点复杂.

DELAY20MS:

MOVR7,#4

D1:

MOVR6,#248

DJNZR6,$

DJNZR7,D1

NOP

NOP

RET

2）一些通过计算51汇编指令得出的软延时子程序

;*****************************************************************   

;延时10uS   

;***********************