STM32F072从零配置工程-实现delay功能

因为是使用SysTick来作为延时时钟，因此在这里给出SysTick时钟的寄存器；

CTRL：SysTick控制及状态寄存器

位段	名称	类型	复位值	描述
16	COUNTFLAG	R/W	0	如果在上次读取本寄存器后， SysTick 已经计到 了 0，则该位为 1。
2	CLKSOURCE	R/W	0	时钟源选择位，0=AHB/8，1=处理器时钟AHB
1	TICKINT	R/W	0	1=SysTick倒数计数到 0时产生 SysTick异常请 求，0=数到 0 时无动作。也可以通过读取COUNTFLAG标志位来确定计数器是否递减到0
0	ENABLE	R/W	0	SysTick 定时器的使能位

LOAD：SysTick 重装载数值寄存器

位段	名称	类型	复位值	描述
23:0	RELOAD	R/W	0	当倒数计数至零时，将被重装载的值

VAL：SysTick当前数值寄存器

位段	名称	类型	复位值	描述
23:0	CURRENT	R/W	0	读取时返回当前倒计数的值，写它则使之清零，同时还会清除在SysTick控制及状态寄存器中的COUNTFLAG 标志

此处参考外设库的例子，程序结构和逻辑大致如下：

　　通过SystemInit()配置好时钟；

　　通过SysTick_Config(SystemCoreClock/1000)配置SysTick时钟；

　　创建Delay(__IO uint32_t nTime)毫秒延时函数（设置执行几次中断，时间为nTime×中断时间）；

　　在SysTick中断SysTick_Handler()中按照配置的减小计数值并检测是否清零；

static __IO uint32_t TimingDelay;
void Delay(__IO uint32_t nTime);

/**
  * @brief   Main program
  * @param  None
  * @retval None
  */
int main(void)
{
  /*!< At this stage the microcontroller clock setting is already configured,
       this is done through SystemInit() function which is called from startup
       file (startup_stm32f0xx.s) before to branch to application main.
       To reconfigure the default setting of SystemInit() function, refer to
       system_stm32f0xx.c file
     */     

  /* Setup SysTick Timer for 1 msec interrupts.
     ------------------------------------------
    1. The SysTick_Config() function is a CMSIS function which configure:
       - The SysTick Reload register with value passed as function parameter.
       - Configure the SysTick IRQ priority to the lowest value (0x0F).
       - Reset the SysTick Counter register.
       - Configure the SysTick Counter clock source to be Core Clock Source (HCLK).
       - Enable the SysTick Interrupt.
       - Start the SysTick Counter.

    2. You can change the SysTick Clock source to be HCLK_Div8 by calling the
       SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8) just after the
       SysTick_Config() function call. The SysTick_CLKSourceConfig() is defined
       inside the misc.c file.

    3. You can change the SysTick IRQ priority by calling the
       NVIC_SetPriority(SysTick_IRQn,...) just after the SysTick_Config() function
       call. The NVIC_SetPriority() is defined inside the core_cm0.h file.

    4. To adjust the SysTick time base, use the following formula:

         Reload Value = SysTick Counter Clock (Hz) x  Desired Time base (s)

       - Reload Value is the parameter to be passed for SysTick_Config() function
       - Reload Value should not exceed 0xFFFFFF
   */
  if (SysTick_Config(SystemCoreClock / ))
  {
    /* Capture error */
    while ();
  }

  while ()
  {
    /* Insert 100 ms delay */
    Delay();
  }
}

/**
  * @brief  Inserts a delay time.
  * @param  nTime: specifies the delay time length, in milliseconds.
  * @retval None
  */
void Delay(__IO uint32_t nTime)
{
  TimingDelay = nTime;

  while(TimingDelay != );
}

/**
  * @brief  Decrements the TimingDelay variable.
  * @param  None
  * @retval None
  */
void TimingDelay_Decrement(void)
{
  if (TimingDelay != 0x00)
  {
    TimingDelay--;
  }
}

由于官方的例子中默认配置好了时钟，因此给出的SystemCoreClock是48000000；

　　设置好重装值后，就可以确定发生一次中断需要的时间；

uint32_t SystemCoreClock    = ;  

/** 

  * @brief  This function handles SysTick Handler. 

  * @param  None 

  * @retval None 

  */  

void SysTick_Handler(void)  

{  

　　TimingDelay_Decrement();  

}  

从SysTick_Config()中可以看出配置SysTick的步骤：

设置重装载寄存器LOAD的值；（设置的是中断时间）

设置中断优先级；

清楚当前数值寄存器VAL的值；

配置控制与状态寄存器CTRL，包括时钟源、系统定时器中断、使能定时器；

__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
{
  if ((ticks - ) > SysTick_LOAD_RELOAD_Msk)  return ();      /* Reload value impossible */

  SysTick->LOAD  = ticks - ;                                  /* set reload register */
  NVIC_SetPriority (SysTick_IRQn, (<<__NVIC_PRIO_BITS) - );  /* set Priority for Systick Interrupt */
  SysTick->VAL   = ;                                          /* Load the SysTick Counter Value */
  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
                   SysTick_CTRL_TICKINT_Msk   |
                   SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
  return ();                                                  /* Function successful */
}

SysTick中断时间的计算：

假设f_AHB=180MHz，则计数值±1的时间为t=1/f_AHB，中断一次的时间=LOAD×t；

根据计算，中断1us的时间= LOAD×1/f_AHB=180×（1/180M）=1us；

若需要中断1ms的时间=180000×（1/180M）=1ms；

因此，设置SystemCoreClock=180M/1000=180000=LOAD值；

这样取LOAD值为180000就可以得到一次中断需要的时间为1ms；

由于库例子是默认设置好了时钟，因此这里涉及到一个时钟的配置

在SystemInit中重要任务是清除RCC中的时钟配置：

　　将HSI作为默认时钟；

　　且SYSCLK不分频、HCLK不分频、ADC时钟不分频、MCO时钟输出不分频；

　　关闭HSE、CSS、PLL时钟；

　　将外部HSE时钟输入旁路；

　　清空PLL系数；

　　清空USART1、I2C、CEC和ADC外设的时钟源；

　　关闭HSI14时钟；

　　关闭所有中断Int；

void SystemInit (void)
{
  /* Set HSION bit */
  RCC->CR |= (uint32_t)0x00000001;

#if defined(STM32F051)
  /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits */
  RCC->CFGR &= (uint32_t)0xF8FFB80C;
#else
  /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
  RCC->CFGR &= (uint32_t)0x08FFB80C;
#endif /* STM32F051 */

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

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

  /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
  RCC->CFGR &= (uint32_t)0xFFC0FFFF;

  /* Reset PREDIV1[3:0] bits */
  RCC->CFGR2 &= (uint32_t)0xFFFFFFF0;

  /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */
  RCC->CFGR3 &= (uint32_t)0xFFFFFEAC;

  /* Reset HSI14 bit */
  RCC->CR2 &= (uint32_t)0xFFFFFFFE;

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

  /* Configure the System clock frequency, AHB/APBx prescalers and Flash settings */
  SetSysClock();
}

时钟配置的重点在函数SetSysClock()中；

使能HSE并等待HSE初始化完成；

若HSE初始化完成后用HSE配置PLL时钟，并将PLL输出时钟作为系统时钟SYSCLK；

/**
  * @brief  Configures the System clock frequency, 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)
{
  __IO uint32_t StartUpCounter = , HSEStatus = ;

/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/

  /* SYSCLK, HCLK, PCLK configuration ----------------------------------------*/
  /* 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 == ) && (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)
  {
    /* Enable Prefetch Buffer and set Flash Latency */
    FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY;

    /* HCLK = SYSCLK */
    RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;

    /* PCLK = HCLK */
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE_DIV1;

    /* PLL configuration */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_PREDIV1 | RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLMULL6);

    /* Enable PLL */
    RCC->CR |= RCC_CR_PLLON;

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

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

    /* Wait till PLL is used as system clock source */
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)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 */
  }
}

而在核心时钟HCLK发生变化时，需要调用SystemCoreClockUpdate()函数来更新SystemCoreClock值，以便调整使用了该参数的配置；

如果SYSCLK源为HSI，则SystemCoreClock=HSI_VALUE；（HSI_VALUE默认为8MHz，实际值会随电压和温度变化而变化）

如果SYSCLK源为HSE，则SystemCoreClock=HSE_VALUE；（HSE_VALUE需要确保和实际所使用的外接晶振频率相同，否则此功能可能会失效）

如果SYSCLK源为PLL，则SystemCoreClock= HSE/HSI_VALUE与PLL因子的计算；

如果SYSCLK源不确定，默认为HSI时钟源；

最后考虑HCLK的分频系数；

void SystemCoreClockUpdate (void)
{
  uint32_t tmp = , pllmull = , pllsource = , prediv1factor = ;

  /* Get SYSCLK source -------------------------------------------------------*/
  tmp = RCC->CFGR & RCC_CFGR_SWS;

  switch (tmp)
  {
    case 0x00:  /* HSI used as system clock */
      SystemCoreClock = HSI_VALUE;
      break;
    case 0x04:  /* HSE used as system clock */
      SystemCoreClock = HSE_VALUE;
      break;
    case 0x08:  /* PLL used as system clock */
      /* Get PLL clock source and multiplication factor ----------------------*/
      pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
      pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
      pllmull = ( pllmull >> ) + ;

      if (pllsource == 0x00)
      {
        /* HSI oscillator clock divided by 2 selected as PLL clock entry */
        SystemCoreClock = (HSI_VALUE >> ) * pllmull;
      }
      else
      {
        prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + ;
        /* HSE oscillator clock selected as PREDIV1 clock entry */
        SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;
      }
      break;
    default: /* HSI used as system clock */
      SystemCoreClock = HSI_VALUE;
      break;
  }
  /* Compute HCLK clock frequency ----------------*/
  /* Get HCLK prescaler */
  tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> )];
  /* HCLK clock frequency */
  SystemCoreClock >>= tmp;
}

另一中延时函数的配置方法，是不利用中断来实现的

首先初始化SysTick时钟

这里直接将SysTick时钟源设置为HCLK的8分频；

由于这里SYSCLK=SystemCoreClock=168MHz，因此SysTick时钟为168MHz/8=21MHz；

因此要延时1us=10^(-6)s=21/21M，此时的重装值为21=SYSCLK/8=fac_us；

要延时1ms=10^(-3)=21k/21M，此时的重装值为21k=1000*fac_us= fac_ms；

void delay_init(u8 SYSCLK)
{
     SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
    fac_us=SYSCLK/;
    fac_ms=(u16)fac_us*;
}

延时1us到延时1ms的函数

流程大致如下：将x*fac_us加载入重装寄存器LOAD；

清空计数寄存器VAL；

通过CTRL寄存器，开启SysTick时钟；

等待计数完成，关闭SysTick时钟，清空计数寄存器VAL；

void delay_us(u32 nus)
{
    u32 temp;
    SysTick->LOAD=nus*fac_us;
    SysTick->VAL=0x00;
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;
    do
    {
        temp=SysTick->CTRL;
    }while((temp&0x01)&&!(temp&(<<)));
    SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;
    SysTick->VAL =0X00;
}  

void delay_xms(u16 nms)
{
    u32 temp;
    SysTick->LOAD=(u32)nms*fac_ms;
    SysTick->VAL =0x00;
    SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;
    do
    {
        temp=SysTick->CTRL;
    }while((temp&0x01)&&!(temp&(<<)));
    SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;
    SysTick->VAL =0X00;
}   

void delay_ms(u16 nms)
{
    u8 repeat=nms/;
    u16 remain=nms%;
    while(repeat)
    {
        delay_xms();
        repeat--;
    }
    if(remain)delay_xms(remain);
}   

2019-7-18更新

从STM32Cube生成的代码已经默认包含了延时功能，但是仅用于实现1ms的延时，其实现是通过系统自带的配置：

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

然后延时的功能采用库函数实现HAL_Delay()来实现：

　　可以实现延时1ms的功能；

/**
  * @brief This function provides accurate delay (in milliseconds) based
  *        on variable incremented.
  * @note In the default implementation , SysTick timer is the source of time base.
  *       It is used to generate interrupts at regular time intervals where uwTick
  *       is incremented.
  * @note ThiS function is declared as __weak to be overwritten in case of other
  *       implementations in user file.
  * @param Delay specifies the delay time length, in milliseconds.
  * @retval None
  */
__weak void HAL_Delay(__IO uint32_t Delay)
{
  uint32_t tickstart = HAL_GetTick();
  uint32_t wait = Delay;

  /* Add a period to guarantee minimum wait */
  if (wait < HAL_MAX_DELAY)
  {
     wait++;
  }

  while((HAL_GetTick() - tickstart) < wait)
  {
  }
}