Guias · 12 min de leitura

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

Placa de desenvolvimento ESP32 para um projeto com Firebase
Placa de desenvolvimento ESP32: graças ao Wi-Fi integrado, ela se conecta ao Firebase Realtime Database sem nenhum módulo extra.

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ísticaValor / descrição
Modelo de dadosÁrvore JSON (NoSQL), acesso por caminho
ConexãoHTTPS (TLS); uma conexão HTTP que fica aberta para o stream
Plano Spark gratuito1 GB de armazenamento, 10 GB de download por mês, 100 conexões simultâneas
LatênciaAs alterações normalmente chegam em menos de 1 segundo
AutenticaçãoE-mail/senha, login anônimo, conta Google e outros
SegurançaRegras de segurança em JSON que rodam no servidor
Placas compatíveisESP32 e ESP8266 (com a biblioteca); Pico W (pela API REST)

Criando um projeto no Firebase passo a passo

  1. 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.
  2. No menu à esquerda, vá em Build > Realtime Database e clique em Create Database.
  3. 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.
  4. 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.
  5. Vá em Build > Authentication, clique em Get started e ative o provedor Email/Password na aba Sign-in method.
  6. 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.
  7. 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.
Se você abrir o banco de dados em Test mode, as regras dão acesso de leitura e escrita a todo mundo por 30 dias; quando o prazo acaba, todas as requisições são rejeitadas com o erro Permission denied e seu projeto para de funcionar de repente. Pior ainda: durante esses 30 dias, qualquer pessoa que saiba o endereço do banco pode ler ou apagar seus dados. Começar em Locked mode e vincular as regras à autenticação é a solução segura e também a duradoura.

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

  1. 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.
  2. 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.
  3. No mesmo gerenciador, instale a DHT sensor library, da Adafruit; se ele perguntar sobre a dependência Adafruit Unified Sensor, adicione também.
  4. 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çãoOnde encontrarExemplo
API_KEYProject settings > General > Web API KeyUma sequência de 39 caracteres que começa com AIza
DATABASE_URLTopo da página do Realtime Databasehttps://seu-projeto-default-rtdb.europe-west1.firebasedatabase.app
USER_EMAILAuthentication > Users[email protected]
USER_PASSWORDA senha que você definiu ao adicionar o usuárioPelo menos 6 caracteres
WIFI_SSID / WIFI_PASSWORDAs configurações do seu roteadorSomente rede de 2,4 GHz (o ESP32 não suporta 5 GHz)

Circuito: ligando o DHT22 e o LED

ConexãoESP32Raspberry Pi Pico W
DHT22 VCC3V33V3(OUT)
DHT22 DATAGPIO 4GP15
DHT22 GNDGNDGND
Ânodo do LED (por um resistor de 220 Ω)GPIO 26GP14
Cátodo do LEDGNDGND
Se você usa o sensor DHT22 sem módulo, precisa colocar um resistor de pull-up de 10 kΩ entre DATA e 3V3; nas versões em módulo esse resistor já vem na placa. Numa saída de 3,3 V, 220 Ω dá cerca de 6 mA para um LED vermelho; para outras cores, confira o valor com a calculadora de resistor para LED. Se você pretende adicionar um sensor analógico ao projeto, lembre que os pinos ADC2 do ESP32 (GPIO 0, 2, 4, 12–15, 25–27) não podem ser usados com analogRead enquanto o Wi-Fi está ligado; escolha pinos ADC1 (GPIO 32–39) para as entradas analógicas.

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.

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

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

Atenção ao tipo ao digitar o valor no console: se você escrever "true" entre aspas, ele vira uma string e o código não o reconhece como boolean. O código também aceita inteiros como 1 e 0. Se você for juntar a gravação do sensor e a escuta do LED em uma única placa, use dois objetos FirebaseData separados: um só para o stream e outro para as requisições de gravação. Cada conexão TLS usa dezenas de KB de RAM; para o ESP32 isso não é problema, mas não aumente o número de objetos sem necessidade.

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.

MicroPython
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érioFirebase Realtime DatabaseGoogle Sheets (Apps Script)
Direção dos dadosBidirecional: gravação, leitura e escuta instantâneaGeralmente unidirecional: do dispositivo para a planilha
LatênciaAlterações normalmente em menos de 1 segundoCada requisição pode levar alguns segundos
Controle do dispositivoLED, relé, servo na hora com streamNão é adequado; exige consultas constantes
Gráficos e análiseVocê precisa escrever sua própria página web ou appGráficos prontos, fórmulas, exportação para Excel
SegurançaRegras detalhadas por usuárioQualquer pessoa que saiba o endereço do script publicado pode gravar
LimitesSpark: 1 GB de armazenamento, 10 GB de download por mêsAté 10 milhões de células por arquivo, cotas do Apps Script
ConfiguraçãoMédia: projeto, autenticação, regrasFá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 / sintomaCausa provávelSolução
Permission denied (permissão negada)As regras não permitem a requisição, ou o modo de teste expirouConfira a aba Rules; verifique se o caminho começa com /cihazlar/UID
EMAIL_NOT_FOUND, INVALID_PASSWORD ou INVALID_LOGIN_CREDENTIALSO usuário não existe ou a senha está erradaConfira 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á ativadoAtive-o na aba Sign-in method
API key not valid (chave de API inválida)A chave de API está faltando ou foi copiada erradaCopie 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 terminarVerifique 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 GHzCopie o endereço exatamente como está no console; conecte-se a uma rede de 2,4 GHz
O ESP32 fica reiniciandoPico 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 encontradoA biblioteca errada está instalada (por exemplo FirebaseClient)Instale a Firebase Arduino Client Library for ESP8266 and ESP32, do Mobizt
Ao procurar o problema, abra o Monitor Serial em 115200 baud: a função tokenStatusCallback mostra o processo de login e os códigos de erro passo a passo. Se a placa não consegue se conectar ao Wi-Fi de jeito nenhum, siga os passos de ESP32 não conecta ao Wi-Fi; se ela reinicia sozinha, veja brownout e Guru Meditation.

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.

Ver todos os projetos
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
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
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
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
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

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

4.5(14)
23
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
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