Detector de Santa Claus con Arduino: sensor PIR y sonido navideño
Haz un detector de Santa Claus con Arduino: un sensor PIR ve movimiento de noche, el DFPlayer dice jo jo jo, los LED parpadean y se guarda la hora. Con ESP32.
Un detector de Santa Claus es un pequeño proyecto con Arduino que nota cuando algo se mueve junto al árbol de Navidad por la noche, reproduce un "jo jo jo" por un altavoz, enciende unos LED y guarda la hora exacta. En su interior hay un sensor de movimiento PIR, un módulo MP3 DFPlayer Mini y una LDR que sabe cuándo está oscuro. Por la mañana puedes mirar el registro con tus hijos y anunciar: "¡Santa vino a las 02:14!". Es un proyecto navideño divertido y educativo que terminas en una tarde de fin de semana.
En esta guía verás cómo funciona el detector, la lista de materiales, una tabla de conexiones para Arduino Uno, ESP32 y Raspberry Pi Pico, cómo nombrar los archivos de sonido en la tarjeta SD, cómo montar un modo nocturno con una LDR y un sketch de Arduino completo que guarda la hora de cada detección en la EEPROM. Después convertirás el mismo proyecto en una versión con ESP32 que envía un aviso de Telegram a tu móvil y, por último, escribirás la versión para Pico en MicroPython.

¿Cómo funciona un detector de Santa Claus?
Un sensor PIR (infrarrojo pasivo) no emite luz; mide la radiación infrarroja que personas y animales desprenden como calor corporal. Detrás de la lente hay un detector dividido en dos mitades. Cuando un cuerpo cálido se mueve por el campo de visión, primero una mitad y luego la otra recibe más calor, y esa diferencia pone la salida del sensor en HIGH durante unos segundos. Cuando el Arduino detecta este flanco de subida, comprueba con la LDR si está oscuro; si es de noche, pide al DFPlayer que reproduzca un sonido, hace parpadear los LED rojo y verde y escribe en la EEPROM la hora leída del reloj en tiempo real (RTC).
| Etapa | ¿Qué pasa? | Pieza responsable |
|---|---|---|
| 1. Calentamiento | Espera 60 segundos al arrancar mientras parpadea el LED verde | Sensor PIR |
| 2. Control nocturno | El detector se arma solo si la habitación está oscura | LDR + resistencia de 10 kΩ |
| 3. Detección | La salida pasa de LOW a HIGH | Sensor PIR |
| 4. Sonido | Suena uno de tres sonidos al azar | DFPlayer Mini + altavoz |
| 5. Luz | Los LED rojo y verde parpadean unos 4 segundos | 2 LED + 220 Ω |
| 6. Registro | Fecha y hora se guardan en la EEPROM (últimas 10) | RTC DS1307 + EEPROM del Arduino |
| 7. Pausa | No hay nueva alarma durante 30 segundos | Código (COOLDOWN) |
Lista de materiales
- Arduino Uno o Nano: El sketch funciona en ambos con los mismos pines. Si quieres avisos en el móvil usa un ESP32, y si te gusta MicroPython, una Raspberry Pi Pico.
- Sensor PIR HC-SR501: El modelo común de 5 V con ajuste de sensibilidad y de tiempo. Sus ajustes se explican en la guía del sensor de movimiento PIR.
- DFPlayer Mini y un altavoz de 8 Ω y 0,5–3 W: Reproduce archivos MP3 de una microSD con su propio amplificador.
- Tarjeta microSD: Cualquiera de menos de 32 GB en FAT32; los sonidos ocupan solo unos cientos de KB.
- LDR y una resistencia de 10 kΩ: Divisor de tensión para el modo nocturno.
- Módulo RTC DS1307: Guarda la hora real de cada detección y, gracias a su pila de botón, no la olvida aunque la placa esté apagada.
- LED rojo y verde, dos resistencias de 220 Ω y una de 1 kΩ, protoboard y cables jumper.
- Alimentación de 5 V: Un cargador USB o una batería externa. A volumen alto el altavoz puede pedir 300–500 mA por momentos, así que un cargador es mejor que el USB del ordenador.

Tabla de conexiones
| Conexión | 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 (a través de 1 kΩ) | D11 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DFPlayer TX | D10 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DFPlayer SPK_1 / SPK_2 | Los dos cables del altavoz | Los dos cables del altavoz | Los dos cables del altavoz |
| LDR: una pata | 5V | 3V3 | 3V3(OUT) |
| Otra pata de la LDR + 10 kΩ (el otro extremo a GND) | A0 | GPIO 34 | GP26 (ADC0) |
| LED rojo (con 220 Ω) | D6 | GPIO 25 | GP14 |
| LED verde (con 220 Ω) | D9 | GPIO 26 | GP13 |
| DS1307 SDA / SCL | A4 / A5 | No se usa (NTP) | No se usa |
Preparar los archivos de sonido
- Formatea la microSD en el ordenador como FAT32 y crea una carpeta llamada mp3 en la raíz.
- Copia en ella tres sonidos cortos como 0001.mp3, 0002.mp3 y 0003.mp3. El sketch los llama con playMp3Folder(1), (2) y (3); como cuenta el número del nombre, el orden de copia da igual.
- Lo más divertido es grabar los sonidos tú mismo: di con voz grave en el móvil "jo jo jo, ¿hay niños buenos por aquí?" y convierte la grabación a MP3. También sirven cascabeles, un timbre o una canción corta.
- Que los archivos duren entre 2 y 5 segundos; mientras suena un sonido largo no se detecta movimiento nuevo de todos modos.
- Mete la tarjeta en el DFPlayer y empieza con volume(22) en el código; de noche, con la casa en silencio, 15–20 suele bastar.
Modo nocturno: detectar la oscuridad con una LDR
No quieres que el detector salte cada vez que alguien pasa de día, así que solo se arma a oscuras. La resistencia de una LDR baja al aumentar la luz: unos pocos kΩ en una habitación iluminada y más de 100 kΩ a oscuras. Con la LDR entre 5V y A0 y la resistencia de 10 kΩ entre A0 y GND, la tensión en A0 es V = 5 × 10 kΩ / (10 kΩ + R(LDR)). A oscuras la resistencia de la LDR sube, así que la tensión, y con ella el valor de analogRead(), baja. Puedes probar el divisor con otros valores en la calculadora de divisor de tensión.
| Ambiente | Resistencia de la LDR (aprox.) | Tensión en A0 | Valor de analogRead() |
|---|---|---|---|
| Habitación con luz de día | 1 kΩ | 4,5 V | 930 |
| Habitación con la luz encendida | 5–10 kΩ | 3,3–2,5 V | 680–510 |
| Penumbra, luz quitamiedos | 20–30 kΩ | 1,7–1,25 V | 340–255 |
| Habitación con la luz apagada | 100 kΩ o más | 0,45 V o menos | 90 o menos |
Los valores DARK_ON = 300 y DARK_OFF = 400 del código son dos umbrales distintos. El modo nocturno se activa cuando el valor baja de 300, pero solo se desactiva por encima de 400. Ese margen se llama histéresis y evita que el modo cambie una y otra vez mientras parpadean las luces del árbol o pasan los faros de un coche por la ventana. Las LDR varían mucho, así que lo mejor es imprimir el valor de A0 en el Monitor Serie en tu propia habitación y ajustar los umbrales con él. Orienta la LDR hacia la ventana o el techo, no hacia las luces del árbol.
Código para Arduino Uno: sonido, luz y registro con hora
Instala las librerías DFRobotDFPlayerMini y RTClib desde el Gestor de Librerías; SoftwareSerial, Wire y EEPROM vienen con el IDE de Arduino. En la primera carga, el sketch pone el RTC a la hora de compilación de tu ordenador y después guarda cada detección con fecha y hora en la EEPROM. Abre el Monitor Serie a 9600 baudios: l muestra las 10 últimas entradas de la más antigua a la más reciente, c las borra y t es una prueba de sonido.
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}| Parte del código | Función |
|---|---|
| pir && !lastPir | Capta solo el instante del cambio de LOW a HIGH; aunque el sensor siga en HIGH 5 segundos, solo hay una alarma |
| millis() - lastAlert > COOLDOWN | Deja al menos 30 segundos entre alarmas, así una persona dando vueltas ante el árbol no genera decenas de entradas |
| saveEvent() | Escribe la marca de tiempo como número de 4 bytes en un búfer circular; la entrada 11 sobrescribe la más antigua |
| rtc.adjust(DateTime(F(__DATE__), F(__TIME__))) | Si el RTC nunca ha funcionado, lo pone a la hora de compilación; con la pila puesta, esta línea no vuelve a ejecutarse |
| playMp3Folder(random(1, TRACKS + 1)) | Elige al azar uno de los archivos 0001–0003 de la carpeta mp3 |
| randomSeed(analogRead(A1)) | Usa el ruido del pin A1 al aire para obtener un orden de sonidos distinto en cada arranque |
Cada celda de la EEPROM aguanta unas 100.000 escrituras. El sketch escribe solo 6 bytes por detección y espera al menos 30 segundos entre alarmas, así que acercarse a ese límite en una temporada navideña es imposible. La ventaja de guardar el registro en la EEPROM y no en la RAM es que los momentos captados de noche no se pierden aunque por la mañana desenchufes la placa y la conectes al ordenador.
Ajustes del PIR: sensibilidad, tiempo y modo de disparo
| Ajuste | ¿Dónde? | Recomendación para este proyecto |
|---|---|---|
| Sx (sensibilidad) | Potenciómetro naranja | Cerca del centro: unos 3–4 m. Si lo subes demasiado, hasta el aire caliente de un radiador puede dispararlo. |
| Tx (tiempo) | El otro potenciómetro | Mínimo (todo en sentido antihorario), unos 3 segundos |
| Puente de disparo | H / L en la esquina de la placa | H (repetitivo): la salida sigue en HIGH mientras haya movimiento |
| Calentamiento | Al encender | 60 segundos; no pases por delante durante ese tiempo |
Versión con ESP32: aviso de Telegram en el móvil
Con un ESP32 el detector va un paso más allá: en cuanto detecta movimiento, tu móvil recibe el mensaje "¡Jo jo jo! Hay movimiento junto al árbol" con la fecha, la hora y el número de visita de esa noche. La hora llega de internet por NTP, así que no hace falta un módulo RTC. Antes de cargar el código, crea un bot con BotFather en Telegram y apunta su token y tu chat ID; los pasos están en la guía bot de Telegram con ESP32. Instala también las librerías UniversalTelegramBot y 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}La lectura analógica del ESP32 va de 0 a 4095 y la LDR se alimenta a 3,3 V, por eso los umbrales son 1200 y 1600; equivalen más o menos al mismo nivel de luz que 300 y 400 en el Uno. Conecta siempre la LDR a un pin del grupo ADC1 (GPIO 32–39): los pines ADC2 no se pueden leer con el Wi-Fi activo. El DFPlayer va al segundo puerto serie por hardware del ESP32 (UART2), así que no hace falta serie por software. El contador de visitas se reinicia cada vez que se activa el modo nocturno, de modo que el número de los mensajes de la mañana muestra el total de esa noche. Un último detalle: el token es la contraseña de tu bot; bórralo junto con el chat ID antes de compartir el código y, si lo publicaste por error, pide uno nuevo con /revoke en BotFather.
Versión para Raspberry Pi Pico con MicroPython
En la Pico no necesitas librería para el DFPlayer: el módulo funciona con tramas de comando sencillas de 10 bytes, y la función df_cmd() de abajo arma la trama, suma de control incluida, por sí sola. 0x06 fija el volumen y 0x12 reproduce un archivo numerado de la carpeta mp3. Cada detección se añade como una línea al archivo noel_log.txt del sistema de archivos de la Pico; por la mañana lo abres en Thonny y ves la lista.
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)La Pico no tiene un reloj con pila. Cuando ejecutas el código desde Thonny, Thonny sincroniza el reloj de la placa con el de tu ordenador, así que las horas del registro son correctas. Si desconectas la Pico del ordenador y la alimentas con un cargador, el reloj empieza a contar desde principios de 2021; las entradas siguen en orden y los intervalos son correctos, pero si quieres la hora real tendrás que añadir un módulo DS1307 por I2C o usar NTP con una Pico W.
Montarlo con niños e ideas divertidas
- Reparte las tareas: Que los niños graben los sonidos y nombren los archivos mientras conectáis los cables juntos. Oír el jo jo jo con su propia voz suele ser la parte favorita del proyecto.
- Caja de pruebas: Mete el detector en una caja de regalo decorada y haz agujeros en la tapa para la lente del PIR y los LED. Añade encima una pequeña etiqueta de "radar de Santa".
- Informe matutino: En el desayuno leed juntos las horas en el Monitor Serie o en los mensajes del móvil y montad una historia del tipo "Santa llegó a las 02:14 y se comió la galleta a las 02:16".
- Secuencia de sonidos: Reproduce un sonido distinto según el número de visita: jo jo jo en la primera, campanas en la segunda y una grabación de "me habéis pillado" en la tercera.
- Más luz: Usa una tira WS2812B en lugar de dos LED y enciende todo el árbol en rojo y verde al detectar; la conexión y el cálculo de consumo están en la guía WS2812B NeoPixel.
- Ciencia honesta: Un sensor PIR solo ve cuerpos cálidos en movimiento; no distingue a Santa del gato ni del padre que se levanta a beber agua. Hablarlo con los niños es una gran oportunidad para explicar cómo funcionan los sensores.
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| Alarmas continuas al encender | Aún no han pasado los 60 segundos de calentamiento del PIR | El código ya espera; apártate del sensor durante ese tiempo |
| No suena nada | TX y RX conectados en recto, la tarjeta no es FAT32 o los archivos no están en la carpeta mp3 | TX del módulo a D10, RX a D11 a través de 1 kΩ; formatea en FAT32 y nombra los archivos como /mp3/0001.mp3 |
| La placa se reinicia al sonar | El altavoz pide demasiada corriente por momentos | Baja el volumen a 15–20, usa un cargador de 5 V 1 A y pon un condensador de 100 µF entre VCC y GND del DFPlayer |
| También salta de día | Los umbrales de la LDR no encajan con tu habitación o la LDR mira a una lámpara | Mide el valor de A0 en el Monitor Serie y ajusta DARK_ON y DARK_OFF |
| Hora incorrecta en el registro | El RTC no tiene pila o nunca se ajustó la hora | Pon una pila CR2032 y vuelve a cargar el sketch; en el ESP32 revisa UTC_OFFSET |
| No llega el mensaje de Telegram | Token o chat ID erróneos, o nunca se pulsó Iniciar en el bot | Abre el bot en Telegram, pulsa Iniciar y copia de nuevo el token sin espacios |
Un detector de Santa Claus hecho con un sensor PIR, un pequeño módulo MP3 y unos LED hace emocionante la mañana de Navidad para los niños y enseña en un proyecto real temas básicos como sensores, divisores de tensión, comunicación serie y EEPROM. En la app BlueGrays encontrarás esquemas paso a paso y código de proyectos parecidos, como un timbre con sensor de movimiento, una iluminación automática con PIR y una alarma de movimiento con avisos de Telegram, para llevar tu detector al siguiente nivel.
Preguntas frecuentes
¿Un detector de Santa Claus detecta de verdad a Santa?
El detector usa un sensor PIR y detecta cualquier cuerpo cálido que se mueva en su campo de visión. Así que quien pase junto al árbol de noche lo dispara y queda registrado con su hora. Es una forma bonita de mantener la magia y, de paso, explicar a los niños cómo funciona el sensor.
¿Por qué mi sensor PIR se dispara sin parar nada más encenderlo?
El HC-SR501 necesita 30–60 segundos tras el encendido para adaptarse al nivel infrarrojo de la habitación, y en ese tiempo su salida puede ponerse en HIGH al azar. Por eso el código espera 60 segundos. Si después sigue disparándose sin parar, baja la sensibilidad y aleja el sensor de fuentes de calor.
¿Por qué no suena mi DFPlayer Mini?
Las causas más comunes son TX y RX conectados en recto, una tarjeta que no está en FAT32 y archivos mal nombrados. El TX del módulo va al D10 del Arduino y el RX al D11 a través de una resistencia de 1 kΩ, y los archivos deben estar en la carpeta mp3 como 0001.mp3. Conectar un cable del altavoz a GND también corta el sonido.
¿Necesito un módulo RTC para guardar la hora del movimiento?
El Arduino Uno no tiene reloj propio, así que para la fecha y la hora reales necesitas un módulo RTC con pila como el DS1307. Sin él solo puedes medir el tiempo desde el encendido con millis(). En el ESP32 la hora llega de internet por NTP, así que no hace falta RTC.
¿El sensor PIR detecta también al gato o al perro?
Sí, un sensor PIR detecta cualquier ser vivo con calor corporal y no distingue un gato grande de una persona. Para reducir falsas alarmas, colócalo a unos 1,5 metros de altura, inclínalo un poco hacia abajo y baja su sensibilidad. Si necesitas distinguirlos con fiabilidad, el siguiente paso es un radar mmWave o una solución con cámara.
¿Puede funcionar el detector de Santa Claus con pilas?
Puede, pero a volumen alto el altavoz pide cientos de mA por momentos y las pilas se agotan rápido. Una batería externa USB de 10.000 mAh aguanta de sobra una noche. Mantener el volumen bajo y encender los LED solo al detectar alarga la autonomía.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Luz nocturna con LDR
Una pequeña lamparita que se enciende sola cuando oscurece y se apaga cuando llega la mañana.

Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Detector de movimiento con sensor de movimiento
Un vigilante sencillo que te avisa cuando alguien entra en la habitación. El sensor de movimiento capta el calor que desprende el cuerpo humano, y el Arduino mantiene el LED encendido mientras hay…

Timbre y luz con sensor de movimiento
Cuando alguien se acerca a tu puerta, te enteras antes de que llame. En cuanto el sensor de movimiento detecta a alguien, se enciende el LED y el zumbador toca un timbre de tres notas de agudo a…

Iluminación automática con el sensor de movimiento PIR del ESP32
Un sensor de movimiento PIR HC-SR501 detecta a quien entra en la habitación y enciende un LED automáticamente. millis() controla cuánto sigue encendido: cada lectura HIGH renueva la hora del último movimiento y el LED se apaga al menos 10 segundos después del último HIGH. El código además espera 50 ms con delay(50) en cada ciclo, así que el bucle no es del todo no bloqueante. Ideal para escaleras, pasillos, baños o armarios.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

