Weihnachtsmann-Detektor mit Arduino: PIR-Sensor und Ho-Ho-Ho
Weihnachtsmann-Detektor mit Arduino bauen: PIR-Sensor erkennt nachts Bewegung, DFPlayer ruft Ho Ho Ho, LEDs blinken, Uhrzeit wird gespeichert. Mit ESP32-Code.
Ein Weihnachtsmann-Detektor ist ein kleines Arduino-Projekt, das nachts eine Bewegung neben dem Weihnachtsbaum bemerkt, über einen Lautsprecher "Ho Ho Ho" ruft, LEDs aufleuchten lässt und die genaue Uhrzeit speichert. Im Kern stecken ein PIR-Bewegungsmelder, ein DFPlayer-Mini-MP3-Modul und ein LDR, der erkennt, wann es dunkel ist. Am Morgen schaust du mit deinen Kindern ins Protokoll und verkündest: "Der Weihnachtsmann war um 02:14 Uhr da!" Ein lustiges und lehrreiches Weihnachtsprojekt, das an einem Wochenendnachmittag fertig ist.
In dieser Anleitung erfährst du, wie der Detektor funktioniert, was du brauchst, wie du ihn an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt, wie die Sounddateien auf der SD-Karte heißen müssen, wie du mit einem LDR einen Nachtmodus einrichtest, und du bekommst einen vollständigen Arduino-Sketch, der jede Erkennung mit Uhrzeit ins EEPROM schreibt. Danach baust du daraus eine ESP32-Version, die dir eine Telegram-Nachricht aufs Handy schickt, und zum Schluss eine Pico-Version in MicroPython.

Wie funktioniert ein Weihnachtsmann-Detektor?
Ein PIR-Sensor (passiver Infrarotsensor) sendet selbst kein Licht aus; er misst die Infrarotstrahlung, die Menschen und Tiere als Körperwärme abgeben. Hinter der Linse sitzt ein Detektor aus zwei Hälften. Bewegt sich ein warmer Körper durch das Sichtfeld, sieht erst die eine, dann die andere Hälfte mehr Wärme, und dieser Unterschied schaltet den Ausgang für einige Sekunden auf HIGH. Erkennt der Arduino diese steigende Flanke, prüft er mit dem LDR, ob es dunkel ist. Ist es Nacht, lässt er den DFPlayer einen Sound abspielen, die rote und grüne LED blinken und schreibt die Uhrzeit aus der Echtzeituhr (RTC) ins EEPROM.
| Schritt | Was passiert? | Zuständiges Bauteil |
|---|---|---|
| 1. Aufwärmen | Nach dem Einschalten 60 Sekunden warten, die grüne LED blinkt | PIR-Sensor |
| 2. Nachtprüfung | Der Detektor wird nur scharf, wenn es dunkel ist | LDR + 10-kΩ-Widerstand |
| 3. Erkennung | Der Ausgang wechselt von LOW auf HIGH | PIR-Sensor |
| 4. Sound | Einer von drei Sounds wird zufällig abgespielt | DFPlayer Mini + Lautsprecher |
| 5. Licht | Rote und grüne LED blinken etwa 4 Sekunden | 2 LEDs + 220 Ω |
| 6. Protokoll | Datum und Uhrzeit landen im EEPROM (letzte 10 Einträge) | RTC DS1307 + Arduino-EEPROM |
| 7. Pause | 30 Sekunden lang kein neuer Alarm | Code (COOLDOWN) |
Materialliste
- Arduino Uno oder Nano: Der Sketch läuft auf beiden mit denselben Pins. Für Handy-Benachrichtigungen nimmst du einen ESP32, wenn du MicroPython magst, einen Raspberry Pi Pico.
- PIR-Sensor HC-SR501: Das verbreitete 5-V-Modell mit Empfindlichkeits- und Zeitregler. Die Einstellungen erklärt der Beitrag PIR-Bewegungsmelder.
- DFPlayer Mini und ein Lautsprecher mit 8 Ω, 0,5–3 W: Spielt MP3-Dateien von der microSD-Karte über den eigenen Verstärker ab.
- microSD-Karte: Jede Karte unter 32 GB im Format FAT32; die Sounddateien belegen nur ein paar hundert KB.
- LDR und ein 10-kΩ-Widerstand: Spannungsteiler für den Nachtmodus.
- RTC-Modul DS1307: Speichert die echte Uhrzeit jeder Erkennung und vergisst sie dank Knopfzelle auch ausgeschaltet nicht.
- Rote und grüne LED, zwei 220-Ω- und ein 1-kΩ-Widerstand, Steckbrett und Jumperkabel.
- 5-V-Versorgung: USB-Netzteil oder Powerbank. Bei hoher Lautstärke zieht der Lautsprecher kurzzeitig 300–500 mA, deshalb ist ein Netzteil besser als der USB-Port des Computers.

Anschlusstabelle
| Verbindung | Arduino Uno / Nano | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| PIR VCC / GND | 5V / GND | VIN (5V) / GND | VBUS (5V) / GND |
| PIR OUT | D2 | GPIO 27 | GP16 |
| DFPlayer VCC / GND | 5V / GND | VIN (5V) / GND | VBUS (5V) / GND |
| DFPlayer RX (über 1 kΩ) | D11 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DFPlayer TX | D10 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DFPlayer SPK_1 / SPK_2 | Beide Lautsprecheradern | Beide Lautsprecheradern | Beide Lautsprecheradern |
| LDR: ein Bein | 5V | 3V3 | 3V3(OUT) |
| Anderes LDR-Bein + 10 kΩ (anderes Ende an GND) | A0 | GPIO 34 | GP26 (ADC0) |
| Rote LED (mit 220 Ω) | D6 | GPIO 25 | GP14 |
| Grüne LED (mit 220 Ω) | D9 | GPIO 26 | GP13 |
| DS1307 SDA / SCL | A4 / A5 | Nicht benutzt (NTP) | Nicht benutzt |
Sounddateien vorbereiten
- Formatiere die microSD-Karte am Computer als FAT32 und lege im Hauptverzeichnis einen Ordner namens mp3 an.
- Kopiere drei kurze Sounddateien als 0001.mp3, 0002.mp3 und 0003.mp3 hinein. Der Sketch ruft sie mit playMp3Folder(1), (2) und (3) auf; da die Nummer im Dateinamen zählt, ist die Kopierreihenfolge egal.
- Am lustigsten ist es, die Sounds selbst aufzunehmen: Sag mit tiefer Stimme ins Handy "Ho Ho Ho, sind hier brave Kinder?" und wandle die Aufnahme in MP3 um. Schlittenglocken, ein Türgong oder ein kurzes Lied gehen auch.
- Halte die Dateien zwischen 2 und 5 Sekunden; während ein langer Sound läuft, wird ohnehin keine neue Bewegung erkannt.
- Steck die Karte in den DFPlayer und starte im Code mit volume(22); nachts, wenn es im Haus still ist, reichen meist 15–20.
Nachtmodus: Dunkelheit mit dem LDR erkennen
Der Detektor soll nicht tagsüber bei jedem Vorbeigehen losgehen, deshalb wird er nur im Dunkeln scharf. Der Widerstand eines LDR sinkt mit zunehmendem Licht: in einem hellen Raum einige kΩ, im Dunkeln über 100 kΩ. Liegt der LDR zwischen 5V und A0 und der 10-kΩ-Widerstand zwischen A0 und GND, beträgt die Spannung an A0 V = 5 × 10 kΩ / (10 kΩ + R(LDR)). Im Dunkeln steigt der Widerstand des LDR, also sinken die Spannung und damit der Wert von analogRead(). Mit anderen Widerstandswerten kannst du den Teiler im Spannungsteiler-Rechner ausprobieren.
| Umgebung | LDR-Widerstand (ca.) | Spannung an A0 | Wert von analogRead() |
|---|---|---|---|
| Raum mit Tageslicht | 1 kΩ | 4,5 V | 930 |
| Raum mit eingeschaltetem Licht | 5–10 kΩ | 3,3–2,5 V | 680–510 |
| Gedämpftes Licht, Nachtlicht | 20–30 kΩ | 1,7–1,25 V | 340–255 |
| Raum mit ausgeschaltetem Licht | 100 kΩ und mehr | 0,45 V und weniger | 90 und weniger |
Die Werte DARK_ON = 300 und DARK_OFF = 400 im Code sind zwei getrennte Schwellen. Der Nachtmodus geht an, wenn der Wert unter 300 fällt, und erst über 400 wieder aus. Den Abstand dazwischen nennt man Hysterese; er verhindert, dass der Modus ständig umschaltet, während die Baumbeleuchtung blinkt oder Autoscheinwerfer durchs Fenster streifen. LDRs streuen stark, deshalb gibst du am besten in deinem eigenen Zimmer den A0-Wert im seriellen Monitor aus und stellst die Schwellen danach ein. Richte den LDR aufs Fenster oder an die Decke, nicht auf die Lichterkette.
Arduino-Uno-Code: Sound, Licht und Protokoll mit Uhrzeit
Installiere über den Bibliotheksverwalter die Bibliotheken DFRobotDFPlayerMini und RTClib; SoftwareSerial, Wire und EEPROM sind in der Arduino IDE enthalten. Beim ersten Hochladen stellt der Sketch die RTC auf die Kompilierzeit deines Computers und schreibt danach jede Erkennung mit Datum und Uhrzeit ins EEPROM. Öffne den seriellen Monitor mit 9600 Baud: l listet die letzten 10 Einträge von alt nach neu, c löscht sie und t ist ein Soundtest.
1#include <SoftwareSerial.h>
2#include <DFRobotDFPlayerMini.h>
3#include <Wire.h>
4#include <RTClib.h>
5#include <EEPROM.h>
6
7const byte PIR_PIN = 2; // PIR OUT / PIR OUT
8const byte RED_LED = 6; // kırmızı LED, 220 ohm / red LED, 220 ohm
9const byte GREEN_LED = 9; // yeşil LED, 220 ohm / green LED, 220 ohm
10const byte LDR_PIN = A0; // LDR + 10k bölücü / LDR + 10k divider
11
12const int DARK_ON = 300; // bunun altı gece / below this it is night
13const int DARK_OFF = 400; // bunun üstü gündüz (histerezis) / above this it is day (hysteresis)
14const unsigned long WARMUP = 60000UL; // PIR ısınma süresi / PIR warm-up time
15const unsigned long COOLDOWN = 30000UL; // iki algılama arası en az / minimum gap between alerts
16const byte TRACKS = 3; // /mp3/0001.mp3 ... 0003.mp3
17const byte LOG_SIZE = 10; // EEPROM'da saklanan kayıt / records kept in EEPROM
18
19SoftwareSerial dfSerial(10, 11); // RX = D10 (modül TX), TX = D11 (1k ile modül RX) / RX, TX
20DFRobotDFPlayerMini player;
21RTC_DS1307 rtc;
22
23bool nightMode = false;
24bool lastPir = false;
25unsigned long lastAlert = 0;
26
27// EEPROM düzeni: 0 = sıradaki yuva, 1 = kayıt sayısı, 2.. = 4 baytlık zaman damgaları
28// EEPROM layout: 0 = next slot, 1 = record count, 2.. = 4-byte timestamps
29void saveEvent(uint32_t t) {
30 byte slot = EEPROM.read(0);
31 byte count = EEPROM.read(1);
32 if (slot >= LOG_SIZE) slot = 0;
33 if (count > LOG_SIZE) count = 0;
34 EEPROM.put(2 + slot * 4, t);
35 EEPROM.write(0, (slot + 1) % LOG_SIZE);
36 if (count < LOG_SIZE) EEPROM.write(1, count + 1);
37}
38
39void printTime(uint32_t t) {
40 DateTime d(t);
41 char buf[20];
42 snprintf(buf, sizeof(buf), "%02d.%02d.%04d %02d:%02d:%02d",
43 d.day(), d.month(), d.year(), d.hour(), d.minute(), d.second());
44 Serial.println(buf);
45}
46
47void printLog() {
48 byte count = EEPROM.read(1);
49 if (count > LOG_SIZE) count = 0;
50 Serial.print(F("Kayit sayisi / records: "));
51 Serial.println(count);
52 byte start = (count < LOG_SIZE) ? 0 : EEPROM.read(0); // en eski kayıttan başla / start from the oldest
53 for (byte i = 0; i < count; i++) {
54 uint32_t t;
55 EEPROM.get(2 + ((start + i) % LOG_SIZE) * 4, t);
56 Serial.print(i + 1);
57 Serial.print(F(") "));
58 printTime(t);
59 }
60}
61
62void lightShow() {
63 for (byte i = 0; i < 12; i++) { // ~3,6 sn kırmızı-yeşil yanıp sönme / ~3.6 s red-green blink
64 digitalWrite(RED_LED, i % 2);
65 digitalWrite(GREEN_LED, !(i % 2));
66 delay(300);
67 }
68 for (int b = 255; b >= 0; b -= 5) { // yavaşça sön / fade out slowly
69 analogWrite(RED_LED, b);
70 analogWrite(GREEN_LED, b);
71 delay(20);
72 }
73}
74
75void setup() {
76 Serial.begin(9600);
77 pinMode(PIR_PIN, INPUT);
78 pinMode(RED_LED, OUTPUT);
79 pinMode(GREEN_LED, OUTPUT);
80 randomSeed(analogRead(A1)); // boş pin gürültüsü / noise from a floating pin
81
82 if (!rtc.begin()) Serial.println(F("RTC yok / RTC not found"));
83 if (!rtc.isrunning()) rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // saati ilk kez ayarla / set the clock once
84
85 dfSerial.begin(9600);
86 if (!player.begin(dfSerial)) Serial.println(F("DFPlayer yok, SD karti kontrol et / DFPlayer not found, check the SD card"));
87 player.volume(22); // 0-30 arası ses / volume 0-30
88
89 Serial.println(F("PIR isiniyor / PIR warming up..."));
90 while (millis() < WARMUP) { // ısınırken yeşil LED yanıp söner / green LED blinks while warming up
91 digitalWrite(GREEN_LED, (millis() / 500) % 2);
92 }
93 digitalWrite(GREEN_LED, LOW);
94 Serial.println(F("Hazir! l = kayitlar, c = sil, t = ses testi / Ready! l = log, c = clear, t = sound test"));
95}
96
97void loop() {
98 int light = analogRead(LDR_PIN);
99 if (!nightMode && light < DARK_ON) nightMode = true;
100 if (nightMode && light > DARK_OFF) nightMode = false;
101
102 bool pir = digitalRead(PIR_PIN);
103 if (pir && !lastPir && nightMode && millis() - lastAlert > COOLDOWN) {
104 lastAlert = millis();
105 uint32_t now = rtc.now().unixtime();
106 saveEvent(now);
107 Serial.print(F("Noel Baba goruldu! / Santa spotted! "));
108 printTime(now);
109 player.playMp3Folder(random(1, TRACKS + 1)); // rastgele ho ho ho / random ho ho ho
110 lightShow();
111 }
112 lastPir = pir;
113
114 if (Serial.available()) {
115 char c = Serial.read();
116 if (c == 'l') printLog();
117 if (c == 'c') { EEPROM.write(0, 0); EEPROM.write(1, 0); Serial.println(F("Silindi / cleared")); }
118 if (c == 't') player.playMp3Folder(1);
119 }
120}| Codeteil | Aufgabe |
|---|---|
| pir && !lastPir | Erfasst nur den Moment des Wechsels von LOW auf HIGH; selbst wenn der Sensor 5 Sekunden HIGH bleibt, gibt es nur einen Alarm |
| millis() - lastAlert > COOLDOWN | Lässt mindestens 30 Sekunden zwischen zwei Alarmen; wer vor dem Baum herumläuft, erzeugt nicht Dutzende Einträge |
| saveEvent() | Schreibt den Zeitstempel als 4-Byte-Zahl in einen Ringpuffer; der 11. Eintrag überschreibt den ältesten |
| rtc.adjust(DateTime(F(__DATE__), F(__TIME__))) | Lief die RTC noch nie, wird sie auf die Kompilierzeit gestellt; mit eingelegter Batterie läuft diese Zeile nicht erneut |
| playMp3Folder(random(1, TRACKS + 1)) | Wählt zufällig eine der Dateien 0001–0003 im Ordner mp3 |
| randomSeed(analogRead(A1)) | Nutzt das Rauschen am offenen Pin A1, damit die Soundreihenfolge bei jedem Start anders ist |
Jede EEPROM-Zelle verträgt etwa 100.000 Schreibvorgänge. Der Sketch schreibt pro Erkennung nur 6 Byte und wartet mindestens 30 Sekunden zwischen zwei Alarmen, sodass du in einer Weihnachtszeit nicht annähernd an diese Grenze kommst. Der Vorteil des EEPROM gegenüber dem RAM: Die nachts erfassten Momente bleiben erhalten, auch wenn du morgens den Stecker ziehst und das Board an den Computer hängst.
PIR-Einstellungen: Empfindlichkeit, Zeit und Auslösemodus
| Einstellung | Wo? | Empfehlung für dieses Projekt |
|---|---|---|
| Sx (Empfindlichkeit) | Orangefarbenes Potentiometer | Etwa Mitte: rund 3–4 m. Zu weit aufgedreht löst schon warme Luft über der Heizung aus. |
| Tx (Zeit) | Das andere Potentiometer | Kürzeste Zeit (ganz gegen den Uhrzeigersinn), etwa 3 Sekunden |
| Auslöse-Jumper | H / L in der Ecke der Platine | H (wiederholt): Der Ausgang bleibt HIGH, solange Bewegung anhält |
| Aufwärmen | Beim Einschalten | 60 Sekunden; in dieser Zeit nicht davor herumlaufen |
ESP32-Version: Telegram-Nachricht aufs Handy
Mit einem ESP32 geht der Detektor einen Schritt weiter: Sobald Bewegung erkannt wird, bekommst du auf dem Handy die Nachricht "Ho Ho Ho! Bewegung am Baum" mit Datum, Uhrzeit und der Nummer des Besuchs in dieser Nacht. Die Uhrzeit kommt per NTP aus dem Internet, ein RTC-Modul ist also überflüssig. Erstelle vor dem Hochladen in Telegram mit BotFather einen Bot und notiere seinen Token und deine Chat-ID; die Schritte stehen im Beitrag ESP32-Telegram-Bot. Installiere außerdem die Bibliotheken UniversalTelegramBot und ArduinoJson.
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <DFRobotDFPlayerMini.h>
5#include <time.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // BotFather token'ı / token from BotFather
10#define CHAT_ID "123456789" // bildirimin gideceği ID / the ID that receives alerts
11const long UTC_OFFSET = 3 * 3600; // Türkiye UTC+3; kendi saat dilimini yaz / set your own time zone
12
13const int PIR_PIN = 27; // PIR OUT
14const int RED_LED = 25; // kırmızı LED, 220 ohm / red LED, 220 ohm
15const int GREEN_LED = 26; // yeşil LED, 220 ohm / green LED, 220 ohm
16const int LDR_PIN = 34; // LDR + 10k bölücü (ADC1) / LDR + 10k divider (ADC1)
17const int DARK_ON = 1200; // 0-4095: bunun altı gece / below this it is night
18const int DARK_OFF = 1600; // histerezis / hysteresis
19const unsigned long COOLDOWN = 30000UL; // iki bildirim arası en az 30 sn / at least 30 s between alerts
20
21HardwareSerial dfSerial(2); // UART2: RX = GPIO 16, TX = GPIO 17
22DFRobotDFPlayerMini player;
23WiFiClientSecure client;
24UniversalTelegramBot bot(BOT_TOKEN, client);
25
26bool nightMode = false;
27bool lastPir = false;
28unsigned long lastAlert = 0;
29int visits = 0; // bu gece kaç kez geldi / visits tonight
30
31String timeText() {
32 struct tm t;
33 if (!getLocalTime(&t, 1000)) return "--:--";
34 char buf[20];
35 strftime(buf, sizeof(buf), "%d.%m.%Y %H:%M:%S", &t);
36 return String(buf);
37}
38
39void lightShow() {
40 for (int i = 0; i < 12; i++) { // kırmızı-yeşil yanıp sönme / red-green blink
41 digitalWrite(RED_LED, i % 2);
42 digitalWrite(GREEN_LED, !(i % 2));
43 delay(300);
44 }
45 digitalWrite(RED_LED, LOW);
46 digitalWrite(GREEN_LED, LOW);
47}
48
49void setup() {
50 Serial.begin(115200);
51 pinMode(PIR_PIN, INPUT);
52 pinMode(RED_LED, OUTPUT);
53 pinMode(GREEN_LED, OUTPUT);
54
55 dfSerial.begin(9600, SERIAL_8N1, 16, 17);
56 if (!player.begin(dfSerial)) Serial.println("DFPlayer yok / DFPlayer not found");
57 player.volume(22);
58
59 WiFi.mode(WIFI_STA);
60 WiFi.begin(WIFI_SSID, WIFI_PASS);
61 while (WiFi.status() != WL_CONNECTED) {
62 delay(500);
63 Serial.print(".");
64 }
65 Serial.println(WiFi.localIP());
66 configTime(UTC_OFFSET, 0, "pool.ntp.org"); // internetten saat / time from the internet
67 client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org sertifikası / certificate
68
69 delay(60000); // PIR ısınması / PIR warm-up
70 bot.sendMessage(CHAT_ID, "Noel Baba dedektörü hazır / Santa detector is ready");
71}
72
73void loop() {
74 int light = analogRead(LDR_PIN);
75 if (!nightMode && light < DARK_ON) { nightMode = true; visits = 0; }
76 if (nightMode && light > DARK_OFF) nightMode = false;
77
78 bool pir = digitalRead(PIR_PIN);
79 if (pir && !lastPir && nightMode && millis() - lastAlert > COOLDOWN) {
80 lastAlert = millis();
81 visits++;
82 player.playMp3Folder(random(1, 4)); // 0001-0003.mp3 arasından / one of 0001-0003.mp3
83 String msg = "Ho ho ho! Ağacın yanında hareket var / motion near the tree\n";
84 msg += timeText() + " (#" + String(visits) + ")";
85 if (WiFi.status() == WL_CONNECTED) bot.sendMessage(CHAT_ID, msg);
86 else WiFi.reconnect(); // bağlantı koptuysa yeniden dene / reconnect if dropped
87 lightShow();
88 }
89 lastPir = pir;
90}Der Analogwert des ESP32 reicht von 0 bis 4095, und der LDR hängt an 3,3 V, deshalb liegen die Schwellen bei 1200 und 1600; das entspricht ungefähr derselben Helligkeit wie 300 und 400 am Uno. Schließ den LDR immer an einen Pin der Gruppe ADC1 an (GPIO 32–39): ADC2-Pins lassen sich bei aktivem WLAN nicht lesen. Der DFPlayer hängt an der zweiten Hardware-Schnittstelle (UART2) des ESP32, Software-Serial ist also nicht nötig. Der Besuchszähler wird bei jedem Start des Nachtmodus zurückgesetzt, sodass die Nummer in den Morgennachrichten die Summe dieser Nacht zeigt. Und noch etwas: Der Bot-Token ist das Passwort deines Bots. Lösch Token und Chat-ID, bevor du den Code irgendwo teilst, und hast du ihn versehentlich veröffentlicht, hol dir mit /revoke bei BotFather einen neuen.
Raspberry Pi Pico und MicroPython
Auf dem Pico brauchst du für den DFPlayer keine Bibliothek: Das Modul arbeitet mit einfachen 10-Byte-Befehlspaketen, und die Funktion df_cmd() unten baut das Paket samt Prüfsumme selbst zusammen. 0x06 setzt die Lautstärke, 0x12 spielt eine nummerierte Datei aus dem Ordner mp3. Jede Erkennung wird als Zeile an die Datei noel_log.txt im Dateisystem des Pico angehängt; morgens öffnest du sie in Thonny und siehst die Liste.
1from machine import Pin, ADC, UART
2import time, random
3
4pir = Pin(16, Pin.IN) # PIR OUT
5red = Pin(14, Pin.OUT) # kırmızı LED, 220 ohm / red LED, 220 ohm
6green = Pin(13, Pin.OUT) # yeşil LED, 220 ohm / green LED, 220 ohm
7ldr = ADC(26) # LDR + 10k bölücü (ADC0) / LDR + 10k divider (ADC0)
8uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1)) # GP0 -> 1k -> DFPlayer RX
9
10DARK_ON = 20000 # 0-65535: bunun altı gece / below this it is night
11DARK_OFF = 26000 # histerezis / hysteresis
12COOLDOWN = 30000 # ms, iki algılama arası / between two alerts
13
14
15def df_cmd(cmd, param=0):
16 # DFPlayer paketi: 7E FF 06 CMD 00 P1 P2 CS1 CS2 EF / DFPlayer frame
17 data = [0xFF, 0x06, cmd, 0x00, param >> 8, param & 0xFF]
18 cs = (-sum(data)) & 0xFFFF
19 uart.write(bytes([0x7E] + data + [cs >> 8, cs & 0xFF, 0xEF]))
20 time.sleep_ms(30)
21
22
23def stamp():
24 t = time.localtime()
25 return "%02d.%02d.%04d %02d:%02d:%02d" % (t[2], t[1], t[0], t[3], t[4], t[5])
26
27
28def light_show():
29 for i in range(12): # kırmızı-yeşil yanıp sönme / red-green blink
30 red.value(i % 2)
31 green.value(1 - i % 2)
32 time.sleep_ms(300)
33 red.off()
34 green.off()
35
36
37time.sleep(2) # DFPlayer açılsın / let the DFPlayer boot
38df_cmd(0x06, 22) # ses seviyesi 22 / volume 22
39print("PIR isiniyor / PIR warming up...")
40time.sleep(60)
41
42night = False
43last_pir = 0
44last_alert = time.ticks_add(time.ticks_ms(), -COOLDOWN)
45
46while True:
47 light = ldr.read_u16()
48 if not night and light < DARK_ON:
49 night = True
50 elif night and light > DARK_OFF:
51 night = False
52
53 now = pir.value()
54 if now and not last_pir and night and time.ticks_diff(time.ticks_ms(), last_alert) > COOLDOWN:
55 last_alert = time.ticks_ms()
56 df_cmd(0x12, random.randint(1, 3)) # /mp3/0001-0003.mp3
57 with open("noel_log.txt", "a") as f: # Pico'daki dosyaya yaz / append to a file on the Pico
58 f.write(stamp() + "\n")
59 print("Noel Baba goruldu! / Santa spotted!", stamp())
60 light_show()
61 last_pir = now
62 time.sleep_ms(50)Der Pico hat keine batteriegepufferte Uhr. Startest du den Code aus Thonny, gleicht Thonny die Uhr des Boards mit deinem Computer ab, und die Zeiten im Protokoll stimmen. Betreibst du den Pico getrennt vom Computer an einem Netzteil, zählt die Uhr ab Anfang 2021; die Einträge sind trotzdem in der richtigen Reihenfolge und die Abstände stimmen, aber für die echte Uhrzeit brauchst du ein DS1307-Modul per I2C oder NTP mit einem Pico W.
Mit Kindern aufbauen und lustige Ideen
- Aufgaben verteilen: Die Kinder nehmen die Sounds auf und benennen die Dateien, die Kabel steckt ihr gemeinsam. Das Ho Ho Ho mit ihrer eigenen Stimme wird meist der Lieblingsteil des Projekts.
- Beweiskiste: Steck den Detektor in eine geschmückte Geschenkbox und schneide Löcher für die PIR-Linse und die LEDs in den Deckel. Oben drauf kommt ein kleines Schild "Weihnachtsmann-Radar".
- Morgenbericht: Lest beim Frühstück zusammen die Zeiten aus dem seriellen Monitor oder vom Handy und erfindet eine Geschichte wie "Der Weihnachtsmann kam um 02:14 Uhr und hat um 02:16 Uhr den Keks gegessen".
- Soundfolge: Spiel je nach Besuchsnummer einen anderen Sound: beim ersten Besuch Ho Ho Ho, beim zweiten Glocken, beim dritten eine Aufnahme "Ihr habt mich erwischt".
- Mehr Licht: Nimm statt zwei LEDs einen WS2812B-Streifen und lass bei einer Erkennung den ganzen Baum rot und grün leuchten; Anschluss und Strombedarf erklärt der Beitrag WS2812B NeoPixel.
- Ehrliche Wissenschaft: Ein PIR-Sensor sieht nur warme, bewegte Körper; er kann den Weihnachtsmann nicht von der Katze oder vom Papa unterscheiden, der nachts Wasser trinken geht. Darüber mit Kindern zu reden, ist eine schöne Gelegenheit zu erklären, wie Sensoren funktionieren.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Dauerhafter Alarm nach dem Einschalten | Die 60-sekündige Aufwärmzeit des PIR ist noch nicht vorbei | Der Code wartet bereits; geh in dieser Zeit aus dem Sichtfeld |
| Überhaupt kein Ton | TX und RX gerade verbunden, Karte nicht FAT32 oder Dateien nicht im Ordner mp3 | Modul-TX an D10, RX über 1 kΩ an D11; Karte als FAT32 formatieren, Dateien wie /mp3/0001.mp3 benennen |
| Board startet beim Abspielen neu | Der Lautsprecher zieht kurzzeitig zu viel Strom | Lautstärke auf 15–20 senken, 5-V-1-A-Netzteil nutzen, 100-µF-Kondensator an VCC und GND des DFPlayers |
| Löst auch tagsüber aus | Die LDR-Schwellen passen nicht zum Raum oder der LDR zeigt auf eine Lampe | A0-Wert im seriellen Monitor messen und DARK_ON und DARK_OFF anpassen |
| Falsche Uhrzeit im Protokoll | Die RTC hat keine Batterie oder die Zeit wurde nie gestellt | CR2032 einlegen und den Sketch neu hochladen; beim ESP32 UTC_OFFSET prüfen |
| Keine Telegram-Nachricht | Token oder Chat-ID falsch, im Bot nie auf Start getippt | Bot in Telegram öffnen, auf Start tippen und den Token ohne Leerzeichen neu kopieren |
Ein Weihnachtsmann-Detektor aus einem PIR-Sensor, einem kleinen MP3-Modul und ein paar LEDs macht den Weihnachtsmorgen für Kinder spannend und vermittelt Grundlagen wie Sensoren, Spannungsteiler, serielle Kommunikation und EEPROM an einem echten Projekt. In der BlueGrays-App findest du Schritt-für-Schritt-Schaltpläne und Code für ähnliche Projekte wie eine Türklingel mit Bewegungsmelder, eine automatische PIR-Beleuchtung und eine Bewegungsalarmanlage mit Telegram-Nachricht, mit denen du deinen Detektor weiter ausbauen kannst.
Häufige Fragen
Erkennt ein Weihnachtsmann-Detektor wirklich den Weihnachtsmann?
Der Detektor nutzt einen PIR-Sensor und erkennt jeden warmen Körper, der sich in seinem Sichtfeld bewegt. Wer auch immer nachts am Baum vorbeigeht, löst ihn also aus und wird mit Uhrzeit protokolliert. So bleibt der Zauber erhalten, und du kannst Kindern nebenbei erklären, wie der Sensor funktioniert.
Warum löst mein PIR-Sensor direkt nach dem Einschalten ständig aus?
Der HC-SR501 braucht nach dem Einschalten 30–60 Sekunden, um sich an die Infrarotstrahlung im Raum zu gewöhnen, und kann in dieser Zeit zufällig HIGH melden. Deshalb wartet der Code 60 Sekunden. Löst er danach immer noch ständig aus, verringere die Empfindlichkeit und stell den Sensor weiter weg von Wärmequellen.
Warum kommt aus meinem DFPlayer Mini kein Ton?
Die häufigsten Ursachen sind gerade verbundene TX- und RX-Leitungen, eine Karte, die nicht FAT32 ist, und falsch benannte Dateien. TX des Moduls gehört an D10 des Arduino, RX über einen 1-kΩ-Widerstand an D11, und die Dateien müssen im Ordner mp3 als 0001.mp3 usw. liegen. Eine Lautsprecherader an GND schaltet den Ton ebenfalls ab.
Brauche ich ein RTC-Modul, um die Uhrzeit zu speichern?
Der Arduino Uno hat keine eigene Uhr, für echtes Datum und Uhrzeit brauchst du deshalb ein batteriegepuffertes RTC-Modul wie den DS1307. Ohne RTC kannst du mit millis() nur die Zeit seit dem Einschalten messen. Beim ESP32 kommt die Uhrzeit per NTP aus dem Internet, eine RTC ist dort nicht nötig.
Erkennt der PIR-Sensor auch Katze oder Hund?
Ja, ein PIR-Sensor erkennt jedes Lebewesen mit Körperwärme und kann eine große Katze nicht von einem Menschen unterscheiden. Gegen Fehlalarme hilft es, den Sensor etwa 1,5 Meter hoch anzubringen, leicht nach unten zu neigen und die Empfindlichkeit zu senken. Für eine sichere Unterscheidung kommen mmWave-Radar oder Kameralösungen in Frage.
Läuft der Weihnachtsmann-Detektor mit Batterien?
Ja, aber bei hoher Lautstärke zieht der Lautsprecher kurzzeitig Hunderte mA, sodass Batterien schnell leer sind. Eine USB-Powerbank mit 10.000 mAh reicht locker für eine Nacht. Geringe Lautstärke und LEDs, die nur bei einer Erkennung leuchten, verlängern die Laufzeit.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Nachtlicht mit LDR
Ein kleines Nachtlicht, das von selbst angeht, wenn es dunkel wird, und am Morgen wieder ausgeht.

Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

Bewegungsmelder mit Bewegungssensor
Ein einfacher Wächter, der Bescheid gibt, wenn jemand den Raum betritt. Der Bewegungsmelder spürt die Wärme, die der menschliche Körper abgibt; der Arduino lässt die LED leuchten, solange sich etwas…

Türklingel und Licht mit Bewegungssensor
Kommt jemand an deine Tür, weißt du es, bevor er klingelt. Sobald der Bewegungsmelder jemanden bemerkt, leuchtet die LED und der Summer spielt einen Gong aus drei Tönen, von hoch nach tief; ist die…

Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor
Ein PIR-Bewegungssensor HC-SR501 erkennt, wenn jemand den Raum betritt, und schaltet automatisch eine LED ein. millis() misst, wie lange sie leuchtet: Jedes HIGH erneuert die Zeit der letzten Bewegung, frühestens 10 Sekunden nach dem letzten HIGH geht die LED aus. Der Code wartet zudem in jeder Schleife 50 ms mit delay(50), ist also nicht ganz blockierungsfrei. Ideal für Treppen, Flure, Bäder oder Schrankbeleuchtung.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

