Guia ESP32 com Firebase: grave dados de sensores e controle um LED
Configuração do ESP32 com o Firebase Realtime Database: crie o projeto, autentique por e-mail, grave dados do DHT22 e controle um LED com stream, além de um exemplo REST com o Pico W.
A dupla ESP32 e Firebase é um dos jeitos mais rápidos de levar dados de sensores para a internet e controlar seu dispositivo de qualquer lugar do mundo. O Realtime Database do Firebase, do Google, é um banco de dados na nuvem que guarda os dados como uma árvore JSON e envia cada alteração para todos os clientes conectados, normalmente em menos de um segundo. O ESP32 grava ali as leituras de temperatura e umidade, e uma página web ou um app no seu celular vê os mesmos dados na hora. O contrário também funciona: mude o valor led no banco de dados para true e o LED ligado ao ESP32 acende imediatamente.
Neste guia você vai criar um projeto no Firebase do zero, ativar a autenticação por e-mail e senha, escrever as regras de segurança corretamente e instalar a biblioteca Firebase ESP Client no Arduino IDE. Depois vamos ver, passo a passo, um código que grava os dados do sensor DHT22 no banco de dados a cada 30 segundos e um segundo exemplo que escuta as alterações do banco com um stream e acende o LED na hora. Nas seções finais você vai fazer o mesmo trabalho com um Raspberry Pi Pico W em MicroPython pela API REST, comparar o Firebase com o Google Sheets e reunir as soluções para as mensagens de erro mais comuns. Se você está começando com o ESP32, dê uma olhada primeiro em O que é o ESP32?.

O que é o Firebase Realtime Database e como ele funciona?
Diferente dos bancos de dados clássicos baseados em tabelas (SQL), o Realtime Database guarda os dados como uma grande árvore JSON. Cada dado é endereçado por um caminho (path); por exemplo, o caminho /cihazlar/UID/son/sicaklik pode guardar um número, e /cihazlar/UID/led pode guardar true ou false. O ESP32 grava e lê nesses caminhos por uma conexão HTTPS criptografada. A grande força dele é o recurso de stream (escuta): o dispositivo se inscreve em um caminho, a conexão fica aberta e, no instante em que o valor nesse caminho muda, o servidor envia o novo dado por conta própria. Você não precisa de um laço que faça consultas a cada segundo, então a latência e o tráfego de dados diminuem.
| Característica | Valor / descrição |
|---|---|
| Modelo de dados | Árvore JSON (NoSQL), acesso por caminho |
| Conexão | HTTPS (TLS); uma conexão HTTP que fica aberta para o stream |
| Plano Spark gratuito | 1 GB de armazenamento, 10 GB de download por mês, 100 conexões simultâneas |
| Latência | As alterações normalmente chegam em menos de 1 segundo |
| Autenticação | E-mail/senha, login anônimo, conta Google e outros |
| Segurança | Regras de segurança em JSON que rodam no servidor |
| Placas compatíveis | ESP32 e ESP8266 (com a biblioteca); Pico W (pela API REST) |
Criando um projeto no Firebase passo a passo
- Entre no console do Firebase com sua conta Google e clique em Create a project (Criar um projeto). Dê um nome como esp32-sera; o Google Analytics não é necessário para este projeto, então você pode desativá-lo.
- No menu à esquerda, vá em Build > Realtime Database e clique em Create Database.
- Escolha a localização do banco de dados. Se você está na Europa, europe-west1 (Bélgica) dá menor latência; nesse caso o endereço fica no formato https://seu-projeto-default-rtdb.europe-west1.firebasedatabase.app. Para uma localização nos EUA, o endereço termina com -default-rtdb.firebaseio.com.
- Escolha Locked mode como modo de segurança; você mesmo vai escrever as regras daqui a pouco. Copie o endereço no topo da página que se abre: esse é o seu DATABASE_URL.
- Vá em Build > Authentication, clique em Get started e ative o provedor Email/Password na aba Sign-in method.
- Na aba Users, crie um usuário para o ESP32 com Add user (por exemplo [email protected] e uma senha de pelo menos 6 caracteres). Anote o valor de User UID na nova linha.
- Clique no ícone de engrenagem no canto superior esquerdo, vá em Project settings > General e copie a Web API Key; esse é o seu API_KEY.
Autenticação e regras de segurança
A Web API Key, sozinha, não é uma senha secreta; ela só informa ao Firebase a qual projeto a requisição pertence. A proteção de verdade são as regras de segurança que rodam no servidor do Firebase. Quando o ESP32 faz login com e-mail e senha, o Firebase entrega a ele um ID token válido por uma hora; a biblioteca renova o token automaticamente antes que ele expire. Dentro das regras, a expressão auth.uid fornece a identidade do usuário que enviou a requisição. A tabela abaixo mostra três regras diferentes que você pode colocar na aba Realtime Database > Rules e o que elas significam. A estrutura recomendada é a terceira: cada dispositivo só acessa o ramo sob o próprio UID, então, mesmo que a senha de um dispositivo seja roubada, os dados dos outros dispositivos continuam seguros.
| Regra (aba Rules) | Significado |
|---|---|
| {"rules": {".read": true, ".write": true}} (acesso aberto a qualquer pessoa) | Qualquer pessoa lê e grava. Só para alguns minutos de teste; nunca deixe assim. |
| {"rules": {".read": "auth != null", ".write": "auth != null"}} (somente usuários autenticados) | Todo usuário logado acessa o banco inteiro. Suficiente para projetos pequenos de um único usuário. |
| {"rules": {"cihazlar": {"$uid": {".read": "$uid === auth.uid", ".write": "$uid === auth.uid"}}}} (cada usuário acessa apenas o próprio ramo) | Cada usuário só lê e grava no ramo /cihazlar/o-próprio-UID. O código deste post foi escrito para essa estrutura. |
Instalação da biblioteca e configurações
- Confira se o pacote de placas do ESP32 está instalado no Arduino IDE (Ferramentas > Placa > esp32). O código deste post funciona com as versões 2.x e 3.x do core.
- No Gerenciador de Bibliotecas, busque Firebase ESP Client e instale a Firebase Arduino Client Library for ESP8266 and ESP32, do Mobizt. O código usa a interface Firebase_ESP_Client.h dessa biblioteca; a biblioteca mais nova do mesmo desenvolvedor, chamada FirebaseClient, tem outra interface, então não misture as duas.
- No mesmo gerenciador, instale a DHT sensor library, da Adafruit; se ele perguntar sobre a dependência Adafruit Unified Sensor, adicione também.
- Substitua as seis configurações no início do código (nome e senha do Wi-Fi, chave de API, endereço do banco de dados, e-mail e senha do usuário) pelos seus próprios valores.
| Configuração | Onde encontrar | Exemplo |
|---|---|---|
| API_KEY | Project settings > General > Web API Key | Uma sequência de 39 caracteres que começa com AIza |
| DATABASE_URL | Topo da página do Realtime Database | https://seu-projeto-default-rtdb.europe-west1.firebasedatabase.app |
| USER_EMAIL | Authentication > Users | [email protected] |
| USER_PASSWORD | A senha que você definiu ao adicionar o usuário | Pelo menos 6 caracteres |
| WIFI_SSID / WIFI_PASSWORD | As configurações do seu roteador | Somente rede de 2,4 GHz (o ESP32 não suporta 5 GHz) |
Circuito: ligando o DHT22 e o LED
| Conexão | ESP32 | Raspberry Pi Pico W |
|---|---|---|
| DHT22 VCC | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | GP15 |
| DHT22 GND | GND | GND |
| Ânodo do LED (por um resistor de 220 Ω) | GPIO 26 | GP14 |
| Cátodo do LED | GND | GND |
Gravando dados do sensor no Firebase
O código abaixo se conecta ao Wi-Fi, faz login no Firebase com e-mail e senha e grava a leitura do DHT22 em dois lugares a cada 30 segundos: o nó /cihazlar/UID/son guarda a última leitura, sobrescrita a cada vez, enquanto o nó /cihazlar/UID/kayit guarda o histórico de registros adicionados com push. O UID é obtido automaticamente da biblioteca depois do login, então você não precisa digitá-lo.
1#include <WiFi.h>
2#include <Firebase_ESP_Client.h>
3#include "addons/TokenHelper.h" // token durumunu Seri Monitör'e yazar / prints token status to Serial
4#include <DHT.h>
5
6// Kendi bilgilerinle değiştir / Replace with your own values
7#define WIFI_SSID "WIFI_ADIN"
8#define WIFI_PASSWORD "WIFI_SIFREN"
9#define API_KEY "WEB_API_KEY"
10#define DATABASE_URL "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
11#define USER_EMAIL "[email protected]"
12#define USER_PASSWORD "sifre123"
13
14#define DHT_PIN 4
15
16DHT dht(DHT_PIN, DHT22);
17FirebaseData fbdo; // istek nesnesi / request object
18FirebaseAuth auth; // kullanıcı bilgisi / user credentials
19FirebaseConfig config; // proje ayarları / project settings
20
21unsigned long sonGonderim = 0;
22const unsigned long ARALIK = 30000; // 30 saniye / 30 seconds
23
24void setup() {
25 Serial.begin(115200);
26 dht.begin();
27
28 WiFi.mode(WIFI_STA);
29 WiFi.setAutoReconnect(true); // kopunca yeniden bağlan / reconnect on drop
30 WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
31 Serial.print("Wi-Fi baglaniyor");
32 while (WiFi.status() != WL_CONNECTED) {
33 delay(300);
34 Serial.print(".");
35 }
36 Serial.println();
37 Serial.print("IP: ");
38 Serial.println(WiFi.localIP());
39
40 config.api_key = API_KEY;
41 config.database_url = DATABASE_URL;
42 auth.user.email = USER_EMAIL;
43 auth.user.password = USER_PASSWORD;
44 config.token_status_callback = tokenStatusCallback; // giriş durumunu izle / watch sign-in status
45
46 Firebase.begin(&config, &auth); // arka planda giriş yapar / signs in in the background
47}
48
49void loop() {
50 if (!Firebase.ready()) return; // token hazır değil / token not ready
51 if (millis() - sonGonderim < ARALIK) return;
52 sonGonderim = millis();
53
54 float t = dht.readTemperature();
55 float h = dht.readHumidity();
56 if (isnan(t) || isnan(h)) {
57 Serial.println("DHT22 okunamadi / read failed");
58 return;
59 }
60
61 FirebaseJson json;
62 json.set("sicaklik", t);
63 json.set("nem", h);
64 json.set("zaman/.sv", "timestamp"); // sunucu saati / server timestamp
65
66 String kok = String("/cihazlar/") + auth.token.uid.c_str();
67 String yolSon = kok + "/son";
68 String yolKayit = kok + "/kayit";
69
70 if (Firebase.RTDB.setJSON(&fbdo, yolSon.c_str(), &json)) { // son ölçümü güncelle / update latest
71 Serial.printf("Yazildi: %.1f C, %.0f %%\n", t, h);
72 } else {
73 Serial.println(fbdo.errorReason());
74 }
75
76 if (!Firebase.RTDB.pushJSON(&fbdo, yolKayit.c_str(), &json)) { // geçmişe ekle / append to history
77 Serial.println(fbdo.errorReason());
78 }
79}| Linha / função | O que faz |
|---|---|
| Firebase.begin(&config, &auth) (inicialização) | Carrega as configurações, faz login em segundo plano e obtém um token. |
| Firebase.ready() (token pronto) | Retorna true se o token estiver pronto e válido; renova o token se ele estiver para expirar. Deve ser chamada antes de cada requisição. |
| Firebase.RTDB.setJSON() (substituir) | Substitui todo o conteúdo do caminho indicado pelo novo JSON. |
| Firebase.RTDB.pushJSON() (adicionar registro) | Adiciona sob o caminho um novo registro com chave única, ordenada por tempo. |
| json.set("zaman/.sv", "timestamp") (hora do servidor) | Grava a hora do próprio servidor (tempo Unix em milissegundos); não é preciso acertar o relógio no ESP32. |
| fbdo.errorReason() (motivo do erro) | Se a requisição falhar, informa o motivo do erro em texto. |
Cada registro, incluindo a chave, ocupa cerca de 100 bytes. Um registro a cada 30 segundos significa 2.880 registros por dia e aproximadamente 0,3 MB; nesse ritmo, o 1 GB de armazenamento do plano gratuito não enche nem em anos. Se você reduzir o intervalo para 1 segundo, são 86.400 registros por dia e cerca de 8,6 MB; além disso, todo cliente que lê esses dados consome sua cota mensal de 10 GB de download. Por isso, em painéis ao vivo, é um bom hábito ler só o nó da última leitura e buscar o histórico apenas na hora de desenhar um gráfico.
Controlando um LED pelo banco de dados: resposta instantânea com stream
Há dois jeitos de controlar um LED a distância. O primeiro é consultar o valor a cada poucos segundos dentro do loop; é simples, mas cada consulta é uma nova requisição HTTPS e a resposta atrasa até o tamanho do intervalo de consulta. O segundo é o stream: o ESP32 se inscreve uma vez no caminho /cihazlar/UID/led, a conexão fica aberta e, no instante em que você muda o valor no console, o novo valor chega ao ESP32. O código abaixo usa esse método. No ESP32, a função de callback do stream roda em uma tarefa (task) separada; por isso, em vez de mudar o LED diretamente ali, mudamos no loop por meio de uma flag. Isso também evita que operações demoradas travem o stream.
1#include <WiFi.h>
2#include <Firebase_ESP_Client.h>
3#include "addons/TokenHelper.h"
4
5// Kendi bilgilerinle değiştir / Replace with your own values
6#define WIFI_SSID "WIFI_ADIN"
7#define WIFI_PASSWORD "WIFI_SIFREN"
8#define API_KEY "WEB_API_KEY"
9#define DATABASE_URL "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
10#define USER_EMAIL "[email protected]"
11#define USER_PASSWORD "sifre123"
12
13#define LED_PIN 26
14
15FirebaseData stream; // yalnızca dinleme için / for listening only
16FirebaseAuth auth;
17FirebaseConfig config;
18
19volatile bool yeniVeri = false;
20volatile bool ledDurum = false;
21bool streamAcik = false;
22
23// Değer değişince çağrılır / Called when the value changes
24void streamCallback(FirebaseStream data) {
25 if (data.dataType() == "boolean") {
26 ledDurum = data.boolData();
27 yeniVeri = true;
28 } else if (data.dataType() == "int") {
29 ledDurum = (data.intData() != 0); // 1 ve 0 da kabul / 1 and 0 also accepted
30 yeniVeri = true;
31 }
32}
33
34// Bağlantı zaman aşımında çağrılır / Called on stream timeout
35void streamTimeoutCallback(bool timeout) {
36 if (timeout) Serial.println("Stream zaman asimi, devam ediliyor / timeout, resuming");
37 if (!stream.httpConnected()) Serial.println(stream.errorReason());
38}
39
40void setup() {
41 Serial.begin(115200);
42 pinMode(LED_PIN, OUTPUT);
43 digitalWrite(LED_PIN, LOW);
44
45 WiFi.mode(WIFI_STA);
46 WiFi.setAutoReconnect(true);
47 WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
48 while (WiFi.status() != WL_CONNECTED) {
49 delay(300);
50 Serial.print(".");
51 }
52 Serial.println();
53
54 config.api_key = API_KEY;
55 config.database_url = DATABASE_URL;
56 auth.user.email = USER_EMAIL;
57 auth.user.password = USER_PASSWORD;
58 config.token_status_callback = tokenStatusCallback;
59 Firebase.begin(&config, &auth);
60}
61
62void loop() {
63 // Giriş tamamlanınca stream'i bir kez başlat / Start the stream once after sign-in
64 if (Firebase.ready() && !streamAcik) {
65 String yol = String("/cihazlar/") + auth.token.uid.c_str() + "/led";
66 if (Firebase.RTDB.beginStream(&stream, yol.c_str())) {
67 Firebase.RTDB.setStreamCallback(&stream, streamCallback, streamTimeoutCallback);
68 streamAcik = true;
69 Serial.println("Dinleniyor / Listening: " + yol);
70 } else {
71 Serial.println(stream.errorReason());
72 delay(2000);
73 }
74 }
75
76 // Yeni değer geldiyse LED'i güncelle / Update the LED when new data arrives
77 if (yeniVeri) {
78 yeniVeri = false;
79 digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
80 Serial.println(ledDurum ? "LED ACIK / ON" : "LED KAPALI / OFF");
81 }
82}Depois de carregar o código, abra a página do Realtime Database no console do Firebase, adicione uma chave chamada led dentro do seu próprio UID, no nó cihazlar, escolha boolean como tipo do valor e coloque true. Quando o stream abre, o Firebase primeiro envia o valor que já existe no caminho e depois cada alteração; assim, mesmo que o ESP32 reinicie, o LED volta ao último estado salvo. Se você aplicar a mesma estrutura a um módulo relé, pode ligar e desligar uma lâmpada, uma ventoinha ou uma bomba d'água pela internet.
Firebase com o Raspberry Pi Pico W (MicroPython)
Para o Pico W não existe uma biblioteca de Firebase tão difundida quanto a do ESP32, mas você nem precisa dela: o Realtime Database também oferece cada caminho como um endereço REST. Você acrescenta .json ao final do caminho e grava com PUT ou lê com GET. Para a autenticação, primeiro você envia o e-mail e a senha ao serviço de login do Firebase para obter um idToken e o ID do usuário, localId; depois, adiciona o token a cada requisição com o parâmetro ?auth=. Como o token vale por uma hora, o código faz login de novo a cada 50 minutos. Esse método não é tão rápido quanto o stream; o estado do LED é consultado a cada ciclo de 10 segundos. Para configurar o Wi-Fi do Pico W, veja o post servidor web Wi-Fi com o Pico W.
1import network, time, urequests, dht
2from machine import Pin
3
4# Kendi bilgilerinle değiştir / Replace with your own values
5SSID = "WIFI_ADIN"
6SIFRE_WIFI = "WIFI_SIFREN"
7API_KEY = "WEB_API_KEY"
8DB_URL = "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
9EMAIL = "[email protected]"
10SIFRE = "sifre123"
11
12sensor = dht.DHT22(Pin(15))
13led = Pin(14, Pin.OUT)
14
15wlan = network.WLAN(network.STA_IF)
16wlan.active(True)
17wlan.connect(SSID, SIFRE_WIFI)
18while not wlan.isconnected(): # bağlantıyı bekle / wait for connection
19 time.sleep(0.5)
20print("IP:", wlan.ifconfig()[0])
21
22def giris():
23 # E-posta/şifre ile token al / Get a token with email/password
24 url = "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=" + API_KEY
25 r = urequests.post(url, json={"email": EMAIL, "password": SIFRE, "returnSecureToken": True})
26 cevap = r.json()
27 r.close()
28 return cevap["idToken"], cevap["localId"] # token ve UID / token and UID
29
30token, uid = giris()
31giris_zamani = time.time()
32
33while True:
34 try:
35 if time.time() - giris_zamani > 3000: # 50 dakikada bir yenile / refresh every 50 min
36 token, uid = giris()
37 giris_zamani = time.time()
38 kok = DB_URL + "/cihazlar/" + uid
39 sensor.measure()
40 veri = {"sicaklik": sensor.temperature(), "nem": sensor.humidity(),
41 "zaman": {".sv": "timestamp"}} # sunucu saati / server timestamp
42 r = urequests.put(kok + "/son.json?auth=" + token, json=veri)
43 r.close()
44 r = urequests.get(kok + "/led.json?auth=" + token)
45 durum = r.json() # true, false ya da None / true, false or None
46 r.close()
47 led.value(1 if durum else 0)
48 print(veri["sicaklik"], veri["nem"], "LED:", durum)
49 except Exception as e:
50 print("Hata / Error:", e)
51 time.sleep(10)Firebase ou Google Sheets?
| Critério | Firebase Realtime Database | Google Sheets (Apps Script) |
|---|---|---|
| Direção dos dados | Bidirecional: gravação, leitura e escuta instantânea | Geralmente unidirecional: do dispositivo para a planilha |
| Latência | Alterações normalmente em menos de 1 segundo | Cada requisição pode levar alguns segundos |
| Controle do dispositivo | LED, relé, servo na hora com stream | Não é adequado; exige consultas constantes |
| Gráficos e análise | Você precisa escrever sua própria página web ou app | Gráficos prontos, fórmulas, exportação para Excel |
| Segurança | Regras detalhadas por usuário | Qualquer pessoa que saiba o endereço do script publicado pode gravar |
| Limites | Spark: 1 GB de armazenamento, 10 GB de download por mês | Até 10 milhões de células por arquivo, cotas do Apps Script |
| Configuração | Média: projeto, autenticação, regras | Fácil: uma planilha e um script curto |
Resumindo: se o seu objetivo é só registrar leituras e desenhar um gráfico semanal, o método ESP32 com Google Sheets é mais rápido de configurar e você vê os dados direto na planilha. Se você quer controlar o dispositivo a distância, monitorar vários dispositivos ao mesmo tempo ou montar um painel ao vivo com um app no celular, o Firebase é a melhor escolha. Também dá para usar os dois juntos: o estado ao vivo no Firebase e o resumo diário no Sheets. Se você vai integrar com um sistema de automação residencial, MQTT e Home Assistant também é uma alternativa forte.
Ideias de projetos com ESP32 e Firebase
- Monitoramento remoto de estufa: grave os valores de temperatura, umidade e umidade do solo no Firebase e acione a bomba de irrigação com uma chave no banco de dados.
- Tomada inteligente: controle o relé com stream e registre no banco de dados quanto tempo ele fica ligado; veja os detalhes no post tomada inteligente com ESP32.
- Registro de movimento: cada vez que o sensor PIR disparar, adicione um registro com data e hora usando push e consulte o histórico pelo celular.
- Estação meteorológica para vários cômodos: coloque um ESP32 em cada cômodo da casa, cada um gravando sob o próprio UID, e acompanhe todos ao vivo em uma única página web.
- Termostato ajustável a distância: leia a temperatura alvo no banco de dados e controle o aquecedor de acordo com ela; o post termostato com Arduino é um bom ponto de partida para a lógica.
- Sensor alimentado por bateria: depois de gravar a leitura, entre no modo deep sleep e acorde a cada poucos minutos para enviar um novo valor.
Erros comuns e como resolver
| Erro / sintoma | Causa provável | Solução |
|---|---|---|
| Permission denied (permissão negada) | As regras não permitem a requisição, ou o modo de teste expirou | Confira a aba Rules; verifique se o caminho começa com /cihazlar/UID |
| EMAIL_NOT_FOUND, INVALID_PASSWORD ou INVALID_LOGIN_CREDENTIALS | O usuário não existe ou a senha está errada | Confira o e-mail e a senha na lista Authentication > Users |
| OPERATION_NOT_ALLOWED (operação não permitida) | O provedor Email/Password não está ativado | Ative-o na aba Sign-in method |
| API key not valid (chave de API inválida) | A chave de API está faltando ou foi copiada errada | Copie a chave de novo na página Project settings |
| token is not ready (token não está pronto) | Uma requisição foi enviada antes de o login terminar | Verifique Firebase.ready() antes de cada requisição; confira a conexão Wi-Fi |
| connection refused, send request failed (falha na conexão) | DATABASE_URL errado, sinal fraco ou rede de 5 GHz | Copie o endereço exatamente como está no console; conecte-se a uma rede de 2,4 GHz |
| O ESP32 fica reiniciando | Pico de corrente durante o Wi-Fi e o TLS (brownout) | Use um cabo USB de qualidade e uma fonte de alimentação forte |
| Firebase_ESP_Client.h não encontrado | A biblioteca errada está instalada (por exemplo FirebaseClient) | Instale a Firebase Arduino Client Library for ESP8266 and ESP32, do Mobizt |
Um caminho mais fácil: BlueGrays IoT
O Firebase dá a você controle total sobre a estrutura do banco de dados e as regras de segurança. Mas, se você só quer ligar e desligar um relé ou acompanhar um sensor pelo celular, não precisa criar um projeto, escrever regras do Realtime Database, adicionar um usuário no Authentication e copiar a chave de API e o DATABASE_URL para o código na mão. O BlueGrays IoT, no app BlueGrays, começa com modelos prontos em Minha oficina › Meus dispositivos › Adicionar novo dispositivo: o Ohmi prepara o código com a chave do seu dispositivo, você o carrega uma vez pelo Arduino IDE com a biblioteca BlueGraysIoT e, depois, tem chaves, valores ao vivo e gráficos no celular. Funciona com o ESP32 e o Raspberry Pi Pico W em Wi-Fi de 2,4 GHz, e o primeiro dispositivo é grátis; veja os detalhes no guia para controlar o ESP32 pelo celular.
Com o Firebase, seu ESP32 deixa de ser só um aparelho que mede: ele passa a conversar pela internet e a receber comandos. Rode primeiro o exemplo de gravação do sensor, depois adicione o controle do LED com stream e não deixe de vincular as regras à autenticação. No app BlueGrays você pode acompanhar passo a passo, com esquema do circuito e código, os projetos de conexão Wi-Fi do ESP32, relógio NTP, servidor web, WebSocket e registrador de temperatura com DHT22, e adicionar facilmente a camada de Firebase deste post em cima deles.
Perguntas frequentes
Usar o Firebase com o ESP32 é grátis?
Sim, o plano gratuito Spark do Firebase oferece para o Realtime Database 1 GB de armazenamento, 10 GB de download por mês e 100 conexões simultâneas. Projetos hobby em que alguns ESP32 gravam dados a cada 30 segundos ficam muito abaixo desses limites. Você pode criar um projeto sem cadastrar cartão de crédito.
Qual é a diferença entre o Firebase Realtime Database e o Firestore?
O Realtime Database guarda os dados em uma única árvore JSON, é simples de configurar e a escuta ao vivo com stream já está madura nas bibliotecas para ESP32. O Firestore usa coleções e documentos e é mais forte em consultas complexas, mas no plano gratuito o número diário de leituras e gravações é limitado. Para dados de sensores e controle de dispositivos, o Realtime Database costuma ser mais prático.
Por que meu ESP32 não se conecta ao Firebase?
As causas mais comuns são o endereço do banco de dados copiado errado, o login Email/Password não ativado, uma chave de API incorreta e uma rede Wi-Fi de 5 GHz. Se você recebe o erro Permission denied, suas regras de segurança não estão permitindo a requisição. Ler a saída da tokenStatusCallback no Monitor Serial mostra em qual etapa está o problema.
É seguro deixar a chave de API do Firebase no código?
A Web API Key só identifica o projeto e, sozinha, não dá acesso ao banco de dados. A segurança de verdade vem da autenticação e das regras de segurança; se as suas regras têm auth != null ou uma verificação de UID, quem conhece a chave não consegue ler dados sem fazer login. Mesmo assim, lembre-se de remover as senhas do Wi-Fi e do usuário quando compartilhar o código publicamente.
Com que frequência o ESP32 pode enviar dados ao Firebase?
Cada requisição HTTPS leva algumas centenas de milissegundos, dependendo da conexão, então tecnicamente é possível gravar uma vez por segundo. Para dados que mudam devagar, como a temperatura, um intervalo entre 10 segundos e alguns minutos protege tanto a sua cota quanto a energia. Em tarefas de controle que precisam de resposta instantânea, usar stream em vez de consultas é mais eficiente.
O mesmo código funciona com o ESP8266 (NodeMCU)?
A biblioteca Firebase ESP Client também suporta o ESP8266; basta incluir ESP8266WiFi.h em vez de WiFi.h. Como o ESP8266 tem menos RAM, as conexões TLS podem pesar na memória, então é melhor usar só um objeto FirebaseData por vez e combinar stream e gravação com cuidado. Se você vai começar um projeto novo, o ESP32 é a escolha mais confortável.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

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.

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.

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.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

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.

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

