Componentes · 10 min de leitura

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ísticaValor
Alimentação3,3–5,5 V (nas placas com TLC555)
SaídaAnalógica, cerca de 1,2–3,0 V; alta quando seco, baixa quando molhado
CorrenteCerca de 5 mA
ConectorPH2.0 de 3 pinos: GND, VCC, AOUT
TamanhoCerca de 98 × 23 mm
OsciladorTLC555 (CMOS), cerca de 1,5 MHz; NE555 nas cópias
ReguladorXC6206 marcado 662K, 3,3 V
EletrodosCobre 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.

Sensor resistivo de umidade do solo YL-69 e placa LM393
Sensor resistivo YL-69: as hastes de metal nu passam corrente pelo solo e se desgastam em semanas com alimentação contínua.
CaracterísticaResistivo (YL-69, FC-28)Capacitivo v1.2
Método de mediçãoResistência elétrica do soloCapacitância (constante dielétrica)
EletrodosMetal nu niqueladoCobre isolado pela máscara de solda
CorrosãoEm poucas semanas com alimentação contínuaNenhuma (a não ser que a máscara seja riscada)
Efeito de adubo e saisGrandePequeno
SaídaAO e DO (comparador LM393)Só analógica (AOUT)
Funciona em 3,3 VSimSó nas placas com TLC555
Vida útilMesesAnos, 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çãoPlaca boaPlaca com problemaSintoma
Chip 555TLC555 (CMOS)NE555 ou SA555Em 3,3 V a saída não muda ou fica fixa
ReguladorPequeno chip de 3 pinos marcado 662KFaltando ou em curtoEm 5 V a saída pode passar de 3 V
Resistor de saída de 1 MΩLigado ao GNDSem a ligação ao GNDResposta muito lenta, valor sempre alto
Bordas da placaCobertas com verniz ou epóxiFibra de vidro nuaAs leituras derivam em semanas
As entradas analógicas do ESP32 e da Raspberry Pi Pico não aguentam mais de 3,3 V. Nessas placas, alimente o sensor sempre com 3,3 V. Se você alimentar uma placa sem regulador com 5 V, a saída pode passar de 3,3 V e danificar a entrada; na dúvida, meça a saída com um multímetro antes de ligar. Se a tensão medida com o sensor no ar ficar abaixo de 3,3 V, a placa é segura.

Ligação: Arduino Uno, ESP32 e Raspberry Pi Pico

Pino do sensorArduino UnoESP32Raspberry Pi Pico
GND (preto)GNDGNDGND
VCC (vermelho)5VGPIO 25 (3,3 V só durante a medição)GP22 (3,3 V só durante a medição)
AOUT (amarelo)A0GPIO 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

  1. Carregue o código do Uno abaixo sem a bomba ligada e abra o Monitor Serial a 9600 baud.
  2. 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).
  3. Mergulhe o sensor em um copo de água sem passar da linha da placa e anote a leitura como WET_VALUE (geralmente 250–300).
  4. 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.
  5. 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)UmidadeEstado do soloO que fazer
590 ou mais0 %Ar ou solo totalmente secoConfira se o sensor está bem firme no solo
51025 %SecoHora de regar para a maioria das plantas
43050 %Levemente úmidoFaixa ideal; não precisa regar
35075 %ÚmidoSolo recém-regado
270 ou menos100 %Á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.

C++ (Arduino IDE)
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}
Mini bomba de água submersível
Mini bomba submersível de 3–6 V: alimentada por uma fonte separada por meio de um módulo relé ou de um MOSFET.

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.

C++ (Arduino IDE)
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.

MicroPython
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.
Depois de cobrir as bordas e a área sensora, os valores seco e molhado do sensor podem mudar algumas unidades. Recalibre quando a camada estiver totalmente seca e não coloque uma camada grossa na área sensora, porque isso reduz a sensibilidade.

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

SintomaCausa provávelSolução
O valor nunca muda no ESP32 ou na PicoA placa tem um NE555, e 3,3 V não bastamConfira o chip; use uma placa com TLC555 ou troque o NE555 por um TLC555
O valor leva minutos para ir de seco a molhadoO resistor de descarga de 1 MΩ não está ligado ao GNDLigue a ponta solta do resistor ao GND com um fio fino
A leitura deriva devagar ao longo de algumas semanasAs bordas absorvem água ou a eletrônica se molhaCubra 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 100Valores de calibração errados ou trocadosDRY_VALUE deve ser o valor seco (maior) e WET_VALUE o molhado (menor)
Os valores ficam pulandoCabo longo, ruído ou terra fofaTire a média das leituras, mantenha o cabo curto e aperte a terra ao redor do sensor
O Arduino reinicia quando a bomba ligaA bomba é alimentada pela linha de 5V do ArduinoAlimente a bomba por uma fonte separada e ligue os GNDs
As leituras do ESP32 erram quando o Wi-Fi ligaO sensor está em um pino ADC2Passe 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.

Ver todos os projetos
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Medição da intensidade da luz com LDR
AR-11Iniciante

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.

4.6(83)
143
Leitura da intensidade da luz com módulo LDR e ESP32
ES-11Iniciante

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.

4.6(36)
55
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

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.

4.5(19)
32