Bewegungsmelder HC-SR501 + ESP32 Tutorial

Übersicht – Bewegungssensor HC-SR501 und ESP32

Für dieses einfache und spannende Projekt, bei dem wir einen Bewegungssensor mit einem ESP32 verbinden, benötigst du nur wenige Komponenten. Der HC-SR501 ist ein passiver Infrarot-Sensor (PIR), der Bewegungen durch die Erkennung von Änderungen in der Infrarotstrahlung seiner Umgebung feststellt – ideal, um beispielsweise eine Alarmanlage oder eine automatische Beleuchtung zu bauen. Der ESP32 ist die perfekte Wahl für die Verarbeitung der Daten, da er dank seines eingebauten Wi-Fi und Bluetooth die erfassten Bewegungen direkt ins Internet senden oder komplexe Logiken ausführen kann.
Hier ist eine kurze Liste der benötigten Teile:
1x ESP32 (Mikrocontroller)
1x Bewegungssensor HC-SR501 (Passiver Infrarot Sensor – PIR)
3x Verbindungskabel (Dupont-Kabel)

Pinout – Bewegungssensor HC-SR501

Der HC-SR501 Bewegungssensor ist sehr einfach aufgebaut und verfügt lediglich über drei Anschlusspins. Diese Pins sind standardisiert und ermöglichen eine problemlose Anbindung an den ESP32. Du findest die Anschlüsse für die Spannungsversorgung (VCC und GND) sowie einen Datenpin (OUT) für das eigentliche Signal.
Hier ist eine kurze Erklärung der drei Pins:
VCC: Hier legst du die Versorgungsspannung von 5V an, um den Sensor zu betreiben.
GND: Der Masse-Anschluss.
OUT: Dies ist der digitale Ausgangspin. Er liefert ein HIGH-Signal (ca. 3.3V oder 5V, je nach Betrieb) bei erkannter Bewegung und ein LOW-Signal bei Ruhe.

Erklärung / Funktion – Bewegungssensor HC-SR501

Der HC-SR501 Bewegungssensor ist ein digitaler Sensor und kann so am Daten-Pin High und Low ausgeben.
Grundsätzlich gilt: High, wenn eine Bewegung erkannt wurde. Wurde keine Bewegung erkannt wird Low ausgegeben.

Kommt es zu einem Bewegungsimpuls, gibt der HC-SR501 für eine bestimmte Zeit (der sogenannten Haltezeit) ein High-Signal aus.
Danach ist der Sensor für eine bestimmte Zeit gesperrt (der sogenannten Sperrzeit) in dieser Zeit wird keine Bewegung erkannt.
Ist die Sperrzeit vorüber, kann auch wieder eine Bewegung erkannt werden.

Einstellung des Bewegungssensors HC-SR501

Der HC-SR501 Bewegungssensor verfügt über zwei Potentiometer und einen Jumper zur Konfiguration. Diese Bedienelemente erlauben es dir, die Empfindlichkeit (Erfassungsreichweite) und die Dauer des Ausgangssignals individuell an dein Projekt anzupassen.

Linkes Potentiometer: Einstellung Empfindlichkeit + Reichweite
Auf der Platine findest du, wie unten dargestellt, auf der linken Seite ein Potentiometer.
Einstellung: Durch Drehen dieses Potis kannst du die Empfindlichkeit und somit die Erfassungsreichweite des Sensors einstellen.
Reichweite: Die Reichweite kann typischerweise von etwa 3 Metern bis zu 7 Metern variiert werden.
Drehrichtung:
Drehen im Uhrzeigersinn (CW): Erhöht die Empfindlichkeit und damit die Reichweite.
Drehen gegen den Uhrzeigersinn (CCW): Verringert die Empfindlichkeit und damit die Reichweite.

Rechtes Potentiometer: Einstellung der Haltezeit
Das zweite Potentiometer ist für die Haltezeit (auch Verzögerungszeit oder Blockierungszeit genannt) zuständig.
Ausgangssignal: Der Bewegungssensor liefert am Datenpin (OUT) ein digitales Signal aus: HIGH bei erkannter Bewegung und LOW bei Ruhe.
Zeitdauer: Die Haltezeit bestimmt, wie lange der Pin nach einer Bewegungserkennung mindestens auf HIGH geschaltet bleibt, bevor er wieder auf LOW zurückfällt und auf die nächste Bewegung warten kann.
Einstellbereich: Dieser Bereich kann in der Regel von wenigen Sekunden (ca. 5 Sekunden) bis zu mehreren Minuten (z.B. 5 Minuten) eingestellt werden.
Drehrichtung:
Drehen im Uhrzeigersinn (CW): Verlängert die HIGH-Dauer.
Drehen gegen den Uhrzeigersinn (CCW): Verkürzt die HIGH-Dauer.

Der Jumper – Wiederholtes Auslösen (Trigger Mode)

Der Jumper (oft mit L und H oder Single/Repeat markiert) bestimmt das Verhalten des Sensors, wenn während der Verzögerungszeit eine neue Bewegung erkannt wird.
Der Bewegungssensor hat zwei Modi:

Jumper auf L: Nicht-wiederholbarer Trigger (Single Trigger):
Position: Jumper auf die L-Position.
Verhalten: Nach der ersten Bewegung bleibt der Ausgang für die eingestellte Verzögerungszeit auf HIGH. Erkannte Bewegungen während dieser Zeit werden ignoriert. Das Signal geht danach auf LOW, und der Sensor startet neu.

Jumper auf H: Wiederholbarer Trigger (Repeatable Trigger):
Position: Jumper auf die H-Position.
Verhalten: Solange im Erfassungsbereich Bewegungen erkannt werden, verlängert jede neue Bewegung die Verzögerungszeit erneut. Der Ausgang bleibt so lange auf HIGH, wie Aktivität im Sichtfeld herrscht.

Erklärung / Auswirkung der Jumper-Einstellung

Auf dem Bild sind oben die Bewegungsimpulse über der Zeit dargestellt, welche auf den Bewegungsmelder wirken.
Direkt darunter die Auswirkung, wenn der Jumper auf L gestellt ist. Darunter ist die Auswirkung dargestellt, wenn der Jumper auf H eingestellt ist.

Beim ersten Bewegungsimpuls (lila) löst bei beiden Varianten der Sensor aus und gibt ein High-Signal aus.
Direkt danach kommen weitere Bewegungsimpulse (grün).
Wenn der Jumper auf L eingestellt ist, werden diese nicht erkannt. Das Signal bleibt während der Haltezeit auf High und geht danach auf Low.
Wenn der Jumper auf H eingestellt ist, werden auch während der Haltezeit Bewegungsimpulse erkannt. Das Signal bleibt dann auf High.

Der blaue Bewegungsimpuls ist der letzte.
Bei der Jumper-Einstellung H bleibt das Signal noch die eingestellte Haltezeit High. Danach geht es auf Low zurück und es setzt die Sperrzeit ein, in welcher kein Bewegungsimpuls erkannt wird.
So wird hier auch der orangene Bewegungsimpuls nicht erkannt.
Hingegen bei der Jumper-Einstellung L ist die Sperrzeit vorbei. Daher wird auch der orangene Bewegungsimpuls erkannt.

Hardware Aufbau / Verkabelung / Schaltungsaufbau

Der physische Aufbau ist denkbar einfach und erfordert nur drei Verbindungen, um den Bewegungssensor (HC-SR501) mit deinem ESP32 zu verknüpfen. Es ist wichtig, die Spannungsversorgung (VCC und GND) korrekt anzuschließen, um den Sensor mit Strom zu versorgen. Das Ausgangssignal des Sensors, das uns über erkannte Bewegungen informiert, wird direkt an einen digitalen GPIO-Pin des ESP32 gesendet.
Die Verdrahtung erfolgt wie folgt:
Der VCC-Pin des Bewegungssensors wird mit dem 3,3V-Pin des ESP32 verbunden (Achtung: Der Sensor läuft oft auch mit 5V, aber die 3,3V des ESP32 sind hier sicherer, da der Ausgangspin des Sensors manchmal auch nur 3,3V ausgibt und somit direkt mit dem GPIO Pin kompatibel ist).
Der GND-Pin des Bewegungssensors wird mit einem GND-Pin des ESP32 verbunden.
Der Daten-Pin (OUT) des Bewegungssensors wird mit dem digitalen Pin D15 (GPIO 15) des ESP32 verbunden, um das Signal auszulesen.

ESP32 VIN → HC-SR501 links

ESP32 D15 → HC-SR501 Mitte

ESP32 GND → HC-SR501 rechts

Die korrekte und sorgfältige Verdrahtung ist von entscheidender Bedeutung, um sicherzustellen, dass dein ESP32 die Signale des Bewegungssensors ordnungsgemäß erfassen kann.
Nachdem du diese Verbindungen erfolgreich hergestellt hast, bist du bereit, mit der Programmierung fortzufahren. Im nächsten Abschnitt werden wir detailliert darauf eingehen, wie du den Code für den Bewegungssensor und den ESP32 programmieren kannst.

Software Programmierung

Sobald der erfolgreiche Hardware-Aufbau abgeschlossen ist, können wir uns nun der Programmierung des ESP32 zuwenden. In diesem Abschnitt werden wir ausführlich die essentiellen Schritte zur Codeerstellung behandeln und die Schlüsselfunktionen, die du verwenden wirst, im Detail erläutern, um den Bewegungssensor auszulesen.

Schritt 1: IDE Projekt
Um mit der Arduino-IDE zu arbeiten, öffnest du zunächst die Anwendung auf deinem Computer. Falls du die Arduino-IDE noch nicht installiert hast, kannst du unter folgendem Link eine Anleitung hierzu finden: [Link zur Installationsanleitung einfügen].
Nachdem du die Arduino-IDE geöffnet hast, erstellst du ein neues Projekt, indem du auf „Datei“ und anschließend auf „Neu“ klickst. Dadurch wird ein neues Sketch-Fenster geöffnet, in dem du den Code für deinen ESP32 eingeben kannst.

// Hier kommt dein Code
void setup(){
  // Initialisierung
}

void loop(){
  // Schleife
}

Schritt 2: Bibliothek einbinden
Um die Daten des Bewegungssensors auszulesen, ist keine Bibliothek notwendig. Der HC-SR501 ist ein einfacher digitaler Sensor, der direkt einen HIGH- oder LOW-Pegel liefert. Das bedeutet, wir benötigen keine spezielle Bibliothek, um das Signal zu erfassen, da die Standard-Arduino-Befehle dafür vollkommen ausreichen. Nur so erhältst du die erforderlichen Funktionen, um die Bewegungsdaten zu erfassen und auszulesen.

Schritt 3: Initialisierung
Vor der setup()-Funktion werden in der Regel globale Variablen und Konstanten definiert. Dies ermöglicht es uns, Pins einmalig zu benennen und diese Namen im gesamten Code wiederzuverwenden, was den Sketch viel lesbarer macht. Hier legen wir fest, welcher GPIO-Pin des ESP32 für den Anschluss des Bewegungssensors verwendet wird. Außerdem deklarieren wir eine Integer-Variable, um den aktuellen Status des Sensors (Bewegung erkannt oder nicht) zu speichern.

#define triggerPin 15 //D15

int sensor_status;

Schritt 4: Void Setup
Die void setup()-Funktion wird einmal ausgeführt, wenn der ESP32 gestartet oder neu gestartet wird. Hier initialisieren wir die serielle Kommunikation (Serial.begin(9600)), damit wir später die erkannten Bewegungen am PC im seriellen Monitor ausgeben können. Der wichtigste Schritt ist jedoch die Definition der Pin-Funktion (pinMode), bei der wir den zuvor definierten Pin (D15) als INPUT festlegen, um das digitale Signal vom Bewegungssensor empfangen zu können.

void setup() { 
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  delay(500); // 500ms Pause zur Stabilität
  pinMode(triggerPin, INPUT); // Setzt den "triggerPin" als InputPin
}

Schritt 5: Loop Setup
Die void loop()-Funktion wird kontinuierlich und in einer Endlosschleife ausgeführt, nachdem setup() abgeschlossen ist.
Zuerst lesen wir mit digitalRead() den aktuellen Status des Bewegungssensors aus und speichern ihn in unserer Variablen sensor_status.
Anschließend stehen zwei Optionen zur auswahl:
Entweder kannst du später die Ausgabe im Seriellen Plotter darstellen. Hierfür musst du den auskommentierten Code wieder einkommentieren und die if-Abfrage dafür auskommentieren. Oder du lässt den Code so wie er ist, dann kannst du über den Seriellen Monitor darstellen, ob eine Bewegung erkannt wurde.

Option 1:
Bei der ersten Option wird der Zustand direkt ausgegeben. Hierdurch wird auf dem seriellen Plotter der Zustand über der Zeit dargestellt.

Option 2:
Hier prüft eine if-Abfrage, ob der Status HIGH (Bewegung erkannt) ist. Wenn ja, geben wir eine Nachricht über den seriellen Monitor aus und legen eine kurze Zwangspause ein, um eine Flut von Meldungen zu verhindern.

void loop() {
  sensor_status = digitalRead(triggerPin); // Sensor-Daten auslesen
  
  //Serial.println(sensor_status); //Ausgabe für den Seriellen Plotter
  //delay(100); //Ausgabe für den Seriellen Plotter
  
  if(sensor_status==HIGH){
    Serial.println("erkannt");
    delay(2000); // 2 Sekunde Pause um Ausgabe nach Erkennungs-Impuls zu begrenzen
    // Hinweis: Das Modul hat eine Sperrzeit von ca 3 Sekunden.
  }
}

Gesamter Code

Hier siehst du noch einmal zur Übersicht den gesamten Programmier-Code aufgezeigt, den du in deine Arduino-IDE kopieren kannst, um den Bewegungssensor (HC-SR501) mit deinem ESP32 in Betrieb zu nehmen.

#define triggerPin 15 //D15

int sensor_status;

void setup()
{
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  delay(500); // 500ms Pause zur Stabilität
  pinMode(triggerPin, INPUT); // Setzt den "triggerPin" als InputPin
}

void loop()
{
  sensor_status = digitalRead(triggerPin); // Sensor-Daten auslesen
  
  //Serial.println(sensor_status); //Ausgabe für den Seriellen Plotter
  //delay(100); //Ausgabe für den Seriellen Plotter
  
  if(sensor_status==HIGH){
    Serial.println("erkannt");
    delay(2000); // 2 Sekunde Pause um Ausgabe nach Erkennungs-Impuls zu begrenzen
    // Hinweis: Das Modul hat eine Sperrzeit von ca 3 Sekunden.
  }

}

Ausführung / Anwendung

Nachdem der Code nun in die IDE eingegeben ist, muss dieser noch kompiliert, hochgeladen und auf den ESP32 übertragen werden, um den Bewegungssensor in Betrieb zu nehmen.
Du gehst dabei wie folgt vor:
Schritt 1: Kompilieren
Klicke in der Arduino-IDE auf das Haken-Symbol (Überprüfen). Dieser Schritt prüft den Code auf Syntaxfehler.

Schritt 2: Hochladen
Klicke auf das Pfeil-Symbol (Hochladen). Dadurch wird der fehlerfreie Code auf deinen ESP32 übertragen.

Weitere Themen

Ultraschallsensor + ESP32

BME280 + ESP32

4 Ziffern Display + ESP32