Learning digital electronics with the Elegoo UNO R3 starter kit.

Every computer, phone and smart device is built from the same small set of ideas: a voltage is either high or low, a high-or-low is a bit, bits in a row make a number, and a chip that can count, compare and remember numbers can do anything. Reading about that is one thing. Watching it happen on your own bench, with an LED that lights when a voltage crosses a threshold you can measure, is another. That’s what an Elegoo UNO R3 starter kit is for. The board is an Arduino-compatible microcontroller; the kit adds the parts and a lesson-by-lesson tutorial. Below: what the board is, which of the three kits to buy, how to set it up, and ten experiments that take you from a blinking light to a chip talking to another chip.

Why learn digital electronics with a microcontroller?

There are two classic ways to learn electronics. One starts with components: resistors, capacitors, transistors, the maths of each. The other starts with logic chips: gates, flip-flops, counters, wired by hand. Both work, and both take a while before anything interesting happens.

A microcontroller board flips that around. In the first ten minutes you have a program running on a real chip and an LED blinking under its control. From there, every component you add teaches one idea, because you can see what the chip sees: print the voltage on a pin to the screen, change a number in the code and watch a motor turn further, swap a resistor and measure the difference. It’s the same approach we take in our other hands-on lessons, like testing a battery with a multimeter: learn the idea at the moment you need it, with the thing in your hands.

The UNO is the right board to start on for a boring reason: it’s the most documented microcontroller board ever made. Every sensor module you’ll ever buy has a wiring diagram for it, the tutorial that comes with the kit is written for it, and when something doesn’t work, someone has already asked your exact question.

What’s on the board

The Elegoo UNO R3 is a copy of the Arduino Uno Rev3, and Arduino’s own specification applies to it. The figures that matter when you’re learning:

Which kit to buy

Elegoo sells three UNO R3 kits on Amazon Australia, and the board on its own. Every kit has the same board, a USB cable, a breadboard, jumper wires, LEDs, buttons, a 74HC595 shift register and a bag of resistors, so the first six experiments below work with any of them. The difference is how far the tutorial goes after that: the Basic kit stops at the digital fundamentals, the Super kit adds a display, motors and sensors, and the Complete kit adds more sensors and modules again. Here’s what each listing says is in the box.

The three kits side by side

Contents are from Elegoo’s Amazon Australia listings on 22 October 2026 and can change. Elegoo also sells a Mega 2560 version of the Complete kit with a bigger board (more pins, more memory). It’s a fine kit, but the UNO is the board every tutorial assumes, so start here.

Setting up, in ten minutes

1. Install the Arduino IDE. It’s free, from arduino.cc, for Windows, macOS and Linux. Get version 2; the tutorial’s screenshots may show the older version 1, but every menu it mentions is still there.
2. Download the tutorial. The kit comes with a CD, which most computers can no longer read. The same PDF and code live on Elegoo’s site under Arduino kits support files; pick your kit and, for the Complete kit, the version on your box.
3. Plug the board in. The cable is USB-A to USB-B, the square-ish plug you’ll recognise from printers (it’s in our connector reference). The green ON light comes on and the L LED often starts blinking, because boards usually ship with the Blink example already loaded. If your computer only has USB-C, any USB-C to USB-B cable or a small adaptor works.
4. Tell the IDE what you’ve got. In the IDE, the drop-down at the top lists connected boards. Pick the one on a COM port (Windows) or /dev/cu.usbmodem… (Mac) and choose Arduino Uno as the board type. Because the Elegoo board uses the same ATmega16U2 USB chip as the official one, there’s no driver to install on Windows 10 or 11, macOS or Linux.
5. Upload something. File › Examples › 01.Basics › Blink, then the right-arrow Upload button. The TX and RX lights flicker, the IDE says “Done uploading”, and the L LED blinks once a second. You’ve just compiled a program on your computer, sent it down a serial link, and had a bootloader on the chip write it into flash memory. That’s most of how every device you own gets its firmware.

Two words you’ll see everywhere: a program for the board is called a sketch, and the two functions every sketch has are setup(), which runs once, and loop(), which runs forever.

The breadboard: the one thing to understand first

Almost every wiring mistake in the first week is a breadboard mistake, so it’s worth a minute. Under the plastic, the holes are joined in strips. In the middle section, each row of five holes is one connection, and the trench down the centre separates the two halves. Along the edges, the two long rails run the full length of the board (on some boards they break in the middle; look for a gap in the printed line). Plug the board’s 5V and GND into the rails and you have power anywhere on the board.

Ten experiments, one idea each

These follow the order of Elegoo’s tutorial loosely, but they’re chosen for what each one teaches about digital electronics. Do them in order; each one leans on the last. The tutorial PDF has the wiring diagram and the full code for every one of them; what’s below is the idea you’re meant to take away. “Kit” says which kits have the parts.

1. Blink: a digital output

Kit: any, nothing to wire. Idea: a pin is a switch the program controls.

You’ve already run it. Now read it. The whole program is this:

void setup() {
  pinMode(13, OUTPUT);        // pin 13 will drive things
}

void loop() {
  digitalWrite(13, HIGH);     // put 5 V on the pin: LED on
  delay(1000);                // wait 1000 ms
  digitalWrite(13, LOW);      // put 0 V on the pin: LED off
  delay(1000);
}

HIGH connects the pin to 5 V inside the chip; LOW connects it to 0 V. There is no in-between, and that’s the whole of digital in one line. Change the two delays to 100 and watch it flicker; change them to 10 and it looks steadily on, because your eyes can’t keep up. Remember that for experiment 7.

If you have a multimeter (our BM786 guide explains how), put the black lead on GND and the red on pin 13 while it blinks: you’ll see it swing between about 0 V and about 5 V. That’s the bit, made visible.

2. An LED on the breadboard: why the resistor

Kit: any. Idea: Ohm’s law protects the chip.

Same code, but now pin 13 goes through a 220 Ω resistor to the long leg of an LED, and the short leg goes to GND. The LED is a diode: it lets current one way and drops a near-fixed voltage, about 2 V for a red one. Without the resistor, the pin would try to push the remaining 3 V through almost no resistance, well past its 40 mA limit, and something would eventually give. With it:

I = (5 V − 2 V) ÷ 220 Ω ≈ 14 mA

Comfortably under the 20 mA the board is happy with. Try 1 kΩ and it’s dimmer (3 mA); the kit’s resistors are sorted by value, and the colour bands tell you which is which. If the LED doesn’t light at all, it’s almost certainly in backwards: the long leg (anode) goes towards the pin. The kit’s resistor values are printed on the strips; measure one with the meter if you want to check your reading of the bands.

3. A button: a digital input, and why pins float

Kit: any. Idea: an input has to be pulled somewhere.

Now a pin reads instead of writes: pinMode(2, INPUT) and digitalRead(2) returns HIGH or LOW. Wire a button from pin 2 to GND, press it, and the pin reads LOW. Let go and it reads… garbage. A pin connected to nothing isn’t HIGH or LOW; it floats, picking up whatever stray voltage is around, and your program sees random presses. The fix is a pull-up: a resistor from the pin to 5 V, so that with the button released the pin is held HIGH and only the button can pull it LOW. The chip has pull-ups built in; pinMode(2, INPUT_PULLUP) switches one on, and that’s what nearly every real button in the world does.

The second thing you’ll meet is bounce: a mechanical button doesn’t close cleanly, it chatters for a few milliseconds, and a chip checking it 100,000 times a second sees a dozen presses. Count presses on the serial monitor (experiment 9) and you’ll see it. Ignoring changes for 20 ms after each one, which is called debouncing, fixes it, and it’s the first time you’ll write code to compensate for physics.

4. Four LEDs: counting in binary

Kit: any. Idea: bits in a row are a number.

Four LEDs on pins 8 to 11, each with its 220 Ω resistor. Write a loop that counts from 0 to 15 and, for each number, lights the LEDs according to its binary digits: the right-hand LED is the 1s, then 2s, 4s, 8s. The Arduino library makes this a one-liner per LED: digitalWrite(8, (n >> 0) & 1), digitalWrite(9, (n >> 1) & 1), and so on. Slow it to a count a second and watch: 0001, 0010, 0011, 0100… This is exactly what the chip is doing inside, with 8 bits per byte instead of 4. Our lesson on how computers check data picks this thread up.

5. The 74HC595 shift register: a chip talking to a chip

Kit: any. Idea: serial in, parallel out, and a clock.

This is the experiment that turns the lights on, metaphorically. The 74HC595 is a 16-pin logic chip with eight outputs you control through just three wires: data, clock and latch. You present one bit on the data line, pulse the clock, and the chip shifts it in; do that eight times and you’ve loaded a byte; pulse the latch and all eight outputs change at once. The Arduino function is shiftOut(dataPin, clockPin, MSBFIRST, value), and the kit wires eight LEDs to the outputs so you can see the byte.

Why it matters: this is the pattern behind nearly every digital interface you’ve heard of. SPI, I²C, USB, HDMI and Ethernet are all, at bottom, bits clocked down a wire and reassembled at the other end. The 74HC595 is also your first memory: it holds its eight bits until you tell it otherwise. And it’s why three pins can run a display that would otherwise need twelve, which the Super and Complete kits’ four-digit display relies on.

6. A seven-segment display: encoding

Kit: Super and Complete have the displays; Basic can do it with seven LEDs. Idea: a number is whatever pattern you agree it is.

The one-digit display is seven LEDs arranged as an 8, plus a decimal point. To show a “3”, you light segments a, b, c, d and g. To show every digit, you need a lookup table: ten bytes, one per digit, each bit saying whether a segment is on. Drive it through the 74HC595 from experiment 5 and you’ve built a tiny display driver. The lesson underneath is that the chip never knows it’s showing a 3; it’s putting out the byte you told it means 3. All digital information works like this, from the ASCII codes in experiment 9 to the pits on a CD.

The four-digit display adds a trick called multiplexing: there aren’t enough pins to light all four digits at once, so the program lights them one at a time, fast. At a few hundred times a second your eye sees four steady digits. Point your phone camera at it and you may catch the flicker.

7. Fading an LED: PWM, digital pretending to be analogue

Kit: any. Idea: switching fast enough looks like a level.

The UNO can’t output 2.5 V; its pins are HIGH or LOW, full stop. But on the six PWM pins, analogWrite(9, 128) switches the pin HIGH and LOW about 490 times a second with the HIGH part lasting half the time. The LED is on half the time, your eye averages it, and it looks half as bright. analogWrite(9, 64) is a quarter. The number from 0 to 255 is the duty cycle, and the trick is called pulse-width modulation.

This is how nearly everything “analogue” in a digital device is done: screen brightness, motor speed, the volume of a buzzer, even the servo in the Super kit, which reads the width of a pulse as an angle. The kit’s RGB LED is the satisfying version: three PWM pins, three colours, mix any shade.

8. A knob or a light sensor: analogue to digital

Kit: Super and Complete have the potentiometer; Basic uses the photoresistor. Idea: a real voltage becomes a number, in steps.

Wire the potentiometer’s ends to 5 V and GND and its middle pin to A0; it’s a voltage divider, and the middle pin sits anywhere from 0 to 5 V as you turn it. analogRead(A0) returns a number from 0 to 1023. The chip’s analogue-to-digital converter has 10 bits, so it chops 5 V into 1024 steps of about 4.9 mV each. Turn the knob slowly while printing the number (experiment 9) and you’ll see the steps: analogue in, digital out, and a little bit of information thrown away at every step. That compromise, resolution against cost and speed, is the same one in every digital recording; our lesson on WAV, FLAC and MP3 is the 16- and 24-bit version of this 10-bit knob.

Swap the pot for the photoresistor and a 10 kΩ resistor in series (a divider again) and the number follows the room light. Feed it into analogWrite from experiment 7 and you have an LED that brightens as the room darkens. That’s a sensor, a converter, a decision and an actuator: the shape of every embedded device there is.

9. The serial monitor: how chips talk

Kit: any, nothing to wire. Idea: bits timed down a wire, and an agreed code for letters.

Serial.begin(9600) in setup(), then Serial.println(analogRead(A0)) in loop(), and the Serial Monitor in the IDE fills with numbers. You’re watching a UART at work: each character is sent as a start bit, 8 data bits and a stop bit, at 9600 bits a second, on pin 1 (TX) to the ATmega16U2, which repackages it as USB. The characters themselves are ASCII: the digit “7” travels as the byte 55. Change the 9600 to 115200 in both the code and the monitor’s drop-down and it’s twelve times faster; leave them mismatched and you get gibberish, which is the best lesson in why both ends of a link must agree on timing. From here on, Serial.println is how you’ll debug everything.

10. The ultrasonic sensor: measuring with time

Kit: Super and Complete. Idea: a microcontroller’s real superpower is timing.

The HC-SR04 sends a 40 kHz click and raises its Echo pin for exactly as long as the sound takes to come back. pulseIn(echoPin, HIGH) measures that in microseconds; divide by 58 and you have centimetres. Every reading in the kit that isn’t a plain voltage works this way: the DHT11 sends its temperature as timed pulses, the infrared remote sends its button codes as timed bursts, and the servo takes its angle as a pulse width. A 16 MHz chip counts in 62.5 ns ticks, so it’s very good at this, and once you’ve seen one timed protocol you can read the datasheet for any of them.

Finish by printing the distance to the serial monitor, lighting the four binary LEDs from experiment 4 as a bar graph, and beeping the buzzer faster as something gets closer. You’ve just built a parking sensor from first principles, and you understand every part of it.

Staying safe, and keeping the board alive

• It’s 5 volts. Nothing in the kit can shock you. The hazards are small parts, the sharp header pins, and heat: a shorted 9 V battery or a motor stalled against something gets hot.
• Never join 5V to GND with a wire, and never plug an LED straight across them. The USB port’s protection will usually save you, but not always.
• Unplug before you rewire. Most dead boards die from a jumper slipping across two pins while powered.
• 20 mA per pin, about 200 mA for the whole chip. An LED through a resistor is fine; a motor, a relay coil or a string of LEDs is not, which is why the kit includes transistors, the ULN2003 and the L293D. The servo and stepper draw from the 5V pin, not a data pin.
• The power supply module takes 9 V at most, in Elegoo’s own words, and the barrel jack 7 to 12 V. Don’t connect a laptop charger to either.
• Don’t put 5 V into A0 to A5 from anything bigger than the board. The analogue pins read 0 to 5 V; a car battery or a wall adaptor needs a divider first, and our battery guide is the safer way to measure those.

When it doesn’t work

What next

When you’ve done the tutorial, you’ll know what a pin, a bit, a byte, a clock, a bus, a converter and a protocol are, from the inside. That’s the foundation for everything else in computing, and most people in IT never get it this concretely. Three directions from here:

• Build something that stays built. A second bare board (above) and a few sensors, and the breadboard becomes a weather station or a plant-waterer that lives on a shelf.
• Add radio. The ESP32 family costs about the same as a UNO and adds Wi-Fi and Bluetooth, and it programs from the same IDE. Our software-defined radio lesson is the receiving end of that story.
• Go up a level. A Raspberry Pi runs Linux and talks to the same sensors, but through an operating system. Having done it on bare metal first, you’ll understand what the OS is doing for you, and what it costs. Alan Turing worked out the theory of all of this in 1936; our Turing machine lesson is the long view.

Common questions

Sources

Elegoo listings on Amazon Australia (contents, lesson counts, age guidance, the 9 V warning; all sold by ELEGOO Official AU). Checked 22/10/2026.

• ELEGOO UNO R3 Project Basic Starter Kit with Tutorial: component list. link
• ELEGOO UNO R3 Project Super Starter Kit with Tutorial: component list, 24-lesson tutorial, “suitable for 10-year-old and up”, power supply module “do not use the voltage higher than 9V”. link
• ELEGOO UNO R3 Project Complete Starter Kit with Tutorial (More Than 200 Items): “more than 200 components”, “over 60 kinds”, 33 projects, LCD1602, RFID module, 830 tie-point breadboard, L293D and DC motor, 74HC595, Wi-Fi module not included, compartment case. link
• ELEGOO UNO R3 Microcontroller Board ATmega328P+ATmega16U2 with USB Cable: 16 MHz, 32 KB flash, 14 digital I/O, 6 PWM, 6 analogue inputs, 7 to 12 V external supply. link

Elegoo

• Arduino kits support files (tutorial and code downloads for the Basic, Super and Most Complete kits). link. Checked 22/10/2026.
• ELEGOO UNO R3 Project The Most Complete Starter Kit Tutorial: V1.0 and V2.0 downloads, “check your kit version”. link. Checked 22/10/2026.

Arduino

• Arduino UNO Rev3 tech specs: ATmega328P, 5 V, 7 to 12 V recommended input, 14 digital pins (6 PWM), 6 analogue inputs, 20 mA per pin, 32 KB flash, 2 KB SRAM, 1 KB EEPROM, 16 MHz, LED on pin 13, ATmega16U2 as USB-to-serial. link. Checked 22/10/2026.
• Arduino UNO R3 documentation: socketed microcontroller, “the most robust board you can start playing with”. link. Checked 22/10/2026.
• Arduino language reference: digitalWrite, pinMode (INPUT_PULLUP), analogWrite (0 to 255, about 490 Hz, 980 Hz on pins 5 and 6), analogRead (10-bit, 0 to 1023), shiftOut, pulseIn. link. Checked 22/10/2026.

Microchip

• ATmega328P datasheet, DC characteristics: input low voltage maximum 0.3 V_CC, input high voltage minimum 0.6 V_CC, 40 mA absolute maximum per I/O pin, 200 mA maximum through V_CC and GND. link. Checked 22/10/2026.