How to Create Microsecond Delay in STM32 Using HAL Timer

When working with STM32 microcontrollers, we often need precise delays for tasks like generating waveforms, controlling sensors, or handling communication protocols. The commonly used HAL_Delay() function only provides millisecond delays, which is not enough for applications that require microsecond accuracy.

In this tutorial, we will learn how to create microsecond delay in STM32 using the hardware timer. We’ll configure the timer in CubeMX, write a delay_us function, and verify the output with a simple test. By the end of this guide, you’ll be able to implement accurate microsecond delays in your STM32 projects.

Hardware Required for STM32 UART Example

Before we begin with the project, let’s look at the hardware and software needed for this STM32 UART tutorial. Below are the affiliate links you can consider before purchasing the items.

• STM32F446 Dev Board
• ST-Link V2
• Logic Analyzer to conform the Timing
• Jumper Wires

Why Do We Need Microsecond Delay in STM32?

Delays are an important part of many embedded projects. In STM32, we often need very short and accurate delays for tasks like reading sensors, generating waveforms, or controlling communication protocols. A simple millisecond delay is not always enough. Therefore, we must use a method that allows us to create a microsecond delay in STM32.

Limitation of HAL_Delay

The HAL_Delay() function in STM32 works with the SysTick timer. This timer runs at 1ms resolution, which means it can only provide delays in milliseconds. If you try to use it for smaller delays, like 10µs or 100µs, it will not work correctly. As a result, HAL_Delay() is not suitable when your project requires precise timing in microseconds.

Applications Requiring Microsecond Precision

Many real-world applications need microsecond-level accuracy. For example:

• Communication protocols like One-Wire or custom serial data transfer need microsecond timing.
• Sensor interfaces such as ultrasonic sensors require accurate delays to measure distance.
• PWM signal generation or waveform creation needs precise control of ON and OFF times.
• High-speed data sampling often depends on accurate microsecond delays.

Because of these cases, using a timer-based delay_us function in STM32 is the best choice.

Configuring Timer in CubeMX for Microsecond Delay

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 Timer1.

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.

STM32 Clock Configuration

We will start with configuring the clock for the project. The image below shows the Clock setup for STM32F103C8 Microcontroller.

The Bluepill board (STM32F103C8) has a 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.

STM32 Timer Configuration for Microsecond Delay

The image below shows the TIM1 configuration.

In this setup, we configure Timer 1 (TIM1) using the STM32CubeMX tool.

• Clock Source – Internal Clock: The timer uses the internal system clock as its source.
• Prescaler (PSC – 16 bits): We set the prescaler value to 71. Since the APB2 clock runs at 72 MHz, dividing it by 72 gives a timer clock of 1 MHz. This means the timer counts every 1 microsecond.
• Counter Mode: The counter increases upward, starting from 0 and going up to the AutoReload value.
• AutoReload Register (ARR – 16 bits): We set ARR to 0xFFFF (65535). This is the maximum value before the counter resets.

With this setup, the timer counts from 0 to 65535. Because the timer clock is 1 MHz, each count equals 1 µs. Setting a high ARR value allows us to create both short and long microsecond delays.

Finally, we enable PA1 pin as output. This helps us test the delay function by toggling the pin and checking the signal on an oscilloscope or Logic Analyzer.

STM32 HAL Timer Code for Microsecond Delay (delay_us Function)

Below is a simple, reliable way to implement a delay_us function using a HAL timer.

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 function, we must start the timer after all the peripherals are initialized.

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 of STM32 Microsecond delay

To test the delay_us function, I toggled the PA1 pin in a simple while loop. By observing the pin on an oscilloscope, we can verify whether the delay works correctly.

10us Delay

The image below shows the oscilloscope output when I used delay_us(10); inside the toggle loop. As you can see, the waveform confirms that the delay (PW) is around 10 microseconds (0.010ms), which matches our expectation.

100us Delay

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

1ms Delay

The image below shows the output when delay_us(1000) is used to toggle the PA1 in a while loop.

Conclusion

By using a hardware timer, you can easily generate an accurate 1 microsecond delay in STM32. Unlike HAL_Delay(), which only works in milliseconds, the delay_us() function built with HAL timer gives you precise control down to the microsecond. This approach works across most STM32 series, whether you use STM32CubeMX or direct HAL code.

With this method, you can reliably handle time-critical tasks such as ultrasonic sensors, RF modules, and fast communication protocols. If your STM32 project requires precise microsecond timing, the timer-based delay_us() function is the most efficient and dependable solution

PROJECT DOWNLOAD

STM32 Microsecond Delay FAQs