1. Home
2. Academy
3. Embedded C from Zero
4. Volume 00

0.1 What an embedded system is

An embedded system is a computer hidden inside something that is not a computer. It does one job, for years, and nobody thinks of it as a computer at all.

Your microwave has one. So does your washing machine, your car's wing mirror, the fitness band on your wrist and the charger for your phone. None of them has a screen full of apps. Each one has a small chip running a program that was written once and never changes.

That program is called firmware, and it is usually written in C.

Where you meet them

What makes embedded different

• One job, forever. The program starts when the power comes on and runs until the power goes off.
• Very little memory. A laptop has gigabytes. A small chip has a few kilobytes, and you count every byte.
• It cannot crash. Nobody reboots a smoke alarm. The code has to keep going for years.
• It touches the real world. Pins, sensors, motors and lights, not files and windows.
• Timing is part of the job. A late answer can be as wrong as no answer.

0.2 Microcontrollers vs computers

A microcontroller is a whole computer on one chip: a processor, its memory, and the hardware that reaches the outside world. It is small, cheap and slow by laptop standards, and that is exactly the point.

The same parts, a thousand times smaller

Look at the memory row again. A single photo would not fit in the SRAM of a small chip. That one fact shapes everything in this course.

0.3 How code becomes a running chip

A chip cannot read C. Your text file is turned into numbers the processor understands, given addresses, and copied into the chip's flash. At power-on, the chip starts running those numbers.

Four steps, every time

1. You write C. A file of plain text, such as blink.c. A person can read it; a chip cannot.
2. The compiler translates it. The compiler turns your C into machine code: the numbers this one processor knows how to obey.
3. The linker arranges it. The linker joins your pieces with the library pieces, and decides which address each part lives at.
4. The image is flashed. The finished firmware image is copied into the chip's flash over a cable. From then on the chip runs it every time it is powered.

Together, those programs are called the toolchain. When the compiler runs on your computer but makes code for a different processor, it is a cross-compiler. That is the normal case in embedded work: you write on a laptop, the code runs on a chip.

Here is a program of the kind this course builds towards. It will not run in an online compiler, because your computer has no pin called LED - but a chip does.

#include "board.h"

int main(void)
{
    led_init();                 /* set the LED pin as an output */

    for (;;) {                  /* forever */
        led_on();
        delay_ms(500);
        led_off();
        delay_ms(500);
    }
}

Notice the for (;;) loop with no end. On a computer, a program finishes and gives control back to the operating system. On a chip, there is nothing to go back to, so firmware loops for ever.

0.4 Tools: an online compiler, GCC and a simulator

You need nothing but a browser to do this course. Every program here compiles and runs in a free online C compiler, and prints its answer where you can see it.

Your first program

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    printf("Hello, embedded world!\n");
    printf("char %zu, short %zu, int %zu, long %zu bytes\n",
           sizeof(char), sizeof(short), sizeof(int), sizeof(long));
    return 0;
}

Run it, and you get:

Hello, embedded world!
char 1, short 2, int 4, long 8 bytes

The first line is the traditional greeting. The second asks the compiler how big its number types are, in bytes. Those sizes are not the same on every machine, and that turns out to matter a great deal in embedded work. Volume 02 comes back to it.

1. Open a free online C compiler in another tab.
2. Delete whatever example it starts with.
3. Type the program above. Typing it beats pasting: your fingers remember what your eyes skim.
4. Press Run, and read the output.

The three ways to run C in this course

0.5 How to use this course

Read in order, type every program yourself, and change one thing before you move on. That habit is worth more than any amount of reading.

How to work through a volume

1. Read the sub-module. Each one is short, and ends with a quick check.
2. Type the program. Not paste - type. You will meet the compiler's error messages, which is the point.
3. Run it, and read the output. Compare it with what the lesson says you should see.
4. Change one thing. A number, a type, an operator. Predict what happens, then run it again.
5. Take the quick check. If it goes wrong, the answer says why, and which idea to re-read.

What the boxes mean

A word about hardware

Nothing here needs a board. Where a lesson talks about registers or pins, it models them in plain C so the program still runs on your computer. Later, if you do pick up a board, everything transfers: the same C, the same ideas, real pins.

What you learned

• An embedded system is a computer built into a product, doing one fixed job for years.
• A microcontroller holds a processor, flash, SRAM and peripherals on a single chip.
• Flash keeps the program with the power off; SRAM holds the variables while it runs.
• Your C is compiled to machine code, linked to addresses, and flashed into the chip.
• A cross-compiler runs on your computer but makes code for the chip.
• Firmware loops for ever, because there is no operating system to return to.
• Everything in this course runs free in a browser; a board is optional.

Key words from this volume

Every word below has a plain-English entry in the glossary.

• Embedded system
• Firmware
• Microcontroller
• Compiler
• Machine code
• Linker
• Firmware image
• Toolchain
• Cross-compiler
• Byte

Practice

Interview corner

Next, Volume 01 writes real C: variables, decisions, loops and your own functions, with every program small enough to type in a minute.