各种延时程序
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:感谢大家的阅读，本文由我司收集整编。
单片机延时500ms程序汇编
单片机延时500ms程序汇编一、概述在单片机编程中，延时操作是非常常见且重要的一部分。
延时可以使程序在执行过程中暂停一段时间，以确保输入输出设备能够正常工作，或者是为了保护其他设备。
本文将介绍如何使用汇编语言编写单片机延时500ms的程序。
二、延时原理在单片机中，延时操作通常通过循环来实现。
每个循环需要一定的时间，通过控制循环次数和循环体内的指令数量，可以实现不同长度的延时。
在汇编语言中，可以使用计数器来控制循环次数，从而实现精确的延时操作。
三、汇编语言编写延时程序接下来，我们将使用汇编语言编写延时500ms的程序。
1. 设置计数器初值在程序的开头我们需要设置计数器的初值，这个初值需要根据单片机的工作频率和所需的延时时间来计算。
假设单片机的工作频率为1MHz，那么在循环500次后，就能够达到500ms的延时。
我们需要将计数器的初值设为500。
2. 循环计数接下来，我们进入一个循环，在循环中进行计数操作。
每次循环结束时，都需要检查计数器的值，当计数器减至0时，表示已经达到了500ms的延时时间，可以退出循环。
3. 优化程序为了提高程序的执行效率，可以对计数器进行优化。
例如可以通过嵌套循环的方式，减少循环的次数，从而提高延时的精度和稳定性。
四、程序示例下面是一个简单的示例程序，演示了如何使用汇编语言编写延时500ms的程序。
```org 0x00mov r2, #500 ; 设置计数器初值为500delay_loop:djnz r2, delay_loop ; 进行计数ret ; 延时结束，退出程序```五、结语通过以上的示例程序，我们可以看到如何使用汇编语言编写单片机延时500ms的程序。
当然，实际的延时程序可能会更加复杂，需要根据具体的单片机型号和工作频率进行调整，但是思路是相似的。
在实际的编程中，需要根据具体的需求和硬件环境来进行调整和优化，以实现更加稳定和精确的延时操作。
希望本文对单片机延时程序的编写有所帮助，也欢迎大家在评论区提出宝贵意见和建议。
STC12系列单片机C语言的延时程序
STC12系列单片机C语言的延时程序本举例所用CPU为STC12C5412系列12倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
共有三条延时函数说明如下：函数调用分两级：一级是小于10US的延时，二级是大于10US的延时//====================小于10US的【用1US级延时】====================//----------微秒级延时---------for(i=X;i>;X;i--) 延时时间=(3+5*X)/12提示(单位us, X不能大于255)//================大于10US;0;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)/0x1 00; //每毫秒执行一次if(DelayMs_1>;0)DelayMs_1--;//大于20Ms延时程序}函数调用void DelayMs(uint a)//延时 a×1(ms)的时间。
{DelayMs_1=a;while(DelayMs_1);}如果延时50Ms则函数值为 DelayMs(50)。
新手常用单片机延时程序
_NOP_( );
}
/*****************11us延时函数*************************/
//
void delay(uint t)
{
for (;t0;t--);
}
1ms延时子程序(12MHZ)
void delay1ms(uint p)//12mhz
DELAY:CLR EX0
MOV TMOD,#01H ;设置定时器的工作方式为方式1
MOV TL0,#0B0H ;给定时器设置计数初始值
MOV TH0,#3CH
SETB TR0;开启定时器
HERE:JBC TF0,NEXT1
SJMP HERE
NEXT1:MOV TL0,#0B0H
MOVTH0,#3CH
DJNZ R7,HERE
CLR TR0;定时器要软件清零
SETB EX0
RET
C语言延时程序：
void delay_18B20(unsigned inti)
{
while(i--);
}
void Delay10us( )//12mhz
{
_NOP_( );
_NOP_( );
_NOP_( );
_NOP_( );
延时则应该注意晶振的频率是多大。
软件延时：(asm)
晶振12MHZ,延时1秒
程序如下：
DELAY:MOV 72H,#100
LOOP3:MOV 71H,#100
LOOP1:MOV 70H,#47
LOOP0JNZ 70H,LOOP0
NOP
DJNZ 71H,LOOP1
MOV 70H,#46
LOOP2JNZ 70H,LOOP2
各种汇编延时程序大集合
MOV TL0,#0B0H
MOV R4, #10
SETB ET0
SETB EA
SETB TR0
SJMP $ ;
RET
DELAY: ;延时子程序(1秒)
MOV R0,#0AH
DELAY1: MOV R1,#00H
DELAY2: MOV R2,#0B2H
DJNZ ห้องสมุดไป่ตู้2,$
DJNZ R1,DELAY2
DJNZ R0,DELAY1
RET
MOV R2,#10 ;延时1秒
LCALL DELAY
*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晶振
POP R0
POP R1
POP R2
RET
1:DEL: MOV R7, #200
DEL1: MOV R6, #123
NOP
DEL2: DJNZ R6, DEL2
D52: NOP
NOP
NOP
NOP
DJNZ R6,D52
DJNZ R7,D51
POP PSW
RET
DELAY: ;延时1毫秒
PUSH PSW
SETB RS0
MOV R7,#50
D1: MOV R6,#10
D2: DJNZ R6,$
DJNZ R7,D1
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. 内部计时器延时的优点是能够利用单片机内部的硬件资源，提高延时的准确性和稳定性。
不同晶振频率时1MS延时程序
for(y=314; y>0; y--);
}
/********************（STC12C5608AD 4.9152MHZ z=1时精确延时1ms）****************/
void delay_1ms(uint z)
{
uint x,y;
for(x=z; x>0; x--)
for(y=848; y>0; y--);
}
/********************（STC12C5608AD 12MHZ z=1时精确延时1ms）*******************/
void delay_1ms(uint z)
{
uint x,y;
for(x=z; x>0; x--)
for(y=920; y>0; y--);
void delay_1ms(uint z)
{
uinபைடு நூலகம் x,y;
for(x=z; x>0; x--)
for(y=1228; y>0; y--);
}
/******************（STC12C5608AD 16.384MHZ z=1时精确延时1ms）******************/
void delay_1ms(uint z)
{
uint x,y;
for(x=z; x>0; x--)
for(y=306; y>0; y--);
}
/********************（STC12C5608AD 4.096MHZ z=1时精确延时1ms）****************/
void delay_1ms(uint z)
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延时函数*************************/
关于各种延时
关于各种延时在Linux中，如果是应用层下的一些应用，我们可以：1）调用unsigned int sleep(unsigned int second);函数去定时，这个时候它是秒级的；头文件为<unistd.h>；2）调用int usleep(useconds_t);函数去定时，这个时候它是微秒级的；头文件为<unistd.h>；3）调用高精度睡眠int nanosleep(const struct timespec * rep, struct timespec *rem);是一个相比标准UNIX 的sleep 调用具有更高高精度的版本。
和普通的sleep 调用计算整秒数不同，nanosleep 接受一个指向一个struct timespec 对象的指针作为参数，它可以表示毫微秒（nanosecond，十亿分之一秒）的时间。
然而，了解Linux 内核的工作细节后可知，nanosleep 所提供的真正精确度是10毫秒——比sleep 提供的要精确。
这个附加的精确度非常有用，比如说，可以根为反复进行的任务设置更短的间隔。
struct timespec 由两部分构成：tv_sec 表示整秒数部分；tv_nsec 则表示毫微秒。
tv_nesc 的值必须小于109。
nanosleep 相比sleep具有另一个优点。
与sleep 相同，nanosleep 调用可以被信号中断，这是errno 将被设置为EINTR 而调用将返回-1。
但是，nanosleep 的第二个参数，另一个指向struct timespec 对象的指针，如果不为NULL 则在这种情况下它将被写入剩余的时间（这就是所请求的睡眠时间和实际睡眠时间的差)。
这使重新开始睡眠变的很容易。
头文件<time.h>。
以下是内核中的：1.udelay(); mdelay(); ndelay();实现的原理本质上都是忙等待，ndelay和mdelay都是通过udelay衍生出来的，我们使用这些函数的实现往往会碰到编译器的警告implicit declaration of function 'udelay'，这往往是由于头文件的使用不当造成的。
delphi 延时的方法
delphi 延时的方法Delphi是一种流行的编程语言，常用于Windows平台的应用程序开发。
在Delphi中，延时（Delay）是一种常用的操作，用于暂停程序的执行一段时间。
本文将介绍Delphi中常用的延时方法，并探讨其使用场景和注意事项。
一、使用Sleep函数实现延时在Delphi中，可以使用Sleep函数来实现延时效果。
Sleep函数属于Windows API，通过将当前线程挂起一段时间来实现延时。
Sleep函数的参数是以毫秒为单位的时间，表示需要暂停的时间长度。
下面是一个使用Sleep函数实现延时的示例代码：```pascalprocedure Delay(ms: Integer);beginSleep(ms);end;```在上述示例代码中，Delay过程接受一个整数参数ms，表示需要延时的毫秒数。
然后调用Sleep函数，将当前线程挂起指定的时间长度。
使用Sleep函数实现延时的优点是简单易用，代码量少。
但缺点是Sleep函数会阻塞当前线程的执行，导致程序无法响应其他操作。
因此，当需要延时的同时还需要保持程序的响应性时，应考虑其他方法。
二、使用TTimer组件实现延时Delphi中的TTimer组件可以用于实现延时效果，而不阻塞程序的执行。
TTimer组件是一个计时器，可以在指定的时间间隔内触发事件。
下面是一个使用TTimer组件实现延时的示例代码：```pascalprocedure TForm1.Delay(ms: Integer);beginTimer1.Interval := ms;Timer1.Enabled := True;end;procedure TForm1.Timer1Timer(Sender: TObject);beginTimer1.Enabled := False;// 延时结束后要执行的代码end;```在上述示例代码中，Delay过程接受一个整数参数ms，表示需要延时的毫秒数。
延时程序
;50毫秒延时程序(12M晶振）
YS05S: MOV R7,#200 ;单周期指令（1uS）
D1: MOV R6,#125 ;单周期指令（1uS）
DJNZ R6,$ ;双周期指令（2uS）该指令自身执行R5次
DJNZ R7,D1 ;双周期指令（2uS）D1执行R7次
RET ;双周期指令（2uS）
;0.1秒延时程序(12M晶振）
YS01S: MOV R7,#200 ;单周期指令（1uS）
D1: MOV R6,#250 ;单周期指令（1uS）
DJNZ R7,D1 ;双周期指令（2uS）D1执行R7次
RET ;双周期指令（2uS）
;1秒延时程序(12M晶振）
YS1S: MOV R7,#100 ;单周期指令（1uS）
D1: MOV R6,#100 ;单周期指令（1uS）
D2: MOV R5,#47 ;单周期指令（1uS）
NOP
DJNZ R5,$ ;双周期指令（2uS）该指令自身执行R5次
DJNZ R6,D2 ;双周期指令（2uS）D1执行R6次
DJNZ R7,D1 ;双周期指令（2uS）D1执行R7次
DJNZ R6,D1 ;双周期指令（2uS）D1执行R6次
DJNZ R7,D1 ;双周期指令（2uS）D1执行R7次
NOP
RET ;双周期指令（2uS）
RET ;双周期指令（2uS）
;1秒延时程序(12M晶振）
YS1S: MOV R7,#08H ;单周期指令（1uS）
D1: MOV R6,#0F4H ;单周期指令（1uS）
D2: MOV R5,#0FFH ;单周期指令（1uS）
汇编延时程序
DELAY:MOV R4,#2 ;延时子程序，12M晶振延时约1秒L3: MOV R2 ,#255L1: MOV R3 ,#255L2: DJNZ R3 ,L2DJNZ R2 ,L1DJNZ R4 ,L3RET这里的延时不是很精确..谁能给个精确点的数..R2,R3,R4DELAY:MOV R4,#25 ;延时子程序，12M晶振延时1.001秒L3: MOV R2 ,#200L1: MOV R3 ,#248L2: DJNZ R3 ,L2DJNZ R2 ,L1DJNZ R4 ,L3RET计算延时时间应注意以下几点：1、晶振跑多少的，象这里的6M的话，那么它执行的机器周期就是2us，2、看指令执行要多少个机器周期，向DJNZ、RET都要两个机器周期，3、那么，这里总共时间是26（1A）*255（0FF）*255（0FF）*2（机器周期）*2us(1个机器周期的时间)=6762600us 若要精确计算的话要加上上面赋值的时间和子程序返回的时间。
不过一般只要计算到上面就行了，因为赋值和返回指令的时间很短（相对于整个延时程序来说）希望对你有所帮助...51单片机 Keil C 延时程序的简单研究应用单片机的时候,经常会遇到需要短时间延时的情况。
需要的延时时间很短,一般都是几十到几百微妙(us)。
有时候还需要很高的精度,比如用单片机驱动DS18B20的时候,误差容许的范围在十几us以内,不然很容易出错。
这种情况下,用计时器往往有点小题大做。
而在极端的情况下,计时器甚至已经全部派上了别的用途。
这时就需要我们另想别的办法了。
以前用汇编语言写单片机程序的时候,这个问题还是相对容易解决的。
比如用的是12MHz晶振的51,打算延时20us,只要用下面的代码,就可以满足一般的需要：mov r0, #09hloop: djnz r0, loop51单片机的指令周期是晶振频率的1/12,也就是1us一个周期。
mov r0, #09h需要2个极其周期,djnz也需要2个极其周期。
延时程序设计简洁范本
延时程序设计延时程序设计1. 简介2. 原理延时程序设计的原理是通过使程序暂停一段时间来实现延迟效果。
一般来说，计算机程序的执行速度非常快，可以在很短时间内完成大量的计算和操作。
有些情况下，我们希望程序在执行过程中能够暂停一段时间，以便等待输入、控制程序的执行节奏或实现特定功能。
延时程序设计的实现原理有多种，常见的包括基于硬件定时器的延时、基于软件循环的延时和基于系统调用的延时。
3. 方法3.1 基于硬件定时器的延时基于硬件定时器的延时是指通过控制计算机内部的硬件定时器来实现延时效果。
具体实现方式因计算机硬件平台而异，但一般都涉及配置定时器的频率和计数器的值。
通过设置定时器的频率和计数器的值，可以控制定时器中断的触发时间，从而实现延时效果。
3.2 基于软件循环的延时基于软件循环的延时是指通过让程序在一个循环中反复执行无意义的操作来实现延时效果。
具体实现方式包括使用空循环、使用轮询等。
在软件循环的延时中，程序执行时间的长短直接影响延时效果。
3.3 基于系统调用的延时基于系统调用的延时是指通过调用操作系统提供的延时函数来实现延时效果。
具体实现方式因操作系统而异，但一般涉及调用操作系统提供的函数，如`sleep`、`usleep`或`nanosleep`等。
通过调用这些函数，可以使程序暂停一段时间，从而实现延时效果。
4. 注意事项在进行延时程序设计时，需要注意以下事项：延时时间的选择：根据具体需求和应用场景选择合适的延时时间。
延时方式的选择：根据实际情况选择合适的延时方式，如硬件定时器、软件循环或系统调用。
延时程序的影响：延时程序可能会影响程序的响应性能和资源利用率，需要综合考虑延时程度和程序性能的平衡。
并发与延时：在多线程或多任务环境下，延时程序可能会对程序的并发性和调度产生影响，需要注意并发安全和调度策略。
5.延时程序设计是一种常用的技术，用于控制程序执行中的延迟时间。
通过选择合适的延时时间和延时方式，可以实现各种时间相关的功能。
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结构来完成，每个循环体内的变量仍然采用无符号字符变量。
DEV C++类似单片机延时程序
DEVC++类似单片机延时程序VC中的WM_TIMER消息映射能进行简单的时间控制。
首先调用函数SetTimer()设置定时间隔，如SetTimer(0,200,NULL)即为设置200ms的时间间隔。
然后在应用程序中增加定时响应函数OnTimer()，并在该函数中添加响应的处理语句，用来完成到达定时时间的操作。
这种定时方法非常简单，可以实现一定的定时功能，但其定时功能如同Sleep()函数的延时功能一样，精度非常低，最小计时精度仅为30ms，CPU占用低，且定时器消息在多任务操作系统中的优先级很低，不能得到及时响应，往往不能满足实时控制环境下的应用。
只可以用来实现诸如位图的动态显示等对定时精度要求不高的情况。
VC中使用sleep()函数实现延时，它的单位是ms，如延时2秒，用sleep(2000)。
精度非常低，最小计时精度仅为30ms，用sleep函数的不利处在于延时期间不能处理其他的消息，如果时间太长，就好象死机一样，CPU占用率非常高，只能用于要求不高的延时程序中。
利用COleDateTime类和COleDateTimeSpan类结合WINDOWS的消息处理过程来实现秒级延时。
在精度要求较高的情况下，VC中可以利用GetTickCount()函数，该函数的返回值是DWORD型，表示以ms为单位的计算机启动后经历的时间间隔。
精度比WM_TIMER消息映射高，在较短的定时中其计时误差为15ms，在较长的定时中其计时误差较低，如果定时时间太长，就好象死机一样，CPU占用率非常高，只能用于要求不高的延时程序中。
DWORDdwStart=GetTickCount();DWORDdwEnd=dwStart;do{dwEnd=GetTickCount()-dwStart;}while(dwEnd)为使GetTickCount()函数在延时或定时期间能处理其他的消息，可以把代码改为：DWORDdwStart=GetTickCount();DWORDdwEnd=dwStart;do{MSGmsg;GetMessage(&msg,NULL,0,0);TranslateMessage(&msg);DispatchMessage(&msg);dwEnd=GetTickCount()-dwStart;}while(dwEnd)虽然这样可以降低CPU的占有率，并在延时或定时期间也能处理其他的消息，但降低了延时或定时精度。
各种延时程序集合(汇编)
延时5秒左右DELAY5S:PUSH 04HPUSH 05HPUSH 06HMOV R4,#50DELAY5S_0:MOV R5,#200 DELAY5S_1:MOV R6,#245 DJNZ R6,$DJNZ R5,DELAY5S_1DJNZ R4,DELAY5S_0POP 06HPOP 05HPOP 04HRET;513微秒延时程序DELAY: MOV R2,#0FEHDELAY1: DJNZ R2,DELAY1RET;10毫秒延时程序DL10MS: MOV R3,#14HDL10MS1:LCALL DELAYDJNZ R3,DL10MS1RET;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+5DEL : 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秒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: ;500500MSMOV 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=2390MOV R0,#244 ;1DELAY24001:MUL AB ;4MUL AB ;4DJNZ R0,DELAY24001 ;2RETDELAY: ;延时子程序(1秒)MOV R0,#0AHDELAY1: MOV R1,#00HDELAY2: MOV R2,#0B2HDJNZ R2,$DJNZ R1,DELAY2DJNZ R0,DELAY1RETMOV R2,#10 ;延时1秒LCALL DELAYMOV R2,#50 ;延时5秒LCALL DELAYDELAY: ;延时子程序PUSH R2PUSH R1PUSH R0DELAY1: MOV R1,#00HDELAY2: MOV R0,#0B2HDJNZ R0,$DJNZ R1,DELAY2 ;延时100 mSDJNZ R2,DELAY1POP R0POP R1POP R2RET。
单片机延时子程序
精确延时计算公式:延时时间=[(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的晶振所以在网上查找程序时如果涉及到精确延时则应该注意晶振的频率是多大。
单片机各种延时程序符号的含义解析
单片机各种延时程序符号的含义解析单片机延时程序MOV：这是一条指令，意思是传递数据。
说到传递，我们都很清楚，传东西要从一本人的手上传到另一本人的手上，也就是说要有一个接受者，一个传递者和一样东西。
从指令MOV R7，#250中来分析，R7是一个接受者，250是被传递的数，传递者在这条指令中被省略了（注意：并不是每一条传递指令都会省的，事实上大部份数据传递指令都会有传递者）。
它的意义也很明显：将数据250送到R7中去，因此执行完这条指令后，R7单元中的值就应当是250。
在250前面有个#号，这又是什么意思呢？这个#就是用来说明250就是一个被传递的东西本身，而不是传递者。
那么MOV R6，#250是什么意思，应当不用分析了吧。
DJNZ：这是另一条指令，我们来看一下这条指令后面跟着的两个东西，一个是R6，一个是D2，R6我们当然已知是什么了，查一下D2是什么。
D2在本行的前面，我们已学过，这称之为标号。
标号的用途是什么呢？就是给本行起一个名字。
DJNZ指令的执行过程是这样的，它将其后面的第一个参数中的值减1，然后看一下，这个值是否等于0，如果等于0，就往下执行，如果不等于0，就转移，转到什么地方去呢？可能大家已猜到了，转到第二个参数所指定的地方去（请大家用自已的话讲一下这条语句是怎样执行的）。
本条指令的最终执行结果就是，在原地转圈250次。
执行完了DJNZ R6，D2之后（也就是R6的值等于0之后），就会去执行下面一行，也就是DJNZ R7，D1，请大家自行分析一下这句话执行的结果。
（转去执行MOV R6，#250，同时R7中的值减1），最终DJNZ R6，D2这句话将被执行250*250=62500次，执行这么多次同一条指令干吗？就是为了延时。
一个问题：如果在R6中放入0，会有什么样的结果。
二、时序分析：前面我们介绍了延时程序，但这还不完善，因为，我们只知道DJNZ R6，D2这句话会被执行62500次，但是执行这么多次需要多长时间呢？是否满足我们的要求呢？我们还不知。
C++程序延时处理的几种方法
9. }
10.
11. /// @brief 程序延时
12. /// @param[in] sec : 秒
13. /// @remark
14. /// @return void
15. void delay_sec(int sec)//
16. {
17. time_t start_time, cur_time;
18. time(&start_time);
19. do
20. {
21.
time(&cur_time);
22. } while((cur_time - start_time) < sec);
23. }
例如，延时2秒可以这样：delay_msec(2000); 或者 delay_sec(2);
需要指出的是，delay_msec由于使用的是clock()，所以具有更高的时间精度（精确到1毫秒，具体看编译器定义）。
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
C++程 序 延 时 处 理 的 几 种 方 法
（—）使用_sleep()函数 例如：_sleep(200);//延时200毫秒
（二）使用delay(int time)函数 （需要自己实现，编译器里面没有）
[cpp]
1. /// @brief 程序延时
2. /// @param[in] msec : 毫秒
3. /// @remark
4. /// @return void
5. void delay_msec(int msec)
6. {
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
DJNZ R0,$
DJNZ R1,DELAY2 ;延时 100 mS
DJNZ R2,DELAY1
POP R0
POP R1
POP R2
RET
(转贴)精确廷时计算公式:
延时时间=[(2*第一层循环+3)*第二层循环+3]*第三层循环+5
另外,网上有很多计算延时的应用程序,我这也有几个,有需要的同学发邮件.
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)
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
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指令周期
*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
RET
DELAY_500MS: ;500500MS
MOV R2,#208
JMP DELAY_MS
DELAY_175MS: ;175MS
MOV R2,#73
JMP DELAY_MS
delaY_120MS: ;120MS
MOV R2,#50
DJNZ R4,DELAY5S_0
POP 06H
POP 05H
POP 04H
RET
DELAY:MOV R6,#245
DJNZ R6,$
DJNZ R5,DELAY5S_1
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;
;延时5秒左右
DELAY5S:PUSH 04H
PUSH 05H
PUSH 06H
MOV R4,#50
MOV R3,#10
JMP DELAY10MS
DELAY_10MS:
MOV R3,#1
DELAY10MS: ;去抖动10MS
(11.0592mhz)
MOV R4,#20
DELAY10MSA:
MOV R5,#247
DJNZ R5,$
DJNZ R4,DELAY10MSA
DJNZ R3,DELAY10MS
MOV R5,#248;
DJNZ R5,$
DJNZ R6,D2;
DJNZ R7,D1;
RET
DELAY_2S: ;10MS(11.0592mhz)
MOV R3,#200
JMP DELAY10MS
DELAY_100MS: ;100MS(11.0592mhz)
JMP DELAY_MS
delay_60ms: ;60ms
MOV R2,#25
JMP DELAY_MS
delay_30ms: ;30ms
MOV R2,#12
JMP DELAY_MS
DELAY_5MS: ;5MS
MOV R2,#2
;===================================
DELAY_MS:
CALL DELAY2400
DJNZ R2,DELAY_MS
RET
;===================================
DELAY2400: ;10x244+4=2447
/1.024=2390
MOV R0,#244 ;1
DELAY24001:
MUL AB ;4
MUL AB ;4
DJNZ R0,DELAY240
01 ;2
RET
DELAY: ;延时子程序(1秒)
MOV R0,#0AH
DELAY1: MOV R1,#00H
DELAY2: MOV R2,#0B2H
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
;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
DJNZ R2,$
DJNZ R1,DELAY2
DJNZ R0,DELAY1
RET
MOV R2,#10 ;延时1秒
LCALL DELAY
MOV R2,#50 ;延时5秒
LCALL DELAY
DELAY: ;延时子程序
PUSH R2
PUSH R1
PUSH R0
DELAY1: MOV R1,#00H