1. Toy模板网首页
  2. > Toy博客

【STM32】HAL库学习 3—hal_time

9月前 作者：咕咕与瓜 分类：Toy博客 阅读(18) 违法举报

这篇具有很好参考价值的文章主要介绍了【STM32】HAL库学习 3—hal_time。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

1 TIM定时器基础函数 

        HAL_TIM_Base_Start_IT

        HAL_TIM_PeriodElapsedCallback

        HAL_TIM_IRQHandler

         HAL_TIM_Base_MspInit

        HAL_TIM_Base_MspDeInit 

 2 驱动步进电机

        __HAL_TIM_SET_COMPARE

        HAL_TIM_PWM_Start

        __HAL_TIM_SET_AUTORELOAD 

推荐阅读：4.基于STM32CubeMX使用TIM定时器_tao_sc的博客-CSDN博客_cubemx tim设置

1 TIM定时器基础函数 

        HAL_TIM_Base_Start_IT

        开启定时器中断功能。

/**
  *@brief 在中断模式下启动TIM Base生成。
  * @param htim TIM Base handle
  * @retval HAL状态
  */

HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim)
{
  uint32_t tmpsmcr;

  /* Check the parameters */
  assert_param(IS_TIM_INSTANCE(htim->Instance));

  /* Check the TIM state */
  if (htim->State != HAL_TIM_STATE_READY)
  {
    return HAL_ERROR;
  }

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

  /* Enable the TIM Update interrupt */
  __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);

  /* Enable the Peripheral, except in trigger mode where enable is automatically done with trigger */
  if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
  {
    tmpsmcr = htim->Instance->SMCR & TIM_SMCR_SMS;
    if (!IS_TIM_SLAVEMODE_TRIGGER_ENABLED(tmpsmcr))
    {
      __HAL_TIM_ENABLE(htim);
    }
  }
  else
  {
    __HAL_TIM_ENABLE(htim);
  }

  /* Return function status */
  return HAL_OK;
}

eg:  HAL_TIM_Base_Start_IT(&htim1);

        HAL_TIM_PeriodElapsedCallback

/**
  * @brief 在非阻塞模式下的周期过期回调
  * @param htim TIM handle
  * @retval 无
  */

__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
   */
}

        HAL_TIM_IRQHandler

/**
  *@brief 这个函数处理TIM中断请求。
  * @param htim TIM handle
  * @retval 无
  */

void HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim)
{
  /* Capture compare 1 event */
  if (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC1) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC1) != RESET)
    {
      {
        __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 (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC2) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC2) != RESET)
    {
      __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 (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC3) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC3) != RESET)
    {
      __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 (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_CC4) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_CC4) != RESET)
    {
      __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 (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_UPDATE) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_UPDATE) != RESET)
    {
      __HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
      htim->PeriodElapsedCallback(htim);
#else
      HAL_TIM_PeriodElapsedCallback(htim);               //HAL_TIM_PeriodElapsedCallback
#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */
    }
  }
  /* TIM Break input event */
  if (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_BREAK) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_BREAK) != RESET)
    {
      __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 Trigger detection event */
  if (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_TRIGGER) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_TRIGGER) != RESET)
    {
      __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 (__HAL_TIM_GET_FLAG(htim, TIM_FLAG_COM) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(htim, TIM_IT_COM) != RESET)
    {
      __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 */
    }
  }
}

         HAL_TIM_Base_MspInit

 /**
  * @brief  对TIM Base MSP进行初始化.
  * @param  htim TIM Base handle
  * @retval None
  */

__weak void HAL_TIM_Base_MspInit(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_Base_MspInit could be implemented in the user file
   */
}

        HAL_TIM_Base_MspDeInit 

 /**
  * @brief  对TIM Base MSP进行去初始化.
  * @param  htim TIM Base handle
  * @retval None
  */

__weak void HAL_TIM_Base_MspDeInit(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_Base_MspDeInit could be implemented in the user file
   */
}

 2 驱动步进电机

        __HAL_TIM_SET_COMPARE

/**
  * @brief 在运行时设置TIM捕获比较寄存器的值，而不需要调用另一个time ConfigChannel函数。
  * @param __HANDLE__ TIM handle.
  * @param __CHANNEL__ 要配置的TIM通道。
  *该参数可以是以下值之一。
  * @arg TIM_CHANNEL_1: 选择的TIM通道1。
  * @arg TIM_CHANNEL_2: 选择的TIM通道2
  * @arg TIM_CHANNEL_3：选择的TIM通道3。
  * @arg TIM_CHANNEL_4: 选择的TIM通道4。
  * @param __COMPARE__指定捕获比较寄存器的新值。
  * @retval 无
  */

#define __HAL_TIM_SET_COMPARE(__HANDLE__, __CHANNEL__, __COMPARE__) \
  (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCR1 = (__COMPARE__)) :\
   ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCR2 = (__COMPARE__)) :\
   ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCR3 = (__COMPARE__)) :\
   ((__HANDLE__)->Instance->CCR4 = (__COMPARE__)))

        HAL_TIM_PWM_Start

/**
  * @brief 启动PWM信号的生成。
  * @param htim TIM handle
  * @param Channel 要启用的TIM通道
  *该参数可以是以下值之一。
  * @arg TIM_CHANNEL_1: 选择的TIM通道1
  * @arg TIM_CHANNEL_2: 选择的TIM通道2
  * @arg TIM_CHANNEL_3: 选择的TIM通道3。
  * @arg TIM_CHANNEL_4: 选择的TIM通道4
  * @retval HAL status
  */

HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
{
  uint32_t tmpsmcr;

  /* Check the parameters */
  assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));

  /* Check the TIM channel state */
  if (TIM_CHANNEL_STATE_GET(htim, Channel) != HAL_TIM_CHANNEL_STATE_READY)
  {
    return HAL_ERROR;
  }

  /* Set the TIM channel state */
  TIM_CHANNEL_STATE_SET(htim, Channel, HAL_TIM_CHANNEL_STATE_BUSY);

  /* Enable the Capture compare channel */
  TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);

  if (IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
  {
    /* Enable the main output */
    __HAL_TIM_MOE_ENABLE(htim);
  }

  /* Enable the Peripheral, except in trigger mode where enable is automatically done with trigger */
  if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
  {
    tmpsmcr = htim->Instance->SMCR & TIM_SMCR_SMS;
    if (!IS_TIM_SLAVEMODE_TRIGGER_ENABLED(tmpsmcr))
    {
      __HAL_TIM_ENABLE(htim);
    }
  }
  else
  {
    __HAL_TIM_ENABLE(htim);
  }

  /* Return function status */
  return HAL_OK;
}

        __HAL_TIM_SET_AUTORELOAD 

/**
* @brief 在运行时设置TIM自动加载寄存器的值，不需要再调用任何Init函数。
* @param __HANDLE__ TIM handle.
* @param __AUTORELOAD__指定计数器寄存器的新值。
* @retval 无
*/文章来源地址https://www.toymoban.com/news/detail-426921.html

#define __HAL_TIM_SET_AUTORELOAD(__HANDLE__, __AUTORELOAD__) \
   do{                                                    \
     (__HANDLE__)->Instance->ARR = (__AUTORELOAD__);  \
     (__HANDLE__)->Init.Period = (__AUTORELOAD__);    \
     } while(0)

到了这里，关于【STM32】HAL库学习 3—hal_time的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • STM32 HAL库-定时器中断

    STM32 HAL库-定时器中断

    关闭或开启所有中断；代码如下： STM32F407 有众多的定时器，其中包括 2 个基本定时器（TIM6 和 TIM7）、10 个通用定时 器（TIM2 ~ TIM5、TIM9 ~TIM14）、2 个高级控制定时器（TIM1 和 TIM8），这些定时器彼此完 全独立，不共享任何资源。 选择定时器，配置时钟源，设置预分频系数，计

    2024年01月25日
    浏览(61)
  • STM32 HAL库 STM32CubeMX -- TIM（定时器中断）

    STM32 HAL库 STM32CubeMX -- TIM（定时器中断）

    STM32F1 系列中，除了一些特殊的型号，大部分F1有8 个定时器，分为 基本定时器，通用定时器和高级定时器 。 基本定时器TIM6 和TIM7 是一个16 位的只能向上计数的定时器，只能定时，没有外部IO。 通用定时器TIM2/3/4/5 是一个16 位的可以向上/下计数的定时器，可以定时，可以输出

    2024年02月16日
    浏览(73)
  • 基于STM32的定时器--定时中断（HAL库）

    基于STM32的定时器--定时中断（HAL库）

    本文旨在介绍如何使用STM32CubeMX配置+KEIL 5开发一个每10us定时器中断触发一次的项目。帮助初学者入门STM32的定时器使用。 定时器是STM32微控制器中非常重要的功能模块之一，用于计时、生成精确的时间延迟、触发事件等。STM32微控制器通常具有多个定时器模块，包括通用定时

    2024年02月14日
    浏览(54)
  • STM32 HAL库 STM32CubeMX -- TIM（定时器输入捕获）

    STM32 HAL库 STM32CubeMX -- TIM（定时器输入捕获）

    输入捕获可以对 输入的信号的上升沿、下降沿或者双边沿进行捕获 ，常用的有 测量输入信号的脉宽 和 测量PWM 输入信号的频率 和 占空比 这两种。 输入捕获的原理 就是，当捕获到信号的跳变沿的时候，把计数器CNT 的值锁存到捕获寄存器CCR 中，把前后两次捕获到的CCR 寄存

    2023年04月14日
    浏览(101)

  • STM32 hal库编程定时器计数清零

    1、stm32定时器是有重装载功能的，所以定时器中断不关的话，就不需要计数清零 2、主要是应对单次计时使用，可能因为没有清零导致程序再次运行到相同位置时，中断立即出发，没有完成计时的功能。 顺便加一个读取定时器计数值得函数

    2024年02月03日
    浏览(54)
  • 【STM32】HAL库-系统滴答定时器SysTick

    【STM32】HAL库-系统滴答定时器SysTick

    SysTick定时器被捆绑在NVIC中，是一个简单的定时器，对于CM3、CM4内核芯片，都有Systick定时器。Systick定时器常用来做延时，或者实时系统的心跳时钟。这样可以节省MCU资源，不用浪费一个定时器。 Systick定时器就是系统滴答定时器，一个 24 位的倒计数定时器 ，计到0 时，将从

    2023年04月08日
    浏览(46)
  • STM32 HAL库开发——入门篇（2）：定时器

    STM32 HAL库开发——入门篇（2）：定时器

    一、TIMER定时器概述 1.1 软件定时原理 1.2 定时器定时原理 1.3 STM32定时器分类 1.4 STM32定时器特性表 1.5 STM32基本、通用、高级定时器功能整体的区别 二、基本定时器 2.1 基本定时器简介 2.3 STM32定时器计数模式及溢出条件 2.4 定时器中断实验相关寄存器 2.5 定时器溢出时间计算方

    2024年02月10日
    浏览(94)
  • # HAL库STM32常用外设教程（四）—— 基础定时器

    # HAL库STM32常用外设教程（四）—— 基础定时器

    1、STM32F407ZGT6 2、STM32CubeMx软件 3、keil5 内容简述： 通篇文章将涉及以下内容，如有错误，欢迎指出 ： 1、基础定时器特性 2、基础定时器的结构和功能 3、基础定时器HAL库驱动程序 （1）CubeMx配置 （2）TIM驱动程序   STM32F407有2个高级控制定时器（TIM1、TIM8）、8个通用定时器和

    2024年02月04日
    浏览(52)
  • STM32 hal库使用笔记（二）中断—定时器中断

    STM32 hal库使用笔记（二）中断—定时器中断

    目录 一、定时器简介 二、HAL库配置 1.时钟树的配置 2. CubeMX的配置 三、代码编写 四、拓展实验 五、实验效果 实验目的：利用定时器6控制LED灯的亮灭，间隔500ms 实验平台：正点原子精英板 一、定时器简介     定时器可以对输入的时钟进行计数，并在计数值达到设定值时触发

    2024年01月19日
    浏览(56)
  • STM32-HAL-定时器(无源蜂鸣器的驱动)

    STM32-HAL-定时器(无源蜂鸣器的驱动)

    有源蜂鸣器： 有源蜂鸣器内部有一个发声电路,也就是“源”（震荡源，与无源蜂鸣器的区别），只要通电就可以响。 无源蜂鸣器： 无源蜂鸣器相当于扬声器，无源蜂鸣器直接接直流电，只在刚接触和离开的时候发声（利用电磁感应现象，通电、断电时推动振膜发声），一般

    2024年02月14日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包