Radar-Projekt: Objekte erkennen mit Ultraschall und Arduino

Arduino Ideen

Details: Kategorie: Arduino neue Ideen; Erstellt: 05. April 2026; Zugriffe: 20

Hast du dich jemals gefragt, wie Schiffe im Nebel navigieren oder wie Flughäfen den Luftraum überwachen? Das Prinzip dahinter ist faszinierend einfach und lässt sich mit einem Arduino, einem Ultraschallsensor und einem Display wunderbar nachbauen. In diesem Projekt zeige ich dir, wie du dein eigenes Desktop-Radar baust – inklusive grafischer Oberfläche und Einstellungsmenü.

Wie funktioniert ein Radar im Original?

Das Wort RADAR steht für Radio Detection and Ranging. Ein echtes Radar sendet elektromagnetische Wellen (Radiowellen) aus. Diese breiten sich mit Lichtgeschwindigkeit aus. Trifft eine Welle auf ein Hindernis (z. B. ein Flugzeug), wird sie reflektiert und zum Empfänger zurückgeschickt. Da wir die Lichtgeschwindigkeit kennen, müssen wir nur die Zeit messen, bis das Signal wieder bei uns eintrifft, um die Entfernung zu berechnen.

Das Arduino-Radar: Schall statt Funk

Bei unserem Projekt nutzen wir statt Radiowellen Ultraschall. Das Prinzip bleibt das gleiche, aber wir arbeiten mit der Schallgeschwindigkeit (ca. $343 m/s$).

Der Sensor: Der HC-SR04 Ultraschallsensor sendet einen kurzen Ton aus, den wir nicht hören können.
Der Servo: Damit wir nicht nur in eine Richtung messen, montieren wir den Sensor auf einen Servo-Motor. Dieser dreht den Sensor Stück für Stück von $0^\circ$ bis $180^\circ$.
Die Berechnung: Der Arduino misst die Zeit in Mikrosekunden, die der Schall für den Hin- und Rückweg braucht. Mit der Formelerrechnet er die Entfernung in Zentimetern.
$$Distanz = \frac{Zeit \times 0,034}{2}$$
Das Display: Die Daten werden in Echtzeit auf ein ILI9486 TFT-Display gezeichnet, sodass eine klassische Radar-Anzeige entsteht.

Hardware und PIN-Definition

Für dieses Projekt habe ich einen Arduino R4 Minima verwendet, da dieser genug Power für die Grafikberechnung hat. Die Steuerung erfolgt über einen Drehencoder mit Tastfunktion.

Komponente	Pin am Arduino	Beschreibung
Ultraschall TRIG	7	Auslöser für den Messimpuls
Ultraschall ECHO	6	Empfänger des Echos
Servo PWM	5	Steuerung der Drehbewegung
Encoder Button	4	Menü aufrufen / Bestätigen
Encoder A	2	Drehrichtung (Interrupt Pin)
Encoder B	3	Drehrichtung
TFT Display	SPI Pins	Grafik-Ausgabe (ILI9486)

Ein Blick in den Code: So wird es schlau

Der Code ist in drei große Bereiche unterteilt, die dafür sorgen, dass das Radar flüssig läuft und du es einfach bedienen kannst.

1. Die Filter-Logik (Anti-Flacker-System)

Ultraschallsensoren können manchmal "lügen", wenn Schallwellen ungünstig reflektiert werden. Deshalb nutzt der Code die Funktion getCleanDistance(). Hier wird nicht nur einmal gemessen, sondern der Arduino vergleicht zwei Messungen kurz hintereinander. Weichen diese zu stark voneinander ab, wird eine dritte Kontrollmessung gemacht. Das sorgt für ein extrem ruhiges Bild auf dem Display ohne "Geister-Objekte".

2. Die Radar-Grafik

Um die Punkte auf dem runden Radar-Grid zu zeichnen, nutzt der Arduino Trigonometrie. Da das Display X und Y Koordinaten "denkt", wir aber Winkel und Distanz haben, rechnen wir das intern um:

arduino projekt Radar mit 4 zoll TFT

Ein alter Punkt wird immer gelöscht, bevor ein neuer gezeichnet wird, damit das Display nicht "zumüllt".

3. Das Menü-System

Das Highlight ist das integrierte Menü. Du kannst während des Betriebs den Encoder-Taster drücken, um in den Einstellungsmodus zu wechseln.

Betrieb: Schaltet den Scan ein oder aus.
Max/Min Dist: Hier legst du fest, in welchem Bereich das Radar Objekte suchen soll (bis zu $300 cm$).
Speed: Hier kannst du die Geschwindigkeit des Servos in vier Stufen anpassen.

Damit der Encoder auch bei schnellen Drehungen keine Schritte verpasst, wird Pin 2 über einen Interrupt abgefragt. Das bedeutet, egal was der Arduino gerade tut, er pausiert kurz sein Hauptprogramm, zählt den Encoder-Schritt und macht sofort weiter.

Tipp: Wenn du merkst, dass dein Servo beim Anlaufen das Display kurz flackern lässt, baue einen großen Elko (z. B. $1000 \mu F$) in die Stromversorgung ein. Das fängt die Stromspitzen ab und hält dein System stabil!

Viel Spaß beim Nachbauen und Experimentieren mit deinem eigenen Arduino-Radar!

Der obere Servo wird nicht benötigt. Das Gestell gehört zu einem Sonnenverfolger, deshalb sind es zwei Servors.

Der Arduino Code für das Radar

// www.kreativekiste.de // 2026-04-05 // 1.2
#include <SPI.h>
#include <ILI9486_SPI.h>
#include <Servo.h>

// Pins
const int TRIG_PIN = 7;
const int ECHO_PIN = 6;
const int SERVO_PIN = 5;
const int SW_PIN = 4;
const int ENC_A = 2;
const int ENC_B = 3;

// Display & Servo
ILI9486_SPI tft(SS, 8, 9);
Servo radarServo;

// Radar Variablen
int angle = 0;
int step = 1;
bool isScanning = false;
int maxDistance = 40;
int minDistance = 3; // Etwas höherer Mindestwert hilft oft gegen Eigenreflexionen
int detectedDistances[181];
const int centerX = 240;
const int centerY = 310;
const int radius = 280;

// Menü Variablen
enum SystemState { RADAR_MODE, MENU_NAV, MENU_EDIT };
SystemState currentState = RADAR_MODE;

int menuIndex = 0;
const int totalMenuItems = 5;
const char* menuLabels[] = {"Betrieb", "Max Dist", "Min Dist", "Speed", "Zurueck"};

const char* speedNames[] = {"Low", "Mid Low", "Mid High", "High"};
int speedDelays[] = {60, 40, 25, 15}; // Zeiten leicht erhöht für mehr Stabilität
int currentSpeedIdx = 2; 

// Encoder Logik
volatile int encoderPos = 0;
int lastEncoderPos = 0;
bool buttonPressed = false;
bool needsMenuRedraw = true;

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(SW_PIN, INPUT_PULLUP);
  pinMode(ENC_A, INPUT_PULLUP);
  pinMode(ENC_B, INPUT_PULLUP);

  attachInterrupt(digitalPinToInterrupt(ENC_A), readEncoder, CHANGE);

  radarServo.attach(SERVO_PIN);
  tft.setSpiKludge(false);
  tft.init();
  tft.setRotation(3);
  tft.fillScreen(0x0000);
  
  drawRadarGrid();
}

void readEncoder() {
  if (digitalRead(ENC_A) == digitalRead(ENC_B)) encoderPos++;
  else encoderPos--;
}

void loop() {
  checkButton();

  if (currentState == RADAR_MODE) {
    if (isScanning) {
      scan();
    }
  } else {
    handleMenu();
  }
}

void checkButton() {
  static unsigned long lastDebounce = 0;
  if (digitalRead(SW_PIN) == LOW && (millis() - lastDebounce > 350)) {
    buttonPressed = true;
    lastDebounce = millis();
    
    if (currentState == RADAR_MODE) {
      currentState = MENU_NAV;
      tft.fillScreen(0x0000);
      needsMenuRedraw = true;
    }
  }
}

void handleMenu() {
  int change = encoderPos - lastEncoderPos;
  
  if (change != 0 || buttonPressed) {
    lastEncoderPos = encoderPos;

    if (currentState == MENU_NAV) {
      if (change != 0) {
        menuIndex = constrain(menuIndex + (change > 0 ? 1 : -1), 0, totalMenuItems - 1);
      }
      if (buttonPressed) {
        buttonPressed = false;
        if (menuIndex == 0) isScanning = !isScanning;
        else if (menuIndex == 4) { 
          switchToRadar();
          return;
        } else {
          currentState = MENU_EDIT;
        }
      }
    } 
    else if (currentState == MENU_EDIT) {
      if (change != 0) {
        int dir = (change > 0 ? 1 : -1);
        if (menuIndex == 1) maxDistance = constrain(maxDistance + dir, 10, 300);
        if (menuIndex == 2) minDistance = constrain(minDistance + dir, 0, maxDistance - 5);
        if (menuIndex == 3) currentSpeedIdx = constrain(currentSpeedIdx + dir, 0, 3);
      }
      if (buttonPressed) {
        buttonPressed = false;
        currentState = MENU_NAV;
      }
    }
    needsMenuRedraw = true;
  }

  if (needsMenuRedraw) {
    drawMenu();
    needsMenuRedraw = false;
  }
}

void switchToRadar() {
  currentState = RADAR_MODE;
  tft.fillScreen(0x0000);
  drawRadarGrid();
  for (int i = 0; i <= 180; i++) {
    if (detectedDistances[i] > 0) {
      float rad = i * PI / 180;
      int x = centerX + cos(rad + PI) * map(detectedDistances[i], 0, maxDistance, 0, radius);
      int y = centerY + sin(rad + PI) * map(detectedDistances[i], 0, maxDistance, 0, radius);
      tft.fillCircle(x, y, 3, 0xF800);
    }
  }
}

void drawMenu() {
  tft.setCursor(20, 20);
  tft.setTextColor(0xFFFF, 0x0000);
  tft.setTextSize(3);
  tft.println("--- EINSTELLUNGEN ---");
  
  for (int i = 0; i < totalMenuItems; i++) {
    uint16_t color = (i == menuIndex) ? 0xF800 : 0xFFFF;
    tft.setTextColor(color, 0x0000);
    
    tft.setCursor(20, 70 + (i * 40));
    tft.print(menuLabels[i]);
    tft.print(": ");
    
    if (i == 0) tft.print(isScanning ? "EIN    " : "AUS    ");
    if (i == 1) { tft.print(maxDistance); tft.print(" cm   "); }
    if (i == 2) { tft.print(minDistance); tft.print(" cm   "); }
    if (i == 3) { tft.print(speedNames[currentSpeedIdx]); tft.print("      "); }
    if (i == 4) { tft.print("       "); }
    
    if (i == menuIndex && currentState == MENU_EDIT) {
      tft.setTextColor(0x07E0, 0x0000);
      tft.print(" <--");
    } else {
      tft.print("    "); 
    }
  }
}

void scan() {
  radarServo.write(angle);
  // Wartezeit, damit der Servo zur Ruhe kommt
  delay(speedDelays[currentSpeedIdx]);

  int distance = getCleanDistance();
  updateDisplay(angle, distance);

  angle += step;
  if (angle >= 180 || angle <= 0) step *= -1;
}

// Neue Filter-Logik: Misst 3x und prüft auf Plausibilität
int getCleanDistance() {
  int d1 = measureDistance();
  delay(10); // Kurze Pause zwischen Pings
  int d2 = measureDistance();
  
  // Wenn zwei Messungen weit auseinander liegen, ist eine vermutlich falsch
  if (abs(d1 - d2) > 5) {
     delay(10);
     int d3 = measureDistance();
     // Nimm den Wert, der öfter vorkommt oder plausibler ist
     if (abs(d2 - d3) < 5) return d2;
     if (abs(d1 - d3) < 5) return d1;
     return 0; // Zu unruhig -> ignoriere Messung
  }
  return d1;
}

int measureDistance() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(5);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  // Timeout auf 15000 reduziert (reicht für ca. 2.5m und macht den Code schneller)
  long duration = pulseIn(ECHO_PIN, HIGH, 20000); 
  if (duration == 0) return 0;

  int dist = (int)(duration * 0.034 / 2);
  
  if (dist > maxDistance || dist < minDistance) return 0;
  return dist;
}

void drawRadarGrid() {
  for (int i = 1; i <= 4; i++) {
    tft.drawCircle(centerX, centerY, (radius / 4) * i, 0x07E0);
  }
  for (int i = 30; i <= 150; i += 30) {
    float rad = i * PI / 180;
    tft.drawLine(centerX, centerY, centerX + cos(rad + PI) * radius, centerY + sin(rad + PI) * radius, 0x07E0);
  }
}

void updateDisplay(int ang, int dist) {
  float rad = ang * PI / 180;
  int xLine = centerX + cos(rad + PI) * radius;
  int yLine = centerY + sin(rad + PI) * radius;

  if (detectedDistances[ang] > 0) {
    int oldX = centerX + cos(rad + PI) * map(detectedDistances[ang], 0, maxDistance, 0, radius);
    int oldY = centerY + sin(rad + PI) * map(detectedDistances[ang], 0, maxDistance, 0, radius);
    tft.fillCircle(oldX, oldY, 3, 0x0000);
  }

  if (dist > 0) {
    int newX = centerX + cos(rad + PI) * map(dist, 0, maxDistance, 0, radius);
    int newY = centerY + sin(rad + PI) * map(dist, 0, maxDistance, 0, radius);
    tft.fillCircle(newX, newY, 3, 0xF800);
    detectedDistances[ang] = dist;
  } else {
    detectedDistances[ang] = 0;
  }

  tft.drawLine(centerX, centerY, xLine, yLine, 0x07E0);
  float oldRad = (ang - (step * 2)) * PI / 180;
  tft.drawLine(centerX, centerY, centerX + cos(oldRad + PI) * radius, centerY + sin(oldRad + PI) * radius, 0x0000);
  
  if (ang % 20 == 0) drawRadarGrid();
}

Kontakt

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen.