Embedded C Programming for Microcontrollers

Embedded C bridges high-level algorithms with physical silicon. While standard C applications run atop multi-gigabyte operating systems with virtual memory and file systems, embedded C firmware executes directly on resource-constrained microcontrollers—orchestrating hardware registers, timer interrupts, and peripheral sensors with deterministic timing.

1. Standard C vs. Embedded C Architecture

Understanding the architectural divide between desktop and embedded environments is crucial: • Desktop C: Runs in user space managed by an OS (Linux, Windows). Memory is virtualized via an MMU, processes are isolated, standard I/O (stdin/stdout) is available, and crashes are handled gracefully by signals. • Embedded C: Runs bare-metal or on a real-time operating system (RTOS) like FreeRTOS. Microcontrollers often feature as little as 16 KB of RAM and 128 KB of Flash. There is no virtual memory, no console output, and memory addresses map directly to physical hardware peripheral pins.

2. The Superloop Pattern: Why Embedded Systems Never Exit

Unlike command-line tools that execute main() and exit to the shell, an embedded system must operate indefinitely until physical power is removed. Embedded firmware utilizes a Superloop architecture consisting of a one-time hardware initialization phase followed by an infinite while(1) loop.

#define LED_PIN (1 << 5)

void hardware_init(void);
void poll_peripherals(void);

int main(void) {
    hardware_init(); // Configure clock trees, GPIO pins, and UART
    
    while (1) {      // Infinite control loop
        poll_peripherals();
    }
    return 0;        // Unreachable in bare-metal systems
}

3. Bit Manipulation & Hardware Register Masking

Embedded engineers configure microcontroller registers using three fundamental bitwise idioms: • Setting a bit (Turn ON): REG |= (1 << BIT_NUM); • Clearing a bit (Turn OFF): REG &= ~(1 << BIT_NUM); • Toggling a bit (Invert): REG ^= (1 << BIT_NUM); • Checking a bit state: if (REG & (1 << BIT_NUM)) { ... }

4. Memory-Mapped I/O and volatile Pointers

In microcontrollers (ARM Cortex-M, STM32, AVR, ESP32), hardware peripherals are mapped into fixed 32-bit physical memory addresses. Casting an address to a volatile pointer ensures the CPU reads the physical register pins directly rather than caching an old value in a CPU register.

// Memory-mapped address for GPIO Output Data Register
#define GPIOA_ODR (*((volatile unsigned int *)0x40020014))

void toggle_pin5(void) {
    GPIOA_ODR ^= (1U << 5); // Toggles pin state in real hardware
}