The Arduino Family

Learning Goals 5 min

Welcome to Level 4. For three levels you've treated "Arduino" as one board — the UNO R3. The real Arduino family is a dozen boards spanning tiny, cheap microcontrollers to powerful IoT boards. The certification exam expects you to know them. By the end of this lesson you will be able to:

1. Name the main boards in the official Arduino family (UNO, Mega, Nano, MKR, Nano 33 BLE, Portenta) and roughly when to choose each.
2. Identify the four properties that distinguish boards: processor, memory, radios, operating voltage.
3. Spot the three biggest "UNO-shaped but different" gotchas: 3.3 V logic, native USB instead of FTDI, and different pinouts despite the same form factor.

Warm-Up 10 min

Lay out whatever Arduino-shaped boards you have. Likely candidates:

• UNO R3 — the original.
• Maybe a UNO R4 WiFi (the 2023 update with an ESP32-S3 co-processor).
• Nano (cheap clones often labelled "Nano V3").
• Nano 33 BLE / Nano 33 BLE Sense (from L03-26).
• An ESP-based board you used in L03-29..38 (NodeMCU, ESP32 DevKit).

Two quick questions

1. What's the highest voltage you should ever apply to a UNO R3 GPIO pin? What about a Nano 33 BLE?
2. You wrote a sketch using analogRead(A0) on UNO. Will it return the same numbers if you upload to a Nano 33 BLE?

New Concept · The board lineup 25 min

The official Arduino families

The lineup splits into three eras:

• Classic AVR (UNO, Nano, Mega): 8-bit, 5 V, simple, robust. The learning standard.
• Modern 32-bit (Nano 33 BLE, MKR, UNO R4, Nano ESP32): ARM or RISC-V, 3.3 V, much more memory, radios on board.
• Pro (Portenta, Opta): industrial form factors, dual-core, video / Ethernet / industrial bus support.

The four properties that matter

1. Processor: 8-bit AVR vs 32-bit ARM/RISC-V. 32-bit is faster and can run bigger libraries (TensorFlow Lite, OpenCV); 8-bit is more power-efficient and forgiving.
2. Memory: RAM (working memory, < 1 ms) and Flash (program memory, persistent). 2 KB RAM is tight for anything with a web server; 256 KB RAM runs a small operating system.
3. Radios: WiFi, BLE, Bluetooth Classic, LoRa, sub-GHz. Built-in vs add-on shield. Adds cost but removes wiring.
4. Operating voltage: 5 V for AVR; 3.3 V for everything modern. A 5 V signal into a 3.3 V GPIO can damage the chip.

The three biggest UNO-shaped gotchas

1. 3.3 V GPIO. The UNO R4 still has a 5 V supply rail but its GPIO can be configured 3.3 V. Many newer "UNO shape" boards (Arduino UNO R4 WiFi, Adafruit Metro M0) are 3.3 V GPIO. Old 5 V shields might still work if their inputs accept 3.3 V; old 5 V outputs into your board damage it.
2. Native USB. Modern boards use the main chip's native USB instead of a separate USB-serial chip. Different reset behaviour (no auto-reset on serial connect on some), and they can present as USB HID, mouse, keyboard, MIDI.
3. Different pinouts. The Mega's I²C pins are 20/21 not A4/A5. The MKR boards don't expose every GPIO on labelled pins. Always check the pinout diagram before connecting.

Worked Example · Pick a board for three real briefs 20 min

Brief 1 — "A wearable that detects when I wave and lights an LED"

Requirements: low power (battery), tiny, BLE optional, accelerometer, runs on a coin cell for hours.

Brief 2 — "A web-controlled lamp running for years on mains power"

Requirements: WiFi, robust, lots of free memory, OTA updates nice-to-have.

Brief 3 — "Replace 30 control wires with a single chassis with lots of GPIO"

Requirements: many digital inputs / outputs, no radio, lots of analog channels too.

Pattern in all three answers

The choice flows from the brief, not from the hype:

1. List the must-haves (radio, voltage, GPIO count, memory).
2. Filter the table from §3.
3. Pick the cheapest board that meets the must-haves.

Basic 5 min

Challenge 1 5 min

Challenge 2 5 min

const int SENSOR_PIN = A0;
const float VREF = 5.0;
const int ADC_MAX = 1023;

void setup() {
  Serial.begin(9600);
  analogReadResolution(12);
}

void loop() {
  int raw = analogRead(SENSOR_PIN);
  float volts = raw * VREF / ADC_MAX;
  Serial.println(volts);
  delay(500);
}

Challenge 3 · Make the data logger fit 10 min

This UNO logger will not upload. The IDE says it needs more memory than the UNO's 2 KB of RAM.

const int SENSOR_PIN = A0;

int readings[400];
float history[200];
char logText[300];
int count = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  readings[count] = map(analogRead(SENSOR_PIN), 0, 1023, 0, 100);
  count = count + 1;
  if (count == 400) {
    count = 0;
  }
  delay(1000);
}

1. On a UNO an int is 2 bytes, a float is 4 bytes and a char is 1 byte. Calculate the bytes the three arrays use.
2. Change the sketch so it fits. You must still keep 400 readings and 200 history values.
3. Upload it. Read the "Global variables use … bytes" line at the bottom of the IDE.

It works if the sketch uploads with global variables under 1,536 bytes (75 %). Then there is no "Low memory" warning.

Recap 5 min

The Arduino family is ~10 boards across three eras. Pick by listing requirements (voltage, GPIO count, memory, radio) and matching to the cheapest qualifying board. 5 V UNO-shaped boards are not always 5 V; modern boards are 3.3 V GPIO. Memory matters more than people think. Tomorrow we make this systematic — a board-picking checklist.

Microcontroller

A small all-in-one chip with CPU + memory + peripherals + GPIO. Arduino boards are essentially convenient packaging around microcontrollers.

AVR vs ARM vs RISC-V

Processor architectures. AVR = original 8-bit Atmel (UNO, Mega). ARM = 32-bit (Nano 33 BLE, MKR, Portenta). RISC-V = newest open architecture (some ESP32 variants).

Flash / RAM

Flash = program storage, persistent, KB to MB. RAM = working memory, volatile, KB to MB. Sketches need both.

3.3 V vs 5 V logic

The voltage that represents "HIGH". Mixing without a level shifter risks damage on the lower-voltage chip.

Native USB

USB built into the main chip, not a separate USB-serial converter. Lets the board be a HID device (keyboard, mouse, MIDI), faster, but different reset behaviour.

Form factor

The physical shape + pin arrangement: UNO shape, Nano shape, MKR shape. Sometimes interchangeable for shields, sometimes not.

Shield

An add-on board that plugs into another Arduino's headers. UNO-shaped shields work on most UNO-shaped boards but pinouts may differ.

Co-processor

A second chip handling specific functions (e.g. ESP32-S3 for WiFi on UNO R4 WiFi). Keeps the main chip simple.

Extra Mission 5 min

Part 1 — Design a gadget, then pick its board

Pick a gadget you would like to own — a bike light, a pet feeder, a desk weather display. On paper, design it and choose the right board from today's table.

Your design must include:

• A name and the gadget's one job, in one sentence.
• A list of every input and output part.
• Its needs: radio or not, 5 V or 3.3 V parts, and a rough memory guess.
• The board you chose, and one reason each for rejecting two other boards.

Part 2 — Make it

Build the core of your gadget on the UNO, using parts from Levels 1–3. Get one input driving one output. In setup(), print the board you chose and why, so the reason travels with the code.

Bring back next class: your design sheet, the uploaded sketch, and a photo of the working circuit.