Create delay in Microseconds in STM32

This guide explains how to create an accurate STM32 microsecond delay using hardware timers and the HAL library. The built-in HAL_Delay() function only supports millisecond delays, which is not precise enough for time-sensitive peripherals like ultrasonic sensors, NRF modules, and high-speed signal toggling. Here, you’ll learn to configure STM32CubeMX, set up TIM1 for 1 µs resolution, and implement a delay_us() function in C. This method is tested on STM32F103 (Blue Pill) but applies to most STM32 series.

The HAL_Delay function in STM32 provides delays with a minimum resolution of 1 millisecond. However, when precise microsecond-level delays are required, the HAL library does not offer a built-in function for this purpose. In this tutorial, we will demonstrate how to generate accurate microsecond delays using a hardware timer. The approach is applicable across all STM32 microcontrollers, with only minor device-specific adjustments needed.

VIDEO TUTORIAL

Watch the video below to see complete process of adding libraries, integrating LVGL and using Squareline Studio.

Importance of Microseconds Delay

In embedded systems development, precise timing is often a critical requirement—particularly when dealing with time-sensitive peripherals or communication protocols. Many external devices such as ultrasonic sensors, digital displays, or RF modules require signals with exact timing down to a few microseconds. In such cases, using standard delay functions like HAL_Delay, which only provides millisecond resolution, is insufficient. Tasks such as generating pulse trains, bit-banging protocols, or managing sensor trigger timings demand a finer time granularity to function reliably.

Microsecond delays are especially important in real-time applications where even a small timing deviation can lead to incorrect data transmission or hardware malfunction. They are also essential for performance tuning in systems where latency and response time must be minimised. Since STM32’s HAL library does not include built-in support for microsecond-level delays, developers must leverage hardware timers to implement precise delay routines. This ensures accurate control over signal timing, which is fundamental to the stability and functionality of advanced embedded applications.

What Is Delay in Microcontrollers?

Delays in microcontrollers refer to the intentional pausing of code execution for a specific duration. They’re commonly used to:

• Synchronize communication (UART, SPI, I2C)
  
• Wait between sensor triggers
  
• Generate timed pulses or signals
  
• Create timeouts or software-based waits
  

In STM32, HAL_Delay() works for milliseconds, but to get precise timing in microseconds, you need a timer-based method.

Hardware Requirement

• I am going to use the STM32F103C8 Microcontroller for this project, but as I mentioned it will work same for other microcontrollers as well.
• You can Purchase the Logic Analyzer to visualise the data on the computer

CUBEMX Configuration

This is the most important part of this process, so read this section very carefully. First of all we need to decide which Timer to use for the process. There is no special requirement, just choose any one. I will use timer 1.

As you can see in the image below (from the datasheet of the MCU), the TIM1 is connected to the APB2 clock. This is a very important piece of information, and you should know it about the timer that you are going to use.

Clock Configuration

We will start with configuring the clock for the project. Below is the image showing the Clock setup for STM32F103C8 Microcontroller.

The Bluepill board (STM32F103C8) has an 8MHz oscillator on it. We will use this HSE crystal to run the system at maximum possible 72MHz clock.
Note that he APB2 Timer clock is also at 72MHz. The Timer1 is connected to APB2 bus, hence the Timer1 clock is also at 72MHz.

Timer Configuration

Below is the image showing the TIM1 configuration.

• TIM1 Mode and Configuration: This indicates that Timer 1 is being configured in the STM32CubeMX tool.
• Clock Source: Internal Clock : The timer’s clock source is set to the internal clock, which is typically derived from the system clock.
• Prescaler (PSC – 16 bits value): The prescaler is set to 71 (since 72 – 1 = 71). This divides the APB2 clock frequency by 72, effectively slowing down the timer’s counting rate to 1MHz.
• Counter Mode: The timer will count in the upward direction—from 0 to the value set in the AutoReload Register.
• Counter Period (AutoReload Register – 16 bits value): 0xFFFF – 1
• The AutoReload value is set to 0xFFFF (65535), which defines the maximum count value before the timer resets.

Basically, the counter is going to count from 0 to ARR. Since the Timer clock is 1MHz, every count will take 1us. So setting this value as high as possible is the best, because this way you can have large delays also.

I have also enabled the pin PA1 as output, so that we can see the result in an oscilloscope.

HAL Delay vs Timer Delay – What’s the Difference?

• HAL_Delay() uses the SysTick timer and provides delays in milliseconds. It’s simple, but not accurate enough for fast signals.
  
• delay_us() uses a hardware timer (TIM1) to count microseconds precisely. It is ideal for protocols, sensors, or tasks requiring high-resolution delays.
  

Use HAL_Delay() for general waits, and delay_us() for precise microsecond timing.

STM32 HAL Timer Code for Microsecond Delay (delay_us Function)

The Delay Function

Let’s write a function to block the CPU until the predefined count is reached.

void delay_us (uint16_t us)
{
	__HAL_TIM_SET_COUNTER(&htim1,0);  // set the counter value a 0
	while (__HAL_TIM_GET_COUNTER(&htim1) < us);  // wait for the counter to reach the us input in the parameter
}

void delay_us (uint16_t us)
{
	__HAL_TIM_SET_COUNTER(&htim1,0);  // set the counter value a 0
	while (__HAL_TIM_GET_COUNTER(&htim1) < us);  // wait for the counter to reach the us input in the parameter
}

When the function is called with the parameter as the number of microseconds, the following operations takes place

• The TIM1 counter will reset to 0.
• The counter will start counting up, till the value (us) has been reached.
• Once the value is reached, the function will exit.

As I mentioned before, each count takes 1 us, and therefore the counter will keep counting in microseconds until the input value has reached. Once it happens, the control will come out of the loop, and we have had achieved the delay.

The Main Function

Inside the main loop, we must start the timer after all the peripherals are initialised.

int main ()
{
  ....
  HAL_TIM_Base_Start(&htim1);  // start the Timer1
  while (1)
  {
    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_1);
    delay_us(10);
  }
}

int main ()
{
  ....
  HAL_TIM_Base_Start(&htim1);  // start the Timer1
  while (1)
  {
    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_1);
    delay_us(10);
  }
}

To use the required delay, all we have to do is call the function delay_us() we created above.

RESULT

Below are the images showing the pin PA1 toggle behaviour on the scope.

10us Delay

The following is the output when delay_us(10); is used to toggle the PA1 in a while loop.

100us Delay

The following is the output when delay_us(100); is used to toggle the PA1 in a while loop.

1ms Delay

The following is the output when delay_us(1000); is used to toggle the PA1 in a while loop.

 This example provides a clean and tested method for STM32 delay in microseconds using HAL timer. You now know how to configure TIM1 in STM32CubeMX, implement a delay function in C, and verify the result using an oscilloscope. This technique is applicable across STM32F1, STM32F4, and STM32G0 series with minor changes in timer selection. It’s a practical solution when precision is more important than simplicity.

PROJECT DOWNLOAD

ESP32 Microsecond Delay FAQs