21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › STM32的时钟系统RCC详细整理
返回列表 发新帖我要提问

[STM32F1] STM32的时钟系统RCC详细整理

[复制链接]
1477|11
 楼主| Tennasi 发表于 2016-10-30 14:36 | 显示全部楼层 |阅读模式
时钟系统, STM32, rc, hz, 倍频
一、综述：
1、时钟源
在 STM32 中，一共有 5 个时钟源，分别是 HSI 、 HSE 、 LSI 、 LSE 、 PLL 。
①HSI 是高速内部时钟， RC 振荡器，频率为 8MHz ；
②HSE 是高速外部时钟，可接石英 / 陶瓷谐振器，或者接外部时钟源，频率范围是 4MHz – 16MHz ；
③LSI 是低速内部时钟， RC 振荡器，频率为 40KHz ；
④LSE 是低速外部时钟，接频率为 32.768KHz 的石英晶体；
⑤PLL 为锁相环倍频输出，严格的来说并不算一个独立的时钟源， PLL 的输入可以接 HSI/2 、 HSE 或者 HSE/2 。PLL倍频可选择为 2 – 16 倍，但是其输出频率最大不得超过 72MHz 。
其中， 40kHz 的 LSI 供独立看门狗 IWDG 使用，另外它还可以被选择为实时时钟 RTC 的时钟源。另外，实时时钟 RTC 的时钟源还可以选择 LSE ，或者是 HSE 的 128 分频。
STM32 中有一个全速功能的 USB 模块，其串行接口引擎需要一个频率为 48MHz 的时钟源。该时钟源只能从 PLL 端获取，可以选择为 1.5 分频或者 1 分频，也就是，当需使用到 USB 模块时， PLL 必须使能，并且时钟配置为 48MHz 或 72MHz 。
另外 STM32 还可以选择一个时钟信号输出到 MCO 脚 (PA.8) 上，可以选择为 PLL 输出的 2 分频、 HSI 、 HSE 或者系统时钟。
系统时钟 SYSCLK ，它是提供 STM32 中绝大部分部件工作的时钟源。系统时钟可以选择为 PLL 输出、 HSI 、 HSE 。系系统时钟最大频率为 72MHz ，它通过 AHB 分频器分频后送给各个模块使用， AHB 分频器可以选择 1 、 2 、 4 、 8 、 16 、 64 、 128 、 256 、 512 分频，AHB分频器输出的时钟送给 5 大模块使用：
       ①送给 AHB 总线、内核、内存和 DMA 使用的 HCLK 时钟；
       ②通过 8 分频后送给 Cortex 的系统定时器时钟STCLK；
       ③直接送给 Cortex 的空闲运行时钟 FCLK ；
       ④送给 APB1 分频器。 APB1 分频器可以选择 1 、 2 、 4 、 8 、 16 分频，其输出一路供 APB1 外设使用（ PCLK1 ，最大频率 36MHz ），另一路送给定时器 (Timer)2 、 3 、 4 倍频器使用。该倍频器根据PCLK1的分频值自动选择 1 或者 2 倍频，时钟输出供定时器 2 、 3 、 4 使用。
       ⑤送给 APB2 分频器。 APB2 分频器可以选择 1 、 2 、 4 、 8 、 16 分频，其输出一路供 APB2 外设使用（ PCLK2 ，最大频率 72MHz ），另外一路送给定时器 (Timer)1 倍频使用。该倍频器根据PCLK2的分频值自动选择1 或 2 倍频，时钟输出供定时器 1 使用。另外 APB2 分频器还有一路输出供 ADC 分频器使用，分频后送给 ADC 模块使用。 ADC 分频器可选择为 2 、 4 、 6 、 8 分频。
需要注意的是定时器的倍频器，当 APB 的分频为 1 时，它的倍频值为 1 ，否则它的倍频值就为 2 。

回复

收藏2 举报

相关帖子
 楼主| Tennasi 发表于 2016-10-30 14:36 | 显示全部楼层
2、APB1和APB2连接的模块
①连接在 APB1( 低速外设 ) 上的设备有：电源接口、备份接口、 CAN 、 USB 、 I2C1 、 I2C2 、 UART2 、 UART3 、 SPI2 、窗口看门狗、 Timer2 、 Timer3 、 Timer4 。 注意 USB 模块虽然需要一个单独的 48MHz 的时钟信号，但是它应该不是供 USB 模块工作的时钟，而只是提供给串行接口引擎 (SIE) 使用的时钟。 USB 模块的工作时钟应该是由 APB1 提供的。
②连接在 APB2 （高速外设）上的设备有： UART1 、 SPI1 、 Timer1 、 ADC1 、 ADC2 、 GPIOx(PA~PE) 、第二功能 IO 口。
二、寄存器介绍：
复制
  1. typedef struct
    


  2. 

  3. {
    


  4. 

  5.   __IO uint32_t CR;
    


  6. 

  7.   __IO uint32_t CFGR;
    


  8. 

  9.   __IO uint32_t CIR;
    


  10. 

  11.   __IO uint32_t APB2RSTR;
    


  12. 

  13.   __IO uint32_t APB1RSTR;
    


  14. 

  15.   __IO uint32_t AHBENR;
    


  16. 

  17.   __IO uint32_t APB2ENR;
    


  18. 

  19.   __IO uint32_t APB1ENR;
    


  20. 

  21.   __IO uint32_t BDCR;
    


  22. 

  23.   __IO uint32_t CSR;
    


  24. 

  25. #ifdef STM32F10X_CL 
    


  26. 

  27.   __IO uint32_t AHBRSTR;
    


  28. 

  29.   __IO uint32_t CFGR2;
    


  30. 

  31. #endif /* STM32F10X_CL */
    


  32. 

  33. #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)  
    


  34. 

  35.   uint32_t RESERVED0;
    


  36. 

  37.   __IO uint32_t CFGR2;
    


  38. 

  39. #endif /* STM32F10X_LD_VL || STM32F10X_MD_VL || STM32F10X_HD_VL */
    


  40. 

  41. } RCC_TypeDef;


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:37 | 显示全部楼层
1、时钟控制寄存器(RCC_CR)：（复位值为0x0000 xx83，内部低速时钟使能和就绪，内部时钟校准）
主要功能：内外部高速时钟的使能和就绪标志（含内部高速时钟校准调整），外部高速时钟旁路，时钟安全系统CSS使能，PLL使能和PLL就绪标志。
2、时钟配置寄存器(RCC_CFGR)：（复位值为0x0000 0000）
主要功能：系统时钟源切换及状态，AHB、APB1、APB2、ADC、USB预分频，PLL输入时钟源选择及HSE输入PLL分频选择，PLL倍频系数，MCO（PA8）引脚微控制器时钟输出。
3、时钟中断寄存器 (RCC_CIR)：（复位值: 0x0000 0000）
主要功能：LSI、LSE、HIS、HSE、PLL就绪中断标志，HSE时钟失效导致时钟安全系统中断标志，LSI、LSE、HIS、HSE、PLL就绪中断使能，清除LSI、LSE、HIS、HSE、PLL就绪中断，清除时钟安全系统中断。
4、APB2外设复位寄存器 (RCC_APB2RSTR)：（复位值: 0x0000 0000）
主要功能：AFIO、IOPA、IOPB、IOPC、IOPD、IOPE、IOPF、IOPG、ADC1、ADC2、TIM1、SPI1、TIM8、USART1、ADC3复位。
5、APB1外设复位寄存器 (RCC_APB1RSTR) ：（复位值: 0x0000 0000）
主要功能：TIM2、TIM3、TIM4、TIM5、TIM6、TIM7、WWDG、SPI2、SPI3、USART2、USART3、USART4、USART5、I2C1、I2C2、USB、CAN、BKP、PWR、DAC复位。
6、AHB外设时钟使能寄存器 (RCC_AHBENR) ：（复位值: 0x0000 0014睡眠模式时SRAM、闪存接口电路时钟开启）
主要功能：DMA1、DMA2、SRAM、FLITF、CRC、FSMC、SDIO时钟使能。
7、APB2外设时钟使能寄存器(RCC_APB2ENR) ：（复位值: 0x0000 0000）
主要功能：AFIO、IOPA、IOPB、IOPC、IOPD、IOPE、IOPF、IOPG、ADC1、ADC2、TIM1、SPI1、TIM8、USART1、ADC3时钟使能。
8、APB1外设时钟使能寄存器(RCC_APB1ENR) ：（复位值: 0x0000 0000）
主要功能：TIM2、TIM3、TIM4、TIM5、TIM6、TIM7、WWDG、SPI2、SPI3、USART2、USART3、USART4、USART5、I2C1、I2C2、USB、CAN、BKP、PWR、DAC时钟使能。
9、备份域控制寄存器 (RCC_BDCR) ：（复位值: 0x0000 0000）
主要功能：外部低速振荡器使能和就绪标志及旁路、RTC时钟源选择和时钟使能、备份域软件复位。
10、控制/状态寄存器 (RCC_CSR) ：（复位值: 0x0C00 0000 NRST引脚复位标志、上电/掉电复位标志）
主要功能：内部低速振荡器就绪、清除复位标志、NRST引脚复位标志、上电/掉电复位标志、软件复位标志、独立看门狗复位标志、窗口看门狗复位标志、低功耗复位标志。
三、初始化设置
采用8MHz 外部HSE 时钟，在 MDK 编译平台中，程序的时钟设置参数流程如下：
    将 RCC 寄存器重新设置为默认值：RCC_DeInit();
    打开外部高速时钟晶振 HSE ：    RCC_HSEConfig(RCC_HSE_ON);
    等待外部高速时钟晶振工作：       HSEStartUpStatus = RCC_WaitForHSEStartUp();
    设置 AHB 时钟 (HCLK) ：          RCC_HCLKConfig(RCC_SYSCLK_Div1);
        设置APB 2时钟 (APB2) ：    RCC_PCLK2Config(RCC_HCLK_Div1);
        设置APB1 时钟 (APB1) ：    RCC_PCLK1Config(RCC_HCLK_Div2);
        设置 PLL ：       RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
    打开 PLL ：                                  RCC_PLLCmd(ENABLE);
    等待 PLL 工作：    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
设置系统时钟：    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
判断 PLL 是否是系统时钟：        while(RCC_GetSYSCLKSource() != 0x08);

回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:38 | 显示全部楼层
1、使用库函数进行时钟系统初始化配置
复制
  1. void RCC_config()//如果外部晶振为8M，PLLCLK=SYSCLK=72M，HCLK=72M，//P2CLK=72M，P1CLK=36M，ADCCLK=36M，USBCLK=48M，TIMCLK=72M
    


  2. 

  3. {
    


  4. 

  5.        ErrorStatus HSEStartUpStatus; // 定义错误状态变量
    


  6. 

  7.        RCC_DeInit();//将RCC寄存器重新设置为默认值
    


  8. 

  9.        RCC_HSEConfig(RCC_HSE_ON); //打开外部高速时钟晶振
    


  10. 

  11.        HSEStartUpStatus = RCC_WaitForHSEStartUp();// 等待外部高速时钟晶振工作
    


  12. 

  13.        if(HSEStartUpStatus == SUCCESS)
    


  14. 

  15.        {
    


  16. 

  17.        RCC_HCLKConfig(RCC_SYSCLK_Div1);//设置AHB不分频，HCLK=SYSCLK
    


  18. 

  19.        RCC_PCLK2Config(RCC_HCLK_Div1);//设置APB2不分频，P2CLK=HCLK
    


  20. 

  21.        RCC_PCLK1Config(RCC_HCLK_Div2); //设置APB1 为2分频，P1CLK=HCLK/2
    


  22. 

  23.        FLASH_SetLatency(FLASH_Latency_2);//设置FLASH代码延时
    


  24. 

  25.        FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);//使能预取指缓存
    


  26. 

  27.        RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);//设置PLL时钟源，
    


  28. 

  29. //外部时钟不分频，为HSE的9倍频8MHz * 9 = 72MHz
    


  30. 

  31.        RCC_PLLCmd(ENABLE);//使能PLL
    


  32. 

  33.        while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);//等待PLL准备就绪
    


  34. 

  35.        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//设置PLL为系统时钟源
    


  36. 

  37.        while(RCC_GetSYSCLKSource() != 0x08);//判断PLL是否是系统时钟
    


  38. 

  39.        }
    


  40. 

  41.             /*RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOD, ENABLE); // 打开 PB 和 PD 用于点亮 LED 灯*/
    


  42. 

  43. }


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:39 | 显示全部楼层
2、使用寄存器进行RCC时钟初始化配置
复制
  1. void RCC_init(u8 PLL)//输入PLL的倍频值2—16倍频
    


  2. 

  3. //HCLK=PLLCLK=SYSCLK=P2CLK=P1CLK*2=ADCCLK*2=TIMCLK=USBCLK*2/3
    


  4. 

  5. {
    


  6. 

  7.        unsigned char temp=0;  
    


  8. 

  9.        //RCC_DeInit();              //将RCC寄存器重新设置为默认值
    


  10. 

  11.        RCC->CR|=0x00010000;  //外部高速时钟使能HSEON
    


  12. 

  13.        while(!(RCC->CR>>17));//等待外部时钟就绪
    


  14. 

  15.        RCC->CFGR=0X00000400; //APB1=DIV2;APB2=DIV1;AHB=DIV1;
    


  16. 

  17.        PLL-=2;//抵消2个单位
    


  18. 

  19.        RCC->CFGR|=PLL<<18;   //设置PLL倍频值 2~16
    


  20. 

  21.        RCC->CFGR|=1<<16;     //PLL时钟源选择
    


  22. 

  23.        FLASH->ACR|=0x32;     //FLASH 2个延时周期
    


  24. 

  25.        RCC->CR|=0x01000000;  //PLLON
    


  26. 

  27.        while(!(RCC->CR>>25));//等待PLL锁定
    


  28. 

  29.        RCC->CFGR|=0x00000002;//PLL作为系统时钟      
    


  30. 

  31.        while(temp!=0x02)     //等待PLL作为系统时钟设置成功
    


  32. 

  33.        {  
    


  34. 

  35.               temp=RCC->CFGR>>2;
    


  36. 

  37.               temp&=0x03;
    


  38. 

  39.        }   
    


  40. 

  41. }

四、相关库函数解析
1、库中所涉及到的结构体
复制
  1. typedef struct
    


  2. 

  3. {
    


  4. 

  5.   uint32_t SYSCLK_Frequency;  /*!< returns SYSCLK clock frequency expressed in Hz */
    


  6. 

  7.   uint32_t HCLK_Frequency;    /*!< returns HCLK clock frequency expressed in Hz */
    


  8. 

  9.   uint32_t PCLK1_Frequency;   /*!< returns PCLK1 clock frequency expressed in Hz */
    


  10. 

  11.   uint32_t PCLK2_Frequency;   /*!< returns PCLK2 clock frequency expressed in Hz */
    


  12. 

  13.   uint32_t ADCCLK_Frequency; /*!< returns ADCCLK clock frequency expressed in Hz */
    


  14. 

  15. }RCC_ClocksTypeDef;


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:40 | 显示全部楼层
2、库函数解析
复制
  1. void RCC_DeInit(void);//将外设RCC寄存器设为缺省值；（除RCC_BDCR和RCC_CSR）
    


  2. 

  3. void RCC_HSEConfig(uint32_t RCC_HSE);//设置外部高速晶振（HSE）；
    


  4. 

  5. //输入：RCC_HSE_OFF，RCC_HSE_ON，RCC_HSE_Bypass(HSE旁路)
    


  6. 

  7. ErrorStatus RCC_WaitForHSEStartUp(void);//等待HSE起振；
    


  8. 

  9. //返回值：SUCCESS,HSE晶振稳定且就绪；ERROR，HSE晶振未就绪
    


  10. 

  11. void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue);//调整内部高速晶振（HSI）校准值
    


  12. 

  13. //输入：校准补偿值（该参数取值必须在0到0x1F之间）
    


  14. 

  15. void RCC_HSICmd(FunctionalState NewState);//使能或者失能内部高速晶振（HSI）
    


  16. 

  17. //输入：ENABLE或者DISABLE（如果HSI被用于系统时钟，或者FLASH编写操作进行中，那么它不能被停振）
    


  18. 

  19. void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul);//设置PLL时钟源及倍频系数
    


  20. 

  21. //输入：RCC_PLLSource_HSI_Div2，RCC_PLLSource_HSE_Div1，RCC_PLLSource_HSE_Div2
    


  22. 

  23. //输入：RCC_PLLMul_2到RCC_PLLMul_16
    


  24. 

  25. void RCC_PLLCmd(FunctionalState NewState);// 使能或者失能PLL
    


  26. 

  27. //输入：ENABLE或者DISABLE
    


  28. 

  29. #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL) || defined (STM32F10X_CL)
    


  30. 

  31.  void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Source, uint32_t RCC_PREDIV1_Div);//
    


  32. 

  33. #endif
    


  34. 

  35. #ifdef  STM32F10X_CL
    


  36. 

  37.  void RCC_PREDIV2Config(uint32_t RCC_PREDIV2_Div);//
    


  38. 

  39.  void RCC_PLL2Config(uint32_t RCC_PLL2Mul);//
    


  40. 

  41.  void RCC_PLL2Cmd(FunctionalState NewState);//
    


  42. 

  43.  void RCC_PLL3Config(uint32_t RCC_PLL3Mul);//
    


  44. 

  45.  void RCC_PLL3Cmd(FunctionalState NewState);//
    


  46. 

  47. #endif /* STM32F10X_CL */
    


  48. 

  49. void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource);//设置系统时钟(SYSCLK)源
    


  50. 

  51. // RCC_SYSCLKSource_HSI，RCC_SYSCLKSource_HSE，RCC_SYSCLKSource_PLLCLK
    


  52. 

  53. uint8_t RCC_GetSYSCLKSource(void);// 返回用作系统时钟的时钟源
    


  54. 

  55. //返回值：0x00 HSI作为系统时钟，0x04 HSE作为系统时钟，0x08 PLL作为系统时钟
    


  56. 

  57. void RCC_HCLKConfig(uint32_t RCC_SYSCLK);//设置AHB时钟（HCLK）
    


  58. 

  59. //输入：RCC_SYSCLK_Div1，RCC_SYSCLK_Div2，RCC_SYSCLK_Div4，RCC_SYSCLK_Div8，RCC_SYSCLK_Div16，
    


  60. 

  61. //RCC_SYSCLK_Div32，RCC_SYSCLK_Div64，RCC_SYSCLK_Div128，RCC_SYSCLK_Div256，RCC_SYSCLK_Div512
    


  62. 

  63. void RCC_PCLK1Config(uint32_t RCC_HCLK);// 设置低速AHB时钟（PCLK1）
    


  64. 

  65. //输入： RCC_HCLK_Div1, RCC_HCLK_Div2, RCC_HCLK_Div4, RCC_HCLK_Div8, RCC_HCLK_Div16
    


  66. 

  67. void RCC_PCLK2Config(uint32_t RCC_HCLK);// 设置高速AHB时钟（PCLK2）
    


  68. 

  69. //输入：RCC_HCLK_Div1, RCC_HCLK_Div2, RCC_HCLK_Div4, RCC_HCLK_Div8, RCC_HCLK_Div16
    


  70. 

  71. void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState);// 使能或者失能指定的RCC中断
    


  72. 

  73. //输入：RCC_IT_LSIRDY  LSI就绪中断->ENABLE或者DISABLE
    


  74. 

  75. //RCC_IT_LSERDY  LSE就绪中断，RCC_IT_HSIRDY  HSI就绪中断
    


  76. 

  77. //RCC_IT_HSERDY  HSE就绪中断，RCC_IT_PLLRDY  PLL就绪中断
    


  78. 

  79. #ifndef STM32F10X_CL
    


  80. 

  81.  void RCC_USBCLKConfig(uint32_t RCC_USBCLKSource);// 设置USB时钟（USBCLK）
    


  82. 

  83. //输入：RCC_USBCLKSource_PLLCLK_1Div5，USB时钟 = PLL时钟除以1.5
    


  84. 

  85. RCC_USBCLKSource_PLLCLK_Div1，USB时钟 = PLL时钟
    


  86. 

  87. #else
    


  88. 

  89.  void RCC_OTGFSCLKConfig(uint32_t RCC_OTGFSCLKSource);//
    


  90. 

  91. #endif /* STM32F10X_CL */
    


  92. 

  93. void RCC_ADCCLKConfig(uint32_t RCC_PCLK2);// 设置ADC时钟（ADCCLK）
    


  94. 

  95. //RCC_PCLK2_Div2,ADC时钟 = PCLK / 2;RCC_PCLK2_Div4,ADC时钟 = PCLK / 4;
    


  96. 

  97. //RCC_PCLK2_Div6,ADC时钟 = PCLK / 6;RCC_PCLK2_Div8,ADC时钟 = PCLK / 8
    


  98. 

  99. #ifdef STM32F10X_CL
    


  100. 

  101.  void RCC_I2S2CLKConfig(uint32_t RCC_I2S2CLKSource); //                                
    


  102. 

  103.  void RCC_I2S3CLKConfig(uint32_t RCC_I2S3CLKSource);//
    


  104. 

  105. #endif /* STM32F10X_CL */
    


  106. 

  107. void RCC_LSEConfig(uint8_t RCC_LSE);// 设置外部低速晶振（LSE）
    


  108. 

  109. //输入：RCC_LSE_OFF,LSE晶振OFF;RCC_LSE_ON,LSE晶振ON;
    


  110. 

  111. //RCC_LSE_Bypass,LSE晶振被外部时钟旁路
    


  112. 

  113. void RCC_LSICmd(FunctionalState NewState);// 使能或者失能内部低速晶振（LSI）
    


  114. 

  115. //输入：ENABLE或者DISABLE   (IWDG运行的话，LSI不能被失能)
    


  116. 

  117. void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource);//设置RTC时钟(RTCCLK)源(RTC时钟一经选定即不能更改，除非复位后备域)
    


  118. 

  119. //输入：RCC_RTCCLKSource_LSE,选择LSE作为RTC时钟;RCC_RTCCLKSource_LSI,选择LSI作为RTC时钟;RCC_RTCCLKSource_HSE_Div128,选择HSE时钟频率除以128作为RTC时钟
    


  120. 

  121. void RCC_RTCCLKCmd(FunctionalState NewState);// 使能或者失能RTC时钟
    


  122. 

  123. //输入：ENABLE或者DISABLE
    


  124. 

  125. void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks);// 返回时钟的频率
    


  126. 

  127. //输入：指向结构RCC_ClocksTypeDef的指针，包含了各个时钟的频率（单位为Hz）
    


  128. 

  129. void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);// 使能或者失能AHB外设时钟
    


  130. 

  131. //输入：RCC_AHBPeriph_DMA，DMA时钟->ENABLE或者DISABLE；
    


  132. 

  133. //RCC_AHBPeriph_SRAM，SRAM时钟；RCC_AHBPeriph_FLITF，FLITF时钟
    


  134. 

  135. //RCC_AHBPeriph_DMA1，DMA1时钟；RCC_AHBPeriph_DMA2，DMA2时钟
    


  136. 

  137. //RCC_AHBPeriph_CRC，CRC时钟；RCC_AHBPeriph_FSMC，FSMC时钟
    


  138. 

  139. //RCC_AHBPeriph_SDIO，SDIO时钟
    


  140. 

  141. void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);// 使能或者失能APB2外设时钟
    


  142. 

  143. //输入：RCC_APB2Periph_AFIO，功能复用IO时钟->ENABLE或者DISABLE；
    


  144. 

  145. //RCC_APB2Periph_GPIOA，GPIOA时钟；RCC_APB2Periph_GPIOB,GPIOB时钟;
    


  146. 

  147. //RCC_APB2Periph_GPIOC,GPIOC时钟;RCC_APB2Periph_GPIOD,GPIOD时钟;
    


  148. 

  149. //RCC_APB2Periph_GPIOE,GPIOE时钟;RCC_APB2Periph_ADC1,ADC1时钟;
    


  150. 

  151. //RCC_APB2Periph_ADC2,ADC2时钟;RCC_APB2Periph_TIM1,TIM1时钟;
    


  152. 

  153. //RCC_APB2Periph_SPI1,SPI1时钟;RCC_APB2Periph_USART1,USART1时钟;
    


  154. 

  155. //RCC_APB2Periph_ALL,全部APB2外设时钟
    


  156. 

  157. void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);// 使能或者失能APB1外设时钟
    


  158. 

  159. //输入：RCC_APB1Periph_TIM2，TIM2时钟->ENABLE或者DISABLE;
    


  160. 

  161. //RCC_APB1Periph_TIM3,TIM3时钟;RCC_APB1Periph_TIM4,TIM4时钟
    


  162. 

  163. //RCC_APB1Periph_WWDG,WWDG时钟;RCC_APB1Periph_SPI2,SPI2时钟
    


  164. 

  165. //RCC_APB1Periph_USART2,USART2时钟;RCC_APB1Periph_USART3,USART3时钟
    


  166. 

  167. //RCC_APB1Periph_I2C1,I2C1时钟;RCC_APB1Periph_I2C2,I2C2时钟
    


  168. 

  169. //RCC_APB1Periph_USB,USB时钟;RCC_APB1Periph_CAN,CAN时钟
    


  170. 

  171. //RCC_APB1Periph_BKP,BKP时钟;RCC_APB1Periph_PWR,PWR时钟
    


  172. 

  173. //RCC_APB1Periph_ALL,全部APB1外设时钟
    


  174. 

  175. #ifdef STM32F10X_CL
    


  176. 

  177. void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);//
    


  178. 

  179. #endif /* STM32F10X_CL */
    


  180. 

  181. void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);// 强制或者释放高速APB（APB2）外设复位
    


  182. 

  183. //输入：同void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);函数的值
    


  184. 

  185. void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);// 强制或者释放低速APB（APB1）外设复位
    


  186. 

  187. //输入：同void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);函数的值
    


  188. 

  189. //例：/* Enter the SPI1 peripheral to reset */
    


  190. 

  191. //RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
    


  192. 

  193. /* Exit the SPI1 peripheral from reset */
    


  194. 

  195. //RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE);
    


  196. 

  197. void RCC_BackupResetCmd(FunctionalState NewState);// 强制或者释放后备域复位
    


  198. 

  199. void RCC_ClockSecuritySystemCmd(FunctionalState NewState);//使能或者失能时钟安全系统
    


  200. 

  201. //输入：ENABLE或者DISABLE
    


  202. 

  203. void RCC_MCOConfig(uint8_t RCC_MCO);// 选择在MCO管脚上输出的时钟源
    


  204. 

  205. //输入：RCC_MCO_NoClock 无时钟被选中 ；RCC_MCO_SYSCLK 选中系统时钟；
    


  206. 

  207. //RCC_MCO_HSI 选中HSI ；RCC_MCO_HSE 选中HSE ；
    


  208. 

  209. //RCC_MCO_PLLCLK_Div2 选中PLL时钟除以2
    


  210. 

  211. //警告：当选中系统时钟作为MCO管脚的输出时，注意它的时钟频率不超过50MHz(最大I/O速率)。
    


  212. 

  213. FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG);// 检查指定的RCC标志位设置与否
    


  214. 

  215. //输入：待检查的RCC标志位


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:41 | 显示全部楼层
复制
  1. //RCC_FLAG_HSIRDY ，HSI晶振就绪；RCC_FLAG_HSERDY ，HSE晶振就绪；
    


  2. 

  3. //RCC_FLAG_PLLRDY ，PLL就绪；RCC_FLAG_LSERDY ，LSI晶振就绪；
    


  4. 

  5. //RCC_FLAG_LSIRDY ，LSE晶振就绪；RCC_FLAG_PINRST ，管脚复位 ；
    


  6. 

  7. //RCC_FLAG_PORRST ，POR/PDR复位；RCC_FLAG_SFTRST ，软件复位 ；
    


  8. 

  9. //RCC_FLAG_IWDGRST ，IWDG复位；RCC_FLAG_WWDGRST ，WWDG复位；
    


  10. 

  11. //RCC_FLAG_LPWRRST ，低功耗复位
    


  12. 

  13. //返回值：RCC_FLAG的新状态（SET或者RESET）
    


  14. 

  15. //例：/* Test if the PLL clock is ready or not */
    


  16. 

  17. //FlagStatus Status;
    


  18. 

  19. //Status = RCC_GetFlagStatus(RCC_FLAG_PLLRDY);
    


  20. 

  21. //if(Status == RESET)
    


  22. 

  23. //{
    


  24. 

  25. //...
    


  26. 

  27. //}
    


  28. 

  29. //else
    


  30. 

  31. void RCC_ClearFlag(void);// 清除RCC的复位标志位
    


  32. 

  33. //(可以清除的复位标志位有：RCC_FLAG_PINRST, RCC_FLAG_PORRST, //RCC_FLAG_SFTRST, RCC_FLAG_IWDGRST, RCC_FLAG_WWDGRST, RCC_FLAG_LPWRRST)
    


  34. 

  35. ITStatus RCC_GetITStatus(uint8_t RCC_IT);// 检查指定的RCC中断发生与否
    


  36. 

  37. //输入：RCC_IT_LSIRDY，LSI晶振就绪中断；RCC_IT_LSERDY，LSE晶振就绪中断
    


  38. 

  39. //RCC_IT_HSIRDY，HSI晶振就绪中断；RCC_IT_HSERDY，HSE晶振就绪中断
    


  40. 

  41. //RCC_IT_PLLRDY，PLL就绪中断；RCC_IT_CSS，时钟安全系统中断
    


  42. 

  43. //返回值：RCC_IT的新状态
    


  44. 

  45. //例：
    


  46. 

  47. /* Test if the PLL Ready interrupt has occurred or not */
    


  48. 

  49. //ITStatus Status;
    


  50. 

  51. //Status = RCC_GetITStatus(RCC_IT_PLLRDY);
    


  52. 

  53. //if(Status == RESET)
    


  54. 

  55. //{
    


  56. 

  57. //...
    


  58. 

  59. //}
    


  60. 

  61. //else
    


  62. 

  63. //{
    


  64. 

  65. //...
    


  66. 

  67. //}
    


  68. 

  69. void RCC_ClearITPendingBit(uint8_t RCC_IT);// 清除RCC的中断待处理位
    


  70. 

  71. //RCC_IT_LSIRDY,LSI晶振就绪中断;RCC_IT_LSERDY,LSE晶振就绪中断
    


  72. 

  73. //RCC_IT_HSIRDY,HSI晶振就绪中断;RCC_IT_HSERDY,HSE晶振就绪中断
    


  74. 

  75. //RCC_IT_PLLRDY,PLL就绪中断;RCC_IT_CSS,时钟安全系统中断


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:42 | 显示全部楼层
五、实例详解
复制
  1. #if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)//如果定义了这些系统时钟将设为24M，如果没有定义则为72M
    

  2. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
    

  3.  #define SYSCLK_FREQ_24MHz  24000000
    

  4. #else
    

  5. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
    

  6. /* #define SYSCLK_FREQ_24MHz  24000000 */
    

  7. /* #define SYSCLK_FREQ_36MHz  36000000 */
    

  8. /* #define SYSCLK_FREQ_48MHz  48000000 */
    

  9. /* #define SYSCLK_FREQ_56MHz  56000000 */
    

  10. #define SYSCLK_FREQ_72MHz  72000000      //系统时钟默认值的定义 ，如果没有定义外部高速时钟则用内部高速时钟，为8000000
    


  11. 

  12. /*只需修改以上几句就可以自动设置使用外部倍频作为系统时钟，如果以上宏都未定义则在下边把内部高速时钟作为系统时钟*/
    

  13. #endif
    


  14. 

  15. /*!< Uncomment the following line if you need to use external SRAM mounted
    

  16.      on STM3210E-EVAL board (STM32 High density and XL-density devices) or on
    

  17.      STM32100E-EVAL board (STM32 High-density value line devices) as data memory */
    

  18. #if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)//内外部SRAM选择
    

  19. /* #define DATA_IN_ExtSRAM */
    

  20. #endif
    


  21. 

  22. /*!< Uncomment the following line if you need to relocate your vector Table in
    

  23.      Internal SRAM. */
    

  24. /* #define VECT_TAB_SRAM */
    

  25. #define VECT_TAB_OFFSET  0x0 /*!< Vector Table base offset field. //向量表的基址偏移量
    

  26.                                   This value must be a multiple of 0x100. */
    


  27. 


  28. 

  29. /*******************************************************************************
    

  30. *  Clock Definitions;以下为把系统时钟的定义值传给系统内核时钟变量,如果没有定义外部高速时钟则用内部高速时钟，为8M
    

  31. *******************************************************************************/
    

  32. #ifdef SYSCLK_FREQ_HSE
    

  33.   uint32_t SystemCoreClock         = SYSCLK_FREQ_HSE;        /*!< System Clock Frequency (Core Clock) */
    

  34. #elif defined SYSCLK_FREQ_24MHz
    

  35.   uint32_t SystemCoreClock         = SYSCLK_FREQ_24MHz;        /*!< System Clock Frequency (Core Clock) */
    

  36. #elif defined SYSCLK_FREQ_36MHz
    

  37.   uint32_t SystemCoreClock         = SYSCLK_FREQ_36MHz;        /*!< System Clock Frequency (Core Clock) */
    

  38. #elif defined SYSCLK_FREQ_48MHz
    

  39.   uint32_t SystemCoreClock         = SYSCLK_FREQ_48MHz;        /*!< System Clock Frequency (Core Clock) */
    

  40. #elif defined SYSCLK_FREQ_56MHz
    

  41.   uint32_t SystemCoreClock         = SYSCLK_FREQ_56MHz;        /*!< System Clock Frequency (Core Clock) */
    

  42. #elif defined SYSCLK_FREQ_72MHz
    

  43.   uint32_t SystemCoreClock         = SYSCLK_FREQ_72MHz;        /*!< System Clock Frequency (Core Clock) */
    

  44. #else /*!< HSI Selected as System Clock source */
    

  45.   uint32_t SystemCoreClock         = HSI_VALUE;        /*!< System Clock Frequency (Core Clock) 如果没有定义外部高速时钟则用内部高速时钟，为8000000*/
    

  46. #endif
    


  47. 

  48. __I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};//AHB配方表
    

  49. /**
    

  50.   * @}
    

  51.   */
    


  52. 

  53. /** @addtogroup STM32F10x_System_Private_FunctionPrototypes
    

  54.   * @{
    

  55.   */
    

  56. /*********************************************************************************
    

  57.                以下为函数声明
    

  58. *********************************************************************************/
    

  59. static void SetSysClock(void); //设置系统时钟的函数声明
    

  60. //以下为根据不同的系统时钟的定义来声明用到的相应的函数，为后面的函数调用做好准备
    

  61. #ifdef SYSCLK_FREQ_HSE
    

  62.   static void SetSysClockToHSE(void);
    

  63. #elif defined SYSCLK_FREQ_24MHz
    

  64.   static void SetSysClockTo24(void);
    

  65. #elif defined SYSCLK_FREQ_36MHz
    

  66.   static void SetSysClockTo36(void);
    

  67. #elif defined SYSCLK_FREQ_48MHz
    

  68.   static void SetSysClockTo48(void);
    

  69. #elif defined SYSCLK_FREQ_56MHz
    

  70.   static void SetSysClockTo56(void); 
    

  71. #elif defined SYSCLK_FREQ_72MHz
    

  72.   static void SetSysClockTo72(void);
    

  73. #endif
    


  74. 

  75. #ifdef DATA_IN_ExtSRAM //外部SRAM选择后的初始化函数声明
    

  76.   static void SystemInit_ExtMemCtl(void);
    

  77. #endif /* DATA_IN_ExtSRAM */


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 14:43 | 显示全部楼层
复制
  1. /**
    

  2.   * @}
    

  3.   */
    


  4. 

  5. /** @addtogroup STM32F10x_System_Private_Functions
    

  6.   * @{
    

  7.   */
    


  8. 

  9. /**
    

  10.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Setup the microcontroller system
    

  11.   *         Initialize the Embedded Flash Interface, the PLL and update the
    

  12.   *         SystemCoreClock variable.
    

  13.   * [url=home.php?mod=space&uid=536309]@NOTE[/url]   This function should be used only after reset.
    

  14.   * @param  None
    

  15.   * @retval None
    

  16.   */
    

  17. void SystemInit (void)//系统初始化函数，设置系统的时钟及时钟中断（在startup_stm32f10x_md.s中调用）(复位RCC时钟配置为默认状态，直到设置时钟函数)
    

  18. {
    

  19.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
    

  20.   /* Set HSION bit */
    

  21.   RCC->CR |= (uint32_t)0x00000001; //内部高速时钟使能,内部8MHz时钟开启
    


  22. 

  23.   /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
    

  24. #ifndef STM32F10X_CL
    

  25.   RCC->CFGR &= (uint32_t)0xF8FF0000;//MCO微控制器没有时钟输出(对外部引脚),ADC预分频PCLK2 2分频后作为ADC时钟,APB预分频HCLK不分频,AHB预分频SYSCLK不分频,HSI作为系统时钟
    

  26.                                     //HSI作为系统时钟输出（已输出），SYSCLK=PCLK=PCLK1=PCLK2=8M，ADCCLK=1/2(PCLK2)=4M
    

  27. #else
    

  28.   RCC->CFGR &= (uint32_t)0xF0FF0000;//同上；RCC->CFGR的27位为保留位始终为0 ，HSI作为系统时钟输出（未输出原因为未编译）
    

  29. #endif /* STM32F10X_CL */  
    

  30.  
    

  31.   /* Reset HSEON, CSSON and PLLON bits */
    

  32.   RCC->CR &= (uint32_t)0xFEF6FFFF;//时钟监测器关闭,HSE振荡器关闭
    


  33. 

  34.   /* Reset HSEBYP bit */
    

  35.   RCC->CR &= (uint32_t)0xFFFBFFFF;//外部4-25MHz振荡器没有旁路
    


  36. 

  37.   /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
    

  38.   RCC->CFGR &= (uint32_t)0xFF80FFFF; //PLL时钟1.5倍分频作为USB时钟,PLL 2倍频输出,HSE不分频,HSI时钟2分频后作为PLL输入时钟
    

  39.                                      //PLLCLK=HSICLK=8M（还未输出）,HSECLK=HSEOSC,USBCLK=PLLCLK/1.5 ，除PLL外其他分频系数都为0
    

  40. #ifdef STM32F10X_CL
    

  41.   /* Reset PLL2ON and PLL3ON bits */
    

  42.   RCC->CR &= (uint32_t)0xEBFFFFFF;//CR中的26和28位置0
    


  43. 

  44.   /* Disable all interrupts and clear pending bits  */
    

  45.   RCC->CIR = 0x00FF0000;//清除中断标志，关闭一些中断
    


  46. 

  47.   /* Reset CFGR2 register */
    

  48.   RCC->CFGR2 = 0x00000000; //没有此寄存器
    

  49. #elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
    

  50.   /* Disable all interrupts and clear pending bits  */
    

  51.   RCC->CIR = 0x009F0000;//清除中断标志，关闭一些中断
    


  52. 

  53.   /* Reset CFGR2 register */
    

  54.   RCC->CFGR2 = 0x00000000; //没有此寄存器    
    

  55. #else
    

  56.   /* Disable all interrupts and clear pending bits  */
    

  57.   RCC->CIR = 0x009F0000; //清除中断标志，关闭一些中断
    

  58. #endif /* STM32F10X_CL */
    

  59.    
    

  60. #if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
    

  61.   #ifdef DATA_IN_ExtSRAM
    

  62.     SystemInit_ExtMemCtl();//如果宏定义了外部SRAM则对其初始化控制
    

  63.   #endif /* DATA_IN_ExtSRAM */
    

  64. #endif
    


  65. 

  66.   /* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
    

  67.   /* Configure the Flash Latency cycles and enable prefetch buffer */
    

  68.   SetSysClock();//设置系统时钟
    


  69. 

  70. #ifdef VECT_TAB_SRAM
    

  71.   SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. 向量表放在内部SRAM中*/
    

  72. #else
    

  73.   SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. 向量表放在内部flash中*/
    

  74. #endif
    

  75. }


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 20:22 | 显示全部楼层
复制
  1. /**
    

  2.   * @brief  Update SystemCoreClock according to Clock Register Values
    

  3.   * @note   None
    

  4.   * @param  None
    

  5.   * @retval None
    

  6.   */
    

  7. void SystemCoreClockUpdate (void)
    

  8. {
    

  9.   uint32_t tmp = 0, pllmull = 0, pllsource = 0;
    


  10. 

  11. #ifdef  STM32F10X_CL
    

  12.   uint32_t prediv1source = 0, prediv1factor = 0, prediv2factor = 0, pll2mull = 0;
    

  13. #endif /* STM32F10X_CL */
    


  14. 

  15. #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
    

  16.   uint32_t prediv1factor = 0;
    

  17. #endif /* STM32F10X_LD_VL or STM32F10X_MD_VL or STM32F10X_HD_VL */
    

  18.    
    

  19.   /* Get SYSCLK source -------------------------------------------------------*/
    

  20.   tmp = RCC->CFGR & RCC_CFGR_SWS;
    

  21.  
    

  22.   switch (tmp)
    

  23.   {
    

  24.     case 0x00:  /* HSI used as system clock */
    

  25.       SystemCoreClock = HSI_VALUE;
    

  26.       break;
    

  27.     case 0x04:  /* HSE used as system clock */
    

  28.       SystemCoreClock = HSE_VALUE;
    

  29.       break;
    

  30.     case 0x08:  /* PLL used as system clock */
    


  31. 

  32.       /* Get PLL clock source and multiplication factor ----------------------*/
    

  33.       pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
    

  34.       pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
    

  35.      
    

  36. #ifndef STM32F10X_CL     
    

  37.       pllmull = ( pllmull >> 18) + 2;
    

  38.      
    

  39.       if (pllsource == 0x00)
    

  40.       {
    

  41.         /* HSI oscillator clock divided by 2 selected as PLL clock entry */
    

  42.         SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
    

  43.       }
    

  44.       else
    

  45.       {
    

  46.  #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
    

  47.        prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
    

  48.        /* HSE oscillator clock selected as PREDIV1 clock entry */
    

  49.        SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;
    

  50.  #else
    

  51.         /* HSE selected as PLL clock entry */
    

  52.         if ((RCC->CFGR & RCC_CFGR_PLLXTPRE) != (uint32_t)RESET)
    

  53.         {/* HSE oscillator clock divided by 2 */
    

  54.           SystemCoreClock = (HSE_VALUE >> 1) * pllmull;
    

  55.         }
    

  56.         else
    

  57.         {
    

  58.           SystemCoreClock = HSE_VALUE * pllmull;
    

  59.         }
    

  60.  #endif
    

  61.       }
    

  62. #else
    

  63.       pllmull = pllmull >> 18;
    

  64.      
    

  65.       if (pllmull != 0x0D)
    

  66.       {
    

  67.          pllmull += 2;
    

  68.       }
    

  69.       else
    

  70.       { /* PLL multiplication factor = PLL input clock * 6.5 */
    

  71.         pllmull = 13 / 2;
    

  72.       }
    

  73.            
    

  74.       if (pllsource == 0x00)
    

  75.       {
    

  76.         /* HSI oscillator clock divided by 2 selected as PLL clock entry */
    

  77.         SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
    

  78.       }
    

  79.       else
    

  80.       {/* PREDIV1 selected as PLL clock entry */
    

  81.        
    

  82.         /* Get PREDIV1 clock source and division factor */
    

  83.         prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC;
    

  84.         prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
    

  85.        
    

  86.         if (prediv1source == 0)
    

  87.         {
    

  88.           /* HSE oscillator clock selected as PREDIV1 clock entry */
    

  89.           SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;         
    

  90.         }
    

  91.         else
    

  92.         {/* PLL2 clock selected as PREDIV1 clock entry */
    

  93.          
    

  94.           /* Get PREDIV2 division factor and PLL2 multiplication factor */
    

  95.           prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1;
    

  96.           pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2;
    

  97.           SystemCoreClock = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;                        
    

  98.         }
    

  99.       }
    

  100. #endif /* STM32F10X_CL */
    

  101.       break;
    


  102. 

  103.     default:
    

  104.       SystemCoreClock = HSI_VALUE;
    

  105.       break;
    

  106.   }
    

  107.   


回复

收藏2 举报

 楼主| Tennasi 发表于 2016-10-30 20:26 | 显示全部楼层
复制
  1. /* Compute HCLK clock frequency ----------------*/
    

  2.   /* Get HCLK prescaler */
    

  3.   tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
    

  4.   /* HCLK clock frequency */
    

  5.   SystemCoreClock >>= tmp; 
    

  6. }
    


  7. 

  8. /**
    

  9.   * @brief  Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers.
    

  10.   * @param  None
    

  11.   * @retval None
    

  12.   */
    

  13. static void SetSysClock(void)//根据不同的宏定义，设置不同的系统时钟
    

  14. { 
    

  15. #ifdef SYSCLK_FREQ_HSE
    

  16.   SetSysClockToHSE();
    

  17. #elif defined SYSCLK_FREQ_24MHz
    

  18.   SetSysClockTo24();
    

  19. #elif defined SYSCLK_FREQ_36MHz
    

  20.   SetSysClockTo36();
    

  21. #elif defined SYSCLK_FREQ_48MHz
    

  22.   SetSysClockTo48();
    

  23. #elif defined SYSCLK_FREQ_56MHz
    

  24.   SetSysClockTo56(); 
    

  25. #elif defined SYSCLK_FREQ_72MHz
    

  26.   SetSysClockTo72();
    

  27. #endif
    

  28.  
    

  29.  /* If none of the define above is enabled, the HSI is used as System clock
    

  30.     source (default after reset) */
    

  31. }
    


  32. 

  33. /**
    

  34.   * @brief  Setup the external memory controller. Called in startup_stm32f10x.s
    

  35.   *          before jump to __main
    

  36.   * @param  None
    

  37.   * @retval None
    

  38.   */
    

  39. #ifdef DATA_IN_ExtSRAM
    

  40. /**
    

  41.   * @brief  Setup the external memory controller.
    

  42.   *         Called in startup_stm32f10x_xx.s/.c before jump to main.
    

  43.   *        This function configures the external SRAM mounted on STM3210E-EVAL
    

  44.   *         board (STM32 High density devices). This SRAM will be used as program
    

  45.   *         data memory (including heap and stack).
    

  46.   * @param  None
    

  47.   * @retval None
    

  48.   */
    

  49. void SystemInit_ExtMemCtl(void)
    

  50. {
    

  51. /*!< FSMC Bank1 NOR/SRAM3 is used for the STM3210E-EVAL, if another Bank is
    

  52.   required, then adjust the Register Addresses */
    


  53. 

  54.   /* Enable FSMC clock */
    

  55.   RCC->AHBENR = 0x00000114;
    

  56.  
    

  57.   /* Enable GPIOD, GPIOE, GPIOF and GPIOG clocks */ 
    

  58.   RCC->APB2ENR = 0x000001E0;
    

  59.  
    

  60. /* ---------------  SRAM Data lines, NOE and NWE configuration ---------------*/
    

  61. /*----------------  SRAM Address lines configuration -------------------------*/
    

  62. /*----------------  NOE and NWE configuration --------------------------------*/ 
    

  63. /*----------------  NE3 configuration ----------------------------------------*/
    

  64. /*----------------  NBL0, NBL1 configuration ---------------------------------*/
    

  65.  
    

  66.   GPIOD->CRL = 0x44BB44BB; 
    

  67.   GPIOD->CRH = 0xBBBBBBBB;
    


  68. 

  69.   GPIOE->CRL = 0xB44444BB; 
    

  70.   GPIOE->CRH = 0xBBBBBBBB;
    


  71. 

  72.   GPIOF->CRL = 0x44BBBBBB; 
    

  73.   GPIOF->CRH = 0xBBBB4444;
    


  74. 

  75.   GPIOG->CRL = 0x44BBBBBB; 
    

  76.   GPIOG->CRH = 0x44444B44;
    

  77.   
    

  78. /*----------------  FSMC Configuration ---------------------------------------*/ 
    

  79. /*----------------  Enable FSMC Bank1_SRAM Bank ------------------------------*/
    

  80.  
    

  81.   FSMC_Bank1->BTCR[4] = 0x00001011;
    

  82.   FSMC_Bank1->BTCR[5] = 0x00000200;
    

  83. }
    

  84. #endif /* DATA_IN_ExtSRAM */
    


  85. 

  86. #ifdef SYSCLK_FREQ_HSE
    

  87. /**
    

  88.   * @brief  Selects HSE as System clock source and configure HCLK, PCLK2
    

  89.   *          and PCLK1 prescalers.
    

  90.   * @note   This function should be used only after reset.
    

  91.   * @param  None
    

  92.   * @retval None
    

  93.   */
    

  94. static void SetSysClockToHSE(void)
    

  95. {
    

  96.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
    

  97.  
    

  98.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/   
    

  99.   /* Enable HSE */   
    

  100.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);
    

  101.  
    

  102.   /* Wait till HSE is ready and if Time out is reached exit */
    

  103.   do
    

  104.   {
    

  105.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    

  106.     StartUpCounter++; 
    

  107.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    


  108. 

  109.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
    

  110.   {
    

  111.     HSEStatus = (uint32_t)0x01;
    

  112.   }
    

  113.   else
    

  114.   {
    

  115.     HSEStatus = (uint32_t)0x00;
    

  116.   } 
    


  117. 

  118.   if (HSEStatus == (uint32_t)0x01)
    

  119.   {
    


  120. 

  121. #if !defined STM32F10X_LD_VL && !defined STM32F10X_MD_VL && !defined STM32F10X_HD_VL
    

  122.     /* Enable Prefetch Buffer */
    

  123.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    


  124. 

  125.     /* Flash 0 wait state */
    

  126.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    


  127. 

  128. #ifndef STM32F10X_CL
    

  129.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
    

  130. #else
    

  131.     if (HSE_VALUE <= 24000000)
    

  132.  {
    

  133.       FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
    

  134.  }
    

  135.  else
    

  136.  {
    

  137.       FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;
    

  138.  }
    

  139. #endif /* STM32F10X_CL */
    

  140. #endif
    

  141.  
    

  142.     /* HCLK = SYSCLK */
    

  143.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
    

  144.      
    

  145.     /* PCLK2 = HCLK */
    

  146.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    

  147.    
    

  148.     /* PCLK1 = HCLK */
    

  149.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
    

  150.    
    

  151.     /* Select HSE as system clock source */
    

  152.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    

  153.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_HSE;   
    


  154. 

  155.     /* Wait till HSE is used as system clock source */
    

  156.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x04)
    

  157.     {
    

  158.     }
    

  159.   }
    

  160.   else
    

  161.   { /* If HSE fails to start-up, the application will have wrong clock
    

  162.          configuration. User can add here some code to deal with this error */
    

  163.   } 
    

  164. }
    

  165. #elif defined SYSCLK_FREQ_24MHz
    


  166. 

  167. static void SetSysClockTo72(void)//系统时钟设置为72M：SYSCLK=72M，HCLK=72M，PCLK1=36M（最高36M），PCLK2=72M，ADCCLK=36M,
    

  168. {
    

  169.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;//启动计数，HSE状态
    

  170.  
    

  171.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/   
    

  172.   /* Enable HSE */   
    

  173.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);//HSE使能
    

  174.  
    

  175.   /* Wait till HSE is ready and if Time out is reached exit */
    

  176.   do //循环，直到HSE使能成功或者超时
    

  177.   {
    

  178.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    

  179.     StartUpCounter++; 
    

  180.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    


  181. 

  182.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
    

  183.   {
    

  184.     HSEStatus = (uint32_t)0x01;//HSE使能成功
    

  185.   }
    

  186.   else
    

  187.   {
    

  188.     HSEStatus = (uint32_t)0x00;//HSE使能不成功
    

  189.   } 
    


  190. 

  191.   if (HSEStatus == (uint32_t)0x01)//HSE使能成功
    

  192.   {
    

  193.     /* Enable Prefetch Buffer */
    

  194.     FLASH->ACR |= FLASH_ACR_PRFTBE;//flash缓存使能
    


  195. 

  196.     /* Flash 2 wait state */
    

  197.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);//
    

  198.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;//   
    


  199. 

  200.  
    

  201.     /* HCLK = SYSCLK */
    

  202.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;//RCC_CFGR_HPRE_DIV1=0，CFGR中的值不变
    

  203.      
    

  204.     /* PCLK2 = HCLK */
    

  205.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;//RCC_CFGR_PPRE2_DIV1=0，CFGR中的值不变
    

  206.    
    

  207.     /* PCLK1 = HCLK/2 */
    

  208.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;//低速APB预分频把HCLK 2分频,APB1CLK=HCLK/2
    


  209. 

  210. #ifdef STM32F10X_CL
    

  211.     /* Configure PLLs ------------------------------------------------------*/
    

  212.     /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
    

  213.     /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
    

  214.        
    

  215.     RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
    

  216.                               RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
    

  217.     RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
    

  218.                              RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
    

  219.  
    

  220.     /* Enable PLL2 */
    

  221.     RCC->CR |= RCC_CR_PLL2ON;
    

  222.     /* Wait till PLL2 is ready */
    

  223.     while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    

  224.     {
    

  225.     }


回复

收藏2 举报

Soraka 发表于 2016-10-31 21:39 | 显示全部楼层
PLL 为锁相环倍频输出，并不算一个独立的时钟源
回复

收藏2 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Tennasi

22

主题

169

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部