STM32高精度延时实验

4 \: ^3 t3 E* o+ X7 X

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   2 t, k6 j8 ^4 I7 p5 o
2. void delay_us(u16 time)
   
3. {   
   2 q$ f7 E6 m, b* @
4.    u16 i=0;
   
5. 
   ! U% B4 T+ g# `* p
6.    while(time--)
   
7.    {
   
8.       i=10; //自己定义
   2 e; l3 r, n  N
9.       while(i--) ;   
   
10.    }
    
11. }
    
12. 
    
13. //毫秒级的延时
    ; s$ y* d2 G" D  @# Z4 }/ s/ I
14. void delay_ms(u16 time)
    6 H" g) Y; ]/ l
15. {   
    . y3 U4 ]5 W: X, C2 {
16.    u16 i=0;
    
17. 
    ; Z/ K7 _: R. T7 Y+ c7 P6 Y: p; h
18.    while(time--)
    
19.    {
    4 v- k7 H8 m6 D3 R
20.       i=12000; //自己定义
    
21.       while(i--) ;   
    
22.    }
    1 ?; o! W3 }& m" R- Y8 u
23. }

复制代码

4 x3 I5 s/ H" D) l4 `. e

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

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; // 延时时间，注意定义为全局变量
   % H8 W% r! p1 Z0 d( }) n1 N
2. 
   5 g; W6 M9 ^' _- ~7 b
3. //延时n_ms
   
4. void delay_ms(volatile unsignedlong nms)
   
5. {
   6 V: Y$ R( n/ D
6.   //SYSTICK分频--1ms的系统时钟中断
   $ H, m3 W; y4 t% }
7. if (SysTick_Config(SystemFrequency/1000))
   
8. {
   
9.        while (1);
   
10. }
    1 j/ w0 m" G% p+ z) [# d( }
11. 
    
12. time_delay=nms;//读取定时时间
    
13. 
    
14. while(time_delay);
    $ A! O2 w5 _7 c: f; u8 x3 {
15. 
    % o3 m: o! M' n, v* u
16. SysTick->CTRL=0x00; //关闭计数器
    
17. SysTick->VAL =0X00; //清空计数器
    
18. }
    ; Q! d$ Y3 R3 |) h( T& ?- h0 \
19. 
    
20. //延时nus
    % r  }/ M; h9 S3 m! ?* |% |3 E! g
21. void delay_us(volatile unsignedlong nus)
    : u* h( U4 \. F
22. {
    
23. //SYSTICK分频--1us的系统时钟中断
    9 Q! M0 |/ B5 U% G" \
24. if (SysTick_Config(SystemFrequency/1000000))
    
25. {
    
26.        while (1);
    
27. }
    
28. 
    
29. time_delay=nus;//读取定时时间
    
30. while(time_delay);
    
31. SysTick->CTRL=0x00; //关闭计数器
    3 I8 G, t! S8 |$ n: Q
32. SysTick->VAL =0X00; //清空计数器
    
33. }
    
34. 
    
35. //在中断中将time_delay递减。实现延时
    
36. void SysTick_Handler(void)
    ' Y8 q) p. ~7 b+ p- H9 f% a: j
37. {
    
38. if(time_delay)
    
39.         time_delay--;
    1 R2 F* O5 j. u
40. }

复制代码

还有一种标准写法：

1. static __IO u32 TimingDelay;
   # T2 f# r# g- l2 \3 Q' R
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   ' q3 Z1 f6 V( [- g9 i9 {5 n  U
3. /**
   
4. * @brief   启动系统滴答定时器 SysTick
   
5. * @param   无
   - Q, i; @) C8 R
6. * @retval  无
   
7. */
   / V0 Q# v% L! E7 s
8. void sysTick_init(void)
   
9. {
   
10.        /*SystemFrequency / 1000    1ms中断一次
    $ ~' a6 l& Q$ a+ Z: Y5 U# n
11.         * SystemFrequency / 100000 10us中断一次
    
12.         * SystemFrequency / 1000000 1us中断一次
    - g; T+ p) a; X, P$ K/ V- M( ?# }
13.         */
    
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    
15.        {
    6 N$ n  ?3 g9 [5 s# k3 f
16.               /*Capture error */
    ! x3 d$ c% ]8 h2 U
17.               while(1);
    
18.        }
    
19.        //关闭滴答定时器
    
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    
21. }
    
22. 
    6 Y7 l4 W+ b6 V" n+ A0 a: |
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    0 D( c% G) o3 l3 H  ^
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    % }7 ?  c: k3 Z% E# N6 U9 Z
26. * @retval   无
    " j! }( d7 [) Y4 e8 Y8 R
27. */
    
28. void delay_us(__IO u32 nTime)
    6 P9 V( T, f3 T9 L% I
29. {
    
30.        TimingDelay= nTime;      
    
31.        //使能滴答定时器
    
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    ' o* r# u0 _7 k) A1 Q7 m
33. 
    
34.        while(TimingDelay!= 0);
    
35. }
    
36. 
    
37. /**
    1 c7 Q1 d3 n1 u, c/ h7 _
38. * @brief      获取节拍程序
    . N: t. F/ ^, U) d) Q  k
39. * @param      无
    
40. * @retval     无
    2 }; Q3 i; m% `. B  F% [$ \
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    
42. */
    
43. void TimingDelay_Decrement(void)
    - J* K+ ]4 `2 g- n* `
44. {
    
45.        if(TimingDelay != 0x00)
    
46.        {
    
47.               TimingDelay--;
    
48.        }
    ! u* m% T% U4 w! I3 [* B3 X
49. }
    
50. /**
    
51. 
    
52. * @brief  This function handlesSysTick Handler.
    ; W  N! ?+ D$ o$ v5 c4 y6 f) h
53. * @param  None
    ) q3 n6 D+ J6 J/ f' m& M: t1 @/ x8 M
54. * @retval None
    & l  E, x' i$ y8 g3 t6 y
55. */
    
56. void SysTick_Handler(void)
    
57. {
    
58.        TimingDelay_Decrement();   
    8 H$ f1 Y/ u1 q7 G0 q
59. }

复制代码

$ L' E" v% Q7 {# h

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延时倍乘数
   
3. //SYSTICK的时钟固定为HCLK时钟的1/8
   
4. //SYSCLK:系统时钟
   
5. /**
   ; k5 m- R/ |, m+ I( Z
6. * @brief  初始化延迟函数
   
7. * @param  None
   
8. * @retval None
   
9. */
   
10. void sysTick_init()
    4 S0 O5 u8 _, Y9 a
11. {
    6 C3 _; D1 g; \& y) W
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    
16. }                                                         
    ! W5 F4 c6 A/ E* P  m
17.       
    . C" [( n/ }' i1 Q  @. l2 F2 S  b
18. /**
    
19. * @brief  延时nus
    
20. * @param  nus为要延时的us数.
    
21. * @retval None
    
22. */
    " j0 ?' @& `4 r! J" q; ]+ i8 c( @
23. void delay_us(u32 nus)
    - N& I/ `( M( q& S7 g$ n9 x8 V
24. {            
    
25.        u32temp;               
    9 b  F' \+ f7 `0 J! @4 b
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    
27.        SysTick->VAL=0x00;                                     //清空计数器
    ) Y* `& U9 B2 L2 _
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    5 K0 q: I7 g, W/ T. P
29. 
    7 ^* T* }. m) u, d1 @- i" [
30.        do
    1 F" v' Q/ J' ^9 i9 R. o
31.        {
    , K  q3 P9 `/ T0 W/ z
32.               temp=SysTick->CTRL;
    3 n0 n& Q, r7 `6 {0 [- A* X2 W
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    $ g- @/ U! J& G; ~$ r* I7 Y( r
36. }
    % h, i+ ]. R, m: u! Q9 F
37. 
    1 ?6 U9 W% X* @# F, Y3 r
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    " ?$ R: f& l9 {& h
39. //nms<=0xffffff*8*1000/SYSCLK
    
40. //SYSCLK单位为Hz,nms单位为ms
    8 e- N2 W# e- `3 I& s7 b5 s( b# Y
41. //对72M条件下,nms<=1864
    4 K0 o  C4 l) V+ Q  g+ y' U9 D
42. /**
    
43. * @brief  延时nms
    
44. * @param  nms为要延时的nms数.
    ) x! s/ k- j1 \7 |. J! r
45. * @retval None
    5 Z+ c4 `% q& ~; {6 M) I
46. */
    + m3 q# V% l$ t# @3 Y3 m  C) i
47. void delay_ms(u16 nms)
    
48. {                          
    9 w7 Q- @( j' l! O1 ?# E
49.        u32temp;            
    
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    , `1 i- u8 }8 y# O$ ^$ ~
51.        SysTick->VAL=0x00;                                             //清空计数器
    2 }& u0 {$ F5 ]/ e7 |
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    
53. 
    ' p( i) L5 }& u8 G6 b% B
54.        do
    
55.        {
    
56.               temp=SysTick->CTRL;
    
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    # k$ \$ r* g: a7 Y, V4 l; J
58. 
    & m5 a3 W8 m2 _6 A8 H
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
60.        SysTick->VAL=0X00;                                     //清空计数器              
    . }5 a9 H7 e! W
61. }

复制代码

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

3 RTOS延时

, q/ J8 Q% X8 ]5 V

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

1. /*Includes*********************************************************************/
   
2. 
   4 Z4 D# p, L6 H& F1 `
3. #include"./SysTick/stm32f103_SysTick.h"
   
4. 
   
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   * J( K& p" t+ Z* Q7 R
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   
8. #include "rtthread.h"                     //支持OS时，使用
   
9. #endif
   2 n& ]1 S3 ?4 F0 ~# s6 l
10. 
    
11. //********************************************************************************
      I0 C% U1 ?. ^
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    2 U/ i" f+ G" P2 n' Z6 ^1 f- u+ G
13. 
    
14. #if SYSTEM_SUPPORT_OS      
    $ r% c  ]) c5 u9 N1 M; I7 t  I
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    9 D' t0 q5 `" \2 d" @& j
16. #endif
    
17. 
    
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    
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任务调度,禁止调度
    
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    
29. //支持RT-Thread
    
30. 
    
31. extern volatile rt_uint8_trt_interrupt_nest;
    - o& l, r$ `2 o+ d  L' d6 m/ D
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    
33. 
    7 v1 v0 F' e8 l5 r
34. uint8_t OSRunning=0;
    
35. 
    
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时钟节拍,即每秒调度次数
    4 v' J% L( }& C/ Z5 U( z
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
      i" J) \4 L) ~
40. #endif
    & C9 J! r/ ~+ C3 R$ {1 H1 G
41. 
    
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    - A: \3 e( |6 _% {8 d1 P& b7 y1 T
43. void delay_osschedlock(void)
    
44. {
    6 z+ l0 x9 f7 H, a! E
45. #ifdef RT_THREAD_PRIORITY_MAX
    2 i3 q; B4 R# T- c$ D
46.         rt_enter_critical();
    , X5 ]* q* M' A& M2 e
47. #endif  
    ( p" t/ |4 w  _
48. }
    
49. 
    
50. //us级延时时,恢复任务调度
    
51. void delay_osschedunlock(void)
    
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    ! i" R% H' C( k3 m  S
54.          rt_exit_critical();
    , B% J6 w: v6 _/ i! ?  U' d- ]( W
55. #endif  
    
56. }
    $ ?  \3 \. k/ G* J6 f4 C# B
57. //调用OS自带的延时函数延时
    
58. //ticks:延时的节拍数
    0 K% Y" n0 L0 F$ K- T  b9 Y% X4 t  [
59. void delay_ostimedly(uint32_tticks)
    
60. {
    & N* K$ D7 T% O8 P) h: J: n1 B3 r
61. #ifdef RT_THREAD_PRIORITY_MAX
    % R) D# z5 d+ K0 B# E9 V3 F% X
62.          rt_thread_delay(ticks);
    
63. #endif   
    
64. }
    
65. #endif
    
66.    
    : V) ]7 u, n# q: A" B. ^$ [7 {
67. //初始化延迟函数
    
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    
69. //SYSTICK的时钟固定为AHB时钟
    8 Y- N% s0 _) }4 a& C
70. //SYSCLK:系统时钟频率
    
71. void delay_init()
    
72. {
    8 d& s0 }* Q8 q2 S+ e
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    8 i6 l% J4 m1 l6 i
75. #endif
    
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    " a" P( J$ e5 `9 f
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    , B+ m# M( S0 g* A
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    / d. e: v6 G' o8 D; e( ~1 ^8 @
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    - a; M5 R* B" S9 t) [
83. 
    8 U* \- x0 i) r# z
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    & H& T. ?8 T  T# Z/ S& v4 \& b
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
    $ [$ J7 t( y2 n/ h0 s: A/ l, Y
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    , ]) I. y6 H/ p6 v
88. #endif
    7 s; {4 R5 b; O1 I
89. }                                                         
    
90. 
    
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
92. //延时nus
    * X! P% i: ]& ]( q; O
93. //nus:要延时的us数.   
    
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    
95. void delay_us(uint32_t nus)
    : U& v6 ?7 S! p  @# L. {* Z5 x1 o9 I
96. {            
    
97.        uint32_tticks;
    
98.        uint32_ttold,tnow,tcnt=0;
    1 V* U, T8 U; q4 [4 S  r+ z! G. J4 P! c
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    1 {7 W  d! Y9 P* x
100.        ticks=nus*fac_us;                                       //需要的节拍数
     ' m0 f9 W! Q6 [, f8 N
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     % I& Z) N* c6 X2 R' o+ G* b
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     
103. 
     
104.        while(1)
     
105.        {
     * _4 M5 _4 \& \* |$ x2 m, o0 w# e1 D
106.               tnow=SysTick->VAL;  
     # ~" G* J! c' r! `( u8 h8 k% `
107.               if(tnow!=told)
     . {+ Z- N8 @4 S6 Y; O
108.               {         
     
109.                      if(tnow<told)
     5 D/ a1 ?& ?5 E. C
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
111.                      else
     , @, |+ f* j4 O) C! f6 C
112.                          tcnt+=reload-tnow+told;   
     
113.                      told=tnow;
     ' ^5 c8 a. t7 T$ |  e
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     
116.               }
     
117.        };
     
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     4 |/ H4 J' L- [+ _* e
119. }
     & d4 [) B/ a) H+ @
120. 
     $ Z% n0 K. X* t
121. //延时nms
     ' f# Z5 Z# Z/ }
122. //nms:要延时的ms数
     
123. //nms:0~65535
     # K* s0 {- p" a8 @1 m4 l9 ?
124. void delay_ms(uint16_t nms)
     1 u) t- R6 u3 v
125. {     
     
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     3 X2 q+ `$ |. w
127.        {              
     
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     
129.               {
     ; E3 F% `, s  j6 R* ?
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     . v& Y, ~3 {/ D: E. R& ~( p. o3 H
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     : D( m4 V( R- B3 k4 u  H+ f4 ?
133.        }
     * M7 A: w; d0 ?! n) R3 T& X* U1 \
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     1 U, u4 O5 F- p
135. }
     
136. 
     % x  r  g; ~! x7 {* `5 O
137. #else  //不用ucos时
     + Y- v1 X" C* e# `9 w, G
138. //延时nus
     
139. //nus为要延时的us数.
     
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     
141. void delay_us(uint32_t nus)
     ; h9 _# j2 j6 u5 N2 w# F
142. {            
     * \  f3 e2 R+ u3 P
143.        uint32_tticks;
     & Q" ]+ u6 e" D# ]
144.        uint32_ttold,tnow,tcnt=0;
     , q+ E0 v0 N0 a1 O" ^: X9 o9 \7 u
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     3 m5 }  V, j. S- W
146.        ticks=nus*fac_us;                                       //需要的节拍数
     
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     
148.        while(1)
     
149.        {
     
150.               tnow=SysTick->VAL;  
     7 W) a: ?  g5 H# F) }. f
151.               if(tnow!=told)
     
152.               {         
     
153.                      if(tnow<told)
     
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     & x/ M) @. h4 X- n$ ~$ ^
155.                      else
     
156.                         tcnt+=reload-tnow+told;   
       x: ~& Y: y7 o" C/ z- G
157.                      told=tnow;
     
158.                      if(tcnt>=ticks)
     
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     % F. B, K2 ?! m7 |% z
160.               }
     
161.        };
     $ @- {9 B; _' _- A! d7 w  z- h
162. }
     
163. //延时nms
     $ ^5 ^0 j8 k7 k. p& E0 t# |8 O
164. //nms:要延时的ms数
     * }7 k9 U+ A7 q$ g' V$ E( v
165. void delay_ms(uint16_t nms)
     , k* }- t6 b+ B( c
166. {
     
167.        uint32_ti;
     
168.        for(i=0;i<nms;i++)
     % {/ M5 n: V$ z# C( @; }1 s: E( n
169.        {     
     + I5 N/ h/ \: G
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一下

这叫什么高精度呀，只能说是普通石英晶体振荡器的精度。
# m- `- M$ Z# Z, v5 k* y6 p" I* P& j
/ J3 C/ Q1 |+ u5 @. z( L要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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