Electronics Learning Curriculum & Project Roadmap

Your Inventory

Microcontrollers

Item Qty Notes
Arduino UNO R4 WiFi 1 ⭐ Star of the show — genuine Italian, Renesas RA4M1 ARM Cortex-M4, onboard LED matrix, WiFi+BLE, 256KB Flash/32KB RAM
Arduino Nano 3.0 5 ATmega328P, CH340 USB-C, great for permanent projects
Arduino UNO R3 (clone) 1 ATmega328P, CH340 — workhorse, identical pinout to R4
ESP32-S3 Nano 1 WiFi+BLE, 8MB PSRAM, runs MicroPython & Arduino — IoT powerhouse

Tools

Item Notes
FNIRSI DMT-99 Multimeter 9999-count True RMS, capacitance, frequency, temperature probe input
FNIRSI HS-02 Soldering Station 100W (GaN adapter), USB-C/DC, 100–450°C, instant heat, sleep + auto-off safety modes, multiple tips (I/IS/K + more). Portable toolbox kit.
FNIRSI DSO-TC3/TC4 Oscilloscope 3-in-1: digital oscilloscope + transistor/component tester + signal generator. TC4: 10MHz bandwidth, 48MSa/s. TC3: 500kHz, 10MSa/s. Auto-measure Vpp, frequency, duty cycle. Identifies unknown components automatically.
30V/10A bench power supply Adjustable DC source for safe breadboard testing. Use current limit first; think of it as circuit training wheels.
Helping hands (magnetic) 4x PCB holders + alligator clips
Soldering third hand 4x magnetic base, flexible arms

Power & Prototyping

Item Qty
MB-102 Breadboard (830-point) 1 large board
MB-102 Power supply modules 3 (3.3V/5V, 9V battery clip)
Dupont jumper wires (20cm) M-M, M-F, F-F kits with 40-pin connectors
Breadboard wires Extra short links for clean IC and display wiring
USB breakout board Exposes USB 5V/GND for breadboard power experiments
Double-side PCB prototype boards 5 (various sizes)

Components

Item Qty Details
Resistors (metal film 1%) 300 30 values, 10Ω–1MΩ, 1/4W
Electrolytic capacitors 500 24 specs, 0.1µF–1000µF, 16V–50V
Standard LEDs (3mm+5mm) 200 White, green, red, blue, yellow, orange
RGB LEDs (5mm, 4-pin) 50 Common cathode, diffused
Tactile push buttons 100 Momentary, breadboard-friendly
Toggle slide switches 20 4mm, PCB/breadboard mount
Passive piezo buzzers 10 3V–12V, needs PWM for tones
Potentiometers 10–20 WH148 B10K 10KΩ linear, breadboard-friendly, with knobs
Photoresistors (LDRs) 20 GL5528, 5mm, dark ~1MΩ / light ~10–20KΩ
DHT22 (AM2302 module) 2–3 ±0.5°C, 0–100% RH, pre-soldered module with dupont cable
1N4148 signal diodes set Fast small-signal diodes for one-way current, diode OR gates, and flyback experiments
NPN transistors set 2N3904 and 2N2222 low-side switches and small amplifiers
PNP transistors set 2N3906 high-side switching and push-pull output experiments
2N7000 MOSFETs set Voltage-controlled low-side switches and gate-charge demos
uA741 op amps set Amplifiers, comparators, and oscillator experiments
555 timer ICs set Hardware clocks, one-shots, latches, and tone generators
Relays set Mechanical switching controlled by a transistor or Arduino
74HC logic ICs set 74HC00/02/04/08/32 and related gates for truth tables and memory
LED bar graph set Compact multi-LED display for meters and status bars
7-segment display + 74LS48 set Numeric display driven from binary-coded decimal
330 ohm SIP resistor networks set Compact current-limiting resistors for displays and LED arrays
Small speaker + 3.5mm socket set Audio output, signal tracing, and tiny amplifier experiments

Phase 0: Tool Familiarisation (2–3 sessions)

0.1 Multimeter Mastery

Your DMT-99 is a serious instrument. Learn it well.

Exercises:

  • Measure battery voltages (AA, 9V, USB)
  • Measure resistor values and verify against colour codes
  • Measure continuity on jumper wires and breadboard rails
  • Measure capacitance on those electrolytics
  • Test diodes/LEDs with the diode mode

0.2 Oscilloscope & Component Tester (DSO-TC3/TC4)

Your DSO-TC3/TC4 is a 3-in-1: oscilloscope + transistor tester + signal generator. Absolute gem for learning.

Component Tester Exercises:

  • Insert an unknown resistor → it identifies value automatically
  • Test all your capacitors — verifies capacitance and ESR
  • Identify NPN vs PNP transistors (if you get any), pinout, hFE gain
  • Test diodes and LEDs — shows forward voltage and polarity
  • The TC4 will even identify MOSFETs, JFETs, triacs, and more

Oscilloscope Exercises:

  • Connect probe to the 1kHz test signal output (built-in calibration square wave) — learn to read volts/div and time/div
  • Measure the PWM output from Arduino (see the waveform change from 0% to 100% duty cycle)
  • Capture a button press (watch the voltage drop on the falling edge)
  • Measure buzzer tone frequency
  • Key skill: trigger setup — auto, normal, single-shot. Learn when to use each.

Signal Generator Exercises:

  • Output a 1kHz sine/square wave into the oscilloscope channel — see both generated and measured signal
  • Drive a buzzer at different frequencies
  • Use it as a clock source for a 555 timer circuit later

0.3 Breadboard Anatomy

  • Power rails (red/blue lines run vertically)
  • Terminal strips (rows of 5 connected horizontally, split by centre channel)
  • How the MB-102 power supply module snaps on
  • Key rule: never insert/depower ICs or modules while powered

Phase 1: Ohm's Law & Basic Circuits (no microcontroller)

Lesson 1.1 — LED + Resistor: The First Circuit

Learn: Ohm's Law (V=IR), forward voltage, current limiting Build:

  • Power an LED from 5V breadboard supply
  • Calculate the correct resistor: R = (5V − Vf) / I
    • Red LED Vf ≈ 2.0V, 20mA → R = 150Ω
    • Blue/white LED Vf ≈ 3.2V, 20mA → R = 100Ω
  • Measure actual current with multimeter in series
  • Experiment: try different resistor values, observe brightness

Lesson 1.2 — Series vs Parallel

Build:

  • 3 LEDs in series with one resistor (why won't it work well from 5V?)
  • 3 LEDs in parallel, each with its own resistor (the correct way)
  • Measure voltage drops across each LED
  • Key insight: current is the same in series; voltage is the same in parallel

Lesson 1.3 — Switches & Buttons

Learn: Normally open (NO) vs normally closed, pull-up vs pull-down resistors Build:

  • Toggle switch controlling an LED (simple SPST)
  • Push button with pull-down resistor controlling LED
  • Push button with pull-up resistor (inverted logic)
  • Measure: voltage at the input pin in both switch states

Lesson 1.4 — Capacitors: Timing & Smoothing

Learn: RC time constant τ = R×C, charging/discharging curves Build:

  • RC circuit with large cap (1000µF) + resistor, watch LED fade on/off
  • Use multimeter to watch voltage rise/fall
  • Experiment: calculate τ for different R×C combinations, verify with stopwatch
  • Application: simple debounce circuit for a button

Phase 2: Active Components, Logic, Displays, and Power

This is the new bridge the original plan was missing: the middle ground between "LED plus resistor" and "the Arduino magically does things." These lessons teach the parts that let small signals control bigger loads, shape time, make decisions, display information, and handle power safely.

Lesson A.0 - Power Sources and Current Limits

Learn: bench supply voltage/current limit, USB breakout power, common ground, safe first measurements Build: power the same LED from USB, the MB-102 supply, and the bench supply; use current limit to dim the LED safely.

Lesson A.1 - Diodes

Learn: one-way current, forward voltage, rectification, diode OR gates Build: LED diode tester, half-wave rectifier on the scope, two-button diode OR gate.

Lesson A.2 - NPN Transistor Switch

Learn: base current, collector/emitter switching, saturation Build: LED switch, finger touch sensor, LDR dark detector.

Lesson A.3 - PNP and Push-Pull Outputs

Learn: high-side switching, source vs sink current, push-pull output stages Build: PNP LED switch and complementary transistor output.

Lesson A.4 - MOSFET Switch

Learn: voltage-controlled switching, floating gates, gate discharge resistors Build: 2N7000 LED switch, touch latch, signal-generator PWM dimmer.

Lesson A.5 - 555 Astable

Learn: hardware clocks, RC timing, square waves Build: blinking LED clock, scope the capacitor ramp, make a light-controlled buzzer.

Lesson A.6 - 555 Monostable and Bistable

Learn: one-shot timers, button triggers, hardware memory Build: timed LED pulse, touch-triggered one-shot, set/reset latch.

Lesson A.7 - Op-Amp Amplifier

Learn: gain, biasing, tiny-signal amplification Build: uA741 non-inverting amplifier and scope input/output.

Lesson A.8 - Op-Amp Comparator and Oscillator

Learn: thresholds, comparator decisions, Schmitt action, relaxation oscillators Build: adjustable light/dark trip point and square-wave oscillator.

Lesson A.9 - Relays

Learn: coil current, COM/NO/NC contacts, flyback diodes Build: Arduino-controlled relay driver through a 2N3904 and 1N4148.

Lesson A.10 - Logic Gates

Learn: 74HC truth tables, NAND gates, latches, simple binary decisions Build: button-driven NAND gate, SR latch, majority vote, half-adder.

Lesson A.11 - 7-Segment Displays

Learn: BCD, 74LS48 decoding, segment current limiting Build: DIP-switch number display and Arduino counter.

Lesson A.12 - Audio

Learn: oscillators, coupling capacitors, speaker drivers, 3.5mm audio input Build: 555 tone maker, small speaker driver, stylophone-style pitch toy, tiny amplifier experiment.

Lesson A.13 - LED Bar Graph and Resistor Networks

Learn: LED bar graph pin mapping, SIP resistor networks, bar/dot displays Build: pot-controlled 10-segment meter with button-selectable display mode.

Phase 3: Arduino Fundamentals

Lesson 2.1 — Setup & Blink (Arduino UNO R4)

Software: Install Arduino IDE 2.x, select "Arduino UNO R4 WiFi" board Code:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);  // Built-in LED on pin 13
}
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

Extensions:

  • Change blink rate, make patterns (SOS in Morse)
  • External LED on breadboard with resistor (pin 13 already has one built-in, so external needs its own)

Lesson 2.2 — Digital I/O: Button → LED

Learn: pinMode(INPUT_PULLUP), digitalRead(), debouncing Build: Button controls LED toggle (each press toggles state) Key concept: INPUT_PULLUP uses internal ~20KΩ resistor — no external resistor needed

Lesson 2.3 — Analog Input: Potentiometer + Serial Monitor

Learn: ADC (analog-to-digital conversion), 0–1023 range (10-bit), analogRead(), Serial.begin(), map() Hardware: 10KΩ potentiometer, 3 jumper wires Wiring: Left pin → 5V, middle pin (wiper) → A0, right pin → GND Build:

  • Read the pot with analogRead(A0) — prints 0–1023 to Serial Monitor
  • Turn the knob, watch the value change
  • Oscilloscope bonus: probe the wiper pin — watch the DC voltage level shift up and down in real time
  • Map 0–1023 → 0–255, use as PWM duty cycle → pot-controlled LED dimmer
  • Map to a delay value → pot-controlled blink speed

Key insight: The potentiometer is a variable voltage divider. At midpoint, the wiper sits at 2.5V (half of 5V) → ADC reads ~512. This is exactly how every analog sensor works — they all produce a variable voltage that the ADC measures.

Lesson 2.4 — PWM: Fading & Tones

Learn: PWM (pulse-width modulation), analogWrite(), 0–255 range Build:

  • LED fade in/out (breathing effect) on PWM pin (~D3, D5, D6, D9, D10, D11)
  • Passive buzzer: use tone(pin, frequency) to play notes
    • Middle C = 262Hz
    • Play a simple melody (Twinkle Twinkle Little Star)

Phase 4: Real Sensors (Potentiometer, LDR, Temperature)

Lesson 3.1 — Light Sensor (LDR + Voltage Divider)

Learn: Voltage dividers as sensors, analogRead() with real-world input, threshold logic Hardware: GL5528 LDR, 10KΩ fixed resistor Wiring (voltage divider):

  • 5V → LDR (one leg) → junction point → 10KΩ resistor → GND
  • Junction point → A0
  • This is a "pull-down" divider: bright light = LDR ~10KΩ → A0 reads ~2.5V (~512). Dark = LDR ~1MΩ → A0 reads ~0.05V (~10). Build:
  • Print raw ADC value to Serial Monitor — cover the LDR with your finger, shine a torch on it
  • Use the oscilloscope to watch the DC level shift as light changes
  • Set a threshold: if light level < threshold → turn on an LED → automatic night light
  • Extension: calibrate min/max readings, map to LED brightness → auto-dimming lamp

Lesson 3.2 — Temperature & Humidity (DHT22)

Learn: Digital sensors, one-wire protocol, libraries (#include), sensor datasheets

Hardware: AM2302 module (3 pins: VCC, DATA, GND)

Wiring:

  • VCC → 5V (or 3.3V — works on both)
  • DATA → D2 (any digital pin, but use D2 to start)
  • GND → GND
  • Module has built-in pull-up resistor — no extra components needed

Software: Install "DHT sensor library" by Adafruit (Sketch → Include Library → Manage Libraries → search "DHT")

Code skeleton:

#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

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

void loop() {
  float t = dht.readTemperature();
  float h = dht.readHumidity();

  Serial.print("Temp: "); Serial.print(t); Serial.print("°C  ");
  Serial.print("Humidity: "); Serial.print(h); Serial.println("%");

  delay(2000);
}

Experiments:

  • Breathe on the sensor — watch humidity spike within 1–2 seconds
  • Move it from indoors to outdoors — see temperature shift
  • Log data to Serial Plotter (Tools → Serial Plotter) — see temperature trends in real-time graph

Lesson 3.3 — Combining Sensors: Decision Logic

Learn: if/else if/else, compound conditions, sensor fusion Build: Temperature-dependent night light

  • If it's dark (LDR < threshold) AND warm (>25°C) → red LED (hot night)
  • If it's dark AND cool (<20°C) → blue LED (cold night)
  • If it's light → all LEDs off Key concept: Combining multiple sensor inputs to make decisions — this is the foundation of every thermostat, weather station, and automation controller.

Phase 5: Intermediate Projects

Project 1: Reaction Timer Game

Hardware: 1 LED, 1 button, buzzer Gameplay:

  1. LED lights after random delay (2–8 seconds)
  2. Player presses button ASAP
  3. Buzzer plays victory beep, Serial prints reaction time in ms
  4. Track best score Learn: millis(), random(), non-blocking timing, state machines

Project 2: RGB Colour Mixer

Hardware: 1 RGB LED (common cathode), 3 PWM pins per colour channel Learn: PWM mixing to create any colour, common cathode wiring (shared GND, each anode gets PWM via resistor) Build:

  • Three buttons cycle R, G, B values up/down
  • Serial monitor shows current RGB values
  • Create a rainbow fade sequence Extension: Make a colour-changing night light that cycles slowly

Project 3: Electronic Dice

Hardware: 7 LEDs arranged as dice dots, 1 button Build: Press button → LEDs "roll" animation → settle on random number 1–6 Learn: randomSeed() from floating analog pin, LED multiplexing logic, arrays of pin numbers Challenge: Use the 6 LEDs to display numbers in traditional dice patterns (not just count)

Project 4: Simon Says Memory Game

Hardware: 4 coloured LEDs (R, G, B, Y), 4 buttons, buzzer Gameplay:

  1. Game plays an increasingly long sequence of LED flashes + tones
  2. Player must repeat the sequence by pressing the correct buttons
  3. Buzzer plays different tones for success/failure Learn: Arrays for sequence storage, state machines, tone library

Project 5: Pot-Controlled Rainbow

Hardware: Potentiometer + RGB LED Build: Turn the knob → colour shifts through the rainbow. Potentiometer controls hue, second pot (or button) controls brightness. Learn: map() with multiple ranges, HSV-to-RGB conversion logic, smooth colour transitions Extension: Add a button to toggle between "manual knob" mode and "auto-fade" mode

Project 6: Automatic Night Light

Hardware: LDR + white LED + 10KΩ resistor Build: LDR reads ambient light. When it drops below a calibrated threshold, a white LED fades on smoothly over 2 seconds (not a harsh snap-on). When light returns, it fades off. Learn: Calibration (min/max readings), hysteresis (so it doesn't flicker at the threshold), constrain(), non-blocking fade with millis() Real use: Actually put this in a hallway or kid's room. No switch needed — it just works.

Project 7: Temperature Alert System

Hardware: DHT22 + 3 LEDs (blue/green/red) + buzzer Build:

  • Blue LED: below 18°C ("it's cold")
  • Green LED: 18–26°C ("comfortable")
  • Red LED + buzzer beep: above 30°C ("too hot!")
  • Bonus: log the highest/lowest temperature seen since power-on Learn: Multi-threshold logic, state tracking variables, millis() for timed alerts

Project 8: Desktop Weather Station

Hardware: DHT22 + LDR + 4 LEDs + UNO R4 WiFi (or ESP32-S3) Build:

  • Display temperature, humidity, and "light level" on Serial Monitor (and eventually on the UNO R4 LED matrix or a web page)
  • Use the LEDs as a simple bar graph: more LEDs lit = warmer
  • Stretch goal: send data to a Google Sheet or a simple web dashboard via WiFi Learn: Structuring multi-sensor code cleanly, data formatting, timing sensor reads

Phase 6: WiFi & IoT (UNO R4 WiFi + ESP32-S3)

Lesson 5.1 — Arduino UNO R4 WiFi Basics

  • Connect to WiFi
  • Run a simple web server that toggles an LED from a browser
  • Use the onboard 12×8 LED matrix to display text/graphics

Lesson 5.2 — ESP32-S3 Nano

Two paths here:

  • Arduino framework: familiar syntax, massive library ecosystem
  • MicroPython: REPL interactive, great for rapid prototyping, good with James

First ESP32 project: WiFi scanner — list all nearby networks with signal strength

Project 5: Web-Controlled RGB Lamp

Hardware: ESP32-S3 + RGB LED (or 3 separate LEDs) Build: Web server with colour picker UI — control LED colour from phone browser Learn: WiFi connection, HTTP server, HTML/CSS basics, PWM control

Project 6: Internet Clock

Hardware: UNO R4 WiFi, onboard LED matrix Build: Fetch time from NTP server, display on LED matrix Learn: NTP protocol, time libraries, LED matrix programming

Project 7: Doorbell to Telegram

Hardware: ESP32-S3 + button + buzzer Build: Press button → plays chime on buzzer AND sends Telegram message (or ntfy notification) via HTTP POST Learn: HTTPClient, webhook APIs, JSON formatting Real-world use: Can be James's room doorbell 😄

Phase 7: Soldering & Permanent Projects

Now that you've got the FNIRSI HS-02 (100W, 100–450°C, USB-C/DC powered with instant heat-up), you can start making breadboard prototypes permanent.

Soldering Starter Exercises

Before tackling a real project:

  1. Tin a tip — learn to apply solder to the tip, wipe clean, re-tin
  2. Through-hole resistor — solder a resistor into one of your proto boards. Inspect with magnifier.
  3. Solder a header pin strip onto a Nano — this is the most practical first skill
  4. Desolder and rework — use solder wick or a sucker to remove a joint cleanly
  5. Wire-to-pad — solder Dupont wire directly to a proto board pad

HS-02 tips: Use 320–350°C for through-hole work, 280–300°C for finer SMD. The K tip is ideal for most through-hole; IS for finer work.

Soldering Projects

  1. LED flasher board — classic 555 timer + LEDs on protoboard. First permanent circuit!
  2. Nano breakout board — solder female headers to a proto board so you can swap Nanos easily
  3. Permanent reaction timer — Nano + button + LED + buzzer soldered to protoboard, in a small enclosure
  4. Bike tail light — Nano + 5 red LEDs in sequence + toggle switch, 9V battery powered
  5. Caravan voltage monitor — Nano + voltage divider reads 12V battery → LED bar graph display (useful real-world project!)
  6. Home watering system — Replace the broken irrigation controller with Arduino Nano + relay hardware and a Raspberry Pi web interface.

Quick-Reference: Pin Cheat Sheet

Arduino UNO R4 WiFi (and R3)

Function Pins
Digital I/O D0–D13
PWM (~) D3, D5, D6, D9, D10, D11
Analog In A0–A5
I²C A4 (SDA), A5 (SCL)
Built-in LED D13
LED Matrix Built-in (R4 only)

Arduino Nano

Function Pins
Digital I/O D2–D13 (D0/D1 are RX/TX, avoid for general I/O)
PWM (~) D3, D5, D6, D9, D10, D11
Analog In A0–A7
Built-in LED D13

ESP32-S3 Nano

Function Pins
GPIO Most pins (check pinout diagram — some are input-only: 34–39 on classic ESP32)
ADC Multiple channels, 12-bit (0–4095)
DAC 2 channels (8-bit)
Touch Capacitive touch on several pins
Built-in LED Usually GPIO 48 or similar (check specific board)

Wiring Quick-Reference

LED (standard):
  Anode (long leg) → Resistor → GPIO pin
  Cathode (short leg, flat side) → GND
  Resistor: Red/Yellow/Green ~150–220Ω, Blue/White ~100–150Ω

RGB LED (common cathode):
  Common cathode (longest leg) → GND
  Red anode → 220Ω → PWM pin
  Green anode → 220Ω → PWM pin
  Blue anode → 220Ω → PWM pin

Button (with INPUT_PULLUP):
  One leg → GND
  Other leg → GPIO pin
  (Internal pull-up enables — reads HIGH when open, LOW when pressed)

Passive Buzzer:
  One pin → GPIO (PWM capable)
  Other pin → GND
  tone(pin, frequency, duration);

Capacitor (electrolytic):
  Longer leg = positive (anode)
  Stripe on can = negative (cathode)
  Voltage rating must exceed circuit voltage

Potentiometer (B10K, 3 pins in a row):
  Left pin    → 5V (or GND — just be consistent)
  Middle pin  → ADC input (A0–A5) — this is the wiper, variable voltage out
  Right pin   → GND (or 5V)
  Acts as adjustable voltage divider. Clockwise = wiper moves toward the 5V pin.

LDR (GL5528 photoresistor, voltage divider):
  5V → LDR → junction → 10KΩ resistor → GND
              ↓
             A0
  Bright = LDR ~10KΩ → A0 ~2.5V → ADC ~512
  Dark   = LDR ~1MΩ  → A0 ~0.05V → ADC ~10

DHT22 (AM2302 module, 3 pins):
  VCC  → 5V (or 3.3V)
  DATA → D2 (any digital pin, 10KΩ pull-up already on the module PCB)
  GND  → GND
  Library: Adafruit DHT Sensor Library

Bench supply:
  Start low: 5.00V, 0.03A to 0.10A current limit for breadboard lessons
  Black terminal is this circuit's GND reference
  Never connect 30V to a 5V Arduino/breadboard circuit

USB breakout:
  VBUS/5V -> breadboard 5V rail
  GND     -> breadboard GND rail
  D+ / D- are USB data pins; ignore until a lesson explicitly uses them

1N4148 diode:
  Current flows anode -> cathode band
  Diode test should show about 0.6V to 0.8V forward, OL reverse

NPN low-side switch (2N3904/2N2222):
  +5V -> load -> collector
  emitter -> GND
  control signal -> base resistor -> base

PNP high-side switch (2N3906):
  emitter -> +5V
  collector -> load -> GND
  pull base low through a resistor to turn on

2N7000 MOSFET low-side switch:
  +5V -> load -> drain
  source -> GND
  gate -> control signal
  add 100K to 10M gate-to-GND so it turns off predictably

Relay driven by transistor:
  +5V -> relay coil -> NPN collector
  NPN emitter -> GND
  1N4148 across coil, cathode stripe to +5V
  Arduino pin -> 1K -> NPN base

74HC logic IC:
  pin 14 -> 5V
  pin 7  -> GND
  never leave inputs floating; use pull-up or pull-down resistors

LED bar graph with bussed SIP network:
  Arduino pin -> segment anode
  segment cathode -> SIP resistor output
  SIP common -> GND

Learning Resources

Books

  • Make: Electronics by Charles Platt — the gold standard for hands-on learning
  • Practical Electronics for Inventors — reference bible
  • Arduino Workshop by John Boxall

Online

  • Paul McWhorter's Arduino tutorials on YouTube (excellent, methodical)
  • Adafruit Learning System (adafruit.com)
  • Random Nerd Tutorials (for ESP32)

Simulators

  • Wokwi.com — simulate Arduino + ESP32 circuits in browser before building
  • Tinkercad Circuits — beginner-friendly

Suggested First Session

  1. Multimeter: Measure everything — batteries, resistors, continuity on breadboard
  2. Blink: External LED on breadboard with Arduino UNO R4
  3. Button: Add a button, make it toggle the LED
  4. Serial: Print button press count to Serial Monitor

That's a solid 1–2 hour first session and covers the fundamentals you'll use in every future project.

📖 Read the blog post  |  📚 Browse all 47 lessons  |  🐙 GitHub repo