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.

¿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érmino | Significado | Ejemplo meteorológico |
|---|---|---|
| API | La puerta por la que los programas intercambian datos | Servicio de pronóstico de Open-Meteo |
| Endpoint | La dirección de la API que hace un trabajo concreto | /v1/forecast |
| Parámetro de consulta | Ajustes que van después del ? en la dirección | latitude=41.01¤t=temperature_2m |
| Petición GET | Pedir datos al servidor | http.GET() |
| Código de estado | Número que describe el resultado de la petición | 200 correcto, 404 no encontrado |
| JSON | Formato de texto hecho de claves y valores | {"temperature_2m":17.3} |
| Clave de API | Identificador secreto que te reconoce | El 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ística | Open-Meteo | OpenWeatherMap (gratis) |
|---|---|---|
| Registro y clave | No hacen falta | Cuenta y clave de API obligatorias |
| Ubicación | Latitud y longitud | Nombre de ciudad, coordenadas o ID de ciudad |
| Límite gratuito | 10.000 peticiones al día, 5.000 por hora, 600 por minuto | 60 peticiones por minuto, 1.000.000 al mes |
| Actualización de datos | Datos actuales cada 15 minutos | Aproximadamente cada 10 minutos |
| Estado del tiempo | Có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 respuesta | Solo los campos elegidos, unos 400 bytes | Unos 500 bytes |
Qué necesitas y configuración
- 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.
- 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.
- Para la versión con pantalla instala Adafruit SSD1306 y Adafruit GFX, o LiquidCrystal I2C si vas a usar una LCD.
- 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.
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.
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}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.
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}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.
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 WMO | Significado |
|---|---|
| 0 | Despejado |
| 1, 2, 3 | Mayormente despejado, parcialmente nublado, cubierto |
| 45, 48 | Niebla, niebla con escarcha |
| 51, 53, 55 | Llovizna ligera, moderada, densa |
| 56, 57 | Llovizna helada |
| 61, 63, 65 | Lluvia débil, moderada, fuerte |
| 66, 67 | Lluvia helada |
| 71, 73, 75 | Nevada débil, moderada, fuerte |
| 77 | Granos de nieve |
| 80, 81, 82 | Chubascos débiles, moderados, violentos |
| 85, 86 | Chubascos de nieve débiles y fuertes |
| 95 | Tormenta eléctrica |
| 96, 99 | Tormenta 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.
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.
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}Mostrar el clima de tu ciudad en una pantalla OLED

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 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}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.
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.
| Intervalo | Peticiones al día | Valoración |
|---|---|---|
| 1 segundo | 86.400 | Se supera el límite; tu dirección IP puede quedar bloqueada temporalmente |
| 1 minuto | 1.440 | Dentro del límite pero inútil, porque los datos no cambian |
| 10 minutos | 144 | Ideal para una estación de escritorio |
| 15 minutos | 96 | Coincide con la actualización de Open-Meteo |
| 1 hora | 24 | Suficiente para equipos a batería y pronósticos diarios |
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ódigo | Significado | ¿Qué hacer? |
|---|---|---|
| 200 | Correcto | Leer y analizar el cuerpo |
| 400 | Petición incorrecta | Revisar los nombres de los parámetros y las comas de la dirección |
| 401 | No autorizado: falta la clave de API, es incorrecta o aún no está activa | Copiar la clave de nuevo; si es nueva, esperar un rato |
| 404 | No encontrado: nombre de ciudad o dirección incorrectos | Escribir la ciudad sin tildes (Malaga,ES), revisar la dirección |
| 429 | Demasiadas peticiones | Alargar el intervalo |
| 500-503 | Problema en el servidor | Volver a intentarlo en unos minutos |
| -1 | Sin conexión: no hay internet, no se resolvió el dominio, dirección errónea o falló el handshake HTTPS | Revisar el Wi-Fi, la dirección y el certificado |
| -5 | La conexión se cortó a medias | Mejorar la señal Wi-Fi, repetir la petición |
| -11 | Tiempo de lectura agotado | Alargar 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.
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.
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.
1import network
2import time
3import urequests
4
5SSID = "AgAdi"
6PASS = "Sifre123"
7URL = ("https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
8 "¤t=temperature_2m,relative_humidity_2m,weather_code&timezone=auto")
9
10wlan = network.WLAN(network.STA_IF)
11wlan.active(True)
12wlan.connect(SSID, PASS)
13while not wlan.isconnected(): # bağlanana kadar bekle / wait until connected
14 time.sleep(0.5)
15print("IP:", wlan.ifconfig()[0])
16
17while True:
18 try:
19 r = urequests.get(URL)
20 if r.status_code == 200:
21 now = r.json()["current"] # JSON -> sözlük / JSON -> dict
22 print(now["time"], now["temperature_2m"], "C",
23 "%", now["relative_humidity_2m"], "kod/code", now["weather_code"])
24 else:
25 print("HTTP hata / error:", r.status_code)
26 r.close() # soketi kapat, belleği boşalt / close socket, free memory
27 except OSError as e: # ağ hatası / network error
28 print("Baglanti hatasi / connection error:", e)
29 time.sleep(600) # 10 dakika bekle / wait 10 minutesurequests de MicroPython 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íntoma | Causa probable | Solución |
|---|---|---|
| Puntos sin fin en el Monitor Serie | No se conecta al Wi-Fi | Red de 2,4 GHz, contraseña correcta, más cerca del router |
| Código HTTP -1 | Problema de internet, dominio o HTTPS | Probar la dirección en el navegador, revisar WiFiClientSecure y el certificado |
| 401 Invalid API key | Clave incorrecta o aún inactiva | Copiar la clave de nuevo; con cuenta nueva, esperar un rato |
| Error JSON InvalidInput | La respuesta no es JSON (página de error HTML) | Imprimir antes la respuesta con getString() |
| Error JSON IncompleteInput | Respuesta cortada o flujo por trozos | Usar getString() o añadir useHTTP10(true) |
| Temperatura siempre 0.00 | Nombre de clave mal escrito | Copiar el nombre exacto del JSON (temperature_2m) |
| Caracteres raros en la pantalla | La fuente no tiene tildes, ñ ni el símbolo ° | Usar lang=en, escribir el grado con (char)247 |
| Se cuelga tras unas horas | Conexiones sin cerrar, fragmentación de memoria | Llamar a http.end() tras cada petición, alargar el intervalo |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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.

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

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

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

