Sensore PIR HC-SR505: mini PIR con Arduino, ESP32, Pico e AM312
Sensore PIR HC-SR505: differenze con HC-SR501 e AM312, tempo fisso di 8 s, uso a 3,3 V, calcolo dell'autonomia e codice per Arduino, ESP32 deep sleep e Pico.
Il sensore PIR HC-SR505 è un mini sensore di movimento PIR (infrarosso passivo) di circa 1 cm di diametro e 2,5 cm di altezza, senza trimmer né jumper di regolazione. Fa lo stesso lavoro del classico HC-SR501, cioè rileva una persona o un animale che si muove nel suo campo visivo e porta l'uscita a HIGH, ma in un corpo molto più piccolo. È ideale per campanelli, luci dentro gli armadi, piccoli contenitori d'allarme e sensori a batteria. L'AM312, delle stesse dimensioni, funziona già da 2,7 V ed è spesso la scelta migliore per ESP32, Raspberry Pi Pico e progetti a batteria.
In questo articolo vedrai come funziona l'HC-SR505, in cosa differisce dall'HC-SR501 e dall'AM312 in una tabella di confronto, come convivere con il suo tempo fisso di 8 secondi, i limiti dell'uso a 3,3 V e un vero calcolo dell'autonomia. Poi scriveremo uno sketch Arduino che conta i movimenti e misura il tempo di uscita, un codice che risveglia un ESP32 dal deep sleep con il movimento e aspetta dormendo che il movimento finisca, e un codice MicroPython con interrupt per il Raspberry Pi Pico.

Che cos'è l'HC-SR505 e come funziona?
Nel cuore di ogni sensore PIR c'è un elemento piroelettrico diviso in due metà. Quando la scena è ferma, le due metà ricevono la stessa radiazione infrarossa e i loro segnali si annullano. Quando qualcuno che emette calore corporeo attraversa il campo visivo, prima una metà e poi l'altra ricevono più radiazione, e il sensore interpreta questa differenza come movimento. La piccola lente di Fresnel davanti divide il campo visivo in zone e amplifica la differenza. Nell'HC-SR505, il circuito che elabora il segnale, il regolatore e la lente stanno su una minuscola scheda, e tempo di uscita e sensibilità sono fissati in fabbrica. Quando rileva un movimento, l'uscita resta HIGH per circa 8 secondi, e se in quel tempo c'è un nuovo movimento il conteggio riparte (riattivabile).
| Caratteristica | HC-SR505 |
|---|---|
| Tensione di alimentazione | 4,5–20 V (regolatore da 3,3 V sulla scheda) |
| Corrente a riposo | Meno di 60 µA |
| Uscita | Digitale: 3,3 V con movimento, 0 V senza |
| Portata di rilevamento | Fino a 3 metri |
| Angolo di rilevamento | Un cono inferiore a 100° |
| Tempo di uscita | Circa 8 secondi (±30 %), non regolabile |
| Modalità di attivazione | Riattivabile: l'uscita resta HIGH finché il movimento continua |
| Dimensioni | Circa 10 mm di diametro, 23–25 mm di altezza |
| Temperatura di esercizio | Da −20 a +80 °C |
HC-SR501, HC-SR505 e AM312 a confronto
| Caratteristica | HC-SR501 | HC-SR505 | AM312 |
|---|---|---|---|
| Dimensioni | Scheda 32 × 24 mm, cupola grande | Circa 10 mm di diametro | Circa 10 mm, simile all'HC-SR505 |
| Alimentazione | 4,5–20 V | 4,5–20 V | 2,7–12 V |
| Corrente a riposo | Circa 50 µA | Meno di 60 µA | Meno di 0,1 mA |
| Livello di uscita | 3,3 V | 3,3 V | Circa 3 V |
| Portata | 3–7 m, regolabile | Fino a 3 m | 3–5 m |
| Angolo | Circa 110° | Inferiore a 100° | Inferiore a 100° |
| Tempo di uscita | 3 s – 5 min, con trimmer | Fisso, circa 8 s | Fisso, circa 2 s |
| Modalità di attivazione | Jumper H (riattivabile) o L (singola) | Solo riattivabile | Solo riattivabile |
| Quando sceglierlo | Stanze e corridoi, portata lunga | Contenitori piccoli, sistemi a 5 V | 3,3 V, batteria, ESP32 e Pico |
In breve: se devi sorvegliare una stanza grande o un corridoio lungo e vuoi regolare il tempo con il cacciavite, l'HC-SR501 resta l'opzione più flessibile. Se il contenitore è piccolo e il sistema funziona già a 5 V, l'HC-SR505 fa il suo lavoro. Se usi una scheda a 3,3 V come ESP32 o Pico, o alimenti il sensore direttamente da una cella al litio, scegli l'AM312: è progettato ufficialmente per tensioni basse e il suo breve tempo di uscita di 2 secondi tiene sveglio il microcontrollore per meno tempo. Tutti e tre hanno un'uscita di circa 3 V, quindi nessuno ha bisogno di un partitore per collegarsi all'ESP32.
L'HC-SR505 funziona a 3,3 V?
Ufficialmente no: l'HC-SR505 ha sulla scheda un piccolo regolatore con uscita a 3,3 V, e il minimo dichiarato per il modulo è 4,5 V. Se dai 3,3 V all'ingresso del regolatore, il circuito interno riceve circa 3,1–3,2 V. Molti sensori funzionano lo stesso, ma la sensibilità può calare e i falsi allarmi aumentare, quindi non conviene progettare un prodotto contando su questo. Questo limite decide anche quali batterie usare: 3 pile AA danno 4,5 V da nuove ma scendono presto sotto questo valore; 4 pile AA o NiMH sono più sicure per l'HC-SR505. Con una sola cella Li-ion da 3,7 V l'HC-SR505 è sotto il suo limite, mentre l'AM312 continua a funzionare fino a 2,7 V.
Collegamento: Arduino Uno, ESP32 e Pico
| Pin del sensore | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+), HC-SR505 | 5V | VIN (5V) | VBUS (5V) |
| VCC (+), AM312 | 5V o 3.3V | 3V3 | 3V3 (OUT) |
| OUT | D2 | GPIO 33 | GP16 |
| GND (−) | GND | GND | GND |
Sketch Arduino: contare i movimenti e misurare il tempo di uscita
Lo sketch qui sotto aspetta prima 30 secondi che il sensore si scaldi, poi incrementa un contatore a ogni inizio di movimento e, quando l'uscita torna LOW, stampa per quanti secondi è rimasta HIGH. Anche il LED integrato segue l'uscita. Questo piccolo test è il modo più semplice per capire se il tuo sensore è un HC-SR505 o un AM312 e per vedere come funziona la riattivazione. Apri il Monitor seriale a 115200 baud:
1// HC-SR505 / AM312 testi: hareketi say, çıkışın HIGH kalma süresini ölç / count motion, measure how long OUT stays HIGH
2const int PIR_PIN = 2;
3const int LED_PIN = 13; // dahili LED / built-in LED
4
5bool lastState = LOW;
6unsigned long riseTime = 0;
7unsigned int events = 0;
8
9void setup() {
10 pinMode(PIR_PIN, INPUT);
11 pinMode(LED_PIN, OUTPUT);
12 Serial.begin(115200);
13 Serial.println(F("Isinma 30 sn / warming up 30 s"));
14 delay(30000); // açılıştaki yanlış tetiklemeleri atla / skip false triggers at power-up
15 Serial.println(F("Hazir / ready"));
16}
17
18void loop() {
19 bool state = digitalRead(PIR_PIN);
20 digitalWrite(LED_PIN, state); // LED çıkışı takip eder / LED follows the output
21 if (state == HIGH && lastState == LOW) { // yükselen kenar: hareket başladı / rising edge: motion started
22 riseTime = millis();
23 events++;
24 Serial.print(F("Hareket / motion #"));
25 Serial.println(events);
26 }
27 if (state == LOW && lastState == HIGH) { // düşen kenar: tutma süresi bitti / falling edge: hold time over
28 float seconds = (millis() - riseTime) / 1000.0;
29 Serial.print(F("OUT HIGH kaldi / stayed HIGH: "));
30 Serial.print(seconds, 1);
31 Serial.println(F(" s"));
32 }
33 lastState = state;
34}Se muovi la mano una volta e la togli, vedrai circa 8 secondi con un HC-SR505 (tra 5,6 e 10,4 secondi a seconda dell'esemplare) e circa 2 secondi con un AM312. Se continui a muoverti davanti al sensore, il conteggio riparte a ogni nuovo movimento e leggerai un valore molto più lungo; ecco cosa significa riattivabile. Se vuoi che la luce resti accesa 20 secondi o 2 minuti dopo l'ultimo movimento, gestisci il tempo nel codice e non nel sensore; mostriamo come farlo con millis() in sensore di movimento PIR.
Lavorare con tempo e sensibilità fissi
La grande differenza dell'HC-SR505 è che non si può regolare. Nel codice puoi allungare il tempo quanto vuoi, ma non scendere sotto gli 8 secondi; per un gioco o un contatore che deve reagire in fretta, l'AM312 da 2 secondi è più adatto. Anche la sensibilità è fissa, quindi la zona di rilevamento si modella fisicamente e non via software. Sulla carta, un cono di 100° a 3 metri copre una zona larga circa 7 metri; in realtà il rilevamento si indebolisce verso i bordi. Questi accorgimenti aiutano a restringere la zona e a ridurre i falsi allarmi:
- Copri una parte della lente con del nastro: Coprendo la metà inferiore della lente con nastro opaco, il sensore vedrà meno gli animali sul pavimento e le variazioni di temperatura vicino al suolo.
- Aggiungi un tubetto di carta o plastica: Un tubetto di 2–3 cm davanti al sensore restringe la vista a un cono stretto, ideale per una porta o un singolo corridoio.
- Altezza e orientamento giusti: Monta il sensore a 1,5–2 metri di altezza; un PIR rileva meglio i movimenti che attraversano il campo da un lato all'altro e nota più tardi chi gli cammina dritto incontro.
- Tienilo lontano dalle fonti di calore: Termosifoni, bocchette del condizionatore, finestre al sole e lampade calde fanno scattare il sensore con sbalzi di temperatura.
- Non metterlo dietro un vetro: Il vetro normale blocca la radiazione infrarossa del calore corporeo; un PIR dietro una finestra non vede i movimenti all'esterno.
Basso consumo e progetti a batteria
A riposo i mini PIR assorbono meno di 60–100 µA, quindi il sensore da solo non può scaricare una cella 18650 per anni. A decidere davvero l'autonomia è la scheda a cui è collegato. Un Arduino Uno assorbe circa 45–50 mA anche senza fare nulla e svuota una batteria da 2000 mAh in meno di due giorni. Per questo, in un sensore di movimento a batteria, il microcontrollore deve passare quasi tutto il tempo dormendo e svegliarsi solo quando l'uscita del PIR va HIGH. La tabella mostra valori indicativi con una cella 18650 da 2000 mAh e 50 movimenti al giorno:
| Configurazione | Corrente in sleep | Consumo giornaliero | Autonomia indicativa |
|---|---|---|---|
| ESP32 DevKit (AMS1117, LED di alimentazione, chip USB) + HC-SR505 | Circa 6 mA | Circa 145 mAh | 2 settimane |
| Modulo ESP32 nudo + LDO MCP1700 + mini PIR, senza Wi-Fi | Circa 75 µA | Circa 2,5 mAh | Oltre 2 anni in teoria |
| Stessa configurazione, notifica Wi-Fi a ogni movimento | Circa 75 µA | Circa 6,5 mAh | Circa 10 mesi |
La prima riga non sorprende: il regolatore AMS1117 delle schede di sviluppo assorbe da solo circa 5 mA. Per una lunga autonomia, alimenta il modulo ESP32 con un LDO come l'MCP1700, la cui corrente di riposo è di pochi µA. Nella seconda riga la batteria dura così tanto che il vero limite diventa la sua autoscarica. Puoi fare il calcolo per la tua configurazione con lo strumento Autonomia batteria, leggere dei mAh in capacità della batteria e imparare a usare in sicurezza le celle 18650 in batteria Li-ion 18650.
ESP32 deep sleep: risveglio con HC-SR505 o AM312
Con il risveglio ext0 l'ESP32 può sorvegliare il livello di un singolo pin GPIO RTC anche in deep sleep. C'è però una trappola che quasi tutti gli esempi saltano: se la scheda si sveglia quando l'uscita del PIR va HIGH, fa il suo lavoro e torna subito a dormire, l'uscita è ancora HIGH e si risveglia all'istante. Durante gli 8 secondi di uscita dell'HC-SR505 la scheda si accende e si spegne decine di volte e spreca batteria. Il codice qui sotto risolve così: quando si sveglia per un movimento incrementa il contatore e accende il LED, poi, se l'uscita è ancora HIGH, si rimette a dormire con un timer di 2 secondi. Quando l'uscita torna LOW, riattiva il risveglio ext0. Il contatore resta nella memoria RTC_DATA_ATTR, che sopravvive al deep sleep.
1// ESP32 derin uyku + HC-SR505 / AM312: hareketle uyan, çıkış sakinleşene kadar uyuyarak bekle / ESP32 deep sleep: wake on motion, wait asleep until the output settles
2#include "driver/rtc_io.h"
3
4const gpio_num_t PIR_PIN = GPIO_NUM_33; // RTC GPIO olmalı / must be an RTC GPIO
5const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
6const uint64_t RECHECK_US = 2ULL * 1000000ULL; // OUT HIGH ise 2 sn sonra yeniden bak / recheck in 2 s while OUT is HIGH
7RTC_DATA_ATTR int motionCount = 0; // derin uykuda silinmez / survives deep sleep
8
9void sleepUntilMotion() {
10 rtc_gpio_pullup_dis(PIR_PIN);
11 rtc_gpio_pulldown_en(PIR_PIN); // boşta LOW kalsın / keep LOW when idle
12 esp_sleep_enable_ext0_wakeup(PIR_PIN, 1); // OUT HIGH olunca uyan / wake when OUT goes HIGH
13 esp_deep_sleep_start();
14}
15
16void sleepAndRecheck() {
17 esp_sleep_enable_timer_wakeup(RECHECK_US); // hareket sürüyor: uyuyarak bekle / motion goes on: wait asleep
18 esp_deep_sleep_start();
19}
20
21void setup() {
22 Serial.begin(115200);
23 pinMode(LED_PIN, OUTPUT);
24 esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
25
26 if (cause == ESP_SLEEP_WAKEUP_EXT0) { // yeni hareket / new motion
27 motionCount++;
28 Serial.printf("Hareket / motion #%d\n", motionCount);
29 digitalWrite(LED_PIN, HIGH); // bildirim kodu buraya / notification code goes here
30 delay(200);
31 digitalWrite(LED_PIN, LOW);
32 } else if (cause != ESP_SLEEP_WAKEUP_TIMER) { // ilk açılış ya da reset / first boot or reset
33 Serial.println("Sensor isiniyor 30 sn / sensor warming up 30 s");
34 delay(30000);
35 }
36
37 rtc_gpio_deinit(PIR_PIN); // pini normal girişe çevir / turn the pin back into a normal input
38 pinMode(PIR_PIN, INPUT);
39 if (digitalRead(PIR_PIN) == HIGH) sleepAndRecheck(); // hâlâ HIGH: hemen uyanmamak için bekle / still HIGH: avoid an instant re-wake
40 sleepUntilMotion();
41}
42
43void loop() {
44}Mini PIR con il Raspberry Pi Pico (MicroPython)
Sul Pico è più pulito usare un interrupt (IRQ) che leggere il sensore di continuo: la funzione parte da sola a ogni cambio dell'uscita e il loop principale resta disponibile per altri compiti. Il codice qui sotto incrementa il contatore e accende il LED sul fronte di salita, e sul fronte di discesa stampa per quanto tempo l'uscita è rimasta HIGH. Alimenta l'AM312 dal pin 3V3 (OUT) e l'HC-SR505 da VBUS; in entrambi i casi OUT va a GP16:
1# HC-SR505 / AM312 ile Raspberry Pi Pico: kesmeyle hareket sayacı / motion counter with an interrupt
2from machine import Pin
3import time
4
5pir = Pin(16, Pin.IN, Pin.PULL_DOWN) # GP16; boştayken LOW kalsın / stays LOW when idle
6led = Pin(25, Pin.OUT) # dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7count = 0
8rise_ms = 0
9
10def on_change(pin):
11 global count, rise_ms
12 if pin.value(): # hareket başladı / motion started
13 count += 1
14 rise_ms = time.ticks_ms()
15 led.on()
16 print("Hareket / motion #", count)
17 else: # tutma süresi bitti / hold time over
18 led.off()
19 held = time.ticks_diff(time.ticks_ms(), rise_ms) / 1000
20 print("HIGH kaldi / stayed HIGH: {:.1f} s".format(held))
21
22time.sleep(30) # ısınma süresi / warm-up time
23pir.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=on_change)
24
25while True:
26 time.sleep(1)Anche nelle sue modalità di sleep con MicroPython, il Pico non scende ai livelli del deep sleep dell'ESP32. Per un progetto sulla scrivania o collegato alla rete non importa, ma per un sensore di movimento che deve durare mesi a batteria è meglio un ESP32 o un Arduino Pro Mini, la cui corrente in sleep scende a pochi microampere dopo aver rimosso il LED di alimentazione e il regolatore.
Falsi allarmi e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Scatta da solo qualche volta all'accensione | Il sensore si sta scaldando e impara l'ambiente | Aspetta 30 secondi dopo l'accensione o ignora i primi allarmi |
| Scatta quando si accende il Wi-Fi dell'ESP32 | Il mini PIR capta le onde radio dell'antenna | Allontana il sensore di almeno 10 cm dall'antenna e aggiungi 100 nF e 10 µF tra VCC e GND |
| Non scatta mai | HC-SR505 alimentato sotto 4,5 V o sensore dietro un vetro | Alimentalo a 5 V o passa all'AM312; togli il vetro |
| L'uscita non torna mai LOW | Movimento o variazioni di temperatura continue nel campo visivo | Allontana il sensore da termosifoni, condizionatori e tende che si muovono, copri parte della lente |
| Allarmi casuali quando la batteria si scarica | Con il calo di tensione l'alimentazione del sensore diventa instabile | Alimenta il sensore da una linea regolata e ricarica la batteria per tempo |
| L'ESP32 si sveglia di continuo | Va in sleep con il risveglio ext0 mentre l'uscita è HIGH | Aspetta con il timer che l'uscita sia LOW, come fa il codice di questo articolo |
Idee di progetto con l'HC-SR505
- Luce per armadi e cassetti: Una piccola striscia LED si accende quando apri l'anta e allunghi la mano, e si spegne da sola 8 secondi dopo.
- Allarme di movimento a batteria: Un ESP32 aspetta in deep sleep e avvisa via Telegram quando rileva un movimento.
- Campanello all'ingresso: Un buzzer suona una breve melodia quando qualcuno si avvicina alla porta.
- Attivazione di una fototrappola: Un movimento in giardino scatta una foto con un ESP32-CAM.
- Sistema d'allarme intelligente: Combina più mini PIR con sensori per porte e finestre e costruisci un sistema d'allarme con Arduino.
- Rilevamento attraverso un contenitore: Se il sensore deve vedere attraverso una scatola di plastica, prova il sensore radar RCWL-0516 al posto di un PIR.
HC-SR505 e AM312 sono il modo più pratico per rilevare il movimento ovunque non entri un grande modulo PIR: tre fili, nessuna regolazione e un consumo di pochi microampere. Quale scegliere dipende dalla tensione del tuo sistema e dal tempo di uscita che ti serve. Nell'app BlueGrays puoi seguire passo passo, con schemi e codice pronto, i progetti di campanello e luce con sensore di movimento, di illuminazione automatica con ESP32 e PIR e di allarme di movimento con ESP32 e notifiche Telegram.
Domande frequenti
Che differenza c'è tra HC-SR505 e HC-SR501?
L'HC-SR505 è un PIR minuscolo, di circa 1 cm di diametro e senza regolazioni: il tempo di uscita è fisso a circa 8 secondi e la portata a circa 3 metri. L'HC-SR501 è più grande e ha due trimmer per regolare la portata da 3 a 7 metri e il tempo da 3 secondi a 5 minuti. Entrambi si alimentano a 4,5–20 V e danno un'uscita a 3,3 V.
Il sensore PIR HC-SR505 funziona a 3,3 V?
Il minimo ufficiale è 4,5 V, perché sulla scheda c'è un regolatore da 3,3 V. Molti esemplari funzionano anche a 3,3 V, ma la sensibilità può calare e i falsi allarmi aumentare. Per sistemi a 3,3 V e batterie al litio a una cella è più sicuro l'AM312, che funziona da 2,7 V.
Si può regolare il tempo dell'HC-SR505?
No, non ha trimmer né jumper; l'uscita resta HIGH per circa 8 secondi dopo ogni movimento e più a lungo se il movimento continua. Nel codice puoi allungare il tempo quanto vuoi, ma non scendere sotto gli 8 secondi. Se ti serve una reazione più rapida, scegli l'AM312, con circa 2 secondi di uscita.
Che portata ha il sensore PIR HC-SR505?
Rileva il movimento fino a circa 3 metri dentro un cono inferiore a 100°. Funziona meglio quando il movimento attraversa il campo visivo di lato. Se ti serve più portata, usa l'HC-SR501, regolabile fino a circa 7 metri.
Meglio l'AM312 o l'HC-SR505?
Se il tuo sistema funziona a 5 V e un tempo di uscita di 8 secondi ti va bene, l'HC-SR505 basta. Su schede a 3,3 V come ESP32 o Pico, nei progetti a batteria e nelle applicazioni che richiedono una reazione rapida, l'AM312, che funziona a 2,7–12 V e ha 2 secondi di uscita, è la scelta migliore.
Un mini PIR può risvegliare l'ESP32 dal deep sleep?
Sì. Collega il pin OUT a un GPIO RTC come il GPIO 33 e imposta il risveglio ext0 sul livello HIGH: l'ESP32 si sveglierà con il movimento. Prima di rimettere a dormire la scheda, aspetta che l'uscita torni LOW, altrimenti si risveglierà subito. Il codice di questo articolo passa questa attesa dormendo con un timer.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Illuminazione intelligente di scale e corridoi
Metti piede sulle scale o nel corridoio e le luci si accendono gradino dopo gradino nella direzione in cui cammini.
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

