Gidsen · 16 min leestijd

Lijnvolgerrobot met Arduino: TCRT5000-sensoren en PID

Bouw een lijnvolgerrobot met Arduino: TCRT5000-sensoren, plaatsing en kalibratie, if-else- en PID-code, Kp/Kd afstellen, motordriver, batterij en wedstrijdregels.

Een lijnvolgerrobot is een autonoom voertuig dat met infraroodsensoren een zwarte (of witte) lijn op de vloer detecteert en de snelheid van zijn twee wielen steeds bijstuurt, zodat hij op die lijn blijft. Het is een van de eerste echte robotprojecten die mensen met Arduino bouwen, omdat sensoren uitlezen, beslissingen nemen en motoren aansturen in één project samenkomen. De autonome karretjes (AGV's) die in fabrieken materiaal vervoeren werken volgens hetzelfde idee, en lijnvolgen is een van de drukst bezette categorieën bij robotwedstrijden voor scholen.

In deze gids leer je hoe de TCRT5000-sensor werkt, wat het verschil is tussen sensorarrays met 2, 3 en 5 sensoren, op welke hoogte en met welke onderlinge afstand je de sensoren monteert en hoe je de drempelwaarde kalibreert. Eerst krijg je de robot aan het rijden met een eenvoudige if-else-sketch. Daarna stap je over op een versie met PID-regeling die de lijn volgt zonder te zigzaggen en zonder in bochten van de baan te raken. Naast werkende code voor de Arduino Uno, ESP32 en Raspberry Pi Pico lees je hoe je de motordriver en batterij kiest, welke wedstrijdregels gebruikelijk zijn en hoe je de meest voorkomende problemen oplost.

TCRT5000 infraroodreflectiesensor
TCRT5000: een blauwgetinte infrarood-led en een zwarte fototransistor zitten naast elkaar in één behuizing; lijnsensormodules zijn rond dit onderdeel gebouwd.

Hoe werkt een lijnvolgerrobot?

Een wit oppervlak kaatst het grootste deel van het infraroodlicht terug, terwijl een matzwart oppervlak het meeste absorbeert. De sensoren onder de robot meten dit verschil om te bepalen waar de lijn zich ten opzichte van de robot bevindt. De robot heeft geen stuur; hij draait met zogenaamde differentiële aandrijving: als het linkerwiel sneller draait dan het rechter, maakt de robot een bocht naar rechts, en als het langzamer draait een bocht naar links. Het programma voert honderden keren per seconde dezelfde lus uit: sensoren uitlezen, berekenen hoe ver de lijn is weggedreven en de snelheid van de twee motoren daarop corrigeren. Hoe sneller en stabieler deze gesloten lus draait, hoe soepeler de robot rijdt.

OnderdeelAanbevolenOpmerking
ControllerboardArduino Uno of NanoDe Nano past makkelijker op een klein chassis; een ESP32 of Pico werkt ook
LijnsensorTCRT5000-array met 3 of 5 kanalen, QTR-8AEen array met analoge uitgangen geeft betere resultaten met PID
MotordriverL298N of TB6612FNGDe TB6612FNG is kleiner en efficiënter
Motoren2 gelijkstroommotoren met tandwielkast (TT 1:48 of N20)Beide motoren moeten hetzelfde model en dezelfde snelheid hebben
Wielen2 aandrijfwielen en 1 zwenkwielWielen van 65 mm zijn het meest gebruikelijk
Voeding2 × 18650 li-ioncellen (7,4 V) en een schakelaarEen 9V-blokbatterij (PP3) is te zwak voor motoren
OverigChassis, drukknop, jumperdradenMet een knop kalibreer en start je makkelijker
Arduino Nano
Arduino Nano
L298N
L298N
N20
N20
18650 Li-ion
18650 Li-ion

De TCRT5000-sensor: arrays met 2, 3 en 5 sensoren

De TCRT5000 bestaat uit een infrarood-led (950 nm) en een fototransistor die naast elkaar in dezelfde behuizing zitten. Hoe meer licht van de led van de vloer terugkaatst naar de fototransistor, hoe beter de transistor geleidt. De sensor werkt het best op een afstand van ongeveer 2,5 mm; boven 1 cm neemt het verschil tussen zwart en wit snel af. Kant-en-klare modules hebben een LM393-comparator: bij de meeste modules geeft de DO-pin HIGH boven zwart en LOW boven wit, afhankelijk van de drempel die je met de potentiometer instelt, en de led op het bordje brandt boven een wit oppervlak. De AO-pin geeft de ruwe analoge waarde: hoog boven zwart, laag boven wit. Alle details over de sensor vind je in TCRT5000 infraroodsensor.

SensorenPlaatsingAlgoritmeWanneer kiezen
2Aan weerszijden van de lijn; beide zien normaal witif-elseEerste poging, brede baan met zachte bochten
3De middelste boven de lijn, de buitenste aan de randen ervanif-else of eenvoudige PIDSchoolprojecten, wedstrijden op beginnersniveau
5Gelijkmatig verdeelde rij, de middelste boven de lijnPID (gewogen gemiddelde)Snel, soepel lijnvolgen
8Brede rij (zoals de QTR-8A)PID plus kruispuntdetectieWedstrijdbanen met scherpe bochten en kruispunten

Sensorplaatsing: hoogte, onderlinge afstand en afstand vooruit

Hoe goed je code ook is, de robot kan niet goed rijden als de sensoren op de verkeerde plek zitten. Monteer de sensorbalk vóór de wielas, evenwijdig aan de vloer en symmetrisch ten opzichte van de middellijn van de robot. Deze maten zijn een goed beginpunt:

  • Hoogte: Laat 3–5 mm tussen de onderkant van de sensor en de vloer. Pololu geeft 3 mm als optimale en 6 mm als maximaal aanbevolen afstand voor de QTR-8A-array. Hoger wordt het verschil tussen zwart en wit kleiner, zodat de robot de lijn mist.
  • Onderlinge afstand: Houd bij analoge arrays de afstand tussen twee sensoren tussen de helft en twee derde van de lijnbreedte; 10–13 mm werkt goed bij een lijn van 20 mm. Zo ligt de lijn meestal onder twee sensoren en wordt de positie vloeiend berekend.
  • Digitale opstelling met 3 sensoren: Zet de middelste sensor precies boven de lijn en de zijsensoren net buiten de randen; bij een lijn van 20 mm is dat ongeveer 18–22 mm hart op hart.
  • Afstand vooruit: Plaats de sensoren 4–8 cm vóór de wielas. Te dichtbij en de robot merkt bochten laat op; te ver en zelfs een kleine draai laat de sensoren flink uitzwaaien, waardoor de robot gaat wiebelen.
  • Omgevingslicht: Zonlicht en halogeenlampen bevatten ook infrarood licht. Als je de sensoren afschermt met een zwarte rand of tape, worden de metingen veel stabieler.
Een veelgemaakte fout is de sensoren scheef of te hoog monteren. Als de robot de lijn al in de eerste bocht kwijtraakt, controleer dan de sensorhoogte vóór je de code controleert: zelfs een paar millimeter kan de meetwaarden halveren. Glanzende isolatietape reflecteert ook infrarood, waardoor een zwarte lijn soms wit lijkt; gebruik mat tape of een afgedrukte lijn als dat kan.

Bedrading: Arduino Uno, ESP32 en Pico

De tabel hieronder komt precies overeen met de sensortest- en PID-sketches; de bedrading voor het if-else-voorbeeld met 3 sensoren staat in een eigen sectie. Nummer de sensoren van links naar rechts gezien vanaf de achterkant van de robot: de meest linkse sensor is nummer 1. Als motordriver gebruiken we een L298N; wat elke pin doet en hoe de H-brug werkt, wordt uitgebreid uitgelegd in Gelijkstroommotor aansturen met de L298N. De Pico heeft maar drie analoge ingangen, dus daarop gebruiken we sensoren 1, 3 en 5.

AansluitingArduino UnoESP32Raspberry Pi Pico
Sensor 1 (meest links) AOA0GPIO 36GP26
Sensor 2 AOA1GPIO 39-
Sensor 3 (midden) AOA2GPIO 34GP27
Sensor 4 AOA3GPIO 35-
Sensor 5 (meest rechts) AOA4GPIO 32GP28
Sensor VCC5V3V33V3
L298N ENA (snelheid linkermotor)D9GPIO 25GP15
L298N IN1, IN2D8, D7GPIO 26, 27GP14, GP13
L298N ENB (snelheid rechtermotor)D10GPIO 33GP10
L298N IN3, IN4D5, D4GPIO 18, 19GP11, GP12
Startknop (andere pootje naar GND)D2GPIO 23GP16
GNDGNDGNDGND (gedeeld met batterij en driver)
De minpool van de batterij, de GND van de motordriver en de GND van het board moeten allemaal met elkaar verbonden zijn; zonder gemeenschappelijke massa gedragen de motoren zich grillig. Voed de motoren nooit via de 5V-pin van het board. Voed de sensoren op de ESP32 en Pico vanaf 3V3: de AO-uitgang van een module op 5 V kan oplopen tot 5 V en de analoge ingangen van 3,3 V beschadigen.

De motordriver en batterij kiezen

De L298N is goedkoop en robuust, maar zijn bipolaire transistors slokken 1,5–3 V op: van een accupakket van 7,4 V komt maar ongeveer 5–5,5 V bij de motoren aan. Bij kleine, snelle robots werkt een TB6612FNG of DRV8833 op MOSFET-basis beter. Bij de TB6612FNG blijft de code hetzelfde: je sluit de aansluitingen ENA, IN1 en IN2 aan op PWMA, AIN1 en AIN2 (PWMB, BIN1 en BIN2 op kanaal B) en verbindt de STBY-pin met VCC. De DRV8833 heeft geen aparte snelheidspin (enable); het PWM-signaal gaat rechtstreeks naar de IN-pins, dus je moet de functie drive() aanpassen. Voor de voeding is twee 18650 li-ioncellen in serie de praktischste keuze: 8,4 V als ze vol zijn, 7,4 V nominaal, en ze leveren moeiteloos hoge stroom. 9V-blokbatterijen (PP3) kunnen de motorstroom niet aan en zijn snel leeg. Met de tool Batterijduur reken je uit hoe lang je batterij meegaat.

DriverMotorspanningStroom per kanaalSpanningsverliesOordeel
L298N5–35 V2 A1,5–3 VRobuust, maar groot en inefficiënt
TB6612FNG4,5–13,5 V1,2 A (3,2 A piek)Zeer laagBeste prijs-kwaliteit voor een lijnvolger
DRV88332,7–10,8 V1,5 A (2 A piek)Zeer laagKleine robots met N20-motoren
L9110S2,5–12 V0,8 ALaagAlleen lichte, langzame robots
Gele TT-gelijkstroommotor met tandwielkast en wiel
Gele TT-motor met tandwielkast en een wiel van 65 mm: de tandwielkast verlaagt het toerental en verhoogt het koppel; het is de meest gebruikte motor in lijnvolger- en robotautoprojecten.

Een snel snelheidsvoorbeeld: gele TT-motoren (1:48) draaien onbelast op 6 V met ongeveer 200 tpm. Een wiel van 65 mm heeft een omtrek van π × 65 ≈ 204 mm, dus de robot kan maximaal 200 × 0,204 ≈ 41 m per minuut afleggen, ofwel ongeveer 0,7 m per seconde. Dat is ruim voldoende voor de meeste schoolbanen; de echte uitdaging is de lijn niet kwijtraken bij die snelheid. Snellere robots gebruiken N20-micromotoren met tandwielkast en een licht chassis. Naarmate de batterijspanning daalt, draaien de motoren langzamer en lopen je afgestelde PID-waarden uit de pas; de batterijspanning meten met een spanningsdeler en de snelheid daarop afstemmen is een geavanceerde verbetering.

Stap 1: Test de sensoren en bepaal de drempelwaarde

Zoek eerst uit wat de sensoren zien voordat je de motoren aansluit. De onderstaande sketch print de ruwe analoge waarde van alle vijf de sensoren, gescheiden door tabs; open in de Arduino IDE Tools > Serial Plotter op 115200 baud en je ziet elke sensor als een eigen lijn. Beweeg de robot langzaam met de hand over de lijn en kijk hoe de waarden veranderen.

C++ (Arduino IDE)
1// 5 sensörün ham değerlerini okur / reads the raw values of 5 sensors
2const int N = 5;
3const int SENSOR[N] = {A0, A1, A2, A3, A4};   // A0 en solda / A0 is the leftmost
4
5void setup() {
6  Serial.begin(115200);
7}
8
9void loop() {
10  for (int i = 0; i < N; i++) {
11    Serial.print(analogRead(SENSOR[i]));
12    Serial.print(i < N - 1 ? '\t' : '\n');    // Serial Plotter için sekme / tabs for the Serial Plotter
13  }
14  delay(50);
15}

Bij 5 V geeft een gangbare TCRT5000-module 30–200 op een wit oppervlak en 600–1000 op een zwarte lijn, maar deze getallen veranderen met sensorhoogte, vloermateriaal en omgevingslicht. De eenvoudigste drempelwaarde is drempel = (witwaarde + zwartwaarde) / 2. Lees je bijvoorbeeld 80 op wit en 820 op zwart, dan is de drempel 450. Omdat elke sensor net anders meet, doet de PID-sketch dit automatisch: tijdens de kalibratie legt hij de laagste en hoogste waarde van elke sensor vast en schaalt dan elke meting naar een waarde tussen 0 (wit) en 1000 (zwart) met (meting − min) × 1000 / (max − min). Zo is de drempel voor elke sensor 500.

Bij modules met een digitale uitgang (DO) stel je de drempel in met de potentiometer op het bordje. Draai aan de trimmer zodat de led van de module uit blijft terwijl de sensor boven de zwarte lijn zit en aan gaat boven het witte oppervlak; de stand precies tussen die twee punten is het stabielst. Doe de afstelling op de baan waarop je gaat rijden en bij dezelfde verlichting.

Stap 2: Een eenvoudig if-else-algoritme (3 sensoren)

Voor een eerste werkende robot is de duidelijkste aanpak een keuze uit een paar vaste bewegingen op basis van de toestand van drie sensoren. Sluit de DO-uitgangen van een module met 3 kanalen aan op A0 (links), A1 (midden) en A2 (rechts); de analoge pins van de Uno werken ook als digitale ingang. De logica staat in deze tabel (1 betekent dat de sensor de lijn ziet):

LinksMiddenRechtsBetekenisActie
010Lijn in het middenRechtdoor
110Lijn iets naar linksLinkerwiel vertraagt, zachte bocht naar links
100Lijn ver naar linksLinkerwiel draait achteruit, scherpe bocht naar links
011Lijn iets naar rechtsRechterwiel vertraagt, zachte bocht naar rechts
001Lijn ver naar rechtsRechterwiel draait achteruit, scherpe bocht naar rechts
111Kruispunt of finishlijnRechtdoor oversteken
000Lijn kwijtDraaien naar de laatst geziene kant
C++ (Arduino IDE)
1// 3 sensörlü basit çizgi izleyen / simple 3-sensor line follower
2const int ENA = 9, IN1 = 8, IN2 = 7;      // sol motor / left motor
3const int ENB = 10, IN3 = 5, IN4 = 4;     // sağ motor / right motor
4const int S_LEFT = A0, S_MID = A1, S_RIGHT = A2;   // sensörlerin DO çıkışları / sensor DO outputs
5const bool WHITE_LINE = false;            // siyah zemin + beyaz çizgi ise true / true for a white line on black
6
7const int SPEED = 150;                    // düz gidiş hızı / straight-line speed
8const int SOFT = 80;                      // hafif dönüşte iç teker / inner wheel on a soft turn
9const int BACK = -90;                     // sert dönüşte iç teker geri / inner wheel reverses on a sharp turn
10int lastSide = 0;                         // -1 sol, 1 sağ / -1 left, 1 right
11
12void drive(int left, int right) {         // her biri -255 … 255 / each -255 … 255
13  left = constrain(left, -255, 255);
14  right = constrain(right, -255, 255);
15  digitalWrite(IN1, left >= 0);  digitalWrite(IN2, left < 0);
16  digitalWrite(IN3, right >= 0); digitalWrite(IN4, right < 0);
17  analogWrite(ENA, abs(left));
18  analogWrite(ENB, abs(right));
19}
20
21void setup() {
22  int outputs[] = {ENA, IN1, IN2, ENB, IN3, IN4};
23  for (int p : outputs) pinMode(p, OUTPUT);
24  pinMode(S_LEFT, INPUT);
25  pinMode(S_MID, INPUT);
26  pinMode(S_RIGHT, INPUT);
27}
28
29void loop() {
30  bool l = digitalRead(S_LEFT) != WHITE_LINE;    // true = sensör çizgide / true = sensor on the line
31  bool m = digitalRead(S_MID) != WHITE_LINE;
32  bool r = digitalRead(S_RIGHT) != WHITE_LINE;
33
34  if (m && !l && !r) {                    // tam ortada: düz git / centered: go straight
35    drive(SPEED, SPEED);
36  } else if (l && r) {                    // kavşak ya da bitiş çizgisi: düz geç / junction or finish line: go straight
37    drive(SPEED, SPEED);
38  } else if (l && m) {                    // çizgi biraz solda / line slightly to the left
39    drive(SOFT, SPEED);  lastSide = -1;
40  } else if (r && m) {                    // çizgi biraz sağda / line slightly to the right
41    drive(SPEED, SOFT);  lastSide = 1;
42  } else if (l) {                         // çizgi çok solda / line far to the left
43    drive(BACK, SPEED);  lastSide = -1;
44  } else if (r) {                         // çizgi çok sağda / line far to the right
45    drive(SPEED, BACK);  lastSide = 1;
46  } else {                                // çizgi kayıp: son görülen tarafa dön / line lost: turn to the last seen side
47    if (lastSide < 0)      drive(BACK, SPEED);
48    else if (lastSide > 0) drive(SPEED, BACK);
49    else                   drive(SOFT, SOFT);
50  }
51}

De variabele lastSide onthoudt aan welke kant de robot de lijn het laatst zag; als alle drie de sensoren de lijn in een scherpe bocht missen, draait de robot die kant op om hem terug te vinden in plaats van rechtdoor te dwalen. Met twee sensoren is dezelfde logica nog eenvoudiger: de sensoren zitten aan weerszijden van de lijn, de robot rijdt rechtdoor zolang beide wit zien, draait naar links als de linker zwart ziet en naar rechts als de rechter zwart ziet. De zwakte van deze methode is dat de bewegingen trapsgewijs zijn: de robot wisselt alleen tussen een paar vaste snelheden, dus hij zigzagt een beetje, zelfs op rechte stukken, en raakt in bochten van de baan zodra je de snelheid verhoogt.

Stap 3: Soepel lijnvolgen met PID

PID past een correctie toe die evenredig is met hoe ver de robot van de lijn is afgedreven. Eerst wordt de lijnpositie uit de vijf sensoren berekend als gewogen gemiddelde: de waarde 0–1000 van elke sensor wordt vermenigvuldigd met zijn eigen positie (0, 1000, 2000, 3000, 4000), de uitkomsten worden opgeteld en gedeeld door de som van de waarden. Het resultaat is een getal tussen 0 en 4000, en 2000 als de lijn precies in het midden ligt. Meten de sensoren bijvoorbeeld 0, 0, 300, 900, 0, dan is de positie (300 × 2000 + 900 × 3000) / 1200 = 2750. De fout = positie − 2000: een positieve waarde betekent dat de lijn rechts ligt, een negatieve dat hij links ligt.

De correctie is de som van drie termen: correctie = Kp × fout + Ki × som van fouten + Kd × (fout − vorige fout). De P-term stuurt harder bij naarmate de afwijking groter wordt. De D-term kijkt hoe snel de fout verandert en remt af als de robot de lijn nadert, waardoor de slingering gedempt wordt. De I-term corrigeert kleine fouten die lang aan één kant blijven, maar bij een lijnvolger laat je hem meestal op nul staan. Daarna draait de linkermotor op basissnelheid + correctie en de rechtermotor op basissnelheid − correctie. Bij een fout van 800 en Kp = 0.06 is de correctie bijvoorbeeld 48; bij een basissnelheid van 140 draait de linkermotor op 188 en de rechter op 92, en maakt de robot een vloeiende bocht naar rechts.

C++ (Arduino IDE)
1// PID çizgi izleyen: Arduino Uno + 5 analog sensör + L298N
2// PID line follower: Arduino Uno + 5 analog sensors + L298N
3const int ENA = 9, IN1 = 8, IN2 = 7;      // sol motor / left motor
4const int ENB = 10, IN3 = 5, IN4 = 4;     // sağ motor / right motor
5const int BUTTON = 2;                     // diğer bacağı GND'ye / other leg to GND
6const int N = 5;
7const int SENSOR[N] = {A0, A1, A2, A3, A4};   // A0 en solda / A0 is the leftmost
8const bool WHITE_LINE = false;            // siyah zemin + beyaz çizgi ise true / true for a white line on black
9const int CENTER = (N - 1) * 500;         // orta konum: 2000 / center position: 2000
10
11float Kp = 0.06, Ki = 0.0, Kd = 0.6;      // başlangıç değerleri / starting values
12int baseSpeed = 140;                      // düzlük hızı (0-255) / straight-line speed (0-255)
13const unsigned long PERIOD_MS = 5;        // sabit döngü süresi / fixed loop period
14
15int minVal[N], maxVal[N];
16int lastPosition = CENTER;
17float integral = 0, lastError = 0;
18unsigned long lastTime = 0;
19
20void drive(int left, int right) {         // her biri -255 … 255 / each -255 … 255
21  left = constrain(left, -255, 255);
22  right = constrain(right, -255, 255);
23  digitalWrite(IN1, left >= 0);  digitalWrite(IN2, left < 0);
24  digitalWrite(IN3, right >= 0); digitalWrite(IN4, right < 0);
25  analogWrite(ENA, abs(left));
26  analogWrite(ENB, abs(right));
27}
28
29void waitButton() {
30  while (digitalRead(BUTTON) == HIGH) {}  // basılmasını bekle / wait for a press
31  delay(30);
32  while (digitalRead(BUTTON) == LOW) {}   // bırakılmasını bekle / wait for the release
33  delay(30);
34}
35
36void calibrate() {                        // 5 sn: robotu çizginin üstünde sağa sola gezdir / 5 s: sweep the robot across the line
37  for (int i = 0; i < N; i++) { minVal[i] = 1023; maxVal[i] = 0; }
38  digitalWrite(LED_BUILTIN, HIGH);
39  unsigned long start = millis();
40  while (millis() - start < 5000) {
41    for (int i = 0; i < N; i++) {
42      int v = analogRead(SENSOR[i]);
43      if (v < minVal[i]) minVal[i] = v;
44      if (v > maxVal[i]) maxVal[i] = v;
45    }
46  }
47  digitalWrite(LED_BUILTIN, LOW);
48}
49
50int readPosition() {                      // 0 (en sol) … 4000 (en sağ) / 0 (leftmost) … 4000 (rightmost)
51  long sum = 0, weighted = 0;
52  bool onLine = false;
53  for (int i = 0; i < N; i++) {
54    int range = max(maxVal[i] - minVal[i], 1);
55    long v = (long)(analogRead(SENSOR[i]) - minVal[i]) * 1000 / range;
56    v = constrain(v, 0L, 1000L);          // 0 = beyaz, 1000 = siyah / 0 = white, 1000 = black
57    if (WHITE_LINE) v = 1000 - v;
58    if (v > 500) onLine = true;           // eşik: kalibrasyonun ortası / threshold: middle of the calibration
59    if (v > 50) {                         // küçük gürültüyü yok say / ignore small noise
60      weighted += v * (i * 1000L);
61      sum += v;
62    }
63  }
64  if (!onLine) {                          // çizgi kayıp: son görülen tarafa dön / line lost: turn to the last seen side
65    return (lastPosition < CENTER) ? 0 : (N - 1) * 1000;
66  }
67  lastPosition = weighted / sum;
68  return lastPosition;
69}
70
71void setup() {
72  int outputs[] = {ENA, IN1, IN2, ENB, IN3, IN4, LED_BUILTIN};
73  for (int p : outputs) pinMode(p, OUTPUT);
74  pinMode(BUTTON, INPUT_PULLUP);
75  drive(0, 0);
76  waitButton();                           // 1. basış: kalibrasyon / 1st press: calibration
77  calibrate();
78  waitButton();                           // 2. basış: yarış / 2nd press: race
79  lastTime = millis();
80}
81
82void loop() {
83  if (millis() - lastTime < PERIOD_MS) return;
84  lastTime += PERIOD_MS;
85
86  float error = readPosition() - CENTER;  // artı: çizgi sağda / positive: line is to the right
87  integral = constrain(integral + error, -20000.0f, 20000.0f);   // birikmeyi sınırla / anti-windup
88  float derivative = error - lastError;
89  lastError = error;
90
91  int correction = (int)(Kp * error + Ki * integral + Kd * derivative);
92  drive(baseSpeed + correction, baseSpeed - correction);
93}

Druk na het uploaden één keer op de knop: de led op het board brandt 5 seconden. Schuif de robot in die tijd een paar keer met de hand links en rechts over de lijn, zodat elke sensor zowel zwart als wit ziet. Als de led uitgaat, zet je de robot op de lijn en druk je nog een keer op de knop. De lus draait elke 5 ms met millis(); een vaste periode houdt de D-term steeds op dezelfde schaal. Als de lijn helemaal verdwijnt, geeft readPosition() 0 of 4000 terug, afhankelijk van aan welke kant hij het laatst werd gezien, en zoekt de robot hem met de scherpste draai. Voor de bedrading van de knop zie Een knop aansluiten op Arduino, en voor timing zonder delay zie Arduino millis() en delay().

Kp en Kd afstellen

  1. Houd de basissnelheid laag (bijvoorbeeld 100) en zet Ki en Kd op nul.
  2. Begin met een kleine Kp (0.02) en verhoog die stapsgewijs tot de robot de bochten aankan. Als de robot snel en regelmatig rond de lijn begint te slingeren, heb je de bovengrens van Kp bereikt; blijf een beetje onder die waarde.
  3. Begin met Kd op ongeveer 10 keer Kp en verhoog die tot de slingering uitdooft. Wordt Kd te groot, dan trilt de robot en janken de motoren.
  4. Zodra de robot kaarsrecht over rechte stukken rijdt en soepel door bochten gaat, verhoog je de basissnelheid met 10–20 en herhaal je stap 2 en 3.
  5. Probeer Ki alleen, met een heel kleine waarde (zoals 0.0001), als de robot op lange rechte stukken steeds naar één kant wegdrijft.
  6. Noteer de gevonden waarden en de batterijspanning op dat moment; naarmate de batterij leegloopt, gedragen dezelfde waarden zich anders.
Op de schaal die in dit artikel wordt gebruikt (positie 0–4000, PWM 0–255, lus van 5 ms) is een goed beginbereik 0.04–0.08 voor Kp en 0.4–1.2 voor Kd. Zet tijdens het afstellen geen Serial.print in de lus: elke print vertraagt de lus en verstoort de D-term. Als je waarden wilt zien, print ze dan hooguit eens per 200 ms.

Lijnvolger met de ESP32: stel de PID af vanaf je telefoon

Het grote voordeel van de ESP32 is dat je de PID-waarden vanaf je telefoon kunt aanpassen zonder elke keer de code opnieuw te uploaden. De logica is dezelfde als bij de Uno-versie; de verschillen zijn: de analoge ingang van de ESP32 is 12 bit (0–4095), de sensoren moeten op ADC1-pins, GPIO 32–39 (ADC2-pins kunnen niet worden uitgelezen terwijl Wi-Fi aan staat), en de sensoren worden gevoed met 3,3 V. analogWrite() werkt op zowel de 2.x- als de 3.x-versie van de ESP32 Arduino-core. Installeer een app zoals Serial Bluetooth Terminal op je Android-telefoon, maak verbinding met het apparaat "CizgiRobot" en stuur commando's als p0.07, d0.9 of s160; de robot gebruikt de nieuwe waarde meteen en stuurt hem terug als bevestiging. Klassieke Bluetooth bestaat alleen op de originele ESP32 (niet op de S3 of C3), en iPhones ondersteunen dit soort seriële verbinding niet. Ben je nieuw met de ESP32, lees dan eerst Wat is de ESP32?.

C++ (Arduino IDE)
1// ESP32 PID çizgi izleyen + Bluetooth ile canlı ayar
2// ESP32 PID line follower + live tuning over Bluetooth
3#include "BluetoothSerial.h"
4
5BluetoothSerial SerialBT;
6
7const int ENA = 25, IN1 = 26, IN2 = 27;   // sol motor / left motor
8const int ENB = 33, IN3 = 18, IN4 = 19;   // sağ motor / right motor
9const int BUTTON = 23;                    // diğer bacağı GND'ye / other leg to GND
10const int LED_PIN = 2;                    // DevKit üzerindeki LED / onboard LED on the DevKit
11const int N = 5;
12const int SENSOR[N] = {36, 39, 34, 35, 32};   // yalnız ADC1 pinleri / ADC1 pins only
13const bool WHITE_LINE = false;            // siyah zemin + beyaz çizgi ise true / true for a white line on black
14const int CENTER = (N - 1) * 500;
15
16float Kp = 0.06, Ki = 0.0, Kd = 0.6;
17int baseSpeed = 140;
18const unsigned long PERIOD_MS = 5;
19
20int minVal[N], maxVal[N];
21int lastPosition = CENTER;
22float integral = 0, lastError = 0;
23unsigned long lastTime = 0;
24
25void drive(int left, int right) {         // her biri -255 … 255 / each -255 … 255
26  left = constrain(left, -255, 255);
27  right = constrain(right, -255, 255);
28  digitalWrite(IN1, left >= 0);  digitalWrite(IN2, left < 0);
29  digitalWrite(IN3, right >= 0); digitalWrite(IN4, right < 0);
30  analogWrite(ENA, abs(left));
31  analogWrite(ENB, abs(right));
32}
33
34void waitButton() {
35  while (digitalRead(BUTTON) == HIGH) {}
36  delay(30);
37  while (digitalRead(BUTTON) == LOW) {}
38  delay(30);
39}
40
41void calibrate() {                        // ESP32 ADC 12 bit: 0-4095 / ESP32 ADC is 12-bit: 0-4095
42  for (int i = 0; i < N; i++) { minVal[i] = 4095; maxVal[i] = 0; }
43  digitalWrite(LED_PIN, HIGH);
44  unsigned long start = millis();
45  while (millis() - start < 5000) {
46    for (int i = 0; i < N; i++) {
47      int v = analogRead(SENSOR[i]);
48      if (v < minVal[i]) minVal[i] = v;
49      if (v > maxVal[i]) maxVal[i] = v;
50    }
51  }
52  digitalWrite(LED_PIN, LOW);
53}
54
55int readPosition() {
56  long sum = 0, weighted = 0;
57  bool onLine = false;
58  for (int i = 0; i < N; i++) {
59    int range = max(maxVal[i] - minVal[i], 1);
60    long v = (long)(analogRead(SENSOR[i]) - minVal[i]) * 1000 / range;
61    v = constrain(v, 0L, 1000L);
62    if (WHITE_LINE) v = 1000 - v;
63    if (v > 500) onLine = true;
64    if (v > 50) {
65      weighted += v * (i * 1000L);
66      sum += v;
67    }
68  }
69  if (!onLine) {
70    return (lastPosition < CENTER) ? 0 : (N - 1) * 1000;
71  }
72  lastPosition = weighted / sum;
73  return lastPosition;
74}
75
76void readTuning() {                       // telefondan "p0.07", "d0.9", "s160" gibi komutlar / commands like "p0.07", "d0.9", "s160" from the phone
77  if (!SerialBT.available()) return;
78  char cmd = SerialBT.read();
79  if (cmd != 'p' && cmd != 'i' && cmd != 'd' && cmd != 's') return;   // satır sonlarını atla / skip line endings
80  float value = SerialBT.parseFloat();
81  if (cmd == 'p') Kp = value;
82  if (cmd == 'i') { Ki = value; integral = 0; }
83  if (cmd == 'd') Kd = value;
84  if (cmd == 's') baseSpeed = (int)value;
85  SerialBT.printf("Kp=%.3f Ki=%.4f Kd=%.3f speed=%d\n", Kp, Ki, Kd, baseSpeed);
86}
87
88void setup() {
89  int outputs[] = {ENA, IN1, IN2, ENB, IN3, IN4, LED_PIN};
90  for (int p : outputs) pinMode(p, OUTPUT);
91  pinMode(BUTTON, INPUT_PULLUP);
92  drive(0, 0);
93  SerialBT.begin("CizgiRobot");           // telefonda görünecek ad / name shown on the phone
94  SerialBT.setTimeout(20);                // parseFloat robotu bekletmesin / keep parseFloat from blocking
95  waitButton();
96  calibrate();
97  waitButton();
98  lastTime = millis();
99}
100
101void loop() {
102  readTuning();
103  if (millis() - lastTime < PERIOD_MS) return;
104  lastTime += PERIOD_MS;
105
106  float error = readPosition() - CENTER;
107  integral = constrain(integral + error, -20000.0f, 20000.0f);
108  float derivative = error - lastError;
109  lastError = error;
110
111  int correction = (int)(Kp * error + Ki * integral + Kd * derivative);
112  drive(baseSpeed + correction, baseSpeed - correction);
113}
Sommige wedstrijdreglementen verbieden Wi-Fi-, Bluetooth- of RF-modules op de robot, of zelfs boards met Wi-Fi. De veiligste aanpak is de ESP32 te gebruiken om af te stellen en te oefenen en daarna mee te doen met een Arduino Uno, Nano of een Pico zonder Wi-Fi; als je het niet zeker weet, vraag het dan aan de organisatoren.

Lijnvolger met de Raspberry Pi Pico en MicroPython

De Pico heeft maar drie analoge ingangen die de gebruiker kan gebruiken (GP26, GP27, GP28), dus de onderstaande code werkt met drie analoge sensoren en berekent de positie tussen 0 en 2000. Wil je vijf sensoren, dan kun je een module met 5 kanalen en digitale uitgangen op vijf willekeurige GPIO's aansluiten en elke sensor als 0 of 1000 tellen; het gewogen gemiddelde wordt grover maar werkt nog steeds. read_u16() geeft een waarde van 0 tot 65535 terug en de motorsnelheid wordt als percentage opgegeven (van -100 tot 100). Voor de installatie en eerste stappen zie Wat is de Raspberry Pi Pico?.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4ena = PWM(Pin(15)); ena.freq(1000)        # sol motor hızı / left motor speed
5in1 = Pin(14, Pin.OUT); in2 = Pin(13, Pin.OUT)
6enb = PWM(Pin(10)); enb.freq(1000)        # sağ motor hızı / right motor speed
7in3 = Pin(11, Pin.OUT); in4 = Pin(12, Pin.OUT)
8button = Pin(16, Pin.IN, Pin.PULL_UP)     # diğer bacağı GND'ye / other leg to GND
9led = Pin("LED", Pin.OUT)
10sensors = [ADC(26), ADC(27), ADC(28)]     # sol, orta, sağ / left, middle, right
11WHITE_LINE = False                        # siyah zemin + beyaz çizgi ise True / True for a white line on black
12
13N = len(sensors)
14CENTER = (N - 1) * 500                    # orta konum: 1000 / center position: 1000
15Kp, Ki, Kd = 0.05, 0.0, 0.4
16BASE = 45                                 # taban hız (%) / base speed (%)
17min_val = [65535] * N
18max_val = [0] * N
19last_pos = CENTER
20
21def drive(left, right):                   # her biri -100 … 100 / each -100 … 100
22    left = max(-100, min(100, left))
23    right = max(-100, min(100, right))
24    in1.value(left >= 0); in2.value(left < 0)
25    in3.value(right >= 0); in4.value(right < 0)
26    ena.duty_u16(int(abs(left) * 655.35))
27    enb.duty_u16(int(abs(right) * 655.35))
28
29def wait_button():
30    while button.value():                 # basılmasını bekle / wait for a press
31        time.sleep_ms(10)
32    time.sleep_ms(30)
33    while not button.value():             # bırakılmasını bekle / wait for the release
34        time.sleep_ms(10)
35    time.sleep_ms(30)
36
37def calibrate():                          # 5 sn sağa sola gezdir / sweep for 5 s
38    led.on()
39    start = time.ticks_ms()
40    while time.ticks_diff(time.ticks_ms(), start) < 5000:
41        for i, s in enumerate(sensors):
42            v = s.read_u16()
43            min_val[i] = min(min_val[i], v)
44            max_val[i] = max(max_val[i], v)
45    led.off()
46
47def read_position():                      # 0 (sol) … 2000 (sağ) / 0 (left) … 2000 (right)
48    global last_pos
49    total = weighted = 0
50    on_line = False
51    for i, s in enumerate(sensors):
52        rng = max(1, max_val[i] - min_val[i])
53        v = max(0, min(1000, (s.read_u16() - min_val[i]) * 1000 // rng))
54        if WHITE_LINE:
55            v = 1000 - v
56        if v > 500:
57            on_line = True
58        if v > 50:
59            weighted += v * i * 1000
60            total += v
61    if not on_line:                       # çizgi kayıp / line lost
62        return 0 if last_pos < CENTER else (N - 1) * 1000
63    last_pos = weighted // total
64    return last_pos
65
66drive(0, 0)
67wait_button()                             # 1. basış: kalibrasyon / 1st press: calibration
68calibrate()
69wait_button()                             # 2. basış: yarış / 2nd press: race
70integral = 0
71last_error = 0
72while True:
73    t0 = time.ticks_ms()
74    error = read_position() - CENTER
75    integral = max(-10000, min(10000, integral + error))
76    correction = Kp * error + Ki * integral + Kd * (error - last_error)
77    last_error = error
78    drive(BASE + correction, BASE - correction)
79    while time.ticks_diff(time.ticks_ms(), t0) < 5:   # 5 ms sabit döngü / fixed 5 ms loop
80        pass

Wedstrijdregels en de baan

De regels voor lijnvolgerwedstrijden verschillen per organisator en per jaar, maar het basisidee is hetzelfde: de robot moet de baan in de kortst mogelijke tijd afleggen zonder de lijn te verlaten. In het reglement voor lijnvolgers op beginnersniveau van de Turkse nationale MEB Robot Competition uit 2024 is de baan bijvoorbeeld een witte lijn van 20 ± 2 mm op een zwarte achtergrond. De robot mag inclusief wielen maximaal 280 × 180 mm meten en inclusief batterijen maximaal 1 kg wegen; de werkspanning mag niet hoger zijn dan 12 V en hij moet twee L-vormige gelijkstroommotoren van 6–12 V met kunststof tandwielen gebruiken, wielen met een diameter van maximaal 65 mm en een sensorarray met hooguit 8 sensoren. De baan heeft een brug met een helling van 13 graden en een vierkant gedeelte waar dwars door het midden snijden 20 seconden strafijd kost; een robot waarvan het chassis volledig op de zwarte achtergrond belandt, geldt als van de baan, en een robot die langer dan 30 seconden stilstaat op de lijn wordt gediskwalificeerd. Andere school- en regionale wedstrijden gebruiken het tegenovergestelde, een zwarte lijn van 20 ± 2 mm op een witte achtergrond, en vragen om kleinere robots van maximaal 500 gram. Kortom: lees altijd het reglement van dat jaar voordat je je robot ontwerpt.

  • Omgekeerde baan: Zet voor een witte lijn op een zwarte achtergrond de variabele WHITE_LINE in de sketches op true. Wisselen de kleuren binnen de baan, dan kun je een controle toevoegen die van modus wisselt wanneer de buitenste sensoren zwart gaan zien en de middelste wit.
  • Bochten van 90 graden: Verlaag de basissnelheid vóór de bocht of laat het binnenste wiel achteruit draaien; in de sketches in dit artikel draait het binnenste wiel al achteruit wanneer de correctie groter is dan de basissnelheid.
  • Kruispunten: Als alle sensoren tegelijk de lijn zien, ga je rechtdoor; moet je een richting kiezen, bouw dan een toestandsmachine die de kruispunten telt.
  • Onderbroken lijnen: Als de lijn even verdwijnt, probeer dan 100–200 ms rechtdoor te rijden in plaats van meteen te draaien.
  • Hellingen en bruggen: Op een helling verandert de afstand tussen sensor en vloer; houd de sensorbalk laag en dicht bij de wielen en rem op de helling een beetje af.
  • Oefenbaan: Plak mat zwarte isolatietape van 19 mm op wit mat karton of schuimplaat; maak bij je eerste pogingen geen bochten die krapper zijn dan een straal van 15 cm.

Veelvoorkomende problemen en oplossingen

ProbleemWaarschijnlijke oorzaakOplossing
Robot zigzagt op rechte stukkenKp te hoog, Kd te laag of snelheid te hoogVerlaag Kp met ongeveer 20%, verhoog Kd; verlaag zo nodig de basissnelheid
Raakt in bochten van de baanSnelheid te hoog, sensorarray te smal of verkeerde reactie als de lijn kwijt isVerlaag de basissnelheid, laat het binnenste wiel achteruit draaien, draai naar de laatst geziene kant als de lijn kwijt is
Robot trekt steeds naar één kantMotoren draaien met verschillende snelheden of de sensorbalk is niet gecentreerdCentreer de sensoren, schaal de snellere motor omlaag met een kleine factor (bijvoorbeeld 0.95)
Sensoren zien overal zwart of witGeen kalibratie, sensor te hoog of trimmer niet ingesteldVerlaag de hoogte naar 3–5 mm, herhaal de kalibratie op de baan
Arduino reset als de motoren startenBatterijspanning zakt even in of de gemeenschappelijke GND is slechtVoed het board apart of voeg een condensator van 470 µF toe aan de voeding, kort de draden in
Robot gedraagt zich anders naarmate de batterij leeglooptMotorsnelheid daalt met de spanningMeet de batterijspanning en schaal de snelheid, of plaats voor elke rit een volle batterij
Werkt thuis, mislukt op de wedstrijdlocatieOmgevingslicht of een glanzende vloer verstoort het infraroodSchermt de sensoren af met een zwarte rand, kalibreer onder de wedstrijdverlichting
De snelste manier om een probleem in te kaderen is de wielen van de grond te tillen en de robot met de hand over de lijn te bewegen: als de wielen in de goede richting sneller gaan draaien, zijn de sensoren en de code in orde en zit het probleem in de mechaniek of de voeding. Voor een uitgebreide diagnose van resetproblemen zie Arduino blijft resetten.

Volgende stappen en projectideeën

  • Lijnvolger die obstakels ontwijkt: Voeg vooraan een HC-SR04 toe zodat de robot om obstakels op de baan heen rijdt; de beslislogica staat in Robot die obstakels ontwijkt.
  • Bluetooth-modus: Schakel met een knop van lijnvolgen naar bediening met je telefoon; dat is makkelijk toe te voegen met de HC-05 Bluetooth-module.
  • Rondetijdmeter: Een robot die de startlijn detecteert en de rondetijd toont op een OLED-display.
  • Doolhofoplosser: Een robot die de kruispunten telt en onthoudt en in zijn tweede ronde het kortste pad volgt.
  • Magazijnrobot: Een klein AGV-model dat bij stations langs de lijn stopt en met een servo een lading laat vallen.
  • Een stevige basis: Heb je het chassis, de motoren en de batterij nog niet gemonteerd, begin dan met de gids Arduino-robotauto.

Een lijnvolgerrobot leert je tegelijk over sensoren, algoritmen, motoren en voeding, en hij wordt met elke afstelronde iets sneller. Krijg de robot eerst aan het rijden met de eenvoudige if-else-versie, stap dan over op PID en stel de waarden geduldig af. Ben je benieuwd hoe PWM de motorsnelheid instelt, dan is Wat is PWM? een goede volgende lezing. In de BlueGrays-app vind je de projecten voor TCRT5000-detectie van zwarte en witte oppervlakken, de met Bluetooth bestuurde L298N-auto en de robot die obstakels ontwijkt stap voor stap, met schakelschema's en code.

Veelgestelde vragen

Hoeveel sensoren heeft een lijnvolgerrobot nodig?

Twee sensoren zijn genoeg voor een werkende robot, maar drie geven veel stabielere resultaten met een eenvoudige if-else-sketch. Voor soepel, snel lijnvolgen worden 5 of 8 analoge sensoren met PID aanbevolen. Veel wedstrijden staan maximaal 8 sensoren toe.

Waarom zigzagt mijn lijnvolgerrobot?

De meest voorkomende reden is een te hoge Kp en een te lage Kd: de robot corrigeert elke afwijking te sterk en schiet over naar de andere kant van de lijn. Een iets lagere Kp, een hogere Kd, een lagere basissnelheid en de sensoren 4–8 cm vóór de wielen plaatsen verminderen allemaal de slingering. Met eenvoudige if-else-code is een lichte zigzag normaal, omdat de robot wisselt tussen een paar vaste snelheden.

Kun je een lijnvolger bouwen zonder PID?

Ja. Met een eenvoudige if-else-sketch en 2 of 3 sensoren volgt de robot de lijn, en dat is voor schoolprojecten vaak genoeg. Naarmate de snelheid toeneemt, mist de robot de lijn echter in bochten en wiebelt hij op rechte stukken. Als je op een goede plek in een wedstrijd mikt, moet je overstappen op PID.

Welke batterij is het best voor een lijnvolgerrobot?

De praktischste optie is twee 18650 li-ioncellen in serie: ze geven nominaal 7,4 V en leveren makkelijk de hoge stroom die de motoren vragen. Lichte robots gebruiken ook een 2S-LiPo-pakket. Een 9V-blokbatterij (PP3) kan de motorstroom niet leveren en is snel leeg.

Hoe pas ik de code aan voor een witte lijn op een zwarte achtergrond?

Je hoeft alleen de sensorwaarden om te keren: in de sketches in dit artikel zorgt WHITE_LINE op true ervoor dat de genormaliseerde waarde 1000 − waarde wordt, zodat de robot de witte lijn volgt. Bij digitale modules keert dezelfde variabele de DO-meting om. Je moet nog steeds kalibreren op de baan waarop je gaat rijden.

Hoe hoog moet de TCRT5000-sensor boven de vloer zitten?

De TCRT5000 werkt het best op ongeveer 2,5 mm; in de praktijk geeft 3–5 mm tussen sensor en vloer goede resultaten. Boven 1 cm wordt het verschil tussen zwart en wit veel kleiner en mist de robot de lijn. Op banen met hellingen beperkt het dicht bij de wielen houden van de sensorbalk hoeveel de afstand verandert.

Alle projecten bekijken
Zwart-wit ondergrond herkennen met TCRT5000
AR-78Gemiddeld
Premium

Zwart-wit ondergrond herkennen met TCRT5000

Met de kleine sensor die de ogen van lijnvolgrobots vormt, merk je of de ondergrond zwart of wit is.

4.7(40)
49
Reflectie (nabijheid) meten met de TCRT5000
AR-77Gemiddeld
Premium

Reflectie (nabijheid) meten met de TCRT5000

Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

4.6(33)
43
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
252
ESP32-led dimmen met PWM
ES-8Beginner

ESP32-led dimmen met PWM

De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

4.8(36)
55
Raspberry Pi Pico PWM-led-fade (ademeffect)
PI-14Beginner

Raspberry Pi Pico PWM-led-fade (ademeffect)

De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

4