Line-Following Robot

The finish line

What you will build

The robot completes a 3-metre high-contrast loop twice without leaving the line for more than one second.

Before you build

Materials, tools, and safety

Reuse-material cost: Usually under $5 with an existing kit. Supervision: Adult guidance recommended for wiring and cutting.

Build it

Step-by-step instructions

1. Step 1

   Build a straight rover

   Align both axle centers and match wheel diameters.

   Roll unpowered through a 1-metre lane.

2. Step 2

   Mount the sensor bar

   Place sensors 15-25 mm apart and 5-10 mm above the floor.

   Keep them ahead of the wheel axle.

3. Step 3

   Wire the motor stage

   Connect motors through the H-bridge and use common ground.

   Do not power motors from controller pins.

   Builder checkpoint: After wire the motor stage, the first subassembly should stay aligned when handled gently.

4. Step 4

   Wire and inspect sensors

   Connect each sensor at its rated voltage and route outputs to A0 and A1.

   Add strain relief.

   Watch for: If this stage binds or drifts, inspect control delay before adding more parts.

5. Step 5

   Calibrate surfaces

   Read 100 samples over line and background for each sensor.

   Choose midpoint thresholds or normalized ranges.

6. Step 6

   Test motor matching

   Command equal low PWM with wheels raised, then on a straight lane.

   Record drift and apply a small trim.

   Builder checkpoint: After test motor matching, operate the build slowly and confirm that differential wheel-speed corrections begins without binding.

7. Step 7

   Tune proportional steering

   Start with low base speed and correction gain.

   Increase gain until turns work without rapid oscillation.

8. Step 8

   Run full-loop trials

   Complete two loops and log line-loss locations.

   Change only speed or gain between tests.

   Builder checkpoint: At the final checkpoint, The robot completes a 3-metre high-contrast loop twice without leaving the line for more than one second.

See the engineering

Why it works

Input

left and right reflectance measurements

Output

differential wheel-speed corrections

Motion

sensor feedback-to-steered vehicle motion

Energy losses

wheel slip, sensor noise, motor mismatch, control delay

const int leftSensor=A0, rightSensor=A1;
const int leftPwm=5, rightPwm=6, leftDir=7, rightDir=8;
const int whiteL=220, blackL=810, whiteR=205, blackR=790;
const int baseSpeed=105; const float gain=85.0;
float normalized(int value,int whiteValue,int blackValue){
  return constrain((float)(value-whiteValue)/(blackValue-whiteValue),0.0,1.0);
}
void setup(){
  pinMode(leftPwm,OUTPUT); pinMode(rightPwm,OUTPUT);
  pinMode(leftDir,OUTPUT); pinMode(rightDir,OUTPUT);
  digitalWrite(leftDir,HIGH); digitalWrite(rightDir,HIGH);
}
void loop(){
  float left=normalized(analogRead(leftSensor),whiteL,blackL);
  float right=normalized(analogRead(rightSensor),whiteR,blackR);
  int correction=(int)(gain*(left-right));
  analogWrite(leftPwm,constrain(baseSpeed-correction,0,200));
  analogWrite(rightPwm,constrain(baseSpeed+correction,0,200));
  delay(8);
}

Make it behave

Test, troubleshoot, and tune

Keep experimenting

Try another version

Build together

Classroom and access options

Reflect on the design

1. How did proportional gain change the measured result?
2. Where did wheel slip affect the build most strongly?
3. What evidence shows that closed-loop line control explains the motion?
4. Which change would improve differential wheel-speed corrections without creating a new problem?