ESP32 Firebase Anleitung: Sensordaten senden und LED steuern
ESP32 Firebase Realtime Database einrichten: Projekt anlegen, E-Mail-Login, DHT22-Daten schreiben, LED per Stream steuern und Pico-W-REST-Beispiel.
ESP32 und Firebase sind eine der schnellsten Kombinationen, um Sensordaten ins Internet zu bringen und dein Gerät von überall auf der Welt zu steuern. Die Realtime Database der Google-Plattform Firebase ist eine Cloud-Datenbank, die Daten als JSON-Baum speichert und jede Änderung meist in weniger als einer Sekunde an alle verbundenen Clients weitergibt. Der ESP32 schreibt Temperatur und Luftfeuchtigkeit dorthin, und eine Webseite oder App auf deinem Handy zeigt dieselben Daten sofort an. Es funktioniert auch umgekehrt: Setzt du in der Datenbank den Wert led auf true, leuchtet die am ESP32 angeschlossene LED sofort.
In dieser Anleitung legst du ein Firebase-Projekt von Grund auf an, aktivierst die Anmeldung per E-Mail und Passwort, schreibst die Sicherheitsregeln richtig und installierst die Bibliothek Firebase ESP Client in der Arduino IDE. Danach gehen wir Schritt für Schritt zwei Codes durch: einen, der die Daten des DHT22 alle 30 Sekunden in die Datenbank schreibt, und einen zweiten, der Änderungen per Stream abhört und die LED sofort schaltet. In den letzten Abschnitten machst du dasselbe mit dem Raspberry Pi Pico W in MicroPython über die REST-API, vergleichst Firebase mit Google Sheets und findest Lösungen für die häufigsten Fehlermeldungen. Bist du neu beim ESP32, wirf zuerst einen Blick auf Was ist der ESP32?.

Was ist die Firebase Realtime Database und wie funktioniert sie?
Anders als klassische SQL-Datenbanken mit Tabellen speichert die Realtime Database Daten in einem einzigen großen JSON-Baum. Jeder Wert wird über einen Pfad angesprochen; zum Beispiel kann der Pfad /cihazlar/UID/son/sicaklik eine Zahl enthalten und der Pfad /cihazlar/UID/led den Wert true oder false. Der ESP32 schreibt und liest diese Pfade über eine verschlüsselte HTTPS-Verbindung. Die eigentliche Stärke ist der Stream (Abhören): Das Gerät abonniert einen Pfad, die Verbindung bleibt offen, und sobald sich der Wert ändert, schickt der Server die neuen Daten von selbst. So brauchst du keine Schleife, die jede Sekunde nachfragt; Latenz und Datenverkehr sinken.
| Merkmal | Wert / Erklärung |
|---|---|
| Datenmodell | JSON-Baum (NoSQL), Zugriff über Pfade |
| Verbindung | HTTPS (TLS); für Streams eine offen bleibende HTTP-Verbindung |
| Kostenloser Spark-Tarif | 1 GB Speicher, 10 GB Download pro Monat, 100 gleichzeitige Verbindungen |
| Latenz | Änderungen kommen meist in unter 1 Sekunde an |
| Authentifizierung | E-Mail/Passwort, anonyme Anmeldung, Google-Konto und weitere |
| Sicherheit | JSON-Sicherheitsregeln, die auf dem Server laufen |
| Unterstützte Boards | ESP32 und ESP8266 (mit Bibliothek); Pico W (über REST-API) |
Firebase-Projekt Schritt für Schritt anlegen
- Melde dich mit deinem Google-Konto in der Firebase-Konsole an und klicke auf Create a project (Projekt erstellen). Gib dem Projekt einen Namen wie esp32-sera; Google Analytics brauchst du dafür nicht, du kannst es ausschalten.
- Gehe im linken Menü auf Build > Realtime Database und klicke auf Create Database.
- Wähle den Standort der Datenbank. Wenn du in Europa bist, bietet europe-west1 (Belgien) eine geringere Latenz; die Adresse hat dann die Form https://dein-projekt-default-rtdb.europe-west1.firebasedatabase.app. Bei einem US-Standort endet die Adresse auf -default-rtdb.firebaseio.com.
- Wähle als Sicherheitsmodus Locked mode; die Regeln schreibst du gleich selbst. Kopiere die Adresse oben auf der geöffneten Seite: Das ist dein Wert für DATABASE_URL.
- Öffne Build > Authentication, klicke auf Get started und aktiviere im Tab Sign-in method den Anbieter Email/Password.
- Lege im Tab Users mit Add user einen Benutzer für den ESP32 an (zum Beispiel [email protected] und ein Passwort mit mindestens 6 Zeichen). Notiere dir die User UID in der entstandenen Zeile.
- Öffne über das Zahnrad oben links Project settings > General und kopiere den Web API Key; das ist dein Wert für API_KEY.
Authentifizierung und Sicherheitsregeln
Der Web-API-Key ist für sich genommen kein geheimes Passwort; er sagt nur, zu welchem Firebase-Projekt eine Anfrage gehört. Den eigentlichen Schutz liefern die Sicherheitsregeln, die auf dem Firebase-Server laufen. Meldet sich der ESP32 mit E-Mail und Passwort an, gibt Firebase ihm ein ID-Token, das eine Stunde gültig ist; die Bibliothek erneuert das Token vor Ablauf automatisch. In den Regeln liefert der Ausdruck auth.uid die Kennung des Benutzers, der die Anfrage sendet. In der folgenden Tabelle siehst du drei Regeln, die du im Tab Realtime Database > Rules eintragen kannst, und ihre Bedeutung. Empfohlen ist die dritte: Jedes Gerät darf nur auf den Zweig unter seiner eigenen UID zugreifen, sodass die Daten der anderen Geräte sicher bleiben, selbst wenn das Passwort eines Geräts in falsche Hände gerät.
| Regel (Tab Rules) | Bedeutung |
|---|---|
| {"rules": {".read": true, ".write": true}} | Jeder darf lesen und schreiben. Nur für einen Test von ein paar Minuten; lass sie niemals offen. |
| {"rules": {".read": "auth != null", ".write": "auth != null"}} | Jeder angemeldete Benutzer hat Zugriff auf die gesamte Datenbank. Genügt für kleine Projekte mit nur einer Person. |
| {"rules": {"cihazlar": {"$uid": {".read": "$uid === auth.uid", ".write": "$uid === auth.uid"}}}} | Jeder Benutzer darf nur den Zweig /cihazlar/eigene-UID lesen und beschreiben. Die Codes in diesem Artikel sind auf diese Struktur ausgelegt. |
Bibliothek installieren und Einstellungen
- Stelle sicher, dass das ESP32-Boardpaket in der Arduino IDE installiert ist (Werkzeuge > Board > esp32). Die Codes in diesem Artikel laufen sowohl mit dem Core 2.x als auch mit 3.x.
- Suche im Bibliotheksverwalter nach Firebase ESP Client und installiere von Mobizt die Firebase Arduino Client Library for ESP8266 and ESP32. Die Codes nutzen die Schnittstelle Firebase_ESP_Client.h dieser Bibliothek; die neue Bibliothek FirebaseClient desselben Entwicklers hat eine andere Schnittstelle, verwechsle die beiden nicht.
- Installiere über denselben Verwalter die DHT sensor library von Adafruit; wenn nach der Abhängigkeit Adafruit Unified Sensor gefragt wird, installiere sie ebenfalls.
- Ersetze die sechs Einstellungen am Anfang des Codes (WLAN-Name und -Passwort, API-Key, Datenbankadresse, E-Mail und Passwort des Benutzers) durch deine eigenen Werte.
| Einstellung | Woher bekommst du sie? | Beispiel |
|---|---|---|
| API_KEY | Project settings > General > Web API Key | Eine 39 Zeichen lange Zeichenfolge, die mit AIza beginnt |
| DATABASE_URL | Oberer Bereich der Realtime-Database-Seite | https://dein-projekt-default-rtdb.europe-west1.firebasedatabase.app |
| USER_EMAIL | Authentication > Users | [email protected] |
| USER_PASSWORD | Das Passwort, das du beim Anlegen des Benutzers vergeben hast | Mindestens 6 Zeichen |
| WIFI_SSID / WIFI_PASSWORD | Einstellungen deines Routers | Nur 2,4-GHz-Netz (der ESP32 unterstützt kein 5 GHz) |
Schaltung: DHT22 und LED anschließen
| Anschluss | ESP32 | Raspberry Pi Pico W |
|---|---|---|
| DHT22 VCC | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | GP15 |
| DHT22 GND | GND | GND |
| LED-Anode (über 220-Ω-Widerstand) | GPIO 26 | GP14 |
| LED-Kathode | GND | GND |
Sensordaten in Firebase schreiben
Der folgende Code verbindet sich mit dem WLAN, meldet sich bei Firebase mit E-Mail und Passwort an und schreibt die DHT22-Messung alle 30 Sekunden an zwei Stellen: Der Knoten /cihazlar/UID/son enthält die letzte Messung, die jedes Mal überschrieben wird, und der Knoten /cihazlar/UID/kayit die per push hinzugefügten früheren Einträge. Die UID bekommst du nach der Anmeldung automatisch von der Bibliothek, du musst sie nicht von Hand eintragen.
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}| Zeile / Funktion | Aufgabe |
|---|---|
| Firebase.begin(&config, &auth) | Lädt die Einstellungen, meldet sich im Hintergrund an und holt das Token. |
| Firebase.ready() | Gibt true zurück, wenn das Token bereit und gültig ist; erneuert es, wenn es bald abläuft. Muss vor jeder Anfrage aufgerufen werden. |
| Firebase.RTDB.setJSON() | Ersetzt den Inhalt am angegebenen Pfad komplett durch das neue JSON. |
| Firebase.RTDB.pushJSON() | Fügt unter dem Pfad einen neuen, nach Zeit sortierten Eintrag mit eindeutigem Schlüssel hinzu. |
| json.set("zaman/.sv", "timestamp") | Schreibt die Serverzeit (Unix-Zeit in Millisekunden); am ESP32 ist keine Uhrzeiteinstellung nötig. |
| fbdo.errorReason() | Liefert bei einer fehlgeschlagenen Anfrage den Grund als Text. |
Jeder Eintrag belegt mit seinem Schlüssel etwa 100 Byte. Ein Eintrag alle 30 Sekunden bedeutet 2880 Einträge pro Tag und grob 0,3 MB; der 1 GB Speicher im kostenlosen Tarif ist damit auch nach Jahren nicht voll. Setzt du das Messintervall auf 1 Sekunde, sind es 86.400 Einträge pro Tag und rund 8,6 MB; außerdem verbraucht jeder Client, der diese Daten liest, etwas von deinem monatlichen Download-Kontingent von 10 GB. Deshalb ist es eine gute Angewohnheit, bei Live-Anzeigen nur den Knoten son zu lesen und den Verlauf nur beim Zeichnen eines Diagramms abzurufen.
LED aus der Datenbank steuern: sofortige Reaktion per Stream
Es gibt zwei Wege, die LED aus der Ferne zu steuern. Der erste ist, den Wert in loop alle paar Sekunden abzufragen; das ist einfach, aber jede Abfrage ist eine neue HTTPS-Anfrage, und die Reaktion verzögert sich um das Abfrageintervall. Der zweite ist der Stream: Der ESP32 abonniert den Pfad /cihazlar/UID/led einmal, die Verbindung bleibt offen, und sobald du den Wert in der Konsole änderst, kommt er beim ESP32 an. Der folgende Code nutzt diese Methode. Weil die Stream-Callback-Funktion beim ESP32 in einem eigenen Task läuft, schalten wir die LED nicht direkt dort, sondern über ein Flag in loop; so blockieren auch lange Vorgänge den Stream nicht.
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}Öffne nach dem Hochladen des Codes in der Firebase-Konsole die Seite Realtime Database, füge unter dem Knoten cihazlar in deiner eigenen UID einen Schlüssel namens led hinzu, wähle als Typ boolean und schreibe true. Wenn der Stream startet, sendet Firebase zuerst den aktuellen Wert am Pfad und danach jede Änderung; deshalb kehrt die LED auch nach einem Neustart des ESP32 in den zuletzt gespeicherten Zustand zurück. Wendest du dieselbe Struktur auf ein Relaismodul an, kannst du Lampe, Lüfter oder Wasserpumpe übers Internet ein- und ausschalten.
Firebase mit dem Raspberry Pi Pico W (MicroPython)
Für den Pico W gibt es keine so verbreitete Firebase-Bibliothek wie beim ESP32, aber du brauchst auch keine: Die Realtime Database stellt jeden Pfad auch als REST-Adresse bereit. Du hängst .json ans Ende des Pfads, schreibst mit PUT und liest mit GET. Zur Authentifizierung schickst du zuerst E-Mail und Passwort an den Anmeldedienst von Firebase und erhältst den idToken sowie die Benutzerkennung localId; danach hängst du das Token mit dem Parameter ?auth= an jede Anfrage. Weil das Token eine Stunde gültig ist, meldet sich der Code alle 50 Minuten neu an. Diese Methode ist nicht so schnell wie der Stream; der LED-Zustand wird in jedem 10-Sekunden-Durchlauf abgefragt. Für die WLAN-Einrichtung des Pico W siehe den Artikel Pico W WLAN-Webserver.
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 oder Google Sheets?
| Kriterium | Firebase Realtime Database | Google Sheets (Apps Script) |
|---|---|---|
| Datenrichtung | Beidseitig: Schreiben, Lesen und sofortiges Abhören | Meist einseitig: vom Gerät in die Tabelle |
| Latenz | Änderungen meist in unter 1 Sekunde | Jede Anfrage kann einige Sekunden dauern |
| Gerätesteuerung | LED, Relais, Servo sofort per Stream | Nicht geeignet; ständiges Abfragen nötig |
| Diagramme und Analyse | Du musst eine eigene Webseite oder App schreiben | Fertige Diagramme, Formeln, Export nach Excel |
| Sicherheit | Detaillierte Regeln pro Benutzer | Jeder, der die Adresse des öffentlich veröffentlichten Skripts kennt, kann schreiben |
| Grenzen | Spark: 1 GB Speicher, 10 GB Download pro Monat | Höchstens 10 Millionen Zellen pro Datei, Apps-Script-Kontingente |
| Einrichtung | Mittel: Projekt, Authentifizierung, Regeln | Einfach: eine Tabelle und ein kurzes Skript |
Kurz gesagt: Wenn du nur Messwerte speichern und ein Wochendiagramm zeichnen willst, ist ESP32 mit Google Sheets schneller eingerichtet, und du siehst deine Daten direkt in der Tabelle. Willst du ein Gerät aus der Ferne steuern, mehrere Geräte gleichzeitig überwachen oder eine Live-Anzeige mit mobiler App bauen, ist Firebase die bessere Wahl. Beide Methoden lassen sich auch kombinieren: den aktuellen Zustand in Firebase und die Tageszusammenfassung in Sheets halten. Wenn du ein Smart-Home-System anbinden willst, ist auch MQTT und Home Assistant eine starke Alternative.
Projektideen für ESP32 und Firebase
- Gewächshaus aus der Ferne überwachen: Schreibe Temperatur, Luftfeuchtigkeit und Bodenfeuchte in Firebase und schalte die Bewässerungspumpe über einen Schalter in der Datenbank.
- Smarte Steckdose: Steuere das Relais per Stream und speichere die Einschaltdauer in der Datenbank; Details findest du im Artikel ESP32 Smart Plug.
- Bewegungsprotokoll: Füge bei jeder Auslösung des PIR-Sensors per push einen Eintrag mit Zeitstempel hinzu und sieh dir den Verlauf auf dem Handy an.
- Wetterstation für mehrere Räume: Stelle in jeden Raum einen ESP32, der unter seiner eigenen UID schreibt, und beobachte alle live auf einer einzigen Webseite.
- Thermostat mit Fernsteuerung: Lies die Solltemperatur aus der Datenbank und regle die Heizung danach; für die Logik ist der Artikel Arduino-Thermostat ein guter Einstieg.
- Batteriebetriebener Sensor: Gehe nach dem Schreiben der Messung in den Deep Sleep, wache alle paar Minuten auf und sende den neuen Wert.
Häufige Fehler und ihre Lösungen
| Fehler / Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Permission denied | Die Regeln erlauben die Anfrage nicht oder der Testmodus ist abgelaufen | Prüfe den Tab Rules; achte darauf, dass der Pfad mit /cihazlar/UID beginnt |
| EMAIL_NOT_FOUND, INVALID_PASSWORD oder INVALID_LOGIN_CREDENTIALS | Benutzer existiert nicht oder Passwort ist falsch | Prüfe E-Mail und Passwort in der Liste unter Authentication > Users |
| OPERATION_NOT_ALLOWED | Der Anbieter Email/Password ist nicht aktiviert | Aktiviere ihn im Tab Sign-in method |
| API key not valid | API-Key fehlt oder wurde falsch kopiert | Kopiere den Key erneut von der Seite Project settings |
| token is not ready | Anfrage wurde gesendet, bevor die Anmeldung abgeschlossen war | Prüfe vor jeder Anfrage Firebase.ready(); kontrolliere die WLAN-Verbindung |
| connection refused, send request failed | Falsche DATABASE_URL, schwaches Signal oder 5-GHz-Netz | Kopiere die Adresse unverändert aus der Konsole; verbinde dich mit einem 2,4-GHz-Netz |
| ESP32 startet ständig neu | Stromspitze bei WLAN und TLS (Brownout) | Nutze ein gutes USB-Kabel und eine stabile Stromversorgung |
| Firebase_ESP_Client.h nicht gefunden | Falsche Bibliothek installiert (zum Beispiel FirebaseClient) | Installiere die Firebase Arduino Client Library for ESP8266 and ESP32 von Mobizt |
Ein einfacherer Weg: BlueGrays IoT
Firebase gibt dir volle Kontrolle über Datenbankstruktur und Sicherheitsregeln. Willst du aber nur ein Relais schalten oder einen Sensor vom Handy aus beobachten, musst du nicht von Hand ein Projekt anlegen, Realtime-Database-Regeln schreiben, einen Authentication-Benutzer anlegen und API-Schlüssel und DATABASE_URL in den Code kopieren. BlueGrays IoT in der BlueGrays-App startet mit fertigen Vorlagen unter Werkstatt › Meine Geräte › Neues Gerät hinzufügen: Ohmi bereitet den Code mit deinem Geräteschlüssel vor, du lädst ihn einmal mit der Bibliothek BlueGraysIoT aus der Arduino IDE hoch, und dann hast du Schalter, Live-Werte und Diagramme auf dem Handy. Es funktioniert mit dem ESP32 und dem Raspberry Pi Pico W über 2,4-GHz-WLAN, und dein erstes Gerät ist kostenlos; Details findest du in der Anleitung, einen ESP32 vom Handy aus zu steuern.
Mit Firebase misst dein ESP32 nicht mehr nur, sondern spricht übers Internet und nimmt Befehle entgegen. Starte zuerst das Beispiel zum Schreiben der Sensordaten, ergänze dann die LED-Steuerung per Stream und koppel die Regeln unbedingt an die Authentifizierung. In der BlueGrays-App findest du die Projekte ESP32-WLAN-Verbindung, NTP-Uhr, Webserver, WebSocket und DHT22-Temperaturlogger mit Schaltplänen und Code, auf die du die Firebase-Schicht aus diesem Artikel leicht aufsetzen kannst.
Häufige Fragen
Ist Firebase mit dem ESP32 kostenlos?
Ja, der kostenlose Spark-Tarif von Firebase bietet für die Realtime Database 1 GB Speicher, 10 GB Download pro Monat und 100 gleichzeitige Verbindungen. Hobbyprojekte, in denen ein paar ESP32 alle 30 Sekunden Daten schreiben, bleiben weit unter diesen Grenzen. Du kannst das Projekt auch ohne hinterlegte Kreditkarte anlegen.
Was ist der Unterschied zwischen Firebase Realtime Database und Firestore?
Die Realtime Database speichert Daten in einem einzigen JSON-Baum, ist einfach einzurichten, und das Live-Abhören per Stream ist in den ESP32-Bibliotheken ausgereift. Firestore nutzt Sammlungen und Dokumente, ist bei komplexen Abfragen stärker, begrenzt aber im kostenlosen Tarif die täglichen Lese- und Schreibzugriffe. Für Sensordaten und Gerätesteuerung ist die Realtime Database meist praktischer.
Warum verbindet sich mein ESP32 nicht mit Firebase?
Die häufigsten Ursachen sind eine falsch kopierte Datenbankadresse, nicht aktivierte Email/Password-Anmeldung, ein falscher API-Key und ein 5-GHz-WLAN. Bekommst du den Fehler Permission denied, erlauben deine Sicherheitsregeln die Anfrage nicht. Die Ausgabe von tokenStatusCallback im Seriellen Monitor zeigt dir, in welchem Schritt das Problem liegt.
Ist es sicher, den Firebase-API-Key im Code zu speichern?
Der Web-API-Key identifiziert nur das Projekt und gibt allein keinen Zugriff auf die Datenbank. Die eigentliche Sicherheit entsteht durch Authentifizierung und Sicherheitsregeln; enthalten deine Regeln auth != null oder eine UID-Prüfung, kann jemand, der den Key kennt, ohne Anmeldung keine Daten lesen. Entferne trotzdem WLAN- und Benutzerpasswort, wenn du den Code öffentlich teilst.
Wie oft kann der ESP32 Daten an Firebase senden?
Weil jede HTTPS-Anfrage je nach Verbindung einige hundert Millisekunden dauert, ist Schreiben im Sekundentakt technisch möglich. Für langsam veränderliche Werte wie die Temperatur schont ein Intervall von 10 Sekunden bis einigen Minuten aber Kontingent und Energie. Wo sofortige Reaktion nötig ist, ist ein Stream effizienter als Abfragen.
Läuft derselbe Code auch mit dem ESP8266 (NodeMCU)?
Die Bibliothek Firebase ESP Client unterstützt auch den ESP8266; du musst nur statt WiFi.h die Datei ESP8266WiFi.h einbinden. Da der ESP8266 weniger RAM hat, können TLS-Verbindungen den Speicher belasten; nutze deshalb nur ein FirebaseData-Objekt gleichzeitig und kombiniere Stream und Schreiben vorsichtig. Wenn du ein neues Projekt startest, ist der ESP32 die bequemere Wahl.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32: Echtzeit aus dem Internet per NTP
Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

ESP32 HTTPClient + Wetter-API (mit LCD-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

