STM32高精度延时实验

; |! X; K* Q/ a$ b% u# \) v( l

$ ~. O, v6 A7 u

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   # r5 j% e, r& e$ U6 b$ i
2. void delay_us(u16 time)
   
3. {   
   
4.    u16 i=0;
   
5. 
   
6.    while(time--)
   
7.    {
   
8.       i=10; //自己定义
   
9.       while(i--) ;   
     Z+ B7 c& p% E8 J" r
10.    }
    ) [2 P- }: @9 ~5 R  ]8 l; L) o8 W
11. }
    
12. 
    
13. //毫秒级的延时
    2 M) N: B; z7 m! Z. i7 g4 d+ M7 }
14. void delay_ms(u16 time)
    $ ]! s. C6 \  B; e  D' x  U. t
15. {   
    / O# ^2 x3 Q% O( t$ H. Y
16.    u16 i=0;
    . t" F4 \, ^5 i- P  f6 ?
17. 
    
18.    while(time--)
    
19.    {
    
20.       i=12000; //自己定义
    
21.       while(i--) ;   
    
22.    }
    $ ]0 B, P1 }3 E$ L
23. }

复制代码

2 y9 [2 x5 |3 I2 L

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

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. 
   
3. //延时n_ms
   
4. void delay_ms(volatile unsignedlong nms)
   
5. {
   
6.   //SYSTICK分频--1ms的系统时钟中断
   7 S8 F/ S1 |" g" q
7. if (SysTick_Config(SystemFrequency/1000))
   8 b3 T/ H- S$ Z3 x/ w: W
8. {
   
9.        while (1);
   9 z5 Y1 j8 d( k
10. }
    : ~6 b, x, @8 O! P
11. 
    
12. time_delay=nms;//读取定时时间
    : ^, O" Q, [% J
13. 
    
14. while(time_delay);
    ; ]/ d5 l% P5 N7 y
15. 
    
16. SysTick->CTRL=0x00; //关闭计数器
    
17. SysTick->VAL =0X00; //清空计数器
    - K2 `' y/ o) m! Q! ^2 J
18. }
    : c- B7 ?( [- J0 L1 U; r. [- [* `
19. 
    
20. //延时nus
    
21. void delay_us(volatile unsignedlong nus)
    8 w  R: R7 Y" u. e
22. {
    
23. //SYSTICK分频--1us的系统时钟中断
    - [$ t* z* a/ v1 r. L
24. if (SysTick_Config(SystemFrequency/1000000))
    
25. {
    
26.        while (1);
    
27. }
    
28. 
    8 m2 w( j/ y7 n
29. time_delay=nus;//读取定时时间
    
30. while(time_delay);
    
31. SysTick->CTRL=0x00; //关闭计数器
    4 P+ V& J/ |* `: k! D
32. SysTick->VAL =0X00; //清空计数器
    7 r5 W. c* N$ |
33. }
    6 J; a: P- @3 J: G  U/ m3 H  i
34. 
    
35. //在中断中将time_delay递减。实现延时
    6 @; k% I- J+ @" k: g( _/ ]5 K( n
36. void SysTick_Handler(void)
    ) _% m4 [9 A- A- w6 Y2 b- p
37. {
      {1 [0 u, r, v) {* [. {
38. if(time_delay)
    ) v' O* |, r2 k/ ?4 J+ K7 x7 N
39.         time_delay--;
    
40. }

复制代码

4 i3 }, @  u: F) I* o

还有一种标准写法：

1. static __IO u32 TimingDelay;
   
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   ( O- Q* x+ e) K: n
3. /**
   1 v9 L1 a. N/ N9 t  w1 Z
4. * @brief   启动系统滴答定时器 SysTick
   2 E. N7 p& a  V
5. * @param   无
   
6. * @retval  无
   3 K1 q$ r$ k, k8 f
7. */
   
8. void sysTick_init(void)
   
9. {
   
10.        /*SystemFrequency / 1000    1ms中断一次
    
11.         * SystemFrequency / 100000 10us中断一次
    * C8 P9 r& O0 I4 L! F( i
12.         * SystemFrequency / 1000000 1us中断一次
    
13.         */
    
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    / ?: {% @5 C. O) d4 d; a8 w
15.        {
    0 P& R% u, f1 ^! N
16.               /*Capture error */
    
17.               while(1);
      W; T& J3 f% h; B
18.        }
    
19.        //关闭滴答定时器
    
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    - }$ z, q" f& @4 C' z* d) G
21. }
    
22. 
    # {9 y, s9 @! F. }6 U" T. z! h
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    , {' B7 P( I6 m8 m1 m3 J
26. * @retval   无
    + n8 @; G( J! ]# [4 ?
27. */
    
28. void delay_us(__IO u32 nTime)
    
29. {
    
30.        TimingDelay= nTime;      
    
31.        //使能滴答定时器
    
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    
33. 
    6 V' g. `8 o5 \6 e$ o0 H  Q
34.        while(TimingDelay!= 0);
    - k! L- U0 D5 D# T$ Y% b
35. }
    
36. 
    
37. /**
    
38. * @brief      获取节拍程序
    
39. * @param      无
    
40. * @retval     无
    : D1 E  [) H  n- ^9 j
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    
42. */
    
43. void TimingDelay_Decrement(void)
    
44. {
    0 R9 l& X- D; h6 n" Z! R
45.        if(TimingDelay != 0x00)
    / v/ J- }- l0 T9 Z+ B: k
46.        {
    
47.               TimingDelay--;
    ! |1 D6 q2 t7 \4 J1 D: X! a  y! U
48.        }
    
49. }
    : w* N2 O! r$ H1 g: {# t
50. /**
    5 ?9 w( q7 w$ M0 e( {
51. 
    
52. * @brief  This function handlesSysTick Handler.
    
53. * @param  None
    
54. * @retval None
    
55. */
    & u, U6 h- \, h- Q* k& W
56. void SysTick_Handler(void)
    / V! r( C; J6 K( T. k) n
57. {
    - M$ O2 t) I0 T8 ?# {6 C
58.        TimingDelay_Decrement();   
    8 n+ B8 m9 j" s" q5 ^
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延时倍乘数                 
   0 T: L- u6 `/ A7 K5 L9 \
2. static u16 fac_ms=0;                                            //ms延时倍乘数
   6 ?, ]" n  S: o3 z3 Q: Q# U% k3 s' \
3. //SYSTICK的时钟固定为HCLK时钟的1/8
   ! k6 s9 s2 m* w# ^+ `! U& c# e; N
4. //SYSCLK:系统时钟
   
5. /**
   
6. * @brief  初始化延迟函数
   
7. * @param  None
   
8. * @retval None
   5 P' W' h( S# J5 r
9. */
   
10. void sysTick_init()
    * y. O8 f: ~3 t+ p0 T  y
11. {
    
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    - f( M8 d6 r! h+ s  m% a# B) [' M
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    7 |& |% J( D) d; o2 q- Z
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    
16. }                                                         
    
17.       
    " e- Q2 B7 [# D! t  K5 s$ A
18. /**
    3 v9 F2 i1 ~) J0 J7 Q2 E
19. * @brief  延时nus
    
20. * @param  nus为要延时的us数.
    
21. * @retval None
    
22. */
    
23. void delay_us(u32 nus)
    6 h/ |, h4 v: ~" y) W
24. {            
    
25.        u32temp;               
    
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    ' _: P+ \% B) {1 b" \4 A
27.        SysTick->VAL=0x00;                                     //清空计数器
    - |+ t% J  N: i2 K" W. Z% o4 R) a
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    & `  X& v5 Z4 I7 {, C( O2 k
29. 
    / r% z0 `$ M" d  O& e+ |" J
30.        do
    8 _6 l0 O9 g1 g. j6 r3 C7 ]% j4 H% s1 M
31.        {
    / J8 E/ d( U* D5 Y, P' X1 q! m
32.               temp=SysTick->CTRL;
    # O, }0 b3 J9 K
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    - q+ A9 ]: V/ P. |
36. }
    - _" k# A2 a& i2 x& J! K4 Y
37. 
    ; o, J" I3 |7 O- i( W0 @
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    
39. //nms<=0xffffff*8*1000/SYSCLK
    
40. //SYSCLK单位为Hz,nms单位为ms
    
41. //对72M条件下,nms<=1864
    
42. /**
    5 r, Z; ~  s9 H1 E9 e
43. * @brief  延时nms
    
44. * @param  nms为要延时的nms数.
    1 ?9 S8 Z$ E2 c$ K$ E
45. * @retval None
    
46. */
    % X) Y) b) O: X! p: a0 B( B/ `  w
47. void delay_ms(u16 nms)
    
48. {                          
    
49.        u32temp;            
    
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    ; ^/ L9 [3 o: s' `7 f5 J& i+ b* I
51.        SysTick->VAL=0x00;                                             //清空计数器
    9 [2 Z& e/ ]; ?; @
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    " {* g  Q/ Q4 A+ r8 t$ O4 d. H
53. 
    
54.        do
    
55.        {
    9 p* S2 B9 [7 N  o" s9 s$ a/ _4 @
56.               temp=SysTick->CTRL;
    / Z6 w& G, w# e
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    * R& }' J, q1 H% q9 c9 d9 Z
58. 
    
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    + R6 \! j9 T, ?: U: \) o% S
60.        SysTick->VAL=0X00;                                     //清空计数器              
    
61. }

复制代码

) y( Y; d8 k, f1 ~9 g

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

1 u+ q/ a' y0 W4 P/ C1 [. R

3 RTOS延时

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

1. /*Includes*********************************************************************/
   
2. 
   
3. #include"./SysTick/stm32f103_SysTick.h"
   3 Z: s" i, U8 N% p. U6 H
4. 
   
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   4 ?8 j- J. q3 k
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   # u, ?  Q+ K4 k# h/ h* M1 o
8. #include "rtthread.h"                     //支持OS时，使用
   # ]8 s8 U5 M7 a
9. #endif
   4 X" [8 f( B5 V1 V! A2 s
10. 
    
11. //********************************************************************************
    
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    
13. 
    & w( r, e! p0 b1 {0 d) T* t- K
14. #if SYSTEM_SUPPORT_OS      
    " h5 |6 {$ A, K
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    5 A( A/ |+ t- e; f# {
16. #endif
    0 [1 Y0 b8 d/ L" R) p
17. 
    
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    * B7 p9 A9 S4 J; B4 g2 e
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    * O; i4 J/ a- ]5 u, E
20. //首先是3个宏定义:
    
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    
24. //然后是3个函数:
    
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
    # H$ z5 Z" U2 a% B
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    ' r6 H4 a* N, {! K3 v! q8 w1 I8 p
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    
29. //支持RT-Thread
    
30. 
    - k+ _) o3 h8 X* D# D. k: u
31. extern volatile rt_uint8_trt_interrupt_nest;
    
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    * A* }6 P0 e0 R4 G& p" {
33. 
    
34. uint8_t OSRunning=0;
    ( X6 c6 I8 r4 _% z) |, L( X
35. 
    8 V6 A% ^, e, y# h; @
36. #ifdef    RT_THREAD_PRIORITY_MAX                                        //RT_THREAD_PRIORITY_MAX定义了,说明要支持RT-Thread   
    
37. #define delay_osrunning         OSRunning                           //OS是否运行标记,0,不运行;1,在运行
    ! m3 S$ _/ S1 [- d
38. #define delay_ostickspersec   RT_TICK_PER_SECOND     //OS时钟节拍,即每秒调度次数
    & G% ^% e: z* i0 O. b# Y; \) _0 y- W
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
    : q' t8 I5 c! F8 h
40. #endif
    
41. 
    
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    : K( B5 s- H; }- x$ I1 M& Z7 B
43. void delay_osschedlock(void)
    0 Q  u) ?2 Q$ g! n2 u9 m& d% y
44. {
    4 `  o1 c# H1 F8 a
45. #ifdef RT_THREAD_PRIORITY_MAX
    " `$ Z; W8 u, \- K& p+ {0 ]! y
46.         rt_enter_critical();
    
47. #endif  
    0 @8 l9 o0 `+ E' s) l; C3 g
48. }
    
49. 
    
50. //us级延时时,恢复任务调度
    + h/ y* o$ W5 w
51. void delay_osschedunlock(void)
    ! W+ l* c2 F( d& K: a2 F
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    
54.          rt_exit_critical();
    # P8 K4 L- y* z6 S% h6 j7 x9 C+ k
55. #endif  
    0 z/ _5 _, w  y
56. }
    ' Y8 |: l! S' p
57. //调用OS自带的延时函数延时
    5 j& b1 I: \5 n. J
58. //ticks:延时的节拍数
    + k1 }& |9 E: t& ?4 R
59. void delay_ostimedly(uint32_tticks)
    
60. {
    
61. #ifdef RT_THREAD_PRIORITY_MAX
    
62.          rt_thread_delay(ticks);
    * u7 ~$ T# F$ M  \+ A! [$ t0 l* j
63. #endif   
    
64. }
    
65. #endif
    
66.    
    " P/ K% i- E4 r0 g9 n2 w
67. //初始化延迟函数
    
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    ! g' n/ e; c' H9 N- t
69. //SYSTICK的时钟固定为AHB时钟
    / ~) p0 b& G$ ]6 I0 R
70. //SYSCLK:系统时钟频率
    ' Q$ r1 Z+ x! ?; G1 o. s) \
71. void delay_init()
    
72. {
    
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    
75. #endif
    
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    7 u5 C2 Q1 ^2 y  s- ?
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    1 S' I1 K; t. y6 k% s; M) |7 ?# i
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    8 _! o# ~1 y4 v: p0 u* Z# p5 r
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    $ m. X+ m& g1 D8 d" w0 I
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    3 V# X7 V" d2 S* R: \5 R: _) t
83. 
    " O: ?5 O! l) q/ N1 l* ?
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    ' p* ]: u9 U/ v$ ]  O
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
      T3 U4 k' m( V9 g4 l
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    ! N) f& j4 ~! |" V9 q) _
88. #endif
    & q) F* r+ v& F5 X5 d  f7 K8 v
89. }                                                         
    / h. w$ @. X/ F
90. 
    + Z  o4 g9 s# F- X3 ]1 C
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    ; U( J7 U. A8 T, Y( o2 E
92. //延时nus
    
93. //nus:要延时的us数.   
    
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    
95. void delay_us(uint32_t nus)
    ; k' I9 D: w5 J  x. }: J
96. {            
    
97.        uint32_tticks;
    
98.        uint32_ttold,tnow,tcnt=0;
    5 B/ I/ f  v6 N$ q# k6 b
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    # i4 k  S9 G6 m! ], B/ u
100.        ticks=nus*fac_us;                                       //需要的节拍数
       E7 W2 @# o6 K( I' Q3 Y/ M, Q: q, g
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     
102.        told=SysTick->VAL;                                //刚进入时的计数器值
       c/ G! Q# p  b0 R& n% O8 W6 T& h
103. 
     - _* J" q& A8 ~( V" `! z5 |: \& J
104.        while(1)
     
105.        {
     ! ?% z: q  S* i3 `. U8 l: _
106.               tnow=SysTick->VAL;  
     
107.               if(tnow!=told)
     
108.               {         
     
109.                      if(tnow<told)
     
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     % c* D9 ^( O2 _& Z
111.                      else
     
112.                          tcnt+=reload-tnow+told;   
     0 @3 f, ^" p  o) w" g. J
113.                      told=tnow;
     ( ^( [4 r$ i& {- x) Q2 H4 F
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     
116.               }
     
117.        };
     3 [4 H3 Y2 ?9 n% O! ^9 L8 o
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     
119. }
     - f; a' n3 k% l. s: t8 \
120. 
     " G, v! a! Q/ f5 c
121. //延时nms
     
122. //nms:要延时的ms数
     / K* m- Z3 d( @( c
123. //nms:0~65535
     0 V: ]) p" Z( p, O" G5 O& T% U3 F  {, B
124. void delay_ms(uint16_t nms)
     ) K$ [6 ]9 }) [& \4 S1 ^2 D6 F" ]1 }( \7 i
125. {     
     & C7 i' _7 J7 E& V1 X$ b
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
       D# Z9 j" h* P+ q
127.        {              
     
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     
129.               {
     6 R4 D, v' d4 O- o
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     ' h' }& f9 q. S' P
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     " j( O$ b# S  W. k" `% P! V
133.        }
     9 n, [4 Q% I1 G$ }& h  Q* H3 ~
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     
135. }
     
136. 
     0 G' Z" x* H/ i0 }& q. x
137. #else  //不用ucos时
     ) H! L4 I+ V  H3 }+ p
138. //延时nus
     2 V: G2 U: Z2 Y2 @9 `
139. //nus为要延时的us数.
     
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     ; J. U: E! G3 q# Q
141. void delay_us(uint32_t nus)
     # j' q1 ?" {/ a( H) k( E4 E
142. {            
     9 m" U9 b$ z; p
143.        uint32_tticks;
     - ]. z- i) {, y& Y! Q7 \5 b1 D
144.        uint32_ttold,tnow,tcnt=0;
     
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     8 F& n4 R" n8 p5 |' Y  K  D6 b
146.        ticks=nus*fac_us;                                       //需要的节拍数
     
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     
148.        while(1)
     
149.        {
     
150.               tnow=SysTick->VAL;  
     
151.               if(tnow!=told)
     + t1 R0 f: V' F2 W& k% \
152.               {         
     
153.                      if(tnow<told)
     
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     * M% t. i: ^- k* b% r- b. N
155.                      else
     6 _7 |4 k# ^4 E4 d" x
156.                         tcnt+=reload-tnow+told;   
     
157.                      told=tnow;
     
158.                      if(tcnt>=ticks)
     
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     
160.               }
     
161.        };
     
162. }
     ! f! u3 w- g% v/ x7 ~
163. //延时nms
     2 e! p; ~, @, b; c0 G2 C; Z* l( k
164. //nms:要延时的ms数
     
165. void delay_ms(uint16_t nms)
     
166. {
     
167.        uint32_ti;
     
168.        for(i=0;i<nms;i++)
     
169.        {     
     
170.               delay_us(1000);
     . X2 b$ c2 z5 ~) l' ?
171.        }
     & J3 s  I0 B) X1 F/ C+ q( X
172. }
     : m! ]6 l+ K) G: \
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]

文章出处：  嵌入式实验楼

. z' G* H# I9 z9 }$ n8 Q5 f. X

收集归纳比较好！

学习了，mark一下

这叫什么高精度呀，只能说是普通石英晶体振荡器的精度。

2 k8 ~( b# h& d( X) o& J' E2 a要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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