STM32高精度延时实验

9 D. G" }+ R+ M, v% a( o

1 前言

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

2 裸机延时

2.1普通延时

1. //粗延时函数，微秒
   
2. void delay_us(u16 time)
   
3. {   
   ( R9 z5 U5 u7 }* l
4.    u16 i=0;
   1 N  G3 [0 k, c1 E- R# z
5. 
   
6.    while(time--)
   
7.    {
   
8.       i=10; //自己定义
   
9.       while(i--) ;   
   - L' L6 t* z( F( o: \- l1 b3 _& k
10.    }
    9 g2 \# I# K# f2 d) M
11. }
    : E2 p3 s! y2 b6 l" ^
12. 
      }* R) ~2 }& P% J
13. //毫秒级的延时
    & j% B& j' ~  a. l2 c* ~( ~/ r: r
14. void delay_ms(u16 time)
    
15. {   
    
16.    u16 i=0;
    - Z2 }1 U* m$ B
17. 
    ' y- T1 `4 y- Y# B
18.    while(time--)
    
19.    {
    / }- d1 f! J) N9 R3 A% T4 ~
20.       i=12000; //自己定义
    
21.       while(i--) ;   
    % v  h, V. k( b
22.    }
    
23. }

复制代码

& A8 Z8 U( ?% ]# @" `

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

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. 
   4 ~1 L+ X; ~8 J! s
3. //延时n_ms
   
4. void delay_ms(volatile unsignedlong nms)
   * h$ B, r+ e# R, |
5. {
   
6.   //SYSTICK分频--1ms的系统时钟中断
   
7. if (SysTick_Config(SystemFrequency/1000))
   % C, D+ n+ {5 _% I& T8 M" I1 b# R
8. {
     P8 K% h9 Z+ R, Y
9.        while (1);
   ! q7 L4 K# M# ]8 D5 S# a( Q$ A7 u
10. }
    
11. 
    $ k8 T! _0 E; o, n
12. time_delay=nms;//读取定时时间
    
13. 
    
14. while(time_delay);
    
15. 
    
16. SysTick->CTRL=0x00; //关闭计数器
    , m6 `: F! a  D5 L9 @
17. SysTick->VAL =0X00; //清空计数器
    
18. }
    7 c3 p1 p  j$ Q; Y8 l$ b. B
19. 
    5 m. \# t, {! X" j. O7 x
20. //延时nus
    ( ^# E) P2 s' F* K* ]" o
21. void delay_us(volatile unsignedlong nus)
    
22. {
    
23. //SYSTICK分频--1us的系统时钟中断
    4 d$ ~; O9 z) L! L& ?% v
24. if (SysTick_Config(SystemFrequency/1000000))
    5 J: o  g: @/ h' W; Z+ S
25. {
    + @, l) o8 g6 H; p7 s; S9 z
26.        while (1);
    . C2 `/ g. Q2 W* @6 f( u$ G6 R* e' p
27. }
    ; L1 ~$ ^0 G# |2 q
28. 
    
29. time_delay=nus;//读取定时时间
    
30. while(time_delay);
    ' e8 Z' `/ z; W2 F6 v. h8 @
31. SysTick->CTRL=0x00; //关闭计数器
    
32. SysTick->VAL =0X00; //清空计数器
    1 P% I5 \" t; }' f  N
33. }
    
34. 
    
35. //在中断中将time_delay递减。实现延时
    
36. void SysTick_Handler(void)
    & n$ k% x4 t4 d. D1 d5 e4 F; Z& d
37. {
    
38. if(time_delay)
    
39.         time_delay--;
      g1 g  g0 T* z, o7 r2 ~/ Z9 i* J
40. }

复制代码

) r9 i* c" @3 e& e

还有一种标准写法：

1. static __IO u32 TimingDelay;
   
2. #define delay_ms(x) delay_us(1000*x)       //单位ms
   ( J: p1 n/ t2 z1 `0 H
3. /**
   
4. * @brief   启动系统滴答定时器 SysTick
   
5. * @param   无
   3 ~# \8 u: s# ~4 P$ H. L
6. * @retval  无
   " J; T; }1 m3 ?) v9 @+ W
7. */
   
8. void sysTick_init(void)
   
9. {
   
10.        /*SystemFrequency / 1000    1ms中断一次
    / m, ?* R- C( z) h* X/ ^1 @% D
11.         * SystemFrequency / 100000 10us中断一次
    . }2 B! N+ T; g  @) ~# b" L) p
12.         * SystemFrequency / 1000000 1us中断一次
    - N$ C+ B: ^' q2 j: p; `  _$ }
13.         */
    9 w1 X+ Q; p8 h9 v$ a0 ?
14.        if(SysTick_Config(SystemCoreClock / 1000000))       //ST3.5.0库版本
    
15.        {
    
16.               /*Capture error */
    
17.               while(1);
    7 J( r% `" |) V, E, D. B
18.        }
    
19.        //关闭滴答定时器
    3 |1 C3 M/ y& u6 D
20.        SysTick->CTRL&= ~ SysTick_CTRL_ENABLE_Msk;
    ( t- ?) A+ z& s' r
21. }
    , q& _+ ]  X6 s. @
22. 
    
23. /**
    
24. * @brief    us延时程序,1us为一个单位
    
25. * @param    nTime: Delay_us( 1 ) 则实现的延时为 1 * 1us = 1us
    
26. * @retval   无
    ! ]+ |$ P. ?6 D2 _: B# f9 M  b
27. */
    ' {( c) A4 ^* O. F$ m
28. void delay_us(__IO u32 nTime)
    - ?. ~( S3 |9 E7 M& q
29. {
    & c! D2 ~; V1 H" l5 n
30.        TimingDelay= nTime;      
    * y, F. Q: w$ r0 N1 }. q
31.        //使能滴答定时器
    
32.        SysTick->CTRL|=  SysTick_CTRL_ENABLE_Msk;
    
33. 
    5 J+ H9 M) }  j, X+ g! k$ ^
34.        while(TimingDelay!= 0);
    
35. }
    & ~! p6 J  y' P9 _
36. 
    
37. /**
    
38. * @brief      获取节拍程序
    : `3 w) ~" k! H
39. * @param      无
    * d# c' h* e# w" b  B7 ]
40. * @retval     无
    : _$ a5 J6 x2 z; c
41. * @attention  在 SysTick 中断函数 SysTick_Handler()调用
    0 O, U$ x' i$ r' n& Z
42. */
    ' _/ @5 S7 _9 H$ X5 ^/ r2 g* {. \
43. void TimingDelay_Decrement(void)
    8 J8 v& h# @, F; a& N
44. {
    ! g, M9 o& P) x! s6 `
45.        if(TimingDelay != 0x00)
    
46.        {
    , ?' t7 b1 Y$ M, s  V8 E: [0 u
47.               TimingDelay--;
    / O# Z7 {8 o8 U
48.        }
    
49. }
    & }$ u6 ]$ F' q7 ]$ s. \
50. /**
    " F% y( O' v; ^- F; f& G! P
51. 
    
52. * @brief  This function handlesSysTick Handler.
    
53. * @param  None
    9 k3 V" a/ x- [4 q4 C1 @( K
54. * @retval None
    
55. */
    
56. void SysTick_Handler(void)
    
57. {
    
58.        TimingDelay_Decrement();   
    / }2 R& g, w# l/ Y
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延时倍乘数                 
   . H! |$ I) Z+ ?' }$ B/ w
2. static u16 fac_ms=0;                                            //ms延时倍乘数
   
3. //SYSTICK的时钟固定为HCLK时钟的1/8
   
4. //SYSCLK:系统时钟
   , l/ K% u, f1 }, ?
5. /**
   
6. * @brief  初始化延迟函数
   
7. * @param  None
   
8. * @retval None
   
9. */
   
10. void sysTick_init()
    & w* i+ a7 z  w  g$ R
11. {
    9 n) N+ q/ O9 j
12.        //SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    
13.        SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
    % u2 [9 k! Y  `% S7 a
14.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    & v, ^- a& B0 N: ~5 r* H
15.        fac_ms=(u16)fac_us*1000;                                 //非OS下,代表每个ms需要的systick时钟数  
    * x3 l# Z. I5 m/ w2 D
16. }                                                         
    4 v# c6 D: }6 r0 g# S0 |
17.       
    
18. /**
    
19. * @brief  延时nus
    ; [; _& n+ @" {( _
20. * @param  nus为要延时的us数.
    
21. * @retval None
    
22. */
    
23. void delay_us(u32 nus)
    
24. {            
    ) i: [2 m* I+ g6 E% E9 C* \
25.        u32temp;               
    
26.        SysTick->LOAD=nus*fac_us;                              //时间加载              
    
27.        SysTick->VAL=0x00;                                     //清空计数器
    
28.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数   
    
29. 
    
30.        do
    2 \% e  C" a" w" D4 B' K' `  W$ g( g
31.        {
    
32.               temp=SysTick->CTRL;
    
33.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    7 I% Z2 T0 c" G8 p$ |3 |
34.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
35.        SysTick->VAL=0X00;                                       //清空计数器   
    : d  H9 ?* `9 A- x' U+ l
36. }
    ( h( T0 H; V; V4 q3 G5 o
37. 
    9 Q# ?" C7 b" A$ [8 G
38. //SysTick->LOAD为24位寄存器,所以,最大延时为:
    
39. //nms<=0xffffff*8*1000/SYSCLK
    
40. //SYSCLK单位为Hz,nms单位为ms
    " I% i3 t+ ?7 q! K' ]2 ^0 Z; s, h
41. //对72M条件下,nms<=1864
    2 N7 M& O! v4 [  K
42. /**
    
43. * @brief  延时nms
    
44. * @param  nms为要延时的nms数.
    4 X  A6 {$ u2 ?  c& {
45. * @retval None
    
46. */
    
47. void delay_ms(u16 nms)
    
48. {                          
    # w; f3 R$ w! s4 o' ^
49.        u32temp;            
    3 s3 ?" W) _6 x' k
50.        SysTick->LOAD=(u32)nms*fac_ms;                    //时间加载(SysTick->LOAD为24bit)
    
51.        SysTick->VAL=0x00;                                             //清空计数器
    
52.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;    //开始倒数
    
53. 
    
54.        do
    
55.        {
    . P- b% M" S) p( U" c6 ?; i
56.               temp=SysTick->CTRL;
    3 H% [7 S& q' ?. X8 Q, l' G
57.        }while((temp&0x01)&&!(temp&(1<<16)));         //等待时间到达  
    , B8 V) {& f0 s7 U+ g5 S+ f
58. 
    
59.        SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;//关闭计数器
    
60.        SysTick->VAL=0X00;                                     //清空计数器              
    
61. }

复制代码

5 U$ B, f5 D& ~" T

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

; A1 Q8 E8 }7 M' V# c

3 RTOS延时

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

1. /*Includes*********************************************************************/
   ! I: X9 n7 V! I  E3 \4 B+ c
2. 
   6 H4 C% y' T5 B2 P, U  {8 n
3. #include"./SysTick/stm32f103_SysTick.h"
   * v  T; |# P% x; K8 `' m- v
4. 
   
5. #define SYSTEM_SUPPORT_OS             1            //定义系统文件夹是否支持UCOS
   
6. //如果使用rt-thread,则包括下面的头文件即可.
   
7. #if SYSTEM_SUPPORT_OS
   
8. #include "rtthread.h"                     //支持OS时，使用
   + b0 p) k$ w# E0 J- t% ]7 O$ F
9. #endif
   0 E1 w# L# @9 y3 }! I. }% }
10. 
    # ]; }; t2 u/ O9 Y1 A$ M
11. //********************************************************************************
    8 X9 Z! o: _: T
12. static uint32_t fac_us=0;                                            //us延时倍乘数
    . c7 @; ^( n, d( z* P2 o% v
13. 
    ( M8 s) V% v; [0 t& X2 }% ^
14. #if SYSTEM_SUPPORT_OS      
    ) f; j5 r6 l9 a6 W5 ^
15.     static uint16_t fac_ms=0;                             //ms延时倍乘数,在os下,代表每个节拍的ms数
    
16. #endif
    
17. 
    
18. #if SYSTEM_SUPPORT_OS                                          //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于rt-thread).
    ; a  q% ~, o/ Z2 V% H
19. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    
20. //首先是3个宏定义:
    5 o: i) w% Z3 A+ n  z& K: ?
21. //delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
22. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    0 l0 z' \2 |# q5 i3 W2 w: s# [
23. //delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    1 t9 z0 n: ^0 Y( Z( u, X7 ^! c
24. //然后是3个函数:
    
25. //delay_osschedlock:用于锁定OS任务调度,禁止调度
    
26. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    9 d0 u0 o% g' A/ E
27. //delay_ostimedly:用于OS延时,可以引起任务调度.
    3 K0 q# D. A7 j0 u: q; x
28. //本例程仅作RT-Thread的支持,其他OS,请自行参考着移植
    0 A3 N9 X. ~2 k. G: N: `
29. //支持RT-Thread
    
30. 
    3 Q4 u- C% y2 o: K6 O4 m; O
31. extern volatile rt_uint8_trt_interrupt_nest;
    . A0 ?( `' \) {. F) q  u
32. //在board.c文件的rt_hw_board_init()里面将其置为1
    
33. 
    5 r  k4 }  M: g
34. uint8_t OSRunning=0;
    
35. 
    
36. #ifdef    RT_THREAD_PRIORITY_MAX                                        //RT_THREAD_PRIORITY_MAX定义了,说明要支持RT-Thread   
      Q- F( s1 m; h& z% s) g, F
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. 
    
42. //us级延时时,关闭任务调度(防止打断us级延迟)
    / ?* Z+ ~' R$ {/ j
43. void delay_osschedlock(void)
    $ U% i: w" w! ~' J
44. {
    
45. #ifdef RT_THREAD_PRIORITY_MAX
      @; ~4 o. K3 `% S+ l
46.         rt_enter_critical();
    
47. #endif  
    
48. }
    8 e, y1 G; x4 D
49. 
    
50. //us级延时时,恢复任务调度
    9 x5 @) U3 L! R8 V+ `! I
51. void delay_osschedunlock(void)
    
52. {     
    
53. #ifdef RT_THREAD_PRIORITY_MAX
    / K0 i0 C2 c; x
54.          rt_exit_critical();
    : @. |# w& ^2 s. T3 {( w4 Q- }) Z
55. #endif  
    1 Y4 X; f: \: S" e
56. }
    
57. //调用OS自带的延时函数延时
    - `/ `- s4 }% V& |4 Y
58. //ticks:延时的节拍数
    $ ?& k  b  D+ k* v
59. void delay_ostimedly(uint32_tticks)
    
60. {
    * K2 R2 L1 ?# x/ q* M
61. #ifdef RT_THREAD_PRIORITY_MAX
    
62.          rt_thread_delay(ticks);
    
63. #endif   
    
64. }
    
65. #endif
    0 z0 e/ W$ ^3 ?' I
66.    
    
67. //初始化延迟函数
    ) K: `- ]4 i5 {7 n
68. //当使用ucos的时候,此函数会初始化ucos的时钟节拍
    
69. //SYSTICK的时钟固定为AHB时钟
    % R- i9 t0 O: z. i% E# ]6 u3 i
70. //SYSCLK:系统时钟频率
    7 U" \& _8 V* A1 [/ n
71. void delay_init()
    : u+ G  p7 J2 H% x6 v4 p7 R
72. {
    
73. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
74.        uint32_treload;
    1 A+ ^" M# H1 M7 e$ w
75. #endif
    
76. SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);      //选择外部时钟  HCLK/8
    5 I7 C; D. C! \( @% s
77.        fac_us=SystemCoreClock/8000000;                           //为系统时钟的1/8
    
78. #if SYSTEM_SUPPORT_OS                                                   //如果需要支持OS.
    % |) b- S5 ~- Y) r; B/ d+ _
79.        reload=SystemCoreClock/8000000;                           //每秒钟的计数次数单位为K              
    
80.        reload*=1000000/delay_ostickspersec;      //根据delay_ostickspersec设定溢出时间
    
81. 
    ! o7 R: i8 G! N) y
82.                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右     
    5 K) D% y. F; s
83. 
    
84.        fac_ms=1000/delay_ostickspersec;              //代表OS可以延时的最少单位      
    
85.        SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;//开启SYSTICK中断
    $ o# a7 h4 P* o
86.        SysTick->LOAD=reload;                                     //每1/OS_TICKS_PER_SEC秒中断一次
    2 b) f' P- c7 o; a/ R6 H2 |( H
87.        SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;//开启SYSTICK
    * b; F" T; d; v/ c( p5 g
88. #endif
    * I, ?$ j9 K. q  T; V4 H4 {
89. }                                                         
    / U- B( e4 W, |& o
90. 
    ! B) }( l# o; H6 o" z. Z
91. #if SYSTEM_SUPPORT_OS                                         //如果需要支持OS.
    
92. //延时nus
    
93. //nus:要延时的us数.   
    
94. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)                                                                 
    : u' L+ `9 [$ i6 h4 F6 i
95. void delay_us(uint32_t nus)
    
96. {            
    . J5 c2 x6 u" W* u
97.        uint32_tticks;
    + L/ ^9 F$ t; [2 F
98.        uint32_ttold,tnow,tcnt=0;
    . ]+ A/ _7 H. k- ?
99.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
    3 O  }/ G: I2 k# ]' c7 q4 u9 X* P
100.        ticks=nus*fac_us;                                       //需要的节拍数
     
101.        delay_osschedlock();                             //阻止OS调度，防止打断us延时
     2 e% `  |, W. S9 O6 W
102.        told=SysTick->VAL;                                //刚进入时的计数器值
     5 p7 t7 e/ D! w  g
103. 
     2 }) H2 e0 ~5 ^+ A, [4 I- V. C" }) C
104.        while(1)
     
105.        {
     ) m6 S  H: q: q* e0 I- h6 r6 V
106.               tnow=SysTick->VAL;  
     - \) K& Y$ @2 e% M7 \4 Z* i7 q
107.               if(tnow!=told)
     5 D8 t# i2 E+ a; L! O- J
108.               {         
     4 p4 |& s. @- G9 V
109.                      if(tnow<told)
     2 R/ x  J# M4 F+ ~4 t! O
110.                          tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     
111.                      else
       m7 {' K& ~1 Z' j( P* Y
112.                          tcnt+=reload-tnow+told;   
     
113.                      told=tnow;
     
114.                      if(tcnt>=ticks)
     
115.                         break;                //时间超过/等于要延迟的时间,则退出.
     
116.               }
     / J% |$ |* q2 j, @- q+ I& D+ q5 r
117.        };
     : ?# J& q) e! R4 w
118.        delay_osschedunlock();                                //恢复OS调度                                                                           
     
119. }
     8 n# K% E! ?# e  @6 L6 t5 n# A
120. 
     1 J3 U# `4 l5 K
121. //延时nms
     
122. //nms:要延时的ms数
     0 O7 m  p  {: b# |
123. //nms:0~65535
     ' \3 p6 k' h6 h1 ^+ ~/ y
124. void delay_ms(uint16_t nms)
     
125. {     
     * t- k3 |/ p- ?8 t+ u! n' b
126.        if(delay_osrunning&&delay_osintnesting==0)//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)        
     1 z) {3 g0 A( ]4 U9 J* Y% s
127.        {              
     6 m2 M/ D8 e! Z& b3 b3 O/ B2 Y
128.               if(nms>=fac_ms)                                    //延时的时间大于OS的最少时间周期
     
129.               {
     
130.                   delay_ostimedly(nms/fac_ms);      //OS延时
     ' K( ^  R% b/ u7 R: s5 C: T. `
131.               }
     
132.               nms%=fac_ms;                                       //OS已经无法提供这么小的延时了,采用普通方式延时   
     ; C% |5 I8 z- l% d8 \" K. h
133.        }
       x9 P! O6 p. p
134.        delay_us((uint32_t)(nms*1000));                       //普通方式延时
     9 f9 N. o$ h$ L7 g, F
135. }
     
136. 
     ) m% L$ B( p- B
137. #else  //不用ucos时
     
138. //延时nus
     + _* \+ p; a' s$ k7 w6 n
139. //nus为要延时的us数.
     
140. //nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)   
     
141. void delay_us(uint32_t nus)
     
142. {            
     , @, e) F) K- p, ?/ \; B1 q
143.        uint32_tticks;
     
144.        uint32_ttold,tnow,tcnt=0;
     - k1 z, `/ E; L5 P5 b4 ?
145.        uint32_treload=SysTick->LOAD;                         //LOAD的值                  
     + R6 i5 a8 E/ |+ W; C# C/ D
146.        ticks=nus*fac_us;                                       //需要的节拍数
     " b) W8 B: p3 ?: R, f" M: y
147.        told=SysTick->VAL;                                //刚进入时的计数器值
     7 C, ~, i7 F6 z, h; `$ a4 s
148.        while(1)
     
149.        {
     7 ~, p% J+ g* s# C$ Q. B& {
150.               tnow=SysTick->VAL;  
     
151.               if(tnow!=told)
     
152.               {         
     
153.                      if(tnow<told)
     
154.                         tcnt+=told-tnow;//这里注意一下SYSTICK是一个递减的计数器就可以了.
     7 u# p5 l. W/ Z9 F) f$ ?- D
155.                      else
     
156.                         tcnt+=reload-tnow+told;   
     
157.                      told=tnow;
     / Q- V6 _1 z, H1 J4 H) t
158.                      if(tcnt>=ticks)
     
159.                         break;                //时间超过/等于要延迟的时间,则退出.
     
160.               }
     
161.        };
     
162. }
     1 m9 L; i! |. V: j/ U4 ]8 O. A
163. //延时nms
     
164. //nms:要延时的ms数
     
165. void delay_ms(uint16_t nms)
     
166. {
     ' t8 J+ H3 F* Y. Y" P3 q$ M% a
167.        uint32_ti;
     9 p7 Q- ~# k7 L' h9 m% h3 G. f) j: E
168.        for(i=0;i<nms;i++)
     $ M- h! D# a4 P2 `# W; d+ x% ?
169.        {     
     
170.               delay_us(1000);
       i, |/ n( U% H1 d$ U1 }
171.        }
     $ k# A1 M( v" r6 h& d! U# y$ U) f
172. }
     ' e2 D( i0 u/ v3 E
173. #endif

复制代码

- [; G) s9 Y( y3 W1 s+ p

以上代码适配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 z0 ~7 G' Y3 V! Z" j
# b9 Y* J1 f; W要能够保证连续运行一个月，时间累计误差不超过几秒钟的，才对得起高精度一词。

good job

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

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