•

Paul Rodolf P. Castor

Published June 14, 2026

STM32 Timer Interrupts and Task Scheduling

Two LEDs blinking at different rates using STM32 timer interrupts, plus instant button response.

BeginnerProtip23

STM32 Timer Interrupts and Task Scheduling

Things used in this project

Hardware components

RT-Thread RT-SPARK Board (STM32F407ZGT6)

Breadboard (generic)

SparkFun Pushbutton switch 12mm

Jumper wires (generic)

Software apps and online services

STMicroelectronics STM32 CUBEIDE

STMicroelectronics STM32 CUBEMX

Story

INTRODUCTION

This project demonstrates concurrency through hardware timers and interrupts: TIM2 and TIM3 run independent background tasks at 1Hz and 2Hz, while a button press triggers an immediate foreground response, all coordinated through a foreground/background cyclic executive.

HARDWARE SETUP

Board: RT-Thread RT-Spark (STM32F407ZGT6)
LED_RED: PF11
LED_BLUE: PF12
DEBUG_PIN: PE0 (used for ISR timing measurements)
User Button: PA0 (configured as external interrupt, rising edge, pull-down)

Figure 1: STM32 CubeMX hardware setup

SOFTWARE SETUP

The system follows a foreground/background design:

Background tasks (ISRs): TIM2 fires every 1 second (highest priority), TIM3 fires every 0.5 seconds (lower priority). Both simply toggle their LED and set a flag for the foreground to process.
Foreground tasks (main loop): continuously checks the flags set by the ISRs and runs the corresponding task (Task A for TIM2, Task B for TIM3, Task C for periodic background monitoring).
Event-triggered task: a button press on PA0 triggers an EXTI interrupt that directly toggles both LEDs immediately, independent of the main loop — demonstrating fast, asynchronous event handling.

IMPLEMENTATION

TIM2: Prescaler = 8399, ARR = 9999 → 1 Hz interrupt (with PLL configured for 84 MHz APB1 timer clock)
TIM3: Prescaler = 8399, ARR = 4999 → 2 Hz interrupt
NVIC priorities: TIM2 = 0 (highest), TIM3 = 1, EXTI0 = 2 (lowest)

1 / 3 • Figure 2: TIM2 Modification

HOW IT WORKS:

At startup, main() initializes TIM2 and TIM3 and starts both with interrupts enabled.
TIM2 counts up and overflows every 1 second, firing its ISR — this toggles the RED LED, sets the task_adc_ready flag, and increments tick_count.
TIM3 counts up and overflows every 0.5 seconds, firing its ISR — this toggles the BLUE LED and sets the task_display_ready flag.
Back in the main loop, the foreground code continuously checks these flags:
If task_adc_ready is set → runs Task A (simulated ADC processing, 50ms)
If task_display_ready is set → runs Task B (simulated display update, 20ms)
If tick_count >= 10 → runs Task C (10-second periodic check) and resets the count
Meanwhile, the button (PA0) is wired as an external interrupt. Pressing it fires the EXTI ISR, which immediately toggles both LEDs, bypassing the main loop entirely, so the response is instant regardless of what the foreground tasks are doing.
This combination of two independent timers driving background flags, a foreground loop consuming them, and an asynchronous button interrupt, demonstrates a complete foreground/background (cyclic executive) scheduling model.

Initial test — TIM2 ISR toggling the RED LED every 1 second.

Both timers running — RED (1Hz) and BLUE (2Hz) blinking independently, demonstrating concurrent hardware interrupts.

RESULTS

Using the STM32CubeIDE debugger with the DWT cycle counter (84 MHz clock):

1 / 2 • TABLE 1: Calculated Timing Parameters

Pressing the button immediately toggles both LEDs, regardless of the timer cycle — demonstrating interrupt-driven event handling.

Observations:

RED LED (TIM2) blinks every 1 second, BLUE LED (TIM3) blinks every 0.5 second — since TIM3 has the shorter period, BLUE toggles first and twice as often as RED. Pressing the button toggles both LEDs immediately, regardless of where the main loop is in its cycle, confirming that hardware interrupts can preempt the foreground tasks at any time.

ANALYSIS

The ISR execution time itself is negligible (~0.65 µs), confirming that the actual response time is dominated by the task processing time (e.g., 50ms for Task A), not by interrupt overhead. In the worst case, Task A's latency can reach ~20ms if it has to wait for Task B (HAL_Delay(20)) to finish in the non-preemptive main loop, giving a worst-case response time of ~70ms. A preemptive scheduler would reduce this to near-idle latency (~5µs) by allowing higher-priority tasks to interrupt lower-priority ones immediately — at the cost of added complexity and potential priority inversion issues.

GitHub Link:https://github.com/bertaldearias/Arias-Timer-ISR-Lab1

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 */
/// Flags for foreground/background communication
volatile uint32_t time_isr_entry = 0;
volatile uint32_t time_taskA_start = 0;
volatile uint32_t time_taskA_end = 0;
volatile uint8_t task_adc_ready = 0;
volatile uint8_t task_display_ready = 0;
volatile uint32_t tick_count = 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 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
// Background Task 1: TIM2 - High priority, 1 Hz
	if (htim->Instance == TIM2)
	{
		time_isr_entry = DWT->CYCCNT;   // <-- ADD THIS LINE (first line)

		HAL_GPIO_TogglePin(LED_RED_GPIO_Port, LED_RED_Pin);
		task_adc_ready = 1; // Signal foreground to process ADC
		tick_count++; // Increment system tick
		}
// Background Task 2: TIM3 - Lower priority, 2 Hz
	if (htim->Instance == TIM3)
	{
		HAL_GPIO_TogglePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin);
		task_display_ready = 1; // Signal foreground to update display
		}
}
/* 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 */
  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
  DWT->CYCCNT = 0;
  DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
  /// Start Timer 2 with interrupt enabled
  HAL_TIM_Base_Start_IT(&htim2);
  HAL_TIM_Base_Start_IT(&htim3);
  /* USER CODE END 2 */

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

      /* USER CODE BEGIN 3 */
  	  // Task A: Process ADC data (triggered by TIM2)
  	  if (task_adc_ready)
  	  {
  		  time_taskA_start = DWT->CYCCNT;
  		  task_adc_ready = 0;
  		  // Simulate ADC processing
  		  HAL_Delay(50); // 50ms processing time
  		  time_taskA_end = DWT->CYCCNT;
  	  }

  	  // Task B: Update display (triggered by TIM3)
  	  if (task_display_ready)
  	  {
  		  task_display_ready = 0;
  		  // Simulate display update
  		  HAL_Delay(20); // 20ms processing time
  	  }

  	  // Task C: Background monitoring (always runs)
  	  if (tick_count >= 10)
  	  {
  		  tick_count = 0;
  		  // Perform 10-second periodic task
  	  }
      }
    /* 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_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != 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 = 8399;
  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 = 8399;
  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_GPIOA_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 : PA0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOA, &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(EXTI0_IRQn, 2, 0);
  HAL_NVIC_EnableIRQ(EXTI0_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_0)
	{
// Button pressed - toggle both LEDs immediately
		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

Bert Alde ARIAS

3 projects • 0 followers

Paul Rodolf P. Castor

53 projects • 9 followers

STM32 Timer Interrupts and Task Scheduling

Things used in this project

Hardware components

Software apps and online services

Story

IMPLEMENTATION

RESULTS

Schematics

Pin Configuration Schematic

Code

main.c

Credits

Bert Alde ARIAS

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

IMPLEMENTATION

RESULTS

Schematics

Pin Configuration Schematic

Code

main.c

Credits

Bert Alde ARIAS

Paul Rodolf P. Castor

Comments

Related channels and tags