Published June 13, 2026

Timers, Interrupts, and Task Scheduling

Exploring timer-based ISRs and foreground/background task scheduling on the STM32F407ZGT6 RT-Spark development board.

BeginnerProtip13

Things used in this project

Hardware components

RT-Thread RT-Spark Development Board

Software apps and online services

STM32CubeIDE

STM32CubeMX

Story

INTRODUCTION

Ever wondered how microcontrollers handle multiple tasks at the same time? This project shows how timer interrupts and task scheduling work on the STM32F407ZGT6 RT-Spark board. Two timers blink LEDs at different rates while a button interrupt responds instantly to presses — all running together using a simple foreground/background system.

HardwareSetup

The project uses the RT-Thread RT-Spark development board built around the STM32F407ZGT6 microcontroller. Two onboard LEDs are connected to pins PF11 (Red) and PF12 (Blue), a user button is connected to PA0, and a debug pin is set up on PE0 for timing measurements.

SoftwareArchitecture

The system uses a foreground/background architecture. Timer interrupts run in the background as ISRs, setting flags when tasks are ready. The main loop in the foreground checks these flags and executes the corresponding tasks. TIM2 runs at 1Hz with the highest priority, TIM3 runs at 2Hz with medium priority, and the button EXTI interrupt has the lowest priority among the three.

Implementation

TIM2 and TIM3 were configured in STM32CubeMX with their respective prescaler and auto-reload values to achieve the target frequencies. The HAL_TIM_PeriodElapsedCallback function handles both timer ISRs, toggling LEDs and setting task flags. The main loop processes Task A when TIM2 fires, Task B when TIM3 fires, and Task C runs a periodic 10-second check. A button interrupt on PA0 toggles both LEDs immediately when pressed, demonstrating event-driven response.

1 / 6 • Figure 1.1 GPIO Configuration

Results

This video shows the RT-Spark board in action — the red and blue LEDs blinking at different rates using timer interrupts, and both LEDs toggling instantly when the button is pressed.

Figure 2. Output

TimingMeasurement

Table 1. Timing Measurement

Observations

During testing, the red LED blinked every 1 second as triggered by TIM2, while the blue LED blinked every 0.5 seconds as triggered by TIM3. When the user button was pressed, both LEDs responded immediately, confirming that the external interrupt works correctly. The foreground tasks executed properly whenever the timer flags were set.

Analysis

The measured TLatency of 24.94 µs shows the small delay between the interrupt firing and the task starting. The TISR of 4.31 µs confirms that the ISR executes very quickly. The total response time of 50.02443 ms is close to the expected 50 ms task delay. The worst-case response time is 120 ms when all tasks are running simultaneously. Using a preemptive scheduler would reduce this latency significantly since higher priority tasks could run immediately without waiting for other tasks to finish.

Code

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body with DWT cycle counter
  ******************************************************************************
  * @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 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 */
// ------------------- DWT Cycle Counter for Microsecond Timing -------------------
static void DWT_Init(void) {
    if (!(CoreDebug->DEMCR & CoreDebug_DEMCR_TRCENA_Msk)) {
        CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; // Enable trace
    }
    DWT->CYCCNT = 0;            // Reset cycle counter
    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk; // Enable cycle counter
}

static uint32_t DWT_GetMicroseconds(void) {
    return DWT->CYCCNT / (SystemCoreClock / 1000000);
}
// --------------------------------------------------------------------------------

// Timer Interrupt Callback
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2)
    {
        uint32_t start_us = DWT_GetMicroseconds();

        HAL_GPIO_WritePin(DEBUG_PIN_GPIO_Port, DEBUG_PIN_Pin, GPIO_PIN_SET);
        HAL_GPIO_TogglePin(LED_RED_GPIO_Port, LED_RED_Pin);
        task_adc_ready = 1;

        HAL_GPIO_WritePin(DEBUG_PIN_GPIO_Port, DEBUG_PIN_Pin, GPIO_PIN_RESET);

        uint32_t elapsed_us = DWT_GetMicroseconds() - start_us;
        // You can store or print elapsed_us if needed
    }
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
    /* USER CODE BEGIN 1 */
    /* USER CODE END 1 */

    /* MCU Configuration--------------------------------------------------------*/
    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_IT(&htim2);
    HAL_TIM_Base_Start_IT(&htim3);

    DWT_Init();  // Initialize DWT cycle counter
    /* USER CODE END 2 */

    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1)
    {
        if (task_adc_ready)
        {
            uint32_t start_us = DWT_GetMicroseconds();

            HAL_GPIO_WritePin(DEBUG_PIN_GPIO_Port, DEBUG_PIN_Pin, GPIO_PIN_SET);
            task_adc_ready = 0;
            HAL_Delay(50); // Simulate ADC processing
            HAL_GPIO_WritePin(DEBUG_PIN_GPIO_Port, DEBUG_PIN_Pin, GPIO_PIN_RESET);

            uint32_t elapsed_us = DWT_GetMicroseconds() - start_us;
            // You can store or print elapsed_us if needed
        }
    }
    /* 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};

    __HAL_RCC_PWR_CLK_ENABLE();
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

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

    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
  */
static void MX_TIM2_Init(void)
{
    TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    TIM_MasterConfigTypeDef sMasterConfig = {0};

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

/**
  * @brief TIM3 Initialization Function
  */
static void MX_TIM3_Init(void)
{
    TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    TIM_MasterConfigTypeDef sMasterConfig = {0};

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

/**
  * @brief GPIO Initialization Function
  */
static void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    __HAL_RCC_GPIOF_CLK_ENABLE();
    __HAL_RCC_GPIOE_CLK_ENABLE();

    HAL_GPIO_WritePin(GPIOF, LED_RED_Pin|LED_BLUE_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DEBUG_PIN_GPIO_Port, DEBUG_PIN_Pin, GPIO_PIN_RESET);

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

    GPIO_InitStruct.Pin = DEBUG_PIN_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(DEBUG_PIN_GPIO_Port, &GPIO_InitStruct);
}

/**
  * @brief  This function is executed in case of error occurrence.
  */
void Error_Handler(void)
{
    __disable_irq();
    while (1)
    {
    }
}

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */

Credits

Princess Nashema MACASERO

6 projects • 0 followers

Timers, Interrupts, and Task Scheduling

Things used in this project

Hardware components

Software apps and online services

Story

INTRODUCTION

Implementation

Results

Observations

Analysis

Schematics

Sequence Diagram

Code

main.c

GitHub Repository

Credits

Princess Nashema MACASERO

Comments

Embed the widget on your own site

Timers, Interrupts, and Task Scheduling

Timers, Interrupts, and Task Scheduling

Things used in this project

Hardware components

Software apps and online services

Story

INTRODUCTION

Implementation

Results

Observations

Analysis

Schematics

Sequence Diagram

Code

main.c

GitHub Repository

Credits

Princess Nashema MACASERO

Comments

Related channels and tags