Push Buttons & digitalRead

Learning Goals 5 min

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

1. Wire a 4-pin push button straddling the breadboard trough, with a 10 kΩ pull-down resistor that anchors the input pin to GND when the button is released.
2. Set a pin as INPUT in setup() with pinMode(pin, INPUT), and read its state with digitalRead(pin), which returns HIGH or LOW.
3. Write a sketch where pressing the button makes the onboard L LED light up — by passing the result of digitalRead straight into digitalWrite on pin 13.

Warm-Up 10 min

For fifteen lessons every pin you've touched has been an output — you decided HIGH or LOW, the world reacted. Today the direction flips. The pin becomes an input — the world (a button) decides HIGH or LOW, and your sketch reacts.

Quick-fire puzzle

Priya holds up the small 4-pin push button from her starter kit and asks three questions before wiring anything:

1. If she connects 5 V straight to a digital pin through the button, and presses it — what voltage is on the pin? What does the pin read?
2. Now she releases the button. The pin is no longer connected to 5 V. Is it connected to anything else? What might its voltage be?
3. If a pin is connected to nothing at all, what voltage does it actually have?

New Concept 20 min

The big idea — inputs need to know what to read when nothing's pressed

An Arduino digital pin can be set to one of two roles:

• OUTPUT — your sketch chooses the pin's voltage with digitalWrite. You've been doing this since L01-07.
• INPUT — the outside world chooses the pin's voltage. Your sketch reads it with digitalRead. New today.

An input pin is happy with either 5 V (reads HIGH) or 0 V (reads LOW). What it cannot handle is nothing — a floating pin reads garbage. Every input pin in every reliable circuit must be tied to a known voltage at all times, even when the user isn't pressing the button.

The pull-down resistor

A pull-down resistor is a 10 kΩ resistor connecting the input pin to GND. It "pulls" the pin to LOW when nothing else is pulling it the other way. The button's job is then to occasionally pull the pin HIGH by connecting it to 5 V.

• Button open (not pressed): 5 V is isolated from the pin. The pull-down resistor quietly drains any noise to GND. Pin reads LOW.
• Button closed (pressed): 5 V flows through the button to the pin. The pull-down resistor is still there, but the button is "stronger" — current flows from 5 V to GND through the resistor, and the pin sits near 5 V. Pin reads HIGH.

Why 10 kΩ? Two reasons. (1) It's big enough that almost no current is wasted: when the button is pressed, only 0.5 mA flows from 5 V to GND through the resistor — practically free. (2) It's small enough to be "stronger" than the air around the pin, so it dominates over any stray noise.

The push button itself

The button in your starter kit has four pins arranged in a small square. Internally:

• The two pins on the top side are always connected to each other.
• The two pins on the bottom side are always connected to each other.
• Press the button → the top pair connects to the bottom pair. Release → that connection breaks.

You only need to wire one pin from each pair. The other two pins are duplicates and stay empty. To make sure the top pair and bottom pair are different tie strips on the breadboard, the button must straddle the trough — top pins in the top half (row D), bottom pins in the bottom half (row F).

Wiring map

Two new pieces of code

The trick that avoids needing if/else

You haven't met conditional statements yet — those come in L01-20. But you don't need them today, because HIGH and LOW mean the same thing whether you're reading a pin or writing one. So you can take the value digitalRead returns and pass it straight to digitalWrite on the onboard LED:

digitalWrite(13, digitalRead(BUTTON_PIN));

If the button reads HIGH, the onboard LED writes HIGH → LED on. If the button reads LOW, the LED writes LOW → LED off. One line, one mirror.

No new external LED today

We control the onboard L LED on pin 13 — the one built into the Arduino board itself, between the digital headers. No need to wire an external LED. This keeps today's focus 100% on the input side of the circuit.

Why it matters

Every interactive Arduino project — game controller, alarm panel, smart switch, robot remote — starts with the pattern you'll build today. Read a digital input, make a decision, drive an output. Today is the input half of that pipeline; you already know the output half.

Worked Example 20 min

Goal: build the button circuit, then write a sketch that makes the onboard LED light up when you press the button.

The wiring

The same circuit as a schematic

The vertical schematic reads top to bottom: 5 V → button → junction (where D7 takes off) → 10 kΩ → GND. Press the button and the junction sees 5 V; release it and the junction is dragged down to GND by the resistor.

The sketch

const int BUTTON_PIN = 7;
const int LED_PIN = 13;  // onboard L LED, no wiring needed

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

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

Expected behaviour

• Plug in the Arduino. The onboard L LED stays dark.
• Press the button. The onboard LED lights up immediately.
• Release the button. The LED goes off immediately.
• Hold the button for 5 seconds. The LED stays on for those 5 seconds, then off as soon as you let go.

If the LED stays dark no matter how hard you press: check the button is straddling the trough (top pair in row D, bottom pair in row F — not all four in the top half). If the LED stays on even when you don't touch the button: the pull-down resistor isn't doing its job; check that it bridges the signal tie strip and a GND-bound tie strip.

Trace the trick

The one-line loop() body is doing two things at once:

1. digitalRead(BUTTON_PIN) looks at pin 7 and returns either HIGH or LOW.
2. That value flows directly into digitalWrite(LED_PIN, …) as its second argument.

So when the button is pressed, the line becomes digitalWrite(13, HIGH) — LED on. When released, it becomes digitalWrite(13, LOW) — LED off. The loop runs thousands of times per second, so the mirror feels instant.

Try It Yourself 20 min

void loop() {
  int state = digitalRead(BUTTON_PIN);
  digitalWrite(LED_PIN, !state);  // the ! flips HIGH ↔ LOW
}

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

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

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

void loop() {
  int buttonState = digitalRead(BUTTON_PIN);
  digitalWrite(LED_PIN, buttonState);
  delay(10);  // hmm — this just slows the mirror, not extends it
}

Mini-Challenge 15 min

Diagnose three broken circuits

You're going to look at three "broken" versions of today's button circuit. For each one, predict what the onboard LED will do before you build it, then build it and check. Your job is to explain why each failure happens — not to fix it (yet).

1. Version A: Remove the 10 kΩ pull-down resistor entirely. Leave everything else exactly as the Worked Example.
   • Predict: When you don't touch the button, what does the LED do? When you place a finger near the breadboard (without pressing), what does the LED do? Does pressing the button still cause the LED to light? ____
2. Version B: Re-plug the button so all four pins are in the top half of the board (D11, D14, E11, E14 — same columns, but bottom pair moved up from row F to row E so it stays in the top-half tie strip).
   • Predict: What does the LED do at all times — pressed or released? Why? ____
3. Version C: Keep the Worked-Example wiring but accidentally swap the 5 V wire and the GND wire — so 5 V goes through the resistor to col 16 and GND goes to A11.
   • Predict: What does the LED do when you press the button? What about when you release it? Is this a useful circuit, or a useless one? ____

Recap 5 min

An input pin reads HIGH or LOW from the outside world. To make the reading reliable, the pin must be tied to a known voltage at all times — a pull-down resistor (10 kΩ to GND) gives it a default LOW, and the button connects it temporarily to 5 V. In code, pinMode(pin, INPUT) declares the pin's role and digitalRead(pin) returns its state — which you can pass straight into digitalWrite() on an output pin to make one mirror the other.

Input pin

A digital pin whose voltage is set by the outside world (a button, a sensor) and read by your sketch. The partner of an output pin.

pinMode(pin, INPUT)

Declares the pin as an input. Goes in setup(), just like pinMode(pin, OUTPUT).

digitalRead(pin)

Returns the pin's current state — either HIGH (≈ 5 V) or LOW (≈ 0 V). Use only on pins declared as INPUT.

Pull-down resistor

A 10 kΩ resistor connecting an input pin to GND. Pulls the pin to LOW when nothing else is driving it — preventing floating.

Floating pin

An input pin not connected to either 5 V or GND. Its voltage is undefined and its readings are random. Always avoid by adding a pull-down (or pull-up) resistor.

Straddling the trough

Placing a 4-pin button so its top pair sits in the top half of the breadboard and its bottom pair in the bottom half. Required so the trough breaks the tie strip between the two pairs.

Homework 5 min

Build a "press counter" — almost. Using only today's tools, write a sketch that shows when the button is being held by lighting the onboard LED, and add a single line that prints the button's state to the Serial Monitor every loop.

You haven't met Serial properly yet (that's L01-23), but it's safe to try the form below as a sneak preview. Open the Serial Monitor in the Arduino IDE (top-right magnifying-glass icon) at 9600 baud while the sketch runs.

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

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int buttonState = digitalRead(BUTTON_PIN);
  digitalWrite(LED_PIN, buttonState);
  Serial.println(buttonState);
  delay(50);
}

You should see a long column of 0s when the button is released, switching to a long column of 1s when held. (HIGH = 1, LOW = 0 — they're the same value in two notations.)

Also: a design reflection on paper.

• If you wanted the LED to stay on for 2 seconds after release (like a doorbell that keeps ringing for a moment), name the two new pieces of the language you'd need. (Hint: one for "make a decision", one for "remember when something happened".) ____
• The pull-down resistor "wastes" 0.5 mA whenever the button is pressed. The Arduino UNO can supply about 200 mA across all pins. How many pressed-button circuits could you have on one Arduino before the budget runs out? ____ (Hint: 200 ÷ 0.5.)

Bring back next class:

• The saved .ino file (call it button-mirror).
• A phone photo of the Serial Monitor window showing the 0/1 column while you held the button.
• Your reflection answers on a notebook page.

Heads up for next class: in L01-17 "INPUT_PULLUP" you'll meet a built-in resistor inside the Arduino itself that replaces today's external 10 kΩ — saving you one component and one wire on every future button. Today's circuit is the canonical version; tomorrow's is the shortcut.