Guides · 15 min de lecture

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.

Carte de développement ESP32
ESP32 : grâce à son Wi-Fi intégré, il récupère les données météo sur internet sans aucun module supplémentaire.

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.

TermeSignificationExemple météo
APILa porte par laquelle les programmes échangent des donnéesService 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êteLes réglages après le ? dans l'adresselatitude=41.01¤t=temperature_2m
Requête GETDemander des données au serveurhttp.GET()
Code d'étatNombre qui décrit le résultat de la requête200 succès, 404 introuvable
JSONFormat texte fait de clés et de valeurs{"temperature_2m":17.3}
Clé d'APIIdentifiant secret qui te reconnaîtLa 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éristiqueOpen-MeteoOpenWeatherMap (gratuit)
Inscription et cléInutilesCompte et clé d'API obligatoires
LieuLatitude et longitudeNom de ville, coordonnées ou identifiant de ville
Limite gratuite10 000 requêtes par jour, 5 000 par heure, 600 par minute60 requêtes par minute, 1 000 000 par mois
Mise à jour des donnéesDonnées actuelles toutes les 15 minutesEnviron toutes les 10 minutes
État du cielCode 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éponseSeulement les champs choisis, environ 400 octetsEnviron 500 octets
Si tu veux seulement afficher la température et le temps qu'il fait, commence par Open-Meteo : tu auras un résultat dès la première minute sans attendre de clé. Pour connaître la latitude et la longitude de ton lieu, fais un clic droit sur ta ville dans une appli de cartes (ou un appui long sur téléphone). Pour Paris 48.86, 2.35, pour Lyon 45.76, 4.84 et pour Montréal 45.50, -73.57 suffisent.

Matériel nécessaire et installation

  1. 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.
  2. 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.
  3. Pour la version avec écran, installe Adafruit SSD1306 et Adafruit GFX, ou LiquidCrystal I2C si tu utilises un LCD.
  4. 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.
L'ESP32 ne se connecte qu'aux réseaux Wi-Fi 2,4 GHz. Si le code affiche des points sans fin sur la ligne du Wi-Fi, le problème vient de la connexion, pas de l'API : vérifie le nom du réseau, le mot de passe et que ta box émet bien en 2,4 GHz. Tu trouveras une liste détaillée de solutions dans le guide l'ESP32 ne se connecte pas au Wi-Fi.

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.

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

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.

FonctionQue 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.

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

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.

Si deserializeJson() renvoie une erreur, err.c_str() t'en donne la raison : IncompleteInput signifie que la réponse a été coupée, InvalidInput que le texte n'est pas du JSON (le plus souvent une page d'erreur HTML) et NoMemory que la mémoire n'a pas suffi. Le moyen le plus rapide de régler le problème est d'afficher d'abord la réponse avec Serial.println() et de la regarder.

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 WMOSignification
0Ciel dégagé
1, 2, 3Plutôt dégagé, partiellement nuageux, couvert
45, 48Brouillard, brouillard givrant
51, 53, 55Bruine légère, modérée, dense
56, 57Bruine verglaçante
61, 63, 65Pluie faible, modérée, forte
66, 67Pluie verglaçante
71, 73, 75Chute de neige faible, modérée, forte
77Neige en grains
80, 81, 82Averses faibles, modérées, violentes
85, 86Averses de neige faibles et fortes
95Orage
96, 99Orage 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.

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

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.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7
8// ISRG Root X1: Let's Encrypt kök sertifikası, 2035'e kadar geçerli
9// ISRG Root X1: Let's Encrypt root certificate, valid until 2035
10const char* ROOT_CA = R"EOF(
11-----BEGIN CERTIFICATE-----
12MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
13TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
14cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
15WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
16ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
17MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
18h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
190TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
20A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
21T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
22B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
23B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
24KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
25OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
26jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
27qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
28rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
29HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
30hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
31ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
323BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
33NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
34ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
35TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
36jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
37oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
384RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
39mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
40emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
41-----END CERTIFICATE-----
42)EOF";
43
44void setup() {
45  Serial.begin(115200);
46  WiFi.begin(WIFI_SSID, WIFI_PASS);
47  while (WiFi.status() != WL_CONNECTED) delay(500);
48
49  WiFiClientSecure client;
50  client.setCACert(ROOT_CA);       // sunucuyu doğrula / verify the server
51  // client.setInsecure();         // yalnız deneme için: şifreler ama doğrulamaz / testing only: encrypts, no verification
52
53  HTTPClient http;
54  http.begin(client, "https://api.open-meteo.com/v1/forecast?latitude=39.93&longitude=32.86&current=temperature_2m");
55  int code = http.GET();
56  Serial.printf("HTTPS kodu / code: %d\n", code);
57  if (code > 0) Serial.println(http.getString());
58  else Serial.println(HTTPClient::errorToString(code));
59  http.end();
60}
61
62void loop() {
63}
Avant d'utiliser un certificat racine pour un autre service, vérifie de quelle racine dépend ce site : OpenWeatherMap utilise la chaîne Sectigo et USERTrust, Frankfurter celle de Google Trust Services. Si tu donnes la mauvaise racine, GET() renvoie -1 et le moniteur série ne t'offre aucun autre indice. Si tu envoies une information secrète, comme ta clé d'API, utilise toujours setCACert() plutôt que setInsecure().

Afficher la météo de ta ville sur un écran OLED

Écran OLED I2C de 0,96 pouce
OLED SSD1306 de 0,96 pouce : il se branche à l'ESP32 avec seulement quatre fils et affiche la météo en gros chiffres.

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

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.

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

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.

IntervalleRequêtes par jourVerdict
1 seconde86 400Limite dépassée ; ton adresse IP peut être bloquée temporairement
1 minute1 440Dans la limite mais inutile, car les données ne changent pas
10 minutes144Idéal pour une station de bureau
15 minutes96Correspond au rafraîchissement d'Open-Meteo
1 heure24Suffisant pour les appareils sur batterie et les prévisions du jour
Dans une station météo sur batterie, c'est le Wi-Fi qui consomme le plus. Si tu mets l'ESP32 en sommeil profond pendant 15 minutes après avoir récupéré les données, le courant moyen descend sous 1 mA sur un module nu et à quelques milliampères sur une carte de développement classique, et une seule cellule 18650 tient des semaines. Les détails sont dans le guide deep sleep de l'ESP32.

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.

CodeSignificationQue faire ?
200SuccèsLire et analyser le corps
400Requête incorrecteVérifier les noms des paramètres et les virgules de l'adresse
401Non autorisé : clé d'API absente, fausse ou pas encore activeRecopier la clé ; si elle est neuve, patienter un peu
404Introuvable : nom de ville ou adresse erronésÉcrire la ville sans accents (Orleans,FR), vérifier l'adresse
429Trop de requêtesAllonger l'intervalle
500-503Problème côté serveurRéessayer dans quelques minutes
-1Pas de connexion : pas d'internet, domaine non résolu, adresse erronée ou échec de la négociation HTTPSVérifier le Wi-Fi, l'adresse et le certificat
-5Connexion perdue en cours de routeAméliorer le signal Wi-Fi, relancer la requête
-11Dé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.

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

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.

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

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.

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

urequests 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ômeCause probableSolution
Points sans fin dans le moniteur sériePas de connexion au Wi-FiRéseau 2,4 GHz, bon mot de passe, plus près de la box
Code HTTP -1Problème d'internet, de domaine ou de HTTPSTester l'adresse dans un navigateur, vérifier WiFiClientSecure et le certificat
401 Invalid API keyClé fausse ou pas encore activeRecopier la clé ; avec un compte neuf, patienter un peu
Erreur JSON InvalidInputLa réponse n'est pas du JSON (page d'erreur HTML)Afficher d'abord la réponse avec getString()
Erreur JSON IncompleteInputRéponse coupée ou flux par morceauxUtiliser getString() ou ajouter useHTTP10(true)
Température toujours à 0.00Nom de clé mal écritCopier le nom exact du JSON (temperature_2m)
Caractères bizarres à l'écranAccents ou signe ° absents de la policeUtiliser lang=en, écrire le degré avec (char)247
Blocage après quelques heuresConnexions non fermées, fragmentation de la mémoireAppeler http.end() après chaque requête, allonger l'intervalle
Le moyen le plus simple d'isoler un problème est de coller d'abord l'adresse dans le navigateur de ton ordinateur. Si tu y vois un JSON propre, le problème vient de l'ESP32 (Wi-Fi, certificat ou analyse) ; si le navigateur affiche lui aussi une erreur, c'est l'adresse ou la clé d'API qu'il faut corriger.

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.

Voir tous les projets
ESP32 HTTPClient + API météo (avec écran LCD)
ES-31Avancé
Premium

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.

4.7(13)
20
ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
ES-32Avancé
Premium

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.

4.3(10)
22
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

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.

4.4(21)
38
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

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.

4.5(13)
22
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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).

4.8(16)
26
Écran LCD I2C ESP32 (16x2)
ES-17Intermédiaire
Premium

É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).

4.9(23)
40
Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
ES-33Avancé
Premium

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.

4.3(10)
16
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

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.

4.7(7)
12