Microcontroller anatomy & GPIO

ALearning Material

A microcontroller (MCU) is a whole computer on one chip: CPU + memory + peripherals, designed to control hardware. Unlike a PC (which boots an OS and runs apps), an MCU usually runs one program directly "on the bare metal."

‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍A microcontroller is a whole computer squeezed onto one chip (CPU, memory, and peripherals) built not to run apps but to control hardware. Unlike a PC that boots an operating system, an MCU usually runs a single program directly 'on the bare metal', which means you are much closer to the silicon and responsible for things a desktop hides from you.

The central idea that unlocks everything is memory-mapped peripherals: you control hardware by reading and writing special memory addresses called registers. Set a particular bit and a pin goes high; set another and a timer starts. The datasheet is the map from peripheral to address. GPIO is the simplest example, and even it teaches a fundamental gotcha. An input pin left unconnected floats and reads random noise, so it needs a pull-up or pull-down to give it a defined level. Registers, bits, and defined logic levels are the vocabulary of every peripheral that follows.

What's inside: - CPU core (e.g. ARM Cortex-M): executes your instructions. - Flash: non-volatile program storage (your code lives here). - RAM: volatile working memory (variables); small, often KB. - ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍Peripherals: hardware blocks: GPIO, timers, ADC, UART/SPI/I²C, PWM.

Memory-mapped peripherals: the central idea. You control hardware by reading and writing special memory addresses called registers. Setting a bit in a register can switch a pin, start a timer, or send a byte. The MCU's datasheet maps every peripheral to addresses.

GPIO (General-Purpose Input/Output) is the simplest peripheral: pins you can set HIGH/LOW (output) or read as HIGH/LOW (input). Each GPIO pin needs configuring: - Direction: input or output. - For inputs: often a pull-up or pull-down resistor so a disconnected pin reads a defined level instead of "floating" (random noise). A button to GND with a pull-up reads HIGH when released, LOW when pressed.

Two ways to write the same blink (Arduino-style vs register-level):

// High-level (Arduino) - readable, portable
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);   // LED on

// Register-level (what's really happening on an AVR/STM32-like MCU)
DDRB  |= (1 << 5);        // set pin 5 of port B as output (Direction Register)
PORTB |= (1 << 5);        // drive it HIGH (Port Output Register)
PORTB &= ~(1 << 5);       // drive it LOW

‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍The |= (1 << n) / &= ~(1 << n) idiom (bit manipulation) sets/clears a single bit without disturbing the others, essential embedded vocabulary.

Why it exists. A microcontroller is the brain inside almost every robot, tool, and appliance. A whole computer on one chip that runs your code directly on the bare metal. The first mental shift is from "a program" to "flipping hardware bits at memory addresses."

Mental model. Registers are a wall of labelled light switches wired to the hardware. Flipping switch #5 in the "direction" panel makes a pin an output; flipping #5 in the "output" panel turns the actual pin on. Your code just flips switches.

Common misunderstandings.

• "PORTB = (1<<5) is fine to set one pin." Plain = overwrites all the bits; use |= / &= ~ to change one bit without disturbing the others.
• "An unconnected input pin reads 0." It floats and reads random noise. Give it a pull-up or pull-down for a defined level.
• "The MCU runs an operating system like a PC." Usually not. It runs one bare-metal program directly; your code ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍is the system.

Connections. Memory-mapped registers and bit manipulation are the foundation for interrupts and timers (next lesson), the Turn-2 STM32-peripherals lesson, and the button+UART project. Pull-ups reappear on the I2C bus (Turn 2) and the PCB project, and the fixed-rate loop from Python Turn 1 becomes a timer interrupt here.

BImmediate Active Recall

C‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍Conceptual Questions

Answer each in your own words in the box, then reveal the model answer to compare. These ask why, not how, and your answers are saved.

DPractice Problems

P1 (easy). Write the bit operation to clear bit 3 of register PORTC without affecting other bits.

P2 (medium). A button wired between a pin and GND reads random values when not pressed. What's missing, and which level will the pin read when the button is pressed?

P3 (harder). Explain why PORTB = (1 << 5) is risky compared to PORTB |= (1 << 5) if other pins on port B are also in use.

E‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍Feynman Exercise

Explain to a beginner what a microcontroller register is, using the "wall of labelled light switches" analogy. Then explain why we flip just one switch (|=/&=) instead of resetting the whole panel, and what "a floating input" means using the idea of a switch wired to nothing.

FError Analysis Framework

• Overwriting a whole register. Why: using = not |=/&=. Recognise: unrelated pins change. Avoid: read-modify-write single bits.
• Floating inputs. Why: no pull resistor. Recognise: random reads. Avoid: enable pull-up/down; know active-high vs active-low.
• Wrong direction register. Why: setting output value before direction. Recognise: pin won't drive. Avoid: configure direction first, then value.
• Bit-position off-by-one. Why: counting pins from 1 not 0. Recognise: wrong pin toggles. Avoid: check datasheet bit numbering (usually 0-based).

‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍GMini Challenge

A button wired from an MCU pin to ground reads erratically. Sometimes 'pressed' when it isn't. Name the cause and the one-component fix, and state what level the pin reads when pressed versus released once it's fixed.

Quiz Check

A quick auto-graded check, separate from the recall cards above. Your score is pooled with the recall cards into this module's Mastery score, and completing this lesson requires the quiz submitted with pooled mastery at 80% or above.