Section outline

  • Collapse Expand

    Introduction to Robotics with Arduino

    Collapse all Expand all

     

    Welcome to a whole new level of robotics! In this course, you will learn how to actually build and program robots using Arduino – one of the most popular and beginner-friendly microcontrollers used by hobbyists, students, and even professionals.

    • 🔍 What Makes a Robot Robotic?

      Not all machines are robots! A robot is something that can:

      • Sense its environment (using sensors)
      • Think or decide what to do next (using a microcontroller)
      • Act or move in the real world (using motors or other actuators)

      With Arduino, we can bring all three together to create real, working robots that can move, avoid obstacles, follow lines, blink lights, and even respond to voice or gestures!

      💡 Why Arduino?

      Arduino is an open-source electronics platform that lets you connect sensors, buttons, motors, and more with just a few wires and code. Some cool reasons to use Arduino:

      • Easy to learn with tons of online resources
      • Very affordable – a basic board costs less than a meal!
      • Works on Windows, Mac, Linux – and even from the browser
      • You can build real robots, games, alarms, and more!

       

    • 🎒 What Will You Learn in This Course?

      Here’s what you’ll be doing in this course:

      • Controlling motors and wheels with Arduino
      • Reading sensor inputs like line sensors and IR
      • Building a line-following robot
      • Assembling real circuits with drivers and sensors
      • Writing and debugging Arduino code

      🌍 Real-Life, Fun Examples

      • Delivery robots that drop off packages
      • Floor-cleaning robots that avoid walls
      • DIY robots that follow a track made of black tape!

      🚀 Get Ready!

       

      By the end of this course, you’ll not only know how robots work, but you’ll actually have a robot of your own that follows lines and moves smartly – built with your own hands and logic!

  • Collapse Expand

    Controlling Motors

     

    Motors are what give robots the ability to move – to spin wheels, lift arms, or rotate sensors. In this section, we’ll explore how to connect and control basic DC motors using an Arduino board.

    • ⚙️ Types of Motors Used in Robots

      • DC Motor – Spins in one direction or the other. Simple and fast.
      • Servo Motor – Rotates to a specific angle (0° to 180°). Great for precise control.
      • Stepper Motor – Moves in small steps. Used in CNC machines and printers.

      🔌 Connecting a DC Motor to Arduino

      You can't connect a DC motor directly to an Arduino. Why?

      • Motors need more current than Arduino can provide.
      • To reverse motor direction, we need a special circuit.

      This is where a motor driver like the L298N or L293D comes in. It acts like a middleman that lets Arduino control the motor safely.

      📦 Components Needed

      • 1 x Arduino Uno
      • 1 x L298N or L293D Motor Driver
      • 2 x DC motors (like BO motors)
      • 1 x External power source (battery or USB power bank)
      • Jumper wires

       

    • 🔁 Controlling Motor Direction with Code

      Here's a simple example of Arduino code to spin a DC motor in both directions using a motor driver:

      // Motor pins
int in1 = 7;
int in2 = 8;

void setup() {
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
}

void loop() {
  // Forward
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  delay(1000);

  // Reverse
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  delay(1000);
}

      📘 How the Code Works

      • in1 and in2 are connected to the motor driver.
      • Setting one HIGH and the other LOW moves the motor in a specific direction.
      • Switching the HIGH/LOW values reverses the direction.

       

    • 🧠 Important Tips

      • Always use a separate power supply for motors to avoid damaging Arduino.
      • If motors don’t spin, check wiring and motor driver connections.
      • Use delay() for testing but consider more advanced timing later.

      🏁 Up Next

      Now that your robot can move, let’s teach it how to see where it’s going! In the next section, we’ll add line sensors and learn how to detect paths.

  • Collapse Expand

    Sensors for Line Following

    To make a robot follow a line on the ground, we need to help it “see” the line. This is done using infrared (IR) sensors that detect differences in surface color.

    • 🔍 How IR Sensors Work

      • IR sensors emit invisible light and detect how much is reflected back.
      • White surfaces reflect IR light, while black surfaces absorb it.
      • This lets the sensor detect if it’s over a white or black area.

      🎯 Application in Line Following

      Robots can use multiple IR sensors (usually 2 or 3) to detect their position relative to a black line on a white background:

      • If the center sensor is on the line, go straight.
      • If the left sensor sees the line, turn left.
      • If the right sensor sees the line, turn right.

    • 🧰 Components Needed

      • 1 x Arduino Uno
      • 2 or 3 x IR sensors (like TCRT5000 modules)
      • Jumper wires
      • Small black electrical tape for the line

      📐 Wiring the Sensors

      • Connect VCC of each IR sensor to 5V on Arduino.
      • Connect GND to GND.
      • Connect OUT pins to Arduino digital pins (e.g., D2, D3, D4).

    • 💻 Sample Code to Read Sensor Values

      int leftSensor = 2;
int centerSensor = 3;
int rightSensor = 4;

void setup() {
  pinMode(leftSensor, INPUT);
  pinMode(centerSensor, INPUT);
  pinMode(rightSensor, INPUT);
  Serial.begin(9600);
}

void loop() {
  int left = digitalRead(leftSensor);
  int center = digitalRead(centerSensor);
  int right = digitalRead(rightSensor);

  Serial.print("Left: ");
  Serial.print(left);
  Serial.print("  Center: ");
  Serial.print(center);
  Serial.print("  Right: ");
  Serial.println(right);

  delay(200);
}

      📘 How to Test

      • Upload the code and open the Serial Monitor.
      • Move the sensor over the black line and white background.
      • You should see changes in the printed values (0 or 1).

      🔧 Logic Output

       

      Left Center Right Robot Action
      0 1 0 Go Forward
      1 0 0 Turn Left
      0 0 1 Turn Right
  • Collapse Expand

    Using Motor Drivers

    ⚙️ Using Motor Drivers – L298N and Alternatives

    Arduino alone cannot directly power motors, especially DC motors or stepper motors. This is where motor drivers come in. They act as intermediaries between the Arduino and the motors.

    • ❓ Why Motor Drivers Are Essential

      • Motors draw more current than an Arduino can safely supply.
      • Motor drivers allow you to control speed and direction using digital signals.
      • They protect your microcontroller from power surges or back EMF (reverse current from motors).

      🔌 Meet the L298N Dual H-Bridge Driver

      • Can control two DC motors independently.
      • Handles up to 2A per channel.
      • Can also control stepper motors.

      📍 Pinout of L298N

       

      Pin Name Description
      IN1, IN2 Control Motor A
      IN3, IN4 Control Motor B
      ENA, ENB Enable pins for motors A and B (can be connected to PWM for speed control)
      VCC Connect to motor power supply (e.g., 9V battery)
      GND Ground connection
      5V Optional regulated output for Arduino if jumper is used

      🧰 Basic Wiring to Arduino

      • IN1 → D7, IN2 → D6 (Motor A)
      • IN3 → D5, IN4 → D4 (Motor B)
      • ENA → D9 (PWM control), ENB → D10 (PWM control)
      • VCC to 9V battery, GND to Arduino GND

    • 💻 Sample Code for Direction and Speed Control

      int ENA = 9;
int IN1 = 7;
int IN2 = 6;

void setup() {
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
}

void loop() {
  // Move forward
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, 150); // Set speed (0-255)
  delay(2000);

  // Stop
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  delay(1000);

  // Reverse
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  analogWrite(ENA, 150);
  delay(2000);
}

      🔄 Alternatives to L298N

      • L293D: Similar but with lower current rating (600mA)
      • TB6612FNG: More efficient and compact, preferred for battery-powered robots

      Choosing the right motor driver depends on the current requirement and available space in your robot. L298N is a great starting point for beginners due to its popularity and simplicity.

  • Collapse Expand

    Line Follower Robot

    🤖 Logic and Design

    A line follower robot is one of the most popular and exciting beginner projects in robotics. These robots can detect and follow a line—usually black on a white surface—using sensors and simple logic. It's like giving your robot a path to walk on!

    • 🧠 How a Line Follower Works

      Line follower robots use sensors—usually infrared (IR) sensors—to detect the difference between dark and light surfaces. Here’s the basic idea:

      • IR sensors shine light and measure how much reflects back.
      • White reflects more IR light, black absorbs more (reflects less).
      • When the robot detects it’s on a black line, it adjusts its motors to stay on track.

      📋 Simple Logic Behind It

      Let’s assume you have two IR sensors—one on the left, one on the right.

      Left Sensor Right Sensor Action
      White White Go straight
      Black White Turn left
      White Black Turn right
      Black Black Stop or reverse (off track)

      🛠️ Algorithm Design – Step-by-Step

      1. Start robot and turn on sensors
      2. Keep checking sensor readings
      3. If both sensors see white – keep going straight
      4. If left is black and right is white – turn left
      5. If right is black and left is white – turn right
      6. If both are black – stop and adjust

    • 🎯 Planning Your Robot Build

      • Chassis (robot body)
      • 2 IR sensors (or more for advanced version)
      • 2 DC motors with wheels
      • Motor driver module (like L298N)
      • Arduino board (like Uno)
      • Power supply (battery)

      Once you have this logic clear, building the line follower becomes a fun challenge! In the next section, we’ll begin assembling the robot step-by-step.

  • Collapse Expand

    Assembling

     

    🔧 Assembling Your First Robot

    Now that you understand how a line follower robot works, it's time to bring the parts together and build your very first robot. This section focuses on assembling the basic components safely and neatly.

     

    • 📦 Required Components

      • Robot chassis (2-wheel base or acrylic robot kit)
      • 2 DC motors with wheels
      • 1 caster wheel (for balance)
      • 2 IR sensors (TCRT5000 or similar)
      • Arduino Uno board
      • L298N motor driver
      • Battery holder (4xAA or 9V) and battery
      • Jumper wires, screws, nuts, and a screwdriver

       

    • 🔩 Step-by-Step Assembly

      1. Attach the Motors: Mount the two DC motors to the chassis using screws and brackets. Make sure the wheels face forward.
      2. Add the Caster Wheel: Fix the caster wheel at the front or back depending on your chassis design to balance the robot.
      3. Mount the IR Sensors: Place the IR sensors on the front underside of the robot so they face the ground. Use glue or screws for stability.
      4. Place the Arduino and Motor Driver: Use double-sided tape or mounts to fix the Arduino and L298N motor driver on the chassis.
      5. Wiring:
        • Connect the motors to the L298N OUT1–OUT4
        • Connect IN1–IN4 of L298N to Arduino digital pins
        • Connect the IR sensors to Arduino analog/digital pins
        • Power L298N with battery; Arduino can be powered from L298N's 5V pin or separately
      6. Secure the Battery: Fix the battery pack firmly to avoid shaking during movement

      💡 Tips for Neat and Safe Assembly

      • Use a breadboard temporarily to test your circuit before soldering or permanent fixing
      • Keep wires short and tidy using zip ties or tape
      • Double-check power connections to avoid overheating or damage
      • Mark sensor pins (VCC, GND, OUT) to avoid confusion

      Once the robot is fully assembled and wired, you are ready to move to the most exciting part—writing the code and seeing your robot come to life!

  • Collapse Expand

    Coding and Testing Your Robot

     

    Now that your line follower robot is physically assembled, it's time to program it so it can follow a line intelligently. This section covers sensor logic, writing your first complete code, uploading it, and step-by-step testing and debugging.

    • 🔍 How the Robot Makes Decisions

      Line follower robots use sensors to detect dark and light surfaces. Typically, black tape on a white background is used. The logic is:

      • IR sensor gives LOW when over black (absorbs IR)
      • IR sensor gives HIGH when over white (reflects IR)

      With two sensors (left and right), we can determine direction:

      • Left = 0, Right = 0 → On track (go straight)
      • Left = 0, Right = 1 → Off to right (turn left)
      • Left = 1, Right = 0 → Off to left (turn right)
      • Left = 1, Right = 1 → Off track (stop or reverse)

       

    • 💡 Sample Arduino Code for Line Following

      This sample sketch helps your robot follow a black line using two IR sensors and an L298N motor driver.

      
// Pin configuration
int leftSensor = A0;
int rightSensor = A1;

int motorLeft1 = 9;
int motorLeft2 = 8;
int motorRight1 = 7;
int motorRight2 = 6;

void setup() {
  pinMode(leftSensor, INPUT);
  pinMode(rightSensor, INPUT);
  
  pinMode(motorLeft1, OUTPUT);
  pinMode(motorLeft2, OUTPUT);
  pinMode(motorRight1, OUTPUT);
  pinMode(motorRight2, OUTPUT);
}

void loop() {
  int left = digitalRead(leftSensor);
  int right = digitalRead(rightSensor);

  if (left == 0 && right == 0) {
    // Move forward
    forward();
  } else if (left == 0 && right == 1) {
    // Turn left
    turnLeft();
  } else if (left == 1 && right == 0) {
    // Turn right
    turnRight();
  } else {
    // Stop
    stopMotors();
  }
}

void forward() {
  digitalWrite(motorLeft1, HIGH);
  digitalWrite(motorLeft2, LOW);
  digitalWrite(motorRight1, HIGH);
  digitalWrite(motorRight2, LOW);
}

void turnLeft() {
  digitalWrite(motorLeft1, LOW);
  digitalWrite(motorLeft2, HIGH);
  digitalWrite(motorRight1, HIGH);
  digitalWrite(motorRight2, LOW);
}

void turnRight() {
  digitalWrite(motorLeft1, HIGH);
  digitalWrite(motorLeft2, LOW);
  digitalWrite(motorRight1, LOW);
  digitalWrite(motorRight2, HIGH);
}

void stopMotors() {
  digitalWrite(motorLeft1, LOW);
  digitalWrite(motorLeft2, LOW);
  digitalWrite(motorRight1, LOW);
  digitalWrite(motorRight2, LOW);
}

      🔌 Uploading the Code

      1. Connect Arduino to your computer using a USB cable.
      2. Open the Arduino IDE and paste the code above.
      3. Select the correct board and port under the Tools menu.
      4. Click the Upload button (arrow icon).
      5. Wait for "Done Uploading" message at the bottom.

    • 🧪 Testing the Robot

      1. Place the robot on a black line path (preferably black tape on white chart paper).
      2. Power on the robot (use batteries, not USB).
      3. Observe how it responds:
        • If it moves forward on line, it’s working!
        • If it turns wrongly, check sensor connections and readings.

      🐞 Debugging Tips

      • Use the Serial Monitor to print sensor readings and debug.
      • Check sensor orientation – sometimes it may need flipping.
      • Double-check motor driver wiring; wrong pin order may reverse logic.
      • Use fresh batteries – weak power leads to inconsistent behavior.

      ✅ What You’ve Achieved

       

      By the end of this section, you've written your first logic-based Arduino program, uploaded it to your robot, tested sensor responses, and debugged real-world issues. This is a major step in robotics programming!

  • Collapse Expand

    Improving and Tuning

    🔧 Improving and Tuning Robot Behavior

    Once your line follower robot is running, the next step is to make it smarter, smoother, and more reliable. In this section, we explore how to fine-tune your robot's behavior for better performance in different environments.

    • ⚙️ Speed vs Accuracy Trade-offs

      Increasing motor speed makes the robot faster, but it may overshoot turns or miss the line. Reducing speed improves precision but slows down the robot. Here’s how to manage the balance:

      • Use analogWrite() instead of digitalWrite() for speed control.
      • Test different speed values (e.g., 100 to 255) to find the best range.
      • Use slower speeds during turns and higher speed on straight paths.

    • 🔆 Dealing with Lighting and Surface Changes

      IR sensors can be affected by external light and surface texture. Try the following:

      • Test your robot under different lighting conditions (natural light, bulbs, LEDs).
      • Use darker black tape and matte white background for clear contrast.
      • Adjust sensor height to reduce interference.

      🧠 Improving Logic – Smarter Turning

      Instead of stopping when off-track (both sensors HIGH), you can try remembering the last direction:

      
if (left == 1 && right == 1) {
  // Go in the direction last known to be correct
  if (lastTurn == 'L') {
    turnLeft();
  } else {
    turnRight();
  }
}

      This gives your robot a chance to recover if it briefly loses the path.

       

    • 🔄 Smoother Turns Using PWM

      By varying motor speeds using PWM (Pulse Width Modulation), you can make smoother curves:

      
// Example: Gentle left turn
analogWrite(leftMotorPWM, 80);  // slower
analogWrite(rightMotorPWM, 150); // faster

      This helps in handling curved lines instead of sharp corners.

    • 🎛️ Add-ons and Feedback Features

      You can make your robot more interactive or informative:

      • Buzzer – Beep on start or when lost line.
      • LEDs – Indicate direction (turning left, right, etc.).
      • LCD/OLED screen – Display sensor readings or status.

      💬 Code Sample: Speed Control Using PWM

      
void forward() {
  analogWrite(motorLeft1, 150);
  analogWrite(motorLeft2, 0);
  analogWrite(motorRight1, 150);
  analogWrite(motorRight2, 0);
}

      📋 Checklist for Better Performance

      • ✔ Tune motor speeds
      • ✔ Optimize sensor placement and height
      • ✔ Handle corners and curves more smoothly
      • ✔ Add visual or audio feedback
      • ✔ Calibrate for lighting conditions

      🎉 What You’ve Learned

      You now know how to go beyond just making your robot move. You've entered the world of fine-tuning and debugging—important skills in real robotics projects.

  • Collapse Expand

    Summary and Quiz

    Congratulations on completing this exciting journey into building and programming your very first line-following robot! 🚗✨ You’ve learned how to design the logic, assemble the hardware, connect sensors and motors, write Arduino code, and fine-tune your robot’s behavior for real-world conditions. Each section added a critical piece to your robotics puzzle — from understanding motor drivers to debugging curves and junctions.

     

    Now, it’s time to test your knowledge and see how much you’ve grasped before you take on your next challenge. Let’s dive into the quiz and hands-on project recap! 🧩💡