Build a Line Follower Robot: From Simulator to Real Track

A line follower is the best first robot: it senses, decides, and moves, yet every part of it is simple enough to understand completely. This build path treats it as exactly that—a path. Instead of a parts list and a wiring photo to copy, you unlock one node at a time, learning the mechanism behind each step before you build it.

You start by understanding how a row of infrared (IR) sensors becomes a single steering error, and how a Proportional-Integral-Derivative (PID) loop turns that error into smooth motion. Five sensors are the sweet spot for a first build: three work at low speed but give coarse position, eight give finer resolution at high speed but complicate wiring and calibration. The weighted average that collapses those readings into one signed number—negative when the line is left, positive when it is right—is the only signal the steering loop ever sees, which is why getting that number right matters more than picking a particular board.

That signal then has to become two different wheel speeds. Differential drive means the robot steers by spinning its wheels at different rates, and the tech tree walks you from the raw motor driver through pulse-width modulation (PWM) and the kinematics that turn a single correction into left and right commands. You will also see where odometry fits in: counting wheel motion tells you how far you have travelled, and why that estimate drifts without external reference — a theme that returns in every maze robot.

Before spending anything or risking a miswire, you tune the behaviour in the browser simulator, drawing a track, changing sensor count and spacing, and dragging Proportional, Integral and Derivative gains while watching error, lap time and time-on-track. The simulator is a teaching model, not hardware: it assumes a flat, high-contrast binary track, ideal calibration, no ambient-light change and a perfectly periodic loop with no wheel slip. Gains found here transfer as a close starting point, but you will still calibrate the real array and re-tune on your own tape.

Only then do you wire the real robot: reflectance outputs to analog-capable pins, PWM and direction to the L298N (Logic pins cannot source motor current — the dual H-bridge switches the real current instead), a separate motor supply on its own rail, and a common ground tying every module together. The final node is assembly and iteration on a real taped course, where you transfer the simulator gains and adjust for surface, battery voltage and loop timing. The same structure returns later in the line maze solver — which adds a decision layer on top of this follower — so getting this foundation solid saves time twice.

Follow the tech tree below top to bottom. Each node opens once its prerequisites are done, and your progress is saved on this device, so you can build the robot over a weekend without losing your place.

Bill of materials

Total: roughly $30–45. The single most valuable upgrade in that list is motors with encoders — not for this project, which does not need them, but because a line follower almost always becomes a line maze solver, and that one does.

For the track: matte black tape on a matte light floor. Glossy tape reflects like white at the wrong angle, and a glossy floor does the same, which produces a robot that works on one surface and not another for reasons that look like software.

How it all connects

Two failures account for most first-run problems, and neither produces an error message. A missing common ground means the direction signals have no reference, so nothing moves while everything looks correctly wired. Motor current through the Arduino sags the 5 V rail, resets the board, and presents as a software crash.

Build it in milestones

Do not wire the whole robot and then debug it. Each stage below has a test, and a stage that does not pass its test will hide inside the next one.

Milestone 6 is the one people skip and should not. If the position signal jumps as the line crosses between two sensors, no control loop can be tuned — the discontinuity looks like a sudden enormous error, and the robot will jerk at exactly that point every lap. A jump there means either the array is not calibrated per channel, or a channel’s threshold is excluding it too early.

What good looks like

Loop rate deserves attention because it silently caps everything else. A control loop running at 50 Hz sees the line every 20 ms, and at 0.5 m/s that is 10 mm of travel between decisions. Removing every delay() from the loop and reading only the sensors you use typically takes a first build from 50 Hz to several hundred, and the tracking improves without touching a gain.

Troubleshooting

Where to take it next

The line follower is deliberately a foundation, and three directions build directly on it.

Add junction detection and it becomes a line maze solver — the same PID loop underneath, with a thin decision layer on top that classifies branches and remembers the route. This is the single best next project, because it reuses everything here and adds one genuinely new idea.

Add encoders and you can hold a commanded speed rather than a commanded duty, which removes the “it degrades as the battery drains” problem entirely and makes the tune stable across a whole run.

Go faster, which is harder than it sounds and teaches the most. Speed exposes every approximation: the loop rate becomes the limit, the array needs to be further forward for lead time, the corners need slowing before they arrive rather than after, and the tyres start to slip. That last one is the wall — see wheel slip and traction for where it sits.