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

1.1 Hello, world - every line explained

Every C program is made of functions, and one of them is special: main. That is where the program starts.

Here is the whole program. Type it, run it, then read the table under it.

#include <stdio.h>

int main(void)
{
    printf("Hello, embedded world!\n");
    return 0;
}

Hello, embedded world!

Every line, one at a time

Three rules that catch everyone

• C is case sensitive. main is not Main, and printf is not Printf.
• Every statement ends with a semicolon. The compiler will not guess where you meant to stop.
• Text goes in double quotes. 'A' is one character; "A" is text.

hello.c: In function 'main':
hello.c:5:39: error: expected ';' before 'return'
    5 |     printf("Hello, embedded world!\n")
      |                                       ^
      |                                       ;
    6 |     return 0;
      |     ~~~~~~

1.2 Variables and types

A variable is a named box in memory. Its type says how big the box is and how to read the bits inside.

Declaring and using them

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

int main(void)
{
    int      count      = 12;      /* a whole number, positive or negative */
    unsigned tries      = 3u;      /* a whole number, never negative       */
    char     grade      = 'B';     /* one character                        */
    float    volts      = 3.3f;    /* a number with a fractional part      */
    uint8_t  brightness = 255;     /* exactly 8 bits, 0 to 255             */

    printf("count      = %d\n", count);
    printf("tries      = %u\n", tries);
    printf("grade      = %c\n", grade);
    printf("volts      = %.2f\n", (double)volts);
    printf("brightness = %u\n", brightness);

    count = count + 1;             /* variables can change */
    brightness = 0;                /* the LED goes dark    */
    printf("after: count = %d, brightness = %u\n", count, brightness);

    printf("an int takes %zu bytes here\n", sizeof(int));
    return 0;
}

count      = 12
tries      = 3
grade      = B
volts      = 3.30
brightness = 255
after: count = 13, brightness = 0
an int takes 4 bytes here

Each line declares a variable: first the type, then the name, then an initial value. The text between /* and */ is a comment, written for people and ignored by the compiler.

The types you will use

Printing them

printf needs a format specifier for each value: a small code saying how to read it.

1.3 Making decisions: if and switch

if runs a piece of code only when something is true. switch picks one path out of many, when you are choosing on a single value.

int temperature = 42;

if (temperature > 60) {
    printf("too hot: turn the heater off\n");
} else if (temperature < 20) {
    printf("too cold: turn the heater on\n");
} else {
    printf("just right: do nothing\n");
}

just right: do nothing

The tests run in order, and the first true one wins. else catches everything left over.

The comparisons

In C there is no separate true or false type to learn first: 0 is false, and anything else is true. That is why if (count) means "if count is not zero".

if (mode = 3) {        /* assigns 3 to mode, and is always true */

switch: many fixed choices

switch (button) {
case 1:
    printf("button 1: start\n");
    break;
case 2:
    printf("button 2: stop\n");
    break;
case 3:
    printf("button 3: reset\n");
    break;
default:
    printf("no such button\n");
    break;
}

With button set to 2, that prints button 2: stop.

break leaves the switch. Without it, C carries straight on into the next case - which is sometimes useful and usually a bug:

fell into case 4
...and kept going into case 5

1.4 Repeating: for, while and do-while

All three loops do the same job - repeat while something stays true. They differ only in where the check happens, and how much bookkeeping they do for you.

for: when you know how many times

for (int i = 1; i <= 5; i++) {
    printf("blink %d\n", i);
}

blink 1
blink 2
blink 3
blink 4
blink 5

The brackets hold three parts, separated by semicolons.

while: when you do not know how many times

int level = 40;
while (level > 0) {
    level = level - 15;
}
printf("level ended at %d\n", level);     /* level ended at -5 */

int tries = 0;
do {
    tries++;
} while (tries < 3);
printf("tried %d times\n", tries);        /* tried 3 times */

A while loop checks first, so it can run zero times. A do-while runs the body first and checks afterwards, so it always runs at least once - even when the condition was false from the start:

this line runs once, although 99 > 100 is false

Leaving early: break and continue

break leaves the loop completely. continue skips the rest of this turn and goes to the next one. Adding up 1 to 10, skipping 4 and stopping at 7, gives:

sum of 1,2,3,5,6 = 17

for (;;) {        /* or: while (1) */
    do_the_work();
}

1.5 Functions

A function is a named piece of work. You hand it values, it does its job, and it can hand one value back. Firmware is mostly a set of small functions called from one loop.

#include <stdio.h>

/* declarations first, so main can call them */
int  add(int a, int b);
int  larger(int a, int b);
void print_banner(void);
void try_to_change(int value);

int main(void)
{
    print_banner();

    printf("add(2, 3)      = %d\n", add(2, 3));
    printf("larger(9, 4)   = %d\n", larger(9, 4));

    int reading = 100;
    try_to_change(reading);
    printf("reading is still %d\n", reading);
    return 0;
}

int add(int a, int b)
{
    return a + b;
}

int larger(int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}

void print_banner(void)
{
    printf("--- sensor board ---\n");
}

/* value is a copy, so changing it changes nothing in main */
void try_to_change(int value)
{
    value = 0;
    printf("inside the function, value = %d\n", value);
}

--- sensor board ---
add(2, 3)      = 5
larger(9, 4)   = 9
inside the function, value = 0
reading is still 100

The parts of a function

The lines at the top of the file, ending in a semicolon, are declarations. They tell the compiler what exists before it reaches the full definitions. Volume 15 shows how headers do this across several files.

The one surprise: C copies your arguments

Look at the last two lines of the output. The function set value to 0, yet reading in main is still 100. That is pass by value: the function received a *copy*, and changed the copy.

What you learned

• Every C program starts at main, and every statement ends with a semicolon.
• #include brings in a header so the compiler knows what printf and friends are.
• A variable has a type, which fixes its size and how its bits are read.
• printf needs the right format specifier for each value: %d, %u, %c, %f, %x.
• if and else if choose in order; switch picks one case, and needs break.
• for, while and do-while all repeat; only do-while always runs once.
• for (;;) is the endless loop every bare-metal program ends with.
• A function takes copies of its arguments, so it cannot change your variables.

Key words from this volume

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

• Function
• main
• Header file
• Standard library
• Statement
• Variable
• Data type
• Comment
• Format specifier
• Infinite loop
• Parameter
• Return value
• Pass by value

Practice

for (int i = 0; i < 5; i++)   { /* A */ }
for (int i = 1; i <= 5; i++)  { /* B */ }
for (int i = 0; i <= 5; i++)  { /* C */ }

int x = 0;
do {
    printf("%d ", x);
    x++;
} while (x < 3);
printf("| x = %d\n", x);

int clamp(int value)
{
    if (value < 0) {
        return 0;
    }
    if (value > 100) {
        return 100;
    }
    return value;
}

if (code = 42) {
    printf("unlocked\n");
}

Interview corner

Next, Volume 02 goes under the surface: bits, bytes and addresses, hexadecimal, the fixed-width types, two's complement, overflow, and why endianness bites when bytes travel between chips.