Ratgeber · 10 Min. Lesezeit

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

ESP32-Entwicklungsboard für ein Firebase-Projekt
ESP32-Entwicklungsboard: Dank integriertem WLAN verbindet es sich ohne zusätzliches Modul mit der Firebase Realtime Database.

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.

MerkmalWert / Erklärung
DatenmodellJSON-Baum (NoSQL), Zugriff über Pfade
VerbindungHTTPS (TLS); für Streams eine offen bleibende HTTP-Verbindung
Kostenloser Spark-Tarif1 GB Speicher, 10 GB Download pro Monat, 100 gleichzeitige Verbindungen
LatenzÄnderungen kommen meist in unter 1 Sekunde an
AuthentifizierungE-Mail/Passwort, anonyme Anmeldung, Google-Konto und weitere
SicherheitJSON-Sicherheitsregeln, die auf dem Server laufen
Unterstützte BoardsESP32 und ESP8266 (mit Bibliothek); Pico W (über REST-API)

Firebase-Projekt Schritt für Schritt anlegen

  1. 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.
  2. Gehe im linken Menü auf Build > Realtime Database und klicke auf Create Database.
  3. 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.
  4. 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.
  5. Öffne Build > Authentication, klicke auf Get started und aktiviere im Tab Sign-in method den Anbieter Email/Password.
  6. 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.
  7. Öffne über das Zahnrad oben links Project settings > General und kopiere den Web API Key; das ist dein Wert für API_KEY.
Wenn du die Datenbank im Test mode anlegst, erlauben die Regeln 30 Tage lang jedem Lesen und Schreiben; danach werden alle Anfragen mit dem Fehler Permission denied abgelehnt, und dein Projekt hört eines Tages plötzlich auf zu funktionieren. Schlimmer noch: In diesen 30 Tagen kann jeder, der die Datenbankadresse kennt, deine Daten lesen oder löschen. Die sichere und dauerhafte Lösung ist, mit dem Locked mode zu starten und die Regeln an die Authentifizierung zu koppeln.

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

  1. 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.
  2. 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.
  3. Installiere über denselben Verwalter die DHT sensor library von Adafruit; wenn nach der Abhängigkeit Adafruit Unified Sensor gefragt wird, installiere sie ebenfalls.
  4. 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.
EinstellungWoher bekommst du sie?Beispiel
API_KEYProject settings > General > Web API KeyEine 39 Zeichen lange Zeichenfolge, die mit AIza beginnt
DATABASE_URLOberer Bereich der Realtime-Database-Seitehttps://dein-projekt-default-rtdb.europe-west1.firebasedatabase.app
USER_EMAILAuthentication > Users[email protected]
USER_PASSWORDDas Passwort, das du beim Anlegen des Benutzers vergeben hastMindestens 6 Zeichen
WIFI_SSID / WIFI_PASSWORDEinstellungen deines RoutersNur 2,4-GHz-Netz (der ESP32 unterstützt kein 5 GHz)

Schaltung: DHT22 und LED anschließen

AnschlussESP32Raspberry Pi Pico W
DHT22 VCC3V33V3(OUT)
DHT22 DATAGPIO 4GP15
DHT22 GNDGNDGND
LED-Anode (über 220-Ω-Widerstand)GPIO 26GP14
LED-KathodeGNDGND
Wenn du einen DHT22 ohne Modulplatine verwendest, musst du zwischen DATA und 3V3 einen 10-kΩ-Pull-up-Widerstand einfügen; bei Modulen sitzt dieser Widerstand schon auf der Platine. An einem 3,3-V-Ausgang liefern 220 Ω bei einer roten LED etwa 6 mA; für andere Farben kannst du den Wert mit dem LED-Widerstandsrechner prüfen. Wenn du dem Projekt einen analogen Sensor hinzufügst, denk daran, dass die ADC2-Pins des ESP32 (GPIO 0, 2, 4, 12–15, 25–27) bei aktivem WLAN nicht mit analogRead nutzbar sind; wähle für analoge Eingänge die ADC1-Pins (GPIO 32–39).

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.

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}
Zeile / FunktionAufgabe
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.

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}

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

Achte beim Eintragen des Werts in der Konsole auf den Typ: Schreibst du "true" in Anführungszeichen, ist das ein String, und der Code erkennt ihn nicht als boolean. Der Code akzeptiert auch Ganzzahlen wie 1 und 0. Wenn du Sensordaten schreiben und die LED abhören auf einem Board kombinierst, nutze zwei getrennte FirebaseData-Objekte: eines nur für den Stream, das andere für Schreibanfragen. Jede TLS-Verbindung braucht einige zehn KB RAM; für den ESP32 ist das kein Problem, aber erhöhe die Zahl der Objekte nicht unnötig.

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.

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 oder Google Sheets?

KriteriumFirebase Realtime DatabaseGoogle Sheets (Apps Script)
DatenrichtungBeidseitig: Schreiben, Lesen und sofortiges AbhörenMeist einseitig: vom Gerät in die Tabelle
LatenzÄnderungen meist in unter 1 SekundeJede Anfrage kann einige Sekunden dauern
GerätesteuerungLED, Relais, Servo sofort per StreamNicht geeignet; ständiges Abfragen nötig
Diagramme und AnalyseDu musst eine eigene Webseite oder App schreibenFertige Diagramme, Formeln, Export nach Excel
SicherheitDetaillierte Regeln pro BenutzerJeder, der die Adresse des öffentlich veröffentlichten Skripts kennt, kann schreiben
GrenzenSpark: 1 GB Speicher, 10 GB Download pro MonatHöchstens 10 Millionen Zellen pro Datei, Apps-Script-Kontingente
EinrichtungMittel: Projekt, Authentifizierung, RegelnEinfach: 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 / SymptomMögliche UrsacheLösung
Permission deniedDie Regeln erlauben die Anfrage nicht oder der Testmodus ist abgelaufenPrüfe den Tab Rules; achte darauf, dass der Pfad mit /cihazlar/UID beginnt
EMAIL_NOT_FOUND, INVALID_PASSWORD oder INVALID_LOGIN_CREDENTIALSBenutzer existiert nicht oder Passwort ist falschPrüfe E-Mail und Passwort in der Liste unter Authentication > Users
OPERATION_NOT_ALLOWEDDer Anbieter Email/Password ist nicht aktiviertAktiviere ihn im Tab Sign-in method
API key not validAPI-Key fehlt oder wurde falsch kopiertKopiere den Key erneut von der Seite Project settings
token is not readyAnfrage wurde gesendet, bevor die Anmeldung abgeschlossen warPrüfe vor jeder Anfrage Firebase.ready(); kontrolliere die WLAN-Verbindung
connection refused, send request failedFalsche DATABASE_URL, schwaches Signal oder 5-GHz-NetzKopiere die Adresse unverändert aus der Konsole; verbinde dich mit einem 2,4-GHz-Netz
ESP32 startet ständig neuStromspitze bei WLAN und TLS (Brownout)Nutze ein gutes USB-Kabel und eine stabile Stromversorgung
Firebase_ESP_Client.h nicht gefundenFalsche Bibliothek installiert (zum Beispiel FirebaseClient)Installiere die Firebase Arduino Client Library for ESP8266 and ESP32 von Mobizt
Öffne bei der Fehlersuche den Seriellen Monitor mit 115200 Baud: Die Funktion tokenStatusCallback gibt den Anmeldevorgang und die Fehlercodes Schritt für Schritt aus. Wenn sich das Board gar nicht mit dem WLAN verbindet, folge den Schritten in ESP32 verbindet sich nicht mit dem WLAN, und wenn es sich von selbst neu startet, denen in Brownout und Guru Meditation.

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.

Alle Projekte ansehen
LED Blinken mit ESP32
ES-1Anfänger

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.

4.7(37)
108
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
ESP32: Echtzeit aus dem Internet per NTP
ES-26Fortgeschritten
Premium

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.

4.5(13)
22
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

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.

4.8(16)
26
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

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.

4.5(14)
23
ESP32 HTTPClient + Wetter-API (mit LCD-Display)
ES-31Fortgeschritten
Premium

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.

4.7(13)
20
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12