背景
3 G$ q% {3 j( I1 g延时函数在STM32单片机开发的项目中有广泛的应用,微秒级延时在一些时间要求严格的场景下(例如软件模拟I2C通讯)是必不可少的。由于FreeRTOS默认采用了system tick作为时间片分配的时基定时器,可能与利用system tick设计的延时函数出现冲突。再加上FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )最小的延时时间等于FreeRTOS的tick时间(一般设置为1ms),因此需要重新设计一套不基于system tick的微秒级延时函数。利用CM3/4内核中的数据观察点与跟踪(DWT)寄存器,可以在不占用硬件外设定时器的情况下实现微秒级的精准延时。
& B- n7 X& D, F6 U$ T
* Z/ `& w: A+ }3 g源码0 T& N/ l$ e( t( `( y4 d
通过选择#define USE_SYS_TICK, #define USE_DWT, #define USE_NOP_DELAY其中一个宏定义来决定delay函数的实现方式。需要特别注意的是,由于函数调用是需要时间的,因此使用延时函数时,一般会额外多出一些时间(1微秒左右)。1 s" w6 `2 v8 S8 S( K
+ M& w- Z# |+ E5 y- W3 ]
#define USE_SYS_TICK是利用system tick设计的延时函数,在没有使用实时操作系统的时候,它是一个比较适合实现微秒级延时的通用方法。
3 u7 g7 x( Z9 H8 T* f& G#define USE_DWT是利用CM3/4内核DWT寄存器设计的延时函数,它具有不占用system tick与外设定时器,延时精度高的特点。
& ?. N% ^4 c1 d5 f) l- N#define USE_NOP_DELAY是利用了空指令设计的延时函数,它主要实现微秒以下的超短时间延时。
7 y( Q# u3 O# L, R头文件. E- X# o/ m: f# J. c
- #ifndef __DELAY_H__
4 K W0 b$ C7 Q0 n8 h - #define __DELAY_H__
4 O5 {$ n) v$ e. w- m: T - ; A5 U9 O; z) X# z! l7 L2 K. a+ Z
- #include "stm32f10x_conf.h"
- d9 @1 |) ~2 B0 X - #include "stm32f10x.h"
* ?! f; Q& s, z) m1 S! N9 Q9 w - 6 r+ O5 I7 N( {" \) F, m
- //#define USE_SYS_TICK( J' X. D- t5 Y' V7 y5 Y
- #define USE_DWT& l( Z+ k0 @! [, r3 W- D; Y4 B1 Y
- //#define USE_NOP_DELAY+ R+ h- w9 Y# [% f+ D4 F) p) r9 l
- B g5 s. Z7 f- void delay_init(void);) s7 M8 c, x! c0 j; Z3 ~
- void delay_ms(uint16_t ms);
$ F# ?, @2 O- M$ r - void delay_us(u32 us);1 ]( o+ Z8 E; J
- * R8 u7 X9 ?( f! k. x
- /**5 ~ B: j1 _4 @4 `& F) `
- * 定义ns级延时,72M主频下,每一条空指令大约14ns0 R2 x0 {4 A9 h% n& t4 a& t
- */! E. \4 [$ S' g
- //#define DELAY_6ns() __NOP()+ H- z2 Q% C, @5 l
- //#define DELAY_12ns() DELAY_6ns(); __NOP()
5 i$ k+ L/ [& b& F: X0 l - //#define DELAY_18ns() DELAY_12ns(); __NOP()
/ x }. C9 S8 |8 y8 V) Q - //#define DELAY_24ns() DELAY_18ns(); __NOP()9 [+ G, E8 j1 z0 N
- //#define DELAY_30ns() DELAY_24ns(); __NOP()
) B- Y/ L% m2 B; v& F1 r - //#define DELAY_60ns() DELAY_30ns(); DELAY_30ns()
3 j9 {: A7 T# [7 {, Q& }' N/ S; E - //#define DELAY_90ns() DELAY_60ns(); DELAY_30ns()
5 c. j8 E1 |+ h3 J1 Y/ f2 T
1 c( v! @5 m6 l$ Y4 q0 ?- * ? F, X2 v. z7 r. G( O* ~: P( x" G
- #endif2 `4 ]9 i6 @% v P; ]
- % ?! e4 A, m6 ?/ A' f
复制代码 : O- h" x1 S& \% [" s r5 i
源文件
9 _8 L3 [; M) t5 r+ b/ q) u- #include "delay.h"6 z. P: K$ H8 G* {1 d9 I& E' |
e7 D) ^6 @5 G) Y8 Z8 S3 Q3 v4 B- #ifdef USE_SYS_TICK0 r l! Q; f4 T4 Y; s& W' Y
8 a& ~$ J* ^# g2 F' |- static uint8_t fac_us = 0; //us延时倍乘数7 `5 G$ ^ n& _3 V/ u0 ?& s, ^
- static uint16_t fac_ms = 0; //ms延时倍乘数,在ucos下,代表每个节拍的ms数$ Y3 v/ i# E, z
- X9 K! E* ~ h" Q- //初始化延迟函数
3 X1 K0 m2 P3 c" p' T j G - //当使用OS的时候,此函数会初始化OS的时钟节拍+ y/ i; E% m; d" [" Y5 Z6 r: u
- //SYSTICK的时钟固定为HCLK时钟的1/81 \2 O g! v2 q9 d. y
- //SYSCLK:系统时钟
E0 H& u/ w8 u" K& v( K6 ] - void delay_init()
1 E X" S/ y. k' R5 q - {0 N! F" ~9 q9 G7 W. h8 L' C
- SysTick_CLKSourceConfig ( SysTick_CLKSource_HCLK_Div8 ); //选择外部时钟 HCLK/8& P; [; c9 [3 b: \ n0 M) c# j9 t% ^
- fac_us = SystemCoreClock / 8000000; //为系统时钟的1/8$ Y( |9 ^) ?& P3 A+ W. r) V) d
- fac_ms = ( uint16_t ) fac_us * 1000; //非OS下,代表每个ms需要的systick时钟数; ^2 s+ ^# k2 v7 }' @. H0 g! z, I
- }: q& ?1 t# [* M$ R+ z _
( Z4 z& s+ K' i' Y! I, E- //延时nus% o9 w$ U+ q7 M7 [( J7 X
- //nus为要延时的us数.
7 c* o& [8 `3 h' M X) R: Z+ ? - void delay_us ( u32 us )
2 h+ B f; n1 d3 H& Q! Y% l2 ? - {' @" V! u- y1 a
- u32 temp;, @& r" V5 z$ n1 Y1 ~& o0 N& U7 K
- SysTick->LOAD = us * fac_us; //时间加载
* D% f* S" U0 g. ?. u G! D9 a" L - SysTick->VAL = 0x00; //清空计数器; F3 l3 a" |+ o* p* [
- SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ; //开始倒数1 n" ?: W+ a0 r; Z7 c2 h4 @
- ) x/ q+ c7 @7 g4 ?
- do `+ k: m: G" p% Z
- {
& l5 B' S- C& R2 j9 a# ~ - temp = SysTick->CTRL;
`7 G& f4 p- R a. x/ }4 ~, \ - }
% a* Y/ q* _" Z1 V - while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达3 f7 A9 w' T0 J! i7 A
- 2 S s: v) a1 Q- _3 Q
- SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; //关闭计数器
8 V/ A, c: R+ X1 [; t - SysTick->VAL = 0X00; //清空计数器
, P' D9 W- n' ?5 A' y$ D - }) R4 t1 R; g: K: o
- //延时nms
+ U* T5 i3 D* ^& c" H: g - //注意nms的范围
1 F. p; z' x4 k - //SysTick->LOAD为24位寄存器,所以,最大延时为:
7 o+ f5 W+ v; O- L - //nms<=0xffffff*8*1000/SYSCLK' Y w9 L; C. y1 W+ U; D. J7 P' N
- //SYSCLK单位为Hz,nms单位为ms. Z' ~% G9 R6 S7 s
- //对72M条件下,nms<=18646 r0 _, p1 b7 z9 l8 G8 w- {
- void delay_ms ( uint16_t ms )* B! W1 _" N$ q+ o9 W
- {
, j2 B1 h8 y1 q9 W8 k- M+ \* v - u32 temp;: \ p' J% O$ @2 y
- SysTick->LOAD = ( u32 ) ms * fac_ms; //时间加载(SysTick->LOAD为24bit)6 Y- s9 [/ y$ ]) _- g
- SysTick->VAL = 0x00; //清空计数器+ F% F: W- _2 T; ~& q/ F; C3 _
- SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ; //开始倒数& m% o0 |4 H! g& R7 A2 G
1 X6 F/ D8 r/ @- e3 F) g- do
& O/ \' i1 y6 l/ S - {
. J7 K' B4 g1 m' y$ Z, E: `2 o - temp = SysTick->CTRL;& y) X- ^ e& `. K' u% V: }
- }
6 e0 q1 i& i- i$ d - while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达7 e1 C) o3 q7 j" r0 z& m
- 9 c- g6 c8 Q& r
- SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; //关闭计数器
4 T* ^( M7 c$ k5 [1 _1 _ - SysTick->VAL = 0X00; //清空计数器% }; d& i, u/ x- R7 M+ a
- }
5 W0 b+ M6 V0 v$ B - 7 F: h5 n8 V Z, r2 d. G
- #elif defined USE_DWT* v+ t; D6 X o7 L8 w1 Z' k
6 c3 M, |5 m2 O, c: w2 P( T0 f- // 0xE000EDFC DEMCR RW Debug Exception and Monitor Control Register.& a! H; Z- L% A% v J" ~
- #define DEMCR ( *(__IO uint32_t *)0xE000EDFC )$ b# T' U" S) u8 X/ Q9 K) S# O
- #define TRCENA ( 0x01 << 24) // DEMCR的DWT使能位9 Z: h- ], Z V6 ?# ?
5 L1 d" K, o, l3 u! W0 x: k/ ]- #define DBGMCU_CR *(__IO uint32_t *)0xE0042004 //MCU调试模块控制寄存器,详细内容参考《stm32中文参考手册》调试支持(DBG)章节,747页
! G! _! p5 c/ f+ g+ L7 S7 r& n- M& n - c) B( H+ ~" `) c
- // 0xE0001000 DWT_CTRL RW The Debug Watchpoint and Trace (DWT) unit: h* `% C- A( z( a$ g5 y
- #define DWT_CTRL ( *(__IO uint32_t *)0xE0001000 )! O: C1 X6 V) Y
- #define DWT_CTRL_CYCCNTENA ( 0x01 << 0 ) // DWT的SYCCNT使能位
0 o' N- g7 z3 M; Q+ n
8 D( J& j, k2 M1 t8 d- // 0xE0001004 DWT_CYCCNT RW Cycle Count register,( x" I# S0 J7 a
- #define DWT_CYCCNT ( *(__IO uint32_t *)0xE0001004) // 显示或设置处理器的周期计数值
( e3 h5 G+ I/ f& }. w7 J
}% n; G9 ]2 t+ t' |* j8 ?8 [% p- //#define DWT_DELAY_mS(mSec) DWT_DELAY_uS(mSec*1000)
4 u" O. T) A5 H+ v - 9 M0 t( |; B$ [! t
- void delay_init()7 ]1 h0 _. N! y8 O- u6 K6 L* n8 d. X
- {9 C* _0 P$ ^2 K/ V8 K1 d( \
- //使能DWT外设
9 T( n- T' @4 m. z( s) z5 ~ - DEMCR |= (uint32_t)TRCENA;5 F, y. A3 P/ p6 `4 C# v
" Q$ s9 @3 X8 `- //DWT CYCCNT寄存器计数清0! F$ h$ }/ X$ j7 |/ h
- DWT_CYCCNT = (uint32_t)0u;% C; I3 U+ M- G+ \( i! K1 G
. Y+ L, A! p/ c) b, f7 [- //使能Cortex-M3 DWT CYCCNT寄存器
, e- w# l$ S+ L4 K. O, m - DWT_CTRL |= (uint32_t)DWT_CTRL_CYCCNTENA;
2 t4 u; y6 |( V0 M- N' D - }3 j/ a. g) p6 q
- ; f5 W, j2 [8 Q8 ?- T
+ j+ c' a' D* G H# U- // 微秒延时
- Q$ S! o C9 f* i" Y% D - void delay_us(uint16_t uSec)" ]# ^. c. V4 k5 Y, g- J
- { A0 H& Z% A- K- m0 x" m7 I
- if(uSec > 10000) uSec = 10000;
! c8 A2 t+ y2 H
2 P5 q% p6 I0 y/ h1 [- uint32_t ticks_start, ticks_end, ticks_delay;
5 T3 Z* i! [+ q5 ?" N: h - " r+ h3 E# P4 H1 D. ~$ i' N+ C
- ticks_start = DWT_CYCCNT;- b# d5 G+ E2 _4 z' V5 B/ ?, E! ~
- ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数+ J% G" V- e8 o* k+ X
- ticks_end = ticks_start + ticks_delay;
2 P) Y8 q) F* A' |
4 N7 Z3 T' w" j! h- // ticks_end没有溢出
' u" I% A9 t/ E1 X- q# j; R6 V - if ( ticks_end >= ticks_start ) X, M: t0 l# k' ?9 w7 m l
- {9 z3 W( P; b k
- // DWT_CYCCNT在上述计算的这段时间中没有溢出" b1 E* a/ @! o( n% k
- if(DWT_CYCCNT > ticks_start)1 M# \5 a8 N* ?) g
- {9 W1 R/ S& }8 N$ R! x- U& C; Y
- while( DWT_CYCCNT < ticks_end );% B% }" V, R* S+ c
- }- Z* b8 |- y8 Q
- // DWT_CYCCNT溢出& \! ?! o1 B1 T9 ?# x. ]) T
- else
' C& K3 R" a7 ^4 U. U/ ~, T2 x - {
% T* c- Z, v6 Z- E- J a/ I; N - // 已经超时,直接退出# ?5 [& I! |5 G. k; h8 s
- return;
V/ M3 c4 z3 Z' R6 H; V8 X( p - }
0 F2 t2 N* U3 V% N - }# V4 S# d' l# p1 o( {! o! K
- else // ticks_end溢出
9 t l' g+ [7 w. F ? - {% j9 N) L" I+ q5 ]( W
- // DWT_CYCCNT在上述计算的这段时间中没有溢出, l% B3 g) ^5 _# f2 M9 {! l
- if(DWT_CYCCNT > ticks_start)
+ X% w% J0 R8 T/ T9 i/ D. H/ e/ e8 h - {+ ?) Z+ r" b1 S! u' X
- // 等待DWT_CYCCNT的值溢出( ?2 J" I% a7 n% m/ Q: U
- while( DWT_CYCCNT > ticks_end );
8 |/ ], `3 U9 Y$ l' \, G, z) X( ~ - }
1 V2 R3 D% b- a4 c0 C; N - // 等待溢出后的DWT_CYCCNT到达ticks_end
) C" ?; E" l) E; g8 E- z - while( DWT_CYCCNT < ticks_end );1 D' ` e$ ]6 q( k# K! ?) y; u
- } s- b1 ^* j3 ]
- }% x" y( Z- E, X% R
- 6 y; m! B& Z* ], n# e& c4 Y
- void delay_ms(uint16_t ms)7 q- B( p4 [4 q5 R/ B9 \
- {8 i7 z4 N) ~- G0 ~% B; D) A
- for(uint16_t i = 0; i < ms; i++)1 k5 J/ V" z3 ~# x; u7 B
- {
: j. y8 ]" p9 [1 H/ |1 ^1 O( N - // delay 1 ms
* M; s7 p% l, a. ?. T4 _ - delay_us(1000);7 X# n( G; _& ]( S* y2 ]
- }8 [& }/ }8 d7 L
- }+ Y( N) ~, O; v- I( L- I) _6 S
' w+ k; }3 V9 N2 y# {! j& x- #elif defined USE_NOP_DELAY8 g* ~/ g9 J4 |" Y
- * D( {4 o, v' R$ r- a
- void delay_init(void)
# R' M7 W& ]: f# s. H* z! ~ - {1 B, M7 a! n" J8 q* W" `
- ) e) o4 L$ O, _9 ?& v$ K
- }
, C5 R; ?0 z+ C" r4 F) c* Y - 9 {( _( G1 A# }- \# G% p5 s
- void delay_ms(uint16_t ms)
! i- x7 @' a. a( @& s0 S - {
- p3 z3 {* I; c" G4 x: } - ' @4 q% o* O" X* p
- }4 M. D" \* N a8 c6 c
2 h: P) U' F ]5 [) A- void delay_us(u32 us)( o/ F# }/ V& }4 D- ^/ u; C2 y# ^
- {; U \5 f( P$ U; F
- # b, {$ l' P( V
- }
+ U0 K# B: F% s1 ? - ' C- U# [, \$ n& P& W8 y
- #else
% N' r( I3 m) T0 N) r; d! t3 Z# b - . C- e/ D- g e0 R5 K9 k( F
- #endif
复制代码 7 v6 s9 J4 ?+ K' A
特别说明
i1 v7 M7 K7 h3 [6 ]: r, V使用DWT内核的延时函数中,涉及了两次数据溢出处理,第一次数据溢出处理是指计算结束时间(ticks_end = ticks_start + ticks_delay)发生溢出,如下图所示:3 J$ q4 I0 V' g' L$ X
2 E" ]8 P) O9 I1 ?
这里有个限制条件就是延时长度(ticks_delay)不能超过uint32_t的最大值,但考虑到这是一个极大的数值,几乎不可能发生,因此可以简化处理限制微秒延时函数的输入参数小于10k,以提高延时精度。对于这个溢出判断就比较明确了:. T- c7 I$ |& z q/ J% o% k
% \" n1 [' r; S J( T- if ( ticks_end >= ticks_start )
- Y5 `5 H! p+ ]* K - {
6 x5 t+ v/ ]/ V6 _# c - // 计算未溢出
, ~: d- C9 ^" j- E' G& x# ~; V1 b - }1 J2 L2 N; W+ S2 e6 J
- else : o8 M$ H: q! r& l5 o
- {
: q2 z. R/ ? Q$ q+ a2 n! R" k) Q$ Z - // 计算溢出
( n# o& E; d0 Y5 \4 E# y+ | - }
复制代码 + F; N2 W) `) B( F
第二个溢出相对比较复杂,处理不当会导致严重问题,尤其是使用了RTOS的系统中有很可能遇到。其核心原因是从标记初始化时间戳ticks_start = DWT_CYCCNT到准备比较时间戳例如while( DWT_CYCCNT < ticks_end );的这段时间的耗时是不确定的。即使没有使用RTOS,如下代码(使用绿色底色标注)在执行时也可能被硬中断暂停,从而导致DWT_CYCCNT时间戳可能已经越过了ticks_end ,或者也发生了溢出重置。+ Q3 `6 a$ ^* n. G) q2 B9 D
+ S+ |: z: g) r0 {4 u1 I' u
- ticks_start = DWT_CYCCNT;& m3 _" |2 A; ]- u
- ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数4 c; P: F; k+ U- n
- ticks_end = ticks_start + ticks_delay;
2 C7 z( X: v! U4 f% z6 C
V; T% Q2 Y* W) ?- if ( ticks_end >= ticks_start ). k8 w( g! Y: f5 @0 _! }' J* L
- {
# n; J) `. [ n; m - // DWT_CYCCNT在上述计算的这段时间中没有溢出7 P' o0 _, B3 r0 O* J
- if(DWT_CYCCNT > ticks_start)
6 E* H( [% B3 ?6 H& [ - {
2 Y' D' e+ f' j+ Q5 Y5 e" Q+ V - 3 g8 c7 J% ^4 ~, c
- }
" L, K/ ?" U, `0 s6 c. E1 m - else- [! i! d: H& c8 w- ?, \" p& H" L
- {
& J3 r, p/ R2 B& N6 _, f -
; C4 V2 V& F' v- |3 M) S; I - }% A5 ~/ U# v* ]- G1 K
- }. [4 }$ n& f0 C; V
- else
8 x% ~2 b) F: s& G6 {/ u - {0 [+ d& R8 \4 P" s
- // DWT_CYCCNT在上述计算的这段时间中没有溢出) m Y8 b# h# a0 A" y+ W, K
- if(DWT_CYCCNT > ticks_start)
$ x+ u; s9 l* Z - {
' U2 T0 X% Y6 X* H& t
+ [6 C9 G! y7 V- }" Z3 `. ]; a" X# A$ ]$ x
- else/ d# D3 ~( y* G7 O+ d4 N" K* O% t* _
- {; Q1 X1 [3 a, h. K/ a
-
5 U( i% s1 L) a9 S - }, }1 @% {0 a) r! g9 D& ?4 a' {2 @8 [1 ]
- }
复制代码 ) F8 @; O) G( a6 K. j
因此需要根据延时等待操作时DWT_CYCCNT所处位置再进行一次判断:
9 A2 }1 l' y s+ O8 f* Q, w# T$ O \: ~8 W
2 d" [/ j$ E! I, o" A1 b: ~1 m9 m( K$ Z2 f7 J) F" i" a% a% `
ticks_end未溢出时(ticks_end1):! u: N" o! K9 P6 N2 ]* ^
DWT_CYCCNT未溢出(DWT_CYCCNT2 & DWT_CYCCNT3)时:while( DWT_CYCCNT < ticks_end );) m) M+ ^1 E+ F# P& `
DWT_CYCCNT溢出(DWT_CYCCNT4)时:直接返回。
1 z g" g, L6 p) i: Y+ mticks_end溢出时(ticks_end2):+ }- v o. T! e0 h! f
DWT_CYCCNT未溢出(DWT_CYCCNT2)时:while( DWT_CYCCNT > ticks_end ); while( DWT_CYCCNT < ticks_end );5 Z7 T+ F. ]6 W. i
DWT_CYCCNT溢出(DWT_CYCCNT4 & DWT_CYCCNT5)时:while( DWT_CYCCNT < ticks_end );
* F9 q0 f7 Z k. B3 U- Y2 C! P0 i; L- H
$ o( h. Z3 l+ w7 |; E* B
% g5 u Z: i9 ]使用指南5 `* p) q) N0 f1 J% h- @6 w
在程序开始的地方初始化延时函数:delay_init();
* ?1 M2 I P/ j( V; r5 T4 C' p在需要延时的地方调用延时函数:delay_us(10);
9 p4 ?' e6 K; F; K2 I需要特别说明的是,在FreeRTOS的任务中调用本文介绍的例如void delay_us(uint32_t us)等延时函数,任务会阻塞等待延时结束。如果是调用FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay ),系统会执行低优先级任务直到延时结束。. O1 A. D- h* q' t
' J7 D: J, ^) {4 V1 R& W9 U- b8 ~, u! }( @/ W* J7 ^: ]
* G. E5 F' C8 o3 Q1 p( v5 g
|