Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 37 ยท Getting Started

What Is an Embedded System?

Learn what an embedded system is, where you find them, how they differ from desktop software, and the constraints (memory, power, time) that shape every design.

Look around the room you are in. A microwave, a TV remote, a thermostat, a car key, a washing machine, a smart watch, the router in the corner: each of them contains a small computer running a program that its owner never sees. These are embedded systems: computers built into a larger product to do one specific job, usually without a keyboard, a screen, or an operating system you can log into.

This course teaches you how to program them. Embedded work feels different from writing desktop or web software. You talk directly to hardware, you count bytes, you care about microseconds, and a bug can mean a motor that does not stop. In this first lesson you learn the vocabulary and the constraints that explain almost every design decision in the rest of the track.

The definition

An embedded system is a combination of hardware and software designed for a dedicated function, often as a part of a bigger mechanical or electrical system. Three ideas matter:

  • Dedicated: a washing machine controller washes clothes. It does not browse the web. Because the job is fixed, you can size the hardware exactly.
  • Embedded: the computer is hidden inside the product. The user interacts with buttons, knobs, sensors and lights, not with "a computer".
  • Real-world facing: the program reads sensors (temperature, speed, buttons) and drives actuators (motors, heaters, displays, radios). Time and physics are part of the problem.

Most embedded systems are built around a microcontroller (MCU): a single chip that holds a processor core, program memory, working memory and peripherals such as timers, serial ports and analog converters. You will study its inside in Microcontroller vs Microprocessor.

Where embedded systems live

Domain Examples What the software does
Home microwave, washing machine, smart lock timing, safety interlocks, simple user interface
Automotive engine control, airbags, ABS, parking sensors hard real-time control, functional safety
Medical pacemaker, insulin pump, patient monitor life-critical sensing and control, certification
Industrial PLCs, motor drives, robot arms deterministic loops, fieldbus communication
Consumer fitness band, earbuds, drone low power, wireless, sensor fusion
Infrastructure smart meters, traffic lights, elevators long life, remote updates, reliability

Embedded chips are by far the most numerous computers on Earth. A single modern car has dozens to well over a hundred separate processors, and billions of microcontrollers are sold every year.

The building blocks

Every embedded system, from a blinking LED to an aircraft component, follows the same simple pattern: sense, decide, act.

flowchart LR
    S["Sensors<br/>(temperature, buttons, speed)"] --> M["Microcontroller<br/>(your firmware)"]
    M --> A["Actuators<br/>(motor, heater, display, radio)"]
    A -. "changes the world" .-> S
    P["Power supply"] --> M
    C["Communication<br/>(UART, I2C, SPI, CAN, BLE)"] <--> M

The control loop: the world changes, sensors notice, firmware decides, actuators change the world again.

The program that runs on the microcontroller is called firmware, because it lives in non-volatile memory close to the hardware ("firm" between hard and soft). It starts when power is applied and, in most products, never ends.

How embedded software differs

Desktop software runs on a machine with gigabytes of memory, a file system, and an operating system that hides the hardware. Firmware usually has none of that. The differences show up everywhere:

Concern Desktop / server Typical embedded
Memory gigabytes, virtual memory from 2 KB to a few MB, no virtual memory
Program start user launches an app runs from power-on, forever
Failure exception, crash dialog, restart must recover alone; may be unreachable
Timing "fast enough" deadlines measured in microseconds
Hardware access through drivers and OS direct register access
Updates download and click flashed in the field, or never
Power wall outlet battery for months or years

Constraints you will meet again and again

  1. Memory. A small MCU may have 16 KB of flash and 2 KB of RAM. That is less than a single icon on your desktop. You choose data types carefully and avoid dynamic allocation.
  2. Processing power. Clock speeds from 1 MHz to a few hundred MHz, often with no floating-point hardware. A float multiply may cost dozens of cycles.
  3. Power. A coin cell holds about 600 joules. Every wasted CPU cycle shortens battery life, so cores sleep as much as possible (Low Power Design comes later in the track).
  4. Real time. A correct answer delivered too late is a wrong answer. Braking control that is 50 ms late can be fatal.
  5. Cost. If a product sells for a few dollars and ships in millions, saving ten cents on the chip pays for months of engineering.
  6. Reliability. Nobody reboots a pacemaker. Watchdog timers, defensive coding and testing are normal practice.

The six constraints

Memory KBs, not GBs
Power Battery for years
Real time Deadlines in microseconds
Cost Cents matter at scale

Every design choice trades between these.

1 / 2

Classifying embedded systems

You will see systems described by several overlapping labels:

  • By timing: hard real-time (missing a deadline is a failure: airbag), firm (a late result is useless but not catastrophic: video frame), soft (late results degrade quality: user interface).
  • By performance: small-scale (8-bit MCU, a few KB), medium (32-bit MCU such as an ARM Cortex-M, up to MBs), sophisticated (application processors running Linux, such as in a router or a car infotainment unit).
  • By connectivity: standalone, networked, mobile or wireless (the Internet of Things).

This course focuses on the first two performance classes, the world of "bare-metal" firmware and small real-time operating systems, because that is where you learn the fundamentals that carry over to every other class.

A taste: the simplest firmware

Every firmware program has the same shape. Here it is simulated in plain C so you can run it: set up, then loop forever (we stop after a few passes so the simulation ends). The "sensor" is just a function that returns made-up temperatures.

C The shape of every firmware program

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with scanf or fgets), it gets the next line from this box.

A real thermostat would add a small hysteresis band so the heater does not flicker around 22 degrees, a safety cutoff, and a sleep between readings. We will add those as the course goes on.

Notice what is different from an everyday C program: there is no input from a user, the result is not text but a change in the outside world, and the loop is meant to run for years. On a real chip, main must never return, because there is nothing to return to.

Memory is a budget

To feel the constraints, compare the size of common types with a typical budget. This program computes how many samples fit into a 2 KB RAM budget if half of RAM is reserved for everything else.

C How many samples fit in 2 KB?

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with scanf or fgets), it gets the next line from this box.

A 12-bit ADC reading needs only a uint16_t, so storing it in a double wastes four times the memory. Choosing the right type is the first embedded skill; Fixed-Width Types goes deeper.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which description best fits an embedded system?

    Embedded systems are dedicated, hidden computers inside a product. Having no monitor is common but is not the definition.
  2. 2. What is firmware?

    Firmware is the program stored in the device's non-volatile memory (usually flash), starting at power-on.
  3. 3. An airbag controller must fire within a few milliseconds of a crash. This is an example of:

    Missing the deadline is a failure of the function itself, which is the definition of hard real-time.
  4. 4. Why does embedded firmware usually avoid double on small MCUs?

    An 8-byte double costs RAM, and without floating-point hardware each operation runs as many instructions of library code.

Summary

  • An embedded system is a dedicated computer built into a product; its software is called firmware.
  • The core pattern is sense, decide, act, repeated forever.
  • Constraints (memory, power, timing, cost, reliability) drive nearly every design decision.
  • Embedded software talks directly to hardware, usually without an OS, and must run unattended.
  • Systems range from 8-bit MCUs to Linux-capable application processors; this course starts with bare-metal and small RTOS firmware.

Next: The Embedded Development Workflow