10 STM32 Interview Questions and Answers

STM32 microcontrollers are a popular choice in embedded systems due to their versatility, performance, and extensive ecosystem. These microcontrollers, developed by STMicroelectronics, are widely used in applications ranging from consumer electronics to industrial automation. Their robust architecture and support for various peripherals make them a go-to solution for engineers and developers working on complex embedded projects.

This article provides a curated selection of interview questions designed to test your knowledge and proficiency with STM32 microcontrollers. By reviewing these questions and their detailed answers, you will be better prepared to demonstrate your expertise and problem-solving abilities in your upcoming technical interviews.

STM32 Interview Questions and Answers

1. Write a function to configure a GPIO pin as an output and toggle its state every second using HAL library functions.

To configure a GPIO pin as an output and toggle its state every second using the STM32 HAL library, follow these steps:

1. Initialize the HAL library.
2. Configure the GPIO pin as an output.
3. Create a loop to toggle the pin state every second.

Example:

#include "stm32f4xx_hal.h"

void SystemClock_Config(void);
void GPIO_Init(void);

int main(void) {
    HAL_Init();
    SystemClock_Config();
    GPIO_Init();

    while (1) {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
        HAL_Delay(1000); // Delay for 1 second
    }
}

void GPIO_Init(void) {
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

void SystemClock_Config(void) {
    // System Clock Configuration code here
}

2. Provide a code example to configure ADC1 to read an analog value from channel 0 and print the result via UART.

#include "stm32f4xx_hal.h"

ADC_HandleTypeDef hadc1;
UART_HandleTypeDef huart2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_USART2_UART_Init(void);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_ADC1_Init();
    MX_USART2_UART_Init();

    HAL_ADC_Start(&hadc1);

    while (1)
    {
        if (HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY) == HAL_OK)
        {
            uint32_t adcValue = HAL_ADC_GetValue(&hadc1);
            char msg[10];
            sprintf(msg, "%lu\r\n", adcValue);
            HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);
        }
    }
}

static void MX_ADC1_Init(void)
{
    ADC_ChannelConfTypeDef sConfig = {0};

    hadc1.Instance = ADC1;
    hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
    hadc1.Init.Resolution = ADC_RESOLUTION_12B;
    hadc1.Init.ScanConvMode = DISABLE;
    hadc1.Init.ContinuousConvMode = ENABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;
    hadc1.Init.DMAContinuousRequests = DISABLE;
    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
    HAL_ADC_Init(&hadc1);

    sConfig.Channel = ADC_CHANNEL_0;
    sConfig.Rank = 1;
    sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

static void MX_USART2_UART_Init(void)
{
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    HAL_UART_Init(&huart2);
}

static void MX_GPIO_Init(void)
{
    __HAL_RCC_GPIOA_CLK_ENABLE();
}

void SystemClock_Config(void)
{
    // System Clock Configuration code here
}

3. Write a function to initialize UART2 with a baud rate of 9600 and send a string “Hello, World!”.

To initialize UART2 with a baud rate of 9600 and send a string “Hello, World!” on an STM32 microcontroller, use the HAL library provided by STMicroelectronics. Below is an example demonstrating the initialization and transmission:

#include "stm32f4xx_hal.h"

UART_HandleTypeDef huart2;

void UART2_Init(void) {
    __HAL_RCC_USART2_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    huart2.Instance = USART2;
    huart2.Init.BaudRate = 9600;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    HAL_UART_Init(&huart2);
}

void UART2_SendString(char *str) {
    HAL_UART_Transmit(&huart2, (uint8_t*)str, strlen(str), HAL_MAX_DELAY);
}

int main(void) {
    HAL_Init();
    UART2_Init();
    UART2_SendString("Hello, World!");

    while (1) {
    }
}

4. Provide a code example to initialize both UART and I2C peripherals and handle their interrupts.

#include "stm32f4xx_hal.h"

UART_HandleTypeDef huart2;
I2C_HandleTypeDef hi2c1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_I2C1_Init(void);

int main(void)
{
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART2_UART_Init();
    MX_I2C1_Init();

    while (1)
    {
    }
}

static void MX_USART2_UART_Init(void)
{
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart2) != HAL_OK)
    {
        Error_Handler();
    }
}

static void MX_I2C1_Init(void)
{
    hi2c1.Instance = I2C1;
    hi2c1.Init.ClockSpeed = 100000;
    hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
    hi2c1.Init.OwnAddress1 = 0;
    hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
    hi2c1.Init.OwnAddress2 = 0;
    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
    hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
    if (HAL_I2C_Init(&hi2c1) != HAL_OK)
    {
        Error_Handler();
    }
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART2)
    {
        // Handle UART receive interrupt
    }
}

void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
{
    if (hi2c->Instance == I2C1)
    {
        // Handle I2C receive interrupt
    }
}

void Error_Handler(void)
{
    while (1)
    {
    }
}

5. Describe how you would integrate FreeRTOS with an STM32 project and create a simple task that blinks an LED.

Integrating FreeRTOS with an STM32 project involves setting up the FreeRTOS environment, configuring the STM32 microcontroller, and creating tasks. FreeRTOS is a real-time operating system kernel for embedded devices that helps manage tasks, memory, and other resources efficiently.

To begin, download and include the FreeRTOS source files in your STM32 project. This can be done using STM32CubeMX, which simplifies the configuration process. Once FreeRTOS is included, configure the system clock and peripherals, such as GPIO, to control the LED.

Creating a simple task in FreeRTOS involves defining a task function and using the xTaskCreate function to create the task. The task function will contain the code to blink the LED, typically using a delay to control the blink rate.

Example:

#include "FreeRTOS.h"
#include "task.h"
#include "stm32f4xx_hal.h"

void SystemClock_Config(void);
void MX_GPIO_Init(void);

void BlinkTask(void *pvParameters) {
    while (1) {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); // Toggle LED
        vTaskDelay(pdMS_TO_TICKS(500)); // Delay for 500ms
    }
}

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();

    xTaskCreate(BlinkTask, "Blink", 128, NULL, 1, NULL);
    vTaskStartScheduler();

    while (1) {
    }
}

void SystemClock_Config(void) {
    // System clock configuration code
}

void MX_GPIO_Init(void) {
    __HAL_RCC_GPIOA_CLK_ENABLE();
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

6. Write a function to erase a sector of flash memory and then write new data to it.

To erase a sector of flash memory and write new data to it on an STM32 microcontroller, follow these steps:

• Unlock the flash memory for writing.
• Erase the specific sector.
• Write the new data to the flash memory.
• Lock the flash memory to prevent further writing.

Example:

#include "stm32f4xx_hal.h"

void Flash_Write(uint32_t sector, uint32_t address, uint32_t *data, uint32_t length) {
    // Unlock the Flash to enable the flash control register access
    HAL_FLASH_Unlock();

    // Erase the specified sector
    FLASH_Erase_Sector(sector, VOLTAGE_RANGE_3);

    // Write new data to the flash memory
    for (uint32_t i = 0; i < length; i++) {
        HAL_FLASH_Program(TYPEPROGRAM_WORD, address + (i * 4), data[i]);
    }

    // Lock the Flash to disable the flash control register access
    HAL_FLASH_Lock();
}

7. Write a function to configure the system clock to use an external crystal oscillator.

To configure the system clock of an STM32 microcontroller to use an external crystal oscillator, follow these steps:

• Enable the HSE (High-Speed External) oscillator.
• Wait for the HSE to stabilize.
• Configure the PLL (Phase-Locked Loop) if you need to multiply the frequency.
• Select the HSE (or PLL if used) as the system clock source.
• Update the SystemCoreClock variable to reflect the new clock configuration.

Example using the STM32 HAL (Hardware Abstraction Layer) library:

void SystemClock_Config(void) {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    // Enable HSE Oscillator and activate PLL with HSE as source
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 8;
    RCC_OscInitStruct.PLL.PLLN = 336;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 7;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        // Initialization Error
        while(1);
    }

    // Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 clocks dividers
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
                                  | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK) {
        // Initialization Error
        while(1);
    }

    // Update the SystemCoreClock variable
    SystemCoreClockUpdate();
}

8. Describe the steps to configure and use the RTC (Real-Time Clock) to keep track of time.

To configure and use the RTC (Real-Time Clock) on an STM32 microcontroller, follow these steps:

1. Enable the RTC Clock Source: Select and enable the clock source for the RTC, such as LSE (Low-Speed External), LSI (Low-Speed Internal), or HSE (High-Speed External) divided by a prescaler.
2. Enable the RTC Peripheral: Enable the RTC peripheral by setting the appropriate bits in the RCC (Reset and Clock Control) registers.
3. Enter Initialization Mode: Enter the RTC initialization mode to allow configuration of the RTC registers.
4. Configure the RTC Prescaler: Set the prescaler values to divide the clock source to achieve a 1 Hz clock for the RTC.
5. Set the Time and Date: Configure the time and date registers with the desired initial values.
6. Exit Initialization Mode: Exit the RTC initialization mode to start the RTC.
7. Enable RTC Interrupts (Optional): If you need to handle time-based events, enable the RTC interrupts and configure the NVIC (Nested Vectored Interrupt Controller) accordingly.
8. Read the Time and Date: Use the appropriate functions to read the current time and date from the RTC registers.

9. Write a function to initialize and start a PWM signal on a specific GPIO pin.

To initialize and start a PWM signal on a specific GPIO pin in an STM32 microcontroller, configure the timer and the GPIO pin. The STM32 HAL (Hardware Abstraction Layer) library provides functions to simplify this process.

Example:

#include "stm32f4xx_hal.h"

TIM_HandleTypeDef htim2;

void PWM_Init(void) {
    __HAL_RCC_TIM2_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    TIM_OC_InitTypeDef sConfigOC = {0};
    htim2.Instance = TIM2;
    htim2.Init.Prescaler = 84 - 1;
    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim2.Init.Period = 1000 - 1;
    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_PWM_Init(&htim2);

    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = 500;
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);

    HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
}

int main(void) {
    HAL_Init();
    PWM_Init();
    while (1) {
    }
}

10. Explain how to use the HAL library to perform a non-blocking UART transmission.

The HAL (Hardware Abstraction Layer) library in STM32 provides a set of APIs to interact with the hardware peripherals in a more abstracted and user-friendly manner. For UART (Universal Asynchronous Receiver/Transmitter) communication, the HAL library offers both blocking and non-blocking modes. Non-blocking UART transmission is useful when you want to perform other tasks while the data is being transmitted, thus improving the efficiency of your application.

To perform a non-blocking UART transmission using the HAL library, you can use the HAL_UART_Transmit_IT function. This function initiates the transmission and returns immediately, allowing the CPU to execute other tasks. The actual transmission is handled by the UART interrupt service routine (ISR).

Example:

#include "stm32f4xx_hal.h"

UART_HandleTypeDef huart2;

void UART_Init(void) {
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 9600;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    HAL_UART_Init(&huart2);
}

void Transmit_Data(uint8_t *data, uint16_t size) {
    HAL_UART_Transmit_IT(&huart2, data, size);
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART2) {
        // Transmission complete callback
    }
}

int main(void) {
    HAL_Init();
    UART_Init();

    uint8_t data[] = "Hello, UART!";
    Transmit_Data(data, sizeof(data) - 1);

    while (1) {
        // Main loop
    }
}