延时与中断出错，是单片机新手在单片机开发应用过程中，经常会遇到的问题，本文汇总整理了包含了MCS-51系列单片机、MSP430单片机、C51单片机、8051F的单片机、avr单片机、STC89C52、PIC单片机…..在内的各种单片机常见的延时与中断问题及解决方法，希望对单片机新手们，有所帮助!

1、单片机延时程序的延时时间怎么算的?

答:如果用循环语句实现的循环，没法计算，但是可以通过软件仿真看到具体时间，但是一般精精确延时是没法用循环语句实现的。

如果想精确延时，一般需要用到定时器，延时时间与晶振有关系，单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率，后两种的一个机器周期分别为1 μs和2 μs，便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536 μs。若定时器工作在方式2，则可实现极短时间的精确延时;如使用其他定时方式，则要考虑重装定时初值的时间(重装定时器初值占用2个机器周期)。

1 Z4 F" q4 K# W+ w  d  V, X& W

2、求个单片机89S51 12M晶振 用定时器延时10分钟，控制1个灯就可以

答：可以设50ms中断一次，定时初值，TH0=0x3c、TL0=0xb0。中断20次为1S，10分钟的话，需中断12000次。计12000次后，给一IO口一个低电平(如功率不够，可再加扩展)，就可控制灯了。

) z5 W! o: ?; y& S9 a  H0 m

而且还要看你用什么语言计算了，汇编延时准确，知道单片机工作周期和循环次数即可算出，但不具有可移植性，在不同种类单片机中，汇编不通用。用c的话，由于各种软件执行效率不一样，不会太准，通常用定时器做延时或做一个不准确的延时，延时短的话，在c中使用汇编的nop做延时

3、51单片机C语言for循环延时程序时间计算 ，设晶振12MHz，即一个机器周期是1us。

1. 
   
2. for(i=0,i<100;i++)
   
3. for(j=0,j<100;j++)

复制代码

5 R+ l% D  j# q6 N+ e

我觉得时间是100*100*1us=10ms，怎么会是100ms

答：

不可能的，是不是你的编译有错的啊

我改的晶振12M，在KEIL 4.0 里面编译的，为你得出的结果最大也就是40ms，这是软件的原因，

不可能出现100ms那么大的差距，是你的软件的原因。

不信你实际编写一个秒钟，利用原理计算编写一个烧进单片机和利用软件测试的秒程序烧进单片机，你会发现原理计算的程序是正确的

# o, G; J7 E6 y# [: q& z

4 、51单片机c语言 _nop_()是一个空指令?短时间延时的?空几个机器周期?

答：这个_nop_()等效与汇编里面的，NOP指令，也就是空一个机器周期，如果是传统51单片机的话，等于空12个时钟周期【即一个机器周期】

. A  [$ n: w, E; U

5、51单片机 延时500ms 用机器周期叠加怎么算?

答：

1. 
   
2. DELAY:
   7 ^5 r# d  W  C4 X0 M' R
3. MOV R7,#4
   
4. D2:MOV R6,#250
   , C: ]7 J! l( t  k4 N$ T
5. D1:MOV R5,#250
   # P' e" \4 p. Y) }5 J
6. DJNZ R5,$
   
7. DJNZ R6,D1
   
8. DJNZ R7,D2
   " p& V  w2 K; ]2 t! j0 o
9. RET
   8 v1 Q7 q* r  ?' C
10. 假设晶振为12MHz
    5 ?- k( W+ ^$ u1 y; _5 ~" ]
11. 刚延时时间为:
    4 g# b* @( t! x" C- ]) |- P
12. 250*250*4*2=500MS

复制代码

6、51单片机C语言程序中延时函数delay的原理是什么?

现在找到两个函数

第一：

1. 
   . [- Y6 [8 N# x3 E8 ~0 A+ H5 E
2. void delay(void)
   
3. { unsigned int i,j;
   , y% K& _9 d. g8 U7 Y( G  }- @
4. for(i=0;i<500;i++)
   
5. { for(j=0;j<121;j++)
   . {: {, l) b5 ]9 [6 i, B7 A& ]
6. {;}
   / {3 k9 c' ~  I0 K: E" b$ U  `
7. }
   
8. }

复制代码

第二：

1. 
   
2. void delay(unsigned int k)
   
3. { unsigned int i,j;
     k2 q* |9 V  R* [
4. for(i=0;i
   . e/ F! ?% ]4 \# a" Q' r
5. { for(j=0;j<121;j++)
   $ H8 @4 M& H4 c  v# H) l; o
6. {;}
   & y( `5 b3 I" W, Z! I
7. }
   6 ?& |- |2 r  K/ N* V2 k7 G
8. }

复制代码

" v6 m/ J/ C3 t' Q9 b& I1 q8 e

现有几个疑问：

(1)：延时函数的原理?

(2)：两个for循环的作用?

(3)：i、j的取值有什么规律和依据?是不是和单片机接的晶振频率有关?所能延时的最小单位时间是怎么计算的?

( r' A) _7 ~& e! ]

延时时间怎么计算啊!假如用的是AT89C51RC+11.0592M的晶振呢?

答：

1：原理：仅仅执行一些，没有实质性影响的所谓“无意义指令”，比如做比大小啊，做某个int的自加运算啊之类的

2：两重for的作用：简单的说，就像高中数学中的“乘法原理”一样，这样可以很轻易的迅速增加上述“无意义指令”的数目

3：关于取值大小：这个如果是在C下变成，这个值不仅仅与晶振、单片机本身运算速度有关，而且还与C的编译器有关，所以说，这个值虽说是可以精确计算的，但大多数情况下，程序员用的都是“经验值”——当然，如果用汇编编程，情况就不一样了，因为每一条指令所使用的机器周期是一定的，你当然可以根据所有指令使用的总时间，精确的算出具体延时的总时间

* S2 E( U5 g0 J, j

综合你的的问题，我给你一点建议，就是刚学单片机的时候，还是一定要老老实实的从汇编编程学起——这样，在你以后接触到C之后，你才能明白，这中间实际上经历了一个什么样的过程，只有这样你才能真正理解单片机。当然，等最终你完全拿下一种单片机之后，尽量使用C编程，无疑是历史所肯定的。

$ Y5 O7 x! p" [3 I

7、51单片机，晶振为6M,求一个10ms的延时程序

答：延时有很多种方法，有一种是让单片机去做无聊的循环，还有一种是用定时器。

第一种的算法是：

晶振的周期T1=1/f; 这里f=6MHz 所以T1=1/6 us;(微秒)

单片机花12个T1去执行一个指令，

所以一个机器周期等于12个晶振周期，

T2=12*T1=2us

10ms=1000 0us

所以你要得到10ms的延时就要想办法让机器去做5000条“无聊的指令”

. C  |: K' D8 K  K% \( _9 ^! q

所以

1. 
   
2. DEL: MOV R5,#05H
   
3. F1: MOV R6,#05H
   
4. F2: MOV R7,#32H
   8 t  K& [+ y" V& u1 |' U
5. F3: DJNZ R7,F3
   
6. DJNZ R6,F2
   
7. DJNZ R5,F1
   
8. RET

复制代码

" Q$ S0 n! }' ?& p- k

这种方法是用于对时间要求不高的地方，我说的是其思想，程序中可能有错的地方

用定时器的方法我不太会就不误人了 (补充一下就是这个是用汇编写的，你在主程序中用ACALL DEL调用就延时了。

8、今天我用单片机做“眨眼的LED”实验时，程序运行，每次只令灯亮或灭都没问题，但是一开延时不能出现期盼的灯亮灯灭的现象，这是怎么回事?

实验的硬件条件是：STC89C52，编译环境：keil 3。

下面是我写的程序，请教高手!!!

1. 
   
2. #include // 文件包含处理
   
3. #define uchar unsigned char //宏定义，方便以后程序的书写
   , v2 J  H) F2 u3 u5 u4 \9 A
4. #define uint unsigned int
   ) W% W. z, D, U& S# y
5. sbit P1_0 = P1 ^ 0; //位变量定义
   , r( N4 _( _9 k) u$ R" d
6. void Delay(uint t)
   
7. {
   
8. uchar i;
   
9. while(--t)
   
10. {
    3 ]2 w8 W) U% o# y
11. for(i = 0; i < 125; i++) //延时1MS，在这里我们用的晶振是是12M，根据机器周期的计算，我们
    6 D1 C: y0 P" _  J8 Q
12. {;} //可算得本次循环延时约1MS
    
13. }
    
14. }
    
15. void main(void)
    
16. {
    
17. while(1)
    
18. {
    
19. P1_0 = 0; //点亮LED灯
    
20. Delay(1000); //应单片执行程序的时间很快，所以必须延时，要不看不到实验现象
    * R7 J  O! m/ P6 i9 R" T( \' S
21. P1_0 = 1; //熄灭LED灯
    2 T7 h" B2 H- K9 l) T
22. }
    7 x" Z5 n9 P7 R" C$ r# p' c; E
23. 补充提问：我是让P1.0先低然后延时之后再高，即灯先亮再灭，然后开始循环的
    
24. 答：应该这样写
    
25. while(1)
    
26. {
    ; Z) h5 A1 G7 Q9 h3 L# b7 ~
27. P1_0 = 0; //点亮LED灯
    % `$ I; F- W; u3 C( y! F
28. Delay(1000); //应单片执行程序的时间很快，所以必须延时，要不看不到实验现象
    9 ?) l- o, V' \. c
29. P1_0 = 1; //熄灭LED灯
    ( S. U0 B1 E: m6 E% O8 J4 P; n
30. Delay(1000);

复制代码

补充问题回复：问题恰恰就错在这了，循环完一遍之后灯由灭到亮根本没有时间延时，即第一次循环中灯还没来的机灭呢，就进入到第二轮循环中的亮了，所以原因就在这，这错误太低级了，以后引以为鉴吧

9、单片机延时函数的问题

1. 
   2 ^3 C: k2 m- e" w! U3 \
2. void delay(uchar i)
   % b) B. g# w1 @9 U7 i
3. {
   
4. uchar j;
   , m) B) J6 a( _; X9 V7 S% `
5. while(i--)
   
6. {
   
7. for(j=125;j>0;j--)
   
8. ;
   
9. }
   7 X# Q, \! h8 S0 C$ v  ?! n* w
10. }

复制代码

这个函数中的i，j的大小有**吗?

答：这个函数中j的大小和你定义的数据类型有关，因为你定义的为无符号字符型，为单字节数据，所以最大为255。.

8 y/ |- `' N+ A0 j

如果你需要增大，可以改变j的数据类型定义，如unsigned int (2字节)可以到65535;无符号长整形unsigned long(4字节) 可以到4294967295。而上面所所256是-1,而你定义的是无符号字符型。

, z3 |6 }$ d% B* \6 p1 u

10、请教一个AVR单片机延时的问题

外部晶振用的是8MHz,延时1微秒的程序如下:

1. 
   
2. void delay_us(unsigned int delay_counter)//延时1us
   4 Q/ a  u% t5 ]1 {
3. {
   
4. do
   6 U0 I9 c: N+ H' V2 c
5. {
   9 Y% O' n7 r3 E; K3 G+ U
6. delay_counter--;
   
7. }
   " L& R6 z; r2 G1 c1 m( i1 D
8. while(delay_counter>1);
   / e8 [" M; N9 h
9. }

复制代码

请问,为什么能延时1微秒啊?

答：8MHZ表示单片机的运行周期为1/8us，也就是0.125us执行一步

* O* W3 y- i3 E" `9 e

你使用的是软件延时

那么包括程序的提取，执行等都要花费时间

比如，你提取这个函数可能花去一步，那现在就使用了0.125us啦

接着你执行这个函数，在单片机内部，运算是通过寄存器的移来移去实现的

这都需要时间，可能你看到的就一句counter--这个指令，可能会花费好几个时钟周期来实现

举个例子：

1. 
   
2. c=a+b，只有一句，但实际上花费的时间并不短
   
3. mov a，#data1;//数据data1放入a寄存器
   
4. mov b，#data2;//数据data2放入b寄存器
   0 @& W4 b5 o7 u) w" k9 R5 x: r0 V
5. add a，b;//寄存器a的值与b相加，结果放入a
   - d: o% v! A1 ~. |" T* u4 i
6. mov c，a;//将a的值放入c

复制代码

/ \* V% F6 c$ I% N# x  ^$ u

这样才是单片机内部真正执行的指令，这需要花费至少4个时钟周期，而不是1个

至于晶体管级的我就不解释了，你得好好学习汇编才能理解单片机的运作。

至于这个函数为什么能延时1ms，这个是靠经验来判断的，最直接的方法就是用示波器看，以上均为推论。

/ j. x6 M5 P' \9 U

11、PIC单片机的延时问题 晶振4Mhz：

1. 
   " B) D3 M# S3 M6 K
2. void delay()
   " C, D5 T) ?) |9 U3 C
3. {
   
4. unsigned int d=1000;
   0 c  n5 Q1 V0 b: `8 p6 i
5. while(--d){;}
   
6. }

复制代码

7 @* \+ n& A- a9 Q; x

此函数在4M晶体下产生10003us的延时,也就是10MS。

问题：我刚算了一下他应该执行了999条指令，1条单周期的指令也才1US，那就是999us,为什么会有10ms的延时?

1：for(x=100;--x;){;} : 2：for(x=0;x<100;x++){;} 2句话相同

第一句：X的值范围是不是 1~99?为什么?

第二句：X的范围是不是0~99?为什么?这么算的。我知道符号在前在后的区别。2句话应该是不一样的才对啊!

答：

问题1：“我刚算了一下他应该执行了999条指令”因为你算错了。延时时间是由产生的汇编代码所决定的，C语言语句只是个假象，千万不要以为C语言一行就是一条指令!此处由于涉及到双字节减法，因此会有额外的判断，编译结果每次循环耗费几十个周期毫不奇怪。

问题2：前一句x从100开始递减，递减至1时退出循环。后一句x从0开始递增，递增到100时退出循环。所谓“2句话”相同仅仅是指这两个循环体的循环次数相同。实际上两个循环的执行过程是完全不同的，所消耗时间也有可能不同。

12、stc单片机的延时问题 ，STC10F08XE单片机，晶振22.1184M

1. 
   
2. void delay(unsigned long uldata)
   
3. {
   
4. unsigned int j = 0;
   
5. unsigned int g = 0;
   
6. for (j=0;j<5;j++)
   ) {% a  s7 s7 G/ h6 J* E; Q
7. {
   : i; ~5 ^+ J+ z
8. for (g=0;g
   1 h; H% r! s) v" a2 E; L/ o% |) b+ J* n
9. {
   2 ^+ c7 j# G. ^; x& Y$ e
10. _nop_();
    * Q9 g! @4 W4 ^1 {1 D9 @' ^" D7 P
11. _nop_();
    2 d) M  @- n2 S0 F
12. _nop_();
    0 o$ I* x7 o4 Q1 C3 n
13. }
    
14. }
    
15. }

复制代码

( z, i/ E$ E& I  t/ }' w

当uldata=1时延时多少秒?

请给出具体算法…………

答：用keil转换成汇编语句，然后对照指令表计算就行了

7 Z% ?& i9 Z8 L0 C4 \4 k2 u' |

13、我想用单片机连接不断地向电脑发数，如下：

1. 
   3 Z; W" M' k" b5 i8 y
2. while (1)
   % g; `9 M+ a+ z
3. {
   
4. send_char('9');
   
5. delay(n);
   
6. }

复制代码

如每发送一个数，应延时多少微妙好呢?即一般最短能延时多少微米呢?如延时太长的话，那发送很多数据不就用很长时间吗?

答：不做太多的串口处理分析，只顺着你的问题和你的方法说说：

先考虑下串口的速率 假设9600，那么发送一个字符要多久?

(9600bit/S) / 10bit(一个字符1+8+1) = 960字符/秒 约 1ms/byte

也就是说你如果在1ms内发送超过一个字符就没意义了，硬件速度达不到。

1. 
   # [7 r; ^" _7 b& @
2. while(1)
   % E! J! v) q4 Z) h2 J$ q
3. {
   
4. send_char('9');
   
5. delay(n);
   
6. }

复制代码

这个循环是执行周期也就十几微秒+delay()的延迟，所以任何小于1040微秒的延迟对串口硬件来说没意义，上一个还没处理完，下一个就来了根本执行不了嘛。

如果你send_char()里面有while(!TI);TI = 0;这样的语句或有串口中断TI的处理的话，那么实际上你的delay()已经在发送函数里了，while(!TI);这部就是延迟等待吗?那根本不需要主函数去延迟了，直接发就行了。

2 M  \& H, h8 g9 s. C* a  \8 Y" ^0 S- B

14、一个单片机延时子程序的问题，在延时子程序那里，一直搞不明白，给r7和r6赋予0，然后下面的djnz r7,delayloop不就一直循环了，那还怎么接下去的程序?

1. 
   ; |1 ]0 m, [' f1 e; J, M
2. org 0000h
   1 u( E* f1 t- ^* m
3. ljmp start
   
4. org 0030h
   
5. start: mov a,#0feh
   
6. mov r5,#8
   . E$ e3 H% I3 f4 i' D
7. output: mov p1,a
   
8. rl a
   
9. call delay
   
10. djnz r5,output
    
11. ljmp start
    2 ]  G, u  L! i( {
12. delay: mov r6,#0
    $ L7 u7 Z; ?/ ^0 @* _6 G. v; z
13. mov r7,#0
    
14. delayloop:djnz r7,delayloop
    & ?* S  p5 k( a9 B& n
15. djnz r6,delayloop
    
16. ret
    
17. end

复制代码

) E; I' B4 h0 d  a, Q. u- r, e4 w

答：你的延时程序不是因为值为0，而是跳转位置不对，改为如下：

1. 
   
2. delay: mov r6,#0
   1 V) ~" r1 Y( x$ u+ b* P5 C
3. delayloop:mov r7,#0
   
4. :djnz r7,$
   
5. djnz r6,delayloop
   ( E, N3 }" N1 D" n$ S
6. ret

复制代码

/ a5 k* m: `7 U4 j6 b3 u

R7,R6初值为0，但是当DJNZ执行时，这条指令是先减1再判断，所以0-1=255，判断的话也不为0，仍然循环256次。

0-1=255的解释：

0000 0000

- 0000 0001

-------------------------

1111

" O; q% S/ f1 I( U6 H; t9 o3 p

15、我想提两个单片机延时与按键的问题

1：如果一个程序中延时和按键，如果延时子程序比较长(假如2秒),怎样确保按键能够得到及时响应(假如PC正在执行延时子程序，正在这时候有按键输入，不是响应不了)——，，，前提是不能用定时器定时扫描，和中断来做，因为定时器和中断我另有其他用途

# y0 R7 _8 H# Y! p' D6 Q, Q

2：单片机没有串口。怎样才能使得他与24C02进行通信(24C02是具有2K内存的EEPROM)

答：

首先明确一点你说单片机没有串口，应该是指没有I2C口吧。

1 在延时程序里面加入按键的检测

2 用IO口模拟I2C时序读写

16、51单片机延时小程序，求高手解释什么意思?

1. 
   * X  i1 R+ z# S0 U/ M/ l
2. delay200ms:
   $ i% t& E; G* c5 q
3. mov r2,#82
   
4. l0:mov r1,#116
   % m& q5 M( j  ^
5. l1:mov r0,#9
   
6. djnz r0,$
   $ Y) s4 \& k* m! A( w
7. djnz r1,l1
   ( O) k, [8 X& A- l; L0 N1 J% L
8. djnz r2,l0
   
9. ret

复制代码

4 H  @2 c3 w4 G0 M  J2 J

答：以下是每条指令的时间，T为一个机器周期

1. 
   
2. delay200ms:
   1 P! P# ?8 X3 R( z
3. mov r2,#82;1T
   3 r( M6 G8 C: C  w7 Z# H
4. l0:mov r1,#116;1T
   
5. l1:mov r0,#9;1T
   
6. djnz r0,$;2T
   * x4 Z$ W! t5 S" w' N7 K4 z
7. djnz r1,l1;2T
   
8. djnz r2,l0;2T
   / w( c9 C$ X/ f) F" U- C2 V( l( b
9. ret;2T

复制代码

以上共三层循环，忽略部分指令，最简单算法是：

2*9*116*82=171216

不忽略指令是：

1+(1+(1+2*9+2)*116+2)*82+2=200001

因此延时时间大约为200ms

17、于51单片机延迟时间的问题

uchar i;i--;

uint i;i--;

这两条语句在12M晶振下运行时间分别是多少??

答：一个时钟周期，2us，共4us

5 J: l8 i1 g. E6 N  p* l1 R

18、周期为6MHZ的单片机延时10秒的子程序的怎么编?

答：

1. 
   $ \, {0 I1 i; ?$ @5 @; S
2. /********************************************************************
   
3. * 名称 : Delay()
   4 G; Y$ m$ A- Q" ^& s  y% i
4. * 功能 : 延时,延时时间为 10ms * del。这是通过软件延时，有一定误差。
   
5. * 输入 : del
   & P3 g2 U3 p# s5 c: x
6. * 输出 : 无
   1 c2 W9 {; ?  o& B6 B- C  ~5 c) K
7. ***********************************************************************/
   
8. void Delay(uint del)
   & d8 ~& Z( }  L2 K# j* z
9. {
   3 T! F) t5 L' K5 c& C
10. uint i,j;
    
11. for(i=0; i
    3 U. \+ g# [) R+ v3 k! X' a
12. for(j=0; j<1827; j++) //这个是通过软件仿真得出的数
    
13. ;
    
14. }

复制代码

这个是晶振为12mhz的单片机延时10ms的程序，你只要在这个基础上减小一倍就行了，当然至于具体值还是要调试下的。

, n0 @9 X  k! Q6 a* ~0 m0 X6 {7 r# S  Y

19、片机的有些程序需要调用延时程序，如何能合理的安排循环次数以及空操作的个数?

答：用汇编的话就根据你的当前晶振频率去推算你的指令周期，然后结合你需要延迟的时间，编写延迟程序，用C的话还是要看最后生成的汇编码是什么样的了。最简单的方法就是写好程序以后再编译器里软仿真看时间。

8 e$ f8 k+ j& q, o

20、单片机延时程序问题

1. 
   
2. 延时程序 void delay(uint dt)
   # ?$ M  J! b! O: k
3. {
   7 T, `4 |0 ]1 K6 E+ V2 y5 b" t  O$ {
4. uchar bt;
   & P1 Z4 a- U" V+ x  h. g
5. for(;dt;dt--);
   
6. for(bt=0;bt<255;bt++);
   
7. }

复制代码

编译时有警告COCUMENTS AND SETTINGSADMINISTRATOR桌面字 310 点阵LED显示.C(46): warning C235: parameter 1: different types

% P6 F: Q! B1 T3 V- h

为什么?求大侠指点

答：某个函数传参类型与声明类型不符。

另外你这个for(;dt;dt--);没有起到外层循环的作用……

4 T7 ?% F/ J, B