Loops are a crucial concept in programming, allowing code to be executed repeatedly without the need to write the same instructions multiple times. The most common types of loops are for, while, and do-while. In this article, we will explain the basic concepts and syntax of each loop, providing examples to help you better understand Arduino loops and effectively support you in building your next project.
for Loop in Arduino
Concept
A for loop is a type of control structure in programming that allows you to execute a block of code a specific number of times. Rather than manually repeating the same code multiple times, the for loop automates the process, making the program more efficient and easier to read. It is particularly useful in situations where the number of iterations is predetermined, enabling more concise and structured code.
Syntax Structure
The for loop in Arduino follows this basic syntax:
for (initialization; condition; iteration) {
// Code to execute in each iteration
}
Breakdown of the Syntax:
- Initialization: Runs once before the loop starts.
It is used to declare and set an initial value for the loop variable (e.g., int i = 0).
- Condition: Checked before each iteration to determine whether the loop continues.
If true, the loop executes the block of code.
If false, the loop stops.
- Iteration (Increment/Decrement): Updates the loop variable after each cycle.
It usually increments (e.g., i++) or decrements (e.g., i–) the loop variable.
Blinking an LED 5 Times Using a for Loop
void setup() {
pinMode(13, OUTPUT); // Set pin 13 as an output, used to control the LED
}
void loop() {
for (int i = 0; i < 5; i++) { // Loop runs 5 times, i starts from 0 and goes to 4
digitalWrite(13, HIGH); // Turn the LED on (HIGH represents 5V)
delay(500); // Wait for 500 milliseconds (LED stays on)
digitalWrite(13, LOW); // Turn the LED off (LOW represents 0V)
delay(500); // Wait for 500 milliseconds (LED stays off)
}
delay(2000); // Wait for 2000 milliseconds before repeating the loop, LED will not blink
}
Step-by-Step Execution:
| Steps | Description |
|---|---|
| Initialization (int i = 0) | Before the loop starts, an integer variable i is declared and initialized to 0. |
| Condition Check (i < 5) | Before each loop execution, Arduino checks if i is less than 5. If true, the loop executes. If false, the loop stops. |
| Code Execution | The LED turns on (HIGH), stays on for 500ms, then turns off (LOW) and waits for another 500ms. |
| Iteration (i++) | The loop variable i increases by 1 (i = i + 1). |
| Repeat Until the Condition is False | Steps 2–4 repeat until i becomes 5. At this point, the loop stops. |
| Delay & Restart | After 5 blinks, the program waits 2 seconds (delay(2000)) before starting again. |
Finally, the LED blinks 5 times, pauses for 2 seconds, then repeats.
Nested for Loops
A nested for loop is a loop inside another loop, useful for tasks like LED matrices or multi-dimensional arrays.
void setup() {
// Initialize pins 2 through 6 as OUTPUT
for (int i = 2; i <= 6; i++) {
pinMode(i, OUTPUT); // Set the pin mode for pins 2 to 6 to OUTPUT
}
}
void loop() {
// Loop through pins 2 to 6
for (int i = 2; i <= 6; i++) {
// Blink each LED 3 times
for (int j = 0; j < 3; j++) { // Inner loop runs 3 times for each LED
digitalWrite(i, HIGH); // Turn on the LED connected to pin 'i'
delay(200); // Wait for 200 milliseconds
digitalWrite(i, LOW); // Turn off the LED connected to pin 'i'
delay(200); // Wait for 200 milliseconds
}
}
}
- Outer loop: Iterates through LEDs (pins 2 to 6).
- Inner loop: Blinks each LED 3 times before moving to the next.
while Loop in Arduino
Concept
A while loop in Arduino is a control structure that repeats a block of code as long as a specified condition remains true. It is particularly useful when the number of iterations is not known in advance and depends on external factors, such as sensor inputs, button presses, or serial communication data.
Syntax Structure
The while loop in Arduino follows this basic syntax:
while (condition) {
// Code to execute
}
Breakdown of the Syntax:
- Condition: Evaluated before each iteration.
If the condition is true, the code inside the loop executes.
If the condition is false, the loop stops and the program moves to the next section.
Waiting for a Button Press
while (digitalRead(2) == LOW) { // Wait until the button is pressed
Serial.println("Waiting...");
delay(500); // Print "Waiting..." every 500ms
}
Explanation:
- The while loop continuously checks if the button connected to pin 2 is not pressed (LOW).
- It prints “Waiting…” every 500 milliseconds while the button remains unpressed.
- Once the button is pressed (HIGH), the loop exits and the program proceeds to the next section.
Key Features:
- Ideal for event-driven tasks (e.g., waiting for user input or a sensor reading).
- The loop runs indefinitely until the condition changes (button pressed).
- Caution: If the condition never becomes false (e.g., if the button is never pressed), the loop will continue indefinitely, which could lead to an infinite loop.
- Can be controlled using break to exit early or continue to skip an iteration.
For this, while loop is particularly useful for real-time monitoring, waiting for events (like button presses or sensor triggers), and continuously checking for changes in Arduino projects.
do-while Loop in Arduino
Concept
A do-while loop is a control structure that ensures a block of code is executed at least once, regardless of whether the condition is true or false. After the first execution, the loop repeats as long as the condition remains true.
Unlike the while loop, which checks the condition before executing the loop body, the do-while loop executes the code once first and then evaluates the condition. This makes it ideal for scenarios where an action must occur initially, such as waiting for user input, reading sensor data, or initializing a process.
Syntax Structure
The do-while loop in Arduino follows this basic syntax:
do {
// Code to execute at least once
} while (condition);
Comparing while and do-while Loops
To better understand how the do-while loop works, let’s explore some practical examples.
int value = 10; // Initialize the variable 'value' to 10
void setup() {
Serial.begin(9600); // Start serial communication with a baud rate of 9600
// Using do-while loop, which will execute at least once
Serial.println("Using do-while loop:");
do {
Serial.println(value); // Print the current value
value++; // Increment the value
} while (value < 10); // Condition check: if value is less than 10, continue the loop. After the first execution, value becomes 11, so the loop stops
// Using while loop, this loop won't execute because the condition is false from the beginning
Serial.println("Using while loop:");
while (value < 10) { // Condition check: if value is less than 10, the loop will execute
Serial.println(value); // This line will never execute because value is already 10 or more
value++; // Increment the value, but the loop won't execute
}
}
void loop() {
// The loop function is empty because all operations are demonstrated in the setup function
}
Output:
Using while loop:
Using do-while loop:
10
Explanation:
- Since the value is 10 at the start and the condition (value < 10) is false, the while loop does not execute.
- The do-while loop executes once even though the condition is false.
Controlling an LED Until a Condition is Met
This example turns on an LED and keeps it on until a condition is met, such as a sensor reading reaching a threshold.
const int ledPin = 13; // Pin for the LED
int sensorValue; // Variable to store the sensor value
void setup() {
pinMode(ledPin, OUTPUT); // Set the LED pin as output
Serial.begin(9600); // Start serial communication for debugging
}
void loop() {
do {
digitalWrite(ledPin, HIGH); // Turn the LED on
sensorValue = analogRead(A0); // Read the sensor value
} while (sensorValue < 600); // Keep the LED on until sensor value is >= 600
digitalWrite(ledPin, LOW); // Turn the LED off after threshold is reached
Serial.println("Threshold Reached!"); // Output a message indicating the threshold is reached
}
- The loop checks sensor readings and stays active until sensorValue ≥ 600.
- Once the threshold is reached, the LED turns off and the loop exits.
Use of ‘break’ and ‘continue’ in the Arduino IDE
In some situations, we may need to control the flow of a loop by either stopping the loop early or skipping certain iterations. To achieve this, Arduino provides two key control statements:
- break: Exits the loop immediately.
- continue: Skips the current iteration and moves to the next iteration of the loop.
Both break and continue are commonly used in for, while, and do-while loops to provide more control over the program flow.
Using ‘Break’
The break statement is used to terminate a loop prematurely, even if the loop condition is still true. Stopping a process early when a specific event occurs, such as a sensor threshold being met.
This example stops a for loop when the variable reaches 5.
void setup() {
Serial.begin(9600); // Initialize serial communication at 9600 baud rate
}
void loop() {
for (int i = 1; i <= 10; i++) { // Start a for loop from 1 to 10
if (i == 5) { // Check if the value of i is 5
Serial.println("Loop Stopped!"); // Print "Loop Stopped!" to serial monitor
break; // Exit the loop when i reaches 5
}
Serial.println(i); // Print the current value of i to the serial monitor
}
while (true); // Infinite loop to stop the program from repeating (halts execution)
}
- The loop normally runs from 1 to 10.
- When i == 5, the break statement executes, forcing an exit from the loop.
- The remaining numbers are not printed.
Using ‘continue’
The continue statement is used to skip the current iteration and move to the next iteration of the loop without executing the remaining statements. Skipping unwanted data, filtering inputs, or ignoring certain loop iterations.
The example prints only odd numbers between 1 and 10, skipping even numbers using continue.
void setup() {
Serial.begin(9600); // Initialize serial communication at 9600 baud rate
}
void loop() {
// Start a for loop, iterating from 1 to 10
for (int i = 1; i <= 10; i++) {
// Check if the value of i is equal to 5
if (i == 5) {
Serial.println("Loop Stopped!"); // Print message to Serial Monitor when i reaches 5
break; // Exit the for loop immediately when i equals 5
}
// Print the current value of i to the Serial Monitor
Serial.println(i);
}
// Create an infinite loop to stop the program from continuing
// This prevents the loop() function from repeating itself
while (true); // The program halts here indefinitely, so no further code executes
}
- When i is even, continue skips the Serial.println(i); statement.
- The loop continues to the next iteration without printing even numbers.
Ending
Loops in Arduino (for, while, and do-while) allow repetitive tasks to be executed efficiently, making programming more structured and automated. Understanding loop structures effectively helps optimize Arduino programs, improve responsiveness, and manage tasks efficiently. Proper loop control enhances automation, sensor handling, and user interactions in embedded systems.
You Might Be Interested
Unlock the power of Arduino UNO! This versatile development board lets you build everything from automated systems to robots. Explore its features and discover how it can turn your creative
This article showcases a beginner-friendly project that utilizes Arduino and touch-sensitive technology to control LED lights. The project involves building a simple circuit and programming the Arduino board to detect
In this comprehensive tutorial, we will provide a detailed exploration of various Arduino boards, delve into essential concepts, and highlight their distinctive features. Our aim is to assist you in
A breathing light is an LED lighting effect that simulates the human breathing process, gradually increasing or decreasing in brightness within a specific cycle. This project can be achieved through
Creating an alcohol sensing project with an MQ-3 sensor and Arduino allows for accurate alcohol concentration monitoring in environments like bars and factories. The MQ-3 sensor’s high sensitivity to alcohol,
In this article, we’ll start with the basics of ultrasonic sensors, walk you through using Arduino for distance measurement, and explore practical applications of this technology in projects like smart
This Arduino temperature alarm project effectively demonstrates how to create a practical temperature monitoring system. By utilizing the LM35 temperature sensor and a buzzer, it warns users with an audible
This article introduces six beginner-friendly projects for Arduino UNO, a popular microcontroller board. These projects cover a range of applications, from marquee lights and stepper motor control to ultrasonic ranging,