JSON-APIs mit Mikrocontrollern nutzen
Eine JSON-API liefert strukturierte Daten über HTTP oder HTTPS. Damit kannst du Wetterwerte, Fahrpläne, Sensordaten, Kryptowährungskurse oder Daten aus deinem eigenen Webservice auf einem Arduino, ESP8266 oder ESP32 verwenden.
Der grundlegende Ablauf ist immer gleich:
- Das Gerät verbindet sich mit dem WLAN.
- Es sendet einen HTTP-Request an einen API-Endpunkt.
- Der Server antwortet mit einem HTTP-Statuscode und JSON-Daten.
- ArduinoJson wandelt den JSON-Text in Werte um, die dein Sketch verwenden kann.
- Dein Programm prüft Fehler, fehlende Felder und Speichergrenzen.
Voraussetzungen und Bibliotheken
Für ESP8266, ESP32 und Arduino UNO R4 benötigst du in der Arduino IDE jeweils das passende Board-Paket. Zusätzlich installierst du über den Bibliotheksverwalter die Bibliothek ArduinoJson von Benoit Blanchon.
- ESP8266: ESP8266WiFi und ESP8266HTTPClient sind im Board-Paket enthalten.
- ESP32: WiFi und HTTPClient sind im Board-Paket enthalten.
- Arduino Uno R3/Nano: benötigt ein Netzwerkmodul, etwa Ethernet W5100/W5500 oder ein WLAN-Modul.
- Arduino Uno R4 WiFi: WLAN ist über die Bibliothek WiFiS3 bereits integriert; für komfortable Requests kommt ArduinoHttpClient dazu.
- ArduinoJson: übernimmt das Parsen, also das Auslesen einzelner Werte aus JSON.
Für Tests eignet sich eine öffentliche API ohne Anmeldung besonders gut. In echten Projekten solltest du die Nutzungsbedingungen, das Abfragelimit und gegebenenfalls einen API-Schlüssel beachten.
HTTP und JSON kurz erklärt
Der HTTP-Request
Ein HTTP-Request besteht mindestens aus einer Methode und einer Adresse. Für das Abrufen von Daten verwendest du meist GET.
GET /api/weather?city=Karlsruhe HTTP/1.1
Host: example.org
Accept: application/jsonDer Server antwortet mit einem Statuscode. Besonders wichtig sind diese Codes:
- 200 OK: Anfrage war erfolgreich.
- 301 oder 302: Die Adresse wurde weitergeleitet.
- 400 Bad Request: Die Anfrage ist fehlerhaft.
- 401 Unauthorized: API-Schlüssel fehlt oder ist ungültig.
- 404 Not Found: Der API-Endpunkt existiert nicht.
- 429 Too Many Requests: Abfragelimit wurde überschritten.
- 500 bis 599: Fehler auf dem Server der API.
JSON-Strukturen verstehen
JSON besteht aus Objekten mit geschweiften Klammern, Arrays mit eckigen Klammern sowie Zahlen, Texten, Wahrheitswerten und null.
___STEADY_PAYWALL___{
"city": "Karlsruhe",
"temperature": 21.4,
"rain": false,
"forecast": [
{ "day": "Mon", "max": 23 },
{ "day": "Tue", "max": 20 }
]
}Die Werte greifst du über ihre Schlüssel und Array-Indizes ab:
const char* city = doc["city"];
float temperature = doc["temperature"];
bool rain = doc["rain"];
int maxTomorrow = doc["forecast"][1]["max"];ESP32: JSON per HTTP abrufen
Das folgende Beispiel verbindet einen ESP32 mit deinem WLAN, ruft einen Endpunkt ab und verarbeitet die Antwort direkt aus dem Netzwerkstream. Das spart RAM, weil der gesamte JSON-Text nicht zuerst in einem großen String abgelegt wird. Hier ein Sketch mit einer Abfrage an einer Beispiel-API. Am Ende dieses Tutorials findest du einen Sketch mit einer echten Abfrage: Dem Zeitpunkt des nächsten Überflugs der International Space Station.
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
const char* ssid = "DEIN_WLAN";
const char* password = "DEIN_PASSWORT";
// Beispieladresse durch den Endpunkt deiner API ersetzen
const char* apiUrl = "http://example.org/api/data";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("WLAN-Verbindung wird aufgebaut");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WLAN verbunden");
WiFiClient client;
HTTPClient http;
http.setTimeout(10000);
http.begin(client, apiUrl);
int httpCode = http.GET();
if (httpCode == HTTP_CODE_OK) {
JsonDocument doc;
DeserializationError error = deserializeJson(doc, http.getStream());
if (error) {
Serial.print("JSON-Fehler: ");
Serial.println(error.c_str());
} else {
const char* city = doc["city"] | "unbekannt";
float temperature = doc["temperature"] | -999.0;
Serial.print("Ort: ");
Serial.println(city);
Serial.print("Temperatur: ");
Serial.println(temperature);
}
} else {
Serial.print("HTTP-Fehler: ");
Serial.println(httpCode);
}
http.end();
}
void loop() {
}Der Operator | definiert einen Standardwert. Falls ein Feld fehlt oder nicht den erwarteten Typ hat, stürzt dein Sketch nicht wegen eines ungültigen Zeigers ab.
ESP8266: Unterschiede beim HTTP-Request
Beim ESP8266 ist der Ablauf nahezu identisch. Der wichtigste Unterschied ist die verwendete WLAN-Bibliothek. Bei aktuellen ESP8266-Core-Versionen übergibst du für HTTP eine WiFiClient-Instanz an begin().
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ArduinoJson.h>
const char* ssid = "DEIN_WLAN";
const char* password = "DEIN_PASSWORT";
const char* apiUrl = "http://example.org/api/data";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
WiFiClient client;
HTTPClient http;
http.setTimeout(10000);
http.begin(client, apiUrl);
int httpCode = http.GET();
if (httpCode == HTTP_CODE_OK) {
JsonDocument doc;
DeserializationError error = deserializeJson(doc, http.getStream());
if (!error) {
int value = doc["value"] | 0;
Serial.print("API-Wert: ");
Serial.println(value);
} else {
Serial.println(error.c_str());
}
} else {
Serial.printf("HTTP-Anfrage fehlgeschlagen: %d\n", httpCode);
}
http.end();
}
void loop() {
}Arduino Uno R4 WiFi: WLAN und JSON ohne Zusatzmodul
Der Arduino Uno R4 WiFi nimmt eine Sonderstellung ein: Er hat den Formfaktor eines klassischen Uno, bringt aber dank des Renesas RA4M1 rund 32 KB SRAM mit und besitzt über ein integriertes ESP32-S3-Modul bereits WLAN an Bord. Damit eignet er sich für JSON-APIs deutlich besser als ein Uno R3, der ein separates Netzwerkmodul benötigt.
Die WLAN-Funktionen sprichst du über die Bibliothek WiFiS3 an, die im Board-Paket „Arduino UNO R4 Boards“ enthalten ist. Für komfortable HTTP-Requests kombinierst du sie mit der Bibliothek ArduinoHttpClient. Der Ablauf unterscheidet sich dadurch etwas von ESP32 und ESP8266: Statt einer HTTPClient-Klasse mit begin() und GET() nutzt du hier ein HttpClient-Objekt mit get() und responseStatusCode().
#include <WiFiS3.h>
#include <ArduinoHttpClient.h>
#include <ArduinoJson.h>
const char* ssid = "DEIN_WLAN";
const char* password = "DEIN_PASSWORT";
// Host, Port und Pfad deiner API
const char* host = "example.org";
const int port = 80;
const char* path = "/api/data";
WiFiClient wifi;
HttpClient http = HttpClient(wifi, host, port);
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("WLAN-Verbindung wird aufgebaut");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WLAN verbunden");
int err = http.get(path);
if (err != 0) {
Serial.print("Request fehlgeschlagen: ");
Serial.println(err);
return;
}
int statusCode = http.responseStatusCode();
if (statusCode == 200) {
// Header ueberspringen, dann direkt aus dem Stream parsen
http.skipResponseHeaders();
JsonDocument doc;
DeserializationError error = deserializeJson(doc, http);
if (error) {
Serial.print("JSON-Fehler: ");
Serial.println(error.c_str());
} else {
const char* city = doc["city"] | "unbekannt";
float temperature = doc["temperature"] | -999.0;
Serial.print("Ort: ");
Serial.println(city);
Serial.print("Temperatur: ");
Serial.println(temperature);
}
} else {
Serial.print("HTTP-Fehler: ");
Serial.println(statusCode);
}
http.stop();
}
void loop() {
}Da das HttpClient-Objekt selbst ein Stream ist, kannst du es nach skipResponseHeaders() direkt an deserializeJson() übergeben. So sparst du dir auch hier den Umweg über einen großen String.
Für HTTPS ersetzt du WiFiClient durch WiFiSSLClient. Das WLAN-Modul des R4 bringt bereits gängige Root-Zertifikate mit, sodass viele öffentliche HTTPS-APIs ohne eigene Zertifikatsverwaltung funktionieren.
HTTPS und Zertifikate
Viele moderne APIs akzeptieren ausschließlich HTTPS. Das ist richtig und wichtig, erhöht auf Mikrocontrollern aber den Aufwand: Der Client muss das TLS-Zertifikat des Servers prüfen können.
Auf dem ESP32 verwendest du dafür üblicherweise WiFiClientSecure. Für ein dauerhaftes Projekt solltest du das Root-Zertifikat der ausstellenden Zertifizierungsstelle hinterlegen.
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
WiFiClientSecure secureClient;
// Nur zum Testen: Zertifikat wird nicht geprüft!
secureClient.setInsecure();
HTTPClient http;
http.begin(secureClient, "https://example.org/api/data");
int httpCode = http.GET();Wichtig: setInsecure() ist bequem für einen schnellen Test, prüft aber nicht, ob du wirklich mit dem gewünschten Server verbunden bist. In produktiven Projekten solltest du ein passendes Root-Zertifikat mit setCACert() verwenden.
Der ESP8266 kann HTTPS ebenfalls verarbeiten, verfügt aber über weniger RAM. Besonders große HTTPS-Antworten und umfangreiche Zertifikatsketten können dort problematisch werden.
ArduinoJson richtig einsetzen
JSON direkt aus dem Stream parsen
Die sparsamste Variante ist das direkte Parsen aus http.getStream(). ArduinoJson liest dabei Zeichen für Zeichen aus der HTTP-Antwort.
JsonDocument doc;
DeserializationError error = deserializeJson(doc, http.getStream());
if (error) {
Serial.println(error.c_str());
return;
}Vermeide nach Möglichkeit diese Variante bei großen Antworten:
String payload = http.getString();
JsonDocument doc;
deserializeJson(doc, payload);Sie funktioniert, benötigt aber zusätzlich Speicher für den kompletten Antworttext. Auf einem ESP8266 kann eine fragmentierte Heap-Speicherverwaltung dadurch nach längerer Laufzeit zu Abstürzen führen.
Verschachtelte Objekte und Arrays auslesen
{
"main": {
"temp": 18.6,
"humidity": 64
},
"weather": [
{
"description": "leicht bewölkt"
}
]
}float temperature = doc["main"]["temp"] | -999.0;
int humidity = doc["main"]["humidity"] | -1;
const char* description =
doc["weather"][0]["description"] | "keine Daten";Prüfe bei optionalen Daten zusätzlich, ob ein Objekt oder Array vorhanden ist:
if (doc["weather"].is<JsonArray>() &&
!doc["weather"].as<JsonArray>().isNull()) {
const char* text = doc["weather"][0]["description"] | "unbekannt";
Serial.println(text);
}Große API-Antworten mit Filtern verkleinern
Viele APIs liefern viel mehr Daten, als dein Projekt benötigt. Wenn dich beispielsweise nur Temperatur und Luftfeuchte interessieren, solltest du nicht die komplette Vorhersage mit Dutzenden Einträgen im Speicher ablegen.
ArduinoJson kann beim Deserialisieren einen Filter verwenden. Nicht benötigte Zweige werden dann übersprungen.
JsonDocument filter;
filter["main"]["temp"] = true;
filter["main"]["humidity"] = true;
filter["weather"][0]["description"] = true;
JsonDocument doc;
DeserializationError error = deserializeJson(
doc,
http.getStream(),
DeserializationOption::Filter(filter)
);
if (!error) {
float temp = doc["main"]["temp"] | -999.0;
int humidity = doc["main"]["humidity"] | -1;
const char* weather = doc["weather"][0]["description"] | "unbekannt";
}Ein Filter reduziert vor allem den Speicherbedarf des erzeugten JSON-Dokuments. Die Daten müssen je nach Übertragungsart trotzdem vollständig aus dem Netzwerk gelesen werden.
Speicherlimits auf Arduino, ESP8266 und ESP32
JSON ist textbasiert und dadurch einfach zu lesen, aber nicht besonders speichersparend. Die Plattform entscheidet deshalb stark darüber, welche APIs sinnvoll nutzbar sind.
- Arduino Uno R3/Nano (ATmega328P): nur 2 KB SRAM. Kleine JSON-Antworten sind möglich, komplexe Web-APIs meist nicht.
- Arduino Mega: 8 KB SRAM. Für überschaubare JSON-Dokumente besser geeignet, aber weiterhin begrenzt.
- Arduino Uno R4 WiFi (Renesas RA4M1): 32 KB SRAM und integriertes WLAN. Verarbeitet mittelgroße JSON-Antworten problemlos, ohne Zusatzmodul.
- ESP8266: deutlich mehr RAM als ein Uno, aber für große HTTPS-Anfragen und lange Laufzeiten sorgfältig planen.
- ESP32: mehr Reserven für WLAN, TLS und JSON. Große Antworten sollten dennoch gefiltert oder durch serverseitige Endpunkte reduziert werden.
Seit ArduinoJson 7 verwaltet ein JsonDocument seinen Speicher dynamisch. Das vereinfacht kleine Projekte, ersetzt aber keine Speicherplanung: Begrenze die Größe von Antworten, verwende Filter und vermeide unnötige Strings.
JsonDocument doc;Nutzt du noch die ältere ArduinoJson 6, legst du die Größe des Dokuments dagegen fest. Sie muss zu Struktur und Textlängen deiner Antwort passen:
StaticJsonDocument<512> doc;Speicherverbrauch messen
Auf ESP32 und ESP8266 kannst du vor und nach einer Anfrage den freien Heap ausgeben. So erkennst du Speicherlecks oder zu große temporäre Objekte.
Serial.print("Freier Heap: ");
Serial.println(ESP.getFreeHeap());Wenn der freie Speicher nach jedem Abruf dauerhaft sinkt, fehlen oft Aufräumarbeiten wie http.end(), oder es werden viele dynamische String-Objekte erzeugt.
Robuste Fehlerbehandlung
Ein funktionierender Abruf besteht nicht nur aus http.GET(). Netzwerk, DNS, Server und JSON-Inhalt können jederzeit fehlschlagen. Prüfe daher mindestens diese Ebenen:
- Ist die WLAN-Verbindung aktiv?
- Konnte der HTTP-Request gesendet werden?
- Ist der HTTP-Statuscode tatsächlich 200?
- War der JSON-Text syntaktisch gültig?
- Sind die benötigten Felder vorhanden und vom richtigen Typ?
if (WiFi.status() != WL_CONNECTED) {
Serial.println("WLAN nicht verbunden");
return;
}
int httpCode = http.GET();
if (httpCode <= 0) {
Serial.printf("Netzwerkfehler: %s\n",
http.errorToString(httpCode).c_str());
return;
}
if (httpCode != HTTP_CODE_OK) {
Serial.printf("Unerwarteter HTTP-Code: %d\n", httpCode);
return;
}
DeserializationError error = deserializeJson(doc, http.getStream());
if (error) {
Serial.print("JSON konnte nicht gelesen werden: ");
Serial.println(error.c_str());
return;
}Bei zeitgesteuerten Messstationen solltest du fehlende API-Daten nicht sofort als Messwert 0 speichern. Verwende einen klaren ungültigen Wert, einen Zeitstempel oder behalte den letzten gültigen Wert bei.
Timeouts, Wiederholungen und Abrufintervalle
Ein Server kann langsam antworten oder zeitweise nicht erreichbar sein. Ohne Timeout kann dein Projekt unnötig lange blockieren.
http.setConnectTimeout(5000);
http.setTimeout(10000);Wiederhole fehlgeschlagene Requests nur begrenzt. Bei einem Fehler 429 solltest du besonders vorsichtig sein, denn die API fordert damit ausdrücklich weniger Anfragen.
const int maxRetries = 3;
for (int attempt = 1; attempt <= maxRetries; attempt++) {
int httpCode = http.GET();
if (httpCode == HTTP_CODE_OK) {
Serial.println("Abruf erfolgreich");
break;
}
Serial.printf("Versuch %d fehlgeschlagen: %d\n", attempt, httpCode);
delay(attempt * 2000);
}Für viele Wetter- oder Kursdaten genügt ein Abruf alle 5, 10 oder 15 Minuten. Ein zu kurzes Intervall verbraucht Strom, belastet den Server und kann das Limit eines kostenlosen API-Tarifs überschreiten.
API-Schlüssel sicher behandeln
Viele Dienste verlangen einen API-Key, beispielsweise als URL-Parameter oder HTTP-Header. Lege ihn nicht öffentlich in GitHub-Repositories ab und veröffentliche ihn nicht in Screenshots.
http.addHeader("X-API-Key", "DEIN_GEHEIMER_API_KEY");
http.addHeader("Accept", "application/json");Für private Projekte kannst du Zugangsdaten in einer separaten Datei speichern, die nicht in die Versionsverwaltung gelangt.
// secrets.h
const char* wifiSsid = "DEIN_WLAN";
const char* wifiPassword = "DEIN_PASSWORT";
const char* apiKey = "DEIN_API_KEY";Füge secrets.h dann zu deiner Ignore-Datei hinzu. Bei Geräten, die du an Dritte weitergibst, ist ein fest eingebauter geheimer Schlüssel grundsätzlich keine gute Lösung. Nutze in diesem Fall besser einen eigenen Proxy-Server oder kurzlebige Zugriffstokens.
Arduino Uno mit Ethernet oder WLAN-Modul
Ein klassischer Arduino Uno kann JSON grundsätzlich verarbeiten, stößt aber durch seine 2 KB SRAM schnell an Grenzen. Verwende deshalb kurze Antworten, kompakte eigene API-Endpunkte und möglichst keine großen HTTPS-Verbindungen.
Eine gute Architektur ist ein kleiner Server oder ein Raspberry Pi als Vermittler:
- Der Server ruft die komplexe externe API ab.
- Er extrahiert nur die benötigten Werte.
- Er liefert dem Arduino ein minimales JSON, etwa Temperatur und Status.
{
"temp": 21.4,
"humidity": 58,
"ok": true
}Damit bleibt das JSON-Dokument klein und der Mikrocontroller muss weder große Antworten noch komplexe TLS-Verbindungen verarbeiten.
Typische Probleme und ihre Ursachen
Fehler „NoMemory“
Das JSON-Dokument ist zu klein oder die API liefert mehr Daten als erwartet. Verwende einen Filter, reduziere die Antwort serverseitig oder wähle bei ArduinoJson 6 eine größere Dokumentkapazität.
Fehler „InvalidInput“
Die Antwort ist kein gültiges JSON. Häufige Ursachen sind ein HTML-Fehlerdokument, eine Weiterleitung, ein ungültiger API-Key oder eine Seite mit Captcha. Gib für die Fehlersuche Statuscode und Antwortinhalt aus, aber achte darauf, keine geheimen Zugangsdaten ins Log zu schreiben.
HTTP-Code 301 oder 302
Der Server leitet auf eine andere URL weiter, oft von HTTP zu HTTPS. Verwende direkt die endgültige HTTPS-Adresse oder aktiviere Weiterleitungen, wenn deine verwendete HTTPClient-Version dies unterstützt.
HTTP-Code -1 oder Verbindungsfehler
Prüfe WLAN-Empfang, DNS, URL, TLS-Zertifikat und Timeouts. Bei HTTPS ist außerdem wichtig, ob dein Gerät die aktuelle Uhrzeit kennt und das Zertifikat validieren kann.
Werte sind immer null, 0 oder leer
Meist stimmt der JSON-Pfad nicht mit der tatsächlichen API-Antwort überein. Prüfe die Antwort im Browser oder mit einem API-Tool und achte auf Groß- und Kleinschreibung bei Schlüsseln.
Praxisbeispiel: ISS-Überflüge mit der Pollux-Labs-API
Zum Abschluss bringen wir alles zusammen und fragen mit dem ESP32 eine echte API ab: die kostenlose ISS-Pass-API von Pollux Labs. Sie sagt voraus, wann die Internationale Raumstation über deinem Standort vorbeifliegt – und wann der Überflug mit bloßem Auge sichtbar ist.
Der Endpunkt erwartet Breiten- und Längengrad als Parameter. Für meine Heimatstadt Karlsruhe (49.0069 °N, 8.4037 °E) lautet die Adresse:
https://iss-api.polluxlabs.io/iss-pass?lat=49.0069&lon=8.4037&n=5Wichtig: Diese API ist ausschließlich über HTTPS erreichbar. Auf dem ESP32 verwenden wir deshalb WiFiClientSecure. Die Antwort ist ein Objekt mit einem Array passes, aus dem wir nur wenige Felder brauchen:
{
"satellite": "ISS (ZARYA)",
"observer": { "lat": 49.0069, "lon": 8.4037 },
"passes": [
{
"rise": { "time": "2026-07-13T20:14:06Z", "compass": "W" },
"culmination": { "time": "2026-07-13T20:17:29Z", "elevation_deg": 61.5 },
"set": { "time": "2026-07-13T20:20:52Z", "compass": "ENE" },
"visible": true
}
]
}Mit einem Filter übernehmen wir gezielt nur satellite, die Aufgangszeit, die maximale Höhe und das Feld visible. So bleibt das JSON-Dokument klein – wichtig, wenn du den Sketch später auf einem Uno R4 WiFi oder ESP8266 nutzen möchtest.
#include <WiFi.h>
#include <HTTPClient.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>
const char* ssid = "DEIN_WLAN";
const char* password = "DEIN_PASSWORT";
// ISS-Pass-API von Pollux Labs, Beispielstadt Karlsruhe
const char* apiUrl =
"https://iss-api.polluxlabs.io/iss-pass?lat=49.0069&lon=8.4037&n=5";
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.print("WLAN-Verbindung wird aufgebaut");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WLAN verbunden");
WiFiClientSecure client;
// Nur zum Testen: Zertifikat wird nicht geprueft.
client.setInsecure();
HTTPClient http;
http.setTimeout(10000);
http.begin(client, apiUrl);
int httpCode = http.GET();
if (httpCode == HTTP_CODE_OK) {
// Filter: nur die benoetigten Felder ins Dokument uebernehmen
JsonDocument filter;
filter["satellite"] = true;
filter["passes"][0]["rise"]["time"] = true;
filter["passes"][0]["culmination"]["elevation_deg"] = true;
filter["passes"][0]["visible"] = true;
JsonDocument doc;
DeserializationError error = deserializeJson(
doc, http.getStream(), DeserializationOption::Filter(filter));
if (error) {
Serial.print("JSON-Fehler: ");
Serial.println(error.c_str());
} else {
const char* sat = doc["satellite"] | "unbekannt";
Serial.print("Satellit: ");
Serial.println(sat);
for (JsonObject pass : doc["passes"].as<JsonArray>()) {
const char* rise = pass["rise"]["time"] | "?";
float elev = pass["culmination"]["elevation_deg"] | -1.0;
bool visible = pass["visible"] | false;
Serial.printf("Aufgang %s | max %.1f Grad | %s\n",
rise, elev,
visible ? "SICHTBAR" : "nicht sichtbar");
}
}
} else {
Serial.print("HTTP-Fehler: ");
Serial.println(httpCode);
}
http.end();
}
void loop() {
}Auf dem seriellen Monitor erscheint dann eine Liste der nächsten Überflüge, zum Beispiel:
Satellit: ISS (ZARYA)
Aufgang 2026-07-13T18:37:27Z | max 44.4 Grad | nicht sichtbar
Aufgang 2026-07-13T20:14:06Z | max 61.5 Grad | SICHTBAR
Aufgang 2026-07-13T21:51:11Z | max 58.0 Grad | SICHTBAR
Aufgang 2026-07-13T23:28:04Z | max 52.2 Grad | SICHTBAR
Aufgang 2026-07-14T01:06:37Z | max 10.9 Grad | nicht sichtbarAlle Zeiten liefert die API in UTC (erkennbar am Z am Ende). Für die Anzeige in Ortszeit rechnest du auf dem Mikrocontroller die Zeitzone hinzu, etwa über NTP und die passende Sommer- oder Winterzeit. Das Feld visible unterscheidet dabei zwischen Überflügen, die nur rechnerisch über dem Horizont liegen, und solchen, die du tatsächlich als hellen Punkt am Himmel sehen kannst.
Checkliste für dein Projekt
- Rufe den API-Endpunkt zunächst im Browser oder mit einem Testwerkzeug auf.
- Notiere den exakten JSON-Pfad jedes benötigten Werts.
- Prüfe HTTP-Statuscode und Deserialisierungsfehler getrennt.
- Parse die Antwort direkt aus dem Stream statt über große String-Variablen.
- Verwende Filter für umfangreiche JSON-Antworten.
- Setze Timeouts und begrenze Wiederholungsversuche.
- Rufe Daten nur so oft ab, wie es technisch und laut API-Limit nötig ist.
- Behandle API-Schlüssel wie Passwörter.
- Teste auch WLAN-Ausfall, ungültige Antworten und fehlende JSON-Felder.
Mit diesem Muster kannst du praktisch jede JSON-basierte Web-API in ein ESP8266- oder ESP32-Projekt integrieren. Auf kleinen Arduino-Boards funktioniert derselbe Ansatz mit stark reduzierten Antworten und einer sorgfältigen Speicherplanung.
