Ratgeber · 13 Min. Lesezeit

ESP32 Wetter-API: Daten abrufen, JSON auswerten, OLED-Anzeige

ESP32 Wetter-API Anleitung: HTTPClient-Anfragen an Open-Meteo und OpenWeatherMap, ArduinoJson, OLED/LCD-Anzeige, HTTPS-Zertifikat und Fehler 401, 404, -1.

Bei ESP32 Wetter-Projekten verbindest du das Board mit dem WLAN, stellst einem Wetterdienst im Internet eine Frage und zeigst die Antwort auf einem Display an. Ganz ohne Sensor erfährst du so Temperatur, Luftfeuchtigkeit, Wind und die Vorhersage für morgen in deiner Stadt, denn eine API (Programmierschnittstelle), die von Wetterstationen und Wettermodellen gespeist wird, hat die Messung bereits für dich erledigt. Der ESP32 schickt diesem Dienst wie ein Webbrowser eine HTTP-GET-Anfrage, bekommt als Antwort reinen Text im JSON-Format und holt mit der Bibliothek ArduinoJson die Zahlen daraus.

In dieser Anleitung schickst du zuerst eine Anfrage an Open-Meteo, das keinen Schlüssel braucht, und wechselst dann zu OpenWeatherMap, das mit Städtenamen arbeitet. Du lernst, JSON auszuwerten, WMO-Wettercodes in Text umzuwandeln, das Ergebnis auf einem 0,96-Zoll-OLED und einem 16x2-I2C-LCD anzuzeigen, HTTPS und Zertifikate einzurichten, die Abruflimits einzuhalten und was Fehlercodes wie 401, 404 und -1 bedeuten. Am Ende folgen ein Beispiel, das auf dieselbe Weise Wechselkurse abruft, und MicroPython-Code für den Raspberry Pi Pico W.

ESP32-Entwicklungsboard
ESP32: Dank des eingebauten WLANs holt er Wetterdaten ohne zusätzliches Modul aus dem Internet.

Wie holt der ESP32 Daten aus dem Internet? API, HTTP und JSON

Wenn du eine Adresse in den Browser tippst, schickt er eine HTTP-Anfrage an den Server, und der Server liefert eine Webseite zurück. Eine API funktioniert genauso; der einzige Unterschied ist, dass die Antwort keine für Menschen gestaltete Seite ist, sondern geordneter Text, den Programme leicht lesen können. Auf dem ESP32 erledigt das die mitgelieferte Bibliothek HTTPClient: Du gibst ihr die Adresse, sie schickt die GET-Anfrage und übergibt dir den Statuscode des Servers und den Inhalt der Antwort. Die Antwort ist meist JSON: "Schlüssel": Wert-Paare in geschweiften Klammern, die verschachtelte Objekte oder Arrays enthalten können.

BegriffBedeutungWetter-Beispiel
APIDie Schnittstelle, über die Programme Daten austauschenVorhersagedienst von Open-Meteo
Endpunkt (Endpoint)Die Adresse der API für eine bestimmte Aufgabe/v1/forecast
AbfrageparameterEinstellungen nach dem ? in der Adresselatitude=41.01¤t=temperature_2m
GET-AnfrageDaten vom Server anfordernhttp.GET()
StatuscodeEine Zahl, die das Ergebnis der Anfrage beschreibt200 Erfolg, 404 nicht gefunden
JSONTextformat aus Schlüsseln und Werten{"temperature_2m":17.3}
API-SchlüsselGeheime Kennung, die dich identifiziertDer appid-Wert bei OpenWeatherMap

Welcher Dienst: Open-Meteo oder OpenWeatherMap?

Viele Wetterdienste haben einen kostenlosen Tarif, aber für den Einstieg stechen zwei hervor. Open-Meteo braucht weder Anmeldung noch Schlüssel: Du gibst den Ort als Breiten- und Längengrad an, wählst nur die gewünschten Felder, und die Antwort bleibt kurz und leicht für den ESP32. OpenWeatherMap braucht ein kostenloses Konto und einen API-Schlüssel, bietet dafür aber Abfragen per Städtename, einen fertigen Beschreibungstext (zum Beispiel "light rain") und einen Symbolcode. Die kostenlosen Tarife beider Dienste sind für private und Lernprojekte gedacht; wenn du ein kommerzielles Produkt baust, lies die Nutzungsbedingungen gesondert.

MerkmalOpen-MeteoOpenWeatherMap (kostenlos)
Anmeldung und SchlüsselNicht nötigKonto und API-Schlüssel nötig
OrtBreiten- und LängengradStädtename, Koordinaten oder Stadt-ID
Kostenloses Limit10.000 Abrufe am Tag, 5.000 pro Stunde, 600 pro Minute60 Abrufe pro Minute, 1.000.000 im Monat
AktualisierungAktuelle Daten alle 15 MinutenEtwa alle 10 Minuten
WetterzustandWMO-Zahlencode (0, 3, 61...)Beschreibungstext und Symbolcode
Einheiten°C und km/h (per Parameter änderbar)°C und m/s mit units=metric
AntwortgrößeNur die gewählten Felder, etwa 400 ByteEtwa 500 Byte
Willst du nur Temperatur und Wetter anzeigen, fang mit Open-Meteo an: Ohne auf einen Schlüssel zu warten, hast du in der ersten Minute ein Ergebnis. Breiten- und Längengrad deines Orts findest du, indem du in einer Karten-App mit der rechten Maustaste auf deine Stadt klickst (am Handy lange drücken). Für Berlin reichen 52.52, 13.41, für München 48.14, 11.58 und für Wien 48.21, 16.37.

Was du brauchst und Einrichtung

  1. Installiere in der Arduino IDE das ESP32-Boardpaket (Werkzeuge > Board > Boardverwalter, esp32 by Espressif). Die Einrichtung ist ausführlich in der Anleitung Was ist ein ESP32 beschrieben.
  2. Suche im Bibliotheksverwalter nach ArduinoJson (Benoit Blanchon) und installiere Version 7.x. Die Bibliotheken HTTPClient, WiFi und WiFiClientSecure gehören zum ESP32-Paket und müssen nicht extra installiert werden.
  3. Für die Display-Version installierst du Adafruit SSD1306 und Adafruit GFX, für ein LCD LiquidCrystal I2C.
  4. Ersetze AgAdi und Sifre123 im Code durch deinen WLAN-Namen und dein Passwort, wähle ESP32 Dev Module als Board und stelle den seriellen Monitor auf 115200 Baud.
Der ESP32 verbindet sich nur mit 2,4-GHz-WLANs. Gibt der Code in der WLAN-Zeile endlos Punkte aus, liegt das Problem an der Verbindung, nicht an der API: Prüfe Netzwerkname, Passwort und ob dein Router auf 2,4 GHz sendet. Eine ausführliche Liste mit Lösungen findest du in der Anleitung ESP32 verbindet sich nicht mit dem WLAN.

Schritt für Schritt: die erste GET-Anfrage mit HTTPClient

Der erste Sketch hat nur eine Aufgabe: sich mit dem WLAN verbinden, bei Open-Meteo das aktuelle Wetter in Istanbul abfragen und die Antwort unverändert im seriellen Monitor ausgeben. Der Parameter current= in der Adresse legt fest, welche Felder du willst; durch Kommas getrennt haben wir Temperatur, Luftfeuchtigkeit, Wettercode und Windgeschwindigkeit gewählt. timezone=auto rechnet die Uhrzeiten in die Ortszeit des Standorts um.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3
4const char* WIFI_SSID = "AgAdi";        // Wi-Fi adı / Wi-Fi name
5const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifresi / Wi-Fi password
6
7// İstanbul'un anlık hava durumu (anahtar gerekmez) / current weather for Istanbul (no key needed)
8const char* URL = "http://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
9                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
10                  "&timezone=auto";
11
12void setup() {
13  Serial.begin(115200);
14  WiFi.mode(WIFI_STA);
15  WiFi.begin(WIFI_SSID, WIFI_PASS);
16  Serial.print("Wi-Fi");
17  while (WiFi.status() != WL_CONNECTED) {   // bağlanana kadar bekle / wait until connected
18    delay(500);
19    Serial.print(".");
20  }
21  Serial.println(" OK");
22
23  HTTPClient http;
24  http.begin(URL);                          // isteği hazırla / prepare the request
25  int code = http.GET();                    // GET isteğini gönder / send the GET request
26  Serial.printf("HTTP kodu / code: %d\n", code);
27
28  if (code > 0) {                           // sunucu yanıt verdi / the server answered
29    Serial.println(http.getString());       // yanıtın gövdesi (JSON) / response body (JSON)
30  } else {                                  // eksi kod: bağlantı sorunu / negative: connection problem
31    Serial.println(http.errorToString(code));
32  }
33  http.end();                               // bağlantıyı kapat, belleği boşalt / close and free memory
34}
35
36void loop() {
37}

Nach dem Hochladen solltest du im seriellen Monitor zuerst "HTTP kodu / code: 200" und dann eine einzelne JSON-Zeile sehen. Der nützliche Teil der Antwort sieht so aus: "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. Der interval-Wert 900 sagt dir, dass die Daten alle 900 Sekunden, also alle 15 Minuten, erneuert werden; das brauchst du später, um festzulegen, wie oft du abfragst.

FunktionWas macht sie?
http.begin(url)Zerlegt die Adresse und bereitet die Verbindung vor
http.GET()Sendet die Anfrage; liefert den HTTP-Statuscode oder einen negativen Fehlercode
http.getString()Liest den Inhalt der Antwort als String
http.getStream()Gibt den Inhalt als Stream weiter, ohne ihn zwischenzuspeichern (für große Antworten)
http.errorToString(code)Wandelt einen negativen Fehlercode in lesbaren Text um
http.setTimeout(ms)Wartezeit auf die Antwort (Standard 5000 ms)
http.end()Schließt die Verbindung und gibt den Speicher frei

JSON mit ArduinoJson auswerten

Rohes JSON auf einem Display bringt nichts; du musst die Zahl 17.3 herausholen und in eine float-Variable schreiben. ArduinoJson macht aus dem Text eine Baumstruktur im Speicher, und du hangelst dich mit den Schlüsselnamen durch die Äste: doc["current"]["temperature_2m"] geht zuerst zum Objekt current und dann zur Temperatur darin. Welchem Variablentyp du den Wert zuweist, in diesen Typ wandelt die Bibliothek ihn um. Fragst du nach einem Schlüssel, den es nicht gibt, stürzt das Programm nicht ab; du bekommst 0 für eine Zahl und einen Nullzeiger für Text.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3#include <ArduinoJson.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7const char* URL = "http://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
8                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
9                  "&timezone=auto";
10
11bool fetchWeather() {
12  HTTPClient http;
13  http.begin(URL);
14  int code = http.GET();
15  if (code != HTTP_CODE_OK) {               // 200 değilse vazgeç / give up if not 200
16    Serial.printf("Hata / error: %d %s\n", code, http.errorToString(code).c_str());
17    http.end();
18    return false;
19  }
20
21  JsonDocument doc;                         // ArduinoJson 7: boyut otomatik / size is automatic
22  DeserializationError err = deserializeJson(doc, http.getString());
23  http.end();
24  if (err) {                                // JSON bozuk ya da eksik / JSON broken or truncated
25    Serial.print("JSON hatasi / error: ");
26    Serial.println(err.c_str());
27    return false;
28  }
29
30  JsonObject now = doc["current"];          // "current" nesnesi / the "current" object
31  float temp     = now["temperature_2m"];   // °C
32  int humidity   = now["relative_humidity_2m"];
33  int wmo        = now["weather_code"];     // WMO hava kodu / WMO weather code
34  float wind     = now["wind_speed_10m"];   // km/sa / km/h
35  const char* t  = now["time"];             // ölçüm zamanı / observation time
36
37  Serial.printf("%s  %.1f C  %%%d nem/hum  kod/code %d  ruzgar/wind %.1f km/h\n",
38                t, temp, humidity, wmo, wind);
39  return true;
40}
41
42void setup() {
43  Serial.begin(115200);
44  WiFi.begin(WIFI_SSID, WIFI_PASS);
45  while (WiFi.status() != WL_CONNECTED) delay(500);
46  fetchWeather();
47}
48
49void loop() {
50}

Dieser Code ist für ArduinoJson 7. Die Zeilen StaticJsonDocument und DynamicJsonDocument doc(1024) aus älteren Beispielen gehören zu Version 6.x; in 7.x schreibst du einfach JsonDocument doc;, und der Speicher wird automatisch nach Bedarf reserviert. Bekommst du beim Kompilieren alter Sketche die Warnung "StaticJsonDocument is deprecated", ist das der Grund: Der Code läuft meist trotzdem, aber der Umstieg auf die neue Schreibweise ist sauberer. Das Auslesen mit doc["schluessel"] ist in beiden Versionen gleich.

Gibt deserializeJson() einen Fehler zurück, verrät dir err.c_str() den Grund: IncompleteInput heißt, die Antwort wurde abgeschnitten, InvalidInput, dass der Text kein JSON ist (meist eine HTML-Fehlerseite), und NoMemory, dass der Speicher nicht gereicht hat. Am schnellsten löst du das Problem, indem du die Antwort zuerst mit Serial.println() ausgibst und dir ansiehst.

WMO-Wettercodes: die Zahl in Text umwandeln

Open-Meteo beschreibt das Wetter nicht mit einem Wort wie "bewölkt", sondern mit einer Zahl, die die Weltorganisation für Meteorologie (WMO) festgelegt hat. Dadurch ist die Antwort sprachunabhängig, und du entscheidest, in welcher Sprache dein Display anzeigt. Diese Codes siehst du am häufigsten:

WMO-CodeBedeutung
0Klar
1, 2, 3Überwiegend klar, teilweise bewölkt, bedeckt
45, 48Nebel, Nebel mit Reifablagerung
51, 53, 55Leichter, mäßiger, starker Nieselregen
56, 57Gefrierender Nieselregen
61, 63, 65Leichter, mäßiger, starker Regen
66, 67Gefrierender Regen
71, 73, 75Leichter, mäßiger, starker Schneefall
77Schneegriesel
80, 81, 82Leichte, mäßige, heftige Regenschauer
85, 86Leichte und starke Schneeschauer
95Gewitter
96, 99Gewitter mit Hagel

Die Funktion wmoText() im OLED-Sketch unten macht aus dieser Tabelle kurze Beschriftungen. Sie sind im Code auf Türkisch ohne Sonderzeichen geschrieben; ersetze sie ruhig durch deutsche Wörter wie "Klar", "Regen" oder "Schnee" (ohne Umlaute, siehe unten). Willst du eigene Symbole zeichnen, wähle mit denselben Bereichen Bitmaps für Sonne, Wolke oder Regentropfen; für 61 bis 67 und 80 bis 82 reicht zum Beispiel ein einziges Regensymbol.

Wetter per Städtename mit OpenWeatherMap

Nachdem du ein kostenloses Konto bei OpenWeatherMap angelegt hast, findest du im Bereich API keys deines Kontos einen 32-stelligen Schlüssel. Ein neuer Schlüssel kann von ein paar Minuten bis zu ein paar Stunden brauchen, bis er aktiv ist; bis dahin liefert jede Anfrage 401, und du hältst vielleicht deinen Code für fehlerhaft. In der Abfrage legt q=Ankara,TR Städtename und Ländercode fest, units=metric Celsius und m/s und lang die Sprache der Beschreibung.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3#include <ArduinoJson.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7const char* API_KEY   = "BURAYA_API_ANAHTARIN";   // OpenWeatherMap hesabındaki anahtar / key from your account
8const char* CITY      = "Ankara,TR";              // şehir,ülke kodu / city,country code
9
10void fetchCity() {
11  String url = String("http://api.openweathermap.org/data/2.5/weather?q=") + CITY +
12               "&appid=" + API_KEY + "&units=metric&lang=en";   // metric = °C ve m/s / °C and m/s
13  HTTPClient http;
14  http.begin(url);
15  int code = http.GET();
16  String body = (code > 0) ? http.getString() : "";
17  http.end();
18
19  if (code == 401) { Serial.println("401: anahtar gecersiz ya da henuz aktif degil / invalid or inactive key"); return; }
20  if (code == 404) { Serial.println("404: sehir bulunamadi / city not found"); return; }
21  if (code == 429) { Serial.println("429: istek siniri asildi / rate limit exceeded"); return; }
22  if (code != 200) { Serial.printf("Hata / error %d: %s\n", code, HTTPClient::errorToString(code).c_str()); return; }
23
24  JsonDocument doc;
25  if (deserializeJson(doc, body)) { Serial.println("JSON hatasi / error"); return; }
26
27  const char* name = doc["name"];                        // şehir adı / city name
28  float temp       = doc["main"]["temp"];                // sıcaklık / temperature
29  float feels      = doc["main"]["feels_like"];          // hissedilen / feels like
30  int humidity     = doc["main"]["humidity"];            // nem % / humidity %
31  int pressure     = doc["main"]["pressure"];            // hPa
32  const char* desc = doc["weather"][0]["description"];   // dizi: [0] ilk eleman / array: [0] first item
33  float wind       = doc["wind"]["speed"];               // m/s
34
35  Serial.printf("%s: %.1f C (hissedilen/feels %.1f), %%%d, %d hPa, %s, %.1f m/s\n",
36                name, temp, feels, humidity, pressure, desc, wind);
37}
38
39void setup() {
40  Serial.begin(115200);
41  WiFi.begin(WIFI_SSID, WIFI_PASS);
42  while (WiFi.status() != WL_CONNECTED) delay(500);
43  fetchCity();
44}
45
46void loop() {
47}

Zwei Details dieser Antwort verdienen Aufmerksamkeit. Erstens ist das Feld weather kein Objekt, sondern ein Array; die Beschreibung erreichst du deshalb über das erste Element mit doc["weather"][0]["description"]. Zweitens kommt die Windgeschwindigkeit mit units=metric in m/s; für km/h multiplizierst du mit 3,6. Mit lang=de bekommst du deutsche Beschreibungen ("leichter Regen"), aber die Standardschriften von Adafruit GFX und HD44780-LCDs können ä, ö, ü und ß nicht darstellen. Damit keine kaputten Zeichen erscheinen, ist lang=en mit eigenen kurzen Beschriftungen die sicherere Wahl.

HTTPS und Zertifikat: setInsecure oder setCACert?

Die meisten Wetterdienste nutzen inzwischen HTTPS, und manche akzeptieren gar kein einfaches HTTP mehr. Bei HTTPS wird der Datenverkehr zwischen ESP32 und Server verschlüsselt; damit der ESP32 außerdem sicher sein kann, dass er wirklich mit diesem Server spricht, muss er die Zertifikatskette mit einem Root-Zertifikat prüfen. Dafür nimmst du WiFiClientSecure statt des einfachen WiFiClient, und es gibt zwei Möglichkeiten.

setInsecure() verschlüsselt die Verbindung, prüft aber das Zertifikat nicht. Für öffentliche, nicht geheime Daten wie das Wetter ist das praktisch und verbreitet, allerdings könnte dir jemand dazwischen gefälschte Daten unterschieben. setCACert() prüft die Kette mit dem Root-Zertifikat, das du angibst. Das Zertifikat von Open-Meteo stammt von Let's Encrypt und führt zur Wurzel ISRG Root X1, die bis 2035 gültig ist. Das eigene Zertifikat des Servers wird alle paar Monate erneuert; trag deshalb nie dieses in den Code ein, sondern immer die Wurzel ganz oben in der Kette.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7
8// ISRG Root X1: Let's Encrypt kök sertifikası, 2035'e kadar geçerli
9// ISRG Root X1: Let's Encrypt root certificate, valid until 2035
10const char* ROOT_CA = R"EOF(
11-----BEGIN CERTIFICATE-----
12MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
13TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
14cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
15WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
16ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
17MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
18h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
190TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
20A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
21T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
22B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
23B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
24KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
25OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
26jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
27qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
28rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
29HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
30hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
31ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
323BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
33NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
34ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
35TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
36jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
37oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
384RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
39mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
40emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
41-----END CERTIFICATE-----
42)EOF";
43
44void setup() {
45  Serial.begin(115200);
46  WiFi.begin(WIFI_SSID, WIFI_PASS);
47  while (WiFi.status() != WL_CONNECTED) delay(500);
48
49  WiFiClientSecure client;
50  client.setCACert(ROOT_CA);       // sunucuyu doğrula / verify the server
51  // client.setInsecure();         // yalnız deneme için: şifreler ama doğrulamaz / testing only: encrypts, no verification
52
53  HTTPClient http;
54  http.begin(client, "https://api.open-meteo.com/v1/forecast?latitude=39.93&longitude=32.86&current=temperature_2m");
55  int code = http.GET();
56  Serial.printf("HTTPS kodu / code: %d\n", code);
57  if (code > 0) Serial.println(http.getString());
58  else Serial.println(HTTPClient::errorToString(code));
59  http.end();
60}
61
62void loop() {
63}
Bevor du ein Root-Zertifikat für einen anderen Dienst verwendest, prüfe, zu welcher Wurzel diese Seite gehört: OpenWeatherMap nutzt die Kette von Sectigo und USERTrust, Frankfurter die von Google Trust Services. Gibst du die falsche Wurzel an, liefert GET() -1, und der serielle Monitor zeigt dir keinen weiteren Hinweis. Sendest du etwas Geheimes wie deinen API-Schlüssel, nimm unbedingt setCACert() statt setInsecure().

Das Wetter deiner Stadt auf einem OLED-Display

0,96-Zoll-I2C-OLED-Display
0,96-Zoll-SSD1306-OLED: Es wird mit nur vier Kabeln an den ESP32 angeschlossen und zeigt das Wetter in großen Ziffern.

Jetzt lassen wir den seriellen Monitor hinter uns und bauen eine echte Wetterstation für den Schreibtisch. Das 0,96-Zoll-SSD1306-OLED kommt an die I2C-Pins des ESP32. Grundlagen und Details zur Bibliothek findest du in der Anleitung OLED-Display SSD1306.

OLED-PinESP32
GNDGND
VCC3V3
SCLGPIO 22
SDAGPIO 21
C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5#include <Wire.h>
6#include <Adafruit_GFX.h>
7#include <Adafruit_SSD1306.h>
8
9const char* WIFI_SSID = "AgAdi";
10const char* WIFI_PASS = "Sifre123";
11const char* CITY_NAME = "Izmir";                   // ekranda görünecek ad / name shown on screen
12const char* URL = "https://api.open-meteo.com/v1/forecast?latitude=38.42&longitude=27.14"
13                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
14                  "&timezone=auto";
15const unsigned long PERIOD = 10UL * 60UL * 1000UL; // 10 dakikada bir / every 10 minutes
16
17Adafruit_SSD1306 display(128, 64, &Wire, -1);
18unsigned long lastFetch = 0;
19bool firstRun = true;
20
21// WMO kodunu kısa metne çevir / turn a WMO code into a short label
22const char* wmoText(int c) {
23  if (c == 0) return "Acik";                       // açık / clear
24  if (c <= 2) return "Az bulutlu";                 // az bulutlu / partly cloudy
25  if (c == 3) return "Kapali";                     // kapalı / overcast
26  if (c == 45 || c == 48) return "Sis";            // sis / fog
27  if (c >= 51 && c <= 57) return "Ciseleme";       // çiseleme / drizzle
28  if (c >= 61 && c <= 67) return "Yagmur";         // yağmur / rain
29  if (c >= 71 && c <= 77) return "Kar";            // kar / snow
30  if (c >= 80 && c <= 82) return "Saganak";        // sağanak / showers
31  if (c == 85 || c == 86) return "Kar saganagi";   // kar sağanağı / snow showers
32  if (c >= 95) return "Firtina";                   // gök gürültülü fırtına / thunderstorm
33  return "?";
34}
35
36void showMessage(const char* line1, const char* line2) {
37  display.clearDisplay();
38  display.setTextSize(1);
39  display.setCursor(0, 0);
40  display.println(line1);
41  display.println(line2);
42  display.display();
43}
44
45void fetchAndShow() {
46  if (WiFi.status() != WL_CONNECTED) {             // Wi-Fi koptuysa yeniden bağlan / reconnect if Wi-Fi dropped
47    showMessage("Wi-Fi yok", "yeniden baglaniyor");
48    WiFi.reconnect();
49    return;
50  }
51
52  WiFiClientSecure client;
53  client.setInsecure();                            // şifreli, sertifika doğrulamasız / encrypted, no cert check
54  HTTPClient http;
55  http.setTimeout(8000);                           // yavaş ağlar için 8 sn / 8 s for slow networks
56  http.begin(client, URL);
57  int code = http.GET();
58  if (code != HTTP_CODE_OK) {
59    char buf[24];
60    snprintf(buf, sizeof(buf), "HTTP hata %d", code);
61    showMessage(buf, "10 dk sonra tekrar");
62    http.end();
63    return;
64  }
65
66  JsonDocument doc;
67  DeserializationError err = deserializeJson(doc, http.getString());
68  http.end();
69  if (err) { showMessage("JSON hatasi", err.c_str()); return; }
70
71  float temp   = doc["current"]["temperature_2m"];
72  int humidity = doc["current"]["relative_humidity_2m"];
73  int wmo      = doc["current"]["weather_code"];
74  float wind   = doc["current"]["wind_speed_10m"];
75  const char* t = doc["current"]["time"];          // "2026-11-17T14:15"
76
77  display.clearDisplay();
78  display.setTextSize(1);
79  display.setCursor(0, 0);
80  display.print(CITY_NAME);
81  display.setCursor(98, 0);
82  if (t && strlen(t) >= 16) display.print(t + 11); // "T"den sonrası: "14:15" / the part after "T"
83  display.drawLine(0, 10, 127, 10, SSD1306_WHITE);
84
85  display.setTextSize(3);                          // büyük sıcaklık / big temperature
86  display.setCursor(0, 16);
87  display.print(temp, 1);
88  display.setTextSize(1);
89  display.print((char)247);                        // derece işareti / degree sign
90  display.print("C");
91
92  display.setCursor(0, 44);
93  display.print(wmoText(wmo));
94  display.setCursor(0, 55);
95  display.printf("Nem %%%d  Ruzgar %.0f", humidity, wind);
96  display.display();
97}
98
99void setup() {
100  Serial.begin(115200);
101  Wire.begin(21, 22);                              // SDA, SCL
102  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
103    Serial.println("OLED bulunamadi / not found");
104    for (;;);
105  }
106  display.setTextColor(SSD1306_WHITE);
107  display.cp437(true);                             // (char)247 derece olsun / so 247 is the degree sign
108  showMessage("Wi-Fi'ye", "baglaniyor...");
109  WiFi.mode(WIFI_STA);
110  WiFi.begin(WIFI_SSID, WIFI_PASS);
111  while (WiFi.status() != WL_CONNECTED) delay(500);
112}
113
114void loop() {
115  if (firstRun || millis() - lastFetch >= PERIOD) { // delay yerine millis / millis instead of delay
116    firstRun = false;
117    lastFetch = millis();
118    fetchAndShow();
119  }
120}

Beim Start verbindet sich der Sketch mit dem WLAN, holt sofort die ersten Daten und aktualisiert sie danach alle 10 Minuten. Zum Warten nutzen wir millis() statt delay(), damit du nebenbei Tasten abfragen oder eine Animation einbauen kannst, während loop() frei läuft. Reißt die Verbindung ab, zeigt der Code eine Warnung und versucht, sich neu zu verbinden; schlägt eine Anfrage fehl, zeigt er den Fehlercode. Die Uhrzeit oben rechts ist der Teil nach dem Buchstaben T im Text "2026-11-17T14:15" der Antwort, so siehst du ohne eigene Uhr, wann zuletzt gemessen wurde. Willst du eine Uhr, die sekundengenau läuft, ergänze die Methode aus der Anleitung ESP32 NTP-Uhrzeit.

Anzeige auf einem 16x2-I2C-LCD

Hast du statt eines OLEDs ein 16x2-Zeichen-LCD, passen dieselben Daten auf zwei Zeilen. Versorgst du das LCD-Modul über den VIN-Pin des ESP32, der 5 V liefert, wird der Kontrast besser; verbinde SDA mit GPIO 21 und SCL mit GPIO 22. Weil das Modul die I2C-Leitungen auf 5 V hochzieht, ist ein Pegelwandler dazwischen die sicherste Lösung. Ersetze einfach die Zeichenbefehle im OLED-Sketch durch eine Funktion wie die folgende; mehr dazu in der Anleitung I2C-LCD-Display.

C++ (Arduino IDE)
1#include <LiquidCrystal_I2C.h>
2
3LiquidCrystal_I2C lcd(0x27, 16, 2);                // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
4
5// OLED kodundaki ekran kısmının yerine / replaces the OLED drawing part
6void showOnLcd(float temp, int humidity, const char* label) {
7  lcd.clear();
8  lcd.setCursor(0, 0);
9  lcd.print("Izmir ");
10  lcd.print(temp, 1);
11  lcd.print((char)223);                            // LCD'de derece işareti / degree sign on HD44780
12  lcd.print("C");
13  lcd.setCursor(0, 1);
14  lcd.print(label);                                // ör. "Yagmur" / e.g. "Yagmur"
15  lcd.print(" %");
16  lcd.print(humidity);
17}
18
19void setup() {
20  lcd.init();                                      // ESP32'de Wire.begin(21, 22) varsayılan / default pins
21  lcd.backlight();
22  showOnLcd(18.4, 62, "Az bulutlu");
23}
24
25void loop() {
26}

Abrufhäufigkeit und kostenlose Limits

Der häufigste Fehler ist, delay(1000) in loop() zu setzen und jede Sekunde eine Anfrage zu senden. Das ist unnötig und bringt dich schnell an die Grenzen: Die aktuellen Daten von Open-Meteo werden ohnehin nur alle 15 Minuten erneuert, wer jede Sekunde fragt, bekommt 900-mal dieselbe Antwort. Eine Anfrage pro Sekunde ergibt 86.400 am Tag und füllt das Tageslimit von Open-Meteo von 10.000 in weniger als drei Stunden. Die Rechnung ist einfach: Anfragen pro Tag sind 1440 geteilt durch das Intervall in Minuten.

IntervallAnfragen pro TagBewertung
1 Sekunde86.400Limit überschritten, deine IP-Adresse kann vorübergehend gesperrt werden
1 Minute1.440Im Limit, aber verschwendet, weil sich die Daten nicht ändern
10 Minuten144Ideal für eine Schreibtisch-Wetterstation
15 Minuten96Entspricht der Aktualisierung von Open-Meteo
1 Stunde24Reicht für Akkugeräte und Tagesvorhersagen
Bei einer akkubetriebenen Wetterstation zieht das WLAN den meisten Strom. Schickst du den ESP32 nach dem Abruf für 15 Minuten in den Tiefschlaf, sinkt der Durchschnittsstrom beim nackten Modul unter 1 mA und bei einem typischen Entwicklungsboard auf wenige Milliampere, und eine einzige 18650-Zelle hält wochenlang. Details findest du in der Anleitung ESP32 Deep Sleep.

Fehlercodes: 401, 404, 429 und -1

http.GET() liefert zwei Arten von Zahlen. Positive Zahlen sind HTTP-Statuscodes vom Server: Die Verbindung steht, der Server hat dich gehört, aber ihm passt etwas an deiner Anfrage nicht. Negative Zahlen sind eigene Fehlercodes des ESP32 und zeigen, dass die Anfrage den Server nie erreicht hat oder die Antwort abgebrochen ist.

CodeBedeutungWas tun?
200ErfolgInhalt lesen und auswerten
400Fehlerhafte AnfrageParameternamen und Kommas in der Adresse prüfen
401Nicht autorisiert: API-Schlüssel fehlt, ist falsch oder noch nicht aktivSchlüssel neu kopieren; ist er neu, etwas warten
404Nicht gefunden: falscher Städtename oder falsche AdresseStadt in englischer Schreibweise angeben (Munich,DE), Adresse prüfen
429Zu viele AnfragenIntervall verlängern
500-503Problem auf der ServerseiteIn ein paar Minuten erneut versuchen
-1Keine Verbindung: kein Internet, Domain nicht aufgelöst, falsche Adresse oder HTTPS-Handshake fehlgeschlagenWLAN, Adresse und Zertifikat prüfen
-5Verbindung mittendrin abgebrochenWLAN-Signal verbessern, Anfrage wiederholen
-11Zeitüberschreitung beim LesenWartezeit mit http.setTimeout() verlängern

Auch bei Fehlern liefert OpenWeatherMap JSON: Bei falschem Schlüssel kommt {"cod":401, "message":"Invalid API key..."}, bei unbekannter Stadt {"cod":"404","message":"city not found"}. Im ersten Fall ist cod eine Zahl, im zweiten ein Text in Anführungszeichen. Baust du deinen Code auf der Zahl auf, die http.GET() zurückgibt, und nicht auf dem Feld cod, stört dich diese Ungereimtheit nicht.

Große Antworten: Filter, getStream und useHTTP10

Fragst du eine stündliche oder 7-Tage-Vorhersage ab, kann die Antwort von wenigen auf Dutzende Kilobyte wachsen. getString() legt die ganze Antwort erst in einen String und dann in den ArduinoJson-Baum, der Speicher wird also doppelt belegt. Stattdessen kannst du die Antwort mit http.getStream() schon beim Empfang auswerten und mit einem Filter nur die Felder behalten, die du brauchst. Eine Falle gibt es: Schickt der Server die Antwort in Stücken (chunked), mischen sich Stückgrößen in den Stream, und das JSON geht kaputt. Open-Meteo schickt seine Antworten chunked; http.useHTTP10(true) stellt die Anfrage per HTTP/1.0 und zwingt den Server zu einer einfachen Antwort.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";
7const char* WIFI_PASS = "Sifre123";
8const char* URL = "https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
9                  "&daily=temperature_2m_max,temperature_2m_min,weather_code"
10                  "&forecast_days=3&timezone=auto";
11
12void setup() {
13  Serial.begin(115200);
14  WiFi.begin(WIFI_SSID, WIFI_PASS);
15  while (WiFi.status() != WL_CONNECTED) delay(500);
16
17  WiFiClientSecure client;
18  client.setInsecure();
19  HTTPClient http;
20  http.useHTTP10(true);                      // parçalı (chunked) yanıtı kapat / disable chunked replies
21  http.begin(client, URL);
22  if (http.GET() != HTTP_CODE_OK) { http.end(); return; }
23
24  JsonDocument filter;                       // yalnız gereken alanları tut / keep only what we need
25  filter["daily"]["time"] = true;
26  filter["daily"]["temperature_2m_max"] = true;
27  filter["daily"]["temperature_2m_min"] = true;
28  filter["daily"]["weather_code"] = true;
29
30  JsonDocument doc;
31  DeserializationError err = deserializeJson(doc, http.getStream(),   // String yerine akış / stream instead of String
32                                             DeserializationOption::Filter(filter));
33  http.end();
34  if (err) { Serial.println(err.c_str()); return; }
35
36  JsonArray days = doc["daily"]["time"];
37  for (size_t i = 0; i < days.size(); i++) {  // 3 gün / 3 days
38    const char* day = days[i];
39    float tmax = doc["daily"]["temperature_2m_max"][i];
40    float tmin = doc["daily"]["temperature_2m_min"][i];
41    int wmo    = doc["daily"]["weather_code"][i];
42    Serial.printf("%s  en dusuk/min %.0f  en yuksek/max %.0f  kod/code %d\n", day, tmin, tmax, wmo);
43  }
44}
45
46void loop() {
47}

Auf dieselbe Weise kannst du hourly=temperature_2m abfragen und eine 24-Stunden-Temperaturkurve zeichnen oder mit daily=precipitation_probability_max eine LED einschalten, wenn morgen wahrscheinlich Regen kommt. Bei Open-Meteo darf forecast_days höchstens 16 sein; für den ESP32 sind 3 bis 7 Tage ein bequemer Bereich.

Andere APIs, gleiche Methode: Beispiel Wechselkurs

Was du hier gelernt hast, gilt nicht nur fürs Wetter: Adresse, GET, JSON und Auswertung laufen bei allen REST-APIs gleich ab. Der Dienst Frankfurter zum Beispiel veröffentlicht die täglichen Referenzkurse der Europäischen Zentralbank, braucht keinen Schlüssel und liefert Währungen wie Dollar, Euro und türkische Lira mit einer einzigen Anfrage.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";
7const char* WIFI_PASS = "Sifre123";
8// Avrupa Merkez Bankası kurları, anahtar gerekmez / European Central Bank rates, no key needed
9const char* URL = "https://api.frankfurter.dev/v1/latest?from=USD&to=TRY,EUR";
10
11void setup() {
12  Serial.begin(115200);
13  WiFi.begin(WIFI_SSID, WIFI_PASS);
14  while (WiFi.status() != WL_CONNECTED) delay(500);
15
16  WiFiClientSecure client;
17  client.setInsecure();
18  HTTPClient http;
19  http.begin(client, URL);
20  int code = http.GET();
21  if (code == HTTP_CODE_OK) {
22    JsonDocument doc;
23    if (!deserializeJson(doc, http.getString())) {
24      const char* date = doc["date"];          // kurun tarihi / rate date
25      float usdTry = doc["rates"]["TRY"];      // 1 USD kaç TL / how many TRY per USD
26      float usdEur = doc["rates"]["EUR"];
27      Serial.printf("%s  1 USD = %.2f TRY = %.4f EUR\n", date, usdTry, usdEur);
28      Serial.printf("1 EUR = %.2f TRY\n", usdTry / usdEur);   // çapraz kur / cross rate
29    }
30  } else {
31    Serial.printf("Hata / error: %d\n", code);
32  }
33  http.end();
34}
35
36void loop() {
37}

Die Kurse der Zentralbank werden an Werktagen einmal täglich gegen 16:00 Uhr mitteleuropäischer Zeit aktualisiert; selbst eine Anfrage pro Stunde ist also mehr als genug. Mit demselben Gerüst kannst du Erdbebendaten, Kryptopreise, Pegelstände oder einen Wert von deinem eigenen Server abrufen. Es ändern sich nur die Adresse und die Schlüsselnamen im JSON, und die findest du heraus, indem du die Adresse im Browser öffnest und dir die Antwort ansiehst.

Wetter mit dem Raspberry Pi Pico W (MicroPython)

Auf den WLAN-Modellen der Raspberry-Pi-Pico-Familie, dem Pico W und dem Pico 2 W, erledigt das MicroPython-Modul urequests dieselbe Aufgabe, und du brauchst keine eigene JSON-Bibliothek: r.json() verwandelt die Antwort direkt in ein Python-Dictionary. Spiel mit Thonny die aktuelle MicroPython-Firmware auf und speichere den Code als main.py. Details zur WLAN-Verbindung stehen in der Anleitung Pico W WLAN-Webserver.

Python
1import network
2import time
3import urequests
4
5SSID = "AgAdi"
6PASS = "Sifre123"
7URL = ("https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
8       "&current=temperature_2m,relative_humidity_2m,weather_code&timezone=auto")
9
10wlan = network.WLAN(network.STA_IF)
11wlan.active(True)
12wlan.connect(SSID, PASS)
13while not wlan.isconnected():          # bağlanana kadar bekle / wait until connected
14    time.sleep(0.5)
15print("IP:", wlan.ifconfig()[0])
16
17while True:
18    try:
19        r = urequests.get(URL)
20        if r.status_code == 200:
21            now = r.json()["current"]  # JSON -> sözlük / JSON -> dict
22            print(now["time"], now["temperature_2m"], "C",
23                  "%", now["relative_humidity_2m"], "kod/code", now["weather_code"])
24        else:
25            print("HTTP hata / error:", r.status_code)
26        r.close()                      # soketi kapat, belleği boşalt / close socket, free memory
27    except OSError as e:               # ağ hatası / network error
28        print("Baglanti hatasi / connection error:", e)
29    time.sleep(600)                    # 10 dakika bekle / wait 10 minutes

urequests in MicroPython verschlüsselt HTTPS-Verbindungen, prüft aber das Serverzertifikat nicht; das Sicherheitsniveau entspricht setInsecure() auf dem ESP32. Wichtig ist, nach jeder Anfrage r.close() aufzurufen: Vergisst du das, gehen dem Pico nach wenigen Anfragen Sockets und Speicher aus, und der Code bricht mit einem OSError ab.

Projektideen mit dem ESP32-Wetter

  • Wetterstation für den Schreibtisch: Zeig die Open-Meteo-Daten auf einem OLED und ergänze mit einem BME280 Temperatur und Luftdruck im Raum, so siehst du drinnen und draußen nebeneinander.
  • Regenschirm-Erinnerung: Ein ESP32 neben der Haustür schaltet eine rote WS2812B-LED ein, wenn die Regenwahrscheinlichkeit des Tages über 60 Prozent liegt.
  • Intelligente Bewässerung: Wird für morgen Regen erwartet, fällt das Gießen aus; zusammen mit einem Bodenfeuchtesensor verschwendest du kein Wasser.
  • Morgendliche Nachricht: Schick dir jeden Morgen um 07:00 Uhr die Tagesvorhersage per Telegram-Bot aufs Handy.
  • Hausautomation: Übertrage die Außentemperatur per MQTT an Home Assistant und nutze sie für Heizungsentscheidungen.
  • Wetter- und Wechselkurs-Tafel: Zeig Temperatur, 3-Tage-Vorhersage und die Tageskurse als farbige Karten auf einem ILI9341-TFT-Display.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Endlose Punkte im seriellen MonitorKeine WLAN-Verbindung2,4-GHz-Netz, richtiges Passwort, näher an den Router
HTTP-Code -1Problem mit Internet, Domain oder HTTPSAdresse im Browser testen, WiFiClientSecure und Zertifikat prüfen
401 Invalid API keyFalscher oder noch nicht aktiver SchlüsselSchlüssel neu kopieren; bei neuem Konto etwas warten
JSON-Fehler InvalidInputAntwort ist kein JSON (HTML-Fehlerseite)Antwort zuerst mit getString() ausgeben
JSON-Fehler IncompleteInputAntwort abgeschnitten oder chunked StreamgetString() nutzen oder useHTTP10(true) ergänzen
Temperatur immer 0.00Schlüsselname falsch geschriebenNamen exakt aus dem JSON kopieren (temperature_2m)
Seltsame Zeichen auf dem DisplayUmlaute oder °-Zeichen fehlen in der Schriftlang=en verwenden, Gradzeichen mit (char)247 ausgeben
Hänger nach einigen StundenNicht geschlossene Verbindungen, SpeicherfragmentierungNach jeder Anfrage http.end() aufrufen, Intervall verlängern
Am einfachsten grenzt du ein Problem ein, indem du die Adresse zuerst in den Browser auf deinem Computer einfügst. Siehst du dort sauberes JSON, liegt das Problem beim ESP32 (WLAN, Zertifikat oder Auswertung); zeigt auch der Browser einen Fehler, musst du die Adresse oder den API-Schlüssel korrigieren.

Ein ESP32-Wetterprojekt lehrt dich das Grundmuster jedes vernetzten Geräts: verbinden, anfragen, auswerten, anzeigen und in sinnvollen Abständen wiederholen. Sitzt dieses Muster einmal, kannst du mit demselben Code Daten von Hunderten verschiedener APIs abrufen. In der BlueGrays-App findest du Projekte, die eine Wetter-API mit ESP32 HTTPClient auf einem LCD und einem SSD1306-OLED anzeigen, dazu Projekte zu WLAN-Verbindung und NTP-Uhr, jeweils mit Schaltplan und Code Schritt für Schritt.

Häufige Fragen

Wie bekomme ich Wetterdaten mit dem ESP32?

Verbinde den ESP32 mit dem WLAN und schick mit der Bibliothek HTTPClient eine GET-Anfrage an einen Dienst wie Open-Meteo oder OpenWeatherMap. Temperatur, Luftfeuchtigkeit und Wettercode liest du dann mit ArduinoJson aus der JSON-Antwort. Open-Meteo braucht keinen API-Schlüssel und ist deshalb für den ersten Versuch am einfachsten.

Ist die Open-Meteo API kostenlos?

Open-Meteo ist für nicht kommerzielle Nutzung kostenlos und braucht weder Anmeldung noch API-Schlüssel. Kostenlos sind bis zu 10.000 Abrufe am Tag, 5.000 pro Stunde und 600 pro Minute erlaubt. Für ein kommerzielles Produkt brauchst du einen kostenpflichtigen Tarif.

Warum liefert mein OpenWeatherMap API-Schlüssel den Fehler 401?

Ein 401 bedeutet, dass der Schlüssel falsch ist, fehlt oder noch nicht aktiviert wurde. Neu erstellte Schlüssel brauchen einige Minuten bis wenige Stunden, bis sie aktiv sind. Prüfe, ob du den Schlüssel ohne Leerzeichen kopiert und in der Adresse mit dem Parameter appid= übergeben hast.

Was bedeutet HTTP-GET-Fehler -1 beim ESP32?

-1 ist HTTPC_ERROR_CONNECTION_REFUSED und bedeutet, dass überhaupt keine Verbindung zustande kam. Ursache ist meist fehlendes Internet, ein Domainname, der nicht aufgelöst werden kann, eine vertippte Adresse oder ein HTTPS-Server mit falschem Zertifikat. Mit http.errorToString(code) gibst du die Beschreibung im seriellen Monitor aus.

Wie oft sollte ein ESP32 das Wetter abrufen?

Alle 10 bis 15 Minuten reicht, denn die Dienste erneuern ihre Daten ungefähr in diesem Takt. Das sind 96 bis 144 Anfragen am Tag, weit unter den kostenlosen Limits. Wer jede Sekunde fragt, verschwendet Energie und riskiert eine Sperre.

Was ist der Unterschied zwischen ArduinoJson 6 und 7?

ArduinoJson 7 ersetzt StaticJsonDocument und DynamicJsonDocument durch eine einzige Klasse JsonDocument, die den Speicher selbst verwaltet. Alter Code kompiliert weiterhin mit einer Warnung, in neuen Projekten genügt JsonDocument doc;. Das Auswerten und das Auslesen mit doc["schluessel"] sind in beiden Versionen gleich.

Alle Projekte ansehen
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 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)

Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

4.3(10)
22
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 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
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
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