Using the language for low-level applications

01What “low level” means

A low-level program is one that talks directly to the hardware: it lights an LED by writing a bit into a register, reads a sensor by waiting for a status bit to change, builds a frame bit by bit to send it over a wire. In the stack of layers from the first topic, it means working just above the instruction set architecture, with no operating system in between.

C is suited to this because it has three things that high-level languages hide: bit operators, pointers to fixed addresses and types of known size. With them, the same language used to write a spreadsheet takes control of the pins of a chip.

02Bit operators and masks

A mask is a number that has 1s in the bits you want to act on. (1 << 5) is 0010 0000: only bit 5. With it, you get the four operations that are used all the time:

reg |=  (1 << n);     // set bit n to 1
reg &= ~(1 << n);     // clear bit n to 0
reg ^=  (1 << n);     // toggle bit n
if (reg & (1 << n))   // is bit n set to 1?

All four touch only the chosen bit and leave the others as they were. That is what matters when each bit of a register controls a different pin: turning on one LED must not turn off the one next to it.

03Registers at fixed addresses

In a microcontroller, peripherals are controlled through registers located at fixed memory addresses, published in the datasheet. In the ATmega328P (the one in the Arduino Uno), the output register of port B is at data address 0x25. In C it is reached with a pointer to that address:

#include <stdint.h>
#define PORTB (*(volatile uint8_t *)0x25)
#define DDRB  (*(volatile uint8_t *)0x24)

DDRB  |= (1 << 5);    // PB5 as an output (the on-board LED)
PORTB |= (1 << 5);    // and turned on

Read from the inside out: 0x25 is a number; (volatile uint8_t *) turns it into the address of a byte; the outer * accesses the byte that is there. From then on, PORTB is used like any other variable. The manufacturer’s header files (<avr/io.h>, the CMSIS ones on ARM) are built exactly this way.

04Exact-width types

The C standard only guarantees minimums: an int has at least 16 bits. On an AVR it has 16; on a PC, 32. A program that assumes 32 bits breaks when ported to a microcontroller. For work with hardware, the types from <stdint.h> are used, which state their size in the name:

05Byte order and bit fields

A uint32_t takes up four bytes, but in what order? In a little-endian processor (x86, almost all ARM, AVR) the least significant byte goes at the lowest address; in a big-endian one, the other way around. The value 0x12345678 stored at 0x100 ends up like this:

Inside a program it goes unnoticed. It shows up when sending data to another machine: network protocols use big-endian, which is why htons and ntohl exist. The portable way is to build the bytes with shifts, b[0] = x >> 24; b[1] = x >> 16; …, which gives the same result on any processor. This applies to any frame of serial communication.

C also allows declaring bit fields inside a structure, unsigned mode : 3;. They are convenient, but the standard leaves the order of the bits within the byte to the compiler. To describe hardware registers that must match the datasheet bit for bit, masks are safer.

06The program facing the hardware

A program for a microcontroller never ends: it initializes the peripherals and enters an infinite loop. Inside the loop it polls inputs and updates outputs; whatever is urgent is handled by an interrupt service routine, which communicates with the main loop through volatile variables:

volatile uint8_t data_ready = 0;
volatile uint8_t data;

ISR(USART_RX_vect)           // called by the hardware when a byte arrives
{
    data = UDR0;
    data_ready = 1;
}

int main(void)
{
    init();
    for (;;) {
        if (data_ready) {
            data_ready = 0;
            process(data);
        }
        /* rest of the work, without long delays */
    }
}

Interrupts and peripherals are covered in interrupts and in microcontroller peripherals.

07What the compiler does with this

The best way to convince yourself that C is close to the machine is to look at what it generates. For the AVR, with optimization:

The 0x05 is the address of PORTB in the I/O space, which in the data space is the 0x25 from the previous example: there is a difference of 0x20 because the first 32 bytes of the data space are the working registers. One line of C, one machine instruction: that is why there is no need to program in assembly to have fine control. Microcontrollers are covered in microprocessor architecture and the buses driven with these techniques, in serial buses.

08In the lab

09Common mistakes

• reg = (1 << n) instead of reg |= (1 << n): it turns one bit on and turns all the others off.
• reg &= (1 << n) to turn off: without the ~ it clears all the bits except n.
• Forgetting volatile on a register or on a variable shared with an interrupt.
• Shifting by more bits than the type has: 1 << 31 with a 16-bit int is undefined; write 1UL << 31.
• Confusing && with &: 4 && 2 is 1; 4 & 2 is 0.
• Writing magic numbers bare: PORTB |= 0x20 works, but (1 << PB5) is understandable.

10Self-assessment

11Further reading

• Michael Barr and Anthony Massa. Programming Embedded Systems: With C and GNU Development Tools. 2nd ed., O'Reilly, 2006. Registers, interrupts and peripherals in C, with examples on real hardware.
• Elecia White. Making Embedded Systems. 2nd ed., O'Reilly, 2024. How to design the software of an embedded system from end to end, with an engineering mindset.
• Randal E. Bryant and David R. O'Hallaron. Computer Systems: A Programmer's Perspective. 3rd ed., Pearson, 2016. Chapter 3 shows, line by line, what the compiler generates from C.
• Microchip Technology. ATmega328P Datasheet. Official datasheet, on the manufacturer’s website. The I/O register map and the instruction set that were used in this topic.