Multiple LEDs at Once

Learning Goals 5 min

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

1. Wire three LEDs — one red, one yellow, one green — to three separate digital pins on the same breadboard, each with its own 220 Ω current-limiting resistor.
2. Use the breadboard's − rail as a shared GND bus so that all three LEDs return through a single GND wire to the Arduino.
3. Declare three named pin constants (RED_PIN, YELLOW_PIN, GREEN_PIN) and write a sketch that lights each LED on its own pin, independently of the others.

Warm-Up 10 min

Last lesson we replaced the literal 13 with the name LED_PIN. The sketch was easier to read and easier to change. Today we have three pins to keep track of — and naming becomes essential, not optional.

Quick-fire puzzle

Wei Jie wants to wire three LEDs — red on pin 9, yellow on pin 10, green on pin 11 — onto the same breadboard. Before peeking at today's diagram, predict:

1. How many 220 Ω resistors does he need? Why is sharing one resistor between two LEDs a bad idea?
2. If each LED needs a wire back to GND, does Wei Jie need three separate black wires running all the way to the Arduino's GND pin — or is there a tidier way?
3. In Wei Jie's sketch, how many pinMode() calls will setup() contain? How many digitalWrite() calls happen each time he wants to turn an LED on?

New Concept 20 min

The big idea — three of everything (except GND)

To drive three LEDs independently you need:

• Three Arduino pins — one per LED. Today we'll use D9, D10 and D11.
• Three resistors — one per LED, in series. Never share.
• Three LEDs — each in its own column pair on the breadboard.
• One shared GND path — running through the breadboard's − rail.

The − rail trick is the key new idea. Without it, you'd have a tangle of three GND wires fighting for space at the Arduino's single GND pin. With it, the breadboard handles the gathering and one tidy wire returns to the Arduino.

Wiring map for today's three modules

Each "module" is a self-contained LED + resistor sub-circuit. Three modules sit side by side across the breadboard's top half.

The sketch — three names at the top

Three pins means three constants. Give each one a name based on the LED's colour, not the pin number — the colour is what matters in the logic.

const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
}

void loop() {
}

That's the skeleton. setup() declares all three pins as outputs. loop() is empty — we'll fill it in once we've tested that the wiring is right.

Why it matters

The "many components, shared rails" pattern is the entire grammar of breadboarding. Every project from here on — traffic lights, RGB nightlights, environmental sensors, robots — uses the same idea: separate signal wires for each part, shared power and ground via the rails.

Worked Example 20 min

Goal: build the three-LED breadboard layout and verify every LED works with a simple "all on" test sketch — before writing any animation logic.

The full wiring diagram

The "wiring test" sketch

Before writing animation logic, prove the wiring is right. This sketch turns on all three LEDs in setup() and then sits in an empty loop() doing nothing — the LEDs stay on as long as the board has power.

const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  digitalWrite(RED_PIN, HIGH);
  digitalWrite(YELLOW_PIN, HIGH);
  digitalWrite(GREEN_PIN, HIGH);
}

void loop() {
}

Expected behaviour

• All three LEDs come on the instant the board boots, and stay on.
• If any of the three is dark, you have a wiring problem on that module alone. Flip its LED first (polarity is the most common culprit), then check its resistor, then check the column numbers against the wiring table.
• The loop() body is empty on purpose. We haven't told the Arduino to do anything over and over yet — that's the next step.

Try It Yourself 20 min

Three sketches that build on the wiring test. For each one, predict on paper what the LEDs will do, then upload and check.

const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  digitalWrite(GREEN_PIN, HIGH);
}

void loop() {
}

const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RED_PIN, HIGH);
  digitalWrite(YELLOW_PIN, HIGH);
  digitalWrite(GREEN_PIN, HIGH);
  delay(500);
  digitalWrite(RED_PIN, LOW);
  digitalWrite(YELLOW_PIN, LOW);
  digitalWrite(GREEN_PIN, LOW);
  delay(500);
}

// Chase: one LED at a time, walking left to right.
const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RED_PIN, HIGH);
  delay(200);
  digitalWrite(RED_PIN, LOW);
  digitalWrite(YELLOW_PIN, HIGH);
  delay(200);
  digitalWrite(YELLOW_PIN, LOW);
  digitalWrite(GREEN_PIN, HIGH);
  delay(200);
  digitalWrite(GREEN_PIN, LOW);
}

Mini-Challenge 15 min

The "bounce"

Combine the chase pattern (🔴 stretch) with a reversed pass so the dot bounces: red → yellow → green → yellow → red → yellow → green → yellow → red → … The dot walks right across the LEDs, then walks back left, and repeats forever.

Your task:

1. Start from the chase sketch in the 🔴 task.
2. Add a "return journey" inside loop() — yellow on, then yellow off + red on. The cycle ends back on red, ready for the next loop iteration.
3. Pick a step delay that makes the bounce look smooth but not frantic. 150 ms is a good starting point.
4. Upload and watch. The bouncing dot is one of the most recognisable patterns in electronics — Knight Rider, KITT's grille, the 1980s called.

It works if:

• At any instant, exactly one LED is on. Never zero, never two.
• The dot reaches the green LED, pauses (one step), then walks back through yellow to red, pauses, then walks forward again.
• A partner watching the breadboard can describe the pattern as "bouncing" without you explaining it first.

// Knight Rider bounce — red → yellow → green → yellow → red, repeating.
const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;
const int STEP_MS = 150;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(YELLOW_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
}

void loop() {
  digitalWrite(RED_PIN, HIGH);    delay(STEP_MS); digitalWrite(RED_PIN, LOW);
  digitalWrite(YELLOW_PIN, HIGH); delay(STEP_MS); digitalWrite(YELLOW_PIN, LOW);
  digitalWrite(GREEN_PIN, HIGH);  delay(STEP_MS); digitalWrite(GREEN_PIN, LOW);
  digitalWrite(YELLOW_PIN, HIGH); delay(STEP_MS); digitalWrite(YELLOW_PIN, LOW);
}

Recap 5 min

To drive N independent LEDs you need N Arduino pins, N resistors and N LEDs — but only one GND path, gathered through the breadboard's − rail. Give every pin a colour-named constant at the top of the sketch and you can read the logic of loop() in plain English. The longhand digitalWrite calls are getting repetitive — that is your sneak preview of why for loops exist.

Module

One LED + its current-limiting resistor + the wires that join them. A self-contained sub-circuit on the breadboard. Today's circuit has three modules.

GND bus

A shared wire — usually a breadboard power rail — that gathers GND returns from several components and carries them back to the Arduino's GND pin as one. The − rail's job in today's circuit.

Chase

An animation in which one LED at a time is lit, marching across a row of LEDs. The simplest multi-LED effect.

Independence

The property that switching one LED on or off has no effect on the others, because each is on its own pin and resistor. Today's circuit guarantees it; cheap toy circuits that share resistors don't.

Homework 5 min

Design a 3-LED panic signal. Write a sketch where, every full cycle:

1. All three LEDs blink together rapidly — 5 quick flashes (80 ms on, 80 ms off).
2. Then all three stay off for 2 seconds.
3. Then the cycle repeats.

Use the three named pin constants from class. The sketch will run longer than 10 lines — that's OK for homework; the lesson in L01-11 is exactly about making patterns like this shorter.

Also: do the quick safety check from L01-05 + L01-07 — when all three LEDs are simultaneously HIGH, what is the total current the Arduino is supplying through pins D9 + D10 + D11 together?

• Given: each module: V_pin = 5 V, V_F (LED) ≈ 2 V, R = 220 Ω
• Per-module current: I = (5 − 2) ÷ 220 = ____ mA
• Total when all three are HIGH: 3 × ____ mA = ____ mA
• The Arduino UNO can supply about 200 mA total across all its pins safely. Is your three-LED circuit comfortably under this budget?

Bring back next class:

• The saved .ino file (call it three-led-panic).
• A short phone video (10–15 seconds) showing the panic pattern in action.
• Your notebook page with the per-module and total current figures.