Electronics/Part VII: Modern Electronics/Microcontrollers

Chapter 20: Microcontrollers

A microcontroller unit (MCU) integrates a CPU, program memory, data memory, and a rich set of peripherals on a single chip. From the 8-bit Arduino UNO to the 32-bit ARM Cortex-M7, MCUs are the brain of every embedded system: motor controllers, IoT sensors, industrial PLCs, and medical devices. This chapter covers architecture, peripherals, interrupt-driven programming, and real-time operating systems.

Microcontroller Block Diagram

20.1 Harvard vs Von Neumann Architecture

Harvard Architecture

Separate address spaces and buses for program (instruction) memory and data memory. The CPU can simultaneously fetch the next instruction while reading/writing data — a hardware form of instruction-level parallelism. Used in most MCUs (AVR, PIC, ARM Cortex-M).

+ Simultaneous instruction fetch and data access
+ Fixed instruction width simplifies pipelining
− Two separate memory bus interfaces
− Cannot execute code from RAM (typically)

Von Neumann Architecture

A single unified memory space shared by instructions and data over one bus. Simple to implement; the bottleneck is the shared bus (the "Von Neumann bottleneck"). Used in x86/x64 PCs, ARM Cortex-A application processors.

+ Flexible: code and data share address space
+ Self-modifying code / JIT compilation possible
− Bus contention between instruction fetch and data
− Cache hierarchy needed to hide latency

20.2 Memory: Flash, SRAM, EEPROM

Flash

Non-volatile, stores program code. Erased in sectors (512 B – 128 KB). Write endurance ~10 000–100 000 cycles. Arduino Uno: 32 KB; STM32F4: up to 2 MB. Wear levelling needed for frequent writes.

SRAM

Volatile, fast random access, stores stack, heap, and global variables. Arduino Uno: 2 KB; STM32F4: 192 KB. Stack overflow is a common MCU bug — always monitor free stack space.

EEPROM

Non-volatile, byte-level erasable, stores configuration data (calibration, device ID). Typically 256 B – 4 KB on MCU; slow write (~3 ms/byte). Many modern MCUs emulate EEPROM in Flash using wear-levelling libraries.

20.3 Peripherals

GPIO — General Purpose I/O

Digital input or output pins, individually configured. Open-drain mode allows wired-OR connections. Pull-up/pull-down resistors programmable in hardware. Typical sink/source current: 8–25 mA per pin.

UART — Universal Async Receiver/Transmitter

Asynchronous serial: start bit, 8 data bits, optional parity, 1–2 stop bits. Baud rates: 9600, 115200, 1 Mbps. No clock line — baud rate must match on both ends. Used for debug consoles, GPS modules, GSM modems.

SPI — Serial Peripheral Interface

Synchronous: SCLK, MOSI, MISO, CS#. Full-duplex. Speeds up to 50 Mbps. Multiple slaves via separate CS lines. Used for SD cards, displays, DACs, ADCs, flash memory.

I2C — Inter-Integrated Circuit

Two-wire (SDA, SCL) multi-master/multi-slave. 7-bit addressing (up to 127 devices). 100 kHz standard, 400 kHz fast, 1 MHz fast-plus. Requires pull-up resistors. Used for sensors (IMU, pressure, humidity), RTCs, EEPROMs.

ADC — Analog-to-Digital Converter

Samples analog voltage, produces digital code. 10-bit (Arduino) to 16-bit (STM32). Successive-approximation register (SAR) architecture. Nyquist: sample rate ≥ 2× signal bandwidth. Anti-aliasing filter required before ADC input.

PWM — Pulse Width Modulation

Timer-generated digital square wave with variable duty cycle D = t_on / T. Used to control motor speed, LED brightness, servo position. Effective analog voltage: V_avg = D × V_supply. Resolution: 8–16 bits.

20.4 Interrupt Handling

An interrupt suspends the main program, saves CPU state (registers + PC on stack), executes an Interrupt Service Routine (ISR), then restores state and resumes. The Nested Vectored Interrupt Controller (NVIC) in ARM Cortex-M supports up to 240 external interrupts with 8–256 priority levels and hardware tail-chaining for back-to-back ISRs.

ISR design rules:

Keep ISRs short — do minimal work (set a flag, push to a queue) and process in the main loop.
Declare variables shared between ISR and main code as volatile to prevent compiler optimisation from caching them in a register.
Disable interrupts around multi-byte variable reads in main code (cli() / sei() on AVR; __disable_irq() on ARM).
Never call blocking functions (delay, print, malloc) inside an ISR.
Latency: ARM Cortex-M0 = 16 cycles; Cortex-M4 = 12 cycles from interrupt assertion to first ISR instruction.

20.5 Arduino Ecosystem & ARM Cortex-M

Arduino

The Arduino platform abstracts AVR and ARM hardware behind a C++ API: pinMode(), digitalWrite(), analogRead(), Serial.print(). The Uno uses an ATmega328P (8-bit AVR, 16 MHz, 32 KB Flash, 2 KB SRAM). The Due/Zero/MKR series use 32-bit ARM Cortex-M cores at 48–84 MHz.

The setup() function runs once; loop() runs repeatedly. Wire (I2C), SPI, and Servo libraries provide peripheral abstraction. Over 10 000 third-party libraries available via the Library Manager.

ARM Cortex-M & STM32

The ARM Cortex-M family spans M0 (tiny, low-power) through M7 (DSP, FPU, 400+ MHz). STM32 (STMicroelectronics) offers over 1 000 MCU variants. The STM32F4 Discovery (Cortex-M4, 168 MHz, 1 MB Flash, 192 KB SRAM) includes a hardware FPU, enabling single-cycle multiply-accumulate for DSP and motor control algorithms.

HAL (Hardware Abstraction Layer) and CMSIS (Cortex Microcontroller Software Interface Standard) provide portable driver APIs. STM32CubeMX generates initialisation code and FreeRTOS project scaffolding.

20.6 Real-Time Operating Systems — FreeRTOS

A Real-Time Operating System (RTOS) provides deterministic task scheduling, inter-task communication, and resource management. FreeRTOS is the most widely deployed RTOS, running on hundreds of MCU families and supported directly by AWS (Amazon FreeRTOS).

Tasks & Scheduler

Each task is a C function running in an infinite loop with its own stack. The scheduler (preemptive, priority-based) uses the SysTick timer (1 ms tick). Higher-priority tasks preempt lower ones. Cooperative scheduling is also available.

Queues

Thread-safe FIFO buffers for inter-task communication. Producer tasks block when full; consumer tasks block when empty. Used to pass sensor readings from an ISR to a processing task without shared-variable races.

Semaphores & Mutexes

Binary semaphore: signal/wait (ISR to task synchronisation). Counting semaphore: resource pool. Mutex: mutual exclusion with priority inheritance to prevent priority inversion — a critical RTOS concept.

Stack & Heap

Each task has its own stack (typically 256–2048 words). FreeRTOS heap (heap_4.c) provides malloc/free with fragmentation management. uxTaskGetStackHighWaterMark() monitors minimum free stack space.

20.7 PID Control — Mathematical Foundation

The PID controller is the most widely used control algorithm in embedded systems. The continuous-time output \(u(t)\) given error \(e(t) = r(t) - y(t)\) is:

\( u(t) = K_p\,e(t) + K_i \int_0^t e(\tau)\,d\tau + K_d\,\frac{de}{dt} \)

In discrete time with sample period \(T_s\) (Euler approximation):

\( u[k] = K_p\,e[k] + K_i\,T_s\sum_{j=0}^{k} e[j] + \frac{K_d}{T_s}(e[k] - e[k-1]) \)

Proportional K_p: Reduces rise time; leaves steady-state error. Too high → oscillation.

Integral K_i: Eliminates steady-state error by integrating past errors. Risk: integrator windup.

Derivative K_d: Damps oscillations by anticipating future error. Amplifies measurement noise.

Python: PID Temperature Control Simulation

The simulation models a first-order thermal plant (τ = 60 s) controlled by a discrete-time PID loop. The left panel shows the temperature response for five controller configurations — P-only, PI, and tuned PID. The right panel plots steady-state error vs K_p, demonstrating that integral action (K_i > 0) drives the error to zero regardless of gain.

Python

script.py102 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# PID controller for temperature regulation
# Discrete-time simulation: Ts = 1 second, 300 seconds total

Ts = 1.0          # sample period (s)
t = np.arange(0, 300, Ts)
N = len(t)

# Plant: first-order thermal model
# T_dot = -(T - T_amb)/tau_th + K_h * u
tau_th = 60.0    # thermal time constant (s)
K_h = 5.0        # heater gain (deg C per unit control)
T_amb = 20.0     # ambient temperature
T_set = 80.0     # setpoint

# Discrete plant (Euler forward)
# T[k+1] = T[k] + Ts * (-(T[k]-T_amb)/tau_th + K_h*u[k])

def simulate_pid(Kp, Ki, Kd, label, color, ax):
    T = np.zeros(N)
    u = np.zeros(N)
    e_int = 0.0
    e_prev = 0.0
    T[0] = T_amb

for k in range(N - 1):
        e = T_set - T[k]
        e_int += e * Ts
        e_der = (e - e_prev) / Ts
        e_prev = e
        u[k] = np.clip(Kp * e + Ki * e_int + Kd * e_der, 0, 10)
        T[k+1] = T[k] + Ts * (-(T[k] - T_amb) / tau_th + K_h * u[k])

ax.plot(t, T, color=color, linewidth=2.2, label=label)
    return T, u

fig, axes = plt.subplots(1, 2, figsize=(14, 6))
fig.patch.set_facecolor('#0a0a1a')

ax1 = axes[0]
ax2 = axes[1]

configs = [
    (0.05, 0.0,  0.0,  'P only  (Kp=0.05)', '#f87171'),
    (0.1,  0.0,  0.0,  'P only  (Kp=0.10)', '#fb923c'),
    (0.1,  0.002, 0.0, 'PI      (Kp=0.10, Ki=0.002)', '#fbbf24'),
    (0.1,  0.002, 2.0, 'PID     (Kp=0.10, Ki=0.002, Kd=2)', '#34d399'),
    (0.2,  0.005, 5.0, 'Tuned   (Kp=0.20, Ki=0.005, Kd=5)', '#22d3ee'),
]

for Kp, Ki, Kd, label, color in configs:
    T, u = simulate_pid(Kp, Ki, Kd, label, color, ax1)

ax1.axhline(T_set, color='white', linestyle='--', linewidth=1.2, label='Setpoint 80 C', alpha=0.7)
ax1.axhspan(T_set - 2, T_set + 2, alpha=0.08, color='#34d399', label='+/-2 C band')
ax1.set_xlabel('Time (s)', fontsize=12, color='white')
ax1.set_ylabel('Temperature (deg C)', fontsize=12, color='white')
ax1.set_title('PID Temperature Control — Step Response', fontsize=13, color='white', fontweight='bold')
ax1.legend(fontsize=8, facecolor='#1a1a2e', edgecolor='#34d399', labelcolor='white', loc='lower right')
ax1.set_facecolor('#0a0a1a')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.2, color='#34d399')
for spine in ax1.spines.values():
    spine.set_color('#34d399')

# Panel 2: Steady-state error vs proportional gain, and effect of integral action
Kp_range = np.linspace(0.01, 0.5, 50)
ss_errors_P = []
ss_errors_PI = []

for Kp_val in Kp_range:
    T_P, _ = simulate_pid(Kp_val, 0.0, 0.0, '', 'gray', ax2)
    T_PI, _ = simulate_pid(Kp_val, 0.003, 0.0, '', 'gray', ax2)
    ss_errors_P.append(abs(T_set - T_P[-1]))
    ss_errors_PI.append(abs(T_set - T_PI[-1]))

ax2.cla()
ax2.plot(Kp_range, ss_errors_P, color='#f87171', linewidth=2.5, label='P only — steady-state error')
ax2.plot(Kp_range, ss_errors_PI, color='#34d399', linewidth=2.5, label='PI (Ki=0.003) — error ~ 0')
ax2.set_xlabel('Proportional Gain Kp', fontsize=12, color='white')
ax2.set_ylabel('Steady-State Temperature Error (deg C)', fontsize=12, color='white')
ax2.set_title('Effect of Integral Action on Steady-State Error', fontsize=13, color='white', fontweight='bold')
ax2.legend(fontsize=10, facecolor='#1a1a2e', edgecolor='#34d399', labelcolor='white')
ax2.set_facecolor('#0a0a1a')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.2, color='#34d399')
for spine in ax2.spines.values():
    spine.set_color('#34d399')

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a')
plt.show()
print('PID simulation complete.')
print('P control: fast but leaves steady-state offset proportional to load disturbance')
print('PI control: eliminates steady-state error; integral windup can cause overshoot')
print('PID control: derivative damps oscillations; sensitive to measurement noise')
print('Ziegler-Nichols tuning: Ku (ultimate gain), Pu (ultimate period) => Kp=0.6Ku, Ti=Pu/2, Td=Pu/8')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Key Equations

PWM average voltage:\( V_{\text{avg}} = D \cdot V_{\text{supply}} \) — duty cycle D = t_on/T

ADC resolution:\( \Delta V = V_{\text{ref}} / 2^N \) — N-bit converter, 1 LSB voltage

PID discrete (Euler):\( u[k] = K_p e[k] + K_i T_s \sum e[j] + (K_d/T_s)(e[k]-e[k-1]) \)

UART bit period:\( T_{\text{bit}} = 1/f_{\text{baud}} \) — e.g. 115200 baud → 8.68 µs/bit

← PCB Design Next: RF, VLSI & Photonics →