前言
' v, {6 R1 q6 d( W) U) [        时钟系统之于单片机就如同与心脏脉搏之于人体，可见时钟系统的重要性可见一斑。然而STM32的时钟系统极其复杂，不像51单片机一样一个时钟系统就可以解决一切问题，这对于初学者来说很不友好，本文致力于讲解STM32时钟系统，使读者清晰了解STM32时钟背后的原理。
6 v! G! h2 ?) e9 t$ X7 l( q$ B0 q
# T2 h  A; s5 g) D0 q2 a5 ]( v一、STM32时钟系统原理
1. 时钟系统框图
以下是STM32时钟系统的结构框图，摘自STM32中文参考手册。
: D0 l# b3 o: x# d


可以看到，官方手册提供的时钟框图很复杂，这里我给出一个简化版的时钟框图：


, Z) A( s5 Y  e8 y, e
/ t" ?4 x, n% A0 q' B) X+ R2. 时钟源讲解
从图中可以看到，STM32共有五个时钟源，分别是HSI、HSE、LSI、LSE和PLL ，下面分别对它们进行讲解：

7 [. g# N+ W2 W5 |. J        ①、HSI是高速内部时钟，RC振荡器，频率为8MHz，精度不高。
8 q# r3 V* {, M) G" m1 O8 J　　 ②、HSE是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为4MHz~16MHz。
　　 ③、LSI是低速内部时钟，RC振荡器，频率为40kHz，提供低功耗时钟。独立看门狗的时钟源只能是 LSI ，同时LSI 还可以作为 RTC 的时钟源。
　　 ④、LSE是低速外部时钟，接频率为32.768kHz的石英晶体。是主要的RTC时钟源。
　　 ⑤、PLL为锁相环倍频输出，其时钟输入源可选择为HSI/2、HSE或者HSE/2。倍频可选择为2~16倍，但是其输出频率最大不得超过72MHz。

" o, D1 X$ X* N% {5 [$ b7 n, O2 X注意：高速外部时钟HSE的引脚是OSC_OUT和OSC_IN这两个引脚芯片是独立引出的，可以接外部的晶振电路，而低速外部时钟LSE的引脚OSC32_IN和OSC32_OUT两个引脚不是独立的，而是在PC14和PC15上，对应关系为OSC32_IN-->PC14 ; OSC32_OUT-->PC15
( {9 s& X0 v3 Q
( j) t; _: V# V3 e6 r0 g, L3.时钟去向讲解
3 O4 K3 |4 y/ j        上面我们简要概括了STM32 的时钟源，那么这 5 个时钟源是怎么给各个外设以及系统提供时钟的呢？这里我们将一一讲解。这里我们使用官方手册提供的框图（图一）进行讲解，图中我们用A~E 标示我们要讲解的地方。

3 l( p% n7 s$ I$ kA   MCO 是 STM32 的一个时钟输出 IO(PA8) PA8)，它可以选择一个时钟信号输出 可以
1 ~  S% @( h& A6 @. M2 A0 w% ]选择为 PLL 输出的 2 分频、 HSI 、 HSE 、或者 系统 时钟 。这个时钟可以用来给外
部其他系统提供时钟源。
B   RTC 时钟源，从图上可以看出， RTC 的时钟源可以选择 LSI LSE ，以及
+ k7 W- {( C* o* K8 I$ E+ [HSE 的 128 分频。
C   从图中可以看出 C 处 USB 的时钟是来自 PLL 时钟源。 STM32 中有一个全速 功能
$ ?* m; ?  M, i2 C% T; g8 y的 USB 模块 ，其串行 接口 引擎需要 一个频率为 48MHz 的时钟源。该时钟源只能
" d, ?; N; A) |: L9 D1 i; F7 q8 n从 PLL 输出端获取，可以选择为 1.5 分频或者 1 分频，也就是，当需要使用 USB
! H: Z9 c7 Q5 U2 J模块时， PLL 必须使能，并且时钟频率配置为 48MHz 或 72MHz 。
( Z5 {% V% ^5 s5 s+ T; hD   STM32 的系统时钟 SYSCLK ，它 是供 STM32 中绝大部分部件 工作 的时
; r3 o# o# u6 ?1 f钟源 。 系统时钟可选择为 PLL 输出、 HSI 或者 HSE 。系统时钟最大频率 为 72MHz
5 X6 T$ E3 {8 x6 L2 E1 R" V4 h0 w9 B' \当然你也可以超频，不过一般情况为了系统稳定性是没有必要冒风险去超频的。
1 N* @" j' O% g3 xE   其他所有外设。从时钟图上可以看出，其他所有外设的时钟最终来源都是 SYSCLK 。 SYSCLK 通过 AHB 分频器分频后送给各模块使用 。这些模块包括：
1 a3 a2 b( s7 }9 j) {5 Y① AHB 总线、内核、内存和 DMA 使用的 HCLK 时钟。
  l* A' L$ C6 L8 y② 通过 8 分频后送给 Cortex 的系统 定时器 时钟 ，也就是 systick 了 。
③ 直接送给 Cortex 的空闲运行时钟 FCLK 。
) K, N( q) w' s1 Y9 ]4 N- w5 D1 ]④ 送给 APB1 分频器。 APB1 分频器输出一路供 APB1 外设使用 (PCLK1 ，最大频率 36MHz)36MHz)，另一路送给定时器 (Timer)2 、 3 、 4 倍频器使用。
4 `: }- P, L  ?⑤送给 APB2 分频器。 APB2 分频器分频输出一路供 APB2 外设使用 (PCLK2最大频率 72MHz)72MHz)，另一 路送给定时器 (Timer)1 倍频器使用。
0 ?' w& z5 x4 q. U4 ~% L$ S- _, w9 e        APB1和APB2的区别： APB1上面连的是低速外设，包括电脑接口、备份接口、CAN、USB、I2C1、I2C2 、 UART2 、 UART3 等等， APB2 上面连接的是高速外设包括 UART1 、 SPI1 、 Timer1 、 ADC1 、 ADC2 、所有普通 IO 口 (PA~ 、第二功能 IO 口 等。 APB2 下面所挂的外设的时钟要比 APB1 的高 。
" w! ?. }: r) S7 @' h3 k% j
% @% W8 A9 i4 X( K在以上的时钟输出中，有很多 是带使能控制的，例如 AHB 总线 时钟、内核时钟、各种 APB1
外设、 APB2 外设等等。当需要使用某模块时，记得一定要先使能对应的时钟。

二、STM32时钟配置
1. 时钟配置简介
3 z' C0 d$ h( c: f  wSTM32时钟系统的配置除了初始化的时候在 system_stm32f10x.c 中的 SystemInit 函数中外，其他的配置主要在 stm32f10x_rcc.c 文件中，里面有很多时钟设置函数，大家可以打开这个文件浏览一下，基本上看看函数的名称就知道这个函数的作用。在大家设置时钟的时候，一定要仔细参考STM32 的时钟图，做到心中有数。这里需要指明一下，对于系统时钟，默认情况下是SystemInit 函数的 SetSysClock() 函数中间判断的，而设置是通过宏定义设置的。我们可以看看 SetSysClock() 函数体：

. C  J/ n* c; o/ A1 U

1. static void SetSysClock(void)
   : T/ V' Y6 V8 v  _9 C
2. {
   
3. #ifdef SYSCLK_FREQ_HSE
   
4.   SetSysClockToHSE();
   & F' w$ u/ a5 ^) S* F
5. #elif defined SYSCLK_FREQ_24MHz
   & K/ y+ E. ^. k  n3 {- i
6.   SetSysClockTo24();
   
7. #elif defined SYSCLK_FREQ_36MHz
   9 r/ t% V+ O4 S3 R0 {( r
8.   SetSysClockTo36();
   1 I& W; q. R: e2 s( h8 }
9. #elif defined SYSCLK_FREQ_48MHz
   
10.   SetSysClockTo48();
    
11. #elif defined SYSCLK_FREQ_56MHz
    
12.   SetSysClockTo56();  
    
13. #elif defined SYSCLK_FREQ_72MHz
    
14.   SetSysClockTo72();
    ( l/ J# m# P2 R4 v, J
15. #endif
    
16. }

复制代码

这段代码非常简单，就是判断系统宏定义的时钟是多少，然后设置相应值。我们系统默认宏定
义是 72MHz:
$ b, ^- p9 z& E! i

1. #define SYSCLK_FREQ_72MHz  72000000

复制代码

, U) ?. R7 n) m* w7 P如果你要设置为36MHz ，只需要注释掉上面代码，然后加入下面代码即可

" x& J/ c) ~2 [) b

1.   #define SYSCLK_FREQ_36MHz  36000000

复制代码

同时还要注意的是，当我们设置好系统时钟后，可以通过变量SystemCoreClock 获取系统时钟
2 Z7 X( i! M$ O. R) x值，如果系统是 72M 时钟，那么 SystemCoreClock =72000000 。这是在 system_stm32f10x.c 文件中设置的：

1. #ifdef SYSCLK_FREQ_HSE
   
2.   uint32_t SystemCoreClock         = SYSCLK_FREQ_HSE;      
   / Q/ @& y9 k5 g1 u
3. #elif defined SYSCLK_FREQ_24MHz
   
4.   uint32_t SystemCoreClock         = SYSCLK_FREQ_24MHz;        
   8 ^8 I7 T2 w9 I* K1 D
5. #elif defined SYSCLK_FREQ_36MHz
   ! C/ K6 K6 l1 w
6. #elif defined SYSCLK_FREQ_48MHz
   
7.   uint32_t SystemCoreClock         = SYSCLK_FREQ_48MHz;      
   
8. #elif defined SYSCLK_FREQ_56MHz
   
9.   uint32_t SystemCoreClock         = SYSCLK_FREQ_56MHz;        
   
10. #elif defined SYSCLK_FREQ_72MHz
    / W' F6 g4 G0 h$ x# U
11.   uint32_t SystemCoreClock         = SYSCLK_FREQ_72MHz;      
    
12. #else
    
13.   uint32_t SystemCoreClock         = HSI_VALUE;      
    $ e3 Q$ R) |- P# H, G! Z
14. #endif

复制代码

这里总结一下SystemInit() 函数中设置的系统时钟大小：
0 y2 |/ r4 z: N" y( p& W5 \
SYSCLK （系统时钟 =72MHz
AHB 总线时钟 使用 SYSCLK) =72MHz
* T& z4 |5 p" ^- I4 W: M0 TAPB1 总线时钟 ( =36MHz
, }8 Z2 ?1 F( |, V3 j. @. z# nAPB2 总线时钟 ( =72MHz
: ?9 t$ }. G/ t" P- S, MPLL 时钟 =72MHz
2.时钟配置寄存器介绍
以上介绍了SystemInit()时钟配置函数，想必大家已经知道了STM32时钟的基本情况，如果你想要更深一步的了解底层原理，那么下面的知识可以帮你揭晓。
0 M% W3 d# }0 t( t
在STM32时钟配置的过程中使用到了RCC寄存器，它们分别是：
$ K- y& i' U- d( M( U; Y; N
7 \# i  R2 L3 v时钟控制寄存器（RCC_CR)
. Y5 b6 |" V2 C: G时钟配置 寄存器（RCC_CFGR)
" n) q0 k, G, n! \
3 b' z8 }% m9 v  F8 h; f1 T首先介绍时钟控制寄存器，先上一张官方手册的寄存器说明:

: k' {8 H: N! Q8 Z/ a6 y3 l
+ l* e5 j" c& G; @( W* o% w. ~


1 O1 E; g/ `; @( w

, _, x" l7 K) C* p0 }1 ?5 a这个是时钟控制寄存器，看似很复杂，实际上并没有使用到寄存器所有的位，而是红框标出的部分位。下表是RCC另一个重要的寄存器：时钟配置寄存器（RCC_CFGR）
# f3 e1 I; i- y0 L! [! e) Z  ~
* _# y0 @( j1 u' q3 ]3 Q3 l

- ?$ g( x! {: c6 q3 ]
* F" ^* {+ W: C1 D; ~

  P( {3 h3 A0 G' {6 v9 \( ^( B
6 q" f8 A6 V# V! v
8 h" t. {( u+ @: t
和时钟控制寄存器RCC_CR相比，时钟配置寄存器RCC_CFGR要复杂一些，同样的，重点使用的位用红色框标识了出来。
2 P) D" l; A1 X! \1 E0 j
1 ]; T& ?) g: I; D) w3. 时钟配置总流程
) T; q/ D" B1 M8 z在STM32单片机复位之后，首先进入startup程序：
& X2 D4 L" P# ~3 y3 u! q3 h- |

1. ; Reset handler
   
2. Reset_Handler   PROC
   
3.                 EXPORT  Reset_Handler             [WEAK]
   * S+ I9 {6 _; u/ E5 w1 X% J
4.                 IMPORT  __main
   8 c/ V5 j9 l8 q7 s( x- S
5.                 IMPORT  SystemInit
   
6.                 LDR     R0, =SystemInit
   9 o& i2 a/ c) ]6 r) \# ]& ]
7.                 BLX     R0               
   # H* K5 c  S5 |8 p: c6 M, M
8.                 LDR     R0, =__main
   
9.                 BX      R0
   
10.                 ENDP

复制代码

可以看出，在进入main主程序之前，先触发了SystemInit()函数，这样就可以保证不需要每次都把时钟配置程序写入main.c文件了，同样，当你想要执行自定义时钟配置程序时也可以改动这个部分。
1 V& |" f0 _2 F' Y0 k' }2 E
. |  B4 k3 M5 O! t. _& F首先我们看一下SystemInit()函数
2 G( Z# B* g1 h1 i

1. void SystemInit (void)
   
2. {
   , @$ {4 Q7 y8 V
3.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
   8 g$ A4 q( m! a. `# l
4.   /* Set HSION bit */
   7 a; R8 T- X% L
5.   RCC->CR |= (uint32_t)0x00000001;
   
6.     SetSysClock();
   
7. }

复制代码

可以看到，SystemInit()函数的作用就是使RCC_CR寄存器最低位置1即开启内部8MHz振荡器，然后转到SetSysClock()函数中。刚刚已经讲过了，对于系统时钟，默认情况下就是SystemInit 函数的 SetSysClock() 函数中间判断的
9 k6 [- y8 i6 X4 U1 ~
下面是SetSysClock()函数：

1. static void SetSysClock(void)
   
2. {
   1 L$ {, u" o% h  s/ K
3. #ifdef SYSCLK_FREQ_HSE
   & F+ c7 ^; ?5 }0 E( `/ z
4.   SetSysClockToHSE();
   1 |* d# B  l. U" W7 p
5. #elif defined SYSCLK_FREQ_24MHz
   8 O6 N4 W. D7 s
6.   SetSysClockTo24();
   # p8 ?3 b; q3 V% }
7. #elif defined SYSCLK_FREQ_36MHz
   % h+ @' d" V7 I: ^7 _- m7 H
8.   SetSysClockTo36();
   
9. #elif defined SYSCLK_FREQ_48MHz
   ' D' t) c$ Z9 n/ f1 G) s7 z
10.   SetSysClockTo48();
    
11. #elif defined SYSCLK_FREQ_56MHz
    
12.   SetSysClockTo56();  
    5 ?. O) a6 X- p2 d4 R9 B% t; ~
13. #elif defined SYSCLK_FREQ_72MHz
    3 r# j3 y1 ^9 ?% {
14.   SetSysClockTo72();
    1 x0 E% i+ V% C' u
15. #endif
    ) g1 W' G  s. {. K7 ~
16. 
    / r$ p) E1 \2 m0 n: i
17. /* If none of the define above is enabled, the HSI is used as System clock
    - E( z8 a6 y8 |' S  B7 l) ?: x
18.     source (default after reset) */
    , {( d4 S8 f) f% B/ |
19. }

复制代码

由于我们把系统时钟频率通过宏定义设置为72MHz，所以这里直接进入最下面的程序即SetSysClockTo72()，这也是为什么有的程序把这一段语句直接写入主函数，原则上来说这是可以的，但是没必要，因为startup启动文件已经帮我们定义好了。
  r" P4 `! l5 {9 u' m
下面就是SetSysClockTo72()程序部分，也就是最关键的部分
  A* h3 M0 p4 K# E0 w* \
7 i6 ^7 j, ?. R5 h3 I8 D6 N% K) p

1. static void SetSysClockTo72(void)
   7 S5 K- U& c7 F- K
2. {
   4 x) ]% ^! ~; p6 D% P: D- p
3.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
   $ i8 D* G- C6 W! l3 v$ J/ l
4. 
   
5.   /* SYSCLK, HCLK, PCLK2 and PCLK1 配置---------------------------*/   
   - L! H# U% w% Q6 F/ v; W/ i1 Z2 M5 p  X1 C
6.   /* 使能 HSE */   
   4 m$ ^( P5 Q# B: ^  g5 I
7.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);//RCC_CR寄存器第16位置1，开启HSE
   
8. 
   , t7 j/ n! b- d
9.   /* 等待HSE就绪 超时退出 */
   
10.   do
    
11.   {
    
12.     HSEStatus = RCC->CR & RCC_CR_HSERDY;  //读取RCC_CR第17位
    * g/ w" i0 @( P7 X& R& ~
13.     StartUpCounter++;  
    
14.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    
15. 
    4 H8 n/ Y4 p- n
16.   if ((RCC->CR & RCC_CR_HSERDY) != RESET) //读取RCC_CR第17位
    
17.   {
    9 C  I% }$ r0 n; O
18.     HSEStatus = (uint32_t)0x01;   //HSE状态写1
    0 q8 O) }  o; c  Z4 c
19.   }
    
20.   else
    
21.   {
    : H0 _- Q- k( X* m5 ?; C
22.     HSEStatus = (uint32_t)0x00;   //HSE状态写0
    ; o! |* S* M1 ]# F% t: e5 y0 R
23.   }  
    % H# H3 x* |5 J  v  b
24. 
    
25.   if (HSEStatus == (uint32_t)0x01) //FLASH寄存器部分可以不用管
    
26.   {
    2 [1 o) `; l( q, ~, v- q9 \
27.     /* 使能 Prefetch Buffer */
    
28.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    
29. 
    
30.     /* Flash 2 wait state */
    ' M6 W" L% s7 p7 J1 v2 k
31.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    
32.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;   
    
33. 
    3 d' I8 L7 t  H/ g
34. 
    8 ?# X, T; G! \) _* H) A
35.     /* HCLK = SYSCLK */
    
36.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;  //RCC_CFGR寄存器第4~7位写0，即AHB不分频，即HCLK使用72MHz时钟
    . i' A/ d- y- n* Z3 D: x
37. 
    
38.     /* PCLK2 = HCLK */
    
39.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1; //RCC_CFGR寄存器第11~13位写0，APB2不分频，即PCLK2使用72MHz时钟
    ) V- @0 N5 I/ G2 `/ y( r
40. 
    
41.     /* PCLK1 = HCLK/2 */
    
42.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2; //RCC_CFGR寄存器第8~10位写100，APB1二分频，即PCLK1使用36MHz时钟
    
43. 
    
44. #else   
    
45.     /*  PLL 配置: PLLCLK = HSE * 9 = 72 MHz */
    
46.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
    0 v  g- K7 q" ^  z( L8 X8 ?9 |
47.                                         RCC_CFGR_PLLMULL)); //RCC_CFGR寄存器的16~21位清零
    ) B9 ]1 v+ T+ \5 y2 f
48.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);//RCC_CFGR寄存器第16位置1，使HSE作为PLL输入时钟；17位置0不变，使HSE作为PLL输入时钟时不分频。RCC_CFGR寄存器第18~21位置0111，配置位PLL 9倍频输出给PLLCLK，即PLLCLK为72MHz
    
49. #endif /* STM32F10X_CL */
    3 F/ O4 T% E4 i" d- f
50. 
    9 w# d: }( a7 ?$ C9 z- u. @
51.     /* 使能 PLL */
    ) \* Q5 H: W* |$ Z3 l( c, [
52.     RCC->CR |= RCC_CR_PLLON; //RCC->CR寄存器第24位置1，使能PLL
    
53. 
      M! f4 ~4 h( E2 Q* Y# X7 n+ a) w
54.     /* 等待PLL就绪 */
    
55.     while((RCC->CR & RCC_CR_PLLRDY) == 0)  //读取PLL时钟就绪标志位（第25位）
    
56.     {
    + o0 m. i; u2 q; u
57.     }
    
58. 
    0 C; p% q& V* `* L0 D
59.     /* 选择PLL作为系统时钟源 */
    . b) M5 U) T7 L: P& m% ?7 F1 w
60.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW)); //RCC->CFGR寄存器第0~1位清零
    
61.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;    //RCC->CFGR寄存器第0~1位(SW位)置10，即PLL输出作为系统时钟
    
62. 
    % r6 @/ W3 |" i( t
63.     /* 等待PLL被用作系统时钟源就绪 */
    6 t- _* a/ x/ s9 d& H; e
64.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08) //等待RCC->CFGR寄存器第2~3位(SWS位)为10即就绪
    ; ?* m% b$ x- O. b
65.     {
    
66.     }
    
67.   }
    ) i  M  a. \, m5 i# s4 F* o: J- y
68.   else
    
69.   { /* If HSE fails to start-up, the application will have wrong clock
    . d6 k* p/ n9 v: M  T. b
70.          configuration. User can add here some code to deal with this error */
    1 z. {" Y* L+ q- ?  ?$ m8 m5 |
71.   }
    9 r9 ?9 l7 w4 f: j! V" M! B
72. }
    , h+ P( P/ |* w
73. #endif

复制代码

这里把所有的备注都写在了程序中，希望读者仔细查看并对照寄存器功能表理解。STM32的寄存器的每一个位都做了宏定义，这样直接查找头文件即可，非常方便。
1 o: i+ H5 Q  s8 ^: R
至此STM32系统时钟的讲解就已经结束了，我们以大容量芯片72MHz的系统时钟为例来进行讲解，你也可以根据实际情况自己配置，原理都是一样的。下面的内容就是灵活使用STM32的系统时钟来实现演示功能了。
1 f% I5 }' S$ t/ Z  ?
三、Systick定时器及delay延时函数
1. Systick定时器
前面讲完了STM32系统时钟的基本配置，下面就是对延时函数进行介绍了，延时函数使用到了STM32的SysTick定时器，这是一个很简单的定时器，对于CM3和CM4内核芯片都具备。
- a5 x. j7 Z' h5 B
9 o" z( f" ]& y" w( JSysTick定时器全称是System tick timer即系统滴答定时器，常用来做延时或者系统的心跳时钟。这样可以节省MCU资源，不用浪费一个定时器。比如在UCOS操作系统中分时复用，需要一个最小的时间戳，一般在STM32+UCOS系统中，都采用SysTick做UCOS心跳时钟。

% G! e/ N$ @' q7 Y0 ?2 q1 [3 lSysTick定时器就是系统滴答定时器，一个24位倒计数定时器，计数到0时将从RELOAD寄存器中自动重装载定时器初值。只要不把它在SysTick控制及状态寄存器中的使能位清除，就永不停息，即使在睡眠模式也能工作。
SysTick定时器被捆绑在NVIC中，用于产生SYSTICK异常（异常号为15）。
$ Z' b+ T  z- P) G' aSysTick中断的优先级也可以设置
% n. N  f( R* J+ V6 h+ M
2. 相关寄存器介绍
SysTick定时器一共有四个相关寄存器：

CTRL              SysTick 控制和状态寄存器
5 F* x% o; R" ~LOAD              SysTick 自动重装载除值寄存器   
VAL                 SysTick 当前值寄存器
: u1 Z" F3 A" Z+ r+ x6 i7 _8 qCALIB             SysTick 校准值寄存器      
7 o# ?+ q% g+ C  X7 n; k  z* h下面分别介绍这四个寄存器
& b: i3 D. B' J- R& z, ~/ O



2 h6 l1 A8 j# O* x9 @7 \




这是四个相关的寄存器，实际上我们一般只用到前三个。
% u% n* A- g% K' l$ g' x
4 T" U6 Z. {) ?, L  B3. 延时函数配置
  {3 U/ `2 \- Z& X对于STM32，外部时钟源是 HCLK(AHB总线时钟）的1/8 ，内核时钟是 HCLK时钟。配置函数：SysTick_CLKSourceConfig();这个函数在misc.c文件中，这里把它粘出来：

1. void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
   
2. {
   
3.   /* Check the parameters */
   ) s3 i9 \  w! n' s, z: y; y5 W& `
4.   assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
   2 E, Y8 \: M( S! ?3 L' V2 R" e
5.   if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
     z: r7 C) w2 N" u
6.   {
   
7.     SysTick->CTRL |= SysTick_CLKSource_HCLK;
   9 ]& \  D2 m; `; h( y  K1 a! Z% k
8.   }
   & |! `( Y! {- A1 o4 j
9.   else
   
10.   {
    
11.     SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
    
12.   }
    
13. }

复制代码

& s  h% z2 A8 ]根据入口参数有效性可知，时钟源可以选择HCLK或者HCLK的8分频。这个函数在下面的delay_init会调用一次，完成延时函数的初始化。
) \+ W7 d) O0 ]7 [  a
/ g' _4 Y, q; b7 L5 c5 h, D, r7 kcore_cm3.h文件中有关于初始化systick时钟和开启中断的函数，如下所示：

1. static __INLINE uint32_t SysTick_Config(uint32_t ticks)
   
2. {
   ! L! C$ O/ c4 f9 n* _
3.   if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
   
4. 
   + a. v) ]5 r/ G& M9 u$ G. ~1 v( ^1 {
5.   SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
   ( S. N3 G; s/ ?7 L! M& [
6.   NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Cortex-M0 System Interrupts */
   1 N* _, a0 G1 Q) s5 C: y+ _. o
7.   SysTick->VAL   = 0;                                          /* Load the SysTick Counter Value */
   
8.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
   ; t+ e4 [$ z( |* T1 ?) Y
9.                    SysTick_CTRL_TICKINT_Msk   |
   
10.                    SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
    / y, M* \7 |8 T( Z4 f4 V
11.   return (0);                                                  /* Function successful */
    
12. }

复制代码

8 |8 I& u) F' B需要注意的是第5行把重装载寄存器的值减1的目的是考虑到执行装在动作也需要一个时钟周期。
. Q; }* o3 c9 U! k& J; s3 T+ k
下面是用中断的方式来实现延时：

) X" C; H# J: a, d8 \% R

1. static __IO uint32_t TimingDelay;
   ) M! {2 d& x: d$ }! @; I9 \
2. void Delay(__IO uint32_t nTime)
   ( j, z- P+ \8 U  T9 i5 S0 h
3. {
   : |6 ~$ z9 ?5 ~! T3 q2 F
4.    TimingDelay = nTime;
   
5.    while(TimingDelay != 0);
   - n% l$ w8 p9 p* }6 D- u, W9 [- a+ m
6. }
   
7. void SysTick_Handler(void)
   
8. {
   
9.     if (TimingDelay != 0x00)
   8 ?# ?2 Q9 d) N  e
10.      {
    9 p/ t2 d3 P' h( i5 S
11.        TimingDelay--;
    
12.      }
    6 i+ W; b) E: t
13. }
    , c" a( x2 s3 i1 e; k- U$ }
14. int main(void)
    
15. {  …
    0 X) a8 \, J6 Q, I% q3 {+ I
16.     if (SysTick_Config(SystemCoreClock / 1000)) //systick时钟为HCLK，中断时间间隔1ms
    # N% _( ?! K) O2 p5 I3 w# X6 _
17.      {
    
18.      while (1);
    , u& D3 ?/ r' o7 s! c9 U
19.      }
    
20.     while(1)
    
21.      { Delay(200);//2ms
    
22.      …
    
23.      }
    
24. }

复制代码

程序中，SysTick_Config(SystemCoreClock / 1000)的目的是确保SysTick定时器每次发生中断的时间间隔都是1ms（因为使用系统时钟的时钟频率为72000000,SystemCoreClock / 1000等于72000，也就是给重装载寄存器值赋72000，这样计72000正好是1ms）
5 P. q6 m& W1 ~! W
一般实际应用中我们不使用通过中断来驱动延时的方法，因为这样会多一个中断线路，我们采用的 是单独的延时函数，下面就是延时函数文件：

1. #include "delay.h"
   7 @, g2 J0 R2 a2 L! I; V
2. //         
     T. }% |- B& T" [( l& F5 B( O
3. //如果需要使用OS,则包括下面的头文件即可.
   
4. #if SYSTEM_SUPPORT_OS
   ' M) J0 w/ Q1 h
5. #include "includes.h"                                        //ucos 使用         
   / w: T6 b" h1 J4 x( h0 ^
6. #endif
   
7. //         
   
8. 
   
9. static u8  fac_us=0;                                                        //us延时倍乘数                           
   
10. static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数
    
11.         
    . L6 D) |8 R$ c, q6 [5 {. [8 W- A
12.         
    9 u1 D. f# l9 ~5 q5 C- I7 J) I
13. #if SYSTEM_SUPPORT_OS                                                        //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
    ) H8 k! v( U0 P4 U
14. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
      ^8 F5 l. m/ u& {2 H' K8 \6 h: `
15. //首先是3个宏定义:
    - w  t) z. q" Z* r2 c; p( ^
16. //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
17. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    
18. // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    
19. //然后是3个函数:
    + R# ^' q2 [' H9 X! {% L  }  s, K) \
20. //  delay_osschedlock:用于锁定OS任务调度,禁止调度
    
21. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
22. //    delay_ostimedly:用于OS延时,可以引起任务调度.
    
23. 
    2 y4 Q6 M5 @0 l# W( V2 {  a
24. //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    
25. //支持UCOSII
    2 o: D8 G, u' }+ L9 b& j) b
26. #ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                                
    " W" k7 n; Q5 F" v+ Y' v3 p
27. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
    ; x" D* k% P+ t; _
28. #define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
    
29. #define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
    
30. #endif
    
31. 
    ( l  Z* Y( I/ d& _3 R( D4 Y  f9 s
32. //支持UCOSIII
    
33. #ifdef         CPU_CFG_CRITICAL_METHOD                                        //CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII        
    
34. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
    
35. #define delay_ostickspersec        OSCfg_TickRate_Hz        //OS时钟节拍,即每秒调度次数
    1 }4 ^6 l0 w+ _4 o! M
36. #define delay_osintnesting         OSIntNestingCtr                //中断嵌套级别,即中断嵌套次数
    # ^6 e/ j" Z9 v7 r! e3 \
37. #endif
    ; H. @# K2 b: X' E
38. 
    - W  n6 i7 ^0 A$ R* e( @) F6 x
39. 
    ' n+ k* v5 _0 W$ L
40. //us级延时时,关闭任务调度(防止打断us级延迟)
    & F" E5 \' T9 b/ d+ }
41. void delay_osschedlock(void)
    / E7 _& y% T/ c' {2 p
42. {
    
43. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
      g- I: U5 V; F. L1 G
44.         OS_ERR err;
    4 T3 w- c  F2 d
45.         OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度，防止打断us延时
    1 q" [* x  [6 l% @
46. #else                                                                                        //否则UCOSII
    ; E! b( L! d0 v% ~, `- @
47.         OSSchedLock();                                                                //UCOSII的方式,禁止调度，防止打断us延时
    8 a: |7 r( D) [3 p, @. M9 [! L
48. #endif
    ( j$ |/ {6 ^3 J/ l- a
49. }
    
50. 
    4 K- y5 I/ V6 p% R& ]" j  F
51. //us级延时时,恢复任务调度
    
52. void delay_osschedunlock(void)
    ( l1 B8 B( K! y* S
53. {        
    3 F( t* I# R" o
54. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
    9 r7 A8 e6 o$ d2 z' m
55.         OS_ERR err;
      m4 H; k- e* x( P0 Y
56.         OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
    / _  T% G% ?' m, B  H( G3 V( Z
57. #else                                                                                        //否则UCOSII
    8 R6 g, |; b3 n) s. D$ Q4 I- Q
58.         OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
    
59. #endif
    - }4 |, v* B# A' S. R) D
60. }
    % n7 _# j7 I2 n! Z
61. 
    % d- N: Q3 @8 i" o4 q
62. //调用OS自带的延时函数延时
    5 K. G& N- k& a: y8 v6 U+ _
63. //ticks:延时的节拍数
    
64. void delay_ostimedly(u32 ticks)
    3 e# A* z6 l( {0 i% M) T8 G
65. {
    ( ~0 w2 m. |9 M9 h/ i; V+ n
66. #ifdef CPU_CFG_CRITICAL_METHOD
    
67.         OS_ERR err;
    
68.         OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
    2 B0 _' F* j, g' \
69. #else
    5 P: r0 F5 z- }5 @3 Y( x/ {
70.         OSTimeDly(ticks);                                                        //UCOSII延时
    
71. #endif
    * q! i# f& b/ J( L/ g
72. }
    
73. 
    ; v& g+ w! x* T* L
74. //systick中断服务函数,使用ucos时用到
    - T5 v+ Z3 Y8 ^
75. void SysTick_Handler(void)
    
76. {        
    
77.         if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
    ( p9 u% N6 v5 ]- I
78.         {
    
79.                 OSIntEnter();                                                        //进入中断
    
80.                 OSTimeTick();                                               //调用ucos的时钟服务程序               
    
81.                 OSIntExit();                                                        //触发任务切换软中断
    
82.         }
    " e) b8 k* F6 R7 T4 v  g
83. }
    & W/ ]/ c" M+ Q; y# W  I1 I
84. #endif
    
85. 
    % a$ u# n; d$ F. g# a
86.                            
    
87. //初始化延迟函数
    
88. //当使用OS的时候,此函数会初始化OS的时钟节拍
    
89. //SYSTICK的时钟固定为HCLK时钟的1/8
    $ V0 V! W! U/ H  ?6 Q
90. //SYSCLK:系统时钟
    6 h# M! g' X# K( Q
91. void delay_init()
    1 z, i. ~+ ^7 |& |) y, ?8 X0 C" |
92. {
    
93. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    
94.         u32 reload;
    8 [3 t# G# E" O. w
95. #endif
    
96.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
    
97.         fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
    
98. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    
99.         reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为M  
    
100.         reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
     ' `6 y# }! N' ]( s. X$ \) k
101.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右        
     
102.         fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位           
     
103. 
     3 o& f! W$ U( y. S
104.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
     7 P3 j* Q+ _; b! |/ ~7 n
105.         SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次        
     ; E) }# [- M/ _. A
106.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
     ! b( w) k2 |: _7 C$ u5 @# ~
107. 
     ) c: p! }; y4 g: W1 o4 I5 x
108. #else
     
109.         fac_ms=(u16)fac_us*1000;                                        //非OS下,代表每个ms需要的systick时钟数   
     
110. #endif
     
111. }                                                                    
     2 |) N/ \$ Y5 x2 v
112. 
     , T8 H1 E) i. {& o: p4 A
113. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
     8 j; G$ k& c: K( J; C4 U
114. //延时nus
     # p4 J: N# I2 X# g* H, e' p: m8 }- g
115. //nus为要延时的us数.                                                                                       
     
116. void delay_us(u32 nus)
     " o: V$ f" O7 F. j
117. {               
     ( v& k/ C+ W+ }& H
118.         u32 ticks;
     
119.         u32 told,tnow,tcnt=0;
     7 R. L" q8 S  c+ D7 o
120.         u32 reload=SysTick->LOAD;                                        //LOAD的值                     
     . o# ]8 O6 c& q$ x/ s2 Q+ }. g
121.         ticks=nus*fac_us;                                                         //需要的节拍数                           
     $ z! w7 \6 _% Y# w* I" s. z& W2 F
122.         tcnt=0;
     + V7 d& x4 c( I1 K- d1 z
123.         delay_osschedlock();                                                //阻止OS调度，防止打断us延时
     
124.         told=SysTick->VAL;                                                //刚进入时的计数器值
     
125.         while(1)
     6 w- X6 E; ]  t
126.         {
     1 q6 x& j) R8 ]! p8 {+ ^  `
127.                 tnow=SysTick->VAL;        
     * k* R- B; I$ e# y  A6 `. @
128.                 if(tnow!=told)
     9 o6 u* B9 R0 S, L/ ~
129.                 {            
     
130.                         if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
     
131.                         else tcnt+=reload-tnow+told;            
     
132.                         told=tnow;
     
133.                         if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
     
134.                 }  
     ! n7 `4 X  m. \' C: _$ `% \, Z
135.         };
     
136.         delay_osschedunlock();                                                //恢复OS调度                                                                           
     
137. }
     
138. //延时nms
     4 a0 u  }) t) D( A" Z' ?
139. //nms:要延时的ms数
     " n8 c7 A6 h7 |* W% d3 U
140. void delay_ms(u16 nms)
     
141. {        
     / q1 \4 r% f0 c6 f* I0 y" g
142.         if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
     
143.         {                 
     9 U" \# `3 B* \2 T+ K
144.                 if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
     
145.                 {
     
146.                            delay_ostimedly(nms/fac_ms);                //OS延时
     
147.                 }
     ( R7 B3 o) j7 c9 n5 t! R* Z
148.                 nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
     
149.         }
     + V( \) a! g$ M; ]- z
150.         delay_us((u32)(nms*1000));                                        //普通方式延时  
     
151. }
     
152. #else //不用OS时
     " W. E* f, `! N5 z6 J6 C
153. //延时nus
     . u0 @! u3 e$ K" O+ o+ v
154. //nus为要延时的us数.                                                                                       
     
155. void delay_us(u32 nus)
     
156. {               
     
157.         u32 temp;                     
     % |7 `$ K2 a3 ]1 M: ]
158.         SysTick->LOAD=nus*fac_us;                                         //时间加载                           
     3 `: g& a+ n8 k# n6 H$ ~& _
159.         SysTick->VAL=0x00;                                                //清空计数器
     / }( k: d, j# V
160.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数         
     
161.         do
     
162.         {
     
163.                 temp=SysTick->CTRL;
     
164.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
     
165.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
     
166.         SysTick->VAL =0X00;                                               //清空计数器         
     - i9 O: d: U4 ]1 y
167. }
     
168. //延时nms
     % `2 `" Y* R/ y, j
169. //注意nms的范围
     
170. //SysTick->LOAD为24位寄存器,所以,最大延时为:
     ! a- K3 g% q; c8 m4 d& W0 r- [
171. //nms<=0xffffff*8*1000/SYSCLK
     
172. //SYSCLK单位为Hz,nms单位为ms
     
173. //对72M条件下,nms<=1864
     
174. void delay_ms(u16 nms)
     
175. {                                    
     ) X$ _' ?1 Q+ r
176.         u32 temp;                  
     ; w: e2 G  X2 S5 n: j4 V
177.         SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
     
178.         SysTick->VAL =0x00;                                                        //清空计数器
     & s/ w2 E3 {7 ~
179.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
     
180.         do
     
181.         {
     
182.                 temp=SysTick->CTRL;
     
183.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
     
184.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
     ( d- L& R% \1 m2 d- I
185.         SysTick->VAL =0X00;                                               //清空计数器                     
     . ~3 x% o; Y. m) i
186. }
     
187. #endif

复制代码

这里需要注意的是我们使用了外部时钟即系统时钟的8分频，这样确保时间足够长。另外，毫秒延时函数有最大上限，最大为1864（72MHz时钟频率）。用这种方式来延时的好处是不用中断比较简单，但是坏处就是最大延时时长有限（不到2秒），所以当需要长延时时间的时候要多写几个delay函数。
1 _! J8 N; A4 H: ?# P0 E. B; A, S

总结
        本节主要对STM32时钟系统进行讲解，我们从原理框图入手，对每一个时钟线路进行来源和去向的分析，介绍了时钟配置的相关寄存器以及STM32时钟的软件配置，最后通过SysTick定时器来编写延时函数。STM32的时钟十分复杂，希望读者能够反复阅读，内化于心，这样在以后的STM32开发以至于其它高性能SOC的学习中才能游刃有余。
# c0 g/ [* N& t+ ?
& t+ @" o" M9 i3 ]

) [) X- M2 X, ~& Q