01前言
5 ], h4 W9 N! M4 K在之前的文章在《STM32延时函数的四种方法》使用定时器延时，在《如何测量代码运行时间》中提到使用定时器外设计算代码运行时间。文中提到这种方法的明显缺点就是需要占用一个定时器，一些MCU在特定应用场景下定时器外设资源是十分稀缺的。在留言区有位大佬提到可以使用DWT，我就研究了一番。

' K' d% M+ W, Y* w
02DWT
* w& Z, G1 i! ]- `' R$ J# h
4 C; z, f2 n( I2 F
5 N) e% p1 q  d& F" p* t在Cortex-M里面有一个外设叫DWT(DataWatchpoint andTrace)，是用于系统调试及跟踪，DWT的中文名字应该是：数据观察点触发。在STM32用户手册的第32章节Debugsupport (DBG)有如下框图。

明显DWT属于DBG部分的功能，从上图的标题可以看出DWT属于CortexM3内核的，理论上M3内核的MCU都支持的，这个下文会说明。在这里我将其称之为“隐藏的定时器”，因为他可以代替定时器外设实现上文提到延时功能和测量代码运行时间的功能，DWT不能代替定时器的其他功能。


& k8 J5 ~1 q7 {8 v! p( g之所以DWT可以实现延时功能，因为它有一个32的计数器CYCCNT，这是一个向上计数的计数器，当它溢出时会自动清零并重新开始向上计数，它的频率就是内核的主频。简单点说，就是内核时钟跳动一下，CYCCNT计数器就加1。
; y7 ?; y3 u2 c

; m" M/ {& V7 H6 e$ v0 @; h, y8 B很明显DWT计数器的精度和系统主频有关，我们常用的STM32F103主频一般为72Mhz，STM32F207一般为120Mhz，STM32H7主频一般为400Mhz。以为主频最低为72Mhz的STM32F103为例，精度是1/72M= 14ns，这个精度足以满足大部分延时函数的需求，同样程序的运行时间都是微秒级别的，远远满足测量代码运行时间的要求。
2 V0 ?. D# R+ J9 `2 u
! d. e" p0 n. N& ]. a7 k9 `' }8 o
" z! L( v, q% }03
# a$ P$ h# ~" K; X; [' ~DWT的配置
5 m, ]; c$ m8 ^! Y$ q4 J% d
) R- N( O2 ~: s3 W
* Q; {9 u" L( _# Y! [首选使用DWT前必须使能DBG的系统跟踪，控制使能位在DEMCR寄存器的bit24。注意该寄存器详细说明在STM32的用户手册上查不到，需要在CortexM3内核手册查到，在《Cortex-M3权威指南》书中也可以查到。
* U. Y1 A# k+ K9 j6 h1 L

在使能CYCCNT计数器前，必须先将其清零。下图是从ARM的官方手册《Cortex-M3Technical Reference Manual》中查到的。
2 P7 L; s* A, n$ j$ _1 `

使能CYCCNT计数器，其控制位是DWT控制寄存器的第一位，写1使能，则启用CYCCNT计数器，否则CYCCNT计数器将不会工作。
7 l, ^6 Z' H: M# n2 E# I# C

总结一下：


a.先使能DWT外设，由内核调试寄存器DEM_CR的位24控制，写1使能。

* @3 Q* F! A* v: A: V  b; W. T! Z# Z
* U: D) n2 p# t5 [8 x; n7 c2 Lb.使能CYCCNT寄存器之前，先清0。


c.使能CYCCNT寄存器，由DWT_CTRL的位0控制，写1使能。
4 A- g, r3 U, I9 m6 C7 W9 S

3 [" b2 R" W' Y, ~9 n- f) s! L- I! ^代码如下
( A$ {) S! F# |6 c$ T

1. 
   
2. //寄存器基地址
   6 U  I' R5 k/ V8 I5 F2 e( |7 D. k5 F
3. #define    DWT_CR    *(uint32_t*)0xE0001000
   
4. #define    DWT_CYCCNT    *(uint32_t*)0xE0001004
   ; k% Z2 Y* z0 P+ K& n8 `
5. #define    DEM_CR    *(uint32_t*)0xE000EDFC
   
6. 
   
7. //定义需使能位
   
8. #define    DEM_CR_TRCENA    (1<<24)
   
9. #define    DWT_CR_CYCCNTENA    (1<<0)
   
10. 
    
11. //DWT init
    0 N6 T2 B' R& W- b( f9 W
12. void DWT_init(void)
    7 _: V1 z( ^& F- [
13. {
    $ |4 a1 Y! K: Z6 Q4 u. x
14.   DEM_CR |= (uint32_t)DEM_CR_TRCENA;
    3 |0 m: y7 o/ z3 u+ [8 [5 B. |
15.   DWT_CYCCNT = (uint32_t)0u;
    9 l3 L" f4 j: i; U- K
16.   DWT_CR |= (uint32_t)DWT_CR_CYCCNTENA;
    
17. }
    
18. //get DWT count
    " x6 `, G# v! e7 P
19. uint32_t DWT_TS_GET(void)
    7 A/ z  C: Z; h7 I' i6 g# I
20. {
    
21.   return((uint32_t)DWT_CYCCNT);
    
22. }

复制代码

04代码
/ P6 f! _8 l0 x" S3 v& {

( z% Z- H3 d) O' S" D. f从上文我们得知，我们已经获得了一个32位向上累加的计数器，溢出会自动清零并累加，频率是系统主频。那么我们简单封装下，就可以实现延时函数。以下代码在120Mhz的STM32F207测试。
% p0 N5 ?8 I; Q# v; }& l) ]

1. 
   1 C+ C9 B& O3 o4 D* S5 f
2. //使用DWT延时time_ms毫秒
   
3. void DWT_Delay_Ms(uint32_t time_ms)
   ) o$ @6 \4 B8 G" Z9 a% [) `& s4 ?$ `
4. {
   
5.   uint32_t old_counter,current_counter;
   
6.   uint32_t delay_ms;
   
7.   
   2 U" ~& R& e& S6 Y8 S
8.   old_counter = DWT_TS_GET();
   + ?" _; V! Q* L7 t. y  \
9.   current_counter = DWT_TS_GET();
   
10.   delay_ms = 0;
    ! |# b$ `2 L* m$ d& G
11.   while(delay_ms<time_ms)
    
12.   {
    
13.     current_counter = DWT_TS_GET();
    + b. m/ P9 @9 V  u+ L
14.     if(current_counter > old_counter)
    
15.       delay_ms = (current_counter - old_counter)/(SystemCoreClock/1000);
    ) C+ l, `# i6 f. r8 F
16.     else
    ' k5 g) C4 G0 Y* _
17.       delay_ms = (current_counter + 0XFFFFFFFF - old_counter)/(SystemCoreClock/1000);
    
18.   }
    4 j9 G  n  B5 f" ^1 L
19. }

复制代码

使用之前的文章《如何测量代码运行时间》测量延时函数是否准确。
+ q: c2 z0 o( N4 g, [  `

1. 
   4 D4 H6 B  V9 E9 O" {: Q
2. DWT_Delay_Ms(100);//延时100ms
   1 c( o5 a' \- Z- o( p5 a7 ~
3. time_ms=Time_Difference_ms();

复制代码

如下图，延时函数精确延时，没有问题

" n8 y! N! F* n" M- b实现测量代码运行时长的函数接口
1 a& l7 n/ K, l! ^

1. 
   9 T: ~' q. v* A$ Y) k5 a& T3 D
2. //使用DWT测量函数运行时间
   . v- W3 h# n1 q# L
3. float DTW_Time_Difference_ms(void)
   ! a% d) Z0 m2 t; D
4. {
   
5.   static uint32_t old_counter;
   8 ?! p* U- q5 N8 d0 e3 w
6.   uint32_t counter,couter_current;
   
7.   couter_current = DWT_TS_GET();
   8 A6 Q( \$ O. g# m7 `
8.   if(couter_current > old_counter)
   5 S$ ?( `+ X; B6 m
9.     counter = couter_current - old_counter;
   1 g% k# J  ~2 s$ u( }
10.   else
    
11.     counter = couter_current + 0XFFFFFFFF - old_counter;
    
12.   old_counter = couter_current;
    
13.   return (counter / (SystemCoreClock/1000));
    
14. }

复制代码

使用之前的文章《STM32延时函数的四种方法》精确延时，然后使用DWT测量延时时间。

1. delay_ms(300);//延时300ms
   1 h9 |4 x6 v$ e, |3 r; R. l6 j- e
2. time_ms=DTW_Time_Difference_ms();

复制代码

05后记


本文使用DWT代替了定时器部分功能，它的优缺点如下：
+ U* C1 K4 ?- `, s; n3 s- \4 _
. ]! l$ ]& E0 M7 r6 ~
1、优点是：方便移植，经过测试在M3、M4、M7内核的MCU上都可以使用。
* e( e2 R/ j( r
/ |, W% m) x1 Z
& C( \/ P3 a* _, d" E2、缺点是：和定时器一样，都有一个延时的最大时间，测量代码运行时间的最大值。


如果项目使用MCU有空闲的定时器，且不考虑换MCU的话，我个人建议还是使用通用的定时器外设，不要使用DWT，虽然DWT方便移植，但通用定时器外设简单易懂，对于没有了解过这部分知识的小白，看到DWT的延时函数，还需要学**。
; D( y- V4 d! m1 k# A: y
4 r+ q0 u$ X6 d) ^8 F, G# [

# p6 S4 j: G/ ^" K- O# q1 x5 C
" g7 |( f1 o+ ]5 a" ?# J5 r0 @