HC-SR04 Ultraschall-Abstandsmesser mit Arduino – Tutorial

Einleitung: Warum der HC-SR04?

Ob Parkhilfe, Füllstandsüberwachung oder Robotik – überall dort, wo berührungslos Entfernungen gemessen werden sollen, ist der HC-SR04 Ultraschallsensor eine der ersten Wahl. Er kostet nur wenige Euro, ist extrem einfach anzusteuern und liefert für die meisten Hobby-Anwendungen völlig ausreichende Genauigkeit. Kein Wunder also, dass er in unzähligen Tutorials, Starter-Kits und Maker-Projekten zu finden ist.

In diesem Artikel tauchen wir tief in die Materie ein. Du erfährst nicht nur, wie du den Sensor anschließt und ein paar Zeilen Code hochlädst – sondern auch, warum das Ganze so funktioniert, welche Fehlerquellen es gibt und wie du den HC-SR04 in echten Projekten einsetzt. Am Ende hast du zwei funktionierende Aufbauten: einen einfachen Abstandsmesser mit Ausgabe im Serial Monitor und einen erweiterten Aufbau mit OLED-Display und Warn-LED.

Physikalische Grundlagen: Wie funktioniert Ultraschall-Messung?

Das Echolot-Prinzip

Die Messmethode des HC-SR04 basiert auf dem gleichen Prinzip, das Fledermäuse und Delfine zur Orientierung nutzen: der Echolotung. Der Sensor sendet einen kurzen Ultraschall-Impuls aus, der von einem Objekt reflektiert wird und als Echo zum Sensor zurückkehrt. Aus der vergangenen Zeit zwischen Senden und Empfangen lässt sich die Entfernung berechnen.

Ultraschall bezeichnet Schallwellen mit Frequenzen oberhalb des menschlichen Hörbereichs – typischerweise ab 20 kHz. Der HC-SR04 arbeitet mit einer Frequenz von 40 kHz. Diese Frequenz ist hoch genug, um von den meisten Oberflächen gut reflektiert zu werden, und gleichzeitig niedrig genug für eine kostengünstige Elektronik.

Die Schallgeschwindigkeit – der Schlüssel zur Berechnung

Die zentrale physikalische Größe ist die Schallgeschwindigkeit in Luft. Sie beträgt bei 20 °C Raumtemperatur etwa 343 m/s (oder 0,0343 cm/µs). Entscheidend ist: Die Schallgeschwindigkeit ist temperaturabhängig. Pro Grad Celsius Temperaturänderung variiert sie um etwa 0,6 m/s. Bei 0 °C liegt sie bei ca. 331 m/s, bei 40 °C schon bei ca. 355 m/s.

Für die Distanzberechnung gilt folgende Formel:

Entfernung = (Schallgeschwindigkeit × gemessene Zeit) / 2

Die Division durch 2 ist notwendig, weil die gemessene Zeit den Hin- und Rückweg des Schalls umfasst. In der Arduino-typischen Mikrosekunden-Rechnung sieht das so aus:

Entfernung [cm] = (Dauer [µs] × 0,0343) / 2
                = Dauer [µs] × 0,01715

In vielen Arduino-Tutorials wird stattdessen mit dem Divisor 58 gerechnet (Dauer / 58 = Entfernung in cm), was mathematisch äquivalent ist (1 / 0,01715 ≈ 58,31). Die Abweichung durch den konstanten Faktor liegt bei unter einem Prozent und ist für die meisten Anwendungen vernachlässigbar.

Wovon werden Ultraschallwellen reflektiert?

Grundsätzlich reflektieren harte, glatte Oberflächen Ultraschallwellen am besten. Weiche, poröse Materialien wie Schaumstoff, Textilien oder dicke Vorhänge absorbieren einen Großteil der Schallenergie und liefern schwache oder gar keine Echos. Auch stark geneigte Flächen können problematisch sein, da sie den Schall weg vom Sensor reflektieren.

Der HC-SR04 hat einen effektiven Öffnungswinkel von etwa 15–30°. Das bedeutet: Je weiter ein Objekt entfernt ist, desto größer ist der vom Schallkegel abgedeckte Bereich – und desto ungenauer wird die laterale Auflösung. Für präzise Messungen sollte das Zielobjekt möglichst senkrecht zur Sensorachse stehen.

Der HC-SR04 im Detail: Technische Daten & Pinout

Bevor wir mit den Projekten loslegen, ein genauerer Blick auf den Sensor selbst. Der HC-SR04 besteht aus zwei zylindrischen Ultraschallwandlern: einem Transmitter (T, Sendewandler) und einem Receiver (R, Empfangswandler). Hinzu kommt die Steuerelektronik auf der kleinen Platine.

Pinout – die vier Anschlüsse

Das ist denkbar einfach: Vier Pins, zwei davon für die Stromversorgung, zwei für die Logik. Mehr braucht es nicht, um Entfernungen präzise zu messen.

So läuft eine Messung ab

1. Der Mikrocontroller sendet einen 10 µs langen HIGH-Puls an den Trig-Pin.
2. Der Sensor sendet daraufhin 8 Ultraschall-Impulse mit 40 kHz über den Transmitter aus.
3. Gleichzeitig setzt der Sensor den Echo-Pin auf HIGH.
4. Trifft ein Echo ein, wird der Echo-Pin wieder auf LOW gesetzt.
5. Der Mikrocontroller misst die Dauer des HIGH-Impulses am Echo-Pin mit pulseIn() in Mikrosekunden.
6. Aus der Dauer wird die Entfernung berechnet.

Benötigte Hardware für beide Projekte

Hier findest du alle Komponenten, die du für die beiden folgenden Projekte brauchst. Projekt 1 benötigt nur die Grundausstattung, Projekt 2 kommt mit Display und LED dazu.

Projekt 1: Einfacher Abstandsmesser

• 1× HC-SR04 Ultraschallsensor
• 1× UNO R3 Entwicklungsboard (oder ein Nano V3 für kompaktere Aufbauten)
• 1× Breadboard 400 Kontakte
• 4× Jumper Wire (Male-to-Male)
• USB-Kabel (USB-C beim verlinkten UNO R3)

Projekt 2: Abstandsmesser mit OLED-Display & Warn-LED

Zusätzlich zu den Komponenten aus Projekt 1:

• 1× 0,96" OLED Display SSD1306 (I2C)
• 1× Rote LED (5 mm)
• 1× Widerstand 220 Ω (für die LED)
• 1× Buzzer oder Piezo-Summer (optional)
• Zusätzliche Jumper Wire

Projekt 1: Einfacher Abstandsmesser mit Serial Monitor

Das erste Projekt ist der Klassiker: ein simpler Abstandsmesser, der die gemessene Entfernung kontinuierlich im Serial Monitor der Arduino IDE ausgibt. Perfekt, um den Sensor kennenzulernen und ein Gefühl für die Messwerte zu bekommen.

Schaltplan – so einfach wie möglich

Die Verkabelung ist in wenigen Minuten erledigt:

1. HC-SR04 VCC → 5V des Arduino
2. HC-SR04 GND → GND des Arduino
3. HC-SR04 Trig → Digital Pin 9 des Arduino
4. HC-SR04 Echo → Digital Pin 10 des Arduino

Steck den HC-SR04 einfach quer ins Breadboard, sodass die vier Pins in verschiedenen Reihen stecken, und verbinde sie mit Jumper-Kabeln zum Arduino. Achte darauf, dass der Sensor senkrecht nach vorne zeigt – in die Richtung, in die du messen möchtest.

Der Code – kommentiert und erklärt

/*
 * Projekt 1: HC-SR04 Abstandsmesser mit Serial Monitor
 * Gibt die gemessene Entfernung in cm auf dem Serial Monitor aus.
 */

const int trigPin = 9;    // Trigger-Pin an Digital 9
const int echoPin = 10;   // Echo-Pin an Digital 10

float duration;           // Dauer des Echo-Impulses in µs
float distance;           // Berechnete Entfernung in cm

void setup() {
  // Serielle Kommunikation starten
  Serial.begin(9600);
  Serial.println("=== HC-SR04 Abstandsmesser ===");
  Serial.println("Entfernung wird kontinuierlich gemessen...");
  Serial.println("");

  // Pin-Modi festlegen
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  // Schritt 1: Kurzen LOW-Puls, um sauberes Signal sicherzustellen
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  // Schritt 2: 10 µs HIGH-Impuls → löst die Messung aus
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Schritt 3: Dauer des Echo-Impulses messen
  // pulseIn() wartet max. 30 ms (30000 µs) – reicht für ~5 m
  duration = pulseIn(echoPin, HIGH, 30000);

  // Schritt 4: Entfernung berechnen
  // Formel: distance = duration * 0.0343 / 2
  // Vereinfacht: distance = duration / 58.0
  distance = duration * 0.0343 / 2;

  // Schritt 5: Ergebnis ausgeben
  if (distance > 0 && distance < 400) {
    // Gültige Messung
    Serial.print("Entfernung: ");
    Serial.print(distance, 1);  // Eine Nachkommastelle
    Serial.println(" cm");
  } else if (distance == 0) {
    // Timeout – kein Echo empfangen
    Serial.println("Kein Echo – Objekt zu weit entfernt oder nicht erkannt!");
  }

  delay(200);  // 200 ms Pause zwischen den Messungen
}

Code-Erklärung – was passiert hier?

Schauen wir uns die wichtigsten Teile genauer an:

• Zeilen 1–5 (Konstanten): trigPin und echoPin sind als Konstanten definiert. Wenn du andere Pins verwenden möchtest, änderst du nur diese zwei Werte.
• Zeile 11 (Serial.begin(9600)): Startet die serielle Kommunikation mit 9600 Baud. Öffne nach dem Upload den Serial Monitor in der Arduino IDE (Strg+Shift+M), um die Ausgabe zu sehen.
• Zeilen 28–31 (Trigger-Signal): Das ist das Herzstück. Der 10-µs-Trigger-Puls startet die Messung. Der vorherige LOW-Puls mit 2 µs stellt sicher, dass kein Restsignal mehr anliegt.
• Zeile 35 (pulseIn()): Misst die Dauer des HIGH-Impulses am Echo-Pin. Der dritte Parameter (30000) ist der Timeout in Mikrosekunden – nach 30 ms bricht die Funktion ab und gibt 0 zurück. Das entspricht einer maximal messbaren Distanz von etwa 5 Metern.
• Zeilen 40–46 (Plausibilitätsprüfung): Werte außerhalb des technisch möglichen Bereichs (0 oder über 400 cm) werden als Fehler behandelt. Das verhindert Ausreißer in der Ausgabe.

Projekt 2: Abstandsmesser mit OLED-Display & Warn-LED

Jetzt wird es praktischer: Statt die Werte nur auf dem PC auszugeben, bauen wir einen autonomen Abstandsmesser mit eigenem Display. Ein OLED-Display zeigt die Entfernung live an, und eine rote LED warnt, sobald ein kritisches Mindestmaß unterschritten wird. Das Ganze läuft komplett ohne PC – perfekt als Einparkhilfe, Füllstandsanzeige oder Robotik-Sensor.

Schaltplan – der erweiterte Aufbau

Zusätzlich zur Verkabelung aus Projekt 1 kommen nun OLED-Display und LED hinzu:

1. HC-SR04 → Arduino wie in Projekt 1 (VCC→5V, GND→GND, Trig→9, Echo→10)
2. OLED SDA → Arduino A4 (I2C Data)
3. OLED SCL → Arduino A5 (I2C Clock)
4. OLED VCC → Arduino 3.3V oder 5V (je nach Modul – die meisten SSD1306 können beides)
5. OLED GND → Arduino GND
6. LED Anode (langes Bein) → 220 Ω Widerstand → Arduino Digital Pin 6
7. LED Kathode (kurzes Bein, abgeflachte Seite) → Arduino GND

Benötigte Bibliotheken

Für das OLED-Display brauchst du zwei Bibliotheken, die du über den Library Manager der Arduino IDE installieren kannst:

• Adafruit SSD1306 – Treiber für das OLED-Display
• Adafruit GFX Library – Grafikbibliothek für Texte und Formen

Der vollständige Code – ausführlich kommentiert

/*
 * Projekt 2: HC-SR04 Abstandsmesser mit OLED-Display & Warn-LED
 * Zeigt die Entfernung live auf einem 0,96" OLED-Display an.
 * Eine rote LED warnt bei Unterschreitung eines Schwellwerts.
 * Optional: Buzzer-Ausgabe für akustische Warnung.
 *
 * Benötigte Bibliotheken:
 *   - Adafruit SSD1306 (von Adafruit)
 *   - Adafruit GFX Library (von Adafruit)
 */

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

// ============ OLED-Display Konfiguration ============
#define SCREEN_WIDTH 128        // OLED Breite in Pixel
#define SCREEN_HEIGHT 64        // OLED Höhe in Pixel
#define OLED_RESET -1           // Reset-Pin (-1 = Arduino Reset teilen)
#define SCREEN_ADDRESS 0x3C     // I2C-Adresse des Displays (oft 0x3C, manchmal 0x3D)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ============ HC-SR04 Konfiguration ============
const int trigPin = 9;
const int echoPin = 10;

// ============ LED & Buzzer Konfiguration ============
const int ledPin = 6;           // Warn-LED
const int buzzerPin = 5;        // Optional: Buzzer (auf 0 setzen wenn nicht genutzt)

// ============ Schwellwerte & Einstellungen ============
const int WARN_DISTANCE = 20;   // Abstand in cm, ab dem gewarnt wird
const int ALARM_DISTANCE = 10;  // Abstand, ab dem Dauer-Alarm ertönt
const int MAX_DISTANCE = 250;   // Maximal anzuzeigende Entfernung
const int MEASURE_DELAY = 100;  // ms zwischen Messungen
const int MOVING_AVG = 5;       // Anzahl Messwerte für gleitenden Mittelwert

// ============ Globale Variablen ============
float distances[MOVING_AVG];    // Array für gleitenden Mittelwert
int measureIndex = 0;           // Aktueller Index im Array
unsigned long lastMeasure = 0;  // Zeitstempel der letzten Messung

// ============ Icons als Bitmaps (einfache Pixel-Grafiken) ============
// Einfaches Distanz-Symbol (12x12 Pixel), nur zur Illustration
// Du kannst eigene Bitmaps mit Tools wie "image2cpp" erstellen
const unsigned char icon_distance [] PROGMEM = {
  0x00, 0x00, 0x0c, 0x00, 0x1e, 0x00, 0x33, 0x00, 0x21, 0x80, 0x61, 0x80,
  0x61, 0x80, 0x21, 0x80, 0x33, 0x00, 0x1e, 0x00, 0x0c, 0x00, 0x00, 0x00
};

void setup() {
  Serial.begin(9600);

  // HC-SR04 Pins
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // LED & Buzzer
  pinMode(ledPin, OUTPUT);
  if (buzzerPin > 0) pinMode(buzzerPin, OUTPUT);

  // OLED initialisieren
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("OLED nicht gefunden! Verkabelung prüfen."));
    while (true);  // Endlosschleife bei Fehler – blinke LED als Hinweis
  }

  // Boot-Animation auf dem Display
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 5);
  display.println(F("HC-SR04"));
  display.setCursor(10, 20);
  display.println(F("Abstandsmesser"));
  display.setCursor(10, 40);
  display.println(F("Starte..."));
  display.display();
  delay(1500);

  // Messarray initialisieren
  for (int i = 0; i < MOVING_AVG; i++) {
    distances[i] = 0;
  }

  Serial.println(F("=== HC-SR04 mit OLED & LED ==="));
}

void loop() {
  // ===== 1. ENTFERNUNG MESSEN =====
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long duration = pulseIn(echoPin, HIGH, 30000);
  float rawDistance = duration * 0.0343 / 2;

  // Plausibilitätsprüfung – Werte außerhalb des gültigen Bereichs ignorieren
  if (rawDistance <= 0 || rawDistance > MAX_DISTANCE) {
    // Ungültiger Wert – Messung überspringen (alten Wert beibehalten)
    rawDistance = distances[(measureIndex - 1 + MOVING_AVG) % MOVING_AVG];
  }

  // ===== 2. GLEITENDEN MITTELWERT BILDEN =====
  distances[measureIndex] = rawDistance;
  measureIndex = (measureIndex + 1) % MOVING_AVG;

  float avgDistance = 0;
  for (int i = 0; i < MOVING_AVG; i++) {
    avgDistance += distances[i];
  }
  avgDistance /= MOVING_AVG;

  // ===== 3. WARN-LED & BUZZER STEUERN =====
  if (avgDistance <= ALARM_DISTANCE) {
    // Dauer-Alarm: LED an, Buzzer Dauer-Ton
    digitalWrite(ledPin, HIGH);
    if (buzzerPin > 0) digitalWrite(buzzerPin, HIGH);
  } else if (avgDistance <= WARN_DISTANCE) {
    // Pulsierende Warnung: LED und Buzzer blitzen im Takt
    // Alle 150 ms umschalten → ca. 3 Hz Blinkfrequenz
    bool blinkState = (millis() / 150) % 2;
    digitalWrite(ledPin, blinkState);
    if (buzzerPin > 0) digitalWrite(buzzerPin, blinkState);
  } else {
    // Keine Gefahr – alles aus
    digitalWrite(ledPin, LOW);
    if (buzzerPin > 0) digitalWrite(buzzerPin, LOW);
  }

  // ===== 4. OLED-UPDATE =====
  updateDisplay(avgDistance);

  // ===== 5. SERIAL OUTPUT (für Debugging) =====
  Serial.print(F("Roh: "));
  Serial.print(rawDistance, 1);
  Serial.print(F(" cm | Mittel: "));
  Serial.print(avgDistance, 1);
  Serial.print(F(" cm | LED: "));
  Serial.println(digitalRead(ledPin) ? "AN" : "AUS");

  delay(MEASURE_DELAY);
}

void updateDisplay(float distance) {
  display.clearDisplay();

  // Kopfzeile mit Titel
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("=== HC-SR04 ==="));

  // Horizontale Trennlinie
  display.drawLine(0, 10, SCREEN_WIDTH, 10, SSD1306_WHITE);

  // Große Entfernungsanzeige
  display.setTextSize(3);
  display.setCursor(5, 18);

  if (distance < 10) {
    // Bei einstelligen Werten etwas einrücken für schöneres Layout
    display.setCursor(30, 18);
    display.print(distance, 1);
  } else if (distance < 100) {
    display.setCursor(15, 18);
    display.print(distance, 1);
  } else {
    display.setCursor(5, 18);
    display.print(distance, 0);  // Bei >100 cm keine Nachkommastelle
  }

  // Einheit
  display.setTextSize(1);
  display.setCursor(100, 22);
  display.print(F("cm"));

  // Status-Zeile
  display.setTextSize(1);
  display.setCursor(0, 54);

  if (distance <= ALARM_DISTANCE) {
    display.print(F("!! ZU NAH !!"));
  } else if (distance <= WARN_DISTANCE) {
    display.print(F("Achtung!"));
  } else if (distance > MAX_DISTANCE) {
    display.print(F("Kein Objekt"));
  } else {
    display.print(F("OK"));
  }

  // Fortschrittsbalken (visuelle Distanzdarstellung)
  int barWidth = map(constrain(distance, 0, MAX_DISTANCE), 0, MAX_DISTANCE, 0, SCREEN_WIDTH);
  display.drawRect(0, 48, SCREEN_WIDTH, 5, SSD1306_WHITE);
  display.fillRect(0, 49, barWidth, 3, SSD1306_WHITE);

  display.display();
}

Feature-Übersicht des erweiterten Codes

Dieser Code geht deutlich über das einfache Beispiel hinaus und enthält mehrere praxisrelevante Features:

• Gleitender Mittelwert: Die letzten 5 Messungen werden gemittelt – das eliminiert Ausreißer und glättet die Anzeige, ohne relevante Verzögerung.
• Zwei Warnstufen: Unter 20 cm blinkt die LED als Vorwarnung, unter 10 cm leuchtet sie dauerhaft. Mit optionalem Buzzer für akustische Rückmeldung.
• Fehlerresistente Messung: Ungültige Werte (0 oder über 250 cm) werden verworfen und durch den letzten gültigen Messwert ersetzt – kein Springen der Anzeige.
• OLED-Startanimation: Ein kurzer Boot-Screen beim Einschalten macht das Gerät benutzerfreundlich.
• Visueller Fortschrittsbalken: Ein Balken am unteren Displayrand zeigt die relative Entfernung grafisch an – intuitive Erfassung auf einen Blick.
• Debug-Ausgabe: Parallel zur OLED-Anzeige laufen Rohdaten über Serial – praktisch während der Entwicklung.

Fehlerbehandlung und Kalibrierung

Typische Fehler und ihre Ursachen

Kalibrierung – wie genau ist dein Sensor?

Jeder HC-SR04 hat leichte Fertigungstoleranzen. Für Anwendungen, die es genauer brauchen, lohnt sich eine einfache Kalibrierung:

1. Referenzdistanzen aufbauen: Stelle ein flaches Objekt (z. B. ein Stück Pappe oder eine Holzplatte) exakt in 20 cm, 50 cm, 100 cm und 150 cm Entfernung vom Sensor auf. Miss mit einem Maßband oder Messschieber.
2. Messwerte aufzeichnen: Nimm für jede Referenzdistanz 20–30 Messwerte auf und bilde den Mittelwert. Unser Code aus Projekt 2 macht das bereits.
3. Korrekturfaktor berechnen: Weicht der Mittelwert systematisch ab (z. B. zeigt der Sensor bei 100 cm immer 102 cm an), kannst du einen linearen Korrekturfaktor in die Berechnung einbauen: distance = distance * 0.98;.
4. Offset anpassen: Ein konstanter Offset (z. B. immer +1,5 cm) kann ebenfalls korrigiert werden: distance = distance - 1.5;.

Stromversorgung – unterschätzter Faktor

Ein häufig übersehener Punkt bei Messproblemen ist die Stromversorgung. Der HC-SR04 zieht während der Messung kurze Stromspitzen von bis zu 40 mA. Wird der Arduino über einen längeren, dünnen USB-Kabel oder einen schwachen USB-Port versorgt, können Spannungseinbrüche die Messung verfälschen. Symptome sind ungewöhnlich lange oder kurze Echozeiten, die mit der Kabellänge variieren.

Abhilfe schafft ein 100–470 µF Elektrolytkondensator zwischen 5V und GND direkt auf dem Breadboard, in unmittelbarer Nähe zum Sensor. Der Kondensator puffert die Stromspitzen und glättet die Versorgungsspannung. Besonders bei batteriebetriebenen Projekten ist dieser kleine Zusatz Gold wert.

Software-Tricks für stabilere Messwerte

• Median-Filter: Statt eines gleitenden Mittelwerts nimmst du den Median aus 5 Messungen – das eliminiert einzelne extreme Ausreißer noch effektiver.
• Timeout reduzieren: Der pulseIn()-Timeout von 30 ms ist für 4 m ausgelegt. Wenn du nur bis 1 m messen willst, setze ihn auf 6000 µs – falsche lange Echozeiten werden schneller verworfen.
• Sprung-Erkennung: Ändert sich der Messwert plötzlich um mehr als 50 cm, ignoriere den Wert – echte Objekte bewegen sich selten so sprunghaft.
• Doppelmessung verwerfen: Manchmal erzeugt eine Messung ein Echo, das in die nächste Messung hineinreicht. Ein längeres delay() (50+ ms) zwischen den Messungen verhindert das.

Praktische Anwendungen für den HC-SR04

Nachdem du den Sensor jetzt im Detail kennst, hier einige konkrete Projektideen, die über das reine „Entfernung messen" hinausgehen:

1. Einparkhilfe für die Werkstatt oder Garage

Montiere den HC-SR04 an der Garagenwand gegenüber dem Parkplatz. Sobald das Auto näher als 50 cm entfernt ist, beginnt die Warn-LED zu leuchten, unter 20 cm ertönt ein Buzzer. Unser Code aus Projekt 2 ist mit minimalen Anpassungen direkt einsatzbereit. Für die dauerhafte Installation empfehlen wir ein Nano V3 – kompakt, günstig und per USB-C versorgbar.

Ein wichtiger Praxistipp für Garagen-Installationen: Feuchte Luft und Temperaturschwankungen im Jahresverlauf verändern die Schallgeschwindigkeit merklich. Im Winter bei 0 °C zeigt der Sensor etwa 3,5 % zu wenig an – bei 2 m Abstand sind das 7 cm Unterschied. Ein Temperatursensor wie der DHT22 zur dynamischen Kompensation macht die Anzeige ganzjährig präzise. Alternativ kannst du den HC-SR04 in einem kleinen wassergeschützten Gehäuse unterbringen – achte aber darauf, dass die Sensorköpfe freie Sicht haben und nicht durch die Gehäusewand messen müssen.

2. Füllstandsmessung in Tanks oder Silos

Der HC-SR04 eignet sich hervorragend für die berührungslose Füllstandsmessung von Flüssigkeiten, Granulaten oder Pellets. Montiere den Sensor oberhalb des Behälters, mit Blickrichtung senkrecht nach unten auf die Materialoberfläche. Beachte: Die Reflexion von Ultraschall an unebenen Oberflächen (Schüttgut) kann streuen – ein breiterer Trichter oder ein Leitungsrohr verbessert die Messgenauigkeit. Für feuchte Umgebungen empfehlen wir den wasserdichten Bruder JSN-SR04T.

3. Robotik – Hinderniserkennung und Navigation

Mobile Roboter nutzen den HC-SR04 zur Hinderniserkennung. Mit zwei oder drei Sensoren (vorne, links, rechts) lassen sich einfache Navigationslogiken umsetzen: „Nähert sich links ein Hindernis, weiche nach rechts aus." Ein Servo-Mount für den Sensor (Schwenk-Neige-Mechanismus) erweitert das Sichtfeld auf nahezu 180°.

Ein häufiges Problem in der Robotik: Schnelle Bewegungen führen zu Störungen, weil der Sensor bei der vorherigen Messung noch ein Echo erwartet. Setze in Robotik-Projekten delay(60) zwischen den Messungen – das verhindert Übersprechen zuverlässig.

Für fortgeschrittene Roboter lohnt sich die Kombination mehrerer Sensortypen: Der HC-SR04 erfasst die grobe Umgebung auf 2–4 m, während ein VL53L0X Time-of-Flight-Lasersensor die Nahbereichs-Präzision (bis 2 m mit ±3 % Genauigkeit, aber dafür mit nur 2° Öffnungswinkel) liefert. Gemeinsam ergeben sie ein robustes Sensor-Fusions-System, das sowohl Weitbereich als auch Feinauflösung abdeckt – perfekt für autonome Fahrzeuge im Maker-Maßstab.

4. Besucherzähler oder Türschranke

Zwei nebeneinander montierte HC-SR04 in einem Türrahmen können erkennen, ob jemand eintritt oder hinausgeht – einfach durch die Reihenfolge, in der die Strahlen unterbrochen werden. Kombiniert mit dem OLED-Display hast du einen kompakten Personenzähler.

5. Interaktive Installationen und Kunstprojekte

Auch im kreativen Bereich glänzt der HC-SR04: gestengesteuerte Sound-Installationen, näherungsabhängige LED-Beleuchtung, oder ein „Theremin-ähnliches" Musikinstrument, das die Handposition in Tonhöhe und Lautstärke übersetzt. Die einfache Ansteuerung macht den Sensor auch für Anfänger im kreativen Coding zugänglich.

Cross-Selling: Das richtige Zubehör für dein Projekt

Ein Projekt wie der autonome Abstandsmesser lebt von der Qualität der Komponenten. Hier eine kurze Übersicht, was bei makeroo gut zusammenpasst: