Gidsen · 19 min leestijd

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.

Arduino Uno
Arduino Uno
L298N
L298N
HC-05
HC-05
18650 Li-ion
18650 Li-ion

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.

Gele TT-reductiemotor en wielenset van 65 mm
De standaardmotor voor een robotauto: een TT-motor met een geel plastic tandwielkastje en een wiel van 65 mm. Het tandwielkastje verlaagt het motortoerental 48 keer en verhoogt het koppel.
EigenschapGele TT-motor (1:48)
Werkspanning3–6 V
Overbrengingsverhouding1:48 (plastic tandwielen)
Toerental zonder belastingOngeveer 90–120 RPM bij 3 V, 200–250 RPM bij 6 V
Stroom zonder belastingOngeveer 150–160 mA
BlokkeerstroomOngeveer 1,1–1,5 A
Wieldiameter (in sets)65 mm
Snelheid van de auto bij 6 VOngeveer 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

OnderdeelAantalOpmerking
2WD-chassisset van acryl voor een robotauto1Bevat meestal 2 TT-motoren, 2 wielen, een zwenkwiel, een schakelaar, motorbeugels en schroeven
Arduino Uno R3 (een kloon is prima) + USB-kabel1Een Nano werkt ook; de pinnummers zijn hetzelfde
L298N-motordrivermodule12 A per kanaal; stuurt twee motoren onafhankelijk aan
HC-05- of HC-06-Bluetooth-module1Voor communicatie met een Android-telefoon
18650 Li-ion-cel2Merkcellen die minstens 5 A kunnen leveren
Batterijhouder voor 2 18650-cellen (in serie)1Schakelt de twee cellen in serie voor 7,4 V
18650-lader1Een 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 + 1Spanningsdeler voor de RXD-ingang van de HC-05
Keramische condensator van 100 nF2–4Over de motoraansluitingen, om ruis te onderdrukken
Elco van 470–1000 µF (16 V of hoger)1Aanbevolen; op de voedingsingang van de L298N
Kabelbinders, dubbelzijdig plakband, M3-afstandhoudersEen paarOm 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.

OnderdeelPrijsniveauBesparingstip
Chassisset (motoren en wielen inbegrepen)GemiddeldEen set is meestal goedkoper dan motoren, wielen en zwenkwiel los kopen
Arduino UnoGemiddeld (kloon) – hoog (origineel)Een kloonboard is prima om mee te leren; je kunt ook de Uno of Nano gebruiken die je al hebt
L298N-motordriverLaagEén module stuurt twee motoren aan; één is ook genoeg voor 4WD
HC-05 / HC-06Laag – gemiddeldAls je alleen met een telefoon rijdt, is een HC-06 genoeg
2× 18650-cellen + laderGrootste postZeer goedkope cellen met het opschrift "9900 mAh" zijn meestal nep; bespaar hier niet
Draden, weerstanden, condensatoren, schroevenLaagHet meeste hiervan zit al in starterssets
Als je al een Arduino-starterset hebt, zijn het board, de jumperdraden en de weerstanden gedekt; je hebt dan alleen de chassisset, een L298N, een HC-05 en de batterijen nodig. Kant-en-klare "smart car"-sets met alles in één doos zijn handig, omdat ze hun eigen motorboard en kant-en-klare code meebrengen, maar ze kosten meer en nemen de kans weg om de bedrading te leren.

2WD of 4WD?

Eigenschap2WD (2 motoren + zwenkwiel)4WD (4 motoren)
DraaienDraait ter plekke, scherp en gemakkelijkDraait door de wielen zijwaarts te laten slippen (skid steer); heeft moeite op tapijt
StroomverbruikOngeveer 0,3–0,6 A tijdens het rijdenOngeveer twee keer zoveel
BatterijduurLangerKorter
Ruw terreinHet zwenkwiel kan achter randjes blijven hakenBetere grip
Rechtuit rijdenHet zwenkwiel kan de auto uit koers duwen als het zwenktStabieler
Aansluiting op de L298NElke motor op een eigen kanaalDe twee motoren aan elke kant parallel op één kanaal
Het beste voorEen eerste auto, een lijnvolgrobotBuiten, 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.

Oplaadbare 18650 Li-ion-cel
18650 Li-ion-cel: 18 mm in diameter en 65 mm lang; 4,2 V als hij vol is en gemiddeld 3,6–3,7 V. Twee in serie vormen het ideale pakket van 7,4 V voor een robotauto.
VoedingsbronSpanningStroomleveringVoor een robotauto
9V-PP3-batterij9 VZeer laagNiet geschikt; de meest voorkomende oorzaak van resets
4× AA alkaline6 V (zakt snel onder belasting)GemiddeldZwak; na de L298N komt er maar ongeveer 4 V bij de motoren aan
4× AA NiMH (oplaadbaar)4,8 VGoedTe 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)HoogTe veel voor TT-motoren; overschrijdt de limiet van 12 V van de 5V-jumper
USB-powerbank5 VGoedAlleen om de Arduino apart te voeden
Li-ioncellen zijn krachtig, maar vragen om zorg. Controleer bij het plaatsen van de cellen twee keer of plus en min goed zitten; een 18650-cel die verkeerd om is geplaatst of kortgesloten raakt, wordt erg heet en kan brand veroorzaken. De spanning per cel mag nooit onder 3,0 V komen; laad op zodra je auto langzamer gaat rijden (rond 6,6 V voor het pakket). TP4056-modules laden alleen een enkele cel op en kunnen een pakket in serie niet rechtstreeks laden; haal de cellen uit de houder, laad ze op in een 18650-lader en laat ze tijdens het laden nooit onbeheerd achter.

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.

C++ (Arduino IDE)
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

  1. 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.
  2. 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 motoras­sen moeten op één lijn liggen en de draadaansluitingen van de motoren moeten naar binnen wijzen.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
Raak voordat je de motoren op het chassis monteert de aansluitingen van elke motor kort aan met 2 AA-batterijen om de draairichting te controleren en markeer de draden. Als je beide motoren zo markeert dat "rode draad op plus betekent vooruit", maak je tijdens het bedraden geen richtingsfouten.

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-motordrivermodule met twee kanalen
L298N-motordriver: de motoren gaan naar de blauwe schroefaansluitingen aan de zijkanten en de batterij naar de driewegaansluiting aan de voorkant; de pins ENA, IN1–IN4 en ENB gaan naar de Arduino.
L298N-aansluitingAansluiting
OUT1, OUT2Linkermotor (bij 4WD de twee linkermotoren parallel)
OUT3, OUT4Rechtermotor (bij 4WD de twee rechtermotoren parallel)
12VBatterij plus via de schakelaar
GNDBatterij min en de GND-pin van de Arduino (gemeenschappelijke massa)
5VBlijft onaangesloten bij de Arduino Uno; voedt bij de ESP32 en de Pico het board
5V-jumperBlijft zitten (batterij onder 12 V)
ENA- en ENB-jumpersVerwijderd; de pins gaan naar de PWM-uitgangen van de Arduino
AansluitingArduino UnoESP32Raspberry Pi Pico
L298N ENA (snelheid linkermotor)D5 (PWM)GPIO 25GP15
L298N IN1D7GPIO 27GP14
L298N IN2D8GPIO 33GP13
L298N ENB (snelheid rechtermotor)D6 (PWM)GPIO 26GP10
L298N IN3D9GPIO 32GP12
L298N IN4D4GPIO 4GP11
HC-05 TXDD10 (SoftwareSerial RX)Niet nodig (ingebouwde Bluetooth)GP1 (UART0 RX)
HC-05 RXDD11, via een 1 kΩ / 2 kΩ-delerNiet nodigGP0 (UART0 TX), rechtstreeks
HC-05 VCC5VNiet nodig5V-uitgang van de L298N
Voeding van het boardVIN ← batterij plus na de schakelaar5V (VIN) ← 5V-uitgang van de L298NVSYS ← 5V-uitgang van de L298N
GNDGedeeld met GND van de L298N en batterij minGedeeldGedeeld
Overtreed nooit drie regels: alle GND's (batterij min, L298N, Arduino, HC-05) moeten met elkaar verbonden zijn; de motoren mogen nooit worden gevoed vanaf de 5V-pin van de Arduino; en de 5V-uitgang van de L298N mag niet naar de VIN-pin van de Arduino. VIN heeft minstens 7 V nodig; met 5 V kan de spanningsregelaar van de Arduino niet goed werken en wordt het board instabiel. De RXD-pin van de HC-05 is een ingang van 3,3 V; breng het TX-signaal van 5 V van de Uno omlaag met een deler van 1 kΩ en 2 kΩ: D11 → 1 kΩ → RXD, RXD → 2 kΩ → GND (5 V × 2/3 ≈ 3,3 V).

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.

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.

C++ (Arduino IDE)
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}
BewegingLinkermotorRechtermotorCode
VooruitVooruitVooruitdrive(180, 180)
AchteruitAchteruitAchteruitdrive(-180, -180)
Ter plekke naar links draaienAchteruitVooruitdrive(-180, 180)
Ter plekke naar rechts draaienVooruitAchteruitdrive(180, -180)
Wijde bocht naar linksLangzaam vooruitVooruitdrive(90, 180)
StopStoptStoptdrive(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.

HC-05-Bluetooth-module
HC-05: verbindt met de telefoon via klassieke Bluetooth (SPP); de standaardsnelheid is 9600 baud en de koppelcode is 1234 of 0000.
  1. 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.
  2. Zoek de HC-05 in de Bluetooth-instellingen van je Android-telefoon en koppel hem met pincode 1234 (of 0000 als dat niet lukt).
  3. 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.
  4. 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.
  5. Haal de USB-kabel eruit, zet de schakelaar aan, zet de auto op de vloer en rijd.
C++ (Arduino IDE)
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}
LetterBewegingLinker- / rechtermotor
FVooruit+snelheid / +snelheid
BAchteruit−snelheid / −snelheid
LNaar links draaien−snelheid / +snelheid
RNaar rechts draaien+snelheid / −snelheid
G, IVooruit-links, vooruit-rechtsEén kant op halve snelheid
H, JAchteruit-links, achteruit-rechtsEén kant op halve snelheid
SStop0 / 0
0–9, qSnelheidsniveau0 → 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 HC-05 en HC-06 gebruiken klassieke Bluetooth en werken dus niet met een iPhone; iOS staat dit soort seriële verbinding niet toe. Als je met een iPhone wilt rijden, gebruik dan een BLE-module zoals de HM-10 of een ESP32 met BLE. Wil je een eigen besturingsapp bouwen, bekijk dan de gids Arduino Bluetooth met App Inventor.

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.

SymptoomWaarschijnlijke oorzaakOplossing
Wijkt altijd naar dezelfde kant afDe motoren draaien met verschillende snelhedenSoftwarecorrectie met TRIM, of encoders
Zwiept bij het starten uit en rijdt dan rechtEén motor start later, of het zwenkwiel zwenktZachte start; een kogelwiel in plaats van een zwenkwiel
De afwijking is elke keer andersLos wiel, slippende band of verbogen motorbeugelDruk het wiel helemaal op de as, draai de schroeven aan
Draait ter plekke in plaats van vooruit te rijdenDe draden van één motor zijn omgedraaidWissel de draden van die motor om op de OUT-aansluiting
De afwijking neemt toe naarmate de batterij leegraaktHet verschil tussen de motoren wordt groter bij lage spanningLaad de batterij op; stel TRIM in met een volle batterij
Trekt naar één kant bij het optrekkenHet gewicht ligt aan één kantVerplaats 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:

  1. Laad de cellen volledig op; kalibreren met een volle batterij geeft consistente resultaten.
  2. Plak een rechte strook tape van 2 meter op de vloer en zet de auto aan het begin, in de richting van de tape.
  3. Houd in loop() van de eerste sketch alleen forward() en een wachttijd van 3 seconden over en laat de auto rijden.
  4. Als de auto naar rechts afwijkt, is de linkermotor sneller: verhoog TRIM met 3; als hij naar links afwijkt, verlaag TRIM met 3.
  5. Herhaal dit tot de afwijking over 2 meter nog maar een paar centimeter is en kopieer dan dezelfde TRIM-waarde naar de Bluetooth-sketch.
  6. 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.
C++ (Arduino IDE)
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()
Een makkelijke manier om te zien of het probleem aan de voeding of aan de code ligt: haal de VIN-draad los, laat de Arduino via USB van je computer gevoed worden (laat de GND-verbinding zitten) en laat de motoren op de batterij draaien. Als de resets ophouden, ligt het probleem zeker aan de voedingskant. Ook als je een multimeter tussen VIN en GND zet en de spanning bekijkt terwijl de auto optrekt, zie je de dip direct. Voor andere oorzaken, zie Arduino blijft resetten.

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.

C++ (Arduino IDE)
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:

MicroPython
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: stop

Volgende 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.
HC-SR04
HC-SR04
TCRT5000
TCRT5000
SG90 servo
SG90 servo

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.

Alle projecten bekijken
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
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

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

4.8(69)
91
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
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
Parkeersensor met HC-SR04
AR-28Gemiddeld
Premium

Parkeersensor met HC-SR04

Een minversie van de parkeersensor van een auto: hoe dichterbij iets komt, hoe sneller de pieptonen.

4.8(64)
86
Een servomotor gebruiken
AR-35Beginner
Premium

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.

4.7(48)
67