GPIO — input - output, pull-up - pull-down, interrupt on pin change: Visual walkthrough

Every symbol below is earned before it is used. If you have never seen a resistor, a transistor, or the word "voltage", start at Step 1 and you will still be fine.

Step 1 — A wire has a voltage, and the pin reads it

WHAT. Look at the figure. A GPIO pin is the end of a metal wire. Electricity in a wire is described by one number: its voltage, written $V$ and measured in volts (V). Think of voltage as how much electrical "push" or "height" the wire is sitting at, like the height of water in a tank.

WHY this idea first. Everything else — HIGH, LOW, pull-up, edge — is just a voltage compared to a threshold. If you don't have the picture of "a wire sitting at some height", nothing later makes sense.

PICTURE. The wire sits at a height between the floor ( $GN D$ , meaning ground, defined as $0 V$ — our zero reference) and the ceiling ( $V_{D D}$ , the chip's supply voltage, e.g. $3.3 V$ ). The little triangle is the sense buffer — the chip's "eye" that looks at the wire and decides:

$read = {HIGH (logic 1) LOW (logic 0) if V > V_{T H} if V < V_{T H}$

$V$ ::: the wire's actual voltage (its "height") right now.
$V_{T H}$ ::: the threshold, a fixed height (≈ half of $V_{D D}$ ) the chip compares against.
The buffer outputs a single bit: $1$ if the wire is above the line, $0$ if below.

Figure — GPIO — input - output, pull-up - pull-down, interrupt on pin change

Step 2 — Nothing connected = the wire floats = random reads

WHAT. Disconnect everything. Now no one is holding the wire at a height. The sense buffer is high-impedance — a fancy way of saying it barely draws any current, so it can't set the wire's height either. The wire is left as a tiny capacitor: a bucket that holds a tiny bit of charge and whose voltage drifts.

WHY this step exists. This is the beginner disaster the parent note warns about. To justify the pull resistor in Step 3, you must first feel the problem: an unheld wire's height wanders up and down as nearby noise couples in.

PICTURE. The red trace wobbles across the threshold line unpredictably. Every time it crosses $V_{T H}$ the read flips $1, 0, 1, 0$ … The pressed/not-pressed answer is pure noise. (Hysteresis from Step 1b helps once the wire is near a level, but here it swings across the whole range, so even a Schmitt trigger reads garbage — the real fix is a pull resistor.)

Step 3 — A pull-up resistor gives the wire a resting height

WHAT. Add a resistor — a component that lets current through but resists it, measured in ohms ( $Ω$ ) — from the wire up to the ceiling $V_{D D}$ . This is a pull-up. When nothing else touches the wire, the resistor gently ties it to $V_{D D}$ , so it rests at HIGH.

WHY a resistor and not a plain wire to $V_{D D}$ ? A plain wire would jam the pin HIGH forever — a button could never pull it down without a dead short. A resistor is a soft connection: strong enough to set the idle height, weak enough that a button can overrule it. We prove "weak enough" in Step 5.

PICTURE. With the button open, the resistor's top is at $V_{D D}$ and its bottom is the wire; since the buffer draws ≈ 0 current, no current flows, so there's no voltage drop across the resistor and the whole wire sits at $V_{D D}$ → reads HIGH, rock-steady.

Step 4 — Press the button: the wire is yanked to LOW (active-LOW)

WHAT. Wire the button between the pin and $GN D$ (the floor). Press it → the wire is now connected to $0 V$ through the button's near-zero resistance. So it drops to LOW and reads $0$ .

WHY the button reads 0 when pressed. With a built-in pull-up, "resting = HIGH, pressed = LOW". Pressed = 0 is called active-LOW. It looks backwards but it's the clean, standard wiring — grounding a wire is electrically tidy and pull-ups are built into most chips.

PICTURE. Now a complete loop exists: $V_{D D} \to R \to button \to GN D$ . Current flows. The whole $V_{D D}$ is dropped across $R$ (the button drops almost nothing), so the pin sits at ≈ $0 V$ → LOW.

The current that now flows is set by Ohm's Law with the full supply across $R$ :

$I = \frac{V _{D D}}{R}$

$V_{D D}$ ::: the full supply voltage now dropped across the resistor (button pressed).
$R$ ::: the pull-up resistance.
$I$ ::: the wasted current that flows the whole time you hold the button.

Step 5 — WHY the resistor value matters: pick $R$ to cap wasted current

WHAT. The pressed-state current $I = V_{D D} / R$ is wasted as heat while held. We choose $R$ big enough to keep $I$ small, but not so big it becomes floppy.

WHY. Two opposing forces — this is the whole sizing argument:

Too small → large $I$ , lots of wasted power (and heat).
Too big → so weak that noise can shove the wire around → back to the Step 2 disaster.

PICTURE. The curve $I = V_{D D} / R$ falls as $R$ grows. We draw the current budget line $I = 100 μ A$ and read off the smallest allowed $R$ . Axes are labelled: horizontal is $R$ in kΩ, vertical is held current $I$ in μA.

Step 6 — Reading forever wastes the CPU: polling vs. interrupt

WHAT. How does the CPU learn the wire changed? Option A: poll — loop forever re-reading the pin. Option B: interrupt — let hardware watch the pin and yank the CPU into a special function only when it changes.

WHY interrupts. Polling burns 100% of the CPU asking "changed yet? changed yet?" and can miss a pulse that arrives between two reads. An interrupt is a tap on the shoulder: the CPU does other work and is called only on the event. See Polling vs Interrupt-Driven I/O.

PICTURE. Top track: polling repeatedly stabs at the wire (wasted stabs shown grey, the one that catches the change in orange). Bottom track: the CPU sleeps until the falling edge fires one arrow into the ISR.

Step 7 — Trigger on the falling edge: one press = one call

WHAT. A press is a transition $1 \to 0$ (HIGH to LOW), called a falling edge. We tell the hardware: fire the ISR (Interrupt Service Routine — the function hardware jumps to) only on the falling edge.

WHY the edge and not the level. A level trigger fires continuously while the wire is LOW — hold the button and the ISR re-fires forever. An edge fires once at the instant of the transition → exactly one call per press, which is what a button-press event deserves.

PICTURE. The wire drops from HIGH to LOW; the down-arrow marks the single falling-edge instant where the ISR launches. The flat LOW that follows produces no further calls.

Worked example The skeleton, tied to the picture

volatile bool pressed = false;    // shared with ISR -> MUST be volatile
void ISR_PIN2() {                 // hardware jumps here on the falling edge
    pressed = true;               // keep it tiny
    clear_interrupt_flag(PIN2);   // else it re-triggers
}
int main() {
    pin_mode(2, INPUT_PULLUP);        // Step 3: idle = HIGH
    attach_interrupt(2, FALLING, ISR_PIN2);  // Step 7: fire on 1->0
    while (1) { if (pressed) { handle(); pressed = false; } }
}

volatile forces the loop to re-read RAM so it sees the ISR's change — see volatile & Memory-Mapped Registers. Keeping the ISR tiny follows Interrupts & ISR Design.

Step 8 — The degenerate case: contacts bounce → many false edges (on BOTH press and release)

WHAT. A mechanical switch does not close cleanly. For ~1–10 ms its metal contacts physically bounce, producing a burst of extra transitions. This happens twice per button use:

On press (the closing bounce): a burst of $1 \to 0 \to 1$ edges → many spurious falling edges.
On release (the opening bounce): as the contacts spring apart they also chatter → a burst of $0 \to 1 \to 0$ edges → many spurious rising edges.

So even if you only trigger on the falling edge, the press alone fires 5–20 times; and if you also watch rising edges (e.g. CHANGE trigger, or to detect release), the release bounce fires again.

WHY this needs its own step. It's the degenerate input the ideal edge model ignores. If you don't handle it, your one-press logic silently multiplies — and forgetting the release bounce is the classic second bug once people fix only the press side.

PICTURE. Two zoomed windows side by side: the press window (contacts settling to LOW, spurious falling edges marked ✗) and the release window (contacts settling back to HIGH, spurious rising edges marked ✗).

The fix — debounce. After the first edge, ignore further edges for ~20 ms — this covers both the press and the release bounce because each burst is shorter than the guard window. In pseudocode: record now in the ISR and bail out if now - last < 20 ms. Or filter the wire with an RC network feeding a Schmitt-trigger input (Step 1b), which cleans the small wobbles in hardware. Full treatment in Switch Debouncing.

The one-picture summary

Everything above, compressed into a single circuit-plus-timeline: the pull-up sets the resting HIGH, the button yanks it LOW via a well-sized $R$ , the Schmitt-trigger input cleans near-threshold wobble, and the one clean falling edge (after debouncing away both bounces) fires the ISR exactly once.

Recall Feynman retelling — the whole walkthrough in plain words

A pin is the end of a wire, and all the chip cares about is how high the wire is sitting: above the middle line = HIGH (1), below = LOW (0). Real chips don't use one line but two close lines (a Schmitt trigger), so a wire hovering in between keeps its last answer instead of chattering. A wire with nothing attached is like a swing in the wind — it drifts and the answer is random noise. So we tie a soft rubber band from the wire up to the ceiling: that's the pull-up resistor. It holds the wire high but gently, so when you press a button that connects the wire to the floor, the wire drops to LOW — that's why "pressed = 0". We can't use a plain wire for the band, because a big enough resistor keeps the wasted electricity trickle tiny when the button is held; too small wastes power, too big and noise sneaks back in — so about 33 kΩ. Now, instead of asking the wire "did you change?" a million times a second (polling, which burns the CPU and can miss a blink), we let the hardware tap us on the shoulder only at the exact instant the wire falls from high to low — that's the falling-edge interrupt, and it runs our tiny ISR once per press. One catch: real switches chatter for a few milliseconds — both when you press AND when you let go — so we ignore any extra taps for ~20 ms. That's the entire journey: bare wire → floating chaos → pull-up rest → button pulls low → sized resistor → two clean thresholds → shoulder-tap on the edge → ignore the chatter on both sides.

Recall Rebuild the chain from memory

What does the buffer read exactly at $V = V_{T H}$ in the ideal model, and how do real chips avoid it? ::: Ideally undefined (tips either way, can chatter); real chips use a Schmitt trigger with two thresholds $V_{T +}, V_{T -}$ so the output sticks. Why does a floating input read randomly? ::: No component sets its voltage, so it drifts across the threshold picking up noise. What does a pull-up do when the button is open? ::: Ties the wire to $V_{D D}$ ; no current flows so no drop → clean HIGH. Why must the pull-up be "weak" (large)? ::: So a real driver overrides it and so held-current $I = V_{D D} / R$ stays small. Why trigger on an edge, not a level? ::: An edge fires once per transition; a level re-fires forever while held. Why does one button use cause many interrupts, and when? ::: Contacts bounce on BOTH press (falling burst) and release (rising burst); ignore further edges for ~20 ms (debounce).