Arduino Radar bauen: Ultraschall-Scanner mit HC-SR04 & Servo (SG90) + Processing-Anzeige

Wie aus Sensor + Servo ein Radar wird

Das Prinzip ist verblueffend einfach: Der HC-SR04 sendet einen Ultraschall-Impuls und misst die Zeit, bis das Echo zurueckkommt – daraus ergibt sich die Entfernung. Er "sieht" dabei aber nur in einem schmalen Kegel nach vorne. Montierst du ihn auf einen SG90-Servo und drehst diesen langsam von 0° bis 180°, misst du bei jedem Winkel den Abstand. Kombinierst du Winkel und Entfernung, hast du fuer jeden Punkt im Halbkreis eine Koordinate – genau das, was ein Radar anzeigt.

Der Arduino uebernimmt das Schwenken und Messen und schickt die Wertepaare per USB an den PC. Dort rechnet ein Processing-Sketch die Polarkoordinaten (Winkel + Distanz) in Bildschirmpunkte um und malt den vertrauten Radarschirm. Das Ergebnis sieht aus wie aus einem U-Boot-Film – kostet aber nur eine Handvoll Bauteile.

Das brauchst du

1Verkabelung

Der HC-SR04 hat vier Pins (VCC, Trig, Echo, GND), der Servo drei (Plus, Minus, Signal). Wir nutzen Trig an D9, Echo an D10 und das Servo-Signal an D11.

2Bausteine testen: Messung & Sweep

Bevor wir alles kombinieren, pruefen wir beide Teile einzeln. Zuerst eine saubere Abstandsmessung als Funktion – mit pulseIn-Timeout, damit ein fehlendes Echo den Ablauf nicht blockiert:

#define TRIG 9
#define ECHO 10

long messeAbstandCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  // Timeout 25 ms = ca. 4 m Reichweite
  long dauer = pulseIn(ECHO, HIGH, 25000);
  if (dauer == 0) return 400;          // kein Echo -> Maximalwert
  long cm = dauer * 0.0343 / 2;        // Schallgeschwindigkeit
  return cm;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(115200);
}

void loop() {
  Serial.print(messeAbstandCm());
  Serial.println(" cm");
  delay(200);
}

Und der Servo-Sweep, der langsam von 0° auf 180° und zurueck faehrt (Bibliothek Servo ist bei der Arduino IDE dabei):

#include <Servo.h>
Servo radarServo;

void setup() {
  radarServo.attach(11);
}

void loop() {
  for (int w = 0; w <= 180; w++) {
    radarServo.write(w);
    delay(15);
  }
  for (int w = 180; w >= 0; w--) {
    radarServo.write(w);
    delay(15);
  }
}

Laeuft beides einzeln, kann nichts mehr schiefgehen. Mehr zu Servo-Ansteuerung und Sweep-Feinheiten findest du im Servo-Tutorial.

3Der komplette Radar-Sketch

Jetzt fuegen wir beides zusammen: Der Servo schwenkt schrittweise, bei jedem Winkel wird gemessen, und Arduino sendet das Paar im Format winkel,abstand. – der Punkt am Ende ist unser Trennzeichen, an dem Processing die Datensaetze auseinanderschneidet.

#include <Servo.h>

#define TRIG 9
#define ECHO 10

Servo radarServo;

long messeAbstandCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  long dauer = pulseIn(ECHO, HIGH, 25000);
  if (dauer == 0) return 400;
  return dauer * 0.0343 / 2;
}

void sendePaar(int winkel) {
  long abstand = messeAbstandCm();
  Serial.print(winkel);
  Serial.print(",");
  Serial.print(abstand);
  Serial.print(".");        // Satz-Ende fuer Processing
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  radarServo.attach(11);
  Serial.begin(115200);
}

void loop() {
  for (int w = 0; w <= 180; w++) {
    radarServo.write(w);
    delay(20);              // Servo Zeit zum Bewegen geben
    sendePaar(w);
  }
  for (int w = 180; w >= 0; w--) {
    radarServo.write(w);
    delay(20);
    sendePaar(w);
  }
}

4Die Radar-Anzeige in Processing

Processing ist eine kostenlose, Arduino-aehnliche Programmierumgebung fuer Grafik – die Syntax kennst du also schon. Lade Processing herunter, oeffne einen neuen Sketch und passe in der Zeile myPort den COM-Port an den deines Arduino an (derselbe wie in der Arduino IDE). Wichtig: Der Serielle Monitor der Arduino IDE muss geschlossen sein, sonst ist der Port belegt.

// Processing-Sketch: Ultraschall-Radar
import processing.serial.*;

Serial myPort;
String daten = "";
int   winkel = 0;
int   abstand = 0;

void setup() {
  size(800, 450);
  // COM-Port anpassen! Serial.list() zeigt alle Ports
  myPort = new Serial(this, Serial.list()[0], 115200);
  myPort.bufferUntil('.');   // bis zum Trennzeichen sammeln
}

void draw() {
  // Nachleuchten simulieren: halbtransparent uebermalen
  noStroke();
  fill(0, 20);
  rect(0, 0, width, height);

  drawGitter();
  drawStrahl();
  drawObjekt();
}

void drawGitter() {
  stroke(0, 255, 0);
  noFill();
  translate(width/2, height - 40);   // Nullpunkt unten mittig
  // Halbkreis-Ringe
  for (int r = 100; r <= 380; r += 90) {
    arc(0, 0, r*2, r*2, PI, TWO_PI);
  }
  // Winkellinien alle 30 Grad
  for (int a = 0; a <= 180; a += 30) {
    float x = cos(radians(a)) * 380;
    float y = -sin(radians(a)) * 380;
    line(0, 0, x, y);
  }
}

void drawStrahl() {
  stroke(0, 255, 0);
  strokeWeight(3);
  float x = cos(radians(winkel)) * 380;
  float y = -sin(radians(winkel)) * 380;
  line(0, 0, x, y);
  strokeWeight(1);
}

void drawObjekt() {
  if (abstand > 0 && abstand < 200) {
    float pixel = map(abstand, 0, 200, 0, 380);
    float x = cos(radians(winkel)) * pixel;
    float y = -sin(radians(winkel)) * pixel;
    stroke(255, 60, 60);
    strokeWeight(8);
    point(x, y);
    strokeWeight(1);
  }
}

// wird bei jedem '.' aufgerufen
void serialEvent(Serial p) {
  daten = p.readStringUntil('.');
  if (daten == null) return;
  daten = trim(daten.replace(".", ""));
  int komma = daten.indexOf(',');
  if (komma > 0) {
    winkel  = int(daten.substring(0, komma));
    abstand = int(daten.substring(komma + 1));
  }
}

Startest du den Processing-Sketch, siehst du den gruenen Radarschirm mit rotierendem Strahl. Kommt ein Objekt in Reichweite, blitzt ein roter Punkt an der passenden Stelle auf – und verblasst dank der halbtransparenten Uebermalung langsam wieder, genau wie beim echten Radar.

5Ohne PC: Radar auf dem OLED

Willst du das Radar mobil und ohne Laptop betreiben, zeichnest du den Sweep direkt auf ein OLED-Display. Das Prinzip ist identisch – nur rechnest du die Polarkoordinaten jetzt auf dem Arduino und zeichnest per Adafruit_GFX. Der Kern der Zeichenroutine:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 display(128, 64, &Wire, -1);

// Nullpunkt unten mittig auf dem 128x64-Display
const int cx = 64;
const int cy = 62;
const int rMax = 58;

void zeichneRadar(int winkel, int abstandCm) {
  display.clearDisplay();

  // Halbkreis-Rahmen
  display.drawCircle(cx, cy, rMax, SSD1306_WHITE);
  display.drawFastHLine(cx - rMax, cy, rMax * 2, SSD1306_WHITE);

  // Sweep-Strahl
  int sx = cx + cos(radians(winkel)) * rMax;
  int sy = cy - sin(radians(winkel)) * rMax;
  display.drawLine(cx, cy, sx, sy, SSD1306_WHITE);

  // Objekt (nur bis 100 cm anzeigen)
  if (abstandCm > 0 && abstandCm < 100) {
    int p = map(abstandCm, 0, 100, 0, rMax);
    int ox = cx + cos(radians(winkel)) * p;
    int oy = cy - sin(radians(winkel)) * p;
    display.fillCircle(ox, oy, 2, SSD1306_WHITE);
  }
  display.display();
}

Diese Funktion rufst du in der Sweep-Schleife statt (oder zusaetzlich zu) sendePaar() auf. Wie du das OLED grundsaetzlich einrichtest und mit radians() rechnest, steht im OLED-SSD1306-Tutorial.

Troubleshooting