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.

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:
- O ESP32 lê os sensores e transforma os valores em um pequeno texto JSON.
- O JSON é enviado por HTTPS com uma requisição POST para o endereço /exec do app da Web.
- 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().
- 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.
- 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
- Crie uma nova planilha no Google Drive e dê a ela um nome como “Registro do ESP32”.
- 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).
- Digite os cabeçalhos na primeira linha: Horário, Dispositivo, Temperatura, Umidade, Luminosidade. Você pode fixar a linha de cabeçalho em Ver > Congelar.
- Selecione as colunas não utilizadas de F a Z e exclua-as. Você verá por que isso importa na seção sobre cotas.
- 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.
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}| Parte | Finalidade |
|---|---|
| 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 |
| PropertiesService | Mantém o valor de TOKEN fora do código, nas configurações do projeto |
| LockService | Impede 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 |
| ContentService | Retorna ao ESP32 uma pequena resposta JSON, como {"ok":true} |
Passo 3: implantar como app da Web
- Clique em Implantar > Nova implantação no canto superior direito e selecione App da Web como tipo.
- 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.
- 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.
- 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.
Passo 4: conectar o DHT22 e o LDR

| Componente | Conexão | Pino do ESP32 |
|---|---|---|
| DHT22 | VCC | 3V3 |
| DHT22 | DATA (pull-up de 10 kΩ para 3V3 no sensor sem módulo) | GPIO 4 |
| DHT22 | GND | GND |
| LDR | Um terminal em 3V3, o outro em GPIO 34 | 3V3 / GPIO 34 |
| Resistor de 10 kΩ | Entre GPIO 34 e GND | GPIO 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.
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
- 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.
- Abra Inserir > Gráfico e defina o tipo como Gráfico de linhas no editor de gráfico.
- Mantenha a coluna Horário como eixo X e Temperatura e Umidade como séries; remova a coluna Dispositivo das séries.
- 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.
- 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?
| Limite | Valor | O que significa na prática |
|---|---|---|
| Quantidade de células | 10 milhões de células por planilha | Colunas vazias também contam; exclua as que você não usa |
| Execuções simultâneas | Cerca de 30 por usuário | Muitos dispositivos enviando dados no mesmo segundo podem receber erros |
| Tempo de execução | 6 minutos por chamada | Sem problemas para appendRow |
| Tempo de resposta | Geralmente de 1 a 5 segundos | Não é adequado para várias leituras por segundo |
| Intervalo recomendado | 1 minuto ou mais | Mais 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 Serial | Significado | O que fazer |
|---|---|---|
| HTTP 200 + "ok":true | Linha adicionada | Tudo certo |
| HTTP 200 + unauthorized | TOKEN não corresponde ou a propriedade não foi adicionada | Compare o código com as Propriedades do script |
| HTTP 302 | O redirecionamento não foi seguido | Adicione a linha setFollowRedirects |
| HTTP 401 / 403 ou uma página HTML de login | O acesso não está definido como “Qualquer pessoa” | Edite a implantação e defina o acesso como Qualquer pessoa |
| HTTP 404 | URL incorreta ou implantação arquivada | Copie a URL atual terminada em /exec |
| Código negativo (-1, -11) | Sem conexão ou tempo limite excedido | Verifique 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étodo | Ponto forte | Ponto fraco |
|---|---|---|
| Google Sheets | Grátis, interface familiar, facilidade para usar fórmulas e compartilhar | Respostas lentas, inadequado para enviar dados mais de uma vez por minuto |
| ThingSpeak | Gráficos prontos, análise com MATLAB, API HTTP simples | Pelo menos 15 s entre atualizações no plano grátis, 8 campos por canal |
| MQTT + Home Assistant | Instantâneo, bidirecional, integra-se à automação residencial | Exige um servidor sempre ligado em casa |
| Blynk | Interface pronta para celular, notificações | O plano grátis limita os dispositivos e os dados |
| Cartão SD | Dispensa internet, registro muito rápido | Você 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.
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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.

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.
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

