How a line follower robot works

A line follower robot uses two downward-facing light sensors, one each side of a dark line. A pale floor reflects lots of light and the line very little, so each sensor's reading drops when it's over the line. If the left sensor sees the line, the robot turns left; if the right one does, it turns right; if neither does, it's centred and drives straight.

Eyes on the floor

Each "eye" is a reflectance sensor: an infrared LED shining down and a phototransistor beside it measuring how much comes back. Read through analogRead, a typical pair gives about 937 over a white floor and about 250 right over a black line, with values in between at the line's edge.

A threshold turns a reading into a yes

The robot needs a yes or no: line, or floor? Put a threshold between the two readings. Halfway is about 594; 512 works too, with room either side for a dusty floor or a faded line. Put it at 950 and even the floor counts as line; put it at 100 and the line never does.

Live experiment

Pick a threshold, follow the loop

Each eye reads about 937 over the floor and 250 over the line. Pick a threshold and drive the loop: 512 or 800 follow it all the way round; 100 or 300 sit too close to the line's reading and run off; 950 is above even the floor, so the rover spins for ever.

Try it yourself: free lesson

“Follow the line” is lesson 2 of 6 in Rover Ridge, Robotics World 1. Free with an account. Lessons unlock in order, so you’ll do the one before it first.

Three rules

With the left eye on A0, the right on A1, and the left and right wheels on pins 9 and 10:

void loop() {
  int left = analogRead(A0);
  int right = analogRead(A1);
  if (left < 512) {           // line under the left eye: swing left
    analogWrite(9, 0);
    analogWrite(10, 255);
  } else if (right < 512) {   // line under the right eye: swing right
    analogWrite(9, 255);
    analogWrite(10, 0);
  } else {                    // centred: straight on
    analogWrite(9, 255);
    analogWrite(10, 255);
  }
}

To swing left, stop the left wheel and run the right: the rover pivots round its stopped wheel and its nose swings toward the line.

Smoother: steer in proportion

The three rules work, but every correction is a lurch, so the robot zigzags. Better: steer by how far off the line it is. The difference between the eyes says which way and how much:

int diff = right - left;   // positive: the line is under the left eye
analogWrite(9, constrain(180 - diff / 8, 0, 255));
analogWrite(10, constrain(180 + diff / 8, 0, 255));

Half over the line, a difference of about 300 slows the left wheel and speeds the right by about 38: a gentle lean, not a pivot. That's proportional control, the P in PID. Divide by too little and the zigzag comes back; by too much and the robot can't turn hard enough for a bend. Racing line followers add more sensors and a D term, and lap tracks at several metres a second.