STM32高精度延时实验

$ `* e* s5 G4 k4 V+ v

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   : p9 R. Y/ r8 [3 m* ?) x
2. void delay_us(u16 time)
   5 P) `5 z0 Y! Q) O  A
3. {   
   
4.    u16 i=0;
   
5. 
   5 t; `9 |' m9 F! u! l# L# p$ o
6.    while(time--)
   # d. s% X0 T$ k& k) I
7.    {
   0 {# A7 C- z6 q* L
8.       i=10; //自己定义
   
9.       while(i--) ;   
   
10.    }
      A. g8 M$ G$ W! U$ i* D. t( W
11. }
    ) J4 V. q; D* q: B5 \# l& B. [
12. 
    " j8 d& v1 R- f8 {& ^" B
13. //毫秒级的延时
    + K+ {) V! a3 r% \
14. void delay_ms(u16 time)
    ' @" @* W' ?6 M8 L* f# a% E
15. {   
    & X6 K, t) y9 G, S( [
16.    u16 i=0;
    & j& W0 z# r% ^; R6 L
17. 
    
18.    while(time--)
    - \3 _" a2 F6 v2 N3 j, Y3 c+ M
19.    {
    ' c0 S2 {, `. X5 y$ i) ~" O
20.       i=12000; //自己定义
    
21.       while(i--) ;   
    % b; ^  X4 \# d& v
22.    }
    ' T7 x2 W+ s' J7 X7 }% Q
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; // 延时时间，注意定义为全局变量
   % s0 {% e  |1 W$ @3 }
2. 
   
3. //延时n_ms
   4 K5 A; T- Z8 n$ o
4. void delay_ms(volatile unsignedlong nms)
   ( S; y4 w9 k3 B% S
5. {
   
6.   //SYSTICK分频--1ms的系统时钟中断
   9 S8 p; s) E( h( S0 }# t  X* n
7. if (SysTick_Config(SystemFrequency/1000))
   
8. {
   
9.        while (1);
   % @+ h: h# N, S- D
10. }
    0 y/ ~! Z6 v# _3 c- }
11. 
    ' [' ]& b7 `4 d# m; F. ^
12. time_delay=nms;//读取定时时间
    
13. 
    . A' k3 W# p% R( M
14. while(time_delay);
    
15. 
    
16. SysTick->CTRL=0x00; //关闭计数器
    
17. SysTick->VAL =0X00; //清空计数器
    # u9 A- }" @) x8 @& b( E1 J' ~
18. }
    
19. 
    6 Y, y* i! D) g' t- W4 G) {
20. //延时nus
    
21. void delay_us(volatile unsignedlong nus)
    ; j4 a) X" h2 i0 ]: \1 T
22. {
    
23. //SYSTICK分频--1us的系统时钟中断
    : r" k5 ]4 r4 A# S! r
24. if (SysTick_Config(SystemFrequency/1000000))
    
25. {
    
26.        while (1);
    + H1 Z1 B+ j5 s0 \' _# T5 j
27. }
    
28. 
    1 l4 X5 ?5 K# |3 B7 {9 J
29. time_delay=nus;//读取定时时间
    7 }5 n, w3 i$ I1 n
30. while(time_delay);
    + U' D# [" F( I5 [1 t4 ~
31. SysTick->CTRL=0x00; //关闭计数器
    0 i0 c* E, z8 M. v8 a( x
32. SysTick->VAL =0X00; //清空计数器
    9 ^# M+ K+ d- N/ P  Y6 B
33. }
    * [0 a6 h% J1 n7 y
34. 
    
35. //在中断中将time_delay递减。实现延时
    % R2 j: O0 M/ ]4 E  e% f
36. void SysTick_Handler(void)
    
37. {
    4 e# W, a# z2 N7 M3 P, Z* W1 M
38. if(time_delay)
    . X  V* `$ D* d# U" ^
39.         time_delay--;
    4 u4 J6 `' }- `: d- A0 F
40. }

复制代码

还有一种标准写法：

1. static __IO u32 TimingDelay;
   
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   
3. /**
   - i5 C1 X( y; |8 w& {& o
4. * @brief   启动系统滴答定时器 SysTick
   ; z9 ~, m; @( u+ g$ ^
5. * @param   无
   
6. * @retval  无
   
7. */
   
8. void sysTick_init(void)
   4 l, g% b' e0 Q, D, [
9. {
   
10.        /*SystemFrequency / 1000    1ms中断一次
    
11.         * SystemFrequency / 100000 10us中断一次
    
12.         * SystemFrequency / 1000000 1us中断一次
    4 [/ X  Q- M2 L) s1 p7 a+ `1 d
13.         */
    : Y% K( \( ^4 Z- S8 t7 u' c
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    0 {  ~9 o$ |. V! R- A
15.        {
    # {! {+ H/ Y- z* l
16.               /*Capture error */
    , I3 L3 E5 A2 O' l$ m5 g8 o
17.               while(1);
    
18.        }
    
19.        //关闭滴答定时器
    ( l  T$ T1 T$ B' i4 ^* v' e
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    / R' y( _5 L, J! ]! @4 \7 ^4 @# w" g
21. }
    
22. 
    9 W$ b3 r6 `* z7 z0 |1 _
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    ' s3 p8 t. [% Z& F
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    
26. * @retval   无
    , L7 V# L, `. d  r( E/ _
27. */
    3 o; M& q! G) ?
28. void delay_us(__IO u32 nTime)
    
29. {
    # c) w9 n& z5 p2 ^
30.        TimingDelay= nTime;      
    
31.        //使能滴答定时器
    $ k6 K1 p: E* v+ e" t+ L+ F
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    
33. 
    
34.        while(TimingDelay!= 0);
    
35. }
    . [' S  ]/ ^8 f& j" V, N4 e
36. 
    
37. /**
    3 Z* n! o, V$ n1 e; x
38. * @brief      获取节拍程序
      _$ q2 ^$ }; k( X4 T; t6 Q
39. * @param      无
    - L4 u7 k" v9 P
40. * @retval     无
    $ T. H/ X% Q3 d% z) z. z5 |
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    + H5 v; N9 L( v) e/ R
42. */
      K$ U2 G1 x- m, \2 u: X
43. void TimingDelay_Decrement(void)
    
44. {
      _9 v/ J0 D3 D8 I4 t
45.        if(TimingDelay != 0x00)
    * r3 W/ j8 u! r; |: I# z
46.        {
    2 x# f) K9 {0 ^/ W: y( G* d
47.               TimingDelay--;
    
48.        }
    
49. }
    4 N) T% ^# ^+ ~$ e% n2 {$ g' Z% ~$ T
50. /**
    
51. 
    ' S: z" G6 X/ X1 C
52. * @brief  This function handlesSysTick Handler.
    7 r4 `# p7 e/ w7 b
53. * @param  None
    ! ^' P8 k% W: U3 ^% J0 ~
54. * @retval None
    
55. */
    
56. void SysTick_Handler(void)
    
57. {
    
58.        TimingDelay_Decrement();   
    6 x' A3 P5 k( N) @0 E4 \
59. }

复制代码

- m+ R& w  O% Q% m' R- U, M

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:系统时钟
   7 w6 u2 m6 s$ R4 t4 u
5. /**
   . R# N+ o1 G; X
6. * @brief  初始化延迟函数
   5 c, ~' E% {/ @. s, E3 F
7. * @param  None
   + G# I* k  a) c( Y% y( d4 V
8. * @retval None
   
9. */
   
10. void sysTick_init()
      x, [- l5 W. W+ i! ?
11. {
    & [* X' q4 l* U; \- m/ f+ `
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    0 X: s; K: u3 ?% ^
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    ( m2 H, t0 V0 I
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    ) I0 M( J  B2 M+ P
16. }                                                         
    5 u" E$ y( u7 }4 R0 P9 c
17.       
    
18. /**
    
19. * @brief  延时nus
    9 a; A5 P3 @, C$ S; u7 }
20. * @param  nus为要延时的us数.
    
21. * @retval None
    3 N) K, ]0 B! T; N8 R' q6 n$ ?2 n
22. */
    & w/ Z6 b) W  E$ m" B
23. void delay_us(u32 nus)
    / W$ f& e6 o: K. S; ~& X8 R
24. {            
    0 U( l& L# {! t6 O" u- ~' g
25.        u32temp;               
    # S  t( u  n8 |1 Q1 Q- }
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    % H" I1 X5 h: t" H
27.        SysTick->VAL=0x00;                                     //清空计数器
    
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    % v# w5 Y+ r6 b6 o. `3 n
29. 
    
30.        do
    . V0 [# ~# j7 S  Y+ H" k6 q
31.        {
    
32.               temp=SysTick->CTRL;
    $ w, O' `- B+ G' H+ c; }8 l$ x& G& d
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    9 o8 G2 b* N, D- M
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    / O- U# ~# @6 i6 o0 n6 V! m3 j$ {$ B
36. }
    
37. 
    6 x  s1 j2 K  K+ v# t4 i1 w* p5 ^5 s3 b
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    0 r; Y) Q  H: m% z+ P! c  @
39. //nms<=0xffffff*8*1000/SYSCLK
    # Z- O; v0 y- a- o" o1 [
40. //SYSCLK单位为Hz,nms单位为ms
    
41. //对72M条件下,nms<=1864
    
42. /**
    
43. * @brief  延时nms
    ) \, q( }! y# {
44. * @param  nms为要延时的nms数.
    
45. * @retval None
    ! c" d  m& H& P
46. */
    
47. void delay_ms(u16 nms)
    * i: V; f8 V2 }0 v
48. {                          
    
49.        u32temp;            
    
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    & l+ ?. ?' \# y
51.        SysTick->VAL=0x00;                                             //清空计数器
    
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    
53. 
    
54.        do
    
55.        {
    0 k, i! A3 X. u: v3 N
56.               temp=SysTick->CTRL;
    " i: G1 K( r, P: H
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    $ m: }5 `; N/ Y8 K
58. 
    
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
60.        SysTick->VAL=0X00;                                     //清空计数器              
    % r* D4 A! f( x8 Y1 j% ]7 N# A
61. }

复制代码

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

4 M) Y5 t! |: q: }8 N: d( O

3 RTOS延时

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

1. /*Includes*********************************************************************/
   
2. 
   ( m4 ^) n/ l5 i* ]% |
3. #include"./SysTick/stm32f103_SysTick.h"
   
4. 
   
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   0 T3 R' Q/ V5 @8 h. l3 L
8. #include "rtthread.h"                     //支持OS时，使用
   0 F+ K, N& V8 d2 t  L: V  w" a
9. #endif
   ' k4 U& d! ]- d+ E) n# \
10. 
    0 C, T! K  l1 n* N8 ~6 Y5 x
11. //********************************************************************************
    ( w# U2 z$ e/ b( u4 p" `/ Q" u( ?
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    
13. 
    ; {/ I0 W3 i; w4 _/ G* f: a
14. #if SYSTEM_SUPPORT_OS      
    
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    8 D/ P9 y$ \/ {; G* t
16. #endif
    / |" C! V# a) a! B4 k% @
17. 
    0 ]9 f$ q& H, `3 l& T3 k
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    
20. //首先是3个宏定义:
    " i, q' v2 p& k8 v8 t- C& u' J
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    ( l0 Y4 W3 d! C2 S, h) [
24. //然后是3个函数:
    $ l  i, k) f) Y* K0 e% u
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
    
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    0 w* v+ M! n2 ]/ a5 W1 @5 r; k4 W
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    
29. //支持RT-Thread
    
30. 
    7 t2 k& {. A& h1 [9 v8 d7 r
31. extern volatile rt_uint8_trt_interrupt_nest;
    , w/ J% w3 K5 q' R9 q- ~1 K
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    ) K& Q1 O2 k2 T# ^5 _, E
33. 
    3 ?6 v( ]2 {6 k! [1 v6 u1 x
34. uint8_t OSRunning=0;
    2 c: V: s) ], n2 N
35. 
    
36. #ifdef    RT_THREAD_PRIORITY_MAX                                        //RT_THREAD_PRIORITY_MAX定义了,说明要支持RT-Thread   
    
37. #define delay_osrunning         OSRunning                           //OS是否运行标记,0,不运行;1,在运行
    * C3 `' _4 ]# d) B
38. #define delay_ostickspersec   RT_TICK_PER_SECOND     //OS时钟节拍,即每秒调度次数
    
39. #define delay_osintnesting    rt_interrupt_nest             //中断嵌套级别,即中断嵌套次数
    ; Q+ g2 g# V4 l, g6 a
40. #endif
    : r; o( j- W& t* g0 e0 T
41. 
    / s" c0 b1 b/ b1 U0 ^
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    
43. void delay_osschedlock(void)
    
44. {
    
45. #ifdef RT_THREAD_PRIORITY_MAX
    
46.         rt_enter_critical();
    7 h0 H* d+ A7 `$ S8 f! f
47. #endif  
    
48. }
    
49. 
    
50. //us级延时时,恢复任务调度
    
51. void delay_osschedunlock(void)
    : ?/ Y) ^0 E$ e6 ^
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    8 j1 J$ K+ V5 U4 h! X
54.          rt_exit_critical();
    % N# d8 x& h# Y3 x! f
55. #endif  
    
56. }
    6 p. g: |4 |, C7 T+ |% h! E# f. O
57. //调用OS自带的延时函数延时
    
58. //ticks:延时的节拍数
    
59. void delay_ostimedly(uint32_tticks)
    
60. {
    
61. #ifdef RT_THREAD_PRIORITY_MAX
    
62.          rt_thread_delay(ticks);
    
63. #endif   
    / c  G* _) z6 r7 d
64. }
    
65. #endif
    
66.    
    + s. Y/ g1 ^( R2 Q6 ?) b  ^
67. //初始化延迟函数
    : W# ~' e$ {3 ^: p
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    
69. //SYSTICK的时钟固定为AHB时钟
    4 `4 H9 Z, S* y+ s6 C7 J( K
70. //SYSCLK:系统时钟频率
    
71. void delay_init()
    
72. {
    ( u( Z! G3 h' Y; M& s0 t% T, P3 M
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    
75. #endif
    3 |- s* [! Q# n" p1 s
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    ! b/ A; L4 V$ c( q; n1 d
81. 
    
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    " k$ W/ P) Q' l9 v; l/ C  M
83. 
    
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    ; n9 g" _; [8 B+ o0 [
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
    8 {5 z. ^& }% A9 i6 f! c
89. }                                                         
    
90. 
    " x% b4 |8 _) q( [7 s3 s
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    & t1 l# m& e# q( w
92. //延时nus
    
93. //nus:要延时的us数.   
    
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    
95. void delay_us(uint32_t nus)
    0 V; Y. Y1 \) j/ Q. y
96. {            
    % Y/ C( n& _! {$ `
97.        uint32_tticks;
    5 K$ A/ K: f3 d3 w; k& o
98.        uint32_ttold,tnow,tcnt=0;
    ' _  V8 U0 ^) M  Z: ]/ L
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    
100.        ticks=nus*fac_us;                                       //需要的节拍数
     ! d" h* k3 }9 w1 S, y& t$ h
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     
103. 
     
104.        while(1)
     
105.        {
     
106.               tnow=SysTick->VAL;  
     
107.               if(tnow!=told)
     
108.               {         
     
109.                      if(tnow<told)
     
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
111.                      else
     
112.                          tcnt+=reload-tnow+told;   
     6 J# y  p9 n- q/ m: f/ K4 c. J  \/ Q
113.                      told=tnow;
     
114.                      if(tcnt>=ticks)
       n. U6 h; p5 ~. y& F
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     
116.               }
     : Q) C7 B  h; }. j- Q" R8 v
117.        };
     % Z* |) u  s9 \
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     ; H, K, [" w' }6 T
119. }
     
120. 
     
121. //延时nms
     
122. //nms:要延时的ms数
     
123. //nms:0~65535
     5 Z1 p' `/ |, W8 N) k
124. void delay_ms(uint16_t nms)
     1 {, v: _. E6 ~# A
125. {     
     1 j) i3 u0 N. _
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     $ W9 x, R: i2 y2 Y- ^- l1 I. R
127.        {              
     
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     
129.               {
     
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     , W# g; u$ a( B, x% p
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     0 O, m$ b( _& s
133.        }
     * Y: ~  b& _1 y: A1 b7 w4 x
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     , m) S3 n2 B5 N: R- ^3 U
135. }
     . l* l2 v$ j6 M
136. 
     % Z1 r* |5 F4 ?4 F$ g6 a) y
137. #else  //不用ucos时
     
138. //延时nus
     
139. //nus为要延时的us数.
     % @6 l$ h7 k0 V2 X
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     
141. void delay_us(uint32_t nus)
     
142. {            
     & C. K) o+ m& ]+ w7 H9 S
143.        uint32_tticks;
     
144.        uint32_ttold,tnow,tcnt=0;
     5 G/ E* A) D) E, n" D& L
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     ( G* w' C1 _* A2 r0 ^: F+ \
146.        ticks=nus*fac_us;                                       //需要的节拍数
     
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     3 y  Q6 o# m3 O% D/ [" G& g8 k( s
148.        while(1)
     
149.        {
     
150.               tnow=SysTick->VAL;  
     
151.               if(tnow!=told)
     ' C% y8 v1 S' j6 W4 @# {' ^
152.               {         
     
153.                      if(tnow<told)
     
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
155.                      else
     
156.                         tcnt+=reload-tnow+told;   
     
157.                      told=tnow;
     
158.                      if(tcnt>=ticks)
     + i- R* E  t) s% O
159.                         break;                //时间超过/等于要延迟的时间,则退出.
       S5 f; D# b# W. R9 f2 B
160.               }
     ; ]0 j- H* ~; T! C) |( }
161.        };
     
162. }
     8 ]6 X2 f+ ^& a3 E
163. //延时nms
     
164. //nms:要延时的ms数
     
165. void delay_ms(uint16_t nms)
     
166. {
     ' H  ?7 Z$ A6 e: c3 k* f4 x
167.        uint32_ti;
     
168.        for(i=0;i<nms;i++)
     
169.        {     
     - S+ R! b: g* j% C$ u3 x
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]

文章出处：  嵌入式实验楼

4 h1 B! z& y) ~" h

收集归纳比较好！

学习了，mark一下

这叫什么高精度呀，只能说是普通石英晶体振荡器的精度。
# F! w, \: v" U2 z( t
要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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