STM32高精度延时实验

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   * ~% z- I  W' a- Y) c) K
2. void delay_us(u16 time)
   
3. {   
   1 ^+ V" Z5 s8 u3 g" ~1 T0 r* [
4.    u16 i=0;
   
5. 
   
6.    while(time--)
   
7.    {
   . m* v( q! N3 Z" {3 U7 V% x% q
8.       i=10; //自己定义
   
9.       while(i--) ;   
   
10.    }
    
11. }
    
12. 
    * n& l7 V  q, o9 z
13. //毫秒级的延时
    
14. void delay_ms(u16 time)
    : ^& L( |" ^3 H8 ^4 {; Z
15. {   
    3 }8 w* N3 q3 [* }
16.    u16 i=0;
    
17. 
    ; ]7 n9 E( U6 {5 t
18.    while(time--)
    
19.    {
    
20.       i=12000; //自己定义
    * Z" b% _9 W% S; Q* D" V, ]
21.       while(i--) ;   
    
22.    }
    ( v; T4 }6 z3 {7 k  M
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. 
   
3. //延时n_ms
   
4. void delay_ms(volatile unsignedlong nms)
   2 z  |5 i& E3 S2 m' g$ v
5. {
   : W0 o( T( {  ?/ P" O
6.   //SYSTICK分频--1ms的系统时钟中断
   
7. if (SysTick_Config(SystemFrequency/1000))
   " z  o9 Q9 T$ i: a) t
8. {
   
9.        while (1);
   $ J! h; ?$ P# @9 y
10. }
    
11. 
    
12. time_delay=nms;//读取定时时间
    
13. 
    
14. while(time_delay);
    
15. 
    $ D. i# R% n/ S
16. SysTick->CTRL=0x00; //关闭计数器
    
17. SysTick->VAL =0X00; //清空计数器
    
18. }
    6 J7 _6 Z2 d3 y' {2 f: z
19. 
    
20. //延时nus
    
21. void delay_us(volatile unsignedlong nus)
    2 c) E" l. T: _# d1 `7 Q
22. {
    
23. //SYSTICK分频--1us的系统时钟中断
    ' S9 b& i( E  u! w$ z
24. if (SysTick_Config(SystemFrequency/1000000))
    ) d& Z  k' u2 m  E7 S5 Q/ o
25. {
    0 @; q0 N  g2 {2 r9 Q* H3 Q, b
26.        while (1);
    
27. }
    
28. 
    
29. time_delay=nus;//读取定时时间
    & ~+ e# R+ C8 x
30. while(time_delay);
    9 S# t5 y, w( j- b
31. SysTick->CTRL=0x00; //关闭计数器
    
32. SysTick->VAL =0X00; //清空计数器
    
33. }
    
34. 
    
35. //在中断中将time_delay递减。实现延时
    " Q0 o$ j# B: l" {
36. void SysTick_Handler(void)
    6 h- l3 {2 J! @  K* e- @# ^/ Q  y
37. {
    
38. if(time_delay)
    
39.         time_delay--;
    9 n! J% U$ s' Q1 A  P: p' H. v
40. }

复制代码

9 z; ^4 R! N) E* c' ^8 N* V) I1 D4 E

还有一种标准写法：

1. static __IO u32 TimingDelay;
   ; G$ t2 r" s6 k
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   2 ~) m# g- n+ S3 u3 X; u$ m# U0 M3 |
3. /**
   / R/ o% U  D! b: p
4. * @brief   启动系统滴答定时器 SysTick
   ' \( h3 Y$ y& X; f
5. * @param   无
   6 R  C; y' g9 u1 {
6. * @retval  无
   
7. */
   , M& J; g7 S6 e/ x- b8 j
8. void sysTick_init(void)
   ; _6 Q& N& W- ]- T& {. h5 W4 {
9. {
   
10.        /*SystemFrequency / 1000    1ms中断一次
    ) \: ~: v6 J9 r5 _) O( |' I
11.         * SystemFrequency / 100000 10us中断一次
    , y4 g! u1 t& U8 T5 u
12.         * SystemFrequency / 1000000 1us中断一次
    
13.         */
    
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    / c; ^4 I3 w( c1 a
15.        {
    
16.               /*Capture error */
    
17.               while(1);
    . f+ R3 t  I" Z& }% `
18.        }
    # c: g9 V" M+ o  Y2 B/ T$ @9 {; F
19.        //关闭滴答定时器
    
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    ( E* _) ]. m+ ]/ j1 j* J& T7 w) S/ Z
21. }
    
22. 
    
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    
26. * @retval   无
    - w' W& T: r0 n2 z5 w' ^' F
27. */
    
28. void delay_us(__IO u32 nTime)
    
29. {
    
30.        TimingDelay= nTime;      
    : R0 `8 m" @7 r, q& o7 }
31.        //使能滴答定时器
    
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    
33. 
    
34.        while(TimingDelay!= 0);
    
35. }
    9 x4 X+ {* K- V1 v% S9 b1 Y' Q
36. 
    # O: g' H" v/ S1 p
37. /**
    ' {: Z/ l; I: p- X0 f0 ]( z4 o
38. * @brief      获取节拍程序
    
39. * @param      无
    $ |3 s$ N/ I- o3 O) c
40. * @retval     无
    
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    
42. */
    
43. void TimingDelay_Decrement(void)
    
44. {
    
45.        if(TimingDelay != 0x00)
    
46.        {
    
47.               TimingDelay--;
    
48.        }
    
49. }
    * Y# S  Z/ ~* U9 X# @
50. /**
    
51. 
    
52. * @brief  This function handlesSysTick Handler.
    3 o/ w4 d5 s1 [! Y0 M2 Y
53. * @param  None
    
54. * @retval None
    8 X2 _, k4 V* P
55. */
    ' K. s9 Y# L0 V2 k2 B6 q0 I
56. void SysTick_Handler(void)
    
57. {
    3 V$ G  t8 N: [* Y( d
58.        TimingDelay_Decrement();   
    0 K) ?: I3 {8 \  j, @
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延时倍乘数                 
   
2. static u16 fac_ms=0;                                            //ms延时倍乘数
   ) i: @" i; u0 w0 r
3. //SYSTICK的时钟固定为HCLK时钟的1/8
   
4. //SYSCLK:系统时钟
   0 U, Y/ N7 |3 C/ W
5. /**
   
6. * @brief  初始化延迟函数
   " S' E- s& l( k+ V5 W7 s
7. * @param  None
   3 R$ ], F! V0 Q# f2 a( u
8. * @retval None
   
9. */
   
10. void sysTick_init()
    
11. {
    ; Z1 m8 Y; u3 I5 t3 ~$ P
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    8 f+ ^. T. C5 O( v7 ?: m; h
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    & k' t5 ~+ _5 ~# G' L
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    1 `& [& f. r8 s: ]
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    + h/ J* l4 M( v8 ?1 D) r
16. }                                                         
    , n* F8 z8 y! v  I2 V
17.       
    3 `! C' I( X. [6 ]% y
18. /**
    . t/ Q0 o; z9 n! D8 g; G
19. * @brief  延时nus
    & K" ^+ t& b& L: Y! i  F6 x/ [
20. * @param  nus为要延时的us数.
    6 T! X, |1 u, N8 M
21. * @retval None
    
22. */
    
23. void delay_us(u32 nus)
    ' E6 R* P. j" F9 Q* R5 Y
24. {            
    ( ?6 v. [% y1 K6 j  K+ p# `
25.        u32temp;               
    : G5 W! n: s- c/ F; L2 J0 h
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    
27.        SysTick->VAL=0x00;                                     //清空计数器
    7 I; U3 Q7 A: `/ X0 V
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    ; l9 j  a) [$ u& x! }) Y8 V
29. 
    ( f" r) H% r" l0 m
30.        do
    " A  p9 `; U* I0 p+ W. p
31.        {
    
32.               temp=SysTick->CTRL;
    
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    
36. }
    
37. 
    
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    
39. //nms<=0xffffff*8*1000/SYSCLK
    + u2 \! x% u0 k0 V9 \
40. //SYSCLK单位为Hz,nms单位为ms
    
41. //对72M条件下,nms<=1864
    
42. /**
    2 J: D; X8 l8 h- Q5 g- f
43. * @brief  延时nms
    3 C/ F  X6 r( k$ h1 |) O
44. * @param  nms为要延时的nms数.
    ! n: |2 n# n- z/ p  O' W, `  v
45. * @retval None
    + p3 r* D: D/ q# B8 F; D
46. */
    
47. void delay_ms(u16 nms)
    
48. {                          
    ! n1 K/ v1 f! [2 i4 L! v( c: E# l6 \9 x
49.        u32temp;            
    ( U" F  Q& K/ b) I9 n, A7 {
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    . q: ?; _# Q' U  I' o  T; O! n$ D
51.        SysTick->VAL=0x00;                                             //清空计数器
    7 n& v6 D* P; b9 A8 C
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    7 E& l+ E7 A2 O) n7 B8 c0 S4 b
53. 
    3 d2 ^) H& M# [6 h% y! v5 t( `
54.        do
    4 T- N1 ]# N1 I! \  k8 I8 P' S
55.        {
    
56.               temp=SysTick->CTRL;
    7 ^5 k) T# B: B- P; C5 r/ Y
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    ! w! w% j* n7 t; t
58. 
    9 X% [8 q6 j; }6 B0 ]- O. H
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    9 o6 Z( J) W; ]# I; X
60.        SysTick->VAL=0X00;                                     //清空计数器              
    1 w+ ]3 w, \8 D/ e0 u
61. }

复制代码

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

7 A$ {, d1 v0 b3 f

3 RTOS延时

$ @! e. w+ G0 z2 u4 j2 e0 _

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

1. /*Includes*********************************************************************/
   6 B/ G) m6 _* x5 l) N& e
2. 
   $ F9 c5 r5 B9 B5 W( K
3. #include"./SysTick/stm32f103_SysTick.h"
   1 ~/ s6 h$ F! E8 }4 b9 Z+ m
4. 
   
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   
8. #include "rtthread.h"                     //支持OS时，使用
   % ~, ?& j2 d4 s$ O
9. #endif
   
10. 
    2 S. r: R; S9 i4 L6 U9 {  y4 b
11. //********************************************************************************
    
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    & Y- U, u. K) g/ P( k' A
13. 
    0 c" T; B! h) u+ {6 A
14. #if SYSTEM_SUPPORT_OS      
    , c) Q& C- V4 l6 X  L) }7 K
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    
16. #endif
    
17. 
    5 t% Z0 B5 [1 \
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    
20. //首先是3个宏定义:
    3 L  H8 r0 O" ~- r: @& s6 {( U- J
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    & ~0 n' N) D  ]) x3 ^! b: a, u) u
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    ( o6 q6 n8 |% b0 g4 n. ]& p
24. //然后是3个函数:
    ) ^+ N5 K+ W) {1 y7 k( R9 P2 p+ D
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
    
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    2 p: Z, S7 t8 q' r2 {
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    7 M8 A( n, Z0 v" p2 [( M
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    & T1 B8 d) j- U$ [+ k
29. //支持RT-Thread
    
30. 
    
31. extern volatile rt_uint8_trt_interrupt_nest;
    
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    
33. 
    ' f  F/ e$ m$ \3 a2 Q7 L0 i/ W
34. uint8_t OSRunning=0;
    ) O' u& ^7 i* A% L: W
35. 
    ) T1 {2 U2 e; u# X. G1 m* [
36. #ifdef    RT_THREAD_PRIORITY_MAX                                        //RT_THREAD_PRIORITY_MAX定义了,说明要支持RT-Thread   
    " s/ p" }0 Q9 C. ]* t
37. #define delay_osrunning         OSRunning                           //OS是否运行标记,0,不运行;1,在运行
    
38. #define delay_ostickspersec   RT_TICK_PER_SECOND     //OS时钟节拍,即每秒调度次数
    
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
    
40. #endif
    
41. 
    4 x3 L3 ?2 X% K3 V' }3 o
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    8 ]0 n7 c' H3 k& y
43. void delay_osschedlock(void)
    
44. {
    
45. #ifdef RT_THREAD_PRIORITY_MAX
    
46.         rt_enter_critical();
    # X1 d: q. E& {1 O( X8 ~, o, l
47. #endif  
    9 K# ~* {/ N0 y8 S, M+ Q, H2 j- [  A
48. }
    
49. 
    
50. //us级延时时,恢复任务调度
    * s0 r+ x+ h2 `: b
51. void delay_osschedunlock(void)
    - a3 s1 C: j! s. d4 R( W* r
52. {     
    / x- o" m, Q4 b# q  @
53. #ifdef RT_THREAD_PRIORITY_MAX
    
54.          rt_exit_critical();
    6 H& G; F- s& a' Y
55. #endif  
      L2 V: Y2 }1 d
56. }
    
57. //调用OS自带的延时函数延时
    " i, H; }8 a5 x* J0 u: Z
58. //ticks:延时的节拍数
    
59. void delay_ostimedly(uint32_tticks)
    
60. {
    " z  X: o: A2 Q3 h4 Y0 t* H
61. #ifdef RT_THREAD_PRIORITY_MAX
    , Q3 z5 A6 o5 r
62.          rt_thread_delay(ticks);
    / z) M2 F% E: `8 u" l* V- U3 S% T
63. #endif   
    
64. }
    6 u' u7 W5 ~' y- R) w' Y0 z
65. #endif
    
66.    
    
67. //初始化延迟函数
    7 M* ^" U/ o7 j" p
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    
69. //SYSTICK的时钟固定为AHB时钟
    : `+ m5 g0 \. B
70. //SYSCLK:系统时钟频率
    
71. void delay_init()
    
72. {
    8 c4 L8 K1 Y# ~! S6 t3 Q
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    
75. #endif
    
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    , |$ R. e" T7 Q) h' w# v! l
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    2 c, I8 \6 U: d7 l0 ~5 a# c
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    5 z& [. x6 `' P5 q! {0 Z* O7 h
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    : S) N/ \0 ^' P
83. 
    / a2 o9 p# X+ d6 c
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    % d% L. V$ P0 N, l5 Y
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    & E# ^/ E  E! Z$ q0 F* V
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
    # I- i- ^* R& F7 h
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    1 }; ]5 D0 s; I1 Q/ t( B  {  w3 T
88. #endif
    % O) ^* ^+ F! |$ \
89. }                                                         
    
90. 
    2 ^0 A+ G* V. F" m- x! m; H
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
92. //延时nus
    ! y4 `9 k9 J' e# W# J4 Z+ P5 v3 k
93. //nus:要延时的us数.   
    ! M7 k( d4 b4 h$ `$ [
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    % z" a7 e. Q7 p# g
95. void delay_us(uint32_t nus)
    
96. {            
    1 T8 S" p9 d. d* q- X
97.        uint32_tticks;
    
98.        uint32_ttold,tnow,tcnt=0;
    . ~, x- |( f9 }
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    ( I7 I( b8 `+ L0 T9 M
100.        ticks=nus*fac_us;                                       //需要的节拍数
     ! {  T* W' t, C, v0 h0 j
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     8 L0 x) ~+ G3 I) M% s8 k4 L
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     ! {# ~  r6 q/ I
103. 
     
104.        while(1)
     * r; a. T  V2 u$ i" i* x- Q
105.        {
     & K7 n- @+ J. H6 ?  R/ e
106.               tnow=SysTick->VAL;  
     
107.               if(tnow!=told)
     2 h" O7 L! k5 X3 K# I
108.               {         
     
109.                      if(tnow<told)
     
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
111.                      else
     8 E, @$ i1 L5 ]7 q: e# ]- E( x
112.                          tcnt+=reload-tnow+told;   
     
113.                      told=tnow;
     ; t% p2 h% j$ z# Y1 ~
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     
116.               }
     
117.        };
     3 O$ |0 E$ y, v3 ~5 J* _) c
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     
119. }
     - J4 \/ Z4 h( o& `2 C) v1 ~
120. 
     / ~7 |' p) w: ^- L/ W
121. //延时nms
     
122. //nms:要延时的ms数
     9 D2 ?# V" g6 C: k3 q
123. //nms:0~65535
       C- ?3 g2 j/ t. X; k
124. void delay_ms(uint16_t nms)
     
125. {     
     
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     
127.        {              
     9 T$ _+ Z+ d5 S/ j. I/ v3 X
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     
129.               {
       P+ K) k! v8 L5 A; g# `2 O
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     9 t5 ^/ k8 k2 |, j/ q# Q2 X
133.        }
     $ p: e" U" u6 R+ R2 E
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     * L5 g2 a5 R( l1 X: U" @
135. }
     
136. 
     
137. #else  //不用ucos时
     
138. //延时nus
     " P/ [0 |. ^6 F" i8 _
139. //nus为要延时的us数.
     
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     ) y( a6 A* A9 J  {
141. void delay_us(uint32_t nus)
     7 s: q3 d$ c# A8 A% g
142. {            
     
143.        uint32_tticks;
     
144.        uint32_ttold,tnow,tcnt=0;
     
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     6 Z7 H% O+ w& F( E4 Z/ B7 s! y
146.        ticks=nus*fac_us;                                       //需要的节拍数
     1 u7 @" h+ ~: B- P6 u' `! X
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     
148.        while(1)
     7 ]: V; H$ T3 B& k  c! N6 w. p! B
149.        {
     
150.               tnow=SysTick->VAL;  
     & E  h. w5 h% ?$ S: v
151.               if(tnow!=told)
     ! x* j! P) Z5 }& n% E2 X
152.               {         
     
153.                      if(tnow<told)
     
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     - E4 N+ b% Q# S8 G' [. ~
155.                      else
     ; e6 }$ r; u* r3 w4 M
156.                         tcnt+=reload-tnow+told;   
     
157.                      told=tnow;
     ! K/ I# T/ T5 s6 V
158.                      if(tcnt>=ticks)
     
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     
160.               }
     " b" o& }# N4 V7 I3 i% |; }  {$ w5 k
161.        };
     
162. }
     . j/ o* B1 [& M2 Z7 @" i: u
163. //延时nms
     7 i! L; e6 k4 n( w: ?5 k
164. //nms:要延时的ms数
     9 K: c( ]7 T( X/ [, N4 P. F
165. void delay_ms(uint16_t nms)
     
166. {
     ; h$ [. {% \; I; b+ O1 C- ?6 v
167.        uint32_ti;
     
168.        for(i=0;i<nms;i++)
     
169.        {     
     , S4 r3 c2 i; \* n5 i
170.               delay_us(1000);
     ) J! ^9 c9 l  z/ F1 s2 V
171.        }
     
172. }
     % y, M+ y' |4 Z0 E. A- ]/ u  A
173. #endif

复制代码

' H9 q+ d9 E! R" ]0 o

以上代码适配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]

文章出处：  嵌入式实验楼

9 p& M! K" {4 C8 R6 b& u

收集归纳比较好！

学习了，mark一下

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

+ j  U: q$ E1 p: a* {4 [要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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