Embedded Systems English Vocabulary: 70 Essential Terms

Embedded systems engineers work at the boundary of hardware and software — writing firmware for microcontrollers, configuring peripherals, and deploying to constrained devices. The vocabulary is hardware-heavy and highly specific. This guide covers the 70 terms you need to communicate confidently in embedded and IoT development.

Core Concepts

Embedded System

An embedded system is a computer designed to perform a specific function within a larger system, typically with constrained resources (CPU speed, RAM, flash, power). Examples: microwave controllers, car ECUs, IoT sensors, industrial PLCs.

Firmware

Firmware is software stored in non-volatile memory (flash) on a hardware device. Unlike application software, firmware directly controls hardware and rarely changes after deployment.

“The factory flashes the latest firmware before shipping. Updates are delivered OTA in the field.”

Bare-Metal Programming

Bare-metal programming means writing software that runs directly on hardware without an operating system — the engineer manages memory, peripherals, and timing manually.

MCU (Microcontroller Unit)

An MCU is a compact integrated circuit containing a processor, RAM, flash memory, and peripherals on a single chip. Examples: STM32 (ARM Cortex-M), ESP32 (Xtensa), ATmega328 (AVR), RP2040.

SoC (System-on-Chip)

A SoC integrates a more powerful processor, GPU, memory controller, wireless radios, and peripherals into a single chip. Examples: Raspberry Pi 4 (BCM2711), Apple M-series, Qualcomm Snapdragon.

Hardware Interfaces & Peripherals

GPIO (General-Purpose Input/Output)

A GPIO pin can be configured as digital input (read a button state) or digital output (drive an LED). The most fundamental microcontroller peripheral.

“GPIO pin PA5 is configured as output to drive the status LED.”

UART (Universal Asynchronous Receiver-Transmitter)

UART is a serial communication protocol for point-to-point communication between two devices. Common baud rates: 9600, 115200 bps. Used for debug consoles and simple sensors.

SPI (Serial Peripheral Interface)

SPI is a synchronous serial protocol for high-speed, short-distance communication — master/slave architecture with separate clock (SCLK), data (MOSI/MISO), and chip select (CS) lines. Used for displays, sensors, flash memory.

I2C (Inter-Integrated Circuit)

I2C is a two-wire serial protocol (SDA + SCL) supporting multiple devices on the same bus, each addressed by a 7-bit address. Slower than SPI but requires fewer pins. Used for sensors, EEPROMs, RTCs.

PWM (Pulse-Width Modulation)

PWM varies the duty cycle (proportion of time a signal is HIGH) to approximate an analogue output. Used for motor speed control, LED dimming, and servo positioning.

“We control the fan speed by adjusting the PWM duty cycle from 20% to 100%.”

ADC (Analogue-to-Digital Converter)

An ADC converts an analogue voltage (e.g., from a thermistor) to a digital number. Resolution is in bits — a 12-bit ADC gives 4096 possible values.

DAC (Digital-to-Analogue Converter)

A DAC converts a digital value to an analogue voltage — used for audio output or reference voltage generation.

DMA (Direct Memory Access)

DMA allows peripherals to transfer data directly to/from memory without CPU involvement, freeing the CPU for other work.

“The SPI DMA transfer completes in background — the CPU isn’t blocked during the display refresh.”

Interrupt

An interrupt is a hardware signal that pauses the main program to execute an ISR (Interrupt Service Routine). Used for time-sensitive events: button presses, UART data received, timer overflow.

“The UART receive interrupt fires whenever a byte arrives — we buffer it in a ring buffer.”

Watchdog Timer (WDT)

A watchdog timer resets the MCU if the firmware fails to periodically “kick” (reset) the timer — detects and recovers from infinite loops, deadlocks, or hangs.

Memory

Flash Memory

Flash memory is non-volatile storage where firmware and constant data are stored. On most MCUs, flash is where your program code lives.

SRAM (Static RAM)

SRAM is the fast, volatile working memory where the stack, heap, and global variables reside. Typically 64 KB – 1 MB on MCUs — scarcity requires careful management.

EEPROM

EEPROM is byte-addressable non-volatile storage for configuration data and calibration values. Slower than flash but supports individual byte writes without erasing a sector.

Stack vs. Heap

The stack stores local variables and function call frames (LIFO). The heap stores dynamically allocated memory. Stack overflows are a critical embedded bug — often caused by deep recursion or large local buffers.

Memory-Mapped I/O

Memory-mapped I/O maps peripheral registers into the address space — you configure and read peripherals by reading and writing specific memory addresses. Fundamental to how MCU peripherals work.

RTOS (Real-Time Operating System)

RTOS

An RTOS is a lightweight operating system designed for deterministic, time-critical applications. It provides task scheduling, inter-task communication, and synchronisation — without the overhead of a full OS.

Popular RTOSes: FreeRTOS (open source), Zephyr, Mbed OS, ThreadX.

Task / Thread

In an RTOS, a task (or thread) is an independently scheduled execution unit with its own stack. Tasks run concurrently, managed by the scheduler.

Preemptive Scheduling

Preemptive scheduling allows the RTOS to interrupt a running task and switch to a higher-priority task at any time. Ensures high-priority work (reading a sensor, responding to an interrupt) is not delayed.

Priority Inversion

Priority inversion is a hazard where a high-priority task is blocked waiting for a resource held by a low-priority task, while a medium-priority task preempts the low-priority task. Solved by priority inheritance mechanisms.

Mutex / Semaphore

A mutex (mutual exclusion) prevents two tasks from accessing a shared resource simultaneously. A semaphore is a signalling primitive — used for task synchronisation and resource counting.

Queue / Message Queue

A message queue passes data between tasks safely. A producer task writes to the queue; a consumer task reads from it — decoupling production and consumption.

Tick / System Tick

The system tick is the RTOS heartbeat — a timer interrupt at a fixed interval (e.g., 1 ms). Used for task scheduling and timeout management.

Communication Protocols (IoT)

MQTT (Message Queuing Telemetry Transport)

MQTT is a lightweight publish-subscribe protocol for IoT — devices publish sensor data to topics; a broker distributes it to subscribers. Designed for unreliable, low-bandwidth networks.

CoAP (Constrained Application Protocol)

CoAP is a REST-like protocol for constrained devices — analogous to HTTP but runs over UDP with minimal overhead. Suitable for microcontrollers with limited TCP/IP support.

BLE (Bluetooth Low Energy)

BLE is a short-range wireless protocol for battery-powered IoT devices — designed for infrequent, low-bandwidth data transfer. Used in fitness trackers, beacons, and medical devices.

LoRa / LoRaWAN

LoRa (Long Range) is a radio modulation technique for sending small amounts of data over long distances (10–15 km) at very low power. LoRaWAN is the network protocol built on LoRa — used in smart cities, agriculture, and remote monitoring.

Zigbee / Thread / Matter

Zigbee and Thread are mesh networking protocols for smart home devices. Matter is the new interoperability standard (supported by Apple, Google, Amazon) that abstracts over Wi-Fi, Thread, and Bluetooth.

OTA (Over-the-Air) Update

An OTA update delivers firmware updates to deployed devices wirelessly — without physical access. A critical feature for managing fleets of IoT devices. Requires secure verification of the update package.

“We pushed the OTA update to 50,000 devices — it includes a security patch for the Bluetooth authentication vulnerability.”

Build & Debugging

Toolchain

A toolchain is the set of compiler, linker, debugger, and build tools for a target architecture. Common toolchains: GNU Arm Embedded, Clang/LLVM, IAR Embedded Workbench.

Cross-Compilation

Cross-compilation means compiling code on a development machine (e.g., x86 Linux) to run on a different target architecture (e.g., ARM Cortex-M). All embedded development is cross-compiled.

JTAG / SWD

JTAG and SWD (Serial Wire Debug) are hardware debugging interfaces. A debug probe (J-Link, ST-Link) connects to these pins to flash firmware and set breakpoints.

Breakpoint / Watchpoint

A breakpoint pauses execution at a specific line of code. A watchpoint pauses execution when a specific memory address is read or written — useful for catching memory corruption.

Logic Analyser / Oscilloscope

A logic analyser captures digital signal timing on multiple channels — essential for debugging UART, SPI, and I2C communication. An oscilloscope captures analogue waveforms.

Safety & Power

Safety-Critical

A safety-critical system is one where failure could cause injury or death — automotive, aerospace, medical. Requires compliance with standards: IEC 61508, ISO 26262, DO-178C.

Functional Safety

Functional safety ensures that a system responds correctly to its inputs, even in the presence of hardware faults. Defined by ISO 26262 (automotive) and IEC 61508 (general industrial).

Low-Power Mode / Sleep Mode

Embedded devices conserve energy by entering sleep modes when idle — disabling the CPU and peripherals, keeping only a timer or interrupt source active to wake up. Critical for battery-powered devices.

Power Budget

A power budget estimates total power consumption across all modes (active, sleep, radio transmit/receive) to predict battery life.

“Active current is 15 mA, sleep current is 5 µA. With a 2000 mAh battery and 99% duty cycle in sleep, expected lifetime is 4 years.”

Useful Phrases

In hardware bring-up:

“The I2C sensor isn’t responding — I’ll probe the SDA and SCL lines with a logic analyser to check the signal integrity.”
“The ADC readings are noisy — we need to add a decoupling capacitor and check the reference voltage.”

In firmware reviews:

“This ISR is too long — move the processing to a task and just set a flag in the ISR.”
“Watchdog is disabled in this configuration — it should always be enabled in production firmware.”

In debugging:

“The stack overflow is caused by the recursive parser — we need to refactor it iteratively and allocate the buffer statically.”
“The MQTT reconnect loop spins without backoff — it’ll drain the battery in minutes if connectivity is lost.”

Practice

Test your embedded and IoT vocabulary with the Embedded Systems & IoT exercise set — 5 exercises covering microcontroller concepts, RTOS, and communication protocols.

Explore the full Embedded & IoT learning path for exercises, interview prep, and technical documentation practice.