Arduino Hobbyist Roadmap: From Blink to IoT

Identify the physical components of an Arduino Uno and establish a working USB connection to the computer.

Install the Arduino IDE, select the correct board and port, and verify the installation with a successful compile.

Explain the role of setup() and loop() functions in an Arduino sketch and identify where code executes once versus repeatedly.

Implement a sketch that turns the built-in LED on and off using pinMode, digitalWrite, and delay.

Implement Serial.begin and Serial.println to send status messages from the Arduino to the computer for verification.

Diagnose and resolve common upload failures including wrong port, wrong board, and driver problems.

Design and upload a sketch that blinks the built-in LED in a unique pattern (e.g., SOS) while printing each state change to the Serial Monitor; success criteria: pattern repeats correctly, serial output matches LED state

Explain how digitalRead interprets voltage levels as HIGH or LOW on a configured input pin.

Implement a pushbutton circuit using an external pull-down resistor to produce a clean HIGH signal when pressed.

Implement a button circuit using INPUT_PULLUP mode, eliminating external resistors and inverting logic interpretation.

Implement a time-based debounce algorithm to filter contact bounce and detect a single stable press event.

Implement edge detection logic to trigger actions only on button press (rising) or release (falling) transitions.

Design a sketch that independently reads three buttons and toggles three corresponding LEDs using non-blocking logic.

Build a working reaction timer game artifact that lights an LED after a random delay, measures milliseconds until button press, and displays the result via Serial Monitor with a pass/fail threshold of 500ms.

Explain the difference between analog and digital signals using real-world examples and a simple text diagram.

Implement a sketch that reads voltage from a potentiometer using analogRead() and prints raw ADC values to the Serial Monitor.

Calculate actual voltage from raw ADC readings using the reference voltage and resolution of the Arduino ADC.

Use the map() function to scale analog input values to a desired output range for controlling an LED or servo.

Implement a moving average filter to smooth noisy analog sensor data and compare raw vs filtered output in the Serial Plotter.

Build a circuit with a photoresistor and LED, then write a sketch that adjusts LED brightness based on ambient light level using analog input and PWM.

Design and build an automatic night light that turns on an LED when ambient light drops below a user-adjustable threshold (set via potentiometer), with smooth transitions and no flickering; success criteria: LED turns on

Explain how Pulse Width Modulation creates the illusion of analog voltage levels using only digital HIGH/LOW signals and a duty cycle percentage.

Identify which pins on the Arduino Uno support hardware PWM (3, 5, 6, 9, 10, 11) and explain why analogWrite() only works on these specific pins.

Implement a sketch that smoothly fades an LED on and off using analogWrite() inside a loop with incremental duty cycle changes and delay().

Implement a circuit and sketch that maps analog input values (0-1023) from a potentiometer to PWM output values (0-255) to manually control LED brightness in real time.

Construct a circuit using an NPN transistor as a switch and implement PWM control to vary the speed of a DC motor, explaining why the transistor is necessary for current amplification.

Implement control of a hobby servo motor using the Servo library to sweep its shaft from 0 to 180 degrees, distinguishing servo PWM timing requirements from standard analogWrite() PWM.

Design and build a working artifact: a single Arduino sketch and breadboard circuit that simultaneously controls LED brightness via potentiometer, DC motor speed via a second potentiometer, and servo position via a third

Explain the purpose of serial communication and demonstrate opening the Serial Monitor at the correct baud rate to view text output from a sketch.

Implement Serial.print() and Serial.println() statements to output static text and variable values for real-time code tracing.

Design formatted serial output using tabs, labels, and strategic newlines to create structured, human-readable debug logs.

Implement Serial.available() and Serial.read() to accept single-character commands from the Serial Monitor and trigger actions.

Implement a string buffer using Serial.readStringUntil() to parse multi-character commands (e.g., "LED ON") and execute corresponding logic.

Debug a deliberately flawed sketch by inserting strategic Serial.print() checkpoints to trace variable state and identify logic errors.

Build a menu-driven serial console that lets a user toggle LEDs, read a potentiometer value, and display system status on demand; success criteria: menu displays within 2 seconds of reset, all 4 commands execute correctl

Explain the I2C protocol's two-wire architecture, addressing scheme, and master-slave roles using a bus diagram

Implement an Arduino I2C master transmitter sketch that initializes the Wire library and scans for connected device addresses

Implement an Arduino I2C master receiver sketch that requests and reads multi-byte sensor data using repeated start conditions

Configure a BMP280 temperature/pressure sensor by writing to its control registers and verify configuration by reading back register values

Design a wiring and code strategy to connect two same-address I2C sensors using a TCA9548A multiplexer and read from both sequentially

Debug I2C communication failures by interpreting logic analyzer captures of SDA/SCL waveforms and identifying ACK/NACK patterns

Build a working I2C environmental monitor that logs temperature, pressure, and humidity from two sensors (BMP280 + AHT20) via multiplexer to an SD card every 30 seconds, with success criteria: (1) both sensors initialize

Explain how the Arduino's 10-bit ADC converts analog voltage (0-5V) into digital values (0-1023) and identify the correct pin mode for analog input.

Implement a voltage divider circuit with a photoresistor and fixed resistor to convert variable light levels into readable analog voltages on an Arduino pin.

Implement a circuit with the TMP36 sensor and write code to convert its raw analog reading into temperature in degrees Celsius using the sensor's linear scale factor.

Implement a circuit with a PIR motion sensor and write code to detect HIGH/LOW digital signals indicating motion presence, including handling the sensor's warm-up delay.

Implement a circuit with the HC-SR04 ultrasonic sensor and write code to trigger a pulse, measure echo duration with pulseIn(), and calculate distance in centimeters using the speed of sound.

Implement a moving average filter in code to reduce noise from analog sensor readings (photoresistor or TMP36) by averaging the last N samples.

Design and build a working environmental monitoring station that simultaneously reads light level, temperature, motion status, and distance, then displays all four values clearly on the Serial Monitor with labeled units

Identify ESP8266 pin functions and construct a voltage-safe wiring circuit between an Arduino Uno and ESP-01 module using a logic level shifter.

Send AT commands via SoftwareSerial to verify ESP8266 responsiveness and interpret common response codes (OK, ERROR, ready).

Configure the ESP8266 in station mode and execute AT commands to join a specified Wi-Fi network, confirming connection via IP address assignment.

Construct and send an HTTP GET request using AT commands to retrieve JSON data from a public test API (e.g., httpbin.org) and parse the response payload.

Format sensor readings as JSON and transmit them via HTTP POST using AT commands to a designated web endpoint, verifying server acknowledgment.

Implement ESP8266 deep sleep mode via AT commands to minimize power consumption between periodic sensor transmissions, calculating expected battery life.

Build a battery-powered weather station that reads temperature/humidity (DHT11), connects to Wi-Fi, posts data to a cloud endpoint (e.g., ThingSpeak) every 10 minutes using deep sleep, and logs locally to SD card. Accept