How to Use STM32 TIM2 for 1ms Event Scheduling and Button Debouncing

Implementing STM32 TIM2 for Precise 1ms Event Scheduling with External Interrupt Handling on GPIO Pin for Button Debouncing

This tutorial will guide you through implementing TIM2 on the STM32 microcontroller to achieve precise 1ms event scheduling, supplemented by external interrupt handling on a GPIO pin for button debouncing. This setup is crucial for responsive and reliable button press detection without the noise associated with mechanical switches.

Prerequisites

• Basic understanding of C programming.
• Familiarity with STM32 microcontroller architecture.
• STM32 development board (like STM32F4 or STM32F1 series).
• STM32CubeIDE installed on your computer.
• USB to UART converter (optional, for debugging).

Parts/Tools

• STM32 development board.
• Micro USB cable.
• Push button switch.
• Resistor (typically 10kΩ for pull-down).
• STM32CubeIDE.

Steps

1. Set up the project in STM32CubeIDE:
   1. Open STM32CubeIDE and create a new STM32 project.
   2. Select your microcontroller or development board.
   3. Enable TIM2 in the “Peripherals” tab.
   4. Enable GPIO for the button input (e.g., PA0) and configure it as an external interrupt.
2. Configure TIM2:
   1. Set the prescaler and auto-reload value to achieve a 1ms time base.
   2. In the “Configuration” tab, set the TIM2 Mode to “Periodic” and enable the interrupt.
   3. Click “Project” and then “Generate Code”.
3. Write the TIM2 interrupt handler:

   Open the generated stm32f4xx_it.c file and implement the TIM2 interrupt service routine (ISR).

   void TIM2_IRQHandler(void)
   {
       if (__HAL_TIM_GET_FLAG(&htim2, TIM_FLAG_UPDATE) != RESET)
       {
           if (__HAL_TIM_GET_IT_SOURCE(&htim2, TIM_IT_UPDATE) != RESET)
           {
               __HAL_TIM_CLEAR_IT(&htim2, TIM_IT_UPDATE);
               // Place your code for 1 ms events here
           }
       }
   }

4. Implement GPIO external interrupt for button debouncing:

   Write the external interrupt handler for the button in stm32f4xx_it.c.

   void EXTI0_IRQHandler(void)
   {
       if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_0) != RESET)
       {
           __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
           // Handle button press event
       }
   }

5. Debouncing logic:
   1. Introduce a simple debounce mechanism in the button interrupt handler.

   volatile uint32_t last_interrupt_time = 0;
   
   void EXTI0_IRQHandler(void)
   {
       uint32_t current_time = HAL_GetTick();
       if (current_time - last_interrupt_time > 50) // 50 ms debounce delay
       {
           last_interrupt_time = current_time;
           // Handle button press event
       }
       __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
   }

6. Initialize peripherals and start the timer:
   1. In main.c, initialize the HAL library and configure the system clock.
   2. Start TIM2 in the main function:

   HAL_TIM_Base_Start_IT(&htim2);

7. Compile and upload the code:

   Build the project and upload it to your STM32 board using the debugger.

8. Test your implementation:

   Connect the button to the configured GPIO pin and observe the behavior. The button should debounce correctly, and the 1ms events should be processed accurately.

Troubleshooting

• Button not detected: Ensure the button is wired correctly and the pull-down resistor is in place.
• Interrupts not firing: Check the NVIC configuration and ensure interrupts are enabled for TIM2 and GPIO.
• Debouncing not effective: Adjust the debounce delay as necessary; a longer delay may be required depending on the button.
• System hangs: Ensure that the ISR executes quickly and does not contain long blocking calls.

Conclusion

By following this tutorial, you have successfully implemented TIM2 for 1ms event scheduling combined with GPIO interrupt handling for button debouncing on STM32. This setup is crucial for responsive applications that rely on user input, ensuring that button presses are accurately detected without the noise that can cause false triggering.