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

  m4 S* `' y  r0 O: G4 w一、STM32时钟系统原理
1 @6 {/ C5 \8 b1. 时钟系统框图
以下是STM32时钟系统的结构框图，摘自STM32中文参考手册。
0 q8 T/ a" m  j; |8 \: A
1 z- \- W$ U! U% l

' D7 G) L, }7 j  l2 b5 U可以看到，官方手册提供的时钟框图很复杂，这里我给出一个简化版的时钟框图：



2. 时钟源讲解
从图中可以看到，STM32共有五个时钟源，分别是HSI、HSE、LSI、LSE和PLL ，下面分别对它们进行讲解：
2 d" _3 D* o! z
" j- g: p' W5 `4 L2 T+ Q6 [; f2 a        ①、HSI是高速内部时钟，RC振荡器，频率为8MHz，精度不高。
, `% c1 o$ J3 v2 ?1 y9 `' E　　 ②、HSE是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为4MHz~16MHz。
　　 ③、LSI是低速内部时钟，RC振荡器，频率为40kHz，提供低功耗时钟。独立看门狗的时钟源只能是 LSI ，同时LSI 还可以作为 RTC 的时钟源。
　　 ④、LSE是低速外部时钟，接频率为32.768kHz的石英晶体。是主要的RTC时钟源。
$ ~" c9 V7 J% Y& f　　 ⑤、PLL为锁相环倍频输出，其时钟输入源可选择为HSI/2、HSE或者HSE/2。倍频可选择为2~16倍，但是其输出频率最大不得超过72MHz。

: L. D/ D* o& T! I9 T# l" C6 n: G% s注意：高速外部时钟HSE的引脚是OSC_OUT和OSC_IN这两个引脚芯片是独立引出的，可以接外部的晶振电路，而低速外部时钟LSE的引脚OSC32_IN和OSC32_OUT两个引脚不是独立的，而是在PC14和PC15上，对应关系为OSC32_IN-->PC14 ; OSC32_OUT-->PC15
8 [/ T# r6 U9 ]2 w, d
, I) y6 B+ e0 w4 n- B6 [7 w3.时钟去向讲解
) Y6 [4 I( I/ s3 F- l9 v        上面我们简要概括了STM32 的时钟源，那么这 5 个时钟源是怎么给各个外设以及系统提供时钟的呢？这里我们将一一讲解。这里我们使用官方手册提供的框图（图一）进行讲解，图中我们用A~E 标示我们要讲解的地方。

A   MCO 是 STM32 的一个时钟输出 IO(PA8) PA8)，它可以选择一个时钟信号输出 可以
选择为 PLL 输出的 2 分频、 HSI 、 HSE 、或者 系统 时钟 。这个时钟可以用来给外
部其他系统提供时钟源。
- M6 b4 S1 }3 l6 R2 z- r3 nB   RTC 时钟源，从图上可以看出， RTC 的时钟源可以选择 LSI LSE ，以及
% n" K. v# W" R; }HSE 的 128 分频。
3 o- K7 G* ^9 j3 z, x/ l7 T/ ~1 UC   从图中可以看出 C 处 USB 的时钟是来自 PLL 时钟源。 STM32 中有一个全速 功能
的 USB 模块 ，其串行 接口 引擎需要 一个频率为 48MHz 的时钟源。该时钟源只能
  w7 X' T* H3 x& Q. n从 PLL 输出端获取，可以选择为 1.5 分频或者 1 分频，也就是，当需要使用 USB
模块时， PLL 必须使能，并且时钟频率配置为 48MHz 或 72MHz 。
% p& K3 D$ H* N6 x+ r  J& uD   STM32 的系统时钟 SYSCLK ，它 是供 STM32 中绝大部分部件 工作 的时
4 p6 c# H+ n( Z$ O钟源 。 系统时钟可选择为 PLL 输出、 HSI 或者 HSE 。系统时钟最大频率 为 72MHz
% d/ B) Q- W! F4 F, d6 _当然你也可以超频，不过一般情况为了系统稳定性是没有必要冒风险去超频的。
& }) v/ _) A  x& {E   其他所有外设。从时钟图上可以看出，其他所有外设的时钟最终来源都是 SYSCLK 。 SYSCLK 通过 AHB 分频器分频后送给各模块使用 。这些模块包括：
① AHB 总线、内核、内存和 DMA 使用的 HCLK 时钟。
② 通过 8 分频后送给 Cortex 的系统 定时器 时钟 ，也就是 systick 了 。
: |$ a  C' q5 v3 [$ U6 v③ 直接送给 Cortex 的空闲运行时钟 FCLK 。
④ 送给 APB1 分频器。 APB1 分频器输出一路供 APB1 外设使用 (PCLK1 ，最大频率 36MHz)36MHz)，另一路送给定时器 (Timer)2 、 3 、 4 倍频器使用。
- k# y) p# h- f* y. O; e7 ?⑤送给 APB2 分频器。 APB2 分频器分频输出一路供 APB2 外设使用 (PCLK2最大频率 72MHz)72MHz)，另一 路送给定时器 (Timer)1 倍频器使用。
' U0 J) {+ T! V2 }        APB1和APB2的区别： APB1上面连的是低速外设，包括电脑接口、备份接口、CAN、USB、I2C1、I2C2 、 UART2 、 UART3 等等， APB2 上面连接的是高速外设包括 UART1 、 SPI1 、 Timer1 、 ADC1 、 ADC2 、所有普通 IO 口 (PA~ 、第二功能 IO 口 等。 APB2 下面所挂的外设的时钟要比 APB1 的高 。

在以上的时钟输出中，有很多 是带使能控制的，例如 AHB 总线 时钟、内核时钟、各种 APB1
外设、 APB2 外设等等。当需要使用某模块时，记得一定要先使能对应的时钟。
$ F0 u/ K% @# m
  x/ f* \- h5 s% N% @& G% `5 H二、STM32时钟配置
$ t: o$ p6 @7 _1 m' ?4 n) G1. 时钟配置简介
STM32时钟系统的配置除了初始化的时候在 system_stm32f10x.c 中的 SystemInit 函数中外，其他的配置主要在 stm32f10x_rcc.c 文件中，里面有很多时钟设置函数，大家可以打开这个文件浏览一下，基本上看看函数的名称就知道这个函数的作用。在大家设置时钟的时候，一定要仔细参考STM32 的时钟图，做到心中有数。这里需要指明一下，对于系统时钟，默认情况下是SystemInit 函数的 SetSysClock() 函数中间判断的，而设置是通过宏定义设置的。我们可以看看 SetSysClock() 函数体：

1. static void SetSysClock(void)
     R. W; _) f8 U9 t9 {* ^
2. {
   
3. #ifdef SYSCLK_FREQ_HSE
   
4.   SetSysClockToHSE();
   
5. #elif defined SYSCLK_FREQ_24MHz
   - S0 ^! ~& v$ S; i9 @
6.   SetSysClockTo24();
   
7. #elif defined SYSCLK_FREQ_36MHz
   
8.   SetSysClockTo36();
   
9. #elif defined SYSCLK_FREQ_48MHz
   
10.   SetSysClockTo48();
    
11. #elif defined SYSCLK_FREQ_56MHz
      k- R( ?+ v; F) p
12.   SetSysClockTo56();  
    : Q, M# S9 [+ J) b# M
13. #elif defined SYSCLK_FREQ_72MHz
    / O  r1 w' a* @4 K' i8 K7 X  f
14.   SetSysClockTo72();
    3 ^# H* y+ K8 W. {6 \; N7 G
15. #endif
    
16. }

复制代码

这段代码非常简单，就是判断系统宏定义的时钟是多少，然后设置相应值。我们系统默认宏定
6 G" }/ w7 c" }  _2 j' H$ B/ Y义是 72MHz:

. Y4 R8 ^4 i' [! Q; W+ f; a( n* i/ I3 j

1. #define SYSCLK_FREQ_72MHz  72000000

复制代码

如果你要设置为36MHz ，只需要注释掉上面代码，然后加入下面代码即可
- B; j4 E$ K% [6 a# P$ ~5 s" @; t
. V& t$ P5 H! N+ N5 x5 s+ X

1.   #define SYSCLK_FREQ_36MHz  36000000

复制代码

+ U: p3 ^- s/ j( _" N, b9 Q) l 同时还要注意的是，当我们设置好系统时钟后，可以通过变量SystemCoreClock 获取系统时钟
值，如果系统是 72M 时钟，那么 SystemCoreClock =72000000 。这是在 system_stm32f10x.c 文件中设置的：

1. #ifdef SYSCLK_FREQ_HSE
   ( F: R( q  r# s, u
2.   uint32_t SystemCoreClock         = SYSCLK_FREQ_HSE;      
   ' a7 y/ Y9 l7 Y) y0 N8 z- s) @$ }
3. #elif defined SYSCLK_FREQ_24MHz
   
4.   uint32_t SystemCoreClock         = SYSCLK_FREQ_24MHz;        
   
5. #elif defined SYSCLK_FREQ_36MHz
   3 U" Y+ O) N. H  y
6. #elif defined SYSCLK_FREQ_48MHz
   ( z! R# y6 V/ n' Z0 H# Y+ D- t7 D
7.   uint32_t SystemCoreClock         = SYSCLK_FREQ_48MHz;      
   . ?; D7 l. z2 W$ r
8. #elif defined SYSCLK_FREQ_56MHz
   * W; G1 D/ ]3 f" {- i6 }
9.   uint32_t SystemCoreClock         = SYSCLK_FREQ_56MHz;        
   5 g- L) `. v9 ~: \
10. #elif defined SYSCLK_FREQ_72MHz
    8 n3 Z7 u2 B. ~  T' `
11.   uint32_t SystemCoreClock         = SYSCLK_FREQ_72MHz;      
    3 I9 a- x, s* z: ^4 {0 C8 A6 O
12. #else
      r$ T1 ], _  F4 [+ L. X8 u, e
13.   uint32_t SystemCoreClock         = HSI_VALUE;      
    7 K& A0 ]( I# O+ z, R
14. #endif

复制代码

/ G' _7 d9 e3 x, N这里总结一下SystemInit() 函数中设置的系统时钟大小：
. k# N; V0 I3 r: d$ P. {& m3 l* m
4 u+ @, b# e3 z1 U' u) P0 ^* ZSYSCLK （系统时钟 =72MHz
2 v4 U2 A9 j% v3 C5 D$ z' zAHB 总线时钟 使用 SYSCLK) =72MHz
APB1 总线时钟 ( =36MHz
$ a$ t8 P7 _( ^APB2 总线时钟 ( =72MHz
PLL 时钟 =72MHz
. Q1 E! ^: R' L8 t# c- T2.时钟配置寄存器介绍
以上介绍了SystemInit()时钟配置函数，想必大家已经知道了STM32时钟的基本情况，如果你想要更深一步的了解底层原理，那么下面的知识可以帮你揭晓。

在STM32时钟配置的过程中使用到了RCC寄存器，它们分别是：
5 f) \4 [6 s( ?. L* R; ^
1 G0 H/ M5 ^, p! h时钟控制寄存器（RCC_CR)
& H) i8 J3 ?5 \, |时钟配置 寄存器（RCC_CFGR)

首先介绍时钟控制寄存器，先上一张官方手册的寄存器说明:

8 _' t6 ^3 w% I
/ R$ L  k0 \8 M! w, _


, X5 |  R/ F0 f6 a+ x4 A6 q( ^! a

这个是时钟控制寄存器，看似很复杂，实际上并没有使用到寄存器所有的位，而是红框标出的部分位。下表是RCC另一个重要的寄存器：时钟配置寄存器（RCC_CFGR）






- U0 q! M% y; ~3 {; P


和时钟控制寄存器RCC_CR相比，时钟配置寄存器RCC_CFGR要复杂一些，同样的，重点使用的位用红色框标识了出来。

% f; {( U4 X0 l( N/ m. ?' x. p3. 时钟配置总流程
3 _+ [7 |3 q& A; _5 c在STM32单片机复位之后，首先进入startup程序：
! u, V7 m3 P! c/ q# T

1. ; Reset handler
   
2. Reset_Handler   PROC
   
3.                 EXPORT  Reset_Handler             [WEAK]
   5 z3 A, Q7 U. a) K9 {7 p+ d! f% c
4.                 IMPORT  __main
   ( c# L" H) W9 X5 H7 L8 T
5.                 IMPORT  SystemInit
   . F& V8 L  |3 e
6.                 LDR     R0, =SystemInit
   ) T* G" _% e1 {% H- G
7.                 BLX     R0               
   % W+ M0 X% ^. B" U
8.                 LDR     R0, =__main
   
9.                 BX      R0
   
10.                 ENDP

复制代码

' W% I/ Q2 w& ?4 K+ t! W可以看出，在进入main主程序之前，先触发了SystemInit()函数，这样就可以保证不需要每次都把时钟配置程序写入main.c文件了，同样，当你想要执行自定义时钟配置程序时也可以改动这个部分。

首先我们看一下SystemInit()函数
0 Y' A: r! d% \3 l/ C

1. void SystemInit (void)
   
2. {
   # c: _1 V$ }9 }' {- [  [3 ^2 w3 o
3.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
   
4.   /* Set HSION bit */
   $ b" [; |9 {5 c) A6 z, U
5.   RCC->CR |= (uint32_t)0x00000001;
   
6.     SetSysClock();
   
7. }

复制代码

可以看到，SystemInit()函数的作用就是使RCC_CR寄存器最低位置1即开启内部8MHz振荡器，然后转到SetSysClock()函数中。刚刚已经讲过了，对于系统时钟，默认情况下就是SystemInit 函数的 SetSysClock() 函数中间判断的
* L' L8 O! g: I5 \* x! u4 @
下面是SetSysClock()函数：

1. static void SetSysClock(void)
   
2. {
   . B) n# R1 l) c" T
3. #ifdef SYSCLK_FREQ_HSE
   
4.   SetSysClockToHSE();
   : D+ v/ {$ O9 |  z0 y
5. #elif defined SYSCLK_FREQ_24MHz
   
6.   SetSysClockTo24();
   & `' G: X( z- P! i7 F
7. #elif defined SYSCLK_FREQ_36MHz
   1 H: c) }% C$ k! D
8.   SetSysClockTo36();
   5 Y# N. G! l+ U; a: R
9. #elif defined SYSCLK_FREQ_48MHz
   
10.   SetSysClockTo48();
    * W. ]6 f( J0 ?9 u4 R. }
11. #elif defined SYSCLK_FREQ_56MHz
    . x. b. K- O! g1 i2 Y5 f9 E3 L& {  e
12.   SetSysClockTo56();  
    7 {% _1 E, b3 _+ q: s- q
13. #elif defined SYSCLK_FREQ_72MHz
    
14.   SetSysClockTo72();
    2 g2 `  Y6 z* [/ |2 ?. r
15. #endif
    
16. 
    ' v% ^% |2 \' n& W2 U+ C$ E
17. /* If none of the define above is enabled, the HSI is used as System clock
    . ~5 P/ o# d2 K9 A
18.     source (default after reset) */
    
19. }

复制代码

由于我们把系统时钟频率通过宏定义设置为72MHz，所以这里直接进入最下面的程序即SetSysClockTo72()，这也是为什么有的程序把这一段语句直接写入主函数，原则上来说这是可以的，但是没必要，因为startup启动文件已经帮我们定义好了。

下面就是SetSysClockTo72()程序部分，也就是最关键的部分
  Z" j# E# P' d

1. static void SetSysClockTo72(void)
   . r; V+ s" k. y; ^, N5 U
2. {
   $ u+ M3 x9 k3 _; v8 c# m0 Y6 o
3.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
   / z3 ^2 M: d: D$ G7 u5 r4 r+ |
4. 
   5 Q; {4 B9 p: j7 D; Y5 s
5.   /* SYSCLK, HCLK, PCLK2 and PCLK1 配置---------------------------*/   
   " D- V' o* K' r0 P5 `+ `& E
6.   /* 使能 HSE */   
   ; J2 [: [) `# u
7.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);//RCC_CR寄存器第16位置1，开启HSE
   , v" R( J4 Q( w5 w1 E
8. 
   . p' G% b) {) j( T$ ]
9.   /* 等待HSE就绪 超时退出 */
   
10.   do
    1 `1 r4 A# o" Q  s* O0 G
11.   {
    
12.     HSEStatus = RCC->CR & RCC_CR_HSERDY;  //读取RCC_CR第17位
    / |1 c2 a% L: R/ N" @% A5 V8 p5 |
13.     StartUpCounter++;  
    
14.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    
15. 
    % v# h( Y- \! N! y# [2 N
16.   if ((RCC->CR & RCC_CR_HSERDY) != RESET) //读取RCC_CR第17位
    / [% z+ d/ Z0 k) U' U$ O) |% W
17.   {
    : V. @1 r# n0 j8 A7 P1 R- l2 W! B; Y
18.     HSEStatus = (uint32_t)0x01;   //HSE状态写1
    
19.   }
    
20.   else
    
21.   {
    
22.     HSEStatus = (uint32_t)0x00;   //HSE状态写0
    - o, I# |! e6 v$ s5 j/ U. i4 r
23.   }  
    
24. 
    
25.   if (HSEStatus == (uint32_t)0x01) //FLASH寄存器部分可以不用管
    # \$ h! O; ~6 S
26.   {
    ( s( E2 [4 M1 w8 n9 N* G
27.     /* 使能 Prefetch Buffer */
    
28.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    
29. 
    
30.     /* Flash 2 wait state */
    
31.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    
32.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;   
    
33. 
    
34. 
    
35.     /* HCLK = SYSCLK */
    
36.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;  //RCC_CFGR寄存器第4~7位写0，即AHB不分频，即HCLK使用72MHz时钟
    
37. 
    / J6 ~' t6 V0 |3 N6 i
38.     /* PCLK2 = HCLK */
    5 `! q. L6 {3 Z/ n3 @- Q
39.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1; //RCC_CFGR寄存器第11~13位写0，APB2不分频，即PCLK2使用72MHz时钟
    6 ]2 A5 K6 e- I1 D
40. 
    5 Y" k- A( ~; d* r
41.     /* PCLK1 = HCLK/2 */
    
42.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2; //RCC_CFGR寄存器第8~10位写100，APB1二分频，即PCLK1使用36MHz时钟
    5 ^% ^- h5 X5 R/ H' @
43. 
    
44. #else   
    
45.     /*  PLL 配置: PLLCLK = HSE * 9 = 72 MHz */
    4 V6 s  z! k6 X
46.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
    ) a  w3 ~9 @! N. C0 i- v
47.                                         RCC_CFGR_PLLMULL)); //RCC_CFGR寄存器的16~21位清零
    " y! t* {$ T3 Y! L& X# ?0 T  q
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 */
    & b: B/ g+ M- m  E8 K2 W
50. 
    1 T: z  E9 }) i% _
51.     /* 使能 PLL */
    
52.     RCC->CR |= RCC_CR_PLLON; //RCC->CR寄存器第24位置1，使能PLL
    0 [+ I5 m) B) ~
53. 
    
54.     /* 等待PLL就绪 */
    
55.     while((RCC->CR & RCC_CR_PLLRDY) == 0)  //读取PLL时钟就绪标志位（第25位）
    
56.     {
    
57.     }
    1 B* L! Q1 c9 P$ K* H4 x/ S! m
58. 
    
59.     /* 选择PLL作为系统时钟源 */
    " T5 w5 Q" y0 _1 ?) ]
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. 
    4 e9 S0 ~9 x4 }# Z5 |
63.     /* 等待PLL被用作系统时钟源就绪 */
    6 c$ p& S$ u" `. Y
64.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08) //等待RCC->CFGR寄存器第2~3位(SWS位)为10即就绪
    
65.     {
    
66.     }
    
67.   }
    
68.   else
    
69.   { /* If HSE fails to start-up, the application will have wrong clock
    ; J* ~: G( \/ v
70.          configuration. User can add here some code to deal with this error */
    
71.   }
    
72. }
    3 ^4 y: S* u: L% K" Y- d
73. #endif

复制代码

2 Q+ u% l7 U& \4 s6 C6 x( ~" ^& N这里把所有的备注都写在了程序中，希望读者仔细查看并对照寄存器功能表理解。STM32的寄存器的每一个位都做了宏定义，这样直接查找头文件即可，非常方便。
6 L- {9 S( a) \1 u  ~' \
至此STM32系统时钟的讲解就已经结束了，我们以大容量芯片72MHz的系统时钟为例来进行讲解，你也可以根据实际情况自己配置，原理都是一样的。下面的内容就是灵活使用STM32的系统时钟来实现演示功能了。
& S( G5 j! }$ g; a9 x
三、Systick定时器及delay延时函数
4 k& c1 u6 H0 h1. Systick定时器
$ e* \: b# [7 s1 q前面讲完了STM32系统时钟的基本配置，下面就是对延时函数进行介绍了，延时函数使用到了STM32的SysTick定时器，这是一个很简单的定时器，对于CM3和CM4内核芯片都具备。

9 E7 p) O) h2 l& y& nSysTick定时器全称是System tick timer即系统滴答定时器，常用来做延时或者系统的心跳时钟。这样可以节省MCU资源，不用浪费一个定时器。比如在UCOS操作系统中分时复用，需要一个最小的时间戳，一般在STM32+UCOS系统中，都采用SysTick做UCOS心跳时钟。
1 G% m4 R& T/ ]# P" |( o, d
( K% F1 k7 n$ h% x. v9 {SysTick定时器就是系统滴答定时器，一个24位倒计数定时器，计数到0时将从RELOAD寄存器中自动重装载定时器初值。只要不把它在SysTick控制及状态寄存器中的使能位清除，就永不停息，即使在睡眠模式也能工作。
2 W& O6 I* G  _- }  \SysTick定时器被捆绑在NVIC中，用于产生SYSTICK异常（异常号为15）。
SysTick中断的优先级也可以设置

2. 相关寄存器介绍
: f) c9 N$ q* X: T7 s( LSysTick定时器一共有四个相关寄存器：
! A% F% }5 T+ i' X( G' C( w
CTRL              SysTick 控制和状态寄存器
' a$ x) }' ^- D9 v$ yLOAD              SysTick 自动重装载除值寄存器   
VAL                 SysTick 当前值寄存器
CALIB             SysTick 校准值寄存器      
下面分别介绍这四个寄存器
4 r  ]- M8 }7 q, Y. k
+ C1 I# x: n9 P. G5 X# B* j* T




  a, x) n  V# n. p' n

9 @" n/ \9 u0 }- W9 s; v  u
, i9 p8 B; f# M, Q! ~ 这是四个相关的寄存器，实际上我们一般只用到前三个。
5 d$ y  k7 E6 z  H9 N4 w
3. 延时函数配置
对于STM32，外部时钟源是 HCLK(AHB总线时钟）的1/8 ，内核时钟是 HCLK时钟。配置函数：SysTick_CLKSourceConfig();这个函数在misc.c文件中，这里把它粘出来：

1. void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
   
2. {
   
3.   /* Check the parameters */
   ' X0 r2 a: |8 X+ S
4.   assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
   1 }4 i) t; a$ }( S9 v, k$ G
5.   if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
   
6.   {
   
7.     SysTick->CTRL |= SysTick_CLKSource_HCLK;
   " k; V- p' d1 J' F4 c; u; v
8.   }
   
9.   else
   6 R  e* {( E8 T* X+ i
10.   {
      Q: G  E0 z, U# y6 i
11.     SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
    
12.   }
    
13. }

复制代码

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

core_cm3.h文件中有关于初始化systick时钟和开启中断的函数，如下所示：

/ I7 x' ?7 U( j+ r  W2 B

1. static __INLINE uint32_t SysTick_Config(uint32_t ticks)
   . o. ]4 p3 h' }! X
2. {
   
3.   if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
   , Q. O" d* @# c% s: m
4. 
   8 I( H+ ~2 l4 l" b# I9 m, K/ ~
5.   SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
   
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 |
   9 O. u# K: M) r( [( [
9.                    SysTick_CTRL_TICKINT_Msk   |
   
10.                    SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
    " f2 l  x( _& }
11.   return (0);                                                  /* Function successful */
    
12. }

复制代码

需要注意的是第5行把重装载寄存器的值减1的目的是考虑到执行装在动作也需要一个时钟周期。
+ m/ ~5 N+ h6 }+ h9 c3 ~) ~0 \
下面是用中断的方式来实现延时：

4 C& f: `9 Z4 X$ `- \

1. static __IO uint32_t TimingDelay;
   
2. void Delay(__IO uint32_t nTime)
   
3. {
   6 N# H% l& W9 f- }/ v
4.    TimingDelay = nTime;
   / v! p5 d+ l' p' v8 @, b
5.    while(TimingDelay != 0);
   
6. }
   0 J+ P. t9 ]9 `8 b
7. void SysTick_Handler(void)
   2 {+ H' w$ o: i8 |
8. {
   
9.     if (TimingDelay != 0x00)
   
10.      {
    
11.        TimingDelay--;
    
12.      }
    
13. }
    5 z5 v7 g! H8 N7 L2 K$ |/ r  U
14. int main(void)
    
15. {  …
    
16.     if (SysTick_Config(SystemCoreClock / 1000)) //systick时钟为HCLK，中断时间间隔1ms
    8 s* w( A7 Z8 t7 @! {. {0 s' Z' J
17.      {
    - M/ T+ l) ~3 G$ r; I, w
18.      while (1);
    , h# ]) X" n" u9 s
19.      }
    
20.     while(1)
    9 n& L3 x* ^) W+ U- ?" U1 a
21.      { Delay(200);//2ms
    
22.      …
    " I' J. [  O. C
23.      }
    2 T  E" q( f: S. X: {/ O
24. }

复制代码

) U9 B+ L; o" |' R) Q2 _
! y- D& Z5 `: L0 P程序中，SysTick_Config(SystemCoreClock / 1000)的目的是确保SysTick定时器每次发生中断的时间间隔都是1ms（因为使用系统时钟的时钟频率为72000000,SystemCoreClock / 1000等于72000，也就是给重装载寄存器值赋72000，这样计72000正好是1ms）
, V3 e& k8 k- N; X. W5 b
, v! e7 @: `9 E/ Z3 S一般实际应用中我们不使用通过中断来驱动延时的方法，因为这样会多一个中断线路，我们采用的 是单独的延时函数，下面就是延时函数文件：

1. #include "delay.h"
   
2. //         
   ' g( _7 y0 S" G$ C  n" }
3. //如果需要使用OS,则包括下面的头文件即可.
   
4. #if SYSTEM_SUPPORT_OS
   6 T$ i) u* @7 y& Q& @
5. #include "includes.h"                                        //ucos 使用         
     U+ g# t; Z* l+ j# f7 x) R
6. #endif
   
7. //         
   . K, \/ k5 v" D" [5 \
8. 
   
9. static u8  fac_us=0;                                                        //us延时倍乘数                           
   ) j8 _5 V% J8 M% B* m
10. static u16 fac_ms=0;                                                        //ms延时倍乘数,在ucos下,代表每个节拍的ms数
    
11.         
    
12.         
    
13. #if SYSTEM_SUPPORT_OS                                                        //如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
    % A. x5 f( X& [7 ^0 e% j& O, Y
14. //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    7 B3 v' j9 z) X
15. //首先是3个宏定义:
    
16. //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
      h: s9 z/ N( j9 b
17. //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    " _* J0 A, R' [" y6 {( g+ @
18. // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    0 S3 I5 A4 P" y! U. ^" W2 {3 N
19. //然后是3个函数:
    
20. //  delay_osschedlock:用于锁定OS任务调度,禁止调度
    
21. //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    
22. //    delay_ostimedly:用于OS延时,可以引起任务调度.
    1 {) T; |0 D0 Q4 @" _
23. 
    
24. //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    
25. //支持UCOSII
    0 l4 l% V& X" H4 ?
26. #ifdef         OS_CRITICAL_METHOD                                                //OS_CRITICAL_METHOD定义了,说明要支持UCOSII                                
    
27. #define delay_osrunning                OSRunning                        //OS是否运行标记,0,不运行;1,在运行
    6 F% I! q8 }% Q; {% R9 c
28. #define delay_ostickspersec        OS_TICKS_PER_SEC        //OS时钟节拍,即每秒调度次数
    , E) v! L2 K% }9 I5 \
29. #define delay_osintnesting         OSIntNesting                //中断嵌套级别,即中断嵌套次数
    2 x" C8 u* j9 v
30. #endif
    
31. 
    
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时钟节拍,即每秒调度次数
    # y3 v1 c( b: q* k! ]
36. #define delay_osintnesting         OSIntNestingCtr                //中断嵌套级别,即中断嵌套次数
    8 \+ b5 q; i( W& C
37. #endif
    " @0 r7 f; u, A( V7 m/ W
38. 
    ; |! D; B% e0 J: d4 a
39. 
    
40. //us级延时时,关闭任务调度(防止打断us级延迟)
    : [. H$ ~" D* Z" w; W) C
41. void delay_osschedlock(void)
    0 {& v2 v8 P- d0 m8 p
42. {
    $ I' q& Z: }% |+ N+ T
43. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
    . Z! h/ F% r/ D. s: m" M
44.         OS_ERR err;
    # X! n+ S. i& Y
45.         OSSchedLock(&err);                                                        //UCOSIII的方式,禁止调度，防止打断us延时
    
46. #else                                                                                        //否则UCOSII
    
47.         OSSchedLock();                                                                //UCOSII的方式,禁止调度，防止打断us延时
    9 S5 F4 X6 f& L: K5 H2 J1 \$ f
48. #endif
    
49. }
    
50. 
    ' H) A, z; e/ ~3 ~1 ~
51. //us级延时时,恢复任务调度
    & S0 E( x. k1 P
52. void delay_osschedunlock(void)
    % M" U; H4 a% b& F0 K7 H- t
53. {        
    
54. #ifdef CPU_CFG_CRITICAL_METHOD                                   //使用UCOSIII
    
55.         OS_ERR err;
    
56.         OSSchedUnlock(&err);                                                //UCOSIII的方式,恢复调度
    
57. #else                                                                                        //否则UCOSII
    ( s5 m0 M$ t  S
58.         OSSchedUnlock();                                                        //UCOSII的方式,恢复调度
    * V# q0 Q0 n" V
59. #endif
    : y/ ]4 S0 X4 Q/ m
60. }
    4 }6 ^6 o- r7 H# G8 Q0 u/ z
61. 
    
62. //调用OS自带的延时函数延时
    & t5 }% h8 @2 Z  q
63. //ticks:延时的节拍数
    
64. void delay_ostimedly(u32 ticks)
    ' R& \- G& p  p1 K7 w
65. {
    
66. #ifdef CPU_CFG_CRITICAL_METHOD
    
67.         OS_ERR err;
    
68.         OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);        //UCOSIII延时采用周期模式
    * m8 Z" J1 h8 p1 R" o
69. #else
    ) N! l' Q* u3 U$ z8 m
70.         OSTimeDly(ticks);                                                        //UCOSII延时
    
71. #endif
    
72. }
      U( A! g3 ^/ F! _( H" w
73. 
    
74. //systick中断服务函数,使用ucos时用到
    
75. void SysTick_Handler(void)
    ' z7 p/ D, E4 t2 {% v$ ^$ ]0 Z
76. {        
    
77.         if(delay_osrunning==1)                                                //OS开始跑了,才执行正常的调度处理
    % L% B9 s/ {" p8 O8 n
78.         {
    
79.                 OSIntEnter();                                                        //进入中断
    
80.                 OSTimeTick();                                               //调用ucos的时钟服务程序               
    
81.                 OSIntExit();                                                        //触发任务切换软中断
    ) p- @# e, G# f3 X
82.         }
      M# F5 P5 o7 [
83. }
    
84. #endif
    
85. 
    
86.                            
    
87. //初始化延迟函数
    . o9 d( X4 W' J7 F
88. //当使用OS的时候,此函数会初始化OS的时钟节拍
    
89. //SYSTICK的时钟固定为HCLK时钟的1/8
    9 l& N; U  W: ]; ~% N' _
90. //SYSCLK:系统时钟
    9 T! R8 k% z1 x$ f$ k+ R
91. void delay_init()
    
92. {
    
93. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    2 ^: H3 J% G  C" G  h
94.         u32 reload;
    5 _# Q; M! E7 a: t9 e; q: N! L
95. #endif
    
96.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);        //选择外部时钟  HCLK/8
    1 e3 O7 k! o- L' B, o
97.         fac_us=SystemCoreClock/8000000;                                //为系统时钟的1/8  
    
98. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
    ! `/ L& q- L- i- w, r( H) h  T9 z
99.         reload=SystemCoreClock/8000000;                                //每秒钟的计数次数 单位为M  
    : y3 \8 N& @  |) S  ?
100.         reload*=1000000/delay_ostickspersec;                //根据delay_ostickspersec设定溢出时间
     / C% k: p3 C8 @9 \$ t
101.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右        
     
102.         fac_ms=1000/delay_ostickspersec;                        //代表OS可以延时的最少单位           
     ; n; z3 n& [0 j; y
103. 
     
104.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
     
105.         SysTick->LOAD=reload;                                                 //每1/delay_ostickspersec秒中断一次        
     - S7 H  \0 y0 \1 M; d1 z
106.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
     9 r( M8 x) l1 S: S  O2 l0 ~
107. 
     + R: w% s9 o% d# l. c
108. #else
     
109.         fac_ms=(u16)fac_us*1000;                                        //非OS下,代表每个ms需要的systick时钟数   
     9 {6 |8 J8 l$ b3 X! O7 }8 |
110. #endif
     
111. }                                                                    
     
112. 
     
113. #if SYSTEM_SUPPORT_OS                                                          //如果需要支持OS.
     
114. //延时nus
     
115. //nus为要延时的us数.                                                                                       
     
116. void delay_us(u32 nus)
     
117. {               
     
118.         u32 ticks;
     
119.         u32 told,tnow,tcnt=0;
     
120.         u32 reload=SysTick->LOAD;                                        //LOAD的值                     
     ! }6 j  k! A$ Z$ {
121.         ticks=nus*fac_us;                                                         //需要的节拍数                           
     3 \' g6 R0 U2 d* Q5 J
122.         tcnt=0;
     7 J0 E/ V! ?# q& ^
123.         delay_osschedlock();                                                //阻止OS调度，防止打断us延时
     
124.         told=SysTick->VAL;                                                //刚进入时的计数器值
     6 U8 G" b2 }. ^3 Y; V; v
125.         while(1)
     
126.         {
     ' O1 |5 O' C( o# Z8 `" Y  T# L
127.                 tnow=SysTick->VAL;        
     
128.                 if(tnow!=told)
     
129.                 {            
     ! Q9 }* p, m4 {& ~
130.                         if(tnow<told)tcnt+=told-tnow;                //这里注意一下SYSTICK是一个递减的计数器就可以了.
     / T: `0 w1 g2 _  G3 B- G# y+ h3 _# B
131.                         else tcnt+=reload-tnow+told;            
     
132.                         told=tnow;
     6 @8 d0 t4 |0 X. H4 Q
133.                         if(tcnt>=ticks)break;                                //时间超过/等于要延迟的时间,则退出.
     
134.                 }  
     
135.         };
     
136.         delay_osschedunlock();                                                //恢复OS调度                                                                           
     
137. }
     
138. //延时nms
     & z' d+ O2 ]; Q0 m" o% G, A$ A  r& X
139. //nms:要延时的ms数
     
140. void delay_ms(u16 nms)
     
141. {        
     " f+ t: x; c/ ~% c+ u! l1 A
142.         if(delay_osrunning&&delay_osintnesting==0)        //如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)            
     # \3 X* r- i' r1 y
143.         {                 
     
144.                 if(nms>=fac_ms)                                                        //延时的时间大于OS的最少时间周期
     7 M4 }1 p% c, O8 G" c! `& M
145.                 {
     
146.                            delay_ostimedly(nms/fac_ms);                //OS延时
     8 ]! I- c: w6 ^2 c* Q( E& A
147.                 }
     
148.                 nms%=fac_ms;                                                        //OS已经无法提供这么小的延时了,采用普通方式延时   
     7 K" c% n8 a7 k7 ]3 q, ~- [
149.         }
     5 ]2 T: X4 e: C7 U
150.         delay_us((u32)(nms*1000));                                        //普通方式延时  
     
151. }
     
152. #else //不用OS时
     
153. //延时nus
     
154. //nus为要延时的us数.                                                                                       
     
155. void delay_us(u32 nus)
     ! M$ P7 b; |3 h9 _/ F1 B
156. {               
     ) w2 c5 ]/ z0 |
157.         u32 temp;                     
     
158.         SysTick->LOAD=nus*fac_us;                                         //时间加载                           
     
159.         SysTick->VAL=0x00;                                                //清空计数器
     
160.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数         
     
161.         do
     
162.         {
     
163.                 temp=SysTick->CTRL;
     3 F8 r) D/ d, t: X
164.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
     
165.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
     " K: Z8 ^- O+ t8 D
166.         SysTick->VAL =0X00;                                               //清空计数器         
     
167. }
     ( F5 F  z  T, d. ~
168. //延时nms
     # J0 V$ y# w1 i' p. f! y# Q7 }
169. //注意nms的范围
     
170. //SysTick->LOAD为24位寄存器,所以,最大延时为:
     + g3 N1 Q% ]8 X3 x4 _6 W) f" J% \
171. //nms<=0xffffff*8*1000/SYSCLK
     
172. //SYSCLK单位为Hz,nms单位为ms
     
173. //对72M条件下,nms<=1864
     
174. void delay_ms(u16 nms)
     
175. {                                    
     
176.         u32 temp;                  
     
177.         SysTick->LOAD=(u32)nms*fac_ms;                                //时间加载(SysTick->LOAD为24bit)
     
178.         SysTick->VAL =0x00;                                                        //清空计数器
     
179.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;        //开始倒数  
     
180.         do
     
181.         {
     
182.                 temp=SysTick->CTRL;
     - a+ @7 S" m" ]$ o" c- d
183.         }while((temp&0x01)&&!(temp&(1<<16)));                //等待时间到达   
     
184.         SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;        //关闭计数器
     
185.         SysTick->VAL =0X00;                                               //清空计数器                     
     9 m9 l8 |4 n! |; o7 W- B
186. }
     # S& n) y/ r6 P7 s
187. #endif

复制代码

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


总结
8 l& L$ ^2 B& Y5 v& T/ x        本节主要对STM32时钟系统进行讲解，我们从原理框图入手，对每一个时钟线路进行来源和去向的分析，介绍了时钟配置的相关寄存器以及STM32时钟的软件配置，最后通过SysTick定时器来编写延时函数。STM32的时钟十分复杂，希望读者能够反复阅读，内化于心，这样在以后的STM32开发以至于其它高性能SOC的学习中才能游刃有余。
5 A- h+ r- l( i; m3 y" K# [
8 f* B( I+ e! W# m& S" l2 [. {3 E
/ `, k8 _% g: d. v