INPUT_PULLUP

Learning Goals 5 min

By the end of this lesson you will be able to:

1. Wire a push button using only two wires — no external resistor, no 5 V wire — by leaning on a resistor that is already inside the Arduino chip.
2. Set a pin with pinMode(pin, INPUT_PULLUP) and explain how the on-chip pull-up resistor changes the pin's default state from "floating" to HIGH.
3. Read the inverted button signal (LOW when pressed, HIGH when released) and flip it back into a normal mirror with the ! (NOT) operator, so that pressing still lights the onboard LED.

Warm-Up 10 min

Last lesson you built the canonical pull-down circuit. Today is short and sweet — it's the same circuit, except a piece you used yesterday turns out to be hiding inside the Arduino itself.

Quick-fire puzzle

Count the components in your L01-16 button circuit:

1. How many wires ran from the Arduino to the breadboard? (Hint: 5 V, GND, signal.)
2. How many resistors sat on the breadboard?
3. If the Arduino chip already had a 10 kΩ-ish resistor hidden inside, connecting every digital pin to 5 V — and you could switch it on with a single line of code — which of those wires/components could you delete?

New Concept 20 min

The big idea — the resistor was inside the chip the whole time

Inside the ATmega328P chip on your Arduino UNO is a network of tiny resistors — one per digital pin — connecting each pin to the chip's internal 5 V rail. They're switched off by default. When you call pinMode(pin, INPUT_PULLUP) instead of pinMode(pin, INPUT), you turn that pin's internal resistor on. From that moment, the pin is "pulled up" to HIGH whenever nothing outside is dragging it down.

The internal pull-up is roughly 20–50 kΩ — a little weaker than the external 10 kΩ you used yesterday, but plenty strong for buttons, switches and most other digital inputs.

The wiring flip — GND replaces 5 V

Yesterday's pull-down circuit had the button supply 5 V when pressed. Today's pull-up circuit is the mirror image: the button supplies GND when pressed. The chip's internal resistor handles the default.

Two new pieces of code

Wiring map — only two wires now

The button still straddles the trough (same as L01-16). What’s gone: the 5 V wire, the 10 kΩ resistor, and its GND-return wire. From a five-thing circuit (button + resistor + 3 wires) down to a three-thing circuit (button + 2 wires).

Why it matters

For a single button you save one wire and one resistor. For a project with ten buttons (a keypad, a game controller, a control panel) you save twenty components. Real makers always use INPUT_PULLUP for buttons, switches, and any input that wants a sensible default — only reaching for an external resistor in the rare cases where the internal one isn't strong enough or fast enough.

Worked Example 20 min

Goal: rebuild the L01-16 mirror circuit using only two wires and no external resistor — then write the new sketch.

Step 1 — strip down the L01-16 wiring

Start from your L01-16 build:

• Remove the 10 kΩ pull-down resistor at H15–H20.
• Remove the 5 V wire from Arduino 5V to the + rail and A15.
• Remove the GND wire from J20 to the − rail.
• Add a new black wire from A15 up to the − rail — where the red 5 V wire used to reach the + rail.
• Keep the yellow signal wire from D7 to J15 and the button itself.

You should now have a much emptier-looking breadboard.

The new wiring — and the resistor you cannot see

Two drawings again. On the breadboard, the resistor has simply vanished; on the schematic it is still there, drawn inside a dashed box marked inside the ATmega328P chip. That box is the whole lesson: nothing was removed from the circuit, it just moved indoors.

Press and hold the button in the left-hand picture and watch the current appear.

Four rows, and two of them are the button. Compare that with L01-16's seven.

Step 3 — write the sketch

Two small changes from L01-16's sketch: INPUT becomes INPUT_PULLUP, and the line that drives the LED gains a ! to flip the inverted reading back to a normal mirror.

const int BUTTON_PIN = 7;
const int LED_PIN = 13;  // onboard L LED

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, !digitalRead(BUTTON_PIN));
}

Expected behaviour

• Plug in the Arduino. The onboard L LED stays dark — same as L01-16.
• Press the button. The LED lights up immediately.
• Release. The LED goes off immediately.
• The visible behaviour is identical to yesterday's lesson. The internal pull-up does its work silently.

Step 4 — trace the inverted logic

Look at the one-line loop() body. Three things happen, right-to-left:

1. digitalRead(BUTTON_PIN) returns HIGH if the button is released, LOW if pressed. (Inverted from yesterday.)
2. The ! in front flips it. !HIGH becomes LOW; !LOW becomes HIGH.
3. digitalWrite(LED_PIN, …) sends that flipped value to the onboard LED.

Net effect: pressed button → !LOW = HIGH → LED on. Released button → !HIGH = LOW → LED off. Same outcome as L01-16, fewer components.

Basic 7 min

void loop() {
  digitalWrite(LED_PIN, digitalRead(BUTTON_PIN));
}

Challenge 1 7 min

// No code change at all from the Worked Example! Both buttons share D7.
void loop() {
  digitalWrite(LED_PIN, !digitalRead(BUTTON_PIN));
}

Challenge 2 6 min

const int BUTTON_PIN = 7;
const int LED_PIN = 13;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, digitalRead(BUTTON_PIN));
}

Challenge 3 15 min

The "any-key wake" circuit

Many real devices have a "press any key to wake" feature — laptops, microwaves, alarm clocks. Build the simplest version: three buttons, all wired in parallel to the same digital input. Pressing any one of them wakes the onboard LED.

Your task:

1. Place three buttons across the breadboard. Each must straddle the trough so its top pair and bottom pair are on different tie strips.
2. Wire each button's top-pair side to GND (via the breadboard's − rail if you like).
3. Wire each button's bottom-pair side to the same shared signal column on the breadboard. From that column, run one yellow wire to D7.
4. Use the exact Worked Example sketch — no code changes at all.

It works if:

• Pressing button 1 lights the onboard LED.
• Pressing button 2 lights it.
• Pressing button 3 lights it.
• Pressing any two together lights it (no different from pressing one).
• Releasing all three turns the LED off.

This Mini-Challenge has no wiring-reveal — the building is the lesson. If you get stuck, the trick is that all three buttons share one signal column and one GND. The internal pull-up handles the default state for free.

Then test the shared column. Move button 3's signal-side wire into an empty column that nothing else uses. Predict what pressing button 3 does now, then press it and check. Put the wire back and confirm all three buttons work again.

Recap 5 min

Every digital pin on the Arduino has a built-in 20–50 kΩ pull-up resistor that you can switch on with pinMode(pin, INPUT_PULLUP). With it on, the pin's default state is HIGH — so you wire the button to GND, and a press pulls the pin LOW. Use the ! operator on the read value if your code still expects "HIGH means pressed". One keyword saves one resistor and one wire per button — for free.

INPUT_PULLUP

A pinMode mode that sets a pin as input and activates the chip's built-in pull-up resistor. The replacement for INPUT in 99% of button circuits.

Internal pull-up

A 20–50 kΩ resistor permanently fabricated inside the ATmega328P chip, connecting a digital pin to the chip's 5 V rail. Off by default; switched on by INPUT_PULLUP.

Active-low

A circuit where the "active" state is LOW rather than HIGH. INPUT_PULLUP buttons are active-low — pressing them drives the pin to LOW. The opposite (L01-16's pull-down) is active-high.

! (NOT operator)

Flips HIGH to LOW and LOW to HIGH. Place it in front of any expression to invert it: !digitalRead(pin).

Pull-up

A resistor (internal or external) connecting a pin to 5V so that the pin defaults to HIGH when nothing else drives it. The partner of "pull-down".

Extra Mission 5 min

Part 1 — Design a button panel

A games controller, a TV remote and a microwave all have a panel of buttons. Invent a device with a button panel. On paper, design its panel and wiring.

Your design must include:

• A name and a one-sentence job for the device.
• At least four buttons, each with a job.
• Which buttons need their own pin, and which could share one pin like today's "any-key wake".
• The Arduino pin for each button, all using INPUT_PULLUP.
• How many resistors and wires you save compared with L01-16's pull-down wiring.

Part 2 — Make it

Build the core of your panel: two buttons on their own pins, D7 and D6, both with INPUT_PULLUP. Button 1 lights the onboard LED while held. Button 2 lights the red LED module on D9 while held. Use !digitalRead() for each one — no if needed.

Bring back next class: your panel design, the saved .ino file, and a short video pressing each button in turn, then both together.

Heads up for next class: L01-18 "Debouncing a Button" explains why one press can count as several. Then it gives you a tiny fix.