一、SysTick（系统滴答定时器）概述

　　操作系统需要一个滴答定时器周期性产生中断，以产生系统运行的节拍。在中断服务程序里，基于优先级调度的操作系统会根据进程优先级切换任务，基于时间片轮转系统会根据时间片切换任务。总之，滴答定时器是一个操作系统的“心跳”。

　　Cortex-M3在内核部分封装了一个滴答定时器--SysTick，在之前的ARM内核通常是不会把定时器做进内核，定时器都是SOC厂商自己制作的外设。显然，Cortex-M3封装了这么一个定时器，对于将操作系统移植到不同SOC厂商生产的Cortex-M3系类MCU上，带来了极大的方便。Cortex-M3内核统一了这样的一个系统滴答定时器，移植操作系统的时候可以使用内核的定时器，而忽略掉不同厂商生产定时器带来的分歧。

二、SysTick control and status register(STK_CTRL)

　　SysTick的控制是极其简单的，它的控制和状态都汇聚在同一个寄存器STK_CTRL上。

3 [1 K' [. e3 s

- w9 @8 ?. a+ O9 l

　　STK_CTRL的每一位的含义英文解释都是很清晰的，不必多说。需要额外讨论的是COUNTFLAG标志位，这个标志位代表的含义是：当计数为0时，也即STK_VAL计数至0时，此标志位置1。

　　经过笔者一番摸索，对此位有更多的看法。

COUNTFLAG:　　

1、此位与SysTick的中断无关，不是中断标志位，可以算作事件标志位（计数至0事件）。

2、此位可以用作软件查询

3、读写此寄存器都会硬件自动更新COUNTFLAG的值，当然此位的值软件也是可以改写的。也就是说，倘若我们轮训查看COUNTFLAG是否置1（也就是计数是否结束）。当SysTick硬件上计数为0，COUNTFLAG因此硬件自动置1。在我们软件读取STK_CTRL的时候，其实SysTick的STK_VAL的值已经不是0（因为自动重装，并且可能计时几个CLK了）。这个时候我们读取到了COUNTFLAG的标志位的1，同时也将COUNTFLAG自动清零。

三、滴答定时器应用之精准延时函数

1、函数实现思路

　　函数实现使用“轮询状态位COUNTFLAG”实现精准延时节拍10us。

　　在使用的时候，首先调用函数SysTick_Init配置SysTick的定时周期为10us。在延时函数中，当启动定时器后，就调用函数SysTick_GetFlagStatus轮询是否定时10us结束，如果结束就更新一下延时节拍变量nTime。

　　由于SysTick定时器自动重装计数器初值，而且SysTick_GetFlagStatus在检测到SET的时候，COUNTFLAG也自动清理。所以软件不必装定时器初值，也不必手动清除标志位COUNTFLAG。

2、函数实现代码

1. #include "bsp_sysTick.h"
   ' J  E( }" V  ?3 \" @5 @1 C) p" P
2. 
   
3. /**
   - b* n% [4 L. W7 l% t
4.   * @brief  读取SysTick的状态位COUNTFLAG
   
5.   * @param  无
   
6.   * @retval The new state of USART_FLAG (SET or RESET).
   
7.   */
   
8. static FlagStatus SysTick_GetFlagStatus(void)
   $ y# m! O/ N7 R1 L
9. {
   8 P, s2 b& D+ I+ f/ s7 a
10.     if(SysTick->CTRL&SysTick_CTRL_COUNTFLAG_Msk)
    7 ]$ I1 g4 J, C& n2 c& T
11.     {
    , k" y* O0 f) s# Q' I4 e
12.         return SET;
    
13.     }
    
14.     else
    
15.     {
    ' A# F' X2 ^; |
16.         return RESET;
    
17.     }
    9 W2 |; b1 r2 H! U3 w
18. }
    + M4 y& d" @! E6 L
19. 
    ( R( J* G+ c7 }/ Q1 w6 f
20. /**
    
21.   * @brief  清除SysTick的状态位COUNTFLAG
    
22.   * @param  无
    
23.   * @retval 无
    
24.   */
    
25. static void SysTick_ClearFlag(void)
    
26. {      
    / \2 t1 e9 T8 {3 w  I# U9 D8 \4 g
27.       SysTick->CTRL &= ~ SysTick_CTRL_COUNTFLAG_Msk;
    4 E. z$ ?9 ?" G3 q% k( \
28. }
    ) e) {" _# ?3 ~" S  P: j% t
29. 
    
30. /**
    
31.   * @brief  配置系统滴答定时器 SysTick
    . N" Y1 [# }# l' Y* q1 Y
32.   * @param  无
    * y; t  U$ u; I( {) c
33.   * @retval 1 = failed, 0 = successful
    , Q0 ]( I/ \4 X# Y* F! ~
34.   */
    
35. uint32_t SysTick_Init(void)
      z# p& a7 g$ S! U& f
36. {
    / J; ?. M% x1 G2 _# m% G
37.     /* SystemFrequency / 1000    1ms中断一次
    
38.      * SystemFrequency / 100000     10us中断一次
    
39.      * SystemFrequency / 1000000 1us中断一次
    
40.      */
    
41. 
    
42.        /* 设置定时周期为10us  */
    
43.     if (SysTick_Config(SystemCoreClock / 100000))
    ; H$ k, E" O$ N: O5 n2 B2 V; v* O
44.     {
    0 x& |3 y- {" T2 ~- _
45.         /* Capture error */
    ' W  V3 o" }3 p* A* a( C
46.         return (1);
    
47.     }
    
48. 
    
49.     /* 关闭滴答定时器且禁止中断  */
    $ g" U3 S+ v& q4 w  n- R' k
50.     SysTick->CTRL &= ~ (SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk);                                                  
    7 @) J3 q9 L- l  f, Q3 C
51.     return (0);
    * F) r2 @4 M+ L0 e6 A& d9 C6 L
52. }
    8 y8 m& ]5 J5 d4 Y8 R) a
53. 
    
54. /**
    
55.   * @brief   us延时程序,10us为一个单位
    # u; X. ~' W$ z2 O9 d2 c, F) Q
56.   * @param  
    
57.   *        @arg nTime: Delay_us( 1 ) 则实现的延时为 1 * 10us = 10us
    ; e2 b1 M" C  s) w1 M
58.   * @retval  无
    " }5 H2 d$ _8 C0 _5 `0 v
59.   */
    
60. void Delay_us(__IO uint32_t nTime)
    
61. {     
    ' L  a& n8 K! {  a8 u! w
62.     /* 清零计数器并使能滴答定时器 */  
    
63.     SysTick->VAL   = 0;  
    
64.     SysTick->CTRL |=  SysTick_CTRL_ENABLE_Msk;     
    3 `6 R- Q* x6 L; K+ b- ~
65. 
    7 Q( ^" s/ ~3 b$ q# l
66.     for( ; nTime > 0 ; nTime--)
    " r/ k/ R5 l2 N% I* {* J( S
67.     {
    
68.      /* 等待一个延时单位的结束 */
    3 A6 q6 L, _/ n: S
69.      while(SysTick_GetFlagStatus() != SET);
    
70.     }
    4 C, S- l& b: l5 Q
71. 
    0 K+ x9 Y4 o3 |! B" G8 E+ i/ }
72.     /* 关闭滴答定时器 */
    
73.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    
74. }

复制代码

3、函数的优点和缺陷

优点：

　　使用轮询法实现精准延时是可靠的，因为硬件自动重装定时器初值，只要我们在下一次计数结束（为0）之前，将节拍计数变量nTime更新，那么这个延时函数就是可靠的。

　　使用轮询法的另一个好处是没有用到全局变量，完全是局部变量搞定了所需功能。倘若使用中断延时，必须利用全局变量给精准延时函数传递参数。

缺陷：

　　由于使用的是轮询法，有可能被其他的中断打断，假设其他的中断的服务时间有很长，使得“在下一次计数结束（为0）之前，没有将节拍计数变量nTime更新”，那么延时的时间将要增长。

4、注意

　　此延时函数的最小分辨率不能设置为1us，最好设置为>=10us，这是因为轮训的周期和1us相比具有可比性，时间误差太大。

四、滴答定时器应用之程序段计时

1、函数实现思路

　　首先对滴答定时器初始化，计时节拍数是计数器的最大值。在感兴趣的程序段开始处，启动定时器，在程序段的结束处关闭定时器。倘若这段时间很长，超过了计数器的计数最大值，就会在中断函数中对溢出次数进行计数。最终的程序段时间决定于计数器的数据寄存器SysTick->VAL 中的剩余值和中断溢出次数。

　　另外为了使程序能够对不同的程序段或者不同情况下的程序段进行计时，使用了一个结构体定义保存计时数据的结构体类型。在对程序段进行计时的时候，通过一个运行指针指向所要保存的变量中。　　

2、函数代码　　

① User_SysTick.c

1. /**
   : S7 ?6 [% M' l( w
2.   ******************************************************************************
   
3.   *计时最小单位：1/72M s
   
4.   *计时最大长度：2^32/72M = 59.65 s
   7 c. _% ^. O, m8 N
5.   *使用方法：
   ' Y; i0 Y4 b2 f4 A  W9 M9 G- Z
6.   *(1) 定义一个保存计时数据的TimingVarTypeDef类型变量Time
   
7.   *(2) 初始化
   8 P6 |- ^* W, ]/ \2 k/ b
8.   *       SysTick_Time_Init(&Time);
   
9.   *(3) 在while循环中放置启动/停止函数
   , w7 J' \. }2 Q+ B
10.   *     while(1){
    ; b0 c# N, f2 N
11.   *            SysTick_Time_Start();
    
12.   *         测试运行时间的代码
    
13.   *            SysTick_Time_Stop();
    
14.   *        }
    6 j% J4 [/ |0 w" ^4 U" F( H3 x7 I: R
15.   ******************************************************************************
    
16.   */
    - m+ X$ S; Y) U( M  T
17. 
    8 G* M$ _9 Z7 w  j
18. /* 定义保存未使用DMA时测试程序段运行时间的变量 */
    $ [. v8 L0 ?" E
19. TimingVarTypeDef Time;
    , q5 o0 ]0 h0 h) p9 g+ B6 {7 a* J2 h
20. 
    # K/ Z- g2 [% i
21. /* 指针指向当前保存时间的变量 */
    
22. TimingVarTypeDef * CurrentTimingVar;
    
23. 
    
24. /* 系统滴答定时器的中断次数 */
    
25. uint32_t TimeupTimes;
    - u5 G0 N3 l% V
26. 
    
27. /**
    
28.   * @brief  配置系统滴答定时器 SysTick
    3 O! j% w5 P( p1 B- r+ E4 K
29.   * @param  无
      b( P3 z$ V5 G
30.   * @retval 1 = failed, 0 = successful
    # o. j& l* {" s; l3 W' K8 Z5 L
31.   */
    8 G% R' c! ^; _' i
32. uint32_t SysTick_Init(void)
    
33. {
    2 S& c/ ~. g' [, k1 o
34.        /* 设置定时周期为最大定时数SysTick_LOAD_RELOAD_Msk  */
    - g3 n& \0 I' o, p
35.     if (SysTick_Config(SysTick_LOAD_RELOAD_Msk))
      y* ^/ v/ y* w: }1 k5 M( i
36.     {
    
37.         /* Capture error */
    
38.         return (1);
    - Q; b" Y, X" k
39.     }
    3 N; l6 F+ z  o/ t* z4 m3 x, b
40. 
    
41.     /* 关闭滴答定时器且禁止中断  */
    - b' y% Z9 s9 O; l
42.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;                                                  
    ( R& F3 g' P5 M1 Z' Z7 b
43.     return (0);
    
44. }
    
45. 
    ) j/ I; W6 M  S. w, p
46. /**
    
47.   * @brief  滴答定时器 SysTick 计时初始化
    # y) i3 {9 E% Q$ C9 m8 b5 l" |
48.   * @param  初始化计时变量的成员--计时次数
    
49.   * @retval 无
    . E+ l- _. m  D7 ~; w& G/ U
50.   */
    
51. void SysTick_Time_Init(TimingVarTypeDef * TimingVar)
    
52. {
    # C$ f1 ]: B2 A$ f, z
53.        /* 指针指向当前保存时间的变量 */
    " e% f6 f# ^$ i. h0 w- p) r
54.      CurrentTimingVar = TimingVar;
    7 Q8 m; k! ^* @$ j9 n1 r3 v  Y4 D
55.     /* 计时次数初始化 */   
    % g( W( q6 ^6 t0 z0 e& T9 `
56.      CurrentTimingVar->SetSaveTimesNum = SaveTimesBufNum - 2;
    1 n/ `) [* ~, k3 d3 u
57. }
    
58. 
    
59. /**
    1 W+ [: S- l- v. d2 l. w; e5 Y
60.   * @brief  滴答定时器 SysTick 计时启动
    
61.   * @param  无
    ) C! X! S9 z! J7 p0 j% |* W
62.   * @retval 无
    3 B/ v( `" I- ^& N1 ?
63.   */
    # h9 G/ w% _6 s- V1 p
64. void SysTick_Time_Start(void)
    ; U0 g" h# T% i" s. |2 ~6 H1 Q
65. {
    
66.     /* 判断已经计时次数是否达到设置的计时次数 */
    & a' c( S; G9 A
67.      if(CurrentTimingVar->SaveTimesTemp < CurrentTimingVar->SetSaveTimesNum){
    8 |& o& `0 W3 O, ?' V6 i
68.          /* 滴答定时器的数据寄存器清零 */
    3 d3 v9 P, q7 O5 {3 P( R# S
69.          SysTick->VAL = 0;
    / Z6 g( x4 J6 `& D, d5 W$ t% x
70.          /* 滴答定时器中断次数清零 */
    + Y0 H/ D* i& P; r; z% F$ I
71.          TimeupTimes = 0;
    8 P6 B- f& v" G  T
72.          /* 启动滴答定时器 */
    7 y) K2 ?4 b" V5 h0 r& c! g
73.          SysTick->CTRL |=  SysTick_CTRL_ENABLE_Msk;
    * t4 ]& k2 N, b1 }9 |
74.      }
    " z& q, C9 J$ D) m0 V, r9 z6 P
75. }
    
76. 
    
77. 
    
78. /**
    
79.   * @brief  滴答定时器 SysTick 计时停止并保存处理数据
    9 g6 H& c0 Q7 D- U. }3 L1 G
80.   * @param  无
    4 p" r" E+ e% a
81.   * @retval 无
    
82.   */
    
83. void SysTick_Time_Stop(void)
    . H% ?! L) V' v) m  T2 S
84. {
    
85.     /* 保存已经计时次数 */   
    ( U1 R9 M2 C0 b$ \
86.     uint32_t TimesTemp = CurrentTimingVar->SaveTimesTemp;
    
87.     /* 保存设置计时总次数 */
    
88.     uint32_t SetSaveTimesNum = CurrentTimingVar->SetSaveTimesNum;
    
89.     uint32_t i,TimeWidthAverageTemp = 0;
    
90.    
    
91.     /* 保存设置计时总次数 */  
    
92.       if(SysTick->CTRL & SysTick_CTRL_ENABLE_Msk)
    
93.      {
    0 N" Q: z, s4 @- R
94.         /* 关闭滴答定时器 */
    
95.          SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    4 Q, l, G7 U  u5 W/ P
96.         /* 计算计时总时间 */
    + i- ~. Z* u! {
97.          CurrentTimingVar->TimeWidth[TimesTemp] =  SysTick_LOAD_RELOAD_Msk * TimeupTimes \
    9 W8 p! G# c3 s: M0 \* q
98.                      + (SysTick_LOAD_RELOAD_Msk - SysTick->VAL + 1);
    - W) ^  G# B5 b( K( L0 W6 ~
99.         /* 判断计时次数是否满 */
    
100.          if((++TimesTemp) == SetSaveTimesNum)
     
101.          {
     6 [1 g) p. `% f' }
102.             /* 计算平均值 */
     # V$ x+ Q4 p. k8 Y; L9 A' R; Z8 R
103.              for(i = 0;i < SetSaveTimesNum; i++)
     
104.             {
     
105.                 TimeWidthAverageTemp += CurrentTimingVar->TimeWidth[i];
     ; q  T, W+ J5 I1 w' M% b' I0 h; x" K2 O
106.             }
     0 \" ]2 {2 S! f% W% |
107.             CurrentTimingVar->TimeWidthAvrage = TimeWidthAverageTemp/SetSaveTimesNum;   
     5 u0 o, o$ T% S1 h6 Y/ R
108.          }
     1 m4 F9 B5 d8 Q: s  [7 Y  @5 M
109.          /* 已经计时次数变量加1 */
     ( w- P- \5 R1 K0 U- s7 A
110.          CurrentTimingVar->SaveTimesTemp++;   
     2 z& Z3 W/ n0 u' M$ W' [  Q
111.      }
     
112. }

复制代码

% ?1 Q) P5 `& \

② User_SysTick.h

1. #define SaveTimesBufNum 4                           /* 计时存储区的大小 */
   
2. 
   # h4 K: r( g, |6 M4 |$ y/ t
3. typedef struct {
   : r1 p+ |7 o7 i
4.     uint32_t SetSaveTimesNum;                     /* 设置计时总次数 */
   
5.     uint32_t SaveTimesTemp;                        /* 已经计时的次数 */
   
6.     uint32_t TimeWidth[SaveTimesBufNum];        /* 计时存储区 */
   # p1 x9 A$ A9 A+ q0 T# c  C
7.     uint32_t TimeWidthAvrage;                     /* 平均计时长度 */
   , |1 o* z' H$ I% N, x- e7 j
8. } TimingVarTypeDef;                                /*  计时变量类型 */
   
9. 
   . E4 |$ U/ m5 }1 d/ u+ x
10. extern TimingVarTypeDef Time;
    
11. extern uint32_t TimeupTimes;
    
12. 
    
13. extern uint32_t SysTick_Init(void);
    3 H" D  K9 R9 u) |: T1 N. [5 J
14. extern void SysTick_Time_Init(TimingVarTypeDef * TimingVar);
    6 ]" L4 t* t8 B% a- s; S  D
15. extern void SysTick_Time_Start(void);
    1 T) H6 Q3 ]: }
16. extern void SysTick_Time_Stop(void);

复制代码

③ stm32f10x_it.c

1. /**
   
2.   * @brief  This function handles SysTick Handler.
   ; U$ c, t6 D3 |/ Q6 ?2 c
3.   * @param  None
   
4.   * @retval None
   
5.   */
   
6. void SysTick_Handler(void)
   
7. {
   
8.     TimeupTimes++;
   
9. }

复制代码