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.

Try It Yourself — three cross-cluster reviews 15 min

For each task below, you have to combine ideas from at least three different clusters. No new techniques — pure consolidation. Do all three on paper first (the L01-47 way), then build the one you find most interesting.

Mini-Challenge — your "Level 1 certification" project 10 min

"One project that proves you've internalised Level 1"

Today's not a quiz — but if there were a one-project Level 1 exam, this would be it. Plan (and, time permitting, build) a single Arduino project that demonstrates competence across at least four of the seven clusters. Use the L01-47 paper-planning workflow to produce all five artefacts before touching the IDE.

The minimum bar — your project must include:

• At least one digital output (LED, buzzer).
• At least one digital input (button, tilt switch).
• At least one piece of analog (an LDR, a pot, an analogWrite fade, or an analogRead threshold).
• At least one multi-state behaviour (an FSM, an animation, or a multi-mode device).
• At least one piece of structured data (an array used somewhere — for sequences, lookup, or storage).
• Serial telemetry — at minimum, print the current state to the Monitor on every transition.

Seed ideas (don't have to use these):

• Mood-light music box: pot picks tempo, button cycles three melodies (each a 1D array), RGB LED pulses to the beat, LDR auto-mutes in dark rooms.
• Game-show clock: 30-second countdown with LED bargraph (5 LEDs ticking off), pot sets starting time, button starts/pauses, buzzer warns at 5 seconds and fires at 0.
• Secret-knock lock: tilt switch detects knocks; correct sequence (stored in array) lights green LED; wrong sequence beeps and resets; pot adjusts the "tolerance window" for knock timing.
• Theremin-thereminth: pot tunes base pitch, LDR (hand distance) modulates pitch up or down, RGB LED shifts colour with pitch, button toggles octaves.

Your task:

1. Pick a project (one of these or your own — must hit the six minimum-bar items).
2. Produce the five L01-47 planning artefacts on paper. Photo each.
3. If you have time today, start the build from your plan. (If not, today's deliverable is just the plan — build over the next few days.)
4. For each of the seven clusters, write next to your plan: "Cluster X is used here for ____". If a cluster has no entry, that's fine — you only need four.

It works if:

• Your plan covers at least four clusters.
• Every line of your pseudocode maps onto a Level 1 skill.
• You can defend, in one sentence per cluster, why you used each one.
• (Bonus, if you built it) the device runs end-to-end and you'd be happy to show it to a friend.

// Secret pattern: gaps between knocks, in ms
const int SECRET[2] = { 300, 600 };   // 3 knocks → 2 gaps
unsigned long knockTimes[3];          // timestamps of recorded knocks
int knockCount = 0;
int state = LISTENING;

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.

Homework 5 min

Three things, in any order:

1. Finish your credentials card from the worked example. All seven sections filled in, in your handwriting, on one page. Photo it.
2. Build your Mini-Challenge project from your five planning artefacts. Time yourself — note how long the build took. Take a 30-second phone video of the finished device.
3. Write a one-page "letter to my Level 1 starting-self". What would you tell yourself, knowing what you know now? What confused you that turned out to be simple? What seemed simple that turned out to matter a lot? Pin this somewhere you'll see it.

Also: a final reflection on paper.

• Of the 48 lessons, which one was your single favourite? Why? ____
• Which lesson did you find hardest? Did the hardness end up being worth it? ____
• Looking at your credentials card, which skill on it surprised you most when you read it back? ("Did I really learn that?") ____
• If you had to recommend Level 1 to a friend, what would you tell them — the honest pitch, including how long it took, what they'd be able to build, and what they should expect to struggle with? ____

Bring back next class (or to Level 2):

• Your completed credentials card (photo or scan).
• The .ino file of your Level-1-certification project.
• Your "letter to starting-self" page.
• Your four written reflection answers.

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.