STM32F4 TIM2 Timer, Getting To 1 Second

11 min read Sep 25, 2024

The STM32F4 series of microcontrollers are known for their versatility and performance, offering a wide range of peripherals and features for embedded applications. Among these features is the TIM2 timer, a powerful and flexible tool that can be utilized for various tasks, including generating precise time delays, implementing PWM control, and creating accurate timing for real-time applications. One common requirement in embedded systems is to achieve accurate 1-second time intervals, which can be accomplished by effectively configuring the STM32F4 TIM2 timer. This article will delve into the process of setting up the TIM2 timer to generate a 1-second delay on an STM32F4 microcontroller, providing a step-by-step guide for beginners and experienced users alike.

Understanding the Basics

Before diving into the configuration details, it's essential to understand the fundamental principles of the STM32F4 TIM2 timer. The TIM2 timer is a 16-bit general-purpose timer that can be configured for various modes of operation. In our case, we'll focus on using it in timer mode, where it continuously counts up from a specified initial value until it reaches a predefined value, triggering an interrupt or generating an output signal. The key elements for configuring the TIM2 timer for 1-second intervals are:

Prescaler (PSC)

The prescaler acts as a divider for the internal clock signal that feeds the timer. It determines the rate at which the timer counter increments. A higher prescaler value leads to a slower timer count rate.

Period (ARR)

The period register defines the maximum value the timer counter can reach. When the timer reaches the ARR value, it resets to zero and begins counting again.

Clock Frequency (SystemCoreClock)

The system clock frequency, denoted as SystemCoreClock, represents the main clock frequency of the microcontroller. This frequency serves as the basis for calculating the timer settings.

Step-by-Step Configuration

To achieve a 1-second delay using the TIM2 timer on the STM32F4, we'll follow a step-by-step approach:

Enabling the Timer Clock:
- First, we need to enable the clock signal for the TIM2 timer. This is achieved by setting the corresponding bit in the RCC (Reset and Clock Control) register. In the STM32F4 series, this involves enabling the TIM2 peripheral clock by setting the TIM2EN bit in the RCC_APB1ENR register.
```
RCC->APB1ENR |= RCC_APB1ENR_TIM2EN; 
```
Setting the Prescaler:
- The prescaler determines the timer counting speed. To achieve a 1-second interval, we need to calculate the appropriate prescaler value based on the system clock frequency. The formula for calculating the prescaler value is:
```
PSC = (SystemCoreClock / (Timer_Frequency * (ARR + 1))) - 1
```
  - Where:
    - SystemCoreClock is the microcontroller's system clock frequency.
    - Timer_Frequency is the desired timer frequency (1 Hz for a 1-second delay).
    - ARR is the period value.
- For example, if the system clock frequency is 84 MHz and we want a 1 Hz timer frequency, the prescaler value would be:
```
PSC = (84000000 / (1 * (65535 + 1))) - 1 ≈ 1274 
```
- To set the prescaler value, we write the calculated value to the TIMx_PSC register (TIM2_PSC in this case).
```
TIM2->PSC = 1274; 
```
Setting the Period:
- The period value determines the maximum count value of the timer. For a 1-second delay, we need to set the period value to a number that will result in a 1-second count cycle.
- We can use the formula below to determine the ideal ARR value:
```
ARR = (SystemCoreClock / (Timer_Frequency * (PSC + 1))) - 1
```
- In our example, with a system clock of 84 MHz and a prescaler of 1274, the ARR value would be:
```
ARR = (84000000 / (1 * (1274 + 1))) - 1 ≈ 65535 
```
- Set the ARR value in the TIMx_ARR register (TIM2_ARR in this case).
```
TIM2->ARR = 65535; 
```
Enabling the Timer:
- With the prescaler and period values set, we now need to enable the TIM2 timer. This is done by setting the CEN bit in the TIMx_CR1 register (TIM2_CR1 in this case).
```
TIM2->CR1 |= TIM_CR1_CEN; 
```
Handling the Timer Interrupt (Optional):
- The TIM2 timer can be configured to generate an interrupt when it reaches the ARR value. This interrupt can be used to trigger specific actions in your code, such as updating a counter or performing a task every second.
- To enable the interrupt, set the UIE bit in the TIMx_DIER register (TIM2_DIER in this case).
```
TIM2->DIER |= TIM_DIER_UIE;
```
- Next, define a function to handle the timer interrupt. In the interrupt handler, clear the interrupt flag by writing a '1' to the TIMx_SR register's UIF bit (TIM2_SR's UIF bit in this case).
```
void TIM2_IRQHandler(void) {
   if (TIM2->SR & TIM_SR_UIF) {
       // Perform your actions every second
       // ...
       TIM2->SR &= ~TIM_SR_UIF; // Clear the interrupt flag
   }
}
```
- Lastly, configure the NVIC (Nested Vectored Interrupt Controller) to enable the TIM2 interrupt.
```
NVIC_EnableIRQ(TIM2_IRQn);
```

Example Code Implementation

Here's a C code example that demonstrates the configuration of the STM32F4 TIM2 timer to achieve a 1-second delay with an interrupt:

#include "stm32f4xx_hal.h"

// Function to initialize the TIM2 timer for a 1-second delay
void TIM2_Init(void) {
  // Enable the TIM2 clock
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;

  // Set the prescaler value
  TIM2->PSC = 1274;

  // Set the period value
  TIM2->ARR = 65535;

  // Enable the timer
  TIM2->CR1 |= TIM_CR1_CEN;

  // Enable the update interrupt
  TIM2->DIER |= TIM_DIER_UIE;

  // Enable the TIM2 interrupt in NVIC
  NVIC_EnableIRQ(TIM2_IRQn);
}

// TIM2 interrupt handler
void TIM2_IRQHandler(void) {
  if (TIM2->SR & TIM_SR_UIF) {
    // Perform actions every second
    // ...

    // Clear the interrupt flag
    TIM2->SR &= ~TIM_SR_UIF;
  }
}

int main(void) {
  // Initialize the HAL library
  HAL_Init();

  // Initialize the TIM2 timer
  TIM2_Init();

  // Main loop
  while (1) {
    // ...
  }
}

Key Points and Considerations

System Clock: The system clock frequency (SystemCoreClock) is crucial for accurate timing. Ensure that the correct system clock frequency is set before configuring the TIM2 timer.
Prescaler and Period: The prescaler and period values are interconnected. Adjusting one may require modifying the other to achieve the desired timer frequency.
Interrupt Handling: If using the timer interrupt, it's essential to clear the interrupt flag in the interrupt handler to avoid triggering the interrupt repeatedly.
Alternative Timer Settings: The TIM2 timer can be configured for other timer frequencies by changing the prescaler and period values.
Timer Accuracy: The TIM2 timer provides a relatively high degree of accuracy, but there can be slight variations due to factors like clock jitter and other system overhead.

Conclusion

Successfully configuring the STM32F4 TIM2 timer to generate a 1-second delay is a fundamental step in developing embedded systems. By understanding the key parameters, following the step-by-step procedure, and implementing the code example, you can effectively utilize this powerful timer for various time-critical applications on the STM32F4 microcontroller. Mastering the use of the STM32F4 TIM2 timer enables you to create precise timing mechanisms, ensuring that your embedded system operates reliably and accurately, meeting the demands of your specific project requirements.