STM32高精度延时实验

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   % _% W5 ?0 U2 C$ u
2. void delay_us(u16 time)
   
3. {   
   ' q$ `# ~! n" l  o) k7 U
4.    u16 i=0;
   " m: k  Z7 w8 \- T" m, x% p2 ~* F
5. 
   
6.    while(time--)
   
7.    {
   
8.       i=10; //自己定义
   : K/ D0 R  J2 M" Q3 j5 Q, ?7 E1 M
9.       while(i--) ;   
   / S6 u( {6 y, V; I
10.    }
    
11. }
    
12. 
    ! w" Y4 T( u( h& Z8 F( S3 O
13. //毫秒级的延时
    
14. void delay_ms(u16 time)
    9 L& p# [' s* a6 Y
15. {   
    1 P5 X6 v+ B* G: _8 j' F
16.    u16 i=0;
    
17. 
    . Y7 K$ j% f9 A! U' E4 f# R# S
18.    while(time--)
    
19.    {
    
20.       i=12000; //自己定义
    
21.       while(i--) ;   
      `9 t8 F7 w) t$ I  v$ Z
22.    }
    $ {; t- \" D6 t+ {
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. 
   ( c1 z+ W3 r4 {7 O8 V  W
3. //延时n_ms
   # m% e! a9 S, Q
4. void delay_ms(volatile unsignedlong nms)
   
5. {
   
6.   //SYSTICK分频--1ms的系统时钟中断
   
7. if (SysTick_Config(SystemFrequency/1000))
   
8. {
   9 H+ Y" M& H( q
9.        while (1);
   
10. }
    
11. 
    
12. time_delay=nms;//读取定时时间
    - p% p7 O, P- y2 r* _! E
13. 
    
14. while(time_delay);
    ; D- d9 A9 Z0 v9 |
15. 
    
16. SysTick->CTRL=0x00; //关闭计数器
    1 S- E, |7 w7 [0 d9 F0 @
17. SysTick->VAL =0X00; //清空计数器
    2 h9 i* N* ]& U8 x. o4 x
18. }
    ) O& h% B8 H& A5 V
19. 
    
20. //延时nus
    * ]- z0 D- w: \3 r
21. void delay_us(volatile unsignedlong nus)
    + v% N! Q: H; G
22. {
    $ @) t" P2 O7 X$ l6 n+ u9 O- X$ s' |2 A
23. //SYSTICK分频--1us的系统时钟中断
    0 e4 R/ ?9 I# |8 @0 i) b0 `
24. if (SysTick_Config(SystemFrequency/1000000))
    
25. {
    
26.        while (1);
    . z/ f9 L( H$ m* z+ c) B5 p
27. }
    9 W/ x. ?1 e7 a; N' F0 ~. f$ a7 ]
28. 
    3 Z: N) u6 T: u. D7 g
29. time_delay=nus;//读取定时时间
    , o2 n: J! A( f! p1 h
30. while(time_delay);
    " Z1 Z% ~5 f; [2 {/ H3 P) V
31. SysTick->CTRL=0x00; //关闭计数器
    6 p& n7 E8 Z- s7 T5 d
32. SysTick->VAL =0X00; //清空计数器
    
33. }
    
34. 
    
35. //在中断中将time_delay递减。实现延时
    - I. ~- P  W2 B
36. void SysTick_Handler(void)
    
37. {
    - H3 D) J; {" }: x; b5 Y
38. if(time_delay)
    3 [2 o3 v8 ~6 ?
39.         time_delay--;
    
40. }

复制代码

还有一种标准写法：

1. static __IO u32 TimingDelay;
   
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   
3. /**
   
4. * @brief   启动系统滴答定时器 SysTick
   
5. * @param   无
   6 x4 ?) q- i9 \" h  V& `4 V
6. * @retval  无
   $ {7 S2 W( b$ L
7. */
   
8. void sysTick_init(void)
   
9. {
   2 Y6 x; r- j! h; D, |
10.        /*SystemFrequency / 1000    1ms中断一次
    
11.         * SystemFrequency / 100000 10us中断一次
    % E# K2 v+ b+ g9 G
12.         * SystemFrequency / 1000000 1us中断一次
    - n2 {5 G$ l  T! T) J7 |
13.         */
    
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
      G' d9 l( j; g: V. q; s1 K( |
15.        {
    7 S: E+ z$ {, r, Y
16.               /*Capture error */
    
17.               while(1);
    ' m! N8 U# S. C6 M, N4 c  v3 v
18.        }
    
19.        //关闭滴答定时器
    
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    & N; ^) e& X) x6 K2 l# r1 Y2 b
21. }
    5 M. q& H# c2 M$ Q; U& d3 Z
22. 
    
23. /**
      o0 p+ _$ Q+ `$ P
24. * @brief    us延时程序,1us为一个单位
    6 R9 e5 B3 a" y; ~* V/ w! x7 N% C9 S
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    
26. * @retval   无
    
27. */
    
28. void delay_us(__IO u32 nTime)
    
29. {
    
30.        TimingDelay= nTime;      
    2 h( `" y* @5 f2 n+ E+ T  v
31.        //使能滴答定时器
    ' `* p/ ~: O9 a7 T: y( W; j
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    2 x0 J& I4 K8 O5 s2 Y
33. 
    
34.        while(TimingDelay!= 0);
    9 ^7 q" Y) ?9 l2 C- h9 h/ {$ j$ v) o
35. }
    0 D) ]: t0 E! Q' M8 L/ A- `) @! I
36. 
    
37. /**
    8 N8 N8 U0 {" {- k
38. * @brief      获取节拍程序
    & f2 Y! X4 {. j. E! t- M( _
39. * @param      无
    
40. * @retval     无
    
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    
42. */
    
43. void TimingDelay_Decrement(void)
    ) |7 U2 i2 K" @* X+ k
44. {
    ) r8 I' J. _% i+ M2 H$ S) G; m; A
45.        if(TimingDelay != 0x00)
    ! c6 x/ [3 I  [( Q; I
46.        {
    
47.               TimingDelay--;
    . p; [; O' l0 X% L( s
48.        }
    
49. }
    $ x5 j4 ]# e5 |- u6 k3 I6 j
50. /**
    
51. 
    
52. * @brief  This function handlesSysTick Handler.
    3 B. V8 J" x# O4 D
53. * @param  None
    
54. * @retval None
    % x. w1 ]$ F2 _2 t3 r8 ]6 w! t( {7 |7 {
55. */
    
56. void SysTick_Handler(void)
    
57. {
    
58.        TimingDelay_Decrement();   
    , B: o# D4 f8 d# L" k$ z( c* A
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延时倍乘数
   0 H. i6 V8 j% `, b4 {& U8 a
3. //SYSTICK的时钟固定为HCLK时钟的1/8
     p" T' h  w4 E* H2 E2 j1 i
4. //SYSCLK:系统时钟
   6 Z- Q" W9 v# j( e
5. /**
   
6. * @brief  初始化延迟函数
   
7. * @param  None
   
8. * @retval None
   ; n1 ^6 s) ]% M( W1 \
9. */
   / f6 W* [4 ?+ g$ I) r
10. void sysTick_init()
    : k6 k7 W8 F9 c! }. \
11. {
    , d+ @! K. m6 b6 E* y7 M: I2 k8 @- ]
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    7 F# n, X, C% U1 g' U6 Q5 X4 E
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    % p4 o1 @& p8 W3 l+ w$ n( o3 q8 k
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    
16. }                                                         
    
17.       
    
18. /**
    
19. * @brief  延时nus
    * D% c* I* R. O) ~" u0 y
20. * @param  nus为要延时的us数.
    5 c* A; r' O/ I* d; ?* Q
21. * @retval None
    
22. */
    
23. void delay_us(u32 nus)
    : h* r  T' X/ ?6 e+ p& o
24. {            
    
25.        u32temp;               
    7 m# ]9 h5 M+ L$ Y
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    & _# b7 z, }( t3 G6 Y
27.        SysTick->VAL=0x00;                                     //清空计数器
    
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    - s# x7 k: x+ R0 w3 N0 S
29. 
    0 ]% {5 B2 |+ T
30.        do
    
31.        {
    
32.               temp=SysTick->CTRL;
    / C+ _( z  |9 n0 b
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    
36. }
    
37. 
    0 i7 s( m: [9 {+ e% `
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    & q% Q% c0 Q* W) ~- f$ K- u" G4 L
39. //nms<=0xffffff*8*1000/SYSCLK
    : E/ p  k) E& \: ~, l
40. //SYSCLK单位为Hz,nms单位为ms
    
41. //对72M条件下,nms<=1864
    
42. /**
    - L9 ]; z: b' w4 U) k( M) s
43. * @brief  延时nms
    
44. * @param  nms为要延时的nms数.
    
45. * @retval None
    
46. */
    
47. void delay_ms(u16 nms)
    
48. {                          
    
49.        u32temp;            
    7 ?1 ^% S2 q% J$ E" c1 P1 ]
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    
51.        SysTick->VAL=0x00;                                             //清空计数器
    
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    
53. 
    
54.        do
    ' s; U+ }- J- p2 R  p$ i0 ^! e) C
55.        {
    ' K- O8 z/ i, J8 @
56.               temp=SysTick->CTRL;
    
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    ; q! y, z2 ?9 _  _& S3 }
58. 
    
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
      u) @4 l! i: G( q* X% V
60.        SysTick->VAL=0X00;                                     //清空计数器              
    
61. }

复制代码

( x1 X6 B7 p) \7 t' X9 z- \

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

* f) f" Z. [2 O8 m4 S8 B

3 RTOS延时

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

1. /*Includes*********************************************************************/
   
2. 
   " \: N) V- k6 {# w! }' U6 W
3. #include"./SysTick/stm32f103_SysTick.h"
   
4. 
   / e& e& D9 X$ B( Q% B
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   $ w6 ]! j' |# t( a3 A! x, `
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   
8. #include "rtthread.h"                     //支持OS时，使用
   
9. #endif
   . i, P- f. H! _8 Q+ r2 U
10. 
    . n+ x% t' E" r9 c- h$ d5 A
11. //********************************************************************************
    ; e+ q% B: n/ b% G# _/ [; s
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    4 t" J) U: s& U; L
13. 
    
14. #if SYSTEM_SUPPORT_OS      
    
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    
16. #endif
    6 x0 a# s% N, X) G8 {  a# L% q8 e9 b
17. 
    ( a8 T9 r- s% }) c2 d
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    ( t  v! j+ a) }$ {
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    , j- ^6 e' i0 }. F- D4 ?6 B: D8 E
20. //首先是3个宏定义:
    ( \/ u( m: K3 H: t
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    + i% Y' R- i) `" G6 ~
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    ) ~; M+ Z, g; o$ {. A* }- P7 O
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    / X9 T! p& ~: G" q
24. //然后是3个函数:
    
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
      D6 I1 J2 g# r3 G, W) ?) E
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    : U7 f$ O8 p% ~. E, D9 G6 I
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    
29. //支持RT-Thread
    ( U$ h3 }' Z0 P7 [" G
30. 
    ; N. V$ x% q9 z6 E
31. extern volatile rt_uint8_trt_interrupt_nest;
    , \3 G. T; u' k2 v
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    . |% Q" a6 o; t' t% f% e
33. 
    9 X- S+ o& b" }/ ]
34. uint8_t OSRunning=0;
    
35. 
    ; R& m2 R7 j1 A) u, X/ G9 R3 \
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时钟节拍,即每秒调度次数
    ( }* Y& T" Z/ ^, ^3 n/ e7 {& h: A" r
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
    & m- D0 R7 L6 r2 I
40. #endif
    - E" A, G: E+ @, f0 X  T
41. 
    4 w$ S% E: }% h
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    
43. void delay_osschedlock(void)
    
44. {
    / @8 [4 G0 Z/ z4 x. G6 r) J9 u
45. #ifdef RT_THREAD_PRIORITY_MAX
    
46.         rt_enter_critical();
    & m/ i$ `$ C3 J( s
47. #endif  
    
48. }
    
49. 
    ( m2 {- P2 C# I5 L; }$ D7 }( X
50. //us级延时时,恢复任务调度
    
51. void delay_osschedunlock(void)
    
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    
54.          rt_exit_critical();
    
55. #endif  
    - \5 i# D7 Z5 z6 A
56. }
    
57. //调用OS自带的延时函数延时
    
58. //ticks:延时的节拍数
    
59. void delay_ostimedly(uint32_tticks)
    
60. {
    ! y0 A# d; \' b. a7 c8 b
61. #ifdef RT_THREAD_PRIORITY_MAX
    
62.          rt_thread_delay(ticks);
    
63. #endif   
    8 q; b2 v( O3 F/ V
64. }
    % E- p# n2 ~+ X3 r
65. #endif
    # J3 P  ]  H6 D) W
66.    
    
67. //初始化延迟函数
    & D1 H- p1 N/ h% T# y/ c3 P0 A
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    - i& [+ l3 d: L( ~) a( x" r) t
69. //SYSTICK的时钟固定为AHB时钟
    4 Z9 F$ X0 F2 z( V) v
70. //SYSCLK:系统时钟频率
    
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
    ) r$ o; j$ i8 U
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    6 ~8 {/ Z/ p+ v
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    . c1 p  Y3 ]# e3 O
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    - G2 G9 j6 z' Y9 y
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    * r1 t) }0 H) ~
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    * |1 z5 h& O& e3 i. T5 [5 l
83. 
    - M5 X$ g# O" q
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    3 v! d% n  e/ }4 q- h
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
    
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    6 Y- M( s% J- }, W4 v/ X! I3 t
88. #endif
    
89. }                                                         
    6 P% J% F, l" ]6 V
90. 
    
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    3 o: V; C" S2 ^: _9 P+ B) p& H" J
92. //延时nus
    * r8 T9 N1 H1 t
93. //nus:要延时的us数.   
    & o5 S5 J7 `+ N
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    ) c( h+ k1 q5 J( E! f$ R
95. void delay_us(uint32_t nus)
    
96. {            
    0 i- D$ n. y/ C; M  B2 ?
97.        uint32_tticks;
    
98.        uint32_ttold,tnow,tcnt=0;
    + Q5 n, r/ `" c* O# G$ ?/ [5 T# o
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    4 ?9 f$ Y# D% u- z: Q
100.        ticks=nus*fac_us;                                       //需要的节拍数
     
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     . I1 J' R6 |4 v. k
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     ( i' ~& U4 k' ?% `/ ~* ?+ m
103. 
     ; a, I. n2 Y* ^2 Y; q) [+ D
104.        while(1)
     ! d. M8 }) N% y! [8 `2 A* f
105.        {
     9 l0 O/ [" p; [; G) @
106.               tnow=SysTick->VAL;  
     
107.               if(tnow!=told)
     7 B) |: D/ Q/ A
108.               {         
     1 e4 D. ?) l- V. F6 U. u) f, h2 l3 n, a
109.                      if(tnow<told)
     - q+ ~4 o+ j  Y! O3 F' A
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     - h4 @) H" U3 s- l
111.                      else
     ( |( A, v- I0 ~0 g* d: c
112.                          tcnt+=reload-tnow+told;   
     ) Q3 {+ r4 ?' i7 ?
113.                      told=tnow;
     
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     - {0 g8 o! w' L( X" F) m2 l
116.               }
     
117.        };
     
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     . [; K) H# d  o. Y  x$ M) R% _5 i
119. }
     
120. 
     
121. //延时nms
     
122. //nms:要延时的ms数
     
123. //nms:0~65535
     + a& ]  ~. c* y3 _7 e3 a8 r, p
124. void delay_ms(uint16_t nms)
     / _5 ~/ u5 l- }* B" a8 a$ K
125. {     
     ' ~5 I4 O& L! n6 a% ?* R
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     ' l0 w8 L# g" u
127.        {              
     
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     7 f8 g2 b) L& I
129.               {
     
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     
131.               }
     2 U  E  ?; P8 s/ Q, Q; o% t6 [
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     " |* G; C; f6 J! W
133.        }
     
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     
135. }
     
136. 
     4 h3 S( b, [$ O4 z  @" e
137. #else  //不用ucos时
     ( S9 P# ^6 Q6 l: u
138. //延时nus
     ! Y$ \5 F- @: ]* t& w
139. //nus为要延时的us数.
     2 ]$ u6 A( g3 J- Q- B
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     , F, U' t' b; |  X- ?( w
141. void delay_us(uint32_t nus)
     
142. {            
     5 k8 a2 J' A* M5 K5 n  @, l
143.        uint32_tticks;
     * E4 Y1 P9 y. l) z1 D* ~
144.        uint32_ttold,tnow,tcnt=0;
     4 j5 [0 ?4 @1 o$ \. z  e
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     8 o0 }% t' w: y% r/ ^% Z9 r/ j
146.        ticks=nus*fac_us;                                       //需要的节拍数
     . d1 p" S: L' E7 j
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     ( ]8 f; @. k! F$ N
148.        while(1)
     3 ~% O5 x6 S3 G0 @/ U. N# G" e
149.        {
     
150.               tnow=SysTick->VAL;  
     ) k9 y0 K% o- O3 ~5 p
151.               if(tnow!=told)
     
152.               {         
       |# z# P( g! v
153.                      if(tnow<told)
     , K+ Y$ J, ]* X/ q( q' J3 o
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     2 @4 n* Z6 y1 I. T6 o6 w
155.                      else
     1 e' V: D) X( p# W9 p; u4 g1 X$ n
156.                         tcnt+=reload-tnow+told;   
     
157.                      told=tnow;
     
158.                      if(tcnt>=ticks)
     + O) U% l  ]) T, N# x2 `* X
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     + F) p/ @, i# Y% Q3 |$ X" Y
160.               }
     
161.        };
     ; F! h8 S0 t4 Q* r; z. A
162. }
     5 Z1 G/ Y# v' ?1 a6 E
163. //延时nms
     
164. //nms:要延时的ms数
     
165. void delay_ms(uint16_t nms)
     , S# j, e5 Q1 W+ A; O3 @
166. {
     
167.        uint32_ti;
     
168.        for(i=0;i<nms;i++)
     4 u* V& P$ W0 f1 u
169.        {     
     + o  ], l8 m% P) l
170.               delay_us(1000);
     
171.        }
     
172. }
     
173. #endif

复制代码

( y) X% y' j% D, x

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

这叫什么高精度呀，只能说是普通石英晶体振荡器的精度。
9 ~3 ^" V# U5 m0 T' ~5 e
0 v; e( d( q; M. s( b* u要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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