Application of SysTick in STM32 3.5 firmware library (1)

There is a system timer in the STM32 core, which is a 24-bit down counter. The working principle is that after the system time base timer is set to the initial value and enabled, the count value decreases every time a system clock cycle passes. When the count value decreases to 0, the system timer will automatically reload the initial value and continue the next count. At the same time, the internal COUNTFLAG flag will be set. Trigger an interrupt.
In the early firmware library, many functions were provided to set SysTick, but in the 3.5 version of the standard firmware library, the relevant driver functions were removed, and users had to call the functions defined by CMSIS. CMSIS only provided a Systick setting function, which replaced all the original driver functions of STM32. The purpose of doing this may be to simplify the Systick setting, but it reduces the user's controllability of SysTick.
The function provided in CMSIS is SysTick_Config(uint32_t ticks); This function sets the value of the automatic reload counter (LOAD), the priority of the SysTick IRQ, resets the value of the counter (VAL), starts counting and turns on the SysTick IRQ interrupt. The SysTick clock uses the system clock by default.
This function is defined in Core_cm3.h, and the source code is as follows:
   static __INLINE uint32_t SysTick_Config(uint32_t ticks)
 {
   if (ticks > SysTick_LOAD_RELOAD_Msk) return (1);                                                                                               
   SysTick->LOAD = (ticks & SysTick_LOAD_RELOAD_Msk) - 1; /* Set initial value*/
   NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* Set interrupt priority */
   SysTick->VAL = 0; /* Load the SysTick Counter Value */
   SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
                    SysTick_CTRL_TICKINT_Msk |
                    SysTick_CTRL_ENABLE_Msk; /* Enable Systick interrupt and Systick timer*/
   return (0);                                               

}
As can be seen from the above function, this function completes the initial value of Systick, interrupt priority, enabling interrupts, and starting the timer, which greatly simplifies the program.
The ticks represent the initial value. For example, if the system clock is 72Mhz, then to generate a 1ms time base, we can write it like this.
SysTick_Config(SystemCoreClock/1000); Of course, it can also be written as: SysTick_Config(72000);
Knowing this, we can use it to make a simple delay function delay_ms(u16 time);
code show as below:
            void delay_ms(u16 time)
             {
                          nTime=time; /nTime is a global variable and can be set as extern u16 nTime;/
                          while(nTime);
             }
Add nTime directly to the interrupt function--;
Add SysTick_Config(72000) during the main function initialization process;

2. Using library functions and interrupts to achieve delay

/**Under Systick control, PB.5 flashes every 1ms
     SysTick is configured to interrupt once every 1ms.
*/

/***Main function***/
 #include "stm32f10x.h"

 __IO uint32_t TimingDelay;

void GPIO_Configuration(void);
void Delay(__IO uint32_t nTime);

int main(void)
 {
   GPIO_Configuration();  
   while (SysTick_Config(72000)); /* Set SysTick timer to generate 1ms interrupt */
   //The set value is less than 0x00FFFFFF and the execution continues...
   while (1)
   {
     GPIO_SetBits(GPIOB, GPIO_Pin_5);
     Delay(1); //Delay 1ms
     GPIO_ResetBits(GPIOB, GPIO_Pin_5);       
     Delay(1); //Delay 1ms
   }
 }

void GPIO_Configuration(void)
 {
   GPIO_InitTypeDef GPIO_InitStructure;
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   GPIO_InitStructure.GPIO_Speed ​​= GPIO_Speed_50MHz;
   GPIO_Init(GPIOB, &GPIO_InitStructure);
 }

/* Function: Delay nTime ms. */
void Delay(__IO uint32_t nTime)
 {
   TimingDelay = nTime;
   while(TimingDelay);
 }
 
 

/***stm32f10x_it.c***/

#include "stm32f10x_it.h"

extern __IO uint32_t TimingDelay;

void SysTick_Handler(void)
 {
   TimingDelay--;
 }