Weekend Electronics Projects You Can Finish in 2 Hours
You bought an Arduino. It's sitting in a drawer. Maybe you opened the box once, looked at the wires, and thought "I'll get to it this weekend." That was three weekends ago.
This guide is the fix. Five projects, each one completable in two hours or less. No prior experience needed beyond the Arduino basics. No soldering. No WiFi configuration. No libraries to install. Just a breadboard, a few components, and an afternoon.
Each project teaches a different core concept, and they get progressively more ambitious. Start with project 1 if you've never touched a breadboard. Jump to project 4 or 5 if you want something that moves or measures.
The 2-Hour Rule
Every project in this guide was timed against one standard: a person who has read the Arduino basics guide and has the Arduino IDE installed can finish it in under two hours. That includes wiring, coding, testing, and the inevitable moment where something doesn't work and you need to check a connection.
What the clock does not include:
- Installing the Arduino IDE. Do this before you sit down to build. It takes 10 minutes: download it here.
- Buying or unpacking components. Have them on the table before you start.
- Soldering. None of these projects require it. Everything uses a breadboard.
- External library installs. All five projects use only built-in Arduino functions.
If those prerequisites are met, the times listed are honest. If a project says 90 minutes, it means 90 minutes of actual building, not 90 minutes plus an hour of setup.
What You Need for All Five Projects
Most of these components overlap across projects. Buy them once and you can work through all five.
| Component | Quantity | Used In | Notes |
|---|---|---|---|
| Arduino Uno (or compatible clone) | 1 | All projects | The R3 or R4 both work |
| USB cable (Type A to Type B) | 1 | All projects | Comes with most boards |
| Breadboard | 1 | All projects | Half-size or full-size |
| Jumper wires (assorted) | ~15 | All projects | Male-to-male |
| 5mm LED (any color) | 2 | Projects 1, 2 | Red is easiest to see |
| 220-ohm resistor | 2 | Projects 1, 2 | Red-Red-Brown-Gold |
| 10k-ohm resistor | 1 | Project 2 | Brown-Black-Orange-Gold |
| Photoresistor (LDR) | 1 | Project 2 | Small disc with squiggly pattern |
| Passive piezo buzzer | 1 | Project 3 | Must be passive, not active |
| HC-SR04 ultrasonic sensor | 1 | Projects 4, 5 | Blue board with two metal cylinders |
| SG90 micro servo motor | 1 | Project 5 | Small blue servo with 3 wires |
Estimated cost: $25-40 for a starter kit that includes all of this (and more). If you already have an Arduino and breadboard, the individual components run about $10-15 total.
Most Arduino starter kits bundle every component on this list. If you have a kit, check the box before buying anything separately.
Project 1: LED + Resistor Circuit
Time: ~30 minutes | Difficulty: Absolute beginner | New components: LED, 220-ohm resistor
What you'll learn
How to build a circuit on a breadboard, why LEDs need resistors, and how digitalWrite() controls an output pin. This is the foundation for everything else on this list.
The build
You wire an LED and a resistor in series between an Arduino output pin and ground. The code is three lines: set the pin as output, turn it HIGH, and it lights up. Add a delay() and a LOW, and it blinks.
The resistor limits the current so the LED doesn't burn out. Without it, the LED pulls too much current from the Arduino pin and dies. The 220-ohm value keeps things around 15mA, well within the LED's safe range.
The real learning happens when it doesn't work on the first try. Check the LED polarity (longer leg is positive). Check that the resistor and LED share a breadboard column. Check that GND actually connects to the ground rail. These are the same debugging steps you'll use in every project.
Full step-by-step guide: Your First Real Circuit: LED + Resistor on a Breadboard
Generate this project on Make-It and skip straight to building.
Project 2: Auto-Nightlight
Time: 60-90 minutes | Difficulty: Beginner | New components: Photoresistor (LDR), 10k-ohm resistor
What you'll learn
How to read analog sensor values with analogRead(), the difference between digital (on/off) and analog (0-1023) input, and how a voltage divider converts resistance changes into voltage changes the Arduino can measure.
The build
You create two mini-circuits on the breadboard: a sensor circuit (the LDR paired with a 10k-ohm resistor forming a voltage divider) and an LED output circuit. When the room gets dark, the LDR's resistance increases, the voltage at the analog pin drops, and your code turns the LED on.
The voltage divider is the key concept here. The Arduino can measure voltage but not resistance. By putting two resistors in series (one fixed, one variable), the voltage at the junction between them shifts as the LDR's resistance changes. Bright room = high reading. Dark room = low reading.
Your code picks a threshold and decides: below this number, it's dark enough to turn on the light.
The extra 30 minutes compared to Project 1 comes from calibrating your threshold. Open the Serial Monitor, note the readings in normal light and darkness, and pick a number in between. Every LDR and room is slightly different.
Full step-by-step guide: Build an Auto-Nightlight with Arduino
Generate this project on Make-It and skip straight to building.
Project 3: Melody Buzzer
Time: 45-60 minutes | Difficulty: Beginner | New components: Passive piezo buzzer
What you'll learn
How tone() generates sound at specific frequencies, how musical notes map to numbers (A4 = 440 Hz), and a pattern you'll use everywhere: parallel arrays where one stores what to do and the other stores how long to do it.
The build
Two wires. That's the entire wiring job. Connect the buzzer's positive leg to a digital pin and the negative leg to GND. No resistor needed (the buzzer's impedance limits the current).
The code starts simple: tone(pin, 440, 1000) plays the note A4 for one second. From there, you build up to a full melody by defining two arrays: one for note frequencies and one for note durations. A for loop plays through them in sequence. Use noTone() for rests (frequency = 0) and add a small delay between notes so they don't blur together.
The most common mistake is using an active buzzer instead of a passive one. An active buzzer has a built-in oscillator and only plays one fixed tone. You need a passive buzzer so tone() can control the pitch. If you connect the buzzer to 5V and GND and it makes a sound on its own, it's active. If it stays silent, it's passive, and that's the one you want.
Full step-by-step guide: Play Melodies with Arduino and a Piezo Buzzer
Generate this project on Make-It and skip straight to building.
Project 4: Ultrasonic Distance Meter
Time: 60-90 minutes | Difficulty: Beginner+ | New components: HC-SR04 ultrasonic sensor
What you'll learn
How ultrasonic distance sensing works (send a pulse, time the echo), how pulseIn() measures microsecond-level timing, and how to convert raw timing data into meaningful distance readings.
The build
The HC-SR04 has four pins: VCC (5V), Trig, Echo, and GND. Wire them to the Arduino with four jumper wires. The Trig pin gets a brief HIGH pulse from your code (10 microseconds), which triggers the sensor to emit an ultrasonic chirp. The Echo pin goes HIGH for a duration proportional to the distance to the nearest object.
The math: sound travels at about 343 meters per second. The echo time includes the trip out and back, so you divide by two. In code, that's distance = pulseIn(echoPin, HIGH) * 0.0343 / 2, giving you the distance in centimeters.
Output the readings to the Serial Monitor and move your hand in front of the sensor. You'll see the numbers change in real time. The sensor is accurate from about 2 cm to 200 cm, though it gets unreliable past that range.
The extra time on this project comes from understanding pulseIn() and the microsecond math. Once that clicks, the rest is straightforward.
Full step-by-step guide: Build a Distance-Controlled Servo with Arduino (covers both the sensor and the servo in Project 5)
Generate this project on Make-It and skip straight to building.
Project 5: Servo Hand Tracker
Time: 90-120 minutes | Difficulty: Beginner+ | New components: SG90 micro servo motor
What you'll learn
How servo motors hold a precise angle (not just spin), how map() translates one range of numbers into another, and the fundamental robotics loop: sense the environment, decide what to do, act on it. This is the core of every robot ever built.
The build
This project combines the ultrasonic sensor from Project 4 with a servo motor. The sensor measures distance to your hand, and the servo rotates to an angle proportional to that distance. Move your hand closer, the servo sweeps one way. Move it further, it sweeps the other. It's a physical distance gauge that tracks your hand in real time.
The servo has three wires: brown (GND), red (5V), orange (signal). Connect the signal wire to a PWM-capable pin. The built-in Servo library (included with every Arduino installation, no download needed) handles the timing pulses.
The key line of code is map(distance, 5, 50, 0, 180), which converts a distance range (5-50 cm) into a servo angle range (0-180 degrees). The map() function is a workhorse you'll use constantly in electronics projects.
Important: Use an SG90 micro servo specifically. It draws about 150-200mA under light load, which the Arduino's 5V pin can handle safely. Larger servos draw more current and can cause the Arduino to reset or behave erratically.
You just built the core loop of every robot: sense distance, decide angle, act with the servo. Want to put wheels on it? The Build a Robot course starts from exactly this foundation.
Full step-by-step guide: Build a Distance-Controlled Servo with Arduino
Generate this project on Make-It and skip straight to building.
Stretch Goals: When You Want a Bit More
These projects are honest 2-3 hour builds. They introduce WiFi configuration, external libraries, or platforms beyond Arduino. If you have the afternoon and want to keep going, pick one.
ESP8266 Web-Controlled LED (2-3 hours)
Control an LED (or an entire NeoPixel strip) from your phone's browser. The ESP8266 runs a tiny web server that serves a color picker page over your local WiFi network. The extra time comes from board setup in the Arduino IDE, WiFi configuration, and the NeoPixel library installation.
Full guide: Control an LED Strip from Your Phone with ESP8266
Raspberry Pi Motion-Activated Light (2-3 hours)
A PIR motion sensor triggers a relay that switches a light on when someone walks into a room. Built with Python and the Raspberry Pi's GPIO pins. The extra time is Raspberry Pi OS setup and GPIO library familiarization.
Full guide: Build a Motion-Activated Light with Raspberry Pi
Temperature and Humidity Monitor with LCD (2-3 hours)
Read temperature and humidity from a DHT11 sensor and display live readings on an I2C LCD screen. Requires the DHT and LiquidCrystal_I2C libraries. The LCD wiring (I2C: just 4 wires) is simple, but library installation and I2C address troubleshooting can add time.
Full guide: Build a Temperature & Humidity Monitor with Arduino
What's Next
If you finished all five projects, you've covered digital output, analog input, sound generation, ultrasonic sensing, and servo control. That's a solid foundation.
Here are three directions to go from here:
Go deeper with structured learning. The Electronics Course is a 13-module path from electricity fundamentals through sensors, displays, motors, and WiFi. Each module builds on the previous one.
Build a robot. The Build a Robot course takes you from a bare chassis to a fully autonomous obstacle-avoiding robot with Bluetooth control. If you liked Project 5's sense-decide-act loop, this is where it goes next.
Pick the right board for your next project. Arduino, ESP32, and Raspberry Pi solve different problems. Our comparison guide helps you decide which one fits what you want to build.
Ready for more project ideas? Check out our top Arduino project ideas or explore fun projects to build with kids.