All Topics
69 in-depth articles across 12 embedded systems domains.
Category
Difficulty
Tags
Compilation Pipeline
Understand what 'press Build' actually does: preprocessor, compiler, assembler, and linker — and what each stage produces.
Data Types & Memory Layout
C data types, memory sections (.text, .data, .bss, stack, heap), storage duration, fixed-width integers, and memory-aware programming for embedded systems.
FSM Fundamentals
States, events, transitions, and actions: the mental model for finite state machines, plus Mealy vs Moore and why FSMs beat nested if/switch.
Interrupts and priorities
Master interrupt service routine design, NVIC priority schemes, nested interrupts, and latency optimization for real-time embedded systems.
Memory Layout & Startup
How VMA/LMA, .data copy, .bss zero, and the C runtime preparation chain make C code work — Reset_Handler from Flash to main().
Pointers, Arrays & Pointer Arithmetic
Pointer fundamentals, pointer arithmetic, array decay, void pointers, and common interview traps — the building blocks of every embedded C program.
RTOS fundamentals
Understand real-time operating systems: hard vs soft real-time, task states, RTOS vs bare-metal tradeoffs, memory model, and FreeRTOS vs Zephyr comparison.
RTOS Scheduling and Timing
Understand preemptive vs cooperative scheduling, context switching mechanics and cost, rate monotonic analysis, timing analysis, and tickless idle for power-efficient RTOS systems.
RTOS Synchronization Primitives
Compare mutex vs semaphore, message queues, event flags, and understand priority inversion and deadlock prevention in RTOS-based embedded systems.
volatile and const
Master the volatile and const type qualifiers — what the compiler does differently, hardware register access, ISR-shared variables, const with pointers, volatile const for read-only hardware, and MISRA C implications.
ADC
ADC (Analog-to-Digital Converter) fundamentals including resolution, sampling theory, SNR, oversampling, and DMA integration for embedded systems.
BLE Basics
Bluetooth Low Energy fundamentals: BLE vs Classic Bluetooth, GAP advertising and connections, GATT services and characteristics, connection parameters, BLE 5.0 features, security, and power optimization for embedded systems.
Boot, vector table, and clock bring-up
Understand the hardware-side boot sequence on a Cortex-M MCU: reset sources, vector table, clock tree bring-up, and peripheral initialization order.
C++ Classes & OOP for Embedded
C++ classes in embedded systems — encapsulating hardware registers, constructors/destructors for init/deinit, inheritance for device hierarchies, the cost of virtual functions and vtables in ROM, CRTP as a zero-cost polymorphism alternative, and when to prefer composition over inheritance.
C++ Embedded Constraints & STL
Navigate C++ in resource-constrained embedded systems — disabled exceptions and RTTI, heap-free programming, safe STL subsets, compiler flags, C/C++ interop with extern C, and industry guidelines (MISRA C++, AUTOSAR C++14).
CAN
CAN (Controller Area Network) communication including classic vs FD, arbitration, bit timing, and error handling for embedded systems.
DMA
DMA (Direct Memory Access) fundamentals including transfer modes, channel configuration, circular buffers, and cache coherency for embedded systems.
Driver design: HAL vs bare metal
Understand HAL vs bare-metal driver design tradeoffs, abstraction layer architecture, register-level access patterns, and when to use each approach in embedded systems.
Embedded C Code Patterns
State machines, ring buffers, bit manipulation, error handling, memory-mapped I/O, volatile-safe patterns, and guard clauses -- the embedded C patterns interviewers expect you to write from memory.
Event-Driven State Machines
Move from polling to event-driven FSMs: RTOS queue dispatch, run-to-completion, ISR safety, and the active-object pattern.
FSM Patterns in C
Three implementation patterns for FSMs in C — switch-case, table-driven, function-pointer table — with trade-offs and a folded-in section on testing FSMs.
Function Pointers & Callbacks
Function pointer syntax and typedef, callback patterns (event handlers, dispatch tables, state machines), qsort as a classic example, HAL abstraction via function pointers, vtable-style polymorphism in C, and safety considerations for embedded systems.
GPIO
GPIO (General Purpose Input/Output) fundamentals including pin modes, push-pull vs open-drain, pull-up/pull-down resistors, interrupts, debouncing, and atomic port operations for embedded systems.
I2C
Master I2C (Inter-Integrated Circuit) communication including addressing, repeated start, clock stretching, and error recovery for embedded systems.
ISR-to-task patterns
Master the deferred processing pattern: how ISRs signal RTOS tasks using semaphores, queues, and task notifications, with FromISR API rules and double-buffering techniques.
Linker Scripts
Master the linker script: MEMORY and SECTIONS blocks, the location counter, KEEP/ALIGN, and how to place code and data exactly where you want it.
Linux boot process
Understand the embedded Linux boot sequence from power-on through U-Boot, kernel initialization, initramfs, and rootfs mounting to the first userspace process.
Linux build systems
Compare Yocto, Buildroot, and OpenWrt for building embedded Linux images. Understand layers, recipes, cross-compilation toolchains, and image generation.
Linux device tree
Understand device tree syntax, node structure, compatible strings, overlays, and how the kernel uses DTB to discover and configure hardware on embedded Linux systems.
Linux drivers and kernel modules
Understand Linux kernel modules, the driver model, character devices, platform drivers, and the probe/remove lifecycle for embedded Linux driver development.
Linux IPC mechanisms
Compare Linux inter-process communication mechanisms — pipes, shared memory, Unix sockets, message queues, signals, and D-Bus — and know when to use each in embedded systems.
MCU cores and clocking
Understand ARM Cortex-M core families, RISC-V in embedded, clock tree architecture, PLL configuration, and power modes for optimal embedded system design.
Memory Alignment & Endianness
Memory alignment rules, struct padding and reordering, endianness (big vs little), network byte order, byte swapping, and portable serialization for cross-architecture embedded systems.
MQTT
MQTT protocol for IoT: publish/subscribe model, topic hierarchy and wildcards, QoS levels (0/1/2), retained messages, last will and testament, persistent sessions, MQTT 5.0, broker selection, and embedded client considerations.
RAII & Smart Pointers
Master RAII (Resource Acquisition Is Initialization) and smart pointers for embedded C++ — deterministic cleanup, lock guards, DMA buffer ownership, unique_ptr with custom deleters, and heap-free RAII patterns.
Sockets API Basics
Sockets API lifecycle for embedded systems: socket/bind/listen/accept/connect/send/recv/close, TCP vs UDP patterns, blocking vs non-blocking I/O, select/poll/epoll multiplexing, socket options, error handling, and lwIP vs Linux sockets.
SPI
Master SPI (Serial Peripheral Interface) communication including modes, CS handling, multi-slave timing, and throughput optimization for embedded systems.
Structs, Unions & Bitfields
Structure layout and padding, packed structs, unions for type punning and register overlays, bitfields for hardware register mapping, and portability pitfalls — all through the lens of embedded systems interviews.
TCP/IP Fundamentals
TCP/IP protocol stack for embedded systems: layers, TCP vs UDP, three-way handshake, flow control, congestion control, sockets API, and lightweight stacks (lwIP).
Templates & Constexpr
Zero-cost abstractions with C++ templates and constexpr — compile-time register maps, type-safe units, static polymorphism via CRTP, constexpr lookup tables, and managing template bloat on flash-constrained MCUs.
Timers and PWM
Master timer peripherals and PWM generation including counting modes, prescaler configuration, input capture, output compare, and dead-time insertion for embedded systems.
TLS for Embedded Systems
TLS in embedded systems: TLS 1.2 vs 1.3 handshake, certificate vs PSK authentication, RAM/flash costs on Cortex-M, hardware crypto acceleration, DTLS for UDP protocols, certificate management in the field, and embedded TLS library comparison (mbedTLS, wolfSSL, BearSSL).
UART
Master UART (Universal Asynchronous Receiver-Transmitter) communication including baud rate configuration, framing, DMA, flow control, and common pitfalls in embedded systems.
WiFi for Embedded
WiFi for embedded systems: station vs AP mode, provisioning methods, power management (DTIM, light/deep sleep), WPA2/WPA3 security, embedded WiFi modules, and decision matrix for choosing WiFi vs BLE vs cellular.
Wireless Technology Selection Guide
Decision matrix for choosing the right wireless technology for embedded IoT: BLE vs WiFi vs LoRa vs Cellular vs Zigbee/Thread vs UWB compared across range, data rate, power, topology, cost, and use case. Includes a decision flowchart and common multi-radio combinations.
Cellular IoT: NB-IoT & LTE-M
Cellular IoT for embedded systems: NB-IoT vs LTE-M (Cat-M1) comparison, PSM and eDRX power saving, AT command modem control, SIM/eSIM provisioning, cellular module integration, data plan considerations, and 5G RedCap for IoT.
CPU fundamentals for embedded
Understand CPU pipeline, cache coherency with DMA, memory barriers, bus architecture (AHB/APB), and memory types (SRAM, TCM, CCM) — the computer architecture concepts embedded interviewers actually test.
Debugging embedded systems
Master embedded debugging: JTAG/SWD, GDB remote debugging, hard fault analysis, printf vs trace, logic analyzers, and systematic debugging methodology.
ELF, Map & Binary Inspection
Read ELF files and linker map files to debug binary-size, symbol-resolution, and unexpected-bloat issues using objdump, nm, size, readelf, strip, and addr2line.
Hardware fundamentals for firmware engineers
Essential EE concepts for embedded interviews: reading schematics, pull-up resistors, LDO vs switching regulators, decoupling caps, voltage levels, and power sequencing.
Hierarchical State Machines
How nested states + behavioral inheritance solve the state-explosion problem; UML statecharts, the QP framework, and when an HSM is justified over a flat FSM.
HTTP REST for IoT
HTTP and REST for embedded/IoT: REST principles, HTTP/1.1 vs HTTP/2, API design for embedded devices, JSON vs CBOR, authentication (API keys, OAuth, JWT), TLS overhead on constrained devices, CoAP for constrained networks, and when REST is appropriate versus lightweight protocols.
Industry safety and security standards
Overview of embedded industry standards: IEC 61508, ISO 26262, IEC 62304, DO-178C, and MISRA C — what firmware engineers need to know for interviews.
Inline Functions & Macros
#define macros (object-like, function-like, pitfalls), inline functions (type safety, debugging advantages), preprocessor directives (include guards, #pragma once, #ifdef), MISRA C guidelines, X-macros, and static inline for header-file functions.
Linux userspace basics
Understand the embedded Linux userspace environment: root filesystem layout, filesystem types for Flash, init systems, BusyBox, process model, and debugging tools.
LoRa & LoRaWAN
LoRa and LoRaWAN for embedded IoT: PHY vs protocol stack, spreading factor/bandwidth/coding rate trade-offs, LoRaWAN architecture, device classes (A/B/C), OTAA vs ABP activation, ADR, duty cycle restrictions, and comparison with NB-IoT and Sigfox.
Low-power design techniques
System-level power optimization for embedded: battery budgeting, duty cycling, peripheral power management, wake-up strategies, and sleep current auditing.
Make & CMake for Embedded
Compare Make and CMake for embedded projects: rules, targets, toolchain files, and when to use each.
Mesh Networking: Zigbee, Thread & Matter
Mesh networking for embedded IoT: why mesh matters (self-healing, range extension), Zigbee architecture and ZCL, Thread's IP-native mesh over 802.15.4, Matter as the unifying application layer, and choosing mesh vs star topology.
OTA updates and rollback
Design reliable over-the-air firmware updates: A/B partitioning, delta updates, rollback strategies, update security, and power-fail safety.
Power profiling and measurement
Measure and optimize embedded power consumption: current probes, power analyzers (PPK2, Joulescope), software estimation, and profiling methodology.
Safety mechanisms for embedded systems
Implement safety mechanisms: defensive programming, watchdog strategies, memory integrity checks, redundancy patterns, and fail-safe vs fail-operational design.
Secure boot and cryptography
Understand secure boot chains, hardware crypto accelerators, TLS for embedded, key management, and common embedded security attacks.
Signal integrity and EMC
Understand signal integrity and electromagnetic compatibility: rise times, reflections, EMC compliance, grounding strategies, and PCB layout awareness for firmware engineers.
Testing and code coverage
Embedded testing strategies: unit testing with Unity/CppUTest, HIL testing, code coverage with gcov, static analysis, and CI/CD for embedded.
Toolchains & Cross-Compilation
Understand cross-compilation: gcc + binutils + libc components, sysroot, target triplets, and the float-ABI/CPU flags that pin a build to specific hardware.
Ultra-Wideband (UWB)
Ultra-Wideband for embedded systems: short-pulse wideband radio for precise ranging, IEEE 802.15.4z, TWR vs TDoA ranging methods, UWB vs BLE positioning comparison, digital car keys, indoor positioning, and embedded UWB chips.
USB
USB (Universal Serial Bus) fundamentals including device architecture, transfer types, enumeration, descriptors, and common device classes for embedded systems.
Watchdog Timer
Watchdog timer fundamentals including IWDG vs WWDG, windowed mode, feeding strategies, and system recovery for reliable embedded systems.