In diesem Tutorial lernst du die Grundlagen, wie du deine eigene Internet-Wetterstation mit einem ESP32 baust.
Wir werden Wetterdaten von OpenWeather herunterladen, JSON-Daten mit ArduinoJson parsen, um Temperatur, Luftfeuchtigkeit, Standort und Wetterbeschreibung zu extrahieren, und diese Informationen auf einem OLED anzeigen.
Los geht’s!
Benötigte Teile
Unten findest du die für dieses Projekt benötigten Teile. Für dieses Projekt verwende ich ein älteres ESP32-Board (ESP32 lite), das zwar abgekündigt ist, aber immer noch erhältlich. Das ist das unten aufgeführte Modell. Es gibt einen Nachfolger mit besseren Spezifikationen, den du findest here . Aber jeder andere ESP32, ESP8266 oder Arduino mit Wi-Fi funktioniert ebenfalls.
ESP32 lite
USB-Datenkabel
Dupont-Kabelset
Breadboard
OLED-Display
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
OpenWeather
Für unsere Internet-Wetterstation müssen wir natürlich Wetterdaten aus dem Internet herunterladen. Es gibt verschiedene Möglichkeiten, das zu tun, aber am einfachsten ist es, OpenWeather zu verwenden.
OpenWeather ist ein Dienst, der aktuelle Wetterdaten und Vorhersagen über eine API bereitstellt, die Entwickler in ihren Projekten nutzen können. Sie bieten einen kostenlosen plan Tarif, mit dem du 1000 API-Aufrufe pro Tag machen kannst. Das entspricht einem API-Aufruf alle 60* 60* 24/1000 = 86,4 Sekunden und ist mehr als ausreichend, da ein Update alle 5 oder 10 Minuten völlig genügt.
Außerdem liefert schon der kostenlose Tarif Informationen zu Current Weather , 3-hour Forecast 5 days , Basic weather maps , Air Pollution und Geocoding . Das reicht für die meisten Hobby-Anwendungen völlig aus.
OpenWeather-Konto erstellen
Bevor du eine der OpenWeather-APIs nutzen kannst, brauchst du einen API-Key, und dafür benötigst du ein Konto. Um ein Konto zu erstellen, gehe auf die sign-up Seite und gib dort deine Daten ein.
OpenWeather API-Key erstellen
Sobald du ein Konto hast und angemeldet bist, gehe zur api-key Erstellungsseite und erstelle einen API-Key. Der API-Key ist dieser lange String „sdfd87fakeby6apikeysf4z“, den du im Screenshot unten siehst. Dein Key wird anders aussehen als meiner, und der gezeigte ist natürlich ein Fake-Key ; )
Du kannst dem Key einen Namen geben, musst aber nicht. Namen sind praktisch, wenn du mehrere Anwendungen mit unterschiedlichen Keys hast und diese auseinanderhalten möchtest.
OpenWeather Wetterdaten herunterladen
Mit deinem API-Key kannst du jetzt Wetterdaten von den verschiedenen APIs abrufen, indem du die entsprechende URL zusammenstellst. Wenn du zum Beispiel zur Current Weather API gehst, zeigt dir die Dokumentation, dass die URL so aussehen sollte:
https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API key}
Du musst also die Breiten- und Längengrade deines Standorts sowie deinen API-Key kennen und die Platzhalter in geschweiften Klammern ( {lat} , {lon} , {API key} ) durch die tatsächlichen Werte ersetzen. Das funktioniert, aber die Koordinaten für verschiedene Städte herauszufinden, ist etwas umständlich.
Zum Glück gibt es die Geocoding API , mit der wir die Wetterdaten einfacher bekommen, indem wir einfach den Stadtnamen und den Ländercode als String angeben. Das URL-Muster sieht so aus:
https://api.openweathermap.org/data/2.5/weather?q={city name},{country code}&appid={API key}
Um zum Beispiel das Wetter in Melbourne, Australien (AU) abzurufen, wo ich wohne, würdest du schreiben:
http://api.openweathermap.org/data/2.5/weather?q=Melbourne,AU&APPID=sdfd87fakeby6apikeysf4z
Wenn du diese URL in die Suchleiste deines Browsers einfügst, siehst du die folgende Ausgabe. Achte darauf, das Kästchen „Pretty print“ oben zu aktivieren.
Wenn du dir die Temperatur anschaust, fällt dir ein extrem hoher Wert auf. Im obigen Beispiel ist der gemeldete Temperaturwert 283,38. Das liegt daran, dass OpenWeather standardmäßig Temperaturen in Kelvin zurückgibt. Wenn du metrische (Celsius) oder imperiale (Fahrenheit) Einheiten möchtest, kannst du das in der URL angeben.
Um zum Beispiel die Temperaturen in Celsius zu bekommen, musst du folgendes verwenden:
https://api.openweathermap.org/data/2.5/weather?q={city name},{country code}&appid={API key}&units=metric
und für Fahrenheit würdest du units=imperial schreiben. Für mehr Infos schau in die OpenWeather-Dokumentation zu units of measurement .
Das ist alles, was du wissen musst, um mit OpenWeather loszulegen. Ich empfehle dir aber, auch die anderen oben genannten APIs durchzusehen. Es gibt viele coole Daten, mit denen du deine Wetterstation richtig nützlich machen kannst.
JSON-Daten mit ArduinoJson parsen
Standardmäßig liefert OpenWeather Daten im JSON Format. JSON ist ein strukturiertes Textformat, das wir parsen müssen, um die gewünschten Daten zu extrahieren. Das ist ziemlich aufwendig, wenn man es selbst implementiert, deshalb nutzen wir die großartige ArduinoJson Bibliothek.
JSON-Dokument
Schauen wir uns zuerst an, welche Informationen wir aus den Wetterdaten extrahieren möchten. Der Screenshot unten zeigt die kompletten Daten, die ich von OpenWeather für das Wetter in Melbourne bekomme.
Für unsere einfache Internet-Wetterstation werde ich vier Informationen extrahieren: Die kurze Wetterbeschreibung unter weather -> main ( "Clouds" ), die aktuelle Temperatur unter main -> temp ( 10.29 ), die aktuelle relative Luftfeuchtigkeit unter main -> humidity ( 82 ) und den Namen des Standorts unter name ( "Melbourne" ).
Daten mit ArduinoJson extrahieren
Ein Code-Snippet mit ArduinoJson , um diese vier Wetterwerte zu extrahieren, sieht so aus:
StaticJsonDocument<4096> doc; String json = http.getString(); deserializeJson(doc, json); const char* name = doc["name"]; const char* weather = doc["weather"][0]["main"]; float temp = doc["main"]["temp"]; int hum = doc["main"]["humidity"];
Zuerst musst du etwas Speicher für die JSON-Daten reservieren. Die Zeile StaticJsonDocument<4096> doc; reserviert 4 KB Speicher. Wenn du mehr Wetterdaten herunterlädst, z.B. Wettervorhersagen, musst du diesen Wert eventuell erhöhen.
Als nächstes laden wir die Wetterdaten herunter und schreiben (deserialisieren) sie ins Dokument. Das Code-Snippet zeigt den verwendeten HTTP-Client nicht, aber du findest ihn im vollständigen Code unten.
String json = http.getString(); deserializeJson(doc, json);
Wenn die von OpenWeather zurückgegebenen JSON-Daten syntaktisch fehlerhaft wären (fehlende Klammern, …), schlägt die Deserialisierung fehl.
Deserialisierung bedeutet einfach, dass der Klartext der json Zeichenkette geparst und in eine Datenstruktur umgewandelt wird, mit der wir einfacher auf die Felder und Werte des JSON-Dokuments doc zugreifen können. Für mehr Details zur Deserialisierung schau in die exzellente ArduinoJson tutorial on deserialization .
Die folgenden vier Codezeilen extrahieren die gewünschten Informationen aus dem doc , das die deserialisierte json Zeichenkette enthält.
const char* name = doc["name"]; const char* weather = doc["weather"][0]["main"]; float temp = doc["main"]["temp"]; int hum = doc["main"]["humidity"];
Die erste Zeile extrahiert den Namen des Wetterstandorts ( "Melbourne" ), der unter doc["name"] gespeichert ist. Da dies als String gespeichert ist (siehe Anführungszeichen), müssen wir es in einer const char* name Variable speichern.
Die kurze Wetterbeschreibung ( "Clouds" ) ist unter doc["weather"][0]["main"] gespeichert. Beachte, dass unter doc["weather"] eine Liste [] steht und wir das erste (und einzige) Element dieser Liste wollen. Deshalb müssen wir doc["weather"][0] schreiben. Dann bekommen wir die Beschreibung unter main , und der komplette Pfad ist doc["weather"][0]["main"] . Auch das ist ein String und muss in einer const char* weather gespeichert werden.
Die aktuelle Temperatur ist ein Gleitkommawert (10,29), der unter doc["main"]["temp"] liegt. Da es ein Gleitkommawert ist, muss er in einer float Variable gespeichert werden.
Schließlich extrahieren wir die aktuelle Luftfeuchtigkeit ( 82 ) aus doc["main"]["humidity"] und speichern sie in einer Variable vom Typ int .
Du musst sehr darauf achten, die Datentypen der Werte mit denen im JSON-Dokument abzugleichen und die richtigen Pfade zu verwenden, um diese Werte zu extrahieren. Andernfalls bekommst du schwer zu findende Speicherfehler. Wenn du andere Werte extrahieren willst, fang langsam an und füge neue Werte Schritt für Schritt hinzu, damit du weißt, wann etwas schiefgeht.
ESP32 und OLED verbinden
Das Anschließen des ESP32 an das OLED ist sehr einfach, da das OLED eine I2C-Schnittstelle hat. Zuerst verbindest du Ground (G) des ESP32 mit GND des OLED. Dann verbindest du 3V des ESP32 mit VCC des OLED.
Jetzt müssen wir noch SCL und SDA verbinden. Jeder Pin funktioniert, aber die Standard-I2C-Pins beim ESP32-lite sind 23 für SCL und 19 für SDA. Also verbindest du die entsprechenden Pins des OLED mit diesen. Das Bild oben zeigt die komplette Verdrahtung. Wenn du damit Schwierigkeiten hast, schau ins Tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino
Wenn du nicht weißt, welche die Standard-I2C-Pins deines ESP32 sind, keine Sorge. Das findest du leicht heraus. Einfach folgenden Code ausführen und dein ESP32 sagt es dir.
void print(const char* name, int pin) {
Serial.print(name);
Serial.println(pin);
}
void setup() {
Serial.begin(9600);
}
void loop() {
print("SDA: ", SDA);
print("SCL: ", SCL);
delay(5000);
}
Für mehr Infos lies unseren Beitrag darüber, Find I2C and SPI default pins . Alternativ kannst du die Pins auch selbst festlegen. Der Code in den folgenden Abschnitten zeigt dir, wie das geht.
Code für die Internet-Wetterstation
In diesem Abschnitt schreiben wir den Code, um Wetterdaten von OpenWeather herunterzuladen, Standort, Temperatur, Luftfeuchtigkeit und Wetterbeschreibung zu extrahieren und sie auf einem OLED anzuzeigen. Schau dir zuerst den vollständigen Code unten an, danach besprechen wir die Details.
#include "WiFi.h"
#include "HTTPClient.h"
#include "ArduinoJson.h"
#include "Adafruit_SSD1306.h"
#define WIFI_SSID "YOURSSID"
#define WIFI_PASSWORD "YOURPASSWORD"
#define URL "http://api.openweathermap.org/data/2.5/weather?q=Melbourne,AU&APPID=YOURAPIKEY&units=metric"
HTTPClient http;
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
StaticJsonDocument<4096> doc;
void downloadWeather() {
http.begin(URL);
if (http.GET() > 0) {
String json = http.getString();
auto err = deserializeJson(doc, json);
if (err) {
Serial.printf("Deserializion error: %s\n", err.f_str());
}
} else {
Serial.println("Could not get data!");
}
http.end();
}
void displayWeather() {
const char* name = doc["name"];
const char* weather = doc["weather"][0]["main"];
float temp = doc["main"]["temp"];
int hum = doc["main"]["humidity"];
oled.clearDisplay();
oled.setCursor(0, 0);
oled.printf(" %s\n", name);
oled.printf(" %s\n", weather);
oled.printf(" T: %.1f C\n", temp);
oled.printf(" H: %d %%\n", hum);
oled.display();
}
void oled_init() {
Wire.begin(19, 23); // sda, scl
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void wifi_init() {
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
while (WiFi.status() != WL_CONNECTED)
delay(500);
}
void setup(void) {
Serial.begin(115200);
oled_init();
wifi_init();
}
void loop() {
downloadWeather();
displayWeather();
delay(10*60*1000); // 10min
}
Bibliotheken
Der Code beginnt mit dem Einbinden der benötigten Bibliotheken. WiFi.h für den WLAN-Zugang, HTTPClient.h zum Herunterladen von Daten via HTTP, ArduinoJson.h zum Parsen der heruntergeladenen Daten und Adafruit_SSD1306.h zur Anzeige der Daten auf dem OLED.
WiFi.h und HTTPClient.h sind Standardbibliotheken, aber ArduinoJson.h und Adafruit_SSD1306.h musst du über den Library Manager installieren.
Konstanten
Als nächstes definieren wir einige Konstanten. Konkret unsere WLAN-Zugangsdaten und die URL zur OpenWeather API, von der wir unsere Wetterdaten herunterladen. Du kannst die URL ändern, um Wetterdaten für einen anderen Ort oder in einer anderen Einheit zu bekommen, aber vergiss nicht, deinen API-Key zu verwenden.
#define WIFI_SSID "YOURSSID" #define WIFI_PASSWORD "YOURPASSWORD" #define URL "http://api.openweathermap.org/data/2.5/weather?q=Melbourne,AU&APPID=YOURAPIKEY&units=metric"
Schau dir die API-Dokumentation zu Current Weather an, die dir alle Möglichkeiten zeigt, wie du eine URL zusammenstellen kannst. Sieh dir auch die Geocoding API an, die die Nutzung von Standorten vereinfacht.
Objekte
Für den restlichen Code brauchen wir drei Objekte: Einen HTTPClient , mit dem wir Daten von einer Website herunterladen, ein StaticJsonDocument zum Speichern der deserialisierten Daten und ein oled Objekt, um die Daten auf dem OLED anzuzeigen.
HTTPClient http; Adafruit_SSD1306 oled(128, 64, &Wire, -1); StaticJsonDocument<4096> doc;
Für das OLED musst du die Abmessungen angeben, in meinem Fall sind das 128×64 Pixel, und für das JSON-Dokument müssen wir den maximal benötigten Speicher reservieren. Ich habe großzügig 4kB (4069 Bytes) reserviert, das reicht für die aktuellen Wetterdaten. Wenn du die Wettervorhersage herunterlädst, die größer ist, musst du eventuell mehr Speicher reservieren.
downloadWeather
Die downloadWeather Funktion lädt die Wetterdaten von OpenWeather über http.GET() herunter, deserialisiert sie und speichert sie im StaticJsonDocument über deserializeJson ().
void downloadWeather() {
http.begin(URL);
if (http.GET() > 0) {
String json = http.getString();
auto err = deserializeJson(doc, json);
if (err) {
Serial.printf("Deserializion error: %s\n", err.f_str());
}
} else {
Serial.println("Could not get data!");
}
http.end();
}
Wenn etwas schiefgeht, geben wir eine Fehlermeldung im Serial Monitor aus.
displayWeather
Um das Wetter anzuzeigen, extrahieren wir zuerst die vier Wetterinformationen aus dem doc wie oben beschrieben. Dann löschen wir das Display, setzen den Cursor und drucken einfach den Standortnamen, die kurze Wetterbeschreibung, die aktuelle Temperatur und die relative Luftfeuchtigkeit.
void displayWeather() {
const char* name = doc["name"];
const char* weather = doc["weather"][0]["main"];
float temp = doc["main"]["temp"];
int hum = doc["main"]["humidity"];
oled.clearDisplay();
oled.setCursor(0, 0);
oled.printf(" %s\n", name);
oled.printf(" %s\n", weather);
oled.printf(" T: %.1f C\n", temp);
oled.printf(" H: %d %%\n", hum);
oled.display();
}
Auf dem OLED werden die Wetterdaten wie im Bild unten angezeigt.
oledInit
Bevor wir das OLED nutzen können, müssen wir es initialisieren. Am wichtigsten ist, dass wir die für die I2C-Schnittstelle verwendeten Pins (SDA, SCL) und die I2C-Adresse des Displays angeben.
Wenn du die Standard-I2C-Pins deines Mikrocontrollers verwendest, musst du Wire.begin() nicht aufrufen, sonst schon.
Die I2C-Adresse des von mir verwendeten OLED ist 0x3C, was häufig vorkommt, aber deine könnte anders sein. Schau ins Tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino , wenn du Probleme hast.
void oled_init() {
Wire.begin(19, 23); // sda, scl
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Ansonsten löschen wir einfach das Display und stellen Textgröße und -farbe ein.
wifiInit
Ähnlich wie beim OLED müssen wir auch die WLAN-Verbindung initialisieren. Achte darauf, die richtige ssid und das richtige Passwort zu verwenden, sonst verbindet sich der WLAN-Client nicht.
void wifi_init() {
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
while (WiFi.status() != WL_CONNECTED)
delay(500);
}
setup
Mit den obigen Hilfsfunktionen ist die setup Funktion sehr einfach geworden. Wir initialisieren nur die serielle Kommunikation, das OLED und das WLAN – das war’s.
void setup(void) {
Serial.begin(115200);
oled_init();
wifi_init();
}
loop
Auch die loop-Funktion ist einfach. Wir laden die Wetterdaten herunter, zeigen sie auf dem OLED an und warten dann 10 Minuten, bevor wir den Vorgang wiederholen.
void loop() {
downloadWeather();
displayWeather();
delay(10*60*1000); // 10min
}
Achte beim Implementieren und Testen darauf, dass du eine ausreichend große Verzögerung beim Herunterladen der Wetterdaten hast. Wenn du mehr als 1000 Aufrufe pro Tag machst, wirst du für diesen Tag gesperrt.
Ansonsten war’s das! Jetzt hast du eine kleine, feine Internet-Wetterstation!
Fazit
In diesem Tutorial hast du gelernt, wie man eine Internet-Wetterstation baut. Sie ist zwar sehr einfach, aber ein super Ausgangspunkt für eine viel fortschrittlichere Wetterstation.
Schau dir die anderen APIs von OpenWeather an und überlege, welche Daten du noch extrahieren möchtest. Die von OpenWeather zurückgegebenen Daten enthalten sogar Icon-IDs, mit denen du Wettersymbole anzeigen kannst.
Vielleicht möchtest du auf ein größeres Display umsteigen als das kleine OLED, das wir hier verwendet haben. Einige der Elecrow-Displays mit integriertem ESP32 und Touchscreen könnten eine gute Wahl sein. Siehe das CrowPanel 2.8″ ESP32 Display : Easy Setup Guide , um zu erfahren, wie man eines davon verwendet.
Zusätzlich zu den Internet-Wetterdaten könntest du auch lokale Wetterdaten mit Temperatur-, Feuchtigkeits- und Luftqualitätssensoren erfassen.
Schließlich machen Projekte Spaß, bei denen du aktiv auf Wetteränderungen reagierst und z.B. Sprinkler einschaltest, Fenster schließt oder die Klimaanlage aktivierst.
Viel Spaß ; )
