Musical Doorbell

Learning Goals 5 min

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

1. Wire the three LEDs from L01-10 and the piezo buzzer from L01-14 onto the same breadboard, all sharing GND through the − rail.
2. Write a sketch that combines a chase across the three LEDs with a 5-note melody on the buzzer — using helper functions from L01-12 so the body of loop() reads like a script.
3. Recognise that you've just built your first multi-component output device — and that every project from here on is the same combine-components-on-one-breadboard pattern.

Warm-Up 10 min

Eight lessons ago you wired your first LED. Fourteen lessons in, you can chase three of them, you can play music on a piezo, you know functions, for-loops and named constants. Today everything you've learned meets one breadboard.

Quick-fire puzzle

Imagine a real doorbell at a house in Petaling Jaya. When the visitor presses the button, two things happen at once:

• a chime sounds (so people in the kitchen hear it),
• a small light flashes (so people watching TV with the volume up see it).

1. You can already make sound (L01-14) and make lights flash (L01-10). What is the new skill today's lesson asks you to learn?
2. Both the LEDs and the buzzer return current to GND. On the breadboard, what physical part of the board lets four components share one wire back to the Arduino's GND pin?
3. Today's doorbell will ring continuously on a loop, because you don't know how to read a button yet. In which upcoming lesson do you think buttons get introduced?

New Concept 20 min

The big idea — multiple components, one breadboard, one sketch

So far your circuits have had one or three of one kind of component. Today's circuit has two kinds on the same board:

• Three LEDs (red on D9, yellow on D10, green on D11) — each with its own 220 Ω resistor, exactly as in L01-10.
• One piezo buzzer on D8 — no resistor, exactly as in L01-14, but moved to the right end of the breadboard so it doesn't share any column tie strip with the LED modules.

All four components return their current to GND through the breadboard's − rail. The Arduino sees one shared GND wire; the rail does the gathering.

Wiring map — all four components in one table

Sketch structure — four constants, two helpers, one loop()

Today's sketch reuses every code idea from Cluster B:

• Four named pin constants at the top (L01-09).
• Five named note constants for the melody (L01-14).
• Two helper functions: flash(pin, durationMs) from L01-12 for the LEDs, beep(frequencyHz, durationMs) for the buzzer.
• setup() with four pinMode calls (or a for loop, L01-11, if you want to be tidy).
• loop() alternates a beep and a flash, building a one-line-per-event "score" you can read top-to-bottom.

Why it matters

Every project from L01-22 (Burglar Alarm) through L01-34 (Mood Lamp + Theme Tune) follows today's pattern:

1. Wire each output component independently to its own pin.
2. Share GND through the − rail.
3. Name every pin and every constant at the top of the sketch.
4. Write a helper function for each kind of output (flashing, beeping, fading).
5. Compose the project's behaviour as a sequence of helper-function calls in loop().

Today you do this for the first time. From now on, it's muscle memory.

Worked Example 20 min

Goal: build the combined breadboard, then write a sketch that rings the doorbell — three LED flashes in sequence followed by a 3-note descending melody — every 4 seconds.

Step 1 — the wiring

Re-plug the three LEDs and their resistors exactly as in L01-10 (cols 1–6, 11–16, 21–26). Then move the buzzer from L01-14 to the right end of the breadboard, cols 28–29.

Step 2 — the same circuit as a schematic

Four branches, one merge bar, one ground. The three LED branches each carry a resistor and an LED in series; the buzzer's branch carries just the piezo.

Step 3 — the doorbell sketch

Open a new sketch and call it musical-doorbell. Type the following from the top down — globals, then helpers, then setup(), then loop().

// Pin assignments — same as L01-10 (LEDs) + L01-14 (buzzer)
const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;
const int BUZZER_PIN = 8;

// Musical notes used in the doorbell jingle
const int NOTE_G4 = 392;
const int NOTE_E4 = 330;
const int NOTE_C4 = 262;

// One quick flash of an LED — same helper from L01-12.
void flash(int pin, int durationMs) {
  digitalWrite(pin, HIGH);
  delay(durationMs);
  digitalWrite(pin, LOW);
}

// One musical note on the buzzer — same helper from L01-14.
void beep(int frequencyHz, int durationMs) {
  tone(BUZZER_PIN, frequencyHz, durationMs);
  delay(durationMs + 50);
}

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

void loop() {
  flash(RED_PIN, 200);
  flash(YELLOW_PIN, 200);
  flash(GREEN_PIN, 200);
  beep(NOTE_G4, 300);
  beep(NOTE_E4, 300);
  beep(NOTE_C4, 500);
  delay(3000);
}

Step 4 — upload and watch (and listen)

Click Upload. Every 4 seconds your circuit should:

1. Flash red, then yellow, then green — about 600 ms total.
2. Play a descending G–E–C melody on the buzzer — about 1.1 seconds.
3. Pause for 3 seconds.
4. Repeat.

If the LEDs flash but the buzzer is silent, check that the piezo is plugged at cols 28–29 (not cols 12–13 like in L01-14). If the buzzer plays but a particular LED doesn't flash, check that LED's polarity and resistor first.

Step 5 — read the loop() as a script

Look back at your loop() body. Seven lines. Each line names what happens, not how. That's the gift of helper functions: you read the sketch like a doorbell instruction sheet rather than like assembly code.

Try It Yourself — extend the project 20 min

void noteWithLight(int ledPin, int frequencyHz, int durationMs) {
  digitalWrite(ledPin, HIGH);
  tone(BUZZER_PIN, frequencyHz, durationMs);
  delay(durationMs);
  digitalWrite(ledPin, LOW);
  delay(50);
}

void loop() {
  noteWithLight(RED_PIN,    NOTE_G4, 300);
  noteWithLight(YELLOW_PIN, NOTE_E4, 300);
  noteWithLight(GREEN_PIN,  NOTE_C4, 500);
  delay(3000);
}

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

  flash(RED_PIN, 200);
  flash(YELLOW_PIN, 200);
  flash(GREEN_PIN, 200);
  beep(NOTE_G4, 300);
  beep(NOTE_E4, 300);
  beep(NOTE_C4, 500);
}

void loop() {
}

Mini-Challenge — add a feature 15 min

"Long press" mode: louder, longer, brighter

Some doorbells have an angry mode for impatient visitors — louder, faster, with the lights actually flashing with the chimes instead of before them. Build it.

Your task:

1. Pick three notes higher than the original G–E–C (say, C5 = 523, E5 = 659, G5 = 784). Higher notes are more attention-grabbing.
2. Use the noteWithLight helper from the 🟡 task so every note arrives with a matching LED flash.
3. Play the three-note sequence three times in quick succession (six rapid LED+beep pairs) before the long pause.
4. Cut the pause from 3 seconds down to 1 second — the doorbell rings more often.

It works if:

• Every beep happens with an LED on, never an LED off.
• The notes are noticeably higher than the original doorbell — feels like a smoke alarm rather than a wedding bell.
• The whole cycle (three repetitions + 1-second pause) takes under 5 seconds.

// Long-press doorbell mode — higher, faster, with sync LED.
const int RED_PIN = 9;
const int YELLOW_PIN = 10;
const int GREEN_PIN = 11;
const int BUZZER_PIN = 8;
const int NOTE_C5 = 523;
const int NOTE_E5 = 659;
const int NOTE_G5 = 784;

void noteWithLight(int ledPin, int frequencyHz, int durationMs) {
  digitalWrite(ledPin, HIGH);
  tone(BUZZER_PIN, frequencyHz, durationMs);
  delay(durationMs);
  digitalWrite(ledPin, LOW);
}

void ringOnce() {
  noteWithLight(RED_PIN,    NOTE_C5, 150);
  noteWithLight(YELLOW_PIN, NOTE_E5, 150);
  noteWithLight(GREEN_PIN,  NOTE_G5, 150);
}

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

void loop() {
  ringOnce();
  ringOnce();
  ringOnce();
  delay(1000);
}

Recap 5 min

To combine output components on one breadboard: give each its own signal pin and (if needed) its own resistor; share a single GND return through the − rail. To control them from one sketch: name every pin, write a tiny helper for each kind of output (flashing for LEDs, beeping for buzzers), then compose the behaviour in loop() as a sequence of helper calls. Today's project is the template for every Cluster B–onwards build.

Multi-component output device

A single breadboard circuit that uses two or more different kinds of output (LED + buzzer here; later LED + buzzer + motor + display) to produce a coordinated effect.

GND bus

The breadboard's − rail acting as a shared return path for many components — so that the Arduino sees only one GND wire instead of one per component. First introduced in L01-07's Mini-Challenge; first required in L01-10; first used for four components today.

Helper-per-kind

The pattern of writing one helper function per kind of output (flash for LEDs, beep for buzzers), so loop() stays readable as a sequence of high-level actions.

Project sketch

A sketch whose loop() body reads like a script of human-readable steps, because every detail has been hidden inside a helper. The opposite of a "wall of digitalWrite calls".

Layering

The technique of building bigger helpers out of smaller ones — ringOnce() calls noteWithLight() which calls tone() and digitalWrite(). Three layers, each understandable on its own.

Homework 5 min

Make it yours. Pick a melody you actually like — the first phrase of your school song, the opening of Negaraku, the first four notes of a video game theme — and re-program the doorbell to play it. Light the LEDs in time with the notes.

1. Write out the melody in note names on paper first (e.g. "C, C, G, G, A, A, G"). Don't start with code.
2. Look up the frequency of each note (the L01-14 table covers C4–C5; for higher notes, double the frequency to jump up an octave: C5 = 523, C6 = 1046).
3. Add a const int NOTE_XX for every note you use, at the top of your sketch.
4. Compose the loop() body as a sequence of noteWithLight() calls — alternating between red, yellow and green LEDs so each note has a flash partner.

Also: a design reflection on paper.

• If you wanted to add a fourth LED (say a blue one on pin 12) to your doorbell, name three places in the sketch you would need to edit, in order. ____
• Today your loop() body is around 7 lines. If you removed the helper functions and inlined every digitalWrite, tone and delay back into loop(), roughly how many lines would it become? ____ (Hint: each flash call expands to 3 lines; each beep to 2 lines.)

Bring back next class:

• The saved .ino file (call it doorbell-your-name).
• A 15–20 second phone video with sound on showing your melody.
• The two answers from the design reflection on a notebook page.

Heads up for next class: in L01-16 "Push Buttons & digitalRead" you'll finally meet the missing piece — the button. The class after that, in L01-22, this doorbell circuit returns and gets its long-promised press-to-ring behaviour. Keep your kit assembled.