C and C++ development environments

01The toolchain

Programming a microcontroller has one central difference from programming a PC: the program is written and compiled on one machine and run on another. This is called cross-compilation.

02Pointers

A pointer is a variable that holds a memory address. It is the concept that is hardest to grasp and the one that pays off most: without pointers there is no hardware access, no pass by reference, and no data structures.

int  x = 42;
int *p;          // p is a pointer to int

p = &x;         // p takes the ADDRESS of x
printf("%d", *p);  // prints 42 — * accesses the CONTENTS
*p = 7;          // now x is 7, without naming x

What they are really for

// does NOT work: receives copies
void mal(int a, int b) {
    int t = a; a = b; b = t;
}

// DOES work: receives addresses
void bien(int *a, int *b) {
    int t = *a; *a = *b; *b = t;
}
bien(&x, &y);

void leer_sensor(int *temp,
                 int *hum)
{
    *temp = medir_t();
    *hum  = medir_h();
}

int t, h;
leer_sensor(&t, &h);

Pointer arithmetic

Adding 1 to a pointer does not add 1 to the address: it adds the size of the pointed-to type. That is the reason a pointer has a type.

int v[5] = {10, 20, 30, 40, 50};
int *p = v;        // the array name is ALREADY the address of the first element

*p        // 10  — equivalent to v[0]
*(p + 2)  // 30  — equivalent to v[2]; advanced 2 * sizeof(int) bytes
p[2]      // 30  — bracket notation IS pointer arithmetic

// Traverse an array with pointers
for (int *q = v; q < v + 5; q++) {
    printf("%d ", *q);
}

03Structures, unions and typedef

A structure groups data of different types under a single name. It is what lets you treat “a sensor” or “a measurement” as a single thing.

typedef struct {
    uint8_t  id;
    int16_t  temperatura;   // in tenths of a degree
    uint16_t humedad;
    uint8_t  valido;
} Sensor;

Sensor s1;
s1.id = 3;
s1.temperatura = 235;      // 23.5 °C

Sensor red[8];             // an array of structures
red[0].humedad = 640;

Sensor *ps = &s1;
ps->id = 4;                // with a pointer, use -> instead of .

union {
    uint16_t palabra;
    uint8_t  byte[2];
} conv;

conv.palabra = 0xABCD;
// conv.byte[0] and [1] are
// 0xCD and 0xAB (or the reverse,
// depending on endianness)

struct {
    uint8_t habilitado : 1;
    uint8_t modo       : 2;
    uint8_t prescaler  : 3;
    uint8_t reservado  : 2;
} ctrl;

ctrl.modo = 2;   // readable

04Hardware access and device drivers

Here everything above comes together. In a microcontroller, peripherals are controlled by writing and reading registers located at fixed memory addresses. A pointer to a specific address is the mechanism that makes it possible.

// A register is a pointer to a fixed address, marked volatile
#define PORTB  (*(volatile uint8_t *) 0x25)
#define DDRB   (*(volatile uint8_t *) 0x24)
#define PINB   (*(volatile uint8_t *) 0x23)

DDRB  |= (1 << 0);   // PB0 as output
PORTB |= (1 << 0);   // PB0 high

The three elements of that line are the ones you need to understand:

• (volatile uint8_t *) 0x25 — converts the number 0x25 into a pointer to a byte at that address.
• volatile — forbids the compiler from optimizing the accesses, because the value can change by hardware.
• *(...) — dereferences, so that PORTB behaves like an ordinary variable.

What a device driver is

It is the software layer that translates between “what the program wants to do” and “the registers that have to be touched”. It isolates the rest of the program from the details of the chip.

// ---- led.h : the INTERFACE, the only thing the rest of the program sees ----
void led_init(void);
void led_on(uint8_t n);
void led_off(uint8_t n);
void led_toggle(uint8_t n);

// ---- led.c : the IMPLEMENTATION, specific to this micro ----
#include "led.h"
#include "registros.h"

void led_init(void)          { DDRB = 0xFF; PORTB = 0x00; }
void led_on(uint8_t n)     { PORTB |=  (1 << n); }
void led_off(uint8_t n)    { PORTB &= ~(1 << n); }
void led_toggle(uint8_t n) { PORTB ^=  (1 << n); }

05Bootloaders

A bootloader is a small program that lives in a reserved area of the flash and runs first at power-up. Its function is to be able to program the rest of the flash without needing an external programmer.

06Real time and interrupts

A system is real-time when responding late is equivalent to responding wrongly. It does not mean “fast”: it means predictable. An airbag that fires 200 ms late has failed, even if the processor is extremely fast.

while (1) {
  if (boton_apretado())
      accion();
  otras_tareas();
}

ISR(INT0_vect) {
    bandera = 1;   // short
}

while (1) {
  if (bandera) { ... }
}

07Concurrency

As soon as there are interrupts, there are two flows of execution sharing variables. And that is where errors appear that do not exist in a sequential program.

volatile uint16_t contador;   // 16 bits on an 8-bit micro

ISR(TIMER0_OVF_vect) { contador++; }

int main(void) {
    while (1) {
        uint16_t c = contador;   // ← DANGER
        ...
    }
}

uint8_t sreg = SREG;   // save the previous state
cli();                  // disable interrupts
uint16_t c = contador; // atomic read
SREG = sreg;            // restore (do NOT call sei() blindly)

08In the lab

09Common mistakes