Level 1 Recap & Cert Vocab

Learning Goals 5 min

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

1. Walk back through the seven clusters of Level 1 and name the single highest-leverage idea from each — the one that, if you forgot everything else, you'd want to keep.
2. Fill in your own "what I can do now" credentials card — a one-page personal reference that lists every skill, vocabulary term and worked sketch you've genuinely internalised over the past 47 lessons.
3. Tackle a certification-style mini-challenge that touches at least four clusters' worth of ideas — proof to yourself that the skills compose, not just sit in isolation.

Warm-Up 10 min

This is the closing lesson of Level 1. No new wiring, no new code — today is for looking back. You arrived at L01-01 not knowing what an Arduino was. You leave L01-48 having built thirteen working projects across three categories — Build, Project, and lesson-embedded examples — and acquired vocabulary that maps onto any microcontroller you'll ever touch.

Quick-fire puzzle

Cast your mind back. Without re-reading anything:

1. What was the very first sketch you wrote? What did it do?
2. What was the largest sketch you've written (most lines, most components)? What was its job?
3. If a friend who's never touched Arduino asked you "what's the one thing it does that's magic?", what would you say?

New Concept — the seven big ideas of Level 1 20 min

The big idea — every cluster has one core idea

Forty-eight lessons across seven clusters is a lot. But each cluster has one idea that anchors the rest. Memorise these seven and you've memorised the spine of Level 1.

Cluster A — First Light (L01-01 to L01-06)

Big idea: a sketch is a setup() called once and a loop() called forever. Everything else is detail. You met the IDE, Ohm's Law (V = IR), resistor colour bands, the breadboard's columns and rails, and the LED's anode/cathode polarity. The first sketch — Blink — proved that the chip can be told what to do.

• Skills: open the IDE, upload to the board, calculate a current-limiting resistor, read a colour code.
• One-line code summary: digitalWrite(LED_BUILTIN, HIGH); delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000);

Cluster B — Digital Output (L01-07 to L01-15)

Big idea: digitalWrite + a variable + a for loop = nearly every output sketch. You moved off the onboard LED to external ones, learned variables for pin numbers, met for loops, extracted functions, met circuit diagrams (schematics), and added the piezo buzzer with tone(). Cluster ends with a doorbell project pulling it all together.

• Skills: drive any digital pin HIGH/LOW; loop with for (int i = 0; i < N; i++); package logic into a named function; read a circuit diagram.
• Key sketch: the L01-12 functions lesson — void blink(int pin, int duration) { … } as the first reusable helper.

Cluster C — Digital Input (L01-16 to L01-23)

Big idea: digitalRead + INPUT_PULLUP + state-change detection + debounce = every input sketch. Buttons let the world talk back; the four patterns above make their inputs reliable. Cluster ends with a burglar alarm — the first state machine.

• Skills: read a button with INPUT_PULLUP (pressed = LOW); detect edges not just states; combine inputs with &&/||; build a 2-state FSM.
• Key sketch: the L01-19 state-change pattern — compare digitalRead to lastButton to act once per press.

Cluster D — Serial Monitor (L01-24 to L01-29)

Big idea: the chip can talk back through the USB cable — and that single fact transforms debugging. You learned Serial.begin / println / print, then Serial.read for keyboard input, then ASCII (every character is a number), then switch/case as the right tool for command dispatch. Cluster ends with a non-blocking serial-controlled light show.

• Skills: open and use the Serial Monitor; print-debug any sketch; parse single-character commands; route them with switch; convert digits with c - '0'.
• Key sketch: the L01-29 light show's main loop — two tiny if-checks (keyboard + clock), no delay ever, animation engine driven by millis().

Cluster E — Lights and Sound (L01-30 to L01-35)

Big idea: PWM fakes analog output by switching fast; arrays let you describe melodies and animations as data. You met the RGB LED, learned analogWrite (which is really PWM on tilde pins), worked out the maths of tone() at musical frequencies, met 1D arrays (notes) and then 2D arrays (frames). Cluster ends with a mood-lamp-plus-theme-tune device.

• Skills: analogWrite(pin, 0..255) for brightness/colour mixing; tone(pin, freq, dur) for music; declare and walk 1D arrays for sequences; 2D arrays for "frames × channels".
• Key sketch: the L01-33 melody player — three lines of data + one for loop = any tune.

Cluster F — First Sensors (L01-36 to L01-43)

Big idea: sensors turn the world into numbers; voltage dividers convert resistance to voltage; map() rescales any range to any other. You met the LDR, formalised the analog/digital pin distinction, derived the voltage-divider formula, met the tilt switch and the pot, met map() and constrain(), formalised boolean logic. Cluster ends with the auto night light — your first sensor product with hysteresis, smooth fade, and a user knob.

• Skills: analogRead(A0) returns 0..1023; build a voltage divider for any variable-resistor sensor; scale with map(); clamp with constrain(); combine decisions with boolean logic.
• Key sketch: the L01-43 night light — sensor → hysteresis → PWM fade → user-pot threshold, all in 20 lines.

Cluster G — Build, Reflect, Recap (L01-44 to L01-48)

Big idea: state machines + non-blocking loops + paper planning = the universal recipe for interactive code. You polished three "Build" projects — the reaction arcade (5 states, scorecard), Morse blinker (string + lookup table + timing), and traffic-light controller (4 states, FSM formally named). Then you stepped back and learned the planning workflow professional engineers use.

• Skills: formalise any responsive device as an FSM; structure code as data + helpers + tiny loop(); plan on paper before opening the IDE.
• Key sketch: the L01-46 traffic light — four-state FSM with a clean enterState() helper and millis()-driven transitions.

The seven big ideas, side by side

Why it matters

Forty-eight lessons in, you've crossed the line from "person who's curious about microcontrollers" to "person who can build small devices that interact with the world". Level 2 will introduce real motors, communication protocols (I²C, SPI), libraries, more complex sensors, and persistent storage — but the foundation is built. The seven big ideas above will still be true on the last lesson of Level 4.

Worked Example — your "what I can do now" card 20 min

On a fresh page of your notebook (or a printed handout if you have one), produce a one-page reference card for everything Level 1 taught you. Use the structure below as a template; fill in the blanks with your actual recall and your actual built projects.

Section 1 — header

=== MY ARDUINO LEVEL 1 CREDENTIALS ===
Name:    __________
Started: __________ (date of your first lesson)
Finished: _________ (date of today)
Board:   Arduino Uno (or whichever you used)

Section 2 — pin operations cheat sheet (the L01-37 table)

Reproduce this table from memory. If you have to look it up, that's a sign Cluster D needs one more pass.

Section 3 — built-in functions I use most

List the Arduino functions you can write from memory without checking the reference. Aim for at least 10.

pinMode, digitalWrite, digitalRead, delay, millis, tone, noTone,
analogWrite, analogRead, Serial.begin, Serial.print, Serial.println,
Serial.available, Serial.read, map, constrain, random, randomSeed,
isDigit, isAlpha, toupper, abs, min, max ...

(Tick off the ones you actually remember; circle the ones you'd have to look up. Use the circled list as your "next week's refresh" target.)

Section 4 — projects I've built

List every project you actually completed end-to-end. Be honest — only count the ones that worked. For each, write the cluster it came from.

L01-02  Blink (built-in LED)                           [Cluster A]
L01-07  First external LED                             [Cluster B]
L01-10  Multiple LEDs                                  [Cluster B]
L01-15  Musical doorbell                               [Cluster B project]
L01-22  Reaction timer                                 [Cluster C]
L01-23  Simple burglar alarm                           [Cluster C project]
L01-29  Serial light show                              [Cluster D project]
L01-35  Mood lamp + theme tune                         [Cluster E project]
L01-43  Auto night light                               [Cluster F project]
L01-44  Reaction arcade                                [Cluster G build]
L01-45  Morse blinker                                  [Cluster G build]
L01-46  Traffic light + crossing                       [Cluster G build]
L01-47  Your own planned project: ___________________
...     any homework projects you built                ...

Section 5 — patterns I reach for by reflex

Name the high-leverage patterns you can produce from memory. Not specific code — the shape.

• State-change detection — compare digitalRead to lastButton, act once per edge. ✓ / ✗
• Non-blocking timing — if (millis() - lastEvent >= interval). ✓ / ✗
• State machine — switch (state) { case X: …; case Y: … } + stateEntryTime. ✓ / ✗
• Array + for-loop walk — for (int i = 0; i < N; i++) { … arr[i] … }. ✓ / ✗
• Voltage divider — sensor on top, fixed resistor on bottom, junction to analog pin. ✓ / ✗
• Map + constrain — constrain(map(x, 0, 1023, 0, 255), 0, 255) for scaling sensors to PWM. ✓ / ✗
• Hysteresis — two thresholds with a dead band to avoid flicker. ✓ / ✗
• Data / code split — keep the "what to play" in arrays, the "how to play" in a function. ✓ / ✗

Section 6 — vocab I can define in one sentence

Pick 15 of these vocabulary terms and write a one-sentence definition for each. Sources: every cluster's recap section.

setup() · loop() · pinMode · digitalWrite · digitalRead · INPUT_PULLUP
analog vs digital pin · PWM · duty cycle · analog-to-digital converter
voltage divider · pull-up resistor · LED polarity (anode/cathode)
debounce · state-change detection · finite state machine · transition
state diagram · hysteresis · deadband · linear interpolation
serial baud rate · Serial Monitor · null-terminator · ASCII code
boolean · AND / OR / NOT · short-circuit evaluation · truth table
array · 2D array · for loop · while loop · switch/case · helper function
millis() · non-blocking loop · ring buffer · linear scaling
sensor · actuator · sensor → decision → actuator loop

Section 7 — what's next

Next stop: Level 2.
Three things I want to build that I can't yet:
  1. ____________________
  2. ____________________
  3. ____________________

That's your credentials card — one page summarising the entire course. Take a phone photo of the finished version. Keep it somewhere you'll see it (taped above your desk, in the front of your notebook). When you start Level 2 and feel lost, glance at it and remember: you built thirteen things. The next thing is just one more.

Basic 5 min

For each task below, you have to combine ideas from at least three different clusters. No new techniques — pure consolidation. Build and test all three. Plan on paper first if it helps — the L01-47 way.

Challenge 1 5 min

Challenge 2 5 min

Challenge 3 — fix the broken music box 10 min

"Five bugs from five different lessons"

A classmate built a press-to-play music box. This is what it should do:

• Each button press plays the next note of a five-note tune — one note per press.
• The pot sets how long each note lasts, from 100 ms to 600 ms.
• The LED gets brighter with each note.
• After the fifth note, the next press starts again from the first.
• The Serial Monitor prints note 1 to note 5.

Their wiring: button from D7 to GND, LED with a 220 Ω resistor on D4, buzzer on D8, pot wiper on A0. Here is the sketch:

const int BUTTON_PIN = 7;
const int LED_PIN = 4;
const int BUZZER_PIN = 8;
const int POT_PIN = A0;
const int NUM_NOTES = 5;

int melody[NUM_NOTES] = { 262, 294, 330, 349, 392 };
int noteIndex = 0;
int lastButton = HIGH;

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

void loop() {
  int button = digitalRead(BUTTON_PIN);
  if (lastButton == HIGH && button == LOW) {
    int noteMs = map(analogRead(POT_PIN), 0, 1023, 100, 600);
    tone(BUZZER_PIN, melody[noteIndex], noteMs);
    analogWrite(LED_PIN, map(noteIndex, 0, NUM_NOTES - 1, 50, 255));
    Serial.print("note ");
    Serial.println(noteIndex);
    noteIndex = noteIndex + 1;
    if (noteIndex > NUM_NOTES) {
      noteIndex = 0;
    }
    delay(20);
  }
}

There are five mistakes, in the wiring and the code. For each one, write what is wrong, what you would see, and the fix. Then build the circuit, fix the sketch and upload it.

It works if:

• Each press plays exactly one note, even if you hold the button down.
• Five presses play the tune, and the sixth starts it again with no odd sixth note.
• The LED steps brighter with each note, and turning the pot changes the note length.
• The Monitor shows note 1 to note 5.

Recap 5 min

Forty-eight lessons. Seven clusters. One sketch shape (setup() + loop()) that hasn't changed since lesson 2. Today's lesson is the closing ceremony — you produced a personal credentials card, exercised cross-cluster combinations, and planned a project that integrates four or more clusters' worth of ideas. The seven big ideas — Cluster A's sketch shape, Cluster B's digitalWrite+for-loop, Cluster C's input pattern, Cluster D's Serial debug, Cluster E's PWM + arrays, Cluster F's sensors + map(), Cluster G's FSM + planning — are the foundation. Level 2 will add motors, libraries, communication protocols, and persistent storage, but every Level 2 lesson sits on what you built in Level 1. Keep the credentials card. Be proud of the projects. And turn the page — the next chapter is bigger.

The seven clusters

A · First Light, B · Digital Output, C · Digital Input, D · Serial Monitor, E · Lights & Sound, F · First Sensors, G · Build, Reflect, Recap. The structure of Level 1.

Cluster's big idea

The single most-load-bearing concept in a cluster — the one you'd want to keep if you forgot everything else. Seven big ideas summarise Level 1.

Credentials card

A one-page personal reference summarising every skill, vocabulary term, and project you've internalised. Produced today; kept somewhere visible for future-you to glance at.

Cross-cluster project

A project that draws on ideas from multiple clusters at once. The composition test — proof that skills don't just sit in isolation but combine into real devices.

"What I can do now"

The honest answer to "if a friend asked you to build an Arduino device, which devices could you confidently build today?" Builds — not memories of lessons — are the right measure.

The Level 1 → Level 2 transition

Level 2 introduces motors (servo + DC), communication (I²C and SPI), external libraries, and persistent storage (EEPROM). The seven big ideas of Level 1 stay true; new tools layer on top.

Extra Mission 5 min

Part 1 — Plan your Level 1 certification project

Design one project that proves you can use Level 1. Use the L01-47 workflow and produce all five artefacts. Ideas: a game-show countdown clock, a secret-knock lock, or a mood-light music box.

Your design must include:

• At least one digital output (LED or buzzer).
• At least one digital input (button or tilt switch).
• At least one analog part: an LDR, a pot, or an analogWrite fade.
• At least one multi-state behaviour: a state machine, an animation or several modes.
• At least one array, used for a sequence, a lookup or storage.
• A Serial Monitor message on every state change.

Part 2 — Make it

Build the project from your plan. Test every item on the checklist above, one by one.

Bring back next class:

• The saved .ino file.
• Photos of your five planning artefacts.
• A short video of the device running end to end.
• A Serial Monitor screenshot of the state messages.

Heads up for what's next: Level 2 opens with Cluster H — Motion: servos (precise angle control), DC motors and H-bridges (speed and direction). After that, Cluster I introduces real communication (I²C and SPI talking to chips that are smarter than the Uno), and Cluster J brings serious sensors — distance, accelerometer, temperature, humidity. The seven big ideas of Level 1 still apply on every lesson. You're ready. Congratulations on finishing Level 1.