Embedded Systems

An embedded system is a computer built into a larger device to do one job, usually without a screen, keyboard, or user who thinks of it as a computer.

8 frameworks, from 1973 to today · Computer Architecture · Computer Science

still a working view ended · each leads to its entry below

Overview

An embedded system is a computer built into a larger device to do one job, usually without a screen, keyboard, or user who thinks of it as a computer1. The engine controller in a car, the flight computer in a drone, the pacemaker, the washing machine, the traffic light, the insulin pump: each contains a processor running a program fixed at design time, sensing the world and acting on it. What is at stake is a different set of constraints from those of the general-purpose computer. A desktop is judged on average speed; an embedded system is often judged on whether it answers in time, every time, on whether it runs for years on a battery or a coin cell, and on whether it can be trusted not to fail in a way that hurts someone. The history of embedded systems is the history of architecture bending to those constraints.

From stored-program computers to dedicated controllers

The stored-program idea, worked out in the late 1940s, made the general-purpose computer possible: one machine, many programs. But almost immediately engineers wanted the opposite—a machine that did one thing forever, cheaply. The Whirlwind flight simulator and the SAGE air-defense computers of the 1950s were early cases of computers built into a control loop rather than a data-processing room. The real shift came with the integrated circuit and then the microprocessor1. When Intel released the 4004 in 1971, a complete central processing unit sat on one chip; the 8-bit 8008 and 8080 followed, and by the mid-1970s the idea of putting a processor inside a product—a traffic controller, a terminal, a microwave—became ordinary engineering.

The Apollo Guidance Computer, flown on the lunar missions from 1969, is the emblem of the era: a machine with roughly 2,000 words of erasable memory and 36,000 words of fixed rope memory, designed so that its software could be woven once and never changed, and so that its real-time executive could schedule the landing tasks within a hard time budget. It showed both the power and the pain of the dedicated computer: everything had to be sized by hand, and the program lived in the hardware.

Microcontrollers: a computer on a chip for one job

The decisive architectural move was to put not just the processor but memory and input/output peripherals on the same chip1. Intel's 8048 (late 1970s) and the 8051 (1980) are the canonical early microcontrollers: a small CPU, a little ROM and RAM, timers, serial ports, and general-purpose pins that could be driven high or low to switch real hardware. The 8051's architecture—separate program and data memory spaces, bit-addressable registers, a handful of interrupt sources—became a template taught for decades. The point of a microcontroller is that the whole system fits in one package, so a product designer needs almost no other logic1.

The pattern repeated across vendors: Microchip's PIC family, Motorola's 68HC05 and 68HC11, Atmel's AVR (later the heart of the Arduino platform), and the ARM7TDMI-derived microcontrollers that arrived in the 1990s. Each generation traded a little generality for determinism and low cost. The architectural questions were concrete: how many interrupt priority levels, how fast can the processor wake from sleep, how much current does it draw when idle.

Real-time computing: correctness includes time

The intellectual core of the field is real-time computing2. A real-time system is one where the timing of a result is part of its correctness: a brake command that arrives late is wrong even if the arithmetic is right2. The distinction between hard deadlines (missing one is a failure) and soft deadlines (missing one degrades quality) was formalized in the 1970s and 1980s, largely through scheduling theory. C. L. Liu and James Layland's 1973 paper on scheduling algorithms for multiprogramming in a hard-real-time environment gave the field its founding result: rate-monotonic scheduling, in which tasks with shorter periods get higher priority, is optimal among fixed-priority schemes, and there is a simple utilization bound that guarantees all deadlines are met. Earliest-deadline-first scheduling, which is optimal among all preemptive schemes when deadlines equal periods, followed in the same tradition.

These results mattered because they turned "will it finish in time?" from a matter of testing into a matter of proof. A designer could compute a utilization bound and know, before running anything, that a task set would meet its deadlines. The theory also exposed its own limits: the simple bounds assume independent periodic tasks, no blocking, and known worst-case execution times—assumptions real systems violate, which drove decades of work on response-time analysis and on measuring worst-case execution time (WCET) for real processors, where caches and pipelines make the worst case hard to bound.

Real-time operating systems

Scheduling theory needed an operating system that could honor it. Early embedded programs were bare-metal loops with interrupts, but as systems grew, a small kernel that could switch between tasks on a timer became standard. The real-time operating system (RTOS) is that kernel: it provides tasks, priorities, a preemptive scheduler, inter-task communication, and bounded interrupt latency. VxWorks (1980s, Wind River), pSOS, QNX (whose microkernel design gave it strong isolation and predictable response), and the open-source FreeRTOS (2003) and Zephyr (2016) are landmarks. The design tension is constant: a general-purpose OS optimizes throughput and fairness, while an RTOS optimizes predictability, so it keeps critical sections short, avoids unbounded priority inversion (the problem where a high-priority task waits behind a low-priority one holding a lock—famously implicated in the 1997 Mars Pathfinder resets, fixed by priority inheritance), and lets the designer reason about the worst case rather than the average.

Digital signal processors: architecture for arithmetic streams

A separate lineage grew from signal processing. Filtering, modulation, and audio and video coding are dominated by repeated multiply-and-accumulate operations over streams of samples. General-purpose CPUs of the 1970s did this poorly. The digital signal processor (DSP) was built for it: a hardware multiplier, a barrel shifter, and an accumulator wide enough to hold intermediate products without overflow, plus special addressing modes—circular buffers and bit-reversed addressing—that make filter and fast-Fourier-transform loops cheap. Texas Instruments' TMS32010 (1982) is the usual starting point; the architecture's hallmark is the single-cycle multiply-accumulate, which let a modest clock rate outperform far faster general CPUs on filter code. Later DSPs added very-long-instruction-word parallelism and multiple execution units, and the boundary with general processors blurred as microcontrollers gained DSP extensions (ARM's Cortex-M4F, for instance).

System-on-chip: the whole system as one design

As transistor budgets grew, the integration that produced the microcontroller continued at a larger scale1. A system-on-chip (SoC) puts a processor core, memory, and a set of specialized blocks—a graphics unit, a radio modem, a video codec, a security engine—on one die, connected by an on-chip bus or network13. The ARM architecture, licensed as a core rather than sold as a chip, made this the dominant model from the 1990s: a company could buy a processor design, add its own peripherals, and ship a custom SoC. The design problem shifted from writing a program to partitioning a system: deciding which functions run in software on the processor and which become dedicated hardware, and how the blocks communicate. The AMBA bus family and later the network-on-chip are the plumbing that made these designs tractable. The smartphone is the mature form of the idea—a dozen specialized engines around application and modem processors—and the same pattern now appears in cars and industrial controllers.

Low-power design: energy as the first constraint

For battery-powered and energy-harvesting devices, power is not a cost but the design's boundary condition. The field's central insight is that dynamic power scales with the square of supply voltage and linearly with frequency, so slowing down and lowering voltage can save large amounts of energy—the basis of dynamic voltage and frequency scaling. The other lever is sleep: a microcontroller that spends most of its life in a deep-sleep mode drawing microamps, waking on an interrupt, doing its work, and returning to sleep, can run for years on a small battery. Architectural support for this—multiple sleep modes, wake-up timers, peripheral autonomy that lets a sensor trigger an action without waking the CPU—became standard. The same reasoning drove the design of ultra-low-power processors and the energy-harvesting sensor nodes that followed.

Embedded Linux and open platforms

Not every embedded system wants a bare-metal loop or a small RTOS. As processors grew capable enough to run an operating system with memory protection and networking, embedded Linux became the platform of choice for devices that need a rich software stack—routers, set-top boxes, industrial gateways, and later the Raspberry Pi (2012) and the Arduino ecosystem on the microcontroller side. The trade-off is stark: Linux gives enormous software leverage but weak timing guarantees, so hard-real-time work is often pushed to a separate microcontroller or handled with real-time patches. The open-source model also changed how the field is taught and prototyped: a student or startup can build a working embedded device from commodity boards and freely available toolchains, which widened the community enormously.

Mixed-criticality: when one machine must be trusted at several levels

The most recent architectural turn addresses a squeeze familiar from avionics and automotive design. Modern vehicles and aircraft want to consolidate many functions onto fewer, more powerful computers, but those functions have different criticality: a brake controller and an infotainment display should not share a processor naively4. Mixed-criticality systems research, crystallized in a 2007 paper by Steve Vestal and developed through the 2010s, asks how to guarantee the safety-critical tasks their deadlines even when lower-criticality tasks misbehave or overrun. The core idea is to design for multiple modes: a processor runs everything in normal operation, but when a high-criticality task needs more time than budgeted, the system degrades gracefully—shedding low-criticality work—rather than failing. This is a scheduling and architecture problem at once, and it connects back to the field's oldest theme: correctness is not just the answer, it is the answer arriving on time, under a stated set of assumptions.

The present

Today the field is defined by heterogeneity and by the collision of its old constraints with new ones. A modern embedded SoC is a mix of application processors running Linux, real-time cores, DSPs, and fixed-function accelerators, often with hardware support for security (secure boot, trusted execution environments) because connected devices are now attack surfaces. The microcontroller world has absorbed 32-bit ARM cores and low-power design as default, while the real-time world has absorbed the lesson that worst-case timing must be analyzed, not assumed. The open questions are the field's own: how to bound the timing of processors whose caches and pipelines were designed for average speed; how to certify mixed-criticality systems whose behavior depends on which tasks overrun; how to keep energy low enough for devices that must run for a decade; and how to make a system that is simultaneously connected, safe, and secure. The through-line from the Apollo computer to the present is unchanged: build a computer that does one job, and make it do that job correctly, on time, within its power budget, every time.

References

  1. Embedded system (introduction, Characteristics, Background, Development, ASIC and FPGA SoC solutions), Wikipedia
  2. Real-time computing, Wikipedia
  3. System on a chip, Wikipedia
  4. Mixed criticality, Wikipedia

The frameworks of Embedded Systems

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1973-Present

    Real-Time Computing

    How can a system guarantee it answers in time?

    Fly to its tower in Nousfarer

  2. 1976-Present

    Microcontroller

    How can a whole computer fit on one chip for one job?

    Fly to its tower in Nousfarer

  3. 1980-Present

    Real-time operating system

    How can an operating system keep timing predictable?

    Fly to its tower in Nousfarer

  4. 1982-Present

    Digital signal processor

    How should a processor be built for arithmetic on streams?

    Fly to its tower in Nousfarer

  5. 1990-Present

    Low-power electronics

    How can a device run for years on little energy?

    Fly to its tower in Nousfarer

  6. 1990-Present

    System on a chip

    How should a whole system be partitioned onto one chip?

    Fly to its tower in Nousfarer

  7. 2000-Present

    Linux on embedded systems

    Can a general-purpose operating system serve embedded devices?

    Fly to its tower in Nousfarer

  8. 2007-Present

    Mixed criticality

    How can tasks of different importance share one processor safely?

    Fly to its tower in Nousfarer

How the ideas connect

Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.

Real-Time ComputingMicrocontrollerReal-time operating systemDigital signal processorLow-power electronicsSystem on a chipLinux on embedded systemsMixed criticality

Beyond the field

Where Embedded Systems's ideas came from in other fields, and what they led to there: the strongest 12 of 42 links.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Embedded Systems is a planet in Nousfarer

Its city has a tower for each of these 8 frameworks. Land, walk in, and climb one concept at a time.

Land on Embedded Systems

Related fields

Fields its ideas are linked to

More in Computer Architecture

See where Embedded Systems sits on the Map of Human Knowledge