单片机编程过程中经常用到延时函数，最常用的莫过于微秒级延时delay_us()和毫秒级delay_ms()。本文基于STM32F207介绍4种不同方式实现的延时函数。

) f( Z# y( t" [% d! b1、普通延时
这种延时方式应该是大家在51单片机时候，接触最早的延时函数。这个比较简单，让单片机做一些无关紧要的工作来打发时间，经常用循环来实现，在某些编译器下，代码会被优化，导致精度较低，用于一般的延时，对精度不敏感的应用场景中。

1. //微秒级的延时
   . A2 [6 p. ?4 h: T" s" V
2. void delay_us(uint32_t delay_us)
   % \* e, E* W* a( r% K* k: H) w
3. {   
   
4.   volatile unsigned int num;
   
5.   volatile unsigned int t;
   ) N+ ~- f( _  o) @2 L; v( u8 ]0 N
6. 
   1 b, ?5 a* I- G0 O2 k
7. 
   
8.   for (num = 0; num < delay_us; num++)
   
9.   {
   3 M0 o% n" B( H) x( g8 q9 f
10.     t = 11;
    
11.     while (t != 0)
    
12.     {
    
13.       t--;
    
14.     }
    
15.   }
    3 M( [5 B4 h- _( R
16. }
    0 B- N: U* X1 x7 Q
17. //毫秒级的延时
    
18. void delay_ms(uint16_t delay_ms)
    
19. {   
    + [5 B- }* f' V! b6 c" c' j! ~
20.   volatile unsigned int num;
    6 ]6 z9 f( p, ?/ V! W  \
21.   for (num = 0; num < delay_ms; num++)
    $ r; X4 K" h3 w, D$ N9 |. W
22.   {
    0 Y; T" H, a9 B$ ]/ E
23.     delay_us(1000);
    ! {  J6 v$ T# f2 E
24.   }
    2 s1 X9 R# v; p( W0 ?4 `
25. }

复制代码

+ [/ s; X; O" z1 H! \! [; _9 @2、定时器中断
定时器具有很高的精度，我们可以配置定时器中断，比如配置1ms中断一次，然后间接判断进入中断的次数达到精确延时的目的。这种方式精度可以得到保证，但是系统一直在中断，不利于在其他中断中调用此延时函数，有些高精度的应用场景不适合，比如其他外设正在输出，不允许任何中断打断的情况。

' L& |8 c7 p2 @; o2 tSTM32任何定时器都可以实现，下面我们以SysTick 定时器为例介绍：
$ n6 _7 l2 {, b0 o$ N2 Y
初始化SysTick 定时器：

1. /* 配置SysTick为1ms */
   ' _( ^5 l+ r2 _$ D0 d( P. L" @
2. RCC_GetClocksFreq(&RCC_Clocks);
   9 R1 x9 f1 l& M/ E# M
3. SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

复制代码

4 \1 c! @5 z. j: e1 T! C; p2 j中断服务函数：

1. void SysTick_Handler(void)
   & X" [+ S$ }3 [# A) {  z
2. {
   $ n- p; P# P/ G
3.   TimingDelay_Decrement();
   1 Q2 s9 o6 c6 ~7 Q1 n
4. }
   
5. void TimingDelay_Decrement(void)
   % r9 n! C( _. Z, T3 ?5 \
6. {
   
7.   if (TimingDelay != 0x00)
   ; X$ T. A- z3 G5 T
8.   {
   ' k9 V3 ]: N" ]9 L: j# t; {
9.     TimingDelay--;
   
10.   }
    
11. }

复制代码

$ S( O( S) h( N" L  E9 K7 z/ u延时函数：

1. void Delay(__IO uint32_t nTime)
   
2. {
   / h0 t+ i6 q9 U( I% ?% H0 `0 q: b
3.   TimingDelay = nTime;
   # r- s: m3 C; W8 I; F/ O$ W0 t
4.   while(TimingDelay != 0);
   
5. }

复制代码

* ]& s0 M) V5 o3、查询定时器
为了解决定时器频繁中断的问题，我们可以使用定时器，但是不使能中断，使用查询的方式去延时，这样既能解决频繁中断问题，又能保证精度。
; f) d0 ]9 M8 c7 E' a" j3 z
STM32任何定时器都可以实现，下面我们以SysTick 定时器为例介绍。

STM32的CM3内核的处理器，内部包含了一个SysTick定时器，SysTick是一个24位的倒计数定时器，当计到0时，将从RELOAD寄存器中自动重装载定时初值。只要不把它在SysTick控制及状态寄存器中的使能位清除，就永不停息。
! Y: \$ V  y$ E( g2 L3 u
: g: w* a/ L% I/ J+ m$ K0 bSYSTICK的时钟固定为HCLK时钟的1/8，在这里我们选用内部时钟源120M，所以SYSTICK的时钟为(120/8)M，即SYSTICK定时器以(120/8)M的频率递减。SysTick 主要包含CTRL、LOAD、VAL、CALIB 等4 个寄存器。
# R% K! w+ t: P  b$ P
▼CTRL：控制和状态寄存器
: a- a! V! T5 {2 i" a' N0 q+ x; l  @* o
+ {2 }& v8 K* V% j# b

▼LOAD：自动重装载除值寄存器
" D* C1 V6 {3 I' `


▼VAL：当前值寄存器

" T# d+ E/ }! g( M* M6 h% @' M

9 {2 S' T! R* V2 R ▼CALIB：校准值寄存器

& [7 D0 S* W+ @) K; Z6 J+ }使用不到，不再介绍

示例代码
& C0 u% T) o) S* \

1. void delay_us(uint32_t nus)
   
2. {
   ( f8 Z8 r, G0 h, o! `+ \7 z
3.   uint32_t temp;
   9 t8 `! X& R- g" ~7 D0 H/ e3 w
4.   SysTick->LOAD = RCC_Clocks.HCLK_Frequency/1000000/8*nus;
   ) R* Z2 _& l4 R) d2 ~+ q. K
5.   SysTick->VAL=0X00;//清空计数器
   
6.   SysTick->CTRL=0X01;//使能，减到零是无动作，采用外部时钟源
   ; [; |9 m8 A; Z, A; b
7.   do
   ' H' {2 u( w7 ^( L) d
8.   {
   
9.     temp=SysTick->CTRL;//读取当前倒计数值
   
10.   }while((temp&0x01)&&(!(temp&(1<<16))));//等待时间到达
    
11.   SysTick->CTRL=0x00; //关闭计数器
    
12.   SysTick->VAL =0X00; //清空计数器
    
13. }
    
14. void delay_ms(uint16_t nms)
    
15. {
    . Y3 [: }) Z( I, S0 q
16.   uint32_t temp;
    $ G' m7 s; \* }
17.   SysTick->LOAD = RCC_Clocks.HCLK_Frequency/1000/8*nms;
    " F1 ^$ n$ n$ c2 s8 T
18.   SysTick->VAL=0X00;//清空计数器
    
19.   SysTick->CTRL=0X01;//使能，减到零是无动作，采用外部时钟源
    
20.   do
    " G& k5 ~2 W2 E$ [
21.   {
    
22.     temp=SysTick->CTRL;//读取当前倒计数值
    ; z- I3 d; ]6 ^1 o" K
23.   }while((temp&0x01)&&(!(temp&(1<<16))));//等待时间到达
    ( d. u/ M: N, \9 k
24.   SysTick->CTRL=0x00; //关闭计数器
    ' ^9 H& @# t" e! p
25.   SysTick->VAL =0X00; //清空计数器
    
26. }

复制代码

, |& h4 @, l0 k& z, H4、汇编指令
如果系统硬件资源紧张，或者没有额外的定时器提供，又不想方法1的普通延时，可以使用汇编指令的方式进行延时，不会被编译优化且延时准确。

STM32F207在IAR环境下

1. /*!
   
2. *  @brief         软件延时
   ( y0 d; e& u3 b( r
3. *  @param        ulCount:延时时钟数
   0 ^( m# ^) c; U( h2 x+ b7 {
4. *  @return none
   + U( n! y$ i9 y' [( x  w! ?: B
5. *        @note         ulCount每增加1，该函数增加3个时钟
   
6. */
   ! d* |6 k0 {1 c
7. void SysCtlDelay(unsigned long ulCount)
   
8. {
   
9.     __asm("    subs    r0, #1\n"
   
10.           "    bne.n   SysCtlDelay\n"
    " V  {3 G1 b1 A* x1 ^
11.           "    bx      lr");
    
12. }

复制代码

这3个时钟指的是CPU时钟，也就是系统时钟。120MHZ，也就是说1s有120M的时钟，一个时钟也就是1/120 us，也就是周期是1/120 us。3个时钟，因为执行了3条指令。

使用这种方式整理ms和us接口，在Keil和IAR环境下都测试通过。
8 ?) m1 D, B8 ?7 _& `
; o3 h6 Q5 P: d  T' o/ O& r4 h

1. /*120Mhz时钟时，当ulCount为1时，函数耗时3个时钟，延时=3*1/120us=1/40us*/
   . c0 j$ g9 }* G0 e' e1 v  ]3 c
2. /*
   4 p9 O) B8 D' f. E" E  J
3. SystemCoreClock=120000000
   
4. us级延时,延时n微秒
   
5. SysCtlDelay(n*(SystemCoreClock/3000000));
   - C- ]; E4 [2 I* o% S
6. ms级延时,延时n毫秒
   
7. SysCtlDelay(n*(SystemCoreClock/3000));
   
8. m级延时,延时n秒
   % D- M( _7 e: `1 N' Y
9. SysCtlDelay(n*(SystemCoreClock/3));
   7 b- l4 S3 a% x. p
10. */
    3 C+ ^5 }3 ~$ J, N% L
11. 
    + M  z  }" j4 r
12. #if defined   (__CC_ARM) /*!< ARM Compiler */
    
13. __asm void
      Q; |! I  C0 w: h
14. SysCtlDelay(unsigned long ulCount)
    
15. {
    - Q5 c' [1 q0 g5 l
16.     subs    r0, #1;
    ( {3 ?9 C# ?& @7 U2 C; _
17.     bne     SysCtlDelay;
    
18.     bx      lr;
    
19. }
    
20. #elif defined ( __ICCARM__ ) /*!< IAR Compiler */
    
21. void
    ' Z) d9 }' b9 Z9 e  l: _# S1 x
22. SysCtlDelay(unsigned long ulCount)
    * W' r7 p- f" w) G
23. {
    $ T6 k# M: N, x, }* M' {3 K
24.     __asm("    subs    r0, #1\n"
    ( H9 _, I) z" {- q: y) g8 P& B
25.        "    bne.n   SysCtlDelay\n"
    
26.        "    bx      lr");
    
27. }
    % n& r5 V0 Z& N# W
28. 
    8 B9 R6 b8 W9 ]1 h
29. #elif defined (__GNUC__) /*!< GNU Compiler */
    * c( N$ Y& n4 l% C/ C6 e2 t, B
30. void __attribute__((naked))
    0 I" |3 i1 Q' X. K, D
31. SysCtlDelay(unsigned long ulCount)
    
32. {
    
33.     __asm("    subs    r0, #1\n"
    
34.        "    bne     SysCtlDelay\n"
    
35.        "    bx      lr");
    ) K3 U' X2 i8 ^( W
36. }
      {- x+ ^! j: X2 e) E6 R1 d1 h
37. 
    
38. #elif defined  (__TASKING__) /*!< TASKING Compiler */                           
    9 o/ d% O% U7 V! Q/ e6 ?% B! X1 u- E
39. /*无*/
    
40. #endif /* __CC_ARM */

复制代码

备注：

, T$ f! E$ p9 }理论上：汇编方式的延时也是不准确的，有可能被其他中断打断，最好使用us和ms级别的延时，采用for循环延时的函数也是如此。采用定时器延时理论上也可能不准确的，定时器延时是准确的，但是可能在判断语句的时候，比如if语句，判断延时是否到了的时候，就在判断的时候，被中断打断执行其他代码，返回时已经过了一小段时间。不过汇编方式和定时器方式，只是理论上不准确，在实际项目中，这两种方式的精度已经足够高了。

) D8 J9 _4 b& k8 Q7 H$ {