PIR Bewegungsmelder Alarmanlage mit ESP32 – Komplettes Tutorial

Warum eine eigene Alarmanlage bauen?

Fertige Alarmanlagen sind teuer, oft herstellergebunden und alles andere als flexibel. Mit einem ESP32-Mikrocontroller und einem HC-SR501 PIR-Sensor baust du dir in unter einer Stunde eine Bewegungserkennung, die genau das tut, was du willst – und das für unter 15 Euro. Ob als Einsteigerprojekt mit blinkender LED oder als voll vernetzte Smart-Home-Lösung mit Telegram-Benachrichtigungen: Dieses Tutorial begleitet dich durch alle drei Schwierigkeitsstufen.

Der ESP32 ist dafür ideal: Er hat WiFi und Bluetooth an Bord, kostet nur wenige Euro und lässt sich mit der Arduino IDE programmieren. Der HC-SR501 ist der meistverwendete PIR-Sensor in der Maker-Szene – günstig, zuverlässig und mit einer effektiven Reichweite von bis zu 7 Metern.

So funktioniert ein PIR-Bewegungsmelder

Infrarot-Grundlagen

Jeder Körper mit einer Temperatur über dem absoluten Nullpunkt strahlt Infrarotlicht (Wärmestrahlung) ab – auch du. Menschen haben eine Oberflächentemperatur von etwa 30–35 °C und senden damit IR-Strahlung mit einer Wellenlänge um 8–14 µm aus. Genau darauf ist der HC-SR501 abgestimmt. Ein pyroelektrischer Sensor im Inneren des Moduls reagiert auf Änderungen dieser Infrarotstrahlung – nicht auf den absoluten Wert. Das bedeutet: Bewegt sich eine warme Person durchs Sichtfeld, registriert der Sensor den Temperaturwechsel und gibt einen Impuls aus.

Die Fresnel-Linse

Ohne Linse wäre der PIR-Sensor nahezu blind – er würde nur einen winzigen Punkt direkt vor dem Gehäuse erfassen. Die Fresnel-Linse (der weiße, geriffelte Plastikdom auf dem Modul) bündelt die IR-Strahlung aus verschiedenen Winkeln und projiziert sie auf den Sensor. Sie teilt das Sichtfeld in mehrere Zonen auf: abwechselnd „sichtbare" und „blinde" Bereiche. Bewegt sich eine Wärmequelle von einer Zone zur nächsten, entsteht genau der Impuls, den der pyroelektrische Chip detektiert. Je näher das Objekt, desto stärker der Signalwechsel – aber auch desto weniger Zonen durchläuft es. Aus größerer Entfernung wird der Effekt schwächer, daher die typische Reichweitenangabe von 5–7 Metern.

Das brauchst du für dieses Projekt

Alle Komponenten sind bei makeroo erhältlich:

• ESP32 DevKit mit USB-C
• HC-SR501 PIR Bewegungsmelder
• 1-Kanal Relais KY-019

Verkabelung – so schließt du alles an

Die Verkabelung ist in allen drei Stufen identisch, bis auf die zusätzlichen Komponenten in Stufe 2 und 3. Der HC-SR501 hat nur drei Pins: VCC, OUT und GND – das macht den Anschluss denkbar einfach.

Basis-Verkabelung (alle Stufen)

Stufe 1 – Zusätzlich: LED

Stufe 2 – Zusätzlich: Relais

Justierung des HC-SR501

Auf dem HC-SR501-Modul findest du zwei orangefarbene Potentiometer und einen Trigger-Mode-Jumper:

• Linkes Potentiometer (Sensitivität / Reichweite): Bestimmt, wie empfindlich der Sensor auf IR-Änderungen reagiert. Dreh gegen den Uhrzeigersinn = weniger Reichweite (ca. 3 m), im Uhrzeigersinn = maximale Reichweite (bis 7 m). Für Innenräume reicht oft die Mittelstellung.
• Rechtes Potentiometer (Verzögerungszeit): Legt fest, wie lange der OUT-Pin nach der letzten erkannten Bewegung auf HIGH bleibt. Einstellbereich ca. 2,5 Sekunden bis 5 Minuten. Für eine Alarmanlage sind 5–10 Sekunden sinnvoll – so wird jede Bewegung einzeln erfasst, ohne dass der Sensor „hängend" bleibt.
• Trigger-Jumper: In Position L (Single / Non-repeatable) löst der Sensor einmal aus und wartet die Verzögerungszeit ab, bevor er erneut auslösen kann. In Position H (Repeatable) erneuert jede weitere Bewegung die HIGH-Phase – ideal für Lichtsteuerungen, wo das Licht so lange an bleiben soll, wie sich jemand im Raum befindet. Für unsere Alarmanlage verwenden wir den L-Modus.

Stufe 1: Basis – LED blinkt bei Bewegung

Der einfachste Einstieg: Sobald der PIR-Sensor eine Bewegung erkennt, leuchtet eine LED auf. Sobald die Bewegung endet, erlischt sie nach der eingestellten Verzögerungszeit. Der Code liest einfach den Sensor-Pin digital ein und steuert die LED entsprechend.

/*
 * Stufe 1: PIR-Bewegungsmelder mit LED-Anzeige
 * makeroo.de – HC-SR501 + ESP32 Tutorial
 */

#define PIR_PIN  15    // HC-SR501 OUT an GPIO 15
#define LED_PIN  2     // LED mit 220Ω Vorwiderstand an GPIO 2

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  Serial.println("PIR-Alarmanlage Stufe 1 gestartet.");
  Serial.println("Warte 30 Sekunden auf Sensor-Kalibrierung...");
  delay(30000);  // HC-SR501 braucht ~30 s zum Stabilisieren
  Serial.println("Bereit! Bewegungen werden erkannt.");
}

void loop() {
  int motion = digitalRead(PIR_PIN);

  if (motion == HIGH) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println("⚠ Bewegung erkannt!");
  } else {
    digitalWrite(LED_PIN, LOW);
  }

  delay(100);  // kurze Pause gegen Flackern
}

Der delay(30000) in setup() ist wichtig: Der HC-SR501 kalibriert beim Einschalten seine interne Referenz. In dieser Zeit kann er Fehlsignale liefern – also einfach warten, bis er betriebsbereit ist.

Stufe 2: Mittel – Relais schaltet Lampe oder Sirene

Jetzt wird es praktisch: Ein 1-Kanal-Relais (KY-019) schaltet bei Bewegung eine externe Last – etwa eine Warnlampe, einen Piezo-Summer oder eine kleine Sirene. Das Relais ist für bis zu 10 A bei 250 V AC ausgelegt, aber für unsere Zwecke reicht eine 5- oder 12-Volt-Lampe als Testlast.

Das Relais an GPIO 4 zu betreiben ist bewusst gewählt: GPIO 4 ist beim ESP32 einer der Pins, die beim Booten nicht kurzzeitig HIGH werden – damit vermeiden wir ein ungewolltes Flackern der angeschlossenen Last beim Einschalten.

/*
 * Stufe 2: PIR-Bewegungsmelder mit Relais-Steuerung
 * makeroo.de – HC-SR501 + ESP32 + KY-019 Tutorial
 */

#define PIR_PIN     15    // HC-SR501 OUT an GPIO 15
#define RELAY_PIN   4     // KY-019 IN an GPIO 4
#define LED_PIN     2     // Eingebaute Status-LED (optional)

unsigned long lastTrigger = 0;
const unsigned long alarmDuration = 10000;  // Alarm für 10 s halten

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);  // Relais AUS
  digitalWrite(LED_PIN, LOW);

  Serial.println("PIR-Alarmanlage Stufe 2 – Relais-Modus");
  delay(30000);
  Serial.println("Scharf geschaltet!");
}

void loop() {
  int motion = digitalRead(PIR_PIN);

  if (motion == HIGH) {
    lastTrigger = millis();
    digitalWrite(RELAY_PIN, HIGH);
    digitalWrite(LED_PIN, HIGH);
    Serial.println("🚨 ALARM! Bewegung erkannt!");
  }

  // Alarm nach eingestellter Dauer automatisch deaktivieren
  if (millis() - lastTrigger > alarmDuration) {
    digitalWrite(RELAY_PIN, LOW);
    digitalWrite(LED_PIN, LOW);
  }

  delay(100);
}

Hier kommt eine Alarm-Haltezeit ins Spiel: Auch wenn der PIR-Sensor im L-Modus nur kurz HIGH liefert, hält das Relais für 10 Sekunden durch. Du kannst alarmDuration beliebig anpassen – für eine Sirene sind 10–30 Sekunden typisch, für eine automatische Beleuchtung eher 60–300 Sekunden.

Stufe 3: Fortgeschritten – ESP32 sendet Push-Nachricht per Telegram

Das ist die Königsdisziplin: Sobald der PIR-Sensor eine Bewegung erkennt, sendet der ESP32 über WLAN eine Push-Benachrichtigung an dein Smartphone – per Telegram Bot. Der Vorteil: Du wirst sofort informiert, egal ob du zuhause bist oder am anderen Ende der Welt. Eine SIM-Karte ist nicht nötig – nur WiFi.

Telegram Bot einrichten (5 Minuten)

1. Öffne Telegram und suche nach @BotFather
2. Sende /newbot und folge den Anweisungen (Name & Username vergeben)
3. Du erhältst einen Bot Token (z. B. 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11) – notiere ihn
4. Suche deinen neuen Bot in Telegram und sende /start
5. Rufe im Browser auf: https://api.telegram.org/bot[DEIN_TOKEN]/getUpdates
6. Notiere deine Chat ID aus der JSON-Antwort

/*
 * Stufe 3: PIR-Alarmanlage mit Telegram-Push-Benachrichtigung
 * makeroo.de – HC-SR501 + ESP32 WiFi Tutorial
 */

#include <WiFi.h>
#include <HTTPClient.h>

#define PIR_PIN     15
#define LED_PIN     2

// WLAN-Zugangsdaten
const char* ssid     = "DEIN_WLAN_NAME";
const char* password = "DEIN_WLAN_PASSWORT";

// Telegram Bot Einstellungen
const char* botToken = "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11";
const char* chatID   = "123456789";

unsigned long lastMotionTime = 0;
unsigned long lastMessageTime = 0;
const unsigned long cooldown = 30000;  // 30 s Sperre zwischen Nachrichten

bool motionActive = false;

void connectWiFi() {
  Serial.print("Verbinde mit WiFi");
  WiFi.begin(ssid, password);
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 40) {
    delay(500);
    Serial.print(".");
    attempts++;
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi verbunden! IP: " + WiFi.localIP().toString());
  } else {
    Serial.println("\nWiFi-Verbindung fehlgeschlagen!");
  }
}

void sendTelegram(String message) {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Kein WiFi – Nachricht verworfen.");
    return;
  }

  HTTPClient http;
  String url = "https://api.telegram.org/bot" + String(botToken)
             + "/sendMessage?chat_id=" + String(chatID)
             + "&text=" + message;
  http.begin(url);
  int httpCode = http.GET();

  if (httpCode > 0) {
    Serial.println("✅ Telegram gesendet – HTTP " + String(httpCode));
  } else {
    Serial.println("❌ Fehler: " + String(httpCode));
  }
  http.end();
}

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  connectWiFi();
  Serial.println("PIR-Alarmanlage Stufe 3 – Telegram-Modus");
  delay(30000);
  Serial.println("Scharf geschaltet!");
  sendTelegram("🚨 Alarmanlage scharf geschaltet!");
}

void loop() {
  int motion = digitalRead(PIR_PIN);
  unsigned long now = millis();

  if (motion == HIGH) {
    lastMotionTime = now;
    if (!motionActive) {
      motionActive = true;
      digitalWrite(LED_PIN, HIGH);
      Serial.println("⚠ Bewegung erkannt!");

      // Nur senden, wenn Cooldown abgelaufen ist
      if (now - lastMessageTime > cooldown) {
        sendTelegram("🚨 ALARM! Bewegung erkannt!\nZeit: " + String(now / 1000) + "s seit Start");
        lastMessageTime = now;
      }
    }
  }

  // Bewegung gilt als beendet nach 5 s ohne Trigger
  if (motionActive && (now - lastMotionTime > 5000)) {
    motionActive = false;
    digitalWrite(LED_PIN, LOW);
    Serial.println("Bewegung beendet.");
  }

  delay(100);
}

Die Cooldown-Sperre (cooldown = 30000) verhindert, dass dein Handy mit Nachrichten überflutet wird, wenn jemand längere Zeit vor dem Sensor steht. Pro 30 Sekunden wird maximal eine Nachricht gesendet – das ist für eine Alarmanlage völlig ausreichend und schont gleichzeitig die Telegram-API-Rate-Limits.

Praktische Anwendungen

Deine selbstgebaute PIR-ESP32-Kombination kann weit mehr als nur eine Alarmanlage. Hier sind vier spannende Anwendungen:

Noch smarter: ESP32-C3 für Akkuprojekte

Fehlersuche & Troubleshooting

Erweiterungen und nächste Schritte

Deine DIY-Alarmanlage ist erst der Anfang. Hier sind Ideen, wohin die Reise gehen kann:

• Mehrere Sensoren: Schließe 2–3 HC-SR501 an verschiedene GPIO-Pins an und überwache mehrere Räume gleichzeitig. Der ESP32 hat genug freie Pins.
• ESPHome / Home Assistant: Flashe den ESP32 mit ESPHome und binde ihn in Home Assistant ein – dann hast du eine vollwertige Smart-Home-Integration mit Web-UI und Automationen.
• SD-Karten-Logging: Zeichne alle Bewegungsereignisse mit Zeitstempel auf einer microSD-Karte auf – so hast du ein Bewegungsprotokoll über Wochen.
• OLED-Statusdisplay: Mit dem 0,96" OLED-Display zeigst du live an: Scharf/Unscharf, letzte Bewegung, Signalstärke, Uptime.
• BME280 Umweltdaten: Der BME280 Sensor liefert präzise Temperatur, Luftfeuchte und Luftdruck – zusammen mit dem PIR-Sensor hast du einen kompletten Raummonitor.
• Batteriebetrieb mit Deep-Sleep: ESP32 + HC-SR501 + 18650-Akku – der Sensor weckt den ESP32 nur bei Bewegung via Interrupt auf. So läuft das System wochenlang autark ohne Netzteil.