Ratgeber · 9 Min. Lesezeit

ESP32 Google Sheets: Sensordaten per WLAN in Tabellen speichern

ESP32 Google Sheets Anleitung: Apps-Script-Web-App, Zeilen per doPost anhängen, HTTPS-Anfrage, Zeitstempel, DHT22 + LDR, Diagramm, Kontingente, geheimer Token.

Die Verbindung von ESP32 und Google Sheets ist der einfachste Weg, Sensordaten ohne eigenen Server in einer kostenlosen Tabelle zu sammeln, auf die du von überall zugreifen kannst. Der ESP32 misst jede Minute Temperatur, Luftfeuchtigkeit und Helligkeit, schickt die Werte per WLAN an Google, und in Google Sheets erscheint eine neue Zeile. Öffnest du die Tabelle auf dem Handy, siehst du den letzten Messwert, seinen Zeitstempel und ein Diagramm, das sich selbst aktualisiert. Die Brücke dafür ist eine kleine Web-App, die du mit dem kostenlosen Google-Dienst Apps Script schreibst.

In dieser Anleitung bereitest du die Tabelle vor, schreibst den Apps-Script-Code, der eingehende Daten prüft und eine Zeile anhängt, veröffentlichst ihn als Web-App und schickst die Daten per HTTPS vom ESP32. Danach geht es um Zeitstempel, mehrere Sensoren und Geräte, Diagramme, Googles Kontingente, Fehlercodes und darum, die Web-App-URL geheim zu halten. Zum Schluss findest du einen Vergleich mit Alternativen wie ThingSpeak. Bist du neu beim ESP32, lies zuerst Was ist der ESP32?; wie der ESP32 HTTP-Anfragen sendet, zeigt auch das Beispiel mit der Wetter-API.

ESP32-Entwicklungsboard
ESP32: Dank eingebautem WLAN schickt er HTTPS-Anfragen direkt an Google, ganz ohne Gateway oder Computer dazwischen.

Wie schreibt der ESP32 Daten in Google Sheets?

Der ESP32 kann nicht direkt in die Tabelle schreiben; die Sheets-API von Google verlangt eine OAuth-Anmeldung, die für einen kleinen Mikrocontroller umständlich ist. Stattdessen schreibst du ein an die Tabelle gebundenes Apps-Script-Projekt und veröffentlichst es als Web-App. Google gibt dir eine Adresse der Form script.google.com/macros/s/.../exec. Schickt der ESP32 Daten an diese Adresse, läuft Folgendes ab:

  1. Der ESP32 liest die Sensoren und packt die Werte in einen kurzen JSON-Text.
  2. Das JSON geht per HTTPS als POST-Anfrage an die /exec-Adresse der Web-App.
  3. Google übergibt die Anfrage an die Funktion doPost(e), die mit deinem Konto läuft; sie prüft den geheimen Token und hängt mit appendRow() eine Zeile an.
  4. Google antwortet nicht sofort, sondern mit einer 302-Weiterleitung; der ESP32 ruft die neue Adresse per GET ab und erhält so die Antwort deiner Funktion.
  5. Steht "ok":true in der Antwort, ist die Sache erledigt; sonst wartet der ESP32 kurz und versucht es erneut.

Schritt 1: Die Google-Sheets-Datei vorbereiten

  1. Lege in Google Drive eine neue Tabelle an und nenne sie zum Beispiel "ESP32 Log".
  2. Benenne das Tabellenblatt unten in Veri um; der Name muss exakt zu SHEET_NAME im Code passen, inklusive Groß- und Kleinschreibung (oder ändere beide).
  3. Schreib die Überschriften in die erste Zeile: Zeit, Gerät, Temperatur, Feuchte, Licht. Mit Ansicht > Fixieren bleibt die Kopfzeile stehen.
  4. Markiere die ungenutzten Spalten F bis Z und lösche sie. Warum das wichtig ist, siehst du im Abschnitt über Kontingente.
  5. Stelle unter Datei > Einstellungen die Zeitzone auf deine Region ein; die Zeitstempel werden in dieser Zone geschrieben.

Schritt 2: doPost und doGet in Apps Script schreiben

Öffne bei geöffneter Tabelle Erweiterungen > Apps Script; es startet ein an die Tabelle gebundenes Projekt. Lösche alles in Code.gs, füge den folgenden Code ein und speichere. Öffne dann über das Zahnrad links die Projekteinstellungen, füge unten unter Skripteigenschaften eine Eigenschaft namens TOKEN hinzu und gib ihr einen langen Wert, den niemand erraten kann. Steht der Schlüssel in den Eigenschaften statt im Code, gelangt er nicht nach außen, wenn du den Code teilst.

C++ (Arduino IDE)
1// Google Apps Script - ESP32 veri alıcı / ESP32 data receiver
2const SHEET_NAME = 'Veri';                      // sayfa (sekme) adı / sheet (tab) name
3
4function doPost(e) {
5  try {
6    const data = JSON.parse(e.postData.contents); // ESP32'nin gönderdiği JSON / JSON sent by the ESP32
7    return addRow(data);
8  } catch (err) {
9    return reply({ ok: false, error: 'json: ' + err });
10  }
11}
12
13function doGet(e) {
14  // Tarayıcı testi / browser test: .../exec?token=...&device=test&temp=21.5&hum=40&light=1200
15  return addRow(e.parameter);
16}
17
18function addRow(data) {
19  const token = PropertiesService.getScriptProperties().getProperty('TOKEN');
20  if (!token || data.token !== token) {
21    return reply({ ok: false, error: 'yetkisiz / unauthorized' });
22  }
23  const lock = LockService.getScriptLock();      // aynı anda gelen istekleri sıraya koy / queue simultaneous requests
24  lock.waitLock(10000);
25  try {
26    const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);
27    sheet.appendRow([
28      new Date(),                                // zaman damgası / timestamp
29      String(data.device || ''),
30      num(data.temp),
31      num(data.hum),
32      num(data.light)
33    ]);
34    return reply({ ok: true, row: sheet.getLastRow() });
35  } catch (err) {
36    return reply({ ok: false, error: String(err) });
37  } finally {
38    lock.releaseLock();
39  }
40}
41
42function num(v) {
43  const n = Number(v);                           // metni sayıya çevir / turn text into a number
44  return isFinite(n) ? n : '';
45}
46
47function reply(obj) {
48  return ContentService.createTextOutput(JSON.stringify(obj))
49    .setMimeType(ContentService.MimeType.JSON);
50}
TeilAufgabe
doPost(e)Nimmt die POST-Anfrage des ESP32 an; der Inhalt steht in e.postData.contents
doGet(e)Erlaubt Tests im Browser oder per einfacher GET-Anfrage; die Werte stehen in e.parameter
PropertiesServiceSpeichert den TOKEN außerhalb des Codes in den Projekteinstellungen
LockServiceVerhindert, dass sich Zeilen überschreiben, wenn zwei Geräte gleichzeitig senden
appendRow([...])Hängt unter der letzten gefüllten Zeile eine neue Zeile an
ContentServiceGibt dem ESP32 eine kleine JSON-Antwort wie {"ok":true} zurück

Schritt 3: Als Web-App bereitstellen

  1. Klicke oben rechts auf Bereitstellen > Neue Bereitstellung und wähle als Typ Web-App.
  2. Stelle "Ausführen als" auf Ich und "Zugriff" auf Jeder; das ist nötig, weil sich der ESP32 nicht mit einem Google-Konto anmelden kann.
  3. Klicke auf Bereitstellen; Google fragt nach der Berechtigung für die Tabelle. Wähle dein Konto, öffne das Projekt über "Erweitert" und erlaube den Zugriff.
  4. Kopiere die angezeigte Web-App-URL, die auf /exec endet; sie kommt im ESP32-Code in die Variable SCRIPT_URL.
Nach jeder Änderung am Apps-Script-Code musst du eine neue Version veröffentlichen; Speichern allein reicht nicht. Klicke unter Bereitstellen > Bereitstellungen verwalten auf den Stift, wähle bei Version Neue Version und stelle bereit. So bleibt die URL gleich. Wählst du stattdessen "Neue Bereitstellung", erzeugt Google eine neue URL und der ESP32 spricht weiter mit dem alten Code; das ist der häufigste Grund für "Ich habe den Code korrigiert, aber nichts ändert sich".
Teste die Einrichtung im Browser, bevor du zum ESP32 wechselst: Hänge ?token=DEINTOKEN&device=test&temp=21.5&hum=40&light=1200 an die URL und öffne sie. Du siehst {"ok":true,"row":2} und findest die Zeile in der Tabelle. Die Antwort "unauthorized" bedeutet, dass der Schlüssel nicht passt; eine Google-Anmeldeseite heißt, dass der Zugriff nicht auf "Jeder" steht.

Schritt 4: DHT22 und LDR anschließen

DHT22 Temperatur- und Feuchtesensor
DHT22: misst von -40 bis 80 °C auf ±0,5 °C genau und die Luftfeuchte auf ±2-5 %; er lässt sich mit 3,3 V direkt an den ESP32 anschließen.
BauteilAnschlussESP32-Pin
DHT22VCC3V3
DHT22DATA (beim nackten Sensor 10 kΩ Pull-up nach 3V3)GPIO 4
DHT22GNDGND
LDREin Bein an 3V3, das andere an GPIO 343V3 / GPIO 34
10-kΩ-WiderstandZwischen GPIO 34 und GNDGPIO 34 / GND

LDR und 10-kΩ-Widerstand bilden einen Spannungsteiler: Je heller es ist, desto kleiner wird der Widerstand des LDR und desto höher die Spannung an GPIO 34. GPIO 34 ist bewusst gewählt; beim ESP32 können die ADC2-Pins (GPIO 0, 2, 4, 12-15, 25-27) bei aktivem WLAN nicht analog messen, schließe analoge Sensoren also immer an die ADC1-Pins GPIO 32-39 an. Der DHT22 ist ein digitaler Sensor und läuft problemlos an GPIO 4. Mehr zur DHT-Familie steht im DHT11- und DHT22-Ratgeber.

Schritt 5: Die HTTPS-Anfrage vom ESP32 senden

Installiere in der Arduino IDE über den Bibliotheksverwalter die DHT sensor library (Adafruit) und bestätige bei Nachfrage die Abhängigkeit Adafruit Unified Sensor. WiFi, WiFiClientSecure und HTTPClient bringt das ESP32-Paket mit. Ersetze WLAN-Daten, die kopierte Web-App-URL und den TOKEN durch deine eigenen Werte, lade den Sketch hoch und öffne den seriellen Monitor mit 115200 Baud.

C++ (Arduino IDE)
1// ESP32 -> Google E-Tablolar veri kaydı / ESP32 -> Google Sheets data logger
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <HTTPClient.h>
5#include <DHT.h>   // "DHT sensor library" (Adafruit)
6
7const char* WIFI_SSID  = "AgAdi";      // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS  = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
9const char* SCRIPT_URL = "https://script.google.com/macros/s/BURAYA_DAGITIM_ID/exec"; // web uygulaması / web app
10const char* TOKEN      = "gizli-anahtar-123";  // Komut dosyası özelliğiyle aynı / same as the script property
11const char* DEVICE     = "salon";              // cihaz adı / device name
12
13const int DHT_PIN = 4;                         // DHT22 veri / data
14const int LDR_PIN = 34;                        // LDR bölücü, ADC1 / LDR divider, ADC1
15const unsigned long INTERVAL_MS = 60000;       // dakikada bir satır / one row per minute
16
17DHT dht(DHT_PIN, DHT22);
18unsigned long lastSend = 0;
19bool firstRun = true;
20
21void connectWiFi() {
22  if (WiFi.status() == WL_CONNECTED) return;
23  WiFi.mode(WIFI_STA);
24  WiFi.begin(WIFI_SSID, WIFI_PASS);
25  Serial.print("Wi-Fi");
26  for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) {  // en fazla 20 sn / 20 s max
27    delay(500);
28    Serial.print(".");
29  }
30  Serial.println(WiFi.status() == WL_CONNECTED ? " OK" : " HATA / FAIL");
31}
32
33bool sendRow(float temp, float hum, int light) {
34  WiFiClientSecure client;
35  client.setInsecure();                        // sertifika denetimi yok, yazıdaki nota bak / no cert check, see note
36  HTTPClient http;
37  http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);  // 302 yönlendirmesini GET ile izle / follow 302 with GET
38  http.setTimeout(15000);                      // Apps Script yavaş olabilir / Apps Script can be slow
39  if (!http.begin(client, SCRIPT_URL)) return false;
40  http.addHeader("Content-Type", "application/json");
41
42  char body[160];
43  snprintf(body, sizeof(body),
44           "{\"token\":\"%s\",\"device\":\"%s\",\"temp\":%.1f,\"hum\":%.1f,\"light\":%d}",
45           TOKEN, DEVICE, temp, hum, light);
46
47  int code = http.POST(body);                  // negatif = bağlantı hatası / negative = connection error
48  String reply = http.getString();
49  http.end();
50  Serial.printf("HTTP %d: %s\n", code, reply.c_str());
51  return code == 200 && reply.indexOf("\"ok\":true") >= 0;
52}
53
54void setup() {
55  Serial.begin(115200);
56  dht.begin();
57  connectWiFi();
58}
59
60void loop() {
61  if (!firstRun && millis() - lastSend < INTERVAL_MS) return;
62  firstRun = false;
63  lastSend = millis();
64
65  float t = dht.readTemperature();             // °C
66  float h = dht.readHumidity();                // %
67  int light = analogRead(LDR_PIN);             // 0-4095
68  if (isnan(t) || isnan(h)) {
69    Serial.println("DHT22 okunamadı / read failed");
70    return;
71  }
72
73  connectWiFi();
74  for (int attempt = 1; attempt <= 3; attempt++) {   // 3 deneme / 3 attempts
75    if (sendRow(t, h, light)) break;
76    delay(2000 * attempt);                           // giderek uzayan bekleme / growing back-off
77  }
78}
  • Ohne setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) bleibt der ESP32 bei Googles 302-Antwort stehen und sieht die echte Antwort nie; die Zeile wird trotzdem angehängt, aber du kannst den Erfolg nicht prüfen.
  • client.setInsecure() verschlüsselt die Verbindung, prüft aber das Serverzertifikat nicht. Für ein Heimprojekt genügt das; für mehr Sicherheit fügst du Googles Stammzertifikat mit setCACert() hinzu.
  • setTimeout(15000) ist wichtig; Apps Script braucht manchmal 2-5 Sekunden, und der Standardwert reicht dann nicht.
  • Schlägt das Senden fehl, versucht der Code es dreimal mit 2, 4 und 6 Sekunden Pause; das verringert Datenverluste bei kurzen Netzausfällen.
  • Das Timing läuft über millis(), die Schleife blockiert also nie; du kannst Displayausgabe oder Tasterabfrage in dieselbe Schleife packen.

Zeitstempel, mehrere Sensoren und Geräte

Den Zeitstempel in Apps Script mit new Date() zu schreiben ist am praktischsten: Der ESP32 muss die Uhrzeit nicht kennen, und alle Geräte nutzen dieselbe Zeitquelle. Einziger Nachteil: Der Stempel zeigt den Eingang bei Google, nicht den Messzeitpunkt; der Unterschied beträgt meist wenige Sekunden. Sammelst du Messwerte und schickst sie gebündelt, hol die Zeit auf dem ESP32 per NTP und füge sie als Feld ts ins JSON ein. Für einen neuen Sensor änderst du nur drei Stellen: das Feld im JSON-Text des ESP32, eine Zeile num(data.neu) im appendRow-Array von Apps Script und die Überschrift in der Tabelle. Mehrere ESP32 können in dieselbe Tabelle schreiben; gib jedem Board einen eigenen DEVICE-Namen, dann kannst du nach dieser Spalte filtern oder pro Gerät ein eigenes Blatt anlegen.

Ein Live-Diagramm in Google Sheets erstellen

  1. Markiere die kompletten Spalten A bis D über die Spaltenbuchstaben, nicht über die Überschriften (A:D); so kommen neue Zeilen automatisch ins Diagramm.
  2. Öffne Einfügen > Diagramm und stelle im Diagrammeditor den Typ Liniendiagramm ein.
  3. Lass die Zeitspalte als X-Achse und Temperatur und Feuchte als Datenreihen; nimm die Gerätespalte aus den Reihen heraus.
  4. Da der Lichtwert von 0 bis 4095 reicht, drückt er die anderen Kurven flach; zeig ihn in einem eigenen Diagramm oder unter Anpassen > Reihen auf der rechten Achse.
  5. Über Diagramm veröffentlichen im Dreipunktmenü oben rechts erhältst du einen Link, der das Diagramm ohne die Tabelle zeigt.

Kontingente und Grenzen: Wie oft darfst du senden?

GrenzeWertPraktische Bedeutung
Zellenzahl10 Millionen Zellen pro TabelleLeere Spalten zählen mit; lösche ungenutzte
Gleichzeitige AusführungenEtwa 30 pro NutzerSenden viele Geräte in derselben Sekunde, kann es Fehler geben
Laufzeit6 Minuten pro AufrufFür appendRow kein Problem
AntwortzeitMeist 1-5 SekundenNicht für mehrere Messungen pro Sekunde geeignet
Empfohlenes Intervall1 Minute oder längerFür Haus- und Gewächshausüberwachung mehr als genug

Rechnen wir die Zellgrenze konkret durch. Eine Zeile pro Minute ergibt 1440 Zeilen am Tag. Behältst du nur 5 Spalten, verbrauchst du 7200 Zellen täglich, und 10 Millionen Zellen reichen etwa 3,8 Jahre. Löschst du die 26 Standardspalten eines neuen Blatts nicht, zählt jede Zeile 26 Zellen und die Grenze ist nach etwa 9 Monaten erreicht. Bei Langzeitaufzeichnung hält ein neues Blatt pro Jahr oder das Auslagern alter Daten in eine eigene Datei die Tabelle zudem schnell; eine Tabelle mit Hunderttausenden Zeilen öffnet sich auf dem Handy nur zäh.

Fehlerbehandlung: Was bedeuten die HTTP-Codes?

Im seriellen MonitorBedeutungWas tun?
HTTP 200 + "ok":trueZeile angehängtAlles in Ordnung
HTTP 200 + unauthorizedTOKEN passt nicht oder Eigenschaft fehltCode und Skripteigenschaften vergleichen
HTTP 302Weiterleitung nicht verfolgtDie Zeile setFollowRedirects ergänzen
HTTP 401 / 403 oder HTML-AnmeldeseiteZugriff steht nicht auf "Jeder"Bereitstellung bearbeiten, Zugriff auf Jeder
HTTP 404Falsche URL oder archivierte BereitstellungAktuelle URL mit /exec kopieren
Negativer Code (-1, -11)Keine Verbindung oder ZeitüberschreitungWLAN-Empfang und setTimeout prüfen

Bei einem Gerät, das lange läuft, sind Netzausfälle unvermeidlich. Für kurze Aussetzer reicht die Schleife mit drei Versuchen im Code. Willst du bei stundenlangen Ausfällen keine Daten verlieren, sammle die Messwerte in einem Array oder in einer Datei im Flash des ESP32 und schicke sie nacheinander, sobald die Verbindung zurück ist. Kommst du gar nicht ins WLAN, helfen die Schritte im Artikel ESP32 verbindet sich nicht mit dem WLAN.

Die Web-App-URL geheim halten

  • Weil der Zugriff auf "Jeder" steht, kann jeder mit der URL Zeilen anhängen; entferne URL und Schlüssel immer, bevor du Code online teilst.
  • Geh nie ohne die TOKEN-Prüfung live; Anfragen ohne Schlüssel werden abgelehnt, ohne die Tabelle zu berühren.
  • Legst du WLAN-Passwort, URL und Schlüssel in eine eigene Datei secrets.h und bindest sie per #include ein, kannst du sie beim Teilen leicht weglassen.
  • Ist die URL durchgesickert, archiviere unter Bereitstellungen verwalten die alte Bereitstellung, erstelle eine neue und ändere den TOKEN.
  • Du musst die Tabelle nicht für "Jeder mit dem Link" freigeben; die Web-App läuft mit deinem Konto, die Tabelle kann also privat bleiben.

ThingSpeak und andere Alternativen

MethodeStärkeSchwäche
Google SheetsKostenlos, vertraute Oberfläche, einfache Formeln und FreigabeLangsame Antworten, nicht für Daten öfter als einmal pro Minute
ThingSpeakFertige Diagramme, MATLAB-Auswertung, einfache HTTP-APIIm Gratisplan mindestens 15 s Abstand, 8 Felder pro Kanal
MQTT + Home AssistantSofort, in beide Richtungen, mit Hausautomation verknüpfbarBraucht einen dauerhaft laufenden Server zu Hause
BlynkFertige Handy-Oberfläche, BenachrichtigungenGratisplan begrenzt Geräte und Daten
SD-KarteKein Internet nötig, sehr schnelle AufzeichnungKein Fernzugriff auf die Daten

Was solltest du wählen? Willst du die Daten in einer Tabelle bearbeiten, mit Formeln auswerten oder mit jemandem teilen, ist Google Sheets unschlagbar. Möchtest du nur Diagramme ansehen, machen die fertigen Dashboards von ThingSpeak weniger Arbeit. Hast du schon eine Hausautomation, ist MQTT mit Home Assistant am flexibelsten. Arbeitest du lieber mit Excel am Computer, sieh dir die Methode über die serielle Schnittstelle in Arduino-Daten nach Excel übertragen an; für Orte ohne Internet bietet sich die Aufzeichnung auf SD-Karte an.

Projektideen mit ESP32 und Google Sheets

  • Gewächshaus-Tagebuch: Temperatur, Luft- und Bodenfeuchte alle 10 Minuten in die Tabelle schreiben und das Gießen anhand der Historie planen.
  • Batteriebetriebene Außenstation: Den ESP32 alle 15 Minuten aus dem Deep Sleep wecken, den Messwert senden und wieder schlafen legen.
  • Tür- und Bewegungszähler: Jedes Öffnen der Tür oder jede PIR-Erkennung mit Zeitstempel speichern und als Tagesdiagramm darstellen.
  • Stromverbrauch erfassen: Den Wert eines Stromsensors als Minutenmittel senden und in der Tabelle per Formel in kWh umrechnen.
  • Klassenexperiment: Mehrere Schülerboards schreiben mit unterschiedlichen DEVICE-Namen in dieselbe Tabelle, und ihr vergleicht die Ergebnisse gemeinsam.
Die in die Tabelle geschriebenen Zahlen hängen nicht vom Gebietsschema ab: Die Funktion num() in Apps Script wandelt den Text in eine echte Zahl um, daher wird 23.5 auch in einer deutsch eingestellten Tabelle als Dezimalzahl gespeichert und korrekt im Diagramm gezeigt. Schreibst du die Werte als Text, kann das Durcheinander von Komma und Punkt das Diagramm leer lassen.

Sobald du Daten in Google Sheets schreiben kannst, wird jedes ESP32-Projekt zu einem kleinen IoT-Gerät mit Messhistorie und Diagramm. In der BlueGrays-App findest du ESP32-Projekte wie WLAN-Verbindung, Temperatur und Feuchte mit dem DHT22, NTP-Uhrzeit, Wetter per HTTPClient und Deep Sleep, jeweils mit Schaltplan und Code Schritt für Schritt, und kannst die Google-Sheets-Aufzeichnung aus diesem Artikel darauf aufsetzen.

Häufige Fragen

Wie sende ich Daten vom ESP32 an Google Sheets?

Du schreibst in einem an die Tabelle gebundenen Google-Apps-Script-Projekt eine doPost-Funktion und veröffentlichst sie als Web-App. Der ESP32 schickt mit WiFiClientSecure und HTTPClient eine HTTPS-POST-Anfrage mit JSON an die /exec-URL der Web-App, und die Funktion hängt mit appendRow eine neue Zeile an.

Brauche ich einen API-Schlüssel für Google Sheets?

Bei der Methode mit Apps-Script-Web-App brauchst du weder API-Schlüssel noch OAuth. Das Skript läuft mit deinem Konto und schreibt selbst in die Tabelle. Für die Sicherheit genügt eine Prüfung auf einen selbst gewählten geheimen Schlüssel (TOKEN).

Warum bekommt der ESP32 bei Google Sheets einen 302-Fehler?

Die Apps-Script-Web-App beantwortet eine POST-Anfrage zuerst mit einer 302-Weiterleitung. HTTPClient auf dem ESP32 folgt Weiterleitungen standardmäßig nicht, daher siehst du den Code 302. Mit http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) erhältst du die eigentliche Antwort.

Wie oft darf ich Daten an Google Sheets senden?

Jede Anfrage dauert 1-5 Sekunden und gleichzeitige Ausführungen sind begrenzt, daher ist einmal pro Minute oder seltener sinnvoll. Eine Tabelle fasst bis zu 10 Millionen Zellen; eine Zeile mit 5 Spalten pro Minute reicht etwa 3,8 Jahre. Brauchst du mehrere Messungen pro Sekunde, mittle sie auf dem ESP32 und sende gebündelt.

Ich habe den Apps-Script-Code geändert, aber der ESP32 bekommt das alte Ergebnis. Warum?

Eine Web-App führt die veröffentlichte Version aus; Speichern allein genügt nicht. Bearbeite unter Bereitstellen > Bereitstellungen verwalten die bestehende Bereitstellung und wähle Neue Version. Legst du stattdessen eine neue Bereitstellung an, ändert sich die URL, und du musst sie auch im ESP32 anpassen.

Ist ThingSpeak oder Google Sheets besser?

Willst du fertige Diagramme und ein einfaches IoT-Dashboard, ist ThingSpeak schneller eingerichtet, im Gratisplan aber auf mindestens 15 Sekunden Abstand und 8 Felder pro Kanal begrenzt. Möchtest du die Daten mit Formeln auswerten, bearbeiten und teilen, ist Google Sheets flexibler.

Alle Projekte ansehen
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 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 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 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
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 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)

Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

4.3(10)
16
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55