[STM32WBA]【STM32WBA52CG测评】-4- 定时器模块TIM例程分析

已于 2023-08-13 17:35:36 修改
阅读量451 收藏
点赞数
分类专栏： 嵌入式基础知识 文章标签： android 嵌入式硬件 单片机
于 2023-08-12 12:26:24 首次发布
原文链接：https://bbs.21ic.com/icview-3318482-1-1.html
版权

ST的官方库有非常丰富的外设使用例程，本文体验的就是：STM32Cube_FW_WBA_V1.1.0\Projects\NUCLEO-WBA52CG\Examples\TIM\TIM_TimeBase
该例程配置使用TIM模块产生一个1s的中断，然后再中断服务函数中翻转LED。

初始化外设，Flash和Systick:
复制
HAL_Init();


SystemClock_Config() 函数用于配置STM32WBA52CGUx 设备系统时钟为100 MHz
复制
  /* Configure the system clock */

  SystemClock_Config();

根据官方ReadMe，TIM模块的时钟频率，TIM2模块的计数器时钟频率，以及周期都有相应的公式：


In this example TIM2 input clock (TIM2CLK)  is set to APB1 clock (PCLK1),since APB1 prescaler is equal to 1.  TIM2CLK = PCLK1  PCLK1 = HCLK  => TIM2CLK = HCLK = SystemCoreClockTo get TIM2 counter clock at 10 KHz, the Prescaler is computed as following:Prescaler = (TIM2CLK / TIM2 counter clock) - 1Prescaler = (SystemCoreClock /10 KHz) - 1
SystemCoreClock is set to 100 MHz for STM32WBAxx Devices.
The TIM2 ARR register value is equal to 10000 - 1
Update rate = TIM2 counter clock / (Period + 1) = 1 Hz
So the TIM2 generates an interrupt each 1 s
When the counter value reaches the auto-reload register value, the TIM update interrupt is generated and, in the handler routine, pin PB.4 (connected to LD1 on board NUCLEO-WBA52CG) is toggled. So led blinks at the following frequency: 0.5Hz.
In case of error, LD3 is turned ON.在main.h中，有相应的参数定义：
 

/* Compute the prescaler value to have TIMx counter clock equal to 10000 Hz */

#define PRESCALER_VALUE (uint32_t)(((SystemCoreClock) / (10000)) - 1)

  /* Initialize TIMx peripheral as follows:

       + Period = 10000 - 1

       + Prescaler = (SystemCoreClock/10000) - 1

       + ClockDivision = 0

       + Counter direction = Up

  */

#define PERIOD_VALUE (10000 - 1);


在main.c中，调用如下函数进行TIM模块初始化：
 

/**

  * [url=home.php?mod=space&uid=247401]@brief[/url] TIM2 Initialization Function

  * @param None

  * @retval None

  */

static void MX_TIM2_Init(void)

{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */

  htim2.Instance = TIM2;

  htim2.Init.Prescaler = PRESCALER_VALUE;

  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

  htim2.Init.Period = PERIOD_VALUE;

  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

  {

    Error_Handler();

  }

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)

  {

    Error_Handler();

  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

  {

    Error_Handler();

  }

  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}

如下定义了TIM2模块的中断服务子程序：
 

/**

  * [url=home.php?mod=space&uid=247401]@brief[/url] This function handles TIM2 global interrupt.

  */

void TIM2_IRQHandler(void)

{

  /* USER CODE BEGIN TIM2_IRQn 0 */

  /* USER CODE END TIM2_IRQn 0 */

  HAL_TIM_IRQHandler(&htim2);

  /* USER CODE BEGIN TIM2_IRQn 1 */

  /* USER CODE END TIM2_IRQn 1 */

}

接着调用HAL库中的中断服务子程序：
 

void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim)

{

  uint32_t itsource = htim->Instance->DIER;

  uint32_t itflag   = htim->Instance->SR;

  /* Capture compare 1 event */

  if ((itflag & (TIM_FLAG_CC1)) == (TIM_FLAG_CC1))

  {

    if ((itsource & (TIM_IT_CC1)) == (TIM_IT_CC1))

    {

      {

        __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC1);

        htim->Channel = HAL_TIM_ACTIVE_CHANNEL_1;

        /* Input capture event */

        if ((htim->Instance->CCMR1 & TIM_CCMR1_CC1S) != 0x00U)

        {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

          htim->IC_CaptureCallback(htim);

#else

          HAL_TIM_IC_CaptureCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

        }

        /* Output compare event */

        else

        {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

          htim->OC_DelayElapsedCallback(htim);

          htim->PWM_PulseFinishedCallback(htim);

#else

          HAL_TIM_OC_DelayElapsedCallback(htim);

          HAL_TIM_PWM_PulseFinishedCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

        }

        htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;

      }

    }

  }

  /* Capture compare 2 event */

  if ((itflag & (TIM_FLAG_CC2)) == (TIM_FLAG_CC2))

  {

    if ((itsource & (TIM_IT_CC2)) == (TIM_IT_CC2))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC2);

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_2;

      /* Input capture event */

      if ((htim->Instance->CCMR1 & TIM_CCMR1_CC2S) != 0x00U)

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->IC_CaptureCallback(htim);

#else

        HAL_TIM_IC_CaptureCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      /* Output compare event */

      else

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->OC_DelayElapsedCallback(htim);

        htim->PWM_PulseFinishedCallback(htim);

#else

        HAL_TIM_OC_DelayElapsedCallback(htim);

        HAL_TIM_PWM_PulseFinishedCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;

    }

  }

  /* Capture compare 3 event */

  if ((itflag & (TIM_FLAG_CC3)) == (TIM_FLAG_CC3))

  {

    if ((itsource & (TIM_IT_CC3)) == (TIM_IT_CC3))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC3);

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_3;

      /* Input capture event */

      if ((htim->Instance->CCMR2 & TIM_CCMR2_CC3S) != 0x00U)

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->IC_CaptureCallback(htim);

#else

        HAL_TIM_IC_CaptureCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      /* Output compare event */

      else

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->OC_DelayElapsedCallback(htim);

        htim->PWM_PulseFinishedCallback(htim);

#else

        HAL_TIM_OC_DelayElapsedCallback(htim);

        HAL_TIM_PWM_PulseFinishedCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;

    }

  }

  /* Capture compare 4 event */

  if ((itflag & (TIM_FLAG_CC4)) == (TIM_FLAG_CC4))

  {

    if ((itsource & (TIM_IT_CC4)) == (TIM_IT_CC4))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_CC4);

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_4;

      /* Input capture event */

      if ((htim->Instance->CCMR2 & TIM_CCMR2_CC4S) != 0x00U)

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->IC_CaptureCallback(htim);

#else

        HAL_TIM_IC_CaptureCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      /* Output compare event */

      else

      {

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

        htim->OC_DelayElapsedCallback(htim);

        htim->PWM_PulseFinishedCallback(htim);

#else

        HAL_TIM_OC_DelayElapsedCallback(htim);

        HAL_TIM_PWM_PulseFinishedCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

      }

      htim->Channel = HAL_TIM_ACTIVE_CHANNEL_CLEARED;

    }

  }

  /* TIM Update event */

  if ((itflag & (TIM_FLAG_UPDATE)) == (TIM_FLAG_UPDATE))

  {

    if ((itsource & (TIM_IT_UPDATE)) == (TIM_IT_UPDATE))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->PeriodElapsedCallback(htim);

#else

      HAL_TIM_PeriodElapsedCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Break input event */

  if ((itflag & (TIM_FLAG_BREAK)) == (TIM_FLAG_BREAK))

  {

    if ((itsource & (TIM_IT_BREAK)) == (TIM_IT_BREAK))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_BREAK);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->BreakCallback(htim);

#else

      HAL_TIMEx_BreakCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Break2 input event */

  if ((itflag & (TIM_FLAG_BREAK2)) == (TIM_FLAG_BREAK2))

  {

    if ((itsource & (TIM_IT_BREAK)) == (TIM_IT_BREAK))

    {

      __HAL_TIM_CLEAR_FLAG(htim, TIM_FLAG_BREAK2);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->Break2Callback(htim);

#else

      HAL_TIMEx_Break2Callback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Trigger detection event */

  if ((itflag & (TIM_FLAG_TRIGGER)) == (TIM_FLAG_TRIGGER))

  {

    if ((itsource & (TIM_IT_TRIGGER)) == (TIM_IT_TRIGGER))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_IT_TRIGGER);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->TriggerCallback(htim);

#else

      HAL_TIM_TriggerCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM commutation event */

  if ((itflag & (TIM_FLAG_COM)) == (TIM_FLAG_COM))

  {

    if ((itsource & (TIM_IT_COM)) == (TIM_IT_COM))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_COM);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->CommutationCallback(htim);

#else

      HAL_TIMEx_CommutCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Encoder index event */

  if ((itflag & (TIM_FLAG_IDX)) == (TIM_FLAG_IDX))

  {

    if ((itsource & (TIM_IT_IDX)) == (TIM_IT_IDX))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_IDX);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->EncoderIndexCallback(htim);

#else

      HAL_TIMEx_EncoderIndexCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Direction change event */

  if ((itflag & (TIM_FLAG_DIR)) == (TIM_FLAG_DIR))

  {

    if ((itsource & (TIM_IT_DIR)) == (TIM_IT_DIR))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_DIR);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->DirectionChangeCallback(htim);

#else

      HAL_TIMEx_DirectionChangeCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Index error event */

  if ((itflag & (TIM_FLAG_IERR)) == (TIM_FLAG_IERR))

  {

    if ((itsource & (TIM_IT_IERR)) == (TIM_IT_IERR))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_IERR);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->IndexErrorCallback(htim);

#else

      HAL_TIMEx_IndexErrorCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

  /* TIM Transition error event */

  if ((itflag & (TIM_FLAG_TERR)) == (TIM_FLAG_TERR))

  {

    if ((itsource & (TIM_IT_TERR)) == (TIM_IT_TERR))

    {

      __HAL_TIM_CLEAR_IT(htim, TIM_FLAG_TERR);

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)

      htim->TransitionErrorCallback(htim);

#else

      HAL_TIMEx_TransitionErrorCallback(htim);

#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */

    }

  }

}

注意其中有个函数调用：

HAL_TIM_PeriodElapsedCallback(htim);

这个回调函数的定义如下：

/**

  * [url=home.php?mod=space&uid=247401]@brief[/url]  Period elapsed callback in non blocking mode

  * @param  htim : TIM handle

  * @retval None

  */

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

        BSP_LED_Toggle(LD1);

}


烧录后，可以看到LD1以1s频率闪烁。

---------------------
作者：南来之风
链接：https://bbs.21ic.com/icview-3318482-1-1.html
来源：21ic.com
此文章已获得原创/原创奖标签，著作权归21ic所有，任何人未经允许禁止转载。
 

21ic电子工程师
关注
专栏目录
STM32H750运行linux,新出的STM32F750成功运行Linux
weixin_29079743的博客
04-30 2308
U-Boot 2010.03 (Nov 26 2018 - 21:30:21)CPU: STM32F7 (Cortex-M7)Freqs: SYSCLK=216MHz,HCLK=216MHz,PCLK1=54MHz,PCLK2=108MHzBoard: STM32F750 Rev 1.0, www.emcraft.comDRAM:64 MBIn: serialOut: seria...
STM32F750成功运行Linux
htjgdw的专栏
04-01 6527
论坛发帖太分散了，在此记录一下我开发STM32F750 uClinux开发板的进程，这是第一篇，发表于2018年12月。 前段时间ST推出了Value Line的STM32F750和H750两个系列，看了一下选型表，F750有LQFP144封装，正好适合我的STM32 linux板子。 于是，双十一买了几片。同时，我对我的linux板做了小幅改版：将SPI Flash容量扩大到32MB...
【STM32】(3) 串口通信实验
qq_44744164的博客
07-13 2694
串口通信实验 ( 1 )定义函数uart_init用来调用HAL_UART_Init初始化串口参数配置： UART_HandleTypeDef UART1_Handler；//UART句柄 void uart_init(u32 bound) { //UART 初始化设置 UART1_Handler.Instance=USART1; //USART1 UART1_Handle...
【记录】STM32串口测试
風韻無聲
06-25 1926
测试环境 正点原子战舰STM32F767 STM32串口 中断收发 为了验证硬件的正确性，最简单的方法是接收串口工具的数据，然后将接收到的数据发送 STM32串口-接收定长数据 uint8_t g_u8SndBuf[UART_LEN] = "USART1 Send test\n\r"; uint8_t g_u8RcvBuf[UART_LEN] = {0}; void MX_USART1_UART_Init(void) { huart1.Instance = USART1; huart1
STM32-CubeMX学习使用记录5-基础定时器的使用
q1440255147的博客
07-24 1096
在计数器运行过程中修改自动重装载寄存器的值分为两种情况，这两种情况受到TIMx_CR1 控制寄存器中的ARPE位决定，如果ARPE = 0，则会直接修改自动重装载寄存器。如果ARPE = 1 ，则会将修改后的值存入影子寄存器中，等待更新事件触发后影子寄存器的数据更新到自动重装载寄存器，所以自动重装载寄存器是有预加载的。到达计数器，为计数器提供脉冲开始计数，当计数值到达自动重装载寄存器的数值后，触发一次更新中断，根据工作模式的不同，停止或者不停循环计数触发更新中断。初始化流程和标准库是一样的。
STM32 库函数学习 TIM篇
s2014201506的博客
06-12 9652
1、HAL_StatusTypeDef HAL_TIM_Base_Init (TIM_HandleTypeDef * htim) 这个函数属于定时器使用基本的定时功能的初始化函数，它的输入参数为自定义的定时器指针。 TIM_HandleTypeDef TIM3_Handler; //定时器句柄 void TIM3_Init(u16 arr,u16 psc) { TIM3_Handler.Instance=TIM3; //通用定时
关于STM32的中断一些感想
qq_46398176的博客
10-26 210
以窗口看门狗为例 STM32的中断配置流程通常为 先创建句柄 WWDG_HandleTypeDef WWDG_Handler; WWDG_Handler通常有几个变量，其中包括instance成员表示配置的对象 WWDG_Hadler.init成员也是一个结构体变量，其成员包括需要设置的参数，以看门狗为例 包含 WWDG_Handler.init.Prescaler 设置分频系数 WWDG_Handler.init.Window 设置窗口值 WWDG_Handler.init.Counte
stm32第五次学习
weixin_43818158的博客
03-05 615
STM32的常见的定时器资源 系统嘀嗒定时器SysTick 这是一个集成在Cortex M3内核当中的定时器，它并不属于芯片厂商的外设，也就是说使用ARM内核的不同厂商，都拥有基本结构相同的系统定时器。主要目的是给RTOS提供时钟节拍做时间基准。 看门狗定时器WatchDog 实时时钟RTC 基本定时器:TIM6、TIM7 通用定时器:TIM2、TIM3、TIM4、TIM5 在基本定时器的基础上，实现输出比较、输入捕获、PWM生成、单脉冲模式输出等功能。这类定时器最具代表性，使用也最广泛。
STM32 keil pack SMT32L5，U0，U5，WBA，WB，WL
最新发布
08-17
STM32 keil pack SMT32L5，U0，U5，WBA，WB，WL
STM32系列单片机选型手册
09-21
- STM32WBA系列和STM32WL系列：同样提供无线连接功能，适用于不同无线通讯标准。 在选择STM32单片机时，需要考虑以下关键参数： - 主频：决定MCU的运算速度，主频越高，处理能力越强。 - FLASH和RAM大小：存储程序...
stm32f746 linux,STM32F746开发板启动Linux4.2也成功了
weixin_28993705的博客
05-14 387
CPU: STM32F7 (Cortex-M7)Freqs: SYSCLK=192MHz,HCLK=192MHz,PCLK1=48MHz,PCLK2=96MHzBoard: STM32F746 Discovery Rev 1.A, efusion.taobao.comDRAM:64 MBIn: serialOut: serialErr: serialNet: miiphy...
（十）STM32学习笔记——PWM输出如何输出指定脉冲
lhyriver的博客
01-04 1177
在上一篇文章中已经实现了启动电机，但是启动之后是一直运行，不会停止。这篇文章将介绍，如何输出指定的脉冲数。输出指定的脉冲数涉及到几个相关的函数。UART串口通讯数据接收回调函数，UART接收到数据后会调用该函数。本例将在该函数中接受串口发送的数据，然后解析出当中脉冲数。一次脉冲结束后的回调函数，当发送完一次脉冲后会调用该函数。PWM启动函数PWM停止函数。
【嵌入式学习-STM32CubeMX篇】定时器的配置和使用
zengchenAAA的博客
10-25 3637
定时器中断处理：通过使能TIM1的更新中断，您可以编写和配置TIM1的中断服务程序（ISR）。需要注意的是，在勾选"Enabled"选项后，还需要正确配置中断优先级和编写相应的中断服务程序来处理TIM1的更新中断。通过定时器的硬件定时功能和中断机制，可以避免在软件中轮询定时器状态，从而降低了处理器的负载并提高了系统的响应性。更新中断是TIM1定时器溢出时触发的中断事件，它允许您在每个定时周期结束时执行相应的中断服务程序（ISR）。通过调整预分频系数和计数周期的值，您可以设置定时器的定时时间。
stm32定时器级联提供64位时间基准[HAL库]
kevin1499的博客
10-23 2190
stm32f407单片机定时器最多只有32位，为了实现64位的高精度时间基准，这里使用stm32的定时器同步功能实现。将TIM2和TIM5级联起来，TIM2作为us定时器，TIM5作为s定时器，实现64位的精确到us的时间基准。
【STM32HAL库】常用功能备忘
m0_57585228的博客
06-14 5998
自用HAL库常用功能备忘，不定时更新（用到哪写哪）
【STM32】知识补充 深入探讨预分频器
我是小白呀的博客
05-01 5311
预分频器 (Prescaler) 是数字系统中用于降低时钟频率的关键组件. 本文小白我将介绍预分频器的工作原理, 应用场景和实现方法, 来帮助大家更好的理解和应用预分频器的技术.
一个奇怪的SystemClock_Config问题解决方法
mhx123456789的博客
10-21 2720
一个奇怪的SystemClock_Config问题解决方法
STM32L0xxHal库SystemClock_Config函数
热门推荐
zzYuanWai的博客
07-20 1万+
STM32L051c8t6 使用内部HSI时钟初始化。   RCC_ClkInitTypeDef RCC_ClkInitStruct;   //结构体初始化 RCC_OscInitTypeDef RCC_OscInitStruct; //结构体初始化   __HAL_RCC_PWR_CLK_ENABLE();  //使能电源控制时钟      __HAL_PWR_VOLTAGESCA...
STM32H743+CubeMX-定时器TIM输出PWM（PWM Generation模式）+ 中断
wallace89的博客
07-08 4152
文章目录一、前言二、CubeMX2.1、Mode and Parameter Settings2.2、NVIC Settings2.3、生成代码三、代码3.1、tim.c3.2、main.c四、DEBUG4.1、OC中断回调函数的验证4.2、定时器溢出中断五、细节补充 一、前言 STM32H743+CubeMX-定时器TIM输出PWM（PWM Generation模式） 上一次完成了使用定时器TIM的PWM Generation模式输出PWM波，没有产生中断。在实际项目上，有时候需要计算一共发了多少个PW
STM32系列单片机全面选型指南：性能、功耗与功能比较
STM32系列单片机选型手册是一份全面介绍STM32家族产品的文档，涵盖了不同性能等级的32位微控制器（MCU）和微处理器（MPU），以及专为无线应用设计的无线微控制器（Wireless）。该手册根据核心性能和特性将其产品划分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值