Obstakelontwijkende robot met Arduino: gids voor HC-SR04 en servo
Bouw een obstakelontwijkende robot met Arduino: HC-SR04 op een servo, bedrading met L298N of L293D, logica voor stoppen, achteruit en draaien, IR-sensoren en handmatige Bluetooth-modus.
Een obstakelontwijkende robot is een zelfrijdend robotautootje dat een muur, stoel of doos voor zich opmerkt zonder ertegenaan te botsen en zelf een nieuwe route vindt. De meest gebruikte opzet bestaat uit een Arduino Uno, een HC-SR04 ultrasone afstandssensor, een SG90-servomotor die de sensor naar links en rechts draait, twee gelijkstroommotoren met tandwielreductie en een L298N-motordriver (of L293D). De robot rijdt rechtdoor, stopt als hij dicht bij een obstakel komt, rijdt een stukje achteruit, draait zijn kop naar beide kanten om te meten en gaat dan verder in de meest open richting.
In deze gids maken we van de 2WD-auto uit ons artikel over de Arduino-robotauto een autonome robot, met dezelfde pinout. Stap voor stap behandelen we de bedradingstabellen, hoe de afstandsdrempels worden berekend, code die in drie stappen groeit, de oppervlakken die de sensor niet ziet en hoe je die gaten dicht met infraroodsensoren, en tot slot het overschakelen naar handmatige modus via Bluetooth vanaf je telefoon. De code om dezelfde robot met een ESP32 of Raspberry Pi Pico aan te sturen staat aan het eind van het artikel.

Hoe werkt een obstakelontwijkende robot?
Elke autonome robot herhaalt tientallen keren per seconde dezelfde lus van drie stappen: waarnemen, beslissen, handelen. De HC-SR04 neemt waar: hij zendt een kort geluid van 40 kHz uit dat je oor niet hoort en meet hoe lang de echo erover doet om terug te komen; deel die tijd in microseconden door 58 en je hebt de afstand in centimeters. De Arduino beslist door de gemeten afstand te vergelijken met de drempels die jij instelt. De L298N en de motoren zorgen voor de actie. Omdat de sensor op een servo zit, kan de robot naar links en rechts "kijken" zonder zijn lichaam te draaien, waardoor hij veel betere beslissingen over bochten neemt dan een robot met een vaste sensor. Hoe de sensor precies werkt lees je in het artikel HC-SR04-afstandssensor.
| Onderdeel | Taak | Opmerking |
|---|---|---|
| Arduino Uno (of Nano) | Brein: meet, beslist en stuurt de motoren aan | Een ESP32 of Pico werkt ook |
| HC-SR04 | Oog: meet de afstand tot het obstakel voor je | Werkt op 5 V, 2–400 cm |
| SG90 servo | Nek: draait de sensor naar links en rechts | De sensor wordt met een plastic beugel op de servohoorn vastgezet |
| L298N of L293D-shield | Spieren: geven de motoren richting en snelheid | Een Arduino-pin kan geen motorstroom leveren |
| 2 TT-motoren met reductie en een zwenkwiel | Differentiële aandrijving | Draaien gebeurt door de twee wielen in tegengestelde richting te laten draaien |
| 2 × 18650-cellen (7,4 V) | Voeding | Een 9V-batterij is niet genoeg |
| 2 IR-obstakelsensoren (optioneel) | Vangen obstakels op bij de hoeken en zijkanten | Modules op basis van de LM393, zoals de FC-51 |
| HC-05 (optioneel) | Handmatige bediening vanaf je telefoon | Werkt alleen met Android |




Voeding: laat de servo de robot niet resetten
Omdat een obstakelontwijkende robot een servo aan de motoren toevoegt, is de stroomverdeling belangrijker dan bij een gewone robotauto. Een SG90 verbruikt in rust ongeveer 10 mA; zodra hij gaat bewegen springt dat naar 100–250 mA en bij belasting komt hij in de buurt van een halve ampère. Als die piek samenvalt met de aanloopstroom van de motoren, zakt de 5V-rail van de Arduino even in en start het board opnieuw op. De oplossing is eenvoudig: de motoren draaien op de batterij via de L298N, de Arduino draait op de batterij via VIN, en de servo, HC-SR04, IR-sensoren en HC-05 delen de 5V-pin van de Arduino, met een condensator van 470 µF vlak bij de voedingsdraden van de servo. Ook terwijl de servo beweegt blijft de totale belasting van de 5V-rail onder een halve ampère, en omdat die kort is kan de regelaar van de Uno dat aan. Om de batterijduur met je eigen cijfers uit te rekenen gebruik je de tool Batterijduur.
| Onderdeel | Gevoed vanuit | Typische stroom |
|---|---|---|
| 2 TT-motoren | L298N 12V-klem ← 2 × 18650 (7,4 V) | 0,3–0,6 A tijdens het rijden, tot 2 A bij het opstarten |
| Arduino Uno | VIN ← plus van de batterij (na de schakelaar) | Ongeveer 50 mA |
| SG90 servo | 5V van de Arduino + condensator van 470 µF | ~10 mA in rust, 100–250 mA tijdens het bewegen |
| HC-SR04 | Arduino 5V | Ongeveer 15 mA |
| 2 IR-sensoren | Arduino 5V | 20–40 mA per stuk |
| HC-05 | Arduino 5V | 30–40 mA tijdens het koppelen, ongeveer 10 mA als er verbinding is |
Bedradingsschema: Arduino Uno, ESP32 en Pico
De motorpins zijn dezelfde als in de gids voor de robotauto, dus je kunt met dit project verder door gewoon de sensorkop toe te voegen, zonder je auto uit elkaar te halen. De snelheidspins staan bewust op 5 en 6: op de Uno gebruikt de Servo-bibliotheek Timer1 en schakelt daarmee PWM op pin 9 en 10 uit; stonden de motorsnelheden op die pins, dan werkte de snelheidsregeling niet meer zodra de servo is aangesloten. De HC-SR04 en de IR-sensoren komen op A0–A3. De analoge pins van de Uno kunnen indien nodig ook als digitale pins 14–19 dienen, en deze keuze maakt het makkelijk om dezelfde code met een L293D-shield te gebruiken, omdat het shield deze pins niet gebruikt. De pinindeling van jouw board vind je in de tool Pinout.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (snelheid linkermotor) | D5 | GPIO 25 | GP15 |
| L298N IN1, IN2 | D7, D8 | GPIO 27, 33 | GP14, GP13 |
| L298N ENB (snelheid rechtermotor) | D6 | GPIO 26 | GP10 |
| L298N IN3, IN4 | D9, D4 | GPIO 32, 4 | GP12, GP11 |
| Servosignaal (oranje) | D3 | GPIO 13 | GP16 |
| Servo + (rood), − (bruin) | 5V, GND | L298N 5V, GND | L298N 5V, GND |
| HC-SR04 TRIG | A0 | GPIO 18 | GP17 |
| HC-SR04 ECHO | A1 (rechtstreeks) | GPIO 19, via een 1 kΩ / 2 kΩ-spanningsdeler | GP18, via een 1 kΩ / 2 kΩ-spanningsdeler |
| HC-SR04 VCC | 5V | L298N 5V | L298N 5V |
| OUT van IR links, OUT van IR rechts | A2, A3 | GPIO 23, 22 | GP19, GP20 |
| VCC van de IR-sensor | 5V | 3V3 | 3V3 |
| HC-05 TXD, RXD | D10, D11 (RXD via spanningsdeler) | Niet nodig (ingebouwde Bluetooth) | GP1, GP0 (UART0) |
| Voeding van het board | VIN ← batterij (na de schakelaar) | 5V (VIN) ← L298N 5V | VSYS ← L298N 5V |
De sensorkop monteren en testen

- Sluit de servo aan zonder hoorn en upload de onderstaande testsketch. Aan het eind van elke zwenking zet de code de servo op 90 graden en wacht 2 seconden; trek in die pauze de USB-kabel los en de servo blijft staan waar hij staat. Zet de hoorn op de as zodat de sensor recht vooruit kijkt; zo betekent 90 graden "recht vooruit".
- Zet de HC-SR04 met een plastic beugel of hotmelt vast op de hoorn. De sensordraden moeten lang genoeg zijn om niet strak te trekken als de servo draait; een kabel die tijdens de zwenking van 140 graden achter het chassis blijft haken is een veelvoorkomende fout.
- Monteer de sensor 8–12 cm boven de vloer en dicht bij het voorste punt van de body. Te laag en hij vangt echo's van de vloer en de structuur van het tapijt op; te hoog en hij ziet lage obstakels niet.
- Kantel de sensor 3–5 graden omhoog. Een sensor die perfect waterpas en laag zit kan een echo van de vloer voor een obstakel aanzien, vooral op ruwe vloeren.
- Open de Serial Monitor op 9600 baud. Zie je kleine waarden op de regels van 125 en 160 graden als je je hand links van de sensor houdt, dan zijn de grote hoeken links; is het andersom, zet dan SERVO_DIR op -1 in de geavanceerde sketch en wissel de waarden van LEFT_ANGLE en RIGHT_ANGLE in de eerste sketch om.
1#include <Servo.h>
2
3const int SERVO_PIN = 3;
4const int TRIG = A0, ECHO = A1; // analog pinler dijital pin olarak / analog pins used as digital pins
5Servo head;
6
7int pingCm() {
8 digitalWrite(TRIG, LOW); delayMicroseconds(2);
9 digitalWrite(TRIG, HIGH); delayMicroseconds(10); // 10 µs tetik darbesi / 10 µs trigger pulse
10 digitalWrite(TRIG, LOW);
11 unsigned long t = pulseIn(ECHO, HIGH, 25000UL); // en fazla 25 ms bekle (~4,3 m) / wait at most 25 ms (~4.3 m)
12 return t / 58; // 0 = yankı yok / 0 = no echo
13}
14
15void setup() {
16 Serial.begin(9600);
17 pinMode(TRIG, OUTPUT);
18 pinMode(ECHO, INPUT);
19 head.attach(SERVO_PIN);
20 head.write(90); // önce ortala / center first
21 delay(1000);
22}
23
24void loop() {
25 const int angles[] = {20, 55, 90, 125, 160};
26 for (int a : angles) {
27 head.write(a);
28 delay(400); // servo yerine otursun / let the servo settle
29 Serial.print(a);
30 Serial.print(F(" derece / degrees: "));
31 Serial.print(pingCm());
32 Serial.println(F(" cm"));
33 }
34 Serial.println();
35 head.write(90);
36 delay(2000);
37}Elke regel toont een hoek en de afstand in die richting. Is er binnen ongeveer 4 meter van de sensor niets, dan lees je 0 cm: pulseIn() geeft 0 terug als er binnen 25 ms geen echo komt. In de hoofdcode behandelen we 0 als "pad vrij", maar een sensor met een losse draad of met verwisselde TRIG en ECHO geeft meestal ook 0. Houd dus voordat je de robot op de vloer zet je hand op 10, 30 en 60 cm en controleer of de waarden echt veranderen; een robot die zonder deze test rijdt knalt zonder vertragen tegen de muur.
Het beslissingsalgoritme: stoppen, achteruit, draaien naar de meest open richting
Het gedrag van de robot in zones opdelen op basis van afstand houdt de code zowel eenvoudig als betrouwbaar. Zonder obstakel voor zich rijdt hij op volle snelheid, hij vertraagt naarmate een obstakel dichterbij komt en bij de stopdrempel stopt hij en scant. Tijdens de scan kijkt de sensor 70 en 35 graden naar links en 35 en 70 graden naar rechts; in elke richting worden drie metingen gedaan en wordt de mediaan gebruikt. De robot draait naar de richting met de grootste afstand, over die hoek. Is geen enkele richting open, bijvoorbeeld als hij in een hoek is gereden, dan rijdt hij een stukje achteruit en draait 180 graden.
| Gemeten afstand | Zone | Wat de robot doet |
|---|---|---|
| Meer dan 60 cm (of geen echo) | Vrij | Volle snelheid vooruit (PWM 200) |
| 25–60 cm | Nadering | Vertraagt evenredig met de afstand (PWM 200 naar 130) |
| 12–25 cm | Obstakel | Stopt, bevestigt de meting, scant beide kanten op, draait naar de meest open richting |
| Minder dan 12 cm | Te dichtbij | Rijdt eerst 350 ms achteruit en scant dan |
| Elke richting minder dan 35 cm | Doodlopend | Rijdt achteruit en draait 180 graden |
Deze drempels zijn niet willekeurig gekozen. De stopafstand is de som van drie marges: de reactiemarge (afstand tussen twee metingen), de remmarge (hoe ver de robot doorrolt nadat de motoren zijn uitgeschakeld) en de draaimarge (zodat zijn neus het obstakel niet raakt terwijl hij ter plekke draait). Een auto met TT-motoren op 6 V rijdt ongeveer 0,5–0,7 m/s en legt in een meetinterval van 60 ms 3–4 cm af. De remmarge is ongeveer 5 cm en voor een body van 15 cm breed die ter plekke draait is de draaimarge rond 10 cm. Samen is dat ongeveer 18–20 cm; met een paar centimeter veiligheidsmarge erbij is STOP_CM = 25 een goed beginpunt. Is je robot sneller of de vloer glad, verhoog de drempel dan naar 30–35 cm. In smalle gangen zorgt een erg grote drempel er juist voor dat de robot voortdurend stopt en scant, dus doe de uiteindelijke afstelling op je eigen parcours.
Code stap voor stap 1: je eerste obstakelontwijkende robot
De eerste versie is het skelet van het algoritme: vooruit rijden, stoppen op 25 cm, achteruit, naar links en rechts kijken en draaien naar de meest open kant. De motorfunctie drive(left, right) is dezelfde als in de gids voor de robotauto en neemt waarden van -255 tot 255; positief is vooruit, negatief achteruit. Zet de auto na het uploaden van de code eerst op een doos met de wielen van de grond en kijk hoe hij stopt en draait als je je hand naar de sensor brengt; ziet alles er goed uit, zet de robot dan op de vloer.
1#include <Servo.h>
2
3const int ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
5const int SERVO_PIN = 3;
6const int TRIG = A0, ECHO = A1;
7
8const int STOP_CM = 25; // bu mesafede dur / stop at this distance
9const int SPEED = 170; // düz gidiş hızı / cruising speed
10const int TURN = 170; // dönüş hızı / turning speed
11const int LEFT_ANGLE = 160, RIGHT_ANGLE = 20; // ters ise yer değiştir / swap if reversed
12
13Servo head;
14
15void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
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
22int pingCm() {
23 digitalWrite(TRIG, LOW); delayMicroseconds(2);
24 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
25 digitalWrite(TRIG, LOW);
26 unsigned long t = pulseIn(ECHO, HIGH, 25000UL);
27 if (t == 0) return 400; // yankı yok: önü açık say / no echo: treat as open
28 return t / 58;
29}
30
31int lookAt(int angle) {
32 head.write(angle);
33 delay(400); // servo dönsün ve dursun / let the servo turn and settle
34 return pingCm();
35}
36
37void setup() {
38 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4, TRIG};
39 for (int p : pins) pinMode(p, OUTPUT);
40 pinMode(ECHO, INPUT);
41 drive(0, 0);
42 head.attach(SERVO_PIN);
43 head.write(90);
44 delay(3000); // yere koyman için süre / time to put it on the floor
45}
46
47void loop() {
48 int front = pingCm();
49 if (front > STOP_CM) {
50 drive(SPEED, SPEED); // yol açık: ileri / path clear: forward
51 delay(60); // ölçümler arası 60 ms / 60 ms between readings
52 return;
53 }
54
55 drive(0, 0); // 1) dur / 1) stop
56 delay(150);
57 drive(-SPEED, -SPEED); // 2) biraz geri çekil / 2) back off a little
58 delay(300);
59 drive(0, 0);
60
61 int left = lookAt(LEFT_ANGLE); // 3) iki yana bak / 3) look both ways
62 int right = lookAt(RIGHT_ANGLE);
63 head.write(90);
64 delay(300);
65
66 if (left < STOP_CM && right < STOP_CM) { // iki yan kapalı: geri dön / both blocked: turn around
67 drive(-TURN, TURN);
68 delay(700);
69 } else if (left > right) { // 4) daha açık tarafa dön / 4) turn to the more open side
70 drive(-TURN, TURN);
71 delay(350);
72 } else {
73 drive(TURN, -TURN);
74 delay(350);
75 }
76 drive(0, 0);
77 delay(100);
78}Deze code doet het werk, maar heeft een paar zwakke punten: één slechte meting laat de robot voor niets stoppen, hij benadert obstakels altijd met dezelfde snelheid, hij kijkt maar in twee richtingen en zijn draaitijden hangen niet af van de hoek. En omdat hij met delay() wacht, kan hij tijdens een scan op niets reageren. De details van de wachtlogica staan in het artikel millis() en delay(); de volgende versie lost de meeste van deze problemen op.
Code stap voor stap 2: filteren, geleidelijk vertragen, IR en Bluetooth
De geavanceerde versie werkt met dezelfde bedrading, en het is prima als je de IR-sensoren en de HC-05 nog niet hebt gemonteerd. Omdat de IR-ingangen zijn ingesteld met INPUT_PULLUP, leest een sensor die niet is aangesloten "geen obstakel" (HIGH); zonder HC-05 start de robot gewoon in automodus. De onderstaande tabel legt uit wat elk deel van de code doet.
1#include <Servo.h>
2#include <SoftwareSerial.h>
3
4// Pinler / Pins
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 SERVO_PIN = 3;
8const int TRIG = A0, ECHO = A1;
9const int IR_LEFT = A2, IR_RIGHT = A3; // LOW = engel (takılı değilse HIGH) / LOW = obstacle (HIGH if not fitted)
10SoftwareSerial bt(10, 11); // RX, TX → HC-05 TXD, RXD (RXD bölücüyle / RXD via divider)
11
12// Ayarlar / Settings
13const int BACK_CM = 12; // daha yakınsa geri çekil / closer: back off first
14const int STOP_CM = 25; // dur ve tara / stop and scan
15const int SLOW_CM = 60; // yavaşlamaya başla / start slowing down
16const int GUARD_CM = 15; // manuel modda çarpışma koruması / collision guard in manual mode
17const int MAX_CM = 400;
18const int CRUISE = 200, SLOW = 130, TURN = 170; // PWM hızları / PWM speeds
19const int SERVO_CENTER = 90; // sensör öne bakmıyorsa düzelt / adjust if not facing ahead
20const int SERVO_DIR = 1; // +70 sola bakmıyorsa -1 yap / set to -1 if +70 doesn't look left
21const float MS_PER_DEG = 4.0; // derece başına ms, kalibre et / ms per degree, calibrate
22const unsigned long BT_TIMEOUT = 600; // manuelde komut kesilirse dur / stop if commands stop
23
24Servo head;
25bool autoMode = true;
26int manualLeft = 0, manualRight = 0, manualSpeed = 200;
27unsigned long lastCmd = 0, lastPing = 0;
28
29void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
30 left = constrain(left, -255, 255);
31 right = constrain(right, -255, 255);
32 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
33 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
34 analogWrite(ENA, abs(left));
35 analogWrite(ENB, abs(right));
36}
37
38int pingCm() {
39 digitalWrite(TRIG, LOW); delayMicroseconds(2);
40 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
41 digitalWrite(TRIG, LOW);
42 unsigned long t = pulseIn(ECHO, HIGH, 25000UL); // ~4,3 m zaman aşımı / ~4.3 m timeout
43 return t == 0 ? MAX_CM : (int)(t / 58); // yankı yok = açık alan / no echo = open space
44}
45
46int distanceCm() { // 3 ölçümün ortancası / median of 3 readings
47 int a = pingCm(); delay(60);
48 int b = pingCm(); delay(60);
49 int c = pingCm();
50 return max(min(a, b), min(max(a, b), c));
51}
52
53bool irBlocked(int pin) {
54 return digitalRead(pin) == LOW;
55}
56
57int lookAt(int offset) { // + sol, - sağ (derece) / + left, - right (degrees)
58 head.write(SERVO_CENTER + SERVO_DIR * offset);
59 delay(300); // servo yerine otursun / let the servo settle
60 return distanceCm();
61}
62
63void turnBy(int deg) { // + sola, - sağa / + left, - right
64 if (deg > 0) drive(-TURN, TURN);
65 else drive(TURN, -TURN);
66 delay((unsigned long)(abs(deg) * MS_PER_DEG));
67 drive(0, 0);
68 delay(100);
69}
70
71void avoid() {
72 drive(0, 0); // 1) dur / 1) stop
73 delay(120);
74 int front = distanceCm(); // ortancayla doğrula / confirm with the median
75 bool sides = irBlocked(IR_LEFT) || irBlocked(IR_RIGHT);
76 if (front >= STOP_CM && !sides) return; // yanlış alarm / false alarm
77
78 if (front < BACK_CM || sides) { // 2) çok yakın: geri çekil / 2) too close: back off
79 drive(-TURN, -TURN);
80 delay(350);
81 drive(0, 0);
82 }
83
84 const int offsets[] = {70, 35, -35, -70}; // 3) tara / 3) scan
85 int bestOffset = 0, bestCm = 0;
86 for (int off : offsets) {
87 int cm = lookAt(off);
88 if (cm > bestCm) { bestCm = cm; bestOffset = off; }
89 }
90 head.write(SERVO_CENTER);
91 delay(200);
92
93 if (bestCm < STOP_CM + 10) { // her yön kapalı: çıkmaz / every way blocked: dead end
94 drive(-TURN, -TURN);
95 delay(400);
96 turnBy(180);
97 } else {
98 turnBy(bestOffset); // 4) en açık yöne dön / 4) turn to the most open direction
99 }
100}
101
102void autoStep() {
103 if (millis() - lastPing < 60) return; // 60 ms'de bir ölç / measure every 60 ms
104 lastPing = millis();
105 int d = pingCm();
106 bool l = irBlocked(IR_LEFT), r = irBlocked(IR_RIGHT);
107
108 if (d < STOP_CM || (l && r)) {
109 avoid();
110 } else if (l) { // sol köşede engel: sağa kaç / front-left: dodge right
111 drive(TURN, -TURN);
112 delay(150);
113 } else if (r) { // sağ köşede engel: sola kaç / front-right: dodge left
114 drive(-TURN, TURN);
115 delay(150);
116 } else if (d < SLOW_CM) {
117 int s = map(d, STOP_CM, SLOW_CM, SLOW, CRUISE); // yaklaştıkça yavaşla / slow down as you get closer
118 drive(s, s);
119 } else {
120 drive(CRUISE, CRUISE);
121 }
122}
123
124void manualStep() {
125 if (millis() - lastCmd > BT_TIMEOUT) { // komut yok: dur / no commands: stop
126 manualLeft = 0;
127 manualRight = 0;
128 }
129 static int front = MAX_CM;
130 if (millis() - lastPing >= 60) {
131 lastPing = millis();
132 front = pingCm();
133 }
134 bool forward = manualLeft > 0 && manualRight > 0;
135 if (forward && front < GUARD_CM) drive(0, 0); // çarpışma koruması / collision guard
136 else drive(manualLeft, manualRight);
137}
138
139void handleBluetooth() {
140 while (bt.available()) {
141 char c = bt.read();
142 Serial.println(c); // gelen harfi göster / show the incoming letter
143 lastCmd = millis();
144 if (c == 'A') { // otomatik mod / auto mode
145 autoMode = true;
146 continue;
147 }
148 if (c == 'M') { // manuel mod / manual mode
149 autoMode = false;
150 manualLeft = manualRight = 0;
151 drive(0, 0);
152 head.write(SERVO_CENTER);
153 continue;
154 }
155 if (autoMode) continue; // otomatikte yön harflerini yok say / ignore in auto mode
156 int s = manualSpeed;
157 switch (c) {
158 case 'F': manualLeft = s; manualRight = s; break; // ileri / forward
159 case 'B': manualLeft = -s; manualRight = -s; break; // geri / backward
160 case 'L': manualLeft = -s; manualRight = s; break; // yerinde sola / spin left
161 case 'R': manualLeft = s; manualRight = -s; break; // yerinde sağa / spin right
162 case 'S': manualLeft = 0; manualRight = 0; break; // dur / stop
163 default:
164 if (c >= '0' && c <= '9') manualSpeed = map(c - '0', 0, 9, 100, 240); // hız kademesi / speed level
165 }
166 }
167}
168
169void setup() {
170 int outs[] = {ENA, IN1, IN2, ENB, IN3, IN4, TRIG};
171 for (int p : outs) pinMode(p, OUTPUT);
172 drive(0, 0);
173 pinMode(ECHO, INPUT);
174 pinMode(IR_LEFT, INPUT_PULLUP);
175 pinMode(IR_RIGHT, INPUT_PULLUP);
176 Serial.begin(9600);
177 bt.begin(9600); // HC-05 veri modu hızı / HC-05 data mode baud rate
178 head.attach(SERVO_PIN);
179 head.write(SERVO_CENTER);
180 delay(3000); // yere koyman için süre / time to put it on the floor
181}
182
183void loop() {
184 handleBluetooth();
185 if (autoMode) autoStep();
186 else manualStep();
187}| Functie of instelling | Wat het doet |
|---|---|
| pingCm() | Doet één meting; geeft 400 cm (vrije ruimte) terug als er binnen 25 ms geen echo komt |
| distanceCm() | Doet 3 metingen met 60 ms ertussen en geeft de mediaan terug; gooit een enkele uitschieter weg |
| autoStep() | Meet elke 60 ms; rijdt op basis van de afstand en de IR-sensoren door, vertraagt, wijkt uit of roept avoid() aan |
| avoid() | Stopt, bevestigt de meting, rijdt zo nodig achteruit, kijkt in 4 richtingen en draait naar de meest open richting |
| turnBy(degrees) | Draait de robot ter plekke over de opgegeven hoek; de tijd wordt berekend met MS_PER_DEG |
| manualStep() | Past de richting toe die de telefoon stuurt; stopt bij 15 cm als hij vooruit rijdt, stopt als er 600 ms geen commando binnenkomt |
| SERVO_CENTER, SERVO_DIR | De hoek waarbij de sensor recht vooruit kijkt en welke kant links is |
| STOP_CM, SLOW_CM, BACK_CM | De drempels voor stoppen, vertragen en achteruitrijden |
Voor een obstakelontwijkende robot is een mediaanfilter beter dan een gemiddelde: bij drie metingen zoals 24, 26 en 400 cm komt het gemiddelde uit op 150 cm en misleidt het de robot, terwijl de mediaan 26 cm kiest. Wil je dieper graven, lees dan het artikel over sensordata filteren. Het onderscheid tussen auto- en handmatige modus is eigenlijk ook een kleine toestandsmachine; deze aanpak leggen we uitgebreid uit in de gids Arduino-toestandsmachine. Stem de robot na het uploaden van de code in deze volgorde af op je eigen kamer:
- Servomidden: Zet de robot haaks op een vlakke muur; wijst de sensor er niet recht naartoe, verander SERVO_CENTER dan in kleine stappen zoals 85 of 95.
- Draaitijd: Voeg tijdelijk een regel turnBy(360); toe aan het eind van setup() en kijk of de robot een volledige draai maakt. Draait hij 300 graden in plaats van 360, zet MS_PER_DEG dan op 4.0 × 360 / 300 = 4.8. Omdat deze waarde verandert met de batterij en de vloer, stel je hem af met een volle batterij op de vloer waarop de robot gaat rijden.
- Stopdrempel: Laat de robot op een muur af rijden en meet hoe ver zijn neus van de muur zit waar hij stopt. Is dat minder dan 10 cm, verhoog STOP_CM dan met 5 cm.
- Lage snelheid: Ligt SLOW onder de aanloopdrempel van de motoren, dan blijft de robot in de naderingszone steken; zet SLOW in dat geval op 150.
Dode hoeken van de HC-SR04: zachte oppervlakken, schuine muren en dunne obstakels
Een ultrasone sensor ziet oppervlakken die geluid goed terugkaatsen, maar niet elk obstakel stuurt het geluid naar de sensor terug. De fabrikant adviseert voor goede resultaten een doel van minstens 0,5 m² dat zo vlak mogelijk is. In een echte kamer loopt de robot echter tegen gordijnen, banken, stoelpoten en muurhoeken aan. Geluid kaatst terug onder dezelfde hoek als waaronder het aankomt, zoals een biljartbal: een sensor die haaks op een muur staat krijgt een sterke echo, maar wijkt zijn zichtlijn meer dan ongeveer 30–40 graden van de loodlijn af, dan ketst het geluid in een andere richting weg en komt het nooit terug. In dat geval geeft pulseIn() 0 terug en denkt de code dat de weg vrij is. Dit is de meest voorkomende reden dat robots langs muren schrapen.
| Obstakel of oppervlak | Waarom het niet wordt gezien | Oplossing |
|---|---|---|
| Gordijnen, banken, kussens, kleding, dierenhaar | Zachte, poreuze oppervlakken absorberen geluid en de echo komt zeer zwak terug | Voeg een IR-sensor voor de korte afstand toe en laat de robot langzaam rijden |
| Schuin naar een muur toe rijden | Het geluid kaatst weg en de echo bereikt de sensor niet | Voeg naar buiten gerichte IR-sensoren toe op de voorhoeken en scan op kleinere hoeken |
| Stoel- en tafelpoten, dunne palen | Het reflecterende oppervlak is klein en de echo is zwak | Verlaag de snelheid, gebruik het mediaanfilter, voeg IR-sensoren toe aan de zijkanten |
| Lage obstakels onder de sensor (kabels, drempels, pantoffels) | Ze blijven onder de geluidskegel | Voeg een naar beneden gerichte IR-sensor of een microschakelaar op de voorbumper toe |
| Tafelranden, trapgaten | De ultrasone sensor kijkt naar voren en ziet geen gat in de vloer | Valdetectie met een naar de vloer gerichte TCRT5000 |
| Objecten dichterbij dan 2 cm | De dode zone van de sensor: de echo komt terug voordat de geluidspuls klaar is | Laat de robot bij 12 cm achteruit rijden |
| Hoeken en smalle gangen | Geluid kaatst heen en weer tussen twee muren en komt laat terug, waardoor de afstand groter lijkt | Mediaanfilter en metingen vanuit meerdere hoeken |
IR-sensoren toevoegen
Ultrasone en infraroodsensoren (IR) maken elkaars zwakke punten goed. IR-obstakelsensoren zoals de FC-51 bestaan uit een infrarood-led en een ontvanger; is het gereflecteerde licht sterk genoeg, dan trekt de LM393-comparator de uitgang LOW en gaat de led op het board branden. Het bereik is met een trimpot instelbaar van ongeveer 2 tot 30 cm, maar hij meet geen afstand, hij zegt alleen "obstakel" of "geen obstakel". Plaats je twee IR-sensoren op de voorhoeken van de robot, 30–45 graden naar buiten gericht, dan vangen ze stoelpoten en schuine muren op die buiten de smalle kegel van de ultrasone sensor vallen. In de geavanceerde code wijkt de robot kort naar rechts uit als de linker IR aanslaat en naar links als de rechter IR aanslaat; slaan beide tegelijk aan, dan stopt hij en scant alsof er een obstakel voor hem staat.
| Eigenschap | HC-SR04 (ultrasoon) | FC-51 (IR-obstakel) | TCRT5000 (IR-reflectie) |
|---|---|---|---|
| Uitgang | Afstand (cm) | Ja / nee (digitaal) | Analoge waarde en digitale uitgang |
| Bereik | 2–400 cm | Ongeveer 2–30 cm (instelbaar) | Ongeveer 1–15 mm |
| Detectiehoek | Ongeveer 15° | Ongeveer 35° | Zeer smal |
| Zwak punt | Zachte, schuine en dunne oppervlakken | Zwarte, matte oppervlakken, zonlicht | Hoogteverschillen, zonlicht |
| Ziet goed | Glas, zwarte objecten, grote vlakke oppervlakken | Stof, hoeken, obstakels dichtbij | Vloerkleur en tafelranden |
| Plaats op de robot | Hoofdoog, gezwenkt door de servo | Voorhoeken | Onder de voorbumper, naar de vloer gericht |

Voor robots die op een tafel rondrijden is het gevaarlijkste obstakel eigenlijk een afgrond. Monteer je een naar de vloer gerichte TCRT5000-module onder de voorbumper, dan weet je op het moment dat de vloer eronder verdwijnt. Sluit de digitale uitgang van de module aan op D2, die op de Uno nog vrij is; controleer eerst in de Serial Monitor naar welk niveau de uitgang gaat als er geen vloer is, lees deze pin dan helemaal aan het begin van autoStep() uit en stop, als de vloer weg is, meteen de motoren en laat de robot achteruit rijden. Deze controle moet vóór de afstandsmeting komen; vallen kost altijd meer dan botsen.
Overschakelen naar handmatige modus via Bluetooth
Soms wil je de autonome robot met de hand besturen: om hem van de ene kamer naar de andere te brengen, om hem voor een obstakel te zetten en zijn reactie te testen, of gewoon om te spelen. De HC-05-verbinding in de geavanceerde code maakt dat mogelijk. Stuurt de telefoon de letter A, dan schakelt de robot over op automodus; bij M schakelt hij over op handmatige modus. In handmatige modus worden de besturingsletters uit de gids voor de robotauto gebruikt (F, B, L, R, S), met één verschil: ziet de robot tijdens het vooruit rijden een obstakel dichterbij dan 15 cm, dan stopt hij ondanks jouw commando. Deze botsbeveiliging laat je ook bij handmatig rijden profiteren van de sensoren van de autonome robot. De koppelstappen en AT-commando's van de HC-05 staan in het artikel HC-05 Bluetooth-module.
| Letter | Actie | In welke modus? |
|---|---|---|
| A | Overschakelen naar automodus | Beide modi |
| M | Overschakelen naar handmatige modus, robot stoppen | Beide modi |
| F / B | Vooruit / achteruit | Handmatig |
| L / R | Ter plekke naar links / rechts draaien | Handmatig |
| S | Stoppen | Handmatig |
| 0–9 | Snelheidsniveau (PWM 100–240) | Handmatig |
- Sluit de TXD-pin van de HC-05 aan op D10, de RXD-pin via een 1 kΩ / 2 kΩ-spanningsdeler op D11, VCC op 5V en GND op GND.
- Koppel de HC-05 in de Bluetooth-instellingen van je Android-telefoon met de pincode 1234 (of 0000 als dat niet lukt).
- Installeer een Bluetooth-afstandsbedieningsapp voor autootjes uit de Play Store en verbind die met de HC-05. Laat je de Arduino op USB aangesloten en open je de Serial Monitor op 9600 baud, dan print de code elke letter die van de telefoon binnenkomt.
- De meeste afstandsbedieningsapps hebben extra knoppen, zoals verlichting of claxon, en elke knop stuurt zijn eigen letter. Zoek deze letters op in de Serial Monitor en zet ze in de code in de plaats van 'A' en 'M'; wil je de knoppen liever zelf bepalen, dan kun je met de gids App Inventor Arduino Bluetooth je eigen afstandsbediening bouwen.
- Trek de USB-kabel los en zet de schakelaar om; na 3 seconden vertrekt de robot in automodus. Schakel over op handmatige modus en rijd hem vanaf je telefoon.
Bouwen met een L293D-motorshield

Houd je niet van een wirwar van draden, dan kun je in plaats van de L298N een L293D-motorshield gebruiken (de Adafruit Motor Shield V1 en kloons) dat rechtstreeks op de Arduino Uno past. Het shield kan vier gelijkstroommotoren aansturen, heeft twee servoheaders en voedt de servo's vanuit de 5V-rail van de Arduino. De motoren zijn niet rechtstreeks met de Arduino-pins verbonden maar via het 74HC595-schuifregister op het board, dus je stuurt ze aan met de Adafruit Motor Shield-bibliotheek (die voor V1, niet V2), dus AFMotor, te installeren via de Library Manager. Het shield gebruikt D3, D4, D5, D6, D7, D8, D11 en D12 voor de motoren en D9 en D10 voor de servo's; A0–A5, D2 en D13 blijven vrij. Omdat de HC-SR04 en de IR-sensoren al op A0–A3 zitten, hoef je alleen de motorcode, de servopin en de HC-05-pins te wijzigen.
| Instelling | Met de L298N | Met het L293D-shield |
|---|---|---|
| Motoraansluiting | Klemmen OUT1–OUT4 | Klemmen M1 (links) en M2 (rechts) |
| Motorcode | digitalWrite en analogWrite in drive() | AFMotor in drive() |
| SERVO_PIN | 3 | 9 of 10, afhankelijk van de header waarin je de servo steekt |
| HC-05 | D10, D11 | A4 (RX) en A5 (TX): SoftwareSerial bt(A4, A5) |
| Stroom per kanaal | 2 A continu | 0,6 A continu, 1,2 A piek |
| Motorvoeding | 12V-klem | EXT_PWR-klem; met de PWR-jumper geplaatst draait de Arduino op dezelfde voeding |
1// L293D shield: ENA–IN4 tanımlarını ve setup()'taki pinMode listesinden bu pinleri sil, drive() fonksiyonunu aşağıdakiyle değiştir
2// L293D shield: delete the ENA–IN4 definitions, remove them from the pinMode list in setup() and replace drive() with the one below
3// Ayrıca / Also: SERVO_PIN = 9 ya da / or 10, SoftwareSerial bt(A4, A5)
4#include <AFMotor.h> // Adafruit Motor Shield V1 kütüphanesi / library
5
6AF_DCMotor leftMotor(1); // M1 klemensi / M1 terminal
7AF_DCMotor rightMotor(2); // M2 klemensi / M2 terminal
8
9void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
10 leftMotor.setSpeed(min(abs(left), 255));
11 rightMotor.setSpeed(min(abs(right), 255));
12 leftMotor.run(left > 0 ? FORWARD : (left < 0 ? BACKWARD : RELEASE));
13 rightMotor.run(right > 0 ? FORWARD : (right < 0 ? BACKWARD : RELEASE));
14}De limiet van 0,6 A per kanaal van de L293D is genoeg voor normaal rijden met een 2WD-robot met TT-motoren, maar als een wiel tegen een obstakel duwt en vastloopt, kan de motor meer dan 1 A trekken en wordt de chip snel warm. Daarom verlengt een scanalgoritme dat de robot laat stoppen voordat hij tegen een obstakel drukt ook de levensduur van het shield. De jumperinstellingen van het shield en een sketch voor een auto met vier motoren staan in het artikel L293D-motorshield, en de werking van de L298N in de gids Gelijkstroommotor aansturen met de L298N.
Obstakelontwijkende robot met een ESP32
Op de ESP32 zijn er twee belangrijke verschillen. Ten eerste werkt de Servo-bibliotheek van Arduino niet op de ESP32, dus genereren we het servosignaal rechtstreeks met LEDC, de PWM-eenheid van het board: in een signaal van 50 Hz komt een puls van 0,544–2,4 ms overeen met 0–180 graden. Omdat de motoren op 1 kHz draaien en de servo op 50 Hz, worden eerst de motorkanalen ingesteld en daarna het servokanaal, zodat de servo een eigen timer krijgt. Ten tweede heeft de ESP32 klassieke Bluetooth ingebouwd, dus een HC-05 is niet nodig; de robot verschijnt op de telefoon als "BlueGrays-Robot" en de richtings- en modusletters zijn dezelfde als in de Uno-versie. De code is voor versie 3.x van de ESP32 Arduino-core (ledcAttach en ledcWrite werken met pinnummers) en omdat hij klassieke Bluetooth nodig heeft, compileert hij niet voor de ESP32-S3 of ESP32-C3.
1// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
2#include "BluetoothSerial.h"
3
4const int ENA = 25, IN1 = 27, IN2 = 33; // sol motor / left motor
5const int ENB = 26, IN3 = 32, IN4 = 4; // sağ motor / right motor
6const int SERVO_PIN = 13;
7const int TRIG = 18, ECHO = 19; // ECHO 1 kΩ / 2 kΩ bölücüyle / ECHO via a 1 kΩ / 2 kΩ divider
8const int IR_LEFT = 23, IR_RIGHT = 22; // LOW = engel / LOW = obstacle
9
10const int BACK_CM = 12, STOP_CM = 25, SLOW_CM = 60, GUARD_CM = 15, MAX_CM = 400;
11const int CRUISE = 200, SLOW = 130, TURN = 170;
12const int SERVO_CENTER = 90, SERVO_DIR = 1;
13const float MS_PER_DEG = 4.0; // kalibre et / calibrate
14
15BluetoothSerial bt;
16bool autoMode = true;
17int manualLeft = 0, manualRight = 0;
18unsigned long lastCmd = 0, lastPing = 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 ledcWrite(ENA, abs(left));
26 ledcWrite(ENB, abs(right));
27}
28
29void servoWrite(int angle) { // 0–180° → 544–2400 µs
30 angle = constrain(angle, 0, 180);
31 uint32_t us = map(angle, 0, 180, 544, 2400);
32 ledcWrite(SERVO_PIN, us * 16384 / 20000); // 14 bit, 20 ms periyot / 14-bit, 20 ms period
33}
34
35int pingCm() {
36 digitalWrite(TRIG, LOW); delayMicroseconds(2);
37 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
38 digitalWrite(TRIG, LOW);
39 unsigned long t = pulseIn(ECHO, HIGH, 25000UL);
40 return t == 0 ? MAX_CM : (int)(t / 58);
41}
42
43int distanceCm() { // 3 ölçümün ortancası / median of 3 readings
44 int a = pingCm(); delay(60);
45 int b = pingCm(); delay(60);
46 int c = pingCm();
47 return max(min(a, b), min(max(a, b), c));
48}
49
50bool irBlocked(int pin) { return digitalRead(pin) == LOW; }
51
52void turnBy(int deg) { // + sola, - sağa / + left, - right
53 if (deg > 0) drive(-TURN, TURN);
54 else drive(TURN, -TURN);
55 delay((unsigned long)(abs(deg) * MS_PER_DEG));
56 drive(0, 0);
57 delay(100);
58}
59
60void avoid() {
61 drive(0, 0);
62 delay(120);
63 int front = distanceCm();
64 bool sides = irBlocked(IR_LEFT) || irBlocked(IR_RIGHT);
65 if (front >= STOP_CM && !sides) return; // yanlış alarm / false alarm
66 if (front < BACK_CM || sides) { // geri çekil / back off
67 drive(-TURN, -TURN);
68 delay(350);
69 drive(0, 0);
70 }
71 const int offsets[] = {70, 35, -35, -70};
72 int bestOffset = 0, bestCm = 0;
73 for (int off : offsets) {
74 servoWrite(SERVO_CENTER + SERVO_DIR * off);
75 delay(300);
76 int cm = distanceCm();
77 if (cm > bestCm) { bestCm = cm; bestOffset = off; }
78 }
79 servoWrite(SERVO_CENTER);
80 delay(200);
81 if (bestCm < STOP_CM + 10) { // çıkmaz / dead end
82 drive(-TURN, -TURN);
83 delay(400);
84 turnBy(180);
85 } else {
86 turnBy(bestOffset);
87 }
88}
89
90void setup() {
91 int outs[] = {IN1, IN2, IN3, IN4, TRIG};
92 for (int p : outs) pinMode(p, OUTPUT);
93 pinMode(ECHO, INPUT);
94 pinMode(IR_LEFT, INPUT_PULLUP);
95 pinMode(IR_RIGHT, INPUT_PULLUP);
96 ledcAttach(ENA, 1000, 8); // motor PWM: 1 kHz, 8 bit
97 ledcAttach(ENB, 1000, 8);
98 ledcAttach(SERVO_PIN, 50, 14); // servo: 50 Hz, 14 bit
99 drive(0, 0);
100 servoWrite(SERVO_CENTER);
101 bt.begin("BlueGrays-Robot"); // telefonda görünecek ad / name shown on the phone
102 delay(3000);
103}
104
105void loop() {
106 while (bt.available()) {
107 char c = bt.read();
108 lastCmd = millis();
109 if (c == 'A') autoMode = true; // otomatik / auto
110 else if (c == 'M') { // manuel / manual
111 autoMode = false;
112 manualLeft = manualRight = 0;
113 servoWrite(SERVO_CENTER);
114 }
115 else if (!autoMode) {
116 if (c == 'F') { manualLeft = 200; manualRight = 200; } // ileri / forward
117 else if (c == 'B') { manualLeft = -200; manualRight = -200; } // geri / backward
118 else if (c == 'L') { manualLeft = -200; manualRight = 200; } // sola / left
119 else if (c == 'R') { manualLeft = 200; manualRight = -200; } // sağa / right
120 else if (c == 'S') { manualLeft = 0; manualRight = 0; } // dur / stop
121 }
122 }
123
124 if (millis() - lastPing < 60) return; // 60 ms'de bir / every 60 ms
125 lastPing = millis();
126 int d = pingCm();
127
128 if (!autoMode) {
129 if (millis() - lastCmd > 600) manualLeft = manualRight = 0; // komut yok: dur / no command: stop
130 bool forward = manualLeft > 0 && manualRight > 0;
131 if (forward && d < GUARD_CM) drive(0, 0); // çarpışma koruması / collision guard
132 else drive(manualLeft, manualRight);
133 return;
134 }
135
136 bool l = irBlocked(IR_LEFT), r = irBlocked(IR_RIGHT);
137 if (d < STOP_CM || (l && r)) avoid();
138 else if (l) { drive(TURN, -TURN); delay(150); }
139 else if (r) { drive(-TURN, TURN); delay(150); }
140 else if (d < SLOW_CM) { int s = map(d, STOP_CM, SLOW_CM, SLOW, CRUISE); drive(s, s); }
141 else drive(CRUISE, CRUISE);
142}Obstakelontwijkende robot met een Raspberry Pi Pico (MicroPython)
Op de Raspberry Pi Pico werkt de functie time_pulse_us() van MicroPython zoals pulseIn() van Arduino; ze geeft een negatieve waarde terug als er geen echo komt, dus behandelen we dat als 400 cm, oftewel vrije ruimte. Voor de servo gebruiken we PWM van 50 Hz en duty_ns(), dat de pulsbreedte in nanoseconden neemt. De servo op GP16 en de snelheidspins van de motoren op GP15 en GP10 zitten op verschillende PWM-slices, dus ze verstoren elkaars frequentie niet. Dit keer worden de snelheden als percentages opgegeven. De Pico heeft geen Bluetooth, dus wil je handmatige modus, sluit dan een HC-05 aan op UART0 (GP0, GP1) zoals in de gids voor de robotauto.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4ena = PWM(Pin(15)); ena.freq(1000) # sol motor hızı / left motor speed
5enb = PWM(Pin(10)); enb.freq(1000) # sağ motor hızı / right motor speed
6in1, in2 = Pin(14, Pin.OUT), Pin(13, Pin.OUT)
7in3, in4 = Pin(12, Pin.OUT), Pin(11, Pin.OUT)
8servo = PWM(Pin(16)); servo.freq(50) # servo sinyali, 50 Hz / servo signal, 50 Hz
9trig = Pin(17, Pin.OUT, value=0)
10echo = Pin(18, Pin.IN) # 1 kΩ / 2 kΩ bölücü üzerinden / via a 1 kΩ / 2 kΩ divider
11ir_left = Pin(19, Pin.IN, Pin.PULL_UP) # 0 = engel / 0 = obstacle
12ir_right = Pin(20, Pin.IN, Pin.PULL_UP)
13
14STOP_CM, BACK_CM = 25, 12
15CRUISE, TURN = 75, 65 # hız yüzdesi / speed in percent
16MS_PER_DEG = 4 # kalibre et / calibrate
17SERVO_CENTER = 90 # öne bakmıyorsa düzelt / adjust if not facing ahead
18
19def drive(left, right): # -100 … 100 (%)
20 in1.value(left > 0); in2.value(left < 0)
21 in3.value(right > 0); in4.value(right < 0)
22 ena.duty_u16(int(min(abs(left), 100) * 655))
23 enb.duty_u16(int(min(abs(right), 100) * 655))
24
25def head(offset): # + sol, - sağ / + left, - right
26 angle = max(0, min(180, SERVO_CENTER + offset))
27 servo.duty_ns((544 + angle * 1856 // 180) * 1000) # 0,544–2,4 ms darbe / 0.544–2.4 ms pulse
28
29def ping_cm():
30 trig.value(1); time.sleep_us(10); trig.value(0) # 10 µs tetik / 10 µs trigger
31 t = time_pulse_us(echo, 1, 25000)
32 return 400 if t < 0 else t // 58 # negatif = yankı yok / negative = no echo
33
34def distance_cm(): # 3 ölçümün ortancası / median of 3 readings
35 r = []
36 for _ in range(3):
37 r.append(ping_cm())
38 time.sleep_ms(60)
39 return sorted(r)[1]
40
41def turn_by(deg): # + sola, - sağa / + left, - right
42 if deg > 0:
43 drive(-TURN, TURN)
44 else:
45 drive(TURN, -TURN)
46 time.sleep_ms(int(abs(deg) * MS_PER_DEG))
47 drive(0, 0)
48 time.sleep_ms(100)
49
50def avoid():
51 drive(0, 0)
52 time.sleep_ms(120)
53 front = distance_cm()
54 sides = not ir_left.value() or not ir_right.value()
55 if front >= STOP_CM and not sides:
56 return # yanlış alarm / false alarm
57 if front < BACK_CM or sides: # geri çekil / back off
58 drive(-TURN, -TURN); time.sleep_ms(350); drive(0, 0)
59 best_off, best_cm = 0, 0
60 for off in (70, 35, -35, -70): # tara / scan
61 head(off)
62 time.sleep_ms(300)
63 cm = distance_cm()
64 if cm > best_cm:
65 best_off, best_cm = off, cm
66 head(0)
67 time.sleep_ms(200)
68 if best_cm < STOP_CM + 10: # çıkmaz / dead end
69 drive(-TURN, -TURN); time.sleep_ms(400)
70 turn_by(180)
71 else:
72 turn_by(best_off)
73
74drive(0, 0)
75head(0)
76time.sleep(3) # yere koyman için süre / time to put it down
77while True:
78 d = ping_cm()
79 left_hit, right_hit = not ir_left.value(), not ir_right.value()
80 if d < STOP_CM or (left_hit and right_hit):
81 avoid()
82 elif left_hit:
83 drive(TURN, -TURN); time.sleep_ms(150) # sağa kaç / dodge right
84 elif right_hit:
85 drive(-TURN, TURN); time.sleep_ms(150) # sola kaç / dodge left
86 else:
87 drive(CRUISE, CRUISE)
88 time.sleep_ms(60) # ölçümler arası / between readingsProjectideeën met een obstakelontwijkende robot
- Radardisplay: Stuur de hoeken en afstanden van de scan via de seriële poort door en teken een groen radarscherm op je computer; details in het artikel Arduino-radarproject.
- Lijn plus obstakel: Laat de robot om een doos op zijn pad heen rijden terwijl hij een baan volgt zoals een lijnvolgrobot, en dan terugkeren naar de lijn; een veelvoorkomende wedstrijdopdracht.
- Muurvolgrobot: Houd de sensor 60 graden naar rechts gedraaid en rijd op een constante afstand van 20 cm van de muur; het is de eerste stap naar het oplossen van doolhoven.
- Robot met display: Toon de afstand en de modus op een klein OLED-display; debuggen wordt een stuk makkelijker.
- Prototype van een robotstofzuiger: Schets een schoonmaakrobot die met willekeurige richtingskeuzes, botsschakelaars en een valsensor door het huis rijdt.
- Slimme stok: Maak van dezelfde afstandsmeetlogica een trillende waarschuwing voor slechtziende mensen; zie Arduino slimme stok.
- School- of wedstrijdproject: Presenteer het met een hindernisparcours, tijdmeting en een demo van de auto- en handmatige modus; voor ideeën kun je het artikel Arduino-projectideeën voor wetenschapswedstrijden bekijken.
Veelgemaakte fouten en hoe je ze oplost
| Probleem | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De robot knalt tegen de muur zonder te stoppen | De sensor leest 0 (kapotte draad, TRIG en ECHO verwisseld) en de code behandelt dat als vrije ruimte | Voer de testsketch uit, probeer 10–60 cm met je hand, controleer de TRIG- en ECHO-pins |
| Hij schraapt langs de muur bij schuin naderen | Het geluid kaatst van het schuine oppervlak in een andere richting weg | Voeg IR-sensoren toe op de voorhoeken en verlaag de snelheid |
| De Arduino reset als hij stopt om te scannen | De stroom van servo en motoren laat de 5V-rail instorten | Condensator van 470 µF op de servo, volledig opgeladen 18650-cellen; voed de servo zo nodig uit een aparte 5V-bron |
| De robot stopt en scant zonder reden | Een enkele slechte meting of een echo van de vloer | Zet de sensor op 8–12 cm hoogte en kantel hem iets omhoog; gebruik de bevestiging met de mediaan |
| De robot draait naar de geblokkeerde kant | De servo is andersom gemonteerd, links en rechts zijn omgedraaid | Zet SERVO_DIR op -1 |
| Bochten zijn veel te kort of te lang | MS_PER_DEG is niet gekalibreerd of de batterij is bijna leeg | Meet met turnBy(360) en stel opnieuw af met een volle batterij |
| Hij blijft in een hoek links en rechts draaien | Beide kanten zitten dicht bij de drempel en de beslissing slaat steeds om | Verhoog de drempel voor doodlopend (STOP_CM + 10) of laat hem de laatste draairichting verkiezen |
| De sensorkop schokt | Zwakke servovoeding of interrupts van SoftwareSerial | Kort de servokabel in, voeg een condensator toe, stuur Bluetooth-commando's niet vaker dan nodig |
Omdat een obstakelontwijkende robot het uitlezen van sensoren, filteren, beslissen en motorsturing in één project combineert, is hij de beste manier om met robotica te beginnen. Bekijk eerst het basisgedrag met de eerste sketch, stem daarna de drempels met de geavanceerde versie af op je kamer en versterk je robot tot slot met IR-sensoren en Bluetooth. In de BlueGrays-app vind je de projecten obstakelontwijkende robot, Bluetooth-bestuurde auto met de L298N, afstandsmeting met de HC-SR04 en parkeersensor stap voor stap, met schakelschema's en code.
Veelgestelde vragen
Wat heb je nodig om een obstakelontwijkende robot te bouwen?
Een eenvoudige obstakelontwijkende robot heeft een Arduino Uno, een HC-SR04 ultrasone sensor, een SG90-servo, een L298N- of L293D-motordriver, een 2WD-chassisset met twee gelijkstroommotoren met tandwielreductie en twee 18650-cellen nodig. Je kunt twee IR-obstakelsensoren toevoegen om de hoeken te zien en een HC-05 Bluetooth-module om hem vanaf je telefoon te besturen.
Kun je een obstakelontwijkende robot bouwen zonder servo?
Ja. De sensor wijst recht vooruit; ziet de robot een obstakel, dan draait hij eerst één kant op en meet opnieuw, en is het pad nog steeds geblokkeerd, dan draait hij de andere kant op. Dat is goedkoper, maar de robot beslist langzamer omdat hij bij elke poging zijn hele lichaam moet draaien; met een servo vindt hij de meest open richting voordat hij draait.
Waarom ziet de HC-SR04 sommige obstakels niet?
Een ultrasone sensor meet met een echo. Zachte oppervlakken zoals gordijnen en banken absorberen geluid, schuine muren kaatsen het in een andere richting terug en dunne objecten zoals stoelpoten geven een zeer zwakke echo. De sensor ziet ook geen obstakels buiten of onder zijn kegel van ongeveer 15 graden; die gaten kun je met IR-sensoren afdekken.
Op welke afstand moet een obstakelontwijkende robot stoppen?
25 cm is een goede beginwaarde: de afstand tussen twee metingen, de remafstand en de marge die nodig is om ter plekke te draaien tellen samen op tot ongeveer 20 cm, plus een kleine veiligheidsmarge. Voor snellere robots en gladde vloeren verhoog je hem naar 30–35 cm; bij een obstakel dichterbij dan 12 cm moet de robot eerst achteruit rijden.
Wat is beter voor een robot, de L298N of een L293D-shield?
De L298N kan 2 A per kanaal leveren, dus hij is robuuster en laat je de pins vrij kiezen. Het L293D-shield past op de Uno, dus er is minder bedrading en hij kan vier motoren aansturen, maar zijn continue stroom is 0,6 A per kanaal en hij neemt veel pins in beslag. Voor een kleine 2WD-robot met TT-motoren voldoet allebei.
Kun je een obstakelontwijkende robot met een telefoon besturen?
Ja. Voeg een HC-05 Bluetooth-module toe en stuur letters vanuit een afstandsbedieningsapp op een Android-telefoon om te wisselen tussen auto- en handmatige modus. Door de ultrasone sensor in handmatige modus als botsbeveiliging te gebruiken, rijd je de robot niet tegen een muur. Met een ESP32 heb je dankzij de ingebouwde Bluetooth geen aparte module nodig.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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…

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.

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

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

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.

ESP32 HC-SR04 ultrasone afstandssensor
De ultrasone sensor HC-SR04 meet afstand door te timen hoe lang zijn geluidspuls erover doet om van een voorwerp terug te kaatsen (time of flight). In dit project stuurt de ESP32 een puls van 10 microseconden naar de TRIG-pin en leest hij de echotijd met pulseIn() van de ECHO-pin. De afstand wordt in cm getoond op een 16x2 I2C-LCD. De HC-SR04 werkt op 5V, dus de ECHO-pin heeft een spanningsdeler nodig, anders raakt de 3,3V-GPIO van de ESP32 beschadigd.
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

