•

Candice S. Guinoo

•

Paul Rodolf P. Castor

Published June 12, 2026

Prelim Exam (Project-based) Human Response Timer

A simple STM32 project that creates sounds and lets users adjust the pitch using buttons controls.

IntermediateProtip1.5 hours16

Prelim Exam (Project-based) Human Response Timer

Things used in this project

Hardware components

Breadboard (generic)

Jumper wires (generic)

Buzzer

Resistor 220 ohm

RT Thread Spark Development Board

Digital Oscilloscope

Software apps and online services

STM32 CubeMX

STM32 CubeIDE

Story

Introduction

This activity we built a simple sound generator using an STM32 microcontroller. The system uses three push buttons and a speaker module.

The first button increases the frequency of the sound, the second button plays the tone, and the third button decreases the frequency. By pressing the buttons, different sound frequencies can be produced through the speaker.

Figure 1. Hardware connections.

First, the hardware components were connected according to the provided schematic diagram. The three push buttons were connected to GPIO input pins, while the speaker was connected to an output pin.

GPIO Configurations

Figure 2. Configuration for GPIO.

The switch pins were configured as pull-up inputs, while the speaker pin was configured as a push-pull output.

Figure 2.1. Configuration for the speaker and push buttons.

The speaker was connected to PA2, while the three push buttons were connected to PC0, PC4, and PC5 as input pins.

Results and Discussion

The activity successfully generated tones with different frequencies. The buttons were able to control the frequency as intended.

The measured frequency values were very close to the expected values. Small differences were observed, which may have been caused by processing delays and hardware limitations.

The speaker produced audible tones at different frequencies, showing that the program worked correctly.

Test the Output Signal

The generated signals were tested using a logic analyzer or oscilloscope.

Different frequency values were measured and compared with their expected values.

Figure 3. Measured output signal using a logic analyzer.

Frequency Measurement Results

Frequency: 1k Hz

Expected Period: 1ms/cycle

Figure 4. Measured period is 1.02ms/cycle.

The measured period was 1.02 ms, which is very close to the expected 1 ms. This means the circuit was able to produce the correct frequency with only a very small difference.

Frequency: 2.5k Hz

Expected Period: 400us/cycle

Figure 5. Measured period is 414us/cycle.

The measured result was 414 µs instead of 400 µs. Even though it was slightly higher than expected, the output was still close to the target frequency.

Frequency: 5k Hz

Expected Period: 200us/cycle

Figure 6. Measured period is 216ms/cycle.

The measured period was 216 µs, while the expected value was 200 µs. The small difference may be due to delays in the program, but the output still worked properly.

Frequency: 8k Hz

Expected Period: 125us/cycle

Figure 7. Measured period is 140us/cycle.

The measured period was 140 µs compared to the expected 125 µs. The result shows that the system was still able to generate a high-frequency signal successfully.

Frequency: 10k Hz

Expected Period: 100us/cycle

Figure 8. Measured period is 116us/cycle.

The measured period was 116 µs instead of 100 µs. Although there was a slight difference, the generated tone was still close to the desired frequency.

Frequency: 100 Hz

Expected Period: 10us/cycle

Figure 9. Measured period is 10.0.ms/cycle.

The measured period was 10.0 ms, which matched the expected value very closely. This shows that the system can also produce accurate low-frequency signals.

Frequency: 250 Hz

Expected Period: 4ms/cycle

Figure 10. Measured period is 4.00ms/cycle.

The measured period was 4.00 ms, which was exactly the same as the expected value. This means the output frequency was very accurate.

Frequency: 500 Hz

Expected Period: 2ms/cycle

Figure 11. Measured period is 2.01ms/cycle.

The measured result was 2.01 ms, which is almost the same as the expected 2 ms. The difference is very small and does not significantly affect the output.

Frequency: 800 Hz

Expected Period: 1.25ms/cycle

Figure 12. Measured period is 1.26ms/cycle.

The measured period was 1.26 ms, while the expected value was 1.25 ms. Since the values are nearly identical, the frequency generation was successful.

The results show that the generated frequencies were close to the expected values, indicating that the tone generator was functioning properly.

Video Demo

This video shows the sound generator project in action. The buttons were used to change the sound frequency and play tones through the speaker.

Conclusion

The system was able to generate tones through a speaker and adjust the frequency using button controls. Through this activity, I learned how square wave signals are generated, how GPIO pins are configured, and how user inputs can be used to control output devices.

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 */
#include "delay.h"
/* 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 ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
volatile uint32_t current_Period_us = 1250; // current Frequency = 10kHz
const uint32_t min_Period_us = 100; // 10kHz
const uint32_t max_Period_us = 10000; // 100 Hz
const uint32_t step_Size_us = 100;

uint8_t switch1_state = 0;
uint8_t switch3_state = 0;
/* USER CODE END PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

// THE BUILT-IN LEDs ARE ACTIVE-LOW OR HIGH = OFF, LOW = ON
void play_tone(unsigned int duration_ms) {
    uint32_t total_duration_us = duration_ms * 1000;
    uint32_t elapsed_us = 0;

    // Loop until the requested duration has passed
    while(elapsed_us < total_duration_us) {
        // Toggle Pin High
        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);
        udelay(current_Period_us / 2);

        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);
        udelay(current_Period_us / 2);

        // Accumulate the time spent in one full cycle
        elapsed_us += current_Period_us;
    }
}

// GPIOC-Pin0/4/5 = Set as Pull-Up
void update_buttons() {
    uint8_t switch1 = HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_0); //BUTTON LEFT
    uint8_t switch2 = HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5); //BUTTON UP
    uint8_t switch3 = HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_4); //BUTTON RIGHT

    // BUTTON LEFT/SWITCH1 CHECK IF PRESSED
    if(switch1 == GPIO_PIN_RESET && switch1_state == 0) {
        if(min_Period_us < current_Period_us) {
            current_Period_us = current_Period_us - step_Size_us;
        }

        switch1_state = 1;
    }

    // BUTTON LEFT/SWITCH1 CHECK IF NOT PRESSED
    if(switch1 == GPIO_PIN_SET && switch1_state == 1) {
        switch1_state = 0;
    }

    //BUTTON RIGHT/SWITCH3 CHECK IF PRESSED
    if(switch3 == GPIO_PIN_RESET && switch3_state == 0) {
        if(current_Period_us < max_Period_us) {
            current_Period_us = current_Period_us + step_Size_us;
        }

        switch3_state = 1;
    }

    // BUTTON RIGHT/SWITCH3 CHECK IF NOT PRESSED
    if(switch3 == GPIO_PIN_SET && switch3_state == 1) {
        switch3_state = 0;
    }

    // BUTTON UP/SWITCH2 CHECK IF PRESSED
    if(switch2 == GPIO_PIN_RESET) {
        play_tone(100);
    }
}

/* 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();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
      update_buttons();
  }
  /* 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 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_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);

  /*Configure GPIO pins : PC0 PC4 PC5 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_4|GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : PA2 */
  GPIO_InitStruct.Pin = 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 BEGIN MX_GPIO_Init_2 */

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

Prelim Exam (Project-based) Human Response Timer

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

GPIO Configurations

Results and Discussion

Test the Output Signal

Frequency Measurement Results

Video Demo

Conclusion

Custom parts and enclosures

Github Repository

Schematics

Pins Schematic Diagram

Code

main.c

Credits

Rebecca Lyn ANTONIO

Candice S. Guinoo

Paul Rodolf P. Castor

Comments

Embed the widget on your own site

Prelim Exam (Project-based) Human Response Timer

Prelim Exam (Project-based) Human Response Timer

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

GPIO Configurations

Results and Discussion

Test the Output Signal

Frequency Measurement Results

Video Demo

Conclusion

Custom parts and enclosures

Github Repository

Schematics

Pins Schematic Diagram

Code

main.c

Credits

Rebecca Lyn ANTONIO

Candice S. Guinoo

Paul Rodolf P. Castor

Comments

Related channels and tags