ESP32 meteo API: scaricare i dati, leggere il JSON e usare OLED
Guida ESP32 meteo API: richieste HTTPClient a Open-Meteo e OpenWeatherMap, ArduinoJson, display OLED/LCD, certificato HTTPS ed errori 401, 404 e -1.
I progetti meteo con ESP32 consistono nel collegare la scheda al Wi-Fi, fare una domanda a un servizio meteo su internet e mostrare la risposta su un display. Senza un solo sensore puoi conoscere temperatura, umidità, vento e previsioni di domani nella tua città, perché un'API (interfaccia di programmazione) alimentata da stazioni meteo e modelli di previsione ha già fatto la misura per te. L'ESP32 invia a questo servizio una richiesta HTTP GET proprio come un browser, riceve testo semplice in formato JSON e ne estrae i numeri con la libreria ArduinoJson.
In questa guida invierai prima una richiesta a Open-Meteo, che non chiede alcuna chiave, e poi passerai a OpenWeatherMap, che funziona con i nomi delle città. Vedrai come analizzare il JSON, trasformare i codici meteo WMO in testo, mostrare il risultato su un OLED da 0,96 pollici e su un LCD I2C 16x2, configurare HTTPS e i certificati, rispettare i limiti di richieste e cosa significano codici di errore come 401, 404 e -1. Alla fine trovi un esempio che legge i tassi di cambio nello stesso modo e il codice MicroPython per il Raspberry Pi Pico W.

Come prende i dati da internet l'ESP32? API, HTTP e JSON
Quando scrivi un indirizzo nel browser, questo invia una richiesta HTTP al server e il server restituisce una pagina web. Un'API funziona allo stesso modo; l'unica differenza è che la risposta non è una pagina abbellita per le persone, ma un testo ordinato che i programmi leggono facilmente. Sull'ESP32 questo lavoro lo fa la libreria HTTPClient, inclusa nel core: le dai l'indirizzo, lei invia la richiesta GET e ti consegna il codice di stato del server e il corpo della risposta. La risposta di solito è JSON: coppie "chiave": valore tra parentesi graffe, che possono contenere oggetti annidati o array.
| Termine | Significato | Esempio meteo |
|---|---|---|
| API | La porta da cui i programmi si scambiano dati | Servizio di previsione di Open-Meteo |
| Endpoint | L'indirizzo dell'API che svolge un compito preciso | /v1/forecast |
| Parametro di query | Le impostazioni dopo il ? nell'indirizzo | latitude=41.01¤t=temperature_2m |
| Richiesta GET | Chiedere dati al server | http.GET() |
| Codice di stato | Numero che descrive l'esito della richiesta | 200 riuscita, 404 non trovato |
| JSON | Formato di testo fatto di chiavi e valori | {"temperature_2m":17.3} |
| Chiave API | Identificativo segreto che ti riconosce | Il valore appid di OpenWeatherMap |
Quale servizio: Open-Meteo o OpenWeatherMap?
Molti servizi meteo hanno un piano gratuito, ma per iniziare ne spiccano due. Open-Meteo non chiede né registrazione né chiave: indichi il luogo con latitudine e longitudine, scegli solo i campi che ti servono e la risposta resta breve e leggera per l'ESP32. OpenWeatherMap richiede un account gratuito e una chiave API, ma in cambio accetta le richieste per nome di città e fornisce un testo descrittivo pronto ("light rain", per esempio) e un codice icona. I piani gratuiti di entrambi sono pensati per progetti personali e didattici; se realizzi un prodotto commerciale, leggi a parte le condizioni d'uso.
| Caratteristica | Open-Meteo | OpenWeatherMap (gratis) |
|---|---|---|
| Registrazione e chiave | Non servono | Account e chiave API obbligatori |
| Luogo | Latitudine e longitudine | Nome della città, coordinate o ID città |
| Limite gratuito | 10.000 richieste al giorno, 5.000 all'ora, 600 al minuto | 60 richieste al minuto, 1.000.000 al mese |
| Aggiornamento dei dati | Dati attuali ogni 15 minuti | Circa ogni 10 minuti |
| Condizioni del cielo | Codice numerico WMO (0, 3, 61...) | Testo descrittivo e codice icona |
| Unità | °C e km/h (modificabili con parametri) | °C e m/s con units=metric |
| Dimensione della risposta | Solo i campi scelti, circa 400 byte | Circa 500 byte |
Cosa ti serve e configurazione
- Installa il pacchetto delle schede ESP32 nell'Arduino IDE (Strumenti > Scheda > Gestore schede, esp32 by Espressif). L'installazione è spiegata nel dettaglio nella guida cos'è l'ESP32.
- Nel Gestore librerie cerca ArduinoJson (Benoit Blanchon) e installa la versione 7.x. Le librerie HTTPClient, WiFi e WiFiClientSecure fanno parte del pacchetto ESP32 e non vanno installate a parte.
- Per la versione con display installa Adafruit SSD1306 e Adafruit GFX, oppure LiquidCrystal I2C se usi un LCD.
- Sostituisci AgAdi e Sifre123 nel codice con il nome e la password del tuo Wi-Fi, scegli ESP32 Dev Module come scheda e imposta il Monitor seriale a 115200 baud.
Passo dopo passo: la prima richiesta GET con HTTPClient
Il primo sketch ha un solo compito: collegarsi al Wi-Fi, chiedere a Open-Meteo il meteo attuale di Istanbul e stampare la risposta così com'è nel Monitor seriale. Il parametro current= dell'indirizzo indica quali campi vuoi; separati da virgole, abbiamo scelto temperatura, umidità, codice meteo e velocità del vento. timezone=auto converte gli orari nell'ora locale del luogo.
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}Dopo il caricamento dovresti vedere nel Monitor seriale prima "HTTP kodu / code: 200" e poi una sola riga di JSON. La parte utile della risposta è simile a questa: "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. Il valore 900 di interval indica che i dati si rinnovano ogni 900 secondi, cioè ogni 15 minuti; ti servirà più avanti per decidere ogni quanto fare le richieste.
| Funzione | Cosa fa? |
|---|---|
| http.begin(url) | Analizza l'indirizzo e prepara la connessione |
| http.GET() | Invia la richiesta; restituisce il codice di stato HTTP o un codice di errore negativo |
| http.getString() | Legge il corpo della risposta come String |
| http.getStream() | Fornisce il corpo come flusso senza memorizzarlo tutto (per risposte grandi) |
| http.errorToString(codice) | Trasforma un codice di errore negativo in testo leggibile |
| http.setTimeout(ms) | Tempo di attesa della risposta (predefinito 5000 ms) |
| http.end() | Chiude la connessione e libera la memoria |
Analizzare il JSON con ArduinoJson
Mostrare il JSON grezzo su un display non serve a niente; devi estrarre il numero 17.3 e metterlo in una variabile float. ArduinoJson trasforma il testo in un albero in memoria e tu scendi lungo i rami usando i nomi delle chiavi: doc["current"]["temperature_2m"] va prima all'oggetto current e poi alla temperatura al suo interno. A qualunque tipo di variabile assegni il valore, la libreria lo converte in quel tipo. Se chiedi una chiave che non esiste il programma non si blocca: ottieni 0 per un numero e un puntatore nullo per un testo.
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}Questo codice è per ArduinoJson 7. Le righe StaticJsonDocument e DynamicJsonDocument doc(1024) che vedrai negli esempi vecchi appartengono alla versione 6.x; nella 7.x basta scrivere JsonDocument doc; e la memoria viene riservata da sola secondo il bisogno. Se compilando un codice vecchio ricevi l'avviso "StaticJsonDocument is deprecated", il motivo è questo: di solito il codice funziona ancora, ma passare alla nuova scrittura è più pulito. La lettura con doc["chiave"] è identica nelle due versioni.
Codici meteo WMO: trasformare il numero in testo
Open-Meteo non descrive il tempo con una parola come "nuvoloso", ma con un numero definito dall'Organizzazione meteorologica mondiale (WMO). Così la risposta non dipende dalla lingua e sei tu a decidere in quale lingua scrive il display. Questi sono i codici che vedrai più spesso:
| Codice WMO | Significato |
|---|---|
| 0 | Sereno |
| 1, 2, 3 | Prevalentemente sereno, parzialmente nuvoloso, coperto |
| 45, 48 | Nebbia, nebbia con brina |
| 51, 53, 55 | Pioviggine leggera, moderata, intensa |
| 56, 57 | Pioviggine gelata |
| 61, 63, 65 | Pioggia debole, moderata, forte |
| 66, 67 | Pioggia gelata |
| 71, 73, 75 | Nevicata debole, moderata, forte |
| 77 | Neve granulosa |
| 80, 81, 82 | Rovesci deboli, moderati, violenti |
| 85, 86 | Rovesci di neve deboli e forti |
| 95 | Temporale |
| 96, 99 | Temporale con grandine |
La funzione wmoText() dello sketch OLED qui sotto trasforma questa tabella in etichette brevi. Nel codice sono scritte in turco senza caratteri speciali; puoi sostituirle con parole italiane come "Sereno", "Pioggia" o "Neve" (senza accenti, come vedrai più avanti). Se vuoi disegnare le tue icone, usa gli stessi intervalli per scegliere bitmap di sole, nuvola o goccia; per esempio, una sola icona di pioggia basta per 61-67 e 80-82.
Il meteo per nome di città con OpenWeatherMap
Dopo aver creato un account gratuito su OpenWeatherMap trovi una chiave di 32 caratteri nella sezione API keys del tuo account. Una chiave nuova può impiegare da qualche minuto a qualche ora per attivarsi; nel frattempo ogni richiesta restituisce 401 e potresti pensare che il tuo codice sia sbagliato. Nella richiesta, q=Ankara,TR imposta il nome della città e il codice del paese, units=metric i gradi Celsius e i m/s, e lang la lingua della descrizione.
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}Due dettagli di questa risposta meritano attenzione. Primo, il campo weather non è un oggetto ma un array, quindi alla descrizione si arriva tramite il suo primo elemento: doc["weather"][0]["description"]. Secondo, con units=metric la velocità del vento arriva in m/s; moltiplica per 3,6 per avere i km/h. Con lang=it le descrizioni arrivano in italiano ("pioggia leggera"), ma i font predefiniti di Adafruit GFX e degli LCD HD44780 non mostrano lettere come à, è o ù. Per non vedere caratteri rotti sul display è più sicuro usare lang=en e scrivere le tue etichette brevi.
HTTPS e certificato: setInsecure o setCACert?
La maggior parte dei servizi meteo ormai usa HTTPS e alcuni non accettano più il semplice HTTP. Con HTTPS il traffico tra ESP32 e server viene cifrato; per essere sicuro di parlare davvero con quel server, l'ESP32 deve anche verificare la catena dei certificati con un certificato radice. Per questo si usa WiFiClientSecure al posto del semplice WiFiClient, e ci sono due possibilità.
setInsecure() cifra la connessione ma non controlla il certificato. È una scelta pratica e diffusa per dati pubblici e non segreti come il meteo, ma qualcuno nel mezzo potrebbe mandarti dati falsi. setCACert() verifica la catena con il certificato radice che fornisci. Il certificato di Open-Meteo è emesso da Let's Encrypt e risale alla radice ISRG Root X1, valida fino al 2035. Il certificato del server si rinnova ogni pochi mesi, quindi non mettere mai quello nel codice: usa sempre la radice in cima alla catena.
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}Mostrare il meteo della tua città su un display OLED

Ora lasciamo il Monitor seriale e costruiamo una vera stazione meteo da scrivania. L'OLED SSD1306 da 0,96 pollici si collega ai pin I2C dell'ESP32. Per le basi del display e i dettagli della libreria, guarda la guida display OLED SSD1306.
| Pin 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}All'avvio lo sketch si collega al Wi-Fi, scarica subito i primi dati e poi li aggiorna ogni 10 minuti. Per l'attesa usiamo millis() al posto di delay(), così puoi leggere pulsanti o aggiungere un'animazione mentre loop() gira libero. Se la connessione cade, il codice mostra un avviso e prova a ricollegarsi; se una richiesta fallisce, mostra il codice di errore. L'ora in alto a destra è la parte dopo la lettera T nel testo "2026-11-17T14:15" della risposta: vedi così l'ora dell'ultima misura senza impostare nessun orologio. Se vuoi un orologio che avanza secondo per secondo, aggiungi a questo sketch il metodo della guida ora NTP con ESP32.
Visualizzarlo su un LCD I2C 16x2
Se al posto dell'OLED hai un LCD a caratteri 16x2, puoi far stare gli stessi dati su due righe. Alimentare il modulo LCD dal pin VIN dell'ESP32, che fornisce 5 V, migliora il contrasto; collega SDA a GPIO 21 e SCL a GPIO 22. Poiché il modulo porta le linee I2C a 5 V, la soluzione più sicura è un convertitore di livello in mezzo. Basta sostituire le righe di disegno dello sketch OLED con una funzione come questa; trovi altri dettagli nella guida display 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}Frequenza delle richieste e limiti gratuiti
L'errore più comune è mettere delay(1000) nel loop() e inviare una richiesta ogni secondo. È inutile e ti porta presto ai limiti: i dati attuali di Open-Meteo si rinnovano comunque solo ogni 15 minuti, quindi chiedendo ogni secondo ricevi 900 volte la stessa risposta. Una richiesta al secondo fa 86.400 al giorno e riempie il limite giornaliero di 10.000 di Open-Meteo in meno di tre ore. Il calcolo è semplice: le richieste al giorno sono 1440 diviso l'intervallo in minuti.
| Intervallo | Richieste al giorno | Valutazione |
|---|---|---|
| 1 secondo | 86.400 | Limite superato, il tuo indirizzo IP può essere bloccato temporaneamente |
| 1 minuto | 1.440 | Nel limite ma sprecato, perché i dati non cambiano |
| 10 minuti | 144 | Ideale per una stazione da scrivania |
| 15 minuti | 96 | Uguale all'aggiornamento di Open-Meteo |
| 1 ora | 24 | Sufficiente per dispositivi a batteria e previsioni giornaliere |
Codici di errore: 401, 404, 429 e -1
http.GET() restituisce due tipi di numeri. I numeri positivi sono codici di stato HTTP del server: la connessione è avvenuta e il server ti ha sentito, ma qualcosa nella tua richiesta non gli va bene. I numeri negativi sono codici di errore propri dell'ESP32 e indicano che la richiesta non ha mai raggiunto il server o che la risposta si è interrotta.
| Codice | Significato | Cosa fare |
|---|---|---|
| 200 | Riuscita | Leggere e analizzare il corpo |
| 400 | Richiesta errata | Controllare i nomi dei parametri e le virgole dell'indirizzo |
| 401 | Non autorizzato: chiave API mancante, sbagliata o non ancora attiva | Ricopiare la chiave; se è nuova, aspettare un po' |
| 404 | Non trovato: nome della città o indirizzo sbagliati | Scrivere la città senza accenti (Forli,IT), controllare l'indirizzo |
| 429 | Troppe richieste | Allungare l'intervallo |
| 500-503 | Problema lato server | Riprovare tra qualche minuto |
| -1 | Nessuna connessione: niente internet, dominio non risolto, indirizzo errato o handshake HTTPS fallito | Controllare Wi-Fi, indirizzo e certificato |
| -5 | Connessione persa a metà | Migliorare il segnale Wi-Fi, ripetere la richiesta |
| -11 | Timeout di lettura | Allungare l'attesa con http.setTimeout() |
Anche in caso di errore OpenWeatherMap restituisce JSON: con una chiave sbagliata arriva {"cod":401, "message":"Invalid API key..."} e per una città sconosciuta {"cod":"404","message":"city not found"}. Nel primo caso cod è un numero, nel secondo un testo tra virgolette. Se basi il codice sul numero restituito da http.GET() e non sul campo cod, questa incoerenza non ti riguarda.
Risposte grandi: filtro, getStream e useHTTP10
Quando chiedi una previsione oraria o a 7 giorni, la risposta può passare da pochi kilobyte a decine. getString() mette prima tutta la risposta in una String e poi nell'albero di ArduinoJson, quindi la memoria si usa due volte. Invece puoi analizzare la risposta mentre arriva con http.getStream() e tenere solo i campi che ti servono con un filtro. C'è una trappola: se il server invia la risposta a pezzi (chunked), le dimensioni dei pezzi si mescolano al flusso e il JSON si rompe. Open-Meteo invia le risposte a pezzi; http.useHTTP10(true) fa la richiesta in HTTP/1.0 e obbliga il server a inviare una risposta semplice.
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}Allo stesso modo puoi chiedere hourly=temperature_2m e disegnare un grafico della temperatura sulle 24 ore, oppure usare daily=precipitation_probability_max per accendere un LED se domani è probabile la pioggia. In Open-Meteo forecast_days può valere al massimo 16; per l'ESP32 da 3 a 7 giorni è un intervallo comodo.
Altre API, stesso metodo: esempio dei tassi di cambio
Quello che hai imparato qui non riguarda solo il meteo: indirizzo, GET, JSON e analisi sono uguali per tutte le API REST. Per esempio il servizio Frankfurter, che pubblica i tassi di riferimento giornalieri della Banca centrale europea, non chiede chiavi e restituisce valute come il dollaro, l'euro e la lira turca con una sola richiesta.
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}I tassi della banca centrale si aggiornano una volta al giorno nei giorni lavorativi, verso le 16:00 ora dell'Europa centrale, quindi anche una richiesta all'ora è più che sufficiente. Con lo stesso scheletro puoi scaricare dati sui terremoti, prezzi delle criptovalute, il livello di un fiume o un valore dal tuo server. Cambiano solo l'indirizzo e i nomi delle chiavi nel JSON, che scopri aprendo l'indirizzo nel browser e guardando la risposta.
Il meteo con il Raspberry Pi Pico W (MicroPython)
Sui modelli Wi-Fi della famiglia Raspberry Pi Pico, il Pico W e il Pico 2 W, lo stesso lavoro lo fa il modulo urequests di MicroPython e non serve una libreria JSON a parte: r.json() converte la risposta direttamente in un dizionario Python. Installa l'ultimo MicroPython con Thonny e salva il codice come main.py. I dettagli della connessione Wi-Fi sono nella guida web server Wi-Fi con 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 di MicroPython cifra le connessioni HTTPS ma non verifica il certificato del server; il livello di sicurezza è lo stesso di setInsecure() sull'ESP32. È importante chiamare r.close() dopo ogni richiesta: se lo dimentichi, dopo poche richieste il Pico esaurisce socket e memoria e il codice si ferma con un OSError.
Idee di progetti meteo con l'ESP32
- Stazione meteo da scrivania: Mostra i dati di Open-Meteo su un OLED e aggiungi temperatura e pressione della stanza con un BME280, così vedi dentro e fuori uno accanto all'altro.
- Promemoria ombrello: Un ESP32 vicino alla porta di casa accende un LED WS2812B rosso quando la probabilità di pioggia del giorno supera il 60 per cento.
- Irrigazione intelligente: Se per domani è prevista pioggia, l'irrigazione salta; insieme a un sensore di umidità del terreno non sprechi acqua.
- Messaggio del mattino: Ogni mattina alle 7:00 invia al telefono la previsione del giorno con un bot Telegram.
- Domotica: Invia la temperatura esterna a Home Assistant via MQTT e usala per decidere il riscaldamento.
- Pannello meteo e valute: Mostra temperatura, previsione a 3 giorni e cambi del giorno come schede colorate su un display TFT ILI9341.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Puntini infiniti nel Monitor seriale | Non si collega al Wi-Fi | Rete a 2,4 GHz, password corretta, più vicino al router |
| Codice HTTP -1 | Problema di internet, dominio o HTTPS | Provare l'indirizzo nel browser, controllare WiFiClientSecure e certificato |
| 401 Invalid API key | Chiave sbagliata o non ancora attiva | Ricopiare la chiave; con un account nuovo aspettare un po' |
| Errore JSON InvalidInput | La risposta non è JSON (pagina di errore HTML) | Stampare prima la risposta con getString() |
| Errore JSON IncompleteInput | Risposta troncata o flusso a pezzi | Usare getString() o aggiungere useHTTP10(true) |
| Temperatura sempre 0.00 | Nome della chiave scritto male | Copiare il nome esatto dal JSON (temperature_2m) |
| Caratteri strani sul display | Accenti o simbolo ° assenti dal font | Usare lang=en, scrivere il grado con (char)247 |
| Blocco dopo qualche ora | Connessioni non chiuse, frammentazione della memoria | Chiamare http.end() dopo ogni richiesta, allungare l'intervallo |
Un progetto meteo con ESP32 insegna lo schema di base di ogni dispositivo connesso: collegarsi, chiedere, analizzare, mostrare e ripetere a intervalli ragionevoli. Una volta padroneggiato questo schema, lo stesso codice può scaricare dati da centinaia di API diverse. Nell'app BlueGrays trovi progetti che mostrano un'API meteo su un LCD e su un OLED SSD1306 con ESP32 HTTPClient, insieme a progetti di connessione Wi-Fi e orologio NTP, ognuno con schema elettrico e codice passo dopo passo.
Domande frequenti
Come si ottiene il meteo con un ESP32?
Collega l'ESP32 al Wi-Fi e invia una richiesta GET a un servizio come Open-Meteo o OpenWeatherMap con la libreria HTTPClient. Poi leggi temperatura, umidità e codice meteo dalla risposta JSON con ArduinoJson. Open-Meteo non richiede una chiave API, per questo è la scelta più semplice per una prima prova.
L'API di Open-Meteo è gratuita?
Open-Meteo è gratuita per uso non commerciale e non chiede né registrazione né chiave API. L'uso gratuito è limitato a 10.000 richieste al giorno, 5.000 all'ora e 600 al minuto. Per un prodotto commerciale serve un piano a pagamento.
Perché la mia chiave OpenWeatherMap dà errore 401?
Un 401 indica che la chiave è sbagliata, mancante o non ancora attivata. Le chiavi appena create impiegano da qualche minuto a qualche ora per diventare attive. Controlla di aver copiato la chiave senza spazi e di passarla nell'indirizzo con il parametro appid=.
Cosa significa l'errore -1 di HTTP GET sull'ESP32?
-1 è HTTPC_ERROR_CONNECTION_REFUSED e indica che non è stato possibile stabilire alcuna connessione. Di solito dipende dalla mancanza di internet, da un dominio che non si risolve, da un indirizzo scritto male o dal collegarsi a un server HTTPS con il certificato sbagliato. Con http.errorToString(codice) stampi la descrizione nel Monitor seriale.
Ogni quanto un ESP32 dovrebbe aggiornare il meteo?
Ogni 10-15 minuti è sufficiente, perché i servizi rinnovano i dati più o meno con questo ritmo. Sono da 96 a 144 richieste al giorno, molto sotto i limiti gratuiti. Chiedere ogni secondo spreca energia e può farti bloccare.
Che differenza c'è tra ArduinoJson 6 e 7?
ArduinoJson 7 sostituisce StaticJsonDocument e DynamicJsonDocument con un'unica classe JsonDocument che gestisce la memoria da sola. Il codice vecchio compila ancora con un avviso, ma nei progetti nuovi basta JsonDocument doc;. L'analisi e la lettura con doc["chiave"] sono uguali nelle due versioni.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
ESP32 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

