C语言中的延时与计时技巧
c语言delay的用法
c语言delay的用法在单片机应用中，经常会遇到需要短时间延时的情况，一般都是几十到几百μs，并且需要很高的精度(比如用单片机驱动DS18B20时，误差容许的范围在十几μs以内，不然很容易出错);而某些情况下延时时间较长，用计时器往往有点小题大做。
另外在特殊情况下，计时器甚至已经全部用于其他方面的定时处理，此时就只能使用软件定时了。
下面小编就和大家分享下c语言delay的用法1 C语言程序延时Keil C51的编程语言常用的有2种：一种是汇编语言;另一种是C 语言。
用汇编语言写单片机程序时，精确时间延时是相对容易解决的。
比如，用的是晶振频率为12 MHz的AT89C51，打算延时20 μs，51单片机的指令周期是晶振频率的1/12，即一个机器周期为1 μs;“MOV R0,#X”需要2个机器周期，DJNZ也需要2个机器周期，单循环延时时间t=2X+3(X为装入寄存器R0的时间常数)[2]。
这样，存入R0里的数初始化为8即可，其精度可以达到1 μs。
用这种方法，可以非常方便地实现512 μs以下时间的延时。
如果需要更长时间，可以使用两层或更多层的嵌套，当然其精度误差会随着嵌套层的增加而成倍增加。
虽然汇编语言的机器代码生成效率很高，但可读性却并不强，复杂一点的程序就更难读懂;而C语言在大多数情况下，其机器代码生成效率和汇编语言相当，但可读性和可移植性却远远超过汇编语言，且C 语言还可以嵌入汇编程序来解决高时效性的代码编写问题。
就开发周期而言，中大型软件的编写使用C 语言的开发周期通常要比汇编语言短很多，因此研究C语言程序的精确延时性能具有重要的意义。
C程序中可使用不同类型的变量来进行延时设计。
经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时应该使用unsigned char作为延时变量。
2 单层循环延时精度分析下面是进行μs级延时的while程序代码。
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;。
.c延时函数 纳秒级别
.c延时函数纳秒级别在C语言中，一般使用以下两种方法实现纳秒级别的延时函数：方法一：使用“空循环”来实现延时空循环指的是在函数中使用一个循环，但循环内部不进行任何有意义的操作，而是使循环的迭代次数达到一定数量，从而达到一定的延时效果。
例如，假设我们需要实现一个延时1纳秒的函数，可以使用下面的代码实现：cvoid delay_ns(unsigned int ns) {volatile int i,j; volatile表示变量可能被意外修改，防止被编译器优化掉for (i = 0; i < ns; i++) {for (j = 0; j < 12; j++); 循环12次，大约需要1纳秒的时间（具体需要根据CPU速度进行调整）}}需要注意的是，空循环的实现方式虽然简单，但有两个明显的缺点：1. 循环的迭代次数需要手动调整，且不同的CPU速度需要使用不同的迭代次数，不方便移植。
2. 空循环会消耗CPU的资源，并且不能保证在不同的CPU架构下具有相同的延时精度。
方法二：使用CPU提供的硬件定时器来实现延时现代的CPU一般都会提供一些硬件定时器，可以通过编程的方式来设置定时器的计数器和预分频器，从而实现精确的延时。
例如，假设我们需要实现一个延时1纳秒的函数，可以使用在Linux下使用POSIX定时器API实现：c#include <time.h>void delay_ns(unsigned int ns) {struct timespec t = {0, ns};nanosleep(&t, NULL);}需要注意的是，使用硬件定时器来实现延时通常比空循环的方式更准确，但在实现上需要考虑平台的差异性、可移植性和系统开销等问题。
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编程中，免不了要用到软件延时。
这一般通过循环语句实现。
通过控制循环语句的循环次数，便可获得多种不同的延时时间。
为了便于使用和提高程序代码的复用率，一般又将循环语句封装成一个带参数的函数，称为延时函数。
如：void wait(unsigned int n){unsigned int i;for(i=0;i<n;i++);}延时函数的参数（形参，如上例中的变量 n ），即为控制循环语句循环次数的变量。
这样，在需要软件延时的时候，只需要调用延时函数,并将实际参数（实参，即n的实际值）代入形参，便可获得与该实际参数对应的延时时间。
这便是经典的软件延时的实现方法，非常简单。
但细心的读者会发现：延时函数的参数（比如上面的 n ），表征的是循环语句的“循环次数”，而不是“实际的延时时间”。
一般来说，假令循环语句每循环一次的时间为 b（注意，单位是“步”，即一个时钟周期，下同），函数调用、传值和返回所需的固有时间为 a ，那么，给定参数 n 时，调用一次延时函数实际实现的延时时间应为 t = a + b*n ， ——而不是 n ！这就意味着，当需要的延时时间为 t 时，应当传入的实参为 n = (t-a)/b，而不是 t 。
这样，为了获得比较准确的延时，每次调用函数之前，都要手工计算实际参数，很不方便；其次，当需要改变晶振频率的时候，程序中所有的延时参数都要重新计算，这显然不利于程序的移植。
为了解决这两个问题，提高程序的可移植性，可以利用宏定义的方式，对延时函数进行参数预修正。
例如，对上面给出的wait延时函数，可以使用下面的宏定义：#define delay(n) wait( ( (n) - a ) / b )这样，调用 delay(t) 就意味着调用 wait( (t-a)/b ) ，从而得到时间为t的延时，实现了参数与延时时间的同步，使用起来更加方便。
为了进一步提高可移植性，使软件延时能够适应不同的晶振频率，应当顺着上面的思路选择寻找更优方案。
c语言延时程序的计算方法经典
for(k=81;k>0;k--);
}
下面是用了8.0000MHZ的晶振的几个延时程序(用定时0的工作模式1)：
(1)延时0.9MS
void delay_0_9ms(void)
{
TMOD=0x01; /*定时器0工作在模式1下（16位计数器）*/
TH0=0xfd;
Loop2: djnz r6, loop2; djnz双周期指令
Djnz r7, loop1,
延时时间=T+i*T+i*j*2T+i*2T
下面几个是单片机的延时程序(包括asm和C程序，都是我在学单片机的过程中用到的),在单片机延时程序中应考虑所使用的晶振的频率，在51系列的单片机中我们常用的是11.0592MHz和12.0000MHz的晶振，而在AVR单片机上常用的有8.000MHz和4.000MH的晶振所以在网上查找程序时如果涉及到精确延时则应该注意晶振的频率是多大。
{
unsigned char i,j,k;
for(i=5;i>0;i--)
for(j=132;j>0;j--)
for(k=150;k>0;k--);
}
500ms延时子程序程序:（12MHZ）
void delay500ms(void)
{
unsigned char i,j,k;
for(i=15;i>0;i--)
DJNZ R7,HERE
CLR TR0 ;定时器要软件清零
SETB EX0
RET
C语言延时程序：
10ms延时子程序（12MHZ）
void delay10ms(void)
{
单片机C语言延时计算
单片机C语言延时计算单片机是一种集成电路芯片，内部集成了微处理器、存储器、输入输出接口等主要部件。
C语言是常用的单片机编程语言，可以通过编写C程序来实现单片机的控制和功能。
在单片机编程中，延时是一种常用的操作，用于控制程序执行过程中的时间间隔。
延时的实现方法有多种，可以使用循环遍历、定时器、外部中断等方式。
在循环遍历的延时方法中，可以通过设定一个循环次数来实现延时。
具体的延时时间与循环的次数成正比关系。
例如，在一个8位单片机中，循环一次大约需要4个机器周期，因此可以通过适当设置循环次数来达到需要的延时时间。
但是，使用循环遍历的延时方法会占用CPU资源，可能会影响其他任务的执行。
另一种常用的延时方法是使用定时器。
单片机内部通常集成了一个或多个定时器，可以通过设置定时器的初值和工作模式来实现精确的延时。
例如，可以通过设置定时器的计数值和工作频率来计算出延时的时间。
在定时器工作期间，单片机可以继续执行其他任务，不会占用过多的CPU资源。
除了循环遍历和定时器方法外，还可以使用外部中断的方式来实现延时。
具体的实现方法是通过外部信号触发中断，并在中断处理程序中实现延时功能。
这种方法可以根据外部信号的频率和工作模式来调整延时时间。
在单片机编程中，为了提高代码的可读性和可重用性，可以将延时操作封装成函数。
例如，可以定义一个名为delay的函数，函数的参数为延时的时间（单位为毫秒），函数内部通过循环遍历、定时器或外部中断的方式实现延时。
延时的时间计算可以考虑单片机的工作频率、机器周期以及延时的时间要求。
单片机的工作频率可以由时钟源来决定，一般可以通过设置分频系数来调整。
机器周期是单片机执行一条指令所需的时间，通过单片机的数据手册可以查到相关的数据。
根据单片机的工作频率和机器周期，可以计算出所需的循环次数或定时器计数值。
在使用延时功能时需要注意延时时间的准确性和可调性。
准确性是指延时的实际时间与预期时间之间的误差，通过调整循环次数或定时器计数值可以实现较高的准确性。
c语言延时程序的计算方法经典
MOV 70H,#48
LOOP4:DJNZ 70H,LOOP4
定时器延时：
晶振12MHZ,延时1s，定时器0工作方式为方式1
DELAY1:MOV R7,#0AH ;;晶振12MHZ，延时0.5秒
AJMP DELAY
DELAY2:MOV R7,#14H ;;晶振12MHZ，延时1秒
TL0=0xa8;
TR0=1; /*启动定时器*/
while(TF0==0);
TR0=0;
}
(2)延时1MS
void delay_1ms(void)
{
TMOD=0x01; /*定时器0工作在模式1下（16位计数器）*/
TH0=0xfd;
TL0=0x65;
TR0=1; /*启动定时器*/
while(TF0==0);
TR0=0;
}
（3）延时4.5ms
void delay_4_5ms(void)
{
TMOD=0x01; /*定时器0工作在模式1下（16位计数器）*/
TH0=0xf4;
TL0=0x48;
TR0=1; /*启动定时器*/
while(TF0==0);
TR0=0;
}
}
1s延时子程序（12MHZ）
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--);
}
200ms延时子程序（12MHZ）
void delay200ms(void)
怎么用c md指令让指令运行等待指定的时间
使用C语言编程时，有时需要让程序在执行到某个指令时暂停一段时间，这就需要用到延时函数。
在C语言中，我们可以通过调用<time.h>库中的函数来实现延时操作。
下面我将详细介绍如何使用C 语言的命令让指令在运行时等待一段指定的时间。
一、包含头文件在使用延时函数之前，首先需要包含<time.h>头文件，该头文件中包含了一些时间处理的函数和结构定义。
#include <time.h>二、使用延时函数C语言中常用的延时函数是sleep()和usleep()函数。
这两个函数能够让程序在执行到该函数时暂停指定的时间。
1. sleep()函数sleep()函数的原型为：unsigned int sleep(unsigned int seconds);该函数的参数为要延时的秒数，函数返回时表示休眠结束或者还剩下多少时间没有休眠完成。
下面是一个使用sleep()函数的例子：#include <stdio.h>#include <time.h>int m本人n() {printf("This is a demo for sleep function\n");printf("Sleep for 2 seconds\n");sleep(2); // sleep for 2 secondsprintf("Wake up after 2 seconds\n");return 0;}2. usleep()函数usleep()函数可以让程序在执行到该函数时暂停指定的微秒时间。
该函数的原型为：int usleep(useconds_t usec);下面是一个使用usleep()函数的例子：#include <stdio.h>#include <time.h>int m本人n() {printf("This is a demo for usleep function\n");printf("Sleep for 1 second\n");usleep(xxx); // sleep for 1 secondprintf("Wake up after 1 second\n");return 0;}三、实例分析下面我们来看一个实际的例子，假设我们需要让程序在执行到某个指令时等待5秒钟再继续执行，我们可以使用sleep()函数来实现：#include <stdio.h>#include <stdlib.h>#include <time.h>int m本人n() {printf("Start\n");// do somethingprintf("W本人t for 5 seconds...\n");sleep(5); // w本人t for 5 seconds// do something elseprintf("End\n");return 0;}在上面的例子中，程序在执行到sleep(5)时会暂停5秒钟，然后再继续执行后面的指令。
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结构来完成，每个循环体内的变量仍然采用无符号字符变量。
c语言delay的用法
c语言delay的用法在单片机应用中，经常会遇到需要短时间延时的情况，一般都是几十到几百μs，并且需要很高的精度(比如用单片机驱动DS18B20时，误差容许的范围在十几μs以内，不然很容易出错);而某些情况下延时时间较长，用计时器往往有点小题大做。
另外在特殊情况下，计时器甚至已经全部用于其他方面的定时处理，此时就只能使用软件定时了。
下面就和大家分享下c语言delay的用法1 C语言程序延时Keil C51的编程语言常用的有2种：一种是汇编语言;另一种是C 语言。
用汇编语言写单片机程序时，精确时间延时是相对容易解决的。
比如，用的是晶振频率为12 MHz的AT89C51，打算延时20 μs，51单片机的指令周期是晶振频率的1/12，即一个机器周期为1 μs;“MOV R0,#X”需要2个机器周期，DJNZ也需要2个机器周期，单循环延时时间t=2X+3(X为装入寄存器R0的时间常数)[2]。
这样，存入R0里的数初始化为8即可，其精度可以达到1 μs。
用这种方法，可以非常方便地实现512 μs以下时间的延时。
如果需要更长时间，可以使用两层或更多层的嵌套，当然其精度误差会随着嵌套层的增加而成倍增加。
虽然汇编语言的机器代码生成效率很高，但可读性却并不强，复杂一点的程序就更难读懂;而C语言在大多数情况下，其机器代码生成效率和汇编语言相当，但可读性和可移植性却远远超过汇编语言，且C 语言还可以嵌入汇编程序来解决高时效性的代码编写问题。
就开发周期而言，中大型软件的编写使用C 语言的开发周期通常要比汇编语言短很多，因此研究C语言程序的精确延时性能具有重要的意义。
C程序中可使用不同类型的变量来进行延时设计。
经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时应该使用unsigned char作为延时变量。
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语言 延时函数
c语言延时函数一、概述延时函数在程序设计中是非常常用的一种函数，它可以让程序在执行到该函数时暂停一定时间，以达到控制程序执行速度的目的。
C语言中提供了多种实现方式，本文将详细介绍其中两种：使用系统提供的函数和自己编写实现。
二、使用系统提供的函数1. sleep函数sleep函数是C语言标准库中提供的一个延时函数，其原型如下：```unsigned int sleep(unsigned int seconds);```该函数接受一个参数seconds，表示要延时的秒数。
在调用该函数后，程序会暂停seconds秒钟，然后继续执行下一条语句。
注意：sleep函数只能精确到秒级别，并且在暂停期间程序会进入睡眠状态，无法响应其他事件。
2. usleep函数usleep函数也是C语言标准库中提供的一个延时函数，其原型如下：```int usleep(useconds_t usec);```该函数接受一个参数usec，表示要延时的微秒数。
在调用该函数后，程序会暂停usec微秒，然后继续执行下一条语句。
注意：usleep函数可以精确到微秒级别，并且在暂停期间程序不会进入睡眠状态。
三、自己编写实现1. 使用循环实现延时使用循环实现延时的原理是在一个循环中不停地执行空语句，以达到占用CPU时间的目的。
具体实现代码如下：```void delay(unsigned int ms){unsigned int i, j;for(i = 0; i < ms; i++)for(j = 0; j < 110; j++);}```该函数接受一个参数ms，表示要延时的毫秒数。
在调用该函数后，程序会占用CPU时间ms毫秒，然后继续执行下一条语句。
注意：使用循环实现延时会占用大量CPU时间，可能会影响其他进程的运行。
2. 使用系统调用实现延时使用系统调用实现延时的原理是通过操作系统提供的定时器功能来实现。
具体实现代码如下：```#include <sys/time.h>void delay(unsigned int ms){struct timeval tv;_sec = ms / 1000;_usec = (ms % 1000) * 1000;select(0, NULL, NULL, NULL, &tv);}```该函数接受一个参数ms，表示要延时的毫秒数。
C语言delay的用法
C语言delay的用法延迟操作在编程中是非常常见的需求，通过控制程序的执行速度，我们可以实现各种各样的功能。
在C语言中，使用delay函数可以实现延迟操作，本文将介绍C语言中delay函数的用法，以及一些注意事项。
一、什么是delay函数在C语言中，delay函数通常用于使程序休眠一段时间。
它可以让程序停止执行指定的时间长度，然后再继续向下执行。
当需要暂停程序一段时间以等待外部设备响应或者执行时间敏感的任务时，delay函数非常有用。
二、使用头文件要使用delay函数，首先需要包含合适的头文件。
在标准库stdio.h之外，在C 语言中，并没有提供一个专门用于延时操作的标准库头文件。
不过，在很多编译器中（如gcc），可以通过包含特定的头文件来获得延迟功能。
#include <unistd.h> //包含这个头文件以使用usleep函数#include <Windows.h> //包含这个头文件以使用Sleep函数根据所选编译器和操作系统不同，可能需要包含不同的头文件。
要确保选择适当的头文件，并与所选平台兼容。
三、使用usleep进行微秒级别延迟在Linux和Unix系统上，我们可以使用usleep函数来实现微秒级别的延迟。
usleep函数接受一个参数，该参数表示程序休眠的时间长度，以微秒为单位。
下面是一个利用usleep函数实现延迟功能的示例代码：#include <stdio.h>#include <unistd.h>int main() {printf("Delaying for 1 second...\n");usleep(1000000); //延时1秒printf("Delay complete.\n");return 0;}在上面的例子中，我们使用usleep函数延迟了1秒钟。
注意，在使用usleep函数之前需要包含对应的头文件。
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--); }。
VC中七种延时方法
七种VC延时方式方式一：VC中的WM_TIMER消息映射能进行简单的时间控制。
首先调用函数SetTimer()设置定时间隔，如SetTimer(0,200,NULL)即为设置200ms的时间间隔。
然后在应用程序中增加定时响应函数OnTimer()，并在该函数中添加响应的处理语句，用来完成到达定时时间的操作。
这种定时方法非常简单，可以实现一定的定时功能，但其定时功能如同Sleep()函数的延时功能一样，精度非常低，最小计时精度仅为30ms，CPU占用低，且定时器消息在多任务操作系统中的优先级很低，不能得到及时响应，往往不能满足实时控制环境下的应用。
只可以用来实现诸如位图的动态显示等对定时精度要求不高的情况。
如示例工程中的Timer1。
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////方式二：VC中使用sleep()函数实现延时，它的单位是ms，如延时2秒，用sleep(2000)。
精度非常低，最小计时精度仅为30ms，用sleep函数的不利处在于延时期间不能处理其他的消息，如果时间太长，就好象死机一样，CPU占用率非常高，只能用于要求不高的延时程序中。
如示例工程中的Timer2。
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////方式三：利用COleDateTime类和COleDateTimeSpan类结合WINDOWS的消息处理过程来实现秒级延时。
单片机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倍速的单片机,只要修改一下参数值其它系例单片机也通用,适用范围宽。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言中的延时与计时技巧
一、延时技巧
1．延时的定义：控制程序中当前语句的后一语句，延缓一段时间再执行。
2．C常用的两个延时函数:
(1) delay函数。
书写格式：delay（数值）。
其中，括号中的整型数值取值范围0 ~ 32767之间。
注意：这个数值与计算机主机的频率有关，因此在不同的计算机上，同样的延时数值，会得到不同的延时效果。
(2) sleep (数值)。
（睡眠函数）
书写格式：sleep (数值)。
其中数值是以秒为单位，用在动态显示中最少一秒变化一次，那会有明显的停顿感觉。
二、计时技巧
1．计时的定义：计算程序中某段程序的运行时间。
2．计时程序使用条件：
(1)使用头部文件：
#include <time.h>
(2)使用当前时间的时钟函数：
clock()
(3)使用时间一秒常数：
CLK_TCK
例如：
A．在“蛇吃蛋”的程序中，要引入计时程序，则：在进入while(1)循环前，先要取得计时开始时的那一时刻，使用变量t0表示。
即：
t0 = clock();
B．在while(1)循环的最后处，再取当前时刻，使用变量t1表示。
即：
t1=clock();
C．t1 和t0 之差即为所经历的时间，即;
t = (t1-t0 );
D．转换成秒：
sec=t/CLK_TCK;。