•

Paul Rodolf P. Castor

Published May 20, 2026

Assignment 2 Human Response Timer

Measure human reaction time using RT-SPARK board's built-in LEDs and hardware interrupts

IntermediateFull instructions provided5 hours7

Story

The project has been developed using RT-Spark Development Board (STM32F407ZGT6). There is a of a random number between one and three seconds before turning on green LED. Once the light turns on, the user should press the button at the earliest convenience. The microcontroller calculates the number of loops executed before the interrupt from the button occurs, which is a relative measure of the reaction speed of the user.

STM32CubeMX

Step 1: Configure the Hardware in STM32CubeMX

1. Open STM32CubeMX and click File then New Project.

2. Click Access to MCU Selector Search for and select the STM32F407ZGT6 microcontroller.

3. In the left menu, expand System Core and click SYS Change the Debug interface to Serial Wire This is critical for flashing the board later.

1 / 2

4. Configure the LED: On the chip diagram, left-click pin PF11 and select GPIO_Output. Right-click the same pin, select Enter User Label and name it GREEN_LED.

1 / 2

5. Configure the Button: Left-click pin PC0 (which corresponds to the LEFT button on the RT-Spark board) and select GPIO_EXTI. Right-click it, select Enter User Label, and name it USER_SWITCH.

1 / 2

6. Set the Interrupt Trigger: Go to System Core > GPIO. Click the USER_SWITCH pin (PC0) and change the GPIO mode to External Interrupt Mode with Falling edge trigger detection.

7. Enable the Interrupt: Go to System Core > NVIC and check the Enable box next to the EXTI line for your switch (EXTI line0 interrupt).

8. Go to the Project Manager tab, name your project, change the Toolchain / IDE to STM32CubeIDE, and click Generate Code.

STM32CubeIDE Setup

Step 2: Import the Project into STM32CubeIDE

1. In the Project Explorer, locate your Core folder. You will need to create four new files here to handle our custom functions.

2. Right-click the Inc folder, select New > Header File, and create leds.h and delay.h.

3. Right-click the Src folder, select New > Source File, and create leds.c and delay.c.

4. Paste the respective support module code (provided in the Code section) into these four files and save them.

Step 3: Write the Core Firmware Logic

1. Open your main.c file located in the Src folder.

2. Near the top of the file, find the /* USER CODE BEGIN Includes */ section and include your custom libraries along with the standard library for random number generation:

#include "leds.h" 
#include "delay.h" 
#include <stdlib.h>

3. Scroll down to /* USER CODE BEGIN PV */ and declare the global variables that will track your interrupt status and your final score:

volatile int isr_triggered = 0; 
volatile uint32_t final_reaction_time = 0;

4. Scroll to the bottom of the file to /* USER CODE BEGIN 4 */ and write the callback function. This tells the microcontroller to change our flag variable to '1' the exact moment the button is pressed.

5. Finally, find the infinite while (1) loop inside your int main(void) function. Paste the core game logic (provided in the Code section) inside the /* USER CODE BEGIN 3 */ block.

Step 4: Build, Flash, and Play

1. Click the Hammer icon in the top toolbar to build the project. Ensure the console shows 0 errors.

2. Plug your RT-Spark board into your computer and click the Bug icon (Debug) to flash the code to the microcontroller.

3. Once the Debug view opens, locate the Live Expressions tab (or open it via Window > Show View > Live Expressions).

4. Click "Add new expression" and type in final_reaction_time.

5. Click the Resume icon (Green Play button) to start the code.

6. Play the game! Keep your eyes on the white square on the board. When it turns green, press the LEFT button as fast as you can. Look at your computer screen to see your reaction score update live!

Assignment 2 Human Response Timer

// leds.h
#ifndef LEDS_H
#define LEDS_H
#include "main.h"

void LED_On(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
void LED_Off(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

#endif /* LEDS_H */

/////////////////////////////////////////////////////////////

// leds.c
#include "leds.h"

void LED_On(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) {
    HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_SET);
}

void LED_Off(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) {
    HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_RESET);
}

//////////////////////////////////////////////////////

// delay.h
#ifndef DELAY_H
#define DELAY_H
#include "main.h"

void delay_ms(uint32_t ms);

#endif /* DELAY_H */

//////////////////////////////////////////////////////

// delay.c
#include "delay.h"

void delay_ms(uint32_t ms) {
    HAL_Delay(ms);
}

///////////////////////////////////////////////////////

/* USER CODE BEGIN Includes */
#include "leds.h"
#include "delay.h"
#include <stdlib.h>
/* USER CODE END Includes */

/////////////////////////////////////////////////////////////////////

/* USER CODE BEGIN PV */
// Global variables to track the interrupt and score
volatile int isr_triggered = 0;
volatile uint32_t final_reaction_time = 0;
/* USER CODE END PV */

////////////////////////////////////////////////////////////

/* USER CODE BEGIN 4 */
// The Interrupt Service Routine (ISR)
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
    if(GPIO_Pin == USER_SWITCH_Pin) {
        isr_triggered = 1;
    }
}
/* USER CODE END 4 */

////////////////////////////////////////////////////////////////////////

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

    /* USER CODE BEGIN 3 */
    
    // 1. Ensure LED is off to start
    LED_Off(GREEN_LED_GPIO_Port, GREEN_LED_Pin);
    
    // 2. Clear the counter
    uint32_t counter = 0;
    
    // 3. Wait a random amount of time (1000ms to 3000ms)
    delay_ms((rand() % 2001) + 1000); 
    
    // 4. Visual cue: Turn on the Green LED
    LED_On(GREEN_LED_GPIO_Port, GREEN_LED_Pin); 
    
    // 5. Count rapidly until the LEFT button triggers the interrupt
    while (isr_triggered == 0) {
        counter++; 
    }
    
    // 6. Save the score to the global variable to view in the debugger
    final_reaction_time = counter; 
    
    // 7. Reset the flag and turn off the LED to show the press was registered
    isr_triggered = 0;
    LED_Off(GREEN_LED_GPIO_Port, GREEN_LED_Pin);
    
    // 8. Wait 5 seconds before starting the next round automatically
    delay_ms(5000); 

    /* USER CODE END 3 */
  }

Credits

MICHAEL CADIZ

3 projects • 0 followers

Paul Rodolf P. Castor

20 projects • 9 followers

Thanks to Paul Rodolf.

Embed the widget on your own site

Assignment 2 Human Response Timer

Assignment 2 Human Response Timer

Story

Step 1: Configure the Hardware in STM32CubeMX

Step 2: Import the Project into STM32CubeIDE

Step 3: Write the Core Firmware Logic

Step 4: Build, Flash, and Play

Code