STM32高精度延时实验

5 T- W- l  ^: o  G$ W* H* e" h& c

1 前言

在STM32编程过程中经常用到延时函数，最常用的莫过于微秒级延时和毫秒级延时。那么本文针对STM32的延时进行分析和实验。关于STM32的时钟系统，参考笔者博文。

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   4 g4 P6 `. O9 z7 `. j
2. void delay_us(u16 time)
   
3. {   
   + F/ n; o% i1 G, A  V4 ^5 ^9 `
4.    u16 i=0;
   ! S! a1 z. C8 v8 Q1 `7 ?" O- p1 L
5. 
   * L5 F4 d3 T' f( N% I
6.    while(time--)
   7 ?; Z* u9 ~) D2 O; B5 R+ O
7.    {
   
8.       i=10; //自己定义
   5 R6 B+ Z- ?4 [2 {: U
9.       while(i--) ;   
   8 T' i+ T5 N3 J7 I, c" w" S. m
10.    }
    # r" U- l4 u* R5 B4 V
11. }
    
12. 
    1 u7 R- o9 ^$ `* m
13. //毫秒级的延时
    
14. void delay_ms(u16 time)
    
15. {   
    3 S; A& ^0 I* z% a- e- E0 h
16.    u16 i=0;
    
17. 
    
18.    while(time--)
    2 {. c5 j1 v$ @7 S, n  h# z1 T
19.    {
    ' f$ k  U& M+ m5 M/ U0 x
20.       i=12000; //自己定义
    1 ^( c7 }# o$ C4 N0 p& [
21.       while(i--) ;   
    
22.    }
    ) [4 \* C- q5 }+ o% `1 h
23. }

复制代码

这个比较简单，让单片机做一些无关紧要的工作来打发时间，经常用循环来实现，不过要做的比较精准还是要下一番功夫。下面的代码是在网上搜到的，经测试延时比较精准。

2.2SysTick 定时器延时

CM3 内核的处理器，内部包含了一个SysTick 定时器，SysTick 是一个24 位的倒计数定时器，当计到0 时，将从RELOAD 寄存器中自动重装载定时初值。只要不把它在SysTick 控制及状态寄存器中的使能位清除，就永不停息。系统定时器一般用于操作系统，用于产生时基，维持操作系统的心跳。SysTick 在STM32的参考手册里面介绍的很简单，其详细介绍，请参阅《Cortex-M3 权威指南》。

1.中断方式

如下，定义延时时间time_delay，SysTick_Config()定义中断时间段，在中断中递减time_delay，从而实现延时。

1. volatile unsigned longtime_delay; // 延时时间，注意定义为全局变量
   
2. 
   2 x% q/ e5 u% `4 e7 d' N1 ]
3. //延时n_ms
   - c% l/ }5 h) x# I9 \3 ^- v
4. void delay_ms(volatile unsignedlong nms)
   1 E  V. O; h& ~$ T  {
5. {
   . v5 q- o3 d) |- R  b
6.   //SYSTICK分频--1ms的系统时钟中断
   ) {3 o8 @% y' a) e
7. if (SysTick_Config(SystemFrequency/1000))
   
8. {
   
9.        while (1);
   , L  M+ t7 n' \* ~# w8 Z2 D* n8 g
10. }
    0 M" q, a  k# I# |# H
11. 
    4 f2 G. r3 B9 D) [& }% T5 |; _
12. time_delay=nms;//读取定时时间
    
13. 
    
14. while(time_delay);
    0 q& v3 {5 j" y; P0 D; N; ~
15. 
    8 p3 Z# |7 E  y5 f
16. SysTick->CTRL=0x00; //关闭计数器
    
17. SysTick->VAL =0X00; //清空计数器
    2 Y$ X% P$ L9 C2 r" U
18. }
    6 a! [4 j' K/ Z5 G8 s
19. 
    
20. //延时nus
    1 k3 y( I  ]0 y) v2 i
21. void delay_us(volatile unsignedlong nus)
    
22. {
    % I" i2 a, y  V- f) V
23. //SYSTICK分频--1us的系统时钟中断
    
24. if (SysTick_Config(SystemFrequency/1000000))
    - Y2 v1 d/ ]' [1 _- G! a1 r
25. {
    
26.        while (1);
    
27. }
    
28. 
    $ z2 V$ p6 d: D% ^- T, d. d6 m
29. time_delay=nus;//读取定时时间
    1 u1 h3 Y- z2 E7 r3 G" I
30. while(time_delay);
    4 w* }4 D% _# v0 b6 Q/ D
31. SysTick->CTRL=0x00; //关闭计数器
    & y/ N& Q1 U( T$ j) c; Y& @6 g
32. SysTick->VAL =0X00; //清空计数器
    % _; g& C+ J- G9 {
33. }
    
34. 
    ) m: L+ X" b' J# i3 {& o
35. //在中断中将time_delay递减。实现延时
    
36. void SysTick_Handler(void)
    
37. {
    % r. d& r5 C& W( T5 h" ?2 I6 B; @! ?
38. if(time_delay)
    ) F* |8 y9 e$ k. f) y$ h
39.         time_delay--;
    
40. }

复制代码

还有一种标准写法：

1. static __IO u32 TimingDelay;
   4 F& {6 \& l3 P2 l0 z/ {
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
     i6 m6 X. u$ Q7 C; w
3. /**
   
4. * @brief   启动系统滴答定时器 SysTick
   ' ~# i6 W6 ~) U% @; @  i
5. * @param   无
   
6. * @retval  无
   
7. */
   
8. void sysTick_init(void)
   7 W+ i" m2 u3 w( U) p
9. {
   ; w& {3 O6 X! I0 k8 [% m
10.        /*SystemFrequency / 1000    1ms中断一次
    " a, x& M" n2 z5 f
11.         * SystemFrequency / 100000 10us中断一次
    0 @5 p0 z: J( Q0 X3 k
12.         * SystemFrequency / 1000000 1us中断一次
    3 x# ~1 i% ~2 D8 E; a7 {
13.         */
    
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    1 G3 y- }0 w# ?! u
15.        {
    ) C; E" U' }. ~3 N2 G, W
16.               /*Capture error */
    ) X4 s) u0 _$ e  ^- @9 J
17.               while(1);
    
18.        }
    $ C1 b- s* n* n# |4 a
19.        //关闭滴答定时器
    
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    
21. }
    - r+ @6 S4 n  u. j
22. 
    6 w7 r, {% R' S% w+ k4 X+ }* O1 m
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    
26. * @retval   无
    
27. */
    
28. void delay_us(__IO u32 nTime)
    6 |. f7 h! h* g  R8 \+ J/ M; ?: {3 y
29. {
    / f6 D/ x0 ^8 p+ u8 b& q
30.        TimingDelay= nTime;      
    
31.        //使能滴答定时器
    3 r# L( |3 @1 C( j  R! b% }- M8 _
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    
33. 
    
34.        while(TimingDelay!= 0);
    4 r7 j1 a1 Z* g4 h6 M
35. }
    
36. 
    
37. /**
    8 q  y  u* ^5 r+ l+ j+ d! U
38. * @brief      获取节拍程序
    + T) G7 I8 d  V1 O8 T0 S
39. * @param      无
    
40. * @retval     无
    
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    
42. */
    
43. void TimingDelay_Decrement(void)
    
44. {
    / Z+ ?* e4 W3 s3 G" l1 k
45.        if(TimingDelay != 0x00)
    * u7 V/ @" ]1 Z* O) s
46.        {
    
47.               TimingDelay--;
    
48.        }
    - G' B$ `" e# h: F  k' f1 Q. d
49. }
    : w" u1 y5 ?! Y7 ^  q5 H9 Z+ `) W
50. /**
    
51. 
    ; S3 ], S, z! U. t
52. * @brief  This function handlesSysTick Handler.
    ' e$ [5 [6 ~% u3 A1 f
53. * @param  None
    
54. * @retval None
    
55. */
    
56. void SysTick_Handler(void)
    & s5 G) B  C7 ?- B/ @( `/ K
57. {
    
58.        TimingDelay_Decrement();   
    
59. }

复制代码

2.非中断方式

SysTick的时钟以 HCLK（AHB 时钟）或 HCLK/8作为运行时钟，在这里我们选用内部时钟源72M，固定为HCLK 时钟的1/8，所以SYSTICK的时钟为9M，即SYSTICK定时器以9M的频率递减。SysTick主要包含CTRL、LOAD、VAL、CALIB 等4 个寄存器。

CTRL： SysTick控制和状态寄存器

LOAD： SysTick重装载值寄存器

VAL：    SysTick当前值寄存器

CALIB：SysTick校准值寄存器

对这几个寄存器的操作被封装到core_cm3.h中：

           

STM32中的Systick 部分内容属于NVIC控制部分，一共有4个寄存器，名称和地址分别是：

STK_CTRL,     0xE000E010 --  控制寄存器      

表1SysTick控制及状态寄存器

第0位：ENABLE，Systick 使能位  （0：关闭Systick功能；1：开启Systick功能）      

第1位：TICKINT，Systick 中断使能位（0：关闭Systick中断；1：开启Systick中断）      

第2位：CLKSOURCE，Systick时钟源选择（0：使用HCLK/8 作为Systick时钟；1：使用HCLK作为Systick时钟）   

第16位：COUNTFLAG，Systick计数比较标志，如果在上次读取本寄存器后，SysTick 已经数到了0，则该位为1。如果读取该位，该位将自动清零

STK_LOAD,    0xE000E014 --  重载寄存器

表2SysTick重装载数值寄存器

Systick是一个递减的定时器，当定时器递减至0时，重载寄存器中的值就会被重装载，继续开始递减。STK_LOAD  重载寄存器是个24位的寄存器最大计数0xFFFFFF。

STK_VAL,     0xE000E018 --  当前值寄存器   

表3SysTick当前数值寄存器

也是个24位的寄存器，读取时返回当前倒计数的值，写它则使之清零，同时还会清除在SysTick 控制及状态寄存器中的COUNTFLAG 标志。

STK_CALRB,  0xE000E01C --  校准值寄存器

表4SysTick校准数值寄存器

校准值寄存器提供了这样一个解决方案：它使系统即使在不同的CM3产品上运行，也能产生恒定的SysTick中断频率。最简单的作法就是：直接把TENMS的值写入重装载寄存器，这样一来，只要没突破系统极限，就能做到每10ms来一次 SysTick异常。如果需要其它的SysTick异常周期，则可以根据TENMS的值加以比例计算。只不过，在少数情况下， CM3芯片可能无法准确地提供TENMS的值（如， CM3的校准输入信号被拉低），所以为保险起见，最好在使用TENMS前检查器件的参考手册。

SysTick定时器除了能服务于操作系统之外，还能用于其它目的：如作为一个闹铃，用于测量时间等。要注意的是，当处理器在调试期间被喊停（ halt）时，则SysTick定时器亦将暂停运作。

程序如下，相当于查询法。

1. static u8  fac_us=0;                                            //us延时倍乘数                 
   ; e' y( K. v" d
2. static u16 fac_ms=0;                                            //ms延时倍乘数
   
3. //SYSTICK的时钟固定为HCLK时钟的1/8
   
4. //SYSCLK:系统时钟
   
5. /**
   6 H7 h( h- k/ e
6. * @brief  初始化延迟函数
   % a7 {7 z! q( ?! c) ~" {
7. * @param  None
   
8. * @retval None
   , F# ~- a, V/ ]( n8 u: j
9. */
   
10. void sysTick_init()
    
11. {
    
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    . C6 Y' `* d3 V' F
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    + h. K1 w5 v% k
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    1 K' p& T/ n, \! J3 y
16. }                                                         
    8 `" W0 j7 }( L9 f2 P
17.       
    
18. /**
    
19. * @brief  延时nus
    " g) C$ h, D( p
20. * @param  nus为要延时的us数.
    2 I: p3 H) C0 l( n- G
21. * @retval None
    
22. */
    & j. a0 I; y, j6 R' h
23. void delay_us(u32 nus)
    
24. {            
    & H: \9 a! @1 \8 N* E
25.        u32temp;               
    
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    " R& I4 o# ^  E
27.        SysTick->VAL=0x00;                                     //清空计数器
    
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    
29. 
    
30.        do
    * g& \1 e. y* x& z
31.        {
    
32.               temp=SysTick->CTRL;
    
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    - J7 v) p; S2 V0 h3 D7 L# r
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    
36. }
    : t1 h: E9 m- X. X& F% O
37. 
    0 h# J. I* {+ X2 ~+ p; K  b9 M
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    ' x$ M# Z0 x3 i1 s' s. R) d( W
39. //nms<=0xffffff*8*1000/SYSCLK
    
40. //SYSCLK单位为Hz,nms单位为ms
    
41. //对72M条件下,nms<=1864
    ( F& I4 \. A" k# U: l+ {2 ?/ d+ y
42. /**
    ; T$ `; R! i3 j; r2 B; H
43. * @brief  延时nms
      q' j: U4 w) o0 \  W
44. * @param  nms为要延时的nms数.
    8 V2 v* `; H) ^8 C: U" \- p% r
45. * @retval None
    ; C0 `1 e3 u0 H7 l
46. */
    " ?. ]: e* G& v! R7 ?7 p( k5 f
47. void delay_ms(u16 nms)
    
48. {                          
    & E/ B. C# P, p4 u8 f3 C
49.        u32temp;            
    
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    
51.        SysTick->VAL=0x00;                                             //清空计数器
    + o6 S+ V& b9 t8 o# ~
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    3 w( A  Y5 d  M8 H1 z
53. 
    6 s+ \* w6 I- @9 y
54.        do
    
55.        {
    0 s; ^/ \1 O& O6 E$ @
56.               temp=SysTick->CTRL;
    
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    
58. 
    
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    * v. Y. r/ r* n' f2 U! g3 a
60.        SysTick->VAL=0X00;                                     //清空计数器              
    
61. }

复制代码

; i2 D& P, G$ T1 [: e# [( X
8 ]6 T- Z' o, i* h5 A

前文所述的两种方式各有利弊，第一种方式采用库函数，编写简单，由于中断的存在，不利于在其他中断中调用此延时函数，还需要考虑中断嵌套和中断优先级的问题。第二种方式直接操作寄存器，看起来比较繁琐，其实也不难，同时克服了中断方式实现的缺点。

3 RTOS延时

在RTOS中，我们时常需要高精度的定时，一般RTOS都有延时函数，但是不够精确，我们还是用SysTick 定时器，采用寄存器方式进行延时，代码如下：

1. /*Includes*********************************************************************/
   & E! _. ~& H  ?8 o% [
2. 
   
3. #include"./SysTick/stm32f103_SysTick.h"
   " g6 B- W7 h* Y1 U* `
4. 
   ! B5 I, d% V$ g1 x; i3 w
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   7 r$ I7 v" [# y! G8 a% E: D
6. //如果使用rt-thread,则包括下面的头文件即可.
   / E2 K, T  O, K& X
7. #if SYSTEM_SUPPORT_OS
   
8. #include "rtthread.h"                     //支持OS时，使用
   
9. #endif
   , a% H. q" ^) \% z8 ]
10. 
    
11. //********************************************************************************
    8 @- p3 ~; [4 @) q& l) U; {' B
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    
13. 
    
14. #if SYSTEM_SUPPORT_OS      
    
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    0 x) Z% g* V2 x& R9 ^6 h& V* i5 v
16. #endif
    
17. 
    
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    
20. //首先是3个宏定义:
    / f) E6 n9 e- s# o% u& G
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    1 T6 l9 T+ y6 }" Z7 p+ f. k
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
      s) z9 ^" N% H1 W
24. //然后是3个函数:
    7 z; X) {1 H% Y! Y' Q4 W! }6 d9 ?
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
    + i3 w  z3 R2 a+ Q: C
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    * C. O( z& k/ D( _
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    6 L2 E6 b7 ~0 ^' F; a
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    
29. //支持RT-Thread
    5 w. T9 a' ?9 t3 d) d' U: x
30. 
    / d4 ?& Z, _4 \( I# B& z. B
31. extern volatile rt_uint8_trt_interrupt_nest;
    
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    % R  d4 {2 i% o( N
33. 
    
34. uint8_t OSRunning=0;
    , ^$ r# l' U( q! F
35. 
    # q" p) }  g( [& q' Y
36. #ifdef    RT_THREAD_PRIORITY_MAX                                        //RT_THREAD_PRIORITY_MAX定义了,说明要支持RT-Thread   
    
37. #define delay_osrunning         OSRunning                           //OS是否运行标记,0,不运行;1,在运行
    
38. #define delay_ostickspersec   RT_TICK_PER_SECOND     //OS时钟节拍,即每秒调度次数
    
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
    * [8 P" F. b/ }8 J
40. #endif
    
41. 
      V- w* B; k, r
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    
43. void delay_osschedlock(void)
    
44. {
    3 K" l7 _2 [' _" t% M# u
45. #ifdef RT_THREAD_PRIORITY_MAX
    ' n+ r  V- _1 J# x
46.         rt_enter_critical();
      N: B* O% r$ ?+ G9 N+ b( _; q
47. #endif  
    
48. }
    
49. 
    
50. //us级延时时,恢复任务调度
    ! g5 K) Z0 A8 v) ~
51. void delay_osschedunlock(void)
    
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    
54.          rt_exit_critical();
    # b; L, A, e) K% W2 ^5 P( r: h* B
55. #endif  
    4 A& K1 i! d: N' c
56. }
    
57. //调用OS自带的延时函数延时
    ' b. s9 q( q; C) Y$ E8 f
58. //ticks:延时的节拍数
    $ y3 {6 H9 ^! s/ Q( Y
59. void delay_ostimedly(uint32_tticks)
    / d* @' V. b8 h/ t6 l9 H' |
60. {
    6 Z8 w' P' X2 \7 \) a
61. #ifdef RT_THREAD_PRIORITY_MAX
    . r! t. ?) _4 x2 k. D) L
62.          rt_thread_delay(ticks);
    6 o% E* {# S3 l- X5 H* G) p( H
63. #endif   
    
64. }
    
65. #endif
    
66.    
    : y. x% [# A  [6 M: M
67. //初始化延迟函数
    2 D% V# x' w) j$ }3 T
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    ' Z  `/ x! E5 s6 c* L2 r; k
69. //SYSTICK的时钟固定为AHB时钟
    4 f# c- W3 @! j" \9 |( U4 \3 \) K: p
70. //SYSCLK:系统时钟频率
    
71. void delay_init()
    & P% T. ?0 N& d5 j. j) m
72. {
    % L6 b, @" U, _- y
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    + m4 d+ R7 @3 ?. G- x6 S1 C) c% K7 r
75. #endif
    + A- _8 h$ _8 l2 ~
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    - o; J: d3 X& @3 }7 {" L; s
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    3 }3 U- D% e  E; u4 d
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    ; h9 q5 Y) D' Z- j8 H* d
83. 
    ' m) _$ O6 X* l9 `
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
    
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    
88. #endif
    ( D; W  K" o" k! Z/ K( H( ?% V( U
89. }                                                         
    
90. 
    
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
92. //延时nus
    " T9 V! O/ x. }* M5 G5 x4 O6 j
93. //nus:要延时的us数.   
    
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    ' x& X! ?7 O4 I3 j+ m0 q
95. void delay_us(uint32_t nus)
    
96. {            
    
97.        uint32_tticks;
    5 T% x( r4 H- E9 R
98.        uint32_ttold,tnow,tcnt=0;
    
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    
100.        ticks=nus*fac_us;                                       //需要的节拍数
     
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     : }3 Z  ]' s$ e4 c' T
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     ' O. @0 _+ r4 y( a* ^
103. 
     
104.        while(1)
     
105.        {
     7 j: e" ~& b- a7 B8 I
106.               tnow=SysTick->VAL;  
     
107.               if(tnow!=told)
     $ M9 s- u) s4 H9 {  k+ o
108.               {         
     % O# n$ k1 V& E) R
109.                      if(tnow<told)
     
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
111.                      else
     6 t2 P! @& b% E4 J' E0 f0 m4 J( P5 Q( }
112.                          tcnt+=reload-tnow+told;   
     ) M, \* `! ?* m9 i& d# a& ~' \
113.                      told=tnow;
     
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     ) u2 o; k$ W) W. [+ F
116.               }
     
117.        };
     
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     # R" v" @7 w  m  r' ?( a
119. }
     & U$ n' L+ }. j1 y
120. 
     
121. //延时nms
     2 s9 k5 [1 \- c
122. //nms:要延时的ms数
     
123. //nms:0~65535
     1 b# m8 }- i5 y
124. void delay_ms(uint16_t nms)
     & N# F6 q! z$ W- J7 ]+ q
125. {     
       ?* r7 E8 f/ h* G% W
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     
127.        {              
     
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     * |% Q  x8 g1 t6 j, C* R
129.               {
     # v* ]7 F  i  g. _
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     1 k7 H' U3 ~; t3 ^# \: g
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     
133.        }
     " \( s1 ~0 a5 M
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     
135. }
     
136. 
     
137. #else  //不用ucos时
     
138. //延时nus
     
139. //nus为要延时的us数.
     + q; {3 e4 K% t) ?5 H) ~8 j) v
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     
141. void delay_us(uint32_t nus)
     # n3 T+ z+ `: t, O  T
142. {            
     # D- ?1 Y) Q7 h5 k
143.        uint32_tticks;
     
144.        uint32_ttold,tnow,tcnt=0;
     
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     # u) v) x" D/ x9 f
146.        ticks=nus*fac_us;                                       //需要的节拍数
     
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     
148.        while(1)
     4 M; J( ~& [" u7 z+ [
149.        {
     . N' d0 g; S( s2 \
150.               tnow=SysTick->VAL;  
     
151.               if(tnow!=told)
     
152.               {         
     
153.                      if(tnow<told)
     + d' k3 ]& P" f$ n  t0 H
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     , q3 W- p1 j, }- {- C- _) j  |
155.                      else
     
156.                         tcnt+=reload-tnow+told;   
     , l9 B7 ?+ i9 ^: r3 [
157.                      told=tnow;
     
158.                      if(tcnt>=ticks)
     
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     
160.               }
     
161.        };
     2 E. o; Q% x6 i  y3 `$ S
162. }
     # ]( R* [4 i, |6 ?8 ?% f$ A$ N
163. //延时nms
     
164. //nms:要延时的ms数
     # w* w' J$ p8 Z# `$ [+ n
165. void delay_ms(uint16_t nms)
     
166. {
     " u% L6 b* N. k0 V4 P1 K
167.        uint32_ti;
     3 t8 Y1 ^. ~4 I) P
168.        for(i=0;i<nms;i++)
     * |* J, W# b' j8 U' Q/ I1 h/ `
169.        {     
     
170.               delay_us(1000);
     
171.        }
     
172. }
     
173. #endif

复制代码

以上代码适配RT-Thread实时系统，针对系统嵌入式系统需要进行修改，以上代码包含了裸机的延时函数。值得注意的是，初始化函数在board.c中调用的。

【ps】针对RT-Thread官方是有高精度延时方案的，大家也可参考：

[url=https://www.rt-thread.org/docume ... manual/timer/timer/]https://www.rt-thread.org/docume ... manual/timer/timer/[/url]

文章出处：  嵌入式实验楼

收集归纳比较好！

学习了，mark一下

这叫什么高精度呀，只能说是普通石英晶体振荡器的精度。
: a$ u6 h3 K( Q/ l" t
要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

高精度还是用定时器比较合适

这不就是正点原子的代码么，大哥~~