单片机C语言(for)延时计算

合集下载

STC12系列单片机C语言的延时程序

STC12系列单片机C语言的延时程序本举例所用CPU 为STC12C5412 系列12 倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。

共有三条延时函数说明如下：函数调用分两级：一级是小于10US 的延时，二级是大于10US 的延时//====================小于10US 的【用1US 级延时】====================//----------微秒级延时---------for(i=X;i>X;i--) 延时时间=(3+5*X)/12 提示(单位us, X 不能大于255)//================大于10US0;Ms--)for(i=26;i>0;i--);}i=[(延时值-1.75)*12/Ms-15]/4 如想延时60US 则i=[(60-1.75)*12/6-15]/4=25.375≈26; 修改i 的值=26,再调用上面的【10US 级延时函数】Delay10us(6); 则就精确延时60US;如果想延时64US 可以用这二种函数组合来用: Delay10us(6); for(i=9;i>X;i--) 共延时64US//============== 对于大于20Ms 的可用中断来实现程序运行比较好===============中断用定时器0, 1Ms 中断:void timer0(void) interrupt 1{ TL0=(0xffff-1000+2)% 0x100;TH0=(0xffff-1000+2)/0x100; //每毫秒执行一次if(DelayMs_1>0) DelayMs_1--;//大于20Ms 延时程序}函数调用void DelayMs(uint a)//延时 a 乘以1(ms)的时间。

{ DelayMs_1=a; while(DelayMs_1);}如果延时50Ms 则函数值为DelayMs(50)tips:感谢大家的阅读，本文由我司收集整编。

51单片机C语言延时程序几种方式对比

51单片机C语言延时程序几种方式对比51单片机C语言延时程序的简单研究应用单片机的时候，经常会遇到需要短时间延时的情况。

需要的延时时间很短，一般都是几十到几百微妙(us)。

有时候还需要很高的精度，比如用单片机驱动DS18B20(ds18b20型单线智能温度传感器又称数字温度传感器,属于新一代适配微处理器的智能温度传感器,可广泛用于工业、民用、军事等领域的温度测量及控制仪器、测控系统和大型设备中。

它具有体积小,接口方便,传输距离远等特点。

)的时候，误差容许的范围在十几us以内，不然很容易出错。

这种情况下，用计时器往往有点小题大做。

而在极端的情况下，计时器甚至已经全部派上了别的用途。

这时就需要我们另想别的办法了。

以前用汇编语言写单片机程序的时候，这个问题还是相对容易解决的。

比如用的是12MHz晶振的51，打算延时20us，只要用下面的代码，就可以满足一般的需要：mov r0, #09hloop:djnz r0, loop51单片机的指令周期是晶振频率的1/12，也就是1us一个周期。

mov r0, #09h需要2个极其周期，djnz也需要2个极其周期。

那么存在r0里的数就是(20-2)/2。

用这种方法，可以非常方便的实现256us以下时间的延时。

如果需要更长时间，可以使用两层嵌套。

而且精度可以达到2us，一般来说，这已经足够了。

现在，应用更广泛的毫无疑问是Keil的C编译器。

相对汇编来说，C固然有很多优点，比如程序易维护，便于理解，适合大的项目。

但缺点（我觉得这是C的唯一一个缺点了）就是实时性没有保证，无法预测代码执行的指令周期。

因而在实时性要求高的场合，还需要汇编和C的联合应用。

但是是不是这样一个延时程序，也需要用汇编来实现呢？为了找到这个答案，我做了一个实验。

用C语言实现延时程序，首先想到的就是C常用的循环语句。

下面这段代码是我经常在网上看到的：void delay2(unsigned char i){for(; i != 0; i--);}到底这段代码能达到多高的精度呢？为了直接衡量这段代码的效果，我把Keil C 根据这段代码产生的汇编代码找了出来：; FUNCTION _delay2 (BEGIN); SOURCE LINE # 18;---- Variable "i" assigned to Register "R7" ----; SOURCE LINE # 19; SOURCE LINE # 200000?C0007:0000 EF MOV A,R70001 6003JZ?C00100003 1F DEC R70004 80FA SJMP?C0007; SOURCE LINE # 210006?C0010:0006 22RET; FUNCTION _delay2 (END)真是不看不知道~~~一看才知道这个延时程序是多么的不准点~~~光看主要的那四条语句，就需要6个机器周期。

C8051F单片机C程序精确延时的方法

编译情况相同。３种循环语句在ＫｅｉｌＣ５１中具有不同编译特点的原因在于它们的流程不同。ｄｏ—ｗｈｉｌｅ语句是先执行后判断，ｗｈｉｌｅ和ｆｏｒ语句都是先判断后执行。进行
多层循环时，使用ｄｏ—ｗｈｉｌｅ语句具有更大的优势：编译的汇编代码就如直接用汇编语言编写的程序，结构紧凑，编
译效率高，条件转移控制循环次数的过程简单。因此，虽
Ｃ８０５１Ｆ单片机是完全集成的混合信号系统级芯片（Ｓ０ｃ），其ＭＣＵ系统控制器的内核是ＣＩＰ一５１微控制器。ＣＩＰ一５１的指令集与标准８０５１指令集完全兼容。ＣＩＰ一５１采用流水线指令结构，指令时序与标准８０５ｌ不同：７０％指令的执行时间为ｌ或２个系统时钟周期；所有指令时序都以时钟周期计算；大多数指令执行所需的时钟周期数与指令的字节数一致；条件转移指令在不发生转移时和发生转移时的时钟周期数不同。同标准８０５１相比，Ｃ８０５１Ｆ单片机实现程序延时的方法更复杂些。
ｖｏｉｄＳｉｎｇｌｅＣｉｒｃｌｅ（ｕｎｓｉｇｎｅｄｃｈａｒｔ）｛ｕｎｓｉｇｎｅｄｃｈａｒＸ＝ｔ，Ｙ５ｔｌ
ｔ基金项目：福建省教育厅科技硬目（ｊＢ０７２７７）。
ｄｏ（
；
｝ｗｈｉｌｅ（一一ｔ）；ｗｈｉｌｅ（ｘ一一）；
ｆｏｒ（；ｙ－－一；）；｝
使用ＫｅｉｌＣ５１Ｖ７．５０编译器编泽，得到的汇编代码如下：
２丁＋（７ｌ＋３）Ｔ·（Ｘ一１）＋（，ｌ＋２）Ｔ＝ＺＴ＋（行＋３）Ｔ·Ｘ一１’
同理，可得Ｄｅｌａｙ函数的延时时间：｛２Ｔ＋［２Ｔ＋（咒＋３）Ｔ·ｘ—Ｔ＋３Ｔ］·ｙ一丁＋３丁）·
￡一１’＋５丁＝｛［４ｙ＋（咒＋３）Ｘ·ｙ＋４］·￡＋４｝·Ｔ其中，５丁为返回指令ＲＥＴ的时钟周期数。考虑调用Ｄｅ－ｌａｙ函数的ＬＣＡＬＬ指令（时钟周期数为４Ｔ）和参数传递的ＭＯＶ指令（时钟周期数为２ｎ，则总延时时间ｔ且为

c语言中delay的用法

c 语言中 delay 的用法C 语言作为一门新型高级编程语言 ,在计算机软件编程中具有较为广泛的应用和实现。

下面小编就跟你们详细介绍下 c 语言中 delay 的用法，希望对你们有用。

c 语言中 delay 的用法如下：假设一个延时函数如下：void delay(){uint i;for(i=0;i<20000;i++);}我们怎么来算呢，先将 20000 转成 16 进制，得到 4E20,然后将高字节 4E 乘以 6 得到 468D，再将 468+2＝470，然后将 470D*20HEX （即 32D）＝15040；所心这个延时函数总共要执行 15040 个周期，假设所用的晶振为 12MHZ，则该段函数总延时：15.04ms。

有了这个公式我们如果想要设定指定的延时长度就可以用它的己知公式确定。

即：总时间＝[（6*i 值的高 8 位）+2]*i 的低 8 位。

例如：设要延时 125ms。

我们将低字节先赋值200D*（即：C8），然后再算高低节的定值，由式中可知 125ms＝200*（（i 值的高字节*6）+2），又可推算出（高低节*6）+2 的总延迟时间应等于625us，将625/6＝104.1666，取整数得到 104，将 104 转成 16 进制得到 68H，再将高字节和低字节组合起来即得到了定值，即：68C8HEX，代入函数即如下：void delay(){uint i;for(i=0;i<0x68C8;i++);}如果写直进行就要将 68C8 转成 10 进制，即：26824，代入后得到：void delay(){uint i;for(i=0;i<0x26824;i++);在 c 语言中嵌入一段汇编的延时程序呀，你自己看看书，很简单的用在单片机里的可以 C 和汇编混合使用,因为用汇编编写延时要准确些,所以你不妨写一个汇编程序,然后再调用它好了,要用C来编精确的延时确实是比较难的哦.呵呵谁说 C 语言不能精确延时，用 51 单片机的定时/计数器一或者用定时/计数器 2 的工作方式 2，自动再装入 8 位计数器，就可以精确延时，别说 1MS 了就是 100um 也能精确做到。

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，并设置定时器中断。

在中断服务程序中，我们进行相应的操作来实现精确的延时。

这种方法需要使用到单片机的定时器中断功能，相对复杂一些，但是可以实现精确的延时。

51单片机延时程序

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--);
//
void delay(uint t)
{
for (;t>0;t--);
}
1ms延时子程序（12MHZ）
void delay1ms(uint p)//12mhz
{ uchar i,j;
for(i=0;i<p;i++)
{
for(j=0;j<124;j++)
{;}
在实际应用中，定时常采用中断方式，如进行适当的循环可实现几秒甚至更长时间的延时。使用定时器/计数器延时从程序的执行效率和稳定性两方面考虑都是最佳的方案。但应该注意，C51编写的中断服务程序编译后会自动加上PUSH ACC、PUSH PSW、POP PSW和POP ACC语句，执行时占用了4个机器周期；如程序中还有计数值加1语句，则又会占用1个机器周期。这些语句所消耗的时间在计算定时初值时要考虑进去，从初值中减去以达到最小误差的目的。
}
void Delay10us( ) //12mhz
{
_NOP_( );
_NOP_( );
_NOP_( );
_NOP_( );
_NOP_( );
_NOP_( );
}
/*****************11us延时函数*************************/

单片机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--);}关于单片机C语言的精确延时，网上很多都是大约给出延时值没有准确那值是多少,也就没有达到精确高的要求，而本函数克服了以上缺点，能够精确计数出要延时值且精确达到1us,本举例所用CPU为STC12C5412系列12倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。

51单片机c语言延时

51单片机c语言延时51单片机（8051微控制器）是一种广泛使用的嵌入式系统芯片，其编程语言包括C语言和汇编语言等。

在C语言中，实现51单片机延时的方法有多种，下面介绍其中一种常用的方法。

首先，我们需要了解51单片机的指令周期和机器周期。

指令周期是指单片机执行一条指令所需的时间，而机器周期是指单片机执行一个操作所需的时间，通常以微秒为单位。

在C语言中，我们可以使用循环结构来实现延时。

#include <reg51.h> // 包含51单片机的寄存器定义void delay(unsigned int time) // 延时函数，参数为需要延时的微秒数{unsigned int i, j;for (i = 0; i < time; i++)for (j = 0; j < 1275; j++); // 1275个机器周期，约等于1ms}void main() // 主函数{while (1) // 无限循环{// 在这里添加需要延时的代码P1 = 0x00; // 例如将P1口清零delay(1000); // 延时1秒P1 = 0xFF; // 将P1口清零delay(1000); // 延时1秒}}在上面的代码中，我们定义了一个名为delay的函数，用于实现延时操作。

该函数接受一个无符号整数参数time，表示需要延时的微秒数。

在函数内部，我们使用两个嵌套的循环来计算延时时间，其中外层循环控制需要延时的次数，内层循环控制每个机器周期的时间（约为1微秒）。

具体来说，内层循环执行了约1275次操作（具体数值取决于编译器和单片机的型号），以实现约1毫秒的延时时间。

需要注意的是，由于单片机的指令周期和机器周期不同，因此我们需要根据具体的单片机型号和编译器进行调整。

在主函数中，我们使用一个无限循环来不断执行需要延时的操作。

例如，我们将P1口的所有引脚清零，然后调用delay函数进行1秒钟的延时，再将P1口清零并再次调用delay函数进行1秒钟的延时。

单片机C语言延时程序计算

2 软件延时与时间计算
在很多情况下，定时器/计数器经常被用作其他用途，这时候就只能用软件方法延时。下面介绍几种软件延时的方法。
2.1 短暂延时
可以在C文件中通过使用带_NOP_( )语句的函数实现，定义一系列不同的延
单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率，后两种的一个机器周期分别为1 μs和2 μs，便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536 μs。若定时器工作在方式2，则可实现极短时间的精确延时；如使用其他定时方式，则要考虑重装定时初值的时间（重装定时器初值占用2个机器周期）。
80us 1 1 48 0
90us 1 1 55 +0.5
}
延时时间 a的值 b的值 c的值延时误差（us）
10us 1 1 1 -0.5
1ms 1 3 219 -1.5
2ms 2 3 220 +3
900us
9 1 63 -1.5
60us 1 1 35 +0.5
70us 1 1 42 +1
在实际应用中，定时常采用中断方式，如进行适当的循环可实现几秒甚至更长时间的延时。使用定时器/计数器延时从程序的执行效率和稳定性两方面考虑都是最佳的方案。但应该注意，C51编写的中断服务程序编译后会自动加上PUSH ACC、PUSH PSW、POP PSW和POP ACC语句，执行时占用了4个机器周期；如程序中还有计数值加1语句，则又会占用1个机器周期。这些语句所消耗的时间在计算定时初值时要考虑进去，从初值中减去以达到最小误差的目的。
300us 3 1 63 +1.5

单片机C语言延时计算

单片机C语言延时计算单片机是一种集成电路芯片，内部集成了微处理器、存储器、输入输出接口等主要部件。

C语言是常用的单片机编程语言，可以通过编写C程序来实现单片机的控制和功能。

在单片机编程中，延时是一种常用的操作，用于控制程序执行过程中的时间间隔。

延时的实现方法有多种，可以使用循环遍历、定时器、外部中断等方式。

在循环遍历的延时方法中，可以通过设定一个循环次数来实现延时。

具体的延时时间与循环的次数成正比关系。

例如，在一个8位单片机中，循环一次大约需要4个机器周期，因此可以通过适当设置循环次数来达到需要的延时时间。

但是，使用循环遍历的延时方法会占用CPU资源，可能会影响其他任务的执行。

另一种常用的延时方法是使用定时器。

单片机内部通常集成了一个或多个定时器，可以通过设置定时器的初值和工作模式来实现精确的延时。

例如，可以通过设置定时器的计数值和工作频率来计算出延时的时间。

在定时器工作期间，单片机可以继续执行其他任务，不会占用过多的CPU资源。

除了循环遍历和定时器方法外，还可以使用外部中断的方式来实现延时。

具体的实现方法是通过外部信号触发中断，并在中断处理程序中实现延时功能。

这种方法可以根据外部信号的频率和工作模式来调整延时时间。

在单片机编程中，为了提高代码的可读性和可重用性，可以将延时操作封装成函数。

例如，可以定义一个名为delay的函数，函数的参数为延时的时间（单位为毫秒），函数内部通过循环遍历、定时器或外部中断的方式实现延时。

延时的时间计算可以考虑单片机的工作频率、机器周期以及延时的时间要求。

单片机的工作频率可以由时钟源来决定，一般可以通过设置分频系数来调整。

机器周期是单片机执行一条指令所需的时间，通过单片机的数据手册可以查到相关的数据。

根据单片机的工作频率和机器周期，可以计算出所需的循环次数或定时器计数值。

在使用延时功能时需要注意延时时间的准确性和可调性。

准确性是指延时的实际时间与预期时间之间的误差，通过调整循环次数或定时器计数值可以实现较高的准确性。

单片机 c语言例题

单片机 c语言例题单片机 C 语言例题在单片机教学中，C 语言的例题是帮助学生理解和掌握单片机编程的重要工具。

通过例题的学习，学生可以更好地理解C语言语法和单片机的工作原理。

本文将介绍几个单片机 C 语言例题，帮助读者更好地了解单片机的应用。

例题一：LED 灯的闪烁以下是一个简单的单片机 C 语言例题，通过控制单片机上的LED 灯，实现灯的闪烁效果。

```c#include <reg51.h> // 单片机头文件// 主函数void main() {while(1) { // 循环执行P1 = 0x00; // 将 P1 置为低电平（LED 灯熄灭）Delay(); // 延时P1 = 0xFF; // 将 P1 置为高电平（LED 灯亮）Delay(); // 延时}}// 延时函数void Delay() {int i, j;for(i = 0; i < 800; i++) { // 大约延时 1 秒for(j = 0; j < 1000; j++) {}}}```在上述例题中，我们使用了一个延时函数 `Delay()`，通过循环控制LED 灯的亮灭状态，实现了灯的闪烁效果。

通过修改延时循环，可以改变灯闪烁的频率。

例题二：数码管显示数字以下是另一个单片机 C 语言例题，通过控制单片机上的数码管，实现数字的显示效果。

```c#include <reg51.h> // 单片机头文件sbit LED = P2^0; // 数码管的引脚定义// 数码管显示数字函数void Display(int num) {switch (num) {case 0: LED = 0xFC; break; // 数字0显示case 1: LED = 0x60; break; // 数字1显示case 2: LED = 0xDA; break; // 数字2显示case 3: LED = 0xF2; break; // 数字3显示case 4: LED = 0x66; break; // 数字4显示case 5: LED = 0xB6; break; // 数字5显示case 6: LED = 0xBE; break; // 数字6显示case 7: LED = 0xE0; break; // 数字7显示case 8: LED = 0xFE; break; // 数字8显示case 9: LED = 0xF6; break; // 数字9显示default: LED = 0xFF; break; // 其他情况，不显示数字 }}// 主函数void main() {int num = 0; // 待显示的数字while(1) { // 循环执行Display(num); // 数码管显示数字num++; // 数字自增if (num > 9) { // 数字大于9后重置为0 num = 0;}Delay(); // 延时}}// 延时函数void Delay() {int i, j;for(i = 0; i < 800; i++) { // 大约延时 1 秒 for(j = 0; j < 1000; j++) {}}}```在上述例题中，我们通过控制数码管的引脚，并编写了一个显示数字的函数 `Display()`，通过循环控制数码管显示不同的数字，实现了数字的切换和显示效果。

8位单片机微妙延时函数

在单片机编程中，延时函数是非常重要的部分，它可以帮助我们控制程序的执行速度和节奏。

下面是一个基于8位单片机的微妙延时函数的示例。

假设我们使用的是8位单片机，如AT89C51，并且我们使用C语言进行编程。

这个延时函数将使用循环来达到延时的效果。

```c
#include <reg51.h> // 包含单片机特定的头文件
// 延时函数，单位为微秒
void delay(unsigned int time) {
unsigned int i, j;
for (i = 0; i < time; i++) {
for (j = 0; j < 125; j++); // 假设单片机的晶振频率为12.5MHz
}
}
```
这个函数的基本原理是通过循环延迟来达到延时的效果。

在每次循环中，我们使用一个空的for循环来消耗时间，这个循环的次数正好是所需延迟时间的倒数。

这里我们假设单片机的晶振频率为12.5MHz，这是许多8位单片机常见的频率。

需要注意的是，延时函数的具体实现会根据单片机型号、晶振频率、系统时钟等不同而有所差异。

在某些情况下，可能需要更精确或更适合的延时算法。

另外，对于大规模的应用，通常建议使用专门的时间库或者操作系统提供的延时函数，这样可以避免手动编写复杂的延时逻辑。

最后，要注意的是延时函数只是实现时间控制的一个手段，具体的实现需要根据具体的需求和环境来决定。

例如，如果你的应用需要高精度的延时，那么可能需要使用更复杂的方法，如定时器中断等。

单片机C语言的延时计算

标准的C语言中没有空语句。

但在单片机的C语言编程中，经常需要用几个空指令产生短延时的效果。

这在汇编语言中很容易实现，写几个nop就行了。

在keil C51中，直接调用库函数：#include<intrins.h> // 声明了void _nop_(void);_nop_(); // 产生一条NOP指令作用：对于延时很短的，要求在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指令来完成，相当于如下指令：MOV09H，＃0FFHLOOP：DJNZ09H，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结构来完成，每个循环体内的变量仍然采用无符号字符变量。

Keil C中软件实现精确延时的几种方法

void delay (uint i)
{
uchar j;
while(i--)
{
for(j=0;j<123;j++);//1ms基准延时程序
}
}
2设置断点计算延时时间
对于熟悉汇编语言的开发人员可用Keil C中的反汇编工具计算延时时间。但很多C程序员可能对汇编语言不太熟悉，特别是每个指令执行的时间是很难记忆的，因此，常使用Keil C的性能分析器计算延时时间。这里以前面介绍的for(i=0；i<124；i--)结构为例。使用这种方法时，必须先设置系统所用的晶振频率，选择Optionsfor target中的target选项，在Xtal(MHz)中填入所用晶振的频率。将程序编译后，分别在延时程序开始和结束处设置两个运行断点。选择start／stop debug session按钮进入程序调试窗口。运行程序前，要首先将程序复位，计时器清零，然后按F5键运行程序，从左边窗口的sec项可以看到程序到了第一个断点，也就是所要计算的程序段的开始处，用了多少时间；再按F5键，程序到了第2个断点处也就是所要计算的程序段的结束处，记下此时sec项显示的时间。最后用结束处的时间减去开始处时间，就得到循环程序段所占用的时间。
KeilC中软件实现精确延时的几种方法
赵晓东，张丽梅
（中北大学信息与通信工程学院山西太原030051）
摘要：在单片机应用系统开发过程中，经常需要编写各种延时程序，延时时间从数微秒到数秒不等，本文讨论了几种常用的软件延时及计算时间的方法，以供学习和使用。
关键词：KeilC软件延时
单片机开发者在编制各种应用程序时经常会遇到实现精确延时的问题，比如按键去抖、数据传输等操作都要在程序中插入一段或几段延时，时间从几十微秒到几秒。有时还要求有很高的精度，如使用单总线芯片DS18B20时，允许误差范围在十几微秒以内，否则芯片无法工作。实现延时分为两类方法：一种是硬件延时，要用到定时器／计数器；另一种是软件延时，主要采用循环体进行。从程序的执行效率和稳定性两方面考虑，使用定时器／计数器延时是最佳的方案。但是占用了一个定时器，比较浪费，并且可移植性也比较差。因此，一般不建议采用，本文主要讨论软件延时。目前开发嵌入式系统软件的主流工具为C语言，写延时程序时需要一些技巧。本文介绍几种实用的编制精确延时程序和计算程序执行时间的方法。

C语言精确延时方法

C语言精确延时方法有些特殊的应用会用到比较精确的延时（比如DS18B20等），而C不像汇编，延时精准度不好算。

本人经过反复调试，对照KEIL编译后的汇编源文件，得出了以下几条精确延时的语句（绝对精确！本人已通过实际测试），今天贴上来，希望对需要的朋友有所帮助。

sbit LED = P1^0; // 定义一个管脚(延时测试用)unsigned int i = 3; // 注意i,j的数据类型，unsigned char j = 3; // 不同的数据类型延时有很大不同//-----------------各种精确延时语句-----------------------------------while( (i--)!=1 ); // 延时10*i个机器周期i = 10; while( --i ); // 延时8*i+2个机器周期i = 10; while( i-- ); // 延时(i+1)*9+2个机器周期j = 5; while( --j ); // 延时2*j+1个机器周期j = 5; while( j-- ); // 延时(j+1)*6+1个机器周期i = 5;while( --i ) // 延时i*10+2个机器周期，在i*10+2个机器周期if( LED==0 ) break; // 内检测到LED管脚为低电平时跳出延时i = 5;while( LED ) // 每隔10个机器周期检测一次LED管脚状态，当LEDif( (--i)==0 ) break;// 为低时或者到了10*i+2个机器周期时跳出延时//--------------------------------------------------------------------例如18b20的复位函数（12M晶振）://************************************************************* **********// 函数功能：18B20复位// 入口参数：无// 出口参数：unsigned char x： 0：成功 1：失败//************************************************************* **********unsigned char ow_reset(void){unsigned char x=0; // 12M晶振 1个机器周期为1usDQ = 1; // DQ复位j = 10; while(--j);// 稍做延时(延时10*2+1=21个机器周期，21us)DQ = 0; // 单片机将DQ拉低j = 85; while(j--);// 精确延时(大于480us) 85*6+1=511usDQ = 1; // 拉高总线j = 10; while(j--);// 精确延时10*6+1=61usx = DQ; // 稍做延时后,return x; // 如果x=0则初始化成功 x=1则初始化失败j = 25; while(j--);// 精确延时25*6+1=151us}//************************************************************* ********************再如红外解码程序：（先说传统红外解码的弊端：程序中用了while(IR_IO);while(!IR_IO);这样的死循环，如果管脚一直处于一种状态，就会一直执行while，造成“死机”现象。

关于单片机C语言的精确延时

一、函数调用分两级：一级是小于10US的延时，二级是大于10US的延时 //====================小于10US的【用1US级延时】==================== //----------微秒级延时--------for(i=X;i>0;i--) 延时时间=(3+5*X)/12 提示(单位us, X不能大于255)
for(i = 0; i < 600; i++); } } /********************************************************************************************
/******************************************************************************************** void main (void){ //主程序 while(1){
LED = ~LED; //取LED相反状态 DELAY_MS(1000); //修改这里的数值看看会有什么变化 }
} /******************************************************************************************** - 应用实例
可将其模板下载到本地硬盘，在编写新程序的时候复制、粘贴到工程当中，然后根据情况写入具体内容。
- 使用说明
data unsigned char cou = 0; // 定义软计数器,放在程序最前面的寄存器定义部分
/********************************************************************************************

单片机延时子程序

精确延时计算公式:延时时间=[(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晶振Delay1S: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: ;500MS MOV 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 ;1DELAY24001: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+200*0.002ms ;(123*2+4)*200+12: DEL: MOV R7, #200DEL1: MOV R6, #123DEL2:NOPDJNZ R6,DEL2DJNZ R7,DEL1RETD500MS:PUSH PSWSETB RS0MOV R7,#200D51: MOV R6,#250D52: NOPNOPNOPNOPDJNZ R6,D52DJNZ R7,D51POP PSWRETDELAY: ;延时1毫秒PUSH PSWSETB 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的晶振，而在A VR单片机上常用的有8.000MHz和4.000MH的晶振所以在网上查找程序时如果涉及到精确延时则应该注意晶振的频率是多大。

stm32单片机延迟计算

stm32单片机延迟计算
在STM32单片机中，延迟计算通常涉及到两个方面，延迟时长
的计算和延迟函数的实现。

首先，对于延迟时长的计算，我们需要考虑单片机的时钟频率
和所需的延迟时间。

通常情况下，单片机的时钟频率可以通过内部RC振荡器或外部晶体振荡器来提供。

在确定了时钟频率之后，我们
可以根据所需的延迟时间和时钟频率来计算出所需的时钟周期数。

假设我们需要一个精确的延迟时间，我们可以使用以下公式来计算
所需的时钟周期数：
时钟周期数 = 延迟时间× 时钟频率。

其次，一旦我们知道了所需的时钟周期数，我们可以实现相应
的延迟函数。

在STM32单片机中，延迟函数通常使用循环来实现。

具体来说，我们可以编写一个循环，使其在达到所需的时钟周期数
之前不断执行，从而实现延迟。

需要注意的是，由于单片机的特性，延迟函数的实现需要考虑到编译器优化和指令执行的时间，以确保
延迟时间的准确性。

除了使用循环实现延迟函数外，STM32单片机还提供了一些内置的延迟函数，例如HAL库中的HAL_Delay()函数，可以直接调用这些函数来实现延迟。

总的来说，STM32单片机的延迟计算涉及到时钟频率的确定、时钟周期数的计算以及延迟函数的实现。

通过合理的计算和实现，我们可以实现精确的延迟控制，满足各种应用场景的需求。

单片机一些常用的延时与中断问题及解决方法

单片机一些常用的延时与中断问题及解决方法(总4页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--单片机一些常用的延时与中断问题及解决方法延时与中断出错，是单片机新手在单片机开发应用过程中，经常会遇到的问题，本文汇总整理了包含了MCS－51系列单片机、MSP430单片机、C51单片机、8051F的单片机、avr单片机、STC89C52、PIC单片机…..在内的各种单片机常见的延时与中断问题及解决方法，希望对单片机新手们，有所帮助！一、单片机延时问题20问1、单片机延时程序的延时时间怎么算的答:如果用循环语句实现的循环，没法计算，但是可以通过软件仿真看到具体时间，但是一般精精确延时是没法用循环语句实现的。

如果想精确延时，一般需要用到定时器，延时时间与晶振有关系，单片机系统一般常选用 2 MHz、12 MHz或6 MHz晶振。

第一种更容易产生各种标准的波特率，后两种的一个机器周期分别为1 μs和2 μs，便于精确延时。

本程序中假设使用频率为12 MHz的晶振。

最长的延时时间可达216=65 536 μs。

若定时器工作在方式2，则可实现极短时间的精确延时；如使用其他定时方式，则要考虑重装定时初值的时间（重装定时器初值占用2个机器周期）。

2、求个单片机89S51 12M晶振用定时器延时10分钟，控制1个灯就可以答：可以设50ms中断一次，定时初值，TH0=0x3c、TL0=0xb0。

中断20次为1S，10分钟的话，需中断12000次。

计12000次后，给一IO口一个低电平（如功率不够，可再加扩展），就可控制灯了。

而且还要看你用什么语言计算了，汇编延时准确，知道单片机工作周期和循环次数即可算出，但不具有可移植性，在不同种类单片机中，汇编不通用。

用c 的话，由于各种软件执行效率不一样，不会太准，通常用定时器做延时或做一个不准确的延时，延时短的话，在c中使用汇编的nop做延时3、51单片机C语言for循环延时程序时间计算，设晶振12MHz，即一个机器周期是1us。