Rilevatore di Babbo Natale Arduino: sensore PIR e suono ho ho ho
Costruisci un rilevatore di Babbo Natale con Arduino: un sensore PIR vede il movimento notturno, il DFPlayer dice ho ho ho, i LED lampeggiano e l'ora è salvata.
Un rilevatore di Babbo Natale è un piccolo progetto Arduino che si accorge quando qualcosa si muove vicino all'albero di notte, riproduce un "ho ho ho" da un altoparlante, accende dei LED e salva l'ora esatta. Il cuore del progetto sono un sensore di movimento PIR, un modulo MP3 DFPlayer Mini e una fotoresistenza (LDR) che capisce quando è buio. La mattina puoi guardare il registro con i tuoi figli e annunciare: "Babbo Natale è passato alle 02:14!". È un progetto natalizio divertente e istruttivo che finisci in un pomeriggio del fine settimana.
In questa guida trovi come funziona il rilevatore, l'elenco dei componenti, una tabella dei collegamenti per Arduino Uno, ESP32 e Raspberry Pi Pico, come chiamare i file audio sulla scheda SD, come creare una modalità notte con la LDR e uno sketch Arduino completo che salva l'ora di ogni rilevamento nella EEPROM. Poi trasformerai lo stesso progetto in una versione ESP32 che invia un avviso Telegram al telefono e, infine, scriverai la versione per Pico in MicroPython.

Come funziona un rilevatore di Babbo Natale?
Un sensore PIR (infrarosso passivo) non emette luce; misura la radiazione infrarossa che persone e animali emettono come calore corporeo. Dietro la lente c'è un rilevatore diviso in due metà. Quando un corpo caldo attraversa il campo visivo, prima una metà e poi l'altra riceve più calore, e questa differenza porta l'uscita del sensore a HIGH per qualche secondo. Quando Arduino coglie questo fronte di salita, controlla con la LDR se è buio; se è notte, chiede al DFPlayer di riprodurre un suono, fa lampeggiare i LED rosso e verde e scrive nella EEPROM l'ora letta dall'orologio in tempo reale (RTC).
| Fase | Cosa succede? | Componente responsabile |
|---|---|---|
| 1. Riscaldamento | All'accensione attende 60 secondi mentre il LED verde lampeggia | Sensore PIR |
| 2. Controllo notte | Il rilevatore si arma solo se la stanza è buia | LDR + resistenza da 10 kΩ |
| 3. Rilevamento | L'uscita passa da LOW a HIGH | Sensore PIR |
| 4. Suono | Parte a caso uno di tre suoni | DFPlayer Mini + altoparlante |
| 5. Luce | I LED rosso e verde lampeggiano per circa 4 secondi | 2 LED + 220 Ω |
| 6. Registro | Data e ora finiscono nella EEPROM (ultimi 10) | RTC DS1307 + EEPROM di Arduino |
| 7. Pausa | Nessun nuovo allarme per 30 secondi | Codice (COOLDOWN) |
Elenco dei componenti
- Arduino Uno o Nano: Lo sketch funziona su entrambi con gli stessi pin. Se vuoi gli avvisi sul telefono usa un ESP32, se ti piace MicroPython un Raspberry Pi Pico.
- Sensore PIR HC-SR501: Il diffuso modello a 5 V con regolazione di sensibilità e durata. Le regolazioni sono spiegate nella guida al sensore di movimento PIR.
- DFPlayer Mini e un altoparlante da 8 Ω e 0,5–3 W: Riproduce file MP3 da una microSD con il proprio amplificatore.
- Scheda microSD: Qualsiasi scheda sotto i 32 GB in FAT32; i suoni occupano solo qualche centinaio di KB.
- LDR e resistenza da 10 kΩ: Partitore di tensione per la modalità notte.
- Modulo RTC DS1307: Tiene l'ora reale di ogni rilevamento e, grazie alla batteria a bottone, non la dimentica anche a scheda spenta.
- LED rosso e verde, due resistenze da 220 Ω e una da 1 kΩ, breadboard e cavetti jumper.
- Alimentazione a 5 V: Un alimentatore USB o un power bank. A volume alto l'altoparlante può assorbire per un attimo 300–500 mA, quindi un alimentatore è meglio della porta USB del computer.

Tabella dei collegamenti
| Collegamento | 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 (tramite 1 kΩ) | D11 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DFPlayer TX | D10 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DFPlayer SPK_1 / SPK_2 | I due fili dell'altoparlante | I due fili dell'altoparlante | I due fili dell'altoparlante |
| LDR: un piedino | 5V | 3V3 | 3V3(OUT) |
| Altro piedino della LDR + 10 kΩ (altro capo a GND) | A0 | GPIO 34 | GP26 (ADC0) |
| LED rosso (con 220 Ω) | D6 | GPIO 25 | GP14 |
| LED verde (con 220 Ω) | D9 | GPIO 26 | GP13 |
| DS1307 SDA / SCL | A4 / A5 | Non usato (NTP) | Non usato |
Preparare i file audio
- Formatta la microSD in FAT32 sul computer e crea una cartella chiamata mp3 nella radice.
- Copia al suo interno tre suoni brevi chiamati 0001.mp3, 0002.mp3 e 0003.mp3. Lo sketch li richiama con playMp3Folder(1), (2) e (3); dato che conta il numero nel nome del file, l'ordine di copia non importa.
- La cosa più divertente è registrare i suoni da te: di' con voce profonda nel telefono "ho ho ho, ci sono bambini buoni qui?" e converti la registrazione in MP3. Vanno bene anche campanelli, un campanello di casa o una breve canzone.
- Tieni i file tra 2 e 5 secondi; mentre suona un file lungo, nessun nuovo movimento viene comunque rilevato.
- Inserisci la scheda nel DFPlayer e parti con volume(22) nel codice; di notte, con la casa silenziosa, 15–20 di solito basta.
Modalità notte: capire il buio con la LDR
Non vuoi che il rilevatore scatti a ogni passaggio durante il giorno, quindi si arma solo al buio. La resistenza di una LDR cala quando la luce aumenta: pochi kΩ in una stanza illuminata, oltre 100 kΩ al buio. Con la LDR tra 5V e A0 e la resistenza da 10 kΩ tra A0 e GND, la tensione su A0 è V = 5 × 10 kΩ / (10 kΩ + R(LDR)). Al buio la resistenza della LDR sale, quindi la tensione e il valore di analogRead() scendono. Puoi provare il partitore con altri valori nel calcolatore del partitore di tensione.
| Ambiente | Resistenza della LDR (circa) | Tensione su A0 | Valore di analogRead() |
|---|---|---|---|
| Stanza con luce del giorno | 1 kΩ | 4,5 V | 930 |
| Stanza con la luce accesa | 5–10 kΩ | 3,3–2,5 V | 680–510 |
| Penombra, luce notturna | 20–30 kΩ | 1,7–1,25 V | 340–255 |
| Stanza con la luce spenta | 100 kΩ e oltre | 0,45 V e meno | 90 e meno |
I valori DARK_ON = 300 e DARK_OFF = 400 del codice sono due soglie separate. La modalità notte si attiva quando il valore scende sotto 300, ma si disattiva solo sopra 400. Questo margine si chiama isteresi ed evita che la modalità cambi di continuo mentre le luci dell'albero lampeggiano o i fari di un'auto passano dalla finestra. Le LDR variano molto, quindi la cosa migliore è stampare il valore di A0 sul monitor seriale nella tua stanza e regolare le soglie di conseguenza. Punta la LDR verso la finestra o il soffitto, non verso le luci dell'albero.
Codice Arduino Uno: suono, luce e registro con orario
Installa le librerie DFRobotDFPlayerMini e RTClib dal Gestore librerie; SoftwareSerial, Wire ed EEPROM sono incluse nell'IDE di Arduino. Al primo caricamento lo sketch imposta l'RTC all'ora di compilazione del tuo computer, poi scrive ogni rilevamento con data e ora nella EEPROM. Apri il monitor seriale a 9600 baud: l elenca gli ultimi 10 eventi dal più vecchio al più recente, c li cancella e t è un test audio.
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 codice | Funzione |
|---|---|
| pir && !lastPir | Cattura solo l'istante del passaggio da LOW a HIGH; anche se il sensore resta HIGH per 5 secondi, l'allarme è uno solo |
| millis() - lastAlert > COOLDOWN | Lascia almeno 30 secondi tra due allarmi, così una persona che gira davanti all'albero non crea decine di voci |
| saveEvent() | Scrive il timestamp come numero da 4 byte in un buffer circolare; l'11° evento sovrascrive il più vecchio |
| rtc.adjust(DateTime(F(__DATE__), F(__TIME__))) | Se l'RTC non è mai partito, lo imposta all'ora di compilazione; con la batteria inserita questa riga non viene più eseguita |
| playMp3Folder(random(1, TRACKS + 1)) | Sceglie a caso uno dei file 0001–0003 nella cartella mp3 |
| randomSeed(analogRead(A1)) | Usa il rumore del pin A1 scollegato per avere un ordine dei suoni diverso a ogni avvio |
Ogni cella della EEPROM sopporta circa 100.000 scritture. Lo sketch scrive solo 6 byte per rilevamento e attende almeno 30 secondi tra due allarmi, quindi avvicinarsi a quel limite in un periodo natalizio è impossibile. Il vantaggio di tenere il registro nella EEPROM invece che nella RAM è che i momenti catturati di notte non si perdono anche se la mattina stacchi la scheda e la colleghi al computer.
Regolazioni del PIR: sensibilità, durata e modalità di attivazione
| Regolazione | Dove? | Consiglio per questo progetto |
|---|---|---|
| Sx (sensibilità) | Trimmer arancione | Verso il centro: circa 3–4 m. Se lo alzi troppo, perfino l'aria calda sopra un termosifone può farlo scattare. |
| Tx (durata) | L'altro trimmer | Al minimo (tutto in senso antiorario), circa 3 secondi |
| Ponticello di attivazione | H / L nell'angolo della scheda | H (ripetuto): l'uscita resta HIGH finché il movimento continua |
| Riscaldamento | All'accensione | 60 secondi; non passarci davanti in questo tempo |
Versione ESP32: avviso Telegram sul telefono
Con un ESP32 il rilevatore fa un passo in più: appena rileva un movimento, il telefono riceve il messaggio "Ho ho ho! Movimento vicino all'albero" con data, ora e numero della visita di quella notte. L'ora arriva da internet tramite NTP, quindi il modulo RTC non serve. Prima di caricare il codice crea un bot con BotFather su Telegram e annota il token e il tuo chat ID; i passaggi sono nella guida bot Telegram con ESP32. Installa anche le librerie UniversalTelegramBot e 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 lettura analogica dell'ESP32 va da 0 a 4095 e la LDR è alimentata a 3,3 V, per questo le soglie sono 1200 e 1600; corrispondono più o meno allo stesso livello di luce di 300 e 400 sull'Uno. Collega sempre la LDR a un pin del gruppo ADC1 (GPIO 32–39): i pin ADC2 non si possono leggere con il Wi-Fi attivo. Il DFPlayer usa la seconda seriale hardware dell'ESP32 (UART2), quindi la seriale software non serve. Il contatore delle visite si azzera a ogni attivazione della modalità notte, così il numero nei messaggi del mattino indica il totale di quella notte. Un'ultima cosa: il token è la password del tuo bot; cancellalo insieme al chat ID prima di condividere il codice e, se l'hai pubblicato per errore, generane uno nuovo con /revoke in BotFather.
Versione per Raspberry Pi Pico in MicroPython
Sul Pico non serve una libreria per il DFPlayer: il modulo funziona con semplici pacchetti di comando da 10 byte e la funzione df_cmd() qui sotto costruisce il pacchetto, checksum compreso, da sola. 0x06 imposta il volume e 0x12 riproduce un file numerato della cartella mp3. Ogni rilevamento viene aggiunto come riga al file noel_log.txt nel file system del Pico; la mattina lo apri in Thonny e vedi l'elenco.
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)Il Pico non ha un orologio con batteria tampone. Quando esegui il codice da Thonny, Thonny sincronizza l'orologio della scheda con quello del computer, quindi gli orari del registro sono corretti. Se stacchi il Pico dal computer e lo alimenti con un alimentatore, l'orologio parte dall'inizio del 2021; le voci restano in ordine e gli intervalli sono giusti, ma per l'ora reale devi aggiungere un modulo DS1307 via I2C o usare NTP con un Pico W.
Costruirlo con i bambini e idee divertenti
- Dividete i compiti: I bambini registrano i suoni e rinominano i file, mentre i cavi li collegate insieme. Sentire l'ho ho ho con la loro voce diventa spesso la parte preferita del progetto.
- Scatola delle prove: Metti il rilevatore in una scatola regalo decorata e fai dei fori nel coperchio per la lente del PIR e i LED. Aggiungi sopra una piccola etichetta "radar per Babbo Natale".
- Rapporto del mattino: A colazione leggete insieme gli orari sul monitor seriale o nei messaggi del telefono e inventate una storia come "Babbo Natale è arrivato alle 02:14 e ha mangiato il biscotto alle 02:16".
- Sequenza di suoni: Riproduci un suono diverso in base al numero della visita: ho ho ho alla prima, campanelli alla seconda, una registrazione "mi avete scoperto" alla terza.
- Più luce: Usa una striscia WS2812B al posto dei due LED e illumina tutto l'albero di rosso e verde a ogni rilevamento; collegamenti e calcolo dei consumi sono nella guida WS2812B NeoPixel.
- Scienza onesta: Un sensore PIR vede solo corpi caldi in movimento; non distingue Babbo Natale dal gatto o dal genitore che si alza a bere un bicchiere d'acqua. Parlarne con i bambini è un'ottima occasione per spiegare come funzionano i sensori.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Allarmi continui all'accensione | Il riscaldamento di 60 secondi del PIR non è finito | Il codice aspetta già; stai fuori dal campo del sensore in quel tempo |
| Nessun suono | TX e RX collegati dritti, scheda non in FAT32 o file fuori dalla cartella mp3 | TX del modulo su D10, RX su D11 tramite 1 kΩ; formatta in FAT32 e chiama i file /mp3/0001.mp3 |
| La scheda si riavvia quando suona | L'altoparlante assorbe per un attimo troppa corrente | Abbassa il volume a 15–20, usa un alimentatore da 5 V 1 A e metti un condensatore da 100 µF tra VCC e GND del DFPlayer |
| Scatta anche di giorno | Le soglie della LDR non vanno bene per la stanza o la LDR guarda una lampada | Misura il valore di A0 sul monitor seriale e regola DARK_ON e DARK_OFF |
| Ora sbagliata nel registro | L'RTC non ha la batteria o l'ora non è mai stata impostata | Inserisci una CR2032 e ricarica lo sketch; sull'ESP32 controlla UTC_OFFSET |
| Il messaggio Telegram non arriva | Token o chat ID sbagliati, oppure non hai mai premuto Avvia nel bot | Apri il bot su Telegram, premi Avvia e ricopia il token senza spazi |
Un rilevatore di Babbo Natale fatto con un sensore PIR, un piccolo modulo MP3 e qualche LED rende emozionante la mattina di Natale per i bambini e insegna, in un progetto reale, basi come sensori, partitori di tensione, comunicazione seriale ed EEPROM. Nell'app BlueGrays trovi schemi passo passo e codice di progetti simili, come un campanello con sensore di movimento, un'illuminazione automatica con PIR e un allarme di movimento con avvisi Telegram, per portare il tuo rilevatore al livello successivo.
Domande frequenti
Un rilevatore di Babbo Natale rileva davvero Babbo Natale?
Il rilevatore usa un sensore PIR e rileva qualsiasi corpo caldo che si muove nel suo campo visivo. Quindi chiunque passi vicino all'albero di notte lo fa scattare e viene registrato con l'orario. È un bel modo per mantenere la magia e spiegare ai bambini come funziona il sensore.
Perché il mio sensore PIR scatta di continuo appena acceso?
Dopo l'accensione l'HC-SR501 ha bisogno di 30–60 secondi per abituarsi al livello di infrarossi della stanza, e in questo tempo l'uscita può andare a HIGH a caso. Per questo il codice aspetta 60 secondi. Se dopo il riscaldamento scatta ancora di continuo, riduci la sensibilità e allontana il sensore dalle fonti di calore.
Perché il mio DFPlayer Mini non suona?
Le cause più comuni sono TX e RX collegati dritti, una scheda non in FAT32 e file con nomi sbagliati. Il TX del modulo va al D10 di Arduino e l'RX al D11 tramite una resistenza da 1 kΩ, e i file devono stare nella cartella mp3 con nomi come 0001.mp3. Collegare un filo dell'altoparlante a GND toglie anche il suono.
Serve un modulo RTC per salvare l'ora del movimento?
Arduino Uno non ha un orologio proprio, quindi per data e ora reali serve un modulo RTC con batteria come il DS1307. Senza, puoi misurare solo il tempo trascorso dall'accensione con millis(). Sull'ESP32 l'ora arriva da internet tramite NTP, quindi l'RTC non serve.
Il sensore PIR rileva anche il gatto o il cane?
Sì, un sensore PIR rileva qualsiasi essere vivente che emette calore e non distingue un gatto grande da una persona. Per ridurre i falsi allarmi montalo a circa 1,5 metri d'altezza, inclinalo un po' verso il basso e abbassa la sensibilità. Per una distinzione affidabile serve un radar mmWave o una soluzione con telecamera.
Il rilevatore di Babbo Natale può funzionare a batterie?
Sì, ma a volume alto l'altoparlante assorbe per un attimo centinaia di mA e le batterie si scaricano in fretta. Un power bank USB da 10.000 mAh basta tranquillamente per una notte. Tenere il volume basso e accendere i LED solo durante il rilevamento allunga l'autonomia.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Luce notturna con LDR
Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino.

Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Rilevatore di movimento con sensore di movimento
Un semplice guardiano che ti avvisa quando qualcuno entra nella stanza. Il sensore di movimento percepisce il calore emesso dal corpo umano, e l'Arduino tiene acceso il LED finché c'è movimento e lo…

Campanello e luce con sensore di movimento
Quando qualcuno si avvicina alla tua porta, lo sai prima ancora che suoni. Appena il sensore di movimento rileva qualcuno, il LED si accende e il buzzer suona un campanello di tre note, dalla più…

Illuminazione automatica con sensore di movimento PIR ESP32
Un sensore di movimento PIR HC-SR501 rileva chi entra nella stanza e accende un LED in automatico. millis() misura quanto resta acceso: ogni lettura HIGH aggiorna l'ora dell'ultimo movimento e il LED si spegne almeno 10 secondi dopo l'ultimo HIGH. Il codice attende anche 50 ms con delay(50) a ogni ciclo, quindi il loop non è del tutto non bloccante. Ideale per scale, corridoi, bagni o l'interno degli armadi.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

