背景
延时函数在STM32单片机开发的项目中有广泛的应用，微秒级延时在一些时间要求严格的场景下（例如软件模拟I2C通讯）是必不可少的。由于FreeRTOS默认采用了system tick作为时间片分配的时基定时器，可能与利用system tick设计的延时函数出现冲突。再加上FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )最小的延时时间等于FreeRTOS的tick时间（一般设置为1ms），因此需要重新设计一套不基于system tick的微秒级延时函数。利用CM3/4内核中的数据观察点与跟踪(DWT)寄存器，可以在不占用硬件外设定时器的情况下实现微秒级的精准延时。
3 S1 {5 a; r, J" H) y' B5 ]9 y
源码
通过选择#define USE_SYS_TICK, #define USE_DWT, #define USE_NOP_DELAY其中一个宏定义来决定delay函数的实现方式。需要特别注意的是，由于函数调用是需要时间的，因此使用延时函数时，一般会额外多出一些时间（1微秒左右）。

#define USE_SYS_TICK是利用system tick设计的延时函数，在没有使用实时操作系统的时候，它是一个比较适合实现微秒级延时的通用方法。
#define USE_DWT是利用CM3/4内核DWT寄存器设计的延时函数，它具有不占用system tick与外设定时器，延时精度高的特点。
" h3 X* |' E  b9 Y% ^9 ]#define USE_NOP_DELAY是利用了空指令设计的延时函数，它主要实现微秒以下的超短时间延时。
头文件
/ r) U8 z/ m( H! ]8 \8 q6 \

1. #ifndef __DELAY_H__
   , a) l8 D- [# R3 C
2. #define __DELAY_H__                           
   - r' ~$ a- K5 R3 }
3. 
   
4. #include "stm32f10x_conf.h"
   % Y, H' N+ C( Z. h6 o
5. #include "stm32f10x.h"
   
6. 
   9 U' r+ R( }. v9 I8 B; Y3 `9 O
7. //#define USE_SYS_TICK
   : c' ?4 x7 K- e0 G/ m# `1 }7 j
8. #define USE_DWT
   
9. //#define USE_NOP_DELAY
   * M! c/ O' H. F- w7 R
10. 
    
11. void delay_init(void);
    
12. void delay_ms(uint16_t ms);
    
13. void delay_us(u32 us);
    
14. 
    
15. /**
    8 R6 }- k+ P# j1 z, T4 M2 t1 {
16. * 定义ns级延时，72M主频下，每一条空指令大约14ns
    $ C, }! I- h- `; D" J+ Q" A6 a
17. */
    
18. //#define DELAY_6ns()                                        __NOP()
    
19. //#define DELAY_12ns()                                DELAY_6ns(); __NOP()
    ( H# A( T( P  b# y# j0 l/ |
20. //#define DELAY_18ns()                                DELAY_12ns(); __NOP()
    & ~5 I2 `: H) B& ^6 |$ k
21. //#define DELAY_24ns()                                DELAY_18ns(); __NOP()
    
22. //#define DELAY_30ns()                                DELAY_24ns(); __NOP()
    : B% u0 A' I& _! C" b
23. //#define DELAY_60ns()                                DELAY_30ns(); DELAY_30ns()
    
24. //#define DELAY_90ns()                                DELAY_60ns(); DELAY_30ns()
    % K+ R( C: n$ h
25. 
    9 \% d+ L' `- N: |* j% X1 g7 y
26. 
    
27. #endif
    
28. 
    ! s2 s0 o& k& n% h

复制代码

/ Z3 @, e1 [  y9 _7 _源文件
4 K0 F+ d$ S, y/ e* C$ m

1. #include "delay.h"
   1 B. B4 {. z- q& ?' Q, c5 t
2. 
   5 y7 ?8 y' L4 Q; g
3. #ifdef USE_SYS_TICK
   
4. 
   
5. static uint8_t  fac_us = 0;                          //us延时倍乘数
   5 ^9 X  @4 k% M4 u  i/ F+ U
6. static uint16_t fac_ms = 0;                          //ms延时倍乘数,在ucos下,代表每个节拍的ms数
   $ n* v% }; v( g+ c. A! A
7. 
   
8. //初始化延迟函数
   
9. //当使用OS的时候,此函数会初始化OS的时钟节拍
   
10. //SYSTICK的时钟固定为HCLK时钟的1/8
    * \3 S5 z0 ^3 B* ]8 ]+ l
11. //SYSCLK:系统时钟
    
12. void delay_init()
    
13. {
    1 E* G0 N% C' N- C
14.         SysTick_CLKSourceConfig ( SysTick_CLKSource_HCLK_Div8 ); //选择外部时钟  HCLK/8
    # d- V" }3 _8 O3 j  d1 h# M
15.         fac_us = SystemCoreClock / 8000000;         //为系统时钟的1/8
    6 m, Q9 U& q, I" `6 ^9 K
16.         fac_ms = ( uint16_t ) fac_us * 1000;             //非OS下,代表每个ms需要的systick时钟数
    / S  L. C# Y! Z! ?5 j
17. }
    
18. 
    / D# Z, C! I+ A  S& S$ e& l) D
19. //延时nus
    7 q7 F3 }7 `: C" F" a, o+ S0 p
20. //nus为要延时的us数.
    
21. void delay_us ( u32 us )
    
22. {
    , j9 B1 l! z, y0 M* H4 `( v
23.         u32 temp;
    4 ^5 u; J9 D" r; n* H* D- f% g- ^
24.         SysTick->LOAD = us * fac_us;               //时间加载
    4 r$ h5 m, o1 ]7 o9 Y( C1 h
25.         SysTick->VAL = 0x00;                        //清空计数器
    
26.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数
    + H0 O( |8 x: K5 L! d
27. 
    
28.         do
    
29.         {
    
30.                 temp = SysTick->CTRL;
    
31.         }
    7 B4 z3 x' h' Q. W
32.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达
    
33. 
    8 O+ T& G; l0 }8 [
34.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    
35.         SysTick->VAL = 0X00;                         //清空计数器
    
36. }
    ' }* ^0 a7 v! ^8 D1 g( V9 u
37. //延时nms
    
38. //注意nms的范围
    " g$ `; u6 @: B  s, @9 Q
39. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    & y' }+ a* M, K$ B: ?
40. //nms<=0xffffff*8*1000/SYSCLK
    7 T" t( @; L& l! `& y4 Y
41. //SYSCLK单位为Hz,nms单位为ms
    - `, ^/ B/ g" K2 C$ ]
42. //对72M条件下,nms<=1864
    
43. void delay_ms ( uint16_t ms )
    
44. {
    
45.         u32 temp;
    ; }: w$ w1 W( W; g
46.         SysTick->LOAD = ( u32 ) ms * fac_ms;       //时间加载(SysTick->LOAD为24bit)
    
47.         SysTick->VAL = 0x00;                        //清空计数器
    7 O5 c: m/ x. z7 G
48.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数
    , r. h' ]+ B  i/ B
49. 
    
50.         do
    2 S6 Q+ p# R. }+ d( Z- z  p
51.         {
    8 [2 u  b: E# F; N. _% N
52.                 temp = SysTick->CTRL;
    & E6 w' L8 h' u' b' A
53.         }
    / h7 @, Z( }+ G# f( h# ^+ m
54.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达
    - V1 f1 O, Z; ?! D+ W6 C& C* I$ q
55. 
    5 l  C5 x1 D6 @
56.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    
57.         SysTick->VAL = 0X00;                        //清空计数器
    * l' _3 B5 A! {& d
58. }
    
59. 
    9 u" {9 l# ]6 A; a5 N
60. #elif defined USE_DWT
    
61. 
    9 L" V. S. \3 }& r7 x
62. // 0xE000EDFC DEMCR RW Debug Exception and Monitor Control Register.
    : h, Y0 Q( r% [+ m2 M
63. #define DEMCR           ( *(__IO uint32_t *)0xE000EDFC )
    ; o  Z# D& R1 ]
64. #define TRCENA          ( 0x01 << 24) // DEMCR的DWT使能位
    / g+ l! u5 X1 @! x5 N# I6 m  ^
65. 
    7 v  J' H6 ]! z) c
66. #define  DBGMCU_CR   *(__IO uint32_t *)0xE0042004                        //MCU调试模块控制寄存器，详细内容参考《stm32中文参考手册》调试支持（DBG）章节，747页
    5 j& y7 M' H, x
67. 
    
68. // 0xE0001000 DWT_CTRL RW The Debug Watchpoint and Trace (DWT) unit
    0 T3 Q( U5 \/ v. a$ W4 `
69. #define DWT_CTRL        ( *(__IO uint32_t *)0xE0001000 )
    ; p$ |7 c  `) l' C! X
70. #define DWT_CTRL_CYCCNTENA       ( 0x01 << 0 ) // DWT的SYCCNT使能位
    0 o' k& N. J& d# B& ^3 X) F  v
71. 
    6 R- N8 {9 @  c3 @2 h: A- A
72. // 0xE0001004 DWT_CYCCNT RW Cycle Count register,
    ; [# t4 [. I& Y9 z$ w! C  I
73. #define DWT_CYCCNT      ( *(__IO uint32_t *)0xE0001004) // 显示或设置处理器的周期计数值
    ! w7 S1 N5 |" R2 ^% J3 d
74. 
    2 b7 S, l, v' J5 q( n
75. //#define DWT_DELAY_mS(mSec)    DWT_DELAY_uS(mSec*1000)
    
76. 
    
77. void delay_init()
    5 W5 U' j. @8 i. w& ~* K; \
78. {
    
79.         //使能DWT外设
    
80.         DEMCR |= (uint32_t)TRCENA;
    # h5 k0 V3 m1 Q
81. 
    
82.         //DWT CYCCNT寄存器计数清0
    
83.         DWT_CYCCNT = (uint32_t)0u;
    
84. 
    
85.         //使能Cortex-M3 DWT CYCCNT寄存器
    2 T2 V+ p4 s# ?, Z
86.         DWT_CTRL |= (uint32_t)DWT_CTRL_CYCCNTENA;
    1 D) T1 n  t1 K% M
87. }
    
88. 
      s* X/ s2 W2 S  e
89. 
    
90. // 微秒延时
    
91. void delay_us(uint16_t uSec)
    9 m# e: {" C6 A
92. {
    
93.         if(uSec > 10000) uSec = 10000;
    ; y6 P9 k' V6 ?9 f9 b5 G' A. K
94. 
    5 V1 {1 `$ J- [0 T+ I; D
95.     uint32_t ticks_start, ticks_end, ticks_delay;
    0 d. m: c, ~9 C( P( _3 y, ~: Z+ ]2 R
96. 
    
97.     ticks_start = DWT_CYCCNT;
    / n5 a, j- S* D. q. b0 y/ ~/ ^
98.     ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数
    7 ~, j: H7 Z( l4 A9 h
99.     ticks_end = ticks_start + ticks_delay;
    8 V1 J  f6 G0 h' n% ?/ Y
100. 
     
101.     // ticks_end没有溢出
     
102.     if ( ticks_end >= ticks_start )
     
103.     {
     
104.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
     5 h! o' H+ C& P$ h) B
105.         if(DWT_CYCCNT > ticks_start)
     , c' o* u* H8 o/ P0 D' ^: L
106.         {
     ! q. {& `$ f0 Y+ E4 ~
107.             while( DWT_CYCCNT < ticks_end );
     $ }% j$ k# H. h. L& }
108.         }
     
109.         // DWT_CYCCNT溢出
     ) I1 n9 I- N$ T1 J) R5 o; }
110.         else
     
111.         {
     
112.             // 已经超时，直接退出
     
113.             return;
     & l' r. Y$ A( Z. z
114.         }
     
115.     }
     
116.     else // ticks_end溢出
     ( K, _& P8 u9 R2 g0 D" _
117.     {
     2 k/ j' z$ Q' a" U% C& _' }
118.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
     
119.         if(DWT_CYCCNT > ticks_start)
     
120.         {
     
121.             // 等待DWT_CYCCNT的值溢出
     
122.             while( DWT_CYCCNT > ticks_end );
     
123.         }
     
124.         // 等待溢出后的DWT_CYCCNT到达ticks_end
     
125.         while( DWT_CYCCNT < ticks_end );
     6 F  ^# b& g/ x9 ~8 ]4 P. F; i
126.     }
     ' _7 O9 h+ k, f5 f# Z
127. }
     
128. 
     
129. void delay_ms(uint16_t ms)
     
130. {
     
131.                 for(uint16_t i = 0; i < ms; i++)
     ( p: ~6 I+ h6 \2 I" r2 Z
132.     {
     ; G. M- f4 n' k' O
133.         // delay 1 ms
     % Y9 }/ |6 d2 w/ q6 B- \
134.         delay_us(1000);
     ( |% a% h7 N+ z5 L* x4 U4 I- y& h
135.     }
     
136. }
     
137. 
     
138. #elif defined USE_NOP_DELAY
     
139. 
     5 C3 I" Z" a& y) b# p
140. void delay_init(void)
     
141. {
       j$ q& f* n. D
142. 
     - s2 L7 f( M/ _. q5 p0 y
143. }
     & h9 c* L/ G6 _: G% O  R
144. 
     7 s2 V6 p' d% \: O( }" d
145. void delay_ms(uint16_t ms)
     
146. {
     4 Z% W" _7 O- l( B- r- w# {8 t
147. 
     
148. }
     
149. 
     - ~" Y2 ^2 h/ O
150. void delay_us(u32 us)
     
151. {
     ! k# e9 w1 N4 H$ L1 a# m5 p
152. 
     
153. }
     
154. 
     7 V0 w( B. x: n$ E% W( C
155. #else
     
156. 
     
157. #endif

复制代码

2 w9 c5 l9 f: |6 V/ t2 p) x特别说明
' m. U# Y) Z/ I; l4 W, m3 ]使用DWT内核的延时函数中，涉及了两次数据溢出处理，第一次数据溢出处理是指计算结束时间(ticks_end = ticks_start + ticks_delay)发生溢出，如下图所示：

4 x7 d1 r  R% z$ A& @+ `6 t这里有个限制条件就是延时长度(ticks_delay)不能超过uint32_t的最大值，但考虑到这是一个极大的数值，几乎不可能发生，因此可以简化处理限制微秒延时函数的输入参数小于10k，以提高延时精度。对于这个溢出判断就比较明确了：

7 J6 U. I2 k& {6 ^3 o

1. if ( ticks_end >= ticks_start )
   4 k* `* Z% ^9 J) W# O
2. {
   ; w3 s( M! ^0 V  B
3.         // 计算未溢出
   ) S: {  j8 H# k
4. }
   ) |1 F! h  |' X4 p, g
5. else
   
6. {
   
7.         // 计算溢出
   
8. }

复制代码

# y# C4 E0 ^/ B; s- ^" b. ~% M2 I第二个溢出相对比较复杂，处理不当会导致严重问题，尤其是使用了RTOS的系统中有很可能遇到。其核心原因是从标记初始化时间戳ticks_start = DWT_CYCCNT到准备比较时间戳例如while( DWT_CYCCNT < ticks_end );的这段时间的耗时是不确定的。即使没有使用RTOS，如下代码(使用绿色底色标注)在执行时也可能被硬中断暂停，从而导致DWT_CYCCNT时间戳可能已经越过了ticks_end ，或者也发生了溢出重置。

1. ticks_start = DWT_CYCCNT;
   
2. ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数
   7 U3 {9 x  S5 g/ O& k1 a
3. ticks_end = ticks_start + ticks_delay;
   
4. 
   ! _3 G  W" [& J5 F6 ], ^' @
5. if ( ticks_end >= ticks_start )
   
6. {
   
7.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
   
8.         if(DWT_CYCCNT > ticks_start)
   ' U6 ]6 j& R0 h2 x5 N6 E# f3 u8 Q
9.         {
   
10. 
    
11.         }
    % {3 M, `! u3 Z7 c% O+ x# f  V% _
12.         else
    
13.         {
    6 H9 N. _: D0 X7 j
14.         
    
15.         }
    # R0 ~( l2 h2 [+ Y
16. }
    
17. else
    
18. {
    $ m+ N) ]0 b) t6 A# y
19.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
    + C5 v" K6 f0 n; I8 ]: V$ u
20.         if(DWT_CYCCNT > ticks_start)
    * V, X& ^! c( w9 S
21.         {
    : v3 v" s3 g: N/ W
22. 
    3 X" d' |2 @+ s$ @
23.         }
    
24.         else
    / }: |9 j0 D% \5 b. B
25.         {
    - _' m' k: f$ ^$ ]" `
26.         
    
27.         }
    " j; V* ], R, U' t; A8 @: j! U2 J7 a
28. }

复制代码

* k0 I" _; b/ H9 f2 H$ I7 Y因此需要根据延时等待操作时DWT_CYCCNT所处位置再进行一次判断：

4 l1 v, L1 B% m/ c/ @
& p7 ?/ a* A0 X; G7 }: Q2 i4 U. g8 E8 j
ticks_end未溢出时(ticks_end1)：
DWT_CYCCNT未溢出(DWT_CYCCNT2 & DWT_CYCCNT3)时：while( DWT_CYCCNT < ticks_end );
DWT_CYCCNT溢出(DWT_CYCCNT4)时：直接返回。
8 x9 L; l: h0 I$ p+ Rticks_end溢出时(ticks_end2)：
DWT_CYCCNT未溢出(DWT_CYCCNT2)时：while( DWT_CYCCNT > ticks_end ); while( DWT_CYCCNT < ticks_end );
- _' I9 E4 }. Y" d& V( W6 g( F6 e( n# eDWT_CYCCNT溢出(DWT_CYCCNT4 & DWT_CYCCNT5)时：while( DWT_CYCCNT < ticks_end );
8 O; s$ s5 E, ?3 ?
& u5 a" l8 y+ u1 T, L7 w5 ^
! q9 ]! K, p6 c! k4 v; S
使用指南
在程序开始的地方初始化延时函数：delay_init();
在需要延时的地方调用延时函数：delay_us(10);
需要特别说明的是，在FreeRTOS的任务中调用本文介绍的例如void delay_us(uint32_t us)等延时函数，任务会阻塞等待延时结束。如果是调用FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )，系统会执行低优先级任务直到延时结束。
3 _- P3 x8 s4 ?1 w


' q% p* y; ~! q. q