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，这样的误差已经不算误差了，用汇编语言编写还达不到这个程度。

C及汇编延时程序讲解

有个好帖，从精度考虑，它得研究结果是：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，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=13delay_50us(10):延时513us 503-500=13delay_50us(100):延时5013us 5013-5000=13delay_50us(1000):延时50022us 50022-50000=22赫赫，延时50ms，误差仅仅22us，作为C语言已经是可以接受了。

c语言延时程序的计算方法经典

for(j=202;j>0;j--)
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延时函数delay

c延时函数delay
c语言中的延时函数delay函数是一种简单的延时函数，它能够在程序中帮助我们指定一段时间内暂停一段时间，它可以帮助我们控制程序的运行速度。

delay函数在多种编程语言中均有实现，而在c 语言中，只需要在代码中增加delay函数就可以实现延时的效果。

delay函数的使用非常简单，只需要在程序中添加delay函数，并指定延时时间即可实现延时功能。

delay函数的语法如下所示：delay（time）;其中time参数是指定延时时间，单位为毫秒（ms）。

以下是一个C程序，它演示了在程序中使用delay函数实现延时功能： #include <stdio.h>
#include <windows.h>
int main()
{
tprintf(Program starts.
tSleep(3000); //Delay for 3 seconds
tprintf(Program continues.
treturn 0;
}
在这段代码中，我们使用delay函数Sleep()来指定程序延时3秒钟来实现延时功能。

另外，delay函数也可以被用作测试程序的工具，可以用它来观察程序的运行情况，这可以帮助我们更好地了解程序的执行细节，并及时发现可能出现的问题。

总之，delay函数是一种非常有用的函数，用它可以在程序中控制程序的运行速度，也可以做到测试程序运行状态的功能，使得我们在运用c语言开发软件的过程中可以轻松的实现延时功能。

c语言延时程序的计算方法经典

DJNZ 72H,LOOP3
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语言中的延时函数是一种非常常用的编程方法，主要用于控制程序在某些场景下的运行速度。

在很多情况下，我们需要让程序暂停执行一段时间，以等待外部条件满足或等待其他设备的响应等等。

而这个时候，延时函数就非常有用了。

在c语言中，延时函数的实现主要是通过循环来完成的。

我们可以通过循环执行一些无用的操作，从而达到控制程序执行时间的目的。

下面我们来看一个简单的例子，实现一个延时函数：```cvoid Delay(unsigned int ms){unsigned int i, j;for(i = 0; i < ms; i++)for(j = 0; j < 1000; j++);}```上面的代码实现了一个简单的延时函数，它的参数是一个unsigned int类型的变量ms，表示需要延时的时间（以毫秒为单位）。

函数内部通过两层循环来控制程序的执行时间，循环次数为ms * 1000次。

这个函数看起来非常简单，但它确实非常实用。

不过需要注意的是，延时函数有时候也会带来一些问题。

首先，延时函数会占用CPU的执行时间。

在延时函数执行的过程中，CPU会一直处于忙碌状态，这会导致其他任务无法被及时执行。

如果延时时间过长，会影响系统的整体性能。

其次，延时函数的精度有时也不是很高。

在实际使用中，延时函数的执行时间并不是完全准确的，因为CPU的工作状态有很多不确定性因素，比如操作系统的调度、硬件设备的中断等等。

因此，我们在使用延时函数时，需要注意这点。

除了上面的问题以外，延时函数还有一些其他方面的注意事项。

比如，延时时间过短或过长都会导致系统出现异常。

因此，在使用延时函数时，我们需要事先了解系统的性能特点，并根据实际情况来选择适当的延时时间。

另外，延时函数也不是在所有的程序中都适用的。

在一些实时性要求较高的系统中，通常不能使用延时函数，因为这会影响系统的时序要求。

在这种情况下，我们通常需要使用硬件定时器或者其他更加高级的调度方式来控制程序的执行。

单片机的C语言延时程序

单片机C语言环境延时程序设计东北电力学院（132012）盛文利摘要：讨论运用C语言的单片机开发中，对于时序要求苛刻的延时的开发过程。

实例说明在高级语言中，严格控制时序的可能性和注意事项。

关键词：单片机C语言编译器现在单片机的开发中，C语言以其方便、灵活、逻辑性强、易于维护和可移植性好等强大优势，占据了单片机开发的主要地位。

过去，由于单片机C 语言本身存在的缺陷，加之单片机工程本身都不大，C语言在单片机中的应用没有被重视。

在C语言环境下，我们只需关心程序的逻辑关系，实现细节由编译器完成，这给我们快速开发提供了条件，也大大减小了开发工作量。

但同时实现细节就不被控制了，这个问题对于经常重视实现细节的单片机，就必须得到解决。

好在一般的C语言编译器都提供嵌入汇编、与汇编互调用和汇编级的代码察看等功能。

现以KEIL C51[1]下的一线总线器件程序开发为例，说明我的解决方法。

1 一线总线协议器件一线总线协议（1 wire bus protocol）也叫做单总线协议，是单总线器件数据传输协议。

因为数据（也可以包括电源）都由一条线来传输，没有辅助的数据同步信号，这时就只能由时序来解析协议内容。

这样就只有依靠对时序的严格要求，来保障数据传输的准确性。

单总线协议的信号主要有：初始化时序，包括复位脉冲和在线脉冲，是主机与器件的联络信号。

然后是读、写时序。

单总线器件完全依靠对线上的时序来做出响应，这些有效的时序称作时隙，也有称作时间片的，是同一词汇的不同翻译[2]。

初始化时序时间裕度大，容易实现。

读写脉冲对时序要求相对严格，尤其在慢速的MCS-51下，指令的运行在微妙级，而读写时序在15微秒的后小部分，大约4微秒，不同批次的芯片会有少许差距。

有的会允许你的时序有少许误差，有的则非常严格。

2 C语言编译器在用汇编语言编写的程序时，很容易控制时间，因为我们知道每条语句的执行时间，每段宏的执行时间，每段子程序加调用语句所消耗的时间。

单片机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结构来完成，每个循环体内的变量仍然采用无符号字符变量。

C语言延时程序

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

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

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

NOP指令为单周期指令，可由晶振频率算出延时时间，对于12M晶振，延时1uS。

对于延时比较长的，要求在大于10us，采用C51中的循环语句来实现。

在选择C51中循环语句时，要注意以下几个问题第一、定义的C51中循环变量，尽量采用无符号字符型变量。

第二、在FOR循环语句中，尽量采用变量减减来做循环。

第三、在do…while，while语句中，循环体内变量也采用减减方法。

这因为在C51编译器中，对不同的循环方法，采用不同的指令来完成的。

其三：对于要求精确延时时间更长，这时就要采用循环嵌套的方法来实现，因此，循环嵌套的方法常用于达到ms级的延时。

对于循环语句同样可以采用for，do…while，while结构来完成，每个循环体内的变量仍然采用无符号字符变量。

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函数之前需要包含对应的头文件。