Starting with STM32 - Programming Tutorial for Beginners | Step by Step | Greidi Ajalik

Introduction

This tutorial is designed for beginners looking to start programming with STM32 microcontrollers. It will guide you through the process of setting up your development environment, configuring GPIO pins, and writing your first code. By the end, you'll have a solid foundation to build upon for your STM32 projects.

Step 1: Starting a New Project in STM32 CubeIDE

1. Open STM32 CubeIDE: Launch the STM32 CubeIDE on your computer.
2. Create a New Project:
   • Click on "File" and select "New STM32 Project."
   • Choose the appropriate STM32 microcontroller or development board from the list.
   • Click "Next" and provide a project name. Select a location for your project files.
3. Initialize Project Settings: Review the project configuration and click "Finish."

Step 2: Configuring STM32 Chip and GPIO Pins

1. Open the .ioc File:
   • The .ioc file is essential for configuring the microcontroller’s pins and peripherals.
2. Configure GPIO Pins:
   • In the Pinout view, select the pins you want to configure as GPIO.
   • Set their mode (e.g., Input, Output) and any specific settings (e.g., Pull-up, Pull-down).
3. Save Changes: Save the .ioc file to apply your configurations.

Step 3: Setting Up Clock Configuration

1. Access the Clock Configuration Tab: Click on the "Clock Configuration" tab within the CubeIDE.
2. Adjust Clock Settings:
   • Set the desired system clock frequency.
   • Configure the PLL settings as necessary.
3. Validate Configuration: Ensure all settings are compatible and click "Save."

Step 4: Exploring Project Tree and Files

1. Understand the Project Structure:
   • Familiarize yourself with the generated files (e.g., main.c, stm32fxx_hal_conf.h).
   • Recognize where to add your code (usually in main.c).
2. Review HAL Libraries: Get to know the Hardware Abstraction Layer (HAL) libraries that simplify hardware interactions.

Step 5: Controlling a GPIO in STM32

1. Open main.c: Navigate to the main.c file in your project.
2. Initialize GPIO: Use the following code snippet to initialize GPIO:

   HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
   

3. Toggle GPIO State:
   • To toggle the state, you can use the following code in a loop:

   while(1) {
       HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
       HAL_Delay(500); // Delay for 500ms
   }
   

Step 6: Implementing Delay Function

1. Using HAL_Delay: Ensure that your project includes the HAL library to use HAL_Delay. It allows you to create delays in milliseconds.
2. Example Usage:

   HAL_Delay(1000); // 1-second delay
   

Step 7: Upgrading ST-LINK

1. Connect ST-LINK Programmer: Make sure your ST-LINK programmer is connected to your computer.
2. Open ST-LINK Utility: Launch the ST-LINK utility software.
3. Upgrade Firmware: Follow the prompts to check for and install any firmware updates.

Step 8: Using ST-LINK for Debugging and Programming

1. Set Up Debug Configuration:
   • In STM32 CubeIDE, configure the debugger settings under "Run Configurations."
2. Start Debugging: Click on the debug icon. This will compile your code and upload it to the STM32 chip.
3. Set Breakpoints (if necessary): Insert breakpoints in your code to halt execution at specific lines.

Step 9: Writing an Interrupt Example

1. Configure Interrupt in .ioc File:
   • Set up an external interrupt for a GPIO pin.
2. Implement Interrupt Handler:
   • Create an interrupt service routine (ISR) in main.c:

   void EXTI0_IRQHandler(void) {
       HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_1); // Toggle another GPIO pin
       HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0); // Clear interrupt flag
   }
   

Step 10: UART Communication Example

1. Configure UART in .ioc File: Set up UART settings for communication with a PC.
2. Send Data: Use HAL_UART_Transmit to send data over UART:

   HAL_UART_Transmit(&huart2, (uint8_t *)"Hello, PC!\n", 12, HAL_MAX_DELAY);
   

Conclusion

You've now learned how to set up a project in STM32 CubeIDE, configure GPIO and clock settings, and write simple code to control GPIO pins and use interrupts. Continue to explore more advanced features of the STM32, such as communication protocols and peripheral interfaces, to expand your programming skills. Happy coding!