Sensor capacitivo de umidade do solo com Arduino: calibração e código
Como usar o sensor capacitivo de umidade do solo v1.2 com Arduino: diferença para o resistivo, o problema do TLC555/NE555 em 3,3 V, calibração seco-molhado, tabela de porcentagem, ESP32, Pico.
Um sensor capacitivo de umidade do solo é um módulo que mede o quanto a terra de um vaso ou jardim está molhada sem nenhum eletrodo de metal encostar no solo. Por isso ele não sofre o problema das clássicas sondas resistivas em forma de garfo, que corroem e param em poucas semanas, e em projetos de rega automática com Arduino pode durar meses ou até anos. Ele costuma vir marcado como "Capacitive Soil Moisture Sensor v1.2" ou v2.0, tem uma única saída analógica e se liga a um Arduino Uno, ESP32 ou Raspberry Pi Pico com três fios.
Esses módulos baratos têm armadilhas importantes, porém: algumas placas usam o chip 555 errado e não funcionam em 3,3 V, outras estão sem a ligação de um resistor, e as bordas cortadas absorvem água e fazem as leituras derivarem em poucas semanas. Neste guia você vai aprender como o sensor funciona, como ele difere do resistivo, como reconhecer uma placa boa, como calibrá-lo seco e molhado e como transformar o valor analógico em porcentagem de umidade. Depois vêm a rega automática com Uno, um monitor de planta a bateria com ESP32 e código MicroPython para a Pico.
Como funciona um sensor capacitivo de umidade do solo?
A área larga de cobre na ponta do sensor e a superfície de GND ao redor funcionam como as duas placas de um capacitor, e o isolante entre elas é o próprio solo. A água tem constante dielétrica de cerca de 80, o solo seco de 3–5 e o ar de 1, então quanto mais molhado o solo, maior a capacitância. O chip 555 na parte de cima gera uma onda quadrada de cerca de 1,5 MHz que carrega e descarrega a sonda por um resistor, e depois um diodo e um pequeno filtro transformam o sinal em tensão contínua. Conforme a capacitância sobe, a amplitude da onda na sonda cai, então a tensão de saída é alta em solo seco e baixa em solo molhado. Como os eletrodos são cobertos pela máscara de solda, nenhuma corrente passa pelo solo. Você pode experimentar como o 555 funciona na ferramenta do timer 555.
| Característica | Valor |
|---|---|
| Alimentação | 3,3–5,5 V (nas placas com TLC555) |
| Saída | Analógica, cerca de 1,2–3,0 V; alta quando seco, baixa quando molhado |
| Corrente | Cerca de 5 mA |
| Conector | PH2.0 de 3 pinos: GND, VCC, AOUT |
| Tamanho | Cerca de 98 × 23 mm |
| Oscilador | TLC555 (CMOS), cerca de 1,5 MHz; NE555 nas cópias |
| Regulador | XC6206 marcado 662K, 3,3 V |
| Eletrodos | Cobre isolado pela máscara de solda; nenhuma corrente passa pelo solo |
Diferença para o sensor resistivo: sem corrosão
Os sensores resistivos (YL-69, FC-28) passam corrente entre duas hastes de metal nu enfiadas no solo e medem a resistência dele. No solo molhado essa corrente contínua causa eletrólise: o metal da haste positiva se dissolve, com alimentação contínua o revestimento some em poucas semanas e as leituras ficam derivando. A leitura também depende mais dos sais e do adubo do que da água; no dia em que você aduba as plantas, o solo parece molhado. Já o sensor capacitivo mede o efeito dielétrico da água, então os sais o afetam bem menos, e como não há metal exposto ele não corrói. Falamos do sensor resistivo em sensor de umidade do solo.

| Característica | Resistivo (YL-69, FC-28) | Capacitivo v1.2 |
|---|---|---|
| Método de medição | Resistência elétrica do solo | Capacitância (constante dielétrica) |
| Eletrodos | Metal nu niquelado | Cobre isolado pela máscara de solda |
| Corrosão | Em poucas semanas com alimentação contínua | Nenhuma (a não ser que a máscara seja riscada) |
| Efeito de adubo e sais | Grande | Pequeno |
| Saída | AO e DO (comparador LM393) | Só analógica (AOUT) |
| Funciona em 3,3 V | Sim | Só nas placas com TLC555 |
| Vida útil | Meses | Anos, se as bordas forem protegidas |
Versões v1.2 e v2.0: TLC555, NE555 e o problema dos 3,3 V
O número de versão impresso na placa não garante nada; o que importa é a marcação no chip de oito pinos. As placas boas trazem um TLC555 CMOS, que funciona bem a partir de 2 V. Algumas cópias baratas usam o clássico NE555, que precisa de pelo menos 4,5 V; nos 3,3 V de um ESP32 ou de uma Pico, a saída não muda ou fica presa em um valor sem sentido. A segunda coisa a conferir é o pequeno regulador marcado 662K: se estiver faltando ou em curto, a saída pode passar de 3 V com alimentação de 5 V. Em alguns lotes falta a ligação ao GND do resistor de descarga de 1 MΩ na saída; nessas placas, a mudança de seco para molhado leva minutos ou o valor fica alto. Por fim, a fibra de vidro nua das bordas cortadas absorve água com o tempo e faz as leituras derivarem.
| Verificação | Placa boa | Placa com problema | Sintoma |
|---|---|---|---|
| Chip 555 | TLC555 (CMOS) | NE555 ou SA555 | Em 3,3 V a saída não muda ou fica fixa |
| Regulador | Pequeno chip de 3 pinos marcado 662K | Faltando ou em curto | Em 5 V a saída pode passar de 3 V |
| Resistor de saída de 1 MΩ | Ligado ao GND | Sem a ligação ao GND | Resposta muito lenta, valor sempre alto |
| Bordas da placa | Cobertas com verniz ou epóxi | Fibra de vidro nua | As leituras derivam em semanas |
Ligação: Arduino Uno, ESP32 e Raspberry Pi Pico
| Pino do sensor | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND (preto) | GND | GND | GND |
| VCC (vermelho) | 5V | GPIO 25 (3,3 V só durante a medição) | GP22 (3,3 V só durante a medição) |
| AOUT (amarelo) | A0 | GPIO 34 (ADC1) | GP26 (ADC0) |
| IN do relé (bomba no exemplo do Uno) | D7 | — | — |
Nos exemplos com ESP32 e Pico, o VCC do sensor vai em um GPIO, e não direto no pino 3V3. Como o sensor consome só 5 mA, um pino o alimenta com facilidade; assim o sensor desliga por completo entre as leituras e a bateria dura mais. No ESP32, use para a leitura analógica os pinos ADC1 (GPIO 32–39), que continuam funcionando com o Wi-Fi ligado. No Uno o sensor funciona com 5V, mas graças ao regulador da placa a saída continua em torno de 3 V; por isso o Uno usa só cerca de 250–600 da sua faixa de 10 bits.
Calibração: achando os valores seco e molhado
- Carregue o código do Uno abaixo sem a bomba ligada e abra o Monitor Serial a 9600 baud.
- Segure o sensor seco e limpo no ar; depois de alguns segundos, anote o valor bruto estabilizado como DRY_VALUE (no Uno, geralmente 520–600).
- Mergulhe o sensor em um copo de água sem passar da linha da placa e anote a leitura como WET_VALUE (geralmente 250–300).
- Para um resultado mais realista, faça uma segunda série de leituras: use os valores da terra de vaso totalmente seca e da mesma terra depois de uma boa rega e 30 minutos escorrendo.
- Carregue o código de novo; agora o Monitor Serial mostra uma porcentagem de umidade de 0 a 100. Cada sensor dá valores um pouco diferentes, então calibre cada um separadamente.
| Valor bruto (Uno, calibração de exemplo) | Umidade | Estado do solo | O que fazer |
|---|---|---|---|
| 590 ou mais | 0 % | Ar ou solo totalmente seco | Confira se o sensor está bem firme no solo |
| 510 | 25 % | Seco | Hora de regar para a maioria das plantas |
| 430 | 50 % | Levemente úmido | Faixa ideal; não precisa regar |
| 350 | 75 % | Úmido | Solo recém-regado |
| 270 ou menos | 100 % | Água ou lama | Água demais; risco de apodrecer as raízes |
As porcentagens da tabela são calculadas com % = (590 − bruto) × 100 / (590 − 270) para DRY_VALUE = 590 e WET_VALUE = 270. Isso não é uma medida de laboratório, e sim um valor relativo entre os dois pontos de calibração: "50 %" não quer dizer que metade do volume do solo é água. A resposta do sensor também não é perfeitamente linear, mas é mais que suficiente para decidir quando regar. A compactação do solo, a temperatura e o tipo de solo também deslocam a leitura em alguns pontos; depois de enfiar o sensor, aperte levemente a terra ao redor para fechar os vãos de ar. Explicamos a leitura analógica em detalhes em O que é um ADC?.
Código para Arduino Uno: porcentagem de umidade e rega automática
O código abaixo lê o sensor 10 vezes e tira a média, converte o valor em porcentagem e mostra no Monitor Serial. Quando a umidade cai abaixo de 35 %, a rega começa e continua até a umidade passar de 60 %; a diferença entre esses dois limites (histerese) impede que a bomba fique ligando e desligando sem parar. A rega não é feita de uma vez, mas em doses de 4 segundos, com 1 minuto de espera depois de cada dose para a água se espalhar pelo solo. Como o sensor percebe a água com alguns segundos de atraso, deixar a bomba ligada direto inundaria o vaso.
1const byte SENSOR_PIN = A0; // sensör AOUT / sensor AOUT
2const byte PUMP_PIN = 7; // röle IN (pompa) / relay IN (pump)
3const byte RELAY_ON = HIGH; // röle LOW ile çekiyorsa LOW yap / use LOW for active-low relays
4const int DRY_VALUE = 590; // kuru: havada ya da kuru toprakta / dry: in air or dry soil
5const int WET_VALUE = 270; // ıslak: suda ya da yeni sulanmış toprakta / wet: in water or just-watered soil
6const byte START_PCT = 35; // bunun altında sulamaya başla / start watering below this
7const byte STOP_PCT = 60; // bunun üstünde sulamayı bitir / stop watering above this
8const unsigned long PUMP_MS = 4000; // tek seferde en fazla pompa süresi / max pump time per pulse
9const unsigned long SOAK_MS = 60000; // suyun toprağa yayılması için bekle / let the water spread
10
11bool watering = false;
12
13int readAverage() { // 10 okumanın ortalaması / average of 10 readings
14 long sum = 0;
15 for (byte i = 0; i < 10; i++) {
16 sum += analogRead(SENSOR_PIN);
17 delay(10);
18 }
19 return sum / 10;
20}
21
22int toPercent(int raw) { // ham değeri yüzdeye çevir / raw value to percent
23 long pct = (long)(DRY_VALUE - raw) * 100 / (DRY_VALUE - WET_VALUE);
24 return constrain(pct, 0, 100);
25}
26
27void setup() {
28 Serial.begin(9600);
29 pinMode(PUMP_PIN, OUTPUT);
30 digitalWrite(PUMP_PIN, !RELAY_ON); // pompa kapalı başlasın / start with the pump off
31}
32
33void loop() {
34 int raw = readAverage();
35 int pct = toPercent(raw);
36 Serial.print(F("Ham / raw: "));
37 Serial.print(raw);
38 Serial.print(F(" Nem / moisture: %"));
39 Serial.println(pct);
40
41 if (!watering && pct < START_PCT) watering = true; // histerezis / hysteresis
42 if (watering && pct >= STOP_PCT) watering = false;
43
44 if (watering) {
45 digitalWrite(PUMP_PIN, RELAY_ON); // kısa bir doz su ver / give a short dose of water
46 delay(PUMP_MS);
47 digitalWrite(PUMP_PIN, !RELAY_ON);
48 delay(SOAK_MS); // tekrar ölçmeden önce bekle / wait before measuring again
49 } else {
50 delay(2000);
51 }
52}
Nunca ligue a bomba direto em um pino do Arduino; alimente-a com uma fonte de 5 V separada por meio de um módulo relé ou de um MOSFET e ligue os GNDs. Alguns módulos relé ligam com sinal LOW; se o seu for assim, troque a constante RELAY_ON no código para LOW. Para escolher a bomba e ligar as mangueiras, veja o artigo mini bomba de água. Acrescentar um sensor de nível de água para detectar o reservatório vazio impede que a bomba funcione a seco e queime.
Monitor de umidade de planta a bateria com ESP32
O modo deep sleep do ESP32 permite manter o sensor funcionando com bateria por meses. Ao acordar, o código abaixo liga o sensor pelo GPIO 25, espera 1 segundo para a saída estabilizar, tira a média de 16 leituras, desliga o sensor e mostra o resultado. Se o solo estiver abaixo de 30 %, o LED da placa pisca três vezes; depois o ESP32 dorme por 30 minutos. O contador marcado com RTC_DATA_ATTR sobrevive ao deep sleep. Como o ADC do ESP32 é de 12 bits, os valores de calibração ficam na faixa de 0–4095 e diferem dos do Uno; meça-os de novo com o seu sensor.
1const int SENSOR_PIN = 34; // AOUT, ADC1 pini / ADC1 pin
2const int SENSOR_POWER_PIN = 25; // sensörün VCC'si / sensor VCC
3const int LED_PIN = 2; // dahili LED: kuru uyarısı / onboard LED: dry warning
4const int DRY_VALUE = 3100; // 12 bit, havada / 12-bit, in air
5const int WET_VALUE = 1350; // 12 bit, suda / 12-bit, in water
6const uint64_t SLEEP_MIN = 30; // ölçüm aralığı (dakika) / interval (minutes)
7
8RTC_DATA_ATTR int bootCount = 0; // derin uykuda korunur / kept through deep sleep
9
10void setup() {
11 Serial.begin(115200);
12 bootCount++;
13 pinMode(SENSOR_POWER_PIN, OUTPUT);
14 pinMode(LED_PIN, OUTPUT);
15
16 digitalWrite(SENSOR_POWER_PIN, HIGH); // sensörü aç / power the sensor
17 delay(1000); // çıkış otursun / let the output settle
18 long sum = 0;
19 for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN);
20 digitalWrite(SENSOR_POWER_PIN, LOW); // sensörü kapat / switch it off
21 int raw = sum / 16;
22 int pct = constrain(map(raw, DRY_VALUE, WET_VALUE, 0, 100), 0, 100);
23 Serial.printf("#%d raw %d moisture %d%%\n", bootCount, raw, pct);
24
25 if (pct < 30) { // kuruysa 3 kez yanıp sön / blink 3 times if dry
26 for (int i = 0; i < 3; i++) {
27 digitalWrite(LED_PIN, HIGH);
28 delay(200);
29 digitalWrite(LED_PIN, LOW);
30 delay(200);
31 }
32 }
33 esp_sleep_enable_timer_wakeup(SLEEP_MIN * 60ULL * 1000000ULL); // mikrosaniye / microseconds
34 esp_deep_sleep_start(); // 30 dk uyu / sleep for 30 min
35}
36
37void loop() {
38}Vamos estimar a duração da bateria por alto: a cada despertar, o ESP32 consome 40–50 mA por cerca de 1,5 segundo; acordando a cada 30 minutos, isso dá em média só 50 × 1,5 / 1800 ≈ 0,04 mA. O que importa de verdade é a corrente em repouso: um DevKit comum, com o chip USB-serial e o regulador, consome vários mA mesmo dormindo e esgota uma bateria de 2000 mAh em duas ou três semanas. Com um módulo ESP32 puro e um regulador de baixa perda, a corrente em repouso cai para dezenas de microampères e a bateria dura meses. Calcule o seu circuito com a calculadora de duração de bateria; os detalhes estão em deep sleep no ESP32.
Sensor capacitivo com Raspberry Pi Pico (MicroPython)
Na Raspberry Pi Pico, ligue o AOUT do sensor no GP26, que é o ADC0, e o VCC no GP22. No MicroPython, read_u16() retorna valores de 0 a 65535; no ar você vai ver cerca de 50000–53000 e na água em torno de 22000–26000. Como o ADC da Pico usa referência de 3,3 V, a saída de um sensor com regulador cabe com folga na faixa. O código faz uma leitura a cada 10 segundos e classifica o solo como seco, ok ou molhado.
1from machine import ADC, Pin
2import time
3
4sensor = ADC(26) # GP26 = ADC0, sensör AOUT / sensor AOUT
5power = Pin(22, Pin.OUT) # sensörün VCC'si / sensor VCC
6DRY = 52000 # havada okunan (16 bit) / reading in air (16-bit)
7WET = 24000 # suda okunan (16 bit) / reading in water (16-bit)
8
9def read_moisture():
10 power.value(1) # sensörü aç / power on
11 time.sleep(1) # çıkış otursun / let the output settle
12 total = 0
13 for _ in range(16):
14 total += sensor.read_u16()
15 time.sleep_ms(5)
16 power.value(0) # sensörü kapat / power off
17 raw = total // 16
18 pct = (DRY - raw) * 100 // (DRY - WET)
19 return raw, max(0, min(100, pct))
20
21while True:
22 raw, pct = read_moisture()
23 state = "dry" if pct < 30 else ("ok" if pct < 80 else "wet")
24 print("raw:", raw, "moisture %:", pct, state)
25 time.sleep(10)Impermeabilização: protegendo as bordas e posicionando o sensor
- Cubra as bordas: a fibra de vidro nua das bordas cortadas da placa absorve água e faz as leituras derivarem em semanas. Cubra as bordas da sonda com esmalte de unha, verniz transparente ou uma camada fina de epóxi.
- Proteja a eletrônica: cubra a parte de cima, com o chip 555, o regulador e o conector, com tubo termorretrátil, cola quente ou epóxi para manter longe a chuva e a água da rega.
- Não passe da linha: a linha branca da placa marca o ponto mais fundo que pode entrar no solo; a eletrônica precisa ficar sempre acima da terra.
- Enfie reto e firme: coloque o sensor na vertical e aperte a terra levemente ao redor; vãos de ar fazem o solo parecer mais seco do que está.
- Mantenha a posição fixa: coloque o sensor a 1–2 cm da parede do vaso, na zona das raízes, e não logo embaixo da mangueira de rega. Se mudá-lo de lugar, calibre de novo.
- Não risque a máscara: forçar o sensor em solo duro risca a máscara de solda protetora, e o cobre exposto corrói também em um sensor capacitivo. Se precisar, faça antes um furo com um palito.
Ideias de projetos
- Rega automática de vasos: regue as suas plantas enquanto viaja com o código do Uno, um relé e uma mini bomba.
- Estufa inteligente: junte a umidade do solo com a temperatura e a umidade do ar em uma estufa inteligente que aciona um ventilador e uma bomba.
- Alerta no celular: faça o ESP32 mandar uma mensagem por um bot do Telegram quando o solo secar.
- Gráfico de umidade: registre as leituras no Google Sheets e veja em um gráfico quanto tempo a sua planta leva para secar.
- Display da planta: mostre a porcentagem de umidade como uma barra em um display OLED.
- Pular a rega quando chove: na rega do jardim, não acione a bomba quando um sensor de chuva detectar chuva.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| O valor nunca muda no ESP32 ou na Pico | A placa tem um NE555, e 3,3 V não bastam | Confira o chip; use uma placa com TLC555 ou troque o NE555 por um TLC555 |
| O valor leva minutos para ir de seco a molhado | O resistor de descarga de 1 MΩ não está ligado ao GND | Ligue a ponta solta do resistor ao GND com um fio fino |
| A leitura deriva devagar ao longo de algumas semanas | As bordas absorvem água ou a eletrônica se molha | Cubra as bordas e a parte de cima com verniz, epóxi ou termorretrátil e recalibre |
| A porcentagem fica abaixo de zero ou acima de 100 | Valores de calibração errados ou trocados | DRY_VALUE deve ser o valor seco (maior) e WET_VALUE o molhado (menor) |
| Os valores ficam pulando | Cabo longo, ruído ou terra fofa | Tire a média das leituras, mantenha o cabo curto e aperte a terra ao redor do sensor |
| O Arduino reinicia quando a bomba liga | A bomba é alimentada pela linha de 5V do Arduino | Alimente a bomba por uma fonte separada e ligue os GNDs |
| As leituras do ESP32 erram quando o Wi-Fi liga | O sensor está em um pino ADC2 | Passe o AOUT para um pino ADC1 entre o GPIO 32 e o 39 |
Se você escolher a placa certa e proteger as bordas, o sensor capacitivo de umidade do solo é a peça mais confiável de qualquer projeto de plantas ou jardim. Confira o chip primeiro, depois calibre na sua própria terra e regue com histerese, em doses curtas. No app BlueGrays você encontra uma estação de rega inteligente com Arduino, além de medição de temperatura e umidade, cada um com esquema de ligação passo a passo e código pronto.
Perguntas frequentes
Qual a diferença entre sensores de umidade do solo capacitivos e resistivos?
O sensor resistivo passa corrente entre duas hastes de metal nu enfiadas no solo, e a eletrólise corrói essas hastes em poucas semanas. O sensor capacitivo mede a capacitância do solo com eletrodos isolados, não passa corrente e não corrói. Ele também é bem menos afetado por adubo e sais.
O sensor capacitivo de umidade do solo funciona com 3,3 V?
As placas com chip TLC555 funcionam bem em 3,3 V e podem ser ligadas direto a um ESP32 ou a uma Pico. As cópias com NE555 precisam de pelo menos 4,5 V e, em 3,3 V, a saída não muda. Dá para saber qual é a sua pela marcação do chip de oito pinos da placa.
Como calibrar um sensor capacitivo de umidade do solo?
Segure o sensor no ar ou em solo totalmente seco e anote a leitura como valor seco; depois coloque-o na água ou em solo recém-regado e anote a leitura como valor molhado. A porcentagem é calculada com % = (seco − bruto) × 100 / (seco − molhado). Cada sensor dá valores diferentes, então calibre cada um.
Qual porcentagem de umidade o solo deve ter?
A porcentagem desse sensor é relativa aos próprios pontos de calibração. Para a maioria das plantas de vaso, 40–70 % é uma boa faixa; faz sentido regar quando cai abaixo de 25–30 % e parar acima de 80 %. Use um limite mais baixo para suculentas e cactos.
O sensor capacitivo de umidade do solo é à prova d'água?
A sonda sensora resiste à água, mas as bordas cortadas da placa e a eletrônica da parte de cima não. Cubra as bordas com verniz ou epóxi e a parte de cima com termorretrátil ou cola quente, e o sensor vai durar anos. Não o enfie além da linha marcada na placa.
Por que a leitura do meu sensor muda tão devagar?
Em algumas placas copiadas, o resistor de 1 MΩ da saída não está ligado ao GND, então o capacitor de saída não consegue descarregar. A mudança de seco para molhado passa a levar minutos. Ligar a ponta solta do resistor ao GND com um fio fino resolve o problema.
Projetos para montar depois desta leitura
Ver todos os projetos
Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Leitura da intensidade da luz com módulo LDR e ESP32
Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.
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

