Arduino Radar Projekt: mit HC-SR04, Servo und Processing bauen

Ein Arduino Radar ist ein Projekt, bei dem ein HC-SR04 Ultraschallsensor auf einem SG90 Servomotor sitzt und zwischen 0 und 180 Grad geschwenkt wird, um Richtung und Entfernung von Gegenständen in der Umgebung zu messen. Das Ergebnis erscheint am Computer als grüner Radarschirm wie im Film. Der Arduino misst bei jedem Winkel und schickt eine Zeile im Format "Winkel,Entfernung" über die serielle Schnittstelle; ein kleines Processing-Programm auf dem Computer liest diese Zahlen und zeichnet die kreisende Abtastlinie und die erkannten Objekte als rote Linien.

In dieser Anleitung findest du jeden Schritt mit Erklärung, von der Teileliste und dem Schaltplan bis zum Arduino-Code und dem Radarschirm in Processing. Außerdem geht es um ein Mini-Radar mit OLED-Display, das ohne Computer auskommt, um Versionen für ESP32 und Raspberry Pi Pico, um das Einstellen von Schwenktempo und Messgenauigkeit und um die Lösung der häufigsten Fehler mit der seriellen Schnittstelle. Das Projekt ist günstig, an einem Nachmittag fertig und gehört zu den Arduino-Projekten, die bei Schulpräsentationen am meisten Aufmerksamkeit bekommen.

Wie funktioniert ein Arduino Radar?

Das Herzstück ist der HC-SR04. Einer der beiden Zylinder auf dem Sensor (T) sendet einen kurzen 40-kHz-Schallimpuls aus, den Menschen nicht hören können; trifft der Schall auf einen Gegenstand und kommt zurück, fängt der andere (R) das Echo auf. Der Arduino misst diese Laufzeit für Hin- und Rückweg in Mikrosekunden. Schall breitet sich in Luft mit etwa 343 m/s aus und braucht für einen Zentimeter also rund 29 Mikrosekunden; da der Weg zweimal zurückgelegt wird, lautet die Formel Entfernung (cm) = Zeit (µs) / 58. Der Servo dreht den Sensor Schritt für Schritt weiter, und bei jedem Schritt wird erneut gemessen. Am Ende weißt du, "in welchem Winkel in wie vielen Zentimetern etwas ist", also eine Polarkoordinate. Zum Zeichnen werden Winkel und Entfernung mit x = Entfernung × cos(Winkel) und y = Entfernung × sin(Winkel) in eine Pixelposition umgerechnet.

Teileliste für das Arduino Radar

• Arduino Uno oder Nano und ein USB-Kabel, das Daten überträgt (reine Ladekabel erscheinen am Computer nicht als Port).
• HC-SR04 Ultraschall-Entfernungssensor.
• SG90 Mikroservo mit den mitgelieferten Kunststoffhebeln.
• Ein Steckbrett (Breadboard) und 8–10 Jumperkabel (Stecker-Stecker und Stecker-Buchse).
• Ein 470-µF-Elko (mindestens 10 V): verhindert, dass die Spannung einbricht, wenn sich der Servo bewegt.
• Doppelseitiges Klebeband, Heißkleber oder ein kleiner 3D-gedruckter Halter, um den Sensor am Servo zu befestigen.
• Optional: ein 0,96-Zoll-I2C-OLED-Display (für die Version ohne Computer) und ein externes 5-V-Netzteil mit 2 A.

Arduino Radar Schaltplan

Am Uno wird die Verkabelung übersichtlicher, wenn du die 5-V- und GND-Leitungen von Sensor und Servo auf die Plus- und Minusschienen des Steckbretts legst und diese Schienen mit den Pins 5V und GND des Arduino verbindest. Steck den 470-µF-Kondensator auf dieselben Schienen: das lange Bein (+) an 5 V, das kurze Bein, erkennbar am Streifen auf dem Gehäuse, an GND. Bei manchen Servos sind die Kabel schwarz, rot und weiß; dann ist Schwarz GND und Weiß das Signal. Wo die Pins auf deinem Board liegen, zeigt dir das Pinout-Tool.

Den Sensor auf dem Servo montieren

Bevor du den Hebel aufsteckst, bring den Servo auf 90 Grad: Lade einfach einen kurzen Test-Sketch mit radarServo.write(90) hoch und lass den Servo in dieser Stellung. Steck dann den Hebel so auf, dass der Sensor genau nach vorn zeigt. So entspricht 0° rechts, 90° geradeaus und 180° links, und die Richtungen auf dem Processing-Schirm stimmen exakt mit der Wirklichkeit überein. Achte beim Festkleben des HC-SR04 mit doppelseitigem Klebeband oder Heißkleber darauf, dass die beiden Zylinder parallel zum Boden stehen; zeigt der Sensor nach unten, hält er die Tischplatte für ein Objekt. Lass den Kabeln genug Spiel, damit sie sich bei der 180-Grad-Drehung nicht spannen, und befestige den Servo auf einem schweren Sockel oder einer Box; ein Aufbau, der bei jedem Schritt wackelt, verdirbt die Messwerte.

Arduino Radar Schritt für Schritt bauen

1. Verkabel die Bauteile nach der Tabelle oben, vergiss den Kondensator nicht und montiere den Sensor auf dem Servo.
2. Öffne die Arduino IDE; die Servo-Bibliothek ist bereits dabei, du musst nichts zusätzlich installieren.
3. Lade den Radar-Code unten hoch. Wenn es bei der Board- oder Portauswahl hakt, hilft dir Arduino Sketch lässt sich nicht hochladen.
4. Öffne den Seriellen Monitor mit 9600 Baud; laufen Zeilen wie "30,45" mit Winkel und Entfernung durch, ist die Arduino-Seite fertig. Schließ den Seriellen Monitor danach unbedingt.
5. Installiere Processing 4 auf deinem Computer, öffne einen neuen Sketch und füge den Code für den Radarschirm ein.
6. Klick auf Run; in der Konsole unten erscheint die Portliste und das Radarfenster öffnet sich. Wenn du die Hand vor dem Sensor bewegst, sollten rote Linien auftauchen.

Arduino Radar Code

1#include <Servo.h>
2
3const byte SERVO_PIN  = 9;     // SG90 turuncu kablo / SG90 orange wire
4const byte TRIG_PIN   = 10;    // HC-SR04 Trig
5const byte ECHO_PIN   = 11;    // HC-SR04 Echo
6const int  MIN_ANGLE  = 0;     // tarama başlangıcı / sweep start
7const int  MAX_ANGLE  = 180;   // tarama sonu / sweep end
8const int  STEP       = 2;     // adım başına derece / degrees per step
9const int  STEP_DELAY = 40;    // ölçümden önce bekleme (ms) / wait before measuring (ms)
10
11Servo radarServo;
12int angle = MIN_ANGLE;
13int dir = STEP;
14
15int measureCm() {
16  digitalWrite(TRIG_PIN, LOW);
17  delayMicroseconds(2);
18  digitalWrite(TRIG_PIN, HIGH);                         // 10 µs tetik darbesi / 10 µs trigger pulse
19  delayMicroseconds(10);
20  digitalWrite(TRIG_PIN, LOW);
21  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);  // en çok 30 ms bekle / wait at most 30 ms
22  if (us == 0) return 0;                                // yankı yok = menzil dışı / no echo = out of range
23  return us / 58;                                       // gidiş-dönüş süresi → cm / round-trip time → cm
24}
25
26void setup() {
27  Serial.begin(9600);
28  pinMode(TRIG_PIN, OUTPUT);
29  pinMode(ECHO_PIN, INPUT);
30  radarServo.attach(SERVO_PIN);
31  radarServo.write(angle);
32  delay(500);                                           // başlangıç konumuna gitsin / reach the start position
33}
34
35void loop() {
36  radarServo.write(angle);                              // servoyu yeni açıya döndür / move the servo to the new angle
37  delay(STEP_DELAY);                                    // titreşim geçsin / let the vibration settle
38  int distance = measureCm();
39
40  Serial.print(angle);                                  // biçim: açı,mesafe / format: angle,distance
41  Serial.print(',');
42  Serial.println(distance);
43
44  if (angle + dir > MAX_ANGLE || angle + dir < MIN_ANGLE) dir = -dir;  // uçta yön değiştir / reverse at the ends
45  angle += dir;
46}

Der Code erklärt

Dass die Daten so schlicht sind, hat einen Grund: Eine einzige kommagetrennte Zeile lässt sich im Seriellen Monitor gut lesen und in Processing, Python oder Excel mit einer Codezeile zerlegen. Eine Entfernung von 0 bedeutet "in diesem Winkel nichts in Reichweite", und Processing zeichnet solche Werte nicht. Öffnest du dieselben Daten im Seriellen Plotter der Arduino IDE, siehst du, wie der Winkel wie ein Sägezahn auf- und absteigt und die Entfernung springt, sobald der Sensor an einem Gegenstand vorbeikommt. Für dieses Projekt reicht delay völlig; willst du während des Radarbetriebs gleichzeitig einen Taster abfragen oder eine LED schalten, schreib die Schleife mit millis() um.

Der grüne Radarschirm mit Processing

Processing ist eine kostenlose, Java-basierte Software für visuelles Programmieren, deren Oberfläche der Arduino IDE sehr ähnelt: Du schreibst den Code und klickst auf Run. Die Serial-Bibliothek für die serielle Kommunikation ist bei Processing dabei; du kannst sie über das Menü Sketch > Import Library einbinden oder dich einfach auf die import-Zeile am Anfang des Codes verlassen. Der folgende Code kommt in Processing, nicht in die Arduino IDE.

1// Processing 4 çizimi: Arduino IDE'ye değil, Processing'e yapıştır / Processing 4 sketch: paste into Processing, not the Arduino IDE
2import processing.serial.*;                       // Serial kütüphanesi / Serial library
3
4Serial port;
5int angle = 0;                                    // son açı / last angle
6int distance = 0;                                 // son mesafe (cm) / last distance (cm)
7final int MAX_CM = 100;                           // ekrandaki en uzak mesafe / farthest distance on screen
8float R;                                          // radar yarıçapı (piksel) / radar radius (pixels)
9
10void setup() {
11  size(1200, 700);
12  R = width * 0.45;
13  printArray(Serial.list());                      // portları konsola yaz / print the ports to the console
14  String portName = Serial.list()[0];             // gerekirse [1] ya da "COM4" yaz / use [1] or "COM4" if needed
15  port = new Serial(this, portName, 9600);        // Arduino ile aynı baud / same baud as the Arduino
16  port.bufferUntil('\n');                         // satır sonunu bekle / wait for the end of a line
17  background(0);
18}
19
20void draw() {
21  noStroke();
22  fill(0, 12);                                    // yarı saydam siyah: solan iz / translucent black: fading trail
23  rect(0, 0, width, height);
24  translate(width / 2, height - 60);              // radar merkezi alt ortada / radar centre at the bottom middle
25  drawGrid();
26  drawSweep();
27  drawObject();
28  drawLabels();
29}
30
31void drawGrid() {
32  noFill();
33  strokeWeight(2);
34  stroke(98, 245, 31);
35  for (int i = 1; i <= 4; i++) {
36    float d = 2 * R * i / 4;
37    arc(0, 0, d, d, PI, TWO_PI);                  // 25-50-75-100 cm yayları / 25-50-75-100 cm arcs
38  }
39  for (int a = 0; a <= 180; a += 30) {
40    line(0, 0, R * cos(radians(a)), -R * sin(radians(a)));   // 30 derecelik çizgiler / 30-degree lines
41  }
42}
43
44void drawSweep() {
45  strokeWeight(5);
46  stroke(30, 250, 60);
47  line(0, 0, R * cos(radians(angle)), -R * sin(radians(angle)));   // tarama çizgisi / sweep line
48}
49
50void drawObject() {
51  if (distance <= 0 || distance > MAX_CM) return;  // menzil dışı / out of range
52  float p = R * distance / MAX_CM;                 // cm → piksel / cm → pixels
53  float c = cos(radians(angle));
54  float s = sin(radians(angle));
55  strokeWeight(7);
56  stroke(255, 10, 10);
57  line(p * c, -p * s, R * c, -R * s);              // nesneden dışa kırmızı çizgi / red line from the object outwards
58}
59
60void drawLabels() {
61  resetMatrix();
62  noStroke();
63  fill(0);
64  rect(0, height - 40, width, 40);                 // yazı şeridi / text strip
65  fill(98, 245, 31);
66  textSize(20);
67  for (int i = 1; i <= 4; i++) {
68    text(MAX_CM * i / 4 + " cm", width / 2 + R * i / 4 + 4, height - 66);   // yay etiketleri / arc labels
69  }
70  String d = (distance > 0 && distance <= MAX_CM) ? distance + " cm" : "-";
71  text("Açı / Angle: " + angle + "°", 40, height - 12);
72  text("Mesafe / Distance: " + d, width / 2, height - 12);
73}
74
75void serialEvent(Serial p) {
76  String msg = p.readStringUntil('\n');            // "açı,mesafe" satırı / "angle,distance" line
77  if (msg == null) return;
78  String[] parts = split(trim(msg), ',');
79  if (parts.length == 2) {
80    angle = int(parts[0]);
81    distance = int(parts[1]);
82  }
83}

Der wichtigste Teil ist die Funktion serialEvent(). Dank bufferUntil('\n') sammelt Processing die ankommenden Daten, bis ein Zeilenende kommt, und ruft die Funktion dann automatisch mit einer vollständigen Zeile auf. Die Zeile wird mit trim() von Leerzeichen und dem Zeichen \r befreit, mit split() am Komma geteilt und mit int() in Zahlen umgewandelt. draw() läuft dagegen etwa 60-mal pro Sekunde: Zuerst legt es ein halbtransparentes schwarzes Rechteck über das Bild (fill(0, 12)), danach zeichnet es Raster, Abtastlinie und Objekt neu. Weil alte Linien mit jedem Bild etwas dunkler werden, entsteht der typische Nachleuchteffekt echter Radarschirme ganz von selbst.

Servogeschwindigkeit und Schwenkdauer einstellen

Laut Datenblatt schafft der SG90 bei 4,8 V 60 Grad in 0,1 Sekunden; einen 2-Grad-Schritt erledigt er also in wenigen Millisekunden. Die Dauer eines Schwenks bestimmt deshalb nicht der Servo, sondern die Warte- und Messzeit pro Schritt. Nach dem Anhalten schwingen Hebel und Sensor kurz nach; misst du in diesem Moment, springen die Entfernungen. Außerdem empfiehlt der Hersteller des HC-SR04 rund 60 ms zwischen zwei Messungen, weil Echos des vorherigen Impulses im Raum in die nächste Messung geraten können. In der Praxis sind insgesamt 50–60 ms pro Schritt (Warten + Messen) ein guter Kompromiss. Ein kompletter Schwenk dauert ungefähr (180 / Schritt + 1) × Schrittzeit.

Für eine weichere Bewegung hältst du den Schritt klein und die Wartezeit kurz; brauchst du Tempo, vergrößerst du den Schritt und verlängerst die Wartezeit etwas. Beschränkst du den Schwenk auf den Bereich, der dich interessiert (zum Beispiel 45–135°), halbiert sich die Zeit ebenfalls. Zuckt der Servo von selbst, startet der Arduino ab und zu neu und verliert Processing die Verbindung, liegt es nicht am Tempo, sondern an der Stromversorgung: Der SG90 zieht in Bewegung etwa 100–250 mA und unter Last bis zu 600 mA. Bau den Kondensator ein und versorge den Servo bei Bedarf aus einem externen 5-V-Netzteil, dessen GND mit dem Arduino verbunden ist.

Die Messgenauigkeit verbessern

Auch wenn der HC-SR04 auf dem Papier 3 mm Auflösung verspricht, hängt die Genauigkeit eines Radars von drei Dingen ab: Keulenbreite, Schallgeschwindigkeit und Oberfläche. Der Schall des Sensors breitet sich wie ein Kegel von etwa 15 Grad aus. Deshalb erscheint ein dünner Stift in 50 cm Entfernung auf dem Schirm nicht als Punkt, sondern als 15–20 Grad breiter Bogen; die Winkelauflösung des Radars bestimmt diese Keule, nicht der Servoschritt, und die tatsächliche Richtung des Objekts liegt in der Mitte des Bogens. Die Schallgeschwindigkeit ändert sich mit der Temperatur und wird mit v = 331,3 + 0,606 × T (m/s, T in °C) berechnet. Die Zahl 58 im Code entspricht etwa 22 °C; in einer kalten Garage fallen die Messwerte einige Prozent zu groß aus.

Du kannst die Raumtemperatur mit einem DHT11 oder DS18B20 messen und die Schallgeschwindigkeit berücksichtigen sowie einzelne Ausreißer verwerfen, indem du den Median aus drei Messungen nimmst. Füge einfach die beiden folgenden Funktionen in den Hauptcode ein und ersetze den Aufruf von measureCm() in loop() durch eine davon. Da der Medianfilter pro Schritt dreimal misst, wird der Schwenk etwas langsamer.

1// Ana radar koduna eklenecek fonksiyonlar / functions to add to the main radar sketch
2
3// Sıcaklığa göre düzeltilmiş ölçüm / temperature-compensated reading
4int measureCmTemp(float tempC) {
5  digitalWrite(TRIG_PIN, LOW);
6  delayMicroseconds(2);
7  digitalWrite(TRIG_PIN, HIGH);
8  delayMicroseconds(10);
9  digitalWrite(TRIG_PIN, LOW);
10  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
11  if (us == 0) return 0;                                // yankı yok / no echo
12  float v = 331.3 + 0.606 * tempC;                      // ses hızı (m/s) / speed of sound (m/s)
13  return (int)(us * v / 20000.0 + 0.5);                 // µs × (m/s) / 20000 = cm
14}
15
16// Üç ölçümün ortancası: tek seferlik sıçramaları atar / median of three: drops one-off spikes
17int medianCm() {
18  int a = measureCm(); delay(20);
19  int b = measureCm(); delay(20);
20  int c = measureCm();
21  return max(min(a, b), min(max(a, b), c));
22}
23
24// loop() içinde kullanım / use inside loop():
25// int distance = medianCm();
26// int distance = measureCmTemp(18.5);                  // sıcaklık DHT11'den gelebilir / temperature can come from a DHT11

• Weiche Oberflächen (Vorhänge, Stoff, Schaumstoff) schlucken den Schall; ein Objekt taucht dann womöglich nicht auf.
• Schräge Flächen lenken den Schall ab; eine flache Kiste, die mehr als 45° zum Sensor gedreht ist, kann wie freier Raum aussehen.
• Näher als 2 cm lässt sich nichts messen; Werte unter 3–4 cm solltest du in der Praxis als unzuverlässig betrachten.
• Raumecken erzeugen Mehrfachreflexionen und können ferne "Geister" vortäuschen, die gar nicht da sind; teste in einem leeren, offenen Bereich.
• Reichweite: Das Datenblatt nennt 400 cm, stabile Messungen an kleinen Objekten gelingen meist bis etwa 2 Meter; wähl MAX_CM entsprechend.

Mini-Radar auf dem OLED-Display (ohne Computer)

Soll das Radar ein tragbares, batteriebetriebenes Gerät ohne Computer werden, nimmst du statt Processing ein 0,96-Zoll-OLED-Display. Die Mitte der Unterkante des 128×64-Bildschirms mit SSD1306-Treiber wird zum Mittelpunkt des Radars; darauf werden ein Halbkreis mit 60 Pixeln Radius, die Abtastlinie und Punkte für das zuletzt gemessene Objekt in jedem Winkel gezeichnet. Für den Anschluss des Displays (SDA → A4, SCL → A5) und die Installation der Bibliotheken schau in die Anleitung OLED-Display SSD1306; HC-SR04 und Servo werden wie oben angeschlossen.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Servo.h>
5
6const byte SERVO_PIN = 9;                 // SG90 sinyal / SG90 signal
7const byte TRIG_PIN  = 10;                // HC-SR04 Trig
8const byte ECHO_PIN  = 11;                // HC-SR04 Echo
9const int  MAX_CM    = 50;                // ekrandaki en uzak mesafe / farthest distance on screen
10const int  STEP      = 3;                 // adım başına derece / degrees per step
11const int  CX = 64, CY = 63, R = 60;      // radar merkezi ve yarıçapı (piksel) / radar centre and radius (px)
12
13Adafruit_SSD1306 display(128, 64, &Wire, -1);
14Servo radarServo;
15uint8_t dist[180 / STEP + 1];             // her açının son ölçümü (cm) / last reading per angle (cm)
16int angle = 0;
17int dir = STEP;
18
19int measureCm() {
20  digitalWrite(TRIG_PIN, LOW);
21  delayMicroseconds(2);
22  digitalWrite(TRIG_PIN, HIGH);
23  delayMicroseconds(10);
24  digitalWrite(TRIG_PIN, LOW);
25  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
26  if (us == 0) return 0;                  // yankı yok / no echo
27  return us / 58;
28}
29
30void setup() {
31  pinMode(TRIG_PIN, OUTPUT);
32  pinMode(ECHO_PIN, INPUT);
33  radarServo.attach(SERVO_PIN);
34  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
35    for (;;);                             // ekran bulunamadı / display not found
36  }
37  display.setTextColor(SSD1306_WHITE);
38}
39
40void loop() {
41  radarServo.write(angle);
42  delay(20);                              // çizim de zaman aldığı için kısa / short, drawing takes time too
43  int d = measureCm();
44  dist[angle / STEP] = (d > 255) ? 255 : d;   // byte'a sığdır / fit into a byte
45
46  display.clearDisplay();
47  display.drawCircle(CX, CY, R, SSD1306_WHITE);       // dış yay, alt yarısı ekran dışında / outer arc, lower half off-screen
48  display.drawCircle(CX, CY, R / 2, SSD1306_WHITE);   // orta yay = MAX_CM / 2 / middle arc = MAX_CM / 2
49  for (int i = 0; i <= 180 / STEP; i++) {
50    if (dist[i] > 0 && dist[i] <= MAX_CM) {
51      float rad = radians(i * STEP);
52      int r = map(dist[i], 0, MAX_CM, 0, R);          // cm → piksel / cm → pixels
53      display.fillCircle(CX + r * cos(rad), CY - r * sin(rad), 1, SSD1306_WHITE);
54    }
55  }
56  float rad = radians(angle);
57  display.drawLine(CX, CY, CX + R * cos(rad), CY - R * sin(rad), SSD1306_WHITE);  // tarama çizgisi / sweep line
58  display.setCursor(0, 0);
59  display.print(angle);                   // açı / angle
60  display.setCursor(98, 0);
61  display.print(d);                       // mesafe / distance
62  display.print(F("cm"));
63  display.display();
64
65  if (angle + dir > 180 || angle + dir < 0) dir = -dir;   // uçta yön değiştir / reverse at the ends
66  angle += dir;
67}

In dieser Version werden die Entfernungen nach Winkel im Array dist gespeichert; so bleiben die Punkte auch nach dem Durchlauf der Abtastlinie sichtbar und werden beim nächsten Durchgang aktualisiert. Der Mittelpunkt des Kreises liegt auf der Unterkante des Displays, seine untere Hälfte ragt also aus dem Bild und wird von der Bibliothek nicht gezeichnet; übrig bleibt ein sauberer Halbkreis. Ein Bild an das Display zu senden dauert bei 400 kHz I2C etwa 25 ms, deshalb wurde die Wartezeit auf 20 ms verkürzt und der Schritt auf 3 Grad erhöht; ein Schwenk dauert etwa 4–5 Sekunden. Auf dem kleinen Display ist eine 50-cm-Skala besser lesbar, darum steht MAX_CM auf 50. Die Hälfte der 2 KB Arbeitsspeicher des Uno geht an den Bildpuffer, deshalb ist es wichtig, das Array als Bytes (uint8_t) anzulegen.

Arduino Radar mit dem ESP32

Auf dem ESP32 funktioniert die Servo-Bibliothek des Arduino nicht; installiere stattdessen über den Bibliotheksverwalter die Bibliothek ESP32Servo. Der übrige Code ist fast identisch. Weil der ESP32 mit 3,3 V arbeitet, darfst du den Spannungsteiler in der Echo-Leitung des HC-SR04 nicht vergessen; der 3,3-V-Impuls auf der Trig-Leitung reicht dagegen bei den meisten Sensoren zum Auslösen. Dieser Code nutzt 115200 Baud, also ändere auch die 9600 im Processing-Code auf 115200. Dank WLAN kannst du die Radardaten später auch an eine Webseite auf dem Handy statt an den Computer schicken; wenn der ESP32 neu für dich ist, lies zuerst Was ist der ESP32.

1#include <ESP32Servo.h>                // Kütüphane Yöneticisi: ESP32Servo / Library Manager: ESP32Servo
2
3const int SERVO_PIN  = 13;             // SG90 sinyal / SG90 signal
4const int TRIG_PIN   = 26;             // HC-SR04 Trig
5const int ECHO_PIN   = 27;             // 1k/2k bölücüden / through the 1k/2k divider
6const int STEP       = 2;              // adım başına derece / degrees per step
7const int STEP_DELAY = 40;             // ölçümden önce bekleme (ms) / wait before measuring (ms)
8
9Servo radarServo;
10int angle = 0;
11int dir = STEP;
12
13int measureCm() {
14  digitalWrite(TRIG_PIN, LOW);
15  delayMicroseconds(2);
16  digitalWrite(TRIG_PIN, HIGH);
17  delayMicroseconds(10);
18  digitalWrite(TRIG_PIN, LOW);
19  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL);
20  if (us == 0) return 0;               // yankı yok / no echo
21  return us / 58;
22}
23
24void setup() {
25  Serial.begin(115200);                       // Processing'de de 115200 / 115200 in Processing too
26  pinMode(TRIG_PIN, OUTPUT);
27  pinMode(ECHO_PIN, INPUT);
28  radarServo.setPeriodHertz(50);              // standart servo 50 Hz / standard servo 50 Hz
29  radarServo.attach(SERVO_PIN, 500, 2400);    // SG90 darbe aralığı (µs) / SG90 pulse range (µs)
30  radarServo.write(angle);
31  delay(500);
32}
33
34void loop() {
35  radarServo.write(angle);
36  delay(STEP_DELAY);
37  int distance = measureCm();
38  Serial.printf("%d,%d\n", angle, distance);  // açı,mesafe / angle,distance
39  if (angle + dir > 180 || angle + dir < 0) dir = -dir;   // uçta yön değiştir / reverse at the ends
40  angle += dir;
41}

Radar mit dem Raspberry Pi Pico und MicroPython

Auf dem Pico brauchst du keine eigene Servo-Bibliothek: Es genügt, die Impulsbreite eines 50-Hz-PWM-Signals mit duty_ns() einzustellen. Die Echozeit misst machine.time_pulse_us(), das bei einem Timeout eine negative Zahl liefert. Auch die Pins des Pico arbeiten mit 3,3 V, der Teiler in der Echo-Leitung ist also Pflicht. Speichere den Code mit Thonny als main.py auf dem Pico und schließ Thonny danach; sonst bleibt der Port belegt und Processing kann sich nicht verbinden. Da der Pico über USB eine virtuelle serielle Schnittstelle öffnet, spielt die Baudrate in Processing keine Rolle; derselbe Radarschirm läuft ohne Änderung.

1from machine import Pin, PWM, time_pulse_us
2import time
3
4servo = PWM(Pin(15))                     # SG90 sinyal / SG90 signal
5servo.freq(50)                           # standart servo 50 Hz / standard servo 50 Hz
6trig = Pin(14, Pin.OUT)
7echo = Pin(13, Pin.IN)                   # bölücüden gelir / comes through the divider
8
9def set_angle(a):
10    # 0° = 500 µs, 180° = 2400 µs darbe / pulse
11    servo.duty_ns(500000 + a * 1900000 // 180)
12
13def measure_cm():
14    trig.value(0)
15    time.sleep_us(2)
16    trig.value(1)                        # 10 µs tetik / 10 µs trigger
17    time.sleep_us(10)
18    trig.value(0)
19    t = time_pulse_us(echo, 1, 30000)    # en çok 30 ms bekle / wait at most 30 ms
20    if t < 0:
21        return 0                         # yankı yok / no echo
22    return t // 58
23
24angle, step = 0, 2
25set_angle(angle)
26time.sleep_ms(500)
27
28while True:
29    set_angle(angle)
30    time.sleep_ms(40)                    # servo otursun / let the servo settle
31    print("{},{}".format(angle, measure_cm()))   # açı,mesafe / angle,distance
32    if angle + step > 180 or angle + step < 0:
33        step = -step                     # uçta yön değiştir / reverse at the ends
34    angle += step

Häufige Fehler und Lösungen

Ideen zum Weiterbauen

• Sicherheitsradar mit Alarm: Kommt ein Objekt näher als 30 cm, lässt du einen Summer (Buzzer) ertönen und eine rote LED leuchten; kombiniere das mit den Ideen aus Arduino Alarmanlage.
• Hindernisausweichender Roboter: Setz das Radar vorn auf einen Roboter; hält er an, scannt er links und rechts und dreht sich in die freieste Richtung. Details in Hindernis-Roboter.
• Raumkarte: Speichere die Scandaten auf einem SD-Kartenmodul und zeichne sie am Computer als Punktwolke.
• Kabelloses Radar: Schick die Messwerte mit einem ESP32 per WLAN an eine Webseite auf dem Handy; mit einem ESP32-Webserver zeichnest du in Echtzeit.
• Schärfere Karte: Nimm statt des HC-SR04 einen Laser-Sensor (ToF) mit schmaler Keule; Alternativen findest du im Vergleich der Entfernungssensoren.
• Smarter Blindenstock: Bau mit einem Entfernungssensor und einem Vibrationsmotor einen Stock, der sehbehinderte Menschen vor Hindernissen warnt: Projekt smarter Blindenstock.

Weil das Arduino Radar Entfernungssensor, Servosteuerung, serielle Kommunikation und Grafik am Computer in einem Projekt vereint, ist es ein super nächster Schritt für Einsteiger. Um die Grundlagen zu festigen, lohnt sich auch ein Blick in die Anleitungen zum HC-SR04 Ultraschallsensor und zum Servomotor. In der BlueGrays-App findest du Projekte zur Entfernungsmessung mit dem HC-SR04, zum Parksensor, zur Servo-Ansteuerung und zum hindernisausweichenden Roboter Schritt für Schritt mit Schaltplänen und kommentiertem Code.