stm32f1xx的时钟树

已于 2024-09-19 20:14:27 修改
阅读量618 收藏 16
点赞数 15
文章标签： stm32 嵌入式硬件 单片机
于 2024-07-04 17:39:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mapleay/article/details/140185531
版权

系统主干时钟

在system_stm32f10x.c文件中：

重要注意：

  1. 每次设备复位后，HSI用于系统的时钟源。
  2. 确保所选的系统时钟不要超过设备的最大时钟频率。
  3. 如果没有任何相关预定义，那么HSI将被用作系统默认时钟源。
  4. 在system_stm32f10x.c中系统时钟配置函数默认如下规则：
  1. For Low, Medium and High density Value line devices an external 8MHz crystal is used to drive the System clock.
  2. For Low, Medium and High density devices an external 8MHz crystal is used to drive the System clock.
  3. For Connectivity line devices an external 25MHz crystal is used to drive the System clock.
  4. 如果你使用了不同的外部晶振源，那么你必须正确地适配它。

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

/* #define SYSCLK_FREQ_HSE    HSE_VALUE */

 #define SYSCLK_FREQ_24MHz  24000000

#else

/* #define SYSCLK_FREQ_HSE    HSE_VALUE */

/* #define SYSCLK_FREQ_24MHz  24000000 */

/* #define SYSCLK_FREQ_36MHz  36000000 */

/* #define SYSCLK_FREQ_48MHz  48000000 */

/* #define SYSCLK_FREQ_56MHz  56000000 */

#define SYSCLK_FREQ_72MHz  72000000

#endif

上面这些设置了系统时钟和各个总线的时钟频率，如果我们需要配置外设的时钟输入（比如USART），那么在对应的外设库函数c文件（stm32f10x_usart.c）中有相关函数调用函数RCC_GetClocksFreq（xxx）获取该外设直接的注入时钟源的数值。最后结合外设的输入时钟源与外设的配置方案，算得数值写入先关寄存器。（见下图USART1的配置）

系统主干时钟是比喻的描述方法，包括了系统的物理输入时钟源，系统时钟和各种总线时钟的分频系数配置。

系统枝叶时钟也是比喻的描述方法，包括了系统各个片上外设（USART/CAN/DAC/ADC/USB/等）的由半导体厂商开发设计的硬件模块的配置系统参数配置。

下面就是以USART为例承上启下的案例分析。

系统枝叶时钟（USARTx时钟配置）

下面是系统时钟树的总图

配置USART的波特率寄存器

板载HSE为8MHz. 基于stm32f407vet6的标准外设库


void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)
{
  uint32_t tmpreg = 0x00, apbclock = 0x00;
  uint32_t integerdivider = 0x00;
  uint32_t fractionaldivider = 0x00;
  RCC_ClocksTypeDef RCC_ClocksStatus;

/*---------------------------- USART CR2 Configuration -----------------------*/
  tmpreg = USARTx->CR2;

  /* Clear STOP[13:12] bits */
  tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);

  /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit :
      Set STOP[13:12] bits according to USART_StopBits value */
  tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits;
  
  /* Write to USART CR2 */
  USARTx->CR2 = (uint16_t)tmpreg;

/*---------------------------- USART CR1 Configuration -----------------------*/
  tmpreg = USARTx->CR1;

  /* Clear M, PCE, PS, TE and RE bits */
  tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK);

  /* Configure the USART Word Length, Parity and mode: 
     Set the M bits according to USART_WordLength value 
     Set PCE and PS bits according to USART_Parity value
     Set TE and RE bits according to USART_Mode value */
  tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity |
            USART_InitStruct->USART_Mode;

  /* Write to USART CR1 */
  USARTx->CR1 = (uint16_t)tmpreg;

/*---------------------------- USART CR3 Configuration -----------------------*/  
  tmpreg = USARTx->CR3;

  /* Clear CTSE and RTSE bits */
  tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK);

  /* Configure the USART HFC : 
      Set CTSE and RTSE bits according to USART_HardwareFlowControl value */
  tmpreg |= USART_InitStruct->USART_HardwareFlowControl;

  /* Write to USART CR3 */
  USARTx->CR3 = (uint16_t)tmpreg;

/*---------------------------- USART BRR Configuration -----------------------*/
  /* 第一步 获取USARTx所在总线上的信号频率 apbclock */
  RCC_GetClocksFreq(&RCC_ClocksStatus);

  if ((USARTx == USART1) || (USARTx == USART6))
  {
    apbclock = RCC_ClocksStatus.PCLK2_Frequency;
  }
  else
  {
    apbclock = RCC_ClocksStatus.PCLK1_Frequency;
  }
  
  /* 第二步 计算USARTx波特率寄存器的整数值部分 */
  if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
  {
    /* Integer part computing in case Oversampling mode is 8 Samples */
    integerdivider = ((25 * apbclock) / (2 * (USART_InitStruct->USART_BaudRate)));    
  }
  else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
  {
    /* Integer part computing in case Oversampling mode is 16 Samples */
    integerdivider = ((25 * apbclock) / (4 * (USART_InitStruct->USART_BaudRate)));    
  }
  tmpreg = (integerdivider / 100) << 4;

  /* 第三步 计算USARTx波特率寄存器的小数值部分 */
  fractionaldivider = integerdivider - (100 * (tmpreg >> 4));

  /* Implement the fractional part in the register */
  if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
  {
    tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
  }
  else /* if ((USARTx->CR1 & USART_CR1_OVER8) == 0) */
  {
    tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
  }
  
  /* 第四步 合并整数和小数部分的值，写入 USARTx 波特率寄存器 BRR register 中 */
  USARTx->BRR = (uint16_t)tmpreg;
}

  
  /**
  * @brief  Returns the frequencies of different on chip clocks; SYSCLK, HCLK, 
  *         PCLK1 and PCLK2.
  * 
  * @note   The system frequency computed by this function is not the real 
  *         frequency in the chip. It is calculated based on the predefined 
  *         constant and the selected clock source:
  * @note     If SYSCLK source is HSI, function returns values based on HSI_VALUE(*)
  * @note     If SYSCLK source is HSE, function returns values based on HSE_VALUE(**)
  * @note     If SYSCLK source is PLL, function returns values based on HSE_VALUE(**) 
  *           or HSI_VALUE(*) multiplied/divided by the PLL factors.         
  * @note     (*) HSI_VALUE is a constant defined in stm32f4xx.h file (default value
  *               16 MHz) but the real value may vary depending on the variations
  *               in voltage and temperature.
  * @note     (**) HSE_VALUE is a constant defined in stm32f4xx.h file (default value
  *                25 MHz), user has to ensure that HSE_VALUE is same as the real
  *                frequency of the crystal used. Otherwise, this function may
  *                have wrong result.
  *                
  * @note   The result of this function could be not correct when using fractional
  *         value for HSE crystal.
  *   
  * @param  RCC_Clocks: pointer to a RCC_ClocksTypeDef structure which will hold
  *          the clocks frequencies.
  *     
  * @note   This function can be used by the user application to compute the 
  *         baudrate for the communication peripherals or configure other parameters.
  * @note   Each time SYSCLK, HCLK, PCLK1 and/or PCLK2 clock changes, this function
  *         must be called to update the structure's field. Otherwise, any
  *         configuration based on this function will be incorrect.
  *    
  * @retval None
  */
void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks)
{
  uint32_t tmp = 0, presc = 0, pllvco = 0, pllp = 2, pllsource = 0, pllm = 2;
#if defined(STM32F412xG) || defined(STM32F413_423xx) || defined(STM32F446xx)  
  uint32_t pllr = 2;
#endif /* STM32F412xG || STM32F413_423xx || STM32F446xx */
  
  /* Get SYSCLK source -------------------------------------------------------*/
  tmp = RCC->CFGR & RCC_CFGR_SWS;
  
  switch (tmp)
  {
  case 0x00:  /* HSI used as system clock source */
    RCC_Clocks->SYSCLK_Frequency = HSI_VALUE;
    break;
  case 0x04:  /* HSE used as system clock  source */
    RCC_Clocks->SYSCLK_Frequency = HSE_VALUE;
    break;
  case 0x08:  /* PLL P used as system clock  source */
    
    /* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLLM) * PLLN
    SYSCLK = PLL_VCO / PLLP
    */    
    pllsource = (RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) >> 22;
    pllm = RCC->PLLCFGR & RCC_PLLCFGR_PLLM;
    
    if (pllsource != 0)
    {
      /* HSE used as PLL clock source */
      pllvco = (HSE_VALUE / pllm) * ((RCC->PLLCFGR & RCC_PLLCFGR_PLLN) >> 6);
    }
    else
    {
      /* HSI used as PLL clock source */
      pllvco = (HSI_VALUE / pllm) * ((RCC->PLLCFGR & RCC_PLLCFGR_PLLN) >> 6);      
    }
    
    pllp = (((RCC->PLLCFGR & RCC_PLLCFGR_PLLP) >>16) + 1 ) *2;
    RCC_Clocks->SYSCLK_Frequency = pllvco/pllp;
    break;
    
  default:
    RCC_Clocks->SYSCLK_Frequency = HSI_VALUE;
    break;
  }
  /* Compute HCLK, PCLK1 and PCLK2 clocks frequencies ------------------------*/
  
  /* Get HCLK prescaler */
  tmp = RCC->CFGR & RCC_CFGR_HPRE;
  tmp = tmp >> 4;
  presc = APBAHBPrescTable[tmp];
  /* HCLK clock frequency */
  RCC_Clocks->HCLK_Frequency = RCC_Clocks->SYSCLK_Frequency >> presc;

  /* Get PCLK1 prescaler */
  tmp = RCC->CFGR & RCC_CFGR_PPRE1;
  tmp = tmp >> 10;
  presc = APBAHBPrescTable[tmp];
  /* PCLK1 clock frequency */
  RCC_Clocks->PCLK1_Frequency = RCC_Clocks->HCLK_Frequency >> presc;

  /* Get PCLK2 prescaler */
  tmp = RCC->CFGR & RCC_CFGR_PPRE2;
  tmp = tmp >> 13;
  presc = APBAHBPrescTable[tmp];
  /* PCLK2 clock frequency */
  RCC_Clocks->PCLK2_Frequency = RCC_Clocks->HCLK_Frequency >> presc;
}

/**
  * @brief  Setup the microcontroller system
  *         Initialize the Embedded Flash Interface, the PLL and update the 
  *         SystemFrequency variable.
  * @param  None
  * @retval None
  */
void SystemInit(void)
{
  /* FPU settings ------------------------------------------------------------*/
  #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
    SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));  /* set CP10 and CP11 Full Access */
  #endif
  /* Reset the RCC clock configuration to the default reset state ------------*/
  /* Set HSION bit */
  RCC->CR |= (uint32_t)0x00000001;

  /* Reset CFGR register */
  RCC->CFGR = 0x00000000;

  /* Reset HSEON, CSSON and PLLON bits */
  RCC->CR &= (uint32_t)0xFEF6FFFF;

  /* Reset PLLCFGR register */
  //RCC->PLLCFGR = 0x24003010; //原始版本
	RCC->PLLCFGR = 0x24005408;   //基于8MHz的HSE，设置SystemCoreClock = 168MHz的操作：调整PLLM、PLLN的分倍频系数。 v1.2.2。

  /* Reset HSEBYP bit */
  RCC->CR &= (uint32_t)0xFFFBFFFF;

  /* Disable all interrupts */
  RCC->CIR = 0x00000000;

#if defined(DATA_IN_ExtSRAM) || defined(DATA_IN_ExtSDRAM)
  SystemInit_ExtMemCtl(); 
#endif /* DATA_IN_ExtSRAM || DATA_IN_ExtSDRAM */

/*
** 所有的系统时钟树，都在 SystemInit函数中调用 SetSysClock 函数设置。
** SetSysClock();中配置系统时钟源、PLL各分倍频系数、AHP/APBx的分频系数。
*/
  SetSysClock();

  /* Configure the Vector Table location add offset address ------------------*/
#ifdef VECT_TAB_SRAM
  SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM */
#else
  SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH */
#endif
}

/**
  * @brief  Configures the System clock source, PLL Multiplier and Divider factors, 
  *         AHB/APBx prescalers and Flash settings
  * @Note   This function should be called only once the RCC clock configuration  
  *         is reset to the default reset state (done in SystemInit() function).   
  * @param  None
  * @retval None
  */
static void SetSysClock(void)
{
#if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F401xx) || defined(STM32F412xG) || defined(STM32F413_423xx) || defined(STM32F446xx)|| defined(STM32F469_479xx)
/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
  /* Enable HSE */
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
  /* Wait till HSE is ready and if Time out is reached exit */
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  }

  if (HSEStatus == (uint32_t)0x01)
  {
    /* Select regulator voltage output Scale 1 mode */
    RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;

    /* HCLK = SYSCLK / 1*/
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;

#if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) ||  defined(STM32F412xG) || defined(STM32F446xx) || defined(STM32F469_479xx)    
    /* PCLK2 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;
    
    /* PCLK1 = HCLK / 4*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;
#endif /* STM32F40_41xxx || STM32F427_437x || STM32F429_439xx  || STM32F412xG || STM32F446xx || STM32F469_479xx */

#if defined(STM32F401xx) || defined(STM32F413_423xx)
    /* PCLK2 = HCLK / 1*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
    
    /* PCLK1 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;
#endif /* STM32F401xx || STM32F413_423xx */

#if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F401xx) || defined(STM32F469_479xx)    
    /* Configure the main PLL */
    RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
#endif /* STM32F40_41xxx || STM32F401xx || STM32F427_437x || STM32F429_439xx || STM32F469_479xx */

#if  defined(STM32F412xG) || defined(STM32F413_423xx) || defined(STM32F446xx)
    /* Configure the main PLL */
    RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24) | (PLL_R << 28);
#endif /* STM32F412xG || STM32F413_423xx || STM32F446xx */    
    
    /* Enable the main PLL */
    RCC->CR |= RCC_CR_PLLON;

    /* Wait till the main PLL is ready */
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {
    }
   
#if defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F446xx) || defined(STM32F469_479xx)
    /* Enable the Over-drive to extend the clock frequency to 180 Mhz */
    PWR->CR |= PWR_CR_ODEN;
    while((PWR->CSR & PWR_CSR_ODRDY) == 0)
    {
    }
    PWR->CR |= PWR_CR_ODSWEN;
    while((PWR->CSR & PWR_CSR_ODSWRDY) == 0)
    {
    }      
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
#endif /* STM32F427_437x || STM32F429_439xx || STM32F446xx || STM32F469_479xx */

#if defined(STM32F40_41xxx)  || defined(STM32F412xG)  
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
#endif /* STM32F40_41xxx  || STM32F412xG */

#if defined(STM32F413_423xx)  
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_3WS;
#endif /* STM32F413_423xx */

#if defined(STM32F401xx)
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;
#endif /* STM32F401xx */

    /* Select the main PLL as system clock source */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= RCC_CFGR_SW_PLL;

    /* Wait till the main PLL is used as system clock source */
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
    {
    }
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
         configuration. User can add here some code to deal with this error */
  }
#elif defined(STM32F410xx) || defined(STM32F411xE)
#if defined(USE_HSE_BYPASS) 
/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
  /* Enable HSE and HSE BYPASS */
  RCC->CR |= ((uint32_t)RCC_CR_HSEON | RCC_CR_HSEBYP);
 
  /* Wait till HSE is ready and if Time out is reached exit */
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  }

  if (HSEStatus == (uint32_t)0x01)
  {
    /* Select regulator voltage output Scale 1 mode */
    RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;

    /* HCLK = SYSCLK / 1*/
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;

    /* PCLK2 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
    
    /* PCLK1 = HCLK / 4*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;

    /* Configure the main PLL */
    RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
    
    /* Enable the main PLL */
    RCC->CR |= RCC_CR_PLLON;

    /* Wait till the main PLL is ready */
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {
    }

    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;

    /* Select the main PLL as system clock source */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= RCC_CFGR_SW_PLL;

    /* Wait till the main PLL is used as system clock source */
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
    {
    }
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
         configuration. User can add here some code to deal with this error */
  }
#else /* HSI will be used as PLL clock source */
  /* Select regulator voltage output Scale 1 mode */
  RCC->APB1ENR |= RCC_APB1ENR_PWREN;
  PWR->CR |= PWR_CR_VOS;
  
  /* HCLK = SYSCLK / 1*/
  RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
  
  /* PCLK2 = HCLK / 2*/
  RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
  
  /* PCLK1 = HCLK / 4*/
  RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;
  
  /* Configure the main PLL */
  RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) | (PLL_Q << 24); 
  
  /* Enable the main PLL */
  RCC->CR |= RCC_CR_PLLON;
  
  /* Wait till the main PLL is ready */
  while((RCC->CR & RCC_CR_PLLRDY) == 0)
  {
  }
  
  /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
  FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;
  
  /* Select the main PLL as system clock source */
  RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
  RCC->CFGR |= RCC_CFGR_SW_PLL;
  
  /* Wait till the main PLL is used as system clock source */
  while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
  {
  }
#endif /* USE_HSE_BYPASS */  
#endif /* STM32F40_41xxx || STM32F427_437xx || STM32F429_439xx || STM32F401xx || STM32F469_479xx */  
}

手动调整时钟树

  将 SystemCoreClock 调整到 168MHz 的过程：
  实际开发板的 HSE 是 8MHz.
  void SystemInit(void) 里设置了 RCC->PLLCFGR = 0x24003010;
  0x24003010 转换位二进制数值是 -0010 0100 0000 0000 0011 0000 0001 0000-
  SystemCoreClock = 8000000*192/16/2=48MHz
  
  通过修改 RCC->PLLCFGR 的值调整为：具体修改 PLLN 的值为 336, PLLM的值为 8。
  SystemCoreClock = 8000000*336/8/2=168MHz
  
  得到最终 RCC->PLLCFGR 应该为：
  0x24003010  转换位二进制数值是 -0010 0100 0000 0000 0011 0000 0001 0000- (48MHz的配置)
  
  修改M为8:
  PLL_M Bits 5:0   的寄存器值是 -001000-    对应的分频系数是 -8-   官方要求  2 ≤ PLLM ≤ 63.
  修改N为336:
  PLL_N Bits 14:6  的寄存器值是 -101010000- 对应的倍频系数是 -336- 官方要求 50 ≤ PLLN ≤ 432.   
  P保持不变：
  PLL_P Bits 17:16 的寄存器值是 -00-        对应的分频系数是 -2-   官方要求  PLLP = 2, 4, 6, or 8.
  得到： 
  0010 0100 0000 00 000101010000001000
  -00100100000000000101010000001000- = 0x24005408. (168MHz的配置)
  所以 RCC->PLLCFGR = 0x24005408;
  
  修改代码：
  0. 保持不变： #define HSE_VALUE    ((uint32_t)8000000) /* 需要根据实际外部晶振的频率修改 HSE_VALUE 的值，单位是Hz。实际是8MHz */
  1. uint32_t SystemCoreClock = 168000000;  //168MHz版本 with 8MHz HSE晶振。
  2. void SystemInit(void) 里设置 RCC->PLLCFGR = 0x24005408;
  3. void RCC_DeInit(void) 里设置 RCC->PLLCFGR = 0x24005408;
  4. PLL_M PLL_N PLL_P PLL_Q 参数更新 被应用于 static void SetSysClock(void) 函数中。
  

RCC->PLLCFGR = 0x24005408; 
RCC_PLLCFGR：Bits 31:28 Reserved, must be kept at reset value.
                                 000101010000001000
实际值：0x07405408      0111010000000101010000001000  
设置值：0x24005408  00100100000000000101010000001000

借助 CubeMX 图形化配置时钟树

Mapleay
关注
STM32F1XX时钟树部分概念介绍
m0_51648467的博客
02-29 539
滴答定时器主要用于操作系统级别的任务调度和时间管理，提供固定频率的中断。一般定时器则提供了更广泛的定时和信号生成功能，适用于多种应用场合。STM32自由运行时钟 （FCLK）STM32的自由运行时钟（Free Running Clock，简称FCLK）是Cortex-M3内核的一个特性。它是内核的一个独立时钟源，不依赖于系统时钟（HCLK）或其他时钟源。当系统时钟（HCLK）停止或关闭时，自由运行时钟（FCLK）仍然继续运行。这使得处理器在休眠或低功耗模式下仍能够响应中断和其他关键事件。
Keil.STM32F1xx_DFP.2.4.0.pack (STM32F1xx 的 Keil pack 离线安装包)
07-24
STM32F1xx系列是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M3内核的微控制器，广泛应用于各种嵌入式系统设计。`Keil.STM32F1xx_DFP.2.4.0.pack` 是一个专门为STM32F1系列微控制器设计的开发工具包...
STM32F10X时钟树
xinzhi1992的博客
12-02 326
STM32F10X外设时钟树。
STM32F10X时钟树配置
wanshouxujiu的博客
05-22 593
一、整体框图 二、主系统时钟 1、HSE：外部高速时钟 无源或有源晶振提供，通常为 8 M 通过RCC_CR寄存器的位16：HSEON控制，1开启。 位17：HSERDY，HSE准备好时为1 与之对应的有HSI（内部高速，温度影响精度不高），LSE（外部低速），LSI内部低速 2、HSI：内部高速时钟 芯片内提供，为 8 M，HSE故障时自动切换到HSI，直到HSE启动成功 温度影响精度不高 通过RCC_CR寄存器的位0：HSION控制，1开启。 位1：HSIRDY...
STM32f1时钟系统及配置
weixin_62024838的博客
04-04 827
ad药剂
STM32的时钟配置
Code for Coffee
01-27 2401
5个时钟源 HSI，HSE，LSI，LSE，PLL HSE为高速外部时钟，频率范围4~16 MHz PLL的时钟源可以为： HSE/2 HSE HSI/2 倍频系数为2~16倍 STM32可以选择一个时钟信号输出到MCO脚，即PA8上，可以选择位PLL输出的二分频，HSI，HSE或系统时钟 注意：任何一个外设之前，都必须使能其对应的时钟 /** * @brief Reset and Clock Control */ typedef struct { __IO uint..
STM32的寄存器操作
qq_28576837的博客
08-18 2927
STM32的寄存器操作
Keil.STM32F1芯片安装包 - Keil.STM32F1xx-DFP.2.1.0.pack
12-14
Keil.STM32F1xx_DFP.2.1.0.pack是一个针对STM32F1系列的开发板支持包（Device Family Pack），它是Keil μVision集成开发环境（IDE）的一部分，用于为这些芯片提供编译器、调试器和库支持。 首先，让我们详细了解...
Keil.STM32F1xx_DFP.2.3.0.pack
11-18
《Keil.STM32F1xx_DFP.2.3.0.pack——全面解析STM32F1系列开发环境》 在嵌入式系统开发领域，STM32系列单片机以其强大的性能、丰富的资源以及广泛的应用场景，深受工程师们的喜爱。其中，STM32F1系列作为入门级产品...
stm32f10x.h文件分析理解
Shirven
01-04 2万+
stm32f10x.h 这个头文件是STM32开发最为重要的一个头文件，ST开发了这个库，方便大家开发，缩短开发周期。在 stm32f10x.h 中前面一开始就出现了： #ifndef __STM32F10x_H #define __STM32F10x_H #ifdef __cplusplus extern "C" { #endif 　　extern "C" {   这个语句用
stm32f103rct6的代码移植到stm32f103c8t6
热门推荐
AlwaysSun的博客
10-04 3万+
目前市面上见的较多的STM32单片机一般都是开发板，由于这些开发板又很丰富的例程，因此使用起来非常方便，但是我们实际在应用的时候，有时候可能用不了那么多的管脚，因此会造成管脚资源的浪费，而且管脚多的成本也会很高。同时这些STM32单片机的基础的库基本都是一样的，因此理论上来说，应该是可以进行移植的，博主今天来分享一下代码移植的方法。本次采用stm32f103rct6的代码移植到st...
stm32启动文件ld md hd cl vl xl分析及选择
u013165704的博客
10-24 2万+
说的直白点就是以下区别，在选择启动文件的时候有选择性区别！ startup_stm32f10x_cl.s 互联型的STM32F105xx，STM32F107xx startup_stm32f10x_hd.s 大容量的STM32F101xx，STM32F102xx，STM32F103xx startup_stm32f10x_hd_vl.s 大容量的STM32F100xx startup
stm32f10x芯片型号的选择
boby540138408的专栏
12-30 1482
小容量是指闪存存储器容量在16K至32K字节之间。 中容量是指闪存存储器容量在64K至128K字节之间。 大容量是指闪存存储器容量在256K至512K字节之间。 STM32F10X_LD_VL 对应于 LowDensity ValueLine，即小容量的STM32F100 STM32F10X_MD_VL 对应于 MediumDensity ValueLine，即中等容量的STM32F100 S...
STM32——时钟树与滴答计时器
everything is possible，anything is OK.
12-18 605
主要介绍stm32的时钟树与滴答计时器的一些理论和一个自己编写的delay函数。
STM32HAL（二）外设管理与系统时钟配置
最新发布
嗨咯！这里是三马分享家的博客，欢迎你的到来
05-20 2506
探讨了STM32F4系列微控制器使用HAL库进行系统时钟配置与外设管理的关键步骤与实践策略
STM32不同型号的芯片对应的启动文件如何选择
a只如初见的博客
12-24 4919
startup_stm32f10x_ld_vl.s: for STM32 Low density Value line devices startup_stm32f10x_ld.s: for STM32 Low density devices startup_stm32f10x_md_vl.s: for STM32 Medium density Value line devices startup_stm32f10x_md.s: for STM32 Medium density device..
STM32F1时钟（详解）
m0_57396609的博客
08-07 3868
一、时钟树图表 二、时钟详解（结合时钟树） HSE时钟（72M） HSE:High Speed-External Clock signal，即高速的外部时钟 来源：无源晶振（4-16M），通常使用8M 控制：RCC CR时钟控制寄存器的位16：HSEON控制 HSI时钟 HSI:Low Speed Internal Clock signal，高速的内部时钟 来源：芯片内部，大小为8M，当HSE故障时，系统时钟会自动切换到HSI，直到HSE启动成功。 控制：RCC_CR时钟控制寄存器的位0：HSION控制
STM32F10X系列时钟配置
fantastic_sky的博客
11-29 2069
为什么需要时钟信号：单片机内部有许多时序逻辑电路，每一个时序逻辑电路由若干个需要用到时钟的器件（如通常用来配置输入输出的D触发器），同时单片机的外设器件也会用到时钟来控制数据传输（如单片机SPI通信会用到时钟线CLK），所以单片机工作需要时钟信号。 以PIC16F877单片机内部端口配置为例 单片机时钟是怎么产生的：单片机有一个晶体震荡电路，通常由石英晶体、电容、电阻、反相放大器组成。焊接过STC89C52单片机开发板的同学应该知道需要在XTAL1和XTAL2引脚间接入12MHz（或其他频率）晶
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值