IA Lab #1: Blink! (Hello World)
- Corrina Crazie Espinosa
- Jan 25
- 9 min read
Today we will start by building our first circuit, BLINK!
The Blink circuit is the simplest Arduino project: an LED is turned on and off at a steady interval using a few lines of code. An Arduino sends a HIGH signal to the LED to turn it on, waits for a short delay, then sends a LOW signal to turn it off—repeating this loop endlessly.
It’s often called the “Hello World” of electronics because, like the first program written in any new programming language, it proves that everything is working. The board is powered, the code uploaded correctly, and digital instructions are successfully controlling hardware. One blinking light says, “It’s alive. You can build from here.”
Solderless Breadboard
A solderless breadboard is a reusable prototyping tool used to quickly build and test electronic circuits without soldering anything permanently. Its purpose is experimentation: you can plug components in, change connections instantly, and troubleshoot ideas before committing to a final build.
Inside the breadboard are metal clips that connect specific holes together. The long horizontal rows at the top and bottom are power rails, typically used for distributing voltage (VCC) and ground across the board. The main center area is divided into vertical columns—each column of five holes is electrically connected, but separated from the next column by a central gap. That gap is designed to hold integrated circuits (ICs), keeping their pins electrically isolated on each side.
Nothing on a breadboard is connected by default—you create the circuit entirely by how you place wires and components. Think of it as a temporary, visible map of your circuit logic: flexible, forgiving, and ideal for learning how electricity flows before making anything permanent.
Arduino Uno: the very basics
The Arduino Uno is a small microcontroller board that acts as the brain of many beginner-to-advanced electronics projects. It reads inputs (like buttons, sensors, or data from a computer), processes that information using code you write, and then controls outputs (like LEDs, motors, or relays). What makes it powerful is not raw computing strength, but its ability to easily connect software logic to physical components.
Pin basics (high level)
Digital Pins (0–13)These pins work in simple on/off states: HIGH (5V) or LOW (0V). They’re commonly used for buttons, switches, and LEDs. Pins 0 and 1 are shared with serial communication, so they’re often avoided unless you know you need them.
Analog Input Pins (A0–A5)These pins read a range of voltages (not just on/off) and convert them into numeric values. They’re used for sensors like potentiometers, light sensors, or temperature sensors—anything that varies gradually rather than switching instantly.
Power Pins
5V / 3.3V: Provide power to components
GND: Ground (the common reference point for the circuit)
VIN: External power input when not powered by USB
Reset PinRestarts the program running on the board—useful for testing or recovering from errors.
Together, these pins form a physical interface between your code and the world. You’re essentially telling the Arduino which pins to listen to, which to speak through, and when to do each.
LED (Light-Emitting Diode)
An LED is a small electronic component that emits light when electrical current flows through it. It’s commonly used as an indicator, visual feedback, or simple light source in circuits.
LEDs are polarized, meaning they only work when connected in the correct direction:
The anode (+) is the longer leg and connects to power.
The cathode (–) is the shorter leg and connects to ground (often marked by a flat edge on the LED body).
If the LED is wired backward, it won’t light up—but it also won’t be damaged. Correct polarity is what allows current to flow and the LED to glow.
Resistors
A resistor is a component that limits the flow of electrical current in a circuit. Its main job is protection and control—making sure components (like LEDs) don’t receive more current than they can safely handle.
Unlike LEDs, resistors are not polarized. They work the same no matter which direction they’re placed in the circuit.
Resistors are measured in ohms (Ω), which indicate how much they resist current flow. In basic Arduino circuits, resistors are often used to:
Protect LEDs from burning out
Control signal levels
Create predictable voltage behavior
The colored bands on a resistor encode its resistance value, acting as a compact label. In short: resistors keep circuits safe, stable, and intentional.
For your convenience, here is an easy resistor calculator:
Putting it all together
In this circuit, the Arduino, breadboard, LED, and resistor work as a simple team. A digital pin on the Arduino sends power out through a jumper wire to the breadboard. That power flows through a resistor first, which limits the current and protects the LED. From the resistor, electricity enters the anode (+) of the LED, causing it to light up. The current then exits the cathode (–) of the LED and returns to the Arduino through a wire connected to GND, completing the circuit.
When your code turns the pin HIGH, electricity flows and the LED lights up. When the pin goes LOW, the flow stops and the LED turns off. This is the physical version of the Blink sketch you wrote earlier—code becoming light, logic becoming visible.
Make it BLINK!!
Sign up for Arduino:
Go to Arduino.cc and sign up for an account! You can also choose to download the arduion ide, and work offline.
Once you have access to the arduino sketch software either through the cloud or by downloading the ide, it's time to upload your code! First select your baord, and when your are ready...
Upload the code!
below is the code, ready to copy and paste into the arduino ide and upload to your board.
/*
Blink
*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}hello world!!
If your LED DID blink, congrats! You just made your first circuit! Enjoy it for a moment, take a quick video to post on your blog for credit, and EXPLORE some more!
If your LED did NOT blink, don't worry! This happens, it is a part of the learning process. Proceed to troubleshooting.
Explore (More to Try)
Once your circuit is working and the LED is blinking, it’s time to play. This is where learning really happens.
In the Blink code, the delay() values control how long the LED stays on and off. These numbers are measured in milliseconds (1000 milliseconds = 1 second). Try changing them. Make the numbers smaller to speed the blink up, or larger to slow it down. A tiny change can dramatically alter the behavior.
Next try adding more. Multiple LEDs let you see how electricity behaves when it has more than one path—and this is where circuit design starts to matter.
Series vs. Parallel
Series means components are connected end-to-end in a single path. The same current flows through every LED. In a series LED circuit, the voltage is shared, so LEDs may appear dimmer—and if one LED fails or is removed, all of them turn off. Series circuits are simple, but fragile.
Parallel means each LED has its own path to power and ground. Each LED receives the full voltage it needs, so brightness stays consistent. If one LED fails, the others keep working. This is the preferred method for most LED projects.
What to try
Add a second LED in series and notice the change in brightness
Then rewire them in parallel and compare
Experiment with different resistor placements and values
This is where circuits stop being diagrams and start behaving like systems. Same code. Same power. Very different results.
Troubleshooting:
Basic Troubleshooting: Code vs. Hardware
When something doesn’t work, the first question is simple: is the Arduino talking to the computer, and is the problem in the code or the circuit? Troubleshooting is about isolating variables and checking them one at a time.
1. Arduino not communicating with the software (before anything else)
If your Arduino won’t upload code, nothing else matters yet.
Common fixes:
Make sure the correct board (Arduino Uno) is selected in the IDE
Select the correct port (COM on Windows, /dev/tty on Mac)
Try a different USB cable (many cables are power-only)
Try a different USB port on the computer
Restart the Arduino IDE (yes, really)
Drivers:
Official Arduino Unos usually install drivers automatically
Clone boards (Elegoo, etc.) may need a USB-to-serial driver installed
If the port doesn’t appear at all, it’s almost always a driver or cable issue
If the board uploads successfully, communication is working—move on.
2. Checking the hardware (the physical side)
If the code uploads but nothing happens, the issue is usually in the wiring.
Start simple:
Is the LED plugged in all the way?
Are jumper wires fully seated?
Are wires in the same row on the breadboard when they should be?
Common hardware mistakes:
LED polarity reversed (anode/cathode flipped)
Resistor not actually in series with the LED
Ground not connected back to the Arduino
Power rail assumed to be connected when it isn’t
Using the wrong pin number in code vs. wiring
Faulty parts happen:
LEDs can burn out
Jumper wires can break internally
Breadboard rows can failSwap one component at a time to test.
3. Syntax errors in the code (the software side)
If the code won’t compile or upload, the IDE will usually tell you.
What to look for:
Missing semicolons ;
Misspelled variable or function names
Unmatched { } braces or ( ) parentheses
Code placed outside of setup() or loop()
Tips:
Read the first error message, not the last one
Error messages often point near the problem, not exactly at it
If Blink doesn’t compile, the issue is almost certainly syntax
4. Strategy that actually works
If it won’t upload → communication/driver/cable issue
If it won’t compile → syntax/code issue
If it uploads but doesn’t work → wiring, polarity, or hardware issue
Change one thing at a time, not everything at once. Electronics debugging is not about being clever—it’s about being methodical.
If all else fails: consult your robot friends 🤖
Ask your favorite AI for help. Describe your issue clearly and specifically (what you built, what you expected, what actually happened, and what you already tried). **Ask it to explain why, and ask for sources or references.
Then do the important part: don’t trust it blindly. Verify with tutorials, datasheets, and documentation. Cross-check. Be skeptical. Use AI as a learning tool, not an authority.
The goal isn’t to get an answer fast. The goal is to learn faster, think better, and build with more confidence.
Troubleshooting isn’t failure. It’s literally how you learn how systems behave when reality pushes back.
NEXT!!
After you successfully complete and document BLINK!! It's time to try another circuit! Try one from the kit your using, or any of these suggestions bellow!
RGB LED (Quick Intro)
An RGB LED contains three LEDs in one package: red, green, and blue. By turning each color on or off—and combining them—you can create many different colors. Each color has its own leg, plus a shared ground or power leg (depending on the type).
Exploring with the Blink circuit
You can explore an RGB LED using the same Blink logic by treating each color as its own LED:
Connect each color leg to a different digital pin (with its own resistor)
Turn the pins on and off in different combinations
Blink colors one at a time, alternate them, or stack them to mix colors
Even without fading or PWM, this simple setup reveals a big idea: color is additive, and complexity emerges from combinations of very simple rules.
More circuits to try (with documentation):
Homework: Research + Brainstorm
Research simple circuits that use LEDs (output) and sensors (input). Focus on what the circuit does, not just how it works.
As you explore, ask yourself:
What does this behavior communicate?
How could this function tell a story, express a feeling, or reveal an idea?
How does interaction change meaning?
Your goal is not “a cool circuit,” but using the function of the circuit as part of the concept. Light should act intentionally—responding to people in ways that feel emotional, psychological, or dreamlike.
Final Deliverable: An interactive artwork using light and containment to visualize or evoke a psychological or dreamlike state.
:✔ Light-based output
✔ Interactive input
✔ Embedded circuit
✔ Documentation (photos + short video)
✔ 300-word artist statement
Let the behavior of the circuit do the talking.
Comments