库里面的时钟配置程序。
startup 里面有个调用SystemInit（）函数的过程：

1. Reset handler
   5 D, }0 @6 ?, R, [% n* `3 x
2. Reset_Handler   PROC
   ; y/ B/ w  P) i4 @
3.                 EXPORT  Reset_Handler             [WEAK]
   
4.                 IMPORT  __main
   - J/ g( Z. ^4 R$ F, K: |
5.                 IMPORT  SystemInit
   # Z7 j* t6 c# k+ \: L% e6 M
6.                 LDR     R0, =SystemInit
   6 h" d6 e6 R3 S7 }' t! u
7.                 BLX     R0               
   * Z! Y2 [6 ?0 `- j4 y
8.                 LDR     R0, =__main
   - ]5 W- u& W3 D5 Z0 Z2 c/ d
9.                 BX      R0
   6 K/ Q4 e; a7 Y# D
10.                 ENDP

复制代码

这个SystemInit在哪里定义呢？在system_stm32f10x.c中定义。
1 Q( i- Z8 Q0 g4 l$ iSystemInit()快结束时调用了SetSysClock()函数，时钟配置就由该函数具体实施。
------------------------------------------------------
8 e* w' r: f4 e) I: \9 xSetSysClock()也在system_stm32f10x.c中定义。
$ F$ Y4 X$ g  \其实该函数很短，它根据不同的宏定义来调用不同的SetSysClockToxx()函数，比如SetSysClockTo71()就是当有宏定义SYSCLK_FREQ_72MHz时就调用该函数来具体配置时钟的。这些不同的SetSysClockToxx()调用是有优先级的，频率低的大于频率高的，而直接采用HSE具有最高优先级。
! ^' H0 W5 L1 K' ^& _9 ~! Q来看看这些宏定义和调用函数之间的关系：
) K- t: W. _4 c6 [$ l' K4 q3 \首先是定义宏：
  D- [4 d8 b: U& h: U0 Q  \

1. #if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
   
2. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
     |& H/ ]; N- w* P
3. #define SYSCLK_FREQ_24MHz  24000000
   5 Q( U% B; A4 h) Y( s
4. #else
   . q5 y1 n' h9 E. Y+ y% ~7 t
5. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
     f# t- Q' d* ^) _  \0 [$ D) r- Q
6. /* #define SYSCLK_FREQ_24MHz  24000000 */
   5 F% L. H4 W1 e* K# @3 h# k
7. /* #define SYSCLK_FREQ_36MHz  36000000 */
   3 F$ ?1 h7 }' W7 o6 Z
8. /* #define SYSCLK_FREQ_48MHz  48000000 */
   
9. /* #define SYSCLK_FREQ_56MHz  56000000 */
   . j/ b' f& p8 J' K: H" g$ ~! |( }
10. #define SYSCLK_FREQ_72MHz  72000000
    
11. #endif

复制代码

看来需要根据项目需求来，不能同时使用多个宏，不用的宏需要注释掉。
4 E, q: N7 c2 u" @+ N然后根据定义的宏来声明所需的函数：

1. [mw_shl_code=c,true]#ifdef SYSCLK_FREQ_HSE
   
2.   static void SetSysClockToHSE(void);
   
3. #elif defined SYSCLK_FREQ_24MHz
   . P7 A1 R3 _% i2 Z6 E
4.   static void SetSysClockTo24(void);
   
5. #elif defined SYSCLK_FREQ_36MHz
   
6.   static void SetSysClockTo36(void);
   ) y* x/ N8 P2 z+ P
7. #elif defined SYSCLK_FREQ_48MHz
   ! u& p  F% J+ M; F
8.   static void SetSysClockTo48(void);
   
9. #elif defined SYSCLK_FREQ_56MHz
   4 |; m3 y" H, p3 E# j9 `
10.   static void SetSysClockTo56(void);
    0 v- o2 }: z' R% M! T
11. #elif defined SYSCLK_FREQ_72MHz
    , p: l8 C: b& s2 Y2 }2 \1 ]
12.   static void SetSysClockTo72(void);
    
13. #endif
    
14. [/mw_shl_code]

复制代码

/ Y4 d4 |3 t. G) ~: P如果定义了多个宏会屏蔽掉低优先级的函数。在SetSysClock()里面再根据宏来调用用时钟配置函数：

1. [mw_shl_code=c,true]static void SetSysClock(void)
   4 N9 @0 t# x, _) Y4 n3 S
2. {
   
3. #ifdef SYSCLK_FREQ_HSE
   & f2 U" t3 X5 Q
4.   SetSysClockToHSE();
   + @& o/ Z, S! Z6 o
5. #elif defined SYSCLK_FREQ_24MHz
   + J1 Y8 @, F0 \
6.   SetSysClockTo24();
   
7. #elif defined SYSCLK_FREQ_36MHz
   
8.   SetSysClockTo36();
   ' z. f" W$ U0 ?
9. #elif defined SYSCLK_FREQ_48MHz
   
10.   SetSysClockTo48();
    2 v4 J. t, p. E0 E- r$ `
11. #elif defined SYSCLK_FREQ_56MHz
    
12.   SetSysClockTo56();
    , e: C7 h! o* V( z( @0 z$ S
13. #elif defined SYSCLK_FREQ_72MHz
    6 V9 ^9 Z  E$ ]3 {8 q4 {* v2 f
14.   SetSysClockTo72();
    
15. #endif
    
16. 
    
17. 
    
18. /* If none of the define above is enabled, the HSI is used as System clock
    5 h4 x3 T, g  f7 @9 x
19.     source (default after reset) */
    
20. }
    
21. [/mw_shl_code]

复制代码

+ m! H% ~1 H& ^如果没有宏定义，或者说让SystemInit()函数为空函数，则系统不会配置时钟而直接采用内部高速时钟HSI作为系统时钟使用。
system_stm32f10x.c里面其他的代码就是关于这些SetSysClockToxx()的实现。也就是如何使用寄存器来设置倍频、分频数等等，需要了解了寄存器后才能明白。查看这些函数，有个直观的感受是里面的代码是直接使用寄存器来设置数据的，不是使用库函数。通观整个过程，如果只是学习的话，根据硬件只需要把待设置成的频率宏去掉注释而把不需要的宏注释掉就可以了，编译时会自动加入需要的时钟设置函数的。

2 S* m7 C$ I- j7 C5 j配置好时钟后就开始执行用户程序了，在用户程序里面要使用外设首先必须让外设挂载的总线上的该设备进行时钟使能，让时钟驱动外设工作。
这是通过寄存器设置来实现的。
RCC一共有10个寄存器，互联型更多。启动时配置时钟当然要是通过这些寄存器来设置的，不过进入main后使能外设时钟就只用到了三个寄存器：RCC_AHBENR、RCC_APB2ENR、RCC_APB1ENR。寄存器同样是封装在结构体里面的：RCC_TypeDef，里面的寄存器名称去掉了RCC_前缀。既然是使用库函数，我们也就不必太关心这些寄存器封装是如何使用的了，只需关心库提供了哪些函数去操作这些寄存器实现所需的功能了。
RCC库函数在stm32f10x_rcc.h和.c中实现。
" a$ P/ h# f7 Q% f, X& C( |RCC地址宏定义，在stm32f10x.h中定义：

1. [mw_shl_code=c,true]#define PERIPH_BASE           ((uint32_t)0x40000000) /*!< Peripheral base address in the alias region */
   2 Z2 g& \2 K$ V
2. #define AHBPERIPH_BASE        (PERIPH_BASE + 0x20000)
   
3. #define RCC_BASE              (AHBPERIPH_BASE + 0x1000)#define RCC                 ((RCC_TypeDef *) RCC_BASE)
   & V  c- g4 [0 T$ C( R
4. #define RCC                 ((RCC_TypeDef *) RCC_BASE)
   & \, z, l& C. U/ i
5. [/mw_shl_code]

复制代码

RCC寄存器原来是在AHB总线地址空间上的，这个AHB总线有些不平常。AHB、APB1、APB2总线上外设使能的函数分别是：

1. [mw_shl_code=c,true]void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);
   & A) ~0 M* P$ m' F; j
2. void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);
   
3. void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);[/mw_shl_code]

复制代码

要使某个外设时钟使能，其实就是使RCC_AHBENR、RCC_APB2ENR、RCC_APB1ENR三个寄存器中对应位置1，那么这是如何在函数中实现的呢？首先是定义了这三个寄存器各个位代表的外设的宏，也就是当置1时寄存器的值。以APB2ENR寄存器各个位代表的外设为例说明：
" t! k8 K" P, y

1. [mw_shl_code=c,true]#define RCC_APB2Periph_AFIO              ((uint32_t)0x00000001)
   
2. #define RCC_APB2Periph_GPIOA             ((uint32_t)0x00000004)
   ( H, v# \+ X2 I% K1 y
3. #define RCC_APB2Periph_GPIOB             ((uint32_t)0x00000008)
   7 W: q' L2 }8 Y$ E' H
4. #define RCC_APB2Periph_GPIOC             ((uint32_t)0x00000010)
   ( h9 f, s0 h! ^  D6 W
5. #define RCC_APB2Periph_GPIOD             ((uint32_t)0x00000020)
   # l8 B" m  _' h- D
6. #define RCC_APB2Periph_GPIOE             ((uint32_t)0x00000040)
   4 Z6 w2 K# y+ S. H
7. #define RCC_APB2Periph_GPIOF             ((uint32_t)0x00000080)
   
8. #define RCC_APB2Periph_GPIOG             ((uint32_t)0x00000100)
   
9. #define RCC_APB2Periph_ADC1              ((uint32_t)0x00000200)
   7 m. Q6 t* N/ L  Y  _
10. #define RCC_APB2Periph_ADC2              ((uint32_t)0x00000400)
    
11. #define RCC_APB2Periph_TIM1              ((uint32_t)0x00000800)
    
12. #define RCC_APB2Periph_SPI1              ((uint32_t)0x00001000)
    6 U2 w* z! e# g3 [/ [1 ]; T
13. #define RCC_APB2Periph_TIM8              ((uint32_t)0x00002000)
    & L4 r/ ?9 F3 G/ ^- a; a6 F
14. #define RCC_APB2Periph_USART1            ((uint32_t)0x00004000)
    , n2 m( c5 Q* I$ v+ \) K6 J% O' \
15. #define RCC_APB2Periph_ADC3              ((uint32_t)0x00008000)
    ( y- _2 t, d" {
16. #define RCC_APB2Periph_TIM15             ((uint32_t)0x00010000)
    
17. #define RCC_APB2Periph_TIM16             ((uint32_t)0x00020000)
    
18. #define RCC_APB2Periph_TIM17             ((uint32_t)0x00040000)
    5 v! A! f; ^. q5 @- `
19. #define RCC_APB2Periph_TIM9              ((uint32_t)0x00080000)
    
20. #define RCC_APB2Periph_TIM10             ((uint32_t)0x00100000)
    
21. #define RCC_APB2Periph_TIM11             ((uint32_t)0x00200000)
    
22. [/mw_shl_code]

复制代码

; @, d( S6 {* |. d
均是当外设位为1而其他位为0时寄存器的值。stm32中文参考手册V10.0中关于APB2ENR寄存器只有低16位有定义，高16位保留，可是，库函数里面却有高16位的几个定义，这是为什么？
3 s9 D5 {5 S6 H0 F0 S6 I而如果需要使能就使APB2ENR寄存器“或”上该值，关闭则是“与”上该值的取反值。

1. [mw_shl_code=c,true]void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState)
   / N- w8 K2 I& ~
2. {
   " d( G. S6 p, f4 Z5 Y2 {% E* O1 s+ C
3.   /* Check the parameters */
   
4.   assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph));
   6 A! X4 H5 r; `* x' F
5.   assert_param(IS_FUNCTIONAL_STATE(NewState));
   
6.   if (NewState != DISABLE)
   
7.   {
   % F0 X( x6 w( t: a
8.     RCC->APB2ENR |= RCC_APB2Periph;
   . _" d0 @' B( M$ i! M6 t2 G5 l
9.   }
   * P. Q/ Z; |& c' Q
10.   else
    
11.   {
    , i3 U# R" x- }2 I. |
12.     RCC->APB2ENR &= ~RCC_APB2Periph;
    
13.   }
    . |9 @: |) V) N, {- S
14. }
    
15. [/mw_shl_code]

复制代码

2 c9 X6 v& @2 p+ L6 {------------------------------------------------
% S2 ?9 ]2 q. N: ^$ B断言assert_param()：
2 Z) w7 }6 E1 J: g/ z! R- t% L看似是一个函数，其实是宏，在stm32f10x_conf.h中定义：
6 Q; Y3 l- h+ N3 V- @0 ?% A/ y

1. [mw_shl_code=c,true]#ifdef  USE_FULL_ASSERT
   * G( ?/ Y# K( m: A: f6 y. S7 f
2.   #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
   # E2 N; k) |$ F0 [- T
3. 
   ! ?( x* W9 m, c! M/ `) r7 P7 T
4. 
   & H, d! j5 r9 {: u- @& q+ Q. `3 ~
5.   void assert_failed(uint8_t* file, uint32_t line);
   
6. #else
   
7.   #define assert_param(expr) ((void)0)
   
8. #endif /* USE_FULL_ASSERT */
   8 t  S1 S" Z9 P4 f
9. [/mw_shl_code]

复制代码

, M6 G% F  a( D! @9 W; h1 }断言用于参数检查，如果说传入的参数符合要求那么宏值为(void)0，否则执行assert_failed()函数，这个函数没有实现。如果需要可以实现assert_failed()函数，指出哪个文件的哪行出了错误。
断言一般用在开发阶段，必须定义USE_FULL_ASSERT宏，否则只是得到(void)0，对于C来说就相当于空语句。开发调试结束取消USE_FULL_ASSERT宏。这里需要注意：宏定义不仅仅用于预编译阶段，它甚至可以用于运行阶段。比如在运行阶段才能决定断言里面的值倒地是true还是false，从而决定断言值是(void)0还是执行assert_failed()函数。断言和错误捕捉显然不同。
/ H. w' I, h5 J---------------------------------
& D* Q' t5 Y1 P9 f6 a来看看都做了什么检查：
3 o$ \. b3 Y" J3 `; j, G

1. assert_param(IS_FUNCTIONAL_STATE(NewState));
   
2. [mw_shl_code=c,true]#define IS_FUNCTIONAL_STATE(STATE) (((STATE) == DISABLE) || ((STATE) == ENABLE))
   
3. [/mw_shl_code]很清楚了，如果说参数STATE为DISABLE或ENABLE则宏值为true，否则为false。
   * q) ^5 S8 z  V
4. 那么 assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph))呢？[mw_shl_code=c,true]#define IS_RCC_APB2_PERIPH(PERIPH) ((((PERIPH) & 0xFFC00002) == 0x00) && ((PERIPH) != 0x00))
   . p4 }0 ?7 {: n$ _  g( y
5. [/mw_shl_code]

复制代码

0 c) Y6 B: e) E6 i6 E# e5 D  D这个比较诡异！！
---------------------------------------
总结，void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);中的RCC_APB2Periph参数必须是预定义的宏才能保证是有效值。
. I* m1 I- g7 M/ \0 P* \% [/ p比如：RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
7 D& q& V# {4 o! B7 E1 J如果需要同时使能多个同总线上的外设就采用“或”.
如何记忆这个函数：RCC_APB2PeriphClockCmd就是“关于RCC时钟的”挂载在APB2总线上的外设时钟使能函数，参数开头也必须是RCC_APB2Periph_开头。
————————————————
$ Y- g$ ]/ t% O版权声明：被大佬糊弄的只会点灯的小菜鸡
  Q* N$ Z! j+ ^  {* L2 M6 `+ v如有侵权请联系删除

4 h( z9 Q2 z$ N