HC-SR04 Ultraschall-Entfernungssensor mit Arduino

Der HC-SR04 ist ein günstiger, einfach zu verwendender Ultraschall-Abstandssensor mit einer Reichweite von 2 cm bis 400 cm. Er wird häufig in Hindernisvermeidungsrobotern und Automatisierungsprojekten eingesetzt. In diesem Tutorial lernst du, wie der Sensor funktioniert und wie du ihn mit Arduino verwenden kannst.

Ich habe 5 Beispiele mit Schaltplan und Code beigefügt, damit du mit deinem Sensor experimentieren kannst. Zuerst schauen wir uns ein Beispiel an, das keine Arduino-Bibliothek verwendet. Danach zeige ich dir, wie du die NewPing Bibliothek verwenden kannst, um einen kompakteren Code zu erstellen.

Materialien

Hardware-Komponenten

	HC-SR04 sensor	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	USB cable type A/B	× 1	Amazon
	20×4 character I2C LCD (optional)	× 1	Amazon
	DHT11 sensor (optional)	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Wie funktioniert ein Ultraschall-Abstandssensor?

Ultraschallsensoren arbeiten, indem sie Schallwellen mit einer Frequenz aussenden, die für Menschen nicht hörbar ist. Diese Schallwellen breiten sich mit Schallgeschwindigkeit von etwa 343 m/s durch die Luft aus. Befindet sich ein Objekt vor dem Sensor, werden die Schallwellen reflektiert und vom Empfänger des Ultraschallsensors erkannt. Durch Messen der Zeit zwischen Aussenden und Empfangen der Schallwellen kann der Abstand zwischen Sensor und Objekt berechnet werden.

Bei 20°C beträgt die Schallgeschwindigkeit etwa 343 m/s oder 0,034 cm/µs. Angenommen, die Zeit zwischen Aussenden und Empfangen der Schallwellen beträgt 2000 Mikrosekunden. Multipliziert man die Schallgeschwindigkeit mit der Zeit, erhält man die Strecke, die die Schallwellen zurückgelegt haben.

Entfernung = Geschwindigkeit × Zeit

Das ist jedoch nicht das Ergebnis, das wir suchen. Der Abstand zwischen Sensor und Objekt ist tatsächlich nur halb so groß, da die Schallwellen vom Sensor zum Objekt und zurück zum Sensor reisen. Daher muss das Ergebnis durch zwei geteilt werden.

Entfernung (cm) = Schallgeschwindigkeit (cm/µs) × Zeit (µs) / 2

Für das Beispiel ergibt sich somit:

Entfernung (cm) = 0,0343 (cm/µs) × 2000 (µs) / 2 = 34,3 cm

Temperaturabhängigkeit der Schallgeschwindigkeit

Die Schallgeschwindigkeit hängt stark von der Temperatur und in viel geringerem Maße von der Luftfeuchtigkeit ab. Wikipedia gibt an, dass die Schallgeschwindigkeit um etwa 0,6 m/s pro Grad Celsius zunimmt. Für die meisten Fälle bei 20°C kannst du einfach 343 m/s verwenden, aber wenn du genauere Messwerte möchtest, kannst du die Schallgeschwindigkeit mit folgender Formel berechnen:

V (m/s) = 331,3 + (0,606 × T)

V = Schallgeschwindigkeit (m/s)
T = Lufttemperatur (°C)

Diese Formel berücksichtigt nicht die Luftfeuchtigkeit, da deren Einfluss auf die Schallgeschwindigkeit sehr gering ist.

Unten findest du ein Tutorial, wie du einen DHT11 Temperatur- und Luftfeuchtigkeitssensor verwenden kannst, um die Schallgeschwindigkeit zu kalibrieren und genauere Abstandsmessungen mit dem HC-SR04 zu erhalten.

Wie der HC-SR04 funktioniert

An der Vorderseite des HC-SR04 Sensors befinden sich zwei silberne Zylinder (Ultraschallwandler), einer ist der Sender der Schallwellen, der andere der Empfänger. Um einen Ultraschallimpuls zu erzeugen, muss der Trig-Pin mindestens 10 µs lang auf HIGH gesetzt werden. Der Sensor erzeugt dann einen 8-Zyklen-Ultraschallimpuls bei 40 kHz.

Dieser Ultraschallimpuls breitet sich mit Schallgeschwindigkeit aus, wird reflektiert und vom Empfänger des Sensors empfangen. Der Echo-Pin gibt dann die Zeit aus, die die Schallwellen in Mikrosekunden unterwegs waren.

Du kannst die pulseIn() Funktion im Arduino-Code verwenden, um die Pulsdauer vom Echo-Pin zu lesen. Danach kannst du die oben genannte Formel verwenden, um den Abstand zwischen Sensor und Objekt zu berechnen.

HC-SR04 Spezifikationen

Betriebsspannung	5 V
Betriebsstrom	15 mA
Frequenz	40 kHz
Messbereich	2 – 400 cm
Auflösung	3 mm
Messwinkel	15 Grad
Trigger-Eingangssignal	10 µs hoher Impuls
Kosten	Check price

Weitere Informationen findest du im untenstehenden Datenblatt:

Verdrahtung – HC-SR04 mit Arduino UNO verbinden

Das folgende Schaltbild zeigt, wie du den HC-SR04 Sensor mit dem Arduino verbindest.

Die folgenden Codebeispiele verwenden digitale Pins 2 und 3 für Trigger- bzw. Echo-Pin, du kannst diese aber natürlich auf jeden beliebigen digitalen Pin ändern.

HC-SR04 Anschlüsse

HC-SR04	Arduino
VCC	5 V
Trig	Pin 2
Echo	Pin 3
GND	GND

Beispielcode für HC-SR04 mit Arduino

Nachdem du den Sensor verdrahtet hast, verbinde den Arduino mit dem Computer und lade etwas Code hoch. Du kannst den folgenden Beispielcode mit der Arduino IDE auf deinen Arduino laden. Danach erkläre ich dir, wie der Code funktioniert.

/* Example code for HC-SR04 ultrasonic distance sensor with Arduino. 
   No library required. More info: https://www.makerguides.com */

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);
  // Calculate the distance:
  distance = duration * 0.034 / 2;

  // Print the distance on the Serial Monitor (Ctrl+Shift+M):
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(50);
}

Wie der Code funktioniert

Zuerst werden der Trigger-Pin und der Echo-Pin definiert. Ich nenne sie trigPin und EchoPin. Der Trigger-Pin ist mit digitalem Pin 2 und der Echo-Pin mit digitalem Pin 3 am Arduino verbunden.

Die Anweisung #define wird verwendet, um einem konstanten Wert einen Namen zu geben. Der Compiler ersetzt alle Verweise auf diese Konstante durch den definierten Wert, wenn das Programm kompiliert wird. Überall, wo du trigPinerwähnst, ersetzt der Compiler es beim Kompilieren durch den Wert 2.

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

Als nächstes definiere ich zwei Variablen: duration und distance. Duration speichert die Zeit zwischen Aussenden und Empfangen der Schallwellen. Die Variable distance speichert den berechneten Abstand.

// Define variables:
long duration;
int distance;

Im setup()setzt du den trigPin als Ausgang und den echoPin als Eingang. Danach initialisierst du die serielle Kommunikation mit einer Baudrate von 9600. Später wird die gemessene Entfernung im seriellen Monitor angezeigt, den du mit Strg+Shift+M oder über Tools > Serial Monitor öffnen kannst. Achte darauf, dass die Baudrate auch im seriellen Monitor auf 9600 eingestellt ist.

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

Im loop()löst du den Sensor aus, indem du den trigPin für 10 µs auf HIGH setzt. Beachte, dass du für ein sauberes Signal zuerst den trigPin für 5 Mikrosekunden auf LOW setzt.

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

Als nächstes musst du die Pulsdauer vom echoPin lesen. Ich verwende dafür die Funktion pulseIn() . Diese Funktion wartet darauf, dass der Pin von LOW auf HIGH wechselt, startet die Zeitmessung, wartet dann, bis der Pin wieder LOW wird, und stoppt die Zeitmessung.

Danach kannst du den Abstand mit der im Einführungsteil genannten Formel berechnen.

// Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
duration = pulseIn(echoPin, HIGH);
// Calculate the distance:
distance = duration * 0.034 / 2;

Schließlich wird der berechnete Abstand im seriellen Monitor ausgegeben.

// Print the distance on the Serial Monitor (Ctrl+Shift+M):
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");

delay(50);

Beispielcode HC-SR04 mit Arduino und NewPing Bibliothek

Die NewPing Bibliothek von Tim Eckel kann mit vielen Ultraschall-Abstandssensoren verwendet werden. Die neueste Version dieser Bibliothek kannst du hier auf bitbucket.org. herunterladen. Du wirst feststellen, dass der untenstehende Code, der die NewPing Bibliothek verwendet, viel kürzer ist als der vorherige Code. Außerdem bietet die NewPing Bibliothek einige praktische Funktionen. Du kannst eine maximale Messdistanz einstellen, es gibt keine Verzögerung von einer Sekunde, wenn kein Echo empfangen wird, und sie hat einen eingebauten Medianfilter.

Du kannst die Bibliothek installieren, indem du in der Arduino IDE zu Sketch > Include Library > Add .ZIP Library gehst.

Die Bibliothek enthält einige Beispiele, die du verwenden kannst, aber du musst sie an deine Hardware anpassen. Ich habe unten einen modifizierten Beispielcode beigefügt, der mit der gleichen Verdrahtung wie zuvor funktioniert.

/* HC-SR04 ultrasonic distance sensor with 
   NewPing library example code. 
   More info: www.www.makerguides.com */

// Include the library:
#include "NewPing.h"

// Define pins and max distance:
#define trigPin  2
#define echoPin  3
#define MAX_DISTANCE 350 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
float duration, distance;

void setup() {
  Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results.
}

void loop() {
  delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  
  duration = sonar.ping();
  distance = (duration / 2) * 0.0343;
  
  Serial.print("Distance = ");
  Serial.print(distance); // Distance will be 0 when out of set max range.
  Serial.println(" cm");
}

Du kannst auch distance = sonar.ping_cm() oder distance = sonar.ping_in() verwenden, die die gemessene Entfernung in ganzen Zentimetern oder Zoll zurückgeben. Mit dieser Funktion musst du keine Dauer messen und die Entfernung berechnen.

Ultraschallsensoren im 3-Pin-Modus anschließen

Die NewPing Bibliothek erleichtert auch die Ansteuerung von Ultraschallsensoren mit nur einem I/O-Pin. Das ist praktisch, wenn du nur wenige I/O-Pins zur Verfügung hast oder einen 3-Pin Ultraschallsensor wie den Parallax Ping.

Um eine 3-Pin-Konfiguration (GND, 5V und SIG) zu erstellen, musst du sowohl den Trigger- als auch den Echo-Pin an denselben digitalen Pin am Arduino anschließen. Im Code musst du nur die Zeilen 6-7 ändern und denselben Pin für trigPin und echoPin definieren, z.B. digitalen Pin 2.

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 2

Wie man den digitalen Filter ping_median() verwendet

Das Hauptfeature, das mir an der NewPing Bibliothek gefällt, ist der eingebaute Medianfilter. Dieser Filter kann die Genauigkeit deiner HC-SR04 Messungen deutlich verbessern. Die ping_median() Funktion nimmt viele Dauer-Messungen hintereinander, verwirft Ausreißer und bildet dann den Durchschnitt der verbleibenden Werte. Standardmäßig nimmt sie 5 Messungen, du kannst aber angeben, wie viele es sein sollen. Ersetze Zeile 19 durch die folgenden Zeilen.

int iterations = 5;
duration = sonar.ping_median(iterations);

Beispielcode HC-SR04 mit I2C LCD und Arduino

Um die gemessene Entfernung auf einem 2004 oder 1602 I2C LCD anzuzeigen, musst du nur die folgenden Verbindungen herstellen und den untenstehenden Code hochladen. Der HC-SR04 Sensor wird wie zuvor angeschlossen.

I2C LCD Anschlüsse

I2C LCD	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Wenn du keinen Arduino Uno verwendest, können die SDA- und SCL-Pins an einer anderen Stelle sein. Ein Arduino UNO mit R3 Layout (1.0 Pinout) hat die SDA- (Datenleitung) und SCL- (Taktleitung) Pins in der Nähe des AREF-Pins. Sieh dir die Tabelle unten für Details an.

Board	SDA	SCL
Arduino Uno	A4	A5
Arduino Nano	A4	A5
Arduino Micro	2	3
Arduino Mega 2560	20	21
Arduino Leonardo	2	3
Arduino Due	20	21

Der Code verwendet die LiquidCrystal_I2C Bibliothek, die du auf GitHub herunterladen kannst. Stelle sicher, dass du genau diese Bibliothek installiert hast! Sie enthält auch die Wire.h Bibliothek, die die Kommunikation mit I2C-Geräten ermöglicht. Diese Bibliothek ist normalerweise in der Arduino IDE vorinstalliert.

Wenn du mehr darüber lernen möchtest, wie man ein I2C LCD mit Arduino steuert, kannst du unser Tutorial zu How to control a character I2C LCD with Arduino ansehen.

/* HC-SR04 ultrasonic distance sensor with 
   Arduino and I2C LCD example code.
   More info: https://www.makerguides.com
*/

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define SDA and SCL pin for LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Change to (0x27,16,2) for 1602 LCD 

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance:
  distance = duration*0.034/2;

  // Display the distance on the LCD:
  lcd.setCursor(0,0); // Set the cursor to column 1, line 1 (counting starts at zero)
  lcd.print("Distance = "); // Prints string "Display = " on the LCD
  lcd.print(distance); // Prints the measured distance
  lcd.print(" cm  "); // Prints "cm" on the LCD, extra spaces are needed to clear previously displayed characters
  
  delay(50);
}

Beachte, dass ich ein 20 x 4 LCD Display verwendet habe. Wenn du ein anderes LCD hast (16 x 2 ist ebenfalls üblich), musst du Zeile 20 auf LiquidCrystal_I2C lcd(0x27,16,2);ändern. Wenn dein LCD nicht die Standard-I2C-Adresse 0x27 hat, schau dir das komplette I2C Tutorial an, in dem ich erkläre, wie du die Adresse herausfinden kannst.

Beispielcode HC-SR04 mit DHT11 Temperatursensor und Arduino

Wie bereits erwähnt, hängt die Schallgeschwindigkeit stark von der Lufttemperatur ab. Wenn du lange Distanzen (3-4 m) messen möchtest, kann es sinnvoll sein, einen DHT11 oder DHT22 Temperatur- und Luftfeuchtigkeitssensor in dein Setup einzubauen. So kannst du die Schallgeschwindigkeit in Echtzeit kalibrieren und die Genauigkeit deiner Messungen erhöhen.

Einen DHT11 Sensor hinzuzufügen ist wirklich einfach. Das folgende Schaltbild zeigt, welche Verbindungen du herstellen musst. Ich verwende einen DHT11 mit Breakout-Board, daher muss ich nur 3 Pins anschließen. Achte darauf, das Etikett des Sensors zu prüfen, da die Pin-Reihenfolge je nach Hersteller unterschiedlich sein kann. Der HC-SR04 Sensor wird wie zuvor angeschlossen.

DHT11 Anschlüsse

DHT11	Arduino
VCC (+)	5 V
Signal (s)	Pin 4
GND (-)	GND

Der untenstehende Code verwendet die Adafruit DHT Humidity & Temperature Sensor Bibliothek, die du auf GitHub herunterladen kannst. Diese Bibliothek funktioniert nur, wenn du auch die Adafruit_Sensor Bibliothek installiert hast, die ebenfalls auf GitHub verfügbar ist. Du kannst die beiden Bibliotheken auch über die Buttons unten herunterladen:

Du kannst den Button oben rechts im Codefeld klicken, um den Code zu kopieren.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11 and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" //https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" //https://github.com/adafruit/DHT-sensor-library

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Begin Serial communication:
  Serial.begin(9600); // Starts the serial communication
}

void loop() {
  //  Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  float temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.print(" Celsius");
  Serial.print(", Distance = ");
  Serial.print(distance);
  Serial.println("cm");
  delay(100);
}

Beispielcode HC-SR04 mit DHT11 und I2C LCD

Der untenstehende Code kombiniert alle 3 Beispiele von oben. Er zeigt Temperatur, Schallgeschwindigkeit und gemessenen Abstand auf dem LCD an.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11, I2C LCD and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" // https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" // https://github.com/adafruit/DHT-sensor-library
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define SDA and SCL pin from LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via i2c, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4);

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();

  // Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  int temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  lcd.setCursor(0,0);
  lcd.print("Temperature: ");
  lcd.print(temperature);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Speed: ");
  lcd.print(speedofsound);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distance: ");
  lcd.print(distance);
  lcd.print(" cm  ");
  delay(100);
}

HC-SR04 Abmessungen

Unten findest du die Abmessungen des HC-SR04 Ultraschallsensors. Ich habe festgestellt, dass es kleine Unterschiede zwischen Herstellern gibt, daher empfehle ich, die Maße mit deinem eigenen Sensor abzugleichen.

HC-SR04 CAD

Ich habe einfache CAD-Zeichnungen des HC-SR04 Ultraschallsensors erstellt, die du unten herunterladen kannst.

Fazit

In diesem Artikel habe ich dir gezeigt, wie der HC-SR04 Ultraschall-Abstandssensor funktioniert und wie du ihn mit Arduino verwenden kannst.

Persönliches Projekt: Vor einiger Zeit habe ich mit Freunden eine interaktive Wandinstallation gebaut. Wir haben etwa 30 Ultraschall-Abstandssensoren verwendet, um Personen vor der Wand zu erkennen. Die Wand enthielt Lichter und Soundeffekte, die sich je nach Abstand der Personen änderten.

Günstige Ultraschall-Abstandssensoren sind super, aber in manchen Projekten brauchst du vielleicht einen wasserdichten Sensor wie den JSN-SR04T oder einen IR-Sensor, der nicht von Temperaturschwankungen beeinflusst wird. In diesem Fall könnten die folgenden Artikel hilfreich sein:

• Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial
• How to use a SHARP GP2Y0A21YK0F IR Distance Sensor with Arduino
• How to use a SHARP GP2Y0A710K0F IR Distance Sensor with Arduino
• MaxBotix MB7389 weather-resistant distance sensor tutorial
• MaxBotix MB1240 ultrasonic distance sensor Arduino tutorial

Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte unten einen Kommentar.