{"id":52287,"date":"2026-11-01T10:50:51","date_gmt":"2026-11-01T10:50:51","guid":{"rendered":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/"},"modified":"2026-11-01T10:50:51","modified_gmt":"2026-11-01T10:50:51","slug":"line-following-robot","status":"publish","type":"siratek_tutorial","link":"https:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/","title":{"rendered":"Project, a Line Following Robot"},"content":{"rendered":"

<\/p>\n

What you will build<\/h2>\n

A robot that follows a line of black tape across the floor. Four sensors looking down, two geared motors, and a sketch that turns \u201cthe line is slightly to my left\u201d into \u201cslow the left wheel\u201d.<\/p>\n

It is the first project in this library that is a closed loop<\/strong>: the thing it measures is changed by the thing it does, continuously, and that changes how you think about all of it. Everything in the two component pages that was a problem \u2014 two motors that will not run at the same speed, a sensor with no analog output, a trim that is only right at one speed \u2014 stops mattering here, because the robot corrects its own heading several hundred times a second.<\/p>\n

That is the lesson, and it is worth more than the robot.<\/p>\n

Before you begin<\/h2>\n

Parts<\/h3>\n\n\n\n\n\n\n\n\n\n\n
Part<\/th>\nSiratek product<\/th>\nIts own tutorial<\/th>\n<\/tr>\n<\/thead>\n
Arduino Uno<\/td>\n2219<\/td>\nGetting Started with Arduino Uno<\/em><\/td>\n<\/tr>\n
Four-way line tracking sensor<\/td>\n2943<\/td>\nA Four-Way Line Tracking Sensor<\/em><\/td>\n<\/tr>\n
L298N motor driver<\/td>\n2533<\/td>\nDriving DC Motors with an L298N<\/em><\/td>\n<\/tr>\n
Geared motor and wheel, two of them<\/strong><\/td>\n7406<\/td>\nGeared Motors and Wheels for a Robot<\/em><\/td>\n<\/tr>\n
Push button<\/td>\n2353<\/td>\nRead a Push Button<\/em><\/td>\n<\/tr>\n
Breadboard and jumper wires<\/td>\n<\/td>\nUsing a Breadboard<\/em><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Also needed: a chassis<\/strong> or something to screw the motors to, a castor or ball wheel for the front, a battery pack of four to six AA cells<\/strong> for the motors, a soldering iron, black electrical tape and a large sheet of white paper or card.<\/p>\n

Siratek product 7406 is one motor and one wheel.<\/strong> A driving robot needs two of them. That is the single most common ordering mistake on this project.<\/p>\n

The motor supply, which is not optional<\/h3>\n

Each geared motor draws roughly 150 to 200 mA running free and close to 1 A stalled<\/strong>. Two stalled motors is near 2 A, which is far beyond USB and more than a tired battery pack will hold up under.<\/p>\n

A robot that resets when it bumps into something is this, not a software fault.<\/strong> Separate motor supply, grounds joined, as the L298N page sets out. There is no sketch that fixes a sagging supply.<\/p>\n

Why the motor mismatch stops mattering<\/h3>\n

Geared Motors and Wheels for a Robot<\/em> is blunt about it: two identical motors given the same voltage make a robot curve, every time, often by ten percent or more, and the three honest responses are to trim it, to fit encoders, or to build something that corrects its own heading<\/strong>.<\/p>\n

This project is the third one. The line tells the robot where it is several hundred times a second, and a wheel that runs a little fast simply gets a little less of the correction. You never have to measure the trim at all.<\/p>\n

Which is why a line follower is the right first robot, rather than the hard one it looks like.<\/p>\n

Six pins for the driver, four for the sensor, and the collision between them<\/h3>\n

The L298N takes six<\/strong> Arduino pins, and the page assigns them D5<\/code> to D10<\/code> because three of those are PWM-capable, which the enable pins need.<\/p>\n

The tracking sensor\u2019s own page uses D4<\/code> to D7<\/code>. Those overlap. Something has to move, and it must not be the enable pins, because PWM is not available everywhere.<\/p>\n

So the sensor goes on A0<\/code> to A3<\/code>, used as digital pins.<\/strong> The analog inputs on an Uno are ordinary digital pins as well \u2014 A0<\/code> is D14<\/code>, A1<\/code> is D15<\/code>, and so on \u2014 and digitalRead(A0)<\/code> works exactly as digitalRead(4)<\/code> does. Nothing is lost here, because the sensor has no analog output for us to give up.<\/p>\n

This is a small thing that catches people out on every project with more than two modules in it: pins are a budget<\/strong>, and the ones with special abilities get spent last.<\/p>\n

Set the trimmers before you write any logic<\/h3>\n

The tracking sensor has four trimmers and four indicator LEDs, and nothing works properly until they are set. Lay out your line, hold the sensors at their mounted height over the white card, and turn each trimmer until its LED just changes, then back it off slightly.<\/p>\n

Height matters more than anything else.<\/strong> Five to fifteen millimetres is the usual working range, all four heads must sit at the same height, and a head two millimetres low behaves like a differently adjusted one. Fix the height mechanically; do not try to fix it in software.<\/p>\n

The full procedure is on the sensor\u2019s page. Do it with the robot on a stand, before the motors are ever enabled.<\/p>\n

Build the line before you build the robot<\/h3>\n

Black electrical tape on white card, at least two metres of it, with gentle curves. Make the first one easy<\/strong>: wide radius, no crossings, no sharp corners.<\/p>\n

A tight corner is not a harder version of the same problem \u2014 it is a different problem, because the line leaves the sensor array completely and the robot has to search for it. Get the easy course working first, then make it harder deliberately.<\/p>\n

How it works<\/h2>\n

One loop, running as fast as it can, doing three things:<\/p>\n\n\n\n\n\n\n\n
Step<\/th>\nWhat happens<\/th>\n<\/tr>\n<\/thead>\n
Read<\/td>\nFour digitalRead()<\/code> calls become one position number<\/td>\n<\/tr>\n
Decide<\/td>\nThe position becomes a left speed and a right speed<\/td>\n<\/tr>\n
Act<\/td>\nTwo analogWrite()<\/code> calls<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

There is no delay()<\/code> anywhere, and that is not a style preference. A delay of fifty milliseconds at walking pace is several centimetres of travel with its eyes shut.<\/p>\n

The position number<\/h3>\n

From the sensor\u2019s own page: each head reads light or dark, the dark ones are weighted -3, -1, +1, +3<\/code> from left to right, and averaging the weights of the heads that see the line gives a single number saying how far off-centre it is. Negative is left, positive is right, zero is centred, and NO_LINE<\/code> is a separate answer that is not<\/strong> zero.<\/p>\n

That last distinction is the one that keeps the robot on the table. A sketch that treats \u201cno line\u201d as \u201ccentred\u201d drives confidently straight on.<\/p>\n

Proportional steering<\/h3>\n

The whole controller is one idea: steer in proportion to how far off you are.<\/strong><\/p>\n

left  = base + gain * position\nright = base - gain * position<\/code><\/pre>\n
A little off-centre, a little correction. Far off, a big one. The robot slows the wheel on the side the line is on, which turns it that way.<\/p>\n
gain<\/code> is the number you tune, and it has two failure modes you will meet in this order:<\/p>\n\n\n\n\n\n\n\n
Gain<\/th>\nBehaviour<\/th>\n<\/tr>\n<\/thead>\n
Too low<\/td>\nDrifts off the line on curves; corrects too lazily<\/td>\n<\/tr>\n
About right<\/td>\nFollows the line with a gentle weave<\/td>\n<\/tr>\n
Too high<\/td>\nOscillates violently, left-right-left, and often loses the line entirely<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Start low, raise it until the weave appears, then back off slightly. That is the whole tuning procedure, and doing it by hand once teaches more about control than reading about it does.<\/p>\n
This is proportional control only<\/strong>, the P of PID. Adding the other two terms is a real improvement at speed and a project of its own; at the speed a first robot should run, P alone follows a reasonable line well.<\/p>\n
Speed is the hidden variable<\/h3>\n
Everything above depends on how fast the robot is going. A gain tuned at a crawl oscillates at speed, because the same correction has longer to act.<\/p>\n
So tune slowly first.<\/strong> BASE_SPEED<\/code> of about 120 is a sensible start. Raising the speed later means re-tuning the gain, and that relationship \u2014 faster needs gentler, or needs a better controller \u2014 is worth noticing because it is true of every control loop you will ever write.<\/p>\n
Losing the line, which is normal<\/h3>\n
Especially on corners. The behaviour you choose defines how the robot feels, and the simplest useful rule is: remember which way you were last turning, and keep turning that way.<\/strong> If the line vanished to the left, it is probably still to the left.<\/p>\n
With a time limit on it. Searching for a second is persistence; searching forever is a robot spinning in the corner of the room until its batteries go flat.<\/p>\n
All four dark<\/h3>\n
Four sensors reading dark at once is not a line. It is a junction, the end of the course marked with a wide band, or the sensors lifted off the surface. The sketch reports it separately and stops, which is the honest default \u2014 deciding what a junction means is a choice about your course, not about the robot.<\/p>\n
Build it in stages<\/h2>\n
Each stage ends with something working. Do not skip to the end; a robot that drives before its sensors are trusted is a robot that drives off the bench.<\/p>\n
Stage 1: the mechanics<\/h3>\n
Solder leads to both motors before<\/strong> mounting them \u2014 afterwards the tabs are awkward to reach and they break off easily. A dab of hot glue over each joint earns its place.<\/p>\n
Screw both motors to the chassis, wheels pushed fully onto the D-shaped shafts, castor at the front. Mount the four sensor heads in a row, facing down, all at the same height<\/strong>, spaced so the line falls between the middle two when the robot is centred.<\/p>\n
Because the heads are separate boards on leads, you can space them to suit the chassis rather than building the chassis around the sensor. Use that.<\/p>\n
Stage 2: the motors, on a stand, one at a time<\/h3>\n
Wire the L298N as its page describes \u2014 enable jumpers off<\/strong>, six logic wires, separate supply, grounds joined \u2014 and run the geared motor page\u2019s one-at-a-time test with the wheels off the ground.<\/p>\n
One wheel will turn backwards.<\/strong> The two motors face opposite ways on the chassis, so this is expected rather than puzzling. Swap that motor\u2019s two wires at the terminal block.<\/p>\n
Find the starting duty cycle too: step up from a standstill until both wheels turn reliably. Often around 60 to 80. Below that they hum and do not move.<\/p>\n
Stage 3: the sensors, still on the stand<\/h3>\n
Set the four trimmers. Then run the sensor page\u2019s display sketch and slide the robot across the line by hand, watching the pattern move: . # . .<\/code> becoming . . # .<\/code>.<\/p>\n
Confirm which physical head is which<\/strong>, by covering them one at a time. The ribbon can be plugged in either way round, and a reversed array makes a robot that steers away from the line \u2014 which looks like a broken gain and is not.<\/p>\n
Confirm the polarity as well. On most of these boards the output is LOW over black; check yours.<\/p>\n
Stage 4: position, without motors<\/h3>\n
Run the position sketch from the sensor page and slide the robot across the line again, watching the number go -3, -1, +1, +3<\/code>. Check that lifting it off the card gives NO_LINE<\/code> and not 0<\/code>.<\/p>\n
Stage 5: closed loop, on the stand<\/h3>\n
The complete sketch, with the wheels still off the ground. Move the line under the robot by hand and watch the wheels respond: the line to the left should slow the left wheel.<\/p>\n
If they respond the wrong way, the array is reversed or the motors are swapped. Fix it here, not on the floor.<\/p>\n
Stage 6: the floor<\/h3>\n
Put it down on the easy course, press the button, and tune the gain.<\/p>\n
Pin reference<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Device<\/th>\nPin<\/th>\nConnect to<\/th>\nNotes<\/th>\n<\/tr>\n<\/thead>\n
L298N<\/td>\nENA<\/code><\/td>\nUno D10<\/code><\/td>\nLeft speed, PWM, jumper off<\/strong><\/td>\n<\/tr>\n
L298N<\/td>\nIN1<\/code><\/td>\nUno D9<\/code><\/td>\nLeft direction<\/td>\n<\/tr>\n
L298N<\/td>\nIN2<\/code><\/td>\nUno D8<\/code><\/td>\nLeft direction<\/td>\n<\/tr>\n
L298N<\/td>\nIN3<\/code><\/td>\nUno D7<\/code><\/td>\nRight direction<\/td>\n<\/tr>\n
L298N<\/td>\nIN4<\/code><\/td>\nUno D6<\/code><\/td>\nRight direction<\/td>\n<\/tr>\n
L298N<\/td>\nENB<\/code><\/td>\nUno D5<\/code><\/td>\nRight speed, PWM, jumper off<\/strong><\/td>\n<\/tr>\n
L298N<\/td>\nOUT1<\/code>, OUT2<\/code><\/td>\nLeft motor<\/td>\nEither way round; corrected in stage 2<\/td>\n<\/tr>\n
L298N<\/td>\nOUT3<\/code>, OUT4<\/code><\/td>\nRight motor<\/td>\n<\/td>\n<\/tr>\n
L298N<\/td>\n+12V<\/code>, GND<\/code><\/td>\nBattery pack, and Uno GND<\/code><\/strong><\/td>\nGrounds joined<\/td>\n<\/tr>\n
Sensor<\/td>\nVCC<\/code><\/td>\nUno 5V<\/code><\/td>\nBoard and emitters<\/td>\n<\/tr>\n
Sensor<\/td>\nGND<\/code><\/td>\nUno GND<\/code><\/td>\n<\/td>\n<\/tr>\n
Sensor<\/td>\nD1<\/code><\/td>\nUno A0<\/code><\/td>\nLeftmost, used as a digital pin<\/td>\n<\/tr>\n
Sensor<\/td>\nD2<\/code><\/td>\nUno A1<\/code><\/td>\nCentre left<\/td>\n<\/tr>\n
Sensor<\/td>\nD3<\/code><\/td>\nUno A2<\/code><\/td>\nCentre right<\/td>\n<\/tr>\n
Sensor<\/td>\nD4<\/code><\/td>\nUno A3<\/code><\/td>\nRightmost<\/td>\n<\/tr>\n
Button<\/td>\none leg<\/td>\nUno D2<\/code><\/td>\nINPUT_PULLUP<\/code>, start and stop<\/td>\n<\/tr>\n
Button<\/td>\nother leg<\/td>\nUno GND<\/code><\/td>\n<\/td>\n<\/tr>\n
Status LED<\/td>\n<\/td>\nUno D13<\/code><\/td>\nThe onboard one; on means lost<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\"A
The driver needs six pins and three of them must be PWM, so the sensor moves to A0 to A3 \u2014 ordinary digital pins by another name.<\/figcaption><\/figure>\n
The complete sketch<\/h2>\n
\/\/ Siratek: a line following robot.\n\/\/ Proportional steering from a four-head tracking sensor.\n\n\/\/ Driver pins. ENA and ENB must be PWM-capable.\nconst int enA = 10, in1 = 9, in2 = 8;     \/\/ left\nconst int enB = 5,  in3 = 7, in4 = 6;     \/\/ right\n\n\/\/ The sensor, on the analog pins used as digital inputs.\nconst int sensorPins[4] = {A0, A1, A2, A3};\nconst int weights[4] = {-3, -1, 1, 3};    \/\/ leftmost to rightmost\n\nconst int buttonPin = 2;\nconst int statusLed = 13;\n\n\/\/ ---- Tuned on YOUR course. Start here and adjust. ----\nint BASE_SPEED = 120;        \/\/ slow, until the gain is right\nfloat GAIN = 18.0;           \/\/ raise until it weaves, then back off\nconst int MINIMUM_SPEED = 70;   \/\/ below this the motors hum\nconst int SEARCH_SPEED = 100;\n\/\/ ------------------------------------------------------\n\nconst unsigned long LOST_GIVE_UP = 1200;   \/\/ stop searching after this\n\nconst int NO_LINE  = 99;\nconst int ALL_DARK = 98;\n\nbool running = false;\nint lastSeen = 0;\nunsigned long lostSince = 0;\nunsigned long lastButton = 0;\n\nvoid leftMotor(int speed) {\n  digitalWrite(in1, speed >= 0);\n  digitalWrite(in2, speed < 0);\n  analogWrite(enA, abs(speed));\n}\n\nvoid rightMotor(int speed) {\n  digitalWrite(in3, speed >= 0);\n  digitalWrite(in4, speed < 0);\n  analogWrite(enB, abs(speed));\n}\n\nvoid drive(int left, int right) {\n  leftMotor(constrain(left, -255, 255));\n  rightMotor(constrain(right, -255, 255));\n}\n\nvoid halt() {\n  drive(0, 0);\n}\n\nint linePosition() {\n  int total = 0;\n  int seen = 0;\n\n  for (int i = 0; i < 4; i++) {\n    \/\/ LOW over black on most of these boards. Confirm yours in stage 3.\n    if (digitalRead(sensorPins[i]) == LOW) {\n      total += weights[i];\n      seen++;\n    }\n  }\n\n  if (seen == 0) {\n    return NO_LINE;\n  }\n  if (seen == 4) {\n    return ALL_DARK;     \/\/ a junction, the end marker, or lifted off\n  }\n  return total \/ seen;\n}\n\nvoid setup() {\n  int pins[] = {enA, in1, in2, enB, in3, in4};\n  for (int i = 0; i < 6; i++) {\n    pinMode(pins[i], OUTPUT);\n  }\n  for (int i = 0; i < 4; i++) {\n    pinMode(sensorPins[i], INPUT);\n  }\n  pinMode(buttonPin, INPUT_PULLUP);\n  pinMode(statusLed, OUTPUT);\n\n  halt();\n  Serial.begin(9600);\n  Serial.println(F(\"Siratek: press the button to start. Press again to stop.\"));\n}\n\nvoid loop() {\n  \/\/ The button starts and stops, with a crude debounce.\n  if (digitalRead(buttonPin) == LOW && millis() - lastButton > 400) {\n    lastButton = millis();\n    running = !running;\n\n    if (!running) {\n      halt();\n      Serial.println(F(\"stopped\"));\n    } else {\n      lostSince = 0;\n      Serial.println(F(\"running\"));\n      \/\/ A brief full-power kick, because the motors will not start\n      \/\/ from rest at the speed we actually want.\n      drive(255, 255);\n      delay(60);\n    }\n  }\n\n  if (!running) {\n    halt();\n    digitalWrite(statusLed, LOW);\n    return;\n  }\n\n  int position = linePosition();\n\n  if (position == ALL_DARK) {\n    halt();\n    running = false;\n    digitalWrite(statusLed, HIGH);\n    Serial.println(F(\"all four dark: junction, end marker, or lifted off\"));\n    return;\n  }\n\n  if (position == NO_LINE) {\n    digitalWrite(statusLed, HIGH);\n\n    if (lostSince == 0) {\n      lostSince = millis();\n    }\n\n    if (millis() - lostSince >= LOST_GIVE_UP) {\n      halt();\n      running = false;\n      Serial.println(F(\"line lost: stopped\"));\n      return;\n    }\n\n    \/\/ Keep turning the way we last saw it.\n    if (lastSeen < 0) {\n      drive(-SEARCH_SPEED, SEARCH_SPEED);\n    } else {\n      drive(SEARCH_SPEED, -SEARCH_SPEED);\n    }\n    return;\n  }\n\n  \/\/ We can see the line.\n  digitalWrite(statusLed, LOW);\n  lostSince = 0;\n  lastSeen = position;\n\n  int correction = (int) (GAIN * position);\n\n  int left  = BASE_SPEED + correction;\n  int right = BASE_SPEED - correction;\n\n  \/\/ Do not ask a motor for a speed at which it only hums.\n  if (left > 0 && left < MINIMUM_SPEED) {\n    left = MINIMUM_SPEED;\n  }\n  if (right > 0 && right < MINIMUM_SPEED) {\n    right = MINIMUM_SPEED;\n  }\n\n  drive(left, right);\n}<\/code><\/pre>\n
Four decisions worth explaining<\/h3>\n
There is no delay()<\/code> in the control path.<\/strong> The only one is the starting kick, which happens once when the button is pressed. At walking pace a fifty-millisecond delay is several centimetres driven blind, and that is what a robot sawing across the line usually turns out to be.<\/p>\n
NO_LINE<\/code> and ALL_DARK<\/code> are separate answers, and neither is zero.<\/strong> A position of 0<\/code> means centred. Collapsing either of the other two into it is the bug that drives a robot off a table, and it is an easy one to write by accident.<\/p>\n
MINIMUM_SPEED<\/code> is applied after the correction, not before.<\/strong> The arithmetic happily produces a left speed of 30, at which the motor hums and does nothing while the right wheel drives on \u2014 so the robot turns much harder than intended. Raising small positive speeds to the threshold is the fix, and it is why the robot still steers properly at low base speeds.<\/p>\n
Losing the line stops the robot rather than searching forever.<\/strong> Persistence for a second, then a stop. A robot that spins in a corner indefinitely is both useless and hard on the gearboxes.<\/p>\n
Testing it<\/h2>\n
Stand first, floor second. Every line in this table is worth doing in order.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Try this<\/th>\nIt should<\/th>\n<\/tr>\n<\/thead>\n
On a stand<\/strong>, slide the line to the left<\/td>\nThe left wheel slows<\/td>\n<\/tr>\n
On a stand, slide the line right<\/td>\nThe right wheel slows<\/td>\n<\/tr>\n
On a stand, lift it off the card<\/td>\nWheels search one way, then stop after a second<\/td>\n<\/tr>\n
Cover all four heads<\/td>\nStop, with the status LED on<\/td>\n<\/tr>\n
On the floor, gain too low<\/td>\nDrift off on the curves<\/td>\n<\/tr>\n
Raise the gain until it weaves<\/td>\nA gentle regular weave along a straight line<\/td>\n<\/tr>\n
Raise it further<\/td>\nA violent oscillation; now you know the limit<\/td>\n<\/tr>\n
Back it off, run the course<\/td>\nFollows it, including the curves<\/td>\n<\/tr>\n
Raise BASE_SPEED<\/code> by 40<\/td>\nProbably oscillates again: re-tune the gain<\/td>\n<\/tr>\n
Hold a wheel while it runs<\/td>\nIt should not reset. If it does, the supply is the problem<\/td>\n<\/tr>\n
Run it on a shiny floor<\/td>\nLikely worse than on card; matte surfaces reflect usefully<\/td>\n<\/tr>\n
Run it in direct sunlight<\/td>\nLikely erratic; these are indoor sensors<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The three gain rows are the project. Watching the same robot go from lazy to ideal to unstable because of one number is the clearest demonstration of feedback you can get on a bench, and it costs nothing but a few minutes on the floor.<\/p>\n
Making it yours<\/h2>\n
    \n
  • Add the full PID.<\/strong> The derivative term damps the weave and lets you run much faster; the integral term pulls out a persistent off-centre bias. Both are real improvements once P is tuned, and neither is worth adding before then.<\/li>\n
  • Handle junctions.<\/strong> Right now all four dark stops the robot. Counting junctions, or always turning the same way at one, turns a line into a maze.<\/li>\n
  • Fit encoders.<\/strong> The geared motors have a spare shaft on the other side, exactly for a slotted disc. Then the robot knows how far it has travelled as well as where the line is.<\/li>\n
  • An obstacle sensor.<\/strong> An HC-SR04 on the front, and the robot stops instead of pushing a chair across the room. A servo under the sensor lets it look around before deciding.<\/li>\n
  • A wider array.<\/strong> Five or more heads, spaced further apart, sees a sharp corner before it has lost the line.<\/li>\n
  • Make it wireless.<\/strong> HC-05 Bluetooth to change the gain and base speed while it runs, which turns tuning from a dozen uploads into one session with a phone.<\/li>\n<\/ul>\n
    That last one is the practical one. Tuning by editing a constant and re-uploading is slow enough that people stop before they have found the good value.<\/p>\n
    Troubleshooting<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Symptom<\/th>\nLikely cause<\/th>\nCheck or fix<\/th>\n<\/tr>\n<\/thead>\n
    Steers away from the line<\/td>\nSensor array reversed<\/td>\nCover each head and find the order<\/td>\n<\/tr>\n
    Steers away, order correct<\/td>\nMotor leads swapped<\/td>\nOne motor faces the other way; swap its wires<\/td>\n<\/tr>\n
    Oscillates violently<\/td>\nGain too high for the speed<\/td>\nLower the gain, or lower the speed<\/td>\n<\/tr>\n
    Drifts off on curves<\/td>\nGain too low<\/td>\nRaise it until a weave appears<\/td>\n<\/tr>\n
    Follows straights, fails corners<\/td>\nSpeed too high for the radius<\/td>\nSlow down, or widen the corner<\/td>\n<\/tr>\n
    Wheels hum, robot does not move<\/td>\nBelow the starting duty cycle<\/td>\nThe kick in the sketch; check MINIMUM_SPEED<\/code><\/td>\n<\/tr>\n
    Only full speed, no steering<\/td>\nENA<\/code>\/ENB<\/code> jumpers still fitted<\/td>\nRemove them; they must be on PWM pins<\/td>\n<\/tr>\n
    Resets when it bumps something<\/td>\nStall current, near 1 A each<\/td>\nA supply that holds up, grounds joined<\/td>\n<\/tr>\n
    Drives straight off the card<\/td>\nNO_LINE<\/code> treated as centred<\/td>\nThey are separate answers for this reason<\/td>\n<\/tr>\n
    One channel never changes<\/td>\nThat head\u2019s height, then its trimmer<\/td>\nHeight first; all four must match<\/td>\n<\/tr>\n
    All four always read the same<\/td>\nToo close to the floor<\/td>\nThe emitter is flooding the receiver; raise them<\/td>\n<\/tr>\n
    Erratic outdoors or by a window<\/td>\nInfrared in daylight<\/td>\nShade it; these are indoor parts<\/td>\n<\/tr>\n
    Worse as the batteries drain<\/td>\nExpected<\/td>\nFresh cells, and re-check the gain<\/td>\n<\/tr>\n
    Loses the line on the same corner every time<\/td>\nArray too narrow for that radius<\/td>\nSpace the heads wider<\/td>\n<\/tr>\n
    Works on the stand, not on the floor<\/td>\nWeight and friction change everything<\/td>\nRe-tune on the floor; the stand only proves direction<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Sources and attribution<\/h2>\n
    All text, wiring guidance and code in this project are original Siratek work.<\/p>\n
      \n
    • Sensor behaviour, the separate heads, the working height, the DT<\/code> and DR<\/code> marking, the weighted position number and the NO_LINE<\/code> distinction are as set out in A Four-Way Line Tracking Sensor<\/em>, read from the Siratek product photographs for item 2943.<\/li>\n
    • Driver wiring, the enable jumpers, the PWM pin requirement and the bridge voltage drop are as set out in Driving DC Motors with an L298N<\/em>.<\/li>\n
    • The motor mismatch, the stall current near 1 A, the starting duty cycle and the spare shaft for encoders are as set out in Geared Motors and Wheels for a Robot<\/em>. Product 7406 is one motor and wheel; this project needs two.<\/strong><\/li>\n
    • The proportional controller, the pin reassignment to A0<\/code>\u2013A3<\/code>, the search behaviour and the MINIMUM_SPEED<\/code> handling are Siratek\u2019s own design decisions for this project.<\/li>\n<\/ul>\n
      Gain, base speed and the starting duty cycle depend on the chassis, the surface and the batteries, so the tutorial gives a tuning procedure rather than values to copy. This project has not yet been built and run on hardware.<\/strong> No third-party tutorial text, diagrams, photographs or code has been reproduced here.<\/p>\n
      <\/p>\n<\/body>","protected":false},"excerpt":{"rendered":"
      A robot that follows a line of black tape across the floor. Four sensors looking down, two geared motors, and a sketch that turns "the line is slightly to my left" into "slow the left wheel".<\/p>\n","protected":false},"featured_media":0,"template":"","siratek_tutorial_level":[],"class_list":["post-52287","siratek_tutorial","type-siratek_tutorial","status-publish","hentry"],"yoast_head":"\nProject, a Line Following Robot - siratek<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Project, a Line Following Robot - siratek\" \/>\n<meta property=\"og:description\" content=\"A robot that follows a line of black tape across the floor. Four sensors looking down, two geared motors, and a sketch that turns "the line is slightly to my left" into "slow the left wheel".\" \/>\n<meta property=\"og:url\" content=\"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/\" \/>\n<meta property=\"og:site_name\" content=\"siratek\" \/>\n<meta property=\"og:image\" content=\"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/line-following-robot-wiring.svg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/\",\"url\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/\",\"name\":\"Project, a Line Following Robot - siratek\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/#primaryimage\"},\"image\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/line-following-robot-wiring.svg\",\"datePublished\":\"2026-11-01T10:50:51+00:00\",\"breadcrumb\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/#primaryimage\",\"url\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/line-following-robot-wiring.svg\",\"contentUrl\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/line-following-robot-wiring.svg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/line-following-robot\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/siratek.net\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Tutorials\",\"item\":\"https:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Project, a Line Following Robot\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\",\"url\":\"https:\\\/\\\/siratek.net\\\/\",\"name\":\"siratek\",\"description\":\"Your Best Electronic Retail Shop\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/siratek.net\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Project, a Line Following Robot - siratek","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/","og_locale":"en_US","og_type":"article","og_title":"Project, a Line Following Robot - siratek","og_description":"A robot that follows a line of black tape across the floor. Four sensors looking down, two geared motors, and a sketch that turns "the line is slightly to my left" into "slow the left wheel".","og_url":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/","og_site_name":"siratek","og_image":[{"url":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/line-following-robot-wiring.svg","type":"","width":"","height":""}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/","url":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/","name":"Project, a Line Following Robot - siratek","isPartOf":{"@id":"https:\/\/siratek.net\/#website"},"primaryImageOfPage":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/#primaryimage"},"image":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/#primaryimage"},"thumbnailUrl":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/line-following-robot-wiring.svg","datePublished":"2026-11-01T10:50:51+00:00","breadcrumb":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/#primaryimage","url":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/line-following-robot-wiring.svg","contentUrl":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/line-following-robot-wiring.svg"},{"@type":"BreadcrumbList","@id":"http:\/\/siratek.net\/index.php\/tutorials\/line-following-robot\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/siratek.net\/"},{"@type":"ListItem","position":2,"name":"Tutorials","item":"https:\/\/siratek.net\/index.php\/tutorials\/"},{"@type":"ListItem","position":3,"name":"Project, a Line Following Robot"}]},{"@type":"WebSite","@id":"https:\/\/siratek.net\/#website","url":"https:\/\/siratek.net\/","name":"siratek","description":"Your Best Electronic Retail Shop","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/siratek.net\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52287","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial"}],"about":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/types\/siratek_tutorial"}],"version-history":[{"count":0,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52287\/revisions"}],"wp:attachment":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/media?parent=52287"}],"wp:term":[{"taxonomy":"siratek_tutorial_level","embeddable":true,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial_level?post=52287"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}