前言
        时钟系统之于单片机就如同与心脏脉搏之于人体，可见时钟系统的重要性可见一斑。然而STM32的时钟系统极其复杂，不像51单片机一样一个时钟系统就可以解决一切问题，这对于初学者来说很不友好，本文致力于讲解STM32时钟系统，使读者清晰了解STM32时钟背后的原理。

% J* I9 z2 W% ]# N, E# T一、STM32时钟系统原理
1. 时钟系统框图
$ n8 B  N% a* K以下是STM32时钟系统的结构框图，摘自STM32中文参考手册。



- @; ?+ w; C5 g  [可以看到，官方手册提供的时钟框图很复杂，这里我给出一个简化版的时钟框图：
6 O8 v$ q3 R. d7 Q  P0 @% G5 E  k

/ V9 a) m  |% x1 P
2. 时钟源讲解
- y) ^  o  q0 k! p 从图中可以看到，STM32共有五个时钟源，分别是HSI、HSE、LSI、LSE和PLL ，下面分别对它们进行讲解：
3 }; A! t- r2 o6 n! y
        ①、HSI是高速内部时钟，RC振荡器，频率为8MHz，精度不高。
9 _) ?$ F4 V3 {) h' l' @% _0 v- k' t1 O　　 ②、HSE是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为4MHz~16MHz。
　　 ③、LSI是低速内部时钟，RC振荡器，频率为40kHz，提供低功耗时钟。独立看门狗的时钟源只能是 LSI ，同时LSI 还可以作为 RTC 的时钟源。
　　 ④、LSE是低速外部时钟，接频率为32.768kHz的石英晶体。是主要的RTC时钟源。
/ ]4 @. H  g2 D7 i　　 ⑤、PLL为锁相环倍频输出，其时钟输入源可选择为HSI/2、HSE或者HSE/2。倍频可选择为2~16倍，但是其输出频率最大不得超过72MHz。
1 {) k0 {( }- g! x
注意：高速外部时钟HSE的引脚是OSC_OUT和OSC_IN这两个引脚芯片是独立引出的，可以接外部的晶振电路，而低速外部时钟LSE的引脚OSC32_IN和OSC32_OUT两个引脚不是独立的，而是在PC14和PC15上，对应关系为OSC32_IN-->PC14 ; OSC32_OUT-->PC15
, R& s9 w# b. S( ^. p+ K0 Q
3.时钟去向讲解
" N( j" d8 k- B        上面我们简要概括了STM32 的时钟源，那么这 5 个时钟源是怎么给各个外设以及系统提供时钟的呢？这里我们将一一讲解。这里我们使用官方手册提供的框图（图一）进行讲解，图中我们用A~E 标示我们要讲解的地方。

A   MCO 是 STM32 的一个时钟输出 IO(PA8) PA8)，它可以选择一个时钟信号输出 可以
: B: J1 E) H5 E0 n8 j7 b选择为 PLL 输出的 2 分频、 HSI 、 HSE 、或者 系统 时钟 。这个时钟可以用来给外
部其他系统提供时钟源。
( g; ^. y& i. p4 n% X$ [' \; QB   RTC 时钟源，从图上可以看出， RTC 的时钟源可以选择 LSI LSE ，以及
& V4 l- t" y  T3 V9 kHSE 的 128 分频。
5 {& |! q; Z: |; N, x" a) w7 [( P$ CC   从图中可以看出 C 处 USB 的时钟是来自 PLL 时钟源。 STM32 中有一个全速 功能
的 USB 模块 ，其串行 接口 引擎需要 一个频率为 48MHz 的时钟源。该时钟源只能
从 PLL 输出端获取，可以选择为 1.5 分频或者 1 分频，也就是，当需要使用 USB
- A6 ~  m$ y4 ]5 e$ i9 J) H模块时， PLL 必须使能，并且时钟频率配置为 48MHz 或 72MHz 。
D   STM32 的系统时钟 SYSCLK ，它 是供 STM32 中绝大部分部件 工作 的时
$ p5 I2 P  f! O& d; A钟源 。 系统时钟可选择为 PLL 输出、 HSI 或者 HSE 。系统时钟最大频率 为 72MHz
当然你也可以超频，不过一般情况为了系统稳定性是没有必要冒风险去超频的。
E   其他所有外设。从时钟图上可以看出，其他所有外设的时钟最终来源都是 SYSCLK 。 SYSCLK 通过 AHB 分频器分频后送给各模块使用 。这些模块包括：
& O: E8 R1 }4 M8 \① AHB 总线、内核、内存和 DMA 使用的 HCLK 时钟。
② 通过 8 分频后送给 Cortex 的系统 定时器 时钟 ，也就是 systick 了 。
③ 直接送给 Cortex 的空闲运行时钟 FCLK 。
④ 送给 APB1 分频器。 APB1 分频器输出一路供 APB1 外设使用 (PCLK1 ，最大频率 36MHz)36MHz)，另一路送给定时器 (Timer)2 、 3 、 4 倍频器使用。
' m+ ~8 o# Z0 y2 e8 \" m⑤送给 APB2 分频器。 APB2 分频器分频输出一路供 APB2 外设使用 (PCLK2最大频率 72MHz)72MHz)，另一 路送给定时器 (Timer)1 倍频器使用。
5 K. `, v6 `$ `6 y0 n6 {3 q        APB1和APB2的区别： APB1上面连的是低速外设，包括电脑接口、备份接口、CAN、USB、I2C1、I2C2 、 UART2 、 UART3 等等， APB2 上面连接的是高速外设包括 UART1 、 SPI1 、 Timer1 、 ADC1 、 ADC2 、所有普通 IO 口 (PA~ 、第二功能 IO 口 等。 APB2 下面所挂的外设的时钟要比 APB1 的高 。
! s3 E! _# b& _
在以上的时钟输出中，有很多 是带使能控制的，例如 AHB 总线 时钟、内核时钟、各种 APB1
外设、 APB2 外设等等。当需要使用某模块时，记得一定要先使能对应的时钟。

% [( h0 P; B- V% R" j二、STM32时钟配置
1. 时钟配置简介
" H# o" H9 X) `STM32时钟系统的配置除了初始化的时候在 system_stm32f10x.c 中的 SystemInit 函数中外，其他的配置主要在 stm32f10x_rcc.c 文件中，里面有很多时钟设置函数，大家可以打开这个文件浏览一下，基本上看看函数的名称就知道这个函数的作用。在大家设置时钟的时候，一定要仔细参考STM32 的时钟图，做到心中有数。这里需要指明一下，对于系统时钟，默认情况下是SystemInit 函数的 SetSysClock() 函数中间判断的，而设置是通过宏定义设置的。我们可以看看 SetSysClock() 函数体：
* S0 A& |2 {* P; H/ p& R9 M' G

1. static void SetSysClock(void)
     a, S" x( j7 M
2. {
     B) P: s, D( F, g/ T: d4 _. n
3. #ifdef SYSCLK_FREQ_HSE
   
4.   SetSysClockToHSE();
   2 C& e/ _7 ?' Q$ Q: ~( B
5. #elif defined SYSCLK_FREQ_24MHz
   
6.   SetSysClockTo24();
   9 y1 M# W3 T- ?6 |: J
7. #elif defined SYSCLK_FREQ_36MHz
   5 F4 U( J: Q0 X; O- r; {3 g
8.   SetSysClockTo36();
   
9. #elif defined SYSCLK_FREQ_48MHz
   ' H, k, h+ Y- |: T0 a; E2 O" P4 j+ G
10.   SetSysClockTo48();
    ' F* W* a  V- k& {7 E& c3 D
11. #elif defined SYSCLK_FREQ_56MHz
    
12.   SetSysClockTo56();  
    ' m" i: b3 }6 j1 L$ S' e# C' D2 h
13. #elif defined SYSCLK_FREQ_72MHz
    + _8 g' w/ D- p* q9 f1 q
14.   SetSysClockTo72();
    2 S4 d+ a" ^6 M2 j% O. v( E
15. #endif
    
16. }

复制代码

这段代码非常简单，就是判断系统宏定义的时钟是多少，然后设置相应值。我们系统默认宏定
" `; o) P* E- ~$ B4 a0 u义是 72MHz:
3 V3 A5 r$ `( L9 a/ ?

1. #define SYSCLK_FREQ_72MHz  72000000

复制代码

- n2 e% P7 {' Y  c4 {) R% s如果你要设置为36MHz ，只需要注释掉上面代码，然后加入下面代码即可
6 D6 t2 P/ p! R

1.   #define SYSCLK_FREQ_36MHz  36000000

复制代码

7 x! [4 J' f7 Z 同时还要注意的是，当我们设置好系统时钟后，可以通过变量SystemCoreClock 获取系统时钟
值，如果系统是 72M 时钟，那么 SystemCoreClock =72000000 。这是在 system_stm32f10x.c 文件中设置的：
8 z( Z, ]. B% @: [
) ^! w; u( e9 c4 |: Y1 [1 s

1. #ifdef SYSCLK_FREQ_HSE
   & t0 E! x% X( H
2.   uint32_t SystemCoreClock         = SYSCLK_FREQ_HSE;      
   + h7 R! h0 e/ h. Y
3. #elif defined SYSCLK_FREQ_24MHz
   
4.   uint32_t SystemCoreClock         = SYSCLK_FREQ_24MHz;        
   3 y, O5 @! J; V1 h$ l2 k
5. #elif defined SYSCLK_FREQ_36MHz
   
6. #elif defined SYSCLK_FREQ_48MHz
   8 O/ w! ?: [: d8 `* N- r
7.   uint32_t SystemCoreClock         = SYSCLK_FREQ_48MHz;      
   1 R' a2 D! F4 N6 _0 X
8. #elif defined SYSCLK_FREQ_56MHz
   
9.   uint32_t SystemCoreClock         = SYSCLK_FREQ_56MHz;        
   
10. #elif defined SYSCLK_FREQ_72MHz
    
11.   uint32_t SystemCoreClock         = SYSCLK_FREQ_72MHz;      
    2 \, G1 G+ s- y$ N; O
12. #else
    0 b5 d1 G- H7 e. T# [
13.   uint32_t SystemCoreClock         = HSI_VALUE;      
    
14. #endif

复制代码

+ ?% x* E5 q* _6 b* k/ w. U$ z这里总结一下SystemInit() 函数中设置的系统时钟大小：

SYSCLK （系统时钟 =72MHz
* t& h3 G- n, u  dAHB 总线时钟 使用 SYSCLK) =72MHz
APB1 总线时钟 ( =36MHz
8 |, O+ p6 a7 p" YAPB2 总线时钟 ( =72MHz
PLL 时钟 =72MHz
2.时钟配置寄存器介绍
4 s6 a0 e' X% s以上介绍了SystemInit()时钟配置函数，想必大家已经知道了STM32时钟的基本情况，如果你想要更深一步的了解底层原理，那么下面的知识可以帮你揭晓。
5 @- B  X( a7 S# A5 E9 M6 B0 U
4 z/ o9 ~7 D6 N/ S7 E  C: B8 w" b在STM32时钟配置的过程中使用到了RCC寄存器，它们分别是：
7 M" g3 {5 Q+ k& N! e* M
8 P8 L! _. Z; Y! }  ?$ U9 w) {时钟控制寄存器（RCC_CR)
( `, K0 ~* s( @1 u- A; l时钟配置 寄存器（RCC_CFGR)

# V7 B7 r7 R: J) X! ~% H9 H8 T* G首先介绍时钟控制寄存器，先上一张官方手册的寄存器说明:

7 x2 C  \# ~( g$ c3 K* ]
+ v  C( M  @0 P5 ]2 [& I

4 U5 x% X& D2 H0 i8 P( g
+ Q: ~: d* u: o* ^6 ]& A

8 k% n" C8 Q* s这个是时钟控制寄存器，看似很复杂，实际上并没有使用到寄存器所有的位，而是红框标出的部分位。下表是RCC另一个重要的寄存器：时钟配置寄存器（RCC_CFGR）
# O  |7 K6 h0 G2 ~





. |+ ^% ~  }; v0 z
! |2 L( N! b& \% F; Z5 R5 {
0 n; b% @/ O5 L1 x* h. z" w
3 B9 o4 l8 A6 K& W 和时钟控制寄存器RCC_CR相比，时钟配置寄存器RCC_CFGR要复杂一些，同样的，重点使用的位用红色框标识了出来。
& G: R9 i0 y& P" y* k
3. 时钟配置总流程
在STM32单片机复位之后，首先进入startup程序：

- ]' W8 e$ S5 e* a1 e+ Z! f+ T

1. ; Reset handler
   
2. Reset_Handler   PROC
   
3.                 EXPORT  Reset_Handler             [WEAK]
   
4.                 IMPORT  __main
   8 j+ m, ?6 [  d, t4 h- O/ y- `
5.                 IMPORT  SystemInit
   . B- B" Y2 P( m2 |3 B9 I
6.                 LDR     R0, =SystemInit
   
7.                 BLX     R0               
   ! Z3 K# e$ x# M+ l% B+ \! K) V
8.                 LDR     R0, =__main
   5 x. q" g" B* y" B* I
9.                 BX      R0
   + \! z4 z) ~- W  ?
10.                 ENDP

复制代码

9 I8 N8 _0 A% U: t$ `可以看出，在进入main主程序之前，先触发了SystemInit()函数，这样就可以保证不需要每次都把时钟配置程序写入main.c文件了，同样，当你想要执行自定义时钟配置程序时也可以改动这个部分。

首先我们看一下SystemInit()函数
  Y# n7 [4 ^' y9 J& F$ r
" @, j- ]  y1 s

1. void SystemInit (void)
   2 C8 I  h( g( p) x3 I
2. {
   
3.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
   6 V* ~+ }% q! f+ H( R9 a! P
4.   /* Set HSION bit */
   $ P& s( Q1 |5 K9 d9 p4 b4 K
5.   RCC->CR |= (uint32_t)0x00000001;
   
6.     SetSysClock();
   - d' c& `* }0 E$ c5 e& ~+ q
7. }

复制代码

可以看到，SystemInit()函数的作用就是使RCC_CR寄存器最低位置1即开启内部8MHz振荡器，然后转到SetSysClock()函数中。刚刚已经讲过了，对于系统时钟，默认情况下就是SystemInit 函数的 SetSysClock() 函数中间判断的
4 m! L  W# g& l0 y" |
0 Y! K0 N9 s9 L( N) C, n下面是SetSysClock()函数：
' q  P$ l! c( o; g6 ~1 f6 C1 u

1. static void SetSysClock(void)
   + ^) p& L1 K- a! D0 a( _
2. {
   
3. #ifdef SYSCLK_FREQ_HSE
   
4.   SetSysClockToHSE();
   " o: E" }( }  Y& }1 \- J
5. #elif defined SYSCLK_FREQ_24MHz
   
6.   SetSysClockTo24();
   
7. #elif defined SYSCLK_FREQ_36MHz
   ) J1 j3 U0 h" t
8.   SetSysClockTo36();
   ) T% \: i5 y- {# z; s
9. #elif defined SYSCLK_FREQ_48MHz
   
10.   SetSysClockTo48();
    ( J/ Q2 L1 T9 l" T; |, w) A+ U
11. #elif defined SYSCLK_FREQ_56MHz
    
12.   SetSysClockTo56();  
    
13. #elif defined SYSCLK_FREQ_72MHz
    
14.   SetSysClockTo72();
    
15. #endif
    . u: t4 d7 ?& H7 S
16. 
    
17. /* If none of the define above is enabled, the HSI is used as System clock
    7 n$ e. v9 o  I& F
18.     source (default after reset) */
    4 ~$ v# |4 r& L% [; s( E- s
19. }

复制代码

由于我们把系统时钟频率通过宏定义设置为72MHz，所以这里直接进入最下面的程序即SetSysClockTo72()，这也是为什么有的程序把这一段语句直接写入主函数，原则上来说这是可以的，但是没必要，因为startup启动文件已经帮我们定义好了。
1 A+ H! M% |3 f, R! \
' N' u7 ^/ W1 Y# H下面就是SetSysClockTo72()程序部分，也就是最关键的部分

1. static void SetSysClockTo72(void)
   
2. {
   3 ?- o+ {5 _# p1 m, M4 E0 A
3.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
   + R2 E% s$ ^. L* y
4. 
   
5.   /* SYSCLK, HCLK, PCLK2 and PCLK1 配置---------------------------*/   
   : y0 v8 p6 R7 {; {/ {) r, P3 ^
6.   /* 使能 HSE */   
   : d1 C; }1 U0 ]) ?3 c* S" l2 D) P
7.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);//RCC_CR寄存器第16位置1，开启HSE
   
8. 
   / r( a% j" g) V$ e
9.   /* 等待HSE就绪 超时退出 */
   
10.   do
    - T8 k* z& Y, a, c  e2 w
11.   {
    
12.     HSEStatus = RCC->CR & RCC_CR_HSERDY;  //读取RCC_CR第17位
    
13.     StartUpCounter++;  
    4 Y" h$ j; A& w# T
14.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    ) ?& V9 N6 \; q5 b, V1 `
15. 
    
16.   if ((RCC->CR & RCC_CR_HSERDY) != RESET) //读取RCC_CR第17位
    # Q, a0 Q8 G) S1 |+ o7 `9 d
17.   {
    ! R2 d6 C1 {/ y2 A6 c/ |
18.     HSEStatus = (uint32_t)0x01;   //HSE状态写1
    " X5 N6 j; }" S
19.   }
    $ }7 `+ \* i; q$ Y- u0 H" k: H
20.   else
    
21.   {
    
22.     HSEStatus = (uint32_t)0x00;   //HSE状态写0
    
23.   }  
      x+ I. E4 K# _! A% f8 C
24. 
    
25.   if (HSEStatus == (uint32_t)0x01) //FLASH寄存器部分可以不用管
    ' C. C$ f  d9 X% n3 _" j
26.   {
    
27.     /* 使能 Prefetch Buffer */
    $ ]5 D6 s" h8 x  b( X2 b
28.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    4 M3 W: v0 T6 G
29. 
    
30.     /* Flash 2 wait state */
      n  b/ j# O! ^
31.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    3 a( [4 T2 m% d/ ]
32.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;   
    7 i, b* w( l2 A6 T# c' Y- N, _
33. 
    
34. 
    
35.     /* HCLK = SYSCLK */
    
36.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;  //RCC_CFGR寄存器第4~7位写0，即AHB不分频，即HCLK使用72MHz时钟
    
37. 
    " s6 ]+ v0 f1 n1 Q
38.     /* PCLK2 = HCLK */
    
39.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1; //RCC_CFGR寄存器第11~13位写0，APB2不分频，即PCLK2使用72MHz时钟
    
40. 
    " w7 Q  R( q6 n. f* k) c
41.     /* PCLK1 = HCLK/2 */
    1 M+ V7 }1 E( x* l: N& I: s' Y6 f
42.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2; //RCC_CFGR寄存器第8~10位写100，APB1二分频，即PCLK1使用36MHz时钟
    5 ?" V5 e- }6 g2 X
43. 
    ) b# }: X" ]& X/ U
44. #else   
    $ X) ^) y' u8 w
45.     /*  PLL 配置: PLLCLK = HSE * 9 = 72 MHz */
    2 i: R, I$ F# l: L. d2 D( w
46.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
    1 i+ u1 f' B7 F$ l  z
47.                                         RCC_CFGR_PLLMULL)); //RCC_CFGR寄存器的16~21位清零
    
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 */
    , i6 T& d- x+ c% {9 N, K  t* n
50. 
    
51.     /* 使能 PLL */
    
52.     RCC->CR |= RCC_CR_PLLON; //RCC->CR寄存器第24位置1，使能PLL
    - t' B3 n' e$ j4 N/ W- C
53. 
    4 V1 x& [3 O- @: G5 \9 B
54.     /* 等待PLL就绪 */
    ; \4 w% p: G' ~
55.     while((RCC->CR & RCC_CR_PLLRDY) == 0)  //读取PLL时钟就绪标志位（第25位）
    
56.     {
    
57.     }
    
58. 
    
59.     /* 选择PLL作为系统时钟源 */
      S6 h) w, G% l1 b1 g+ L
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输出作为系统时钟
    5 q+ Y' }" g* M9 ^
62. 
    8 o4 v5 j4 a3 R- k  w8 e
63.     /* 等待PLL被用作系统时钟源就绪 */
    6 @- [0 ?) [7 M5 U
64.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08) //等待RCC->CFGR寄存器第2~3位(SWS位)为10即就绪
    ) n! b( Q! H1 M  U3 i  d
65.     {
    ' ^# a3 {; C7 H, z# A4 G9 q6 Q; i
66.     }
    5 U6 C% ?$ ]# B+ e4 I) M
67.   }
    
68.   else
    
69.   { /* If HSE fails to start-up, the application will have wrong clock
    
70.          configuration. User can add here some code to deal with this error */
    
71.   }
    
72. }
    
73. #endif

复制代码

5 e/ y$ P3 X& W2 W$ b) Y: g这里把所有的备注都写在了程序中，希望读者仔细查看并对照寄存器功能表理解。STM32的寄存器的每一个位都做了宏定义，这样直接查找头文件即可，非常方便。

. H: i2 @. @0 B) i) N: C至此STM32系统时钟的讲解就已经结束了，我们以大容量芯片72MHz的系统时钟为例来进行讲解，你也可以根据实际情况自己配置，原理都是一样的。下面的内容就是灵活使用STM32的系统时钟来实现演示功能了。
6 Z  ]1 s. F# |5 p
0 P, B4 }, ]% I( E) Y5 z三、Systick定时器及delay延时函数
1. Systick定时器
/ O$ n4 A$ ?) A4 E前面讲完了STM32系统时钟的基本配置，下面就是对延时函数进行介绍了，延时函数使用到了STM32的SysTick定时器，这是一个很简单的定时器，对于CM3和CM4内核芯片都具备。

SysTick定时器全称是System tick timer即系统滴答定时器，常用来做延时或者系统的心跳时钟。这样可以节省MCU资源，不用浪费一个定时器。比如在UCOS操作系统中分时复用，需要一个最小的时间戳，一般在STM32+UCOS系统中，都采用SysTick做UCOS心跳时钟。

+ [4 C) ?& V( r4 B% \1 tSysTick定时器就是系统滴答定时器，一个24位倒计数定时器，计数到0时将从RELOAD寄存器中自动重装载定时器初值。只要不把它在SysTick控制及状态寄存器中的使能位清除，就永不停息，即使在睡眠模式也能工作。
SysTick定时器被捆绑在NVIC中，用于产生SYSTICK异常（异常号为15）。
SysTick中断的优先级也可以设置

6 O8 n% N4 E* a6 H2. 相关寄存器介绍
SysTick定时器一共有四个相关寄存器：
8 J- D: Q8 Z9 f+ R. X# |7 Q9 i+ H" u
CTRL              SysTick 控制和状态寄存器
LOAD              SysTick 自动重装载除值寄存器   
VAL                 SysTick 当前值寄存器
( g" \+ u" v8 `& f3 B6 ?CALIB             SysTick 校准值寄存器      
下面分别介绍这四个寄存器

7 D4 {, I- s5 r( l* R' M6 @/ B, z

+ B: P* M$ V5 ~: `. M* e6 Q; h


6 }( U# Q4 A5 B& g. v3 m5 n: }
2 A$ ]- J- [& W8 B
7 ?! ?- [7 t( a! j& I8 M
这是四个相关的寄存器，实际上我们一般只用到前三个。

8 w- G8 b) Z; Z8 j/ c' M9 P3. 延时函数配置
对于STM32，外部时钟源是 HCLK(AHB总线时钟）的1/8 ，内核时钟是 HCLK时钟。配置函数：SysTick_CLKSourceConfig();这个函数在misc.c文件中，这里把它粘出来：

5 ~- f& w1 W7 A9 ~( I& x+ y  }

1. void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
   
2. {
   - m0 f$ p- d" ?$ J4 ^: r" b
3.   /* Check the parameters */
   
4.   assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
   
5.   if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
   $ n9 C9 Z& g- b5 U1 X+ u6 ?( [
6.   {
   ; t/ l1 Y' ?4 n, q! l7 g
7.     SysTick->CTRL |= SysTick_CLKSource_HCLK;
   
8.   }
   " I1 C( w. `2 Z
9.   else
   7 r+ l  v" A+ Y5 [
10.   {
    - m, e- E/ k. J) K
11.     SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
    % i- u. [% y1 K/ [
12.   }
    7 S9 v- G$ d4 f- v
13. }

复制代码

根据入口参数有效性可知，时钟源可以选择HCLK或者HCLK的8分频。这个函数在下面的delay_init会调用一次，完成延时函数的初始化。

$ n$ u: h  P! X3 W4 t+ Ccore_cm3.h文件中有关于初始化systick时钟和开启中断的函数，如下所示：

+ p& C$ ^' R) ?6 }3 _: [5 Z

1. static __INLINE uint32_t SysTick_Config(uint32_t ticks)
   
2. {
   7 M9 \  \+ F' V3 c3 ]/ C
3.   if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
   
4. 
   
5.   SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
   , O! a/ C" w& h0 v8 O- y& Z5 L
6.   NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Cortex-M0 System Interrupts */
   
7.   SysTick->VAL   = 0;                                          /* Load the SysTick Counter Value */
   
8.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
   6 w+ L( P5 q  l) {  M! w
9.                    SysTick_CTRL_TICKINT_Msk   |
   ; J4 j+ G% O2 Y# v( v0 W; P/ B2 X4 i$ v
10.                    SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
    
11.   return (0);                                                  /* Function successful */
    
12. }

复制代码

; i! l6 ~# [3 T7 E需要注意的是第5行把重装载寄存器的值减1的目的是考虑到执行装在动作也需要一个时钟周期。

/ T' A/ P6 D1 v下面是用中断的方式来实现延时：
" E0 s! ~$ ~" g1 y/ S) V
  s! k, x, {/ N4 C$ z7 s0 S

1. static __IO uint32_t TimingDelay;
   ; b- f* {( o& ^
2. void Delay(__IO uint32_t nTime)
   / l, o' K: L' M6 i+ s
3. {
   / R1 D" D8 s2 G5 K+ {, b
4.    TimingDelay = nTime;
   5 T. ~, T" f& ], k8 a: y
5.    while(TimingDelay != 0);
   % T. [4 D3 g5 V( y8 V: ~4 s) z* _
6. }
   
7. void SysTick_Handler(void)
   
8. {
   
9.     if (TimingDelay != 0x00)
   
10.      {
    5 _. W. e; s" o* }( ]
11.        TimingDelay--;
    6 v& ]- O( Y  W( Q, s- u8 C, ^. B
12.      }
    
13. }
    3 d& b# T( S0 [, U1 }! j2 n
14. int main(void)
    $ ~- l; F6 \2 h0 y! \7 H
15. {  …
    % F  t, C0 b- _* i- \* R6 M3 O
16.     if (SysTick_Config(SystemCoreClock / 1000)) //systick时钟为HCLK，中断时间间隔1ms
    
17.      {
    
18.      while (1);
    8 i& p" ~2 B" ^9 @9 s& ^7 r% W  b
19.      }
    * X7 M, x' z# P, Q& h; u
20.     while(1)
    ; c2 `7 R7 X: @# Q$ d$ p
21.      { Delay(200);//2ms
    
22.      …
    $ U, p' s. g" l  B8 t6 T" e6 t
23.      }
    
24. }

复制代码

程序中，SysTick_Config(SystemCoreClock / 1000)的目的是确保SysTick定时器每次发生中断的时间间隔都是1ms（因为使用系统时钟的时钟频率为72000000,SystemCoreClock / 1000等于72000，也就是给重装载寄存器值赋72000，这样计72000正好是1ms）

一般实际应用中我们不使用通过中断来驱动延时的方法，因为这样会多一个中断线路，我们采用的 是单独的延时函数，下面就是延时函数文件：

1. #include "delay.h"
   
2. //         
   
3. //如果需要使用OS,则包括下面的头文件即可.
   
4. #if SYSTEM_SUPPORT_OS
   7 X" O6 q  r1 J
5. #include "includes.h"                                        //ucos 使用         
   9 k* |9 V% y: K' ~: H, x/ @( D+ ?
6. #endif
   
7. //         
   / U- {) `- T3 K6 B- p
8. 
   : t3 X/ ~$ A2 F7 Q3 Y9 [
9. static u8  fac_us=0;                                                        //us延时倍乘数                           
   
10. static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数
    7 h  K- [# ~1 |2 M. u; I- `6 r9 P
11.         
    
12.         
    9 F! c! S6 v6 n: r# f
13. #if SYSTEM_SUPPORT_OS                                                        //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
    8 f$ _& p$ m$ z. f
14. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    " N! T5 U& r8 P2 y! u" g( j# w
15. //首先是3个宏定义:
    9 X/ J9 h$ ]4 \2 x: Y9 P. c
16. //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    
17. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    * e7 q5 `# E0 U# }* w  s
18. // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    
19. //然后是3个函数:
    
20. //  delay_osschedlock:用于锁定OS任务调度,禁止调度
    
21. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
22. //    delay_ostimedly:用于OS延时,可以引起任务调度.
    
23. 
    & L6 t/ D# n+ u. x9 j1 |
24. //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    7 W( ~9 |, G( v% e$ d( X' f3 ?
25. //支持UCOSII
    7 j- d; |* ^% O+ y2 Y4 d0 p& F' V
26. #ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                                
    ! d2 a" _) q6 \+ t3 E* P) d
27. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
    : N* z( t+ _$ |- V5 U$ g3 s- G
28. #define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
    
29. #define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
    : }+ y& `/ a$ z$ `9 r- V  O8 }3 k
30. #endif
    " D5 P- P2 D5 V1 j0 X# ?
31. 
    
32. //支持UCOSIII
    & [- y, [3 T" Y) ^- z/ ?/ Z+ G
33. #ifdef         CPU_CFG_CRITICAL_METHOD                                        //CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII        
    / r9 p2 _2 ]; B( J. w5 l
34. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
    " B2 O& M! t9 d% X
35. #define delay_ostickspersec        OSCfg_TickRate_Hz        //OS时钟节拍,即每秒调度次数
    3 u' q+ y0 c% F) t2 W
36. #define delay_osintnesting         OSIntNestingCtr                //中断嵌套级别,即中断嵌套次数
    7 @, d, R& L& Y$ I6 {( N2 ~
37. #endif
    
38. 
    
39. 
    
40. //us级延时时,关闭任务调度(防止打断us级延迟)
    
41. void delay_osschedlock(void)
    , Z( N# K/ n. o7 D& |; i1 X
42. {
    
43. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
    ; C& @& e8 q+ p4 X
44.         OS_ERR err;
    2 ^. y6 b( a% b4 ]
45.         OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度，防止打断us延时
    
46. #else                                                                                        //否则UCOSII
    
47.         OSSchedLock();                                                                //UCOSII的方式,禁止调度，防止打断us延时
    5 x1 ?+ B$ L$ L* J$ r8 C6 A
48. #endif
    
49. }
    
50. 
    
51. //us级延时时,恢复任务调度
    & G$ M5 Z0 l4 E: L% [
52. void delay_osschedunlock(void)
    
53. {        
    / S. f1 x: N( ]2 ~$ w) A
54. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
    + }; C9 o( R/ k! y9 s+ s6 z
55.         OS_ERR err;
    
56.         OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
    3 }3 I# h6 l/ t( R
57. #else                                                                                        //否则UCOSII
    
58.         OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
    
59. #endif
    
60. }
    
61. 
    + c7 J: a: @" d" D7 P0 V% j" Z
62. //调用OS自带的延时函数延时
    
63. //ticks:延时的节拍数
    9 K5 q& B# M- B/ _
64. void delay_ostimedly(u32 ticks)
    5 D, y) ~. t& T5 P& F; \; K: L
65. {
    & w1 t7 o2 B. {2 ?: y9 z
66. #ifdef CPU_CFG_CRITICAL_METHOD
    7 t$ ?7 _1 D& P1 I- C
67.         OS_ERR err;
    : P( [" n8 k6 u. N2 _+ l) I4 {
68.         OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
    
69. #else
    ; I7 _* g  l0 g# ?! ^4 W
70.         OSTimeDly(ticks);                                                        //UCOSII延时
    
71. #endif
    " r/ t/ [0 A- H# b
72. }
    
73. 
    ; M6 x0 [  D# t! x% @5 ]8 p) z4 T5 K4 A
74. //systick中断服务函数,使用ucos时用到
      i  X2 l, M7 V6 _1 i: [# L
75. void SysTick_Handler(void)
    
76. {        
    7 z* k; i" P1 `# U
77.         if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
    
78.         {
    ! ?1 d! c2 E7 u9 F9 l
79.                 OSIntEnter();                                                        //进入中断
    
80.                 OSTimeTick();                                               //调用ucos的时钟服务程序               
      E8 L' x; K/ M1 L
81.                 OSIntExit();                                                        //触发任务切换软中断
    * z! L* J$ K  ^: y( v
82.         }
    5 ?0 }1 @( {$ B/ R, ~1 |
83. }
    ( j  m- }; E; z
84. #endif
    
85. 
    % b5 e) c( Q  h$ g/ S
86.                            
    
87. //初始化延迟函数
    + n5 U& O6 ~# r" F
88. //当使用OS的时候,此函数会初始化OS的时钟节拍
    6 c( `  m) F7 Q! C
89. //SYSTICK的时钟固定为HCLK时钟的1/8
    
90. //SYSCLK:系统时钟
    
91. void delay_init()
    
92. {
    " x7 ^4 w6 [% f/ _! E2 G+ f
93. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    6 {- V# g7 E# t  ?2 P* J- g: l
94.         u32 reload;
    
95. #endif
    
96.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
    7 ?# M+ h- m1 n; Z9 d9 I+ l
97.         fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
    
98. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    
99.         reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为M  
    5 ]" b. v9 e9 k  \/ X9 B$ H
100.         reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
     
101.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右        
     
102.         fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位           
     8 Y% i. t, Z$ a9 P
103. 
     - c  }8 I; N( L# V; ^
104.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
     7 s* |8 N4 K# Y+ F/ }
105.         SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次        
     
106.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
     4 m1 ~3 d' R5 j* ~0 u
107. 
     
108. #else
     9 h. A3 N" W. H
109.         fac_ms=(u16)fac_us*1000;                                        //非OS下,代表每个ms需要的systick时钟数   
     
110. #endif
     5 [1 J* S8 b2 c! f
111. }                                                                    
     7 J% i( t; B3 ?. s  q1 m% s
112. 
     9 D; c) L* q$ r( r
113. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
     
114. //延时nus
     
115. //nus为要延时的us数.                                                                                       
     + Q0 w) ]3 s0 v$ k
116. void delay_us(u32 nus)
     
117. {               
     
118.         u32 ticks;
     4 }3 I7 D* B7 r4 l
119.         u32 told,tnow,tcnt=0;
     
120.         u32 reload=SysTick->LOAD;                                        //LOAD的值                     
     % E. V  w7 H0 K  q3 X; v
121.         ticks=nus*fac_us;                                                         //需要的节拍数                           
     
122.         tcnt=0;
     
123.         delay_osschedlock();                                                //阻止OS调度，防止打断us延时
     
124.         told=SysTick->VAL;                                                //刚进入时的计数器值
     + e: |6 v1 r1 h6 Z# v
125.         while(1)
     6 K* R1 L- i& I+ `1 q/ e7 w* j
126.         {
     
127.                 tnow=SysTick->VAL;        
     7 {4 d7 M6 V/ r% x4 E
128.                 if(tnow!=told)
     
129.                 {            
     : I; ]8 y7 X1 e0 a; V' ~- y
130.                         if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
     0 S8 z2 H" W5 s! S1 |5 D! B
131.                         else tcnt+=reload-tnow+told;            
     
132.                         told=tnow;
     
133.                         if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
     9 `( h0 p! l7 m& @5 u7 Z* c! _5 P
134.                 }  
     
135.         };
     
136.         delay_osschedunlock();                                                //恢复OS调度                                                                           
     
137. }
     
138. //延时nms
     * \6 o7 \  r9 U, L2 E% u7 b9 f+ |0 F
139. //nms:要延时的ms数
     4 d& m% c& p" I! _
140. void delay_ms(u16 nms)
     
141. {        
     4 Y7 u* X, r- F2 y6 i' h3 [% S# C8 H
142.         if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
     
143.         {                 
     
144.                 if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
     
145.                 {
     
146.                            delay_ostimedly(nms/fac_ms);                //OS延时
     
147.                 }
     " n; U6 [$ J, A) x/ }' w
148.                 nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
     2 ?' j* M  P: S2 Q# B2 ?, y
149.         }
     
150.         delay_us((u32)(nms*1000));                                        //普通方式延时  
     
151. }
     ; d' |; }0 m# B: w+ T
152. #else //不用OS时
     
153. //延时nus
     
154. //nus为要延时的us数.                                                                                       
     , S: f3 Q% h! t: n& @
155. void delay_us(u32 nus)
     % A+ _, t, r7 U# t! d2 E, d$ \: r2 v
156. {               
     8 g. l$ B7 K: H% Y6 ?$ B) }/ v
157.         u32 temp;                     
     
158.         SysTick->LOAD=nus*fac_us;                                         //时间加载                           
     $ s/ P4 T7 k1 g5 ~8 N8 s
159.         SysTick->VAL=0x00;                                                //清空计数器
     7 _2 q! R$ t1 u& k! t6 i
160.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数         
     7 P: f+ o, P1 B
161.         do
     7 I( K' f4 e8 ?, \7 n0 ?
162.         {
     
163.                 temp=SysTick->CTRL;
     9 f2 p& X  H& ]
164.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
     
165.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
     
166.         SysTick->VAL =0X00;                                               //清空计数器         
     & q' _, R* S  M/ d( u/ a
167. }
     
168. //延时nms
     % s1 M. }8 b- U0 q
169. //注意nms的范围
     
170. //SysTick->LOAD为24位寄存器,所以,最大延时为:
     
171. //nms<=0xffffff*8*1000/SYSCLK
     
172. //SYSCLK单位为Hz,nms单位为ms
     % D5 P' \8 j, g* A$ Z6 ~
173. //对72M条件下,nms<=1864
     7 F" F, D9 f# W, `3 y: v" l. \# _; V
174. void delay_ms(u16 nms)
     + ]& f* d" R9 S$ d0 l: x
175. {                                    
     
176.         u32 temp;                  
     
177.         SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
     ) h+ u. W5 L8 o  d& F9 I  f
178.         SysTick->VAL =0x00;                                                        //清空计数器
     
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;        //关闭计数器
     
185.         SysTick->VAL =0X00;                                               //清空计数器                     
     
186. }
     
187. #endif

复制代码

这里需要注意的是我们使用了外部时钟即系统时钟的8分频，这样确保时间足够长。另外，毫秒延时函数有最大上限，最大为1864（72MHz时钟频率）。用这种方式来延时的好处是不用中断比较简单，但是坏处就是最大延时时长有限（不到2秒），所以当需要长延时时间的时候要多写几个delay函数。
+ K. s) D4 Z5 i, [

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


& l6 D; c+ u4 |! S9 D# m