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.

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.
| Onderdeel | Aanbevolen | Opmerking |
|---|---|---|
| Controllerboard | Arduino Uno of Nano | De Nano past makkelijker op een klein chassis; een ESP32 of Pico werkt ook |
| Lijnsensor | TCRT5000-array met 3 of 5 kanalen, QTR-8A | Een array met analoge uitgangen geeft betere resultaten met PID |
| Motordriver | L298N of TB6612FNG | De TB6612FNG is kleiner en efficiënter |
| Motoren | 2 gelijkstroommotoren met tandwielkast (TT 1:48 of N20) | Beide motoren moeten hetzelfde model en dezelfde snelheid hebben |
| Wielen | 2 aandrijfwielen en 1 zwenkwiel | Wielen van 65 mm zijn het meest gebruikelijk |
| Voeding | 2 × 18650 li-ioncellen (7,4 V) en een schakelaar | Een 9V-blokbatterij (PP3) is te zwak voor motoren |
| Overig | Chassis, drukknop, jumperdraden | Met een knop kalibreer en start je makkelijker |




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.
| Sensoren | Plaatsing | Algoritme | Wanneer kiezen |
|---|---|---|---|
| 2 | Aan weerszijden van de lijn; beide zien normaal wit | if-else | Eerste poging, brede baan met zachte bochten |
| 3 | De middelste boven de lijn, de buitenste aan de randen ervan | if-else of eenvoudige PID | Schoolprojecten, wedstrijden op beginnersniveau |
| 5 | Gelijkmatig verdeelde rij, de middelste boven de lijn | PID (gewogen gemiddelde) | Snel, soepel lijnvolgen |
| 8 | Brede rij (zoals de QTR-8A) | PID plus kruispuntdetectie | Wedstrijdbanen 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.
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.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Sensor 1 (meest links) AO | A0 | GPIO 36 | GP26 |
| Sensor 2 AO | A1 | GPIO 39 | - |
| Sensor 3 (midden) AO | A2 | GPIO 34 | GP27 |
| Sensor 4 AO | A3 | GPIO 35 | - |
| Sensor 5 (meest rechts) AO | A4 | GPIO 32 | GP28 |
| Sensor VCC | 5V | 3V3 | 3V3 |
| L298N ENA (snelheid linkermotor) | D9 | GPIO 25 | GP15 |
| L298N IN1, IN2 | D8, D7 | GPIO 26, 27 | GP14, GP13 |
| L298N ENB (snelheid rechtermotor) | D10 | GPIO 33 | GP10 |
| L298N IN3, IN4 | D5, D4 | GPIO 18, 19 | GP11, GP12 |
| Startknop (andere pootje naar GND) | D2 | GPIO 23 | GP16 |
| GND | GND | GND | GND (gedeeld met batterij en driver) |
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.
| Driver | Motorspanning | Stroom per kanaal | Spanningsverlies | Oordeel |
|---|---|---|---|---|
| L298N | 5–35 V | 2 A | 1,5–3 V | Robuust, maar groot en inefficiënt |
| TB6612FNG | 4,5–13,5 V | 1,2 A (3,2 A piek) | Zeer laag | Beste prijs-kwaliteit voor een lijnvolger |
| DRV8833 | 2,7–10,8 V | 1,5 A (2 A piek) | Zeer laag | Kleine robots met N20-motoren |
| L9110S | 2,5–12 V | 0,8 A | Laag | Alleen lichte, langzame robots |

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.
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.
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):
| Links | Midden | Rechts | Betekenis | Actie |
|---|---|---|---|---|
| 0 | 1 | 0 | Lijn in het midden | Rechtdoor |
| 1 | 1 | 0 | Lijn iets naar links | Linkerwiel vertraagt, zachte bocht naar links |
| 1 | 0 | 0 | Lijn ver naar links | Linkerwiel draait achteruit, scherpe bocht naar links |
| 0 | 1 | 1 | Lijn iets naar rechts | Rechterwiel vertraagt, zachte bocht naar rechts |
| 0 | 0 | 1 | Lijn ver naar rechts | Rechterwiel draait achteruit, scherpe bocht naar rechts |
| 1 | 1 | 1 | Kruispunt of finishlijn | Rechtdoor oversteken |
| 0 | 0 | 0 | Lijn kwijt | Draaien naar de laatst geziene kant |
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.
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
- Houd de basissnelheid laag (bijvoorbeeld 100) en zet Ki en Kd op nul.
- 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.
- 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.
- 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.
- Probeer Ki alleen, met een heel kleine waarde (zoals 0.0001), als de robot op lange rechte stukken steeds naar één kant wegdrijft.
- Noteer de gevonden waarden en de batterijspanning op dat moment; naarmate de batterij leegloopt, gedragen dezelfde waarden zich anders.
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?.
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}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?.
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 passWedstrijdregels 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
| Probleem | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Robot zigzagt op rechte stukken | Kp te hoog, Kd te laag of snelheid te hoog | Verlaag Kp met ongeveer 20%, verhoog Kd; verlaag zo nodig de basissnelheid |
| Raakt in bochten van de baan | Snelheid te hoog, sensorarray te smal of verkeerde reactie als de lijn kwijt is | Verlaag de basissnelheid, laat het binnenste wiel achteruit draaien, draai naar de laatst geziene kant als de lijn kwijt is |
| Robot trekt steeds naar één kant | Motoren draaien met verschillende snelheden of de sensorbalk is niet gecentreerd | Centreer de sensoren, schaal de snellere motor omlaag met een kleine factor (bijvoorbeeld 0.95) |
| Sensoren zien overal zwart of wit | Geen kalibratie, sensor te hoog of trimmer niet ingesteld | Verlaag de hoogte naar 3–5 mm, herhaal de kalibratie op de baan |
| Arduino reset als de motoren starten | Batterijspanning zakt even in of de gemeenschappelijke GND is slecht | Voed 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 leegloopt | Motorsnelheid daalt met de spanning | Meet de batterijspanning en schaal de snelheid, of plaats voor elke rit een volle batterij |
| Werkt thuis, mislukt op de wedstrijdlocatie | Omgevingslicht of een glanzende vloer verstoort het infrarood | Schermt de sensoren af met een zwarte rand, kalibreer onder de wedstrijdverlichting |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

Reflectie (nabijheid) meten met de TCRT5000
Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

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…

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.

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.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

