Gidsen · 18 min leestijd

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.

HC-SR04 ultrasone afstandssensor
HC-SR04: de transducer met de T zendt een geluid van 40 kHz uit en die met de R luistert naar de echo. Dit is het oog van de obstakelontwijkende robot; hij meet 2–400 cm binnen een smalle hoek van ongeveer 15 graden.

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.

OnderdeelTaakOpmerking
Arduino Uno (of Nano)Brein: meet, beslist en stuurt de motoren aanEen ESP32 of Pico werkt ook
HC-SR04Oog: meet de afstand tot het obstakel voor jeWerkt op 5 V, 2–400 cm
SG90 servoNek: draait de sensor naar links en rechtsDe sensor wordt met een plastic beugel op de servohoorn vastgezet
L298N of L293D-shieldSpieren: geven de motoren richting en snelheidEen Arduino-pin kan geen motorstroom leveren
2 TT-motoren met reductie en een zwenkwielDifferentiële aandrijvingDraaien gebeurt door de twee wielen in tegengestelde richting te laten draaien
2 × 18650-cellen (7,4 V)VoedingEen 9V-batterij is niet genoeg
2 IR-obstakelsensoren (optioneel)Vangen obstakels op bij de hoeken en zijkantenModules op basis van de LM393, zoals de FC-51
HC-05 (optioneel)Handmatige bediening vanaf je telefoonWerkt alleen met Android
Arduino Uno
Arduino Uno
L298N
L298N
TT motor
TT motor
18650 Li-ion
18650 Li-ion

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.

OnderdeelGevoed vanuitTypische stroom
2 TT-motorenL298N 12V-klem ← 2 × 18650 (7,4 V)0,3–0,6 A tijdens het rijden, tot 2 A bij het opstarten
Arduino UnoVIN ← plus van de batterij (na de schakelaar)Ongeveer 50 mA
SG90 servo5V van de Arduino + condensator van 470 µF~10 mA in rust, 100–250 mA tijdens het bewegen
HC-SR04Arduino 5VOngeveer 15 mA
2 IR-sensorenArduino 5V20–40 mA per stuk
HC-05Arduino 5V30–40 mA tijdens het koppelen, ongeveer 10 mA als er verbinding is
Verbind alle GND's met elkaar (min van de batterij, L298N, Arduino, servo, sensoren); zonder gemeenschappelijke massa meet de sensor onzinnige afstanden en trilt de servo. Voed de servo niet via dezelfde dunne jumperdraad als de motoren. Gebruik je een sterkere servo zoals een MG90S of MG996R, voed die dan niet vanuit de Arduino maar via een aparte step-downmodule die op 5 V staat (bijvoorbeeld een LM2596).

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.

AansluitingArduino UnoESP32Raspberry Pi Pico
L298N ENA (snelheid linkermotor)D5GPIO 25GP15
L298N IN1, IN2D7, D8GPIO 27, 33GP14, GP13
L298N ENB (snelheid rechtermotor)D6GPIO 26GP10
L298N IN3, IN4D9, D4GPIO 32, 4GP12, GP11
Servosignaal (oranje)D3GPIO 13GP16
Servo + (rood), − (bruin)5V, GNDL298N 5V, GNDL298N 5V, GND
HC-SR04 TRIGA0GPIO 18GP17
HC-SR04 ECHOA1 (rechtstreeks)GPIO 19, via een 1 kΩ / 2 kΩ-spanningsdelerGP18, via een 1 kΩ / 2 kΩ-spanningsdeler
HC-SR04 VCC5VL298N 5VL298N 5V
OUT van IR links, OUT van IR rechtsA2, A3GPIO 23, 22GP19, GP20
VCC van de IR-sensor5V3V33V3
HC-05 TXD, RXDD10, D11 (RXD via spanningsdeler)Niet nodig (ingebouwde Bluetooth)GP1, GP0 (UART0)
Voeding van het boardVIN ← batterij (na de schakelaar)5V (VIN) ← L298N 5VVSYS ← L298N 5V
De ECHO-pin van de HC-SR04 geeft een signaal van 5 V, terwijl de pins van de ESP32 en Pico op 3,3 V werken en niet 5V-tolerant zijn. Bouw een spanningsdeler: ECHO → 1 kΩ → punt naar het board → 2 kΩ → GND: 5 V × 2 / 3 ≈ 3,3 V. TRIG heeft geen deler nodig; een signaal van 3,3 V is genoeg om de sensor te triggeren. Op de ESP32 en Pico delen het board, de servo en de HC-SR04 dezelfde 5V-uitgang van de L298N, dus je kunt de limiet van ongeveer 0,5 A van die kleine regelaar naderen; zie je resets, voed de servo dan uit een aparte 5V-bron.

De sensorkop monteren en testen

SG90 micro-servomotor
SG90: een micro-servo van 9 gram die bij 4,8 V in ongeveer 0,1 seconde 60 graden draait. De plastic beugel met de HC-SR04 wordt op de servohoorn geschroefd.
  1. 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".
  2. 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.
  3. 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.
  4. 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.
  5. 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.
C++ (Arduino IDE)
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 afstandZoneWat de robot doet
Meer dan 60 cm (of geen echo)VrijVolle snelheid vooruit (PWM 200)
25–60 cmNaderingVertraagt evenredig met de afstand (PWM 200 naar 130)
12–25 cmObstakelStopt, bevestigt de meting, scant beide kanten op, draait naar de meest open richting
Minder dan 12 cmTe dichtbijRijdt eerst 350 ms achteruit en scant dan
Elke richting minder dan 35 cmDoodlopendRijdt 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.

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

C++ (Arduino IDE)
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 instellingWat 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_DIRDe hoek waarbij de sensor recht vooruit kijkt en welke kant links is
STOP_CM, SLOW_CM, BACK_CMDe 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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 oppervlakWaarom het niet wordt gezienOplossing
Gordijnen, banken, kussens, kleding, dierenhaarZachte, poreuze oppervlakken absorberen geluid en de echo komt zeer zwak terugVoeg een IR-sensor voor de korte afstand toe en laat de robot langzaam rijden
Schuin naar een muur toe rijdenHet geluid kaatst weg en de echo bereikt de sensor nietVoeg naar buiten gerichte IR-sensoren toe op de voorhoeken en scan op kleinere hoeken
Stoel- en tafelpoten, dunne palenHet reflecterende oppervlak is klein en de echo is zwakVerlaag de snelheid, gebruik het mediaanfilter, voeg IR-sensoren toe aan de zijkanten
Lage obstakels onder de sensor (kabels, drempels, pantoffels)Ze blijven onder de geluidskegelVoeg een naar beneden gerichte IR-sensor of een microschakelaar op de voorbumper toe
Tafelranden, trapgatenDe ultrasone sensor kijkt naar voren en ziet geen gat in de vloerValdetectie met een naar de vloer gerichte TCRT5000
Objecten dichterbij dan 2 cmDe dode zone van de sensor: de echo komt terug voordat de geluidspuls klaar isLaat de robot bij 12 cm achteruit rijden
Hoeken en smalle gangenGeluid kaatst heen en weer tussen twee muren en komt laat terug, waardoor de afstand groter lijktMediaanfilter en metingen vanuit meerdere hoeken
Wat één sensor niet ziet afdekken met een andere sensor is altijd effectiever dan proberen één sensor perfect te maken. Maar je eerste stap moet zijn: langzamer rijden. Een robot die met 0,3 m/s rijdt botst na dezelfde slechte meting minder hard dan eentje met 0,7 m/s, en er is nog tijd voor een tweede meting. De sterke en zwakke punten van verschillende afstandssensoren hebben we verzameld in het artikel Arduino-afstandssensoren vergeleken.

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.

EigenschapHC-SR04 (ultrasoon)FC-51 (IR-obstakel)TCRT5000 (IR-reflectie)
UitgangAfstand (cm)Ja / nee (digitaal)Analoge waarde en digitale uitgang
Bereik2–400 cmOngeveer 2–30 cm (instelbaar)Ongeveer 1–15 mm
DetectiehoekOngeveer 15°Ongeveer 35°Zeer smal
Zwak puntZachte, schuine en dunne oppervlakkenZwarte, matte oppervlakken, zonlichtHoogteverschillen, zonlicht
Ziet goedGlas, zwarte objecten, grote vlakke oppervlakkenStof, hoeken, obstakels dichtbijVloerkleur en tafelranden
Plaats op de robotHoofdoog, gezwenkt door de servoVoorhoekenOnder de voorbumper, naar de vloer gericht
TCRT5000 infraroodreflectiesensor
TCRT5000: naar beneden gericht gemonteerd, 5–10 mm boven de vloer, merkt hij tafelranden en trapgaten op; zodra de reflectie verdwijnt, kan de robot stoppen en achteruit rijden.

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.

LetterActieIn welke modus?
AOverschakelen naar automodusBeide modi
MOverschakelen naar handmatige modus, robot stoppenBeide modi
F / BVooruit / achteruitHandmatig
L / RTer plekke naar links / rechts draaienHandmatig
SStoppenHandmatig
0–9Snelheidsniveau (PWM 100–240)Handmatig
  1. 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.
  2. Koppel de HC-05 in de Bluetooth-instellingen van je Android-telefoon met de pincode 1234 (of 0000 als dat niet lukt).
  3. 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.
  4. 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.
  5. 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.
Op de Uno houdt SoftwareSerial andere interrupts ongeveer 1 ms tegen terwijl hij een byte ontvangt; in die tijd kunnen de pulsen van de Servo-bibliotheek uitrekken en kan de sensorkop licht schokken. Het heeft geen invloed op het gedrag van de robot, maar stoort het je, dan kun je overstappen op de ingebouwde Bluetooth van de ESP32. De HC-05 en HC-06 werken niet met een iPhone; voor een iPhone heb je een BLE-module of een ESP32 met BLE-programmering nodig.

Bouwen met een L293D-motorshield

L293D-motordrivershield
L293D-motorshield: het past rechtstreeks op een Arduino Uno; vier gelijkstroommotoren sluit je aan op de klemmen M1–M4 en twee servo's op de headers in de hoek.

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.

InstellingMet de L298NMet het L293D-shield
MotoraansluitingKlemmen OUT1–OUT4Klemmen M1 (links) en M2 (rechts)
MotorcodedigitalWrite en analogWrite in drive()AFMotor in drive()
SERVO_PIN39 of 10, afhankelijk van de header waarin je de servo steekt
HC-05D10, D11A4 (RX) en A5 (TX): SoftwareSerial bt(A4, A5)
Stroom per kanaal2 A continu0,6 A continu, 1,2 A piek
Motorvoeding12V-klemEXT_PWR-klem; met de PWR-jumper geplaatst draait de Arduino op dezelfde voeding
C++ (Arduino IDE)
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.

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

MicroPython
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 readings

Projectideeë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

ProbleemWaarschijnlijke oorzaakOplossing
De robot knalt tegen de muur zonder te stoppenDe sensor leest 0 (kapotte draad, TRIG en ECHO verwisseld) en de code behandelt dat als vrije ruimteVoer de testsketch uit, probeer 10–60 cm met je hand, controleer de TRIG- en ECHO-pins
Hij schraapt langs de muur bij schuin naderenHet geluid kaatst van het schuine oppervlak in een andere richting wegVoeg IR-sensoren toe op de voorhoeken en verlaag de snelheid
De Arduino reset als hij stopt om te scannenDe stroom van servo en motoren laat de 5V-rail instortenCondensator 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 redenEen enkele slechte meting of een echo van de vloerZet de sensor op 8–12 cm hoogte en kantel hem iets omhoog; gebruik de bevestiging met de mediaan
De robot draait naar de geblokkeerde kantDe servo is andersom gemonteerd, links en rechts zijn omgedraaidZet SERVO_DIR op -1
Bochten zijn veel te kort of te langMS_PER_DEG is niet gekalibreerd of de batterij is bijna leegMeet met turnBy(360) en stel opnieuw af met een volle batterij
Hij blijft in een hoek links en rechts draaienBeide kanten zitten dicht bij de drempel en de beslissing slaat steeds omVerhoog de drempel voor doodlopend (STOP_CM + 10) of laat hem de laatste draairichting verkiezen
De sensorkop schoktZwakke servovoeding of interrupts van SoftwareSerialKort de servokabel in, voeg een condensator toe, stuur Bluetooth-commando's niet vaker dan nodig
De snelste manier om de oorzaak van een probleem te vinden is de robot op USB te laten, hem met de wielen in de lucht te laten draaien en de pingCm()-waarden naar de Serial Monitor te printen. Zijn de waarden logisch, dan zit het probleem in de mechaniek of aan de voedingskant. Voor andere redenen waarom een Arduino steeds opnieuw opstart, zie het artikel Arduino blijft resetten.

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.

Alle projecten bekijken
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
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
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
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
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
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
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
ESP32 HC-SR04 ultrasone afstandssensor
ES-14Gemiddeld

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.

4.9(29)
48