Embedded C basics

Microcontrollers

A microcontroller (MCU) is a complete small computer on one chip: CPU, RAM (often a few KB to a few hundred KB), flash memory for the program, and peripherals such as GPIO pins, timers, ADCs (analogue-to-digital converters) and UARTs (serial ports). The Arduino Uno uses an 8-bit AVR chip (ATmega328P, 2 KB of RAM); STM32 and many others use 32-bit ARM Cortex-M cores. They run in washing machines, car engine controllers, glucometers, smart meters and drones.

Memory-mapped registers

Each peripheral is controlled by registers: special memory addresses where reading or writing bits controls the hardware. Writing a 1 to a bit in a GPIO output register drives a pin high (for example turning on an LED). In C, you access such an address through a pointer to a fixed address, declared volatile.

#include <stdint.h>

/* ILLUSTRATIVE addresses only: real ones come from your chip's reference manual or vendor headers */
#define GPIOA_ODR  (*(volatile uint32_t *) 0x40020014u)   /* output data register */
#define LED_PIN    5u

void led_on(void)     { GPIOA_ODR |=  (1u << LED_PIN); }   /* set bit 5 */
void led_off(void)    { GPIOA_ODR &= ~(1u << LED_PIN); }   /* clear bit 5 */
void led_toggle(void) { GPIOA_ODR ^=  (1u << LED_PIN); }

Why volatile?

Normally the compiler may keep a variable in a CPU register, skip repeated reads, or delete writes whose results it never sees used. For a hardware register, every read and write matters: the value can change on its own (a status bit set by hardware), and writes have effects outside the program. volatile tells the compiler: perform every access exactly as written, never cache it.

#define UART_SR  (*(volatile uint32_t *) 0x40011000u)   /* illustrative */
#define RXNE     (1u << 5)                               /* "received a byte" flag */

while ((UART_SR & RXNE) == 0) { }   /* without volatile, the compiler could read once and loop forever */

Fixed-width types and the build

Registers have exact widths, so embedded code uses uint8_t, uint16_t and uint32_t from <stdint.h> rather than int. Code is compiled on a PC with a cross-compiler such as arm-none-eabi-gcc (for ARM Cortex-M) or avr-gcc (for AVR), linked with a linker script that describes the chip's memory, and flashed through a programmer/debugger (ST-Link, J-Link) or a USB bootloader, as the Arduino IDE does.