• 【STM32】Systick定时器

    一、STM32的5种定时器简介

    1.独立看门狗（IWDG） VS 窗口看门狗（WWDG）

    1.独立看门狗（IWDG）

    独立看门狗：当没有到设定时间之前，给它喂了狗，就会回到初始值。

    2.窗口看门狗（WWDG）

    窗口看门狗：只有在设定的窗口时间范围内喂才可以起效果

    最适合哪些要求看门狗在精确计时窗口起作用。

    2.Systick定时器

    3.高级定时器（TIM1+TIM8）

    4.通用定时器（TIMx）

    1）输入捕获：通过输入电平进行捕获

    2）产生中断：

            定时器时间到

            触发事件

    3）正交编码器和霍尔传感器（测小车速度）

    5.基本定时器（TIM6 & TIM7）

    1）最多只能计数65535（2的16次方）

    2）预分频器（因为在定时器的频率不需要那么快）

    3）可以产生中断

    二、SYSTICK定时器

    0.SYSTICK的提出

    我们之前的51只有一个主线（无操作系统），一个进程走到死

    我们想要多种进程并行工作，但是实际上无法这样。因为后面的程序可能还没有等到执行，时间就结束了。所以我们将每一个程序都分成多个小进程，第一个进程的第一个小部分执行完成在执行第二个进程的第一小部分....【从而实现微观上的串行，宏观上的并行】

    1.SYSTICK定时器的作用

    1）专用于生产RTOS的系统滴答时钟【因为RTOS需要多进程执行】

    2）可用于裸机程序中短时间精确延时函数

    3）可用于普通定时器中断功能

    2.SYSTICK定时器的数据手册

    https://www.st.com/resource/en/programming_manual/cd00228163-stm32f10xxx-20xxx-21xxx-l1xxxx-cortex-m3-programming-manual-stmicroelectronics.pdf

    SYSTICK和NVIC不属于SoC部分【属于内核外设】

    1.24个定时器

    2.各种寄存器

    1.STK_CTRL（控制状态）

    2.STK_LOAD（初始值）

    我们计算出来的值要-1

    因为计时是4 3 2 1 0 4 3 2 1 0【0才表示结束】

    3.STK_VAL（计数值）

    4.STK_CALIB

    校准

    3.SYSTICK寄存器在标准库中的封装

    SYSTICK放在misc.c中

    1. SysTick_CLKSourceConfig--分频设置

    本函数在misc.c中

    SYSTICK本身没有分频器。所以需要通过本函数进行设置

    1. /**
    2.   * @brief  Configures the SysTick clock source.
    3.   * @param  SysTick_CLKSource: specifies the SysTick clock source.
    4.   *   This parameter can be one of the following values:
    5.   *     @arg SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8 selected as SysTick clock source.
    6.   *     @arg SysTick_CLKSource_HCLK: AHB clock selected as SysTick clock source.
    7.   * @retval None
    8.   */
    9. void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
    10. {
    11.   /* Check the parameters */
    12.   assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
    13.   if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
    14.   {
    15.     SysTick->CTRL |= SysTick_CLKSource_HCLK;
    16.   }
    17.   else
    18.   {
    19.     SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
    20.   }
    21. }

    全局搜索SYSTICK

    2.SysTick_Config--触发systick中断

    本函数在core_cm3.h中

    Systick config函数配置的状况是： 默认使用AHB时钟。会产生中断，中断优先级为最低，并且最末尾启动了定时器

    1. /**
    2.  * @brief  Initialize and start the SysTick counter and its interrupt.
    3.  *
    4.  * @param   ticks   number of ticks between two interrupts
    5.  * @return  1 = failed, 0 = successful
    6.  *
    7.  * Initialise the system tick timer and its interrupt and start the
    8.  * system tick timer / counter in free running mode to generate 
    9.  * periodical interrupts.
    10.  */
    11.  /**
    12. 	Systick config函数配置的状况是：
    13. 		默认使用AHB时钟。会产生中断
    14. 		中断优先级为最低，并且最末尾启动了定时器
    15. */
    16. static __INLINE uint32_t SysTick_Config(uint32_t ticks)
    17. { 
    18. //检验有没有超过24位寄存器
    19. //SysTick_LOAD_RELOAD_Msk：  0xFFFFFFul
    20.   if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
    21. //减一：因为我们是从0开始的 ，但是一般我们都不在乎因为影响不大                                                              
    22.   SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
    23. //设置中断优先级，默认设置最低
    24.   NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Cortex-M0 System Interrupts */
    25.   SysTick->VAL   = 0;      //让它上来直接完了                                    /* Load the SysTick Counter Value */
    26.   //SysTick_CTRL_CLKSOURCE_Msk（1）：默认使用AHB
    27.   //SysTick_CTRL_TICKINT_Msk：默认会产生中断
    28.   //SysTick_CTRL_ENABLE_Msk：启动了定时器
    29.   SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk | 
    30.                    SysTick_CTRL_TICKINT_Msk   | 
    31.                    SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
    32.   return (0);                                                  /* Function successful */

    3.注意点：SysTick_Config VS SysTick_CLKSourceConfig的调用顺序

    我们在调用库函数进行初始化的时候，要先调用【SysTick_Config】然后再调用【SysTick_CLKSourceConfig】，因为再【SysTick_Config】中对Systick_CTRL中是对其中几位bit进行直接赋值，而不是位或。所以如果先定义【SysTick_CLKSourceConfig】则相关寄存器的值可能被覆盖掉。

    4.SYSTICK定时器的2种工作方式

    1.中断方式

    使能后，到中断处理程序查

    2.查询方式

    检测STK_VAL，因为VAL会不断减少

    5.SYSTICK定时器的定时计算

    1.公式：重装载值=systick时钟频率(Hz)*想要定的时间（s）

    2.例子：1ms 

    我们使用原始的频率：72MHZ=72 000 000HZ

    以1s为单位---》1ms==0.001s

    CNT=72 000 000*0.001=72 000

    查看是否超过2的24次方

    3.查询方式和中断方式都这样计算

    6.SYSTICK中断实现LED每200ms闪烁一次【中断方式-interrupt】

    https://www.cnblogs.com/kinson/p/7967332.html

    0.注意点：

    1）SYSTICK是自动清除中断，不需要手动将其清除

    2）SYSTICK是内核中的，所以不需要打开SYSTICK时钟，它一直都是打开的

    1.接线

    我们将led的j19接到PB0-PB7，但是实际上我们就操作led1，所以使用到PB0

    2.NVIC_Configuration

    因为我们的Systick中断不属于外设中断，所以不需要设置NVIC的部分设置。

    1. void NVIC_Configuration(void)
    2. {
    3.  // NVIC_InitTypeDef NVIC_InitStructure;
    4.   
    5. #ifdef  VECT_TAB_RAM  
    6.   /* Set the Vector Table base location at 0x20000000 */ 
    7.   NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);   //分配中断向量表
    8. #else  /* VECT_TAB_FLASH  */
    9. 	//表示从FLASH中启动；；
    10.   /* Set the Vector Table base location at 0x08000000 */ 
    11.   NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    12. #endif
    13.  
    14.   /* Configure one bit for preemption priority */
    15.   // NVIC_PriorityGroup_1：2个抢占优先级，8个次优先级
    16. 	
    17. 	/*
    18.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);  //设置中断优先级
    19.   
    20.   // Enable the SYSTICK Interrupt 
    21. 	//设置为SYSTICK
    22. 	//这里我们将下面代码注释起来是因为【NVIC_IRQChannel】只接受正整数
    23. 	//但是我们【SysTick_IRQn】是负数，所以不能正确输出
    24.   NVIC_InitStructure.NVIC_IRQChannel = SysTick_IRQn; //中断通道
    25.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =  0;  //强占优先级
    26.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;//次优先级
    27.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  //通道中断使能
    28.   NVIC_Init(&NVIC_InitStructure);//初始化中断
    29. 	*/
    30. }

    3.GPIO_Configuration

    1. //GPIO初始化
    2. void GPIO_Configuration(void){
    3. 	
    4. 	GPIO_InitTypeDef GPIO_InitStructure;
    5.  
    6. 	
    7. 	//PB0 ---LED1【LED的显示输出】
    8. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    9.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    10.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       //推挽输出
    11.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    12. 	// 默认输出0让LED亮
    13. 	//RESET=0
    14. 	//SET=1
    15.   GPIO_WriteBit(GPIOB, GPIO_Pin_8, Bit_RESET);			
    16.  
    17. }

    4.RCC_Configuration

    1. //RCC的配置
    2. void RCC_Configuration(void){
    3. 	
    4. 	//因为起始代码中已经调用SystemInit将主时钟设置为72MHZ
    5. 	//所以我们这里RCC直接使能时钟就可以
    6. 	
    7. 	//使能GPIO端口
    8. 	//通过PB0控制LED1
    9. 	//因为我们使用到的是PB0，所以只使用到GPIOB
    10. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    11. 	//因为systick属于cpu部分的，所以时钟始终打开的，不需要再去打开
    12. 	//所以这里只是打开GPIO的时钟即可
    13. 	
    14. }

    5. SYSTICK_Configuration

    1. //SysTick_Config：是SYSTICK的启动函数
    2. void SYSTICK_Configuration(void){
    3. 	/*
    4. 	这个时间超时了
    5. 	//主频是72MHZ，定时时间是500ms
    6. 	//ticks=72 000 000*0.5 =3600 000
    7. 	SysTick_Config(36000000);//1677 7216
    8. 	*/
    9. 	//100毫秒
    10. 	//范围：233ms
    11. 	//ticks=72 000 000*200ms=14400000
    12. 	SysTick_Config(14400000);
    13. 	//SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
    14. }

    6.main

    1. #include "stm32f10x.h"                  // Device header
    2. /**
    3. 	使用SYSTICK控制led的闪烁【中断式】
    4. 	PB8控制LED8
    5. */
    6.  
    7. //函数声明
    8. //RCC的配置
    9. void RCC_Configuration(void);
    10. //GPIO初始化
    11. void GPIO_Configuration(void);
    12. void NVIC_Configuration(void);
    13. void SYSTICK_Configuration(void);
    14.  
    15. //全局变量定义
    16. EXTI_InitTypeDef EXTI_InitStructure;
    17. ErrorStatus HSEStatartUpStatus;
    18.  
    19.  
    20. int main(){
    21. 	//系统时钟配置
    22. 	RCC_Configuration();
    23. 	//NVIC配置
    24. 	NVIC_Configuration();
    25. 	//配置GPIO
    26. 	GPIO_Configuration();
    27. 	
    28. 	SYSTICK_Configuration();
    29. 	
    30. 	while(1);
    31. 	return 0;
    32. }
    33.  
    34. //RCC的配置
    35. void RCC_Configuration(void){
    36. 	
    37. 	//因为起始代码中已经调用SystemInit将主时钟设置为72MHZ
    38. 	//所以我们这里RCC直接使能时钟就可以
    39. 	
    40. 	//使能GPIO端口
    41. 	//通过PB0控制LED1
    42. 	//因为我们使用到的是PB0，所以只使用到GPIOB
    43. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    44. 	//因为systick属于cpu部分的，所以时钟始终打开的，不需要再去打开
    45. 	//所以这里只是打开GPIO的时钟即可
    46. 	
    47. }
    48.  
    49.  
    50. //GPIO初始化
    51. void GPIO_Configuration(void){
    52. 	
    53. 	GPIO_InitTypeDef GPIO_InitStructure;
    54.  
    55. 	
    56. 	//PB0 ---LED1【LED的显示输出】
    57. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    58.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    59.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       //推挽输出
    60.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    61. 	// 默认输出0让LED亮
    62. 	//RESET=0
    63. 	//SET=1
    64.   GPIO_WriteBit(GPIOB, GPIO_Pin_8, Bit_RESET);			
    65.  
    66. }
    67.  
    68. void NVIC_Configuration(void)
    69. {
    70.  // NVIC_InitTypeDef NVIC_InitStructure;
    71.   
    72. #ifdef  VECT_TAB_RAM  
    73.   /* Set the Vector Table base location at 0x20000000 */ 
    74.   NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);   //分配中断向量表
    75. #else  /* VECT_TAB_FLASH  */
    76. 	//表示从FLASH中启动；；
    77.   /* Set the Vector Table base location at 0x08000000 */ 
    78.   NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    79. #endif
    80.  
    81.   /* Configure one bit for preemption priority */
    82.   // NVIC_PriorityGroup_1：2个抢占优先级，8个次优先级
    83. 	
    84. 	/*
    85.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);  //设置中断优先级
    86.   
    87.   // Enable the SYSTICK Interrupt 
    88. 	//设置为SYSTICK
    89. 	//这里我们将下面代码注释起来是因为【NVIC_IRQChannel】只接受正整数
    90. 	//但是我们【SysTick_IRQn】是负数，所以不能正确输出
    91.   NVIC_InitStructure.NVIC_IRQChannel = SysTick_IRQn; //中断通道
    92.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =  0;  //强占优先级
    93.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;//次优先级
    94.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  //通道中断使能
    95.   NVIC_Init(&NVIC_InitStructure);//初始化中断
    96. 	*/
    97. }
    98.  
    99. //SysTick_Config：是SYSTICK的启动函数
    100. void SYSTICK_Configuration(void){
    101. 	/*
    102. 	这个时间超时了
    103. 	//主频是72MHZ，定时时间是500ms
    104. 	//ticks=72 000 000*0.5 =3600 000
    105. 	SysTick_Config(36000000);//1677 7216
    106. 	*/
    107. 	//100毫秒
    108. 	//范围：233ms
    109. 	//ticks=72 000 000*200ms=14400000
    110. 	SysTick_Config(14400000);
    111. 	//SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
    112. }
    113.  
    114.

    7.注意点：ticks的时间设置

    我们已经知道systick有24个寄存器，所以我们最大的数值范围不能超过2的24次方。

    所以我们计算出来的值不能超过上面那个

    而根据我们单片机上面使用的是72MHZ的频率

    则我们ticks的范围是16 777 216/72 000 000

    举个例子

    如果我们想要设置100ms

    则ticks=72 000 000 *0.1=7,200,000

    8.SYSTICK中断实现LED每200ms闪烁一次【查询方式--delay】

    0.解释

    我们通过使用delay进行精确的延时

    1.代码解析

     1.GPIO_Configuration

    1. //GPIO初始化
    2. void GPIO_Configuration(void){
    3. 	
    4. 	GPIO_InitTypeDef GPIO_InitStructure;
    5.  
    6. 	
    7. 	//PB0 ---LED1【LED的显示输出】
    8. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    9.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    10.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       //推挽输出
    11.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    12. 	// 默认输出0让LED亮
    13. 	//RESET=0
    14. 	//SET=1
    15.   GPIO_WriteBit(GPIOB, GPIO_Pin_8, Bit_RESET);			
    16.  
    17. }

    2.RCC_Configuration

    1. //RCC的配置
    2. void RCC_Configuration(void){
    3. 	
    4. 	//因为起始代码中已经调用SystemInit将主时钟设置为72MHZ
    5. 	//所以我们这里RCC直接使能时钟就可以
    6. 	
    7. 	//使能GPIO端口
    8. 	//通过PB0控制LED1
    9. 	//因为我们使用到的是PB0，所以只使用到GPIOB
    10. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    11. 	//因为systick属于cpu部分的，所以时钟始终打开的，不需要再去打开
    12. 	//所以这里只是打开GPIO的时钟即可
    13. 	
    14. }

    3.delay_us

    此代码要根据频率来进行修改

    1. //用systick计数器来帮我们实现us级别的精确延时
    2. //这个函数成立有2个条件：
    3. //1.主频必须是72MHZ
    4. //2.us要小于（2的24次方）=1864 135us=1.8s
    5. void delay_us(unsigned int us){
    6. 	
    7. 	//记录CTRL的countflag位的值
    8. 	unsigned int tmp=0;
    9. 	
    10. 	//思路是先把systick的时钟源设置好，然后给一个正确的ticks
    11. 	//然后使能systick，while循环等待countflag置位则时间到
    12. 	
    13. 	//72MHZ主频，我们使用8分频，72/8=9MHZ systick
    14. 	 SysTick->LOAD=us*9;
    15. 	 SysTick->VAL=0;
    16. 	//我们要先设置上面的LOAD和VAL，在进行使能
    17. 	//时钟源是AHB/8，禁止中断，使能systick
    18. 	 SysTick->CTRL =0x01;
    19. 	
    20. 	//检测什么时候时间结束
    21. 	//查看CTRL中的countflag
    22. 	do{
    23. 		tmp=SysTick->CTRL;
    24. 	}while(!(tmp&(1<<16)));
    25. 	
    26. 	//时间到，关闭定时器
    27. 	SysTick->VAL=0;
    28. 	SysTick->CTRL =0x00;
    29. }

    4.delay_ms

    1. //不能大于 1864
    2. void delay_ms(unsigned int ms){
    3. 	
    4. 	//记录CTRL的countflag位的值
    5. 	unsigned int tmp=0;
    6. 	
    7. 	//思路是先把systick的时钟源设置好，然后给一个正确的ticks
    8. 	//然后使能systick，while循环等待countflag置位则时间到
    9. 	
    10. 	//72MHZ主频，我们使用8分频，72/8=9MHZ systick
    11. 	 SysTick->LOAD=ms*9000;
    12. 	 SysTick->VAL=0;
    13. 	//我们要先设置上面的LOAD和VAL，在进行使能
    14. 	//时钟源是AHB/8，禁止中断，使能systick
    15. 	 SysTick->CTRL =0x01;
    16. 	
    17. 	//检测什么时候时间结束
    18. 	//查看CTRL中的countflag
    19. 	do{
    20. 		tmp=SysTick->CTRL;
    21. 	}while(!(tmp&(1<<16)));
    22. 	
    23. 	//时间到，关闭定时器
    24. 	SysTick->VAL=0;
    25. 	SysTick->CTRL =0x00;
    26. 	
    27. }

    5.main

    1. #include "stm32f10x.h"                  // Device header
    2. /**
    3. 	使用delay控制led的闪烁--与systick进行等价实现【查询式】
    4. 	PB8控制LED8
    5. */
    6.  
    7. //函数声明
    8. //RCC的配置
    9. void RCC_Configuration(void);
    10. //GPIO初始化
    11. void GPIO_Configuration(void);
    12.  
    13. void delay_ms(unsigned int ms);
    14. void delay_us(unsigned int us);
    15.  
    16. //全局变量定义
    17. EXTI_InitTypeDef EXTI_InitStructure;
    18. ErrorStatus HSEStatartUpStatus;
    19.  
    20.  
    21. int main(){
    22. 	//系统时钟配置
    23. 	RCC_Configuration();
    24. 	
    25. 	//配置GPIO
    26. 	GPIO_Configuration();
    27. 	
    28. 	
    29. 	while(1){
    30. 		GPIO_WriteBit(GPIOB,GPIO_Pin_8,Bit_RESET);//亮
    31. 		delay_ms(200);
    32. 		GPIO_WriteBit(GPIOB,GPIO_Pin_8,Bit_SET);//灭
    33. 		delay_ms(200);
    34. 	}
    35. 	return 0;
    36. }
    37.  
    38. //RCC的配置
    39. void RCC_Configuration(void){
    40. 	
    41. 	//因为起始代码中已经调用SystemInit将主时钟设置为72MHZ
    42. 	//所以我们这里RCC直接使能时钟就可以
    43. 	
    44. 	//使能GPIO端口
    45. 	//通过PB0控制LED1
    46. 	//因为我们使用到的是PB0，所以只使用到GPIOB
    47. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    48. 	//因为systick属于cpu部分的，所以时钟始终打开的，不需要再去打开
    49. 	//所以这里只是打开GPIO的时钟即可
    50. 	
    51. }
    52.  
    53.  
    54. //GPIO初始化
    55. void GPIO_Configuration(void){
    56. 	
    57. 	GPIO_InitTypeDef GPIO_InitStructure;
    58.  
    59. 	
    60. 	//PB0 ---LED1【LED的显示输出】
    61. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    62.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    63.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       //推挽输出
    64.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    65. 	// 默认输出0让LED亮
    66. 	//RESET=0
    67. 	//SET=1
    68.   GPIO_WriteBit(GPIOB, GPIO_Pin_8, Bit_RESET);			
    69.  
    70. }
    71.  
    72. //用systick计数器来帮我们实现us级别的精确延时
    73. //这个函数成立有2个条件：
    74. //1.主频必须是72MHZ
    75. //2.us要小于（2的24次方）=1864 135us=1.8s
    76. void delay_us(unsigned int us){
    77. 	
    78. 	//记录CTRL的countflag位的值
    79. 	unsigned int tmp=0;
    80. 	
    81. 	//思路是先把systick的时钟源设置好，然后给一个正确的ticks
    82. 	//然后使能systick，while循环等待countflag置位则时间到
    83. 	
    84. 	//72MHZ主频，我们使用8分频，72/8=9MHZ systick
    85. 	 SysTick->LOAD=us*9;
    86. 	 SysTick->VAL=0;
    87. 	//我们要先设置上面的LOAD和VAL，在进行使能
    88. 	//时钟源是AHB/8，禁止中断，使能systick
    89. 	 SysTick->CTRL =0x01;
    90. 	
    91. 	//检测什么时候时间结束
    92. 	//查看CTRL中的countflag
    93. 	do{
    94. 		tmp=SysTick->CTRL;
    95. 	}while(!(tmp&(1<<16)));
    96. 	
    97. 	//时间到，关闭定时器
    98. 	SysTick->VAL=0;
    99. 	SysTick->CTRL =0x00;
    100. }
    101.  
    102.  
    103. //不能大于 1864
    104. void delay_ms(unsigned int ms){
    105. 	
    106. 	//记录CTRL的countflag位的值
    107. 	unsigned int tmp=0;
    108. 	
    109. 	//思路是先把systick的时钟源设置好，然后给一个正确的ticks
    110. 	//然后使能systick，while循环等待countflag置位则时间到
    111. 	
    112. 	//72MHZ主频，我们使用8分频，72/8=9MHZ systick
    113. 	 SysTick->LOAD=ms*9000;
    114. 	 SysTick->VAL=0;
    115. 	//我们要先设置上面的LOAD和VAL，在进行使能
    116. 	//时钟源是AHB/8，禁止中断，使能systick
    117. 	 SysTick->CTRL =0x01;
    118. 	
    119. 	//检测什么时候时间结束
    120. 	//查看CTRL中的countflag
    121. 	do{
    122. 		tmp=SysTick->CTRL;
    123. 	}while(!(tmp&(1<<16)));
    124. 	
    125. 	//时间到，关闭定时器
    126. 	SysTick->VAL=0;
    127. 	SysTick->CTRL =0x00;
    128. 	
    129. }
    130.  
    131.  
    132.  
    133.  
    134.  
    135.  
    136.

    2.中断 VS 查询

    查询和中断方式差异：

    查询方式是阻塞式的，中断方式是非阻塞的

  • 相关阅读:
    五. 激光雷达建图和定位方案-算法工具
    探索 GLTF 的世界：3D 内容的未来
    使用canvas绘制时钟
    LLMs之RAG：利用langchain实现RAG应用五大思路步骤—基于langchain使用LLMs(ChatGPT)构建一个问题回答文档的应用程序实战代码
    UML类图画法全程解析
    微信小程序云开发-云函数发起https请求简易封装函数
    Jupyter Notebook 设置黑色背景主题
    【原理分析】SpringBoot的自动装配原理
    大事务导致数据库恢复时间长
    Leetcode—102.二叉树的层序遍历【中等】
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/134069236