Choosing the Right Board

Learning Goals 5 min

Yesterday you met the family. Today you turn "know all the boards" into a systematic checklist that picks the right one for any project. By the end of this lesson you will be able to:

1. Use a five-question checklist to filter the Arduino family down to 1–2 candidate boards for any project brief.
2. Estimate program size and RAM use from a feature list, and reject under-spec'd boards before wasting time.
3. Balance hard requirements (must work) against soft ones (would be nice) so cost and effort stay in budget.

Warm-Up 10 min

Pick three project ideas from your head — wild ones are fine. Some examples:

• A weather station that tweets daily summaries.
• A wearable rhythm game (mat that lights up when you stomp).
• A self-driving line-follower for the school maker fair.
• An aquarium pump scheduler with phone notifications.

For each, jot down: what radios it needs, how many GPIO, how much RAM, voltage, power source, battery hours.

New Concept · The five-question checklist 25 min

Q1 — Does it need a radio? Which kind?

Q2 — How many GPIO do you actually need?

Count every input and output:

• Buttons + switches + sensors (digital + analog).
• LEDs / motors / servos / displays.
• Add 2 for SPI (SCK + COPI + CIPO, with per-device CS).
• Add 2 for I²C (SDA + SCL — shared).
• Add 2 for serial (TX + RX if you talk to another microcontroller).

Q3 — How much memory will the sketch need?

Rough estimates for adding common features:

Sum the estimates. Compare with the candidate board's flash/RAM. UNO's 2 KB RAM eats out fast: HTTPS alone won't fit. ESP8266's 80 KB RAM handles WiFi + HTTPS + a few KB of state comfortably.

Q4 — What's the power source?

Q5 — What's the budget?

Cheapest first. For a one-off school project the savings don't matter; for a 30-student class deploying 30 devices, band 1 vs band 4 matters a lot. Prices change, so this course uses price bands: band 1 is the cheapest, and each band up costs roughly twice as much.

The decision tree

1. Answer Q1 — radio. Filter the list.
2. Answer Q2 — GPIO. Filter further.
3. Answer Q3 — memory. Eliminate under-spec.
4. Answer Q4 — power. Confirm low-power option if needed.
5. Answer Q5 — pick the cheapest survivor.

Worked Example · Pick three boards live 25 min

Brief 1 — Smart Plant Monitor (L03-44)

Requirements list:

• WiFi for dashboard + alerts. (Q1)
• 1 analog (soil) + 1 GPIO (status LED) = 2 GPIO. (Q2)
• WebServer + HTTPS for webhooks: ~80 KB flash, ~35 KB RAM. (Q3)
• USB wall wart, runs continuously. (Q4)
• Budget: band 1–2. (Q5)

Brief 2 — Wearable Gesture-Trigger

Requirements:

• BLE for phone connection. (Q1)
• 1 IMU (on-board), 1 LED. (Q2)
• TFLite Micro for gesture classification: ~150 KB flash, ~50 KB RAM. (Q3)
• Coin cell / LiPo, runs hours. (Q4)
• Budget: band 4. (Q5)

Brief 3 — Maker-fair robot car with phone control + obstacle avoidance + WiFi telemetry

Requirements:

• WiFi + BLE (or just one). (Q1)
• 4 motor IN + 2 enable + 2 sensor (HC-SR04) + 1 LED = 9 GPIO. (Q2)
• WebSocket + sensor sampling: ~50 KB flash, ~20 KB RAM. (Q3)
• 2S LiPo or 4 × AA. (Q4)
• Budget: band 2. (Q5)

Basic 5 min

Challenge 1 5 min

Challenge 2 5 min

Challenge 3 · Code the board picker 10 min

Turn the five-question checklist into a sketch. It asks questions in the Serial Monitor and prints a board.

1. Ask for the radio: 0 = none, 1 = BLE, 2 = WiFi, 3 = WiFi and BLE.
2. Ask for the number of pins, and the RAM needed in KB.
3. Ask if it needs a built-in motion sensor (IMU): 0 = no, 1 = yes.
4. Use if / else if to print one board name.

Use a helper function that waits for a number:

int askNumber(const char* question) {
  Serial.println(question);
  while (Serial.available() == 0) {
  }
  int answer = Serial.parseInt();
  while (Serial.available() > 0) {
    Serial.read();
  }
  return answer;
}

It works if the three Worked Example briefs print NodeMCU ESP8266, Nano 33 BLE Sense and ESP32 DevKit.

Recap 5 min

Board choice is a 5-question filter, not a feel. Radios first, then GPIO, then memory, then power, then cost. Pick the cheapest qualifying board with reasonable headroom. Most school projects land on three families: UNO R3 (simple), ESP8266/ESP32 (WiFi), Nano 33 BLE family (BLE / low-power / ML). Tomorrow we tackle the practical side: what breaks when you move a UNO sketch to a Nano 33 BLE, and how to fix it.

Hard requirement

Something the project absolutely needs. Filter out boards that don't meet these.

Soft requirement

Nice-to-have. Used to choose between qualifying boards but doesn't exclude any.

Headroom

Spare capacity (RAM, flash, GPIO) beyond what the current feature set uses. Lets you add features later without re-spec'ing.

Decision tree / flowchart

A series of yes/no questions that funnel to a recommendation. The most reliable way to pick boards consistently.

I/O expander

An I²C or SPI chip that adds GPIO. Use when a small board doesn't have enough pins natively.

Deep sleep

Microcontroller mode where almost everything is off, drawing µA. Required for any long-life battery project. Covered in L04-37.

OEM project

A design intended to ship as a product. Picks based on cost / power / availability much more strictly than a hobby project.

Extra Mission 5 min

Part 1 — Design a gadget through the checklist

Pick a project idea you have been thinking about — a plant waterer, a reaction game, a bedroom door alarm. On paper, run it through the five questions.

Your design must include:

• A one-sentence job for the gadget.
• A written answer to each of Q1 to Q5, with numbers for pins and memory.
• The board it picks, and the runner-up you rejected.
• A quick drawing of the parts around the board.

Part 2 — Make it

Type your answers into your Challenge 3 board picker. Does it agree with you? If not, fix the picker or your answers. Then build the core of the gadget on the UNO with parts from Levels 1–3.

Bring back next class: the picker's answer (a screenshot), the gadget sketch, and a photo of the circuit. For ARD-L04-03, also bring a UNO sketch and any non-UNO board.