Frequency counter miscalculates when overflow and input capture happen at the same time.

[ABenz.11]

I am using a STM32F446re to detect rising edges, calculate the frequency and execute accordingly.

I have two signals that need to be detected. So I use two Timers 3 and 4. My frequency ranges from 3Hz to 300 kHz so I need to use overflow detection.

However When an overflow and a input capture happen close to each other, the overflow is not recognised and the frequency is miscalculated.

How can I check for interrupts within an interrupt routine?

[waclawek.jan]

uint32_t lastTim3Ccr1, totalTim3Cnt;
 
void TIM3_IRQHandler(void) {
  uint32_t sr, arr, ccr1;
  
  sr = TIM3->SR;
  TIM3->SR = ~sr;  // clear active flags - we don't intend to change mask ever so don't need to mask here
  
  arr = TIM3->ARR; // this may be a constant, if ARR never changes
  
  if (sr & TIM_SR_CC1IF) {  // capture upon edge
    ccr1 = TIM3->CCR1;
    if (ccr1 < arr / 2) {   // may have been yet unhandled overflow before capture
      if (sr & TIM_SR_UIF) {  // and sure it was
        sr &= ~TIM_SR_UIF;
        totalTim3Cnt += arr;
      }
    }
    ccr1 += totalTim3Cnt;
    ProcessDelta(ccr1 - lastTim3Ccr1);
    lastTim3Ccr1 = ccr1;
  }
  if (sr & TIM_SR_UIF) {  // overflow?
    totalTim3Cnt += arr;  // accumulate total time
  }
}

You have to make sure latency is less than arr/2.

JW

[ABenz.11]

Thank you JW

This looks good and it is similar on what I was doing with my atmega2560 before.

I am fairly new to STM32 so forgive me my stupid questions.

Am I right that I will insert your code into the stm32f4xx_it.c

void TIM3_IRQHandler(void)
{
  /* USER CODE BEGIN TIM3_IRQn 0 */
 
--->YOUR CODE HERE<----
 
  /* USER CODE END TIM3_IRQn 0 */
  HAL_TIM_IRQHandler(&htim3);
  /* USER CODE BEGIN TIM3_IRQn 1 */
 
  /* USER CODE END TIM3_IRQn 1 */
}

Also an other stupid question. ProcessDelta is a funktion of the Cube IDE?

I couldn't find anything on it in a quick search.

I will test it tonight and try to educate myself until then on the topic.

Thanks again.

[waclawek.jan]

> Am I right that I will insert your code into the stm32f4xx_it.c

I don't use Cube. This would be the whole ISR, no need to call HAL_TIM_IRQHandler(&htim3).

> ProcessDelta()

No, I just wanted to say, "insert here whatever code you want to process the time difference".

JW

[ABenz.11]

Hello JW

I tried to setup a new project to have a clean start. However the ISR is not triggered.

What am I missing?

I know that the timer is running and the SR register changes when I directly serial print it in the while loop.

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
 
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim3;
 
UART_HandleTypeDef huart2;
 
/* USER CODE BEGIN PV */
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM3_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint32_t lastTim3Ccr1, totalTim3Cnt;
volatile uint32_t delta;
char buffer[100];
/* USER CODE END 0 */
 
/**
  * @brief  The application entry point.
  * @retval int
  */
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_TIM3_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1);
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
 
							    // clear active flags - we don't intend to change mask ever so don't need to mask here
		HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%d", delta), 500);
							debugPrint(&huart2,";");
							HAL_UART_Transmit(&huart2, (uint8_t*)buffer, sprintf(buffer, "%d", __HAL_TIM_GetCounter(&htim3)), 500);
													debugPrintln(&huart2,";");
 
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
 
/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}
 
/**
  * @brief TIM3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM3_Init(void)
{
 
  /* USER CODE BEGIN TIM3_Init 0 */
 
  /* USER CODE END TIM3_Init 0 */
 
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};
 
  /* USER CODE BEGIN TIM3_Init 1 */
 
 
  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 400;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 65535;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_IC_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */
 
  /* USER CODE END TIM3_Init 2 */
 
}
 
/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{
 
  /* USER CODE BEGIN USART2_Init 0 */
 
  /* USER CODE END USART2_Init 0 */
 
  /* USER CODE BEGIN USART2_Init 1 */
 
  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */
 
  /* USER CODE END USART2_Init 2 */
 
}
 
/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
 
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
 
}
 
/* USER CODE BEGIN 4 */
void debugPrint(UART_HandleTypeDef *huart, char _out[]){
	HAL_UART_Transmit(huart, (uint8_t *) _out, strlen(_out), 10);
}
 
void debugPrintln(UART_HandleTypeDef *huart, char _out[]){
	HAL_UART_Transmit(huart, (uint8_t *) _out, strlen(_out), 10);
	char newline[2] = "\r\n";
	HAL_UART_Transmit(huart, (uint8_t *) newline, 2, 10);
}
 
/* USER CODE END 4 */
 
/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
 
  /* USER CODE END Error_Handler_Debug */
}
 
#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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
 
void TIM3_IRQHandler(void)
{
  /* USER CODE BEGIN TIM3_IRQn 0 */
	uint32_t sr, arr, ccr1;
	  debugPrintln(&huart2,"Interrupt");
 
							  sr = TIM3->SR;
							  TIM3->SR = ~sr;  // clear active flags - we don't intend to change mask ever so don't need to mask here
							 delta=99;
 
							  arr = TIM3->ARR; // this may be a constant, if ARR never changes
							//  delta= __HAL_TIM_GetCounter(&htim3);
 
							  if (sr & TIM_SR_CC1IF) {  // capture upon edge
 
								  ccr1 = TIM3->CCR1;
 
							    if (ccr1 < arr / 2) {   // may have been yet unhandled overflow before capture
							      if (sr & TIM_SR_UIF) {  // and sure it was
							        sr &= ~TIM_SR_UIF;
							        totalTim3Cnt += arr;
							      }
							    }
							    ccr1 += totalTim3Cnt;
 
									//(ccr1 - lastTim3Ccr1);
							    lastTim3Ccr1 = ccr1;
							  }
							  if (sr & TIM_SR_UIF) {  // overflow?
							    totalTim3Cnt += arr;  // accumulate total time
							  }
  /* USER CODE END TIM3_IRQn 0 */
  HAL_TIM_IRQHandler(&htim3);
  /* USER CODE BEGIN TIM3_IRQn 1 */
 
  /* USER CODE END TIM3_IRQn 1 */
}
 
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[ABenz.11]

Also how do I setup a project without HAL? I think this is messung up my workflow.