Guías · 11 min de lectura

ESP32 Firebase: Guardar Datos de Sensores y Controlar un LED

ESP32 con Firebase Realtime Database: crea el proyecto, autenticación por correo, guarda datos del DHT22, controla un LED con stream y ejemplo REST en Pico W.

La combinación ESP32 y Firebase es una de las formas más rápidas de llevar los datos de tus sensores a internet y de controlar tu dispositivo desde cualquier lugar. La Realtime Database de la plataforma Firebase de Google es una base de datos en la nube que guarda los datos como un árbol JSON y envía cada cambio a todos los clientes conectados, normalmente en menos de un segundo. El ESP32 escribe aquí la temperatura y la humedad; una página web o una app en tu móvil ve esos datos al instante. También funciona al revés: cuando pones el valor led de la base de datos en true, el LED conectado al ESP32 se enciende de inmediato.

En esta guía crearás el proyecto de Firebase desde cero, activarás la autenticación con correo y contraseña, escribirás bien las reglas de seguridad e instalarás la biblioteca Firebase ESP Client en el IDE de Arduino. Después veremos paso a paso el código que escribe los datos del sensor DHT22 cada 30 segundos y otro que escucha los cambios de la base de datos con stream para encender el LED al instante. En las últimas secciones harás lo mismo con la Raspberry Pi Pico W en MicroPython mediante la API REST, compararás Firebase con Google Sheets y reunirás las soluciones a los errores más comunes. Si empiezas con el ESP32, antes echa un vistazo a ¿Qué es el ESP32?.

Placa de desarrollo ESP32 para un proyecto de Firebase
Placa de desarrollo ESP32: gracias a su Wi-Fi integrado se conecta a Firebase Realtime Database sin módulos adicionales.

¿Qué es Firebase Realtime Database y cómo funciona?

A diferencia de las bases de datos clásicas con tablas (SQL), Realtime Database guarda los datos en un único gran árbol JSON. Cada dato se direcciona con una ruta (path); por ejemplo, la ruta /dispositivos/UID/ultimo/temperatura puede guardar un número y /dispositivos/UID/led puede guardar true o false. El ESP32 escribe y lee en esas rutas a través de una conexión HTTPS cifrada. Su gran fortaleza es el stream (escucha): el dispositivo se suscribe a una ruta, la conexión queda abierta y, en cuanto cambia el valor, el servidor envía el nuevo dato por sí solo. Así no necesitas un bucle que consulte cada segundo, y se reducen tanto la latencia como el tráfico de datos.

CaracterísticaValor / Descripción
Modelo de datosÁrbol JSON (NoSQL), acceso por rutas
ConexiónHTTPS (TLS); conexión HTTP que se mantiene abierta para el stream
Plan gratuito Spark1 GB de almacenamiento, 10 GB de descarga al mes, 100 conexiones simultáneas
LatenciaLos cambios suelen llegar en menos de 1 segundo
AutenticaciónCorreo/contraseña, acceso anónimo, cuenta de Google y otros
SeguridadReglas de seguridad en JSON que se ejecutan en el servidor
Placas compatiblesESP32 y ESP8266 (con biblioteca); Pico W (con API REST)

Cómo crear el proyecto de Firebase paso a paso

  1. Entra en la consola de Firebase con tu cuenta de Google y pulsa Create a project (Crear un proyecto). Ponle un nombre, por ejemplo esp32-invernadero; Google Analytics no es necesario para este proyecto, puedes desactivarlo.
  2. En el menú de la izquierda ve a Build > Realtime Database y pulsa el botón Create Database.
  3. Elige la ubicación de la base de datos. Si estás en Europa, europe-west1 (Bélgica) ofrece menor latencia; en ese caso la dirección tendrá el formato https://nombre-de-tu-proyecto-default-rtdb.europe-west1.firebasedatabase.app. Con la ubicación de EE. UU., la dirección termina en -default-rtdb.firebaseio.com.
  4. Como modo de seguridad elige Locked mode; las reglas las escribirás tú enseguida. Copia la dirección que aparece en la parte superior de la página: es tu valor DATABASE_URL.
  5. Entra en Build > Authentication, pulsa Get started y en la pestaña Sign-in method activa el proveedor Email/Password.
  6. En la pestaña Users, crea con Add user un usuario para el ESP32 (por ejemplo [email protected] y una contraseña de al menos 6 caracteres). Anota el valor User UID de la fila creada.
  7. Desde el icono de engranaje de arriba a la izquierda entra en Project settings > General y copia el valor Web API Key; ese es tu API_KEY.
Si abres la base de datos en Test mode, las reglas permiten leer y escribir a cualquiera durante 30 días; cuando se acaba el plazo, todas las peticiones se rechazan con el error Permission denied y un día el proyecto deja de funcionar de golpe. Peor aún, durante esos 30 días cualquiera que conozca la dirección de tu base de datos puede leer o borrar tus datos. Empezar con Locked mode y atar las reglas a la autenticación es la solución segura y duradera.

Autenticación y reglas de seguridad

La clave de API web por sí sola no es una contraseña secreta; solo indica a qué proyecto de Firebase pertenece la petición. La protección real son las reglas de seguridad que se ejecutan en el servidor de Firebase. Cuando el ESP32 inicia sesión con correo y contraseña, Firebase le entrega un ID token válido durante una hora; la biblioteca lo renueva sola antes de que caduque. Dentro de las reglas, la expresión auth.uid te da la identidad del usuario que envía la petición. En la tabla siguiente ves tres reglas distintas que puedes escribir en la pestaña Realtime Database > Rules y su significado. La estructura recomendada es la tercera: cada dispositivo solo accede a la rama bajo su propio UID, de modo que, aunque roben la contraseña de uno, los datos de los demás siguen a salvo.

Regla (pestaña Rules)Significado
{"rules": {".read": true, ".write": true}}Todo el mundo lee y escribe. Solo para pruebas de unos minutos; nunca la dejes abierta.
{"rules": {".read": "auth != null", ".write": "auth != null"}}Cualquier usuario que haya iniciado sesión accede a toda la base de datos. Suficiente para proyectos pequeños de una sola persona.
{"rules": {"cihazlar": {"$uid": {".read": "$uid === auth.uid", ".write": "$uid === auth.uid"}}}}Cada usuario solo puede leer y escribir la rama /cihazlar/su-UID. Los códigos de este artículo están preparados para esta estructura.

Instalación de la biblioteca y ajustes

  1. Asegúrate de tener instalado el paquete de placas ESP32 en el IDE de Arduino (Herramientas > Placa > esp32). Los códigos de este artículo funcionan tanto con la versión 2.x como con la 3.x del core.
  2. En el Gestor de bibliotecas busca Firebase ESP Client e instala la Firebase Arduino Client Library for ESP8266 and ESP32 de Mobizt. Los códigos usan la interfaz Firebase_ESP_Client.h de esta biblioteca; la nueva biblioteca del mismo desarrollador, llamada FirebaseClient, tiene una interfaz distinta, no las mezcles.
  3. Desde el mismo gestor instala la biblioteca DHT sensor library de Adafruit; si te pregunta por la dependencia Adafruit Unified Sensor, instálala también.
  4. Cambia por tus propios valores los seis ajustes del principio del código (nombre y contraseña del Wi-Fi, clave de API, dirección de la base de datos, correo y contraseña del usuario).
AjusteDónde se obtieneEjemplo
API_KEYProject settings > General > Web API KeyCadena de 39 caracteres que empieza por AIza
DATABASE_URLParte superior de la página de Realtime Databasehttps://nombre-de-tu-proyecto-default-rtdb.europe-west1.firebasedatabase.app
USER_EMAILAuthentication > Users[email protected]
USER_PASSWORDLa contraseña que pusiste al añadir el usuarioMínimo 6 caracteres
WIFI_SSID / WIFI_PASSWORDAjustes de tu routerSolo red de 2,4 GHz (el ESP32 no admite 5 GHz)

Circuito: conexión del DHT22 y el LED

ConexiónESP32Raspberry Pi Pico W
DHT22 VCC3V33V3(OUT)
DHT22 DATAGPIO 4GP15
DHT22 GNDGNDGND
Ánodo del LED (con resistencia de 220 Ω)GPIO 26GP14
Cátodo del LEDGNDGND
Si usas un sensor DHT22 sin módulo, debes añadir una resistencia pull-up de 10 kΩ entre DATA y 3V3; en las versiones en módulo esa resistencia ya está en la placa. Con una salida de 3,3 V, una resistencia de 220 Ω da unos 6 mA a un LED rojo; para otros colores puedes comprobar el valor con la calculadora de resistencia para LED. Si vas a añadir un sensor analógico al proyecto, recuerda que los pines ADC2 del ESP32 (GPIO 0, 2, 4, 12–15, 25–27) no se pueden usar con analogRead mientras el Wi-Fi está activo; para entradas analógicas elige los pines ADC1 (GPIO 32–39).

Escribir datos del sensor en Firebase

El código siguiente se conecta al Wi-Fi, inicia sesión en Firebase con correo y contraseña y escribe la medición del DHT22 cada 30 segundos en dos sitios: el nodo /cihazlar/UID/son guarda la última medición, que se sobrescribe cada vez, y el nodo /cihazlar/UID/kayit guarda el historial que se añade con push. El valor del UID se obtiene automáticamente de la biblioteca tras iniciar sesión; no tienes que escribirlo a mano.

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}
Línea / funciónQué hace
Firebase.begin(&config, &auth)Carga los ajustes, inicia sesión en segundo plano y obtiene el token.
Firebase.ready()Devuelve true si el token está listo y es válido; lo renueva si está a punto de caducar. Hay que llamarla antes de cada petición.
Firebase.RTDB.setJSON()Sustituye por completo el contenido de la ruta indicada con el nuevo JSON.
Firebase.RTDB.pushJSON()Añade bajo la ruta un registro nuevo con clave única, ordenado por tiempo.
json.set("zaman/.sv", "timestamp")Escribe la hora del propio servidor (tiempo Unix en milisegundos); el ESP32 no necesita ajustar el reloj.
fbdo.errorReason()Si la petición falla, devuelve el motivo del error como texto.

Cada registro, con su clave, ocupa unos 100 bytes. Un registro cada 30 segundos son 2880 registros al día y aproximadamente 0,3 MB; con ese ritmo el 1 GB de almacenamiento del plan gratuito no se llena en años. Si bajas el intervalo a 1 segundo, se generan 86 400 registros al día y unos 8,6 MB; además, cada cliente que lea esos datos gasta de tu cuota de descarga de 10 GB al mes. Por eso es buena costumbre leer solo el nodo son en los indicadores en vivo y traer el historial únicamente al dibujar gráficas.

Controlar un LED desde la base de datos: reacción inmediata con stream

Hay dos maneras de controlar el LED a distancia. La primera es consultar el valor cada pocos segundos dentro de loop; es sencilla, pero cada consulta es una nueva petición HTTPS y el tiempo de reacción se retrasa tanto como el intervalo. La segunda es el stream: el ESP32 se suscribe una vez a la ruta /cihazlar/UID/led, la conexión queda abierta y, en cuanto cambias el valor en la consola, el nuevo valor llega al ESP32. El código siguiente usa este método. Como en el ESP32 la función de callback del stream se ejecuta en una tarea aparte, no cambiamos el LED directamente ahí sino en loop mediante una bandera; esto también evita que operaciones largas bloqueen el 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}

Tras subir el código, abre la página de Realtime Database en la consola de Firebase, añade bajo el nodo cihazlar, dentro de tu propio UID, una clave llamada led, elige el tipo boolean y escribe true. Al abrirse el stream, Firebase envía primero el valor actual de la ruta y después cada cambio; por eso, aunque el ESP32 se reinicie, el LED vuelve al último estado guardado. Si aplicas la misma estructura a un módulo de relé, podrás encender y apagar una lámpara, un ventilador o una bomba de agua por internet.

Al escribir el valor en la consola, cuida el tipo: si escribes "true" entre comillas, será un string y el código no lo reconocerá como boolean. El código también acepta enteros como 1 y 0. Si vas a combinar en una sola placa la escritura del sensor y la escucha del LED, usa dos objetos FirebaseData distintos: uno solo para el stream y otro para las peticiones de escritura. Cada conexión TLS usa decenas de KB de RAM; para el ESP32 no es problema, pero no aumentes el número de objetos sin necesidad.

Firebase con Raspberry Pi Pico W (MicroPython)

Para la Pico W no hay una biblioteca de Firebase tan extendida como en el ESP32, pero tampoco hace falta: Realtime Database ofrece cada ruta también como una dirección REST. Añades .json al final de la ruta y escribes con PUT y lees con GET. Para autenticarte, primero envías el correo y la contraseña al servicio de acceso de Firebase y obtienes el idToken y el localId, que es el identificador del usuario; después añades el token a cada petición con el parámetro ?auth=. Como el token es válido durante una hora, el código vuelve a iniciar sesión cada 50 minutos. Este método no es tan rápido como el stream; el estado del LED se consulta en cada ciclo de 10 segundos. Para configurar el Wi-Fi de la Pico W puedes consultar el artículo Servidor web Wi-Fi con 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 o Google Sheets?

CriterioFirebase Realtime DatabaseGoogle Sheets (Apps Script)
Dirección de los datosBidireccional: escritura, lectura y escucha instantáneaNormalmente unidireccional: del dispositivo a la hoja
LatenciaLos cambios suelen llegar en menos de 1 segundoCada petición puede tardar varios segundos
Control de dispositivosLED, relé o servo al instante con streamNo es adecuado; requiere consultas continuas
Gráficas y análisisTienes que crear tu propia página web o appGráficas, fórmulas y exportación a Excel ya listas
SeguridadReglas detalladas por usuarioCualquiera que conozca la dirección del script publicado puede escribir
LímitesSpark: 1 GB de almacenamiento, 10 GB de descarga al mesMáximo 10 millones de celdas por archivo, cuotas de Apps Script
ConfiguraciónMedia: proyecto, autenticación, reglasFácil: una hoja y un script corto

En resumen, si solo quieres registrar mediciones y dibujar una gráfica semanal, el método de ESP32 con Google Sheets se monta más rápido y ves tus datos directamente en la hoja. Si quieres controlar el dispositivo a distancia, supervisar varios dispositivos a la vez o hacer un indicador en vivo con una app móvil, Firebase es la mejor opción. También se pueden usar juntos: el estado instantáneo en Firebase y el resumen diario en Sheets. Si vas a integrarlo en un sistema domótico, MQTT y Home Assistant también es una alternativa potente.

Ideas de proyectos con ESP32 y Firebase

  • Seguimiento remoto de un invernadero: escribe en Firebase la temperatura, la humedad y la humedad del suelo, y activa la bomba de riego con un interruptor de la base de datos.
  • Enchufe inteligente: controla el relé con stream y guarda en la base de datos el tiempo que ha estado encendido; para más detalles mira el artículo Enchufe inteligente con ESP32.
  • Registro de movimiento: cada vez que se active el sensor PIR, añade con push un registro con marca de tiempo y consulta el historial desde el móvil.
  • Estación meteorológica multihabitación: pon un ESP32 en cada habitación, cada uno escribiendo bajo su propio UID, y vigílalos todos en directo en una sola página web.
  • Termostato ajustable a distancia: lee la temperatura objetivo de la base de datos y gestiona la calefacción según ella; para la lógica, el artículo Termostato con Arduino es un buen punto de partida.
  • Sensor alimentado por batería: tras escribir la medición, pasa al modo deep sleep, despierta cada pocos minutos y envía el nuevo valor.

Errores comunes y cómo solucionarlos

Error / síntomaCausa probableSolución
Permission deniedLas reglas no permiten la petición o el modo de prueba ha caducadoRevisa la pestaña Rules; asegúrate de que la ruta empiece por /cihazlar/UID
EMAIL_NOT_FOUND, INVALID_PASSWORD o INVALID_LOGIN_CREDENTIALSEl usuario no existe o la contraseña es incorrectaComprueba el correo y la contraseña en la lista de Authentication > Users
OPERATION_NOT_ALLOWEDEl proveedor Email/Password no está activadoActívalo en la pestaña Sign-in method
API key not validLa clave de API falta o está mal copiadaVuelve a copiar la clave desde la página Project settings
token is not readySe envió una petición antes de completar el inicio de sesiónComprueba Firebase.ready() antes de cada petición; verifica la conexión Wi-Fi
connection refused, send request failedDATABASE_URL incorrecta, señal débil o red de 5 GHzCopia la dirección exactamente de la consola; conéctate a una red de 2,4 GHz
El ESP32 se reinicia constantementePico de corriente durante el Wi-Fi y TLS (brownout)Usa un cable USB de calidad y una alimentación potente
No se encuentra Firebase_ESP_Client.hSe instaló la biblioteca equivocada (por ejemplo FirebaseClient)Instala la Firebase Arduino Client Library for ESP8266 and ESP32 de Mobizt
Para buscar el problema, abre el Monitor serie a 115200 baudios: la función tokenStatusCallback imprime paso a paso el proceso de inicio de sesión y los códigos de error. Si la placa no consigue conectarse al Wi-Fi, sigue los pasos de El ESP32 no se conecta al Wi-Fi; si se resetea solo, los de brownout y Guru Meditation.

Una forma más fácil: BlueGrays IoT

Firebase te da control total sobre la estructura de la base de datos y las reglas de seguridad. Pero si solo quieres encender y apagar un relé o vigilar un sensor desde el móvil, no tienes por qué crear un proyecto, escribir las reglas de Realtime Database, añadir un usuario de Authentication y copiar a mano la clave de API y la DATABASE_URL en tu código. BlueGrays IoT, en la app BlueGrays, parte de plantillas listas en Mi Taller › Mis dispositivos › Añadir nuevo dispositivo: Ohmi prepara el código con la clave de tu dispositivo, tú lo subes una vez desde Arduino IDE con la librería BlueGraysIoT y después tienes interruptores, valores en directo y gráficos en tu móvil. Funciona con el ESP32 y la Raspberry Pi Pico W sobre Wi-Fi de 2,4 GHz, y tu primer dispositivo es gratis; para más detalles, mira la guía para controlar un ESP32 desde el móvil.

Con Firebase, tu ESP32 ya no solo mide: ahora habla por internet y recibe órdenes. Ejecuta primero el ejemplo de escritura del sensor, añade después el control del LED con stream y no olvides atar las reglas a la autenticación. En la app de BlueGrays encontrarás paso a paso, con esquemas de circuito y código, los proyectos de conexión Wi-Fi del ESP32, reloj NTP, servidor web, WebSocket y registrador de temperatura con DHT22, y podrás añadirles fácilmente la capa de Firebase de este artículo.

Preguntas frecuentes

¿Es gratis usar Firebase con el ESP32?

Sí, el plan gratuito Spark de Firebase ofrece para Realtime Database 1 GB de almacenamiento, 10 GB de descarga al mes y 100 conexiones simultáneas. Los proyectos de aficionado en los que unos pocos ESP32 escriben datos cada 30 segundos quedan muy por debajo de esos límites. Además, puedes crear el proyecto sin añadir una tarjeta de crédito.

¿Cuál es la diferencia entre Firebase Realtime Database y Firestore?

Realtime Database guarda los datos en un único árbol JSON, es sencilla de configurar y la escucha instantánea con stream está muy madura en las bibliotecas del ESP32. Firestore usa colecciones y documentos, es más potente en consultas complejas, pero en el plan gratuito limita las lecturas y escrituras diarias. Para datos de sensores y control de dispositivos, Realtime Database suele ser más práctica.

¿Por qué mi ESP32 no se conecta a Firebase?

Las causas más habituales son una dirección de base de datos mal copiada, el acceso Email/Password sin activar, una clave de API incorrecta y una red Wi-Fi de 5 GHz. Si te sale el error Permission denied, tus reglas de seguridad no permiten la petición. Leer la salida de tokenStatusCallback en el Monitor serie te indica en qué paso está el problema.

¿Es seguro guardar la clave de API de Firebase en el código?

La clave de API web solo identifica el proyecto, por sí sola no da permiso para acceder a la base de datos. La seguridad real la dan la autenticación y las reglas; si tus reglas incluyen auth != null o una comprobación del UID, quien conozca la clave no puede leer datos sin iniciar sesión. Aun así, al compartir el código públicamente, no olvides quitar las contraseñas del Wi-Fi y del usuario.

¿Con qué frecuencia puede el ESP32 enviar datos a Firebase?

Como cada petición HTTPS tarda unos cientos de milisegundos según la conexión, técnicamente se puede escribir cada segundo. Pero para datos que cambian despacio, como la temperatura, un intervalo de entre 10 segundos y unos minutos protege tanto la cuota como la energía. Para tareas de control que necesitan reacción inmediata, es más eficiente usar stream en lugar de consultas.

¿Funciona el mismo código con un ESP8266 (NodeMCU)?

La biblioteca Firebase ESP Client también es compatible con el ESP8266; solo tienes que incluir ESP8266WiFi.h en lugar de WiFi.h. Como el ESP8266 tiene menos RAM, las conexiones TLS pueden saturar la memoria, así que conviene usar un solo objeto FirebaseData a la vez y combinar con cuidado el stream y la escritura. Si empiezas un proyecto nuevo, el ESP32 es una opción más cómoda.

Ver todos los proyectos
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108
ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)

Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

4.8(38)
57
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

ESP32: hora real desde Internet con NTP

El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

4.5(13)
22
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)

En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

4.5(14)
23
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla LCD)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

4.7(13)
20
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12