单片机C51延时时间怎样计算
51单片机技巧：精确延时
在用C语言写程序时，初学者遇到的一个难题时精确延时程序的设计。
我刚开始用C语言写程序时同样遇到了这个问题，后来参考了一些文章和实际设计后才知道了精确延时程序的设计。
我现在就用两种方法来实现，一种是while()语句，另一种是for()语句，这两种语句均可产生汇编语句中的DJNZ语句，以12MHZ晶振为例（说明：在编写C程序时，变量尽量使用unsigned char，如满足不了才使用unsigned int）：1.delay＝99；while(--delay)；产生的汇编代码为：000FH MOV 08H,#63H0012H DJNZ 08H,0012H这样产生的延时时间为：(99+1)×2us。
最小延时时间为2us，若加上对delay赋值语句，则最小为4us。
2.for(i=delay;i>0;i--);产生的汇编代码同while()语句。
下面来举例几个延时函数：一. 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,#0x0FC:0x0802 7ECA MOV R6,#0xCAC:0x0804 7D51 MOV R5,#0x51C:0x0806 DDFE DJNZ R5,C:0806C:0x0808 DEFA DJNZ R6,C:0804C:0x080A DFF6 DJNZ R7,C:0802C: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--);}三. 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--);}以上的这先希望对大家有帮组，如有不足之处请指出，如有更好的方法也可以告诉我，大家一起分享第二部分关于单片机C语言的精确延时，网上很多都是大约给出延时值没有准确那值是多少,也就没有达到精确高的要求，而51hei给出的本函数克服了以上缺点，能够精确计数出要延时值且精确达到1us,本举例所用CPU为STC12C5412系列12倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
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开发者特别是初学者编制非常精确的延时程序有一定难度。
51单片机延时时间计算和延时程序设计
一、关于单片机周期的几个概念●时钟周期时钟周期也称为振荡周期，定义为时钟脉冲的倒数（可以这样来理解，时钟周期就是单片机外接晶振的倒数，例如12MHz的晶振，它的时间周期就是1/12 us），是计算机中最基本的、最小的时间单位。
在一个时钟周期内，CPU仅完成一个最基本的动作。
●机器周期完成一个基本操作所需要的时间称为机器周期。
以51为例,晶振12M，时钟周期(晶振周期)就是(1/12)μs，一个机器周期包执行一条指令所需要的时间，一般由若干个机器周期组成。
指令不同，所需的机器周期也不同。
对于一些简单的的单字节指令，在取指令周期中，指令取出到指令寄存器后，立即译码执行，不再需要其它的机器周期。
对于一些比较复杂的指令，例如转移指令、乘法指令，则需要两个或者两个以上的机器周期。
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，#5DEL:DJNZ R7,DEL; rel在本例中指标号DEL1.单层循环由上例可知，当Rn赋值为几，循环就执行几次，上例执行5次，因此本例执行的机器周期个数=1（MOV R7，#5）+2（DJNZ R7,DEL）×5=11，以12MHz的晶振为例，执行时间（延时时间）=机器周期个数×1μs=11μs，当设定立即数为0时，循环程序最多执行256次，即延时时间最多256μs。
2.双层循环1）格式：DELL:MOV R7，#bbDELL1:MOV R6，#aaDELL2:DJNZ R6,DELL2; rel在本句中指标号DELL2DJNZ R7,DELL1; rel在本句中指标号DELL1注意：循环的格式，写错很容易变成死循环，格式中的Rn和标号可随意指定。
mcs-51单片机中汇编程序延时的精确算法。
MCS-51单片机中汇编程序延时的精确算法一、引言MCS-51单片机是一种常用的微控制器，其汇编程序编写对于工程师来说是极为重要的。
在MCS-51单片机中，延时是一种常见的需求，通过延时可以控制程序的执行速度和时间间隔。
而对于汇编程序中的延时算法，精确度的要求往往较高，特别是在一些实时系统中。
本文将针对MCS-51单片机中汇编程序延时的精确算法展开论述。
二、延时的需求在MCS-51单片机中，实现一定时间的延时是非常常见的需求。
在控制LED灯的闪烁过程中，需要一定的时间间隔来控制LED的亮灭频率；在读取传感器数据的过程中，需要一定的时间延时以确保传感器数据的准确性。
精确和可控的延时算法对于MCS-51单片机的应用来说是至关重要的。
三、常见的延时算法在MCS-51单片机的汇编程序中，常见的延时算法包括循环延时、定时器延时和脉冲宽度调制（PWM）延时等。
这些延时算法各有优缺点，需要根据具体的应用场景选择合适的算法。
1. 循环延时循环延时是一种简单而粗糙的延时算法，其原理是通过空转循环来消耗一定的CPU周期来实现延时。
这种延时算法的缺点是精度较差，受到CPU主频和编译器优化等因素的影响较大，不适合对延时精度有较高要求的场景。
2. 定时器延时定时器延时是一种利用MCS-51单片机内部定时器来实现延时的算法。
通过设置定时器的初值和计数方式，可以实现一定范围内的精确延时。
定时器延时的优点是精度高，不受CPU主频影响，适用于对延时精度要求较高的场景。
3. 脉冲宽度调制（PWM）延时脉冲宽度调制（PWM）延时是一种通过调节脉冲信号的宽度来实现延时的算法。
这种延时算法在一些特定的应用场景中具有较高的灵活性和精度。
例如在直流电机的速度调节过程中常常会采用PWM延时算法来实现精确的速度控制。
四、精确延时算法针对MCS-51单片机中汇编程序延时的精确算法，我们可以结合定时器延时和脉冲宽度调制（PWM）延时的优点，设计一种精确度较高的延时算法。
单片机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毫秒延时。
需要注意的是，单片机的延时准确性受到各种因素影响，包括时钟精度、环境温度等。
在实际应用中，如果对延时精度有较高要求，可能需要进一步进行校准或采用其他更精确的延时方式。
单片机延时计算公式
单片机延时计算公式单片机是一种应用广泛的微型计算机系统，它被广泛应用于嵌入式系统、电子设备等领域。
在单片机的编程过程中，经常需要进行延时操作，以控制系统的运行速度或实现特定的功能。
为了准确地控制延时时间，需要使用延时计算公式。
延时时间与单片机的时钟频率有关，通常以秒、毫秒、微秒等单位来表示。
在单片机中，时钟频率是一个基本参数，它决定了单片机每秒钟所执行的指令数。
延时计算公式可以通过时钟频率和所需延时时间来计算出延时所需的指令数。
延时计算公式的一般形式如下：延时指令数 = 延时时间× 时钟频率其中，延时指令数表示需要延时的指令数目，延时时间表示所需延时的时间，时钟频率表示单片机的时钟频率。
在实际应用中，延时时间一般以毫秒或微秒为单位。
为了方便计算，可以将延时时间转换为秒，再根据单片机的时钟频率进行计算。
假设延时时间为T秒，时钟频率为f Hz，则延时指令数可以表示为：延时指令数= T × f延时指令数一般为整数，表示需要延时的指令数目。
在单片机编程中，可以通过循环执行空操作指令或者通过定时器来实现延时操作。
通过控制循环次数或者定时器的设置，可以实现精确的延时时间。
需要注意的是，延时计算公式中的时钟频率必须与实际使用的时钟频率相一致。
在单片机编程中，时钟频率一般通过设置寄存器来进行配置。
如果延时计算公式中的时钟频率与实际使用的时钟频率不一致，将会导致延时时间的不准确。
延时计算公式在单片机编程中具有重要的作用。
通过合理地计算延时指令数，可以实现精确的延时操作，从而实现系统的稳定运行和功能的正常实现。
在实际应用中，需要根据具体的需求和系统的要求，选择合适的延时时间和时钟频率，以确保系统的性能和功能的准确性。
总结起来，单片机延时计算公式是一种根据延时时间和时钟频率来计算延时指令数的方法。
通过合理地计算延时指令数，可以实现精确的延时操作，保证系统的稳定运行和功能的正常实现。
在单片机编程中，合理地应用延时计算公式，可以提高系统的性能和功能的准确性。
51系列单片机软件延时计算方法
算出延时所需 的机器周期数 ｍ后 ，设计延时时间为 ｄ 的延 时 ｔ
程序 就 变 成 了设计 延 时 ｍ 个机 器 周 期 的程 序 。
２ 延 时 程序 的一 般 形 式 ． ２
把延 时程 序分成短暂延 时 、中等延 时和长延 时 ３种 ，形 式不 同，计算方法也不相同。 （）短暂延时程序 ：短暂延 时程 序的延时时 间在几 十 ｓ １
Ｔｈ ｌｕ ａ ｉ ｎ Ｍ ｅ ｈ ｄ ０ １ Ｍ ＣＵ ｏ ｔ ｒ ｌ ｙ ｅ Ｃａ ｃ ｌ ｔ ｔ ｏ ｆ５ ｏ Ｓ ｆｗａ ｅ Ｄｅａ
ＺＨＡＮＧ ｉｎ ｙｎ Ｊａ ｇ ｉ
（ ｚ ｏ ｉｅｓｔ ｍｐ ｔｒ ｐ ｒ ｎ ， ｚ ｏ ２ ３ ０ ） Ｄｅ ｈ ｕＵｎｖ ｒｉ Ｃｏ ｕｅ ａｔ ｔ Ｄｅ ｈ ｕ ５ ０ ０ ｙ Ｄｅ ｍｅ
ｍ ＝ｌ １１０５ ／ ２ ３ ８ ４＝１ ５ ． ９２ １ ＝１ ． ２ ４
时程序 时往往先写 出一个粗 略的框架 ，然后 去计算程 序的延
时时 间 ，不满 足要求时再修改循 环次数 ，如此反复 ，直到满
１ ＷＩＥ器件温度传感器 Ｄ １Ｂ ０需要 １ １ 和 ６ １ 的延时 ， 一 Ｒ Ｓ８ ２ ５Ｌ ． ｓ ０ｓ ｘ
这种 延 时 只 使用 Ｎ Ｐ指 令 即可 ，一 个 Ｎ Ｐ指 令 执行 时间 为 一 ０ Ｏ
个机器周期 。例如 ：对 １．５２ ｚ的晶振 ，设 计 １ １ 的延 １ ９ ＭＨ ０ ５ｓ ｚ 时程序 ，根据 （） ，计算得所需机器周期数为： 】式
Ａｂｓｒ ｃ ：Ｉ ｈｅ Ｍ ＣＵ ｏ ｔｏ ｙ ｔｍ ｏ ｔａ ｔ ｎ ｔ ｃ ｎｒ ｌｓ ｓｅ ｃ ｍｍ ｏ ｌ ｅ ｏ ｔ ｅ ｓ ｆｗａ ｅ ｅａ ｔ ｏ ｓ ｓ ｌ ｏ ｄｅ ｉｎ ａ ｐ ｏ ｒ ｍ ｏ ｍｅ ｔ ｎ ｙ ｕｓ ｄ ｔ ｈ ｏ ｔ ｒ ｄ ｌｙ ｍｅ ｈ ｄ ，ｕ ｕａｌ ｔ ｓｇ ｒ ｇ ａ ｔ ｅ ｙ
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单片机软件延时分析朱铮南一、单片机的时钟周期和机器周期时钟周期也叫做振荡周期，是指为单片机提供时钟信号的振荡源的频率的倒数。
CPU可以完成一个独立的操作的最短时段叫做机器周期。
89C51等老一代单片机将振荡频率12分频后作为机器频率，所以机器周期是12个时钟周期的长度。
一般振荡频率为11.0592MHz，机器周期是1.085μs。
现在的高速单片机如STC15系列，工作在1T模式，即振荡频率不再分频，机器周期等于时钟周期。
振荡频率在从11.0592MHz 到33.1776MHz的范围内可以选择，如果振荡频率为30MHz，它的机器周期即为0.03333μs。
二、指令占用的机器周期每条指令执行时所要占用的机器周期不同，下面列出的是软件延时代码中经常用到的指令及这些指令占用的机器周期：软件延时就是利用循环来占用机器周期，达到延时的目的。
三、几种循环结构的比较为了比较几种循环结构，特意用C语言编写了以下几段主函数和延时子函数，在uVisi on2里建造可执行文件以后，点击菜单“调试”里的“开始/停止调试”，再点击“反汇编窗口”工具，就可以看由C语言编译成的汇编语言代码。
1. 第一种的延时子函数用的是do循环和--i结构，最外层有一层x循环，以便调用时可以指定延时时间的整倍数。
左边是C语言代码，右边是反汇编窗口显示的汇编代码截图。
汇编代码里红色的是对应的C语言语句，黑色的才是汇编代码，只有8行。
底下的两行是主函数，一行是实参赋值，另一行是对子函数的调用。
上面的6行是延时子函数，分别是两行赋值，三行寄存器减1非0跳转，最后一行是返回。
void delay(unsigned char x){unsigned char i, j;do{i = 2;j = 240;do{while (--j);} while (--i);}while(--x);｝void main(){delay(1);}2. 第二种和第一种循环结构相同，仅将“--j”、“--i”变成了“j--”、“i--”。
单片机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.根据定时器的时钟频率和计数器初值，计算延时时间。
延时函数的缺点是，它是通过循环执行一段无用指令来实现延时的，因此在延时期间无法执行其他操作，延时的精度也不够高。
如果需要精确的延时时间，可以利用定时/计数器模块来实现。
51单片机精确延时程序大集合
51单片机精确延时程序大集合51单片机精确延时程序大集合以下程序说是精确延时，实际上都不对。
调用一次差个几微秒、几百微秒，一天下来差好几分钟。
加我的QQ群有精确版本哦，不同频率的晶振都适用。
群：383977592008-04-24 12:10:26,在论坛上看到不少不错的延时程序，整理如下共同分享：精确延时计算公式:延时时间=[(2*第一层循环+3)*第二层循环+3]*第三层循环+5;延时5秒左右DELAY5S:PUSH 04H;2个机器周期PUSH 05H;2个机器周期PUSH 06H;2个机器周期MOV R4,#50;1个机器周期DELAY5S_0:MOV R5,#200;1个机器周期DELAY5S_1:MOV R6,#245;1个机器周期DJNZ R6,$;2×245=490个机器周期DJNZ R5,DELAY5S_1;这条2个机器周期，这层循环包含R5×（490+1）+2×R5=98600个机器周期DJNZ R4,DELAY5S_0;这条2个机器周期，这层循环包含R4×（98600+1）+2×R4=4930150个机器周期POP 06H;2个机器周期POP 05H;2个机器周期POP 04H;2个机器周期RET;2个机器周期;（共2+2+2+1+4930150+2+2+2+2=4930165个机器周期）;513微秒延时程序DELAY: MOV R2,#0FEH;1个机器周期JUZINAIYOU: DJNZ R2,JUZINAIYOU;2×R21即2×245RET;2个机器周期;（实际上是493个机器周期）;10毫秒延时程序DL10MS: MOV R3,#14HDL10MS1:LCALL DELAYDJNZ R3,DL10MS1RET;（缺DELAY）;0.1s延时程序12MHzDELAY: MOV R6,#250DL1: MOV R7,#200DL2: DJNZ R6,DL2DJNZ R7,DL1RET;延时1046549微秒(12MHz);具体的计算公式是:;((((r7*2+1)+2)*r6+1)+2)*r5+1+4 = ((r7*2+3)*r6+3)*r5+5 DEL : MOV R5,#08HDEL1: MOV R6,#0FFHDEL2: MOV R7,#0FFHDJNZ R7,$DJNZ R6,DEL2DJNZ R5,DEL1RET;1秒延时子程序是以12MHz晶振DELAY:MOV R1,#50del0: mov r2,#91del1: mov r3,#100djnz r3,$djnz r2,del1djnz r1,del0Ret;1秒延时子程序是以12MHz晶振为例算指令周期耗时KK: MOV R5,#10 ;1指令周期×1K1: MOV R6,#0FFH ;1指令周期×10K2: MOV R7,#80H ;1指令周期256×10=2560K3: NOP ;1指令周期;128*256*10=327680DJNZ R7,K3 ;2指令周期2*128*256*10=655360DJNZ R6,K2 ;2指令周期2*256*10=5120DJNZ R5,K1 ;2指令周期2*10=20RET;2指令周期;21+10+2560+327680+655360+5120+20+2=990753 ;约等于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: NOPMOV R5,#248;DJNZ R5,$DJNZ R6,D2;DJNZ R7,D1;RETDELAY_2S: ;10MS(11.0592mhz) MOV R3,#200JMP DELAY10MSDELAY_100MS: ;100MS(11.0592mhz) MOV R3,#10JMP DELAY10MSDELAY_10MS:MOV R3,#1DELAY10MS: ;去抖动10MS(11.0592mhz)MOV R4,#20DELAY10MSA:MOV R5,#247DJNZ R5,$DJNZ R4,DELAY10MSADJNZ R3,DELAY10MSRETDELAY_500MS: ;500MSMOV R2,#208JMP DELAY_MSDELAY_175MS: ;175MSMOV R2,#73JMP DELAY_MSdelaY_120MS: ;120MSMOV R2,#50JMP DELAY_MSdelay_60ms: ;60msMOV R2,#25JMP DELAY_MSdelay_30ms: ;30msMOV R2,#12JMP DELAY_MSDELAY_5MS: ;5MSMOV R2,#2;=================================== DELAY_MS:CALL DELAY2400DJNZ R2,DELAY_MSRET;=================================== DELAY2400: ;10x244+4=2447 /1.024=2390 MOV R0,#244 ;1 DELAY24001:MUL AB ;4MUL AB ;4DJNZ R0,DELAY24001 ;2RETDELAY: ;延时子程序(1秒)MOV R0,#0AHDELAY1: MOV R1,#00HJUZINAIYOU: MOV R2,#0B2HDJNZ R2,$DJNZ R1,JUZINAIYOUDJNZ R0,DELAY1RETMOV R2,#10 ;延时1秒LCALL DELAYMOV R2,#50 ;延时5秒LCALL DELAYDELAY: ;延时子程序PUSH R2PUSH R1PUSH R0DELAY1: MOV R1,#00HJUZINAIYOU: MOV R0,#0B2HDJNZ R0,$DJNZ R1,JUZINAIYOU ;延时 100 mSDJNZ R2,DELAY1POP R0POP R1POP R2RET1:DEL: MOV R7, #200DEL1: MOV R6, #123NOPDEL2: DJNZ R6, DEL2DJNZ R7, DEL1RET是50.001ms 算法是:0.001ms+200*0.001ms+200*0.001ms+200*123*0.002ms+2 00*0.002ms ;(123*2+4)*200+12: DEL: MOV R7, #200 DEL1: MOV R6, #123 DEL2:NOPDJNZ R6,DEL2DJNZ R7,DEL1RETD500MS:PUSH PSWSETB RS0MOV R7,#200D51: MOV R6,#250D52: NOPNOPNOPNOPDJNZ R6,D52DJNZ R7,D51POP PSWRETDELAY: ;延时1毫秒PUSH PSW SETB RS0MOV R7,#50D1: MOV R6,#10D2: DJNZ R6,$DJNZ R7,D1POP PSWRETORG 0LJMP MAINORG 000BHLJMP CTC0MAIN: MOV SP, #50HCLR EAMOV TMOD, #01HMOV TH0,#3CHMOV TL0,#0B0HMOV R4, #10SETB ET0SETB EASETB TR0SJMP $ ;CTC0: MOV TH0, #3CHMOV TL0, #0B0HDJNZ R4, LPCPL P1.0MOV R4, #10LP: RETIEND; 定时器中断延时TMOD=0x01; /*定时器0工作在模式1下（16位计数器）*/TH0=0xfd;TL0=0x83;TR0=1; /*启动定时器*/TF0==0;TR0=0;等待中断；100ms定时，11.0592晶振他定时准确啊又不影响程序运行2008-06-10 13:50:46 来源:来于网络,服务大家作者:未知【大中小】点击：9 次下面几个是单片机的延时程序(包括asm和C程序，都是我在学单片机的过程中用到的),在单片机延时程序中应考虑所使用的晶振的频率，在51系列的单片机中我们常用的是11.0592MHz和12.0000MHz的晶振，而在AVR单片机上常用的有8.000MHz和4.000MH的晶振所以在网上查找程序时如果涉及到精确延时则应该注意晶振的频率是多大。
单片机 延时 计算
单片机延时计算
在单片机编程中，延时是一种常用的控制方法。
延时的基本原理是利用单片机内部的计时器来实现时间的计算。
以下是一个简单的延时计算程序的中文代码：
1. 定义延时时间
首先需要定义需要延时的时间，例如下面的代码定义了一个需要延时10毫秒的时间：
unsigned int delay_time = 10;
2. 计算延时时间
接下来需要编写延时计算的函数，在这个函数中需要使用单片机内部的计时器来实现时间的计算。
以51单片机为例，我们可以使用定时器和定时器中断来实现延时计算。
具体代码如下：
void delay(unsigned int time) // time为需要延时的时间（单位：毫秒）
{
unsigned char i, j;
while (time--)
{
i = 10;
j = 120;
do
{
while (--j);
} while (--i);
}
}
3. 调用延时函数
最后，在需要进行延时的地方调用延时函数即可，例如下面的代
码在执行delay函数后会延时10毫秒：
delay(delay_time);
以上就是一个简单的中文延时计算程序，希望能对你有所帮助。
C语言延时计算
C语言延时计算C语言的延时计算C51中精确的延时与计算的实现C51由于其可读性和可移植性很强，在单片机中得到广泛的应用，但在某些时候由于C51编写的程序对在有精确时间要求下，可能就得要用汇编语言来编写，但在C51是否也能实现时间的精确控制呢,答案是肯定的。
在C51中要实现对时间的精确延时有以下几种方法其一:对于延时很短的，要求在us级的，采用“_nop_”函数，这个函数相当汇编NOP指令，延时几微秒，就插入个这样的函数。
NOP指令为单周期指令，可由晶振频率算出延时时间，对于12M 晶振，延时1uS。
其二:对于延时比较长的，要求在大于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，,0FFHLOOP: 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结构来完成，每个循环体内的变量仍然采用无符号字符变量。
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单片机汇编延时程序算法详解将以12MHZ晶振为例，详细讲解MCS-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）的成立。
Keil C51程序设计中几种精确延时方法 精确延时
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_( );_NOP_( );_NOP_( );}Delay10us( )函数中共用了6个_NOP_( )语句，每个语句执行时间为1 μs。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
单片机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;
for(h=5;h>0;h--)
for(i=4;i>0;i--)
for(j=116;j>0;j--)
for(k=214;k>0;k--); }。