你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32开发项目:微秒级的精准延时 - 使用system tick/DWT寄存器/NOP命令

[复制链接]
STMCU小助手 发布时间:2022-4-13 11:00
背景
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
  1. #ifndef __DELAY_H__
    4 K  W0 b$ C7 Q0 n8 h
  2. #define __DELAY_H__                           
    4 O5 {$ n) v$ e. w- m: T
  3. ; A5 U9 O; z) X# z! l7 L2 K. a+ Z
  4. #include "stm32f10x_conf.h"
    - d9 @1 |) ~2 B0 X
  5. #include "stm32f10x.h"
    * ?! f; Q& s, z) m1 S! N9 Q9 w
  6. 6 r+ O5 I7 N( {" \) F, m
  7. //#define USE_SYS_TICK( J' X. D- t5 Y' V7 y5 Y
  8. #define USE_DWT& l( Z+ k0 @! [, r3 W- D; Y4 B1 Y
  9. //#define USE_NOP_DELAY+ R+ h- w9 Y# [% f+ D4 F) p) r9 l

  10. - B  g5 s. Z7 f
  11. void delay_init(void);) s7 M8 c, x! c0 j; Z3 ~
  12. void delay_ms(uint16_t ms);
    $ F# ?, @2 O- M$ r
  13. void delay_us(u32 us);1 ]( o+ Z8 E; J
  14. * R8 u7 X9 ?( f! k. x
  15. /**5 ~  B: j1 _4 @4 `& F) `
  16. * 定义ns级延时,72M主频下,每一条空指令大约14ns0 R2 x0 {4 A9 h% n& t4 a& t
  17. */! E. \4 [$ S' g
  18. //#define DELAY_6ns()                                        __NOP()+ H- z2 Q% C, @5 l
  19. //#define DELAY_12ns()                                DELAY_6ns(); __NOP()
    5 i$ k+ L/ [& b& F: X0 l
  20. //#define DELAY_18ns()                                DELAY_12ns(); __NOP()
    / x  }. C9 S8 |8 y8 V) Q
  21. //#define DELAY_24ns()                                DELAY_18ns(); __NOP()9 [+ G, E8 j1 z0 N
  22. //#define DELAY_30ns()                                DELAY_24ns(); __NOP()
    ) B- Y/ L% m2 B; v& F1 r
  23. //#define DELAY_60ns()                                DELAY_30ns(); DELAY_30ns()
    3 j9 {: A7 T# [7 {, Q& }' N/ S; E
  24. //#define DELAY_90ns()                                DELAY_60ns(); DELAY_30ns()
    5 c. j8 E1 |+ h3 J1 Y/ f2 T

  25. 1 c( v! @5 m6 l$ Y4 q0 ?
  26. * ?  F, X2 v. z7 r. G( O* ~: P( x" G
  27. #endif2 `4 ]9 i6 @% v  P; ]
  28. % ?! e4 A, m6 ?/ A' f
复制代码
: O- h" x1 S& \% [" s  r5 i
源文件
9 _8 L3 [; M) t5 r+ b/ q) u
  1. #include "delay.h"6 z. P: K$ H8 G* {1 d9 I& E' |

  2.   e7 D) ^6 @5 G) Y8 Z8 S3 Q3 v4 B
  3. #ifdef USE_SYS_TICK0 r  l! Q; f4 T4 Y; s& W' Y

  4. 8 a& ~$ J* ^# g2 F' |
  5. static uint8_t  fac_us = 0;                          //us延时倍乘数7 `5 G$ ^  n& _3 V/ u0 ?& s, ^
  6. static uint16_t fac_ms = 0;                          //ms延时倍乘数,在ucos下,代表每个节拍的ms数$ Y3 v/ i# E, z

  7. - X9 K! E* ~  h" Q
  8. //初始化延迟函数
    3 X1 K0 m2 P3 c" p' T  j  G
  9. //当使用OS的时候,此函数会初始化OS的时钟节拍+ y/ i; E% m; d" [" Y5 Z6 r: u
  10. //SYSTICK的时钟固定为HCLK时钟的1/81 \2 O  g! v2 q9 d. y
  11. //SYSCLK:系统时钟
      E0 H& u/ w8 u" K& v( K6 ]
  12. void delay_init()
    1 E  X" S/ y. k' R5 q
  13. {0 N! F" ~9 q9 G7 W. h8 L' C
  14.         SysTick_CLKSourceConfig ( SysTick_CLKSource_HCLK_Div8 ); //选择外部时钟  HCLK/8& P; [; c9 [3 b: \  n0 M) c# j9 t% ^
  15.         fac_us = SystemCoreClock / 8000000;         //为系统时钟的1/8$ Y( |9 ^) ?& P3 A+ W. r) V) d
  16.         fac_ms = ( uint16_t ) fac_us * 1000;             //非OS下,代表每个ms需要的systick时钟数; ^2 s+ ^# k2 v7 }' @. H0 g! z, I
  17. }: q& ?1 t# [* M$ R+ z  _

  18. ( Z4 z& s+ K' i' Y! I, E
  19. //延时nus% o9 w$ U+ q7 M7 [( J7 X
  20. //nus为要延时的us数.
    7 c* o& [8 `3 h' M  X) R: Z+ ?
  21. void delay_us ( u32 us )
    2 h+ B  f; n1 d3 H& Q! Y% l2 ?
  22. {' @" V! u- y1 a
  23.         u32 temp;, @& r" V5 z$ n1 Y1 ~& o0 N& U7 K
  24.         SysTick->LOAD = us * fac_us;               //时间加载
    * D% f* S" U0 g. ?. u  G! D9 a" L
  25.         SysTick->VAL = 0x00;                        //清空计数器; F3 l3 a" |+ o* p* [
  26.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数1 n" ?: W+ a0 r; Z7 c2 h4 @
  27. ) x/ q+ c7 @7 g4 ?
  28.         do  `+ k: m: G" p% Z
  29.         {
    & l5 B' S- C& R2 j9 a# ~
  30.                 temp = SysTick->CTRL;
      `7 G& f4 p- R  a. x/ }4 ~, \
  31.         }
    % a* Y/ q* _" Z1 V
  32.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达3 f7 A9 w' T0 J! i7 A
  33. 2 S  s: v) a1 Q- _3 Q
  34.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    8 V/ A, c: R+ X1 [; t
  35.         SysTick->VAL = 0X00;                         //清空计数器
    , P' D9 W- n' ?5 A' y$ D
  36. }) R4 t1 R; g: K: o
  37. //延时nms
    + U* T5 i3 D* ^& c" H: g
  38. //注意nms的范围
    1 F. p; z' x4 k
  39. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    7 o+ f5 W+ v; O- L
  40. //nms<=0xffffff*8*1000/SYSCLK' Y  w9 L; C. y1 W+ U; D. J7 P' N
  41. //SYSCLK单位为Hz,nms单位为ms. Z' ~% G9 R6 S7 s
  42. //对72M条件下,nms<=18646 r0 _, p1 b7 z9 l8 G8 w- {
  43. void delay_ms ( uint16_t ms )* B! W1 _" N$ q+ o9 W
  44. {
    , j2 B1 h8 y1 q9 W8 k- M+ \* v
  45.         u32 temp;: \  p' J% O$ @2 y
  46.         SysTick->LOAD = ( u32 ) ms * fac_ms;       //时间加载(SysTick->LOAD为24bit)6 Y- s9 [/ y$ ]) _- g
  47.         SysTick->VAL = 0x00;                        //清空计数器+ F% F: W- _2 T; ~& q/ F; C3 _
  48.         SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk ;  //开始倒数& m% o0 |4 H! g& R7 A2 G

  49. 1 X6 F/ D8 r/ @- e3 F) g
  50.         do
    & O/ \' i1 y6 l/ S
  51.         {
    . J7 K' B4 g1 m' y$ Z, E: `2 o
  52.                 temp = SysTick->CTRL;& y) X- ^  e& `. K' u% V: }
  53.         }
    6 e0 q1 i& i- i$ d
  54.         while ( ( temp & 0x01 ) && ! ( temp & ( 1 << 16 ) ) ); //等待时间到达7 e1 C) o3 q7 j" r0 z& m
  55. 9 c- g6 c8 Q& r
  56.         SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;  //关闭计数器
    4 T* ^( M7 c$ k5 [1 _1 _
  57.         SysTick->VAL = 0X00;                        //清空计数器% }; d& i, u/ x- R7 M+ a
  58. }
    5 W0 b+ M6 V0 v$ B
  59. 7 F: h5 n8 V  Z, r2 d. G
  60. #elif defined USE_DWT* v+ t; D6 X  o7 L8 w1 Z' k

  61. 6 c3 M, |5 m2 O, c: w2 P( T0 f
  62. // 0xE000EDFC DEMCR RW Debug Exception and Monitor Control Register.& a! H; Z- L% A% v  J" ~
  63. #define DEMCR           ( *(__IO uint32_t *)0xE000EDFC )$ b# T' U" S) u8 X/ Q9 K) S# O
  64. #define TRCENA          ( 0x01 << 24) // DEMCR的DWT使能位9 Z: h- ], Z  V6 ?# ?

  65. 5 L1 d" K, o, l3 u! W0 x: k/ ]
  66. #define  DBGMCU_CR   *(__IO uint32_t *)0xE0042004                        //MCU调试模块控制寄存器,详细内容参考《stm32中文参考手册》调试支持(DBG)章节,747页
    ! G! _! p5 c/ f+ g+ L7 S7 r& n- M& n
  67.   c) B( H+ ~" `) c
  68. // 0xE0001000 DWT_CTRL RW The Debug Watchpoint and Trace (DWT) unit: h* `% C- A( z( a$ g5 y
  69. #define DWT_CTRL        ( *(__IO uint32_t *)0xE0001000 )! O: C1 X6 V) Y
  70. #define DWT_CTRL_CYCCNTENA       ( 0x01 << 0 ) // DWT的SYCCNT使能位
    0 o' N- g7 z3 M; Q+ n

  71. 8 D( J& j, k2 M1 t8 d
  72. // 0xE0001004 DWT_CYCCNT RW Cycle Count register,( x" I# S0 J7 a
  73. #define DWT_CYCCNT      ( *(__IO uint32_t *)0xE0001004) // 显示或设置处理器的周期计数值
    ( e3 h5 G+ I/ f& }. w7 J

  74.   }% n; G9 ]2 t+ t' |* j8 ?8 [% p
  75. //#define DWT_DELAY_mS(mSec)    DWT_DELAY_uS(mSec*1000)
    4 u" O. T) A5 H+ v
  76. 9 M0 t( |; B$ [! t
  77. void delay_init()7 ]1 h0 _. N! y8 O- u6 K6 L* n8 d. X
  78. {9 C* _0 P$ ^2 K/ V8 K1 d( \
  79.         //使能DWT外设
    9 T( n- T' @4 m. z( s) z5 ~
  80.         DEMCR |= (uint32_t)TRCENA;5 F, y. A3 P/ p6 `4 C# v

  81. " Q$ s9 @3 X8 `
  82.         //DWT CYCCNT寄存器计数清0! F$ h$ }/ X$ j7 |/ h
  83.         DWT_CYCCNT = (uint32_t)0u;% C; I3 U+ M- G+ \( i! K1 G

  84. . Y+ L, A! p/ c) b, f7 [
  85.         //使能Cortex-M3 DWT CYCCNT寄存器
    , e- w# l$ S+ L4 K. O, m
  86.         DWT_CTRL |= (uint32_t)DWT_CTRL_CYCCNTENA;
    2 t4 u; y6 |( V0 M- N' D
  87. }3 j/ a. g) p6 q
  88. ; f5 W, j2 [8 Q8 ?- T

  89. + j+ c' a' D* G  H# U
  90. // 微秒延时
    - Q$ S! o  C9 f* i" Y% D
  91. void delay_us(uint16_t uSec)" ]# ^. c. V4 k5 Y, g- J
  92. {  A0 H& Z% A- K- m0 x" m7 I
  93.         if(uSec > 10000) uSec = 10000;
    ! c8 A2 t+ y2 H

  94. 2 P5 q% p6 I0 y/ h1 [
  95.     uint32_t ticks_start, ticks_end, ticks_delay;
    5 T3 Z* i! [+ q5 ?" N: h
  96. " r+ h3 E# P4 H1 D. ~$ i' N+ C
  97.     ticks_start = DWT_CYCCNT;- b# d5 G+ E2 _4 z' V5 B/ ?, E! ~
  98.     ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数+ J% G" V- e8 o* k+ X
  99.     ticks_end = ticks_start + ticks_delay;
    2 P) Y8 q) F* A' |

  100. 4 N7 Z3 T' w" j! h
  101.     // ticks_end没有溢出
    ' u" I% A9 t/ E1 X- q# j; R6 V
  102.     if ( ticks_end >= ticks_start )  X, M: t0 l# k' ?9 w7 m  l
  103.     {9 z3 W( P; b  k
  104.         // DWT_CYCCNT在上述计算的这段时间中没有溢出" b1 E* a/ @! o( n% k
  105.         if(DWT_CYCCNT > ticks_start)1 M# \5 a8 N* ?) g
  106.         {9 W1 R/ S& }8 N$ R! x- U& C; Y
  107.             while( DWT_CYCCNT < ticks_end );% B% }" V, R* S+ c
  108.         }- Z* b8 |- y8 Q
  109.         // DWT_CYCCNT溢出& \! ?! o1 B1 T9 ?# x. ]) T
  110.         else
    ' C& K3 R" a7 ^4 U. U/ ~, T2 x
  111.         {
    % T* c- Z, v6 Z- E- J  a/ I; N
  112.             // 已经超时,直接退出# ?5 [& I! |5 G. k; h8 s
  113.             return;
      V/ M3 c4 z3 Z' R6 H; V8 X( p
  114.         }
    0 F2 t2 N* U3 V% N
  115.     }# V4 S# d' l# p1 o( {! o! K
  116.     else // ticks_end溢出
    9 t  l' g+ [7 w. F  ?
  117.     {% j9 N) L" I+ q5 ]( W
  118.         // DWT_CYCCNT在上述计算的这段时间中没有溢出, l% B3 g) ^5 _# f2 M9 {! l
  119.         if(DWT_CYCCNT > ticks_start)
    + X% w% J0 R8 T/ T9 i/ D. H/ e/ e8 h
  120.         {+ ?) Z+ r" b1 S! u' X
  121.             // 等待DWT_CYCCNT的值溢出( ?2 J" I% a7 n% m/ Q: U
  122.             while( DWT_CYCCNT > ticks_end );
    8 |/ ], `3 U9 Y$ l' \, G, z) X( ~
  123.         }
    1 V2 R3 D% b- a4 c0 C; N
  124.         // 等待溢出后的DWT_CYCCNT到达ticks_end
    ) C" ?; E" l) E; g8 E- z
  125.         while( DWT_CYCCNT < ticks_end );1 D' `  e$ ]6 q( k# K! ?) y; u
  126.     }  s- b1 ^* j3 ]
  127. }% x" y( Z- E, X% R
  128. 6 y; m! B& Z* ], n# e& c4 Y
  129. void delay_ms(uint16_t ms)7 q- B( p4 [4 q5 R/ B9 \
  130. {8 i7 z4 N) ~- G0 ~% B; D) A
  131.                 for(uint16_t i = 0; i < ms; i++)1 k5 J/ V" z3 ~# x; u7 B
  132.     {
    : j. y8 ]" p9 [1 H/ |1 ^1 O( N
  133.         // delay 1 ms
    * M; s7 p% l, a. ?. T4 _
  134.         delay_us(1000);7 X# n( G; _& ]( S* y2 ]
  135.     }8 [& }/ }8 d7 L
  136. }+ Y( N) ~, O; v- I( L- I) _6 S

  137. ' w+ k; }3 V9 N2 y# {! j& x
  138. #elif defined USE_NOP_DELAY8 g* ~/ g9 J4 |" Y
  139. * D( {4 o, v' R$ r- a
  140. void delay_init(void)
    # R' M7 W& ]: f# s. H* z! ~
  141. {1 B, M7 a! n" J8 q* W" `
  142. ) e) o4 L$ O, _9 ?& v$ K
  143. }
    , C5 R; ?0 z+ C" r4 F) c* Y
  144. 9 {( _( G1 A# }- \# G% p5 s
  145. void delay_ms(uint16_t ms)
    ! i- x7 @' a. a( @& s0 S
  146. {
    - p3 z3 {* I; c" G4 x: }
  147. ' @4 q% o* O" X* p
  148. }4 M. D" \* N  a8 c6 c

  149. 2 h: P) U' F  ]5 [) A
  150. void delay_us(u32 us)( o/ F# }/ V& }4 D- ^/ u; C2 y# ^
  151. {; U  \5 f( P$ U; F
  152. # b, {$ l' P( V
  153. }
    + U0 K# B: F% s1 ?
  154. ' C- U# [, \$ n& P& W8 y
  155. #else
    % N' r( I3 m) T0 N) r; d! t3 Z# b
  156. . C- e/ D- g  e0 R5 K9 k( F
  157. #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
  1. if ( ticks_end >= ticks_start )
    - Y5 `5 H! p+ ]* K
  2. {
    6 x5 t+ v/ ]/ V6 _# c
  3.         // 计算未溢出
    , ~: d- C9 ^" j- E' G& x# ~; V1 b
  4. }1 J2 L2 N; W+ S2 e6 J
  5. else : o8 M$ H: q! r& l5 o
  6. {
    : q2 z. R/ ?  Q$ q+ a2 n! R" k) Q$ Z
  7.         // 计算溢出
    ( n# o& E; d0 Y5 \4 E# y+ |
  8. }
复制代码
+ 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
  1. ticks_start = DWT_CYCCNT;& m3 _" |2 A; ]- u
  2. ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数4 c; P: F; k+ U- n
  3. ticks_end = ticks_start + ticks_delay;
    2 C7 z( X: v! U4 f% z6 C

  4.   V; T% Q2 Y* W) ?
  5. if ( ticks_end >= ticks_start ). k8 w( g! Y: f5 @0 _! }' J* L
  6. {
    # n; J) `. [  n; m
  7.         // DWT_CYCCNT在上述计算的这段时间中没有溢出7 P' o0 _, B3 r0 O* J
  8.         if(DWT_CYCCNT > ticks_start)
    6 E* H( [% B3 ?6 H& [
  9.         {
    2 Y' D' e+ f' j+ Q5 Y5 e" Q+ V
  10. 3 g8 c7 J% ^4 ~, c
  11.         }
    " L, K/ ?" U, `0 s6 c. E1 m
  12.         else- [! i! d: H& c8 w- ?, \" p& H" L
  13.         {
    & J3 r, p/ R2 B& N6 _, f
  14.         
    ; C4 V2 V& F' v- |3 M) S; I
  15.         }% A5 ~/ U# v* ]- G1 K
  16. }. [4 }$ n& f0 C; V
  17. else
    8 x% ~2 b) F: s& G6 {/ u
  18. {0 [+ d& R8 \4 P" s
  19.         // DWT_CYCCNT在上述计算的这段时间中没有溢出) m  Y8 b# h# a0 A" y+ W, K
  20.         if(DWT_CYCCNT > ticks_start)
    $ x+ u; s9 l* Z
  21.         {
    ' U2 T0 X% Y6 X* H& t

  22. + [6 C9 G! y7 V
  23.         }" Z3 `. ]; a" X# A$ ]$ x
  24.         else/ d# D3 ~( y* G7 O+ d4 N" K* O% t* _
  25.         {; Q1 X1 [3 a, h. K/ a
  26.         
    5 U( i% s1 L) a9 S
  27.         }, }1 @% {0 a) r! g9 D& ?4 a' {2 @8 [1 ]
  28. }
复制代码
) F8 @; O) G( a6 K. j
因此需要根据延时等待操作时DWT_CYCCNT所处位置再进行一次判断:
9 A2 }1 l' y  s+ O8 f* Q, w# T$ O  \: ~8 W
7d3cd7bd163a4f0a812be51734efb715.png
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
UR7)6S95828HELIL(I$Y$TG.png $ 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
赞 收藏 评论0 发布时间:2022-4-13 11:00

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版