Controlling an LED with Arduino: setup() and loop()

1. Setting Up Your Development Environment

Before we can control anything, we need the right software. This is the Arduino Integrated Development Environment (IDE), which you'll use to write, compile, and upload your code (called "sketches").

While there are several options, including a web editor and more advanced setups like VS Code with PlatformIO, we'll start with the standard Arduino IDE as it's the most straightforward way to get started.

To summarize the key steps for connecting your board:

1. Install the IDE: Download and install the latest Arduino IDE from the official website.
2. Connect your Arduino: Plug it into your computer using a USB cable.
3. Select your board: Go to Tools > Board and choose the model you are using (e.g., "Arduino Uno").
4. Select your port: Go to Tools > Port and select the serial/COM port that your Arduino is connected to. The IDE usually indicates which one is the Arduino board.

If you don't have a physical Arduino board, you can use the free simulator at Tinkercad.com, which provides a virtual Arduino Uno and basic electronic components.

2. The Program Structure: setup() and loop()

As we discussed previously, every Arduino sketch has two main functions that you must define. This structure is different from a typical C++ program that starts with main(), but remember, the Arduino toolchain creates the main() function for you behind the scenes.

Let's quickly formalize the purpose of these two functions.

• void setup(): This function is called once when the sketch starts. You'll use it for initialization tasks, like configuring pins or starting a serial communication. It's analogous to a constructor in an object or an initialization block in other programming contexts.
• void loop(): After setup() completes, this function is called over and over again in a continuous loop for as long as the board has power. This is where the main logic of your program resides, constantly checking inputs and updating outputs. This is similar to the main event loop in a GUI application or a game engine.

3. The Circuit: Connecting an LED

To see our code in action, we need to connect a Light Emitting Diode (LED). You have two options:

Option A: The Onboard LED (Easiest)
Most Arduino boards, including the Uno, have a small surface-mount LED connected directly to one of the digital pins (usually pin 13). A special constant, LED_BUILTIN, is available in the Arduino environment that automatically maps to this pin. This requires no external wiring.

Option B: An External LED (Better Practice)
For real projects, you'll be controlling external components. This is a simple circuit but introduces important concepts like using a breadboard and current-limiting resistors.

The video below provides a quick visual guide to assembling this circuit.

4. The Code: Your First Sketch

Now, let's write the code to make the LED blink. This requires three key Arduino functions:

1. pinMode(pin, mode): Configures a specific pin to behave as either an INPUT or an OUTPUT. Since we want to send power to the LED, we'll set its pin as an OUTPUT. This is typically done once in setup().
2. digitalWrite(pin, value): Writes a digital value to a pin. The value can be HIGH (which provides 5V, turning the LED on) or LOW (which provides 0V, turning it off).
3. delay(ms): Pauses the program for a specified number of milliseconds. This is essential for controlling the timing of the blink.

The following code implements the blink logic.

// Define the pin connected to the LED.
// Using LED_BUILTIN is the easiest way to start, as it requires no wiring.
// If you wired an external LED to pin 12, you would change this to: #define LED_PIN 12



#define LED_PIN LED_BUILTIN

// The setup function runs once when you press reset or power the board
void setup() {
  // Initialize the digital pin as an output.
  pinMode(LED_PIN, OUTPUT);
}

// The loop function runs over and over again forever
void loop() {
  digitalWrite(LED_PIN, HIGH);   // Turn the LED on (HIGH is the voltage level)
  delay(1000);                   // Wait for a second (1000 milliseconds)
  digitalWrite(LED_PIN, LOW);    // Turn the LED off by making the voltage LOW
  delay(1000);                   // Wait for a second
}

To run this code:

1. Open your Arduino IDE. It should start with a blank sketch containing empty setup() and loop() functions.
2. Copy and paste the code above into the editor.
3. Click the Verify button (the checkmark icon). This compiles your code and checks for errors. You should see a "Done compiling" message.
4. Click the Upload button (the right-arrow icon). The IDE will compile the sketch again and transfer it to your Arduino board. You should see the TX and RX lights on the board flash rapidly during the upload.

Once the upload is complete, the sketch will start running immediately. You should see the onboard 'L' LED (or your external LED) begin to blink on for one second, then off for one second, repeatedly.

Your Turn: Experiment!

You've successfully run your first sketch. Now, experiment by modifying it. This is the best way to build an intuitive feel for the code.

• How would you make the LED blink twice as fast?
• How would you make it stay on for 2 seconds and off for only 200 milliseconds?

Modify the values inside the delay() functions, upload the code again, and observe the change.

Conclusion

Congratulations! You have bridged the gap between software and the physical world. While simple, this "Blink" sketch is a major milestone.

Key Takeaways:

• You can set up the Arduino IDE by selecting the correct board and port.
• The setup() function is for one-time initializations, like setting a pin's mode with pinMode().
• The loop() function contains the main, repetitive logic of the program.
• digitalWrite() is used to control an output, setting it to HIGH (on) or LOW (off).
• delay() is a simple way to control the timing of events in your sketch.

Next Up

You've now successfully controlled a digital output. The logical next step is to read a digital input. In our next lesson, we will learn how to read the state of a push button, allowing your Arduino to react to direct physical interaction.