背景
延时函数在STM32单片机开发的项目中有广泛的应用，微秒级延时在一些时间要求严格的场景下（例如软件模拟I2C通讯）是必不可少的。由于FreeRTOS默认采用了system tick作为时间片分配的时基定时器，可能与利用system tick设计的延时函数出现冲突。再加上FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )最小的延时时间等于FreeRTOS的tick时间（一般设置为1ms），因此需要重新设计一套不基于system tick的微秒级延时函数。利用CM3/4内核中的数据观察点与跟踪(DWT)寄存器，可以在不占用硬件外设定时器的情况下实现微秒级的精准延时。

源码
$ R$ }; w& b3 L/ z3 q: s9 W通过选择#define USE_SYS_TICK, #define USE_DWT, #define USE_NOP_DELAY其中一个宏定义来决定delay函数的实现方式。需要特别注意的是，由于函数调用是需要时间的，因此使用延时函数时，一般会额外多出一些时间（1微秒左右）。

5 r' g  u; e: D; q% d  K#define USE_SYS_TICK是利用system tick设计的延时函数，在没有使用实时操作系统的时候，它是一个比较适合实现微秒级延时的通用方法。
. l( h$ E* H% ]0 G#define USE_DWT是利用CM3/4内核DWT寄存器设计的延时函数，它具有不占用system tick与外设定时器，延时精度高的特点。
# {9 }2 s- ?: l/ n: r#define USE_NOP_DELAY是利用了空指令设计的延时函数，它主要实现微秒以下的超短时间延时。
: E) n2 ?! H  ?$ |( z$ o头文件
1 r- P* I1 v9 b7 z3 w3 t

1. #ifndef __DELAY_H__
   1 L6 R9 P: @4 G9 k3 x* g
2. #define __DELAY_H__                           
   
3. 
   
4. #include "stm32f10x_conf.h"
   , H! ^* k) k' M% w
5. #include "stm32f10x.h"
   
6. 
   6 I, l1 z4 }2 Z5 o
7. //#define USE_SYS_TICK
   
8. #define USE_DWT
     V- J" C/ Z. a- g/ }6 z
9. //#define USE_NOP_DELAY
   
10. 
    + @% O5 j$ t% c9 _5 h1 C
11. void delay_init(void);
    7 D" ^- S+ ?$ G( R6 Z6 U
12. void delay_ms(uint16_t ms);
    ) p7 y8 k: z* S3 t
13. void delay_us(u32 us);
    
14. 
    ! d+ _$ g' H4 I3 _. i6 D- ^- j
15. /**
    * @' m3 b/ `, q& ]' L' o5 d) J. f6 F2 h
16. * 定义ns级延时，72M主频下，每一条空指令大约14ns
    $ R, J" ^6 z8 ]; R6 b+ H5 n
17. */
    1 ?# N+ y( h" f, I. K  l. p
18. //#define DELAY_6ns()                                        __NOP()
    : h6 Q9 [$ \' q8 l% Z: H/ g
19. //#define DELAY_12ns()                                DELAY_6ns(); __NOP()
    
20. //#define DELAY_18ns()                                DELAY_12ns(); __NOP()
      U, [( [9 c2 k
21. //#define DELAY_24ns()                                DELAY_18ns(); __NOP()
    3 m! p2 a/ k9 T% w$ d
22. //#define DELAY_30ns()                                DELAY_24ns(); __NOP()
    
23. //#define DELAY_60ns()                                DELAY_30ns(); DELAY_30ns()
    ( S1 g; \( w( M* }; ~$ h0 P; o
24. //#define DELAY_90ns()                                DELAY_60ns(); DELAY_30ns()
    
25. 
    4 \- g( p/ L  S- V. T/ H
26. 
    
27. #endif
    
28. 
    

复制代码

源文件
2 l6 M4 p$ }6 Q7 K

1. #include "delay.h"
   7 T" x6 I+ E4 h1 w& n: s* D
2. 
   
3. #ifdef USE_SYS_TICK
   
4. 
   
5. static uint8_t  fac_us = 0;                          //us延时倍乘数
   : e- L# _6 ?5 S9 `* Z, _& x9 ^7 c
6. static uint16_t fac_ms = 0;                          //ms延时倍乘数,在ucos下,代表每个节拍的ms数
   
7. 
   4 B0 N" ~3 M/ |8 G
8. //初始化延迟函数
   0 o  m7 W+ p$ `' u* Q* l
9. //当使用OS的时候,此函数会初始化OS的时钟节拍
     s, T6 ~3 y! ^+ Y
10. //SYSTICK的时钟固定为HCLK时钟的1/8
    
11. //SYSCLK:系统时钟
    
12. void delay_init()
    : `# n3 ~5 J0 ^; r3 q5 k
13. {
    ) E- Q0 D+ }1 T, v! s; f1 F9 V
14.         SysTick_CLKSourceConfig ( SysTick_CLKSource_HCLK_Div8 ); //选择外部时钟  HCLK/8
    9 Z& q& w1 l5 b, l; a
15.         fac_us = SystemCoreClock / 8000000;         //为系统时钟的1/8
    
16.         fac_ms = ( uint16_t ) fac_us * 1000;             //非OS下,代表每个ms需要的systick时钟数
    
17. }
    
18. 
    ( Y3 T& w. F3 a6 E! @
19. //延时nus
    3 T" R6 E/ ?' ?) z6 t
20. //nus为要延时的us数.
    
21. void delay_us ( u32 us )
    
22. {
    & C6 B! @7 M3 ?6 I5 i8 R% j1 H0 j
23.         u32 temp;
    $ q( D& ]4 i& K- ~- H5 J
24.         SysTick->LOAD = us * fac_us;               //时间加载
    
25.         SysTick->VAL = 0x00;                        //清空计数器
    * O( V! A* l5 s$ L, W
26.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数
    , h) t& @4 V( Z, x7 S
27. 
    - R3 L' e8 O  J6 Z
28.         do
    
29.         {
    : j  W& X) L+ U; y# i, q: o* h
30.                 temp = SysTick->CTRL;
    : Q3 C4 o% ^* l5 a$ X
31.         }
    ( }. ?; S9 z3 b  L
32.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达
    
33. 
    
34.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    3 [$ \3 y$ f6 R! E( _. D' p
35.         SysTick->VAL = 0X00;                         //清空计数器
    
36. }
    : ]! }! j, X! [% B% Z
37. //延时nms
    
38. //注意nms的范围
    
39. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    
40. //nms<=0xffffff*8*1000/SYSCLK
    ! I/ p1 ]3 r+ v* G
41. //SYSCLK单位为Hz,nms单位为ms
    0 g# j+ Q1 _" p  u0 c) J
42. //对72M条件下,nms<=1864
    
43. void delay_ms ( uint16_t ms )
    % c, M8 p% @; ?
44. {
    ) u9 d* K1 m2 c
45.         u32 temp;
    
46.         SysTick->LOAD = ( u32 ) ms * fac_ms;       //时间加载(SysTick->LOAD为24bit)
    7 \. _' B+ m6 l' {: h# _
47.         SysTick->VAL = 0x00;                        //清空计数器
      D- A& Y9 @) Q/ }
48.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数
    $ Y3 N0 E( S1 H" F
49. 
    
50.         do
    6 j7 N( `  D& J/ S& G7 P3 f
51.         {
    # N  B# [3 n; f( W6 x6 n2 n$ ^, N
52.                 temp = SysTick->CTRL;
    $ \, Z# n5 A2 U# h
53.         }
    ! m0 ?) K4 }& O
54.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达
    
55. 
    
56.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    8 v- g; ^7 b2 r
57.         SysTick->VAL = 0X00;                        //清空计数器
    ( z. A8 d0 o( d: E1 K
58. }
    
59. 
    % A9 Y& }8 O* h8 E
60. #elif defined USE_DWT
    * V2 h: c- [$ }  s; q
61. 
    
62. // 0xE000EDFC DEMCR RW Debug Exception and Monitor Control Register.
    6 g- W) N$ \" s- B9 ?- M1 b
63. #define DEMCR           ( *(__IO uint32_t *)0xE000EDFC )
    & X1 V' ^" p) j2 c. A8 T
64. #define TRCENA          ( 0x01 << 24) // DEMCR的DWT使能位
    % g. b' Y8 \* W6 Q6 l: \8 N8 Z/ |  F
65. 
    & w- N3 R! S: Y) f9 ^
66. #define  DBGMCU_CR   *(__IO uint32_t *)0xE0042004                        //MCU调试模块控制寄存器，详细内容参考《stm32中文参考手册》调试支持（DBG）章节，747页
    
67. 
    ( Q+ r0 O. r+ {: O7 B: `
68. // 0xE0001000 DWT_CTRL RW The Debug Watchpoint and Trace (DWT) unit
    
69. #define DWT_CTRL        ( *(__IO uint32_t *)0xE0001000 )
    
70. #define DWT_CTRL_CYCCNTENA       ( 0x01 << 0 ) // DWT的SYCCNT使能位
    
71. 
    
72. // 0xE0001004 DWT_CYCCNT RW Cycle Count register,
    % n1 u0 F) V( E; p1 J) R& x
73. #define DWT_CYCCNT      ( *(__IO uint32_t *)0xE0001004) // 显示或设置处理器的周期计数值
    2 T) g7 ^; S$ C$ p  B$ M5 |
74. 
    
75. //#define DWT_DELAY_mS(mSec)    DWT_DELAY_uS(mSec*1000)
    
76. 
      v; D. g" k+ i4 m
77. void delay_init()
    
78. {
    ( o* O( z1 R5 W9 {3 M! ]+ K
79.         //使能DWT外设
    : ^2 \% X) u) R; e* A
80.         DEMCR |= (uint32_t)TRCENA;
    + R7 w( D* G/ B  ~4 o: {
81. 
    - \& J8 c* R) z8 t: r
82.         //DWT CYCCNT寄存器计数清0
    
83.         DWT_CYCCNT = (uint32_t)0u;
    $ x9 J% ^. e" i) t: F
84. 
    
85.         //使能Cortex-M3 DWT CYCCNT寄存器
    
86.         DWT_CTRL |= (uint32_t)DWT_CTRL_CYCCNTENA;
    
87. }
    / ~. @, S8 }' k1 v
88. 
    * m$ E  W: v/ O7 ^' g5 a! ~
89. 
    3 u# Q# _+ L& R3 O8 O
90. // 微秒延时
    
91. void delay_us(uint16_t uSec)
    
92. {
    
93.         if(uSec > 10000) uSec = 10000;
    
94. 
    ) _$ Q( m8 p, A
95.     uint32_t ticks_start, ticks_end, ticks_delay;
    
96. 
    
97.     ticks_start = DWT_CYCCNT;
    # X0 g+ S1 J& j* g$ ~
98.     ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数
    
99.     ticks_end = ticks_start + ticks_delay;
    
100. 
     
101.     // ticks_end没有溢出
     6 \& E. Q: y6 D0 k. l' S! }
102.     if ( ticks_end >= ticks_start )
     / l% Z' z% c: i+ F6 D  r7 X( a
103.     {
     - }3 b$ `/ v2 q2 ?
104.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
     
105.         if(DWT_CYCCNT > ticks_start)
     
106.         {
     2 F( _8 h5 w/ V. F
107.             while( DWT_CYCCNT < ticks_end );
     
108.         }
     
109.         // DWT_CYCCNT溢出
     
110.         else
     
111.         {
     
112.             // 已经超时，直接退出
     
113.             return;
     4 G, M$ ?* O; G% \# r6 ?' Y
114.         }
     5 _' ?" {8 m' G, x) i
115.     }
     ; i/ y8 R  u' N- ]. c$ v! k
116.     else // ticks_end溢出
     
117.     {
     . j- V  t9 b4 u6 k" I3 V! \
118.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
     4 b# f8 a; ]( z
119.         if(DWT_CYCCNT > ticks_start)
     . P6 r, ], O/ H4 v
120.         {
     
121.             // 等待DWT_CYCCNT的值溢出
     * B, K) ^; n$ L8 T% K; `/ G9 `
122.             while( DWT_CYCCNT > ticks_end );
     , }0 k: x2 K1 v! S. w4 e6 D1 U
123.         }
     9 m2 l" C' g( n7 }
124.         // 等待溢出后的DWT_CYCCNT到达ticks_end
     / s' @0 j! G" ^' |# o
125.         while( DWT_CYCCNT < ticks_end );
     
126.     }
     & T) h5 Y  I  Z4 l5 ]
127. }
     $ a5 A, o: L6 X  [3 m8 o: w
128. 
     " X( Z3 W! ^2 R
129. void delay_ms(uint16_t ms)
     + h6 A" y( r6 U5 {& H) K
130. {
     
131.                 for(uint16_t i = 0; i < ms; i++)
     ' b! B, K6 V8 p! z1 p
132.     {
     . S' N; Y2 T1 f( |& g$ p
133.         // delay 1 ms
     3 |# W- ?. G( T4 V0 Q7 r$ J
134.         delay_us(1000);
     
135.     }
     
136. }
     
137. 
     ; N0 k* @% @  E8 _! F9 [  M! o
138. #elif defined USE_NOP_DELAY
     
139. 
     
140. void delay_init(void)
     
141. {
       A" d+ ]- [8 L$ I0 O
142. 
     
143. }
     
144. 
     % s  U1 x  N' V- F
145. void delay_ms(uint16_t ms)
     
146. {
     
147. 
     , P% e. U+ N2 n, a' x
148. }
     
149. 
     
150. void delay_us(u32 us)
     ; T& D: B, u' o: d( `
151. {
     
152. 
     
153. }
     
154. 
     
155. #else
     
156. 
     
157. #endif

复制代码

& U9 H5 @. M/ R5 y8 i特别说明
) P+ u$ H* S+ x" r: k使用DWT内核的延时函数中，涉及了两次数据溢出处理，第一次数据溢出处理是指计算结束时间(ticks_end = ticks_start + ticks_delay)发生溢出，如下图所示：

. S% {/ T* h7 w6 B: I( f这里有个限制条件就是延时长度(ticks_delay)不能超过uint32_t的最大值，但考虑到这是一个极大的数值，几乎不可能发生，因此可以简化处理限制微秒延时函数的输入参数小于10k，以提高延时精度。对于这个溢出判断就比较明确了：
) u) a$ T. [; T/ c5 G! [
8 c0 z0 M* R+ v& J# u. @

1. if ( ticks_end >= ticks_start )
   ; U, Q1 U4 q& o# x6 c
2. {
   3 R& i5 `: y. q! ~
3.         // 计算未溢出
   * X3 r/ J0 h. c
4. }
   " l' ^5 a7 O- V3 d
5. else
   / c3 |3 R! K! R- k
6. {
   3 O/ ~, t! v% x$ I: t0 L
7.         // 计算溢出
   
8. }

复制代码

, h& M( H/ r, r9 [9 N7 K5 \- ?4 u' Y第二个溢出相对比较复杂，处理不当会导致严重问题，尤其是使用了RTOS的系统中有很可能遇到。其核心原因是从标记初始化时间戳ticks_start = DWT_CYCCNT到准备比较时间戳例如while( DWT_CYCCNT < ticks_end );的这段时间的耗时是不确定的。即使没有使用RTOS，如下代码(使用绿色底色标注)在执行时也可能被硬中断暂停，从而导致DWT_CYCCNT时间戳可能已经越过了ticks_end ，或者也发生了溢出重置。
2 O5 z  H* Q) ^, p
, {  a+ T) S$ Q

1. ticks_start = DWT_CYCCNT;
   # c4 z; i$ i' |) y! \
2. ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数
   0 J2 p* @1 V/ i: T
3. ticks_end = ticks_start + ticks_delay;
   " w  K$ b5 a: j4 a6 F% J- _# c
4. 
   - M/ ^" d" }9 y- B1 _
5. if ( ticks_end >= ticks_start )
   
6. {
   
7.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
   
8.         if(DWT_CYCCNT > ticks_start)
   
9.         {
   
10. 
    7 b$ N, p( W& W
11.         }
    - W9 C( _! k0 V" p' i7 d4 S
12.         else
    : d' m& O0 p. ~9 y! P
13.         {
    9 F7 K6 ^, i+ ]6 d+ x( \
14.         
    
15.         }
    4 l( n  u6 `. H" F7 P
16. }
    # ^7 r- p/ \# H) |. e0 M. }
17. else
    
18. {
    
19.         // DWT_CYCCNT在上述计算的这段时间中没有溢出
    
20.         if(DWT_CYCCNT > ticks_start)
    ! C& L! T5 n( x! A4 u
21.         {
    " `$ w7 x: V# B% @
22. 
    7 K8 _# k3 F6 V5 P7 x2 l! x# P% Q
23.         }
    1 X* d* K( z% U) A
24.         else
    
25.         {
    
26.         
    
27.         }
    2 @. O' e) `5 N. ?
28. }

复制代码

因此需要根据延时等待操作时DWT_CYCCNT所处位置再进行一次判断：
8 P2 P: E+ r5 c; \* C% Q
  U9 z! Z5 Q+ J9 {3 b6 ~' U
+ }  `7 A9 s8 W: S2 a; c$ U
ticks_end未溢出时(ticks_end1)：
DWT_CYCCNT未溢出(DWT_CYCCNT2 & DWT_CYCCNT3)时：while( DWT_CYCCNT < ticks_end );
1 i* V8 M$ a! b3 j" w7 `9 A, tDWT_CYCCNT溢出(DWT_CYCCNT4)时：直接返回。
  E. ^/ @8 ~8 P& b2 t9 z4 `( xticks_end溢出时(ticks_end2)：
DWT_CYCCNT未溢出(DWT_CYCCNT2)时：while( DWT_CYCCNT > ticks_end ); while( DWT_CYCCNT < ticks_end );
DWT_CYCCNT溢出(DWT_CYCCNT4 & DWT_CYCCNT5)时：while( DWT_CYCCNT < ticks_end );


+ Q1 V" |8 r/ m/ E  [
使用指南
在程序开始的地方初始化延时函数：delay_init();
在需要延时的地方调用延时函数：delay_us(10);
需要特别说明的是，在FreeRTOS的任务中调用本文介绍的例如void delay_us(uint32_t us)等延时函数，任务会阻塞等待延时结束。如果是调用FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )，系统会执行低优先级任务直到延时结束。
" }$ P/ M' Z" ]7 ~


- v5 I8 O0 M6 O$ |  ^1 Q