•

Paul Rodolf P. Castor

Published June 13, 2026

Human Response Timer using RT-Spark

A reaction-time measurement project using the RT-Spark development board powered by the STM32F407ZGT6 microcontroller.

IntermediateFull instructions provided2 hours29

Things used in this project

Hardware components

RT-Spark Development Board

Breadboard (generic)

Jumper wires (generic)

RGB LED

Resistor 220 ohm

Software apps and online services

STM32CubeIDE

STM32CubeMX

Story

INTRODUCTION

This project is a simple Human Response Timer built using the RT-Spark development board with an STM32F407ZGT6 microcontroller. It measures how quickly a person can react when an RGB LED turns on.

The program first waits for a random amount of time between one and three seconds. This prevents the user from guessing when the signal will appear. After the delay, the RGB LED lights up, telling the user to press the push button as fast as possible.

When the button is pressed, an external interrupt is triggered, allowing the microcontroller to immediately detect the user's response. The program then records the result and determines whether the reaction time is fast, average, or slow. A different RGB LED color is displayed to show the result.

To provide immediate feedback, the system categorizes the response speed using colored LEDs:

Red LED – Fast reaction
Green LED – Average reaction
Blue LED – Slow reaction

Setting Up

Create a new STM32 project and search STM32F407ZGT6 in the MCU board selector and then choose the first one that pop up and name your project, then keep the default settings.

After that, configure the Pinout & Configuration into this.

1 / 3 • set the PC0 to GPIO_EXTI0, Falling Edge, Trigger Internal Pull-Up Enabled

Circuit Diagram

The push button is configured as a falling-edge external interrupt on PC0. When the button is pressed, the interrupt callback executes:

Testing

The system was tested by repeatedly performing reaction-time measurements and observing the resulting LED classifications.

The RNG generated random delay between 1-3 seconds.
The interrupt responded immediately to button presses.
RGB LEDs correctly indicated reaction categories.

Testing with Oscilloscope

Configure the PA5 into GPIO_output for the Oscilloscope pin testing

The oscilloscope test confirmed that the Human Response Timer system was functioning as expected. The generated signals were observed correctly, and the button press produced a clear change in the waveform that could be detected by the STM32F407ZGT6 microcontroller. The results also showed that the external interrupt responded immediately when the button was pressed, allowing the system to measure the user's reaction time accurately. Overall, the oscilloscope helped verify the timing and operation of the hardware and demonstrated that the project was working properly.

8 seconds delay

6.46 seconds delay

Conclusion

This project successfully created a Human Response Timer using the STM32F407ZGT6 microcontroller and RGB LED. The system measures how quickly a user reacts when the RGB LED turns on. It uses a random 1-3 seconds delay to prevent the user from predicting when the signal will appear and an external interrupt to detect button presses quickly.

During testing, an issue was observed where the program remembers a button press made before the RGB LED turns white, causing the system to register a response even when the user pressed the button too early. Despite this limitation, the project successfully demonstrates basic embedded systems concepts such as GPIO control, interrupts, random number generation, and user interaction.

Schematics

Code

Main.c Code

/* 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 ---------------------------------------------------------*/
RNG_HandleTypeDef hrng;

/* USER CODE BEGIN PV */
volatile uint8_t flag = 0;
/* USER CODE END PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
	if(GPIO_Pin == GPIO_PIN_0) {
		flag = 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_RNG_Init();
  /* USER CODE BEGIN 2 */
  uint32_t counter = 0;
  uint32_t time = 0;

  uint32_t sum = 0;
  uint32_t avgresponsetime = 0;
  uint8_t iterations = 0;
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
	  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0 | GPIO_PIN_3 | GPIO_PIN_2, GPIO_PIN_RESET);
	  counter = 0;

	  if(HAL_RNG_GenerateRandomNumber(&hrng, &counter) == HAL_OK) {
		  time = (counter % (2001)) + 1000;
	  }
	  HAL_Delay(time);
	  counter = 0;

	  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0 | GPIO_PIN_3 | GPIO_PIN_2, GPIO_PIN_SET);

	  while(flag == 0) {
		  counter++;
	  }

	  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0 | GPIO_PIN_3 | GPIO_PIN_2, GPIO_PIN_RESET);

	  if(counter < 500000) {
		  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET); /* RED */
	  } else if(counter >= 500000 && counter < 2000000) {
		  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_SET); /* GREEN */
	  } else {
		  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET); /* BLUE */
	  }

	  iterations++;
	  sum = sum + counter;
	  if(iterations == 10) {
		  avgresponsetime = sum / 10;
		  iterations = 0; sum = 0;
	  }

	  flag = 0;
	  HAL_Delay(5000);
  }
  /* 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 = 192;
  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 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 RNG Initialization Function
  * @param None
  * @retval None
  */
static void MX_RNG_Init(void)
{

  /* USER CODE BEGIN RNG_Init 0 */

  /* USER CODE END RNG_Init 0 */

  /* USER CODE BEGIN RNG_Init 1 */

  /* USER CODE END RNG_Init 1 */
  hrng.Instance = RNG;
  if (HAL_RNG_Init(&hrng) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN RNG_Init 2 */

  /* USER CODE END RNG_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 */

  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* USER CODE END MX_GPIO_Init_1 */

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

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

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

  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /*Configure GPIO pin : PA0, PA3, PA2 */
  GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_3 | GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* 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

MA REGINE BERMUDO

7 projects • 0 followers

Paul Rodolf P. Castor

57 projects • 9 followers

Human Response Timer using RT-Spark