Een Arduino-robotauto bouwen: Bluetooth-besturing stap voor stap
Bouw stap voor stap een Arduino-robotauto: onderdelen en kosten, bedrading van L298N en HC-05, 18650-cellen, rijcode, bediening met je telefoon en oplossingen voor afwijkend rijden en resets.
Een Arduino-auto bouwen is een van de leukste manieren om elektronica en programmeren in één project te leren. Met twee gelijkstroommotoren met reductie, een L298N-motordriver, twee 18650-cellen, een HC-05 Bluetooth-module en een Arduino Uno bouw je in één weekend een robotauto die je met je telefoon bestuurt. Onderweg ontdek je zelf waarom je motoren niet rechtstreeks op een Arduino kunt aansluiten, waarom de keuze van de batterij zo belangrijk is en hoe een paar regels code een echt voertuig laten rijden.
In deze gids bouwen we samen een robotauto met 2WD (twee motoren) van begin tot eind: onderdelenlijst en kostenoverzicht, montage van het chassis, bedradingstabellen, code voor vooruit, achteruit en bochten en Bluetooth-besturing met je telefoon. De twee problemen waar beginners het vaakst mee worstelen, de auto rijdt niet recht en de Arduino reset zodra de motoren starten, krijgen elk een eigen onderdeel met gemeten, praktische oplossingen. In de laatste delen lees je hoe je dezelfde auto aanstuurt met een ESP32 of een Raspberry Pi Pico en hoe je hem verandert in een robot die obstakels ontwijkt of een lijn volgt.




Hoe werkt een Arduino-robotauto?
Je kunt een robotauto in vier delen opsplitsen. De Arduino is het brein: hij leest het commando van de telefoon en bepaalt welke motor in welke richting en hoe snel draait. De L298N-motordriver is de spierkracht: hij maakt van de zwakke 5 V-signalen van de Arduino de hoge stroom die de motoren nodig hebben. De reductiemotoren laten de wielen draaien en het batterijpakket voedt alles. Deze auto's hebben geen stuur; ze draaien door de twee wielen met verschillende snelheden of in verschillende richtingen te laten draaien. Dit heet differentiële aandrijving: als het linkerwiel vooruit draait en het rechterwiel achteruit, draait de auto ter plekke naar rechts. Een klein, vrij zwenkend zwenkwiel voor of achter houdt de auto in balans.

| Eigenschap | Gele TT-motor (1:48) |
|---|---|
| Werkspanning | 3–6 V |
| Overbrengingsverhouding | 1:48 (plastic tandwielen) |
| Toerental zonder belasting | Ongeveer 90–120 RPM bij 3 V, 200–250 RPM bij 6 V |
| Stroom zonder belasting | Ongeveer 150–160 mA |
| Blokkeerstroom | Ongeveer 1,1–1,5 A |
| Wieldiameter (in sets) | 65 mm |
| Snelheid van de auto bij 6 V | Ongeveer 0,7 m/s (π × 0,065 m × 200 / 60) |
De belangrijkste rij in de tabel is de blokkeerstroom: als een wiel tegen een obstakel duwt of de auto optrekt, trekt elke motor kortstondig meer dan 1 ampère. Een Arduino-pin kan hooguit 20–40 mA leveren, dus motoren sluit je altijd aan via een driver. Bij dit werk verliest de L298N ongeveer 1,5–2,5 V; met een batterijpakket van 7,4 V blijft er dan 5–6 V over voor de motoren, precies het ideale bereik voor TT-motoren. De werking van de driver en het H-brugprincipe leggen we uitgebreid uit in Gelijkstroommotor aansturen met de L298N.
Onderdelenlijst
| Onderdeel | Aantal | Opmerking |
|---|---|---|
| 2WD-chassisset van acryl voor een robotauto | 1 | Bevat meestal 2 TT-motoren, 2 wielen, een zwenkwiel, een schakelaar, motorbeugels en schroeven |
| Arduino Uno R3 (een kloon is prima) + USB-kabel | 1 | Een Nano werkt ook; de pinnummers zijn hetzelfde |
| L298N-motordrivermodule | 1 | 2 A per kanaal; stuurt twee motoren onafhankelijk aan |
| HC-05- of HC-06-Bluetooth-module | 1 | Voor communicatie met een Android-telefoon |
| 18650 Li-ion-cel | 2 | Merkcellen die minstens 5 A kunnen leveren |
| Batterijhouder voor 2 18650-cellen (in serie) | 1 | Schakelt de twee cellen in serie voor 7,4 V |
| 18650-lader | 1 | Een lader die elke cel apart oplaadt |
| Jumperdraden (male-female en female-female) | 20+ | Tussen de Arduino, de L298N en de HC-05 |
| Weerstanden van 1 kΩ en 2 kΩ | 1 + 1 | Spanningsdeler voor de RXD-ingang van de HC-05 |
| Keramische condensator van 100 nF | 2–4 | Over de motoraansluitingen, om ruis te onderdrukken |
| Elco van 470–1000 µF (16 V of hoger) | 1 | Aanbevolen; op de voedingsingang van de L298N |
| Kabelbinders, dubbelzijdig plakband, M3-afstandhouders | Een paar | Om de boards en draden vast te zetten |
De meeste chassissets bevatten ook een batterijhouder voor 4 AA-batterijen; zoals je zo ziet, is die houder te zwak in combinatie met de L298N, en daarom staan er 18650-cellen op de lijst. De HC-06 is de eenvoudigere broer van de HC-05 en werkt alleen als slave; voor het besturen van een auto met je telefoon is hij prima. De plastic schijfjes met sleuven in de set zijn encoderschijfjes voor een snelheidssensor, waarmee je de auto later perfect recht kunt laten rijden; gooi ze niet weg, leg ze voorlopig apart.
Kosten: waar gaat het budget naartoe?
Prijzen veranderen voortdurend, afhankelijk van de verkoper en de wisselkoers, dus we noemen geen bedragen; we laten wel zien welke onderdelen het budget opslokken en waar je kunt besparen. De vuistregel: elektronische modules (L298N, HC-05, weerstanden) zijn goedkoop, terwijl het grootste deel van het budget naar het board, de chassisset en vooral de batterijen en de lader gaat. Op de batterij kun je het slechtst bezuinigen: goede 18650-cellen kun je honderden keren opladen en hergebruiken in elk robotproject dat je daarna bouwt.
| Onderdeel | Prijsniveau | Besparingstip |
|---|---|---|
| Chassisset (motoren en wielen inbegrepen) | Gemiddeld | Een set is meestal goedkoper dan motoren, wielen en zwenkwiel los kopen |
| Arduino Uno | Gemiddeld (kloon) – hoog (origineel) | Een kloonboard is prima om mee te leren; je kunt ook de Uno of Nano gebruiken die je al hebt |
| L298N-motordriver | Laag | Eén module stuurt twee motoren aan; één is ook genoeg voor 4WD |
| HC-05 / HC-06 | Laag – gemiddeld | Als je alleen met een telefoon rijdt, is een HC-06 genoeg |
| 2× 18650-cellen + lader | Grootste post | Zeer goedkope cellen met het opschrift "9900 mAh" zijn meestal nep; bespaar hier niet |
| Draden, weerstanden, condensatoren, schroeven | Laag | Het meeste hiervan zit al in starterssets |
2WD of 4WD?
| Eigenschap | 2WD (2 motoren + zwenkwiel) | 4WD (4 motoren) |
|---|---|---|
| Draaien | Draait ter plekke, scherp en gemakkelijk | Draait door de wielen zijwaarts te laten slippen (skid steer); heeft moeite op tapijt |
| Stroomverbruik | Ongeveer 0,3–0,6 A tijdens het rijden | Ongeveer twee keer zoveel |
| Batterijduur | Langer | Korter |
| Ruw terrein | Het zwenkwiel kan achter randjes blijven haken | Betere grip |
| Rechtuit rijden | Het zwenkwiel kan de auto uit koers duwen als het zwenkt | Stabieler |
| Aansluiting op de L298N | Elke motor op een eigen kanaal | De twee motoren aan elke kant parallel op één kanaal |
| Het beste voor | Een eerste auto, een lijnvolgrobot | Buiten, zwaardere lading |
Voor je eerste auto raden we 2WD aan: het is goedkoper, verbruikt minder stroom, draait gemakkelijk ter plekke en past beter bij vervolgprojecten zoals een lijnvolgrobot. Bouw je een 4WD-auto, sluit dan de twee motoren aan elke kant parallel aan op dezelfde OUT-aansluitingen en controleer dat beide in dezelfde richting draaien. Eén L298N-kanaal voert dan de stroom van twee motoren; bij normaal rijden is dat prima, maar als de wielen vastlopen kan de limiet van 2 A per kanaal worden overschreden en schakelt de thermische beveiliging van de driver de motoren uit.
Voeding: waarom twee 18650-cellen?
De meeste problemen met robotauto's komen door de verkeerde batterij. De juiste bron moet aan twee voorwaarden tegelijk voldoen: hij moet na het verlies in de L298N genoeg spanning overlaten voor de motoren, en hij mag niet instorten wanneer de motoren bij het starten ampères trekken. Twee 18650 Li-ion-cellen in serie (2S) geven 8,4 V als ze vol zijn en gemiddeld 7,4 V, en leveren makkelijk meerdere ampères. De Arduino Uno raadt 7–12 V aan op de VIN-ingang, dus hetzelfde pakket kan zowel de motoren als de Arduino voeden. Met cellen van 2500 mAh en een 2WD-auto die tijdens het rijden gemiddeld 0,8 A verbruikt (motoren plus boards), rijdt de auto in theorie ongeveer 3 uur; omdat je het pakket nooit helemaal leegtrekt, is 2–2,5 uur realistischer. Reken met je eigen waarden via de tool Batterijduur.

| Voedingsbron | Spanning | Stroomlevering | Voor een robotauto |
|---|---|---|---|
| 9V-PP3-batterij | 9 V | Zeer laag | Niet geschikt; de meest voorkomende oorzaak van resets |
| 4× AA alkaline | 6 V (zakt snel onder belasting) | Gemiddeld | Zwak; na de L298N komt er maar ongeveer 4 V bij de motoren aan |
| 4× AA NiMH (oplaadbaar) | 4,8 V | Goed | Te weinig spanning met de L298N |
| 2× 18650 Li-ion (2S) | 7,4 V (8,4 V vol) | Hoog (meerdere ampères) | Beste keuze |
| 3× 18650 Li-ion (3S) | 11,1 V (12,6 V vol) | Hoog | Te veel voor TT-motoren; overschrijdt de limiet van 12 V van de 5V-jumper |
| USB-powerbank | 5 V | Goed | Alleen om de Arduino apart te voeden |
In plaats van te gokken hoeveel lading er nog is, kun je het meten. Sluit de plus van de batterij (na de schakelaar) via een spanningsdeler van twee weerstanden van 10 kΩ aan op A0: een pakket van 8,4 V verschijnt als 4,2 V op A0, onder de meetgrens van 5 V van de Arduino. De deler trekt maar ongeveer 0,4 mA, dus hij heeft geen invloed op de batterijduur.
1// Pil + (anahtardan sonra) → 10 kΩ → A0 → 10 kΩ → GND / battery + (after the switch) → 10 kΩ → A0 → 10 kΩ → GND
2const float DIVIDER = 2.0; // iki eşit direnç gerilimi yarıya böler / two equal resistors halve the voltage
3
4void setup() {
5 Serial.begin(9600);
6}
7
8void loop() {
9 float v = analogRead(A0) * 5.0 / 1023.0 * DIVIDER;
10 Serial.print(F("Pil / Battery: "));
11 Serial.print(v, 2);
12 Serial.println(F(" V"));
13 if (v < 6.6) Serial.println(F("Sarj et / Charge now")); // hücre başına 3,3 V / 3.3 V per cell
14 delay(1000);
15}Montage stap voor stap
- Trek het beschermpapier van de acryldelen. Als de motoren zonder draden kwamen, soldeer dan twee draden aan elke motor en versterk de soldeerverbindingen met hete lijm; een motordraad die door trillingen losbreekt, is de meest voorkomende storing.
- Zet de motoren vast aan de onderkant van het chassis met de T-vormige acrylbeugels en de lange M3-schroeven uit de set. De twee motorassen moeten op één lijn liggen en de draadaansluitingen van de motoren moeten naar binnen wijzen.
- Als je de encoderschijfjes wilt gebruiken, monteer ze dan nu aan de binnenkant van de motoras; als de wielen er eenmaal op zitten, is dat lastig.
- Monteer het zwenkwiel met afstandhouders midden op het andere uiteinde van het chassis. Kies een hoogte van de afstandhouders waarbij het chassis evenwijdig aan de vloer blijft.
- Duw de wielen helemaal op de as en lijn ze uit met de D-vormige as; een los wiel zorgt ervoor dat de auto voortdurend afwijkt.
- Plaats de batterijhouder met dubbelzijdig plakband of klittenband op een plek waar het gewicht dicht bij de wielas zit. Als het meeste gewicht op het zwenkwiel rust, gaan de aandrijfwielen slippen.
- Monteer de Arduino en de L298N met plastic afstandhouders op het bovendek. Je moet gemakkelijk bij de USB-poort van de Arduino kunnen en de koelplaat van de L298N moet in de open lucht zitten; zorg dat metalen schroeven de soldeerverbindingen onder de boards niet raken.
- Schakel de schakelaar in serie met de positieve draad van de batterij, zodat je de auto kunt aan- en uitzetten zonder de cellen te verwijderen.
- Draai de twee draden van elke motor naar de L298N in elkaar, houd alle draden kort en bundel ze met kabelbinders. Controleer voordat je de cellen plaatst met een multimeter dat er geen kortsluiting is tussen de batterijpolen.
Bedradingsschema
Zie de bedrading als twee delen: de voedingskant (batterij, schakelaar, L298N, motoren) en de signaalkant (de dunne draden van de Arduino naar de L298N en de HC-05). Verwijder de kleine jumpers op de pins ENA en ENB van de L298N; deze pins sluiten we aan op de PWM-uitgangen van de Arduino om de snelheid in code in te stellen. Laat de 5V-jumper van de L298N zitten: omdat het pakket onder 12 V blijft, voedt de eigen regelaar van het board de logica van de driver.

| L298N-aansluiting | Aansluiting |
|---|---|
| OUT1, OUT2 | Linkermotor (bij 4WD de twee linkermotoren parallel) |
| OUT3, OUT4 | Rechtermotor (bij 4WD de twee rechtermotoren parallel) |
| 12V | Batterij plus via de schakelaar |
| GND | Batterij min en de GND-pin van de Arduino (gemeenschappelijke massa) |
| 5V | Blijft onaangesloten bij de Arduino Uno; voedt bij de ESP32 en de Pico het board |
| 5V-jumper | Blijft zitten (batterij onder 12 V) |
| ENA- en ENB-jumpers | Verwijderd; de pins gaan naar de PWM-uitgangen van de Arduino |
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (snelheid linkermotor) | D5 (PWM) | GPIO 25 | GP15 |
| L298N IN1 | D7 | GPIO 27 | GP14 |
| L298N IN2 | D8 | GPIO 33 | GP13 |
| L298N ENB (snelheid rechtermotor) | D6 (PWM) | GPIO 26 | GP10 |
| L298N IN3 | D9 | GPIO 32 | GP12 |
| L298N IN4 | D4 | GPIO 4 | GP11 |
| HC-05 TXD | D10 (SoftwareSerial RX) | Niet nodig (ingebouwde Bluetooth) | GP1 (UART0 RX) |
| HC-05 RXD | D11, via een 1 kΩ / 2 kΩ-deler | Niet nodig | GP0 (UART0 TX), rechtstreeks |
| HC-05 VCC | 5V | Niet nodig | 5V-uitgang van de L298N |
| Voeding van het board | VIN ← batterij plus na de schakelaar | 5V (VIN) ← 5V-uitgang van de L298N | VSYS ← 5V-uitgang van de L298N |
| GND | Gedeeld met GND van de L298N en batterij min | Gedeeld | Gedeeld |
We hebben D5 en D6 bewust als snelheidspins gekozen. Op de Uno schakelt de Servo-bibliotheek PWM uit op pin 9 en 10, en de functie tone() doet dat op pin 3 en 11. Met ENA en ENB op 5 en 6 blijft je motorsnelheidsregeling werken als je later een servo of buzzer toevoegt. D2 en D3 zijn gereserveerd voor encoders, omdat ze interrupts ondersteunen. De pinindeling van je board zie je in de tool Pinout.
Eerste sketch: vooruit, achteruit, links en rechts
Voordat we verdergaan met Bluetooth testen we de motoren en de bedrading apart. Het hart van de code is de functie drive(left, right): die neemt de snelheid van elke motor apart, van -255 tot 255, waarbij een positieve waarde vooruit betekent, een negatieve waarde achteruit en nul stop. Hoe de snelheidswaarde in spanning verandert, leggen we uit in Wat is PWM?. Zet de auto voor het uploaden op een doos, zodat de wielen vrij kunnen draaien; de wachttijd van 3 seconden in setup() geeft je tijd daarvoor.
1// Sol motor / left motor: ENA=5, IN1=7, IN2=8 — Sağ motor / right motor: ENB=6, IN3=9, IN4=4
2const int ENA = 5, IN1 = 7, IN2 = 8;
3const int ENB = 6, IN3 = 9, IN4 = 4;
4
5const int SPEED = 180; // temel hız 0-255 / base speed 0-255
6const int TRIM = 0; // % düzeltme: + sol, - sağ motoru yavaşlatır / % trim: + slows left, - slows right
7
8void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
9 if (TRIM > 0) left = left * (100 - TRIM) / 100;
10 if (TRIM < 0) right = right * (100 + TRIM) / 100;
11 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
12 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
13 analogWrite(ENA, abs(left));
14 analogWrite(ENB, abs(right));
15}
16
17void forward() { drive(SPEED, SPEED); }
18void backward() { drive(-SPEED, -SPEED); }
19void turnLeft() { drive(-SPEED, SPEED); } // yerinde sola / spin left in place
20void turnRight() { drive(SPEED, -SPEED); } // yerinde sağa / spin right in place
21void stopCar() { drive(0, 0); }
22
23void setup() {
24 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
25 for (int p : pins) pinMode(p, OUTPUT);
26 stopCar();
27 delay(3000); // tekerlekleri kaldırmak için zaman / time to lift the wheels
28}
29
30void loop() {
31 forward(); delay(1500);
32 stopCar(); delay(500);
33 backward(); delay(1500);
34 stopCar(); delay(500);
35 turnLeft(); delay(600);
36 stopCar(); delay(500);
37 turnRight(); delay(600);
38 stopCar(); delay(2000);
39}| Beweging | Linkermotor | Rechtermotor | Code |
|---|---|---|---|
| Vooruit | Vooruit | Vooruit | drive(180, 180) |
| Achteruit | Achteruit | Achteruit | drive(-180, -180) |
| Ter plekke naar links draaien | Achteruit | Vooruit | drive(-180, 180) |
| Ter plekke naar rechts draaien | Vooruit | Achteruit | drive(180, -180) |
| Wijde bocht naar links | Langzaam vooruit | Vooruit | drive(90, 180) |
| Stop | Stopt | Stopt | drive(0, 0) |
Met de wielen in de lucht moet de auto om beurten vooruit, achteruit, naar links en naar rechts gaan. Als één wiel de verkeerde kant op draait, pas dan niet de code aan; wissel de twee draden van die motor om op de OUT-aansluitingen van de L298N. Als beide wielen de verkeerde kant op draaien, wissel dan de draden van beide motoren om. Als de motoren zoemen maar niet draaien, is de waarde SPEED te laag: de meeste TT-motoren hebben een PWM-waarde van minstens ongeveer 80–120 nodig om te gaan bewegen, en deze drempel stijgt naarmate de batterij leegraakt.
Bluetooth-besturing met je telefoon (HC-05)
De HC-05 werkt als een draadloze seriële kabel tussen de telefoon en de Arduino: de app op de telefoon stuurt een letter, de Arduino leest die en voert de bijbehorende beweging uit. De meeste besturingsapps die je in de Play Store vindt met de zoekterm "Bluetooth RC Car" of "Bluetooth RC Controller" sturen F voor vooruit, B voor achteruit, L voor links, R voor rechts en S voor stop wanneer je een knop loslaat; sommige gebruiken ook G, I, H en J voor de diagonalen en 0–9 plus q voor de snelheid. De pins, ledpatronen en AT-commando's van de module komen aan bod in HC-05-Bluetooth-module.

- De schakelaar van de auto kan uit blijven terwijl je de onderstaande sketch uploadt; de Arduino en de HC-05 worden via USB gevoed. Als de led van de HC-05 snel knippert, wacht de module op een verbinding.
- Zoek de HC-05 in de Bluetooth-instellingen van je Android-telefoon en koppel hem met pincode 1234 (of 0000 als dat niet lukt).
- Open de besturingsapp, geef de rechten voor Bluetooth en apparaten in de buurt en kies de HC-05 in de apparatenlijst. Zodra er verbinding is, knippert de led van de module elke twee seconden twee keer kort.
- Laat de Arduino via USB aangesloten, open de Serial Monitor op 9600 baud en druk op de knoppen in de app. De letter die elke knop stuurt, verschijnt op het scherm; als je app andere letters stuurt, pas dan de case-regels in de code aan.
- Haal de USB-kabel eruit, zet de schakelaar aan, zet de auto op de vloer en rijd.
1#include <SoftwareSerial.h>
2
3SoftwareSerial bt(10, 11); // RX, TX → HC-05 TXD, RXD (RXD bölücüyle / RXD via divider)
4
5const int ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
6const int ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
7const int TRIM = 0; // % düzeltme / % trim
8const unsigned long TIMEOUT = 600; // ms; 0 = kapalı / 0 = disabled
9
10int speed = 200; // 0-255
11unsigned long lastCmd = 0;
12
13void drive(int left, int right) {
14 if (TRIM > 0) left = left * (100 - TRIM) / 100;
15 if (TRIM < 0) right = right * (100 + TRIM) / 100;
16 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
17 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
18 analogWrite(ENA, abs(left));
19 analogWrite(ENB, abs(right));
20}
21
22void setup() {
23 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24 for (int p : pins) pinMode(p, OUTPUT);
25 drive(0, 0);
26 Serial.begin(9600); // gelen harfleri görmek için / to see incoming letters
27 bt.begin(9600); // HC-05 veri modu hızı / HC-05 data mode baud rate
28}
29
30void loop() {
31 if (bt.available()) {
32 char c = bt.read();
33 Serial.println(c);
34 lastCmd = millis();
35 int half = speed / 2;
36 switch (c) {
37 case 'F': drive(speed, speed); break; // ileri / forward
38 case 'B': drive(-speed, -speed); break; // geri / backward
39 case 'L': drive(-speed, speed); break; // yerinde sola / spin left
40 case 'R': drive(speed, -speed); break; // yerinde sağa / spin right
41 case 'G': drive(half, speed); break; // ileri-sol / forward-left
42 case 'I': drive(speed, half); break; // ileri-sağ / forward-right
43 case 'H': drive(-half, -speed); break; // geri-sol / back-left
44 case 'J': drive(-speed, -half); break; // geri-sağ / back-right
45 case 'S': drive(0, 0); break; // dur / stop
46 case 'q': speed = 255; break; // tam hız / full speed
47 default:
48 if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 100, 240); // hız kademesi / speed level
49 }
50 }
51 if (TIMEOUT > 0 && millis() - lastCmd > TIMEOUT) drive(0, 0); // komut yoksa dur / no command: stop
52}| Letter | Beweging | Linker- / rechtermotor |
|---|---|---|
| F | Vooruit | +snelheid / +snelheid |
| B | Achteruit | −snelheid / −snelheid |
| L | Naar links draaien | −snelheid / +snelheid |
| R | Naar rechts draaien | +snelheid / −snelheid |
| G, I | Vooruit-links, vooruit-rechts | Eén kant op halve snelheid |
| H, J | Achteruit-links, achteruit-rechts | Eén kant op halve snelheid |
| S | Stop | 0 / 0 |
| 0–9, q | Snelheidsniveau | 0 → 100, 9 → 240, q → 255 |
De TIMEOUT in de code is een veiligheidsfunctie: deze apps blijven dezelfde letter sturen zolang je een knop ingedrukt houdt, dus als er 600 ms geen letter binnenkomt, gaat de code ervan uit dat de verbinding verbroken is en stopt de auto. Zo blijft de auto niet op de muur afrijden als de telefoon buiten bereik raakt of de app sluit. Als je app de letter maar één keer per druk op een knop stuurt, stopt de auto na 600 ms; zet TIMEOUT in dat geval op 0 om deze functie uit te schakelen. We hebben ook nergens delay() in loop() gebruikt; lange wachttijden laten commando's achterlopen, en waarom dat zo is lees je in millis() versus delay().
De auto rijdt niet recht: oorzaken en oplossingen
Als de auto langzaam naar één kant afwijkt, ook al geef je beide motoren dezelfde PWM-waarde voor "vooruit", maak je dan geen zorgen; dit is het meest voorkomende probleem bij robotauto's. Goedkope reductiemotoren draaien zelfs bij dezelfde spanning met verschillende snelheden: verschillen in tandwielwrijving, koolborstels en magneten maken elke motor een beetje anders. Voeg daar een los wiel, een zwenkwiel dat blijft zwenken of gewicht dat aan één kant ligt aan toe, en een afwijking van 20–30 cm over 2 meter is heel normaal. Los eerst de mechanische oorzaken op en corrigeer daarna het resterende verschil in software.
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Wijkt altijd naar dezelfde kant af | De motoren draaien met verschillende snelheden | Softwarecorrectie met TRIM, of encoders |
| Zwiept bij het starten uit en rijdt dan recht | Eén motor start later, of het zwenkwiel zwenkt | Zachte start; een kogelwiel in plaats van een zwenkwiel |
| De afwijking is elke keer anders | Los wiel, slippende band of verbogen motorbeugel | Druk het wiel helemaal op de as, draai de schroeven aan |
| Draait ter plekke in plaats van vooruit te rijden | De draden van één motor zijn omgedraaid | Wissel de draden van die motor om op de OUT-aansluiting |
| De afwijking neemt toe naarmate de batterij leegraakt | Het verschil tussen de motoren wordt groter bij lage spanning | Laad de batterij op; stel TRIM in met een volle batterij |
| Trekt naar één kant bij het optrekken | Het gewicht ligt aan één kant | Verplaats de batterij en de boards naar het midden, dicht bij de wielas |
Als de mechanische problemen zijn opgelost, stel je in software bij. De constante TRIM in de code remt de snellere motor met een percentage af: een positieve waarde remt de linkermotor af, een negatieve waarde de rechtermotor. Kalibreer zo:
- Laad de cellen volledig op; kalibreren met een volle batterij geeft consistente resultaten.
- Plak een rechte strook tape van 2 meter op de vloer en zet de auto aan het begin, in de richting van de tape.
- Houd in loop() van de eerste sketch alleen forward() en een wachttijd van 3 seconden over en laat de auto rijden.
- Als de auto naar rechts afwijkt, is de linkermotor sneller: verhoog TRIM met 3; als hij naar links afwijkt, verlaag TRIM met 3.
- Herhaal dit tot de afwijking over 2 meter nog maar een paar centimeter is en kopieer dan dezelfde TRIM-waarde naar de Bluetooth-sketch.
- Kalibreer op de snelheid die je het meest gebruikt; het verschil tussen de motoren verandert licht met de snelheid.
De volgende stap voor perfect rechtuit rijden en afstand meten is de encoder. Je monteert de schijfjes met 20 sleuven uit de set op de motorassen en telt elke sleuf met een snelheidssensor met sleuf op basis van de LM393. Sluit de uitgangen van de sensoren aan op de pins D2 en D3, die interrupts ondersteunen, en vergelijk het aantal pulsen van de twee wielen: als de linkerkant voorloopt, remt je de linkermotor een beetje af. Deze eenvoudige proportionele (P-)regeling houdt de auto recht, ongeacht het batterijniveau en de ondergrond. Een wiel van 65 mm legt ongeveer 20,4 cm per omwenteling af, dus elke puls betekent grofweg 1 cm weg. Hoe interrupts werken, leggen we uit in Arduino-interrupts.
De Arduino reset zodra de motoren starten
Als de Arduino opnieuw opstart of de HC-05 de verbinding verliest (de led gaat weer snel knipperen) wanneer de auto optrekt, van richting verandert of tegen een obstakel botst, ligt het probleem bijna altijd aan de voedingskant. Bij het starten kunnen twee motoren samen 2–3 A trekken; een zwakke batterij kan dat niet leveren en de spanning stort even in. De processor van de Uno reset zichzelf voor de veiligheid als zijn voeding onder 2,7 V zakt (brown-out). Daar komen de elektrische ruis van de motorborstels en het spanningsverlies in dunne draden nog bij. Dit zijn de oplossingen, te beginnen met de meest effectieve:
- Vervang de batterij: gebruik twee opgeladen 18650-cellen in plaats van een 9V-batterij of vermoeide AA-batterijen; hier houden de meeste problemen op.
- Gebruik het juiste voedingspad: voed de Arduino vanuit de batterij via VIN; sluit de 5V-uitgang van de L298N niet aan op VIN.
- Motorcondensatoren: soldeer een keramische condensator van 100 nF over de twee aansluitingen van elke motor; die onderdrukt de borstelruis bij de bron.
- Bufferecondensator: sluit een elco van 470–1000 µF aan op de aansluitingen 12V en GND van de L298N (plusdraad naar 12V). Die dekt de korte stroomvraag bij het starten.
- Zachte start: spring niet meteen naar 255, maar verhoog de snelheid stap voor stap zoals hieronder getoond; de stroompiek wordt kleiner.
- Stop voor je achteruit gaat: rechtstreeks van vooruit naar achteruit schakelen duwt de motorstroom naar zijn piek; stop 100–200 ms voordat je van richting verandert.
- Dikke, korte voedingsdraden: gebruik tussen de batterij en de L298N geen jumperdraden of breadboard; gebruik draad van minstens 0,5 mm² en schroefaansluitingen.
- Gescheiden voedingen: als het probleem blijft, voed de Arduino dan met een powerbank en de motoren met de batterij, en verbind de twee GND's.
1// Yumuşak kalkış: ilk koddaki drive() ile kullan / soft start: use with drive() from the first sketch
2void rampTo(int target) {
3 for (int s = 60; s < target; s += 20) {
4 drive(s, s);
5 delay(15); // yaklaşık 10 adımda tam hız / full speed in about 10 steps
6 }
7 drive(target, target);
8}
9
10// Kullanım: forward() yerine rampTo(SPEED) / usage: rampTo(SPEED) instead of forward()Robotauto met een ESP32 en een Raspberry Pi Pico
De ESP32 heeft klassieke Bluetooth ingebouwd, dus je hebt geen HC-05 nodig: de bibliotheek BluetoothSerial maakt dezelfde seriële verbinding met de telefoon en de besturingsapps hierboven werken ongewijzigd. De ingangen van de L298N beschouwen alles boven ongeveer 2,3 V als HIGH, dus de 3,3 V-signalen van de ESP32 zijn genoeg. Voed het ESP32-board vanaf de 5V-uitgang van de L298N naar de 5V-pin (VIN) van het board; sluit de batterij niet rechtstreeks op die pin aan. Deze code compileert niet voor de ESP32-S3 en ESP32-C3, omdat die alleen BLE hebben.
1#include "BluetoothSerial.h"
2
3BluetoothSerial bt;
4
5const int ENA = 25, IN1 = 27, IN2 = 33; // sol motor / left motor
6const int ENB = 26, IN3 = 32, IN4 = 4; // sağ motor / right motor
7
8int speed = 200; // 0-255
9unsigned long lastCmd = 0;
10
11void drive(int left, int right) {
12 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
13 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
14 analogWrite(ENA, abs(left));
15 analogWrite(ENB, abs(right));
16}
17
18void setup() {
19 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
20 for (int p : pins) pinMode(p, OUTPUT);
21 drive(0, 0);
22 bt.begin("BlueGrays-Car"); // telefonda görünecek ad / name shown on the phone
23}
24
25void loop() {
26 if (bt.available()) {
27 char c = bt.read();
28 lastCmd = millis();
29 switch (c) {
30 case 'F': drive(speed, speed); break; // ileri / forward
31 case 'B': drive(-speed, -speed); break; // geri / backward
32 case 'L': drive(-speed, speed); break; // yerinde sola / spin left
33 case 'R': drive(speed, -speed); break; // yerinde sağa / spin right
34 case 'S': drive(0, 0); break; // dur / stop
35 case 'q': speed = 255; break; // tam hız / full speed
36 default:
37 if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 100, 240);
38 }
39 }
40 if (millis() - lastCmd > 600) drive(0, 0); // komut yoksa dur / no command: stop
41}De standaard Raspberry Pi Pico heeft geen Bluetooth, dus je sluit de HC-05 aan op de UART0-pins. Omdat de Pico op 3,3 V werkt, is deze keer geen spanningsdeler nodig. Voed de Pico via zijn VSYS-pin en de HC-05 rechtstreeks vanaf de 5V-uitgang van de L298N; als je op batterijen draait zonder USB, staat er geen spanning op de VBUS-pin. In de Pico-code wordt de snelheid opgegeven als percentage van -100 tot 100:
1from machine import Pin, PWM, UART
2import time
3
4bt = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1)) # GP0 → HC-05 RXD, GP1 ← HC-05 TXD
5
6ena = PWM(Pin(15)); ena.freq(1000) # sol motor hızı / left motor speed
7enb = PWM(Pin(10)); enb.freq(1000) # sağ motor hızı / right motor speed
8in1, in2 = Pin(14, Pin.OUT), Pin(13, Pin.OUT)
9in3, in4 = Pin(12, Pin.OUT), Pin(11, Pin.OUT)
10
11def drive(left, right): # -100 … 100 (%)
12 in1.value(left > 0); in2.value(left < 0)
13 in3.value(right > 0); in4.value(right < 0)
14 ena.duty_u16(int(abs(left) * 655))
15 enb.duty_u16(int(abs(right) * 655))
16
17speed = 80
18last = time.ticks_ms()
19drive(0, 0)
20
21while True:
22 if bt.any():
23 c = bt.read(1)
24 last = time.ticks_ms()
25 if c == b'F': drive(speed, speed) # ileri / forward
26 elif c == b'B': drive(-speed, -speed) # geri / backward
27 elif c == b'L': drive(-speed, speed) # yerinde sola / spin left
28 elif c == b'R': drive(speed, -speed) # yerinde sağa / spin right
29 elif c == b'S': drive(0, 0) # dur / stop
30 elif c == b'q': speed = 100 # tam hız / full speed
31 elif c and 48 <= c[0] <= 57: # '0'…'9' hız kademesi / speed level
32 speed = 40 + (c[0] - 48) * 6
33 if time.ticks_diff(time.ticks_ms(), last) > 600:
34 drive(0, 0) # komut yoksa dur / no command: stopVolgende stappen: maak je auto beter
- Robot die obstakels ontwijkt: voeg vooraan een afstandssensor HC-SR04 toe en een servomotor die hem naar links en rechts draait; details in de gids Robot die obstakels ontwijkt.
- Lijnvolgrobot: monteer 2–3 infraroodsensoren TCRT5000 onder de voorkant en volg een zwarte lijn op de vloer; zie Lijnvolgrobot.
- Joystick-afstandsbediening: bouw een echte afstandsbediening zonder telefoon met een tweede Arduino, een joystickmodule en een nRF24L01.
- Infraroodafstandsbediening: rijd met de knoppen van je tv-afstandsbediening; koppel de codes uit IR-ontvanger en afstandsbediening aan rijcommando's.
- Rijden via Wi-Fi: laat een ESP32 een besturingspagina aanbieden die in de browser van je telefoon opent; de gids ESP32-webserver en WebSocket behandelt de basis.
- Encoders en afstand: gebruik snelheidssensoren om precies 1 meter te rijden en precies 90 graden te draaien; dit is de basis van robots die een doolhof oplossen.
- Robotarm: zet een kleine robotarm met servo's bovenop de auto om voorwerpen te vervoeren.



Veelgemaakte fouten en oplossingen
- Geen enkele motor draait: de GND's zijn niet gedeeld, de schakelaar staat uit, de jumpers ENA en ENB zijn verwijderd maar de pins zijn niet aangesloten, of de batterij is leeg.
- De led van de L298N brandt, maar de motoren zoemen alleen: de PWM-waarde ligt onder de startdrempel van de motor of de batterijspanning is laag; verhoog de snelheid en laad de batterij op.
- De sketch wordt niet geüpload: mogelijk is de verkeerde poort of het verkeerde board geselecteerd; als je de HC-05 op pin 0 en 1 hebt aangesloten, koppel hem dan los tijdens het uploaden. Andere oorzaken staan in Arduino-sketch wordt niet geüpload.
- De telefoon ziet de HC-05 maar maakt geen verbinding: de module is verbonden met een andere telefoon, de app heeft geen toestemming voor "apparaten in de buurt" gekregen, of de koppelcode is fout.
- De auto reageert laat op commando's: er staat een delay() in loop() of er wordt te veel naar de Serial Monitor geprint; doe je wachten met millis().
- De koelplaat van de L298N wordt erg heet: de wielen zitten vast, of bij een 4WD-auto is de stroom per kanaal te hoog; controleer op mechanische wrijving.
- De auto trilt even bij het inschakelen: de pins zijn bij het opstarten kort ongedefinieerd; stel de pins in als uitgangen en roep drive(0, 0) aan in de allereerste regels van setup().
Een Arduino-robotauto is een geweldig beginpunt dat motorsturing, voedingsbeheer, draadloze communicatie en debuggen in één project leert. Als je klaar bent, heb je een chassis dat met elke nieuwe sensor een beetje slimmer wordt. In de BlueGrays-app vind je de projecten met de L298N-auto met Bluetooth-besturing, de robot die obstakels ontwijkt en de detectie van zwart-witte ondergronden met de TCRT5000 stap voor stap, met schakelschema's en code.
Veelgestelde vragen
Wat heb je nodig om een Arduino-auto te bouwen en wat kost het?
Voor een eenvoudige Bluetooth-auto heb je een 2WD-chassisset (2 TT-motoren, wielen, een zwenkwiel), een Arduino Uno, een L298N-motordriver, een HC-05-Bluetooth-module, twee 18650-cellen met houder en een paar jumperdraden nodig. De prijzen verschillen per verkoper; de modules zijn goedkoop en het grootste deel van het budget gaat naar het board, de chassisset en de batterijen met lader. Als je al een starterset hebt, dalen de kosten merkbaar.
Welke batterij moet ik gebruiken voor een Arduino-robotauto?
De beste optie is twee 18650 Li-ion-cellen in serie: ze geven 7,4 V, laten na het verlies van ongeveer 2 V in de L298N nog 5–6 V over voor de motoren en leveren de hoge stroom die bij het starten nodig is. Een 9V-PP3-batterij kan niet genoeg stroom leveren en veroorzaakt resets, terwijl 4 AA-cellen de motoren met een L298N langzaam laten draaien.
Waarom rijdt mijn Arduino-auto niet recht?
Goedkope reductiemotoren draaien ook bij dezelfde PWM-waarde met verschillende snelheden, en losse wielen, het zwenkwiel en ongelijk verdeeld gewicht versterken de afwijking. Los eerst de mechanische problemen op en rem daarna de snellere motor iets af met een trimwaarde in de code. Voor echt rechtuit rijden heb je encoders nodig om de snelheid van beide wielen te meten en gelijk te trekken.
Waarom reset mijn Arduino zodra de motoren starten?
De motoren trekken bij het starten meerdere ampères en de spanning van een zwakke batterij stort even in; de processor van de Uno reset zichzelf als zijn voeding zakt. Gebruik opgeladen 18650-cellen, voeg condensatoren van 100 nF toe over de motoraansluitingen en een condensator van 470–1000 µF op de ingang van de L298N, en verhoog de snelheid geleidelijk. Als het probleem blijft, voed de Arduino dan vanuit een aparte bron en verbind de GND's.
Werkt een Bluetooth-auto met een HC-05 met een iPhone?
Nee. De HC-05 en HC-06 gebruiken het serial port profile van klassieke Bluetooth, en iOS laat gewone apps dat soort verbinding niet openen. Om de auto met een iPhone te besturen, gebruik je een BLE-module zoals de HM-10 of een ESP32 met BLE; Android-telefoons verbinden zonder problemen met de HC-05.
Kan ik een L293D-motorshield gebruiken in plaats van de L298N?
Ja. De L293D-motorshield past bovenop de Arduino Uno en kan vier gelijkstroommotoren aansturen, wat de bedrading bij 4WD-auto's vereenvoudigt. De continue stroom is echter maar ongeveer 0,6 A per kanaal, dus hij komt sneller in de problemen dan de L298N als de motoren blokkeren, en de shield gebruikt veel pins. Wil je iets efficiënters, dan verliezen MOSFET-drivers zoals de TB6612FNG veel minder spanning.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

LED bedienen met je telefoon via Bluetooth
Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

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.

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.

Parkeersensor met HC-SR04
Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.
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

