STM32-CubeMX学习使用记录5-基础定时器的使用

已于 2024-08-08 11:03:32 修改
阅读量1k 收藏 22
点赞数 7
文章标签： stm32 学习 嵌入式硬件
于 2024-07-24 21:04:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1440255147/article/details/140511271
版权

1.STM32定时器介绍

        1.stm32的定时器分为高级定时器、通用定时器、基础定时器三种类型

        2.基础定时器：TIM6、TIM7

                

                基础定时器的功能包括：

                        触发DAC的同步电路、在更新事件(计数器溢出)时产生中断/DMA请求 

                2.1 基本定时器是连接在APB1总线上的，CK_INT为内部时钟源，CK_INT = CK_PSC

                2.2 基本定时器的时基单元有：

                计数器寄存器(TIMx_CNT) 、预分频寄存器(TIMx_PSC)、  自动重装载寄存器(TIMx_ARR）且都是16位寄存器。

                工作流程：内部时钟CK_INT 经过控制器（主要控制计数器的复位、使能、计数）后名字改为CK_PSC（频率与CK_INT 相同）通过PSC预分频器进行分频，名字改为CK_CNT到达计数器，为计数器提供脉冲开始计数，当计数值到达自动重装载寄存器的数值后，触发一次更新中断，根据工作模式的不同，停止或者不停循环计数触发更新中断。

                2.3 软件可以读写计数器、自动重装载寄存器和预分频寄存器，即使计数器运行时也可以操作

 在计时器运行过程中修改寄存器： 

                    1.预分频器

                    预分频可以以系数介于1至65536之间的任意数值对计数器时钟分频，因为TIMx_PSC控制寄存器具有缓冲，可以在运行过程中改变它 的数值，新的预分频数值将在下一个更新事件时起作用.                  

                    2.自动重装载寄存器：

                    在计数器运行过程中修改自动重装载寄存器的值分为两种情况，这两种情况受到TIMx_CR1 控制寄存器中的ARPE位决定，如果ARPE = 0，则会直接修改自动重装载寄存器。如果ARPE = 1 ，则会将修改后的值存入影子寄存器中，等待更新事件触发后影子寄存器的数据更新到自动重装载寄存器，所以自动重装载寄存器是有预加载的。

   

                         3. 计数器寄存器：

                        计数器寄存器也可以修改其数据，不过一般是在计数器停止或者重新计数时修改。

                2.4  定时器的工作模式有两种，一种是触发一次更新中断后就停止计数。另一种是在触发一次更新中断后，触发控制器重新进行新一轮的计数。两种模式的选择由TIMx_CR1寄存器中的OPM位来控制。

2.STM_HAL库基础定时器函数

定时器初始化的函数（cubemx自动生成好了）：

  Ctrl + F 搜索 HAL_TIM_Base找到有关基础定时器的函数

 上述函数中的结构体有：

  TIM_HandleTypeDef

  TIM_TypeDef

  TIM_Base_InitTypeDef

  HAL_TIM_StateTypeDef

                                        

 1. TIM_HandleTypeDef ：定时器句柄，包含的东西有点多，基础定时器看前两个

2. TIM_TypeDef :   就是有关定时器寄存器的结构体，这样就可以操作寄存器了。

比如：

TIM_TypeDef *TIM6 = (TIM_TypeDef *) TIM6_BASE;  
TIM6->CR1 |= TIM_CR1_CEN; // 启用定时器6

3. TIM_Base_InitTypeDef ：对定时器进行参数配置

 4. HAL_TIM_StateTypeDef    ：返回定时器的状态

简单看一下HAL_TIM_Base_Init函数，可以直接将这段代码复制到ChatGpt中查看讲解。其他的函数一样的做法。

HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
{
  /* Check the TIM handle allocation */
  if (htim == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_TIM_INSTANCE(htim->Instance));
  assert_param(IS_TIM_COUNTER_MODE(htim->Init.CounterMode));
  assert_param(IS_TIM_CLOCKDIVISION_DIV(htim->Init.ClockDivision));
  assert_param(IS_TIM_PERIOD(htim, htim->Init.Period));
  assert_param(IS_TIM_AUTORELOAD_PRELOAD(htim->Init.AutoReloadPreload));

  if (htim->State == HAL_TIM_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    htim->Lock = HAL_UNLOCKED;

#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
    /* Reset interrupt callbacks to legacy weak callbacks */
    TIM_ResetCallback(htim);

    if (htim->Base_MspInitCallback == NULL)
    {
      htim->Base_MspInitCallback = HAL_TIM_Base_MspInit;
    }
    /* Init the low level hardware : GPIO, CLOCK, NVIC */
    htim->Base_MspInitCallback(htim);
#else
    /* Init the low level hardware : GPIO, CLOCK, NVIC */
    HAL_TIM_Base_MspInit(htim);
#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */
  }

  /* Set the TIM state */
  htim->State = HAL_TIM_STATE_BUSY;

  /* Set the Time Base configuration */
  TIM_Base_SetConfig(htim->Instance, &htim->Init);

  /* Initialize the DMA burst operation state */
  htim->DMABurstState = HAL_DMA_BURST_STATE_READY;

  /* Initialize the TIM channels state */
  TIM_CHANNEL_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
  TIM_CHANNEL_N_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);

  /* Initialize the TIM state*/
  htim->State = HAL_TIM_STATE_READY;

  return HAL_OK;
}

可以知道 USE_HAL_TIM_REGISTER_CALLBACKS ！= 1 所以调用HAL_TIM_Base_MspInit(htim) 函数来配置时钟、NVIC优先级、中断开启，也就是CubeMX生成的函数。然后TIM_Base_SetConfig(htim->Instance, &htim->Init)这个函数会将配置好的参数赋值给对应的寄存器。HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)这个函数会在main中的MX_TIM6_Init()中调用，MX_TIM6_Init()这个函数也是CubeMX自动生成的，所以初始化只要知道流程就好了。初始化流程和标准库是一样的。

打开main中的MX_TIM6_Init()函数：这里我是使用的168Mhz的STM32F407VET6单片机，主要是记录学习过程，这段代码是cubemx生成的。

/* TIM6 init function */
void MX_TIM6_Init(void)
{

  /* USER CODE BEGIN TIM6_Init 0 */

  /* USER CODE END TIM6_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM6_Init 1 */

  /* USER CODE END TIM6_Init 1 */
  htim6.Instance = TIM6;
  htim6.Init.Prescaler = 83;
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.Period = 999;
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM6_Init 2 */

  /* USER CODE END TIM6_Init 2 */

}

   可以看到在这个函数中调用了  HAL_TIM_Base_Init 函数来进行初始化基础定时器。   

打开生成的HAL_TIM_Base_MspInit(htim)函数：

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM6)
  {
  /* USER CODE BEGIN TIM6_MspInit 0 */

  /* USER CODE END TIM6_MspInit 0 */
    /* TIM6 clock enable */
    __HAL_RCC_TIM6_CLK_ENABLE();

    /* TIM6 interrupt Init */
    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
  /* USER CODE BEGIN TIM6_MspInit 1 */

  /* USER CODE END TIM6_MspInit 1 */
  }
}

可以看到配置了定时器的时钟以及中断优先级和打开中断。 

初始化配置好后，再就是看中断的开启与中断回调流程：      

使用cubemx生成的代码中，定时器中断放到了it . c文件中。打开stm32f4xx_it.c文件。可以看到

/**
  * @brief This function handles TIM6 global interrupt, DAC1 and DAC2 underrun error interrupts.
  */
void TIM6_DAC_IRQHandler(void)
{
  /* USER CODE BEGIN TIM6_DAC_IRQn 0 */

  /* USER CODE END TIM6_DAC_IRQn 0 */
  HAL_TIM_IRQHandler(&htim6);
  /* USER CODE BEGIN TIM6_DAC_IRQn 1 */

  /* USER CODE END TIM6_DAC_IRQn 1 */
}

打开HAL_TIM_IRQHandler(&htim6)：

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_FLAG(htim, TIM_FLAG_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_FLAG(htim, TIM_FLAG_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_FLAG(htim, TIM_FLAG_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_FLAG(htim, TIM_FLAG_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_FLAG(htim, TIM_FLAG_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_FLAG(htim, TIM_FLAG_BREAK);
#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
      htim->BreakCallback(htim);
#else
      HAL_TIMEx_BreakCallback(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_FLAG(htim, TIM_FLAG_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_FLAG(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 Update event */
  if ((itflag & (TIM_FLAG_UPDATE)) == (TIM_FLAG_UPDATE))
  {
    if ((itsource & (TIM_IT_UPDATE)) == (TIM_IT_UPDATE))
    {
      __HAL_TIM_CLEAR_FLAG(htim, TIM_FLAG_UPDATE);
#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
      htim->PeriodElapsedCallback(htim);
#else
      HAL_TIM_PeriodElapsedCallback(htim);
#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */
    }
  }

和外部中断一样都是先检查再清楚标志位，然后进入一个函数HAL_TIM_PeriodElapsedCallback(htim);

打开此函数：

__weak void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(htim);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_TIM_PeriodElapsedCallback could be implemented in the user file
   */
}

发现是一个弱函数，所以和外部中断一样，进行复写。

我选择在tim.c中进行复写：

/* USER CODE BEGIN 1 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  static uint16_t num;
  if (htim->Instance == TIM6)
  {
    num++;
    if (num == 500)
    {
      HAL_GPIO_TogglePin(LED_USER_GPIO_Port, LED_USER_Pin); // 1s翻转一次电平
      num = 0;
    }
  }
}
/* USER CODE END 1 */

在main中加入中断启动定时器的函数：

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim6);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

这样就可以实现1ms进入一次更新中断，500ms翻转一次电平。

一般基础定时器用来作为中断使用。

除此之外，如果想要改变正在运行时定时器的配置，则可以使用宏定义函数来修改：

在stm32f4xx_hal_tim.h中有关于定时器的宏定义函数：

1. __HAL_TIM_ENABLE(__HANDLE__)  启动定时器

2.__HAL_TIM_DISABLE(__HANDLE__) 关闭定时器

3.__HAL_TIM_ENABLE_IT(__HANDLE__, __INTERRUPT__) 使能定时器中断

4.__HAL_TIM_DISABLE_IT(__HANDLE__, __INTERRUPT__) 失能定时器中断

5. __HAL_TIM_ENABLE_DMA(__HANDLE__, __DMA__) 使能更新触发DMA

6.__HAL_TIM_DISABLE_DMA(__HANDLE__, __DMA__) 失能更新触发DMA

7. __HAL_TIM_GET_FLAG(__HANDLE__, __FLAG__)获取当前定时器的中断状态

8. __HAL_TIM_SET_PRESCALER(__HANDLE__, __PRESC__) 设置定时器的预分频值

9. __HAL_TIM_SET_COUNTER(__HANDLE__, __COUNTER__) 设置计数器的计数值 

10. __HAL_TIM_SET_COUNTER(__HANDLE__, __COUNTER__) 获取当前计数器的计数值

11. __HAL_TIM_SET_AUTORELOAD(__HANDLE__, __AUTORELOAD__)  设置重装载寄存器的值

12. __HAL_TIM_GET_AUTORELOAD(__HANDLE__) 获取重装载寄存器的值

除了以上宏定义函数外还有很多。 

3.STM_HAL库 基础定时器cubemx 的配置

    

总结：

在配置基础定时器后，主要做的就两件事：1.在main.c中开启定时器（不要忘）

                                                                      2.复写回调函数。 

吼吼吼欧亚
关注
  • 7
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
stm32-ps2-cubemx
08-08
STM32 CubeMX是ST提供的一个配置工具，用于初始化STM32微控制器的各种外设。在本项目中，我们需要通过CubeMX配置GPIO端口和定时器，以实现PS/2接口的功能。首先，选择相应的STM32型号，然后配置GPIO引脚为输入/输出...
STM32CubeMX学习笔记十一《定时器输入脉冲捕获》源码
04-14
在本“STM32CubeMX学习笔记十一《定时器输入脉冲捕获》”中，我们将深入探讨定时器的输入脉冲捕获功能及其源码实现。 定时器在嵌入式系统中扮演着重要角色，它可以用于执行各种任务，如计数、定时、中断触发等。...
【STM32基础 CubeMX】定时器的使用_cubemx 定时器
2401_83816838的博客
05-13 1515
在嵌入式系统开发中，精确地控制时间和时序是至关重要的。STM32微控制器提供了强大的定时器功能，使开发者能够轻松地实现各种时间相关任务。本文将介绍STM32定时器的基础知识和使用方法，帮助初学者了解如何在STM32上利用定时器实现定时任务、生成脉冲信号、进行计时等操作。无论您是想要构建一个简单的LED闪烁应用还是一个复杂的实时控制系统，理解定时器的使用都是至关重要的。自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
【工具使用】STM32CubeMX-基础定时器配置
知识噬元兽的博客
08-07 5716
定时器，顾名思义，就是定时的功能，定时器在单片机中算是除GPIO外最基本的外设。在ST中，定时器分为几种，基础定时器，通用定时器，高级定时器和低功耗定时器。本文重点在于基础定时器的配置，其他类型的定时器在其他篇章中详细说明。
【嵌入式学习-STM32CubeMX篇】定时器的配置和使用
zengchenAAA的博客
10-25 3448
定时器中断处理：通过使能TIM1的更新中断，您可以编写和配置TIM1的中断服务程序（ISR）。需要注意的是，在勾选"Enabled"选项后，还需要正确配置中断优先级和编写相应的中断服务程序来处理TIM1的更新中断。通过定时器的硬件定时功能和中断机制，可以避免在软件中轮询定时器状态，从而降低了处理器的负载并提高了系统的响应性。更新中断是TIM1定时器溢出时触发的中断事件，它允许您在每个定时周期结束时执行相应的中断服务程序（ISR）。通过调整预分频系数和计数周期的值，您可以设置定时器的定时时间。
STM32-结合Cubemx使用定时器
weixin_42209739的博客
04-25 1085
基本定时器的核心是时间基准，这里以基本定时器为介绍对象。
使用STM32CubeMX进行STM32F4的定时器配置
uyoev123abc的博客
05-08 461
在 TIM3初始化代码后需要增加定时器使能函数；开启内部16MHz晶振。开启最高100MHz。外部使用8MHz晶振。
stm32cubemx stm32f429 UCOS-III工程
01-20
在这个"stm32cubemx stm32f429 UCOS-III工程"中，开发者已经使用STM32CubMX Version 5.5.0创建了一个基于STM32F429微控制器的项目，并且移植了实时操作系统UCOS-III。 STM32F429是一款高性能的Arm Cortex-M4内核微...
STM32CubeMX系列|DHT11温湿度传感器
10-30
STM32CubeMX是一款强大的STM32微控制器配置工具，由意法半导体（STMicroelectronics）开发，用于简化和加速STM32微控制器的初始化设置。在这个实例中，我们关注的是如何利用STM32CubeMX配置STM32F103ZET6单片机来与...
电子-STM32CubeMX生成工程.zip
09-05
使用STM32CubeMX生成的工程，开发者可以快速进入实际应用程序的开发，而无需花费大量时间在基础设置上。这对于缩短项目周期和提高开发效率至关重要。在实际应用中，开发者可以根据需求调整配置，或者添加自己的源...
STM32CubeMX——定时器之定时功能
lcp0633的博客
12-13 2万+
功能实现： 采用定时器实现LED灯的闪烁，周期为1S 准备工作： 1、STM32开发板（我的是STM32F103VET6） 2、STM32CubeMx软件、 IDE：Keil软件 3、按键管脚 ： PA0 PC13 4、LED管脚： PB0 PB1 PB5 定时器简介： SMT32F1系列共有8个定时器： 基本定时器（TIM6、TIM7） 通用定时器（TIM2、TIM3、TIM4、TIM5） 高级定时器（TIM1、TIM8） SMT32F4系列共有15个定时器： ...
cubeMX配置stm32f4，can控制3508以一定速度转动固定时间
qiuqc_的博客
10-12 1944
cubeMX配置stm32f4，can控制3508以一定速度转动固定时间
【STM32】HAL库 STM32CubeMX教程八---定时器输入捕获
热门推荐
Z小旋
08-21 9万+
前言： 本系列教程将外设原理，HAL库与STM32CubeMX结合在一起讲解，使您可以更快速的学会各个模块的使用 所用工具： 1、芯片：STM32F407ZET6/STM32F103ZET6 2、STM32CubeMx软件 3、IDE： MDK-Keil软件 4、STM32F1xx/STM32F4xxHAL库 5 知识概括： 通过本篇博客您将学到： SMT32定时器输...
STM32CubeMx之定时器
夏中伟的博客
11-16 8287
参考网页：http://www.waveshare.net/study/article-642-1.html一、配置点击.ioc重新配置一个工程 开启定时器TIM3,选择内部时钟。 要确定定时的时间我们必须先确定CK_PSC的频率，TIM3配置中选择内部时钟作为时钟源，查看数据手册或者查看代码可以知道TIM3是挂接到APB1时钟线上。 计数器寄存器 (TIMx_CNT)存储的是当前的计数值。预
【STM32F4】HAL库 CubeMX(八)--------定时器输出PWM波实验
qq_47877230的博客
10-09 4020
文章目录前言一、PWM波是什么？二、PWM输出实验1.功能配置2.时钟配置3.生成代码总结 前言 在学习了定时器的中断，接下来我们继续配置定时器的另外一个重要功能——输出PWM波 一、PWM波是什么？ 脉冲宽度调制(PWM)，是英文“Pulse Width Modulation”的缩写，简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术。简单一点，就是对脉冲宽度的控制。 二、PWM输出实验 1.功能配置 1、根据库函数本实验是以定时器14的CH1为例，在功能选择区选择TIM1
【STM32F4】HAL库 CubeMX(七)--------定时器中断实验
qq_47877230的博客
10-08 5464
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
STM32CubeMx配置定时器
野生猿-群号1025127672
12-01 1万+
定时器的用法很多： 1、作为时基。也即仅读取定频自增的TIMx->CNT 2、定时中断 3、计数 4、捕获 5、输出PWM（也叫：比较输出） 6、等等 以编程中最常见的定时中断为例 首先配置时钟树： 定时器的时钟来自于内部的PLL分频->AHB->APB1或2 而且由上图可见，APBx时钟进入定时器之前频率会被x2 定时器溢出时间的计算： T=((period+1)*(psc+1))/(TIM_CLK_Mhz/ TIM_ClockDivision) u.
STM32cubeMX 基于stm32的定时器实现定时1秒LED闪烁。
huluwadeyeye的博客
09-11 3万+
软件： STM32CubeMX V4.25.0   keil_u5 固件库版本： STM32Cube FW_F1 V1.6.1 硬件： OneNet 麒麟座V1.4 在STM32CubeMX中新建项目，选择正确的MCU型号   首先设置RCC和SYS，如下图   启用TIM1，选择内部时钟源（Internal Clock）。   然后根据板子实际情况设置时钟（...
stm32cubemx配置使用dht11
最新发布
06-17
STM32CubeMX是一个图形化工具，用于快速配置和生成STM32微控制器的项目设置。配置DHT11传感器（一种温度和湿度传感器）通常涉及以下步骤： 1. **添加库支持**: 在STM32CubMX中，首先需要添加`HAL_Driver`库，因为DHT11驱动通常集成在这个库中。 2. **选择设备和 Pinout**: 选择你的STM32系列和相应的外设模板，然后配置DHT11的引脚连接。DHT11通常使用数字I/O引脚，如PA0或PB7，以及一个中断引脚。 3. **创建实例**: 在"HAL Drivers" > "Sensor"部分，添加一个新的DHT11实例，并指定相应的引脚配置。 4. **配置初始化参数**: 配置传感器的工作模式（单次测量或多周期测量）、数据解析方式等。确保设置正确的超时时间和温度/湿度单位。 5. **添加测量任务**: 创建一个定时器任务，定期调用DHT11的数据读取函数，以便获取实时的温度和湿度值。 6. **处理中断**: 如果配置了中断，需要在中断服务程序(ISR)中处理DHT11的数据准备好信号，更新数据并可能清除中断。 7. **数据处理和显示**: 从DHT11获取的数值需要在适当的地方进行处理，如存储到变量中或者通过LCD、LED灯或者其他显示组件显示。 8. **错误处理**: DHT11可能返回错误代码，需要处理这些错误情况，比如重试读取、记录日志等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值