Interfaz de la pantalla de 7 segmentos y 4 dígitos TM1637 con Arduino

Ya sea que estés construyendo un reloj digital, un cronómetro o un contador simple, una pantalla de 7 segmentos y 4 dígitos suele ser la manera perfecta de mostrar datos numéricos de forma clara y compacta. Pero si alguna vez has intentado conectar una pantalla de 7 segmentos a un Arduino, sabes que puede ocupar rápidamente una docena de pines y convertir tu placa de pruebas en un lío de cables puente. Por suerte, existe una forma más inteligente de hacerlo.

Presentamos el módulo TM1637: un chip controlador pequeño pero potente que facilita el control de una pantalla de 7 segmentos y 4 dígitos con solo dos pines Arduino. Así es: con solo dos líneas de datos, puedes controlar los cuatro dígitos, junto con los dos puntos y los decimales.

En este tutorial, le mostraremos cómo conectar el TM1637 a su Arduino, cargar la biblioteca correcta y comenzar a mostrar números en poco tiempo.

¡Vamos allá!

Conceptos básicos de la pantalla de 7 segmentos Una pantalla de 7 segmentos está compuesta por siete LED separados, dispuestos en forma de “8”. Cada uno de estos LED se denomina segmento.

Formación de LED internos de 7 segmentos Lo interesante de estas pantallas es su cableado. Cada segmento tiene dos puntos de conexión eléctrica, como cualquier LED normal. Sin embargo, solo uno de estos puntos de conexión sobresale de la carcasa de plástico como un pin individual al que se puede conectar. Estos pines están etiquetados con letras de la “a” a la “g”, una letra por segmento. Los demás puntos de conexión están conectados entre sí dentro de la carcasa de plástico para crear una conexión compartida llamada pin común (COM). Para iluminar la pantalla, puedes controlar cada segmento individualmente configurando su pin en ALTO o BAJO, como lo harías con cualquier LED normal. Activando diferentes combinaciones de segmentos, puedes crear todos los números del 0 al 9. Con un poco de creatividad, ¡incluso puedes mostrar algunas letras del alfabeto!

Descripción general del hardware del módulo TM1637

El módulo TM1637 combina una pantalla de 7 segmentos de 4 dígitos y 0,36 pulgadas con el chip controlador LED TM1637 de Titan MicroElectronics. Esta atractiva combinación permite controlar los cuatro dígitos con solo dos pines del microcontrolador.

Este módulo es perfecto para proyectos que requieren mostrar números, como temporizadores, contadores, lecturas de sensores o temperaturas. Incluso tiene dos puntos en el centro, lo que lo hace ideal para relojes y proyectos relacionados con el tiempo.

Una de las ventajas del TM1637 es que se encarga de actualizar la pantalla automáticamente después de actualizarla. Esto significa que su microcontrolador puede dedicarse a otras tareas importantes en lugar de tener que actualizar la pantalla constantemente.

 

El consumo de energía del módulo depende de cuántos segmentos estén iluminados y del nivel de brillo configurado. Cuando todos los segmentos están iluminados al máximo brillo, el módulo consume aproximadamente 80 mA de corriente. Puede ahorrar energía ajustando el brillo de la pantalla a un nivel más bajo.

El módulo TM1637 funciona con una tensión de alimentación de entre 3,3 V y 5 V. Esto lo hace compatible con microcontroladores de 5 V, como el Arduino estándar, y de 3,3 V, como el ESP32.

El módulo utiliza su propio protocolo de comunicación especial de dos hilos. Si bien no es un protocolo estándar como I2C, existen bibliotecas Arduino fáciles de usar que ocultan todos los aspectos complejos y simplifican la comunicación con la pantalla.

Especificaciones técnicas

Aquí están las especificaciones:

Para obtener información más detallada sobre el chip controlador TM1637, consulte la hoja de datos a continuación.

Distribución de pines del módulo TM1637

El módulo TM1637 tiene solo cuatro pines, lo que facilita su uso. Aquí está la distribución de pines:

es el pin de entrada del reloj.

Es el pin de entrada/salida de datos (E/S).

Es el pin de alimentación. Conéctelo a una fuente de alimentación de 3,3 V a 5 V.

es el pin de tierra.

Cableado del módulo TM1637 con un Arduino

Conectar el TM1637 a un Arduino es muy sencillo. Como el módulo solo tiene cuatro pines, solo se necesitan cuatro cables: dos para la alimentación y dos para la comunicación.

Comience conectando el pin VCC del módulo a la salida de 5 V del Arduino y el pin GND a uno de los pines de tierra del Arduino. Luego, conecte el pin CLK al pin digital 3 del Arduino y el pin DIO al pin digital 4.

A continuación se muestra una tabla de referencia rápida para las conexiones de pines:

Este diagrama le muestra exactamente cómo conectar todo:

Instalación de la biblioteca

Para comunicarse con el chip TM1637, necesitará usar una biblioteca. Una excelente opción es la 

 creada por Avishay Orpaz. Esta biblioteca cuenta con numerosas funciones integradas que simplifican y simplifican el control de la pantalla.

Para instalar la biblioteca:

1. 1. Primero abre tu programa IDE de Arduino. Luego, haz clic en el icono del Administrador de Bibliotecas en la barra lateral izquierda.
   2. Escriba “ tm1637 ” en el cuadro de búsqueda para filtrar los resultados.
   3. Busque la biblioteca TM1637 de Avishay Orpaz .
   4. Haga clic en el botón Instalar para agregarlo a su IDE de Arduino.
   5. ¡Una vez instalada la biblioteca, ya estará todo listo para programar!

Ejemplo 1 de Arduino: Programa de prueba básico

El siguiente es un programa de prueba básico que ejecuta varias rutinas diferentes. Puedes probarlo y repasaremos su funcionamiento en breve.

// Include the library
#include <TM1637Display.h>
// Define the connections pins
#define CLK 3
#define DIO 4
// Create a display object of type TM1637Display
TM1637Display display = TM1637Display(CLK, DIO);
// Create an array that turns all segments ON
const uint8_t allON[] = { 0xff, 0xff, 0xff, 0xff };
// Create an array that turns all segments OFF
const uint8_t allOFF[] = { 0x00, 0x00, 0x00, 0x00 };
// Create an array that sets individual segments per digit to display the word "dOnE"
const uint8_t done[] = {
  SEG_B | SEG_C | SEG_D | SEG_E | SEG_G,          // d
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,  // O
  SEG_C | SEG_E | SEG_G,                          // n
  SEG_A | SEG_D | SEG_E | SEG_F | SEG_G           // E
};
// Create degree celsius symbol
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Degree symbol
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};
void setup() {
  // Set the brightness to 5 (0=dimmest 7=brightest)
  display.setBrightness(5);
  // Set all segments ON
  display.setSegments(allON);
  delay(2000);
  display.clear();
  // Show counter 0-9
  int i;
  for (i = 0; i < 10; i++) {
    display.showNumberDec(i);
    delay(50);
  }
  delay(2000);
  display.clear();
  display.showNumberDec(-12);  // Prints _-12
  delay(2000);
  display.clear();
  display.showNumberDec(-999);  // Prints -999
  delay(2000);
  display.clear();
  display.showNumberDec(31, false);  // Prints __31
  delay(2000);
  display.clear();
  display.showNumberDec(31, true);  // Prints 0031
  delay(2000);
  display.clear();
  display.showNumberDec(14, false, 2, 1);  // Prints _14_
  delay(2000);
  display.clear();
  display.showNumberDec(-5, false, 2, 1);  // Prints _-5_
  delay(2000);
  display.clear();
  // Prints 12:34
  display.showNumberDecEx(1234, 0b01000000, false, 4, 0);
  delay(2000);
  display.clear();
  // Prints 15°C
  int temperature = 15;
  display.showNumberDec(temperature, false, 2, 0);
  display.setSegments(celsius, 2, 2);
  delay(2000);
  display.clear();
  // Prints dOnE
  display.setSegments(done);
}
void loop() {
}

Una vez que cargues el boceto en tu Arduino, deberías ver:

Explicación del código:

Comenzamos incluyendo la biblioteca TM1637 y diciéndole al programa cuáles dos pines de Arduino están conectados al módulo de pantalla: uno para el reloj (CLK) y el otro para la entrada/salida de datos (DIO).

#include <TM1637Display.h>
#define CLK 3
#define DIO 

A continuación, creamos un 

objeto de la clase TM1637Display. Este objeto nos permite enviar comandos al TM1637. Al crear el objeto, debemos indicarle qué dos pines estamos usando.

TM1637Display display = TM1637Display(CLK, DIO);

// Create an array that turns all segments ON
const uint8_t allON[] = {0xff, 0xff, 0xff, 0xff};
// Create an array that turns all segments OFF
const uint8_t allOFF[] = {0x00, 0x00, 0x00, 0x00};

 : La segunda forma de crear estas matrices es aún más sencilla. Podemos simplemente listar los nombres de los segmentos que queremos activar, usando nombres como SEG_A, SEG_B, SEG_C, etc.

// Create an array that sets individual segments per digit to display the word "dOnE"
const uint8_t done[] = {
  SEG_B | SEG_C | SEG_D | SEG_E | SEG_G,          // d
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,  // O
  SEG_C | SEG_E | SEG_G,                          // n
  SEG_A | SEG_D | SEG_E | SEG_F | SEG_G           // E
};
// Create °C symbol
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // °
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};

En la sección setup() del código, utilizamos varias funciones de la biblioteca TM1637:

setBrightness ( brillo , activado )

Esta función controla el brillo de la pantalla. Puede elegir un valor entre 0 (muy tenue) y 7 (muy brillante).

También hay una segunda parte opcional que puedes añadir: si pasas “false”, se apagará la pantalla; si pasas “true” o lo omites, la pantalla permanecerá encendida. Por lo tanto, al escribir ” 

, estás configurando el brillo a un nivel medio. Si escribes ” 

, en realidad estás apagando la pantalla, aunque hayas elegido un nivel de brillo.

setSegments ( segmentos[] , longitud , posición )

Esta función permite controlar segmentos individuales de la pantalla. Le asignamos tres datos: la matriz que contiene la información sobre qué segmentos iluminar, cuántos dígitos queremos actualizar (del 0 al 4) y dónde debe empezar el número en la pantalla (la posición 0 es el dígito más a la izquierda y la posición 3, el más a la derecha).

Tenga en cuenta que el segundo y el tercer argumento son opcionales. Si desea actualizar toda la pantalla sin preocuparse por la longitud ni la posición, puede omitirlos. Por ejemplo, si queremos mostrar la palabra “dOnE”, iluminamos los 4 dígitos comenzando desde el extremo izquierdo (posición 0). Por lo tanto, simplemente llamamos a la función así:

// Prints dOnE
display.setSegments(done)

Pero a veces no queremos actualizar los cuatro dígitos. Por ejemplo, si queremos mostrar el símbolo “°C”, solo queremos actualizar los dos últimos dígitos. En ese caso, también le indicamos a la función cuántos dígitos (2) y desde qué posición (2) debe empezar.

// Prints __°C
display.setSegments(celsius, 2, 2);

// Show counter 0-9
int i;
for (i = 0; i < 10; i++) {
  display.showNumberDec(i);
  delay(50);
}

display.showNumberDec(-12);  // Prints _-12
display.showNumberDec(-999);  // Prints -999

El segundo argumento controla si se deben agregar ceros a la izquierda. Si se establece como verdadero, la pantalla agregará ceros al principio para que el número quepa en los cuatro dígitos. Si se establece como falso, se mostrará el número tal como está.

display.showNumberDec(31, false); // Prints __31

display.showNumberDec(31, true); // Prints 0031

Los argumentos tercero y cuarto funcionan igual que antes. Permiten decidir cuántos dígitos se quieren actualizar y dónde debe empezar el número en la pantalla. Por lo tanto, si se desea que el número aparezca centrado, se debe escribir:

display.showNumberDec(14, false, 2, 1);  // Prints _14_
display.showNumberDec(-5, false, 2, 1);  // Prints _-5_

Esta función es una versión extendida de 

. La principal diferencia radica en que el segundo argumento ahora controla los puntos o dos puntos en la pantalla, lo cual es ideal para mostrar horas o decimales. Para controlar estos puntos, se utiliza un número binario que indica a la pantalla exactamente qué puntos activar. Cada posición del número binario corresponde a un punto específico en la pantalla. Por ejemplo:

Si tiene una pantalla con puntos entre cada dígito, así es como funciona:

Algunas pantallas TM1637 tienen dos puntos en lugar de puntos. En este caso:

Incluso hay pantallas que tienen puntos y dos puntos. En estas pantallas:

Supongamos que quieres crear un reloj digital que marque las “12:34”. Usarías la función así:

// Prints 12:34
display.showNumberDecEx(1234, 0b01000000, false, 4, 0);

Primero, le indicarías que muestre el número 1234. Luego, usarías el código binario 0b01000000 para activar los dos puntos en el medio. Los últimos argumentos indican a la función que no añada ceros a la izquierda, que actualice los cuatro dígitos y que comience desde la primera posición.

Como no hay nada que deba ejecutarse repetidamente en este ejemplo, dejamos la función loop() vacía.

void loop() {
}

Ejemplo 2 de Arduino: Termómetro digital con TM1637 y DHT11/DHT22

El módulo TM1637 es perfecto para mostrar valores numéricos como temperatura, humedad, voltaje o velocidad. En este ejemplo, lo usaremos para mostrar las lecturas de temperatura de un sensor DHT11.

Si no ha trabajado antes con el módulo DHTxx, le recomendamos consultar este útil tutorial:

Alambrado

El cableado es similar al primer ejemplo, pero agregamos un sensor DHT11 a la configuración.

Conecte el pin VCC del sensor DHT11 al pin de 5 V del Arduino y el pin GND a cualquier pin GND del Arduino. Conecte el pin de datos al pin digital n.º 2 del Arduino. También deberá agregar una resistencia pull-up de 10 kΩ entre el pin de datos y el pin VCC. Sin embargo, si tiene un DHT11 en una placa de expansión, la resistencia ya está integrada, así que puede omitir este paso.

Instalación de la biblioteca

Utilizaremos la biblioteca 

 para comunicarnos con DHT11, así que asegúrese de instalarla primero antes de continuar.

Para instalar la biblioteca:

• Primero abre tu programa IDE de Arduino. Luego, haz clic en el icono del Administrador de Bibliotecas en la barra lateral izquierda.
• Escriba “ dhtlib ” en el cuadro de búsqueda para filtrar los resultados.
• Busque la biblioteca “ DHTlib ” creada por Rob Tillaart .
• Haga clic en el botón Instalar para agregarlo a su IDE de Arduino.

Código Arduino

El esquema a continuación se comunica con el sensor DHT11 y muestra las lecturas de temperatura en la pantalla del TM1637. La temperatura se mostrará en grados Celsius y Fahrenheit, alternando cada dos segundos.

// Include the libraries
#include <TM1637Display.h>
#include <dht.h>
// Define the connections pins
#define CLK 3
#define DIO 4
#define DHTPIN 2
// Create °C symbol
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};
// Create °F symbol
const uint8_t fahrenheit[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_E | SEG_F | SEG_G   // F
};
// Create display object of type TM1637Display
TM1637Display display = TM1637Display(CLK, DIO);
// Creates a DHT object
dht DHT;
void setup() {
  // Set the display brightness (0-7)
  display.setBrightness(5);
  // Clear the display
  display.clear();
}
void loop() {
  //Uncomment whatever type you're using!
  //DHT.read22(DHTPIN); // DHT22/AM2302
  DHT.read11(DHTPIN);  // DHT11
  int temperature_celsius = DHT.temperature;                              // Gets the values of the temperature
  int temperature_fahrenheit = (temperature_celsius * 9.0) / 5.0 + 32.0;  // Convert temperature to fahrenheit
  // Display the temperature in celsius format
  display.showNumberDec(temperature_celsius, false, 2, 0);
  display.setSegments(celsius, 2, 2);
  delay(2000);
  // Display the temperature in fahrenheit format
  display.showNumberDec(temperature_fahrenheit, false, 2, 0);
  display.setSegments(fahrenheit, 2, 2);
  delay(2000);
}

Una vez que cargues el boceto en tu Arduino, deberías ver:

Explicación del código

Este boceto es similar al anterior. Sin embargo, presenta algunas diferencias clave.

Al comienzo del código, además de incluir la biblioteca TM1637Display, también incluimos la biblioteca DHT para leer valores de temperatura del sensor.

#include <DHT.h>

Luego, definimos qué pines de Arduino están conectados a la pantalla TM1637 y qué pin está conectado al sensor DHT11.

#define CLK 3
#define DIO 4
#define DHTPIN 2

A continuación, creamos dos pequeñas matrices que almacenan los patrones de segmento necesarios para mostrar los símbolos “°C” y “°F” en el TM1637.

// Create °C symbol
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};

// Create °F symbol
const uint8_t fahrenheit[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_E | SEG_F | SEG_G   // F
};

Después de eso, creamos un objeto para la pantalla y otro objeto para el sensor DHT.

TM1637Display display = TM1637Display(CLK, DIO);
dht DHT;

En la sección setup() del código, configuramos el brillo de la pantalla a un nivel medio (5), lo que facilita la lectura sin ser demasiado brillante. También borramos la pantalla para asegurarnos de que se inicie en blanco.

void setup() {
  // Set the display brightness (0-7)
  display.setBrightness(5);

  // Clear the display
  display.clear();
}

En la sección loop(), comenzamos leyendo los datos de temperatura del sensor. Si usas un sensor DHT11, usa la 

función. Si usas un DHT22, usa 

en su lugar. Solo uno de estos debe estar activo en tu código; asegúrate de comentar la línea del sensor que no uses y deja la correcta sin comentar.

//Uncomment whatever type you're using!
//DHT.read22(DHTPIN); // DHT22/AM2302
DHT.read11(DHTPIN);  // DHT11

Tras leer los datos, recuperamos la temperatura en grados Celsius mediante la 

notación de puntos del objeto DHT y la almacenamos en una variable llamada 

. Luego, calculamos el valor en grados Fahrenheit mediante la fórmula (Celsius × 9 / 5) + 32 y lo almacenamos en otra variable llamada 

.

int temperature_celsius = DHT.temperature;                              // Gets the values of the temperature
int temperature_fahrenheit = (temperature_celsius * 9.0) / 5.0 + 32.0;  // Convert temperature to fahrenheit

Ahora viene la parte de la pantalla. Primero, mostramos la temperatura en grados Celsius. Usamos la 

función para mostrar el número en los dos primeros dígitos de la pantalla del TM1637. Luego, usamos la 

función para mostrar el símbolo “°C” en los dos últimos dígitos. Mantenemos esto en pantalla durante dos segundos.

Después, hacemos lo mismo con la temperatura en grados Fahrenheit. Esta también permanece en pantalla durante dos segundos.

// Display the temperature in celsius format
display.showNumberDec(temperature_celsius, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(2000);

// Display the temperature in fahrenheit format
display.showNumberDec(temperature_fahrenheit, false, 2, 0);
display.setSegments(fahrenheit, 2, 2);
delay(2000);

El bucle se repite constantemente, por lo que la pantalla cambia entre Celsius y Fahrenheit cada dos segundos.

Ejemplo 3 de Arduino: Reloj digital con TM1637 y DS3231

En este ejemplo, vamos a utilizar la pantalla TM1637 junto con un módulo de reloj de tiempo real (RTC) DS3231 para construir un reloj digital simple de 24 horas.

Si no está familiarizado con el módulo DS3231, es una buena idea leer primero un tutorial sobre él.

 Interfaz del módulo RTC de precisión DS3231 con Arduino

Instalación de la biblioteca

Usaremos la biblioteca 

 para comunicarnos con el DS3231. Esta biblioteca simplifica enormemente la lectura de datos de tiempo del RTC.

Para instalar la biblioteca,

1. Primero abre tu programa IDE de Arduino. Luego, haz clic en el icono del Administrador de Bibliotecas en la barra lateral izquierda.
2. Escriba “ urtclib ” en el cuadro de búsqueda para filtrar los resultados.
3. Busque la biblioteca uRTCLib de Naguissa .
4. Haga clic en el botón Instalar para agregarlo a su IDE de Arduino.

Código Arduino

El siguiente boceto se comunica con el módulo DS3231 y muestra la hora en la pantalla TM1637 en formato de 24 horas.

// Include the libraries
#include <TM1637Display.h>
#include "uRTCLib.h"
// Define the connections pins
#define CLK 3
#define DIO 4
// Create rtc and display object
uRTCLib rtc(0x68);
TM1637Display display = TM1637Display(CLK, DIO);
void setup() {
  URTCLIB_WIRE.begin();
  // Comment out below line once you set the date & time.
  // Following line sets the RTC with an explicit date & time
  // for example to set April 14 2025 at 12:56 you would call:
  rtc.set(0, 56, 12, 2, 14, 4, 25);
  // rtc.set(second, minute, hour, dayOfWeek, dayOfMonth, month, year)
  // set day of week (1=Sunday, 7=Saturday)
  // Set the display brightness (0-7)
  display.setBrightness(5);
  // Clear the display
  display.clear();
}
void loop() {
  // Get the current time
  rtc.refresh();
  // Create time format to display
  int displaytime = (rtc.hour() * 100) + rtc.minute();
  // Display the current time in 24 hour format with leading zeros and a center colon enabled
  display.showNumberDecEx(displaytime, 0b01000000, true);
  delay(1000);
}

Una vez que cargues el boceto en tu Arduino, deberías ver:

Explicación del código

En el código, comenzamos incluyendo las bibliotecas necesarias: una para la pantalla TM1637 y otra para el módulo RTC.

#include "uRTCLib.h"

uRTCLib rtc(0x68);

URTCLIB_WIRE.begin();

A continuación, configuramos la fecha y la hora con la 

función. Esta función necesita siete valores: segundos, minutos, horas, día de la semana (donde 1 significa domingo), día del mes, mes y los dos últimos dígitos del año.

En nuestro ejemplo, configuramos el reloj a las 12:56 p. m. del lunes 14 de abril de 2025. Esa línea se ve así:

rtc.set(0, 56, 12, 2, 14, 4, 25);

Solo necesitas ejecutar esta línea una vez para configurar la hora correcta. Después, coméntala para que el RTC conserve la hora y no se restablezca cada vez que subas el código.

Tras configurar la hora, ajustamos el brillo de la pantalla a un nivel medio (5), lo que permite ver los dígitos con claridad sin ser demasiado brillante. A continuación, limpiamos la pantalla para asegurarnos de que se inicie con una pantalla en blanco.

// Set the display brightness (0-7)
display.setBrightness(5);// Clear the display
display.clear();

En la función loop(), lo primero que hacemos es actualizar los valores de tiempo del módulo RTC usando 

. Esto garantiza que la hora más reciente se cargue en la memoria de Arduino.

rtc.refresh();

int displaytime = (rtc.hour() * 100) + rtc.minute();

display.showNumberDecEx(displaytime, 0b01000000, true);