Guias · 11 min de leitura

ESP32 e Google Sheets: registre dados de sensores em uma planilha por Wi-Fi

Tutorial de ESP32 com Google Sheets: app da Web no Apps Script, adição de linhas com doPost, requisições HTTPS, marcações de data e hora, DHT22 + LDR, gráficos ao vivo, cotas e um token secreto.

Conectar um ESP32 ao Google Sheets é a maneira mais fácil de reunir dados de sensores em uma planilha gratuita que você pode acessar de qualquer lugar, sem manter seu próprio servidor. A cada minuto, o ESP32 lê a temperatura, a umidade e a luminosidade, envia os dados ao Google por Wi-Fi e uma nova linha aparece no Google Sheets. Abra a planilha no celular e você verá a leitura mais recente, sua marcação de data e hora e um gráfico que se atualiza sozinho. A ponte que torna isso possível é um pequeno app da Web escrito com o serviço gratuito Apps Script do Google.

Neste guia, você vai preparar a planilha, escrever o código do Apps Script que verifica os dados recebidos e adiciona uma linha, publicá-lo como app da Web e enviar dados do ESP32 por HTTPS. Depois, vamos abordar marcações de data e hora, vários sensores e dispositivos, criação de gráficos, limites de cotas do Google, códigos de erro e como manter a URL do app da Web em segredo. A última seção compara essa solução com alternativas como o ThingSpeak. Se você está começando com o ESP32, veja primeiro O que é ESP32?; você também pode ver como o ESP32 faz requisições HTTP no exemplo de API de previsão do tempo.

Placa de desenvolvimento ESP32
ESP32: graças ao Wi-Fi integrado, ele pode enviar requisições HTTPS diretamente ao Google, sem gateway ou computador no meio.

Como o ESP32 grava dados no Google Sheets?

O ESP32 não consegue gravar diretamente na planilha; a API do Google Sheets exige autenticação OAuth, que é trabalhosa para um pequeno microcontrolador. Em vez disso, você cria um projeto do Apps Script vinculado à planilha e o publica como app da Web. O Google fornece um endereço no formato script.google.com/macros/s/.../exec. Quando o ESP32 envia dados para esse endereço, o fluxo é o seguinte:

  1. O ESP32 lê os sensores e transforma os valores em um pequeno texto JSON.
  2. O JSON é enviado por HTTPS com uma requisição POST para o endereço /exec do app da Web.
  3. O Google encaminha a requisição para a função doPost(e), que é executada na sua conta; a função verifica o token secreto e adiciona uma linha com appendRow().
  4. O Google não responde imediatamente, mas retorna um redirecionamento 302; o ESP32 faz uma requisição GET para esse novo endereço para obter a resposta produzida pela sua função.
  5. Se o ESP32 encontrar "ok":true na resposta, o trabalho está concluído; caso contrário, ele espera um pouco e tenta novamente.

Passo 1: preparar o arquivo do Google Sheets

  1. Crie uma nova planilha no Google Drive e dê a ela um nome como “Registro do ESP32”.
  2. Renomeie a aba na parte inferior para Veri; o nome deve corresponder exatamente a SHEET_NAME no código, incluindo maiúsculas e minúsculas (renomeie os dois se preferir outro nome).
  3. Digite os cabeçalhos na primeira linha: Horário, Dispositivo, Temperatura, Umidade, Luminosidade. Você pode fixar a linha de cabeçalho em Ver > Congelar.
  4. Selecione as colunas não utilizadas de F a Z e exclua-as. Você verá por que isso importa na seção sobre cotas.
  5. Em Arquivo > Configurações, defina o fuso horário da sua região; as marcações de data e hora serão gravadas nesse fuso.

Passo 2: escrever doPost e doGet no Apps Script

Com a planilha aberta, selecione Extensões > Apps Script; será aberto um projeto vinculado à planilha. Apague tudo em Code.gs, cole o código abaixo e salve. Depois, abra Configurações do projeto pelo ícone de engrenagem à esquerda, adicione uma propriedade chamada TOKEN em Propriedades do script, na parte inferior, e atribua a ela um valor longo que ninguém consiga adivinhar. Manter a chave nas propriedades, em vez de no código, evita que ela vaze quando você compartilhar o código com alguém.

C++ (Arduino IDE)
1// Google Apps Script - ESP32 veri alıcı / ESP32 data receiver
2const SHEET_NAME = 'Veri';                      // sayfa (sekme) adı / sheet (tab) name
3
4function doPost(e) {
5  try {
6    const data = JSON.parse(e.postData.contents); // ESP32'nin gönderdiği JSON / JSON sent by the ESP32
7    return addRow(data);
8  } catch (err) {
9    return reply({ ok: false, error: 'json: ' + err });
10  }
11}
12
13function doGet(e) {
14  // Tarayıcı testi / browser test: .../exec?token=...&device=test&temp=21.5&hum=40&light=1200
15  return addRow(e.parameter);
16}
17
18function addRow(data) {
19  const token = PropertiesService.getScriptProperties().getProperty('TOKEN');
20  if (!token || data.token !== token) {
21    return reply({ ok: false, error: 'yetkisiz / unauthorized' });
22  }
23  const lock = LockService.getScriptLock();      // aynı anda gelen istekleri sıraya koy / queue simultaneous requests
24  lock.waitLock(10000);
25  try {
26    const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);
27    sheet.appendRow([
28      new Date(),                                // zaman damgası / timestamp
29      String(data.device || ''),
30      num(data.temp),
31      num(data.hum),
32      num(data.light)
33    ]);
34    return reply({ ok: true, row: sheet.getLastRow() });
35  } catch (err) {
36    return reply({ ok: false, error: String(err) });
37  } finally {
38    lock.releaseLock();
39  }
40}
41
42function num(v) {
43  const n = Number(v);                           // metni sayıya çevir / turn text into a number
44  return isFinite(n) ? n : '';
45}
46
47function reply(obj) {
48  return ContentService.createTextOutput(JSON.stringify(obj))
49    .setMimeType(ContentService.MimeType.JSON);
50}
ParteFinalidade
doPost(e)Trata a requisição POST do ESP32; o corpo está em e.postData.contents
doGet(e)Permite testar pelo navegador ou com uma requisição GET simples; os valores estão em e.parameter
PropertiesServiceMantém o valor de TOKEN fora do código, nas configurações do projeto
LockServiceImpede que as linhas sobrescrevam umas às outras quando dois dispositivos enviam dados ao mesmo tempo
appendRow([...])Adiciona uma nova linha abaixo da última linha preenchida da planilha
ContentServiceRetorna ao ESP32 uma pequena resposta JSON, como {"ok":true}

Passo 3: implantar como app da Web

  1. Clique em Implantar > Nova implantação no canto superior direito e selecione App da Web como tipo.
  2. Defina “Executar como” como Eu e “Quem pode acessar” como Qualquer pessoa; isso é necessário porque o ESP32 não consegue fazer login com uma conta do Google.
  3. Clique em Implantar; o Google pedirá permissão para acessar a planilha. Escolha sua conta, abra o projeto pelo link “Avançado” e permita o acesso.
  4. Copie a URL do app da Web terminada em /exec exibida na tela; você vai colá-la em SCRIPT_URL no código do ESP32.
Toda vez que alterar o código do Apps Script, você precisa publicar uma nova versão; apenas salvar não basta. Em Implantar > Gerenciar implantações, clique no ícone de lápis, escolha Nova versão em Versão e implante. Assim, a URL permanece a mesma. Se você escolher “Nova implantação”, o Google criará uma nova URL e o ESP32 continuará se comunicando com o código antigo; essa é a principal causa de “corrigi o código, mas nada mudou”.
Antes de passar para o ESP32, teste a configuração no navegador: adicione ?token=YOURKEY&device=test&temp=21.5&hum=40&light=1200 ao final da URL e abra-a. Você verá {"ok":true,"row":2} e encontrará a linha na planilha. Uma resposta “unauthorized” significa que a chave não corresponde, e uma página de login do Google significa que o acesso não está definido como “Qualquer pessoa”.

Passo 4: conectar o DHT22 e o LDR

Sensor de temperatura e umidade DHT22
DHT22: mede de -40 a 80 °C com precisão de ±0,5 °C e umidade com precisão de ±2–5%; conecta-se diretamente ao ESP32 com 3,3 V.
ComponenteConexãoPino do ESP32
DHT22VCC3V3
DHT22DATA (pull-up de 10 kΩ para 3V3 no sensor sem módulo)GPIO 4
DHT22GNDGND
LDRUm terminal em 3V3, o outro em GPIO 343V3 / GPIO 34
Resistor de 10 kΩEntre GPIO 34 e GNDGPIO 34 / GND

O LDR e o resistor de 10 kΩ formam um divisor de tensão: conforme a luminosidade aumenta, a resistência do LDR diminui e a tensão em GPIO 34 sobe. GPIO 34 foi escolhido de propósito; no ESP32, os pinos do ADC2 (GPIO 0, 2, 4, 12–15, 25–27) não conseguem fazer leituras analógicas enquanto o Wi-Fi está ligado, então sempre conecte os sensores analógicos aos pinos do ADC1, GPIO 32–39. O DHT22 é um sensor digital, por isso funciona normalmente em GPIO 4. Para saber mais sobre a família DHT, veja o guia de DHT11 e DHT22.

Passo 5: enviar a requisição HTTPS pelo ESP32

No Arduino IDE, instale a DHT sensor library (Adafruit) pelo Gerenciador de Bibliotecas e aceite a dependência Adafruit Unified Sensor se for solicitado. As bibliotecas WiFi, WiFiClientSecure e HTTPClient vêm com o pacote do ESP32. Substitua os dados do Wi-Fi, a URL do app da Web que você copiou e o valor de TOKEN pelos seus, carregue o sketch e abra o Monitor Serial a 115200 baud.

C++ (Arduino IDE)
1// ESP32 -> Google E-Tablolar veri kaydı / ESP32 -> Google Sheets data logger
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <HTTPClient.h>
5#include <DHT.h>   // "DHT sensor library" (Adafruit)
6
7const char* WIFI_SSID  = "AgAdi";      // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS  = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
9const char* SCRIPT_URL = "https://script.google.com/macros/s/BURAYA_DAGITIM_ID/exec"; // web uygulaması / web app
10const char* TOKEN      = "gizli-anahtar-123";  // Komut dosyası özelliğiyle aynı / same as the script property
11const char* DEVICE     = "salon";              // cihaz adı / device name
12
13const int DHT_PIN = 4;                         // DHT22 veri / data
14const int LDR_PIN = 34;                        // LDR bölücü, ADC1 / LDR divider, ADC1
15const unsigned long INTERVAL_MS = 60000;       // dakikada bir satır / one row per minute
16
17DHT dht(DHT_PIN, DHT22);
18unsigned long lastSend = 0;
19bool firstRun = true;
20
21void connectWiFi() {
22  if (WiFi.status() == WL_CONNECTED) return;
23  WiFi.mode(WIFI_STA);
24  WiFi.begin(WIFI_SSID, WIFI_PASS);
25  Serial.print("Wi-Fi");
26  for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) {  // en fazla 20 sn / 20 s max
27    delay(500);
28    Serial.print(".");
29  }
30  Serial.println(WiFi.status() == WL_CONNECTED ? " OK" : " HATA / FAIL");
31}
32
33bool sendRow(float temp, float hum, int light) {
34  WiFiClientSecure client;
35  client.setInsecure();                        // sertifika denetimi yok, yazıdaki nota bak / no cert check, see note
36  HTTPClient http;
37  http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);  // 302 yönlendirmesini GET ile izle / follow 302 with GET
38  http.setTimeout(15000);                      // Apps Script yavaş olabilir / Apps Script can be slow
39  if (!http.begin(client, SCRIPT_URL)) return false;
40  http.addHeader("Content-Type", "application/json");
41
42  char body[160];
43  snprintf(body, sizeof(body),
44           "{\"token\":\"%s\",\"device\":\"%s\",\"temp\":%.1f,\"hum\":%.1f,\"light\":%d}",
45           TOKEN, DEVICE, temp, hum, light);
46
47  int code = http.POST(body);                  // negatif = bağlantı hatası / negative = connection error
48  String reply = http.getString();
49  http.end();
50  Serial.printf("HTTP %d: %s\n", code, reply.c_str());
51  return code == 200 && reply.indexOf("\"ok\":true") >= 0;
52}
53
54void setup() {
55  Serial.begin(115200);
56  dht.begin();
57  connectWiFi();
58}
59
60void loop() {
61  if (!firstRun && millis() - lastSend < INTERVAL_MS) return;
62  firstRun = false;
63  lastSend = millis();
64
65  float t = dht.readTemperature();             // °C
66  float h = dht.readHumidity();                // %
67  int light = analogRead(LDR_PIN);             // 0-4095
68  if (isnan(t) || isnan(h)) {
69    Serial.println("DHT22 okunamadı / read failed");
70    return;
71  }
72
73  connectWiFi();
74  for (int attempt = 1; attempt <= 3; attempt++) {   // 3 deneme / 3 attempts
75    if (sendRow(t, h, light)) break;
76    delay(2000 * attempt);                           // giderek uzayan bekleme / growing back-off
77  }
78}
  • Sem setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS), o ESP32 para na resposta 302 do Google e nunca recebe a resposta real; a linha ainda é adicionada, mas você não consegue confirmar o sucesso.
  • client.setInsecure() criptografa a conexão, mas não verifica o certificado do servidor. Isso é aceitável para um projeto doméstico; para maior segurança, você pode adicionar o certificado raiz do Google com setCACert().
  • setTimeout(15000) é importante; o Apps Script às vezes leva de 2 a 5 segundos para responder, e o tempo limite padrão pode não ser suficiente.
  • Se o envio falhar, o código tenta novamente três vezes, esperando 2, 4 e 6 segundos; isso reduz a perda de dados quando a rede cai por um breve período.
  • O controle do tempo é feito com millis(), então o laço nunca bloqueia; você pode adicionar atualizações do display ou leitura de botões ao mesmo laço.

Marcações de data e hora, vários sensores e dispositivos

Gravar a marcação de data e hora no Apps Script com new Date() é a abordagem mais prática: o ESP32 não precisa saber o horário, e todos os dispositivos compartilham a mesma fonte de relógio. A única desvantagem é que a marcação indica quando os dados chegaram ao Google, e não o momento da medição; a diferença costuma ser de alguns segundos. Se você armazenar leituras em um buffer e enviá-las em lotes, obtenha o horário no ESP32 com NTP e adicione-o ao JSON como um campo ts. Para adicionar um novo sensor, basta atualizar três lugares: adicionar o campo ao texto JSON no ESP32, adicionar uma linha num(data.new) ao array de appendRow no Apps Script e escrever seu cabeçalho na planilha. Várias placas ESP32 podem gravar na mesma planilha; dê um nome DEVICE diferente a cada uma para filtrar as linhas por essa coluna ou abrir uma aba separada por dispositivo.

Criar um gráfico ao vivo no Google Sheets

  1. Selecione as colunas inteiras de A a D clicando nas letras das colunas, e não nos cabeçalhos (A:D); assim, as novas linhas entram no gráfico automaticamente.
  2. Abra Inserir > Gráfico e defina o tipo como Gráfico de linhas no editor de gráfico.
  3. Mantenha a coluna Horário como eixo X e Temperatura e Umidade como séries; remova a coluna Dispositivo das séries.
  4. Como o valor de luminosidade vai de 0 a 4095, ele achata as outras curvas; mostre-o em um gráfico separado ou no eixo direito, em Personalizar > Série.
  5. Usar Publicar gráfico no menu de três pontos no canto superior direito do gráfico fornece um link que mostra o gráfico sem abrir a planilha.

Cotas e limites: com que frequência você pode enviar dados?

LimiteValorO que significa na prática
Quantidade de células10 milhões de células por planilhaColunas vazias também contam; exclua as que você não usa
Execuções simultâneasCerca de 30 por usuárioMuitos dispositivos enviando dados no mesmo segundo podem receber erros
Tempo de execução6 minutos por chamadaSem problemas para appendRow
Tempo de respostaGeralmente de 1 a 5 segundosNão é adequado para várias leituras por segundo
Intervalo recomendado1 minuto ou maisMais do que suficiente para monitoramento doméstico e de estufas

Vamos tornar o limite de células concreto. Uma linha por minuto equivale a 1.440 linhas por dia. Se você mantiver apenas 5 colunas na planilha, usará 7.200 células por dia, e 10 milhões de células durarão cerca de 3,8 anos. Se não excluir as 26 colunas padrão de uma nova aba, cada linha contará como 26 células, e o mesmo limite será atingido em cerca de 9 meses. Para registros de longo prazo, criar uma nova aba a cada ano ou mover os dados antigos para um arquivo separado também mantém a planilha rápida; uma planilha com centenas de milhares de linhas demora para abrir no celular.

Tratamento de erros: o que significam os códigos HTTP?

No Monitor SerialSignificadoO que fazer
HTTP 200 + "ok":trueLinha adicionadaTudo certo
HTTP 200 + unauthorizedTOKEN não corresponde ou a propriedade não foi adicionadaCompare o código com as Propriedades do script
HTTP 302O redirecionamento não foi seguidoAdicione a linha setFollowRedirects
HTTP 401 / 403 ou uma página HTML de loginO acesso não está definido como “Qualquer pessoa”Edite a implantação e defina o acesso como Qualquer pessoa
HTTP 404URL incorreta ou implantação arquivadaCopie a URL atual terminada em /exec
Código negativo (-1, -11)Sem conexão ou tempo limite excedidoVerifique o sinal do Wi-Fi e o valor de setTimeout

Em um dispositivo que funciona por muito tempo, as interrupções da rede são inevitáveis. Para quedas curtas, o laço de três tentativas do código é suficiente. Se você não quiser perder dados durante interrupções que duram horas, armazene as leituras em um array ou em um arquivo na memória flash do ESP32 e envie-as em ordem quando a conexão voltar. Se não conseguir se conectar ao Wi-Fi de forma alguma, os passos de ESP32 não conecta ao Wi-Fi ajudarão você a encontrar a causa.

Manter a URL do app da Web em segredo

  • Como o acesso está definido como “Qualquer pessoa”, qualquer pessoa que conheça a URL pode adicionar linhas; sempre remova a URL e a chave antes de compartilhar seu código na internet.
  • Nunca publique sem a verificação de TOKEN; requisições sem a chave são rejeitadas sem alterar a planilha.
  • Se você colocar a senha do Wi-Fi, a URL e a chave em um arquivo secrets.h separado e incluí-lo no sketch com #include, será fácil deixar esse arquivo de fora ao compartilhar o código.
  • Se a URL vazar, arquive a implantação antiga em Gerenciar implantações, crie uma nova e altere o valor de TOKEN.
  • Você não precisa compartilhar a planilha com “qualquer pessoa com o link”; o app da Web é executado na sua conta, então a planilha pode permanecer privada.

ThingSpeak e outras alternativas

MétodoPonto fortePonto fraco
Google SheetsGrátis, interface familiar, facilidade para usar fórmulas e compartilharRespostas lentas, inadequado para enviar dados mais de uma vez por minuto
ThingSpeakGráficos prontos, análise com MATLAB, API HTTP simplesPelo menos 15 s entre atualizações no plano grátis, 8 campos por canal
MQTT + Home AssistantInstantâneo, bidirecional, integra-se à automação residencialExige um servidor sempre ligado em casa
BlynkInterface pronta para celular, notificaçõesO plano grátis limita os dispositivos e os dados
Cartão SDDispensa internet, registro muito rápidoVocê não consegue acessar os dados remotamente

Qual escolher? Se você quer editar os dados em uma planilha, processá-los com fórmulas ou compartilhá-los com alguém, o Google Sheets é imbatível. Se quiser apenas acompanhar gráficos, os painéis prontos do ThingSpeak exigem menos trabalho. Se você já tem um sistema de automação residencial, MQTT e Home Assistant são a opção mais flexível. Se preferir trabalhar com Excel no computador, veja o método com porta serial em enviar dados do Arduino para o Excel e, para locais sem internet, considere o registro em cartão SD.

Ideias de projetos com ESP32 e Google Sheets

  • Diário da estufa: grave temperatura, umidade e umidade do solo na planilha a cada 10 minutos e tome decisões de irrigação com base no histórico.
  • Estação externa alimentada por bateria: desperte o ESP32 do deep sleep a cada 15 minutos, envie a leitura e coloque-o para dormir novamente.
  • Contador de aberturas de porta e movimentos: registre cada abertura de porta ou detecção do PIR com uma marcação de data e hora e crie um gráfico dos totais diários.
  • Monitor de consumo de energia: envie a leitura de um sensor de corrente como uma média de um minuto e calcule os kWh com uma fórmula na planilha.
  • Experimento em sala de aula: deixe várias placas dos alunos gravarem na mesma planilha com nomes DEVICE diferentes e compare os resultados em conjunto.
Os números gravados na planilha não são afetados pela configuração regional: a função num() no Apps Script transforma o texto em um número real, então, mesmo em uma planilha configurada para usar vírgula decimal, 23.5 é armazenado como número decimal e aparece corretamente no gráfico. Se você enviar os valores como texto e gravá-los dessa forma, a confusão entre vírgula e ponto pode deixar o gráfico vazio.

Quando você aprende a gravar dados no Google Sheets, cada projeto com ESP32 se transforma em um pequeno dispositivo IoT com histórico de medições e gráfico. No app BlueGrays, você encontra projetos com ESP32, como conexão Wi-Fi, temperatura e umidade com DHT22, horário com NTP, previsão do tempo com HTTPClient e deep sleep, cada um com esquemas do circuito e códigos explicados passo a passo, para acrescentar a eles o registro no Google Sheets deste artigo.

Perguntas frequentes

Como enviar dados de um ESP32 para o Google Sheets?

Escreva uma função doPost em um projeto do Google Apps Script vinculado à planilha e publique-o como app da Web. O ESP32 usa WiFiClientSecure e HTTPClient para enviar uma requisição HTTPS POST com JSON para a URL /exec do app da Web, e a função adiciona uma nova linha com appendRow.

Preciso de uma chave de API do Google Sheets?

Com o método do app da Web do Apps Script, você não precisa de uma chave de API nem de configuração OAuth. O script é executado na sua conta e grava os dados na planilha. Para segurança, basta adicionar uma verificação de uma chave secreta (TOKEN) escolhida por você.

Por que o ESP32 recebe um erro 302 do Google Sheets?

O app da Web do Apps Script responde primeiro a uma requisição POST com um redirecionamento 302. O HTTPClient no ESP32 não segue redirecionamentos por padrão, por isso você vê o código 302. Adicionar http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) permite receber a resposta real.

Com que frequência posso enviar dados para o Google Sheets?

Cada requisição leva de 1 a 5 segundos e há um limite de execuções simultâneas, então é recomendado enviar uma vez por minuto ou com menor frequência. Uma planilha comporta até 10 milhões de células; uma linha de 5 colunas por minuto dura cerca de 3,8 anos. Se precisar de várias leituras por segundo, calcule a média delas no ESP32 e envie em lotes.

Alterei o código do Apps Script, mas o ESP32 ainda recebe o resultado antigo. Por quê?

Um app da Web executa a versão publicada, então salvar o código não basta. Em Implantar > Gerenciar implantações, edite a implantação existente e escolha Nova versão. Se você criar uma nova implantação, a URL mudará e será necessário atualizá-la também no ESP32.

ThingSpeak ou Google Sheets: qual é melhor?

Se você quer gráficos prontos e um painel IoT simples, o ThingSpeak é mais rápido de configurar, mas o plano grátis exige pelo menos 15 segundos entre atualizações e permite 8 campos por canal. Se você quer processar os dados com fórmulas, editá-los e compartilhá-los, o Google Sheets é mais flexível.

Ver todos os projetos
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

Conexão Wi-Fi STA com ESP32 e display LCD

Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

4.4(21)
38
ESP32 HTTPClient + API de clima (com display LCD)
ES-31Avançado
Premium

ESP32 HTTPClient + API de clima (com display LCD)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.

4.7(13)
20
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
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

Hora exata pela internet com ESP32 e NTP

O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

4.5(13)
22
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

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.

4.3(10)
16
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