STM32 TIM+GPIO 意外相移（HAL 库）

【问题标题】：STM32 TIM+GPIO unexpected phase shift (HAL library)STM32 TIM+GPIO 意外相移（HAL 库）
【发布时间】：2019-04-20 04:37:47
【问题描述】：

我使用 STM32F405RGT6。 要在 MCU 和传感器之间交换数据，我需要 2 根线：时钟线和与我的时钟同步的信号。 在具有更新中断的输出比较 (OC) 模式下使用定时器似乎是最合适的解决方案。但是有一点我看不懂。

我已将 TIM3 配置为使用 PB8 引脚在 OC 模式下工作，该引脚在周期中间切换。 计时器在每次更新时都会导致中断。此中断的处理程序切换另一个引脚（PB4）。 所以我希望在我的线上有相同的信号，在半个周期内有相移。 TIM3 周期需要 240ms 时没关系，但我在较短的周期内有很大的延迟，直到同步在 1μs 周期完全失败。 TIM3 使用 84MHz APB1 源。预分频器：/1。

main.c code:

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"

/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/
RTC_HandleTypeDef hrtc;

TIM_HandleTypeDef htim4;

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void Error_Handler(void);
static void MX_GPIO_Init(void);
static void MX_TIM4_Init(void);
static void MX_RTC_Init(void);

void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);


/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

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();

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

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM4_Init();
  MX_RTC_Init();

  /* USER CODE BEGIN 2 */

    __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE);
    HAL_TIM_OC_Start(&htim4, TIM_CHANNEL_3);

  /* USER CODE END 2 */

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

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;

    /**Configure the main internal regulator output voltage 
    */
  __HAL_RCC_PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 224;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }

  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

    /**Configure the Systick interrupt time 
    */
  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    /**Configure the Systick 
    */
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  /* SysTick_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

/* RTC init function */
static void MX_RTC_Init(void)
{

    /**Initialize RTC Only 
    */
  hrtc.Instance = RTC;
  hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  hrtc.Init.AsynchPrediv = 127;
  hrtc.Init.SynchPrediv = 255;
  hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  if (HAL_RTC_Init(&hrtc) != HAL_OK)
  {
    Error_Handler();
  }

}

/* TIM4 init function */
static void MX_TIM4_Init(void)
{

  TIM_MasterConfigTypeDef sMasterConfig;
  TIM_OC_InitTypeDef sConfigOC;

  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 0;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 99;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_OC_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

  sConfigOC.OCMode = TIM_OCMODE_TOGGLE;
  sConfigOC.Pulse = 49;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
  if (HAL_TIM_OC_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }

  HAL_TIM_MspPostInit(&htim4);

}

/** Configure pins as 
        * Analog 
        * Input 
        * Output
        * EVENT_OUT
        * EXTI
*/
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);

  /*Configure GPIO pin : PB4 */
  GPIO_InitStruct.Pin = GPIO_PIN_4;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM1 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* USER CODE BEGIN Callback 0 */

/* USER CODE END Callback 0 */
  if (htim->Instance == TIM1) {
    HAL_IncTick();
  }
/* USER CODE BEGIN Callback 1 */

  else if (htim->Instance == TIM4)
  {
      HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_4);
  }

/* USER CODE END Callback 1 */
}

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler */
  /* User can add his own implementation to report the HAL error return state */
  while(1) 
  {
  }
  /* USER CODE END Error_Handler */ 
}

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

这是我的时钟配置。 clock_conf TIM3 使用 84MHz APB1 总线，因此其最小周期小于 50ns。

不同周期的波形（1个计数表示12ns，黄色表示PB4信号，蓝色表示PB8-OC）：120000 counts22000 counts31500 counts41000 counts5400 counts6@987654327 @7 100 counts

为什么我无法以这样的速率实现正确同步？ MCU、定时器和GPIO工作在足够的频率。

对不起，我的英语不是我的母语。

【问题讨论】：

    标签： timer arm stm32 gpio hal


    【解决方案1】：

    这是 HAL 库的开销。

    在定时器中断中切换引脚需要 2 行代码

    /*
 * EDIT
 *
 * Resetting the status register in the very last statement of an interrupt
 * handler might not reach the interrupt controller in time, and the handler
 * would be invoked once again. Swapping the two lines would solve it.
 *
 * wrong order:
 *
 * void TIM4_IRQHandler() {
 *     GPIOB->ODR |= (1 << 4);
 *     TIM4->SR = 0;
 * }
 *
 * right order:
 */

void TIM4_IRQHandler() {
    TIM4->SR = 0;
    GPIOB->ODR |= (1 << 4);
}

    现在看看调用 HAL 的中断处理程序在做什么。

    • 加载句柄，并将其传递给HAL_TIM_IRQHandler()。
    • HAL_TIM_IRQHandler() 从句柄指向的结构中检索 UART 基地址。
    • 加载定时器状态寄存器以检查是否有通道 1 捕获/比较事件。没有。
    • 重新加载定时器状态寄存器以检查是否有通道 2 捕获/比较事件。没有。
    • 重新加载定时器状态寄存器以检查是否有通道 3 捕获/比较事件。有一个，因为通道处于输出比较模式
    • 重新加载定时器状态寄存器以检查通道 3 捕获/比较中断是否启用。不是。
    • 重新加载定时器状态寄存器以检查是否有通道 4 捕获/比较事件。没有。
    • 重新加载定时器状态寄存器以检查是否有更新事件。是的。
    • 重新加载定时器状态寄存器以检查是否启用了更新中断。是的。
    • 清除SR。
    • 调用回调函数。
    • 回调从句柄指向的结构中加载 UART 基地址。
    • 检查中断是否来自TIM1。不是。
    • 检查中断是否来自TIM4。是的。
    • 最后它调用了一个函数来切换引脚。
    • 然后它返回到 HAL 处理程序，该处理程序检查另外 3 个事件，这在 TIM4 上甚至是不可能的，并为每次检查重新加载状态寄存器。

    MCU 的设计考虑到了高效的中断处理，但使用 HAL 会抵消这一优势，以及程序员对所使用的实际功能的了解。 MCU 有一个专用于每个外设的中断向量，但 HAL 有一个用于所有定时器的公共处理程序，它通过双重间接访问外设（指向具有寄存器指针的结构的指针，不能是const )，使得编译器无法优化遍历指针。您知道只启用了更新中断，但 HAL 会检查所有 8 个可能的事件。

    【讨论】：

    • HAL 如此严重地降低了效率。我无法理解人们如何认为 HAL 是为了方便，尽管他们在 HAL 中遇到了很大的问题......
    • HAL 最好被视为示例的集合。毕竟代码大部分都在工作，只是效率低下。
    猜你喜欢
    • 1970-01-01
    • 2015-09-24
    • 2021-08-17
    • 2017-04-07
    • 2020-11-14
    • 2021-12-23
    • 2018-08-26
    • 2021-08-27
    • 2016-09-01
    相关资源
    最近更新 更多
    热门标签
    Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode