ESP32 weer-API: gegevens ophalen, JSON verwerken en tonen op een OLED
ESP32 weer-API-gids: HTTPClient-verzoeken naar Open-Meteo en OpenWeatherMap, ArduinoJson-parsing, OLED/LCD-weergave, HTTPS-certificaten, fouten 401, 404 en -1.
ESP32-weerprojecten komen neer op drie stappen: het board met Wi-Fi verbinden, een online weerdienst iets vragen en het antwoord op een display tonen. Zonder één sensor krijg je de temperatuur, luchtvochtigheid, wind en de verwachting voor morgen van jouw stad, want een API (application programming interface), gevoed door weerstations en voorspellingsmodellen, heeft het meten al voor je gedaan. De ESP32 stuurt zo'n dienst een HTTP GET-verzoek, net als een webbrowser, ontvangt gewone tekst in JSON-formaat en haalt er met de ArduinoJson-bibliotheek de getallen uit.
In deze gids stuur je eerst een verzoek naar Open-Meteo, dat geen sleutel nodig heeft, en ga je daarna verder met OpenWeatherMap, dat met plaatsnamen werkt. Je ziet hoe je JSON verwerkt, WMO-weercodes omzet in woorden, het resultaat toont op een OLED van 0,96 inch en een 16x2 I2C-LCD, HTTPS en certificaten instelt, binnen de limieten blijft en wat foutcodes als 401, 404 en -1 betekenen. Aan het eind staat een voorbeeld dat op dezelfde manier wisselkoersen ophaalt, plus MicroPython-code voor de Raspberry Pi Pico W.

Hoe krijgt de ESP32 gegevens van internet? API, HTTP en JSON
Als je een adres in je browser typt, stuurt die een HTTP-verzoek naar die server en geeft de server een webpagina terug. Een API werkt hetzelfde; het enige verschil is dat het antwoord geen pagina is die voor mensen is opgemaakt, maar gestructureerde tekst die programma's makkelijk kunnen lezen. Op de ESP32 doet de HTTPClient-bibliotheek die bij de core zit dit werk: je geeft het adres op, hij stuurt het GET-verzoek en geeft je de statuscode van de server en de body van het antwoord. Het antwoord is meestal JSON, opgebouwd uit "sleutel": waarde-paren tussen accolades, die geneste objecten of arrays kunnen bevatten.
| Term | Betekenis | Weervoorbeeld |
|---|---|---|
| API | De deur waarlangs programma's gegevens uitwisselen | De voorspellingsdienst van Open-Meteo |
| Endpoint | Het adres van de API dat één specifieke taak uitvoert | /v1/forecast |
| Queryparameter | Instellingen na het ? in het adres | latitude=41.01¤t=temperature_2m |
| GET-verzoek | De server om gegevens vragen | http.GET() |
| Statuscode | Een getal dat het resultaat van het verzoek beschrijft | 200 gelukt, 404 niet gevonden |
| JSON | Een tekstformaat opgebouwd uit sleutels en waarden | {"temperature_2m":17.3} |
| API-sleutel | Een geheime ID die jou identificeert | De appid-waarde van OpenWeatherMap |
Welke dienst: Open-Meteo of OpenWeatherMap?
Veel weerdiensten hebben een gratis variant, maar twee vallen op om mee te beginnen. Open-Meteo vraagt geen registratie en geen sleutel: je geeft de locatie op als breedte- en lengtegraad, kiest alleen de velden die je wilt en het antwoord blijft kort en licht voor de ESP32. OpenWeatherMap vraagt een gratis account en een API-sleutel, maar biedt in ruil daarvoor opvragen op plaatsnaam, een kant-en-klare beschrijving (bijvoorbeeld "light rain") en een icoon-code. De gratis abonnementen van beide zijn bedoeld voor persoonlijke en educatieve projecten; bouw je een commercieel product, lees dan de gebruiksvoorwaarden apart.
| Eigenschap | Open-Meteo | OpenWeatherMap (gratis) |
|---|---|---|
| Registratie en sleutel | Niet nodig | Account en API-sleutel vereist |
| Locatie | Breedte- en lengtegraad | Plaatsnaam, breedte-lengtegraad of stad-ID |
| Gratis limiet | 10.000 aanroepen per dag, 5.000 per uur, 600 per minuut | 60 aanroepen per minuut, 1.000.000 per maand |
| Verversing van gegevens | Actuele gegevens elke 15 minuten | Ongeveer elke 10 minuten |
| Weertoestand | WMO-getalcode (0, 3, 61...) | Beschrijvende tekst en icoon-code |
| Eenheden | °C en km/u (aan te passen met parameters) | °C en m/s met units=metric |
| Grootte van het antwoord | Alleen de velden die je kiest, ongeveer 400 bytes | Ongeveer 500 bytes |
Wat je nodig hebt en de installatie
- Installeer het ESP32-boardpakket in de Arduino IDE (Tools > Board > Boards Manager, esp32 van Espressif). De installatie wordt uitgebreid uitgelegd in de gids wat is ESP32.
- Zoek in de Library Manager naar ArduinoJson (Benoit Blanchon) en installeer versie 7.x. De bibliotheken HTTPClient, WiFi en WiFiClientSecure zitten in het ESP32-pakket en hoef je niet apart te installeren.
- Installeer voor de displayversie de bibliotheken Adafruit SSD1306 en Adafruit GFX, of LiquidCrystal I2C als je een LCD gebruikt.
- Vervang AgAdi en Sifre123 in de code door de naam en het wachtwoord van je eigen wifi, kies ESP32 Dev Module als board en stel de Serial Monitor in op 115200 baud.
Stap voor stap: je eerste GET-verzoek met HTTPClient
De eerste sketch heeft één taak: verbinden met Wi-Fi, Open-Meteo om het actuele weer in Istanbul vragen en het antwoord ongewijzigd naar de Serial Monitor printen. De parameter current= in het adres geeft aan welke velden je wilt; gescheiden door komma's kozen we temperatuur, luchtvochtigheid, weercode en windsnelheid. timezone=auto zet tijden om naar de lokale tijd van de locatie.
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 "¤t=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}Na het uploaden zie je in de Serial Monitor "HTTP kodu / code: 200", gevolgd door één regel JSON. Het nuttige deel van het antwoord ziet er zo uit: "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. De intervalwaarde 900 zegt dat de gegevens elke 900 seconden worden ververst, dus elke 15 minuten; dit heb je straks nodig om te bepalen hoe vaak je verzoeken verstuurt.
| Functie | Wat doet ze? |
|---|---|
| http.begin(url) | Verwerkt het adres en bereidt de verbinding voor |
| http.GET() | Verstuurt het verzoek; geeft de HTTP-statuscode of een negatieve foutcode terug |
| http.getString() | Leest de body van het antwoord als String |
| http.getStream() | Geeft je de body als stream zonder te bufferen (voor grote antwoorden) |
| http.errorToString(code) | Zet een negatieve foutcode om in leesbare tekst |
| http.setTimeout(ms) | Hoe lang er op een antwoord wordt gewacht (standaard 5000 ms) |
| http.end() | Sluit de verbinding en geeft het geheugen vrij |
JSON verwerken met ArduinoJson
Ruwe JSON op een display tonen heeft geen zin; je moet het getal 17.3 eruit halen en in een float-variabele zetten. ArduinoJson zet de tekst om in een boom in het geheugen en je loopt via de sleutelnamen langs de takken: doc["current"]["temperature_2m"] gaat eerst naar het object current en dan naar de temperatuur erin. Aan welk type variabele je de waarde ook toewijst, de bibliotheek zet hem om naar dat type. Vraag je een sleutel die niet bestaat, dan crasht het programma niet; je krijgt 0 voor een getal en een nullpointer voor tekst.
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 "¤t=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}Deze code is voor ArduinoJson 7. De regels StaticJsonDocument en DynamicJsonDocument doc(1024) uit oudere voorbeelden horen bij versie 6.x; in 7.x schrijf je gewoon JsonDocument doc; en wordt het geheugen automatisch naar behoefte toegewezen. Krijg je bij het compileren van oude code de waarschuwing "StaticJsonDocument is deprecated", dan is dat de reden: de code werkt meestal nog, maar overstappen op de nieuwe stijl is netter. De leeskant, de syntaxis doc["key"], is in beide versies hetzelfde.
WMO-weercodes: het getal omzetten in woorden
Open-Meteo beschrijft het weer niet met een woord als "bewolkt" maar met een getal dat is vastgelegd door de Wereld Meteorologische Organisatie (WMO). Daardoor is het antwoord taalonafhankelijk en bepaal jij welke taal je op je display gebruikt. Dit zijn de codes die je het vaakst ziet:
| WMO-code | Betekenis |
|---|---|
| 0 | Onbewolkt |
| 1, 2, 3 | Overwegend helder, half bewolkt, bewolkt |
| 45, 48 | Mist, rijpafzettende mist |
| 51, 53, 55 | Lichte, matige, dichte motregen |
| 56, 57 | Ijzel (aanvriezende motregen) |
| 61, 63, 65 | Lichte, matige, zware regen |
| 66, 67 | Aanvriezende regen |
| 71, 73, 75 | Lichte, matige, zware sneeuwval |
| 77 | Sneeuwkorrels |
| 80, 81, 82 | Lichte, matige, hevige regenbuien |
| 85, 86 | Lichte en zware sneeuwbuien |
| 95 | Onweer |
| 96, 99 | Onweer met hagel |
De functie wmoText() in de OLED-sketch hieronder zet deze tabel om in korte labels. De labels in de code zijn in het Turks geschreven zonder speciale tekens; verander ze naar het Nederlands ("Helder", "Regen", "Sneeuw") als je wilt. Wil je eigen iconen tekenen, gebruik dan dezelfde bereiken om zon-, wolk- of regendruppelbitmaps te kiezen; één regenicoon is bijvoorbeeld genoeg voor 61 tot 67 en 80 tot 82.
Weer op plaatsnaam met OpenWeatherMap
Nadat je een gratis OpenWeatherMap-account hebt gemaakt, vind je in het gedeelte API keys van je account een sleutel van 32 tekens. Een nieuwe sleutel kan van enkele minuten tot enkele uren nodig hebben om actief te worden; tot die tijd geeft elk verzoek 401 en denk je misschien dat je code fout is. In de query stelt q=Ankara,TR de plaatsnaam en landcode in, units=metric geeft Celsius en m/s en lang bepaalt de taal van de beschrijving.
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}Twee details in dit antwoord vragen aandacht. Ten eerste is het veld weather geen object maar een array, dus je komt bij de beschrijving via het eerste element: doc["weather"][0]["description"]. Ten tweede komt de windsnelheid met units=metric in m/s; vermenigvuldig met 3,6 voor km/u. Andere waarden van lang geven beschrijvingen in die taal, maar de standaardlettertypen van Adafruit GFX en HD44780-LCD's dekken alleen basis-ASCII, dus letters met accenten zoals é, ü of ñ komen verminkt over. lang=en met korte eigen labels is de veiligste keuze voor kleine displays.
HTTPS en certificaten: setInsecure of setCACert?
De meeste weerdiensten gebruiken nu HTTPS en sommige accepteren gewone HTTP helemaal niet meer. Met HTTPS is het verkeer tussen de ESP32 en de server versleuteld; om zeker te weten dat hij echt met die server praat, moet de ESP32 ook de certificaatketen controleren aan de hand van een root-certificaat. Hiervoor gebruik je WiFiClientSecure in plaats van de gewone WiFiClient, en je hebt twee opties.
setInsecure() versleutelt de verbinding maar controleert het certificaat niet. Het is een praktische en gangbare keuze voor openbare, niet-geheime gegevens zoals het weer, maar iemand ertussenin zou je nepgegevens kunnen sturen. setCACert() controleert de keten met het root-certificaat dat je opgeeft. Het certificaat van Open-Meteo is uitgegeven door Let's Encrypt en loopt via de keten naar de root ISRG Root X1, die geldig is tot 2035. Het eigen certificaat van de server wordt om de paar maanden vernieuwd, dus zet dat nooit in je code; gebruik altijd de root bovenaan de keten.
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¤t=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}Het weer van jouw stad tonen op een OLED-display

Nu laten we de Serial Monitor achter ons en bouwen we een echt weerstation voor op je bureau. De 0,96-inch SSD1306 OLED sluit je aan op de I2C-pins van de ESP32. Voor de basis van displays en details over de bibliotheek zie je de gids SSD1306 OLED-display.
| OLED-pin | ESP32 |
|---|---|
| GND | GND |
| VCC | 3V3 |
| SCL | GPIO 22 |
| SDA | GPIO 21 |
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 "¤t=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}Bij het opstarten maakt de sketch verbinding met Wi-Fi, haalt direct de eerste gegevens op en ververst daarna elke 10 minuten. Voor het wachten gebruikten we millis() in plaats van delay(), zodat je knoppen kunt uitlezen of een animatie kunt toevoegen terwijl loop() vrij draait. Valt de verbinding weg, dan toont de code een waarschuwing en probeert hij opnieuw te verbinden; mislukt een verzoek, dan toont hij de foutcode. De tijd rechtsboven is het deel na de letter T in de string "2026-11-17T14:15" van het antwoord, dus je ziet wanneer de laatste waarneming is gedaan zonder een klok in te stellen. Wil je een klok die elke seconde tikt, voeg dan de methode uit de gids ESP32 NTP-tijd toe aan deze sketch.
Tonen op een 16x2 I2C-LCD
Heb je in plaats van een OLED een 16x2 tekst-LCD, dan past dezelfde data op twee regels. Voed je de LCD-module via de VIN-pin van de ESP32, die 5 V levert, dan verbetert het contrast; sluit SDA aan op GPIO 21 en SCL op GPIO 22. Omdat de module de I2C-lijnen optrekt naar 5 V, is een niveauconverter ertussen de veiligste optie. Vervang gewoon de tekenregels van de OLED-sketch door een functie zoals hieronder; meer details staan in de gids I2C-LCD-display.
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}Verzoekfrequentie en gratis limieten
De meest voorkomende fout is delay(1000) in loop() zetten en elke seconde een verzoek sturen. Dat is zowel zinloos als een snelle manier om de limieten te raken: de actuele gegevens van Open-Meteo worden maar elke 15 minuten ververst, dus elke seconde vragen levert 900 keer hetzelfde antwoord op. Eén verzoek per seconde is 86.400 per dag en vult de daglimiet van 10.000 van Open-Meteo in minder dan drie uur. De rekensom is simpel: verzoeken per dag is 1440 gedeeld door het interval in minuten.
| Interval | Verzoeken per dag | Oordeel |
|---|---|---|
| 1 seconde | 86.400 | Over de limiet; je IP-adres kan tijdelijk worden geblokkeerd |
| 1 minuut | 1.440 | Binnen de limiet maar verspild, want de gegevens veranderen niet |
| 10 minuten | 144 | Ideaal voor een weerstation op je bureau |
| 15 minuten | 96 | Komt overeen met de verversingssnelheid van Open-Meteo |
| 1 uur | 24 | Genoeg voor apparaten op batterijen en dagverwachtingen |
Foutcodes: 401, 404, 429 en -1
http.GET() geeft twee soorten getallen terug. Positieve getallen zijn HTTP-statuscodes van de server: de verbinding is gelukt en de server heeft je gehoord, maar vond iets in je verzoek niet goed. Negatieve getallen zijn de eigen foutcodes van de ESP32 en laten zien dat het verzoek de server nooit heeft bereikt of dat het antwoord is afgekapt.
| Code | Betekenis | Wat te doen |
|---|---|---|
| 200 | Gelukt | Lees en verwerk de body |
| 400 | Ongeldig verzoek | Controleer de parameternamen en komma's in het adres |
| 401 | Niet geautoriseerd: API-sleutel ontbreekt, is fout of is nog niet actief | Kopieer de sleutel opnieuw; is hij nieuw, wacht dan even |
| 404 | Niet gevonden: verkeerde plaatsnaam of adres | Schrijf de plaats in gewone Engelse letters (Istanbul,TR), controleer het adres |
| 429 | Te veel verzoeken | Maak het interval langer |
| 500-503 | Probleem aan de serverkant | Probeer het over een paar minuten opnieuw |
| -1 | Geen verbinding: geen internet, domein niet gevonden, verkeerd adres of mislukte HTTPS-handshake | Controleer Wi-Fi, het adres en het certificaat |
| -5 | Verbinding halverwege verbroken | Verbeter het wifisignaal, probeer het verzoek opnieuw |
| -11 | Time-out bij lezen | Verleng de wachttijd met http.setTimeout() |
OpenWeatherMap geeft ook bij fouten JSON terug: met een verkeerde sleutel krijg je {"cod":401, "message":"Invalid API key..."}, en bij een onbekende stad {"cod":"404","message":"city not found"}. In het eerste geval is cod een getal, in het tweede een string tussen aanhalingstekens. Baseer je je code op het getal dat http.GET() teruggeeft in plaats van op het veld cod, dan heb je geen last van deze inconsistentie.
Grote antwoorden: filters, getStream en useHTTP10
Vraag je een verwachting per uur of voor 7 dagen, dan kan het antwoord groeien van een paar kilobytes naar tientallen. getString() zet het hele antwoord eerst in een String en daarna in de ArduinoJson-boom, dus het geheugen wordt twee keer gebruikt. In plaats daarvan kun je het antwoord tijdens het binnenkomen verwerken met http.getStream() en met een filter alleen de velden bewaren die je nodig hebt. Er is een valkuil: stuurt de server het antwoord in stukken (chunked encoding), dan raken chunkgroottes in de stream gemengd en breekt de JSON. Open-Meteo stuurt wel chunked antwoorden; http.useHTTP10(true) doet het verzoek via HTTP/1.0 en dwingt de server een gewoon antwoord te sturen.
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}Op dezelfde manier kun je hourly=temperature_2m opvragen en een temperatuurgrafiek van 24 uur tekenen, of met daily=precipitation_probability_max een LED laten branden als morgen regen waarschijnlijk is. Bij Open-Meteo kan forecast_days maximaal 16 zijn; tussen 3 en 7 dagen is een comfortabel bereik voor de ESP32.
Andere API's, dezelfde methode: een voorbeeld met wisselkoersen
Wat je hier hebt geleerd is niet specifiek voor het weer: het adres, GET, JSON en de parsestappen zijn bij elke REST-API hetzelfde. De dienst Frankfurter, die de dagelijkse referentiekoersen van de Europese Centrale Bank publiceert, heeft bijvoorbeeld geen sleutel nodig en geeft valuta als de dollar, de euro en de Turkse lira in één verzoek terug.
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}Koersen van centrale banken worden op werkdagen één keer per dag bijgewerkt, rond 16:00 Midden-Europese tijd, dus zelfs één verzoek per uur is ruim voldoende. Met hetzelfde skelet kun je aardbevingsgegevens, gebedstijden, cryptokoersen of een waarde van je eigen server ophalen. Alleen het adres en de sleutelnamen in de JSON veranderen, en die vind je door het adres in een browser te openen en naar het antwoord te kijken.
Weer met de Raspberry Pi Pico W (MicroPython)
Op de leden van de Raspberry Pi Pico-familie met Wi-Fi, de Pico W en Pico 2 W, doet de module urequests van MicroPython hetzelfde werk, en je hebt geen aparte JSON-bibliotheek nodig: r.json() zet het antwoord direct om in een Python-dictionary. Flash de nieuwste MicroPython met Thonny en sla de code op als main.py. Details over de wifiverbinding staan in de gids Pico W Wi-Fi-webserver.
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 "¤t=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 minutesDe urequests van MicroPython versleutelt HTTPS-verbindingen maar controleert het servercertificaat niet; het beveiligingsniveau is hetzelfde als setInsecure() op de ESP32. r.close() aanroepen na elk verzoek is belangrijk: vergeet je dat, dan raakt de Pico na een paar verzoeken zonder sockets en geheugen en stopt de code met een OSError.
Ideeën voor ESP32-weerprojecten
- Weerstation voor op je bureau: Toon Open-Meteo-gegevens op een OLED en voeg met een BME280 de temperatuur en luchtdruk van de kamer toe, zodat je binnen en buiten naast elkaar ziet.
- Paraplu-herinnering: Een ESP32 naast de voordeur laat een rode WS2812B-LED branden als de regenkans van de dag boven 60 procent ligt.
- Slimme bewatering: Sla het water geven over als morgen regen wordt verwacht; gecombineerd met een bodemvochtsensor verspil je geen water.
- Ochtendmelding: Stuur elke ochtend om 07:00 de weersverwachting van de dag naar je telefoon met een Telegram-bot.
- Domotica: Stuur de buitentemperatuur via MQTT naar Home Assistant en gebruik hem voor beslissingen over de verwarming.
- Weer- en valutabord: Toon de temperatuur, een verwachting voor 3 dagen en de wisselkoersen van de dag als kleurrijke kaarten op een ILI9341 TFT-display.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Eindeloze puntjes in de Serial Monitor | Kan geen verbinding maken met Wi-Fi | 2,4 GHz-netwerk, juist wachtwoord, dichter bij de router |
| HTTP-code -1 | Probleem met internet, domein of HTTPS | Probeer het adres in een browser, controleer WiFiClientSecure en het certificaat |
| 401 Invalid API key | Verkeerde sleutel of nog niet actief | Kopieer de sleutel opnieuw; wacht even bij een nieuw account |
| JSON-fout InvalidInput | Het antwoord is geen JSON (een HTML-foutpagina) | Print het antwoord eerst met getString() |
| JSON-fout IncompleteInput | Antwoord afgekapt of chunked stream | Gebruik getString() of voeg useHTTP10(true) toe |
| Temperatuur altijd 0.00 | Sleutelnaam verkeerd gespeld | Kopieer de naam exact uit de JSON (temperature_2m) |
| Vreemde tekens op het display | Letters met accenten of het °-teken ontbreken in het lettertype | Gebruik lang=en, print het graden-teken met (char)247 |
| Loopt vast na een paar uur | Niet gesloten verbindingen, geheugenfragmentatie | Roep http.end() aan na elk verzoek, verleng het interval |
Een ESP32-weerproject leert je het basispatroon van elk verbonden apparaat: verbinden, vragen, verwerken, tonen en met verstandige tussenpozen herhalen. Als je dit patroon eenmaal onder de knie hebt, kan dezelfde code gegevens ophalen van honderden verschillende API's. In de BlueGrays-app vind je projecten die met ESP32 HTTPClient een weer-API tonen op een LCD en een SSD1306 OLED, naast projecten met een wifiverbinding en NTP-klok, elk met een stapsgewijs schakelschema en code.
Veelgestelde vragen
Hoe krijg ik weergegevens met een ESP32?
Verbind de ESP32 met Wi-Fi en stuur met de HTTPClient-bibliotheek een GET-verzoek naar een dienst als Open-Meteo of OpenWeatherMap. Lees daarna de temperatuur, luchtvochtigheid en weercode uit het JSON-antwoord met de ArduinoJson-bibliotheek. Open-Meteo heeft geen API-sleutel nodig, waardoor het de makkelijkste keuze is voor een eerste poging.
Is de Open-Meteo-API gratis?
Open-Meteo is gratis voor niet-commercieel gebruik en vraagt geen registratie of API-sleutel. De gratis variant is beperkt tot 10.000 aanroepen per dag, 5.000 per uur en 600 per minuut. Voor een commercieel product heb je een betaald abonnement nodig.
Waarom geeft mijn OpenWeatherMap-API-sleutel fout 401?
Een 401 betekent dat de sleutel fout is, ontbreekt of nog niet is geactiveerd. Nieuw aangemaakte sleutels hebben van enkele minuten tot enkele uren nodig om actief te worden. Controleer of je de sleutel zonder spaties hebt gekopieerd en hem met de parameter appid= in het adres hebt meegegeven.
Wat betekent HTTP GET-fout -1 op de ESP32?
-1 is HTTPC_ERROR_CONNECTION_REFUSED, wat betekent dat er helemaal geen verbinding kon worden gemaakt. Meestal komt het door geen internettoegang, een domeinnaam die niet kan worden opgelost, een typefout in het adres of verbinding met een HTTPS-server met het verkeerde certificaat. Print http.errorToString(code) naar de Serial Monitor om de beschrijving te zien.
Hoe vaak moet een ESP32 het weer bijwerken?
Elke 10 tot 15 minuten is genoeg, want de diensten verversen hun gegevens ongeveer in dat tempo. Dat zijn 96 tot 144 verzoeken per dag, ver onder de gratis limieten. Elke seconde vragen verspilt energie en kan ertoe leiden dat je wordt geblokkeerd.
Wat is het verschil tussen ArduinoJson 6 en 7?
ArduinoJson 7 vervangt StaticJsonDocument en DynamicJsonDocument door één JsonDocument-klasse die het geheugen automatisch beheert. Oude code compileert nog steeds met een waarschuwing, maar in nieuwe projecten heb je genoeg aan JsonDocument doc;. De parse-aanroep en de leessyntaxis doc["key"] zijn in beide versies hetzelfde.
Projecten om hierna te bouwen
Alle projecten bekijken
ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 I2C-LCD-display (16x2)
In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

