Design and
Implementation
of an
Autonomous
Line Following
Robot
Introduction:
A Line Following Robot (LFR) is a type of autonomous mobile robot that
detects and follows a visual line embedded on the surface, typically black
on white. This project integrates IR sensors, DC motors, an Arduino
microcontroller, and a motor driver to detect a path and navigate
accordingly.
These robots are a common entry point for learning robotics, control
systems, and sensor integration, offering practical insights into how robots
make real-time decisions using environmental input.
Objective:
To design and build a robot that can autonomously follow a line using
infrared sensors. This robot simulates real-world applications of
automation, such as material handling in factories or smart delivery robots,
and serves as an excellent platform to learn about robotics, electronics,
and embedded systems.
Components Required:
Component Quantity Purpose
Arduino Uno 1 Microcontroller (Brain of the Robot)
IR Sensor Module 2 Line detection using infrared light
L298N Motor Driver 1 Motor direction and speed control
DC Geared Motors 2 Movement of the robot
Robot Chassis 1 Base frame for components
Wheels 2 Enables locomotion
Caster Wheel 1 Provides support and balance
12V Battery Pack 1 Power source
Jumper Wires As much needed Electrical connections
Switch (Optional) 1 Power control
Working Principle:
The working principle of the Line Following Robot is based on real-time
path detection using infrared sensors and responsive motor control guided
by a microcontroller. The robot continuously monitors its surroundings
through sensors and makes decisions instantly to stay aligned with the line
path.
Line Detection:
Two infrared (IR) sensors are placed at the front underside of the robot.
These sensors work by emitting infrared light and detecting the amount of
reflected light. A white surface reflects more light (registering a HIGH
signal), while a black surface absorbs light and reflects less (registering a
LOW signal). By comparing the signals from both sensors, the robot can
detect whether it is centered on the line or veering off track. These sensors
are crucial for enabling the robot to differentiate between the path and the
background surface. Correct sensor positioning and calibration ensure
accurate path recognition even during turns.
Decision Making:
The Arduino Uno serves as the robot's brain. It receives input from the IR
sensors and processes the data to determine the robot’s orientation in
relation to the line:
If both sensors detect black (LOW signal), it means the robot is
perfectly aligned with the line. The robot moves forward.
If the left sensor detects black and the right one detects white, the
robot has drifted to the right and must turn left to re-align.
If the right sensor detects black and the left one detects white, the
robot has drifted to the left and must turn right.
If both sensors detect white, it means the line is lost. The robot stops
to prevent wandering off-course.
These decisions are made continuously and at high speed, allowing the
robot to dynamically adjust its path in real-time and maintain consistent
movement along the line.
Motor Control:
The Arduino sends logic signals to the L298N motor driver based on the
processed sensor inputs. The motor driver, in turn, directs the two DC
motors to drive the robot accordingly. For instance:
To move forward, both motors rotate in the same direction.
To turn left, the left motor slows or stops while the right motor keeps
rotating.
To turn right, the right motor slows or stops while the left motor keeps
rotating.
To stop, both motors are turned off.
The real-time combination of sensor input, decision-making, and controlled
motor output results in a robot that can autonomously and efficiently follow
a line with minimal human intervention. This system works in a continuous
feedback loop where every new sensor reading influences the next
movement decision, enabling adaptive and autonomous navigation.
Behavior Logic Table:
Left Sensor Right Sensor Action
Black (0) Black (0) Move Forward
Black (0) White (1) Turn Left
White (1) Black (0) Turn Right
White (1) White (1) Stop
Circuit Diagram
:
Arduino Code Logic:
Read sensor values
Compare values to threshold
Determine direction (forward, left, right, stop)
Send signals to motor driver for appropriate action
Full Arduino Code:
#define IR_SENSOR_RIGHT 11
#define IR_SENSOR_LEFT 12
#define MOTOR_SPEED 180
//Right motor
int enableRightMotor=6;
int rightMotorPin1=7;
int rightMotorPin2=8;
//Left motor
int enableLeftMotor=5;
int leftMotorPin1=9;
int leftMotorPin2=10;
void setup()
{
//The problem with TT gear motors is that, at very low pwm value it does
not even rotate.
//If we increase the PWM value then it rotates faster, and our robot is not
controlled in that speed and goes out of line.
//For that we need to increase the frequency of analogWrite.
//Below line is important to change the frequency of PWM signal on pin D5
and D6
//Because of this, motor runs in controlled manner (lower speed) at high
PWM value.
//This sets frequecny as 7812.5 hz.
TCCR0B = TCCR0B & B11111000 | B00000010 ;
// put your setup code here, to run once:
pinMode(enableRightMotor, OUTPUT);
pinMode(rightMotorPin1, OUTPUT);
pinMode(rightMotorPin2, OUTPUT);
pinMode(enableLeftMotor, OUTPUT);
pinMode(leftMotorPin1, OUTPUT);
pinMode(leftMotorPin2, OUTPUT);
pinMode(IR_SENSOR_RIGHT, INPUT);
pinMode(IR_SENSOR_LEFT, INPUT);
rotateMotor(0,0);
}
void loop()
{
int rightIRSensorValue = digitalRead(IR_SENSOR_RIGHT);
int leftIRSensorValue = digitalRead(IR_SENSOR_LEFT);
//If none of the sensors detects black line, then go straight
if (rightIRSensorValue == LOW && leftIRSensorValue == LOW)
{
rotateMotor(MOTOR_SPEED, MOTOR_SPEED);
}
//If right sensor detects black line, then turn right
else if (rightIRSensorValue == HIGH && leftIRSensorValue == LOW )
{
rotateMotor(-MOTOR_SPEED, MOTOR_SPEED);
}
//If left sensor detects black line, then turn left
else if (rightIRSensorValue == LOW && leftIRSensorValue == HIGH )
{
rotateMotor(MOTOR_SPEED, -MOTOR_SPEED);
}
//If both the sensors detect black line, then stop
else
{
rotateMotor(0, 0);
}
}
void rotateMotor(int rightMotorSpeed, int leftMotorSpeed)
{
if (rightMotorSpeed < 0)
{
digitalWrite(rightMotorPin1,LOW);
digitalWrite(rightMotorPin2,HIGH);
}
else if (rightMotorSpeed > 0)
{
digitalWrite(rightMotorPin1,HIGH);
digitalWrite(rightMotorPin2,LOW);
}
else
{
digitalWrite(rightMotorPin1,LOW);
digitalWrite(rightMotorPin2,LOW);
}
if (leftMotorSpeed < 0)
{
digitalWrite(leftMotorPin1,LOW);
digitalWrite(leftMotorPin2,HIGH);
}
else if (leftMotorSpeed > 0)
{
digitalWrite(leftMotorPin1,HIGH);
digitalWrite(leftMotorPin2,LOW);
}
else
{
digitalWrite(leftMotorPin1,LOW);
digitalWrite(leftMotorPin2,LOW);
}
analogWrite(enableRightMotor, abs(rightMotorSpeed));
analogWrite(enableLeftMotor, abs(leftMotorSpeed)); }
Real-World Applications:
Industrial line-following carts
Automated warehouse robots
Smart medical delivery bots
Educational robotics competitions
Lane detection systems in autonomous vehicles
