C51的延时函数
51单片机C程序标准延时函数
51单片机C程序标准延时函数在此，我用的是12M晶振，一个时钟周期是1/12us，一个机器周期为12个时钟周期，则机器周期为1us，而51单片机执行一条语句，为1,2,4个机器周期不等，根据语句的长度来定，一般为1个机器周期。
而_nop_()为一条空语句，执行一次需要一个机器周期。
1us#include<intrins.h>_nop_();执行了一条_nop_();所以延时为1us；10usvoid delay10us(){_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}执行了6条_nop_(),延时6us，主函数调用delay10us 时，先执行了LCALL指令2us，然后执行6条_nop_()语句6us，最后执行一条RET指令2us,所以总共延时10us。
100usvoid delay100us(){delay10us();delay10us();delay10us();delay10us();delay10us();delay10us();delay10us();delay10us();delay10us();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}与上面的一样，主函数调用delay100us();先执行了LCALL语句2us,再调用9个delay10us()函数90us，然后执行了6条_nop_()语句6us,最后执行了一条RET语句2us,总共100us。
1msvoid delay1ms(){f=1;TH0=0xe1;TL0=0X13;TR0=1;while(f);}void T0_3() interrupt 1{TR0=0;f=0;}这里就直接用51单片机内部定时器延时了，如果用_nop_();如果要做到微妙不差，那程序就太长了。
这里我用的是定时器0的方式0，13位定时器，这里为了方便，我就没就EA=1;ET0=1;TM0D=0X00;写在延时函数里。
C51单片机的几种常用延时程序设计2024
引言概述：C51单片机是一种广泛应用于嵌入式系统中的微控制器，它具有高度集成化、易于编程和灵活性强等特点。
在C51单片机的软件开发过程中，延时程序设计是非常重要的一部分。
本文将介绍C51单片机中几种常用的延时程序设计方法，包括循环延时、定时器延时、外部中断延时等。
这些方法不仅可以满足在实际应用中对延时的需求，而且可以提高程序的稳定性和可靠性。
正文内容：一、循环延时1. 使用循环控制语句实现延时功能，例如使用for循环、while循环等。
2. 根据需要设置延时的时间，通过循环次数来控制延时的时长。
3. 循环延时的精度受到指令执行时间的影响，可能存在一定的误差。
4. 循环延时的优点是简单易用，适用于较短的延时时间。
5. 注意在循环延时时要考虑其他任务的处理，避免长时间的等待造成程序卡死或响应延迟。
二、定时器延时1. 使用C51单片机内置的定时器模块来实现延时。
2. 配置定时器的工作模式，如工作方式、定时器精度等。
3. 设置定时器的初值和重装值，控制定时器中断的触发时间。
4. 在定时器中断服务函数中进行延时计数和延时结束标志的设置。
5. 定时器延时的优点是精确可控，适用于需要较高精度的延时要求。
三、外部中断延时1. 在C51单片机上配置一个外部中断引脚。
2. 设置外部中断中断触发条件，如上升沿触发、下降沿触发等。
3. 在外部中断中断服务函数中进行延时计数和延时结束标志的设置。
4. 外部中断延时的优点是能够快速响应外部信号，适用于实时性要求较高的场景。
5. 注意在外部中断延时时要处理好外部中断的抖动问题，确保延时的准确性。
四、内部计时器延时1. 使用C51单片机内部的计时器模块来实现延时。
2. 配置计时器的工作模式，如工作方式、计时器精度等。
3. 设置计时器的初值和重装值，使计时器按照一定的频率进行计数。
4. 根据计时器的计数值进行延时的判断和计数。
5. 内部计时器延时的优点是能够利用单片机内部的硬件资源，提高延时的准确性和稳定性。
51单片机的几种精确延时
对于循环语句同样可以采用for，do…while，while结构来完
成，每个循环体内的变量仍然采用无符号字符变量。
unsigned char i,j
for(i=255;i>0;i--)
for(j=255;j>0;j--);
或
unsigned char i,j
{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编写的中断服务程序编译后会自动加上PUSH ACC、PUSH PSW、POP PSW和POP ACC语句，执行时占用了4个机器周期；如程序中还有计数值加1语句，则又会占用1个机器周期。这些语句所消耗的时间在计算定时初值时要考虑进去，从初值中减去以达到最小误差的目的。
51单片机的几种精确延时实现延时
51单片机的几种精确延时实现延时通常有两种方法：一种是硬件延时，要用到定时器/计数器，这种方法可以提高CPU的工作效率，也能做到精确延时；另一种是软件延时，这种方法主要采用循环体进行。
1使用定时器/计数器实现精确延时
单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率，后两种的一个机器周期分别为1μs和2μs，便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536μs。若定时器工作在方式2，则可实现极短时间的精确延时；如使用其他定时方式，则要考虑重装定时初值的时间（重装定时器初值占用2个机器周期）。
51单片机延时函数设计
58:
unsigned char i = 0;
C:0x11A5 E4
CLR
A
C:0x11A6 FF
MOV
R7,A
59:
unsigned char j = 0;
60:
for(i = 0;i < 29;i++)
61:
{
62:
for(j = 0;j < 62;j++)
C:0x11A7 E4
CLR
A
C:0x11A8 FE
djnz r6,DELAY2 ;2 个机器周期
djnz r5,DELAY1 ;2 个机器周期
ret
;2 个机器周期
假定已经给 delayr5、delayr6 和 delayr7 赋予了正确的数值，当调用 DELAY
函数的时候就会进行一段时间的空循环，然后返回，达到延时的目的。必须遵守
如下的调用顺序：
我找到了解决之道，参看示例代码 7。
示例代码 7
unsigned char i = 0;
unsigned char j = 0;
for(i = 0;i < 29;i++)
{
for(j = 0;j < 62;j++)
{
_nop_();
}
_nop_();
}
编译器做出来的代码类似如下格式（蓝色行是汇编代码，红色行是 C 源代码）：
再次强调，延时时间是包括“DelayConstantInner = XXX”这些语句在内 的总时间。当然，在 C 程序中嵌入汇编，还要设置一些编译器选项，这个你自己 找书看。这一步很重要哦，要不编译根本通不过。
51单片机延时函数
51单片机延时函数在嵌入式系统开发中，51单片机因其易于学习和使用、成本低廉等优点被广泛使用。
在51单片机的程序设计中，延时函数是一个常见的需求。
通过延时函数，我们可以控制程序的执行速度，实现定时器功能，或者在需要的时候进行延时操作。
本文将介绍51单片机中常见的延时函数及其实现方法。
一、使用for循环延时这种方法不精确，但是对于要求不高的场合，可以用来估算延时。
cvoid delay(unsigned int time){unsigned int i,j;for(i=0;i<time;i++)for(j=0;j<1275;j++);}这个延时函数的原理是：在第一个for循环中，我们循环了指定的时间次数（time次），然后在每一次循环中，我们又循环了1275次。
这样，整个函数的执行时间就是time乘以1275，大致上形成了一个延时效果。
但是需要注意的是，这种方法因为硬件和编译器的不同，延时时间会有很大差异，所以只适用于对延时时间要求不精确的场合。
二、使用while循环延时这种方法比使用for循环延时更精确一些，但是同样因为硬件和编译器的不同，延时时间会有差异。
cvoid delay(unsigned int time){unsigned int i;while(time--)for(i=0;i<1275;i++);}这个延时函数的原理是：我们先进入一个while循环，在这个循环中，我们循环指定的时间次数（time次）。
然后在每一次循环中，我们又循环了1275次。
这样，整个函数的执行时间就是time乘以1275，大致上形成了一个延时效果。
但是需要注意的是，这种方法因为硬件和编译器的不同，延时时间会有差异，所以只适用于对延时时间要求不精确的场合。
三、使用定时器0实现精确延时这种方法需要在单片机中开启定时器0，并设置定时器中断。
在中断服务程序中，我们进行相应的操作来实现精确的延时。
这种方法需要使用到单片机的定时器中断功能，相对复杂一些，但是可以实现精确的延时。
单片机C51延时时间怎样计算
C程序中可使用不同类型的变量来进行延时设计。
经实验测试，使用unsi gned char类型具有比un signe d int更优化的代码，在使用时应该使用unsi gned char作为延时变量。
以某晶振为12MHz的单片机为例，晶振为12MH z即一个机器周期为1us。
一. 500ms延时子程序程序:void delay500ms(void){unsign ed 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 = 162usDJNZ 2us二层循环m:R6*(n+3) = 202*165 = 33330u s 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){unsign ed 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){unsign ed 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){unsign ed 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--);}参考链接：http://www.picav/news/2010-04/2106.htm摘要实际的单片机应用系统开发过程中，由于程序功能的需要，经常编写各种延时程序，延时时间从数微秒到数秒不等，对于许多C51开发者特别是初学者编制非常精确的延时程序有一定难度。
Keil C51精确延时程序(C语言)
Keil C51精确延时程序程序说明如下：振荡频率：12MHz机器周期=12/振荡频率=12/12000000=1us#include <reg52.h>void delay1(unsigned char i){ while(--i);}说明：delay1程序为:延时时间=(2*i+2)*机器周期。
i=1～255。
void delay2(unsigned char i){ while(i--);}说明：delay2程序为:延时时间=(6*i+2)*机器周期。
i=1～255。
void main (void){unsigned char m;delay1(10); //赋值并调延时程序delay1说明：本句为赋值并调用Delayus1：延时时间=(1+2)*机器周期。
全部延时时间为：延时时间=(1+2+2*i+2)*机器周期。
i=1～255。
本例：延时时间=（1+2+2*10+2)*1us=25usdelay2(10); //赋值并调延时程序delay2说明：本句为赋值并调用Delayus2：延时时间=(1+2)*机器周期。
全部延时时间为：延时时间=(1+2+6*i+2)*机器周期。
i=1～255。
本例：延时时间=（1+2+6*10+2)*1us=65usm=10; //赋值，m=1～255while(--m) ; //计算，延时时间=2*m*机器周期说明：本两句为赋值并计算。
全部延时时间为：延时时间=(1+2*m)*机器周期。
m=1～255。
本例：延时时间=（1+2*10)*1us=25uswhile(1);}。
单片机C51延时时间怎样计算
单片机C51延时时间怎样计算计算单片机C51延时时间通常需要考虑以下几个因素：1. 单片机的工作频率：单片机的工作频率决定了每个时钟周期的时长。
时钟周期（T）为1 / 片内晶振频率。
例如，若单片机的晶振频率为11.0592MHz，则时钟周期为1 / 11.0592MHz ≈ 90.52ns。
2. 延时的时间要求：您需要计算的是具体的延时时间，例如1毫秒（ms），10毫秒（ms）等。
有了上述信息，我们可以使用下面的公式来计算延时时间：延时时间（单位：时钟周期）=（目标延时时间（单位：秒）/时钟周期（单位：秒））延时时间（单位：毫秒）=延时时间（单位：时钟周期）×1000下面是一个示例的代码来演示如何计算并实现一个1毫秒的延时：```c#include <reg51.h>//定义时钟周期#define CLOCK_PERIOD 100 // 以纳秒为单位//定义延时函数void delay_ms(unsigned int milliseconds)unsigned int i, j;for (i = 0; i < milliseconds; i++)for (j = 0; j < 120; j++) // 这里的120是根据实际测量得到的，可以根据硬件和软件环境适当微调//每次循环消耗的时间为120*100纳秒≈12微秒//因此，总延时时间为12*1000微秒=1毫秒}}//主函数void mainP1=0x00;//把P1引脚置为低电平while (1)delay_ms(1000); // 1秒的延时P1=~P1;//翻转P1引脚的电平}```上述代码中，我们通过嵌套循环实现了一个1毫秒的延时。
根据实际硬件和软件环境，您可能需要微调内层循环的次数以达到准确的1毫秒延时。
需要注意的是，单片机的延时准确性受到各种因素影响，包括时钟精度、环境温度等。
在实际应用中，如果对延时精度有较高要求，可能需要进一步进行校准或采用其他更精确的延时方式。
单片机C语言(C51)常用库函数
单片机C语言(C51)常用库函数单片机C语言(C51)常用库函数在单片机编程中，使用库函数可以大大提高开发效率和简化代码结构。
C51是一种常用的单片机编程语言，它提供了许多常用的库函数，本文将介绍一些常用的C51库函数及其用法。
1. 字符串处理函数字符串处理是单片机编程中常见的任务。
C51提供了一些常用的字符串处理函数，如strcpy、strcat、strcmp等。
这些函数可以简化对字符串的操作。
- strcpy：用于将一个字符串复制到另一个字符串中。
用法示例：```char str1[20];char str2[20] = "Hello, world!";strcpy(str1, str2);```- strcat：用于将一个字符串追加到另一个字符串的末尾。
用法示例：```char str1[20] = "Hello,";char str2[20] = " world!";strcat(str1, str2);```- strcmp：用于比较两个字符串是否相等。
用法示例：```char str1[20] = "Hello";char str2[20] = "World";if (strcmp(str1, str2) == 0) {// 字符串相等的处理逻辑} else {// 字符串不相等的处理逻辑}```2. 数学函数单片机编程中常常需要进行数学运算，C51提供了一些常用的数学函数，如abs、sqrt、sin等。
这些函数可以帮助实现各种数学计算。
- abs：用于计算一个整数的绝对值。
用法示例：```int num = -10;int abs_num = abs(num);```- sqrt：用于计算一个浮点数的平方根。
用法示例：```float x = 16.0;float sqrt_x = sqrt(x);```- sin：用于计算一个角度的正弦值。
c51 nop函数
c51 nop函数摘要：1.C51 nop 函数概述2.C51 nop 函数的语法与用法3.C51 nop 函数的功能与特点4.C51 nop 函数的应用实例5.总结正文：【1.C51 nop 函数概述】C51 nop 函数是C 语言中的一种延时函数，其全称为No Operation，意为“无操作”。
它在程序中执行时，不会进行任何操作，只是单纯地消耗一个指令周期，从而达到延时的效果。
在C51 编程中，nop 函数经常用于精确控制程序的执行速度，或者在特定条件下实现一些特定的功能。
【2.C51 nop 函数的语法与用法】C51 nop 函数在程序中的使用方法非常简单，只需在需要延时的地方调用nop 函数即可。
它的语法如下：```op;```需要注意的是，nop 函数没有返回值，因此在调用它时，不需要使用括号。
同时，nop 函数执行时，会消耗一个指令周期，因此在使用时要谨慎，避免过度使用导致程序运行速度过慢。
【3.C51 nop 函数的功能与特点】C51 nop 函数的主要功能是通过消耗指令周期来实现程序的延时。
它的特点如下：1.不需要任何参数，直接在程序中调用即可。
2.执行时不进行任何操作，只是消耗一个指令周期。
3.可以精确控制程序的执行速度，实现一些特定功能。
【4.C51 nop 函数的应用实例】下面是一个使用C51 nop 函数的简单实例，用于实现一个延时功能：```c#include <reg51.h>void delay(unsigned int ms) {unsigned int i, j;for (i = ms; i > 0; i--) {for (j = 110; j > 0; j--) {nop;}}}void main() {delay(5000); // 延时5 秒// 其他代码}```在这个例子中，我们使用两个嵌套循环来实现延时功能。
外层循环控制延时的总时间，内层循环中调用nop 函数来消耗指令周期，从而实现延时的效果。
51单片机延时函数
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 DJNZ2us + 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延时子程序程序:{unsigned char i,j,k;for(i=5;i>0;i--)for(j=132;j>0;j --)for(k=150;k>0;k --);}三. 10ms延时子程序程序:{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 --);}关于单片机C语言的精确延时，网上很多都是大约给出延时值没有准确那值是多少,也就没有达到精确高的要求，而本函数克服了以上缺点，能够精确计数出要延时值且精确达到1us,本举例所用CPU为STC12C5412系列12倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
51单片机延迟函数
51单片机延迟函数51单片机延迟函数是一种非常重要的函数，它可以帮助我们在程序中实现延迟的效果。
在很多应用场景中，我们需要让程序暂停一段时间，比如等待传感器采集数据、等待外设响应等等。
这时候，延迟函数就可以派上用场了。
在51单片机中，延迟函数的实现方式有很多种，比如使用定时器、循环计数等等。
其中，使用循环计数实现延迟函数是最简单、最常用的方法。
具体实现方式如下：```cvoid delay(unsigned int ms){unsigned int i, j;for (i = 0; i < ms; i++){for (j = 0; j < 1141; j++);}}```这个函数的原理很简单，就是通过两个嵌套的循环来实现延迟。
外层循环控制延迟的时间，内层循环则是一个空循环，用来消耗CPU 的时间。
通过调整内层循环的次数，就可以控制延迟的时间。
需要注意的是，这种延迟函数的精度并不高，因为它的延迟时间受到CPU时钟频率的影响。
如果CPU时钟频率发生变化，延迟时间也会发生变化。
因此，在实际应用中，我们需要根据具体的情况来选择合适的延迟函数。
除了使用循环计数实现延迟函数外，还可以使用定时器来实现。
定时器可以精确地控制延迟时间，而且不会受到CPU时钟频率的影响。
但是，定时器的使用比较复杂，需要对定时器的寄存器进行配置，不太适合初学者使用。
51单片机延迟函数是一种非常实用的函数，可以帮助我们在程序中实现延迟的效果。
在实际应用中，我们需要根据具体的情况来选择合适的延迟函数，以达到最佳的延迟效果。
单片机C51延时时间怎样计算
单片机C51延时时间怎样计算
1. 延时函数：C51中提供了一个延时函数`delay(`，可以用来实现简单的延时操作。
该函数的参数为延时的时间，单位是毫秒（ms）。
2.单片机时钟频率：C51的时钟频率一般为12MHz，即每秒钟钟脉冲个数为12,000,000次。
3.定时/计数器模块：C51中的定时/计数器模块可以用来精确控制延时时间。
其中，TMOD寄存器用来设置定时器的工作模式，THx和TLx寄存器用来设置定时器的初值。
4.定时器计数：C51的定时器工作时，会不断地进行计数。
当计数值达到设定的初值时，会触发中断或者产生一个标志位，可以利用这个特性来实现精确的延时操作。
5.延时时间计算公式：延时时间（单位：毫秒）=计数器初值*定时器计数时间/定时器时钟频率
延时时间计算的具体步骤如下：
1.确定延时所需的毫秒数。
2.确定定时器的工作模式。
3.根据定时器的工作模式，设置THx和TLx寄存器的初值。
4.根据定时器的时钟频率和计数器初值，计算延时时间。
延时函数的缺点是，它是通过循环执行一段无用指令来实现延时的，因此在延时期间无法执行其他操作，延时的精度也不够高。
如果需要精确的延时时间，可以利用定时/计数器模块来实现。
C51程序的函数教程
C51程序的函数教程C51是一种基于哈佛体系结构的经典单片机架构，广泛应用于各种嵌入式系统中。
C51程序是指使用C语言编写的针对C51单片机的程序代码。
在本文中，我们将介绍C51程序中常用的几个重要函数，并提供一些实例来帮助读者更好地理解其用法。
1. 主函数（main函数）主函数是C程序的入口点，它是程序的起始位置。
在C51程序中，主函数的定义形式如下：```cvoid main(void)//程序代码```主函数中的程序代码将按照顺序执行，可以包括变量定义、函数调用、条件语句和循环语句等。
2.IO口输入输出函数IO口输入输出函数用于控制C51单片机的输入输出引脚。
C51单片机通常具有多个IO口，每个IO口可以配置为输入或输出。
以下是几个常用的IO口输入输出函数：- `void P0 = value;`：将value的值输出到P0口。
- `value = P0;`：将P0口的值读取到value变量。
- `void P1 = value;`：将value的值输出到P1口。
- `value = P1;`：将P1口的值读取到value变量。
3.延时函数延时函数用于在程序中添加延迟以实现时间控制。
C51单片机没有内置的延时函数，但我们可以使用定时器来实现延时。
以下是一个常用的延时函数示例：```cvoid delay(unsigned int ms)while (ms--)//使用定时器产生延时}```在上述延时函数中，使用了一个循环来实现延时。
具体的延时时间是通过循环次数来控制的，ms参数表示延时的毫秒数。
4.串口通信函数串口通信函数用于实现C51单片机与外部设备之间的串口通信。
串口通信可以用于数据传输和调试等应用。
以下是一个常用的串口通信函数示例：```cvoid UART_Init//配置串口参数void UART_SendChar(unsigned char value)//发送一个字符unsigned char UART_ReceiveChar//接收一个字符```在上述示例中，`UART_Init`函数用于配置串口的参数，`UART_SendChar`函数用于发送一个字符，而`UART_ReceiveChar`函数用于接收一个字符。
C51单片机中的C语言精确延时的资料和例子
在网上搜了一些关于C51单片机C语言的精确延时（相对）的例子和方法现总结如下：1，_nop_() 适用于us级的少量延时标准的C语言中没有空语句。
但在单片机的C语言编程中，经常需要用几个空指令产生短延时的效果。
这在汇编语言中很容易实现，写几个nop就行了。
在keil C51中，直接调用库函数：#include<intrins.h> //声明了void _nop_(void);_nop_(); //产生一条NOP指令作用：对于延时很短的，要求在us级的，采用“_nop_”函数，这个函数相当汇编NOP指令，延时几微秒。
NOP指令为单周期指令，可由晶振频率算出延时时间，对于12M晶振，延时1uS。
2，一般延时大于10us一，定义的C51中循环变量，尽量采用无符号字符型变量。
二，在FOR循环语句中，尽量采用变量减减来做循环。
三，在do…while，while语句中，循环体内变量也采用减减方法这因为在C51编译器中，对不同的循环方法，采用不同的指令来完成的例：unsigned char i;for(i=255;i>0;i--);用keil C51编译后MOV09H，＃0FFHLOOP： DJNZ09H，LOOP指令相当简洁，也很好计算精确的延时时间。
3，延时更长，达到MS级，这时需要嵌套循环循环嵌套的方法常用于达到ms级的延时。
对于循环语句同样可以采用for，do…while，while结构来完成，每个循环体内的变量仍然采用无符号字符变量。
例：unsigned char i,jfor(i=255;i>0;i--)for(j=255;j>0;j--);或unsigned char i,ji=255;do{j=255;do{j--}while(j);i--;}while(i);或unsigned char i,ji=255;while(i){j=255;while(j){j--};i--;}下面给出有关在C51中延时子程序设计时要注意的问题（一些经验之谈）1、在C51中进行精确的延时子程序设计时，尽量不要或少在延时子程序中定义局部变量，所有的延时子程序中变量通过有参函数传递。
c51的精确延时
注：1.编译软件为"Keil uVision3"（Keil uVision2也试用）。用其他编译软件的话就不准了。
2.需要包含头文件<intrins.h>
3.所有函数的延时时间都是在12Mhz晶振下计算的，如用其他晶振需进行换算。
4.函数的执行时间为“函数的参数”乘以精确到的时间。例如delayms(unsigned char n)函数，其精确度为1ms，如果写入语句delayms(4)，那就是延时4ms。
用c语言为单片机编程无疑十分节约时间，可在很短的时间内开发出较高效的代码，对于程序的维护和扩充也较汇编语言方便许多。
但c语言也有它的不足之处，那就是在时间的精确控制上。要想用c实现精确的延时，只能把c的函数编译成汇编语言，然后按照汇编语言计算其执行时间。本人就按照这种方法，编写了几个51单片机的c语言精确延时函数。
(2)精确到100us的延时(12MHz)
void delay100us(unsigned char n)
{ unsigned char i;
for(;n;n--)
{ _nop_();
for(i=46;i;i--);
}
}
(3)精确的半毫秒延时函数(12MHz)
5.计算出来的延时时间不包括函数调用与返回的时间。如果函数的精确度较高，且参数较小，那么实际延时时间就可能与计算的时间差很远。
（1）精确到2us的延时(12MHz)
void delayus(unsigned char n)
{ while(--n);
}
void delay1_2ms(unsigned char n)
{ unsigned char i;
51单片机延时函数
函数简介：以下六个函数为 51 单片机延时函数，全部都下载到 单片机里测试通过，特别是秒、毫秒延时函数，精确度很高，完全可 以替代定时器。 /* 文件名 DELAY.H 功能 延时（12M 24M） 误差 Ms S 5% 10Us 8%-80% */ //24M 晶振 延时 n 毫秒 void DelayMs_24M(unsigned int n) {
} //24M 晶振 延时 10*n 微秒 void Delay10Us_24M(unsigned int n) {
unsigned int i=0; char j=0; for(i=0;i<n;i++)
for(j=0;j<2;j++); }
//12M 晶振 延时 n 毫秒 void DelayMs_12M(unsigned int n) {
unsigned int i=0,j=0; for(i=0;i<n;i++)
for(j=0;j<357;j++); } //24M 晶振 延时 n 秒 void DelayS_24M(unsigned int n) {
unsigned int i=0,j=0; for(i=0;i<n;i++)
for(j=0;j<54053;j++);
} //12M 晶振 延时 10*n 微秒 void Delay10Us_12M(unsigned int n) {
while(n--); }
建议把以上文件封装成头文件，便于以后随时调用。 2012.09.18.whut
unsigned int i=0,j=0; for(i=0;i<n;i++)
转用C51编写单片机延时函数
转用C51编写单片机延时函数这里假定单片机是时钟频率为12MHz，则一个机器周期为：1us.参考了51单片机Keil C延时程序的简单研究后，我们可知道，在Keil C 中获得最为准确的延时函数将是void delay(unsigned char t){while(--t)；}反汇编代码如下：执行DJNZ指令需要2个机器周期，RET指令同样需要2个机器周期，根据输入t，在不计算调用delay()所需时间的情况下，具体时间延时如下：t Delay Time(us)1 2×1+2=4 22×2+2=6 N2×N+2=2(N+1)当在main函数中调用delay(1)时，进行反汇编如下：调用delay()时，多执行了两条指令，其中MOV R,#data需要1个机器周期，LJMP需要2个机器周期，即调用delay()需要3us.Keil C仿真截图与计算过程：加上调用时间，准确的计算时间延时与Keil C仿真对比如下：(可见,仿真结果和计算结果是很接近的)t Delay Time(us)仿真11.0592 Mhz时钟(us)1 3+2×1+2=7|7.7(实际)7.60 23+2×2+2=9|9.9 9.76 N3+2×N+2=2N+5|(2N+5)*1.1/3 11|12.1 11.94 15 35|38.5 37.98 100 205|225.5 222.44 255515|566.5 558.81也就是说，这个延时函数的精度为2us，最小的时间延时为7us，最大的时间延时为3+255×2+2=515us.实际中使用11.0592 MHz的时钟，这个延时函数的精度将为2.2us，最小时间延时为7.7us,最大时间延时为566.5us.这个时间延时函数，对于与DS18B20进行单总线通信，已经足够准确了。
现在，我们将时钟换成11.0592 MHz这个实际用到的频率，每个机器周期约为1.1us.现在让我们来分析一下这个之前用过的延时函数：//延时函数,对于11.0592 MHz时钟,例i=10,则大概延时10ms.void delayMs(unsigned int i){unsigned int j；while(i--){for(j=0；j 125；j++)；}}它的反汇编代码如下：分析：T表示一个机器周期(调用时间相对于这个ms级的延时来说，可忽略不计)1 C：0000 MOV A,R7；1T 2DEC R7；1T低8位字节减1 3MOV R2,0x06；2T 4JNZ C：0007；2T若低8位字节不为0,则跳到C：0007 5DEC R6；1T低8位字节为0,则高8位字节减1 6C：0007 ORL A,R2；1T 7JZ C：001D；2T若高8位也减为0,则RET 8CLR A；1T A清零9 MOV R4,A；1T R4放高位10 MOV R5,A；1T R5放低位11 C：000D CLR C；1T C清零12 MOV A,R5；1T 13 SUBB A,#0x7d；1T A=A-125 14 MOV A,R4；1T 15 SUBB A,#0x00；1T A16 JNC C：0000；2T A为零则跳到C：0000 17 INC R5；1T R5增1 18 CJNE R5,#0x00,C：001B；2T R5 0,跳转到C：000D 19 INC R4；1T 20 C：001B SJMP C：000D；2T 21 C：001D RET对于delayMs(1),执行到第7行就跳到21行,共需时12T,即13.2us对于delayMs(2),需时9T+13T+124×10T+7T+12T=9T+13T+1240T+7T+12T=1281T=1409.1 us.对于delayMs(3),需时9T×(3-1)+(13T+124×10T+7T)×(3-1)+12T=1269T×(3-1)+12T=2550T=2805us.对于delayMs(N),N 1,需时1269T×(N-1)+12T=1269NT-1257T=(1395.9 N-1382.7)us.利用Keil C仿真delayMs(1)=0.00166558 s=1.67ms截图如下：由分析可知具体的计算延时时间与Keil C仿真延时对比如下：i Time Delay仿真延时1 13.2us 1.67ms 21409.1 us 3.31ms 32805us 4.96ms N(1395.9 N-1382.7)us 10 12.6ms 16.50ms 20 26.5ms 32.98ms 30 40.5ms 49.46ms 50 68.4ms 82.43ms 100 138.2ms 164.84 ms 200 277.8ms 329.56 ms 500696.6ms 824.13 ms 1000 1394.5 ms 1648.54 ms 1500 2092.5 ms 2472.34 ms 2000 2790.4 ms 3296.47 ms 55.6ms 8.26ms 73 100.5ms 120.34 ms 720 1003.7 ms=1s 1186.74 ms计算delayMs(10)得到延时时间为：12576.3 us约等于12.6ms，接近我们认为的10ms。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
** 注意项 ：注意延时为 0 < t < 256
** 例子提示：调用delay_2us（1），得到1ms延时
** 说明 ：
** delay2(0):延时518us 518-2*256=6
** delay2(1):延时7us
** delay2(10):延时25us 25-20=5
例子提示：调用delay_50us（20），得到1ms延时
输 入：
返 回：无
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
/*
********************************************************************
** 文件名 : C51延时驱动
** 创建人 ：hebei
** 创建日期 ：2008.11.4
** 说明 ：对以前版本做了深入的修改， 请注意使用
C51的延时函数
#ifndef _DELAY_51_H_
#define _DELAY_51_H_
#include <AT89x52.h>
#define uint unsigned int
#define uchar unsigned char
//nus延时
void delay_nus( uchar n );
*/
#define _DELAY_51_C_
#include "DELAY_51.H" //用户自己定义的头文件
//==========================向以前版本兼容部分函数==============================
/*
********************************************************************
*/
void delay_nus( uchar n ) { 来自while( --n )
{;}
}
/*
********************************************************************
** 函数名：nus延时函数
** 注意 ：注意延时为 0 < n < 256，
*/
void delay_2us( uchar t )
{
while( --t )
{;}
}
/*------------------------------------------------------------------
函数全称：50us 延时
注意事项：AT89系列对应12M晶振
** 全局变量：无
** 返回： 无
** 说明 : 参考网络
** 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
** delay2(20):延时45us 45-40=5
** delay2(100):延时205us 205-200=5
** delay2(200):延时405us 405-400=5
** 可调度为2us，而最大误差为6us
********************************************************************
** 函数名：nus延时函数
** 注意 ：注意延时为 0 < n < 256，
** 说明 ：此版本主要是对前面的驱动兼容, 实际上可调度约为2us, 不做多
** 说明，以后尽量用新版本delay_2us(uchar n)代替。
********************************************************************
误差最大在22us， 很准确了。
------------------------------------------------------------------*/
void delay_50us(uint t)
{
uchar j;
for( ; t > 0; t-- )
for( j = 19; j > 0; j-- )
//==============================================================================
/*
********************************************************************
{;}
}
/*
********************************************************************
** 函数全称：50ms 延时
** 注意事项：基于1MIPS，AT89系列对应12M晶振
** 例子提示：调用delay_50ms（20），得到1s延时
for( j = 6245; j > 0; j-- )
{;}
}
** 说明 ：此版本主要是对前面的驱动兼容, 比较准确
**
********************************************************************
*/
void delay_nms( uchar n )
{
uchar i;
uchar j;
** 延时50s，误差仅仅2.978ms，可以接受
********************************************************************
*/
void delay_50ms( uint t )
{
uint j;
for( ; t > 0; t-- )
** Target : AT89s52
** Crystal : 11.0952
** 联系 : dongxixiaonanbei@
********************************************************************
uchar t;
for( t = 0; t < n; t++ )
{
for( j = 0; j < 15; j ++ )
{
for( i = 0; i < 21; i++ )
{;}
}
}
}
//==============================================================================
//nms延时
void delay_nms( uchar n );
//2us延时
void delay_2us( uchar t );
//50us延时
void delay_50us(uint t);
//50ms延时
void delay_50ms( uint t );
#endif // <DELAY_51_H>