Guías · 15 min de lectura

ESP32 API del clima: obtener datos, leer JSON y mostrar en OLED

Guía ESP32 API del clima: peticiones HTTPClient a Open-Meteo y OpenWeatherMap, ArduinoJson, pantalla OLED/LCD, certificado HTTPS y errores 401, 404 y -1.

Los proyectos de clima con ESP32 consisten en conectar la placa al Wi-Fi, hacer una pregunta a un servicio meteorológico en internet y mostrar la respuesta en una pantalla. Sin un solo sensor puedes saber la temperatura, la humedad, el viento y el pronóstico de mañana en tu ciudad, porque una API (interfaz de programación de aplicaciones) alimentada por estaciones meteorológicas y modelos de predicción ya ha hecho la medición por ti. El ESP32 envía a ese servicio una petición HTTP GET igual que un navegador, recibe texto plano en formato JSON y saca los números con la librería ArduinoJson.

En esta guía primero harás una petición a Open-Meteo, que no necesita clave, y luego pasarás a OpenWeatherMap, que funciona con nombres de ciudad. Verás cómo analizar el JSON, convertir los códigos meteorológicos WMO en texto, mostrar el resultado en una OLED de 0,96 pulgadas y en una LCD I2C de 16x2, configurar HTTPS y certificados, respetar los límites de peticiones y qué significan códigos de error como 401, 404 y -1. Al final hay un ejemplo que obtiene tipos de cambio de la misma forma y código MicroPython para la Raspberry Pi Pico W.

Placa de desarrollo ESP32
ESP32: gracias a su Wi-Fi integrado puede obtener datos meteorológicos de internet sin ningún módulo extra.

¿Cómo obtiene el ESP32 datos de internet? API, HTTP y JSON

Cuando escribes una dirección en el navegador, este envía una petición HTTP al servidor y el servidor devuelve una página web. Una API funciona igual; la única diferencia es que la respuesta no es una página decorada para personas, sino texto ordenado que los programas leen con facilidad. En el ESP32 este trabajo lo hace la librería HTTPClient, que viene con el núcleo: le das la dirección, envía la petición GET y te entrega el código de estado del servidor y el cuerpo de la respuesta. La respuesta suele ser JSON: pares "clave": valor entre llaves, que pueden contener objetos anidados o arrays.

TérminoSignificadoEjemplo meteorológico
APILa puerta por la que los programas intercambian datosServicio de pronóstico de Open-Meteo
EndpointLa dirección de la API que hace un trabajo concreto/v1/forecast
Parámetro de consultaAjustes que van después del ? en la direcciónlatitude=41.01¤t=temperature_2m
Petición GETPedir datos al servidorhttp.GET()
Código de estadoNúmero que describe el resultado de la petición200 correcto, 404 no encontrado
JSONFormato de texto hecho de claves y valores{"temperature_2m":17.3}
Clave de APIIdentificador secreto que te reconoceEl valor appid de OpenWeatherMap

¿Qué servicio: Open-Meteo u OpenWeatherMap?

Muchos servicios meteorológicos tienen un plan gratuito, pero dos destacan para empezar. Open-Meteo no pide registro ni clave: indicas la ubicación con latitud y longitud, eliges solo los campos que quieres y la respuesta queda corta y ligera para el ESP32. OpenWeatherMap necesita una cuenta gratuita y una clave de API, pero a cambio permite consultar por nombre de ciudad y ofrece un texto descriptivo listo ("light rain", por ejemplo) y un código de icono. Los planes gratuitos de ambos son para proyectos personales y educativos; si vas a crear un producto comercial, lee aparte las condiciones de uso.

CaracterísticaOpen-MeteoOpenWeatherMap (gratis)
Registro y claveNo hacen faltaCuenta y clave de API obligatorias
UbicaciónLatitud y longitudNombre de ciudad, coordenadas o ID de ciudad
Límite gratuito10.000 peticiones al día, 5.000 por hora, 600 por minuto60 peticiones por minuto, 1.000.000 al mes
Actualización de datosDatos actuales cada 15 minutosAproximadamente cada 10 minutos
Estado del tiempoCódigo numérico WMO (0, 3, 61...)Texto descriptivo y código de icono
Unidades°C y km/h (se cambian con parámetros)°C y m/s con units=metric
Tamaño de la respuestaSolo los campos elegidos, unos 400 bytesUnos 500 bytes
Si solo vas a mostrar la temperatura y el estado del tiempo, empieza con Open-Meteo: tendrás un resultado en el primer minuto sin esperar ninguna clave. La latitud y longitud de tu ubicación las encuentras haciendo clic derecho sobre tu ciudad en una app de mapas (o manteniendo pulsado en el móvil). Para Madrid bastan 40.42, -3.70; para Ciudad de México 19.43, -99.13 y para Buenos Aires -34.60, -58.38.

Qué necesitas y configuración

  1. Instala el paquete de placas ESP32 en el Arduino IDE (Herramientas > Placa > Gestor de placas, esp32 by Espressif). La instalación se explica en detalle en la guía qué es el ESP32.
  2. En el Gestor de librerías busca ArduinoJson (Benoit Blanchon) e instala la versión 7.x. Las librerías HTTPClient, WiFi y WiFiClientSecure vienen con el paquete ESP32 y no hay que instalarlas aparte.
  3. Para la versión con pantalla instala Adafruit SSD1306 y Adafruit GFX, o LiquidCrystal I2C si vas a usar una LCD.
  4. Sustituye AgAdi y Sifre123 en el código por el nombre y la contraseña de tu Wi-Fi, elige ESP32 Dev Module como placa y pon el Monitor Serie a 115200 baudios.
El ESP32 solo se conecta a redes Wi-Fi de 2,4 GHz. Si el código no para de imprimir puntos en la línea del Wi-Fi, el problema está en la conexión, no en la API: revisa el nombre de la red, la contraseña y que el router emita en 2,4 GHz. Tienes una lista detallada de soluciones en la guía el ESP32 no se conecta al Wi-Fi.

Paso a paso: tu primera petición GET con HTTPClient

El primer sketch tiene una sola tarea: conectarse al Wi-Fi, pedir a Open-Meteo el tiempo actual en Estambul e imprimir la respuesta tal cual en el Monitor Serie. El parámetro current= de la dirección indica qué campos quieres; separados por comas, elegimos temperatura, humedad, código del tiempo y velocidad del viento. timezone=auto convierte las horas a la hora local del lugar.

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}

Tras subirlo deberías ver en el Monitor Serie primero "HTTP kodu / code: 200" y después una línea de JSON. La parte útil de la respuesta se parece a esto: "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. El valor 900 de interval indica que los datos se renuevan cada 900 segundos, es decir, cada 15 minutos; lo necesitarás más adelante para decidir cada cuánto hacer peticiones.

Función¿Qué hace?
http.begin(url)Analiza la dirección y prepara la conexión
http.GET()Envía la petición; devuelve el código de estado HTTP o un código de error negativo
http.getString()Lee el cuerpo de la respuesta como String
http.getStream()Entrega el cuerpo como flujo sin guardarlo entero (para respuestas grandes)
http.errorToString(código)Convierte un código de error negativo en texto legible
http.setTimeout(ms)Tiempo de espera de la respuesta (por defecto 5000 ms)
http.end()Cierra la conexión y libera la memoria

Analizar JSON con ArduinoJson

Mostrar el JSON en bruto en una pantalla no sirve de nada; tienes que sacar el número 17.3 y guardarlo en una variable float. ArduinoJson convierte el texto en un árbol en memoria y tú bajas por sus ramas con los nombres de las claves: doc["current"]["temperature_2m"] va primero al objeto current y luego a la temperatura que contiene. Al tipo de variable al que asignes el valor, a ese tipo lo convierte la librería. Si pides una clave que no existe, el programa no se cuelga; obtienes 0 para un número y un puntero nulo para un texto.

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}

Este código es para ArduinoJson 7. Las líneas StaticJsonDocument y DynamicJsonDocument doc(1024) que verás en ejemplos antiguos pertenecen a la versión 6.x; en la 7.x basta con escribir JsonDocument doc; y la memoria se reserva sola según haga falta. Si al compilar código antiguo te aparece el aviso "StaticJsonDocument is deprecated", esa es la razón: el código suele seguir funcionando, pero pasarse a la nueva forma es más limpio. La lectura con doc["clave"] es igual en las dos versiones.

Si deserializeJson() devuelve un error, err.c_str() te dice el motivo: IncompleteInput significa que la respuesta llegó cortada, InvalidInput que el texto no es JSON (casi siempre una página de error HTML) y NoMemory que no hubo memoria suficiente. La forma más rápida de resolverlo es imprimir antes la respuesta con Serial.println() y mirarla.

Códigos meteorológicos WMO: convertir el número en texto

Open-Meteo no describe el tiempo con una palabra como "nublado", sino con un número definido por la Organización Meteorológica Mundial (WMO). Así la respuesta no depende del idioma y tú decides en qué idioma muestra la pantalla. Estos son los códigos que verás más a menudo:

Código WMOSignificado
0Despejado
1, 2, 3Mayormente despejado, parcialmente nublado, cubierto
45, 48Niebla, niebla con escarcha
51, 53, 55Llovizna ligera, moderada, densa
56, 57Llovizna helada
61, 63, 65Lluvia débil, moderada, fuerte
66, 67Lluvia helada
71, 73, 75Nevada débil, moderada, fuerte
77Granos de nieve
80, 81, 82Chubascos débiles, moderados, violentos
85, 86Chubascos de nieve débiles y fuertes
95Tormenta eléctrica
96, 99Tormenta con granizo

La función wmoText() del sketch de la OLED que verás abajo convierte esta tabla en etiquetas cortas. En el código están en turco sin caracteres especiales; puedes cambiarlas por palabras en español como "Despejado", "Lluvia" o "Nieve" (sin tildes, como verás más abajo). Si quieres dibujar tus propios iconos, usa los mismos rangos para elegir bitmaps de sol, nube o gota; por ejemplo, un solo icono de lluvia basta para 61 a 67 y 80 a 82.

El tiempo por nombre de ciudad con OpenWeatherMap

Tras crear una cuenta gratuita en OpenWeatherMap verás una clave de 32 caracteres en la sección API keys de tu cuenta. Una clave nueva puede tardar desde unos minutos hasta unas horas en activarse; mientras tanto cada petición devuelve 401 y puedes pensar que tu código está mal. En la consulta, q=Ankara,TR fija el nombre de la ciudad y el código del país, units=metric los grados Celsius y m/s, y lang el idioma de la descripción.

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}

Hay dos detalles de esta respuesta que merecen atención. Primero, el campo weather no es un objeto sino un array, así que llegas a la descripción por su primer elemento: doc["weather"][0]["description"]. Segundo, con units=metric la velocidad del viento llega en m/s; multiplica por 3,6 para obtener km/h. Con lang=es las descripciones llegan en español ("lluvia ligera"), pero las fuentes por defecto de Adafruit GFX y de las LCD HD44780 no muestran letras como ñ, á o é. Para no ver caracteres rotos en la pantalla es más seguro usar lang=en y escribir tus propias etiquetas cortas.

HTTPS y certificado: ¿setInsecure o setCACert?

La mayoría de los servicios meteorológicos usan ya HTTPS y algunos no aceptan HTTP simple. Con HTTPS el tráfico entre el ESP32 y el servidor va cifrado; para estar seguro de que habla de verdad con ese servidor, el ESP32 además tiene que verificar la cadena de certificados con un certificado raíz. Para ello se usa WiFiClientSecure en lugar del WiFiClient simple, y hay dos opciones.

setInsecure() cifra la conexión pero no comprueba el certificado. Es una opción práctica y habitual para datos públicos y no secretos como el tiempo, aunque alguien en medio podría enviarte datos falsos. setCACert() verifica la cadena con el certificado raíz que le das. El certificado de Open-Meteo lo emite Let's Encrypt y se apoya en la raíz ISRG Root X1, válida hasta 2035. El certificado propio del servidor se renueva cada pocos meses, así que nunca pongas ese en el código: usa siempre la raíz que está en lo alto de la cadena.

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}
Antes de usar un certificado raíz con otro servicio, comprueba de qué raíz depende ese sitio: OpenWeatherMap usa la cadena de Sectigo y USERTrust, y Frankfurter la de Google Trust Services. Si das la raíz equivocada, GET() devuelve -1 y el Monitor Serie no te da ninguna otra pista. Si envías algo secreto, como tu clave de API, usa siempre setCACert() en lugar de setInsecure().

Mostrar el clima de tu ciudad en una pantalla OLED

Pantalla OLED I2C de 0,96 pulgadas
OLED SSD1306 de 0,96 pulgadas: se conecta al ESP32 con solo cuatro cables y muestra el tiempo con números grandes.

Ahora dejamos el Monitor Serie y construimos una estación meteorológica de escritorio de verdad. La OLED SSD1306 de 0,96 pulgadas se conecta a los pines I2C del ESP32. Para lo básico de la pantalla y los detalles de la librería, consulta la guía pantalla OLED SSD1306.

Pin de la 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}

Al arrancar, el sketch se conecta al Wi-Fi, obtiene los primeros datos enseguida y después los renueva cada 10 minutos. Para esperar usamos millis() en lugar de delay(), así puedes añadir lectura de botones o una animación mientras loop() gira libre. Si se cae la conexión, el código muestra un aviso e intenta reconectar; si una petición falla, muestra el código de error. La hora de la esquina superior derecha es la parte que va tras la letra T en el texto "2026-11-17T14:15" de la respuesta, de modo que ves cuándo se hizo la última medición sin configurar ningún reloj. Si quieres un reloj que avance segundo a segundo, añade a este sketch el método de la guía hora NTP con ESP32.

Mostrarlo en una LCD I2C de 16x2

Si en vez de una OLED tienes una LCD de caracteres de 16x2, puedes meter los mismos datos en dos líneas. Alimentar el módulo LCD desde el pin VIN del ESP32, que da 5 V, mejora el contraste; conecta SDA a GPIO 21 y SCL a GPIO 22. Como el módulo eleva las líneas I2C a 5 V, lo más seguro es poner un conversor de nivel en medio. Basta con sustituir las líneas de dibujo del sketch de la OLED por una función como la siguiente; tienes más detalles en la guía pantalla 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}

Frecuencia de peticiones y límites gratuitos

El error más común es poner delay(1000) en loop() y lanzar una petición cada segundo. Es innecesario y te lleva rápido a los límites: los datos actuales de Open-Meteo solo se renuevan cada 15 minutos, así que preguntando cada segundo recibes 900 veces la misma respuesta. Una petición por segundo suma 86.400 al día y agota el límite diario de 10.000 de Open-Meteo en menos de tres horas. La cuenta es sencilla: peticiones al día es igual a 1440 dividido entre el intervalo en minutos.

IntervaloPeticiones al díaValoración
1 segundo86.400Se supera el límite; tu dirección IP puede quedar bloqueada temporalmente
1 minuto1.440Dentro del límite pero inútil, porque los datos no cambian
10 minutos144Ideal para una estación de escritorio
15 minutos96Coincide con la actualización de Open-Meteo
1 hora24Suficiente para equipos a batería y pronósticos diarios
En una estación meteorológica a batería, el Wi-Fi es lo que más corriente consume. Si después de obtener los datos pones el ESP32 en sueño profundo durante 15 minutos, la corriente media baja de 1 mA en un módulo desnudo y a unos pocos miliamperios en una placa de desarrollo típica, y una sola celda 18650 dura semanas. Tienes los detalles en la guía deep sleep del ESP32.

Códigos de error: 401, 404, 429 y -1

http.GET() devuelve dos tipos de números. Los números positivos son códigos de estado HTTP del servidor: la conexión se hizo y el servidor te escuchó, pero algo de tu petición no le gustó. Los números negativos son códigos de error propios del ESP32 e indican que la petición nunca llegó al servidor o que la respuesta se cortó.

CódigoSignificado¿Qué hacer?
200CorrectoLeer y analizar el cuerpo
400Petición incorrectaRevisar los nombres de los parámetros y las comas de la dirección
401No autorizado: falta la clave de API, es incorrecta o aún no está activaCopiar la clave de nuevo; si es nueva, esperar un rato
404No encontrado: nombre de ciudad o dirección incorrectosEscribir la ciudad sin tildes (Malaga,ES), revisar la dirección
429Demasiadas peticionesAlargar el intervalo
500-503Problema en el servidorVolver a intentarlo en unos minutos
-1Sin conexión: no hay internet, no se resolvió el dominio, dirección errónea o falló el handshake HTTPSRevisar el Wi-Fi, la dirección y el certificado
-5La conexión se cortó a mediasMejorar la señal Wi-Fi, repetir la petición
-11Tiempo de lectura agotadoAlargar la espera con http.setTimeout()

OpenWeatherMap también devuelve JSON cuando hay errores: con una clave incorrecta llega {"cod":401, "message":"Invalid API key..."} y con una ciudad desconocida {"cod":"404","message":"city not found"}. En el primer caso cod es un número y en el segundo un texto entre comillas. Si basas tu código en el número que devuelve http.GET() y no en el campo cod, esta incoherencia no te afectará.

Respuestas grandes: filtro, getStream y useHTTP10

Cuando pides un pronóstico por horas o de 7 días, la respuesta puede pasar de unos pocos kilobytes a decenas. getString() guarda primero toda la respuesta en un String y luego en el árbol de ArduinoJson, así que la memoria se gasta dos veces. En su lugar puedes analizar la respuesta mientras llega con http.getStream() y quedarte solo con los campos que necesitas mediante un filtro. Hay una trampa: si el servidor envía la respuesta por trozos (chunked), los tamaños de los trozos se mezclan con el flujo y el JSON se rompe. Open-Meteo envía sus respuestas por trozos; http.useHTTP10(true) hace la petición con HTTP/1.0 y obliga al servidor a enviar una respuesta 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}

Del mismo modo puedes pedir hourly=temperature_2m y dibujar una gráfica de temperatura de 24 horas, o usar daily=precipitation_probability_max para encender un LED si mañana es probable que llueva. En Open-Meteo forecast_days puede ser como máximo 16; para el ESP32 entre 3 y 7 días es un rango cómodo.

Otras API, mismo método: ejemplo de tipo de cambio

Lo que has aprendido aquí no es exclusivo del tiempo: la dirección, el GET, el JSON y el análisis son iguales en todas las API REST. Por ejemplo, el servicio Frankfurter, que publica los tipos de referencia diarios del Banco Central Europeo, no pide clave y devuelve monedas como el dólar, el euro y la lira turca en una sola petición.

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}

Los tipos del banco central se actualizan una vez al día en días laborables, hacia las 16:00 hora de Europa central, así que incluso una petición por hora es más que suficiente. Con el mismo esqueleto puedes obtener datos de terremotos, precios de criptomonedas, el nivel de un embalse o un valor de tu propio servidor. Lo único que cambia es la dirección y los nombres de las claves en el JSON, y los descubres abriendo la dirección en el navegador y mirando la respuesta.

El tiempo con la Raspberry Pi Pico W (MicroPython)

En los modelos con Wi-Fi de la familia Raspberry Pi Pico, la Pico W y la Pico 2 W, el módulo urequests de MicroPython hace el mismo trabajo y no necesitas una librería JSON aparte: r.json() convierte la respuesta directamente en un diccionario de Python. Graba el MicroPython más reciente con Thonny y guarda el código como main.py. Los detalles de la conexión Wi-Fi están en la guía servidor web Wi-Fi con 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 cifra las conexiones HTTPS pero no verifica el certificado del servidor; el nivel de seguridad es el mismo que setInsecure() en el ESP32. Es importante llamar a r.close() después de cada petición: si lo olvidas, la Pico se queda sin sockets ni memoria tras unas pocas peticiones y el código se detiene con un OSError.

Ideas de proyectos con el clima en el ESP32

  • Estación meteorológica de escritorio: Muestra los datos de Open-Meteo en una OLED y añade con un BME280 la temperatura y la presión de la habitación, para ver dentro y fuera a la vez.
  • Recordatorio de paraguas: Un ESP32 junto a la puerta enciende un LED WS2812B rojo cuando la probabilidad de lluvia del día supera el 60 por ciento.
  • Riego inteligente: Si se espera lluvia mañana, se salta el riego; junto con un sensor de humedad del suelo no malgastarás agua.
  • Aviso por la mañana: Envía a tu móvil el pronóstico del día cada mañana a las 07:00 con un bot de Telegram.
  • Domótica: Pasa la temperatura exterior a Home Assistant por MQTT y úsala para decidir la calefacción.
  • Panel de tiempo y divisas: Muestra la temperatura, el pronóstico de 3 días y los tipos de cambio del día como tarjetas de colores en una pantalla TFT ILI9341.

Errores frecuentes y soluciones

SíntomaCausa probableSolución
Puntos sin fin en el Monitor SerieNo se conecta al Wi-FiRed de 2,4 GHz, contraseña correcta, más cerca del router
Código HTTP -1Problema de internet, dominio o HTTPSProbar la dirección en el navegador, revisar WiFiClientSecure y el certificado
401 Invalid API keyClave incorrecta o aún inactivaCopiar la clave de nuevo; con cuenta nueva, esperar un rato
Error JSON InvalidInputLa respuesta no es JSON (página de error HTML)Imprimir antes la respuesta con getString()
Error JSON IncompleteInputRespuesta cortada o flujo por trozosUsar getString() o añadir useHTTP10(true)
Temperatura siempre 0.00Nombre de clave mal escritoCopiar el nombre exacto del JSON (temperature_2m)
Caracteres raros en la pantallaLa fuente no tiene tildes, ñ ni el símbolo °Usar lang=en, escribir el grado con (char)247
Se cuelga tras unas horasConexiones sin cerrar, fragmentación de memoriaLlamar a http.end() tras cada petición, alargar el intervalo
La forma más fácil de aislar un problema es pegar primero la dirección en el navegador de tu ordenador. Si ahí ves un JSON limpio, el problema está en el ESP32 (Wi-Fi, certificado o análisis); si el navegador también muestra un error, tienes que corregir la dirección o la clave de API.

Un proyecto de clima con ESP32 enseña el patrón básico de todo dispositivo conectado: conectar, pedir, analizar, mostrar y repetir a intervalos razonables. Una vez dominas este patrón, el mismo código puede traer datos de cientos de API distintas. En la app BlueGrays encontrarás proyectos que muestran una API del clima en una LCD y en una OLED SSD1306 con ESP32 HTTPClient, junto con proyectos de conexión Wi-Fi y reloj NTP, cada uno con su esquema y su código paso a paso.

Preguntas frecuentes

¿Cómo obtener el clima con un ESP32?

Conecta el ESP32 al Wi-Fi y envía una petición GET a un servicio como Open-Meteo u OpenWeatherMap con la librería HTTPClient. Después lee la temperatura, la humedad y el código del tiempo de la respuesta JSON con ArduinoJson. Open-Meteo no necesita clave de API, por eso es la opción más fácil para una primera prueba.

¿La API de Open-Meteo es gratis?

Open-Meteo es gratuita para uso no comercial y no pide registro ni clave de API. El uso gratuito está limitado a 10.000 peticiones al día, 5.000 por hora y 600 por minuto. Para un producto comercial necesitas un plan de pago.

¿Por qué mi clave de OpenWeatherMap da error 401?

Un 401 indica que la clave es incorrecta, falta o todavía no está activada. Las claves recién creadas tardan desde unos minutos hasta unas horas en activarse. Comprueba que copiaste la clave sin espacios y que la pasas en la dirección con el parámetro appid=.

¿Qué significa el error -1 de HTTP GET en el ESP32?

-1 es HTTPC_ERROR_CONNECTION_REFUSED e indica que no se pudo establecer ninguna conexión. Suele deberse a que no hay internet, a un dominio que no se resuelve, a una dirección mal escrita o a conectar con un servidor HTTPS usando un certificado equivocado. Con http.errorToString(código) puedes ver la descripción en el Monitor Serie.

¿Cada cuánto debe actualizar el clima un ESP32?

Basta con hacerlo cada 10 a 15 minutos, porque los servicios renuevan sus datos más o menos a ese ritmo. Eso supone de 96 a 144 peticiones al día, muy por debajo de los límites gratuitos. Pedir cada segundo gasta energía para nada y puede hacer que te bloqueen.

¿Qué diferencia hay entre ArduinoJson 6 y 7?

ArduinoJson 7 sustituye StaticJsonDocument y DynamicJsonDocument por una sola clase JsonDocument que gestiona la memoria sola. El código antiguo sigue compilando con un aviso, pero en proyectos nuevos basta con JsonDocument doc;. El análisis y la lectura con doc["clave"] son iguales en ambas versiones.

Ver todos los proyectos
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla LCD)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

4.7(13)
20
ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
ES-32Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

4.3(10)
22
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

ESP32: hora real desde Internet con NTP

El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

4.5(13)
22
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

Pantalla LCD I2C para ESP32 (16x2)

En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

4.9(23)
40
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)

El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

4.3(10)
16
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12