•

Paul Rodolf P. Castor

Published June 14, 2026

STM32 Timer Interrupts and Task Scheduling

A hands-on STM32 project demonstrating timers, interrupts, latency, and task response analysis.

IntermediateProtip2 hours27

STM32 Timer Interrupts and Task Scheduling

Things used in this project

Hardware components

RT Thread Spark Development Board

Software apps and online services

STM32 CubeMX

STM32 CubeIDE

Story

Introduction

In this laboratory activity, I learned how to use timers, interrupts, and task scheduling on the STM32F407ZGT6 microcontroller. The main goal was to understand how interrupts work, how multiple tasks can run in a system, and how different scheduling methods affect task performance.

First, I configured a timer interrupt to automatically toggle an LED. Next, I added another timer and created multiple tasks that run at different time intervals. I then measured timing parameters such as TRelease, TLatency, TISR, and TResponse to see how the system performs. Lastly, I implemented an event-triggered system using a push button and compared its behavior with the timer-based system.

Figure 1. Hardware Setup

Part1: Configure Hardware Timer with Interrupts

Figure 1. Creating a new STM32 project.

A new STM32 project was created using STM32CubeMX. The software was opened, and a new project was created for the STM32F407ZGT6 microcontroller.

Figure 2. STM32F407ZGT6 microcontroller

The STM32F407ZGT6 microcontroller, which is used on the RT-Spark development board, was searched for and selected in STM32CubeMX. This allowed the project to be configured for the correct microcontroller and hardware platform. After that, click "Start Project".

Figure 3. Toolchain Configuration

The STM32CubeIDE toolchain was also selected so that the generated code could be opened, edited, compiled, and uploaded to the STM32F407ZGT6 microcontroller.

Figure 4. GPIO Configuration

The onboard LEDs were configured as GPIO outputs so they could be controlled by the program. Pin PF11 was assigned as LED_RED, while pin PF12 was assigned as LED_BLUE. These pins were set as output pins in STM32CubeMX, allowing the microcontroller to turn the LEDs on and off during execution.

Figure 5. TIM2 Configuration (Parameter Settings).

Figure 5.1. TIM2 Configuration (NVIC Settings).

The TIM2 timer was set up to generate an interrupt every 1 second. The timer settings were adjusted to produce a 1 Hz signal, and the TIM2 interrupt was enabled with the highest priority. After the configuration was completed, the project code was generated.

Implementation

Part 2: Implement Timer ISR for Periodic LED Toggle

Figure 6. main.c file in STM32CubeIDE.

The generated project was opened in STM32CubeIDE. The main.c file was then accessed by navigating to Core to Src to main.c, where the main() function was located for adding the required code.

Figure 7. TIM2 with interrupt enabled in the main() function.

The code HAL_TIM_Base_Start_IT(&htim2) was added before the infinite loop to start TIM2 with interrupts enabled. This allows the timer to begin counting and automatically generate an interrupt whenever the set timer period is reached.

Figure 8. Timer Callback Function.

A timer callback function was implemented to handle the TIM2 interrupt. Whenever the timer reaches its set period, the callback function is automatically executed and toggles the red LED (PF11). This causes the LED to blink once every second.

Figure 9.

The activity was built and uploaded to the RT-Spark development board. After running the program, the red LED was observed blinking every 1 second, confirming that the timer interrupt was working correctly.

Part 3: Create Multi-Task Cyclic Executive System

Figure 10. TIM3 Configuration.

A second timer, TIM3, was configured to create another periodic interrupt with a different rate. The timer was set to generate an interrupt every 0.5 seconds and was assigned a lower priority than TIM2. After the configuration was completed, the project code was regenerated to apply the changes.

Figure 11. Global variables for task communication.

Global variables were added to help the interrupts and main loop share information. The variables task_adc_ready and task_display_ready were used to indicate when a task is ready to run, while tick_count was used to count timer events.

Figure 12. Callback function for TIM2 and TIM3.

The callback function was updated so that TIM2 toggles the red LED and signals Task A, while TIM3 toggles the blue LED and signals Task B. This lets the main loop know when each task is ready to run.

Figure 13. Main loop running the foreground tasks.

The main loop was updated to run tasks when their flags were set. Task A simulates ADC processing, while Task B simulates a display update.

Part 4: Measure and Analyze Response Times

Figure 14. Configuration of PE0 as DEBUG_PIN in STM32CubeMX.

A debug pin (PE0) was configured as a GPIO output and labeled DEBUG_PIN.

Figure 15. Timing markers added to the code.

Timing markers were added using the DEBUG_PIN. The pin was set HIGH when the interrupt or task started and set LOW when it finished.

Part 5: Implement Event-Triggered Scheduling

Figure 16. Configuration of PA0 (GPIO).

Figure 16.1. Configuration of PA0 (NVIC).

The PA0 button was set up as an interrupt input. This allows the microcontroller to react whenever the button is pressed. After the setup was finished, the project code was regenerated.

Figure 17. Button interrupt callback function.

An external interrupt callback function was added to detect button presses. When the PA0 button is pressed, the function immediately toggles both the red LED and blue LED.

Testing the button interrupt operation.

The project was tested by uploading it to the board. The LEDs continued blinking based on the timer interrupts. When the button was pressed, both LEDs changed state immediately, showing that the button interrupt was working.

Analysis

In this activity, timer-based and event-triggered scheduling were used. In the timer-based approach, tasks run when the main loop checks their flags, so there can be some waiting time. In the event-triggered approach, tasks run right away when an event happens, such as a button press.

The event-triggered approach responds faster, while the timer-based approach is useful for tasks that need to run regularly.

Schematics

Code

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2026 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* 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 htim2;
TIM_HandleTypeDef htim3;

/* USER CODE BEGIN PV */

extern uint32_t _callfunction(uint32_t input);
uint32_t value = 0;

/*
 	 These variables are simply used as flags for the CPU to deal with. These variables are constantly checked by
 	 the main function's loop, and they simply are just for checking whether the task is ready to run or not.
 	 The reason we do not put the main interrupt code within the ISR Callback function is that the ISR Callback function
 	 should not wait for the interrupt main code to finish, hindering the ability to even interrupt at all.

 	 task_adc_ready is for TIM2, task_display_ready is for TIM3, they're all just assume for what they do.
 	 tick_count is also a flag that just counts forward whenever TIM2 interrupt fires.
*/
volatile uint8_t task_adc_ready = 0;
volatile uint8_t task_display_ready = 0;
volatile uint32_t tick_count = 0;

volatile uint32_t start = 0;
volatile uint32_t tick = 0;
volatile uint32_t maxlatency = 0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/*
	HAL_TIM_PeriodElapsedCallback is an ISR Callback function that is called when a Timer interrupt occurs (TRelease), the argument or parameter
	simply holds an address to the Timer Hardware Register; TIM_HandleTypeDef is struct which holds the member htim, which
	is also holding an address of a Timer Hardware Register.

	"if(htim->Instance == TIMx)" is used to check whose timer Interrupt Service Routine(ISR) is signaling this, executes the code written
	inside it. TIM2 is RED LED, TIM3 is BLUE LED. The DEBUG_PIN is not an interrupt-based, but rather a technique for us so we can at least
	approximately measure the TISR accurately.

	Variables, such as, task_adc_ready, tick_count, and task_display_ready are simply used as flags for the CPU so that
	the ISR Callback function finishes without having to wait for the interrupt main code to finish
	(More info from the declaration of these variables above).

	volatile uint32_t start = DWT->CYCCNT is just there to record the tick when it has arrived there, and so is the "end" variable.
	volatile uint32_t tick = end - start gives you the tick starting from zero, and you must convert it to seconds, typically ticks/fAPB(hz) or
	ticks/fAPB(no hz) for microseconds.
*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) {
	if((*htim).Instance == TIM2) {
		start = DWT->CYCCNT;
		HAL_GPIO_TogglePin(LED_RED_GPIO_Port, LED_RED_Pin);
		task_adc_ready = 1;
		tick_count++;
	}

	if((*htim).Instance == TIM3) {
		HAL_GPIO_TogglePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin);
		task_display_ready = 1;
	}
}
/* 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_TIM2_Init();
  MX_TIM3_Init();
  /* USER CODE BEGIN 2 */
  /*
   	   HAL_TIM_Base_Start() is a function that simply enable a timer to start, Base mode states that it's very simple and just counts and resets
   	   while "HAL_TIM_Base_Start_IT()" makes it interrupt-enabled. The argument holds an address of a timer to specify whose timer
   	   is being started, and interrupt-enabled.

   	   CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk statement lets us use any built-in debugger, DWT->CYCCNT = 0 just resets the tick,
   	   DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk enables the DWT timer to start incrementing the tick.
  */
  HAL_TIM_Base_Start_IT(&htim2);
  HAL_TIM_Base_Start_IT(&htim3);

  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
  DWT->CYCCNT = 0;
  DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  value = _callfunction(25);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
	  /*
	  	  if(task_adc_ready) function checks if the variable or flag task_adc_ready is set to ready by the ISR Callback function to start
	  	  running the interrupt main code. When running, it resets task_adc_ready to zero so that if(task_adc_ready) function waits for
	  	  another ISR Callback, specifically for TIM2. This part still uses the DEBUG_PIN for measuring time duration.

	  	  if(task_display_ready) function, same as what if(task_adc_ready), but without the DEBUG_PIN and different milliseconds delay.

	  	  if(tick_count >= 10) is the same for the ones above, only that it doesn't really do much, other than reset tick_count to 0
	  	  once tick_count hits 10 or above.
	  */
	  if(task_adc_ready) {
		  tick = DWT->CYCCNT - start;
		  task_adc_ready = 0;
		  HAL_Delay(50);
		  if(tick > maxlatency) {
			  maxlatency = tick;
		  }
	  }

	  if(task_display_ready) {
		  task_display_ready = 0;
		  HAL_Delay(20);
	  }

	  if(tick_count >= 10) {
		  tick_count = 0;
	  }
  }
  /* 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_SCALE1);

  /** 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 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 = 1599;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 9999;
  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 */

}

/**
  * @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_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 1599;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 4999;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  /* USER CODE BEGIN MX_GPIO_Init_1 */

  /* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOF, LED_RED_Pin|LED_BLUE_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC5 */
  GPIO_InitStruct.Pin = GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : LED_RED_Pin LED_BLUE_Pin */
  GPIO_InitStruct.Pin = LED_RED_Pin|LED_BLUE_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI9_5_IRQn, 2, 0);
  HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);

  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
	if(GPIO_Pin == GPIO_PIN_5) {
		HAL_GPIO_TogglePin(LED_RED_GPIO_Port, LED_RED_Pin);
		HAL_GPIO_TogglePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin);
	}
}
/* 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 */
  __disable_irq();
  while (1)
  {
  }
  /* 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,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Credits

Rebecca Lyn ANTONIO

6 projects • 0 followers

Paul Rodolf P. Castor

57 projects • 9 followers

STM32 Timer Interrupts and Task Scheduling

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Implementation

Part 5: Implement Event-Triggered Scheduling

Testing the button interrupt operation.

Analysis

Custom parts and enclosures

Github Repository

Schematics

Sequence Diagram

Code

main.c

Credits

Rebecca Lyn ANTONIO

Paul Rodolf P. Castor

Comments

Embed the widget on your own site

STM32 Timer Interrupts and Task Scheduling

STM32 Timer Interrupts and Task Scheduling

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Implementation

Part 5: Implement Event-Triggered Scheduling

Testing the button interrupt operation.

Analysis

Custom parts and enclosures

Github Repository

Schematics

Sequence Diagram

Code

main.c

Credits

Rebecca Lyn ANTONIO

Paul Rodolf P. Castor

Comments

Related channels and tags