ESP32 météo API : récupérer les données, lire le JSON, OLED
Guide ESP32 météo API : requêtes HTTPClient vers Open-Meteo et OpenWeatherMap, ArduinoJson, écran OLED/LCD, certificat HTTPS et erreurs 401, 404 et -1.
Un projet météo avec l'ESP32 consiste à connecter la carte au Wi-Fi, à poser une question à un service météo sur internet et à afficher la réponse sur un écran. Sans le moindre capteur, tu obtiens la température, l'humidité, le vent et les prévisions de demain pour ta ville, car une API (interface de programmation) alimentée par des stations météo et des modèles de prévision a déjà fait la mesure pour toi. L'ESP32 envoie à ce service une requête HTTP GET, comme un navigateur, reçoit du texte brut au format JSON et en extrait les nombres avec la bibliothèque ArduinoJson.
Dans ce guide, tu enverras d'abord une requête à Open-Meteo, qui ne demande aucune clé, puis tu passeras à OpenWeatherMap, qui fonctionne avec le nom des villes. Tu verras comment analyser le JSON, transformer les codes météo WMO en texte, afficher le résultat sur un OLED de 0,96 pouce et un LCD I2C 16x2, configurer HTTPS et les certificats, respecter les limites de requêtes, et ce que signifient les codes d'erreur comme 401, 404 et -1. À la fin, un exemple récupère des taux de change de la même manière, et tu trouveras du code MicroPython pour le Raspberry Pi Pico W.

Comment l'ESP32 récupère-t-il des données sur internet ? API, HTTP et JSON
Quand tu tapes une adresse dans ton navigateur, il envoie une requête HTTP au serveur et le serveur renvoie une page web. Une API fonctionne de la même façon ; la seule différence, c'est que la réponse n'est pas une page mise en forme pour les humains, mais un texte structuré que les programmes lisent facilement. Sur l'ESP32, c'est la bibliothèque HTTPClient, fournie avec le cœur, qui s'en charge : tu lui donnes l'adresse, elle envoie la requête GET et te remet le code d'état du serveur et le corps de la réponse. La réponse est généralement du JSON : des paires "clé": valeur entre accolades, qui peuvent contenir des objets imbriqués ou des tableaux.
| Terme | Signification | Exemple météo |
|---|---|---|
| API | La porte par laquelle les programmes échangent des données | Service de prévision d'Open-Meteo |
| Point de terminaison (endpoint) | L'adresse de l'API qui fait un travail précis | /v1/forecast |
| Paramètre de requête | Les réglages après le ? dans l'adresse | latitude=41.01¤t=temperature_2m |
| Requête GET | Demander des données au serveur | http.GET() |
| Code d'état | Nombre qui décrit le résultat de la requête | 200 succès, 404 introuvable |
| JSON | Format texte fait de clés et de valeurs | {"temperature_2m":17.3} |
| Clé d'API | Identifiant secret qui te reconnaît | La valeur appid d'OpenWeatherMap |
Quel service : Open-Meteo ou OpenWeatherMap ?
Beaucoup de services météo ont une offre gratuite, mais deux se distinguent pour débuter. Open-Meteo ne demande ni inscription ni clé : tu indiques le lieu par sa latitude et sa longitude, tu choisis seulement les champs voulus, et la réponse reste courte et légère pour l'ESP32. OpenWeatherMap demande un compte gratuit et une clé d'API, mais en échange il accepte les requêtes par nom de ville et fournit un texte descriptif tout prêt ("light rain", par exemple) ainsi qu'un code d'icône. Les offres gratuites des deux services visent les projets personnels et éducatifs ; si tu développes un produit commercial, lis les conditions d'utilisation à part.
| Caractéristique | Open-Meteo | OpenWeatherMap (gratuit) |
|---|---|---|
| Inscription et clé | Inutiles | Compte et clé d'API obligatoires |
| Lieu | Latitude et longitude | Nom de ville, coordonnées ou identifiant de ville |
| Limite gratuite | 10 000 requêtes par jour, 5 000 par heure, 600 par minute | 60 requêtes par minute, 1 000 000 par mois |
| Mise à jour des données | Données actuelles toutes les 15 minutes | Environ toutes les 10 minutes |
| État du ciel | Code numérique WMO (0, 3, 61...) | Texte descriptif et code d'icône |
| Unités | °C et km/h (modifiables par paramètres) | °C et m/s avec units=metric |
| Taille de la réponse | Seulement les champs choisis, environ 400 octets | Environ 500 octets |
Matériel nécessaire et installation
- Installe le paquet de cartes ESP32 dans l'Arduino IDE (Outils > Type de carte > Gestionnaire de carte, esp32 by Espressif). L'installation est détaillée dans le guide qu'est-ce que l'ESP32.
- Dans le gestionnaire de bibliothèques, cherche ArduinoJson (Benoit Blanchon) et installe la version 7.x. Les bibliothèques HTTPClient, WiFi et WiFiClientSecure sont fournies avec le paquet ESP32 et ne s'installent pas à part.
- Pour la version avec écran, installe Adafruit SSD1306 et Adafruit GFX, ou LiquidCrystal I2C si tu utilises un LCD.
- Remplace AgAdi et Sifre123 dans le code par le nom et le mot de passe de ton Wi-Fi, choisis ESP32 Dev Module comme carte et règle le moniteur série sur 115200 bauds.
Pas à pas : ta première requête GET avec HTTPClient
Le premier sketch n'a qu'une seule tâche : se connecter au Wi-Fi, demander à Open-Meteo la météo actuelle à Istanbul et afficher la réponse telle quelle dans le moniteur série. Le paramètre current= de l'adresse indique les champs voulus ; séparés par des virgules, nous avons choisi la température, l'humidité, le code météo et la vitesse du vent. timezone=auto convertit les heures dans l'heure locale du lieu.
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}Après le téléversement, tu devrais voir dans le moniteur série d'abord "HTTP kodu / code: 200", puis une seule ligne de JSON. La partie utile de la réponse ressemble à ceci : "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. La valeur 900 d'interval indique que les données sont renouvelées toutes les 900 secondes, soit toutes les 15 minutes ; tu en auras besoin plus tard pour choisir la fréquence des requêtes.
| Fonction | Que fait-elle ? |
|---|---|
| http.begin(url) | Analyse l'adresse et prépare la connexion |
| http.GET() | Envoie la requête ; renvoie le code d'état HTTP ou un code d'erreur négatif |
| http.getString() | Lit le corps de la réponse sous forme de String |
| http.getStream() | Fournit le corps comme un flux sans tout stocker (pour les grandes réponses) |
| http.errorToString(code) | Transforme un code d'erreur négatif en texte lisible |
| http.setTimeout(ms) | Temps d'attente de la réponse (5000 ms par défaut) |
| http.end() | Ferme la connexion et libère la mémoire |
Analyser le JSON avec ArduinoJson
Afficher le JSON brut sur un écran ne sert à rien ; il faut en extraire le nombre 17.3 et le ranger dans une variable float. ArduinoJson transforme le texte en arbre en mémoire, et tu descends dans ses branches grâce aux noms des clés : doc["current"]["temperature_2m"] va d'abord à l'objet current, puis à la température qu'il contient. Selon le type de variable auquel tu affectes la valeur, la bibliothèque la convertit dans ce type. Si tu demandes une clé qui n'existe pas, le programme ne plante pas : tu obtiens 0 pour un nombre et un pointeur nul pour un texte.
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}Ce code est prévu pour ArduinoJson 7. Les lignes StaticJsonDocument et DynamicJsonDocument doc(1024) que tu verras dans d'anciens exemples appartiennent à la version 6.x ; en 7.x, il suffit d'écrire JsonDocument doc; et la mémoire est réservée automatiquement selon les besoins. Si tu obtiens l'avertissement "StaticJsonDocument is deprecated" en compilant un ancien code, voilà pourquoi : le code fonctionne généralement encore, mais passer à la nouvelle écriture est plus propre. La lecture avec doc["cle"] est identique dans les deux versions.
Codes météo WMO : transformer le nombre en texte
Open-Meteo ne décrit pas le temps avec un mot comme "nuageux", mais avec un nombre défini par l'Organisation météorologique mondiale (OMM, WMO en anglais). La réponse est ainsi indépendante de la langue, et c'est toi qui choisis la langue de ton écran. Voici les codes que tu verras le plus souvent :
| Code WMO | Signification |
|---|---|
| 0 | Ciel dégagé |
| 1, 2, 3 | Plutôt dégagé, partiellement nuageux, couvert |
| 45, 48 | Brouillard, brouillard givrant |
| 51, 53, 55 | Bruine légère, modérée, dense |
| 56, 57 | Bruine verglaçante |
| 61, 63, 65 | Pluie faible, modérée, forte |
| 66, 67 | Pluie verglaçante |
| 71, 73, 75 | Chute de neige faible, modérée, forte |
| 77 | Neige en grains |
| 80, 81, 82 | Averses faibles, modérées, violentes |
| 85, 86 | Averses de neige faibles et fortes |
| 95 | Orage |
| 96, 99 | Orage avec grêle |
La fonction wmoText() du sketch OLED ci-dessous transforme ce tableau en étiquettes courtes. Dans le code, elles sont écrites en turc sans caractères spéciaux ; remplace-les par des mots français comme "Degage", "Pluie" ou "Neige" (sans accents, comme expliqué plus bas). Si tu veux dessiner tes propres icônes, utilise les mêmes plages pour choisir des bitmaps de soleil, de nuage ou de goutte ; une seule icône de pluie suffit par exemple pour 61 à 67 et 80 à 82.
La météo par nom de ville avec OpenWeatherMap
Après avoir créé un compte gratuit sur OpenWeatherMap, tu trouves une clé de 32 caractères dans la section API keys de ton compte. Une nouvelle clé peut mettre de quelques minutes à quelques heures à s'activer ; pendant ce temps, chaque requête renvoie 401 et tu risques de croire que ton code est faux. Dans la requête, q=Ankara,TR fixe le nom de la ville et le code du pays, units=metric les degrés Celsius et les m/s, et lang la langue de la description.
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}Deux détails de cette réponse méritent attention. D'abord, le champ weather n'est pas un objet mais un tableau ; on atteint donc la description par son premier élément : doc["weather"][0]["description"]. Ensuite, avec units=metric, la vitesse du vent arrive en m/s ; multiplie par 3,6 pour obtenir des km/h. Avec lang=fr, les descriptions arrivent en français ("légère pluie"), mais les polices par défaut d'Adafruit GFX et des LCD HD44780 n'affichent pas é, è, à ou ç. Pour éviter les caractères cassés à l'écran, le plus sûr est d'utiliser lang=en et d'écrire tes propres étiquettes courtes.
HTTPS et certificat : setInsecure ou setCACert ?
La plupart des services météo utilisent désormais HTTPS, et certains n'acceptent plus du tout le HTTP simple. Avec HTTPS, le trafic entre l'ESP32 et le serveur est chiffré ; pour être sûr de parler vraiment à ce serveur, l'ESP32 doit en plus vérifier la chaîne de certificats à l'aide d'un certificat racine. On utilise pour cela WiFiClientSecure à la place du simple WiFiClient, et il y a deux options.
setInsecure() chiffre la connexion mais ne vérifie pas le certificat. C'est un choix pratique et courant pour des données publiques et non secrètes comme la météo, mais quelqu'un placé au milieu pourrait t'envoyer de fausses données. setCACert() vérifie la chaîne avec le certificat racine que tu fournis. Le certificat d'Open-Meteo est émis par Let's Encrypt et remonte à la racine ISRG Root X1, valable jusqu'en 2035. Le certificat propre du serveur est renouvelé tous les quelques mois : ne mets donc jamais celui-là dans ton code, utilise toujours la racine en haut de la chaîne.
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}Afficher la météo de ta ville sur un écran OLED

Quittons maintenant le moniteur série pour construire une vraie station météo de bureau. L'OLED SSD1306 de 0,96 pouce se branche sur les broches I2C de l'ESP32. Pour les bases de l'écran et les détails de la bibliothèque, consulte le guide écran OLED SSD1306.
| Broche OLED | 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}Au démarrage, le sketch se connecte au Wi-Fi, récupère immédiatement les premières données, puis les renouvelle toutes les 10 minutes. Pour attendre, nous utilisons millis() au lieu de delay() : tu peux ainsi lire des boutons ou ajouter une animation pendant que loop() tourne librement. Si la connexion tombe, le code affiche un avertissement et tente de se reconnecter ; si une requête échoue, il affiche le code d'erreur. L'heure en haut à droite correspond à la partie après la lettre T dans le texte "2026-11-17T14:15" de la réponse : tu vois l'heure de la dernière mesure sans régler d'horloge. Si tu veux une horloge qui avance à la seconde, ajoute à ce sketch la méthode du guide heure NTP avec l'ESP32.
Affichage sur un LCD I2C 16x2
Si tu as un LCD à caractères 16x2 au lieu d'un OLED, les mêmes données tiennent sur deux lignes. Alimenter le module LCD par la broche VIN de l'ESP32, qui fournit 5 V, améliore le contraste ; relie SDA à GPIO 21 et SCL à GPIO 22. Comme le module tire les lignes I2C à 5 V, le plus sûr est de placer un convertisseur de niveau entre les deux. Il suffit de remplacer les lignes de dessin du sketch OLED par une fonction comme celle-ci ; plus de détails dans le guide écran LCD I2C.
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}Fréquence des requêtes et limites gratuites
L'erreur la plus fréquente consiste à mettre delay(1000) dans loop() et à envoyer une requête chaque seconde. C'est inutile et cela te mène vite aux limites : les données actuelles d'Open-Meteo ne sont renouvelées que toutes les 15 minutes, donc en demandant chaque seconde tu reçois 900 fois la même réponse. Une requête par seconde fait 86 400 par jour et épuise la limite quotidienne de 10 000 d'Open-Meteo en moins de trois heures. Le calcul est simple : le nombre de requêtes par jour vaut 1440 divisé par l'intervalle en minutes.
| Intervalle | Requêtes par jour | Verdict |
|---|---|---|
| 1 seconde | 86 400 | Limite dépassée ; ton adresse IP peut être bloquée temporairement |
| 1 minute | 1 440 | Dans la limite mais inutile, car les données ne changent pas |
| 10 minutes | 144 | Idéal pour une station de bureau |
| 15 minutes | 96 | Correspond au rafraîchissement d'Open-Meteo |
| 1 heure | 24 | Suffisant pour les appareils sur batterie et les prévisions du jour |
Codes d'erreur : 401, 404, 429 et -1
http.GET() renvoie deux sortes de nombres. Les nombres positifs sont les codes d'état HTTP du serveur : la connexion a eu lieu, le serveur t'a entendu, mais quelque chose dans ta requête ne lui convient pas. Les nombres négatifs sont des codes d'erreur propres à l'ESP32 : ils montrent que la requête n'a jamais atteint le serveur ou que la réponse a été coupée.
| Code | Signification | Que faire ? |
|---|---|---|
| 200 | Succès | Lire et analyser le corps |
| 400 | Requête incorrecte | Vérifier les noms des paramètres et les virgules de l'adresse |
| 401 | Non autorisé : clé d'API absente, fausse ou pas encore active | Recopier la clé ; si elle est neuve, patienter un peu |
| 404 | Introuvable : nom de ville ou adresse erronés | Écrire la ville sans accents (Orleans,FR), vérifier l'adresse |
| 429 | Trop de requêtes | Allonger l'intervalle |
| 500-503 | Problème côté serveur | Réessayer dans quelques minutes |
| -1 | Pas de connexion : pas d'internet, domaine non résolu, adresse erronée ou échec de la négociation HTTPS | Vérifier le Wi-Fi, l'adresse et le certificat |
| -5 | Connexion perdue en cours de route | Améliorer le signal Wi-Fi, relancer la requête |
| -11 | Délai de lecture dépassé | Allonger l'attente avec http.setTimeout() |
OpenWeatherMap renvoie aussi du JSON en cas d'erreur : avec une mauvaise clé tu reçois {"cod":401, "message":"Invalid API key..."}, et pour une ville inconnue {"cod":"404","message":"city not found"}. Dans le premier cas cod est un nombre, dans le second un texte entre guillemets. Si tu bases ton code sur le nombre renvoyé par http.GET() plutôt que sur le champ cod, cette incohérence ne te gênera pas.
Grandes réponses : filtre, getStream et useHTTP10
Quand tu demandes une prévision horaire ou sur 7 jours, la réponse peut passer de quelques kilo-octets à plusieurs dizaines. getString() place d'abord toute la réponse dans une String, puis dans l'arbre ArduinoJson : la mémoire est donc utilisée deux fois. À la place, tu peux analyser la réponse au fil de l'arrivée avec http.getStream() et ne garder que les champs utiles grâce à un filtre. Il y a un piège : si le serveur envoie la réponse par morceaux (chunked), les tailles des morceaux se mêlent au flux et le JSON est cassé. Open-Meteo envoie ses réponses par morceaux ; http.useHTTP10(true) fait la requête en HTTP/1.0 et force le serveur à envoyer une réponse simple.
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}De la même façon, tu peux demander hourly=temperature_2m et tracer une courbe de température sur 24 heures, ou utiliser daily=precipitation_probability_max pour allumer une LED si la pluie est probable demain. Chez Open-Meteo, forecast_days vaut au maximum 16 ; pour l'ESP32, 3 à 7 jours est une plage confortable.
D'autres API, même méthode : exemple de taux de change
Ce que tu as appris ici ne se limite pas à la météo : l'adresse, le GET, le JSON et l'analyse sont les mêmes pour toutes les API REST. Par exemple, le service Frankfurter, qui publie les taux de référence quotidiens de la Banque centrale européenne, ne demande pas de clé et renvoie des devises comme le dollar, l'euro et la livre turque en une seule requête.
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}Les taux de la banque centrale sont mis à jour une fois par jour ouvré, vers 16 h, heure d'Europe centrale ; même une requête par heure est donc largement suffisante. Avec le même squelette, tu peux récupérer des données sismiques, le cours des cryptomonnaies, la hauteur d'une rivière ou une valeur de ton propre serveur. Seuls changent l'adresse et les noms des clés dans le JSON, que tu découvres en ouvrant l'adresse dans un navigateur et en regardant la réponse.
La météo avec le Raspberry Pi Pico W (MicroPython)
Sur les modèles Wi-Fi de la famille Raspberry Pi Pico, le Pico W et le Pico 2 W, le module urequests de MicroPython fait le même travail, et tu n'as pas besoin d'une bibliothèque JSON séparée : r.json() convertit directement la réponse en dictionnaire Python. Installe le dernier MicroPython avec Thonny et enregistre le code sous le nom main.py. Les détails de la connexion Wi-Fi sont dans le guide serveur web Wi-Fi avec le Pico W.
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 minutesurequests de MicroPython chiffre les connexions HTTPS mais ne vérifie pas le certificat du serveur ; le niveau de sécurité est le même que setInsecure() sur l'ESP32. Il est important d'appeler r.close() après chaque requête : si tu l'oublies, le Pico manque de sockets et de mémoire au bout de quelques requêtes et le code s'arrête sur une OSError.
Idées de projets météo avec l'ESP32
- Station météo de bureau : Affiche les données d'Open-Meteo sur un OLED et ajoute la température et la pression de la pièce avec un BME280, pour voir l'intérieur et l'extérieur côte à côte.
- Rappel parapluie : Un ESP32 près de la porte d'entrée allume une LED WS2812B rouge quand le risque de pluie du jour dépasse 60 pour cent.
- Arrosage intelligent : Si de la pluie est annoncée pour demain, l'arrosage est sauté ; associé à un capteur d'humidité du sol, tu ne gaspilles pas d'eau.
- Message du matin : Envoie chaque matin à 7 h la prévision du jour sur ton téléphone avec un bot Telegram.
- Domotique : Transmets la température extérieure à Home Assistant via MQTT et utilise-la pour piloter le chauffage.
- Tableau météo et devises : Affiche la température, la prévision sur 3 jours et les taux du jour sous forme de cartes colorées sur un écran TFT ILI9341.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Points sans fin dans le moniteur série | Pas de connexion au Wi-Fi | Réseau 2,4 GHz, bon mot de passe, plus près de la box |
| Code HTTP -1 | Problème d'internet, de domaine ou de HTTPS | Tester l'adresse dans un navigateur, vérifier WiFiClientSecure et le certificat |
| 401 Invalid API key | Clé fausse ou pas encore active | Recopier la clé ; avec un compte neuf, patienter un peu |
| Erreur JSON InvalidInput | La réponse n'est pas du JSON (page d'erreur HTML) | Afficher d'abord la réponse avec getString() |
| Erreur JSON IncompleteInput | Réponse coupée ou flux par morceaux | Utiliser getString() ou ajouter useHTTP10(true) |
| Température toujours à 0.00 | Nom de clé mal écrit | Copier le nom exact du JSON (temperature_2m) |
| Caractères bizarres à l'écran | Accents ou signe ° absents de la police | Utiliser lang=en, écrire le degré avec (char)247 |
| Blocage après quelques heures | Connexions non fermées, fragmentation de la mémoire | Appeler http.end() après chaque requête, allonger l'intervalle |
Un projet météo avec l'ESP32 t'apprend le schéma de base de tout objet connecté : se connecter, demander, analyser, afficher et recommencer à intervalles raisonnables. Une fois ce schéma maîtrisé, le même code peut récupérer des données auprès de centaines d'API différentes. Dans l'application BlueGrays, tu trouveras des projets qui affichent une API météo sur un LCD et un OLED SSD1306 avec ESP32 HTTPClient, ainsi que des projets de connexion Wi-Fi et d'horloge NTP, chacun avec son schéma et son code pas à pas.
Questions fréquentes
Comment obtenir la météo avec un ESP32 ?
Connecte l'ESP32 au Wi-Fi et envoie une requête GET à un service comme Open-Meteo ou OpenWeatherMap avec la bibliothèque HTTPClient. Lis ensuite la température, l'humidité et le code météo dans la réponse JSON avec ArduinoJson. Open-Meteo ne demande pas de clé d'API, c'est donc le choix le plus simple pour un premier essai.
L'API Open-Meteo est-elle gratuite ?
Open-Meteo est gratuite pour un usage non commercial et ne demande ni inscription ni clé d'API. L'usage gratuit est limité à 10 000 requêtes par jour, 5 000 par heure et 600 par minute. Pour un produit commercial, il faut passer à une offre payante.
Pourquoi ma clé OpenWeatherMap renvoie-t-elle l'erreur 401 ?
Un 401 signifie que la clé est fausse, absente ou pas encore activée. Les clés fraîchement créées mettent de quelques minutes à quelques heures à devenir actives. Vérifie que tu as copié la clé sans espace et que tu la passes dans l'adresse avec le paramètre appid=.
Que signifie l'erreur -1 de HTTP GET sur l'ESP32 ?
-1 correspond à HTTPC_ERROR_CONNECTION_REFUSED : aucune connexion n'a pu être établie. Les causes habituelles sont l'absence d'internet, un nom de domaine impossible à résoudre, une adresse mal tapée ou une connexion à un serveur HTTPS avec le mauvais certificat. http.errorToString(code) affiche la description dans le moniteur série.
À quelle fréquence un ESP32 doit-il mettre à jour la météo ?
Toutes les 10 à 15 minutes suffisent, car les services renouvellent leurs données à peu près à ce rythme. Cela représente 96 à 144 requêtes par jour, bien en dessous des limites gratuites. Interroger chaque seconde gaspille de l'énergie et peut te faire bloquer.
Quelle est la différence entre ArduinoJson 6 et 7 ?
ArduinoJson 7 remplace StaticJsonDocument et DynamicJsonDocument par une seule classe JsonDocument qui gère la mémoire toute seule. L'ancien code compile toujours avec un avertissement, mais dans un nouveau projet JsonDocument doc; suffit. L'analyse et la lecture avec doc["cle"] sont identiques dans les deux versions.
Projets à réaliser après cet article
Voir tous les projets
ESP32 HTTPClient + API météo (avec écran LCD)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Écran LCD I2C ESP32 (16x2)
Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

