ESP32 + TM1637: muestra la temperatura de tu ciudad sin sensor

Introducción

En este proyecto vamos a armar un mini termómetro WiFi que muestra la temperatura actual de tu ciudad en un display TM1637 de 4 dígitos y 7 segmentos, sin necesidad de ningún sensor físico. La gracia es que la temperatura la pedimos vía HTTP a la WeatherAPI, así que la placa ESP32 solo necesita estar conectada a tu red WiFi.

El display alterna automáticamente entre la lectura en grados Celsius y en Fahrenheit cada 5 segundos, y la consulta a la API se refresca cada 1 hora para no quemar el cuota gratuita.

Probado en: ESP32 DevKit (cualquier modelo con WiFi sirve) + módulo TM1637 4 dígitos tipo reloj.

Lo que vas a aprender

• Configurar el módulo TM1637 con el ESP32 usando solo 2 pines digitales.
• Hacer peticiones HTTP GET desde el ESP32 a una API externa.
• Parsear JSON con ArduinoJson para extraer campos puntuales.
• Crear símbolos personalizados (°C, °F) en un display de 7 segmentos.

Prerrequisitos

Antes de partir, asegúrate de tener:

1. Arduino IDE instalado con el soporte para placas ESP32 agregado (vía Board Manager).
2. Una cuenta gratuita en WeatherAPI (weatherapi.com) para obtener tu API key. El plan free es más que suficiente.
3. Tu SSID y contraseña WiFi a mano.

Materiales

• ESP32 DevKit (cualquier variante con WiFi).
• Módulo display TM1637 de 4 dígitos y 7 segmentos.
• Cables tipo dupont macho a macho para las conexiones.
• Cable USB para alimentar y programar el ESP32.

Costo aproximado: ~CLP $13.880 (aproximado, según componentes que tengas disponibles).

Conociendo el TM1637

El TM1637 es un módulo que combina 4 dígitos de 7 segmentos en una sola placa, controlados por el chip driver TM1637. Los 4 dígitos están separados por dos puntos (:) entre el segundo y el tercero, lo que lo hace ideal para relojes y, en nuestro caso, para mostrar valores numéricos con símbolos.

Una gran ventaja: el módulo se controla con apenas 2 pines digitales (CLK y DIO) más alimentación, así que no acapara los GPIOs del ESP32.

Obtener tu API Key de WeatherAPI

1. Entra a weatherapi.com y crea una cuenta gratis.
2. Verifica tu email e inicia sesión.
3. En tu dashboard (weatherapi.com/my/) vas a encontrar tu API key. Aunque diga que el trial expira, la key sigue funcionando libremente en el tier free.
4. Cópiala a un lugar seguro: la vas a necesitar dentro del código.

Para probarla rápido, abre esta URL en tu navegador reemplazando los valores entre llaves:

https://api.weatherapi.com/v1/current.json?q={TU_CIUDAD}&key={TU_API_KEY}

La API te devuelve un JSON con un montón de datos. Para este proyecto nos interesan dos campos: current.temp_c y current.temp_f.

Conexiones físicas

Cablear el TM1637 al ESP32 es directo. Solo 4 cables:

Puedes usar otros GPIOs si los 18 y 19 ya los tienes ocupados; basta con cambiar los #define en el código.

Instalación de librerías

Desde el Library Manager de Arduino IDE, instala:

1. TM1637 (de avishorp): para controlar el display. Es vieja pero anda perfecto.
2. ArduinoJson (de bblanchon): para parsear el JSON que devuelve la WeatherAPI.

Los headers nativos WiFi.h y HTTPClient.h ya vienen incluidos con el core de ESP32.

El código

Antes de subir, reemplaza tres cosas en el código:

• REPLACE_WITH_YOUR_SSID → nombre de tu red WiFi.
• REPLACE_WITH_YOUR_PASSWORD → contraseña de la red.
• REPLACE_WITH_YOUR_WeatherAPI_API_Key → tu API key.
• Oporto → cambia por tu ciudad (Santiago, Valparaíso, Concepción, etc.).

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <TM1637Display.h>

// Credenciales WiFi
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

const char* api_key = "REPLACE_WITH_YOUR_WeatherAPI_API_Key";
const char* location = "Santiago";

String url = "https://api.weatherapi.com/v1/current.json?q=" + String(location) + "&key=" + String(api_key);

// Pines del TM1637
#define CLK 19
#define DIO 18

TM1637Display display(CLK, DIO);

// Símbolo °C
const uint8_t Celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Círculo (grado)
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};

// Símbolo °F
const uint8_t Fahrenheit[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Círculo (grado)
  SEG_F | SEG_E | SEG_A | SEG_G   // F
};

float currentTempC = 9999;
float currentTempF = 9999;
unsigned long lastFetchTime = 0;
const unsigned long fetchInterval = 3600000UL;  // 1 hora

void initWiFi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a WiFi..");
  }
  Serial.println("Conexión exitosa");
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
}

bool updateTemperatures() {
  HTTPClient http;
  http.begin(url);
  int httpCode = http.GET();

  if (httpCode == HTTP_CODE_OK) {
    String payload = http.getString();
    Serial.print(payload);

    StaticJsonDocument<1024> doc;
    DeserializationError error = deserializeJson(doc, payload);
    if (error) {
      Serial.print("Falló parseo JSON: ");
      Serial.println(error.c_str());
      http.end();
      return false;
    }

    currentTempC = doc["current"]["temp_c"];
    currentTempF = doc["current"]["temp_f"];
    http.end();
    return true;
  } else {
    Serial.print("Error en la petición: ");
    Serial.println(httpCode);
    http.end();
    return false;
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  initWiFi();
  display.setBrightness(7);

  if (updateTemperatures()) {
    lastFetchTime = millis();
  }
}

void loop() {
  if (millis() - lastFetchTime >= fetchInterval) {
    if (updateTemperatures()) {
      lastFetchTime = millis();
    } else {
      Serial.println("Falló el refresco, mantengo valores anteriores.");
    }
  }

  // Mostrar Celsius
  int roundedTempC = round(currentTempC);
  display.showNumberDec(roundedTempC, false, 2, 0);
  display.setSegments(Celsius, 2, 2);
  delay(5000);

  // Mostrar Fahrenheit
  int roundedTempF = round(currentTempF);
  display.showNumberDec(roundedTempF, false, 2, 0);
  display.setSegments(Fahrenheit, 2, 2);
  delay(5000);
}

Cómo funciona el código

Conexión WiFi

La función initWiFi() deja al ESP32 conectado a tu red WiFi. Si no logra conectarse, queda imprimiendo el aviso hasta que enganche.

Petición a WeatherAPI

updateTemperatures() arma la URL, hace el GET, valida que el código de respuesta sea 200 y parsea el JSON con ArduinoJson. Si todo va bien, guarda temp_c y temp_f en variables globales.

Refresco cada hora

Usamos millis() con un intervalo de 3.600.000 ms (1 hora). Sin esto, la WeatherAPI nos cortaría el servicio rápido en su plan free por demasiadas requests.

Símbolos °C y °F

Los arrays Celsius y Fahrenheit definen, segmento por segmento, los caracteres especiales. El círculo del grado se forma encendiendo los segmentos A, B, F, G del primer dígito.

Loop alternado

Cada 5 segundos cambiamos entre los dos modos: primero muestra roundedTempC + °C, luego roundedTempF + °F, y vuelve a empezar.

Probando el proyecto

Una vez subido el código, abre el Monitor Serial a 115200 baudios. Deberías ver:

1. La conexión al WiFi y la IP asignada al ESP32.
2. El payload completo del JSON que devuelve WeatherAPI.
3. La temperatura actual de tu ciudad alternándose en el display TM1637.

Si el display muestra 9999, significa que la primera petición a la API falló: revisa la API key, el nombre de la ciudad y que tengas señal WiFi estable.

Unos segundos después el mismo display alterna a la lectura en Fahrenheit, sin tocar nada:

Ideas para extender

• Agregar un sensor DHT22 local y comparar la temperatura medida vs la pronosticada.
• Mostrar humedad o velocidad del viento alternando con la temperatura.
• Encender un LED RGB según el rango de temperatura (azul bajo 10°C, verde entre 10 y 25°C, rojo sobre 25°C).
• Subir el dato a un dashboard con MQTT o Home Assistant.

Cierre

Con menos de CLP $14.000 en componentes y unas pocas líneas de código, tienes un termómetro WiFi para tu escritorio. Es un proyecto ideal para entender cómo el ESP32 puede consumir APIs externas y desplegar datos en hardware de bajo costo. ¡Felices proyectos!