You open the box and see a pile of parts. Most first builds go straight from the video to the workbench, matching wires to slots without asking what any of it actually does. That works right up until something stops moving, and now you're debugging six systems you never understood in the first place.

This is the map. Six parts, one job each, and how they talk to each other, so next time something goes wrong, you already know where to look.

If you get stuck anywhere in this list, ask in the Community. Plenty of builders have already taken the same box apart.

The chassis: the frame everything else answers to

Every part on this list bolts, screws, or sticks onto the chassis, so its shape decides how the robot behaves before you write a line of code. A short wheelbase (the gap between the front and back wheels) turns sharper on tight corners. A long one holds a straighter line at speed but understeers into hairpins.

The Basic Chassis for Line Follower is a flat frame you build up from scratch, light and simple enough to learn on. The Advanced Suction Chassis adds an impeller that pulls air out from underneath the robot and presses it onto the track, the way a vacuum cleaner grips a floor.

More downforce means more grip in a corner, without adding weight that slows you down on the straight.

None of that grip matters if nothing is turning the wheels, which is the next part.

The wheels and motors: what actually moves you

N20 Wheels are built around the N20 motor family, a small geared DC motor. The gearbox inside trades speed for pulling power. A higher gear ratio pulls harder off the line. A lower one spins faster but has less muscle when the robot has to accelerate out of a corner.

This is why two robots with the same motor brand can behave completely differently. One's geared for a drag strip, the other for a technical track full of turns. Neither setting is wrong, they just answer different questions.

The motor doesn't decide which way to turn. It just spins when told to, as hard as its gearing allows.

That's the catch. The motors move the robot, but something still has to tell them which way, and that job belongs to the sensor array.

The sensor array: how the robot sees the line

Under the chassis sits a row of small infrared sensors, each one a paired emitter and detector. The emitter shines infrared light down at the track, invisible to your eyes. The detector measures how much of it bounces back. A white surface reflects most of that light back up. A black line absorbs it, so almost none returns.

That contrast is the entire trick. No camera, no image processing, just one number per sensor telling the board how much light came back.

The ARC8 packs eight of these sensors across the width of the robot. The ARC16 doubles that to sixteen. Tighter spacing means finer resolution, and finer resolution means the robot notices the line drifting off center a moment sooner, which matters most exactly where you need it: a sharp corner, where a moment late is a moment off the track.

More sensors packed into the same width isn't a luxury upgrade. It's the difference between seeing a corner coming and finding out after you've already missed it.

(If you want the full picture on how reflectance sensing works, Science Buddies has a clear breakdown of the emitter-detector pair.)

Seeing the line is only half the job. Something has to turn that reading into actual motor speed, and that's the driver.

The motor driver: the muscle between logic and torque

Your carrier board's pins put out a tiny logic signal, a few milliamps at most. Motors need far more current than that to actually turn. The Unidirectional Speed Controller (USC) sits between the two, taking that small signal and switching real current to the motor, thousands of times a second, to control how fast it spins.

Push a driver past what it's built for and it gets hot. A hot driver protects itself by limiting the current it delivers, and a current-limited driver just slows your bot down for no reason you can see on the outside. It looks like a code problem. It's usually a heat problem.

The driver only does what it's told. Give it a clean, well-timed signal and it delivers; overload it and it quietly throttles you instead.

But something upstream has to decide what that signal should be in the first place. That's the carrier board.

The carrier board: where the decision actually gets made

The Robot Carrier Board, also called Blueprint 01, is the brain. It reads the sensor array many times a second, runs the code that decides how far off the line the robot is, and turns that decision into a command for the driver.

This is where PID control lives, the method most line followers use to convert "the line drifted this much" into "turn this hard, right now." We cover PID on its own in PID control, explained for beginners, and the actual code that runs on this loop is in the Mark 2 LFR Code.

The board is where a wobbly line becomes a smooth one, or doesn't, depending entirely on what the code does with the numbers coming in.

None of this reads, decides, or moves without power. That's the last part.

The battery: small, but everything upstream depends on it

Most line followers run on a small LiPo pack, chosen for weight as much as capacity. A heavier battery raises the chassis and slows acceleration. A pack too small in capacity sags under load exactly when the motors demand a current spike, usually mid-correction on a corner, which is the worst possible moment for the robot to lose power.

Charge and store your LiPo pack on a hard, flat surface, never on carpet, and never while you're asleep.

The battery is the one part that never touches a sensor, a wheel, or a line of code, and every other part on this list stops working the moment it can't get enough current from it.

How the six parts actually work together

Think of it as a loop, not a list. The sensor array sees the line. The carrier board decides how far off it is. The driver turns that decision into current. The motors spin the wheels. The chassis carries the correction into an actual turn. Then the sensor array checks again, dozens of times a second, and the whole thing repeats.

If it helps, picture a body: the chassis is the skeleton, the sensor array is the eyes, the driver is the muscle, the carrier board is the brain, and the battery is the heart. Cut any one of them out and the rest stop mattering.

Conclusion

Six parts, one job each. The chassis carries everything. The wheels and motors move it. The sensor array sees the line. The driver turns that reading into current. The carrier board makes the call. The battery keeps the whole loop running. Now that you know what each one does, the wiring diagram in the assembly video will actually make sense.

Next time your bot does something strange on the track, you already know which of these six to check first. Which one do you think yours will need tuning on sooner: the sensor spacing, or the motor driver?

Ready to put these six parts together yourself? The Mark 1 Line Following Robot kit hands you all six, unassembled, so every part on this list is one you'll have actually built.