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

¿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ística | Valor / Descripción |
|---|---|
| Modelo de datos | Árbol JSON (NoSQL), acceso por rutas |
| Conexión | HTTPS (TLS); conexión HTTP que se mantiene abierta para el stream |
| Plan gratuito Spark | 1 GB de almacenamiento, 10 GB de descarga al mes, 100 conexiones simultáneas |
| Latencia | Los cambios suelen llegar en menos de 1 segundo |
| Autenticación | Correo/contraseña, acceso anónimo, cuenta de Google y otros |
| Seguridad | Reglas de seguridad en JSON que se ejecutan en el servidor |
| Placas compatibles | ESP32 y ESP8266 (con biblioteca); Pico W (con API REST) |
Cómo crear el proyecto de Firebase paso a paso
- 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.
- En el menú de la izquierda ve a Build > Realtime Database y pulsa el botón Create Database.
- 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.
- 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.
- Entra en Build > Authentication, pulsa Get started y en la pestaña Sign-in method activa el proveedor Email/Password.
- 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.
- 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.
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
- 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.
- 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.
- 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.
- 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).
| Ajuste | Dónde se obtiene | Ejemplo |
|---|---|---|
| API_KEY | Project settings > General > Web API Key | Cadena de 39 caracteres que empieza por AIza |
| DATABASE_URL | Parte superior de la página de Realtime Database | https://nombre-de-tu-proyecto-default-rtdb.europe-west1.firebasedatabase.app |
| USER_EMAIL | Authentication > Users | [email protected] |
| USER_PASSWORD | La contraseña que pusiste al añadir el usuario | Mínimo 6 caracteres |
| WIFI_SSID / WIFI_PASSWORD | Ajustes de tu router | Solo red de 2,4 GHz (el ESP32 no admite 5 GHz) |
Circuito: conexión del DHT22 y el LED
| Conexión | ESP32 | Raspberry Pi Pico W |
|---|---|---|
| DHT22 VCC | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | GP15 |
| DHT22 GND | GND | GND |
| Ánodo del LED (con resistencia de 220 Ω) | GPIO 26 | GP14 |
| Cátodo del LED | GND | GND |
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.
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ón | Qué 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.
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.
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.
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?
| Criterio | Firebase Realtime Database | Google Sheets (Apps Script) |
|---|---|---|
| Dirección de los datos | Bidireccional: escritura, lectura y escucha instantánea | Normalmente unidireccional: del dispositivo a la hoja |
| Latencia | Los cambios suelen llegar en menos de 1 segundo | Cada petición puede tardar varios segundos |
| Control de dispositivos | LED, relé o servo al instante con stream | No es adecuado; requiere consultas continuas |
| Gráficas y análisis | Tienes que crear tu propia página web o app | Gráficas, fórmulas y exportación a Excel ya listas |
| Seguridad | Reglas detalladas por usuario | Cualquiera que conozca la dirección del script publicado puede escribir |
| Límites | Spark: 1 GB de almacenamiento, 10 GB de descarga al mes | Máximo 10 millones de celdas por archivo, cuotas de Apps Script |
| Configuración | Media: proyecto, autenticación, reglas | Fá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íntoma | Causa probable | Solución |
|---|---|---|
| Permission denied | Las reglas no permiten la petición o el modo de prueba ha caducado | Revisa la pestaña Rules; asegúrate de que la ruta empiece por /cihazlar/UID |
| EMAIL_NOT_FOUND, INVALID_PASSWORD o INVALID_LOGIN_CREDENTIALS | El usuario no existe o la contraseña es incorrecta | Comprueba el correo y la contraseña en la lista de Authentication > Users |
| OPERATION_NOT_ALLOWED | El proveedor Email/Password no está activado | Actívalo en la pestaña Sign-in method |
| API key not valid | La clave de API falta o está mal copiada | Vuelve a copiar la clave desde la página Project settings |
| token is not ready | Se envió una petición antes de completar el inicio de sesión | Comprueba Firebase.ready() antes de cada petición; verifica la conexión Wi-Fi |
| connection refused, send request failed | DATABASE_URL incorrecta, señal débil o red de 5 GHz | Copia la dirección exactamente de la consola; conéctate a una red de 2,4 GHz |
| El ESP32 se reinicia constantemente | Pico 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.h | Se instaló la biblioteca equivocada (por ejemplo FirebaseClient) | Instala la Firebase Arduino Client Library for ESP8266 and ESP32 de Mobizt |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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.

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

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

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

