C语言延时程序
c延时函数delay
c延时函数delay延时函数（delay function）是一种在程序中用来暂停一段时间的函数。
在C语言中，延时函数通常用于需要控制时间间隔的应用程序中，例如时钟、定时器、动画等。
在C语言中，实现延时函数有多种方法，下面将介绍两种常用的方法。
1.使用循环计数法延时函数最常见的实现方式之一是使用循环计数法。
具体步骤如下：-接收一个参数，表示延时的毫秒数；-将参数转换为循环需要的次数。
在现代计算机中，循环一次通常需要几十纳秒到几百纳秒的时间，因此需要将毫秒数转换为相应的循环次数；-使用一个循环来延时，每次循环后递减计数器，直到计数器为0。
下面是一个使用循环计数法实现的延时函数的示例代码：```c#include <stdio.h>#include <stdlib.h>void delay(int milliseconds)for(int i = 0; i < iterations; i++)//什么都不做，只是进行循环迭代}printf("Before delay\n");delay(1000); // 延时1秒printf("After delay\n");return 0;```2.使用标准库函数- `sleep(`函数：使程序休眠指定的秒数。
参数是休眠的秒数。
下面是使用`usleep(`函数实现延时的示例代码：```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>void delay(int milliseconds)usleep(milliseconds * 1000); // 将毫秒转换为微秒int maiprintf("Before delay\n");delay(1000); // 延时1秒printf("After delay\n");```无论是使用循环计数法还是使用标准库函数，延时函数都有一定的局限性。
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:感谢大家的阅读，本文由我司收集整编。
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)。
c语言延时函数
c语言延时函数
C语言中的延时函数是用来暂停程序执行一段时间的函数。
在嵌入式系统中，延时函数非常常见，因为它可以控制程序的执行速度，使程序按照预期的时间顺序执行。
常见的延时函数有两种实现方式：软件延时和硬件延时。
软件延时是通过循环来实现的，即在程序中使用一个循环来占用CPU的时间，从而实现延时的效果。
例如，下面是一个简单的软件延时函数：```。
void delay(unsigned int ms)。
unsigned int i, j;。
for (i = 0; i < ms; i++)。
for (j = 0; j < 1000; j++);。
}。
```这个函数的原理是在内层循环中占用CPU的时间，从而实现延时的效果。
但是，这种方式有一个缺点，就是在延时期间CPU是被占用的，不能执行其他任务。
硬件延时是通过使用定时器来实现的，即在程序中设置一个定时器，定时器到达指定时间后触发中断，从而实现延时的效果。
例如，下面是一个简单的硬件延时函数：```。
void delay(unsigned int ms)。
//设置定时器。
TMR0=0;。
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);}。
单片机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倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
c语言中延时的方法
c语言中延时的方法C语言中实现延时的方法有多种方式。
下面将介绍两种常用的延时方法：方法一：使用循环实现延时使用循环来进行延时是C语言中常用的方法之一。
通过循环次数来控制延时的时间，代码如下：```#include <stdio.h>void delay(int milliseconds) {for (int i = 0; i < milliseconds * 10000; i++) {// 延时}}int main() {printf("开始延时\n");delay(1000); // 延时1秒printf("延时结束\n");return 0;}```在上述代码中，delay函数使用了一个for循环来实现延时，其中循环次数通过乘以10000与延时时间相乘得到。
这种方法的缺点是无法精确控制延时时间，受系统执行速度的影响较大。
方法二：使用<time.h>库函数实现延时另一种常用的延时方法是利用<time.h>头文件中的库函数，如sleep函数。
代码如下：```#include <stdio.h>#include <time.h>void delay(int seconds) {sleep(seconds);}int main() {printf("开始延时\n");delay(1); // 延时1秒printf("延时结束\n");return 0;}```在上述代码中，delay函数通过调用sleep函数来实现延时，参数表示延时的秒数。
这种方法的优点是延时时间较为精确，但缺点是无法实现毫秒级的延时。
以上是C语言中实现延时的两种常用方法。
开发者可以根据具体需求选择合适的延时方法。
C延时程序
单片机C语言延时程序用C语言写出来程序非常的简练，它是一种模块化的语言，一种比汇编更高级的语言，但是就是这样一种语言也还是有它不足之处：它的延时很不好控制，我们常常很难知道一段延时程序它的精确延时到底是多少，这和汇编延时程序没法比。
但有时后写程序又不得不要用到比较精确的延时，虽然说可以用混合编程的方式解决，但这种方式不是每个人都能掌握，且写起来也麻烦。
所以，通过测试我给大家提供一个延时子程序模块，并以此给一个出我们经常用到的延时的数据表格。
（注意：表格中的数据只适合我的延时模块，对其他的延时程序不适用，切忌！！！！！！！！别到时候延时不对来骂我）延时模块：其中问号代表要填的数，要延时多少，到表格中去找数据，然后填上就OK！切忌3条FOR语句不能颠倒顺序void Delay(){unsigned char a,b,c;for(a=0;a<?;a++)for(b=0;b<?;b++)for(c=0;c<?;c++);}数据表如下/****************************************************************************** ****************************************/延时时间a的值b的值c的值延时误差（us）10us 1 1 1 -0.520us 1 1 8 030us 1 1 15 +0.540us 2 1 9 050us 1 1 28 060us 1 1 35 +0.570us 1 1 42 +180us 1 1 48 055 +0.5100us 1 1 61 -0.5200us 1 1 128 0300us 3 1 63 +1.5400us 2 1 129 0500us 5 1 63 +0.5600us 6 1 63 0700us 7 1 63 -0.5800us 1 3 175 +0.5900us 9 1 63 -1.51ms 1 3 219 -1.5220 +33ms 3 3 220 +3Xms X 3 220 +3(X的范围为2到255)基本上我们平时用到的延时都在这里了，每种延时的误差都很小，最大也不过3us，有的甚至没有误差，已经很精确了，如果想延时1秒钟，你可以连续调用延时250ms的程序4次，总共延时误差12us，这样的误差已经不算误差了，用汇编语言编写还达不到这个程度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C51精确延时程序
一、、看了网上延时程序的帖子挺多，我也说点。
用keil调试，
void yanshi( uint n )
{
uchar data i="0";
for(i=0;i<N;I++);
return;
}
延时时间=12*（n*12+17）/fosc
用keil测时功能很容易得到这个关系，很精确，偏差不过几us.
可以自己编一些延时程序，也可以很方便的得到关系式，只是系数不同.
二、、//我看到的地方也是从别的地方转贴，所以我不知道原作者是谁，但相信这么成熟的东西转一下他也不会见意。
看到了个好帖，我在此在它得基础上再抛抛砖！
有个好帖，从精度考虑，它得研究结果是：
void delay2(unsigned char i)
{
while(--i);
}
为最佳方法。
分析：假设外挂12M（之后都是在这基础上讨论）
我编译了下，传了些参数，并看了汇编代码，观察记录了下面的数据：
delay2(0):延时518us 518-2*256=6
delay2(1):延时7us（原帖写“5us”是错的，^_^）
delay2(10):延时25us 25-20=5
delay2(20):延时45us 45-40=5
delay2(100):延时205us 205-200=5
delay2(200):延时405us 405-400=5
见上可得可调度为2us，而最大误差为6us。
精度是很高了！
但这个程序的最大延时是为518us 显然不
能满足实际需要，因为很多时候需要延迟比较长的时间。
那么，接下来讨论将t分配为两个字节，即uint型的时候，会出现什么情况。
void delay8(uint t)
{
while(--t);
}
我编译了下，传了些参数，并看了汇编代码，观察记录了下面的数据：
delay8(0):延时524551us 524551-8*65536=263
delay8(1):延时15us
delay8(10):延时85us 85-80=5
delay8(100):延时806us 806-800=6
delay8(1000):延时8009us 8009-8000=9
delay8(10000):延时80045us 80045-8000=45
delay8(65535):延时524542us 524542-524280=262
如果把这个程序的可调度看为8us，那么最大误差为263us，但这个延时程序还是不能满足要求的，因为延时最大为524.551ms。
那么用ulong t呢？
一定很恐怖，不用看编译后的汇编代码了。
那么如何得到比较小的可调度，可调范围大，并占用比较少得RAM呢？请看下面的程序：
/*--------------------------------------------------------------------
程序名称：50us 延时
注意事项：基于1MIPS，AT89系列对应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=13
delay_50us(10):延时513us 503-500=13
delay_50us(100):延时5013us 5013-5000=13
delay_50us(1000):延时50022us 50022-50000=22
赫赫，延时50ms，误差仅仅22us，作为C语言已经是可以接受了。
再说要求再精确的话，就算是用汇编也得改用定时器了。
/*--------------------------------------------------------------------
程序名称：50ms 延时
注意事项：基于1MIPS，AT89系列对应12M晶振，W77、W78系列对应3M晶振
例子提示：调用delay_50ms（20），得到1s延时
全局变量：无
返回：无
--------------------------------------------------------------------*/
void delay_50ms(uint t)
{
uint j;
/****
可以在此加少许延时补偿，以祢补大数值传递时（如delay_50ms(1000)）造成的误差，但付出的代价是造成传递小数值（delay_50ms(1)）造成更大的误差。
因为实际应用更多时候是传递小数值，所以补建议加补偿！
****/
for(;t>0;t--)
for(j=6245;j>0;j--)
;
}
我编译了下，传了些参数，并看了汇编代码，观察记录了下面的数据：
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
赫赫，延时50s，误差仅仅2.978ms，可以接受！
上面程序没有才用long，也没采用3层以上的循环，而是将延时分拆为两个程序以提高精度。
应该是比较好的做法了。
１、//延时1ms子程序
void DelayMs(unsigned int n)
{
unsigned int i,j;
for(i=0;i<n;i++)
for(j=0;j<120;j++);
}
2、汇编写的：
;;;;;;;;;;延时50ms子程序;;;;;;;;;;;;;;
DELAY:
MOV R7,#98
D1: MOV R6,#255
NOP
NOP
DJNZ R6,$ ;执行一次2微妙
DJNZ R7,D1
RET
３、、//延时1０ms子程序
void DelayMs(unsigned int n)
{
uchar 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--); }
５、２００ms延时子程序程序:
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--); }
６、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--); }
７、
/*--------------------------------------------------- ---------------
函数全称：50us 延时
注意事项：基于1MIPS，AT89系列对应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=13
delay_50us(10):延时513us 513-500=13
delay_50us(100):延时5013us 5013-5000=13
delay_50us(1000):延时50022us 50022-50000=22
延时50ms，误差仅仅22us.
*******************************************************************/。