KeilC51精确延时程序执行时间
延时时间计算
单片机C51延时时间怎样计算?[日期:2010-04-28 ] [来源:本站原创作者:admin] [字体:大中小] (投递新闻)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--);}参考链接:/news/2010-04/2106.htmkeilc51程序设计中几种精确延时及延时的计算、确定软件用法(如protues、keil、Word)2009-09-08 12:04:54 阅读340 评论0 字号:大中小摘要实际的单片机应用系统开发过程中,由于程序功能的需要,经常编写各种延时程序,延时时间从数微秒到数秒不等,对于许多C51开发者特别是初学者编制非常精确的延时程序有一定难度。
51单片机C语言精确延时程序(超级准)
51单片机 C语言精确延时程序(超级准)
51单片机C语言精密延时程序 程序如下: void delayms(unsigned char t) { unsigned char j; unsigned char i; do { j=3; do { i=165; do { --i; } while(i!=0); --j; } while(j!=0); --t; } while(t!=0); } 该程序延时时基为1ms,所以最大延时时间是255ms 下面是反编译的汇编程序 C:0x0031 7E03 MOV R6,#0x03 C:0x0033 7DA5 MOV R5,#0xA5 C:0x0035 DDFE DJNZ R5,C:0035 C:0x0037 DEFA DJNZ R6,C:0033 C:0x0039 DFF6 DJNZ R7,delayms(C:0031) C:0x003B 22 RET 延时时间计算公式如下: ((R5*2 + 2+1)*R6+2+1)R7
假设R7=1,上式为(165*2+3)*3+2+1 =1002us!!!!! 以上程序使用的晶振是12MHz,如果使用的是其他频率的晶振只需计算出1ms的机器周期 数,代入5*2 + 2+1)*R6+2+1,选择合适的R
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个机器周期)。
单片机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);}。
Keil C51精确延时程序设计
Keil C51精确延时程序设计时间:2013-05-16 10:45:33 来源:电子设计工程作者:吴挺运,林成何摘要针对C语言代码的执行时间的可预见性差,结合Keil C51开发工具,分析了在Keil C51开发工具中利用C语言实现精确的延时程序的设计,指出了常用延时方法优缺点。
并通过一些实例分析了延时时间的计算方法,使C语言代码的延时时间可以被预见。
C语言中嵌套汇编语言是一种有效的方法,可以充分发挥出各语言的优势特点、提高开发效率。
关键词 Keil C51;C语言;软件延时;单片机C语言具有较强的数据处理能力、语言功能齐全、使用灵活方便、开发效率高,被广泛应用于在单片机系统开发应用中。
在单片机幕统开发的过程中,经常需要使用到延时程序,但C语言代码执行时间。
的可预见性和实时性较差,在开发一些具有严格通信时序要求的系统时,往往需要反复调试延时代码,给开发者带来了较大困难。
比如使用DS18B20进行温度测控时,必须按照其单总线通信协议,否则无法读取温度数据。
针对上述问题,结合Keil C51开发工具和Proteus仿真软件,介绍在Keil C51开发系统中,利用C语言编写的延时程序设计及其运行的时间的计算方法。
1 常用延时程序的设计方法1.1 利用定时器/计数器延时利用C51单片机内部2个16位定时器/计数器实现精确的程序,由于定时器/计数器不占用CPU的运行时间,可以提高CPU的使用效率。
但假设使用12 MHz晶振,定时器工作在方式1模式下,其最长定时时间也只能达到65.53 ms,由此,可以采用中断方式进行溢出次数累加的方法进行长时间的延时程序设计。
但在开发过程中要考虑C51自动对断点的保护和重装初值所带来的延时误差,也可以使用定时器工作在方式2模式下,减少重装初值所带来的误差。
1.2 利用空操作实现延时当所需的延时非常短,可以利用Keil C51自带intrins.h头文件中的_nop_()函数实现函数延时。
关于51精确延时及keil仿真延时时间
假设参数变量 i 的初值为 m,参数变量 j 的初值为 n,参数变量 k 的初值为 l,则总延时时间为:l 乘以(n 乘以(m 乘以 T+2T)+2T)+3T,其中 T 为 DJNZ 和 MOV 指令执行的时间。当 m=n=l 时,精确延时为 9T,最短;当 m=n=l=256 时,精确延时到 169080102029da1.html 三、下面介绍一下如何用 keil 仿真延时时间 测试函数: void TempDelay (unsigned char idata us) { while(us--); } 测试用例: TempDelay(80); //530uS TempDelay(14); //100uS
LOOP2: MOV R6,#0FFH LOOP1: DJNZ R6,LOOP1 DJNZ R7,LOOP2 这些指令的组合在汇编语言中采用 DJNZ 指令来做延时用,因此它的时间 精确计算也是很简单,假上面变量 i 的初值为 m,变量 j 的初值为 n,则总延 时时间为:m 乘以(n 乘以 T+T),其中 T 为 DJNZ 指令执行时间(DJNZ 指令为 双周期指令)。这里的+T 为 MOV 这条指令所使用的时间。同样对于更长时间 的延时,可以采用多重循环来完成。 只要在程序设计循环语句时注意以上几个问题。 下面给出有关在 C51 中延时子程序设计时要注意的问题 1、在 C51 中进行精确的延时子程序设计时,尽量不要或少在延时子程序 中定义局部变量,所有的延时子程序中变量通过有参函数传递。 2、在延时子程序设计时,采用 dowhile,结构做循环体要比 for 结构做循 环体好。 3、在延时子程序设计时,要进行循环体嵌套时,采用先内循环,再减减比 先减减,再内循环要好。
while(i); 或 unsigned char i,j i=255; while(i) {j=255; while(j) {j--}; i--; } 这三种方法都是用 DJNZ 指令嵌套实现循环的,由 C51 编译器用下面的指 令组合来完成的 MOV R7,#0FFH
C51精确延时
C: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
C:0x080A DDFA DJNZ R5,C:0806
C:0x080C DEF6 DJNZ R6,C:0804
C:0x080E DFF2 DJNZ R7,C:0802
C:0x0810 22 RET
五._nop_指令
可以利用intrins.h所带的头文件中的_nop_指令实现us级得延时,当主程序调用delay()函数时,首先执行LCALL指令占用2个机器周期,然后执行_nop_函数,相当于汇编中的NOP指令,占用一个机器周期,最后执行一个RST指令占用两个机器周期,所以一个_nop_指令延时5个机器周期。要增加延时时间,可以多添加几个_nop_函数指令,进行计算,两个_nop_指令延时6个机器周期。
for(j=116;j>0;j--)
for(k=214;k>0;k--);
}
产生的汇编
C:0x0800 7F05 MOV R7,#0x05
C:0x0802 7E04 MOV R6,#0x04
C:0x0804 7D74 MOV R5,#0x74
C:0x0806 7CD6 MOV R4,#0xD6
C:0x0808 DCFE DJNZ R4,C:0808
Keil C51程序设计中几种精确延时方法
器 延 时 从 程 序 的 执 行 效 率 和 稳 定 性 两 方 面 考 虑 都 是 最 佳
的 方 案 。但 应该 注 意 , 1编 写 的 中断 服 务 程 序 编 译 后 会 C5
自动 加 上 PUS AC P H S 、 OP P W 和 PO H C、 US P W P S P
R
JJ J c…
…
维普资讯
。
珏 譬
I
z
一
N U -( ); J
◆ #p a maam、 rg n a m 和 a m 只 能在 函 rg s #p a mae d s s 数 内使 用 。
一
NOP () 一 ;
N0 P () ;
AC C语 句 , 行 时 占用 了 4个 机 器 周 期 ; 程 序 中还 有 计 执 如 数 值加 1语 句 , 又 会 占用 1个机 器 周 期 。这 些 语 句 所 消 则 耗 的 时 间在 计 算 定 时初 值 时 要 考 虑 进 去 , 初值 中减 去 以 从
达 到最 小 误 差 的 目的 。
一
一
将 汇 编 语 言 与 C 1结 合 起 来 , 分 发 挥 各 自的 优 势 , 5 充
无 疑 是 单 片 机 开 发 人 员 的 最佳 选 择 。
}
Dea l u () ly 0 s 函数 中共 用 了 6个一 NOP () 句 , 个 一 语 每
语 句 执 行 时 间 为 1U 。主 函 数 调 用 Dea l u () , 执 S ly 0 s 时 先 行一 个 L CALL指 令 ( s , 后 执 行 6个一 2 )然 NOP () 句 一 语
维普资讯
K iC 1 序设 计中几 种精确 延 时方法 * el 5 程
延时时间计算
单片机C51延时时间怎样计算?[日期:2010-04-28 ] [来源:本站原创作者:admin] [字体:大中小] (投递新闻)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--);}参考链接:/news/2010-04/2106.htmkeilc51程序设计中几种精确延时及延时的计算、确定软件用法(如protues、keil、Word)2009-09-08 12:04:54 阅读340 评论0 字号:大中小摘要实际的单片机应用系统开发过程中,由于程序功能的需要,经常编写各种延时程序,延时时间从数微秒到数秒不等,对于许多C51开发者特别是初学者编制非常精确的延时程序有一定难度。
keilc51精确延时程序执行时间
K e i l C51精确延时程序执行时间(总6页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--Keil C51 精确延时程序执行时间引言单片机因具有体积小、功能强、成本低以及便于实现分布式控制而有非常广泛的应用领域[1]。
单片机开发者在编制各种应用程序时经常会遇到实现精确延时的问题,比如按键去抖、数据传输等操作都要在程序中插入一段或几段延时,时间从几十微秒到几秒。
有时还要求有很高的精度,如使用单总线芯片DS18B20时,允许误差范围在十几微秒以内[2],否则,芯片无法工作。
用51汇编语言写程序时,这种问题很容易得到解决,而目前开发嵌入式系统软件的主流工具为C语言,用C51写延时程序时需要一些技巧[3]。
因此,在多年单片机开发经验的基础上,介绍几种实用的编制精确延时程序和计算程序执行时间的方法。
实现延时通常有两种方法:一种是硬件延时,要用到定时器/计数器,这种方法可以提高CPU的工作效率,也能做到精确延时;另一种是软件延时,这种方法主要采用循环体进行。
1 使用定时器/计数器实现精确延时单片机系统一般常选用 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个机器周期。
C51精确延时程序
看到了个好帖,我在此在它得基础上再抛抛砖!有个好帖,从精度考虑,它得研究结果是:void delay2(unsigned char i){while(--i);}为最佳方法。
分析:假设外挂12M(之后都是在这基础上讨论)我编译了下,传了些参数,并看了汇编代码,观察记录了下面的数据:delay2(0):延时518us 518-2*256=6delay2(1):延时7us(原帖写“5us”是错的,^_^)delay2(10):延时25us 25-20=5delay2(20):延时45us 45-40=5delay2(100):延时205us 205-200=5delay2(200):延时405us 405-400=5见上可得可调度为2us,而最大误差为6us。
精度是很高了!但这个程序的最大延时是为518us 显然不能满足实际需要,因为很多时候需要延迟比较长的时间。
那么,接下来讨论将t分配为两个字节,即uint型的时候,会出现什么情况。
void delay8(uint t){while(--t);}我编译了下,传了些参数,并看了汇编代码,观察记录了下面的数据:delay8(0):延时524551us 524551-8*65536=263delay8(1):延时15usdelay8(10):延时85us 85-80=5delay8(100):延时806us 806-800=6delay8(1000):延时8009us 8009-8000=9delay8(10000):延时80045us 80045-8000=45delay8(65535):延时524542us 524542-524280=262如果把这个程序的可调度看为8us,那么最大误差为263us,但这个延时程序还是不能满足要求的,因为延时最大为524.551ms。
那么用ulong t呢?一定很恐怖,不用看编译后的汇编代码了。
那么如何得到比较小的可调度,可调范围大,并占用比较少得RAM呢?请看下面的程序:/*--------------------------------------------------------------------程序名称:50us 延时注意事项:基于1MIPS,A T89系列对应12M晶振,W77、W78系列对应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=13delay_50us(10):延时513us 503-500=13delay_50us(100):延时5013us 5013-5000=13delay_50us(1000):延时50022us 50022-50000=22赫赫,延时50ms,误差仅仅22us,作为C语言已经是可以接受了。
单片机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--); }参考链接:摘要实际的单片机应用系统开发过程中,由于程序功能的需要,经常编写各种延时程序,延时时间从数微秒到数秒不等,对于许多C51开发者特别是初学者编制非常精确的延时程序有一定难度。
Keil C中软件实现精确延时的几种方法
KeilC中软件实现精确延时的几种方法
赵晓东,张丽梅
(中北大学信息与通信工程学院山西太原030051)
摘要:在单片机应用系统开发过程中,经常需要编写各种延时程序,延时时间从数微秒到数秒不等,本文讨论了几种常用的软件延时及计算时间的方法,以供学习和使用。
1.2使用while循环或for循环
两种循环可以单独使用,也可以嵌套使用,即可以编写成延时函数使用,也可以在程序中直接使用,但是会有微小的差别,即增加了调用函数的时间。下面的函数可实现1ms到1s的延时,误差为16us,基本满足一般应用的要求。需要注意的是使用不同的循环变量类型,得到的延时也会不同。
1软件延时பைடு நூலகம்法
为了讨论方便,在下面的实例中采用12M晶振,即一个机器周期为1us。
1.1使用_nop_()语句
在程序中可以通过使用带_nop_()语句的函数实现延时。定义一系列不同的延时函数,如Delayl0us()、Delay20us()、Delay40us()等,需要时在主程序中调用。如延时10us的延时函数可编写如下:
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项显示的时间。最后用结束处的时间减去开始处时间,就得到循环程序段所占用的时间。
单片机C51延时时间怎样计算
单片机C51延时时间怎样计算一. 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--);}参考链接::// picavr /news/2010-04/2106.htm摘要实际的单片机应用系统开发过程中,由于程序功能的需要,经常编写各种延时程序,延时时刻从数微秒到数秒不等,关于许多C51开发者专门是初学者编制专门精确的延时程序有一定难度。
使用C语言编写的单片机C51延时时间计算方法和设计经验总结
C 程序中可使用不同类型的变量来进行延时设计。经实验测试,使用 unsigned char 类
型具有比 unsigned int 更优化的代码,在使用时应该使用 unsigned char 作为延时变量。以
某晶振为 12MHz 的单片机为例,晶振为 12MHz 即一个机器周期为 1us。
1
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--); }
延时总时间 = 三层循环 + 循环外 = 499995+5 = 500000us =500ms
计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5
其中:R5 代表最内层循环次数 R6 代表中间层循环次数 R7 代表外层循环次数
二. 200ms 延时子程序 程序: void delay200ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=132;j>0;j--)
一. 500ms 延时子程序
程序:
void delay500ms(void)
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。
KeilC51精确延时程序设计
KeilC51精确延时程序设计吴挺运;林成何【期刊名称】《电子科技》【年(卷),期】2012(025)012【摘要】C programming In view language of the poor predictability of the execution time of the C programming language code, we use to achievethe accurate design of delay procedure in detail, and point out the advantages and disadvantages of the usual delay methods. Besides, introduce the calculation of the delay time through some we take advantage of some powerful functions of Keil C51 to examples so that the delay time of the C programming lan- guage code can be predicted. Nesting the assembly language into C programming language can give full play to the advantages of all kinds of language and thus improving the development efficiency%针对C语言代码的执行时间的可预见性差,结合KeilC51开发工具,分析了在KeilC51开发工具中利用c语言实现精确的延时程序的设计,指出了常用延时方法优缺点。
并通过一些实例分析了延时时间的计算方法,使c语言代码的延时时间可以被预见。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Keil C51精确延时程序执行时间引言单片机因具有体积小、功能强、成本低以及便于实现分布式控制而有非常广泛的应用领域[1]。
单片机开发者在编制各种应用程序时经常会遇到实现精确延时的问题,比如按键去抖、数据传输等操作都要在程序中插入一段或几段延时,时间从几十微秒到几秒。
有时还要求有很高的精度,如使用单总线芯片DS18B20时,允许误差围在十几微秒以[2],否则,芯片无法工作。
用51汇编语言写程序时,这种问题很容易得到解决,而目前开发嵌入式系统软件的主流工具为C语言,用C51写延时程序时需要一些技巧[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<DlyT;i++) {;}”。
在程序中加入这一循环结构,首先选择build taget,然后单击start/stop debug session按钮进入程序调试窗口,最后打开Disassembly window,找出与这部分循环结构相对应的汇编代码,具体如下:C:0x000FE4CLRA//1TC:0x0010FEMOVR6,A//1TC:0x0011EEMOVA,R6//1TC:0x0012C3CLRC//1TC:0x00139FSUBBA,DlyT //1TC:0x00145003JNCC:0019//2TC:0x00160E INCR6//1TC: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//1TC:0x00111F DECR7//1TC:0x0012EE MOVA,R6//1TC: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。
这3种循环结构的延时与循环次数的关系如表1所列。
表1循环次数与延时时间关系单位:μs注意:计算时间时还应加上函数调用和函数返回各2个机器周期时间。
2.5使用性能分析器计算延时时间很多C程序员可能对汇编语言不太熟悉,特别是每个指令执行的时间是很难记忆的,因此,再给出一种使用Keil C51的性能分析器计算延时时间的方法。
这里还以前面介绍的for (i=0;i<124;i++)结构为例。
使用这种方法时,必须先设置系统所用的晶振频率,选择Options for target中的target选项,在Xtal(MHz)中填入所用晶振的频率。
将程序编译后,分别在_point = 1和T_point = 0处设置两个运行断点。
选择start/stop debug session按钮进入程序调试窗口,分别打开Performance Analyzer window和Disassembly window。
运行程序前,要首先将程序复位,计时器清零;然后按F5键运行程序,从程序效率评估窗口的下部分可以看到程序到了第一个断点,也就是所要算的程序段的开始处,用了389 μs;再按F5键,程序到了第2个断点处也就是所要算的程序段的结束处,此时时间为1 386 μs。
最后用结束处的时间减去开始处时间,就得到循环程序段所占用的时间为997 μs。
当然也可以不用打开Performance Analyzer window,这时观察左边工具栏秒(SEC)项。
全速运行时,时间不变,只有当程序运行到断点处,才显示运行所用的时间。
3总结本文介绍了多种实现并计算延时程序执行时间的方法。
使用定时器进行延时是最佳的选择,可以提高MCU工作效率,在无法使用定时器而又需要实现比较精确的延时时,后面介绍的几种方法可以实现不等时间的延时:使用自定义头文件的优点是,可实现任意时间长短的延时,并减少主程序的代码长度,便于对程序的阅读理解和维护。