Guia do HC-SR505 com Arduino: mini sensor PIR vs HC-SR501 e AM312
Guia do HC-SR505 com Arduino: mini PIR vs HC-SR501 e AM312, o tempo fixo de 8 s, uso em 3,3 V, cálculo de bateria e código para Arduino, ESP32 com deep sleep e Pico.
O HC-SR505 é um mini sensor de movimento PIR (infravermelho passivo) com cerca de 1 cm de diâmetro e 2,5 cm de altura, sem trimpots nem jumpers. Ele faz o mesmo trabalho do clássico HC-SR501, detectar uma pessoa ou um animal se movendo no seu campo de visão e colocar a saída em HIGH, em um corpo muito menor. É ideal para campainhas, luzes de armário, pequenas caixas de alarme e sensores a bateria. O AM312, do mesmo tamanho, funciona a partir de 2,7 V e muitas vezes é a melhor escolha para ESP32, Raspberry Pi Pico e projetos a bateria.
Neste artigo você vai ver como o HC-SR505 funciona, em que ele difere do HC-SR501 e do AM312 em uma tabela comparativa, como conviver com o tempo fixo de 8 segundos, os limites de usá-lo em 3,3 V e um cálculo real de duração de bateria. Depois vamos escrever um código Arduino que conta movimentos e mede o tempo de retenção, um código que acorda um ESP32 do deep sleep com movimento e espera dormindo até o movimento acabar, e um código MicroPython com interrupção para o Raspberry Pi Pico.

O que é o HC-SR505 e como funciona?
No coração de todo sensor PIR há um elemento piroelétrico dividido em duas metades. Com a cena parada, as duas metades veem a mesma quantidade de radiação infravermelha e os sinais se anulam. Quando alguém emitindo calor corporal cruza o campo de visão, primeiro uma metade e depois a outra recebe mais radiação, e o sensor interpreta essa diferença como movimento. A pequena lente de Fresnel na frente divide o campo de visão em zonas e aumenta a diferença. No HC-SR505, o circuito de processamento de sinal, o regulador e a lente cabem em uma única plaquinha, e o tempo de retenção e a sensibilidade vêm fixos de fábrica. Quando detecta movimento, a saída fica em HIGH por cerca de 8 segundos, e se houver novo movimento nesse tempo o temporizador recomeça (redisparo).
| Característica | HC-SR505 |
|---|---|
| Tensão de alimentação | 4,5–20 V (regulador de 3,3 V na placa) |
| Corrente em repouso | Menos de 60 µA |
| Saída | Digital: 3,3 V com movimento, 0 V sem |
| Alcance de detecção | Até 3 metros |
| Ângulo de detecção | Um cone mais estreito que 100° |
| Tempo de retenção | Cerca de 8 segundos (±30 %), não ajustável |
| Modo de disparo | Redisparo: a saída fica em HIGH enquanto o movimento continua |
| Tamanho | Cerca de 10 mm de diâmetro, 23–25 mm de altura |
| Temperatura de operação | −20 a +80 °C |
HC-SR501 vs HC-SR505 vs AM312
| Característica | HC-SR501 | HC-SR505 | AM312 |
|---|---|---|---|
| Tamanho | Placa de 32 × 24 mm, cúpula grande | Cerca de 10 mm de diâmetro | Cerca de 10 mm, próximo do HC-SR505 |
| Alimentação | 4,5–20 V | 4,5–20 V | 2,7–12 V |
| Corrente em repouso | Cerca de 50 µA | Menos de 60 µA | Menos de 0,1 mA |
| Nível de saída | 3,3 V | 3,3 V | Cerca de 3 V |
| Alcance de detecção | 3–7 m, ajustável | Até 3 m | 3–5 m |
| Ângulo de detecção | Cerca de 110° | Mais estreito que 100° | Mais estreito que 100° |
| Tempo de retenção | 3 s – 5 min, com trimpot | Fixo, cerca de 8 s | Fixo, cerca de 2 s |
| Modo de disparo | H (redisparo) ou L (único) por jumper | Só redisparo | Só redisparo |
| Quando escolher | Cômodos e corredores, longo alcance | Caixas pequenas, sistemas de 5 V | 3,3 V, baterias, ESP32 e Pico |
A versão curta é esta: se você está vigiando um cômodo grande ou um corredor comprido e quer ajustar o tempo de retenção com uma chave de fenda, o HC-SR501 continua sendo a opção mais flexível. Se a sua caixa é pequena e o seu sistema já roda em 5 V, o HC-SR505 resolve. Se você usa uma placa de 3,3 V como o ESP32 ou o Pico, ou alimenta o sensor direto de uma célula de lítio, vá de AM312: ele é oficialmente especificado para baixa tensão, e o tempo curto de 2 segundos deixa o microcontrolador acordado por menos tempo. Os três têm saída de cerca de 3 V, então nenhum precisa de divisor de tensão para se ligar a um ESP32.
O HC-SR505 funciona com 3,3 V?
Oficialmente, não: o HC-SR505 tem na placa um pequeno regulador com saída de 3,3 V, e o mínimo especificado para o módulo é 4,5 V. Se você colocar 3,3 V no regulador, o circuito interno vê algo em torno de 3,1–3,2 V. Muitos sensores ainda funcionam assim, mas a sensibilidade pode cair e os disparos falsos podem aumentar, então não convém projetar um produto em cima disso. Esse limite também decide a sua escolha de bateria: 3 pilhas AA dão 4,5 V novas, mas logo caem abaixo disso; 4 pilhas AA ou NiMH são mais seguras para o HC-SR505. Com uma única célula Li-ion de 3,7 V o HC-SR505 fica abaixo do limite, enquanto o AM312 continua funcionando até 2,7 V.
Ligação: Arduino Uno, ESP32 e Pico
| Pino do sensor | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+), HC-SR505 | 5V | VIN (5V) | VBUS (5V) |
| VCC (+), AM312 | 5V ou 3,3V | 3V3 | 3V3 (OUT) |
| OUT | D2 | GPIO 33 | GP16 |
| GND (−) | GND | GND | GND |
Código Arduino: contar movimentos e medir o tempo de retenção
O sketch abaixo primeiro espera 30 segundos para o sensor aquecer, depois incrementa um contador a cada início de movimento e, quando a saída volta para LOW, mostra quantos segundos ela ficou em HIGH. O LED integrado acompanha a saída também. Esse pequeno teste é o jeito mais fácil de descobrir se o seu sensor é um HC-SR505 ou um AM312 e de ver como o redisparo funciona. Abra o Monitor Serial 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 você acenar a mão uma vez e tirá-la, vai ver cerca de 8 segundos em um HC-SR505 (entre 5,6 e 10,4 segundos, conforme a unidade) e cerca de 2 segundos em um AM312. Se você continuar se mexendo na frente do sensor, o temporizador recomeça a cada novo movimento e você lê um valor bem maior; isso é o redisparo. Se quiser que a luz fique acesa por 20 segundos ou 2 minutos depois do último movimento, controle o tempo no seu código, e não no sensor; mostramos como fazer isso com millis() em sensor de movimento PIR.
Trabalhando com tempo de retenção e sensibilidade fixos
A maior diferença do HC-SR505 é que ele não tem ajuste. Você pode estender o tempo de retenção no código o quanto quiser, mas não pode deixá-lo menor que 8 segundos; para um jogo ou um contador que precisa de resposta rápida, o AM312 de 2 segundos combina melhor. A sensibilidade também é fixa, então você molda a área de detecção fisicamente, e não no software. No papel, um cone de 100° cobre uma área de cerca de 7 metros de largura a 3 metros; na prática a detecção fica mais fraca nas bordas. Estes métodos ajudam a estreitar a área e reduzir alarmes falsos:
- Cubra parte da lente com fita: cubra a metade de baixo da lente com fita opaca e o sensor passa a ver menos os animais no chão e as variações de temperatura perto do piso.
- Coloque um tubo de papel ou plástico: um tubo de 2–3 cm na frente do sensor estreita a visão para um cone fechado, ideal para uma porta ou um único corredor.
- Altura e direção certas: monte o sensor a 1,5–2 metros de altura; um PIR detecta melhor quando o movimento cruza o campo de visão de lado a lado, e percebe mais tarde alguém andando direto na direção dele.
- Mantenha longe de fontes de calor: aquecedores, saídas de ar-condicionado, janelas ensolaradas e lâmpadas quentes disparam o sensor com mudanças bruscas de temperatura.
- Não o coloque atrás de vidro: o vidro comum bloqueia a radiação infravermelha do calor corporal; um PIR atrás de uma janela não vê o movimento do lado de fora.
Baixo consumo e projetos a bateria
Os mini PIRs consomem menos de 60–100 µA em repouso, então o sensor sozinho não consegue esgotar uma célula 18650 em anos. O que realmente decide a duração da bateria é a placa à qual o sensor está ligado. Um Arduino Uno consome cerca de 45–50 mA mesmo sem fazer nada e esvazia uma bateria de 2000 mAh em menos de dois dias. Por isso, em um sensor de movimento a bateria, o microcontrolador precisa passar quase todo o tempo dormindo e acordar só quando a saída do PIR vai para HIGH. A tabela abaixo mostra números aproximados para uma célula 18650 de 2000 mAh e 50 movimentos por dia:
| Montagem | Corrente dormindo | Consumo diário | Duração aproximada da bateria |
|---|---|---|---|
| ESP32 DevKit (AMS1117, LED de energia, chip USB) + HC-SR505 | Cerca de 6 mA | Cerca de 145 mAh | 2 semanas |
| Módulo ESP32 nu + LDO MCP1700 + mini PIR, sem Wi-Fi | Cerca de 75 µA | Cerca de 2,5 mAh | Mais de 2 anos em teoria |
| Mesma montagem, notificação por Wi-Fi a cada movimento | Cerca de 75 µA | Cerca de 6,5 mAh | Cerca de 10 meses |
A primeira linha não surpreende: o regulador AMS1117 das placas de desenvolvimento consome uns 5 mA sozinho. Para uma bateria duradoura, alimente o módulo ESP32 por um LDO como o MCP1700, cuja corrente quiescente é de poucos µA. Na segunda linha a bateria dura tanto que o limite real passa a ser a autodescarga da própria célula. Você pode fazer as contas para a sua montagem com a ferramenta Duração da Bateria, ler sobre mAh em capacidade da bateria e aprender a usar células 18650 com segurança em bateria Li-ion 18650.
Deep sleep no ESP32: acordando com um HC-SR505 ou AM312
Com o despertar ext0, o ESP32 consegue vigiar o nível de um único pino RTC GPIO mesmo em deep sleep. Há uma armadilha aqui que a maioria dos exemplos ignora: se a placa acorda quando a saída do PIR vai para HIGH, faz o trabalho e volta logo a dormir, a saída ainda está em HIGH, então ela acorda de novo na hora. Durante os 8 segundos de retenção do HC-SR505, a placa liga e desliga dezenas de vezes e desperdiça bateria. O código abaixo resolve isso: quando acordada por movimento, incrementa o contador e acende o LED e, se a saída ainda estiver em HIGH, volta a dormir com um temporizador de 2 segundos. Quando a saída volta para LOW, rearma o despertar ext0. O contador fica na memória RTC_DATA_ATTR, que sobrevive ao 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 com o Raspberry Pi Pico (MicroPython)
No Pico, usar uma interrupção (IRQ) é mais limpo do que consultar o sensor o tempo todo: a função roda sozinha toda vez que a saída muda, e o loop principal fica livre para outras tarefas. O código abaixo incrementa o contador e acende o LED na borda de subida e mostra quanto tempo a saída ficou em HIGH na borda de descida. Alimente o AM312 pelo pino 3V3 (OUT) e o HC-SR505 pelo VBUS; o OUT vai ao GP16 nos dois casos:
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)Mesmo nos modos de sono do MicroPython, o Pico não chega nem perto do consumo baixo do deep sleep do ESP32. Isso não importa para um projeto na bancada ou ligado na tomada, mas para um sensor de movimento que precisa rodar meses com bateria, um ESP32 ou um Arduino Pro Mini, cuja corrente dormindo cai para microampères depois de remover o LED de energia e o regulador, é a melhor escolha.
Disparos falsos e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| Dispara sozinho algumas vezes ao ligar | O sensor está aquecendo e aprendendo a cena | Espere 30 segundos depois de ligar ou ignore os primeiros disparos |
| Dispara quando o Wi-Fi do ESP32 liga | O mini PIR capta as ondas de rádio da antena | Afaste o sensor pelo menos 10 cm da antena e coloque capacitores de 100 nF e 10 µF entre VCC e GND |
| Nunca dispara | HC-SR505 alimentado abaixo de 4,5 V, ou o sensor está atrás de vidro | Alimente com 5 V ou troque por um AM312; tire o vidro |
| A saída nunca volta para LOW | Movimento constante ou variações de temperatura no campo de visão | Afaste o sensor de aquecedores, ar-condicionado e cortinas que se mexem, cubra parte da lente |
| Disparos aleatórios quando a bateria enfraquece | A alimentação do sensor fica instável com a queda de tensão | Alimente o sensor por um trilho regulado e recarregue a bateria a tempo |
| O ESP32 não para de acordar | Vai dormir com o despertar ext0 enquanto a saída está em HIGH | Espere com um temporizador até a saída ir para LOW, como faz o código deste artigo |
Ideias de projetos com o HC-SR505
- Luz de armário e gaveta: acenda uma pequena fita de LED quando a porta abrir e uma mão entrar, e deixe que ela apague sozinha 8 segundos depois.
- Alarme de movimento a bateria: mantenha um ESP32 em deep sleep e faça-o mandar uma mensagem pelo Telegram quando houver movimento.
- Aviso na porta: toque uma melodia curta em um buzzer quando alguém se aproximar da porta.
- Gatilho de câmera para a natureza: deixe o movimento no jardim tirar uma foto com um ESP32-CAM.
- Sistema de alarme inteligente: combine vários mini PIRs com sensores de porta e janela para montar um sistema de alarme com Arduino.
- Detectar através de uma caixa: se o sensor precisa enxergar através de uma caixa plástica, experimente o sensor de radar RCWL-0516 no lugar de um PIR.
O HC-SR505 e o AM312 são o jeito mais prático de detectar movimento onde um módulo PIR grande não cabe: três fios, nenhum ajuste e um consumo medido em microampères. Qual escolher depende da tensão do seu sistema e do tempo de retenção que você quer. No app BlueGrays você pode explorar passo a passo os projetos Campainha e Luz com Sensor de Movimento, Iluminação Automática PIR com ESP32 e Alarme de Movimento com ESP32 e notificações no Telegram, com esquemas de ligação e código pronto.
Perguntas frequentes
Qual é a diferença entre o HC-SR505 e o HC-SR501?
O HC-SR505 é um PIR minúsculo, sem ajuste, com cerca de 1 cm; o tempo de retenção é fixo em cerca de 8 segundos e o alcance em cerca de 3 metros. O HC-SR501 é maior e tem dois trimpots para um alcance de 3–7 metros e um tempo de retenção de 3 segundos a 5 minutos. Os dois funcionam com 4,5–20 V e dão uma saída de 3,3 V.
O HC-SR505 funciona com 3,3 V?
O mínimo especificado é 4,5 V porque há um regulador de 3,3 V na placa. Muitas unidades funcionam em 3,3 V, mas a sensibilidade pode cair e os disparos falsos podem aumentar. Para sistemas de 3,3 V e baterias de lítio de uma célula, o AM312, que funciona a partir de 2,7 V, é a escolha mais segura.
Dá para ajustar o tempo do HC-SR505?
Não, não há trimpots nem jumpers; a saída fica em HIGH por cerca de 8 segundos depois de cada movimento e fica mais tempo enquanto o movimento continua. Você pode estender o tempo no código o quanto quiser, mas não pode ir abaixo de 8 segundos. Se precisa de resposta mais rápida, escolha o AM312, cujo tempo de retenção é de cerca de 2 segundos.
Qual é o alcance do HC-SR505?
O HC-SR505 detecta movimento até cerca de 3 metros dentro de um cone mais estreito que 100°. A detecção é melhor quando o movimento cruza o campo de visão de lado a lado. Se precisa de mais alcance, use o HC-SR501, que pode ser ajustado para cerca de 7 metros.
Compro um AM312 ou um HC-SR505?
Se o seu sistema roda em 5 V e um tempo de retenção de 8 segundos serve, o HC-SR505 está ótimo. Em placas de 3,3 V como o ESP32 ou o Pico, em projetos a bateria e em aplicações que precisam de resposta rápida, o AM312, que funciona com 2,7–12 V e tem tempo de retenção de 2 segundos, é a melhor escolha.
Um mini PIR consegue acordar um ESP32 do deep sleep?
Sim. Ligue o pino OUT do sensor a um RTC GPIO como o GPIO 33 e configure o despertar ext0 para disparar em HIGH, e o ESP32 acorda com o movimento. Antes de pôr a placa para dormir de novo, espere a saída voltar para LOW, senão ela acorda outra vez na hora. O código deste artigo passa esse tempo de espera dormindo com um temporizador.
Projetos para montar depois desta leitura
Ver todos os projetos
Detector de movimento com sensor de movimento
Um vigia simples que avisa quando alguém entra no cômodo. O sensor de movimento detecta o calor emitido pelo corpo humano, e o Arduino mantém o LED aceso enquanto há movimento e o apaga quando ele…

Campainha e luz com sensor de movimento
Quando alguém se aproxima da sua porta, você fica sabendo antes mesmo de a pessoa tocar a campainha.

Iluminação automática com ESP32 e sensor de movimento PIR
Neste projeto, usaremos o sensor de movimento PIR HC-SR501 para detectar quando alguém entra no cômodo e acender o LED automaticamente. Acompanharemos o tempo em que o LED fica aceso com millis(). Cada leitura HIGH do sensor atualizará o instante do último movimento, e o LED apagará pelo menos 10 segundos após a última leitura HIGH. O código atual também espera 50 ms em cada ciclo com delay(50), portanto o laço da aplicação não é totalmente livre de bloqueios.

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Iluminação inteligente de escadas e corredores
Ao entrar na escada ou no corredor, as luzes acendem uma a uma no sentido em que você caminha.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

