STM 32 - Frequently asked interview questions and answer

The STM32 microcontroller family is a comprehensive series of 32-bit ARM Cortex-M-based microcontrollers organized into different series: STM32F series (Flexible, ARM Cortex-M cores), STM32L series (low-power), STM32G series (high-performance and real-time), STM32H series (Cortex-M7 + Cortex-M4), STM32MP series (dual-core Cortex-A and Cortex-M).

The STM32F4 series is known for its high-performance capabilities based on ARM Cortex-M4 core. The STM32F407 sub-family offers a broad range of models. The STM32F407G features a 32-bit ARM Cortex-M4 core running at up to 168 MHz, a rich set of peripherals, various memory options, and advanced features.

The STM32F407G Discovery board features: STM32F407VG Microcontroller (ARM Cortex-M4, up to 168 MHz), ST-Link V2-1 Debugger/Programmer, four User LEDs, two User Push-Buttons, 3-Axis Accelerometer (LIS3DSH), MP45DT02 Digital MEMS Microphone, MicroSD Card Slot, USB Connectivity, 3.5mm Audio and Headphone Jacks, Color LCD Display with touchscreen, Extension Header, flexible Power Supply Options, Crystal Oscillators, Arduino Uno Compatible Header, and On-Board SWD/JTAG/ST-Link debug interfaces.

Digital Signal Processing (DSP): The Cortex-M4 core includes DSP instructions and hardware features that enable it to efficiently perform digital signal processing tasks, making it suitable for audio and sensor signal processing applications.

Floating-Point Unit (FPU): Many Cortex-M4-based microcontrollers, including the STM32F407VG, come with an optional Floating-Point Unit (FPU). The FPU accelerates floating-point mathematical operations, making it valuable for applications requiring precise numerical calculations.

Multicore Processing: In some STM32 microcontroller models, like the STM32H series, the Cortex-M4 core can work alongside other cores, such as a Cortex-M7 core, in a multicore processing setup.

Support for Debugging and Tracing: The Cortex-M4 core features extensive support for debugging and tracing capabilities, including breakpoints, watchpoints, and real-time trace functionality.

Core Performance: STM32F4 uses ARM Cortex-M4 (up to 180 MHz) with hardware FPU. STM32F1 uses Cortex-M3, STM32F0 uses Cortex-M0 — lower clock frequencies.

Memory: STM32F4 offers Flash up to 2 MB and RAM up to 192 KB. STM32L focuses on low power with smaller memory.

Real-Time Performance: STM32F4 is designed for real-time control, motor control, audio processing. STM32L is optimized for ultra-low-power operation.

Advanced Peripherals: STM32F4 includes high-speed USB, Ethernet, advanced timers, DSP instruction set. STM32H focuses on advanced connectivity.

Multicore Processing: Some STM32F4 models (e.g., STM32H7) support Cortex-M4 + Cortex-M7 multicore.

Select a Development Toolchain: Choose STM32CubeIDE, STM32CubeMX, and STM32CubeProgrammer (official) or open-source tools like GCC for ARM, Eclipse IDE, or PlatformIO.

Install Required Software: Install the toolchain, text editor, version control system (Git), and device drivers for your ST-Link debugger.

Install and Configure STM32CubeMX: A graphical tool that helps configure STM32 microcontrollers and generates initialization code.

Download CMSIS and HAL/LL Libraries: These provide essential functions and drivers for STM32 microcontrollers.

Generate Initialization Code: Use STM32CubeMX to configure peripherals and pin assignments, then generate initialization code.

Write, Compile, Flash, and Debug: Write application code in C/C++, compile, flash using ST-Link/JTAG/SWD, then debug using breakpoints and inspection tools.

Abstraction Level: HAL provides higher-level, user-friendly functions. LL provides direct register-level access.

Ease of Use: HAL is easier for beginners and rapid development. LL requires deeper hardware knowledge.

Performance: HAL has slight overhead. LL gives slightly better performance for time-critical code.

Code Size: HAL generates larger code. LL produces compact code, better for memory-constrained applications.

Compatibility: HAL is portable across STM32 families. LL may be more device-specific.

STM32CubeMX simplifies the configuration process by providing a graphical interface for: Configuration and Pin Mapping, Clock Configuration, Interrupt and NVIC Configuration, Middleware Stack Configuration (USB, FreeRTOS, FatFS), Code Generation in C, and Pinout and Power Consumption Analysis. It generates initialization code helping developers quickly set up their projects and focus on application-specific coding.

Steps: Install STM32CubeMX → Create Project → Select Pin → Configure Properties (Mode, Pull-up/down, Speed) → Enable GPIO Clock → Generate Code → Open in IDE → Configure GPIO in Code.

#include "main.h"
int main(void) {
  HAL_Init();
  SystemClock_Config();
  GPIO_InitTypeDef GPIO_InitStruct;
  __HAL_RCC_GPIOC_CLK_ENABLE();
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  while (1) {
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
    HAL_Delay(1000);
  }
}

Interrupt handling allows the microcontroller to respond to external events without constantly polling for them. Steps to configure interrupts on STM32F407G:

// Enable clock
__HAL_RCC_GPIOA_CLK_ENABLE();
// Configure pin as input
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
// Configure NVIC
HAL_NVIC_SetPriority(EXTI0_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
EXTI->RTSR |= EXTI_RTSR_TR0;
// ISR handler
void EXTI0_IRQHandler(void) {
  // Handle interrupt
  EXTI->PR = EXTI_PR_PR0;
}

The DMA (Direct Memory Access) controller allows efficient data transfer between memory and peripherals without CPU intervention. Benefits: Efficient Data Transfer, Reduced CPU Load, Power Efficiency.

DMA_HandleTypeDef hdma_adc;
hdma_adc.Instance = DMA2_Stream0;
hdma_adc.Init.Channel = DMA_CHANNEL_0;
hdma_adc.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_adc.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_adc.Init.MemInc = DMA_MINC_ENABLE;
hdma_adc.Init.Mode = DMA_CIRCULAR;
hdma_adc.Init.Priority = DMA_PRIORITY_HIGH;
HAL_DMA_Init(&hdma_adc);
__HAL_LINKDMA(&hadc1, DMA_Handle, hdma_adc);
HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adcBuffer, BUFFER_SIZE);

Extended Battery Life, Energy Efficiency, Heat Dissipation, Reduced Costs, Real-Time Performance.

Strategies: Clock Gating (disable unused peripherals), Low-Power Modes (Stop, Standby, Sleep), Dynamic Voltage and Frequency Scaling (DVFS), Interrupt-driven and DMA-assisted transfers, Firmware Optimization (avoid busy-wait loops).

Steps: Choose IDE → Create Firmware Image → Connect ST-Link/JTAG → Configure Tool → Erase Flash → Load and Program Image → Verify → Test.

Considerations: Bootloader, OTA Updates, Data Integrity (checksums/signatures), Fallback Mechanism, Version Control, Secure Boot, Testing and Validation, Rollback Plan.

Timers: General-Purpose Timers (TIM2, TIM3, TIM4), Real-Time Clock (RTC), PWM Generation, Capture and Compare, Input Capture.

PWM Applications: Motor Control, LED Dimming, Audio Generation, Power Supplies (switch-mode), Servo Control, Heating Control.

A bootloader handles initial system startup and firmware update procedures. Functions: Firmware Update, Initialization, Security, Fallback Mechanism.

Implementation steps: Create Bootloader Project → Configure → Define Update Mechanism (UART/USB/CAN/OTA) → Implement Update Logic → Security Measures → Fallback → Handoff to Main App → Configure Boot Memory Region → Build and Flash.

IDEs: STM32CubeIDE, Keil MDK, IAR Embedded Workbench, PlatformIO.

Programmers/Debuggers: ST-Link, J-Link, Black Magic Probe.

Analysis Tools: Oscilloscopes, Logic Analyzers, Serial Terminal (Tera Term, PuTTY), Power Analyzers.

RTOS Tools: FreeRTOS+Trace, Percepio Tracealyzer, SEGGER SystemView, Ozone.